From eab47f56c7bd72fbac5c353bff6dff273c2aa0fb Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 15 Dec 2025 17:56:25 -0800 Subject: [PATCH 001/272] first implementation of clustering/classification pipelines --- .vscode/settings.json | 7 + README.md | 69 +- dimelo/__init__.py | 2 + dimelo/cluster.py | 2132 +++++++++++++++++++++++++++++++++++++++++ dimelo/parse_bam.py | 4 + dimelo/run_modkit.py | 59 +- setup.py | 18 +- tests/test_cluster.py | 372 +++++++ tutorial.ipynb | 528 +++++++++- 9 files changed, 3153 insertions(+), 38 deletions(-) create mode 100644 .vscode/settings.json create mode 100644 dimelo/cluster.py create mode 100644 tests/test_cluster.py diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..3e99ede --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,7 @@ +{ + "python.testing.pytestArgs": [ + "." + ], + "python.testing.unittestEnabled": false, + "python.testing.pytestEnabled": true +} \ No newline at end of file diff --git a/README.md b/README.md index 5c19de4..a9fc91e 100644 --- a/README.md +++ b/README.md @@ -38,6 +38,8 @@ This README document contains installation instructions and documentation for va -[2.4 Load values from processed files](#load-values-from-processed-files) +-[2.5 Clustering scaffolding](#clustering-scaffolding) + [3.0 Known Issues](#known-issues) -[3.1 No progress bars](#no-progress-bars) @@ -850,6 +852,72 @@ def regions_to_list( """ ``` +## Clustering scaffolding + +`dimelo.cluster` wraps the loading utilities above so you can quickly build matrices for downstream clustering or dimensionality reduction. + +``` +from dimelo import cluster + +# Region-level features: rows are regions, columns are aligned positions. +pileup_matrix, region_info = cluster.region_feature_matrix_from_pileup( + bedmethyl_file="output/pileup.sorted.bed.gz", + motif="A,0", + regions="regions.bed", + window_size=500, + regions_5to3prime=True, +) +labels, model = cluster.cluster_features(pileup_matrix, n_clusters=4) + +# Read-level feature pipeline using extract outputs. +read_windows = cluster.extract_read_windows( + hdf5_file="output/extract.h5", + motifs=["A,0", "CG,0"], + regions="regions.bed", + config=cluster.ReadWindowExtractionConfig(window_size=2000, orientation_aware=True), +) +feature_matrix, feature_names = cluster.read_window_feature_matrix(read_windows) +read_clusters = cluster.cluster_read_windows(feature_matrix, method="kmeans", n_clusters=8) + +# Optional visualization/export +cluster.plot_region_cluster_profiles(pileup_matrix, labels, window_bp=1000) +cluster.export_region_clusters_to_bed(region_info, labels, "region_clusters.bed") +cluster.plot_cluster_karyotype("region_clusters.bed", "ref.fasta.fai") +# If pileup_matrix concatenates multiple motifs, pass motif_index to select which slice to visualize. + +# Multi-site read raster (paired windows) for exploratory QC +# fig, stats = cluster.plot_multisite_read_raster( +# read_windows, +# n_windows=2, +# min_separation_bp=5000, +# motif_index=0, +# smoothing="gaussian", +# ) + +# Binary classification of read features across two samples +clf_result = cluster.classify_read_features_binary( + feature_matrix, + sample_labels=my_sample_labels, # e.g., ["sampleA", "sampleA", "sampleB", ...] + classifier="xgboost", # or logreg/sgd/random_forest/svc/knn + random_state=42, +) +print(clf_result["metrics"]) +# QC plots +cluster.plot_confusion_matrices(clf_result["predictions"]) +# If you have per-read windows aligned to predictions for this split: +# cluster.plot_classification_profiles(read_windows.data_matrix, clf_result["predictions"], split="test") + +# Optional: sample rows for faster exploratory runs +sampled_features, sampled_labels, idx = cluster.sample_rows(feature_matrix, labels, frac=0.2, stratify=True) +cluster.cluster_read_windows(sampled_features, method="kmeans", n_clusters=4) +``` + +`region_feature_matrix_from_pileup` delegates to `load_processed.regions_to_list`, so you inherit the same controls for multi-core execution and windowing. For read-level work you can either keep using `read_mod_fraction_table` (motif-wide fractions) or run the new window-based pipeline above: `extract_read_windows` builds a matrix of per-base modification calls (optionally enforcing strand orientation and dropping reads spanning multiple regions), `read_window_feature_matrix` augments that matrix with PCA, autocorrelation, density, and summary statistics, and `cluster_read_windows` exposes the same clustering options demonstrated in the exploratory notebook (k-means, GMM, spectral, OPTICS/HDBSCAN, etc.). + +`cluster_features` currently offers a lightweight k-means wrapper powered by `scikit-learn`, while `cluster_read_windows` can switch between `kmeans`, `minibatch_kmeans`, `gmm`, `agglomerative`, `spectral`, `birch`, `dbscan`, `optics`, `hdbscan`, or `umap_kmeans`. These dependencies (`scikit-learn`, `scipy`, `hdbscan`, `umap-learn`) live in the `clustering` extra (`pip install dimelo[clustering]`), or feed the matrices above into your own estimator. + +**Motif semantics:** `extract.h5` stores one row per motif per read. When passing multiple motifs, you will see multiple rows per read; use `build_multimotif_read_windows` to group and concatenate motifs per read (set `require_all_motifs=True` to drop reads missing motifs), or filter by `metadata["motif"]` for per-motif analysis. Visualization helpers take a `motif_index` argument to choose which motif slice to display when windows are concatenated. + ## Parameters and what they mean Many of the parsing, loading, and plotting functions share parameters. The common ones and their meanings/defaults are listed below. @@ -905,4 +973,3 @@ The most common culprit for progress bar issues in notebooks (Jupyter or Colab) ``` pip install ipywidgets==X.XX.X ``` - diff --git a/dimelo/__init__.py b/dimelo/__init__.py index 4906a85..9bb84c2 100644 --- a/dimelo/__init__.py +++ b/dimelo/__init__.py @@ -1,4 +1,5 @@ from . import ( + cluster, export, load_processed, parse_bam, @@ -11,6 +12,7 @@ ) __all__ = [ + "cluster", "export", "load_processed", "parse_bam", diff --git a/dimelo/cluster.py b/dimelo/cluster.py new file mode 100644 index 0000000..9d088a8 --- /dev/null +++ b/dimelo/cluster.py @@ -0,0 +1,2132 @@ +from __future__ import annotations + +from collections import Counter, defaultdict +from dataclasses import dataclass +from functools import partial +from pathlib import Path +from typing import Any, Sequence + +import numpy as np +import pandas as pd + +from . import load_processed, utils + +try: # Optional SciPy dependency for advanced peak metrics + from scipy.signal import find_peaks +except Exception: # pragma: no cover - SciPy is optional + find_peaks = None + +try: # Optional dependency for density-based clustering + import hdbscan as _hdbscan_lib + + _HAS_HDBSCAN = True +except Exception: # pragma: no cover - HDBSCAN is optional + _HAS_HDBSCAN = False + +RegionMetadata = tuple[str, int, int, str] +# Read metadata fields pulled alongside feature matrices by default +DEFAULT_METADATA_FIELDS: tuple[str, ...] = ( + "read_name", + "chromosome", + "region_start", + "region_end", + "motif", + "region_strand", + "read_length", +) + +DEFAULT_AUTOCORR_LAGS = (20, 75, 100, 150, 250) +DEFAULT_DENSITY_WINDOWS = ( + ("density_pm50", -50, 50), + ("density_pm75", -75, 75), + ("density_pm100", -100, 100), + ("density_pm300", -300, 300), + ("density_pm500", -500, 500), + ("density_plus240", 140, 340), + ("density_minus240", -340, -140), + ("density_plus320", 220, 420), + ("density_minus320", -420, -220), + ("density_plus800", 700, 900), + ("density_minus800", -900, -700), + ("density_plus150", 50, 250), + ("density_minus150", -250, -50), +) + + +@dataclass +class ReadWindowExtractionConfig: + # Controls how windows are cut from per-read vectors + window_size: int = 2000 + orientation_aware: bool = True + filter_multi_region_reads: bool = False + + +@dataclass +class ReadWindowExtractionResult: + data_matrix: np.ndarray + val_matrix: np.ndarray | None + metadata: list[dict[str, Any]] + datasets: list[str] + regions_dict: dict | None + + +@dataclass +class ClusterResult: + labels_raw: np.ndarray + labels_size_ordered: np.ndarray + model: Any + metrics: dict[str, float | None] + + +def region_feature_matrix_from_pileup( + bedmethyl_file: str | Path, + motif: str, + regions: str | Path | list[str | Path], + window_size: int | None = None, + single_strand: bool = False, + regions_5to3prime: bool = True, + *, + pseudo_count: float = 1e-3, + chunk_size: int = load_processed.DEFAULT_CHUNK_SIZE, + split_large_regions: bool = False, + quiet: bool = False, + cores: int | None = None, +) -> tuple[np.ndarray, list[RegionMetadata]]: + """ + Convert every region in a pileup into a vector of modification fractions suitable for clustering. + Uses pileup loaders so we never touch raw BAMs here. + + Args: + bedmethyl_file: path to the processed bedmethyl file produced by parse_bam.pileup + motif: motif string (e.g. "A,0") to pull from the pileup + regions: region specifier accepted by load_processed (bed path, list, or str) + window_size: optional window applied to every region before loading + single_strand: whether to only use reads on the strand specified per region + regions_5to3prime: align all regions to the 5'->3' direction before aggregation + pseudo_count: small constant used to avoid division by zero when computing fractions + chunk_size: chunk size forwarded to load_processed.pileup_vectors_from_bedmethyl + split_large_regions: mirror of regions_to_list parameter for large regions + quiet: disable progress bars in downstream loader + cores: number of worker processes for loaders + + Returns: + Tuple containing: + * 2D numpy array (n_regions, region_length) of modification fractions + * ordered list with metadata for every region (chrom, start, end, strand) + """ + + if regions is None: + raise ValueError("regions must be provided when building a clustering matrix.") + + regions_dict = utils.regions_dict_from_input(regions, window_size) + region_metadata = [ + (chromosome, start, end, strand) + for chromosome, region_list in regions_dict.items() + for start, end, strand in region_list + ] + if len(region_metadata) == 0: + raise ValueError("No regions were found to build clustering features.") + + loader = partial( + load_processed.pileup_vectors_from_bedmethyl, + bedmethyl_file=bedmethyl_file, + motif=motif, + window_size=window_size, + single_strand=single_strand, + regions_5to3prime=regions_5to3prime, + quiet=quiet, + cores=cores, + chunk_size=chunk_size, + ) + per_region_vectors = load_processed.regions_to_list( + function_handle=loader, + regions=regions, + window_size=window_size, + quiet=quiet, + cores=cores, + split_large_regions=split_large_regions, + ) + + if len(per_region_vectors) != len(region_metadata): + raise RuntimeError( + "Region metadata and pileup vectors have mismatched lengths. " + "Double-check the region inputs." + ) + + feature_vectors = [] + expected_length: int | None = None + for modified_vec, valid_vec in per_region_vectors: + modified = np.asarray(modified_vec, dtype=np.float64) + valid = np.asarray(valid_vec, dtype=np.float64) + if modified.shape != valid.shape: + raise ValueError("Modified and valid vectors must have matching shapes.") + if expected_length is None: + expected_length = modified.shape[0] + elif modified.shape[0] != expected_length: + raise ValueError( + "All regions must have the same length. " + "Pass window_size to enforce length-matched regions." + ) + + denominator = valid + (2 * pseudo_count) + with np.errstate(divide="ignore", invalid="ignore"): + fraction = np.divide( + modified + pseudo_count, + denominator, + out=np.zeros_like(modified), + where=denominator > 0, + ) + feature_vectors.append(fraction) + + feature_matrix = np.vstack(feature_vectors) + return feature_matrix, region_metadata + + +def read_mod_fraction_table( + hdf5_file: str | Path, + motifs: Sequence[str], + regions: str | Path | list[str | Path] | None = None, + *, + window_size: int | None = None, + single_strand: bool = False, + sort_by: Sequence[str | tuple[str, str]] | str = ( + "chromosome", + "region_start", + "read_start", + ), + subset_parameters: dict | None = None, + span_full_window: bool = False, + metadata_fields: Sequence[str] | None = DEFAULT_METADATA_FIELDS, +) -> tuple[np.ndarray, list[str], list[dict], dict | None]: + """ + Pull per-read modification fractions from an extract .h5 file. + This is the lightest-weight read-level feature matrix: one column per motif. + + Args: + hdf5_file: path to the .h5 output from parse_bam.extract + motifs: motifs whose modification fractions should be returned + regions: optional region specifier to filter reads + window_size: optional window applied to every region before loading + single_strand: whether to enforce strand agreement with each region + sort_by: forwarded to load_processed.read_vectors_from_hdf5 + subset_parameters: forwarded to utils.random_sample through the loader + span_full_window: only keep reads fully covering the requested window + metadata_fields: metadata columns to capture per read + + Returns: + Tuple containing: + * numpy array of shape (n_reads, len(motifs)) with per-read fractions + * ordered list of feature names + * list of metadata dictionaries aligned to the rows + * regions_dict returned by load_processed.read_vectors_from_hdf5 + """ + + read_records, datasets, regions_dict = load_processed.read_vectors_from_hdf5( + file=hdf5_file, + motifs=list(motifs), + regions=regions, + window_size=window_size, + single_strand=single_strand, + sort_by=list(sort_by) if isinstance(sort_by, (list, tuple)) else [sort_by], + subset_parameters=subset_parameters, + span_full_window=span_full_window, + ) + + dataset_indices = {name: idx for idx, name in enumerate(datasets)} + feature_names = [f"{motif}_mod_fraction" for motif in motifs] + missing_features = [name for name in feature_names if name not in dataset_indices] + if missing_features: + raise ValueError( + "Missing modification fraction columns in HDF5 file: " + f"{', '.join(missing_features)}. " + "Ensure calculate_mod_fractions=True when exporting reads." + ) + + feature_matrix = np.zeros((len(read_records), len(feature_names)), dtype=float) + capture_metadata = metadata_fields is not None + metadata: list[dict] = [] + + for idx, record in enumerate(read_records): + feature_matrix[idx, :] = [ + float(record[dataset_indices[name]]) for name in feature_names + ] + if capture_metadata: + metadata.append( + { + field: record[dataset_indices[field]] + if field in dataset_indices + else None + for field in metadata_fields + } + ) + else: + metadata.append({}) + + return feature_matrix, feature_names, metadata, regions_dict + + +def cluster_features( + feature_matrix: np.ndarray, + *, + method: str = "kmeans", + n_clusters: int = 5, + random_state: int | None = 0, + **kwargs, +) -> tuple[np.ndarray, object]: + """ + Run a simple clustering algorithm on a feature matrix. + + Args: + feature_matrix: 2D array of shape (n_samples, n_features) + method: clustering algorithm to run, currently only 'kmeans' is supported + n_clusters: number of clusters to request from the estimator + random_state: forwarded to the estimator for reproducibility + kwargs: forwarded to the sklearn estimator + + Returns: + Tuple of (cluster_labels, fitted_estimator) + """ + + if feature_matrix.ndim != 2: + raise ValueError("feature_matrix must be 2-dimensional.") + if feature_matrix.shape[0] == 0: + raise ValueError("feature_matrix must contain at least one sample.") + + method = method.lower() + if method != "kmeans": + raise ValueError(f"Unsupported clustering method '{method}'.") + + kmeans_cls = _get_kmeans() + estimator = kmeans_cls( + n_clusters=n_clusters, + random_state=random_state, + **kwargs, + ) + labels = estimator.fit_predict(feature_matrix) + return labels, estimator + + +def _get_kmeans(): + try: + from sklearn.cluster import KMeans + except ImportError as exc: # pragma: no cover - exercised in environments w/o sklearn + raise ImportError( + "scikit-learn is required for k-means clustering. " + "Install it with `pip install scikit-learn`." + ) from exc + return KMeans + + +def _get_xgb_classifier(): + try: + from xgboost import XGBClassifier + except Exception as exc: # pragma: no cover - optional dependency + raise ImportError( + "Install xgboost to use classifier='xgboost'. " + "Try `pip install xgboost`." + ) from exc + return XGBClassifier + + +def _build_dataset_index(dataset_names: Sequence[str]) -> dict[str, int]: + # Map dataset names from the HDF5 file into tuple indices for quick lookup + return {name: idx for idx, name in enumerate(dataset_names)} + + +def _coerce_strand(value: Any) -> str | None: + # Normalize strand values to '+' / '-' / None + if isinstance(value, str): + stripped = value.strip() + if stripped in {"+", "-"}: + return stripped + return None + + +def _should_flip(region_strand: str | None, read_strand: str | None) -> bool: + return ( + region_strand in {"+", "-"} + and read_strand in {"+", "-"} + and region_strand != read_strand + ) + + +def _region_key(record: tuple, idx: dict[str, int]) -> tuple[Any, Any, Any]: + # Defines "same region" for multi-region filtering + chrom = record[idx["chromosome"]] if "chromosome" in idx else None + start = record[idx["region_start"]] if "region_start" in idx else None + end = record[idx["region_end"]] if "region_end" in idx else None + return (chrom, start, end) + + +def _identify_multi_region_reads( + records: Sequence[tuple], idx: dict[str, int] +) -> set[str]: + if "read_name" not in idx: + return set() + regions_by_name: defaultdict[str, set[tuple[Any, Any, Any]]] = defaultdict(set) + for rec in records: + name = rec[idx["read_name"]] + regions_by_name[name].add(_region_key(rec, idx)) + return {name for name, keys in regions_by_name.items() if len(keys) > 1} + + +def _extract_window_from_record( + record: tuple, + idx: dict[str, int], + window_size: int, + orientation_aware: bool, +) -> tuple[np.ndarray, np.ndarray | None] | None: + required = ["read_start", "read_end", "region_start", "region_end", "mod_vector"] + for key in required: + if key not in idx: + raise ValueError(f"read_vectors_from_hdf5 output missing '{key}' dataset.") + + read_start = int(record[idx["read_start"]]) + read_end = int(record[idx["read_end"]]) + region_start = int(record[idx["region_start"]]) + region_end = int(record[idx["region_end"]]) + mod_vector = np.asarray(record[idx["mod_vector"]]) + val_vector = ( + np.asarray(record[idx["val_vector"]]) if "val_vector" in idx else None + ) + + if read_end <= read_start or region_end <= region_start: + return None + + center = (region_start + region_end) // 2 + half = window_size // 2 + # Grab a symmetric window around the region center + window_start = center - half + window_end = window_start + window_size + # Skip reads that do not fully span the requested window + if window_start < read_start or window_end > read_end: + return None + + slice_start = window_start - read_start + slice_end = slice_start + window_size + if slice_start < 0 or slice_end > len(mod_vector): + return None + + mod_window = mod_vector[slice_start:slice_end] + val_window = ( + val_vector[slice_start:slice_end] if val_vector is not None else None + ) + + if orientation_aware: + region_strand = ( + _coerce_strand(record[idx["region_strand"]]) + if "region_strand" in idx + else None + ) + read_strand = ( + _coerce_strand(record[idx["strand"]]) if "strand" in idx else None + ) + # If read/reference strands disagree, flip to align everything 5'->3' + if _should_flip(region_strand, read_strand): + mod_window = np.flip(mod_window) + if val_window is not None: + val_window = np.flip(val_window) + + return mod_window, val_window + + +def build_multimotif_read_windows( + hdf5_file: str | Path, + motifs: Sequence[str], + regions: str | Path | list[str | Path] | None = None, + *, + window_size: int, + orientation_aware: bool = True, + single_strand: bool = False, + subset_parameters: dict | None = None, + span_full_window: bool = False, + require_all_motifs: bool = True, +) -> ReadWindowExtractionResult: + """ + Group per-motif rows by read and return a combined window per read, concatenating motifs. + + Each requested motif contributes a window of length `window_size`; missing motifs are filled with zeros. + Windows are concatenated in the order provided by `motifs`. + + Args: + hdf5_file: path to extract .h5 file + motifs: motifs to include (order matters for concatenation) + regions: optional region filter + window_size: fixed window length around region center to extract per motif + orientation_aware: flip windows if read strand != region strand + single_strand: passed to loader + subset_parameters: passed to loader for subsetting + span_full_window: passed to loader (if True, only reads spanning the region are loaded) + require_all_motifs: if True, drop reads that are missing any requested motif + + Returns: + ReadWindowExtractionResult with data_matrix of shape (n_reads, len(motifs) * window_size) + and val_matrix if available, metadata per combined read, and datasets info. + """ + + # Load all per-motif rows + read_tuples, dataset_names, regions_dict = load_processed.read_vectors_from_hdf5( + file=hdf5_file, + motifs=list(motifs), + regions=regions, + window_size=None, # we handle windowing here + single_strand=single_strand, + subset_parameters=subset_parameters, + span_full_window=span_full_window, + ) + idx = _build_dataset_index(dataset_names) + + # Group rows by read+region key + groups: defaultdict[tuple[Any, Any, Any, Any, Any], dict[str, tuple]] = defaultdict(dict) + for rec in read_tuples: + key = ( + rec[idx.get("read_name")], + rec[idx.get("chromosome")], + rec[idx.get("region_start")], + rec[idx.get("region_end")], + rec[idx.get("region_strand")] if "region_strand" in idx else None, + ) + motif = rec[idx.get("motif")] + groups[key][motif] = rec + + combined_windows: list[np.ndarray] = [] + combined_vals: list[np.ndarray] = [] + metadata: list[dict[str, Any]] = [] + has_val = "val_vector" in idx + + for key, motif_map in groups.items(): + motif_windows = [] + motif_val_windows = [] + motifs_present = [] + for motif in motifs: + if motif in motif_map: + extracted = _extract_window_from_record( + motif_map[motif], idx, window_size, orientation_aware + ) + if extracted is None: + # If window cannot be extracted, treat as missing + motif_windows.append(np.zeros(window_size, dtype=float)) + motif_val_windows.append( + np.zeros(window_size, dtype=float) if has_val else None + ) + else: + mw, vw = extracted + motif_windows.append(np.asarray(mw, dtype=float)) + motif_val_windows.append( + np.asarray(vw, dtype=float) if vw is not None else None + ) + motifs_present.append(motif) + else: + motif_windows.append(np.zeros(window_size, dtype=float)) + motif_val_windows.append(np.zeros(window_size, dtype=float) if has_val else None) + + if require_all_motifs and len(motifs_present) < len(motifs): + continue + + combined_windows.append(np.concatenate(motif_windows, axis=0)) + if has_val: + combined_vals.append( + np.concatenate( + [vw if vw is not None else np.zeros(window_size, dtype=float) for vw in motif_val_windows], + axis=0, + ) + ) + metadata.append( + { + "read_name": key[0], + "chromosome": key[1], + "region_start": key[2], + "region_end": key[3], + "region_strand": key[4], + "motifs_present": motifs_present, + } + ) + + if not combined_windows: + raise ValueError("No reads produced combined motif windows; check inputs and window_size.") + + data_matrix = np.vstack(combined_windows) + val_matrix = np.vstack(combined_vals) if has_val and combined_vals else None + + return ReadWindowExtractionResult( + data_matrix=data_matrix, + val_matrix=val_matrix, + metadata=metadata, + datasets=list(dataset_names), + regions_dict=regions_dict, + ) + + +def extract_read_windows( + hdf5_file: str | Path, + motifs: Sequence[str], + regions: str | Path | list[str | Path] | None = None, + *, + config: ReadWindowExtractionConfig | None = None, + window_size: int | None = None, + single_strand: bool = False, + subset_parameters: dict | None = None, + span_full_window: bool = False, + quiet: bool = True, +) -> ReadWindowExtractionResult: + """ + Extract fixed-length windows from single-read vectors, optionally flipping reads + to align with the reference strand. + + Args: + hdf5_file: path to the extract .h5 file + motifs: motifs to pull from the file + regions: optional region specifier + config: controls window size and orientation handling + window_size: overrides config.window_size when provided + + Returns: + ReadWindowExtractionResult containing raw mod/val matrices and metadata + """ + + cfg = config or ReadWindowExtractionConfig() + effective_window = window_size or cfg.window_size + + # Load all requested reads/vectors from extract output + read_tuples, dataset_names, regions_dict = load_processed.read_vectors_from_hdf5( + file=hdf5_file, + motifs=list(motifs), + regions=regions, + window_size=window_size, + single_strand=single_strand, + subset_parameters=subset_parameters, + span_full_window=span_full_window, + ) + idx = _build_dataset_index(dataset_names) + + drop_names: set[str] = set() + if cfg.filter_multi_region_reads: + drop_names = _identify_multi_region_reads(read_tuples, idx) + + matrices: list[np.ndarray] = [] + val_matrices: list[np.ndarray] = [] + metadata: list[dict[str, Any]] = [] + has_val = "val_vector" in idx + + for rec in read_tuples: + read_name = rec[idx["read_name"]] if "read_name" in idx else None + if read_name in drop_names: + continue + + extracted = _extract_window_from_record( + rec, idx, effective_window, cfg.orientation_aware + ) + if extracted is None: + continue + + mod_window, val_window = extracted + matrices.append(mod_window) + if has_val and val_window is not None: + val_matrices.append(val_window) + + # Pull a small set of fields that are helpful for QC/relabelling + meta_fields = [ + "read_name", + "chromosome", + "region_start", + "region_end", + "region_strand", + "strand", + "motif", + ] + metadata.append( + { + field: rec[idx[field]] if field in idx else None + for field in meta_fields + } + ) + + if not matrices: + raise ValueError("No reads produced a full window; try reducing window_size.") + + data_matrix = np.vstack([row.astype(float) for row in matrices]) + val_matrix = ( + np.vstack([row.astype(float) for row in val_matrices]) + if has_val and val_matrices + else None + ) + + return ReadWindowExtractionResult( + data_matrix=data_matrix, + val_matrix=val_matrix, + metadata=metadata, + datasets=list(dataset_names), + regions_dict=regions_dict, + ) + + +def compute_autocorrelation_feature(vec: np.ndarray, lag: int) -> float: + # Normalized autocorrelation at a given lag (handles short/flat vectors) + arr = np.asarray(vec, dtype=float) + if arr.size <= abs(lag): + return 0.0 + centered = arr - arr.mean() + denom = np.dot(centered, centered) + if denom == 0: + return 0.0 + if lag >= 0: + return float(np.dot(centered[:-lag], centered[lag:]) / denom) + return float(np.dot(centered[-lag:], centered[:lag]) / denom) + + +def read_window_feature_matrix( + result: ReadWindowExtractionResult, + *, + n_pca: int = 6, + random_state: int = 42, + autocorr_lags: Sequence[int] = DEFAULT_AUTOCORR_LAGS, + density_windows: Sequence[tuple[str, int, int]] = DEFAULT_DENSITY_WINDOWS, + peak_prominence: float = 0.005, + use_peak_features: bool = False, + require_nonzero_valid: bool = False, + min_valid_fraction: float = 0.0, +) -> tuple[np.ndarray, list[str]]: + """ + Convert read windows into an augmented feature matrix including PCA components, + autocorrelation, density summaries, and basic statistics. + + Set use_peak_features=True to append peak counts/prominences (requires SciPy). + If require_nonzero_valid is True, rows with no valid sites (or below min_valid_fraction) + are dropped before feature computation (requires val_matrix to be present). + """ + + data_matrix = result.data_matrix.astype(float, copy=False) + val_matrix = result.val_matrix + + if require_nonzero_valid and val_matrix is not None: + valid_sums = val_matrix.sum(axis=1) + mask = valid_sums > 0 + if min_valid_fraction > 0 and val_matrix.shape[1] > 0: + mask &= (valid_sums / val_matrix.shape[1]) >= min_valid_fraction + data_matrix = data_matrix[mask] + val_matrix = val_matrix[mask] + if data_matrix.size == 0: + raise ValueError("No rows remaining after filtering for valid sites.") + + n_reads, window_size = data_matrix.shape + center = window_size // 2 + + columns: list[np.ndarray] = [] + names: list[str] = [] + + n_components = min(n_pca, n_reads, window_size) + if n_components > 0: + from sklearn.decomposition import PCA + + pca = PCA(n_components=n_components, random_state=random_state) + pca_vals = pca.fit_transform(data_matrix) + columns.append(pca_vals) + names.extend([f"pca_{i}" for i in range(n_components)]) + + # Precompute cumulative sums to accelerate density windows + cumsum = np.cumsum(data_matrix, axis=1) + cumsum = np.pad(cumsum, ((0, 0), (1, 0)), mode="constant", constant_values=0) + + for lag in autocorr_lags: + values = np.array([compute_autocorrelation_feature(row, lag) for row in data_matrix]) + columns.append(values[:, None]) + names.append(f"autocorr_{lag}") + + for label, start, end in density_windows: + start_idx = max(0, center + start) + end_idx = min(window_size, center + end) + if end_idx <= start_idx: + values = np.zeros(n_reads) + else: + length = end_idx - start_idx + window_sum = cumsum[:, end_idx] - cumsum[:, start_idx] + values = window_sum / length + columns.append(values[:, None]) + names.append(label) + + global_mean = data_matrix.mean(axis=1) + global_var = data_matrix.var(axis=1) + global_median = np.median(data_matrix, axis=1) + q25 = np.percentile(data_matrix, 25, axis=1) + q75 = np.percentile(data_matrix, 75, axis=1) + + columns.extend( + [ + global_mean[:, None], + global_var[:, None], + global_median[:, None], + q25[:, None], + q75[:, None], + (q75 - q25)[:, None], + ] + ) + names.extend( + [ + "global_mean", + "global_var", + "global_median", + "q25", + "q75", + "iqr", + ] + ) + + if val_matrix is not None: + valid_sum = val_matrix.sum(axis=1) + with np.errstate(divide="ignore", invalid="ignore"): + frac = np.divide( + data_matrix.sum(axis=1), + valid_sum, + out=np.zeros_like(valid_sum), + where=valid_sum > 0, + ) + columns.append(frac[:, None]) + names.append("global_mod_fraction") + + if use_peak_features and find_peaks is not None: # pragma: no branch + peak_counts = [] + peak_prominences = [] + for row in data_matrix: + peaks, props = find_peaks(row, prominence=peak_prominence) + peak_counts.append(len(peaks)) + if peaks.size > 0: + peak_prominences.append(float(np.mean(props["prominences"]))) + else: + peak_prominences.append(0.0) + columns.append(np.array(peak_counts)[:, None]) + columns.append(np.array(peak_prominences)[:, None]) + names.extend(["peak_count", "peak_prominence"]) + + feature_matrix = np.hstack(columns) + return feature_matrix, names + + +def _safe_scores(X: np.ndarray, labels: np.ndarray) -> dict[str, float | None]: + from sklearn.metrics import ( + calinski_harabasz_score, + davies_bouldin_score, + silhouette_score, + ) + + scores = {"silhouette": None, "calinski_harabasz": None, "davies_bouldin": None} + unique_labels = np.unique(labels) + valid = len(unique_labels) >= 2 and not ( + len(unique_labels) == 1 and unique_labels[0] == -1 + ) + if not valid: + return scores + try: + scores["silhouette"] = float(silhouette_score(X, labels)) + except Exception: # pragma: no cover + pass + try: + scores["calinski_harabasz"] = float(calinski_harabasz_score(X, labels)) + except Exception: # pragma: no cover + pass + try: + scores["davies_bouldin"] = float(davies_bouldin_score(X, labels)) + except Exception: # pragma: no cover + pass + return scores + + +def _renumber_by_size(labels: np.ndarray, noise_label: int | None = None) -> np.ndarray: + labels = np.asarray(labels) + counts = Counter(labels) + order = [ + label + for label, _ in sorted(counts.items(), key=lambda x: x[1], reverse=True) + if noise_label is None or label != noise_label + ] + mapping = {old: new for new, old in enumerate(order)} + remapped = [] + for label in labels: + if noise_label is not None and label == noise_label: + remapped.append(-1) + else: + remapped.append(mapping.get(label, -1)) + return np.array(remapped, dtype=int) + + +def sample_rows( + data: np.ndarray, + labels: Sequence[Any] | None = None, + *, + n: int | None = None, + frac: float | None = None, + random_state: int | None = 42, + stratify: bool = False, +) -> tuple[np.ndarray, np.ndarray | None, np.ndarray]: + """ + Downsample rows for faster clustering/classification. + + Args: + data: 2D array of shape (n_rows, n_features) + labels: optional parallel labels to return (e.g., cluster or sample labels) + n: fixed number of rows to sample + frac: fraction of rows to sample (ignored if n is provided) + random_state: RNG seed + stratify: if True and labels are provided, sample proportionally to label frequency + + Returns: + sampled_data, sampled_labels (or None), indices of selected rows + """ + + rng = np.random.default_rng(random_state) + n_rows = data.shape[0] + if n is None and frac is None: + raise ValueError("Provide n or frac to sample.") + if n is None: + n = max(1, int(n_rows * frac)) + n = min(n, n_rows) + + if stratify and labels is not None: + labels_arr = np.asarray(labels) + unique, counts = np.unique(labels_arr, return_counts=True) + probs = counts / counts.sum() + selected = [] + for lbl, p in zip(unique, probs): + k = max(1, int(round(p * n))) + choices = np.flatnonzero(labels_arr == lbl) + k = min(k, len(choices)) + selected.append(rng.choice(choices, size=k, replace=False)) + idx = np.unique(np.concatenate(selected)) + if len(idx) > n: + idx = rng.choice(idx, size=n, replace=False) + else: + idx = rng.choice(n_rows, size=n, replace=False) + + sampled_data = data[idx] + sampled_labels = np.asarray(labels)[idx] if labels is not None else None + return sampled_data, sampled_labels, idx + + +def cluster_read_windows( + feature_matrix: np.ndarray, + *, + method: str = "kmeans", + n_clusters: int = 8, + random_state: int = 42, + auto_k: bool = False, + k_grid: Sequence[int] | None = None, + score: str = "silhouette", + **kwargs, +) -> ClusterResult: + """ + Run clustering on a read feature matrix with support for several algorithms. + auto_k=True grid-searches K for methods that require it using the requested score. + """ + + from sklearn.cluster import ( + AgglomerativeClustering, + Birch, + DBSCAN, + KMeans, + MiniBatchKMeans, + OPTICS, + SpectralClustering, + ) + from sklearn.mixture import GaussianMixture + + X = np.asarray(feature_matrix) + + def fit( + n_components: int, + ) -> tuple[np.ndarray, Any, dict[str, float | None], int | None]: + algo = method.lower() + model = None + labels: np.ndarray + noise_label: int | None = None + + if algo == "kmeans": + model = KMeans( + n_clusters=n_components, + random_state=random_state, + n_init=kwargs.get("n_init", 10), + ) + labels = model.fit_predict(X) + elif algo == "minibatch_kmeans": + model = MiniBatchKMeans( + n_clusters=n_components, + random_state=random_state, + n_init=kwargs.get("n_init", 10), + batch_size=kwargs.get("batch_size", 1024), + ) + labels = model.fit_predict(X) + elif algo == "gmm": + model = GaussianMixture( + n_components=n_components, + covariance_type=kwargs.get("covariance_type", "full"), + random_state=random_state, + ) + model.fit(X) + labels = model.predict(X) + elif algo == "agglomerative": + model = AgglomerativeClustering( + n_clusters=n_components, + linkage=kwargs.get("linkage", "ward"), + metric="euclidean", + ) + labels = model.fit_predict(X) + elif algo == "spectral": + model = SpectralClustering( + n_clusters=n_components, + assign_labels=kwargs.get("assign_labels", "kmeans"), + affinity=kwargs.get("affinity", "rbf"), + random_state=random_state, + ) + labels = model.fit_predict(X) + elif algo == "birch": + model = Birch( + n_clusters=n_components, threshold=kwargs.get("threshold", 0.5) + ) + labels = model.fit_predict(X) + elif algo == "dbscan": + model = DBSCAN( + eps=kwargs.get("eps", 0.8), + min_samples=kwargs.get("min_samples", 20), + ) + labels = model.fit_predict(X) + noise_label = -1 + elif algo == "optics": + model = OPTICS( + min_samples=kwargs.get("min_samples", 20), + max_eps=kwargs.get("max_eps", np.inf), + cluster_method="xi", + xi=kwargs.get("xi", 0.05), + ) + labels = model.fit_predict(X) + noise_label = -1 + elif algo == "hdbscan": + if not _HAS_HDBSCAN: + raise ImportError("Install hdbscan to use method='hdbscan'.") + model = _hdbscan_lib.HDBSCAN( + min_cluster_size=kwargs.get("min_cluster_size", 30), + min_samples=kwargs.get("min_samples", None), + ) + labels = model.fit_predict(X) + noise_label = -1 + elif algo == "umap_kmeans": + try: + import umap + except Exception as exc: # pragma: no cover - optional dependency + raise ImportError( + "Install umap-learn to use method='umap_kmeans'." + ) from exc + reducer = umap.UMAP( + n_neighbors=kwargs.get("umap_n_neighbors", 15), + min_dist=kwargs.get("umap_min_dist", 0.1), + n_components=kwargs.get("umap_n_components", 2), + metric=kwargs.get("umap_metric", "euclidean"), + random_state=random_state, + ) + embedded = reducer.fit_transform(X) + kmeans_cls = _get_kmeans() + model = kmeans_cls( + n_clusters=n_components, + random_state=random_state, + n_init=kwargs.get("n_init", 10), + ) + labels = model.fit_predict(embedded) + else: + raise ValueError(f"Unknown clustering method '{method}'.") + + metrics = _safe_scores(X, labels) + return labels, model, metrics, noise_label + + if auto_k: + grid = list(k_grid or range(2, 16)) + best: ClusterResult | None = None + best_score: float | None = None + + def score_value(metric_dict: dict[str, float | None]) -> float | None: + val = metric_dict.get(score) + if val is None: + return None + if score == "davies_bouldin": + return -val + return val + + for k in grid: + labels, model, metrics, noise_label = fit(k) + val = score_value(metrics) + if val is None: + continue + if best is None or val > best_score: + best = ClusterResult( + labels_raw=labels, + labels_size_ordered=_renumber_by_size(labels, noise_label), + model=model, + metrics=metrics, + ) + best_score = val + if best is None: + labels, model, metrics, noise_label = fit(grid[-1]) + best = ClusterResult( + labels_raw=labels, + labels_size_ordered=_renumber_by_size(labels, noise_label), + model=model, + metrics=metrics, + ) + return best + + labels, model, metrics, noise_label = fit(n_clusters) + return ClusterResult( + labels_raw=labels, + labels_size_ordered=_renumber_by_size(labels, noise_label), + model=model, + metrics=metrics, + ) + + +def plot_cluster_profiles( + data_matrix: np.ndarray, + labels: np.ndarray, + *, + val_matrix: np.ndarray | None = None, + include_clusters: Sequence[int] | None = None, + view_bp: int | None = None, + window_bp: int | None = None, + motif_index: int = 0, + motif_count: int | None = None, + cmap_name: str = "viridis", + invert_y: bool = True, + point_size: float = 1.0, + point_alpha: float = 0.01, +): + """ + Scatter plot of per-read modification calls with per-cluster average profiles. + Useful for quick QC after clustering. + Set motif_count when data_matrix contains concatenated motifs to select motif_index safely. + """ + + import matplotlib.pyplot as plt + from matplotlib import gridspec + from matplotlib.colors import Normalize + + X_full = np.asarray(data_matrix) + labs = np.asarray(labels) + if include_clusters is not None: + mask = np.isin(labs, list(include_clusters)) + if not np.any(mask): + raise ValueError("No reads remain after filtering include_clusters.") + X_full = X_full[mask] + labs = labs[mask] + if val_matrix is not None: + val_matrix = np.asarray(val_matrix)[mask] + + # If concatenated motifs are present, select the requested motif slice + if motif_index is not None and X_full.ndim == 2: + window_len = X_full.shape[1] + # Prefer explicit motif_count; otherwise infer from window_bp/view_bp if they evenly tile the window + inferred_count = None + if motif_count is not None: + inferred_count = int(max(1, motif_count)) + elif window_bp and window_bp > 0 and window_len % window_bp == 0: + inferred_count = window_len // window_bp + elif view_bp and view_bp > 0 and window_len % view_bp == 0: + inferred_count = window_len // view_bp + n_motifs = inferred_count or 1 + slice_width = window_len // n_motifs if n_motifs > 0 else window_len + if slice_width == 0: + slice_width = window_len + n_motifs = 1 + start = motif_index * slice_width + end = min(window_len, start + slice_width) + if start >= window_len: + raise ValueError( + f"motif_index {motif_index} exceeds concatenated width {window_len}; " + "pass motif_count/window_bp to disambiguate." + ) + X = X_full[:, start:end] + V = val_matrix[:, start:end] if val_matrix is not None else None + else: + X = X_full + V = val_matrix + + n_reads, window = X.shape + window_bp = window_bp or window + half = window_bp // 2 + if view_bp is not None: + half = view_bp // 2 + x_axis = np.arange(-half, -half + X.shape[1]) + + mod_fraction = X.mean(axis=1) + order = np.lexsort((-mod_fraction, labs)) + X = X[order] + labs = labs[order] + V = V[order] if V is not None else None + + unique_clusters = np.unique(labs) + cmap = plt.get_cmap(cmap_name) + norm = Normalize(vmin=int(unique_clusters.min()), vmax=int(unique_clusters.max())) + + rows, cols = np.nonzero(X) + colors = cmap(norm(labs[rows])) + + fig = plt.figure(figsize=(12, max(4, len(unique_clusters)))) + gs = gridspec.GridSpec(nrows=len(unique_clusters), ncols=2, width_ratios=[3, 1]) + ax_left = fig.add_subplot(gs[:, 0]) + ax_left.scatter(x_axis[cols], rows, s=point_size, alpha=point_alpha, c=colors) + ax_left.set_xlabel("Distance from region center (bp)") + ax_left.set_ylabel("Sorted read index") + if invert_y: + ax_left.invert_yaxis() + + change_points = np.flatnonzero(np.diff(labs)) + 1 + for cp in change_points: + ax_left.axhline(cp, color="0.2", linestyle="--", linewidth=0.3) + + for i, cluster_id in enumerate(unique_clusters): + ax = fig.add_subplot(gs[i, 1]) + mask = labs == cluster_id + mean_profile = X[mask].mean(axis=0) + ax.plot(x_axis, mean_profile, color=cmap(norm(cluster_id))) + if V is not None: + mean_val = V[mask].mean(axis=0) + ax.plot(x_axis, mean_val, color="0.35", linestyle="--", linewidth=1.0) + ax.set_title(f"Cluster {cluster_id} (n={mask.sum()})") + ax.set_xlim(x_axis[0], x_axis[-1]) + ax.set_ylim(0, min(1.0, max(0.05, mean_profile.max() + 0.05))) + + fig.tight_layout() + return fig + + +def classify_read_features_binary( + feature_matrix: np.ndarray, + sample_labels: Sequence[str | int], + *, + classifier: str = "xgboost", + test_size: float = 0.2, + random_state: int = 42, + **kwargs, +) -> dict[str, Any]: + """ + Train/test a binary classifier on read-level features to quantify separability between two samples. + + Args: + feature_matrix: 2D array (n_reads, n_features) + sample_labels: iterable of length n_reads with exactly two distinct values (sample IDs) + classifier: 'xgboost' (default) or one of: + 'logreg' (sklearn LogisticRegression), + 'sgd' (sklearn SGDClassifier), + 'random_forest' (sklearn RandomForestClassifier), + 'svc' (sklearn SVC with probability=True), + 'knn' (sklearn KNeighborsClassifier) + test_size: fraction held out for testing + random_state: RNG seed for reproducibility + kwargs: forwarded to the classifier constructor + + Returns: + dict with keys: + model: fitted estimator + metrics: accuracy, roc_auc, confusion_matrix + predictions: DataFrame with columns ['true_label','pred_label','proba','split','sample_label'] + label_mapping: mapping from class name to encoded int + """ + + from sklearn.metrics import accuracy_score, confusion_matrix, roc_auc_score + from sklearn.model_selection import train_test_split + from sklearn.preprocessing import LabelEncoder + + X = np.asarray(feature_matrix) + y_raw = np.asarray(sample_labels) + if X.shape[0] != y_raw.shape[0]: + raise ValueError("feature_matrix and sample_labels must have matching length.") + + le = LabelEncoder() + y = le.fit_transform(y_raw) + classes = le.classes_ + if len(classes) != 2: + raise ValueError("Binary classification requires exactly two sample labels.") + + X_train, X_test, y_train, y_test, lbl_train, lbl_test = train_test_split( + X, y, y_raw, test_size=test_size, random_state=random_state, stratify=y + ) + + clf_name = classifier.lower() + if clf_name == "xgboost": + XGB = _get_xgb_classifier() + # Sensible defaults; kwargs can override + model = XGB( + n_estimators=kwargs.get("n_estimators", 200), + max_depth=kwargs.get("max_depth", 4), + learning_rate=kwargs.get("learning_rate", 0.1), + subsample=kwargs.get("subsample", 0.8), + colsample_bytree=kwargs.get("colsample_bytree", 0.8), + random_state=random_state, + n_jobs=kwargs.get("n_jobs", 4), + ) + elif clf_name == "logreg": + from sklearn.linear_model import LogisticRegression + + model = LogisticRegression( + max_iter=kwargs.get("max_iter", 200), + solver=kwargs.get("solver", "lbfgs"), + class_weight=kwargs.get("class_weight", "balanced"), + random_state=random_state, + ) + elif clf_name == "sgd": + from sklearn.linear_model import SGDClassifier + + model = SGDClassifier( + loss=kwargs.get("loss", "log_loss"), + max_iter=kwargs.get("max_iter", 1000), + alpha=kwargs.get("alpha", 1e-4), + random_state=random_state, + class_weight=kwargs.get("class_weight", "balanced"), + ) + elif clf_name == "random_forest": + from sklearn.ensemble import RandomForestClassifier + + model = RandomForestClassifier( + n_estimators=kwargs.get("n_estimators", 200), + max_depth=kwargs.get("max_depth", None), + random_state=random_state, + n_jobs=kwargs.get("n_jobs", -1), + class_weight=kwargs.get("class_weight", "balanced_subsample"), + ) + elif clf_name == "svc": + from sklearn.svm import SVC + + model = SVC( + C=kwargs.get("C", 1.0), + kernel=kwargs.get("kernel", "rbf"), + probability=True, + random_state=random_state, + class_weight=kwargs.get("class_weight", "balanced"), + ) + elif clf_name == "knn": + from sklearn.neighbors import KNeighborsClassifier + + model = KNeighborsClassifier( + n_neighbors=kwargs.get("n_neighbors", 5), + weights=kwargs.get("weights", "distance"), + n_jobs=kwargs.get("n_jobs", None), + ) + else: + raise ValueError(f"Unknown classifier '{classifier}'.") + + model.fit(X_train, y_train) + proba = model.predict_proba(X_test)[:, 1] + y_pred = (proba >= 0.5).astype(int) + + proba_train = model.predict_proba(X_train)[:, 1] + y_pred_train = (proba_train >= 0.5).astype(int) + + metrics = { + "test": { + "accuracy": float(accuracy_score(y_test, y_pred)), + "roc_auc": float(roc_auc_score(y_test, proba)), + "confusion_matrix": confusion_matrix(y_test, y_pred).tolist(), + }, + "train": { + "accuracy": float(accuracy_score(y_train, y_pred_train)), + "roc_auc": float(roc_auc_score(y_train, proba_train)), + "confusion_matrix": confusion_matrix(y_train, y_pred_train).tolist(), + }, + } + + preds_df = pd.DataFrame( + { + "true_label": le.inverse_transform(y_test), + "pred_label": le.inverse_transform(y_pred), + "proba": proba, + "split": "test", + "sample_label": lbl_test, + } + ) + + # Also record train predictions for diagnostics + train_df = pd.DataFrame( + { + "true_label": le.inverse_transform(y_train), + "pred_label": le.inverse_transform(y_pred_train), + "proba": proba_train, + "split": "train", + "sample_label": lbl_train, + } + ) + + all_preds = pd.concat([train_df, preds_df], ignore_index=True) + + return { + "model": model, + "metrics": metrics, + "predictions": all_preds, + "label_mapping": {cls: int(code) for cls, code in zip(classes, le.transform(classes))}, + } + + +def plot_confusion_matrices(predictions: pd.DataFrame, *, cmap: str = "Blues"): + """ + Plot train/test confusion matrices from the predictions DataFrame returned by classify_read_features_binary. + """ + import matplotlib.pyplot as plt + import seaborn as sns + from sklearn.metrics import confusion_matrix + + fig, axes = plt.subplots(1, 2, figsize=(8, 4)) + for ax, split in zip(axes, ["train", "test"]): + df_split = predictions[predictions["split"] == split] + labels_true = df_split["true_label"] + labels_pred = df_split["pred_label"] + uniq = sorted(labels_true.unique()) + cm = confusion_matrix(labels_true, labels_pred, labels=uniq) + sns.heatmap( + cm, + annot=True, + fmt="d", + cmap=cmap, + xticklabels=uniq, + yticklabels=uniq, + ax=ax, + ) + ax.set_xlabel("Predicted") + ax.set_ylabel("True") + ax.set_title(f"{split.capitalize()} confusion") + fig.tight_layout() + return fig + + +def plot_classification_profiles( + data_matrix: np.ndarray, + predictions: pd.DataFrame, + *, + val_matrix: np.ndarray | None = None, + split: str = "test", + motif_index: int = 0, + view_bp: int | None = None, + cmap_name: str = "viridis", + invert_y: bool = True, + point_size: float = 1.0, + point_alpha: float = 0.01, +): + """ + Visualize per-read modification calls colored by predicted label, with mean profiles per predicted class. + + Args: + data_matrix: per-read windows (n_reads, window_len) + predictions: DataFrame from classify_read_features_binary (must align row-wise with data_matrix) + val_matrix: optional valid-site matrix to overlay + split: which split to visualize ('train' or 'test') + """ + + import matplotlib.pyplot as plt + from matplotlib import gridspec + from matplotlib.colors import Normalize + + preds = predictions[predictions["split"] == split].reset_index(drop=True) + if len(preds) != data_matrix.shape[0]: + raise ValueError("predictions and data_matrix must have matching rows for the chosen split.") + + labels = preds["pred_label"].to_numpy() + X_full = np.asarray(data_matrix) + V = np.asarray(val_matrix) if val_matrix is not None else None + + # Slice motif window if concatenated + window_len = X_full.shape[1] + motif_width = window_len // max(1, (window_len // (view_bp or window_len))) if window_len else window_len + if motif_index is not None and X_full.ndim == 2: + n_motifs = max(1, window_len // (view_bp or window_len)) + slice_width = window_len // n_motifs + start = motif_index * slice_width + end = start + slice_width + X = X_full[:, start:end] + V = V[:, start:end] if V is not None else None + else: + X = X_full + + n_reads, window = X.shape + half = window // 2 + if view_bp is not None: + half = view_bp // 2 + x_axis = np.arange(-half, -half + X.shape[1]) + + mod_fraction = X.mean(axis=1) + order = np.lexsort((-mod_fraction, labels)) + X = X[order] + labels = labels[order] + V = V[order] if V is not None else None + + unique_labels = np.unique(labels) + cmap = plt.get_cmap(cmap_name) + norm = Normalize(vmin=0, vmax=max(len(unique_labels) - 1, 1)) + + rows, cols = np.nonzero(X) + colors = cmap(norm(pd.factorize(labels)[0][rows])) + + fig = plt.figure(figsize=(12, max(4, len(unique_labels)))) + gs = gridspec.GridSpec(nrows=len(unique_labels), ncols=2, width_ratios=[3, 1]) + ax_left = fig.add_subplot(gs[:, 0]) + ax_left.scatter(x_axis[cols], rows, s=point_size, alpha=point_alpha, c=colors) + ax_left.set_xlabel("Distance from region center (bp)") + ax_left.set_ylabel("Sorted read index") + if invert_y: + ax_left.invert_yaxis() + + change_points = np.flatnonzero(np.diff(pd.factorize(labels)[0])) + 1 + for cp in change_points: + ax_left.axhline(cp, color="0.2", linestyle="--", linewidth=0.3) + + for i, lbl in enumerate(unique_labels): + ax = fig.add_subplot(gs[i, 1]) + mask = labels == lbl + mean_profile = X[mask].mean(axis=0) + ax.plot(x_axis, mean_profile, color=cmap(norm(i)), label=str(lbl)) + if V is not None: + mean_val = V[mask].mean(axis=0) + ax.plot(x_axis, mean_val, color="0.35", linestyle="--", linewidth=1.0) + ax.set_title(f"{lbl} (n={mask.sum()})") + ax.set_xlim(x_axis[0], x_axis[-1]) + ax.set_ylim(0, min(1.0, max(0.05, mean_profile.max() + 0.05))) + fig.tight_layout() + return fig + + +def plot_multisite_read_raster( + read_windows: ReadWindowExtractionResult, + *, + n_windows: int = 2, + min_separation_bp: int = 5000, + distance_mode: str = "center", # or "bounds" + window_bp: int | None = None, + motif_index: int = 0, + smoothing: str | None = "gaussian", # None, "boxcar", "gaussian" + smooth_win: int = 21, + smooth_sigma_bp: float = 6.0, + max_rows: int = 500, + cmap: str = "viridis", + vmin: float | None = None, + vmax: float | None = None, + sort_by: str = "mod_fraction", # or "cluster" + sort_labels: Sequence[int] | None = None, + beds: Sequence[str | Path] | None = None, + rotate: bool = True, +): + """ + Plot n windows per read (e.g., paired sites) as stacked rasters, sorted by cluster or mod fraction. + + Args: + read_windows: ReadWindowExtractionResult from extract_read_windows / build_multimotif_read_windows + n_windows: number of windows per read to plot (e.g., 2 for pairs) + min_separation_bp: minimum separation between site centers (distance_mode="center") or read starts (bounds) + distance_mode: "center" uses region_start/end center; "bounds" uses read_start/read_end + window_bp: overrides default window length inferred from data_matrix slice + motif_index: which motif slice to use if data_matrix concatenates motifs + smoothing: None, "boxcar", or "gaussian" + smooth_win: smoothing window length + smooth_sigma_bp: sigma for gaussian smoothing + max_rows: cap rows; downsample by averaging if exceeded + cmap: matplotlib colormap + vmin/vmax: color scale limits; None auto-scales + sort_by: "mod_fraction" or "cluster" + sort_labels: cluster labels to sort by when sort_by="cluster" + beds: optional list of BED/GTF/GFF paths; only reads intersecting all beds are retained + rotate: if True, rotate rasters for vertical stacking + """ + + import matplotlib.pyplot as plt + import math + + def _kernel(kind: str, win: int, sigma: float): + if win % 2 == 0: + win += 1 + if kind == "gaussian": + r = win // 2 + x = np.arange(-r, r + 1) + k = np.exp(-0.5 * (x / sigma) ** 2) + return k / k.sum() + else: + k = np.ones(win, dtype=float) + return k / k.sum() + + def _smooth(M: np.ndarray) -> np.ndarray: + if smoothing is None: + return M + k = _kernel("gaussian" if smoothing == "gaussian" else "boxcar", smooth_win, smooth_sigma_bp) + r = len(k) // 2 + out = np.empty_like(M, dtype=float) + for i in range(M.shape[0]): + row = M[i] + pad_left = row[1 : r + 1][::-1] if r > 0 else row[:0] + pad_right = row[-r - 1 : -1][::-1] if r > 0 else row[:0] + padded = np.concatenate([pad_left, row, pad_right]) + out[i] = np.convolve(padded, k, mode="same")[r : r + row.size] + return out + + # Optional bed filtering + bed_filters = [] + if beds: + try: + import pyranges as pr + except Exception as exc: # pragma: no cover - optional dependency + raise ImportError("pyranges is required for bed filtering.") from exc + for bed in beds: + bed_filters.append(pr.read_bed(bed)) + + meta = read_windows.metadata + X_full = read_windows.data_matrix + # motif slicing + window_len = X_full.shape[1] + slice_width = window_bp or (window_len // max(1, window_len // (window_bp or window_len))) + n_motifs = max(1, window_len // slice_width) + start = motif_index * slice_width + end = start + slice_width + X = X_full[:, start:end] + + # Filter by beds if provided + keep_idx = np.arange(len(meta)) + if bed_filters: + keep_mask = [] + for i, m in enumerate(meta): + try: + chrom = m.get("chromosome") + rs = int(m.get("region_start", -1)) + re = int(m.get("region_end", -1)) + except Exception: + keep_mask.append(False) + continue + pr_row = pr.PyRanges(pd.DataFrame({"Chromosome": [chrom], "Start": [rs], "End": [re]})) + ok = all(len(pr_row.join(bf)) > 0 for bf in bed_filters) + keep_mask.append(ok) + keep_idx = np.flatnonzero(keep_mask) + X = X[keep_idx] + meta = [meta[i] for i in keep_idx] + + # Group by read key + groups = defaultdict(list) + for i, m in zip(range(len(meta)), meta): + key = ( + m.get("read_name"), + m.get("chromosome"), + m.get("region_strand"), + ) + if distance_mode == "center": + center = (int(m.get("region_start", 0)) + int(m.get("region_end", 0))) // 2 + else: + center = int(m.get("read_start", 0)) + groups[key].append((i, m.get("chromosome"), center)) + + panels = [[] for _ in range(n_windows)] + for _, items in groups.items(): + if len(items) < n_windows: + continue + items = sorted(items, key=lambda x: (x[1], x[2])) + # sliding window of n_windows with separation constraint + for j in range(len(items) - n_windows + 1): + centers = [items[j + k][2] for k in range(n_windows)] + if any((centers[k + 1] - centers[k]) < min_separation_bp for k in range(n_windows - 1)): + continue + idxs = [items[j + k][0] for k in range(n_windows)] + for k, idx in enumerate(idxs): + panels[k].append(X[idx]) + + if not all(len(p) > 0 for p in panels): + raise ValueError("No read sets found meeting separation criteria.") + + panels = [np.vstack(p) for p in panels] + # Smooth + panels_smooth = [_smooth(p) for p in panels] + + # Sorting + if sort_by == "mod_fraction": + means = [p.mean(axis=1) for p in panels_smooth] + order = np.lexsort(tuple(-m for m in reversed(means))) + elif sort_by == "cluster" and sort_labels is not None: + sort_labels = np.asarray(sort_labels)[keep_idx] + # repeat labels to match panels length + order = np.argsort(sort_labels) + else: + order = np.arange(panels_smooth[0].shape[0]) + + panels_sorted = [p[order] for p in panels_smooth] + + # Downsample rows if too tall + def bin_rows(M, k): + n_bins = math.ceil(M.shape[0] / k) + out = np.zeros((n_bins, M.shape[1])) + for i in range(n_bins): + s, e = i * k, min((i + 1) * k, M.shape[0]) + out[i] = M[s:e].mean(axis=0) + return out + + P = panels_sorted[0].shape[0] + downsampled = False + if P > max_rows: + step = math.ceil(P / max_rows) + panels_sorted = [bin_rows(p, step) for p in panels_sorted] + P = panels_sorted[0].shape[0] + downsampled = True + + if vmin is None or vmax is None: + vmax_auto = max(p.max() for p in panels_sorted) + vmin = 0.0 if vmin is None else vmin + vmax = vmax_auto if vmax is None else vmax + + # Plot + import matplotlib.pyplot as plt + + if rotate: + fig, axes = plt.subplots( + n_windows, 1, figsize=(max(6, P * 0.06), 3 + n_windows * 1.5), sharex=True + ) + axes = np.atleast_1d(axes) + for i, ax in enumerate(axes): + im = ax.imshow( + panels_sorted[i].T, + aspect="auto", + origin="lower", + vmin=vmin, + vmax=vmax, + cmap=cmap, + ) + ax.axhline(slice_width // 2, linestyle="--", linewidth=1, color="0.7") + ax.set_ylabel(f"Window {i+1} (bp)") + axes[-1].set_xlabel("Reads (sorted)") + else: + fig, axes = plt.subplots( + 1, n_windows, figsize=(10, max(3, P * 0.06)), sharey=True + ) + axes = np.atleast_1d(axes) + for i, ax in enumerate(axes): + im = ax.imshow( + panels_sorted[i], + aspect="auto", + origin="upper", + vmin=vmin, + vmax=vmax, + cmap=cmap, + ) + ax.axvline(slice_width // 2 - 0.5, linestyle="--", linewidth=1, color="0.7") + ax.set_xlabel("Position (bp)") + axes[0].set_ylabel("Reads (sorted)") + + cbar = fig.colorbar(im, ax=np.ravel(axes).tolist(), shrink=0.6, pad=0.02) + sigma_txt = f", σ={smooth_sigma_bp}" if smoothing == "gaussian" else "" + cbar.set_label( + f"Modification density (smoothed={smoothing}, win={smooth_win}{sigma_txt})\\n" + f"{'downsampled' if downsampled else 'full'}" + ) + + return fig, {"pairs": panels_sorted[0].shape[0], "downsampled": downsampled, "vmin": vmin, "vmax": vmax} + + +def plot_region_cluster_profiles( + pileup_matrix: np.ndarray, + labels: np.ndarray, + *, + window_bp: int | None = None, + motif_index: int | None = None, + motif_count: int | None = None, + show_all_motifs: bool = False, + cmap_name: str = "viridis", +): + """ + Visualize region-level clustering by overlaying per-cluster mean profiles and a heatmap. + + Args: + pileup_matrix: 2D array (n_regions, region_length) of modification fractions + labels: cluster assignments per region + window_bp: optional x-axis width in bp (assumes symmetric window); defaults to range(len(profile)) + motif_index: if pileup_matrix is a concatenation of multiple motifs, select which motif slice to plot + motif_count: total number of motifs concatenated; if None, inferred when possible + show_all_motifs: if True and motifs are concatenated, plot mean profiles for each motif slice per cluster + cmap_name: matplotlib colormap name for clusters + """ + + import matplotlib.pyplot as plt + from matplotlib import gridspec + from matplotlib.colors import Normalize + + X_full = np.asarray(pileup_matrix) + labs = np.asarray(labels) + if X_full.shape[0] != labs.shape[0]: + raise ValueError("pileup_matrix rows and labels must have the same length.") + + # Motif slicing + region_len = X_full.shape[1] + motif_idx = motif_index if motif_index is not None else 0 + if motif_count is None and window_bp and window_bp > 0 and region_len % window_bp == 0: + motif_count = region_len // window_bp + motif_count = max(1, int(motif_count or 1)) + slice_width = region_len // motif_count if motif_count > 0 else region_len + if slice_width == 0: + slice_width = region_len + motif_count = 1 + + start = motif_idx * slice_width + end = min(region_len, start + slice_width) + if start >= region_len: + raise ValueError( + f"motif_index {motif_idx} is out of range for concatenated length {region_len}; " + "pass motif_count to disambiguate." + ) + X = X_full[:, start:end] + + n_regions, region_len = X.shape + if window_bp is None: + x_axis = np.arange(region_len) + else: + half = window_bp // 2 + x_axis = np.linspace(-half, half, region_len) + + # Sort regions by cluster for heatmap readability + order = np.lexsort((np.arange(n_regions), labs)) + X_sorted = X[order] + labs_sorted = labs[order] + + unique_clusters = np.unique(labs_sorted) + cmap = plt.get_cmap(cmap_name) + norm = Normalize(vmin=int(unique_clusters.min()), vmax=int(unique_clusters.max())) + + fig = plt.figure(figsize=(10, 6 if not show_all_motifs else 8)) + rows = 2 if not show_all_motifs else (2 + max(0, motif_count - 1)) + gs = gridspec.GridSpec(rows, 1, height_ratios=[1] * (rows - 1) + [2], hspace=0.3) + + # Mean profiles (optionally per motif) + ax0 = fig.add_subplot(gs[0]) + for cl in unique_clusters: + mask = labs == cl + mean_profile = X[mask].mean(axis=0) + ax0.plot(x_axis, mean_profile, color=cmap(norm(int(cl))), label=f"C{cl} (n={mask.sum()})") + ax0.set_ylabel("Modified fraction") + ax0.legend(loc="upper right", ncol=min(len(unique_clusters), 4), fontsize="small") + + if show_all_motifs and motif_count and motif_count > 1: + for mi in range(1, motif_count): + ax_m = fig.add_subplot(gs[mi]) + start_m = mi * slice_width + end_m = start_m + slice_width + Xm = X_full[:, start_m:end_m] + for cl in unique_clusters: + mask = labs == cl + ax_m.plot( + x_axis, + Xm[mask].mean(axis=0), + color=cmap(norm(int(cl))), + label=f"C{cl}", + ) + ax_m.set_ylabel(f"Motif {mi}") + + # Heatmap sorted by cluster (using selected motif slice) + ax1 = fig.add_subplot(gs[-1]) + im = ax1.imshow( + X_sorted, + aspect="auto", + interpolation="none", + extent=[x_axis[0], x_axis[-1], n_regions, 0], + cmap="viridis", + ) + ax1.set_xlabel("Position (bp)" if window_bp is not None else "Index") + ax1.set_ylabel("Region (sorted by cluster)") + fig.colorbar(im, ax=ax1, label="Modified fraction") + + # Cluster boundaries + change_points = np.flatnonzero(np.diff(labs_sorted)) + 1 + for cp in change_points: + ax1.axhline(cp, color="0.8", linestyle="--", linewidth=0.5) + + fig.tight_layout() + return fig + + +def export_region_clusters_to_bed( + region_metadata: Sequence[RegionMetadata], + labels: Sequence[int], + output_path: str | Path, + *, + name_prefix: str = "cluster", + include_header: bool = False, +): + """ + Export region cluster assignments as a BED-like file. + + Args: + region_metadata: iterable of (chrom, start, end, strand) tuples, typically from region_feature_matrix_from_pileup + labels: cluster labels aligned to region_metadata + output_path: where to write the BED + name_prefix: prefix for the BED name field; final name becomes f\"{prefix}_{label}\" + include_header: if True, writes a comment header line + """ + + if len(region_metadata) != len(labels): + raise ValueError("region_metadata and labels must have the same length.") + + output_path = Path(output_path) + lines = [] + for (chrom, start, end, strand), label in zip(region_metadata, labels): + name = f"{name_prefix}_{label}" + score = str(label) + strand_field = strand if strand in {"+", "-"} else "." + lines.append(f"{chrom}\t{start}\t{end}\t{name}\t{score}\t{strand_field}\n") + + with output_path.open("w") as fh: + if include_header: + fh.write(f"# chrom\tstart\tend\tname({name_prefix}_id)\tscore\tstrand\n") + fh.writelines(lines) + + return output_path + + +def plot_cluster_karyotype( + region_bed: str | Path, + chrom_sizes: str | Path, + *, + cmap_name: str = "viridis", + linewidth: float = 6.0, + figsize_per_chrom: float = 0.4, +): + """ + Plot cluster-labeled regions along chromosomes (ideogram-style), colored by cluster. + + Args: + region_bed: BED file, typically from export_region_clusters_to_bed, with Name carrying cluster id + chrom_sizes: 2-column TSV (chrom, length) e.g. ref.fasta.fai + cmap_name: matplotlib colormap to map cluster ids to colors + linewidth: thickness of region segments + figsize_per_chrom: vertical size per chromosome for sizing the figure + """ + import matplotlib.pyplot as plt + + clusters_df = pd.read_csv( + region_bed, + sep="\t", + comment="#", + header=None, + usecols=[0, 1, 2, 3], + names=["Chromosome", "Start", "End", "Name"], + ) + chrom_df = pd.read_csv( + chrom_sizes, + sep="\t", + header=None, + usecols=[0, 1], + names=["Chromosome", "Length"], + ) + df = clusters_df.merge(chrom_df, on="Chromosome", how="inner") + if df.empty: + raise ValueError("No overlapping chromosomes between BED and chrom_sizes.") + + df["start_frac"] = df["Start"] / df["Length"] + df["end_frac"] = df["End"] / df["Length"] + df["cluster_id"] = ( + df["Name"].astype(str).str.extract(r"(\d+)$", expand=False).astype(int) + ) + + chrom_order = ( + df.groupby("Chromosome")["Length"].max().sort_values(ascending=False).index + ) + cmap = plt.get_cmap(cmap_name) + fig_height = max(3.0, figsize_per_chrom * len(chrom_order)) + fig, ax = plt.subplots(figsize=(10, fig_height)) + + for i, chrom in enumerate(chrom_order): + ax.plot([0, 1], [i, i], color="0.9", lw=linewidth) # chromosome backbone + sub = df[df["Chromosome"] == chrom] + for _, row in sub.iterrows(): + ax.plot( + [row.start_frac, row.end_frac], + [i, i], + color=cmap(row.cluster_id % cmap.N), + lw=linewidth, + solid_capstyle="butt", + ) + ax.text(-0.02, i, chrom, ha="right", va="center", fontsize=8) + + ax.set_xlim(0, 1) + ax.set_ylim(-1, len(chrom_order)) + ax.set_yticks([]) + ax.set_xlabel("Relative position along chromosome") + ax.set_title("Clustered regions by chromosome") + plt.tight_layout() + return fig + + +def summarize_region_cluster_annotations( + region_metadata: Sequence[RegionMetadata], + labels: Sequence[int], + annotation_file: str | Path, + *, + feature_field: str | None = None, + name_prefix: str = "cluster", +) -> pd.DataFrame: + """ + Intersect clustered regions with genome annotations and return per-cluster tallies. + + Args: + region_metadata: iterable of (chrom, start, end, strand) tuples + labels: cluster labels aligned to region_metadata + annotation_file: path to a BED/GTF/GFF file with annotations + feature_field: column to use as the feature/category. For GTF/GFF this defaults + to "Feature" if present. For BED, this defaults to the Name/score column if + available, else "annotation". + name_prefix: expected prefix for cluster names in the BED export (used to strip + when reading Name) + + Returns: + pandas DataFrame with counts per (cluster, feature) and a column "total_cluster" + plus a fraction-normalized view ("fraction"). + + Note: + Requires pyranges (pip install pyranges). This keeps everything in Python without + shelling out to bedtools. + """ + + try: + import pyranges as pr + except Exception as exc: # pragma: no cover - optional dependency + raise ImportError( + "summarize_region_cluster_annotations requires pyranges. " + "Install it with `pip install pyranges`." + ) from exc + + if len(region_metadata) != len(labels): + raise ValueError("region_metadata and labels must have the same length.") + + # Build PyRanges for clusters + cluster_df = pd.DataFrame( + { + "Chromosome": [c for c, _, _, _ in region_metadata], + "Start": [s for _, s, _, _ in region_metadata], + "End": [e for _, _, e, _ in region_metadata], + "Strand": [st if st in {"+", "-"} else "." for *_, st in region_metadata], + "Name": [f"{name_prefix}_{lab}" for lab in labels], + "Score": labels, + } + ) + clusters = pr.PyRanges(cluster_df) + + # Read annotations + annotation_file = Path(annotation_file) + if annotation_file.suffix.lower() in {".gtf", ".gff", ".gff3"}: + annot = pr.read_gff(annotation_file) + else: + annot = pr.read_bed(annotation_file) + + # Pick feature column + annot_df = annot.df + if feature_field and feature_field in annot_df.columns: + feature_col = feature_field + elif "Feature" in annot_df.columns: + feature_col = "Feature" + elif "Name" in annot_df.columns: + feature_col = "Name" + else: + feature_col = None + annot_df["feature_tmp"] = "annotation" + feature_col = "feature_tmp" + annot = pr.PyRanges(annot_df) + + # Intersect and count + overlaps = clusters.join(annot) + if overlaps.df.empty: + return pd.DataFrame() + + df = overlaps.df.copy() + df["cluster"] = df["Name"].astype(str).str.replace(f"{name_prefix}_", "", regex=False).astype(int) + df["feature"] = df[feature_col].astype(str) + + counts = df.groupby(["cluster", "feature"]).size().reset_index(name="count") + totals = counts.groupby("cluster")["count"].sum().reset_index(name="total_cluster") + merged = counts.merge(totals, on="cluster", how="left") + merged["fraction"] = merged["count"] / merged["total_cluster"] + return merged + + +def summarize_read_clusters_by_region( + metadata: Sequence[dict[str, Any]], + labels: Sequence[int], + *, + include_strand: bool = True, +) -> pd.DataFrame: + """ + Summarize read-level cluster composition per locus to assess homogeneity. + + Args: + metadata: list of metadata dicts returned by extract_read_windows + labels: cluster labels aligned to metadata entries + include_strand: if True, region keys include strand; set False to pool strands + + Returns: + DataFrame with one row per region key containing: + - counts per cluster + - total_reads + - dominant_cluster + - dominant_fraction + - entropy (natural log base) + """ + + if len(metadata) != len(labels): + raise ValueError("metadata and labels must have the same length.") + + def region_key(meta: dict[str, Any]) -> tuple[Any, Any, Any, Any]: + strand = meta.get("region_strand") if include_strand else None + return ( + meta.get("chromosome"), + meta.get("region_start"), + meta.get("region_end"), + strand if strand in {"+", "-"} else ".", + ) + + rows = [] + for meta, label in zip(metadata, labels): + key = region_key(meta) + rows.append((*key, label)) + + df = pd.DataFrame(rows, columns=["chrom", "start", "end", "strand", "cluster"]) + if df.empty: + return df + + counts = df.groupby(["chrom", "start", "end", "strand", "cluster"]).size() + counts = counts.reset_index(name="count") + pivot = counts.pivot_table( + index=["chrom", "start", "end", "strand"], + columns="cluster", + values="count", + fill_value=0, + ) + pivot["total_reads"] = pivot.sum(axis=1) + + # Homogeneity metrics per region + def _dominance_and_entropy(row: pd.Series) -> tuple[int, float, float]: + cluster_counts = row[row.index != "total_reads"].astype(float) + total = cluster_counts.sum() + if total == 0: + return -1, 0.0, 0.0 + dominant_cluster = int(cluster_counts.idxmax()) + dominant_fraction = float(cluster_counts.max() / total) + probs = cluster_counts / total + entropy = float(-(probs * np.log(probs + 1e-12)).sum()) + return dominant_cluster, dominant_fraction, entropy + + dom, dom_frac, ent = zip(*pivot.apply(_dominance_and_entropy, axis=1)) + pivot["dominant_cluster"] = dom + pivot["dominant_fraction"] = dom_frac + pivot["entropy"] = ent + + pivot = pivot.reset_index() + return pivot + + +__all__ = [ + "cluster_features", + "read_mod_fraction_table", + "extract_read_windows", + "build_multimotif_read_windows", + "read_window_feature_matrix", + "cluster_read_windows", + "classify_read_features_binary", + "plot_cluster_profiles", + "region_feature_matrix_from_pileup", + "plot_region_cluster_profiles", + "export_region_clusters_to_bed", + "summarize_region_cluster_annotations", + "summarize_read_clusters_by_region", + "plot_cluster_karyotype", + "plot_classification_profiles", + "plot_confusion_matrices", + "sample_rows", + "plot_multisite_read_raster", +] diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index e86b7ee..973b5e0 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -119,6 +119,10 @@ def pileup( ## Verify and prepare inputs and outputs + run_modkit.ensure_modkit_available(quiet=quiet) + + run_modkit.ensure_modkit_available(quiet=quiet) + input_file, ref_genome, output_directory = utils.sanitize_path_args( input_file, ref_genome, output_directory ) diff --git a/dimelo/run_modkit.py b/dimelo/run_modkit.py index c49106c..00fffef 100644 --- a/dimelo/run_modkit.py +++ b/dimelo/run_modkit.py @@ -16,36 +16,39 @@ # This should be updated in tandem with the environment.yml nanoporetech::modkit version EXPECTED_MODKIT_VERSION = "0.2.4" -""" -Import checks -""" -# Add conda env bin folder to path if it is not already present -# On some systems, the directory containing executables for the active environment isn't automatically on the path -# If this is the case, add that directory to the path so modkit can run -current_interpreter = sys.executable -env_bin_path = os.path.dirname(current_interpreter) -if env_bin_path not in os.environ["PATH"]: - print( - f"PATH does not include the conda environment /bin folder. Adding {env_bin_path}." - ) - os.environ["PATH"] = f"{env_bin_path}:{os.environ['PATH']}" - print(f"PATH is now {os.environ['PATH']}") +def ensure_modkit_available(quiet: bool = False) -> None: + """ + Lazily check that modkit is on PATH and matches expected version. + Called by parse functions to avoid import-time failures during analysis-only workflows. + """ -# Check modkit on first import: does it run; does it have the right version -try: - result = subprocess.run(["modkit", "--version"], stdout=subprocess.PIPE, text=True) - modkit_version = result.stdout - if modkit_version.split()[1] == EXPECTED_MODKIT_VERSION: - pass - # print(f"modkit found with expected version {EXPECTED_MODKIT_VERSION}") - else: - print( - f"modkit found with unexpected version {modkit_version.split()[1]}. Versions other than {EXPECTED_MODKIT_VERSION} may exhibit unexpected behavior. It is recommended that you use v{EXPECTED_MODKIT_VERSION}" + # Add conda env bin folder to path if it is not already present + current_interpreter = sys.executable + env_bin_path = os.path.dirname(current_interpreter) + if env_bin_path not in os.environ["PATH"]: + if not quiet: + print( + f"PATH does not include the conda environment /bin folder. Adding {env_bin_path}." + ) + os.environ["PATH"] = f"{env_bin_path}:{os.environ['PATH']}" + + try: + result = subprocess.run( + ["modkit", "--version"], stdout=subprocess.PIPE, text=True, check=True + ) + modkit_version = result.stdout.split() + if len(modkit_version) > 1 and modkit_version[1] != EXPECTED_MODKIT_VERSION: + if not quiet: + print( + f"modkit found with unexpected version {modkit_version[1]}. " + f"Expected {EXPECTED_MODKIT_VERSION}." + ) + except Exception: + raise FileNotFoundError( + 'Executable not found for modkit. Install dimelo using "conda env create -f environment.yml" ' + 'or install modkit manually using "conda install nanoporetech::modkit==0.2.4". ' + "Without modkit you cannot run parse_bam functions." ) -except subprocess.CalledProcessError: - print( - 'Executable not found for modkit. Install dimelo using "conda env create -f environment.yml" or install modkit manually to your conda environment using "conda install nanoporetech::modkit==0.2.4". Without modkit you cannot run parse_bam functions.' - ) def run_with_progress_bars( diff --git a/setup.py b/setup.py index 05ec2f1..e5f6471 100644 --- a/setup.py +++ b/setup.py @@ -13,16 +13,18 @@ "notebook", "ipykernel", "ipywidgets", - # ipywidgets is finicky on some platforms - # Local jupyter notebooks: this works best with ipywidgets and jupyter running the latest versions, which is what this file will do. - # Google Colab: ipywidgets 7.7.1 seems to be necessary for Google Colab needed for tqdm.auto progress bars as of Feb 11 2024. - # This says that was fixed in 2022 but it sure wasn't when I tried https://github.com/googlecolab/colabtools/issues/3023. - # You can simply downgrade after installing using pip install ., it won't break anything to our knowledge. - # VS Code: using the VS code plugin to run jupyter, 7.7.1 also works while the latest version does not. Likely that - # some intermediate versions work too. - # On the Berkeley High Performance Computing Cluster, Savio, I needed to install ipywidgets==7.6.5 for jupyter Open On-Demand. "tqdm", "plotly", "kaleido", ], + extras_require={ + "clustering": [ + "scikit-learn", + "scipy", + "hdbscan", + "umap-learn", + "pyranges", + "xgboost", + ] + }, ) diff --git a/tests/test_cluster.py b/tests/test_cluster.py new file mode 100644 index 0000000..74cc39a --- /dev/null +++ b/tests/test_cluster.py @@ -0,0 +1,372 @@ +import numpy as np +import pytest + +from dimelo import cluster + + +def test_region_feature_matrix_from_pileup(monkeypatch): + # Mock the region parsing and loading helpers so we can focus on the feature logic + fake_regions_dict = { + "chr1": [(0, 3, "+")], + "chr2": [(5, 8, "-")], + } + monkeypatch.setattr( + cluster.utils, "regions_dict_from_input", lambda *args, **kwargs: fake_regions_dict + ) + monkeypatch.setattr( + cluster.load_processed, + "regions_to_list", + lambda **kwargs: [ + (np.array([1, 1, 0], dtype=float), np.array([2, 2, 1], dtype=float)), + (np.array([0, 2, 2], dtype=float), np.array([1, 4, 4], dtype=float)), + ], + ) + + features, metadata = cluster.region_feature_matrix_from_pileup( + bedmethyl_file="pileup.bed.gz", + motif="A,0", + regions="regions.bed", + pseudo_count=0.0, + ) + + np.testing.assert_allclose( + features, + np.array( + [ + [0.5, 0.5, 0.0], + [0.0, 0.5, 0.5], + ] + ), + ) + assert metadata == [("chr1", 0, 3, "+"), ("chr2", 5, 8, "-")] + + +def test_read_mod_fraction_table(monkeypatch): + datasets = [ + "read_name", + "chromosome", + "motif", + "mod_vector", + "val_vector", + "region_start", + "region_end", + "region_strand", + "read_length", + "A,0_mod_fraction", + "CG,0_mod_fraction", + ] + read_records = [ + ("read1", "chr1", "A,0", None, None, 10, 110, "+", 100, 0.25, 0.75), + ("read2", "chr1", "CG,0", None, None, 20, 140, "-", 120, 0.10, 0.60), + ] + monkeypatch.setattr( + cluster.load_processed, + "read_vectors_from_hdf5", + lambda **kwargs: (read_records, datasets, {"chr1": [(0, 100, "+")]}), + ) + + features, feature_names, metadata, regions_dict = cluster.read_mod_fraction_table( + hdf5_file="reads.h5", + motifs=["A,0", "CG,0"], + metadata_fields=("read_name", "chromosome"), + ) + + np.testing.assert_allclose( + features, + np.array( + [ + [0.25, 0.75], + [0.10, 0.60], + ] + ), + ) + assert feature_names == ["A,0_mod_fraction", "CG,0_mod_fraction"] + assert metadata == [ + {"read_name": "read1", "chromosome": "chr1"}, + {"read_name": "read2", "chromosome": "chr1"}, + ] + assert regions_dict == {"chr1": [(0, 100, "+")]} + + +def test_cluster_features_invokes_kmeans(monkeypatch): + class DummyKMeans: + def __init__(self, n_clusters, random_state, **kwargs): + self.n_clusters = n_clusters + self.random_state = random_state + self.kwargs = kwargs + self.observed = None + + def fit_predict(self, matrix): + self.observed = matrix + return np.arange(matrix.shape[0]) + + monkeypatch.setattr(cluster, "_get_kmeans", lambda: DummyKMeans) + + feature_matrix = np.array([[0.1, 0.2], [0.4, 0.6], [0.9, 0.95]]) + labels, estimator = cluster.cluster_features( + feature_matrix, n_clusters=3, random_state=7 + ) + + np.testing.assert_array_equal(labels, np.array([0, 1, 2])) + assert isinstance(estimator, DummyKMeans) + assert estimator.n_clusters == 3 + np.testing.assert_allclose(estimator.observed, feature_matrix) + + +def test_cluster_features_rejects_unknown_method(): + with pytest.raises(ValueError): + cluster.cluster_features(np.ones((2, 2)), method="dbscan") + + +def test_extract_read_windows_orientation(monkeypatch): + dataset_names = [ + "chromosome", + "mod_vector", + "motif", + "read_end", + "read_name", + "read_start", + "strand", + "val_vector", + "region_start", + "region_end", + "region_strand", + "read_length", + ] + record = ( + "chr1", + np.arange(10, dtype=float), + "A,0", + 110, + "read1", + 100, + "-", + np.ones(10, dtype=float), + 104, + 108, + "+", + 10, + ) + + def fake_loader(**kwargs): + return ([record], dataset_names, None) + + monkeypatch.setattr(cluster.load_processed, "read_vectors_from_hdf5", fake_loader) + result = cluster.extract_read_windows( + hdf5_file="reads.h5", + motifs=["A,0"], + config=cluster.ReadWindowExtractionConfig(window_size=4, orientation_aware=True), + ) + + np.testing.assert_allclose(result.data_matrix, np.array([[7.0, 6.0, 5.0, 4.0]])) + assert result.val_matrix is not None + assert len(result.metadata) == 1 + + +def test_extract_read_windows_filter_multi_region(monkeypatch): + dataset_names = [ + "chromosome", + "mod_vector", + "motif", + "read_end", + "read_name", + "read_start", + "strand", + "val_vector", + "region_start", + "region_end", + "region_strand", + "read_length", + ] + rec1 = ( + "chr1", + np.zeros(10, dtype=float), + "A,0", + 110, + "dup", + 100, + "+", + np.ones(10, dtype=float), + 104, + 108, + "+", + 10, + ) + rec2 = ( + "chr1", + np.ones(10, dtype=float), + "A,0", + 115, + "dup", + 100, + "+", + np.ones(10, dtype=float), + 106, + 110, + "+", + 10, + ) + rec3 = ( + "chr1", + np.arange(10, dtype=float), + "A,0", + 112, + "keep", + 100, + "+", + np.ones(10, dtype=float), + 104, + 108, + "+", + 10, + ) + + def fake_loader(**kwargs): + return ([rec1, rec2, rec3], dataset_names, None) + + monkeypatch.setattr(cluster.load_processed, "read_vectors_from_hdf5", fake_loader) + result = cluster.extract_read_windows( + hdf5_file="reads.h5", + motifs=["A,0"], + config=cluster.ReadWindowExtractionConfig( + window_size=4, orientation_aware=False, filter_multi_region_reads=True + ), + ) + assert result.data_matrix.shape[0] == 1 + assert result.metadata[0]["read_name"] == "keep" + + + def test_read_window_feature_matrix(): + data = np.array( + [ + [0, 0, 1, 1], + [1, 1, 0, 0], + [0, 1, 0, 1], + ], + dtype=float, + ) + result = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=[], + datasets=[], + regions_dict=None, + ) + features, names = cluster.read_window_feature_matrix( + result, + n_pca=1, + autocorr_lags=(1,), + density_windows=(("center", -2, 2),), + require_nonzero_valid=False, + min_valid_fraction=0.0, + ) + assert features.shape[0] == 3 + assert "pca_0" in names + assert "autocorr_1" in names + assert "center" in names + assert "global_mean" in names + assert "iqr" in names + + +def test_plot_cluster_profiles_motif_index(monkeypatch): + X = np.hstack([np.ones((3, 2)), np.zeros((3, 2))]) + labels = np.array([0, 1, 0]) + import matplotlib + + matplotlib.use("Agg") + fig = cluster.plot_cluster_profiles(X, labels, motif_index=1, view_bp=2) + assert fig is not None + + +def test_plot_region_cluster_profiles_motif_index(monkeypatch): + X = np.hstack([np.ones((2, 2)), np.zeros((2, 2))]) + labels = np.array([0, 1]) + import matplotlib + + matplotlib.use("Agg") + fig = cluster.plot_region_cluster_profiles( + X, labels, motif_index=1, motif_count=2, window_bp=2 + ) + assert fig is not None + + +def test_read_window_feature_matrix_filters(): + data = np.array( + [ + [0, 0, 1, 1], + [1, 1, 0, 0], + ], + dtype=float, + ) + val = np.array( + [ + [0, 0, 1, 1], + [0, 0, 0, 0], + ], + dtype=float, + ) + result = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=val, + metadata=[], + datasets=[], + regions_dict=None, + ) + features, _ = cluster.read_window_feature_matrix( + result, require_nonzero_valid=True, min_valid_fraction=0.5, n_pca=0, autocorr_lags=() + ) + # Second row should be dropped due to zero valid fraction + assert features.shape[0] == 1 + + +def test_plot_multisite_read_raster_smoke(monkeypatch): + # Build a minimal ReadWindowExtractionResult with two motifs, two reads + data = np.hstack( + [ + np.tile(np.array([[0, 1, 0, 1]], dtype=float), (2, 1)), + np.tile(np.array([[1, 0, 1, 0]], dtype=float), (2, 1)), + ] + ) + meta = [ + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 6000, + "region_end": 6004, + "region_strand": "+", + }, + ] + r = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=meta, + datasets=[], + regions_dict=None, + ) + import matplotlib + + matplotlib.use("Agg") + fig, stats = cluster.plot_multisite_read_raster( + r, n_windows=2, min_separation_bp=5000, motif_index=0, smoothing=None + ) + assert fig is not None + assert stats["pairs"] >= 1 + + +def test_cluster_read_windows_kmeans(): + rng = np.random.default_rng(0) + feature_matrix = rng.normal(size=(20, 5)) + result = cluster.cluster_read_windows( + feature_matrix, method="kmeans", n_clusters=3, random_state=0 + ) + assert isinstance(result.labels_raw, np.ndarray) + assert result.labels_raw.shape[0] == 20 + assert result.labels_size_ordered.shape == result.labels_raw.shape + assert "silhouette" in result.metrics diff --git a/tutorial.ipynb b/tutorial.ipynb index bf7b85d..1b98c1d 100644 --- a/tutorial.ipynb +++ b/tutorial.ipynb @@ -1889,7 +1889,384 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Exporting pileups to bigwig" + "## Clustering and Classification\n", + "\n", + "This section shows how to work with processed files (`pileup.sorted.bed.gz` and `extract.h5`) to discover structure in your data.\n", + "\n", + "- **Read clustering**: build fixed-length windows per read, compute features (PCA, autocorrelation, density, stats), and cluster molecules. Supports single motifs or combined multi-motif windows.\n", + "- **Read classification**: train a binary classifier on read features to quantify separability between two samples; includes train/test metrics, confusion matrices, and per-read profile plots.\n", + "- **Region clustering**: cluster loci on their pileup profiles (single motif or concatenated multi-motif features), and visualize mean profiles plus genome distribution.\n", + "- **Region classification**: treat each locus feature vector as a sample for downstream classifiers.\n", + "\n", + "Optional clustering deps: `scikit-learn`, `scipy`, `hdbscan`, `umap-learn`, `pyranges`, `xgboost` (install via `pip install dimelo[clustering]`).\n", + "Make sure earlier parsing steps have produced the processed files before running these examples." + ] + }, + { + "cell_type": "markdown", + "id": "6f031f5a", + "metadata": {}, + "source": [ + "### Read analysis tips\n", + "- Use `span_full_window=True` and `orientation_aware=True` when extracting to keep windows consistent.\n", + "- For multi-motif windows, set `require_all_motifs=True` to drop reads missing motifs instead of zero-filling.\n", + "- Drop low-information reads by setting `require_nonzero_valid=True` and `min_valid_fraction` in `read_window_feature_matrix`.\n", + "- Inspect cluster/classifier QC: profile plots for clusters, confusion matrices and per-read profile plots for classifiers.\n", + "- Check locus homogeneity with `summarize_read_clusters_by_region` (dominant_fraction/entropy) to see if clusters are locus-driven.\n", + "- Beware class imbalance in classifiers; look at both accuracy and ROC-AUC, and at confusion matrices to spot overfitting." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Read Clustering" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Single motif" + ] + }, + { + "cell_type": "markdown", + "id": "efbdf960", + "metadata": {}, + "source": [ + "*Motif semantics*: the extract file stores one row per motif per read. Passing multiple motifs yields multiple rows; use `build_multimotif_read_windows` to group motifs per read (drops missing motifs by default) or filter by `metadata['motif']` for per-motif analyses. Use `motif_index` in plotting helpers to pick which motif slice to display." + ] + }, + { + "cell_type": "markdown", + "id": "d5ae7b69", + "metadata": {}, + "source": [ + "**Sampling for speed**: Use `cluster.sample_rows` to downsample reads or loci before clustering/classification. Example:\n", + "\n", + "```python\n", + "sampled_feat, sampled_labels, idx = cluster.sample_rows(feature_matrix, labels, frac=0.2, stratify=True)\n", + "```\n", + "\n", + "Run heavy algorithms (e.g., spectral/DBSCAN/UMAP) on the sample, then apply insights back to the full set." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "julia" + } + }, + "outputs": [], + "source": [ + "from dimelo import cluster\n", + "\n", + "# Combine motifs per read; windows are concatenated in the order given\n", + "rw_multi = cluster.build_multimotif_read_windows(\n", + " hdf5_file=\"output/extract.h5\",\n", + " motifs=[\"A,0\", \"CG,0\"],\n", + " regions=\"output/regions.processed.bed\",\n", + " window_size=2000,\n", + " orientation_aware=True,\n", + " span_full_window=True,\n", + " require_all_motifs=True,\n", + ")\n", + "\n", + "feat_multi, _ = cluster.read_window_feature_matrix(\n", + " rw_multi,\n", + " n_pca=6,\n", + " use_peak_features=False,\n", + " require_nonzero_valid=True,\n", + " min_valid_fraction=0.05,\n", + ")\n", + "clust_multi = cluster.cluster_read_windows(feat_multi, method=\"kmeans\", n_clusters=8, random_state=42)\n", + "\n", + "# QC plot: choose which motif slice to visualize\n", + "cluster.plot_cluster_profiles(\n", + " rw_multi.data_matrix,\n", + " clust_multi.labels_size_ordered,\n", + " motif_index=0, # 0 for A, 1 for CG\n", + " view_bp=400,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Multiple motif" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "julia" + } + }, + "outputs": [], + "source": [ + "from dimelo import cluster\n", + "\n", + "# Combine motifs per read; windows are concatenated in the order given\n", + "rw_multi = cluster.build_multimotif_read_windows(\n", + " hdf5_file=\"output/extract.h5\",\n", + " motifs=[\"A,0\", \"CG,0\"],\n", + " regions=\"output/regions.processed.bed\",\n", + " window_size=2000,\n", + " orientation_aware=True,\n", + " span_full_window=True,\n", + ")\n", + "\n", + "feat_multi, _ = cluster.read_window_feature_matrix(rw_multi, n_pca=6, use_peak_features=False)\n", + "clust_multi = cluster.cluster_read_windows(feat_multi, method=\"kmeans\", n_clusters=8, random_state=42)\n", + "\n", + "# QC plot (shows the first motif window for readability)\n", + "motif1_len = rw_multi.data_matrix.shape[1] // len([\"A,0\", \"CG,0\"])\n", + "cluster.plot_cluster_profiles(rw_multi.data_matrix[:, :motif1_len], clust_multi.labels_size_ordered, view_bp=400)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Read Classification" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Single Motif" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# sample_labels must align to feat_single rows (e.g., [\"sampleA\", \"sampleA\", \"sampleB\", ...])\n", + "clf_single = cluster.classify_read_features_binary(\n", + " feat_single,\n", + " sample_labels=sample_labels_single,\n", + " classifier=\"xgboost\", # or logreg/sgd/random_forest/svc/knn\n", + " random_state=42,\n", + ")\n", + "print(clf_single[\"metrics\"])\n", + "cluster.plot_confusion_matrices(clf_single[\"predictions\"])\n", + "# cluster.plot_classification_profiles(rw_single.data_matrix, clf_single[\"predictions\"], split=\"test\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "70a3b81c", + "metadata": {}, + "source": [ + "*Tip*: For concatenated motif windows, use `motif_index` in plotting helpers to choose which motif slice to visualize (e.g., 0 for the first motif, 1 for the second)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Multiple motifs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# sample_labels_multi must align to feat_multi rows\n", + "clf_multi = cluster.classify_read_features_binary(\n", + " feat_multi,\n", + " sample_labels=sample_labels_multi,\n", + " classifier=\"xgboost\",\n", + " random_state=42,\n", + ")\n", + "print(clf_multi[\"metrics\"])\n", + "cluster.plot_confusion_matrices(clf_multi[\"predictions\"])\n", + "# cluster.plot_classification_profiles(rw_multi.data_matrix[:, :motif1_len], clf_multi[\"predictions\"], split=\"test\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Region Clustering" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Single Motif" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Build region-level features from the pileup output (align motifs across loci)\n", + "pileup_matrix, region_info = cluster.region_feature_matrix_from_pileup(\n", + " bedmethyl_file=\"output/pileup.sorted.bed.gz\",\n", + " motif=\"A,0\",\n", + " regions=\"output/regions.processed.bed\",\n", + " window_size=500,\n", + " regions_5to3prime=True,\n", + ")\n", + "\n", + "# Cluster loci on their profiles\n", + "region_labels, _ = cluster.cluster_features(pileup_matrix, n_clusters=4)\n", + "\n", + "# Visualize mean profiles + heatmap of loci sorted by cluster\n", + "cluster.plot_region_cluster_profiles(pileup_matrix, region_labels, window_bp=1000)\n", + "\n", + "# Export cluster-labeled BED and karyotype view\n", + "cluster.export_region_clusters_to_bed(region_info, region_labels, \"region_clusters.bed\")\n", + "cluster.plot_cluster_karyotype(\"region_clusters.bed\", \"ref.fasta.fai\") # chrom sizes (FAI) needed for karyotype plot\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Multiple motifs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Region Classification" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Single motif" + ] + }, + { + "cell_type": "markdown", + "id": "b5e02651", + "metadata": {}, + "source": [ + "*Tip*: When concatenating multiple motifs per locus, use `motif_index` in `plot_region_cluster_profiles` to choose which motif slice to visualize (e.g., 0 for the first motif). Clustering can still use the full concatenated matrix." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from dimelo import cluster\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import accuracy_score, roc_auc_score, confusion_matrix\n", + "from sklearn.linear_model import LogisticRegression\n", + "import numpy as np\n", + "\n", + "# Build region features\n", + "pileup_matrix_A, region_info = cluster.region_feature_matrix_from_pileup(\n", + " bedmethyl_file=\"output/pileup.sorted.bed.gz\",\n", + " motif=\"A,0\",\n", + " regions=\"output/regions.processed.bed\",\n", + " window_size=500,\n", + " regions_5to3prime=True,\n", + ")\n", + "\n", + "# Provide a label per region (e.g., condition, annotation class)\n", + "# region_labels_y = [...]\n", + "# Replace the following line with your actual labels:\n", + "# region_labels_y = np.array([...], dtype=str)\n", + "\n", + "# Split train/test\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " pileup_matrix_A, region_labels_y, test_size=0.2, random_state=42, stratify=region_labels_y\n", + ")\n", + "\n", + "clf = LogisticRegression(max_iter=500, class_weight=\"balanced\")\n", + "clf.fit(X_train, y_train)\n", + "proba = clf.predict_proba(X_test)[:, 1] if len(np.unique(y_train)) == 2 else None\n", + "y_pred = clf.predict(X_test)\n", + "\n", + "print(\"Accuracy:\", accuracy_score(y_test, y_pred))\n", + "if proba is not None:\n", + " print(\"ROC-AUC:\", roc_auc_score(y_test, proba))\n", + "print(\"Confusion matrix:\\n\", confusion_matrix(y_test, y_pred))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Multiple motif" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from dimelo import cluster\n", + "import numpy as np\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import accuracy_score, roc_auc_score, confusion_matrix\n", + "from sklearn.linear_model import LogisticRegression\n", + "\n", + "motifs = [\"A,0\", \"CG,0\"]\n", + "matrices = []\n", + "for m in motifs:\n", + " mat, region_info = cluster.region_feature_matrix_from_pileup(\n", + " bedmethyl_file=\"output/pileup.sorted.bed.gz\",\n", + " motif=m,\n", + " regions=\"output/regions.processed.bed\",\n", + " window_size=500,\n", + " regions_5to3prime=True,\n", + " )\n", + " matrices.append(mat)\n", + "\n", + "# Concatenate features per locus\n", + "pileup_matrix_multi = np.concatenate(matrices, axis=1)\n", + "\n", + "# region_labels_y = [...] # labels per region, same length as pileup_matrix_multi rows\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " pileup_matrix_multi, region_labels_y, test_size=0.2, random_state=42, stratify=region_labels_y\n", + ")\n", + "\n", + "clf = LogisticRegression(max_iter=500, class_weight=\"balanced\")\n", + "clf.fit(X_train, y_train)\n", + "proba = clf.predict_proba(X_test)[:, 1] if len(np.unique(y_train)) == 2 else None\n", + "y_pred = clf.predict(X_test)\n", + "\n", + "print(\"Accuracy:\", accuracy_score(y_test, y_pred))\n", + "if proba is not None:\n", + " print(\"ROC-AUC:\", roc_auc_score(y_test, proba))\n", + "print(\"Confusion matrix:\\n\", confusion_matrix(y_test, y_pred))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Export" ] }, { @@ -3572,6 +3949,155 @@ " smooth_window=50,\n", ")" ] + }, + { + "cell_type": "markdown", + "id": "4d63cc62", + "metadata": {}, + "source": [ + "## Advanced examples: clustering, karyotypes, and binary discrimination\n", + "\n", + "These examples assume you've already run the parsing steps above and produced:\n", + "- `pileup.sorted.bed.gz` and `regions.processed.bed` from `parse_bam.pileup`\n", + "- `extract.h5` from `parse_bam.extract`\n", + "\n", + "Optional dependencies: `scikit-learn`, `scipy`, `hdbscan`, `umap-learn`, `pyranges`, `xgboost` (for boosted classifiers)." + ] + }, + { + "cell_type": "markdown", + "id": "d93718d1", + "metadata": {}, + "source": [ + "### Region-level clustering and karyotype overview\n", + "Cluster loci on their pileup profiles, visualize per-cluster mean traces, and plot their genome distribution." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e90335aa", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "from dimelo import cluster\n", + "\n", + "# Paths produced by earlier steps in this tutorial\n", + "pileup_file = \"output/pileup.sorted.bed.gz\"\n", + "regions_bed = \"output/regions.processed.bed\"\n", + "chrom_sizes = \"ref.fasta.fai\" # 2-column file: chrom\tlength\n", + "\n", + "# Build region features and cluster\n", + "pileup_matrix, region_info = cluster.region_feature_matrix_from_pileup(\n", + " bedmethyl_file=pileup_file,\n", + " motif=\"A,0\",\n", + " regions=regions_bed,\n", + " window_size=500,\n", + " regions_5to3prime=True,\n", + ")\n", + "region_labels, _ = cluster.cluster_features(pileup_matrix, n_clusters=4)\n", + "\n", + "# Visualize and export\n", + "cluster.plot_region_cluster_profiles(pileup_matrix, region_labels, window_bp=1000)\n", + "cluster.export_region_clusters_to_bed(region_info, region_labels, \"region_clusters.bed\")\n", + "cluster.plot_cluster_karyotype(\"region_clusters.bed\", chrom_sizes)\n" + ] + }, + { + "cell_type": "markdown", + "id": "ea579eef", + "metadata": {}, + "source": [ + "### Read-level clustering and QC\n", + "Extract fixed windows per read, build features, cluster, and visualize per-read calls with mean profiles." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d312b57", + "metadata": {}, + "outputs": [], + "source": [ + "# Extract windows from the read-level file\n", + "rw = cluster.extract_read_windows(\n", + " hdf5_file=\"output/extract.h5\",\n", + " motifs=[\"A,0\", \"CG,0\"],\n", + " regions=regions_bed,\n", + " config=cluster.ReadWindowExtractionConfig(window_size=2000, orientation_aware=True, filter_multi_region_reads=True),\n", + " span_full_window=True,\n", + ")\n", + "\n", + "# Build features and cluster\n", + "features, feature_names = cluster.read_window_feature_matrix(rw, n_pca=6, use_peak_features=False)\n", + "read_clusters = cluster.cluster_read_windows(features, method=\"kmeans\", n_clusters=8, random_state=42)\n", + "\n", + "# Visual QC of clustered reads\n", + "cluster.plot_cluster_profiles(rw.data_matrix, read_clusters.labels_size_ordered, val_matrix=rw.val_matrix, view_bp=400)\n" + ] + }, + { + "cell_type": "markdown", + "id": "dc76d638", + "metadata": {}, + "source": [ + "### Binary discrimination between two samples\n", + "Use a classifier to quantify how separable two conditions are and visualize confusion matrices and profiles." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "680d3d09", + "metadata": {}, + "outputs": [], + "source": [ + "# Assume sample_labels is a list/array of sample IDs (length == n_reads) aligned to `features` / `rw`\n", + "# e.g., sample_labels = [\"sampleA\", \"sampleA\", \"sampleB\", ...]\n", + "\n", + "clf_result = cluster.classify_read_features_binary(\n", + " features,\n", + " sample_labels=sample_labels,\n", + " classifier=\"xgboost\", # or logreg/sgd/random_forest/svc/knn\n", + " random_state=42,\n", + ")\n", + "print(clf_result[\"metrics\"])\n", + "\n", + "# Confusion matrices for train/test\n", + "cluster.plot_confusion_matrices(clf_result[\"predictions\"])\n", + "\n", + "# Per-read view colored by predicted label (use the split that matches your data_matrix rows)\n", + "# cluster.plot_classification_profiles(rw.data_matrix, clf_result[\"predictions\"], split=\"test\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "622060ce", + "metadata": {}, + "source": [ + "### Paired / multi-site read raster\n", + "Use `plot_multisite_read_raster` to visualize multiple windows per read (e.g., upstream/downstream sites), with smoothing, separation filters, and optional bed filtering." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d54a6201", + "metadata": {}, + "outputs": [], + "source": [ + "# Example (assumes read_windows from extract_read_windows/build_multimotif_read_windows)\n", + "# fig, stats = cluster.plot_multisite_read_raster(\n", + "# read_windows=rw_single,\n", + "# n_windows=2,\n", + "# min_separation_bp=5000,\n", + "# motif_index=0, # choose motif slice if concatenated\n", + "# smoothing=\"gaussian\",\n", + "# )\n", + "# fig.show()\n", + "# print(stats)\n" + ] } ], "metadata": { From 1468a188f17223a207660f344b086a5b4ae883d6 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 11:40:11 -0700 Subject: [PATCH 002/272] docs: add shared cluster distribution design spec --- ...3-31-shared-cluster-distribution-design.md | 427 ++++++++++++++++++ 1 file changed, 427 insertions(+) create mode 100644 docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md diff --git a/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md b/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md new file mode 100644 index 0000000..aeacc8b --- /dev/null +++ b/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md @@ -0,0 +1,427 @@ +# Shared Cluster Distribution Design + +## Summary + +Add a package-level workflow that defines a single set of clustering boundaries across multiple matched datasets, applies those boundaries consistently to every dataset, and reports how cluster occupancy changes across conditions. The workflow must support two related use cases: + +1. `read_global`: cluster reads pooled across datasets independent of locus, then project cluster assignments back onto matched regions. +2. `region_anchored`: build matched region-level feature rows across datasets, cluster those rows once, and compare condition-level shifts in region-cluster occupancy. + +The workflow should scale from thousands to millions of reads or regions per dataset, with roughly a dozen datasets per run. + +## Goals + +- Define cluster boundaries once and reuse them across all datasets in a run. +- Make the shared-boundary workflow available as a stable package API rather than notebook-only code. +- Preserve compatibility with existing `dimelo` extract outputs and existing feature-engineering code in `dimelo.cluster`. +- Support matched-region analyses while also allowing read clustering that is independent of region. +- Return structured tabular results suitable for downstream notebook analysis, plus a small standard plot set for quick interpretation. +- Use a performant default that remains usable at million-row scale. + +## Non-Goals + +- Reproduce every ad hoc plot or helper from the collaborator notebook as package API. +- Ship experiment-specific hard-coded condition schemes as core logic. +- Recluster separately for each condition or each region. +- Store large raw matrices on result objects by default. + +## User-Facing Workflow + +### Primary Entry Point + +```python +from dimelo.models import SampleSpec +from dimelo import workflows + +samples = [ + SampleSpec( + sample_id="sample_1", + condition="NS", + extract_h5="path/to/sample_1.h5", + regions_bed="path/to/sample_1_regions.bed", + replicate=1, + ), + SampleSpec( + sample_id="sample_2", + condition="15min", + extract_h5="path/to/sample_2.h5", + regions_bed="path/to/sample_2_regions.bed", + replicate=1, + ), +] + +result = workflows.shared_cluster_distribution( + samples=samples, + mode="read_global", + motifs=["A,0"], + matched_regions=None, + clusterer="minibatch_kmeans", + n_clusters=8, + training_sample_per_dataset=100_000, + random_state=42, + make_plots=True, +) +``` + +### Supported Modes + +#### `read_global` + +- Extract read-level windows and read-level feature matrices from every dataset. +- Build one balanced pooled training set across datasets. +- Fit one shared clustering model. +- Assign cluster labels to every read in every dataset. +- Optionally map those read labels back to matched regions for per-region occupancy summaries. + +#### `region_anchored` + +- Build one feature row per matched region per dataset from aggregated read-level metrics. +- Fit one shared clustering model across the pooled region rows. +- Assign cluster labels to every matched region row. +- Summarize cluster distribution shifts across conditions. + +## Recommended Default Algorithm + +### Default Strategy + +Use a balanced pooled reference with `MiniBatchKMeans`. + +1. Extract features separately per dataset. +2. Sample up to `training_sample_per_dataset` rows from each dataset. +3. Concatenate those samples into a pooled training matrix. +4. Fit one preprocessing pipeline on the pooled matrix. +5. Fit one shared clustering model on the pooled matrix. +6. Apply the frozen preprocessing and clustering model to the full datasets in chunks. +7. Summarize cluster distributions globally and by matched region. + +### Why This Default + +- More fair than anchoring cluster boundaries on one reference dataset. +- More performant than full pooled `KMeans` when rows scale into the millions. +- Simpler and more interpretable than per-region or per-condition reclustering. +- Produces fixed centroids, which makes prediction for full datasets cheap. + +### Alternatives Kept Open + +- `KMeans` for smaller runs. +- `GaussianMixture`, `Birch`, or `HDBSCAN` if later needed, but not as the initial default. +- Reference-dataset anchoring as an explicit option rather than the default path. + +## Architecture + +### Module Layout + +#### `dimelo/models.py` + +Owns the workflow dataclasses: + +- `SampleSpec` +- `SharedClusterModel` +- `SharedClusterResult` + +#### `dimelo/distribution.py` + +Owns generic summary logic: + +- counts per dataset and condition +- cluster fractions +- baseline deltas +- log2 fold changes +- replicate-aware aggregations + +#### `dimelo/region_analysis.py` + +Owns region-aware helpers: + +- matched-region validation +- read-to-region projection +- region-by-condition occupancy summaries +- matched region feature table construction for `region_anchored` + +#### `dimelo/workflows.py` + +Owns orchestration: + +- input validation +- dataset iteration +- balanced pooled training subset construction +- fit-once / assign-many execution +- standard plot creation +- result packaging + +#### `dimelo/cluster.py` + +Retains low-level primitives already present on the branch: + +- `extract_read_windows` +- `read_window_feature_matrix` +- `cluster_read_windows` +- generic cluster profile plotting +- generic region-cluster plotting and summaries + +The new workflow should call these lower-level functions rather than duplicate them. + +## Data Model + +### `SampleSpec` + +```python +@dataclass +class SampleSpec: + sample_id: str + condition: str + extract_h5: str | Path + regions_bed: str | Path | None = None + replicate: int | None = None + metadata: dict[str, Any] | None = None +``` + +### `SharedClusterModel` + +```python +@dataclass +class SharedClusterModel: + mode: str + motifs: list[str] + feature_names: list[str] + preprocessing: dict[str, Any] + estimator: Any + cluster_labels: list[str] + fit_metadata: dict[str, Any] +``` + +### `SharedClusterResult` + +```python +@dataclass +class SharedClusterResult: + model: SharedClusterModel + assignments: pd.DataFrame + cluster_distribution: pd.DataFrame + condition_distribution: pd.DataFrame + distribution_change: pd.DataFrame | None + cluster_profiles: pd.DataFrame + region_summaries: pd.DataFrame | None + figures: dict[str, Any] + metadata: dict[str, Any] +``` + +## Detailed Workflow Behavior + +### Shared Validation + +Before any feature extraction: + +- Require at least two datasets. +- Require `sample_id`, `condition`, and `extract_h5` for every sample. +- Require consistent `motifs` and compatible extracted vector lengths across datasets. +- In `region_anchored`, require resolvable matched-region inputs for every dataset. +- Record dataset sizes and rows remaining after filtering. + +### `read_global` Flow + +1. For each sample, load read windows from extract output using existing cluster helpers. +2. Generate read-level feature rows. +3. Build a balanced pooled training subset across samples. +4. Fit preprocessing on the pooled subset: + - optional valid-site filtering + - optional scaling + - PCA or other dimensionality reduction +5. Fit `MiniBatchKMeans` on the pooled subset. +6. Transform and assign the full dataset for each sample in chunks. +7. Build a long-form assignments table with: + - `sample_id` + - `condition` + - `replicate` + - `cluster` + - read metadata columns + - optional region keys if present +8. Summarize: + - global cluster occupancy per sample + - cluster occupancy per condition + - read-cluster occupancy by region when matched-region keys are available + +### `region_anchored` Flow + +1. For each sample, project reads onto matched regions. +2. Aggregate region-level metrics per matched region. +3. Build one aligned feature row per region per dataset. +4. Build a balanced pooled training subset across datasets. +5. Fit preprocessing and one shared clustering model. +6. Assign cluster labels to all region rows. +7. Summarize region-cluster occupancy shifts across conditions. + +## Performance Strategy + +### Core Rules + +- Fit on bounded pooled subsets, not on all rows. +- Use `MiniBatchKMeans` as the default estimator. +- Use chunked prediction for full assignment. +- Convert feature matrices to `float32` after extraction when precision permits. +- Avoid storing raw read-window matrices in the returned object unless explicitly requested. + +### Sampling Strategy + +The pooled training set should be balanced across datasets by default: + +- choose `min(dataset_size, training_sample_per_dataset)` rows per dataset +- concatenate sampled rows +- record actual sampled counts in result metadata + +Optional future extension: + +- stratified sampling by region or prior label if metadata is available + +## Outputs + +### `assignments` + +Long-form row-level output: + +- one row per read in `read_global` +- one row per region in `region_anchored` + +Minimum columns: + +- `sample_id` +- `condition` +- `replicate` +- `cluster` +- mode-specific identifiers + +### `cluster_distribution` + +Per-sample cluster summaries: + +- `sample_id` +- `condition` +- `cluster` +- `count` +- `fraction` + +### `condition_distribution` + +Condition-level aggregate summary: + +- `condition` +- `cluster` +- `count` +- `fraction` +- `replicate_n` + +### `distribution_change` + +Optional comparison against a reference condition: + +- `condition` +- `cluster` +- `fraction` +- `delta_fraction` +- `log2_fc` + +### `cluster_profiles` + +Interpretability table: + +- mean feature values per cluster +- optional mean profile vectors summarized into compact columns + +### `region_summaries` + +Only when region mapping is possible: + +- `region_id` +- `sample_id` +- `condition` +- `cluster` +- `count` +- `fraction` + +## Standard Plots + +The initial standardized plot set should be small: + +1. stacked bar plot of cluster fraction by dataset +2. stacked bar plot of cluster fraction by condition +3. heatmap of cluster fraction or delta/log2FC across conditions +4. cluster profile plot for interpretation + +Optional later additions: + +- top-changing region heatmap +- baseline-vs-induction scatter plots +- preset study-specific figure suites + +## Error Handling + +The workflow should fail fast for structural issues: + +- incompatible motifs across datasets +- inconsistent extracted vector lengths +- missing matched-region metadata in `region_anchored` +- zero usable rows after filtering +- duplicate `sample_id` + +The workflow should warn but continue when possible for soft issues: + +- a dataset contributes fewer rows than requested to the training pool +- region mapping drops a substantial number of reads +- some clusters are absent from some conditions after assignment + +## Testing Strategy + +### Unit Tests + +Add new tests for: + +- balanced pooled sampling +- fit-once / assign-many workflow behavior +- condition distribution summaries +- region summary generation +- reference-condition delta calculations +- chunked assignment equivalence versus unchunked assignment + +### Integration Tests + +Add small synthetic multi-sample fixtures that verify: + +- shared centroids are reused across samples +- `read_global` assignments can be projected back onto region summaries +- `region_anchored` produces stable per-condition cluster distributions + +### Regression Tests + +Retain and extend the clustering tests already on the branch rather than reimplementing feature extraction from scratch. + +## Documentation Strategy + +Add: + +- one API-oriented doc for the workflow +- one example notebook for `read_global` +- one example notebook for `region_anchored` + +The collaborator notebook should be preserved as exploratory history but should not remain the primary interface for this analysis. + +## Implementation Plan Shape + +The implementation should be split into small steps: + +1. add models +2. add distribution summaries +3. add region-aware summarization helpers +4. add workflow orchestration +5. add standardized plots +6. add tests +7. update docs/examples + +## Implementation Defaults + +These defaults are fixed for the first implementation: + +- default clusterer: `MiniBatchKMeans` +- default cluster-boundary source: balanced pooled subset across all datasets +- default result mode: return structured tables and figures, not raw matrices + +No experiment-specific cluster template system is required for the first version of this workflow. From 7c63a1e2310ba5ecf6e03d0175176fc89fd65073 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 11:53:03 -0700 Subject: [PATCH 003/272] docs: extend shared clustering spec with batch orchestration --- ...3-31-shared-cluster-distribution-design.md | 187 +++++++++++++++++- 1 file changed, 181 insertions(+), 6 deletions(-) diff --git a/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md b/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md index aeacc8b..03635df 100644 --- a/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md +++ b/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md @@ -17,6 +17,8 @@ The workflow should scale from thousands to millions of reads or regions per dat - Support matched-region analyses while also allowing read clustering that is independent of region. - Return structured tabular results suitable for downstream notebook analysis, plus a small standard plot set for quick interpretation. - Use a performant default that remains usable at million-row scale. +- Introduce a hybrid batch model that supports both independent dataset processing and flexible cohort-level shared workflows. +- Make downstream workflows consume reusable artifacts when available, while still being able to rebuild from raw inputs when necessary. ## Non-Goals @@ -148,6 +150,25 @@ Owns orchestration: - fit-once / assign-many execution - standard plot creation - result packaging +- artifact resolution for workflow inputs + +#### `dimelo/artifacts.py` + +Owns reusable dataset-level derived outputs and lookup helpers: + +- artifact key definitions +- artifact metadata and provenance +- cache hit / miss resolution +- compatibility checks between requested parameters and stored artifacts + +#### `dimelo/batch.py` + +Owns hybrid batch orchestration: + +- independent dataset processing jobs +- named cohort jobs +- workflow recipes +- batch manifests for downstream workflow execution #### `dimelo/cluster.py` @@ -206,6 +227,144 @@ class SharedClusterResult: metadata: dict[str, Any] ``` +### `DatasetArtifact` + +```python +@dataclass +class DatasetArtifact: + sample_id: str + artifact_type: str + path: str | Path + format: str + params: dict[str, Any] + provenance: dict[str, Any] +``` + +### `CohortSpec` + +```python +@dataclass +class CohortSpec: + cohort_id: str + sample_ids: list[str] + workflow: str + params: dict[str, Any] + metadata: dict[str, Any] | None = None +``` + +### `BatchJob` + +```python +@dataclass +class BatchJob: + job_id: str + workflow: str + cohorts: list[CohortSpec] + artifact_policy: str = "prefer_cached" + metadata: dict[str, Any] | None = None +``` + +## Hybrid Batch Model + +The package should support two complementary batch concepts rather than forcing one batch unit everywhere. + +### Dataset-Centric Processing + +Each dataset can be processed independently into a standard artifact bundle. This is the high-throughput, cache-friendly layer. + +Examples of dataset-level artifacts: + +- QC summaries +- read-level feature tables +- region-mapping tables +- cluster-ready metadata tables +- cached transformed feature matrices + +This layer is best for: + +- parallel processing of many unrelated datasets +- retry and resume at per-dataset granularity +- feeding many downstream workflows from the same reusable intermediates + +### Cohort-Centric Workflows + +Named cohorts should define which datasets participate in a shared analysis recipe. + +Examples: + +- shared-boundary clustering over six matched samples +- region occupancy analysis over one subset +- a different recipe over an unrelated subset processed in parallel + +This layer is best for: + +- pooled fitting +- consistent cluster boundary definition +- any workflow where the group of samples matters scientifically + +### Recommended Hybrid Structure + +The system should use both layers: + +1. dataset processing produces reusable standardized artifacts +2. cohort workflows consume those artifacts to run shared analyses + +This preserves flexibility while avoiding repeated raw-input processing. + +## Artifact Resolution Policy + +Downstream workflows should prefer cached artifacts but fall back to raw inputs automatically when required artifacts are missing or incompatible. + +### Default Policy + +Use `artifact_policy="prefer_cached"` as the default. + +Resolution order: + +1. look for a compatible artifact +2. if found, load it +3. if missing or incompatible, rebuild from raw inputs +4. record whether the workflow used cache hits or rebuilt inputs + +### Additional Policies + +- `prefer_cached` + default pragmatic mode +- `require_cached` + fail if required artifacts are unavailable +- `rebuild` + ignore cached artifacts and regenerate needed intermediates + +### Provenance Requirements + +Every workflow result should record: + +- which artifacts were loaded from cache +- which artifacts were rebuilt +- the parameters used to determine compatibility +- the raw input paths used when fallback occurred + +This keeps the fallback behavior auditable rather than implicit. + +## Shared Workflow Input Contract + +Shared comparison workflows should consume artifact manifests or dataset specs, not notebook-era ad hoc dictionaries. + +### Accepted Input Forms + +1. `SampleSpec` objects with raw input paths +2. artifact manifests derived from those samples +3. `CohortSpec` objects that name a workflow and a set of samples + +The shared workflow should resolve the required inputs internally through the artifact layer. + +### Why This Contract Matters + +- the same sample can participate in multiple shared workflows +- expensive preprocessing is reused +- workflows remain runnable even when some artifacts are absent +- batch orchestration stays decoupled from notebook-specific path plumbing + ## Detailed Workflow Behavior ### Shared Validation @@ -217,6 +376,7 @@ Before any feature extraction: - Require consistent `motifs` and compatible extracted vector lengths across datasets. - In `region_anchored`, require resolvable matched-region inputs for every dataset. - Record dataset sizes and rows remaining after filtering. +- Resolve required artifacts using the selected artifact policy before rebuilding from raw inputs. ### `read_global` Flow @@ -338,6 +498,15 @@ Only when region mapping is possible: - `count` - `fraction` +### `metadata` + +The top-level metadata payload should also include: + +- artifact policy used +- artifact cache hits and misses +- per-sample rebuild decisions +- cohort identifier when the workflow is cohort-driven + ## Standard Plots The initial standardized plot set should be small: @@ -381,6 +550,8 @@ Add new tests for: - region summary generation - reference-condition delta calculations - chunked assignment equivalence versus unchunked assignment +- artifact resolution under `prefer_cached`, `require_cached`, and `rebuild` +- cohort-driven execution that reuses dataset-level artifacts ### Integration Tests @@ -389,6 +560,7 @@ Add small synthetic multi-sample fixtures that verify: - shared centroids are reused across samples - `read_global` assignments can be projected back onto region summaries - `region_anchored` produces stable per-condition cluster distributions +- cohort workflows can mix cache hits and raw-input fallbacks without changing result schema ### Regression Tests @@ -409,12 +581,14 @@ The collaborator notebook should be preserved as exploratory history but should The implementation should be split into small steps: 1. add models -2. add distribution summaries -3. add region-aware summarization helpers -4. add workflow orchestration -5. add standardized plots -6. add tests -7. update docs/examples +2. add artifact definitions and resolution helpers +3. add batch and cohort orchestration models +4. add distribution summaries +5. add region-aware summarization helpers +6. add workflow orchestration +7. add standardized plots +8. add tests +9. update docs/examples ## Implementation Defaults @@ -423,5 +597,6 @@ These defaults are fixed for the first implementation: - default clusterer: `MiniBatchKMeans` - default cluster-boundary source: balanced pooled subset across all datasets - default result mode: return structured tables and figures, not raw matrices +- default artifact policy: `prefer_cached` No experiment-specific cluster template system is required for the first version of this workflow. From 4426d0b6c202b8d60e86099d37405e552ea93e52 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 11:56:47 -0700 Subject: [PATCH 004/272] docs: add normalization modes to shared clustering spec --- ...3-31-shared-cluster-distribution-design.md | 163 ++++++++++++++++-- 1 file changed, 149 insertions(+), 14 deletions(-) diff --git a/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md b/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md index 03635df..c8f6a04 100644 --- a/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md +++ b/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md @@ -57,6 +57,9 @@ result = workflows.shared_cluster_distribution( mode="read_global", motifs=["A,0"], matched_regions=None, + signal_normalization="none", + feature_scaling="robust_zscore", + cluster_basis="shape_plus_level", clusterer="minibatch_kmeans", n_clusters=8, training_sample_per_dataset=100_000, @@ -96,6 +99,11 @@ Use a balanced pooled reference with `MiniBatchKMeans`. 6. Apply the frozen preprocessing and clustering model to the full datasets in chunks. 7. Summarize cluster distributions globally and by matched region. +The preprocessing pipeline in this algorithm must distinguish between: + +- biological signal normalization before feature construction +- feature scaling after feature construction + ### Why This Default - More fair than anchoring cluster boundaries on one reference dataset. @@ -367,6 +375,109 @@ The shared workflow should resolve the required inputs internally through the ar ## Detailed Workflow Behavior +## Normalization And Scaling Model + +The workflow must treat three concepts independently: + +1. biological signal normalization +2. feature scaling for model fitting +3. cluster basis selection + +These must not be collapsed into one generic "scale" option, because they answer different questions. + +### Biological Signal Normalization + +This operates on the raw or aggregated assay signal before clustering features are built. + +Supported modes: + +- `none` + Preserve absolute global shifts across datasets. + Use when broad changes in accessibility or compaction may be biologically real. + +- `per_sample_global` + Normalize each dataset by a global per-sample factor. + Useful when technical global shifts are suspected, but this can remove true biology. + +- `control_regions` + Normalize using designated control loci expected to be stable across conditions. + This is the preferred correction mode when suitable controls are available. + +- `quantile` + Force distributions into alignment across datasets. + This is a strong technical correction mode and should not be the default. + +### Feature Scaling + +This operates only on the feature matrix passed to PCA or clustering. It does not redefine the underlying biological signal in reported outputs. + +Supported modes: + +- `none` +- `zscore` +- `robust_zscore` + +Default: `robust_zscore` + +### Cluster Basis Selection + +This determines whether shared cluster boundaries should use absolute level, local pattern shape, or both. + +Supported modes: + +- `level_only` + Shared boundaries are driven primarily by absolute accessibility level. + This is sensitive to broad global shifts. + +- `shape_only` + Shared boundaries are driven by local pattern shape after removing row-level global offset. + This is useful when asking whether local patterns change independently of global level. + +- `shape_plus_level` + Use both shape-derived features and explicit global-level features. + This is the recommended default because it helps disentangle global compaction from local pattern reorganization. + +### Recommended Default Interpretation + +The first implementation should default to: + +- `signal_normalization="none"` +- `feature_scaling="robust_zscore"` +- `cluster_basis="shape_plus_level"` + +This preserves potential biological global shifts while still making the model numerically stable and keeping both local-pattern and global-level information available for clustering. + +### Comparison-Oriented Helper Workflow + +The package should eventually support a helper that runs the same shared-boundary workflow under multiple normalization or basis settings and compares the outputs. + +Example shape: + +```python +result = workflows.compare_shared_cluster_modes( + samples=samples, + modes=[ + { + "signal_normalization": "none", + "feature_scaling": "robust_zscore", + "cluster_basis": "shape_plus_level", + }, + { + "signal_normalization": "control_regions", + "feature_scaling": "robust_zscore", + "cluster_basis": "shape_plus_level", + }, + { + "signal_normalization": "none", + "feature_scaling": "robust_zscore", + "cluster_basis": "shape_only", + }, + ], +) +``` + +This comparison-oriented wrapper is not required for the first implementation, but the shared clustering workflow should be designed so that it can support this later without API breakage. + ### Shared Validation Before any feature extraction: @@ -377,26 +488,30 @@ Before any feature extraction: - In `region_anchored`, require resolvable matched-region inputs for every dataset. - Record dataset sizes and rows remaining after filtering. - Resolve required artifacts using the selected artifact policy before rebuilding from raw inputs. +- Validate `signal_normalization`, `feature_scaling`, and `cluster_basis` as independent parameters. +- If `signal_normalization="control_regions"`, require control-region inputs or a resolvable control-region artifact. ### `read_global` Flow 1. For each sample, load read windows from extract output using existing cluster helpers. -2. Generate read-level feature rows. -3. Build a balanced pooled training subset across samples. -4. Fit preprocessing on the pooled subset: +2. Apply biological signal normalization if requested. +3. Generate read-level feature rows. +4. Apply cluster-basis transformation and feature scaling. +5. Build a balanced pooled training subset across samples. +6. Fit preprocessing on the pooled subset: - optional valid-site filtering - - optional scaling + - feature scaling - PCA or other dimensionality reduction -5. Fit `MiniBatchKMeans` on the pooled subset. -6. Transform and assign the full dataset for each sample in chunks. -7. Build a long-form assignments table with: +7. Fit `MiniBatchKMeans` on the pooled subset. +8. Transform and assign the full dataset for each sample in chunks. +9. Build a long-form assignments table with: - `sample_id` - `condition` - `replicate` - `cluster` - read metadata columns - optional region keys if present -8. Summarize: +10. Summarize: - global cluster occupancy per sample - cluster occupancy per condition - read-cluster occupancy by region when matched-region keys are available @@ -404,12 +519,14 @@ Before any feature extraction: ### `region_anchored` Flow 1. For each sample, project reads onto matched regions. -2. Aggregate region-level metrics per matched region. -3. Build one aligned feature row per region per dataset. -4. Build a balanced pooled training subset across datasets. -5. Fit preprocessing and one shared clustering model. -6. Assign cluster labels to all region rows. -7. Summarize region-cluster occupancy shifts across conditions. +2. Apply biological signal normalization if requested. +3. Aggregate region-level metrics per matched region. +4. Build one aligned feature row per region per dataset. +5. Apply cluster-basis transformation and feature scaling. +6. Build a balanced pooled training subset across datasets. +7. Fit preprocessing and one shared clustering model. +8. Assign cluster labels to all region rows. +9. Summarize region-cluster occupancy shifts across conditions. ## Performance Strategy @@ -433,6 +550,14 @@ Optional future extension: - stratified sampling by region or prior label if metadata is available +### Scaling And Normalization Performance Notes + +- `signal_normalization="none"` should be the cheapest mode because it avoids extra correction passes. +- `per_sample_global` should remain lightweight because it only requires one global factor per dataset. +- `control_regions` will require extra region-level resolution work but is still acceptable if control-region inputs are cached as artifacts. +- `quantile` is likely the most expensive normalization mode and should not be used implicitly. +- `shape_only` can often be implemented as a per-row centering or offset-removal transform and should remain computationally cheap. + ## Outputs ### `assignments` @@ -506,6 +631,10 @@ The top-level metadata payload should also include: - artifact cache hits and misses - per-sample rebuild decisions - cohort identifier when the workflow is cohort-driven +- signal normalization mode +- feature scaling mode +- cluster basis mode +- any per-sample normalization factors used ## Standard Plots @@ -552,6 +681,9 @@ Add new tests for: - chunked assignment equivalence versus unchunked assignment - artifact resolution under `prefer_cached`, `require_cached`, and `rebuild` - cohort-driven execution that reuses dataset-level artifacts +- `shape_only`, `level_only`, and `shape_plus_level` feature-path behavior +- preservation of global shifts under `signal_normalization="none"` +- expected correction behavior for `per_sample_global` and `control_regions` ### Integration Tests @@ -598,5 +730,8 @@ These defaults are fixed for the first implementation: - default cluster-boundary source: balanced pooled subset across all datasets - default result mode: return structured tables and figures, not raw matrices - default artifact policy: `prefer_cached` +- default signal normalization: `none` +- default feature scaling: `robust_zscore` +- default cluster basis: `shape_plus_level` No experiment-specific cluster template system is required for the first version of this workflow. From 935a51032fea21ac7ff5e6720c11be779b69a4c7 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 12:13:08 -0700 Subject: [PATCH 005/272] docs: add region analysis architecture spec --- ...-31-region-analysis-architecture-design.md | 569 ++++++++++++++++++ 1 file changed, 569 insertions(+) create mode 100644 docs/superpowers/specs/2026-03-31-region-analysis-architecture-design.md diff --git a/docs/superpowers/specs/2026-03-31-region-analysis-architecture-design.md b/docs/superpowers/specs/2026-03-31-region-analysis-architecture-design.md new file mode 100644 index 0000000..b2b242d --- /dev/null +++ b/docs/superpowers/specs/2026-03-31-region-analysis-architecture-design.md @@ -0,0 +1,569 @@ +# Region Analysis Architecture Design + +## Summary + +Add a coherent downstream analysis architecture that separates: + +- preprocessing and artifact materialization in `parse_bam` +- genome-scale summarization in `global_analysis` +- de novo locus finding in `region_discovery` +- defined-region comparison in `region_contrasts` +- deeper structure analysis in `cluster` + +The goal is to preserve the current region-targeted analysis logic while making it easier to support both broad global analysis and explicit defined-region comparison workflows. + +## Goals + +- Keep `parse_bam` as the preprocessing entry point rather than replacing it. +- Preserve the current logic that supports region-targeted downstream analysis. +- Add a global-analysis layer for broad dataset-wide summaries and normalization support. +- Reserve `region_discovery` for de novo locus finding when the user does not yet know which regions matter. +- Add `region_contrasts` for significance testing and effect-size analysis over predefined regions. +- Make it explicit what each comparison is run on: + which datasets are compared, + what the analysis unit is, + and what read or region representation is being contrasted. +- Integrate cleanly with shared clustering workflows and pileup-backed summaries. + +## Non-Goals + +- Collapse all downstream analysis into one giant generic module. +- Hide biological interpretation behind vague names like "region test" or "single-read comparison". +- Replace existing pileup/extract logic with one monolithic artifact type. +- Implement every possible statistical test in the first version. + +## Architectural Split + +### `dimelo.parse_bam` + +Remains the preprocessing and artifact-materialization layer. + +Responsibilities: + +- run `modkit`-backed pileup generation +- run read-level extraction +- validate inputs +- emit reusable outputs that downstream workflows can consume + +User model: + +- preprocessing/materialization lives here +- downstream interpretation does not + +### `dimelo.global_analysis` + +New module for broad dataset-wide summarization. + +Responsibilities: + +- global accessibility or modification summaries +- chromosome- or window-level aggregated tracks +- QC summaries +- global shift metrics +- control-region normalization support +- generation of broad candidate tracks for de novo discovery + +This module is for asking: + +- what is happening globally in this dataset? +- do we see broad compaction or decompaction? +- are there obvious global technical shifts? + +### `dimelo.region_discovery` + +Reserved for de novo locus finding only. + +Responsibilities: + +- scan broad genomic inputs without requiring predefined regions +- tile the genome or candidate intervals +- compute discovery scores on windows +- merge or refine nearby hits +- export discovered loci as BED-like outputs + +This module is for asking: + +- where in the genome are the most interesting regions? +- which loci stand out within one dataset? +- which loci change strongly between matched datasets when regions were not known in advance? + +If the user already has a BED or defined region set, they should not use `region_discovery`. + +### `dimelo.region_contrasts` + +New module for defined-region comparison and testing. + +Responsibilities: + +- summarize signal over known regions +- compute effect sizes across matched datasets +- run region-level statistical tests such as beta-binomial +- support pairwise, grouped, background-adjusted, and time-course contrasts +- export ranked results for downstream region-targeted workflows + +This module is for asking: + +- how do these known loci differ across conditions? +- which predefined regions change significantly? +- are observed differences at known loci likely to reflect technical scaling or real biology? + +### `dimelo.cluster` + +Retains responsibility for structure analysis once reads or regions have been selected. + +Responsibilities: + +- shared-boundary clustering across datasets +- read-global and region-anchored clustering workflows +- cluster occupancy summaries +- integration with region-level summaries and contrasts + +This module is for asking: + +- what structure exists among reads or regions? +- do read states or region states reorganize across conditions? + +## User-Facing Flow + +The intended flow should be: + +1. `parse_bam` + materialize reusable preprocessing outputs +2. `global_analysis` + summarize genome-wide behavior and broad technical or biological shifts +3. `region_discovery` + discover candidate loci when regions are not known +4. `region_contrasts` + score and test known loci +5. `cluster` + perform deep structural analysis on reads or regions of interest + +This flow should be composable rather than mandatory. A user may enter at `region_contrasts` with an existing BED, or enter at `cluster` using a previously selected set of regions. + +## Why `region_discovery` And `region_contrasts` Must Be Separate + +These are different scientific tasks: + +- discovery asks where signal or change exists +- contrasts ask what happens at loci already defined + +If they are collapsed together: + +- de novo scanning logic gets mixed with BED-based testing +- statistical assumptions become unclear +- it becomes hard to tell whether a result was discovered or tested on predefined loci + +The package should therefore reserve: + +- `region_discovery` for unknown loci +- `region_contrasts` for known loci + +## `region_contrasts` Core API + +### Primary Entry Point + +```python +result = region_contrasts.score_regions( + samples=samples, + regions=regions, + contrast=contrast_spec, + analysis_unit="ensemble_region", + representation="modified_fraction", + signal_source="pileup_counts", + test="beta_binomial", + multiple_testing="fdr_bh", +) +``` + +The API must make these dimensions explicit: + +1. `contrast` + which datasets or conditions are compared +2. `analysis_unit` + what the rows represent +3. `representation` + what property of those rows is being contrasted + +## Contrast Specification + +### `ContrastSpec` + +```python +@dataclass +class ContrastSpec: + mode: str + numerator: list[str] | None = None + denominator: list[str] | None = None + background: list[str] | None = None + time_order: list[str] | None = None + pairing_key: str | None = None + reference_condition: str | None = None + metadata: dict[str, Any] | None = None +``` + +### Supported Contrast Modes + +- `single_dataset` + rank regions within one dataset +- `pairwise` + compare two datasets directly +- `matched_pairwise` + compare matched samples using an explicit pairing key +- `group_vs_group` + compare multiple samples or conditions against another group +- `background_adjusted` + compare signal after accounting for matched background measurements +- `time_course` + compare ordered condition trajectories + +The same `ContrastSpec` structure should support all of these rather than fragmenting into unrelated function families. + +## Analysis Unit Model + +The package must be explicit about what observational level is being compared. + +### `analysis_unit="ensemble_region"` + +Rows represent aggregated region-level signal. + +Examples: + +- region-level modified counts +- region-level valid counts +- region-level modified fraction +- region-level enrichment summaries + +This is the default path for significance testing with beta-binomial models. + +### `analysis_unit="single_read"` + +Rows represent individual reads within predefined regions. + +Examples: + +- per-read modification fraction +- read-level density profile summaries +- read window features +- read span or length metrics + +This is for within-region distributional changes, not simple count-based testing. + +### `analysis_unit="cluster_occupancy"` + +Rows represent region-level summaries derived from clustered reads or clustered regions. + +Examples: + +- fraction of reads assigned to a cluster within a region +- dominant cluster fraction +- cluster entropy +- state-mixture proportions + +This is the bridge between clustering and region-level contrasts. + +## Representation Model + +Even within a given analysis unit, users need to know what property is being compared. + +### Ensemble-Region Representations + +- `modified_fraction` +- `modified_count` +- `coverage` +- `enrichment` +- `depth_profile_summary` + +### Single-Read Representations + +- `read_mod_fraction` +- `read_density_profile` +- `read_window_features` +- `read_shape` +- `read_length_or_span` +- `motif_specific_fraction` + +### Cluster-Occupancy Representations + +- `cluster_fraction` +- `dominant_cluster` +- `cluster_entropy` +- `state_mixture` + +## Why `analysis_unit` And `representation` Must Both Be Explicit + +Without these fields, a user cannot tell whether a result means: + +- the average region became more or less accessible +- the distribution of reads within the region changed +- the mixture of read states changed +- the local pattern shape changed while the mean remained constant + +These are biologically different conclusions and should never be hidden behind a generic label like "region contrast". + +## Signal Sources + +The first implementation should support multiple signal substrates with a clear default. + +### `signal_source="pileup_counts"` + +Primary default. + +Uses per-region modified and valid counts. + +This is the natural substrate for: + +- beta-binomial testing +- region-level effect sizes +- broad defined-region comparison + +### `signal_source="region_features"` + +Optional later mode. + +Uses region-level summaries derived from read-level artifacts or feature engineering. + +This is useful when pileup counts are not the right abstraction. + +### `signal_source="cluster_occupancy"` + +Integration mode with clustering workflows. + +Uses region-level cluster proportions or occupancy summaries as input to defined-region contrasts. + +## Statistical Engines + +### First-Pass Default + +Support `test="beta_binomial"` for: + +- `analysis_unit="ensemble_region"` +- `signal_source="pileup_counts"` + +This should be the first formal significance-testing path because it aligns with the current count-oriented architecture and the requested statistical direction. + +### Additional First-Version Mode + +Support `test="effect_size_only"` for fast exploratory use without p-values. + +### Planned But Not Required For V1 + +- distribution-shift tests for `single_read` +- occupancy/fraction tests for `cluster_occupancy` +- richer time-course inferential models + +These should be designed into the schema now, but not block the first implementation. + +## `region_discovery` Core API + +### Primary Entry Point + +```python +result = region_discovery.scan_genome( + samples=samples, + contrast=contrast_spec, + window_size=2000, + step_size=500, + signal_source="pileup_counts", + score="beta_binomial", + merge_hits=True, +) +``` + +`region_discovery` should: + +- generate candidate windows or intervals +- score them using a discovery-specific engine +- rank them +- optionally merge or refine neighboring hits +- export discovered intervals into BED-like outputs + +These outputs should be directly consumable by `region_contrasts` and `cluster`. + +## Shared Evidence Table + +Both `region_discovery` and `region_contrasts` should rely on a common internal region evidence table when possible. + +Example schema: + +```python +RegionEvidence +- region_id +- chrom +- start +- end +- sample_id +- condition +- replicate +- modified_count +- valid_count +- modified_fraction +- coverage +- analysis_unit +- representation +- signal_source +- metadata... +``` + +This shared evidence table keeps discovery and contrast workflows comparable without conflating their user-facing roles. + +## Integration With Clustering + +### `region_contrasts -> cluster` + +Defined-region contrasts should be able to export ranked or significant BEDs for downstream deep clustering analysis. + +Examples: + +- take top significant regions from beta-binomial testing +- cluster reads within those selected loci +- compare region-level cluster occupancy afterward + +### `cluster -> region_contrasts` + +Clustering workflows should be able to emit region-level occupancy artifacts that `region_contrasts` can score. + +Examples: + +- test whether cluster C3 occupancy differs between conditions at known regions +- compare cluster entropy across matched loci + +### `global_analysis -> region_discovery` + +Global summaries should provide coarse substrate for discovery: + +- broad tracks +- normalization factors +- window-level summaries + +### `region_discovery -> region_contrasts` + +Discovered loci should be easy to hand off into formal defined-region testing and ranking workflows. + +## Module Layout + +### `dimelo/global_analysis.py` + +Responsibilities: + +- broad summaries +- QC and global scaling diagnostics +- control-region normalization support + +### `dimelo/region_discovery.py` + +Responsibilities: + +- de novo scans +- candidate interval generation +- discovery scoring +- hit merging and refinement + +### `dimelo/region_contrasts.py` + +Responsibilities: + +- defined-region evidence building +- contrast specification handling +- beta-binomial and effect-size scoring +- result tables and export helpers + +### `dimelo/cluster.py` + +Responsibilities: + +- structure analysis +- cluster occupancy outputs +- integration with defined-region analyses + +## Output Contracts + +### `RegionContrastResult` + +```python +@dataclass +class RegionContrastResult: + regions: pd.DataFrame + summary: pd.DataFrame + contrast: ContrastSpec + metadata: dict[str, Any] + figures: dict[str, Any] +``` + +The metadata must include: + +- contrast mode +- analysis unit +- representation +- signal source +- test +- normalization mode + +### `RegionDiscoveryResult` + +```python +@dataclass +class RegionDiscoveryResult: + hits: pd.DataFrame + windows: pd.DataFrame + contrast: ContrastSpec | None + metadata: dict[str, Any] + figures: dict[str, Any] +``` + +The outputs should be easy to export as BEDs and easy to pass into follow-on workflows. + +## Testing Strategy + +### Unit Tests + +Add tests for: + +- `ContrastSpec` validation across supported modes +- legal and illegal combinations of `analysis_unit`, `representation`, `signal_source`, and `test` +- region evidence table construction +- effect-size-only ranking +- beta-binomial path over predefined region counts +- handoff from discovered regions into defined-region contrasts + +### Integration Tests + +Add synthetic tests that verify: + +- a de novo scan can produce intervals that are then consumed by `region_contrasts` +- a clustering workflow can emit cluster occupancy summaries that `region_contrasts` can score +- metadata clearly records what was contrasted and at what observational level + +## Documentation Strategy + +Add: + +- one doc for global summaries and preprocessing handoff +- one doc for de novo region discovery +- one doc for defined-region contrasts +- one doc showing how discovered or contrasted regions feed into clustering + +## Implementation Plan Shape + +The implementation should be split into small pieces: + +1. add `ContrastSpec` and result models +2. add `global_analysis` scaffolding +3. add `region_contrasts` evidence-building and effect-size workflows +4. add beta-binomial testing for `ensemble_region` plus `pileup_counts` +5. add `region_discovery` scanning and BED export +6. add clustering integration points +7. add tests +8. add docs/examples + +## Implementation Defaults + +These defaults are fixed for the first implementation: + +- `region_discovery` is for de novo loci only +- `region_contrasts` is for known regions only +- default `analysis_unit`: `ensemble_region` +- default `representation`: `modified_fraction` +- default `signal_source`: `pileup_counts` +- default `test`: `beta_binomial` when the combination is valid + +This architecture should make it obvious what is being compared and why, while still supporting clean handoff into clustering and other downstream workflows. From 3cdaaf66f7a55982d0cd52f6db58353b38b854fc Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 12:16:42 -0700 Subject: [PATCH 006/272] docs: clarify region contrast semantics and user flow --- ...-31-region-analysis-architecture-design.md | 139 ++++++++++++++++++ 1 file changed, 139 insertions(+) diff --git a/docs/superpowers/specs/2026-03-31-region-analysis-architecture-design.md b/docs/superpowers/specs/2026-03-31-region-analysis-architecture-design.md index b2b242d..445a97c 100644 --- a/docs/superpowers/specs/2026-03-31-region-analysis-architecture-design.md +++ b/docs/superpowers/specs/2026-03-31-region-analysis-architecture-design.md @@ -140,6 +140,60 @@ The intended flow should be: This flow should be composable rather than mandatory. A user may enter at `region_contrasts` with an existing BED, or enter at `cluster` using a previously selected set of regions. +## User Progression Through Processing And Analysis + +The package should make it obvious how a user proceeds from preprocessing to downstream analysis. + +### Common Starting Point + +All downstream workflows should begin from preprocessing outputs created by `parse_bam`. + +Conceptually: + +```python +from dimelo import parse_bam + +pileup_path, processed_regions = parse_bam.pileup(...) +extract_path, processed_regions = parse_bam.extract(...) +``` + +The user should not have to guess which downstream workflow consumes which preprocessing product: + +- use pileup-backed outputs for: + - global summaries + - defined-region abundance contrasts + - de novo region discovery scans +- use extract-backed outputs for: + - single-read pattern analysis + - read clustering + - cluster occupancy summaries + +### Typical Processing Paths + +#### Path A: Known Regions, Locus-Level Abundance Testing + +1. preprocess with pileup or load an existing pileup-backed artifact +2. run `region_contrasts.score_regions(...)` +3. review ranked or significant loci +4. optionally pass top regions into `cluster` + +#### Path B: Known Regions, Single-Read Or State-Level Analysis + +1. preprocess with extract or load an existing extract-backed artifact +2. run clustering or other read-level feature workflows +3. summarize cluster occupancy or read-state metrics by region +4. optionally score those outputs in `region_contrasts` + +#### Path C: Unknown Regions + +1. preprocess with pileup-backed outputs +2. run `region_discovery.scan_genome(...)` +3. export discovered intervals +4. score those intervals with `region_contrasts` +5. optionally perform deep clustering on selected regions + +This progression should be reflected in documentation and examples so the user sees the intended branching early. + ## Why `region_discovery` And `region_contrasts` Must Be Separate These are different scientific tasks: @@ -300,6 +354,79 @@ Without these fields, a user cannot tell whether a result means: These are biologically different conclusions and should never be hidden behind a generic label like "region contrast". +## Biological Interpretation Of Contrasts + +The package must make it clear what biological question a contrast answers. + +### Reference-Matched Motif Abundance + +This asks: + +- at a defined locus, did the abundance of modification across reference-matched motif opportunities change? + +Interpretation: + +- aggregate motif-level modified and valid counts within a locus +- compare abundance across conditions or matched datasets + +Recommended configuration: + +- `analysis_unit="ensemble_region"` +- `representation="modified_fraction"` or `representation="modified_count"` +- `signal_source="pileup_counts"` +- `test="beta_binomial"` when formal significance testing is desired + +This is the primary count-based contrast path and should be the first-class default. + +### Single-Read Pattern Change + +This asks: + +- within a known locus, did the pattern of modification across individual reads change? + +Interpretation: + +- align and orient reads relative to a common reference frame +- compare per-read fractions, local densities, shapes, or feature vectors + +Recommended configuration: + +- `analysis_unit="single_read"` +- `representation="read_mod_fraction"`, `read_density_profile`, `read_window_features`, or `read_shape` +- extract-backed signal source + +This is not the same question as abundance testing, and beta-binomial should not be presented as the default test here. + +### Locus-Aggregated Structural Change + +This asks: + +- at a locus, did the mixture of read states or the aggregated structure change even if the mean abundance did not? + +Interpretation: + +- summarize read states or read clusters into region-level occupancy features +- compare mixture structure across conditions + +Recommended configuration: + +- `analysis_unit="cluster_occupancy"` +- `representation="cluster_fraction"`, `dominant_cluster`, or `cluster_entropy` +- clustering-derived signal source + +This is the main bridge from clustering into defined-region contrast analysis. + +### Required User Clarity + +Every result and exported table should make all of the following explicit: + +- which datasets or conditions were contrasted +- whether the contrast is abundance, single-read pattern, or state-mixture oriented +- what observational unit was used +- what representation was scored + +Users should never need to infer this from filenames or notebook context. + ## Signal Sources The first implementation should support multiple signal substrates with a clear default. @@ -497,6 +624,7 @@ The metadata must include: - signal source - test - normalization mode +- a short plain-language description of what the contrast means biologically ### `RegionDiscoveryResult` @@ -512,6 +640,17 @@ class RegionDiscoveryResult: The outputs should be easy to export as BEDs and easy to pass into follow-on workflows. +## Documentation Requirements For User Flow + +The user-facing docs should include one concise “how to proceed” table: + +- if you know regions and care about average motif abundance: use `region_contrasts` with pileup-backed inputs +- if you know regions and care about single-read structure: use extract-backed workflows and then optionally `region_contrasts` +- if you do not know regions: use `region_discovery` first +- if you want to compare state mixtures: run clustering first, then feed occupancy summaries into `region_contrasts` + +This guidance should appear in both the API docs and at least one tutorial notebook. + ## Testing Strategy ### Unit Tests From 9f09678be325be9a752b3db5eccc087e90886fd6 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 12:18:18 -0700 Subject: [PATCH 007/272] docs: formalize parsing continuity requirements --- ...-31-region-analysis-architecture-design.md | 21 ++++++++++++++++++ ...3-31-shared-cluster-distribution-design.md | 22 +++++++++++++++++++ 2 files changed, 43 insertions(+) diff --git a/docs/superpowers/specs/2026-03-31-region-analysis-architecture-design.md b/docs/superpowers/specs/2026-03-31-region-analysis-architecture-design.md index 445a97c..2a4a36e 100644 --- a/docs/superpowers/specs/2026-03-31-region-analysis-architecture-design.md +++ b/docs/superpowers/specs/2026-03-31-region-analysis-architecture-design.md @@ -24,6 +24,7 @@ The goal is to preserve the current region-targeted analysis logic while making what the analysis unit is, and what read or region representation is being contrasted. - Integrate cleanly with shared clustering workflows and pileup-backed summaries. +- Preserve continuity with prior versions by leaving the current under-the-hood parsing architecture substantially intact and layering new region-analysis modules on top. ## Non-Goals @@ -31,6 +32,7 @@ The goal is to preserve the current region-targeted analysis logic while making - Hide biological interpretation behind vague names like "region test" or "single-read comparison". - Replace existing pileup/extract logic with one monolithic artifact type. - Implement every possible statistical test in the first version. +- Rewrite the current low-level parsing layer unless the change is behavior-preserving and continuity-safe. ## Architectural Split @@ -50,6 +52,23 @@ User model: - preprocessing/materialization lives here - downstream interpretation does not +## Compatibility And Continuity Requirements + +The updated region-analysis architecture must preserve the current parsing model. + +Required constraints: + +- keep `parse_bam.pileup()` and `parse_bam.extract()` as the low-level preprocessing surface +- do not substantially change the under-the-hood modkit-backed parsing logic unless the behavior is preserved +- build `global_analysis`, `region_discovery`, and `region_contrasts` on top of current parsed outputs +- prefer additive orchestration and metadata layers rather than replacing current parse output semantics +- ensure old region-targeted analysis habits still map naturally onto the new modules + +User-facing consequence: + +- users who know the previous package should still recognize the preprocessing model +- new modules explain what to do after parsing rather than redefining what parsing means + ### `dimelo.global_analysis` New module for broad dataset-wide summarization. @@ -663,6 +682,7 @@ Add tests for: - effect-size-only ranking - beta-binomial path over predefined region counts - handoff from discovered regions into defined-region contrasts +- regression coverage proving continuity for pre-existing pileup/extract-driven region-targeted workflows ### Integration Tests @@ -704,5 +724,6 @@ These defaults are fixed for the first implementation: - default `representation`: `modified_fraction` - default `signal_source`: `pileup_counts` - default `test`: `beta_binomial` when the combination is valid +- existing parsing entry points remain the continuity-preserving preprocessing layer This architecture should make it obvious what is being compared and why, while still supporting clean handoff into clustering and other downstream workflows. diff --git a/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md b/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md index c8f6a04..c891354 100644 --- a/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md +++ b/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md @@ -19,6 +19,7 @@ The workflow should scale from thousands to millions of reads or regions per dat - Use a performant default that remains usable at million-row scale. - Introduce a hybrid batch model that supports both independent dataset processing and flexible cohort-level shared workflows. - Make downstream workflows consume reusable artifacts when available, while still being able to rebuild from raw inputs when necessary. +- Preserve continuity with prior package versions by keeping the existing low-level parsing layer stable and building new workflows on top of it. ## Non-Goals @@ -26,6 +27,7 @@ The workflow should scale from thousands to millions of reads or regions per dat - Ship experiment-specific hard-coded condition schemes as core logic. - Recluster separately for each condition or each region. - Store large raw matrices on result objects by default. +- Rewrite or substantially alter the behavior of the existing parsing internals unless behavior-preserving refactors are required. ## User-Facing Workflow @@ -190,6 +192,24 @@ Retains low-level primitives already present on the branch: The new workflow should call these lower-level functions rather than duplicate them. +## Compatibility And Continuity Requirements + +The shared clustering work must be additive around the existing parsing architecture. + +Required constraints: + +- keep `parse_bam.pileup()` and `parse_bam.extract()` as the core preprocessing entry points +- keep existing modkit-backed parsing logic intact unless a change is behavior-preserving and covered by regression tests +- avoid breaking existing output concepts and file semantics +- prefer additive metadata or manifest layers over changing current parsed output formats +- ensure new workflow wrappers call into existing parsing outputs rather than replacing them + +User-facing consequence: + +- previous preprocessing habits should still work +- existing pileup or extract outputs should remain usable in the updated package +- users should learn new downstream workflows without needing to relearn the parsing layer + ## Data Model ### `SampleSpec` @@ -684,6 +704,7 @@ Add new tests for: - `shape_only`, `level_only`, and `shape_plus_level` feature-path behavior - preservation of global shifts under `signal_normalization="none"` - expected correction behavior for `per_sample_global` and `control_regions` +- regression coverage showing that pre-existing pileup/extract-driven workflows still work after the new shared clustering layer is added ### Integration Tests @@ -733,5 +754,6 @@ These defaults are fixed for the first implementation: - default signal normalization: `none` - default feature scaling: `robust_zscore` - default cluster basis: `shape_plus_level` +- existing low-level parsing entry points remain the continuity-preserving preprocessing surface No experiment-specific cluster template system is required for the first version of this workflow. From 07db478b5e8183ba1a5171ff04c0035b4abb0680 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 12:20:26 -0700 Subject: [PATCH 008/272] docs: add pre-plan decisions addendum --- .../2026-03-31-pre-plan-decisions-addendum.md | 168 ++++++++++++++++++ 1 file changed, 168 insertions(+) create mode 100644 docs/superpowers/specs/2026-03-31-pre-plan-decisions-addendum.md diff --git a/docs/superpowers/specs/2026-03-31-pre-plan-decisions-addendum.md b/docs/superpowers/specs/2026-03-31-pre-plan-decisions-addendum.md new file mode 100644 index 0000000..5b2bd94 --- /dev/null +++ b/docs/superpowers/specs/2026-03-31-pre-plan-decisions-addendum.md @@ -0,0 +1,168 @@ +# Pre-Plan Decisions Addendum + +## Purpose + +This addendum resolves the main remaining policy gaps in the shared clustering and region-analysis specs before writing the implementation plan. + +It should be read alongside: + +- `2026-03-31-shared-cluster-distribution-design.md` +- `2026-03-31-region-analysis-architecture-design.md` + +## Decisions + +### 1. Replicate Handling For V1 + +Formal inferential `region_contrasts` in v1 should be limited to: + +- `analysis_unit="ensemble_region"` +- `signal_source="pileup_counts"` +- `test="beta_binomial"` + +Replicate policy in v1: + +- `single_dataset` + no replicate modeling needed +- `pairwise` + pool counts within each side after recording replicate-level summaries +- `group_vs_group` + pool counts within each side after recording replicate-level summaries +- `matched_pairwise` + allowed in schema, but v1 should expose effect-size summaries only unless replicate pairing can be handled with a clearly defined paired-count procedure +- `background_adjusted` + allowed in schema, but inferential testing should initially operate on pooled background-adjusted summaries only if the correction step is explicitly defined and audited +- `time_course` + effect-size-only in v1, not formal significance testing + +Rationale: + +- this preserves a clean, defensible inferential path for v1 +- it avoids pretending that pooled beta-binomial inference is valid for all replicate structures +- it leaves room for later GLM or hierarchical modeling without blocking the initial release + +### 2. Authoritative V1 Support Matrix + +The implementation plan should treat the following combinations as officially supported in v1: + +#### Fully Supported + +- `region_contrasts` + - `analysis_unit="ensemble_region"` + - `representation in {"modified_fraction", "modified_count"}` + - `signal_source="pileup_counts"` + - `test in {"beta_binomial", "effect_size_only"}` + +- `shared_cluster_distribution` + - `mode in {"read_global", "region_anchored"}` + - `clusterer="minibatch_kmeans"` + - `signal_normalization in {"none", "per_sample_global", "control_regions"}` + - `feature_scaling in {"none", "robust_zscore"}` + - `cluster_basis in {"shape_only", "shape_plus_level", "level_only"}` + +#### Schema-Supported But Exploratory-Only + +- `region_contrasts` + - `analysis_unit="single_read"` + - `analysis_unit="cluster_occupancy"` + - `signal_source in {"region_features", "cluster_occupancy"}` + - `time_course` with inferential testing + +These combinations may return tables or effect sizes in v1, but should not promise formal significance testing unless explicitly implemented. + +### 3. Artifact Compatibility Rules + +Every cached artifact must carry a compatibility fingerprint. + +Required metadata: + +- artifact schema version +- package version +- source file path(s) +- source file digest(s) or timestamp-plus-size fingerprint +- relevant parameter hash +- upstream artifact lineage if the artifact was derived from another artifact + +Workflow-level compatibility checks must include: + +- normalization mode +- feature scaling mode +- cluster basis +- motifs +- window size +- region source or region digest when applicable + +Rule: + +- if any required compatibility field mismatches, `prefer_cached` must rebuild rather than reuse + +### 4. `region_discovery` Search-Space Policy For V1 + +V1 discovery should use a simple, explicit tiled-window model. + +Defaults: + +- canonical contigs only by default +- user-configurable include/exclude contig filters +- fixed `window_size` +- fixed `step_size` +- minimum coverage threshold before scoring +- FDR computed on raw windows before merging +- adjacent significant windows merged after scoring using a fixed merge-distance rule + +Rationale: + +- easy to document +- easy to test +- avoids hiding discovery behavior in heuristic candidate generation + +This can be extended later with adaptive candidate windows, but the first implementation should stay deterministic. + +### 5. Normalization Ownership + +Normalization factors should have one canonical home: + +- `global_analysis` owns computation of reusable normalization diagnostics and factors +- downstream workflows may compute a factor on demand only if no compatible normalization artifact exists + +Workflow rule: + +- prefer canonical normalization artifacts when present +- if absent, compute on demand and record that the factor was rebuilt locally + +This keeps normalization behavior consistent across workflows while preserving the fallback model. + +### 6. User Guidance For `pileup` Versus `extract` + +The docs and examples should include one explicit recommendation table: + +- run `pileup` when you care about: + - motif abundance + - locus-level defined-region contrasts + - de novo region discovery + - broad global summaries + +- run `extract` when you care about: + - single-read pattern analysis + - shared read clustering + - read-state occupancy summaries + +- run both when you want: + - formal locus-level abundance testing plus downstream read-level structural follow-up + - discovery or contrast first, then clustering on selected loci + +V1 should not introduce a new required preprocessing abstraction; it should instead document the decision clearly and allow later wrappers to remain additive. + +## Recommended Implementation Consequences + +The implementation plan should: + +1. treat pooled beta-binomial testing as the only fully inferential defined-region engine in v1 +2. include an explicit support-matrix section rather than leaving legal combinations implicit +3. build artifact compatibility checks before broad cache reuse +4. keep `region_discovery` deterministic and tiled in v1 +5. make normalization artifacts reusable across workflows +6. include user-facing guidance for when to run `pileup`, `extract`, or both + +## Summary + +These decisions keep v1 narrow where statistical claims matter, while still letting the architecture expose broader future-facing schema for single-read and occupancy-based contrasts. They also reduce the risk of cache misuse, inconsistent normalization, and user confusion about how preprocessing connects to downstream analysis. From 5dbf5b4b4fa048dba919784fc6477c02b3effd58 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 12:22:47 -0700 Subject: [PATCH 009/272] docs: add data-first plotting architecture --- .../2026-03-31-pre-plan-decisions-addendum.md | 18 ++++++++ ...-31-region-analysis-architecture-design.md | 22 ++++++++++ ...3-31-shared-cluster-distribution-design.md | 42 +++++++++++++++++++ 3 files changed, 82 insertions(+) diff --git a/docs/superpowers/specs/2026-03-31-pre-plan-decisions-addendum.md b/docs/superpowers/specs/2026-03-31-pre-plan-decisions-addendum.md index 5b2bd94..2c2a6e2 100644 --- a/docs/superpowers/specs/2026-03-31-pre-plan-decisions-addendum.md +++ b/docs/superpowers/specs/2026-03-31-pre-plan-decisions-addendum.md @@ -152,6 +152,23 @@ The docs and examples should include one explicit recommendation table: V1 should not introduce a new required preprocessing abstraction; it should instead document the decision clearly and allow later wrappers to remain additive. +### 7. Plotting Flexibility Policy + +Plotting should be data-first across workflows. + +Required rule: + +- workflows return canonical result tables first +- workflows may also return plot-ready tables or lightweight plot specs +- built-in figure generation should default to Matplotlib for backward familiarity +- users must be able to ignore built-in plotting and use returned tables with their own plotting stack + +V1 should not attempt a full backend plugin system. Instead it should: + +- preserve simple Matplotlib-based renderers +- expose stable `plot_data` payloads where useful +- keep renderer-specific logic out of the analysis core + ## Recommended Implementation Consequences The implementation plan should: @@ -162,6 +179,7 @@ The implementation plan should: 4. keep `region_discovery` deterministic and tiled in v1 5. make normalization artifacts reusable across workflows 6. include user-facing guidance for when to run `pileup`, `extract`, or both +7. make plotting data-first with Matplotlib as the default compatibility renderer ## Summary diff --git a/docs/superpowers/specs/2026-03-31-region-analysis-architecture-design.md b/docs/superpowers/specs/2026-03-31-region-analysis-architecture-design.md index 2a4a36e..17d2734 100644 --- a/docs/superpowers/specs/2026-03-31-region-analysis-architecture-design.md +++ b/docs/superpowers/specs/2026-03-31-region-analysis-architecture-design.md @@ -24,6 +24,7 @@ The goal is to preserve the current region-targeted analysis logic while making what the analysis unit is, and what read or region representation is being contrasted. - Integrate cleanly with shared clustering workflows and pileup-backed summaries. +- Keep plotting flexible and modern by making returned tables canonical, while preserving simple Matplotlib-based renderers for continuity. - Preserve continuity with prior versions by leaving the current under-the-hood parsing architecture substantially intact and layering new region-analysis modules on top. ## Non-Goals @@ -631,6 +632,7 @@ class RegionContrastResult: regions: pd.DataFrame summary: pd.DataFrame contrast: ContrastSpec + plot_data: dict[str, pd.DataFrame | dict[str, Any]] metadata: dict[str, Any] figures: dict[str, Any] ``` @@ -644,6 +646,7 @@ The metadata must include: - test - normalization mode - a short plain-language description of what the contrast means biologically +- renderer used for any built-in figures ### `RegionDiscoveryResult` @@ -653,12 +656,29 @@ class RegionDiscoveryResult: hits: pd.DataFrame windows: pd.DataFrame contrast: ContrastSpec | None + plot_data: dict[str, pd.DataFrame | dict[str, Any]] metadata: dict[str, Any] figures: dict[str, Any] ``` The outputs should be easy to export as BEDs and easy to pass into follow-on workflows. +### Plotting Contract + +Plotting should be layered: + +1. canonical result tables +2. plot-ready tables or lightweight plot specs +3. renderer-specific figure objects + +This keeps the analysis outputs stable while making plotting flexible. + +Default behavior: + +- built-in renderers use Matplotlib for continuity +- users can skip built-in plotting and work directly from `regions`, `summary`, `hits`, `windows`, or `plot_data` +- future renderer adapters can be added without changing the analysis APIs + ## Documentation Requirements For User Flow The user-facing docs should include one concise “how to proceed” table: @@ -700,6 +720,7 @@ Add: - one doc for de novo region discovery - one doc for defined-region contrasts - one doc showing how discovered or contrasted regions feed into clustering +- one doc showing how to build custom plots from returned tables without using package renderers ## Implementation Plan Shape @@ -724,6 +745,7 @@ These defaults are fixed for the first implementation: - default `representation`: `modified_fraction` - default `signal_source`: `pileup_counts` - default `test`: `beta_binomial` when the combination is valid +- default plotting contract: canonical tables first, Matplotlib renderer second - existing parsing entry points remain the continuity-preserving preprocessing layer This architecture should make it obvious what is being compared and why, while still supporting clean handoff into clustering and other downstream workflows. diff --git a/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md b/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md index c891354..8d656d7 100644 --- a/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md +++ b/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md @@ -16,6 +16,7 @@ The workflow should scale from thousands to millions of reads or regions per dat - Preserve compatibility with existing `dimelo` extract outputs and existing feature-engineering code in `dimelo.cluster`. - Support matched-region analyses while also allowing read clustering that is independent of region. - Return structured tabular results suitable for downstream notebook analysis, plus a small standard plot set for quick interpretation. +- Keep plotting flexible by making tables the source of truth, shipping simple Matplotlib renderers by default, and not locking users into one plotting stack. - Use a performant default that remains usable at million-row scale. - Introduce a hybrid batch model that supports both independent dataset processing and flexible cohort-level shared workflows. - Make downstream workflows consume reusable artifacts when available, while still being able to rebuild from raw inputs when necessary. @@ -251,6 +252,7 @@ class SharedClusterResult: distribution_change: pd.DataFrame | None cluster_profiles: pd.DataFrame region_summaries: pd.DataFrame | None + plot_data: dict[str, pd.DataFrame | dict[str, Any]] figures: dict[str, Any] metadata: dict[str, Any] ``` @@ -656,8 +658,29 @@ The top-level metadata payload should also include: - cluster basis mode - any per-sample normalization factors used +### `plot_data` + +Plotting should be data-first. + +The result object should always expose plot-ready tables or spec-like payloads, even when no figure objects are requested. + +Examples: + +- `cluster_distribution_bar` +- `cluster_distribution_heatmap` +- `cluster_profiles` +- `top_region_changes` when available + ## Standard Plots +The package should separate: + +1. analysis tables +2. plot-ready data or plot specs +3. renderer-specific figure generation + +Matplotlib should remain the default built-in renderer for continuity, but workflows should not require Matplotlib-specific figure handling in order to be useful. + The initial standardized plot set should be small: 1. stacked bar plot of cluster fraction by dataset @@ -671,6 +694,23 @@ Optional later additions: - baseline-vs-induction scatter plots - preset study-specific figure suites +### Plotting Architecture + +Recommended layers: + +- results tables + always returned, canonical source of truth +- plotting helpers + convert result tables into plot-ready payloads +- default renderers + Matplotlib-based functions that consume those payloads + +Consequences: + +- users familiar with older package versions can keep using simple Matplotlib outputs +- users with their own preferred plotting stack can ignore built-in renderers and plot directly from returned tables +- future renderer adapters such as Plotly or Altair can be added without changing analysis APIs + ## Error Handling The workflow should fail fast for structural issues: @@ -726,6 +766,7 @@ Add: - one API-oriented doc for the workflow - one example notebook for `read_global` - one example notebook for `region_anchored` +- one short doc showing how to use returned tables with custom plotting code instead of package renderers The collaborator notebook should be preserved as exploratory history but should not remain the primary interface for this analysis. @@ -750,6 +791,7 @@ These defaults are fixed for the first implementation: - default clusterer: `MiniBatchKMeans` - default cluster-boundary source: balanced pooled subset across all datasets - default result mode: return structured tables and figures, not raw matrices +- default plotting contract: return canonical tables plus plot-ready payloads, with Matplotlib as the compatibility renderer - default artifact policy: `prefer_cached` - default signal normalization: `none` - default feature scaling: `robust_zscore` From bfd184853e47b3441da275cf11bbc40e8122f939 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 12:27:25 -0700 Subject: [PATCH 010/272] docs: add shared clustering foundations plan --- ...026-03-31-shared-clustering-foundations.md | 988 ++++++++++++++++++ 1 file changed, 988 insertions(+) create mode 100644 docs/superpowers/plans/2026-03-31-shared-clustering-foundations.md diff --git a/docs/superpowers/plans/2026-03-31-shared-clustering-foundations.md b/docs/superpowers/plans/2026-03-31-shared-clustering-foundations.md new file mode 100644 index 0000000..5b8c5b4 --- /dev/null +++ b/docs/superpowers/plans/2026-03-31-shared-clustering-foundations.md @@ -0,0 +1,988 @@ +# Shared Clustering Foundations Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Add a stable, backward-compatible foundation for shared clustering across datasets, including result models, artifact resolution, data-first plotting payloads, and a usable `shared_cluster_distribution()` workflow covering `read_global` and `region_anchored`. + +**Architecture:** Build new orchestration and data-model modules around the existing `parse_bam`, `load_processed`, and `cluster` code without changing their semantics. Keep canonical outputs as DataFrames plus `plot_data`, with Matplotlib remaining a thin compatibility renderer instead of the core contract. + +**Tech Stack:** Python 3.11, pandas, numpy, scikit-learn, matplotlib, pytest + +--- + +Scope note: + +- This plan intentionally covers the first executable slice only: + shared clustering foundations and orchestration. +- Follow-on plans should handle: + `region_contrasts`, + `region_discovery`, + and `global_analysis`. + +### Task 1: Add Shared Clustering Models And Public Exports + +**Files:** +- Create: `dimelo/models.py` +- Create: `tests/test_models.py` +- Modify: `dimelo/__init__.py` + +- [ ] **Step 1: Write the failing tests** + +```python +# tests/test_models.py +from pathlib import Path + +from dimelo.models import ( + CohortSpec, + DatasetArtifact, + SampleSpec, + SharedClusterModel, + SharedClusterResult, +) + + +def test_sample_spec_basic_fields(): + sample = SampleSpec( + sample_id="s1", + condition="NS", + extract_h5=Path("reads.h5"), + regions_bed=Path("regions.bed"), + replicate=1, + ) + assert sample.sample_id == "s1" + assert sample.condition == "NS" + assert sample.extract_h5 == Path("reads.h5") + + +def test_dataset_artifact_carries_core_metadata(): + artifact = DatasetArtifact( + sample_id="s1", + artifact_type="read_features", + path=Path("features.parquet"), + format="parquet", + params={"window_size": 1000}, + provenance={"schema_version": 1, "package_version": "1.0.0"}, + ) + assert artifact.artifact_type == "read_features" + assert artifact.provenance["schema_version"] == 1 + + +def test_shared_cluster_result_holds_plot_data(): + model = SharedClusterModel( + mode="read_global", + motifs=["A,0"], + feature_names=["feat1"], + preprocessing={}, + estimator=None, + cluster_labels=["C0"], + fit_metadata={}, + ) + result = SharedClusterResult( + model=model, + assignments=None, + cluster_distribution=None, + condition_distribution=None, + distribution_change=None, + cluster_profiles=None, + region_summaries=None, + plot_data={"cluster_distribution_bar": {"kind": "bar"}}, + figures={}, + metadata={}, + ) + assert "cluster_distribution_bar" in result.plot_data + + +def test_cohort_spec_tracks_workflow_and_params(): + cohort = CohortSpec( + cohort_id="cohort-1", + sample_ids=["s1", "s2"], + workflow="shared_cluster_distribution", + params={"mode": "read_global"}, + ) + assert cohort.workflow == "shared_cluster_distribution" + assert cohort.params["mode"] == "read_global" +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `pytest tests/test_models.py -q` +Expected: FAIL with `ModuleNotFoundError: No module named 'dimelo.models'` + +- [ ] **Step 3: Write minimal implementation** + +```python +# dimelo/models.py +from __future__ import annotations + +from dataclasses import dataclass, field +from pathlib import Path +from typing import Any + +import pandas as pd + + +@dataclass +class SampleSpec: + sample_id: str + condition: str + extract_h5: str | Path + regions_bed: str | Path | None = None + replicate: int | None = None + metadata: dict[str, Any] | None = None + + +@dataclass +class DatasetArtifact: + sample_id: str + artifact_type: str + path: str | Path + format: str + params: dict[str, Any] + provenance: dict[str, Any] + + +@dataclass +class SharedClusterModel: + mode: str + motifs: list[str] + feature_names: list[str] + preprocessing: dict[str, Any] + estimator: Any + cluster_labels: list[str] + fit_metadata: dict[str, Any] + + +@dataclass +class SharedClusterResult: + model: SharedClusterModel + assignments: pd.DataFrame | None + cluster_distribution: pd.DataFrame | None + condition_distribution: pd.DataFrame | None + distribution_change: pd.DataFrame | None + cluster_profiles: pd.DataFrame | None + region_summaries: pd.DataFrame | None + plot_data: dict[str, pd.DataFrame | dict[str, Any]] + figures: dict[str, Any] = field(default_factory=dict) + metadata: dict[str, Any] = field(default_factory=dict) + + +@dataclass +class CohortSpec: + cohort_id: str + sample_ids: list[str] + workflow: str + params: dict[str, Any] + metadata: dict[str, Any] | None = None + + +@dataclass +class BatchJob: + job_id: str + workflow: str + cohorts: list[CohortSpec] + artifact_policy: str = "prefer_cached" + metadata: dict[str, Any] | None = None +``` + +```python +# dimelo/__init__.py +from . import ( + cluster, + export, + load_processed, + models, + parse_bam, + plot_depth_histogram, + plot_depth_profile, + plot_enrichment, + plot_enrichment_profile, + plot_read_browser, + plot_reads, +) +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `pytest tests/test_models.py -q` +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add dimelo/models.py dimelo/__init__.py tests/test_models.py +git commit -m "feat: add shared clustering model types" +``` + +### Task 2: Add Artifact Compatibility And Resolver Foundations + +**Files:** +- Create: `dimelo/artifacts.py` +- Create: `tests/test_artifacts.py` + +- [ ] **Step 1: Write the failing tests** + +```python +# tests/test_artifacts.py +from pathlib import Path + +from dimelo.artifacts import artifact_fingerprint, artifact_is_compatible, resolve_artifact +from dimelo.models import DatasetArtifact + + +def test_artifact_fingerprint_includes_required_keys(): + fp = artifact_fingerprint( + schema_version=1, + package_version="1.0.0", + source_files=[Path("reads.h5")], + params={"window_size": 1000, "motifs": ["A,0"]}, + ) + assert fp["schema_version"] == 1 + assert "params_hash" in fp + assert "source_files" in fp + + +def test_artifact_is_compatible_rejects_param_mismatch(): + artifact = DatasetArtifact( + sample_id="s1", + artifact_type="read_features", + path=Path("features.parquet"), + format="parquet", + params={"window_size": 1000, "motifs": ["A,0"]}, + provenance={"schema_version": 1, "package_version": "1.0.0"}, + ) + assert not artifact_is_compatible( + artifact, + required_params={"window_size": 2000, "motifs": ["A,0"]}, + required_provenance={"schema_version": 1}, + ) + + +def test_resolve_artifact_prefers_matching_artifact(): + artifact = DatasetArtifact( + sample_id="s1", + artifact_type="read_features", + path=Path("features.parquet"), + format="parquet", + params={"window_size": 1000}, + provenance={"schema_version": 1, "package_version": "1.0.0"}, + ) + resolved = resolve_artifact( + artifacts=[artifact], + artifact_type="read_features", + sample_id="s1", + required_params={"window_size": 1000}, + required_provenance={"schema_version": 1}, + policy="prefer_cached", + ) + assert resolved is artifact +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `pytest tests/test_artifacts.py -q` +Expected: FAIL with `ModuleNotFoundError: No module named 'dimelo.artifacts'` + +- [ ] **Step 3: Write minimal implementation** + +```python +# dimelo/artifacts.py +from __future__ import annotations + +import hashlib +import json +from pathlib import Path +from typing import Any, Iterable + +from .models import DatasetArtifact + + +def _stable_json(value: Any) -> str: + return json.dumps(value, sort_keys=True, separators=(",", ":")) + + +def artifact_fingerprint( + *, + schema_version: int, + package_version: str, + source_files: Iterable[str | Path], + params: dict[str, Any], +) -> dict[str, Any]: + source_list = [str(Path(p)) for p in source_files] + params_hash = hashlib.sha256(_stable_json(params).encode()).hexdigest() + return { + "schema_version": schema_version, + "package_version": package_version, + "source_files": source_list, + "params_hash": params_hash, + } + + +def artifact_is_compatible( + artifact: DatasetArtifact, + *, + required_params: dict[str, Any], + required_provenance: dict[str, Any], +) -> bool: + for key, value in required_params.items(): + if artifact.params.get(key) != value: + return False + for key, value in required_provenance.items(): + if artifact.provenance.get(key) != value: + return False + return True + + +def resolve_artifact( + *, + artifacts: list[DatasetArtifact], + artifact_type: str, + sample_id: str, + required_params: dict[str, Any], + required_provenance: dict[str, Any], + policy: str = "prefer_cached", +) -> DatasetArtifact | None: + matches = [ + artifact + for artifact in artifacts + if artifact.sample_id == sample_id and artifact.artifact_type == artifact_type + ] + if policy == "rebuild": + return None + compatible = [ + artifact + for artifact in matches + if artifact_is_compatible( + artifact, + required_params=required_params, + required_provenance=required_provenance, + ) + ] + if compatible: + return compatible[0] + if policy == "require_cached": + raise FileNotFoundError( + f"No compatible cached artifact found for sample={sample_id}, type={artifact_type}" + ) + return None +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `pytest tests/test_artifacts.py -q` +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add dimelo/artifacts.py tests/test_artifacts.py +git commit -m "feat: add artifact compatibility helpers" +``` + +### Task 3: Add Distribution Summaries And Data-First Plot Payloads + +**Files:** +- Create: `dimelo/distribution.py` +- Create: `dimelo/plotting.py` +- Create: `tests/test_distribution.py` + +- [ ] **Step 1: Write the failing tests** + +```python +# tests/test_distribution.py +import pandas as pd + +from dimelo.distribution import ( + build_cluster_distribution, + build_condition_distribution, + build_distribution_change, +) +from dimelo.plotting import ( + prepare_cluster_distribution_bar_data, + prepare_cluster_distribution_heatmap_data, +) + + +def test_build_cluster_distribution_counts_and_fractions(): + assignments = pd.DataFrame( + { + "sample_id": ["s1", "s1", "s1", "s2"], + "condition": ["NS", "NS", "NS", "15min"], + "cluster": ["C0", "C0", "C1", "C1"], + } + ) + result = build_cluster_distribution(assignments) + s1 = result[result["sample_id"] == "s1"].sort_values("cluster").reset_index(drop=True) + assert list(s1["count"]) == [2, 1] + assert list(s1["fraction"]) == [2 / 3, 1 / 3] + + +def test_build_distribution_change_against_reference(): + condition_distribution = pd.DataFrame( + { + "condition": ["NS", "NS", "15min", "15min"], + "cluster": ["C0", "C1", "C0", "C1"], + "fraction": [0.75, 0.25, 0.25, 0.75], + } + ) + result = build_distribution_change(condition_distribution, reference_condition="NS") + row = result[(result["condition"] == "15min") & (result["cluster"] == "C1")].iloc[0] + assert row["delta_fraction"] == 0.5 + + +def test_plot_data_helpers_return_dataframes(): + cluster_distribution = pd.DataFrame( + { + "sample_id": ["s1", "s1"], + "condition": ["NS", "NS"], + "cluster": ["C0", "C1"], + "count": [2, 1], + "fraction": [2 / 3, 1 / 3], + } + ) + bar_data = prepare_cluster_distribution_bar_data(cluster_distribution) + heatmap_data = prepare_cluster_distribution_heatmap_data(cluster_distribution) + assert not bar_data.empty + assert not heatmap_data.empty +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `pytest tests/test_distribution.py -q` +Expected: FAIL with `ModuleNotFoundError` for `dimelo.distribution` + +- [ ] **Step 3: Write minimal implementation** + +```python +# dimelo/distribution.py +from __future__ import annotations + +import numpy as np +import pandas as pd + + +def build_cluster_distribution(assignments: pd.DataFrame) -> pd.DataFrame: + grouped = ( + assignments.groupby(["sample_id", "condition", "cluster"]) + .size() + .reset_index(name="count") + ) + totals = grouped.groupby("sample_id")["count"].transform("sum") + grouped["fraction"] = grouped["count"] / totals + return grouped + + +def build_condition_distribution(cluster_distribution: pd.DataFrame) -> pd.DataFrame: + grouped = ( + cluster_distribution.groupby(["condition", "cluster"])["count"] + .sum() + .reset_index() + ) + totals = grouped.groupby("condition")["count"].transform("sum") + grouped["fraction"] = grouped["count"] / totals + grouped["replicate_n"] = ( + cluster_distribution.groupby("condition")["sample_id"].nunique().reindex(grouped["condition"]).to_numpy() + ) + return grouped + + +def build_distribution_change( + condition_distribution: pd.DataFrame, + *, + reference_condition: str, + pseudocount: float = 1e-6, +) -> pd.DataFrame: + ref = ( + condition_distribution[condition_distribution["condition"] == reference_condition] + .loc[:, ["cluster", "fraction"]] + .rename(columns={"fraction": "reference_fraction"}) + ) + merged = condition_distribution.merge(ref, on="cluster", how="left") + merged = merged[merged["condition"] != reference_condition].copy() + merged["delta_fraction"] = merged["fraction"] - merged["reference_fraction"] + merged["log2_fc"] = np.log2( + (merged["fraction"] + pseudocount) / (merged["reference_fraction"] + pseudocount) + ) + return merged +``` + +```python +# dimelo/plotting.py +from __future__ import annotations + +import pandas as pd + + +def prepare_cluster_distribution_bar_data(cluster_distribution: pd.DataFrame) -> pd.DataFrame: + return cluster_distribution.copy() + + +def prepare_cluster_distribution_heatmap_data(cluster_distribution: pd.DataFrame) -> pd.DataFrame: + return cluster_distribution.pivot_table( + index="condition", + columns="cluster", + values="fraction", + fill_value=0.0, + ) +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `pytest tests/test_distribution.py -q` +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add dimelo/distribution.py dimelo/plotting.py tests/test_distribution.py +git commit -m "feat: add shared cluster summary and plot payload helpers" +``` + +### Task 4: Implement `shared_cluster_distribution()` For `read_global` + +**Files:** +- Create: `dimelo/workflows.py` +- Modify: `dimelo/cluster.py` +- Modify: `dimelo/__init__.py` +- Create: `tests/test_workflows.py` + +- [ ] **Step 1: Write the failing tests** + +```python +# tests/test_workflows.py +import numpy as np +import pandas as pd + +from dimelo.models import SampleSpec +from dimelo import workflows + + +def test_shared_cluster_distribution_read_global(monkeypatch): + fake_samples = [ + SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5"), + SampleSpec(sample_id="s2", condition="15min", extract_h5="s2.h5"), + ] + + def fake_extract(*args, **kwargs): + class R: + data_matrix = np.array([[0, 1, 0, 1], [1, 0, 1, 0]], dtype=float) + val_matrix = np.ones((2, 4), dtype=float) + metadata = [ + {"read_name": "r1", "chromosome": "chr1", "region_start": 0, "region_end": 4}, + {"read_name": "r2", "chromosome": "chr1", "region_start": 10, "region_end": 14}, + ] + datasets = [] + regions_dict = None + + return R() + + def fake_features(result, **kwargs): + return result.data_matrix, ["f0", "f1", "f2", "f3"] + + monkeypatch.setattr(workflows.cluster, "extract_read_windows", fake_extract) + monkeypatch.setattr(workflows.cluster, "read_window_feature_matrix", fake_features) + + result = workflows.shared_cluster_distribution( + samples=fake_samples, + mode="read_global", + motifs=["A,0"], + n_clusters=2, + training_sample_per_dataset=2, + make_plots=False, + ) + + assert not result.assignments.empty + assert set(result.assignments["sample_id"]) == {"s1", "s2"} + assert "cluster_distribution_bar" in result.plot_data +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `pytest tests/test_workflows.py -q` +Expected: FAIL with `ModuleNotFoundError: No module named 'dimelo.workflows'` + +- [ ] **Step 3: Write minimal implementation** + +```python +# dimelo/workflows.py +from __future__ import annotations + +import numpy as np +import pandas as pd + +from . import cluster, distribution, plotting +from .models import SharedClusterModel, SharedClusterResult + + +def shared_cluster_distribution( + *, + samples, + mode: str, + motifs, + matched_regions=None, + signal_normalization: str = "none", + feature_scaling: str = "robust_zscore", + cluster_basis: str = "shape_plus_level", + clusterer: str = "minibatch_kmeans", + n_clusters: int = 8, + training_sample_per_dataset: int = 100_000, + artifact_policy: str = "prefer_cached", + random_state: int = 42, + make_plots: bool = True, +) -> SharedClusterResult: + if mode != "read_global": + raise NotImplementedError("First slice implements read_global only.") + + assignments = [] + feature_names = None + matrices = [] + sample_meta = [] + + for sample in samples: + extracted = cluster.extract_read_windows( + hdf5_file=sample.extract_h5, + motifs=motifs, + ) + feature_matrix, feature_names = cluster.read_window_feature_matrix(extracted) + matrices.append(feature_matrix) + sample_meta.extend( + [ + { + "sample_id": sample.sample_id, + "condition": sample.condition, + "replicate": sample.replicate, + **meta, + } + for meta in extracted.metadata + ] + ) + + all_features = pd.DataFrame( + data=np.vstack(matrices), + columns=feature_names, + ) + result = cluster.cluster_read_windows( + all_features.to_numpy(), + method=clusterer, + n_clusters=n_clusters, + random_state=random_state, + ) + + for meta, label in zip(sample_meta, result.labels_size_ordered): + assignments.append({**meta, "cluster": f"C{int(label)}"}) + + assignments_df = pd.DataFrame(assignments) + cluster_distribution = distribution.build_cluster_distribution(assignments_df) + condition_distribution = distribution.build_condition_distribution(cluster_distribution) + plot_data = { + "cluster_distribution_bar": plotting.prepare_cluster_distribution_bar_data( + cluster_distribution + ), + "cluster_distribution_heatmap": plotting.prepare_cluster_distribution_heatmap_data( + cluster_distribution + ), + } + model = SharedClusterModel( + mode=mode, + motifs=list(motifs), + feature_names=list(feature_names or []), + preprocessing={ + "signal_normalization": signal_normalization, + "feature_scaling": feature_scaling, + "cluster_basis": cluster_basis, + }, + estimator=result.model, + cluster_labels=sorted(assignments_df["cluster"].unique()), + fit_metadata={ + "clusterer": clusterer, + "n_clusters": n_clusters, + "artifact_policy": artifact_policy, + "training_sample_per_dataset": training_sample_per_dataset, + }, + ) + return SharedClusterResult( + model=model, + assignments=assignments_df, + cluster_distribution=cluster_distribution, + condition_distribution=condition_distribution, + distribution_change=None, + cluster_profiles=None, + region_summaries=None, + plot_data=plot_data, + figures={}, + metadata={"mode": mode}, + ) +``` + +```python +# dimelo/__init__.py +from . import ( + cluster, + distribution, + export, + load_processed, + models, + parse_bam, + plotting, + workflows, + plot_depth_histogram, + plot_depth_profile, + plot_enrichment, + plot_enrichment_profile, + plot_read_browser, + plot_reads, +) +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `pytest tests/test_workflows.py -q` +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add dimelo/workflows.py tests/test_workflows.py +git commit -m "feat: add read-global shared clustering workflow" +``` + +### Task 5: Add `region_anchored` Support And Backward-Compatibility Regression Coverage + +**Files:** +- Create: `dimelo/region_analysis.py` +- Modify: `dimelo/workflows.py` +- Modify: `tests/test_workflows.py` +- Modify: `tests/test_cluster.py` + +- [ ] **Step 1: Write the failing tests** + +```python +# tests/test_workflows.py +import numpy as np + +from dimelo.models import SampleSpec +from dimelo import workflows + + +def test_shared_cluster_distribution_region_anchored(monkeypatch): + fake_samples = [ + SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5", regions_bed="r1.bed"), + SampleSpec(sample_id="s2", condition="15min", extract_h5="s2.h5", regions_bed="r2.bed"), + ] + + def fake_region_table(*args, **kwargs): + return np.array([[0.2, 0.8], [0.7, 0.3]]), [ + {"region_id": "reg1", "sample_id": "s1", "condition": "NS"}, + {"region_id": "reg1", "sample_id": "s2", "condition": "15min"}, + ] + + monkeypatch.setattr(workflows.region_analysis, "build_region_feature_table", fake_region_table) + + result = workflows.shared_cluster_distribution( + samples=fake_samples, + mode="region_anchored", + motifs=["A,0"], + matched_regions="matched.bed", + n_clusters=2, + make_plots=False, + ) + assert not result.assignments.empty + assert "region_id" in result.assignments.columns +``` + +```python +# tests/test_cluster.py +def test_existing_cluster_result_api_still_returns_metrics(): + rng = np.random.default_rng(0) + feature_matrix = rng.normal(size=(10, 4)) + result = cluster.cluster_read_windows(feature_matrix, method="kmeans", n_clusters=2, random_state=0) + assert "silhouette" in result.metrics +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `pytest tests/test_workflows.py tests/test_cluster.py -q` +Expected: FAIL with `AttributeError` for missing `build_region_feature_table` or missing `region_anchored` branch + +- [ ] **Step 3: Write minimal implementation** + +```python +# dimelo/region_analysis.py +from __future__ import annotations + +from typing import Any, Sequence + +import numpy as np +import pandas as pd + +from . import cluster + + +def build_region_feature_table( + *, + samples, + motifs: Sequence[str], + matched_regions, +): + matrices = [] + metadata = [] + for sample in samples: + matrix, region_meta = cluster.region_feature_matrix_from_pileup( + bedmethyl_file=sample.metadata["pileup_path"], + motif=motifs[0], + regions=matched_regions or sample.regions_bed, + ) + matrices.append(matrix) + metadata.extend( + [ + { + "sample_id": sample.sample_id, + "condition": sample.condition, + "replicate": sample.replicate, + "region_id": f"{chrom}:{start}-{end}", + "chromosome": chrom, + "start": start, + "end": end, + "strand": strand, + } + for chrom, start, end, strand in region_meta + ] + ) + return np.vstack(matrices), metadata +``` + +```python +# dimelo/workflows.py + if mode == "region_anchored": + feature_matrix, metadata_rows = region_analysis.build_region_feature_table( + samples=samples, + motifs=motifs, + matched_regions=matched_regions, + ) + result = cluster.cluster_read_windows( + feature_matrix, + method=clusterer, + n_clusters=n_clusters, + random_state=random_state, + ) + assignments_df = pd.DataFrame(metadata_rows) + assignments_df["cluster"] = [f"C{int(x)}" for x in result.labels_size_ordered] + cluster_distribution = distribution.build_cluster_distribution(assignments_df) + condition_distribution = distribution.build_condition_distribution(cluster_distribution) + return SharedClusterResult( + model=SharedClusterModel( + mode=mode, + motifs=list(motifs), + feature_names=[f"pos_{i}" for i in range(feature_matrix.shape[1])], + preprocessing={ + "signal_normalization": signal_normalization, + "feature_scaling": feature_scaling, + "cluster_basis": cluster_basis, + }, + estimator=result.model, + cluster_labels=sorted(assignments_df["cluster"].unique()), + fit_metadata={"clusterer": clusterer, "n_clusters": n_clusters}, + ), + assignments=assignments_df, + cluster_distribution=cluster_distribution, + condition_distribution=condition_distribution, + distribution_change=None, + cluster_profiles=None, + region_summaries=assignments_df, + plot_data={ + "cluster_distribution_bar": plotting.prepare_cluster_distribution_bar_data(cluster_distribution), + "cluster_distribution_heatmap": plotting.prepare_cluster_distribution_heatmap_data(cluster_distribution), + }, + figures={}, + metadata={"mode": mode}, + ) +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `pytest tests/test_workflows.py tests/test_cluster.py -q` +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add dimelo/region_analysis.py dimelo/workflows.py tests/test_workflows.py tests/test_cluster.py +git commit -m "feat: add region-anchored shared clustering workflow" +``` + +### Task 6: Add Usage Docs For Backward-Compatible Workflow Entry + +**Files:** +- Create: `docs/shared-clustering.md` +- Modify: `README.md` + +- [ ] **Step 1: Write the failing docs check** + +```markdown + +# Shared Clustering + +This file should explain: +- when to run `parse_bam.extract()` +- when to run `parse_bam.pileup()` +- when to run both +- how to call `shared_cluster_distribution()` +- how to plot from returned tables without package renderers +``` + +- [ ] **Step 2: Verify the docs do not yet exist** + +Run: `test -f docs/shared-clustering.md` +Expected: non-zero exit status + +- [ ] **Step 3: Write the docs** + +```markdown +# Shared Clustering + +## Preprocessing Choices + +- Run `parse_bam.extract()` when you want read-level clustering or single-read pattern analysis. +- Run `parse_bam.pileup()` when you want region-anchored clustering from pileup-derived summaries. +- Run both when you want abundance-style region summaries plus deeper read-level follow-up. + +## Workflow Entry Point + +```python +from dimelo import workflows +from dimelo.models import SampleSpec + +result = workflows.shared_cluster_distribution( + samples=[ + SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5"), + SampleSpec(sample_id="s2", condition="15min", extract_h5="s2.h5"), + ], + mode="read_global", + motifs=["A,0"], + n_clusters=8, +) +``` + +## Custom Plotting + +The canonical outputs are: + +- `result.assignments` +- `result.cluster_distribution` +- `result.condition_distribution` +- `result.plot_data` + +You can use these directly in Matplotlib, seaborn, Plotly, Altair, or your own plotting stack. +``` +``` + +- [ ] **Step 4: Review the docs render and match the implemented API** + +Run: `sed -n '1,220p' docs/shared-clustering.md` +Expected: shows preprocessing guidance, workflow entry point, and custom plotting guidance + +- [ ] **Step 5: Commit** + +```bash +git add docs/shared-clustering.md README.md +git commit -m "docs: add shared clustering usage guide" +``` From bd1667ce346db6b33324d6c9af2c14a8d9bdac6a Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 12:30:15 -0700 Subject: [PATCH 011/272] Add shared clustering models --- dimelo/__init__.py | 2 + dimelo/models.py | 71 ++++++++++++++++++++++++++++ tests/test_models.py | 110 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 183 insertions(+) create mode 100644 dimelo/models.py create mode 100644 tests/test_models.py diff --git a/dimelo/__init__.py b/dimelo/__init__.py index 9bb84c2..a6ba361 100644 --- a/dimelo/__init__.py +++ b/dimelo/__init__.py @@ -3,6 +3,7 @@ export, load_processed, parse_bam, + models, plot_depth_histogram, plot_depth_profile, plot_enrichment, @@ -15,6 +16,7 @@ "cluster", "export", "load_processed", + "models", "parse_bam", "plot_depth_histogram", "plot_depth_profile", diff --git a/dimelo/models.py b/dimelo/models.py new file mode 100644 index 0000000..0b4b9e4 --- /dev/null +++ b/dimelo/models.py @@ -0,0 +1,71 @@ +from __future__ import annotations + +from dataclasses import dataclass, field +from pathlib import Path +from typing import Any + +import pandas as pd + + +@dataclass +class SampleSpec: + sample_id: str + condition: str + extract_h5: str | Path + regions_bed: str | Path | None = None + replicate: int | None = None + metadata: dict[str, Any] | None = None + + +@dataclass +class DatasetArtifact: + sample_id: str + artifact_type: str + path: str | Path + format: str + params: dict[str, Any] + provenance: dict[str, Any] = field(default_factory=dict) + metadata: dict[str, Any] = field(default_factory=dict) + + +@dataclass +class SharedClusterModel: + mode: str + motifs: list[str] + feature_names: list[str] + preprocessing: dict[str, Any] + estimator: Any + cluster_labels: list[str] + fit_metadata: dict[str, Any] + + +@dataclass +class SharedClusterResult: + model: SharedClusterModel + assignments: pd.DataFrame | None + cluster_distribution: pd.DataFrame | None + condition_distribution: pd.DataFrame | None + distribution_change: pd.DataFrame | None + cluster_profiles: pd.DataFrame | None + region_summaries: pd.DataFrame | None + plot_data: dict[str, pd.DataFrame | dict[str, Any]] + figures: dict[str, Any] = field(default_factory=dict) + metadata: dict[str, Any] = field(default_factory=dict) + + +@dataclass +class CohortSpec: + cohort_id: str + sample_ids: list[str] + workflow: str + params: dict[str, Any] + metadata: dict[str, Any] | None = None + + +@dataclass +class BatchJob: + job_id: str + workflow: str + cohorts: list[CohortSpec] + artifact_policy: str = "prefer_cached" + metadata: dict[str, Any] | None = None diff --git a/tests/test_models.py b/tests/test_models.py new file mode 100644 index 0000000..d7d58b3 --- /dev/null +++ b/tests/test_models.py @@ -0,0 +1,110 @@ +from pathlib import Path + +import pandas as pd + +from dimelo import models +from dimelo.models import ( + BatchJob, + CohortSpec, + DatasetArtifact, + SampleSpec, + SharedClusterModel, + SharedClusterResult, +) + + +def test_dimelo_package_exports_models(): + assert models.SampleSpec is SampleSpec + + +def test_sample_spec_fields(): + sample = SampleSpec( + sample_id="sample-1", + condition="treated", + extract_h5=Path("sample-1.h5"), + regions_bed=Path("sample-1.bed"), + replicate=2, + metadata={"batch": "A"}, + ) + + assert sample.sample_id == "sample-1" + assert sample.condition == "treated" + assert sample.extract_h5 == Path("sample-1.h5") + assert sample.regions_bed == Path("sample-1.bed") + assert sample.replicate == 2 + assert sample.metadata == {"batch": "A"} + + +def test_dataset_artifact_stores_metadata(): + artifact = DatasetArtifact( + sample_id="sample-1", + artifact_type="extract", + path=Path("sample-1.h5"), + format="hdf5", + params={"window_size": 200}, + metadata={"source": "parse_bam"}, + ) + + assert artifact.metadata == {"source": "parse_bam"} + assert artifact.params == {"window_size": 200} + + +def test_shared_cluster_result_supports_plot_data(): + model = SharedClusterModel( + mode="shared", + motifs=["A,0"], + feature_names=["A,0_mod_fraction"], + preprocessing={"scale": "standard"}, + estimator=object(), + cluster_labels=["cluster-1"], + fit_metadata={"random_state": 7}, + ) + result = SharedClusterResult( + model=model, + assignments=pd.DataFrame({"cluster": ["cluster-1"]}), + cluster_distribution=pd.DataFrame({"cluster": ["cluster-1"]}), + condition_distribution=pd.DataFrame({"condition": ["treated"]}), + distribution_change=None, + cluster_profiles=pd.DataFrame({"profile": [1.0]}), + region_summaries=None, + plot_data={"cluster_distribution_bar": {"kind": "bar"}}, + figures={}, + metadata={"notes": "ok"}, + ) + + assert result.plot_data["cluster_distribution_bar"] == {"kind": "bar"} + assert result.model is model + + +def test_cohort_spec_stores_workflow_and_params(): + cohort = CohortSpec( + cohort_id="cohort-1", + sample_ids=["sample-1", "sample-2"], + workflow="shared_cluster_distribution", + params={"window_size": 200}, + metadata={"owner": "team-a"}, + ) + + assert cohort.workflow == "shared_cluster_distribution" + assert cohort.params == {"window_size": 200} + assert cohort.sample_ids == ["sample-1", "sample-2"] + assert cohort.metadata == {"owner": "team-a"} + + +def test_batch_job_groups_cohorts(): + cohort = CohortSpec( + cohort_id="cohort-1", + sample_ids=["sample-1"], + workflow="shared_cluster_distribution", + params={}, + ) + job = BatchJob( + job_id="job-1", + workflow="shared_cluster_distribution", + cohorts=[cohort], + ) + + assert job.job_id == "job-1" + assert job.workflow == "shared_cluster_distribution" + assert job.cohorts == [cohort] + assert job.artifact_policy == "prefer_cached" From 77e2c0bb7470d50b4db755de4f720365ce4fac05 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 12:34:19 -0700 Subject: [PATCH 012/272] Tighten shared clustering model contracts --- dimelo/models.py | 22 +++++++++++++++++---- tests/test_models.py | 46 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 64 insertions(+), 4 deletions(-) diff --git a/dimelo/models.py b/dimelo/models.py index 0b4b9e4..e4e76c7 100644 --- a/dimelo/models.py +++ b/dimelo/models.py @@ -24,7 +24,7 @@ class DatasetArtifact: path: str | Path format: str params: dict[str, Any] - provenance: dict[str, Any] = field(default_factory=dict) + provenance: dict[str, Any] metadata: dict[str, Any] = field(default_factory=dict) @@ -42,9 +42,9 @@ class SharedClusterModel: @dataclass class SharedClusterResult: model: SharedClusterModel - assignments: pd.DataFrame | None - cluster_distribution: pd.DataFrame | None - condition_distribution: pd.DataFrame | None + assignments: pd.DataFrame + cluster_distribution: pd.DataFrame + condition_distribution: pd.DataFrame distribution_change: pd.DataFrame | None cluster_profiles: pd.DataFrame | None region_summaries: pd.DataFrame | None @@ -52,6 +52,20 @@ class SharedClusterResult: figures: dict[str, Any] = field(default_factory=dict) metadata: dict[str, Any] = field(default_factory=dict) + def __post_init__(self) -> None: + required_fields = { + "assignments": self.assignments, + "cluster_distribution": self.cluster_distribution, + "condition_distribution": self.condition_distribution, + "plot_data": self.plot_data, + } + missing = [name for name, value in required_fields.items() if value is None] + if missing: + raise ValueError( + "SharedClusterResult requires non-None values for: " + f"{', '.join(missing)}" + ) + @dataclass class CohortSpec: diff --git a/tests/test_models.py b/tests/test_models.py index d7d58b3..bb2cafd 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -1,6 +1,7 @@ from pathlib import Path import pandas as pd +import pytest from dimelo import models from dimelo.models import ( @@ -42,11 +43,24 @@ def test_dataset_artifact_stores_metadata(): path=Path("sample-1.h5"), format="hdf5", params={"window_size": 200}, + provenance={"pipeline": "parse_bam"}, metadata={"source": "parse_bam"}, ) assert artifact.metadata == {"source": "parse_bam"} assert artifact.params == {"window_size": 200} + assert artifact.provenance == {"pipeline": "parse_bam"} + + +def test_dataset_artifact_requires_provenance(): + with pytest.raises(TypeError): + DatasetArtifact( + sample_id="sample-1", + artifact_type="extract", + path=Path("sample-1.h5"), + format="hdf5", + params={"window_size": 200}, + ) def test_shared_cluster_result_supports_plot_data(): @@ -76,6 +90,38 @@ def test_shared_cluster_result_supports_plot_data(): assert result.model is model +@pytest.mark.parametrize( + "field_name", + ["assignments", "cluster_distribution", "condition_distribution", "plot_data"], +) +def test_shared_cluster_result_rejects_none_core_outputs(field_name): + model = SharedClusterModel( + mode="shared", + motifs=["A,0"], + feature_names=["A,0_mod_fraction"], + preprocessing={"scale": "standard"}, + estimator=object(), + cluster_labels=["cluster-1"], + fit_metadata={"random_state": 7}, + ) + kwargs = { + "model": model, + "assignments": pd.DataFrame({"cluster": ["cluster-1"]}), + "cluster_distribution": pd.DataFrame({"cluster": ["cluster-1"]}), + "condition_distribution": pd.DataFrame({"condition": ["treated"]}), + "distribution_change": None, + "cluster_profiles": pd.DataFrame({"profile": [1.0]}), + "region_summaries": None, + "plot_data": {"cluster_distribution_bar": {"kind": "bar"}}, + "figures": {}, + "metadata": {"notes": "ok"}, + } + kwargs[field_name] = None + + with pytest.raises(ValueError): + SharedClusterResult(**kwargs) + + def test_cohort_spec_stores_workflow_and_params(): cohort = CohortSpec( cohort_id="cohort-1", From 87b4125111039ff7ae71e8d334906fc1adf93da2 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 12:35:54 -0700 Subject: [PATCH 013/272] Reject null dataset artifact provenance --- dimelo/models.py | 4 ++++ tests/test_models.py | 12 ++++++++++++ 2 files changed, 16 insertions(+) diff --git a/dimelo/models.py b/dimelo/models.py index e4e76c7..f674cad 100644 --- a/dimelo/models.py +++ b/dimelo/models.py @@ -27,6 +27,10 @@ class DatasetArtifact: provenance: dict[str, Any] metadata: dict[str, Any] = field(default_factory=dict) + def __post_init__(self) -> None: + if self.provenance is None: + raise ValueError("DatasetArtifact.provenance cannot be None") + @dataclass class SharedClusterModel: diff --git a/tests/test_models.py b/tests/test_models.py index bb2cafd..1e84b6a 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -63,6 +63,18 @@ def test_dataset_artifact_requires_provenance(): ) +def test_dataset_artifact_rejects_none_provenance(): + with pytest.raises(ValueError): + DatasetArtifact( + sample_id="sample-1", + artifact_type="extract", + path=Path("sample-1.h5"), + format="hdf5", + params={"window_size": 200}, + provenance=None, + ) + + def test_shared_cluster_result_supports_plot_data(): model = SharedClusterModel( mode="shared", From 6a253f312651932130cf24ede69d9a2fa696f412 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 12:37:55 -0700 Subject: [PATCH 014/272] Require shared cluster profiles --- dimelo/models.py | 3 ++- tests/test_models.py | 19 +++++++------------ 2 files changed, 9 insertions(+), 13 deletions(-) diff --git a/dimelo/models.py b/dimelo/models.py index f674cad..790d826 100644 --- a/dimelo/models.py +++ b/dimelo/models.py @@ -50,7 +50,7 @@ class SharedClusterResult: cluster_distribution: pd.DataFrame condition_distribution: pd.DataFrame distribution_change: pd.DataFrame | None - cluster_profiles: pd.DataFrame | None + cluster_profiles: pd.DataFrame region_summaries: pd.DataFrame | None plot_data: dict[str, pd.DataFrame | dict[str, Any]] figures: dict[str, Any] = field(default_factory=dict) @@ -61,6 +61,7 @@ def __post_init__(self) -> None: "assignments": self.assignments, "cluster_distribution": self.cluster_distribution, "condition_distribution": self.condition_distribution, + "cluster_profiles": self.cluster_profiles, "plot_data": self.plot_data, } missing = [name for name, value in required_fields.items() if value is None] diff --git a/tests/test_models.py b/tests/test_models.py index 1e84b6a..c5e26ee 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -52,17 +52,6 @@ def test_dataset_artifact_stores_metadata(): assert artifact.provenance == {"pipeline": "parse_bam"} -def test_dataset_artifact_requires_provenance(): - with pytest.raises(TypeError): - DatasetArtifact( - sample_id="sample-1", - artifact_type="extract", - path=Path("sample-1.h5"), - format="hdf5", - params={"window_size": 200}, - ) - - def test_dataset_artifact_rejects_none_provenance(): with pytest.raises(ValueError): DatasetArtifact( @@ -104,7 +93,13 @@ def test_shared_cluster_result_supports_plot_data(): @pytest.mark.parametrize( "field_name", - ["assignments", "cluster_distribution", "condition_distribution", "plot_data"], + [ + "assignments", + "cluster_distribution", + "condition_distribution", + "cluster_profiles", + "plot_data", + ], ) def test_shared_cluster_result_rejects_none_core_outputs(field_name): model = SharedClusterModel( From 0783cf954d297e355bc314b1a9b72d1ea45134c7 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 12:41:48 -0700 Subject: [PATCH 015/272] feat: add artifact compatibility helpers --- dimelo/artifacts.py | 39 ++++++++++++++++++++ tests/test_artifacts.py | 81 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 120 insertions(+) create mode 100644 dimelo/artifacts.py create mode 100644 tests/test_artifacts.py diff --git a/dimelo/artifacts.py b/dimelo/artifacts.py new file mode 100644 index 0000000..4d56d41 --- /dev/null +++ b/dimelo/artifacts.py @@ -0,0 +1,39 @@ +from __future__ import annotations + +from collections.abc import Iterable + +from dimelo.models import DatasetArtifact + +_FINGERPRINT_FIELDS = ( + "sample_id", + "artifact_type", + "format", + "params", + "provenance", +) + + +def artifact_fingerprint(artifact: DatasetArtifact) -> dict[str, object]: + return {field: getattr(artifact, field) for field in _FINGERPRINT_FIELDS} + + +def artifact_is_compatible( + requested: DatasetArtifact, + candidate: DatasetArtifact, +) -> bool: + return all( + getattr(requested, field) == getattr(candidate, field) + for field in _FINGERPRINT_FIELDS + ) + + +def resolve_artifact( + requested: DatasetArtifact, + candidates: Iterable[DatasetArtifact], + artifact_policy: str = "prefer_cached", +) -> DatasetArtifact: + if artifact_policy == "prefer_cached": + for candidate in candidates: + if artifact_is_compatible(requested, candidate): + return candidate + return requested diff --git a/tests/test_artifacts.py b/tests/test_artifacts.py new file mode 100644 index 0000000..246185d --- /dev/null +++ b/tests/test_artifacts.py @@ -0,0 +1,81 @@ +from pathlib import Path + +from dimelo.artifacts import artifact_fingerprint, artifact_is_compatible, resolve_artifact +from dimelo.models import DatasetArtifact + + +def make_artifact( + *, + path: str, + params: dict[str, object], + provenance: dict[str, object], +) -> DatasetArtifact: + return DatasetArtifact( + sample_id="sample-1", + artifact_type="extract", + path=Path(path), + format="hdf5", + params=params, + provenance=provenance, + ) + + +def test_artifact_fingerprint_includes_required_keys(): + artifact = make_artifact( + path="requested.h5", + params={"window_size": 200}, + provenance={"pipeline": "parse_bam"}, + ) + + fingerprint = artifact_fingerprint(artifact) + + assert set(fingerprint) == { + "sample_id", + "artifact_type", + "format", + "params", + "provenance", + } + assert fingerprint["params"] == {"window_size": 200} + assert fingerprint["provenance"] == {"pipeline": "parse_bam"} + + +def test_artifact_is_compatible_rejects_parameter_mismatch(): + requested = make_artifact( + path="requested.h5", + params={"window_size": 200}, + provenance={"pipeline": "parse_bam"}, + ) + candidate = make_artifact( + path="cached.h5", + params={"window_size": 100}, + provenance={"pipeline": "parse_bam"}, + ) + + assert not artifact_is_compatible(requested, candidate) + + +def test_resolve_artifact_prefers_matching_cached_artifact(): + requested = make_artifact( + path="requested.h5", + params={"window_size": 200}, + provenance={"pipeline": "parse_bam"}, + ) + cached_match = make_artifact( + path="cached.h5", + params={"window_size": 200}, + provenance={"pipeline": "parse_bam"}, + ) + cached_mismatch = make_artifact( + path="other-cached.h5", + params={"window_size": 100}, + provenance={"pipeline": "parse_bam"}, + ) + + resolved = resolve_artifact( + requested, + [cached_mismatch, cached_match], + artifact_policy="prefer_cached", + ) + + assert resolved is cached_match From 14a82edd5b3f82db09d2a2a120f37ad1896e022a Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 12:44:53 -0700 Subject: [PATCH 016/272] fix: tighten artifact compatibility policies --- dimelo/artifacts.py | 56 +++++++++++++------ tests/test_artifacts.py | 117 +++++++++++++++++++++++++++++++++++----- 2 files changed, 145 insertions(+), 28 deletions(-) diff --git a/dimelo/artifacts.py b/dimelo/artifacts.py index 4d56d41..7bb0fea 100644 --- a/dimelo/artifacts.py +++ b/dimelo/artifacts.py @@ -1,29 +1,45 @@ from __future__ import annotations +import hashlib +import json from collections.abc import Iterable from dimelo.models import DatasetArtifact -_FINGERPRINT_FIELDS = ( - "sample_id", - "artifact_type", - "format", - "params", - "provenance", -) + +def _params_hash(params: dict[str, object]) -> str: + payload = json.dumps(params, sort_keys=True, separators=(",", ":")).encode() + return hashlib.sha256(payload).hexdigest() def artifact_fingerprint(artifact: DatasetArtifact) -> dict[str, object]: - return {field: getattr(artifact, field) for field in _FINGERPRINT_FIELDS} + return { + "schema": artifact.metadata.get("schema"), + "package": artifact.metadata.get("package"), + "source": artifact.provenance.get("source"), + "params_hash": _params_hash(artifact.params), + } def artifact_is_compatible( requested: DatasetArtifact, candidate: DatasetArtifact, ) -> bool: - return all( - getattr(requested, field) == getattr(candidate, field) - for field in _FINGERPRINT_FIELDS + requested_fingerprint = artifact_fingerprint(requested) + candidate_fingerprint = artifact_fingerprint(candidate) + if any( + requested_fingerprint[field] != candidate_fingerprint[field] + for field in ("schema", "package") + ): + return False + if ( + requested_fingerprint["source"] is not None + and requested_fingerprint["source"] != candidate_fingerprint["source"] + ): + return False + + return all(item in candidate.params.items() for item in requested.params.items()) and all( + item in candidate.provenance.items() for item in requested.provenance.items() ) @@ -31,9 +47,17 @@ def resolve_artifact( requested: DatasetArtifact, candidates: Iterable[DatasetArtifact], artifact_policy: str = "prefer_cached", -) -> DatasetArtifact: +) -> DatasetArtifact | None: + if artifact_policy == "rebuild": + return None + + if artifact_policy not in {"prefer_cached", "require_cached"}: + raise ValueError(f"Unknown artifact_policy: {artifact_policy}") + + for candidate in candidates: + if artifact_is_compatible(requested, candidate): + return candidate + if artifact_policy == "prefer_cached": - for candidate in candidates: - if artifact_is_compatible(requested, candidate): - return candidate - return requested + return None + raise LookupError("No compatible cached artifact found for require_cached") diff --git a/tests/test_artifacts.py b/tests/test_artifacts.py index 246185d..4736c79 100644 --- a/tests/test_artifacts.py +++ b/tests/test_artifacts.py @@ -1,3 +1,5 @@ +import hashlib +import json from pathlib import Path from dimelo.artifacts import artifact_fingerprint, artifact_is_compatible, resolve_artifact @@ -9,6 +11,7 @@ def make_artifact( path: str, params: dict[str, object], provenance: dict[str, object], + metadata: dict[str, object] | None = None, ) -> DatasetArtifact: return DatasetArtifact( sample_id="sample-1", @@ -17,6 +20,7 @@ def make_artifact( format="hdf5", params=params, provenance=provenance, + metadata=metadata or {}, ) @@ -24,32 +28,58 @@ def test_artifact_fingerprint_includes_required_keys(): artifact = make_artifact( path="requested.h5", params={"window_size": 200}, - provenance={"pipeline": "parse_bam"}, + provenance={"pipeline": "parse_bam", "source": "modkit"}, + metadata={"schema": "artifact-v1", "package": "dimelo"}, ) fingerprint = artifact_fingerprint(artifact) assert set(fingerprint) == { - "sample_id", - "artifact_type", - "format", - "params", - "provenance", + "schema", + "package", + "source", + "params_hash", + } + expected_params_hash = hashlib.sha256( + json.dumps({"window_size": 200}, sort_keys=True, separators=(",", ":")).encode() + ).hexdigest() + assert fingerprint == { + "schema": "artifact-v1", + "package": "dimelo", + "source": "modkit", + "params_hash": expected_params_hash, } - assert fingerprint["params"] == {"window_size": 200} - assert fingerprint["provenance"] == {"pipeline": "parse_bam"} -def test_artifact_is_compatible_rejects_parameter_mismatch(): +def test_artifact_is_compatible_accepts_subset_matches(): requested = make_artifact( path="requested.h5", params={"window_size": 200}, provenance={"pipeline": "parse_bam"}, + metadata={"schema": "artifact-v1", "package": "dimelo"}, ) candidate = make_artifact( path="cached.h5", - params={"window_size": 100}, + params={"window_size": 200, "threads": 8}, + provenance={"pipeline": "parse_bam", "source": "modkit"}, + metadata={"schema": "artifact-v1", "package": "dimelo"}, + ) + + assert artifact_is_compatible(requested, candidate) + + +def test_artifact_is_compatible_rejects_parameter_mismatch(): + requested = make_artifact( + path="requested.h5", + params={"window_size": 200}, provenance={"pipeline": "parse_bam"}, + metadata={"schema": "artifact-v1", "package": "dimelo"}, + ) + candidate = make_artifact( + path="cached.h5", + params={"window_size": 100, "threads": 8}, + provenance={"pipeline": "parse_bam", "source": "modkit"}, + metadata={"schema": "artifact-v1", "package": "dimelo"}, ) assert not artifact_is_compatible(requested, candidate) @@ -60,16 +90,19 @@ def test_resolve_artifact_prefers_matching_cached_artifact(): path="requested.h5", params={"window_size": 200}, provenance={"pipeline": "parse_bam"}, + metadata={"schema": "artifact-v1", "package": "dimelo"}, ) cached_match = make_artifact( path="cached.h5", - params={"window_size": 200}, - provenance={"pipeline": "parse_bam"}, + params={"window_size": 200, "threads": 8}, + provenance={"pipeline": "parse_bam", "source": "modkit"}, + metadata={"schema": "artifact-v1", "package": "dimelo"}, ) cached_mismatch = make_artifact( path="other-cached.h5", params={"window_size": 100}, provenance={"pipeline": "parse_bam"}, + metadata={"schema": "artifact-v1", "package": "dimelo"}, ) resolved = resolve_artifact( @@ -79,3 +112,63 @@ def test_resolve_artifact_prefers_matching_cached_artifact(): ) assert resolved is cached_match + + +def test_resolve_artifact_returns_none_on_prefer_cached_miss(): + requested = make_artifact( + path="requested.h5", + params={"window_size": 200}, + provenance={"pipeline": "parse_bam"}, + metadata={"schema": "artifact-v1", "package": "dimelo"}, + ) + + resolved = resolve_artifact( + requested, + [], + artifact_policy="prefer_cached", + ) + + assert resolved is None + + +def test_resolve_artifact_raises_on_require_cached_miss(): + requested = make_artifact( + path="requested.h5", + params={"window_size": 200}, + provenance={"pipeline": "parse_bam"}, + metadata={"schema": "artifact-v1", "package": "dimelo"}, + ) + + try: + resolve_artifact( + requested, + [], + artifact_policy="require_cached", + ) + except LookupError as exc: + assert "require_cached" in str(exc) + else: + raise AssertionError("Expected resolve_artifact to raise LookupError") + + +def test_resolve_artifact_returns_none_for_rebuild(): + requested = make_artifact( + path="requested.h5", + params={"window_size": 200}, + provenance={"pipeline": "parse_bam"}, + metadata={"schema": "artifact-v1", "package": "dimelo"}, + ) + cached_match = make_artifact( + path="cached.h5", + params={"window_size": 200}, + provenance={"pipeline": "parse_bam"}, + metadata={"schema": "artifact-v1", "package": "dimelo"}, + ) + + resolved = resolve_artifact( + requested, + [cached_match], + artifact_policy="rebuild", + ) + + assert resolved is None From 5cfb116bc6189a117c1adf590c50d9b8bfc5be69 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 12:47:54 -0700 Subject: [PATCH 017/272] fix: strengthen artifact compatibility contract --- dimelo/artifacts.py | 73 ++++++++++++++--- tests/test_artifacts.py | 173 +++++++++++++++++++++++++++------------- 2 files changed, 179 insertions(+), 67 deletions(-) diff --git a/dimelo/artifacts.py b/dimelo/artifacts.py index 7bb0fea..02f47ad 100644 --- a/dimelo/artifacts.py +++ b/dimelo/artifacts.py @@ -12,11 +12,56 @@ def _params_hash(params: dict[str, object]) -> str: return hashlib.sha256(payload).hexdigest() +def _normalize_sequence(values: object) -> tuple[object, ...]: + if values is None: + return () + return tuple(values) + + +def _normalize_source_fingerprints(values: object) -> tuple[dict[str, object], ...]: + if values is None: + return () + normalized = [dict(value) for value in values] + normalized.sort(key=lambda value: json.dumps(value, sort_keys=True, separators=(",", ":"))) + return tuple(normalized) + + +def _mapping_subset_matches( + requested: dict[str, object], + candidate: dict[str, object], +) -> bool: + return all(item in candidate.items() for item in requested.items()) + + +def _requested_params_hash_matches( + requested: dict[str, object], + candidate: dict[str, object], +) -> bool: + if not _mapping_subset_matches(requested, candidate): + return False + candidate_subset = {key: candidate[key] for key in requested} + return _params_hash(requested) == _params_hash(candidate_subset) + + def artifact_fingerprint(artifact: DatasetArtifact) -> dict[str, object]: return { - "schema": artifact.metadata.get("schema"), - "package": artifact.metadata.get("package"), - "source": artifact.provenance.get("source"), + "schema_version": artifact.metadata.get("schema_version"), + "package_version": artifact.metadata.get("package_version"), + "source_files": tuple( + sorted( + _normalize_sequence( + artifact.provenance.get("source_files", artifact.metadata.get("source_files")) + ) + ) + ), + "source_fingerprints": _normalize_source_fingerprints( + artifact.provenance.get( + "source_fingerprints", artifact.metadata.get("source_fingerprints") + ) + ), + "upstream_lineage": _normalize_sequence( + artifact.provenance.get("upstream_lineage", artifact.metadata.get("upstream_lineage")) + ), "params_hash": _params_hash(artifact.params), } @@ -27,20 +72,24 @@ def artifact_is_compatible( ) -> bool: requested_fingerprint = artifact_fingerprint(requested) candidate_fingerprint = artifact_fingerprint(candidate) + if requested.sample_id != candidate.sample_id: + return False + if requested.artifact_type != candidate.artifact_type: + return False if any( requested_fingerprint[field] != candidate_fingerprint[field] - for field in ("schema", "package") + for field in ( + "schema_version", + "package_version", + "source_files", + "source_fingerprints", + "upstream_lineage", + ) ): return False - if ( - requested_fingerprint["source"] is not None - and requested_fingerprint["source"] != candidate_fingerprint["source"] - ): + if not _requested_params_hash_matches(requested.params, candidate.params): return False - - return all(item in candidate.params.items() for item in requested.params.items()) and all( - item in candidate.provenance.items() for item in requested.provenance.items() - ) + return _mapping_subset_matches(requested.provenance, candidate.provenance) def resolve_artifact( diff --git a/tests/test_artifacts.py b/tests/test_artifacts.py index 4736c79..d68b447 100644 --- a/tests/test_artifacts.py +++ b/tests/test_artifacts.py @@ -2,20 +2,24 @@ import json from pathlib import Path +import pytest + from dimelo.artifacts import artifact_fingerprint, artifact_is_compatible, resolve_artifact from dimelo.models import DatasetArtifact def make_artifact( *, + sample_id: str = "sample-1", + artifact_type: str = "extract", path: str, params: dict[str, object], provenance: dict[str, object], metadata: dict[str, object] | None = None, ) -> DatasetArtifact: return DatasetArtifact( - sample_id="sample-1", - artifact_type="extract", + sample_id=sample_id, + artifact_type=artifact_type, path=Path(path), format="hdf5", params=params, @@ -27,59 +31,93 @@ def make_artifact( def test_artifact_fingerprint_includes_required_keys(): artifact = make_artifact( path="requested.h5", - params={"window_size": 200}, - provenance={"pipeline": "parse_bam", "source": "modkit"}, - metadata={"schema": "artifact-v1", "package": "dimelo"}, + params={"window_size": 200, "min_coverage": 5}, + provenance={ + "source_files": ["reads-a.bam", "reads-b.bam"], + "source_fingerprints": [ + {"path": "reads-a.bam", "size": 100, "mtime": 10, "digest": "aaa"}, + {"path": "reads-b.bam", "size": 200, "mtime": 20, "digest": "bbb"}, + ], + "upstream_lineage": ["parse_bam", "normalize"], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, ) fingerprint = artifact_fingerprint(artifact) assert set(fingerprint) == { - "schema", - "package", - "source", + "schema_version", + "package_version", + "source_files", + "source_fingerprints", + "upstream_lineage", "params_hash", } + assert fingerprint["schema_version"] == "artifact-v1" + assert fingerprint["package_version"] == "1.2.3" + assert fingerprint["source_files"] == ("reads-a.bam", "reads-b.bam") + assert fingerprint["source_fingerprints"] == ( + {"path": "reads-a.bam", "size": 100, "mtime": 10, "digest": "aaa"}, + {"path": "reads-b.bam", "size": 200, "mtime": 20, "digest": "bbb"}, + ) + assert fingerprint["upstream_lineage"] == ("parse_bam", "normalize") expected_params_hash = hashlib.sha256( - json.dumps({"window_size": 200}, sort_keys=True, separators=(",", ":")).encode() + json.dumps( + {"min_coverage": 5, "window_size": 200}, + sort_keys=True, + separators=(",", ":"), + ).encode() ).hexdigest() - assert fingerprint == { - "schema": "artifact-v1", - "package": "dimelo", - "source": "modkit", - "params_hash": expected_params_hash, - } + assert fingerprint["params_hash"] == expected_params_hash -def test_artifact_is_compatible_accepts_subset_matches(): +def test_artifact_is_compatible_rejects_sample_id_mismatch(): requested = make_artifact( path="requested.h5", params={"window_size": 200}, - provenance={"pipeline": "parse_bam"}, - metadata={"schema": "artifact-v1", "package": "dimelo"}, + provenance={ + "source_files": ["reads-a.bam"], + "source_fingerprints": [{"path": "reads-a.bam", "size": 100, "mtime": 10}], + "upstream_lineage": ["parse_bam"], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, ) candidate = make_artifact( + sample_id="sample-2", path="cached.h5", - params={"window_size": 200, "threads": 8}, - provenance={"pipeline": "parse_bam", "source": "modkit"}, - metadata={"schema": "artifact-v1", "package": "dimelo"}, + params={"window_size": 200}, + provenance={ + "source_files": ["reads-a.bam"], + "source_fingerprints": [{"path": "reads-a.bam", "size": 100, "mtime": 10}], + "upstream_lineage": ["parse_bam"], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, ) - assert artifact_is_compatible(requested, candidate) + assert not artifact_is_compatible(requested, candidate) -def test_artifact_is_compatible_rejects_parameter_mismatch(): +def test_artifact_is_compatible_rejects_artifact_type_mismatch(): requested = make_artifact( path="requested.h5", params={"window_size": 200}, - provenance={"pipeline": "parse_bam"}, - metadata={"schema": "artifact-v1", "package": "dimelo"}, + provenance={ + "source_files": ["reads-a.bam"], + "source_fingerprints": [{"path": "reads-a.bam", "size": 100, "mtime": 10}], + "upstream_lineage": ["parse_bam"], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, ) candidate = make_artifact( + artifact_type="other", path="cached.h5", - params={"window_size": 100, "threads": 8}, - provenance={"pipeline": "parse_bam", "source": "modkit"}, - metadata={"schema": "artifact-v1", "package": "dimelo"}, + params={"window_size": 200}, + provenance={ + "source_files": ["reads-a.bam"], + "source_fingerprints": [{"path": "reads-a.bam", "size": 100, "mtime": 10}], + "upstream_lineage": ["parse_bam"], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, ) assert not artifact_is_compatible(requested, candidate) @@ -89,25 +127,27 @@ def test_resolve_artifact_prefers_matching_cached_artifact(): requested = make_artifact( path="requested.h5", params={"window_size": 200}, - provenance={"pipeline": "parse_bam"}, - metadata={"schema": "artifact-v1", "package": "dimelo"}, + provenance={ + "source_files": ["reads-a.bam"], + "source_fingerprints": [{"path": "reads-a.bam", "size": 100, "mtime": 10}], + "upstream_lineage": ["parse_bam"], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, ) cached_match = make_artifact( path="cached.h5", params={"window_size": 200, "threads": 8}, - provenance={"pipeline": "parse_bam", "source": "modkit"}, - metadata={"schema": "artifact-v1", "package": "dimelo"}, - ) - cached_mismatch = make_artifact( - path="other-cached.h5", - params={"window_size": 100}, - provenance={"pipeline": "parse_bam"}, - metadata={"schema": "artifact-v1", "package": "dimelo"}, + provenance={ + "source_files": ["reads-a.bam"], + "source_fingerprints": [{"path": "reads-a.bam", "size": 100, "mtime": 10}], + "upstream_lineage": ["parse_bam"], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, ) resolved = resolve_artifact( requested, - [cached_mismatch, cached_match], + [cached_match], artifact_policy="prefer_cached", ) @@ -118,13 +158,28 @@ def test_resolve_artifact_returns_none_on_prefer_cached_miss(): requested = make_artifact( path="requested.h5", params={"window_size": 200}, - provenance={"pipeline": "parse_bam"}, - metadata={"schema": "artifact-v1", "package": "dimelo"}, + provenance={ + "source_files": ["reads-a.bam"], + "source_fingerprints": [{"path": "reads-a.bam", "size": 100, "mtime": 10}], + "upstream_lineage": ["parse_bam"], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, + ) + candidate = make_artifact( + sample_id="sample-2", + path="cached.h5", + params={"window_size": 200}, + provenance={ + "source_files": ["reads-a.bam"], + "source_fingerprints": [{"path": "reads-a.bam", "size": 100, "mtime": 10}], + "upstream_lineage": ["parse_bam"], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, ) resolved = resolve_artifact( requested, - [], + [candidate], artifact_policy="prefer_cached", ) @@ -135,39 +190,47 @@ def test_resolve_artifact_raises_on_require_cached_miss(): requested = make_artifact( path="requested.h5", params={"window_size": 200}, - provenance={"pipeline": "parse_bam"}, - metadata={"schema": "artifact-v1", "package": "dimelo"}, + provenance={ + "source_files": ["reads-a.bam"], + "source_fingerprints": [{"path": "reads-a.bam", "size": 100, "mtime": 10}], + "upstream_lineage": ["parse_bam"], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, ) - try: + with pytest.raises(LookupError, match="require_cached"): resolve_artifact( requested, [], artifact_policy="require_cached", ) - except LookupError as exc: - assert "require_cached" in str(exc) - else: - raise AssertionError("Expected resolve_artifact to raise LookupError") def test_resolve_artifact_returns_none_for_rebuild(): requested = make_artifact( path="requested.h5", params={"window_size": 200}, - provenance={"pipeline": "parse_bam"}, - metadata={"schema": "artifact-v1", "package": "dimelo"}, + provenance={ + "source_files": ["reads-a.bam"], + "source_fingerprints": [{"path": "reads-a.bam", "size": 100, "mtime": 10}], + "upstream_lineage": ["parse_bam"], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, ) - cached_match = make_artifact( + candidate = make_artifact( path="cached.h5", params={"window_size": 200}, - provenance={"pipeline": "parse_bam"}, - metadata={"schema": "artifact-v1", "package": "dimelo"}, + provenance={ + "source_files": ["reads-a.bam"], + "source_fingerprints": [{"path": "reads-a.bam", "size": 100, "mtime": 10}], + "upstream_lineage": ["parse_bam"], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, ) resolved = resolve_artifact( requested, - [cached_match], + [candidate], artifact_policy="rebuild", ) From aa9469f63730e4e536b0bdfe0be08a7a729c6c7c Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 12:54:30 -0700 Subject: [PATCH 018/272] feat: add artifact compatibility resolver foundations --- dimelo/artifacts.py | 68 +++++++++++++++++++++---- tests/test_artifacts.py | 109 +++++++++++++++++++++++++++++++++++++++- 2 files changed, 165 insertions(+), 12 deletions(-) diff --git a/dimelo/artifacts.py b/dimelo/artifacts.py index 02f47ad..fed49ac 100644 --- a/dimelo/artifacts.py +++ b/dimelo/artifacts.py @@ -6,6 +6,19 @@ from dimelo.models import DatasetArtifact +COMPATIBILITY_PROVENANCE_KEYS = frozenset( + { + "normalization_mode", + "feature_scaling", + "cluster_basis", + "motifs", + "window_size", + "region_source", + "region_digest", + "pipeline", + } +) + def _params_hash(params: dict[str, object]) -> str: payload = json.dumps(params, sort_keys=True, separators=(",", ":")).encode() @@ -14,13 +27,22 @@ def _params_hash(params: dict[str, object]) -> str: def _normalize_sequence(values: object) -> tuple[object, ...]: if values is None: - return () + return None + if isinstance(values, str): + return (values,) return tuple(values) -def _normalize_source_fingerprints(values: object) -> tuple[dict[str, object], ...]: +def _normalize_source_files(values: object) -> tuple[str, ...] | None: + normalized = _normalize_sequence(values) + if normalized is None: + return None + return tuple(sorted(str(value) for value in normalized)) + + +def _normalize_source_fingerprints(values: object) -> tuple[dict[str, object], ...] | None: if values is None: - return () + return None normalized = [dict(value) for value in values] normalized.sort(key=lambda value: json.dumps(value, sort_keys=True, separators=(",", ":"))) return tuple(normalized) @@ -43,16 +65,20 @@ def _requested_params_hash_matches( return _params_hash(requested) == _params_hash(candidate_subset) +def _compatibility_provenance(requested: dict[str, object]) -> dict[str, object]: + return { + key: value + for key, value in requested.items() + if key in COMPATIBILITY_PROVENANCE_KEYS + } + + def artifact_fingerprint(artifact: DatasetArtifact) -> dict[str, object]: return { "schema_version": artifact.metadata.get("schema_version"), "package_version": artifact.metadata.get("package_version"), - "source_files": tuple( - sorted( - _normalize_sequence( - artifact.provenance.get("source_files", artifact.metadata.get("source_files")) - ) - ) + "source_files": _normalize_source_files( + artifact.provenance.get("source_files", artifact.metadata.get("source_files")) ), "source_fingerprints": _normalize_source_fingerprints( artifact.provenance.get( @@ -66,12 +92,29 @@ def artifact_fingerprint(artifact: DatasetArtifact) -> dict[str, object]: } +def _has_required_fingerprint_fields(fingerprint: dict[str, object]) -> bool: + required_fields = ( + "schema_version", + "package_version", + "source_files", + "source_fingerprints", + "upstream_lineage", + ) + if any(fingerprint[field] is None for field in required_fields): + return False + return bool(fingerprint["source_files"]) and bool(fingerprint["source_fingerprints"]) + + def artifact_is_compatible( requested: DatasetArtifact, candidate: DatasetArtifact, ) -> bool: requested_fingerprint = artifact_fingerprint(requested) candidate_fingerprint = artifact_fingerprint(candidate) + if not _has_required_fingerprint_fields(requested_fingerprint): + return False + if not _has_required_fingerprint_fields(candidate_fingerprint): + return False if requested.sample_id != candidate.sample_id: return False if requested.artifact_type != candidate.artifact_type: @@ -89,7 +132,10 @@ def artifact_is_compatible( return False if not _requested_params_hash_matches(requested.params, candidate.params): return False - return _mapping_subset_matches(requested.provenance, candidate.provenance) + return _mapping_subset_matches( + _compatibility_provenance(requested.provenance), + candidate.provenance, + ) def resolve_artifact( @@ -109,4 +155,4 @@ def resolve_artifact( if artifact_policy == "prefer_cached": return None - raise LookupError("No compatible cached artifact found for require_cached") + raise FileNotFoundError("No compatible cached artifact found for require_cached") diff --git a/tests/test_artifacts.py b/tests/test_artifacts.py index d68b447..a4af33e 100644 --- a/tests/test_artifacts.py +++ b/tests/test_artifacts.py @@ -71,6 +71,40 @@ def test_artifact_fingerprint_includes_required_keys(): assert fingerprint["params_hash"] == expected_params_hash +def test_artifact_fingerprint_normalizes_source_file_paths_to_strings(): + artifact = make_artifact( + path="requested.h5", + params={"window_size": 200}, + provenance={ + "source_files": [Path("reads-b.bam"), "reads-a.bam"], + "source_fingerprints": [{"path": "reads-a.bam", "size": 100, "mtime": 10}], + "upstream_lineage": [], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, + ) + + fingerprint = artifact_fingerprint(artifact) + + assert fingerprint["source_files"] == ("reads-a.bam", "reads-b.bam") + + +def test_artifact_fingerprint_treats_single_source_file_string_as_one_path(): + artifact = make_artifact( + path="requested.h5", + params={"window_size": 200}, + provenance={ + "source_files": "reads-a.bam", + "source_fingerprints": [{"path": "reads-a.bam", "size": 100, "mtime": 10}], + "upstream_lineage": [], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, + ) + + fingerprint = artifact_fingerprint(artifact) + + assert fingerprint["source_files"] == ("reads-a.bam",) + + def test_artifact_is_compatible_rejects_sample_id_mismatch(): requested = make_artifact( path="requested.h5", @@ -123,6 +157,52 @@ def test_artifact_is_compatible_rejects_artifact_type_mismatch(): assert not artifact_is_compatible(requested, candidate) +def test_artifact_is_compatible_rejects_missing_required_lineage_fields(): + requested = make_artifact( + path="requested.h5", + params={"window_size": 200}, + provenance={ + "source_files": ["reads-a.bam"], + "source_fingerprints": [{"path": "reads-a.bam", "size": 100, "mtime": 10}], + "upstream_lineage": [], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, + ) + candidate = make_artifact( + path="cached.h5", + params={"window_size": 200}, + provenance={}, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, + ) + + assert not artifact_is_compatible(requested, candidate) + + +def test_artifact_is_compatible_rejects_empty_source_metadata(): + requested = make_artifact( + path="requested.h5", + params={"window_size": 200}, + provenance={ + "source_files": ["reads-a.bam"], + "source_fingerprints": [{"path": "reads-a.bam", "size": 100, "mtime": 10}], + "upstream_lineage": [], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, + ) + candidate = make_artifact( + path="cached.h5", + params={"window_size": 200}, + provenance={ + "source_files": [], + "source_fingerprints": [], + "upstream_lineage": [], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, + ) + + assert not artifact_is_compatible(requested, candidate) + + def test_resolve_artifact_prefers_matching_cached_artifact(): requested = make_artifact( path="requested.h5", @@ -198,7 +278,7 @@ def test_resolve_artifact_raises_on_require_cached_miss(): metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, ) - with pytest.raises(LookupError, match="require_cached"): + with pytest.raises(FileNotFoundError, match="require_cached"): resolve_artifact( requested, [], @@ -206,6 +286,33 @@ def test_resolve_artifact_raises_on_require_cached_miss(): ) +def test_artifact_is_compatible_ignores_non_compatibility_provenance_fields(): + requested = make_artifact( + path="requested.h5", + params={"window_size": 200}, + provenance={ + "source_files": ["reads-a.bam"], + "source_fingerprints": [{"path": "reads-a.bam", "size": 100, "mtime": 10}], + "upstream_lineage": ["parse_bam"], + "runtime_host": "worker-a", + "invocation_id": "run-123", + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, + ) + candidate = make_artifact( + path="cached.h5", + params={"window_size": 200}, + provenance={ + "source_files": ["reads-a.bam"], + "source_fingerprints": [{"path": "reads-a.bam", "size": 100, "mtime": 10}], + "upstream_lineage": ["parse_bam"], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.2.3"}, + ) + + assert artifact_is_compatible(requested, candidate) + + def test_resolve_artifact_returns_none_for_rebuild(): requested = make_artifact( path="requested.h5", From fa1c2e984b854bc2a942b0be50bbf3dad32f2aa6 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 13:00:45 -0700 Subject: [PATCH 019/272] feat: add distribution summary helpers --- dimelo/distribution.py | 130 ++++++++++++++++++++++++++++++ dimelo/plotting.py | 46 +++++++++++ tests/test_distribution.py | 161 +++++++++++++++++++++++++++++++++++++ 3 files changed, 337 insertions(+) create mode 100644 dimelo/distribution.py create mode 100644 dimelo/plotting.py create mode 100644 tests/test_distribution.py diff --git a/dimelo/distribution.py b/dimelo/distribution.py new file mode 100644 index 0000000..530f166 --- /dev/null +++ b/dimelo/distribution.py @@ -0,0 +1,130 @@ +from __future__ import annotations + +from collections.abc import Iterable + +import numpy as np +import pandas as pd + +_CLUSTER_DISTRIBUTION_COLUMNS = [ + "sample_id", + "condition", + "cluster", + "count", + "fraction", +] + +_CONDITION_DISTRIBUTION_COLUMNS = [ + "condition", + "cluster", + "count", + "fraction", + "replicate_n", +] + + +def _require_columns(frame: pd.DataFrame, required: Iterable[str], name: str) -> None: + missing = [column for column in required if column not in frame.columns] + if missing: + raise ValueError(f"{name} is missing required columns: {', '.join(missing)}") + + +def build_cluster_distribution(assignments: pd.DataFrame) -> pd.DataFrame: + _require_columns(assignments, ("sample_id", "condition", "cluster"), "assignments") + if assignments.empty: + return pd.DataFrame(columns=_CLUSTER_DISTRIBUTION_COLUMNS) + + grouped = ( + assignments.groupby(["sample_id", "condition", "cluster"], sort=True) + .size() + .reset_index(name="count") + ) + totals = grouped.groupby("sample_id")["count"].transform("sum") + grouped["fraction"] = grouped["count"] / totals + return grouped[_CLUSTER_DISTRIBUTION_COLUMNS] + + +def build_condition_distribution(cluster_distribution: pd.DataFrame) -> pd.DataFrame: + _require_columns( + cluster_distribution, + ("sample_id", "condition", "cluster", "count"), + "cluster_distribution", + ) + if cluster_distribution.empty: + return pd.DataFrame(columns=_CONDITION_DISTRIBUTION_COLUMNS) + + replicate_counts = ( + cluster_distribution.groupby("condition", sort=True)["sample_id"] + .nunique() + .rename("replicate_n") + .reset_index() + ) + grouped = ( + cluster_distribution.groupby(["condition", "cluster"], sort=True) + .agg(count=("count", "sum")) + .reset_index() + ) + grouped = grouped.merge(replicate_counts, on="condition", how="left") + totals = grouped.groupby("condition")["count"].transform("sum") + grouped["fraction"] = grouped["count"] / totals + return grouped[_CONDITION_DISTRIBUTION_COLUMNS] + + +def build_distribution_change( + condition_distribution: pd.DataFrame, + *, + reference_condition: str, + pseudo_count: float = 1e-9, +) -> pd.DataFrame: + _require_columns( + condition_distribution, + ("condition", "cluster", "fraction"), + "condition_distribution", + ) + if condition_distribution.empty: + return pd.DataFrame( + columns=[ + "condition", + "cluster", + "count", + "fraction", + "replicate_n", + "reference_fraction", + "delta_fraction", + "log2_fc", + ] + ) + + reference_rows = condition_distribution[ + condition_distribution["condition"] == reference_condition + ] + if reference_rows.empty: + raise ValueError( + f"reference_condition {reference_condition!r} not present in condition_distribution" + ) + + reference_fractions = reference_rows.loc[:, ["cluster", "fraction"]].rename( + columns={"fraction": "reference_fraction"} + ) + merged = condition_distribution.merge(reference_fractions, on="cluster", how="left") + merged = merged[merged["condition"] != reference_condition].copy() + if "count" not in merged.columns: + merged["count"] = pd.NA + if "replicate_n" not in merged.columns: + merged["replicate_n"] = pd.NA + merged["reference_fraction"] = merged["reference_fraction"].fillna(0.0) + merged["delta_fraction"] = merged["fraction"] - merged["reference_fraction"] + merged["log2_fc"] = np.log2( + (merged["fraction"] + pseudo_count) / (merged["reference_fraction"] + pseudo_count) + ) + return merged[ + [ + "condition", + "cluster", + "count", + "fraction", + "replicate_n", + "reference_fraction", + "delta_fraction", + "log2_fc", + ] + ].sort_values(["condition", "cluster"], kind="stable").reset_index(drop=True) diff --git a/dimelo/plotting.py b/dimelo/plotting.py new file mode 100644 index 0000000..0594a1d --- /dev/null +++ b/dimelo/plotting.py @@ -0,0 +1,46 @@ +from __future__ import annotations + +import pandas as pd + +from dimelo.distribution import _require_columns + + +def prepare_cluster_distribution_bar_data(cluster_distribution: pd.DataFrame) -> pd.DataFrame: + _require_columns( + cluster_distribution, + ("sample_id", "condition", "cluster", "count", "fraction"), + "cluster_distribution", + ) + if cluster_distribution.empty: + return cluster_distribution.loc[:, ["sample_id", "condition", "cluster", "count", "fraction"]].copy() + + return ( + cluster_distribution.loc[:, ["sample_id", "condition", "cluster", "count", "fraction"]] + .sort_values(["sample_id", "condition", "cluster"], kind="stable") + .reset_index(drop=True) + ) + + +def prepare_cluster_distribution_heatmap_data(condition_distribution: pd.DataFrame) -> pd.DataFrame: + _require_columns( + condition_distribution, + ("condition", "cluster", "fraction"), + "condition_distribution", + ) + if condition_distribution.empty: + return pd.DataFrame(columns=["condition"]) + + heatmap = ( + condition_distribution.pivot_table( + index="condition", + columns="cluster", + values="fraction", + aggfunc="sum", + fill_value=0.0, + ) + .sort_index(axis=0) + .reindex(sorted(condition_distribution["cluster"].unique()), axis=1, fill_value=0.0) + .reset_index() + ) + heatmap.columns.name = None + return heatmap diff --git a/tests/test_distribution.py b/tests/test_distribution.py new file mode 100644 index 0000000..7a337df --- /dev/null +++ b/tests/test_distribution.py @@ -0,0 +1,161 @@ +import pandas as pd + +from dimelo.distribution import ( + build_cluster_distribution, + build_condition_distribution, + build_distribution_change, +) +from dimelo.plotting import ( + prepare_cluster_distribution_bar_data, + prepare_cluster_distribution_heatmap_data, +) + + +def test_build_cluster_distribution_counts_and_fractions(): + assignments = pd.DataFrame( + { + "sample_id": ["s1", "s1", "s1", "s2"], + "condition": ["NS", "NS", "NS", "15min"], + "cluster": ["C0", "C0", "C1", "C1"], + } + ) + + result = build_cluster_distribution(assignments) + + assert list(result.columns) == ["sample_id", "condition", "cluster", "count", "fraction"] + s1 = ( + result[result["sample_id"] == "s1"] + .sort_values("cluster") + .reset_index(drop=True) + ) + assert list(s1["count"]) == [2, 1] + assert list(s1["fraction"]) == [2 / 3, 1 / 3] + + +def test_build_condition_distribution_aggregates_sample_distributions(): + cluster_distribution = pd.DataFrame( + { + "sample_id": ["s1", "s1", "s2", "s2"], + "condition": ["NS", "NS", "NS", "NS"], + "cluster": ["C0", "C1", "C0", "C1"], + "count": [2, 1, 1, 2], + "fraction": [2 / 3, 1 / 3, 1 / 3, 2 / 3], + } + ) + + result = build_condition_distribution(cluster_distribution) + + assert list(result.columns) == [ + "condition", + "cluster", + "count", + "fraction", + "replicate_n", + ] + assert set(result["condition"]) == {"NS"} + assert list(result.sort_values("cluster")["count"]) == [3, 3] + assert list(result.sort_values("cluster")["fraction"]) == [0.5, 0.5] + assert set(result["replicate_n"]) == {2} + + +def test_build_condition_distribution_tracks_condition_level_replicate_count(): + cluster_distribution = pd.DataFrame( + { + "sample_id": ["s1", "s1", "s2"], + "condition": ["NS", "NS", "NS"], + "cluster": ["C0", "C1", "C0"], + "count": [2, 1, 1], + "fraction": [2 / 3, 1 / 3, 1.0], + } + ) + + result = build_condition_distribution(cluster_distribution) + + assert set(result["replicate_n"]) == {2} + + +def test_build_distribution_change_against_reference_condition(): + condition_distribution = pd.DataFrame( + { + "condition": ["NS", "NS", "15min", "15min"], + "cluster": ["C0", "C1", "C0", "C1"], + "count": [3, 1, 1, 3], + "fraction": [0.75, 0.25, 0.25, 0.75], + "replicate_n": [2, 2, 2, 2], + } + ) + + result = build_distribution_change( + condition_distribution, + reference_condition="NS", + ) + + row = result[(result["condition"] == "15min") & (result["cluster"] == "C1")].iloc[0] + assert row["reference_fraction"] == 0.25 + assert row["delta_fraction"] == 0.5 + assert row["log2_fc"] > 0 + + +def test_build_distribution_change_accepts_minimal_condition_distribution_shape(): + condition_distribution = pd.DataFrame( + { + "condition": ["NS", "NS", "15min", "15min"], + "cluster": ["C0", "C1", "C0", "C1"], + "fraction": [0.75, 0.25, 0.25, 0.75], + } + ) + + result = build_distribution_change( + condition_distribution, + reference_condition="NS", + ) + + assert list(result.columns) == [ + "condition", + "cluster", + "count", + "fraction", + "replicate_n", + "reference_fraction", + "delta_fraction", + "log2_fc", + ] + assert result["count"].isna().all() + assert result["replicate_n"].isna().all() + + +def test_prepare_cluster_distribution_bar_data_returns_sorted_frame(): + cluster_distribution = pd.DataFrame( + { + "sample_id": ["s2", "s1"], + "condition": ["15min", "NS"], + "cluster": ["C1", "C0"], + "count": [1, 2], + "fraction": [1 / 3, 2 / 3], + } + ) + + result = prepare_cluster_distribution_bar_data(cluster_distribution) + + assert list(result.columns) == ["sample_id", "condition", "cluster", "count", "fraction"] + assert list(result["sample_id"]) == ["s1", "s2"] + assert list(result["cluster"]) == ["C0", "C1"] + + +def test_prepare_cluster_distribution_heatmap_data_pivots_conditions_and_clusters(): + condition_distribution = pd.DataFrame( + { + "condition": ["NS", "NS", "15min", "15min"], + "cluster": ["C0", "C1", "C0", "C1"], + "count": [3, 1, 1, 3], + "fraction": [0.75, 0.25, 0.25, 0.75], + "replicate_n": [2, 2, 2, 2], + } + ) + + result = prepare_cluster_distribution_heatmap_data(condition_distribution) + + assert list(result.columns) == ["condition", "C0", "C1"] + ns_row = result[result["condition"] == "NS"].iloc[0] + assert ns_row["C0"] == 0.75 + assert ns_row["C1"] == 0.25 From d6d200bd3637d958973666c0a69d80370a661392 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 13:17:14 -0700 Subject: [PATCH 020/272] feat: add read-global shared clustering workflow --- dimelo/__init__.py | 8 +- dimelo/cluster.py | 36 ++++ dimelo/workflows.py | 466 ++++++++++++++++++++++++++++++++++++++++ tests/test_workflows.py | 261 ++++++++++++++++++++++ 4 files changed, 770 insertions(+), 1 deletion(-) create mode 100644 dimelo/workflows.py create mode 100644 tests/test_workflows.py diff --git a/dimelo/__init__.py b/dimelo/__init__.py index a6ba361..3e27921 100644 --- a/dimelo/__init__.py +++ b/dimelo/__init__.py @@ -1,27 +1,33 @@ from . import ( cluster, + distribution, export, load_processed, - parse_bam, models, + parse_bam, + plotting, plot_depth_histogram, plot_depth_profile, plot_enrichment, plot_enrichment_profile, plot_read_browser, plot_reads, + workflows, ) __all__ = [ "cluster", + "distribution", "export", "load_processed", "models", "parse_bam", + "plotting", "plot_depth_histogram", "plot_depth_profile", "plot_enrichment", "plot_enrichment_profile", "plot_read_browser", "plot_reads", + "workflows", ] diff --git a/dimelo/cluster.py b/dimelo/cluster.py index 9d088a8..f750724 100644 --- a/dimelo/cluster.py +++ b/dimelo/cluster.py @@ -848,6 +848,40 @@ def _renumber_by_size(labels: np.ndarray, noise_label: int | None = None) -> np. return np.array(remapped, dtype=int) +def cluster_label_mapping( + labels_raw: np.ndarray, + labels_size_ordered: np.ndarray, +) -> dict[int, int]: + """ + Build a stable mapping from raw estimator labels to size-ordered labels. + """ + + mapping: dict[int, int] = {} + for raw_label, ordered_label in zip(labels_raw, labels_size_ordered): + raw = int(raw_label) + ordered = int(ordered_label) + if raw in mapping and mapping[raw] != ordered: + raise ValueError("Raw cluster labels map to multiple size-ordered labels.") + mapping[raw] = ordered + return mapping + + +def apply_cluster_label_mapping( + labels: np.ndarray, + mapping: dict[int, int], + *, + unknown_label: int = -1, +) -> np.ndarray: + """ + Apply a raw-to-size-ordered label mapping to new assignments. + """ + + return np.array( + [mapping.get(int(label), unknown_label) for label in np.asarray(labels)], + dtype=int, + ) + + def sample_rows( data: np.ndarray, labels: Sequence[Any] | None = None, @@ -2128,5 +2162,7 @@ def _dominance_and_entropy(row: pd.Series) -> tuple[int, float, float]: "plot_classification_profiles", "plot_confusion_matrices", "sample_rows", + "cluster_label_mapping", + "apply_cluster_label_mapping", "plot_multisite_read_raster", ] diff --git a/dimelo/workflows.py b/dimelo/workflows.py new file mode 100644 index 0000000..2ed2b8b --- /dev/null +++ b/dimelo/workflows.py @@ -0,0 +1,466 @@ +from __future__ import annotations + +from pathlib import Path +from typing import Any, Iterable + +import numpy as np +import pandas as pd + +from .artifacts import resolve_artifact +from . import cluster, distribution, plotting +from .models import DatasetArtifact, SampleSpec, SharedClusterModel, SharedClusterResult + +_SUPPORTED_SIGNAL_NORMALIZATION = {"none", "per_sample_global", "control_regions"} +_SUPPORTED_FEATURE_SCALING = {"none", "robust_zscore"} +_SUPPORTED_CLUSTER_BASIS = {"shape_only", "shape_plus_level", "level_only"} +_PACKAGE_VERSION = "1.0.0" +_PREDICTION_CHUNK_SIZE = 100_000 +_LEVEL_FEATURES = { + "global_mean", + "global_var", + "global_median", + "q25", + "q75", + "iqr", + "global_mod_fraction", +} + + +def _source_fingerprint(path: Path) -> dict[str, Any]: + if path.exists(): + stat = path.stat() + return { + "path": str(path), + "size": stat.st_size, + "mtime_ns": stat.st_mtime_ns, + } + return {"path": str(path), "missing": True} + + +def _serialize_region_spec(region_spec: Any) -> Any: + if region_spec is None: + return None + if isinstance(region_spec, (str, Path)): + return str(region_spec) + if isinstance(region_spec, list): + return [str(item) if isinstance(item, Path) else item for item in region_spec] + return region_spec + + +def _coerce_artifacts(sample: SampleSpec) -> list[DatasetArtifact]: + if not sample.metadata: + return [] + artifacts = sample.metadata.get("artifacts", []) + coerced: list[DatasetArtifact] = [] + for artifact in artifacts: + if isinstance(artifact, DatasetArtifact): + coerced.append(artifact) + elif isinstance(artifact, dict): + coerced.append(DatasetArtifact(**artifact)) + return coerced + + +def _requested_extract_artifact( + sample: SampleSpec, + *, + motifs: list[str], + matched_regions: Any, + signal_normalization: str, + feature_scaling: str, + cluster_basis: str, + window_size: int | None = None, +) -> DatasetArtifact: + extract_path = Path(sample.extract_h5) + return DatasetArtifact( + sample_id=sample.sample_id, + artifact_type="extract", + path=extract_path, + format=extract_path.suffix.lstrip(".") or "h5", + params={ + "motifs": motifs, + "matched_regions": _serialize_region_spec(matched_regions), + "window_size": window_size, + "signal_normalization": signal_normalization, + "feature_scaling": feature_scaling, + "cluster_basis": cluster_basis, + }, + provenance={ + "pipeline": "parse_bam", + "source_files": [str(extract_path)], + "source_fingerprints": [_source_fingerprint(extract_path)], + "upstream_lineage": [], + }, + metadata={ + "schema_version": "artifact-v1", + "package_version": _PACKAGE_VERSION, + }, + ) + + +def _normalize_read_windows( + result: cluster.ReadWindowExtractionResult, + *, + signal_normalization: str, + control_result: cluster.ReadWindowExtractionResult | None = None, +) -> tuple[cluster.ReadWindowExtractionResult, dict[str, float | None]]: + if signal_normalization == "none": + return result, {"global_offset": None} + if signal_normalization not in {"per_sample_global", "control_regions"}: + raise ValueError(f"Unsupported signal_normalization: {signal_normalization}") + + data_matrix = np.asarray(result.data_matrix, dtype=float) + val_matrix = None if result.val_matrix is None else np.asarray(result.val_matrix, dtype=float) + offset_source = result if signal_normalization == "per_sample_global" else control_result + if offset_source is None: + raise ValueError("control_regions normalization requires control-region read windows.") + offset_matrix = np.asarray(offset_source.data_matrix, dtype=float) + offset_val_matrix = ( + None if offset_source.val_matrix is None else np.asarray(offset_source.val_matrix, dtype=float) + ) + if offset_val_matrix is not None and offset_val_matrix.sum() > 0: + global_offset = float(offset_matrix.sum() / offset_val_matrix.sum()) + else: + global_offset = float(offset_matrix.mean()) + + normalized = cluster.ReadWindowExtractionResult( + data_matrix=data_matrix - global_offset, + val_matrix=val_matrix, + metadata=list(result.metadata), + datasets=list(result.datasets), + regions_dict=result.regions_dict, + ) + return normalized, {"global_offset": global_offset} + + +def _select_feature_columns( + feature_matrix: np.ndarray, + feature_names: list[str], + *, + cluster_basis: str, +) -> tuple[np.ndarray, list[str]]: + if cluster_basis not in _SUPPORTED_CLUSTER_BASIS: + raise ValueError(f"Unsupported cluster_basis: {cluster_basis}") + if cluster_basis == "shape_plus_level": + return feature_matrix, feature_names + + if cluster_basis == "shape_only": + keep = [name not in _LEVEL_FEATURES for name in feature_names] + else: + keep = [name in _LEVEL_FEATURES for name in feature_names] + + selected_names = [name for name, keep_name in zip(feature_names, keep) if keep_name] + if not selected_names: + raise ValueError(f"No features available for cluster_basis={cluster_basis!r}.") + selected_matrix = feature_matrix[:, keep] + return selected_matrix, selected_names + + +def _scale_features( + training_matrix: np.ndarray, + full_matrix: np.ndarray, + *, + feature_scaling: str, +) -> tuple[np.ndarray, np.ndarray, dict[str, Any]]: + if feature_scaling == "none": + return training_matrix, full_matrix, {"scaler": None} + if feature_scaling != "robust_zscore": + raise ValueError(f"Unsupported feature_scaling: {feature_scaling}") + + from sklearn.preprocessing import RobustScaler + + scaler = RobustScaler() + training_scaled = scaler.fit_transform(training_matrix) + full_scaled = scaler.transform(full_matrix) + return training_scaled, full_scaled, {"scaler": "RobustScaler"} + + +def _cluster_label_strings(labels: np.ndarray) -> list[str]: + values = [] + for label in np.asarray(labels): + label_int = int(label) + values.append("noise" if label_int < 0 else f"C{label_int}") + return values + + +def _cluster_profiles( + feature_frame: pd.DataFrame, + assignments: pd.DataFrame, +) -> pd.DataFrame: + profiles = feature_frame.copy() + profiles["cluster"] = assignments["cluster"].to_numpy() + aggregated = profiles.groupby("cluster", sort=True).mean(numeric_only=True).reset_index() + counts = assignments.groupby("cluster", sort=True).size().reset_index(name="count") + return counts.merge(aggregated, on="cluster", how="left") + + +def _sample_training_rows( + feature_matrix: np.ndarray, + *, + training_sample_per_dataset: int, + random_state: int, +) -> tuple[np.ndarray, np.ndarray]: + if training_sample_per_dataset <= 0: + raise ValueError("training_sample_per_dataset must be positive.") + if feature_matrix.shape[0] <= training_sample_per_dataset: + indices = np.arange(feature_matrix.shape[0], dtype=int) + return feature_matrix, indices + sampled_matrix, _, indices = cluster.sample_rows( + feature_matrix, + n=training_sample_per_dataset, + random_state=random_state, + ) + return sampled_matrix, indices + + +def _predict_in_chunks(model: Any, feature_matrix: np.ndarray) -> np.ndarray: + labels: list[np.ndarray] = [] + for start in range(0, feature_matrix.shape[0], _PREDICTION_CHUNK_SIZE): + stop = start + _PREDICTION_CHUNK_SIZE + labels.append(np.asarray(model.predict(feature_matrix[start:stop]))) + return np.concatenate(labels, axis=0) + + +def shared_cluster_distribution( + *, + samples: Iterable[SampleSpec], + mode: str, + motifs: Iterable[str], + matched_regions: str | None = None, + signal_normalization: str = "none", + feature_scaling: str = "robust_zscore", + cluster_basis: str = "shape_plus_level", + clusterer: str = "minibatch_kmeans", + n_clusters: int = 8, + training_sample_per_dataset: int = 100_000, + artifact_policy: str = "prefer_cached", + random_state: int = 42, + make_plots: bool = True, +) -> SharedClusterResult: + """ + Fit one shared clustering model on pooled read windows and assign all reads back + onto those fixed cluster boundaries. + """ + + sample_list = list(samples) + motif_list = list(motifs) + if not sample_list: + raise ValueError("samples must contain at least one sample.") + if not motif_list: + raise ValueError("motifs must contain at least one motif.") + if mode != "read_global": + raise NotImplementedError("The first workflow slice implements mode='read_global' only.") + if len(sample_list) < 2: + raise ValueError("shared_cluster_distribution requires at least two datasets.") + if clusterer != "minibatch_kmeans": + raise NotImplementedError( + "The first workflow slice supports clusterer='minibatch_kmeans' only." + ) + if signal_normalization not in _SUPPORTED_SIGNAL_NORMALIZATION: + raise ValueError(f"Unsupported signal_normalization: {signal_normalization}") + if feature_scaling not in _SUPPORTED_FEATURE_SCALING: + raise ValueError(f"Unsupported feature_scaling: {feature_scaling}") + if cluster_basis not in _SUPPORTED_CLUSTER_BASIS: + raise ValueError(f"Unsupported cluster_basis: {cluster_basis}") + + feature_blocks: list[np.ndarray] = [] + metadata_rows: list[dict[str, Any]] = [] + training_blocks: list[np.ndarray] = [] + selected_feature_names: list[str] | None = None + sample_training_rows: dict[str, int] = {} + sample_dataset_sizes: dict[str, int] = {} + sample_normalization: dict[str, dict[str, float | None]] = {} + cache_hits: dict[str, str] = {} + cache_misses: list[str] = [] + sample_rebuild_decisions: dict[str, str] = {} + + for sample_index, sample in enumerate(sample_list): + requested_artifact = _requested_extract_artifact( + sample, + motifs=motif_list, + matched_regions=matched_regions, + signal_normalization=signal_normalization, + feature_scaling=feature_scaling, + cluster_basis=cluster_basis, + ) + resolved_artifact = resolve_artifact( + requested_artifact, + _coerce_artifacts(sample), + artifact_policy=artifact_policy, + ) + extract_path = sample.extract_h5 + if resolved_artifact is not None: + extract_path = resolved_artifact.path + cache_hits[sample.sample_id] = str(resolved_artifact.path) + sample_rebuild_decisions[sample.sample_id] = "cache_hit" + else: + cache_misses.append(sample.sample_id) + sample_rebuild_decisions[sample.sample_id] = "rebuilt_from_raw" + + extracted = cluster.extract_read_windows( + hdf5_file=extract_path, + motifs=motif_list, + regions=matched_regions, + ) + control_result = None + if signal_normalization == "control_regions": + control_regions = sample.regions_bed or matched_regions + if control_regions is None: + raise ValueError( + "signal_normalization='control_regions' requires sample.regions_bed " + "or matched_regions." + ) + control_artifact = _requested_extract_artifact( + sample, + motifs=motif_list, + matched_regions=control_regions, + signal_normalization=signal_normalization, + feature_scaling=feature_scaling, + cluster_basis=cluster_basis, + ) + resolved_control_artifact = resolve_artifact( + control_artifact, + _coerce_artifacts(sample), + artifact_policy=artifact_policy, + ) + control_path = ( + resolved_control_artifact.path + if resolved_control_artifact is not None + else extract_path + ) + control_result = cluster.extract_read_windows( + hdf5_file=control_path, + motifs=motif_list, + regions=control_regions, + ) + extracted, normalization_meta = _normalize_read_windows( + extracted, + signal_normalization=signal_normalization, + control_result=control_result, + ) + sample_normalization[sample.sample_id] = normalization_meta + + feature_matrix, feature_names = cluster.read_window_feature_matrix(extracted) + feature_matrix, feature_names = _select_feature_columns( + feature_matrix, + feature_names, + cluster_basis=cluster_basis, + ) + if selected_feature_names is None: + selected_feature_names = feature_names + elif selected_feature_names != feature_names: + raise ValueError("Feature names must match across all samples.") + + feature_blocks.append(feature_matrix) + sample_dataset_sizes[sample.sample_id] = int(feature_matrix.shape[0]) + training_matrix, _ = _sample_training_rows( + feature_matrix, + training_sample_per_dataset=training_sample_per_dataset, + random_state=random_state + sample_index, + ) + training_blocks.append(training_matrix) + sample_training_rows[sample.sample_id] = int(training_matrix.shape[0]) + + for metadata in extracted.metadata: + row = { + "sample_id": sample.sample_id, + "condition": sample.condition, + "replicate": sample.replicate, + } + row.update(metadata) + metadata_rows.append(row) + + if selected_feature_names is None: + raise ValueError("No features were generated for the requested samples.") + + full_matrix = np.vstack(feature_blocks) + training_matrix = np.vstack(training_blocks) + if training_matrix.shape[0] < n_clusters: + raise ValueError( + "Pooled training subset has fewer rows than n_clusters. " + "Reduce n_clusters or increase training_sample_per_dataset." + ) + + training_scaled, full_scaled, scaler_meta = _scale_features( + training_matrix, + full_matrix, + feature_scaling=feature_scaling, + ) + clustering_result = cluster.cluster_read_windows( + training_scaled, + method=clusterer, + n_clusters=n_clusters, + random_state=random_state, + ) + label_mapping = cluster.cluster_label_mapping( + clustering_result.labels_raw, + clustering_result.labels_size_ordered, + ) + if not hasattr(clustering_result.model, "predict"): + raise TypeError("Fitted clustering model does not support prediction for full assignment.") + predicted_raw = _predict_in_chunks(clustering_result.model, full_scaled) + predicted_ordered = cluster.apply_cluster_label_mapping(predicted_raw, label_mapping) + + assignments = pd.DataFrame(metadata_rows) + assignments["cluster"] = _cluster_label_strings(predicted_ordered) + + feature_frame = pd.DataFrame(full_matrix, columns=selected_feature_names) + cluster_distribution = distribution.build_cluster_distribution(assignments) + condition_distribution = distribution.build_condition_distribution(cluster_distribution) + cluster_profiles = _cluster_profiles(feature_frame, assignments) + plot_data = { + "cluster_distribution_bar": plotting.prepare_cluster_distribution_bar_data( + cluster_distribution + ), + "cluster_distribution_heatmap": plotting.prepare_cluster_distribution_heatmap_data( + condition_distribution + ), + } + + model = SharedClusterModel( + mode=mode, + motifs=motif_list, + feature_names=list(selected_feature_names), + preprocessing={ + "signal_normalization": signal_normalization, + "feature_scaling": feature_scaling, + "cluster_basis": cluster_basis, + **scaler_meta, + }, + estimator=clustering_result.model, + cluster_labels=sorted(assignments["cluster"].unique()), + fit_metadata={ + "clusterer": clusterer, + "n_clusters": n_clusters, + "artifact_policy": artifact_policy, + "training_sample_per_dataset": training_sample_per_dataset, + "training_rows": int(training_scaled.shape[0]), + "sample_training_rows": sample_training_rows, + "metrics": clustering_result.metrics, + }, + ) + return SharedClusterResult( + model=model, + assignments=assignments, + cluster_distribution=cluster_distribution, + condition_distribution=condition_distribution, + distribution_change=None, + cluster_profiles=cluster_profiles, + region_summaries=None, + plot_data=plot_data, + figures={}, + metadata={ + "mode": mode, + "artifact_policy": artifact_policy, + "cache_hits": cache_hits, + "cache_misses": cache_misses, + "sample_rebuild_decisions": sample_rebuild_decisions, + "signal_normalization": signal_normalization, + "feature_scaling": feature_scaling, + "cluster_basis": cluster_basis, + "make_plots": make_plots, + "matched_regions": matched_regions, + "sample_dataset_sizes": sample_dataset_sizes, + "rows_after_filtering": sample_dataset_sizes, + "sample_normalization": sample_normalization, + }, + ) diff --git a/tests/test_workflows.py b/tests/test_workflows.py new file mode 100644 index 0000000..1342757 --- /dev/null +++ b/tests/test_workflows.py @@ -0,0 +1,261 @@ +import numpy as np +import pandas as pd +import pytest + +from dimelo import workflows +from dimelo.models import DatasetArtifact +from dimelo.models import SampleSpec + + +def test_shared_cluster_distribution_read_global(monkeypatch): + fake_samples = [ + SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5"), + SampleSpec(sample_id="s2", condition="15min", extract_h5="s2.h5"), + ] + + def fake_extract(*args, **kwargs): + hdf5_file = kwargs["hdf5_file"] + + class R: + if hdf5_file == "s1.h5": + data_matrix = np.array([[0.0, 0.0, 0.1, 0.1], [0.0, 0.1, 0.0, 0.1]]) + metadata = [ + {"read_name": "s1-r1", "chromosome": "chr1", "region_start": 0, "region_end": 4}, + {"read_name": "s1-r2", "chromosome": "chr1", "region_start": 10, "region_end": 14}, + ] + else: + data_matrix = np.array([[1.0, 0.9, 1.0, 0.9], [0.9, 1.0, 0.9, 1.0]]) + metadata = [ + {"read_name": "s2-r1", "chromosome": "chr1", "region_start": 20, "region_end": 24}, + {"read_name": "s2-r2", "chromosome": "chr1", "region_start": 30, "region_end": 34}, + ] + val_matrix = np.ones((2, 4), dtype=float) + datasets = [] + regions_dict = None + + return R() + + def fake_features(result, **kwargs): + return result.data_matrix, ["f0", "f1", "f2", "f3"] + + monkeypatch.setattr(workflows.cluster, "extract_read_windows", fake_extract) + monkeypatch.setattr(workflows.cluster, "read_window_feature_matrix", fake_features) + + result = workflows.shared_cluster_distribution( + samples=fake_samples, + mode="read_global", + motifs=["A,0"], + n_clusters=2, + training_sample_per_dataset=2, + make_plots=False, + ) + + assert not result.assignments.empty + assert not result.cluster_distribution.empty + assert not result.condition_distribution.empty + assert not result.cluster_profiles.empty + assert set(result.assignments["sample_id"]) == {"s1", "s2"} + assert "replicate" in result.assignments.columns + assert "cluster_distribution_bar" in result.plot_data + assert "cluster_distribution_heatmap" in result.plot_data + assert result.metadata["artifact_policy"] == "prefer_cached" + assert set(result.metadata["cache_misses"]) == {"s1", "s2"} + + +def test_shared_cluster_distribution_rejects_unsupported_mode(): + with pytest.raises(NotImplementedError, match="read_global"): + workflows.shared_cluster_distribution( + samples=[SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5")], + mode="region_anchored", + motifs=["A,0"], + ) + + +def test_shared_cluster_distribution_requires_two_datasets(): + with pytest.raises(ValueError, match="at least two datasets"): + workflows.shared_cluster_distribution( + samples=[SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5")], + mode="read_global", + motifs=["A,0"], + ) + + +def test_shared_cluster_distribution_tracks_condition_replicates(monkeypatch): + fake_samples = [ + SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5"), + SampleSpec(sample_id="s2", condition="NS", extract_h5="s2.h5"), + SampleSpec(sample_id="s3", condition="15min", extract_h5="s3.h5"), + ] + + matrices = { + "s1.h5": np.array([[0.0, 0.0], [0.0, 0.1]]), + "s2.h5": np.array([[0.1, 0.0], [0.0, 0.0]]), + "s3.h5": np.array([[1.0, 1.0], [0.9, 1.0]]), + } + + def fake_extract(*args, **kwargs): + data = matrices[kwargs["hdf5_file"]] + + class R: + data_matrix = data + val_matrix = np.ones_like(data) + metadata = [ + {"read_name": f"{kwargs['hdf5_file']}-r1", "chromosome": "chr1", "region_start": 0, "region_end": 2}, + {"read_name": f"{kwargs['hdf5_file']}-r2", "chromosome": "chr1", "region_start": 2, "region_end": 4}, + ] + datasets = [] + regions_dict = None + + return R() + + monkeypatch.setattr(workflows.cluster, "extract_read_windows", fake_extract) + monkeypatch.setattr( + workflows.cluster, + "read_window_feature_matrix", + lambda result, **kwargs: (result.data_matrix, ["f0", "f1"]), + ) + + result = workflows.shared_cluster_distribution( + samples=fake_samples, + mode="read_global", + motifs=["A,0"], + n_clusters=2, + training_sample_per_dataset=2, + ) + + ns_rows = result.condition_distribution[result.condition_distribution["condition"] == "NS"] + assert set(ns_rows["replicate_n"]) == {2} + + +def test_shared_cluster_distribution_prefers_cached_extract_artifact(monkeypatch): + cached_artifact = DatasetArtifact( + sample_id="s1", + artifact_type="extract", + path="cached-s1.h5", + format="h5", + params={ + "motifs": ["A,0"], + "matched_regions": None, + "window_size": None, + "signal_normalization": "none", + "feature_scaling": "robust_zscore", + "cluster_basis": "shape_plus_level", + }, + provenance={ + "pipeline": "parse_bam", + "source_files": ["s1.h5"], + "source_fingerprints": [{"path": "s1.h5", "missing": True}], + "upstream_lineage": [], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.0.0"}, + ) + fake_samples = [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + metadata={"artifacts": [cached_artifact]}, + ), + SampleSpec(sample_id="s2", condition="15min", extract_h5="s2.h5"), + ] + seen_paths = [] + + def fake_extract(*args, **kwargs): + seen_paths.append(kwargs["hdf5_file"]) + + class R: + data_matrix = np.array([[0.0, 0.0], [1.0, 1.0]]) + val_matrix = np.ones((2, 2), dtype=float) + metadata = [ + {"read_name": "r1", "chromosome": "chr1", "region_start": 0, "region_end": 2}, + {"read_name": "r2", "chromosome": "chr1", "region_start": 2, "region_end": 4}, + ] + datasets = [] + regions_dict = None + + return R() + + monkeypatch.setattr(workflows.cluster, "extract_read_windows", fake_extract) + monkeypatch.setattr( + workflows.cluster, + "read_window_feature_matrix", + lambda result, **kwargs: (result.data_matrix, ["f0", "f1"]), + ) + + result = workflows.shared_cluster_distribution( + samples=fake_samples, + mode="read_global", + motifs=["A,0"], + n_clusters=2, + training_sample_per_dataset=2, + ) + + assert seen_paths[0] == "cached-s1.h5" + assert result.metadata["cache_hits"]["s1"] == "cached-s1.h5" + + +def test_shared_cluster_distribution_rebuilds_when_source_fingerprint_mismatches(monkeypatch): + stale_artifact = DatasetArtifact( + sample_id="s1", + artifact_type="extract", + path="cached-s1.h5", + format="h5", + params={ + "motifs": ["A,0"], + "matched_regions": None, + "window_size": None, + "signal_normalization": "none", + "feature_scaling": "robust_zscore", + "cluster_basis": "shape_plus_level", + }, + provenance={ + "pipeline": "parse_bam", + "source_files": ["s1.h5"], + "source_fingerprints": [{"path": "s1.h5", "size": 123, "mtime_ns": 1}], + "upstream_lineage": [], + }, + metadata={"schema_version": "artifact-v1", "package_version": "1.0.0"}, + ) + fake_samples = [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + metadata={"artifacts": [stale_artifact]}, + ), + SampleSpec(sample_id="s2", condition="15min", extract_h5="s2.h5"), + ] + seen_paths = [] + + def fake_extract(*args, **kwargs): + seen_paths.append(kwargs["hdf5_file"]) + + class R: + data_matrix = np.array([[0.0, 0.0], [1.0, 1.0]]) + val_matrix = np.ones((2, 2), dtype=float) + metadata = [ + {"read_name": "r1", "chromosome": "chr1", "region_start": 0, "region_end": 2}, + {"read_name": "r2", "chromosome": "chr1", "region_start": 2, "region_end": 4}, + ] + datasets = [] + regions_dict = None + + return R() + + monkeypatch.setattr(workflows.cluster, "extract_read_windows", fake_extract) + monkeypatch.setattr( + workflows.cluster, + "read_window_feature_matrix", + lambda result, **kwargs: (result.data_matrix, ["f0", "f1"]), + ) + + result = workflows.shared_cluster_distribution( + samples=fake_samples, + mode="read_global", + motifs=["A,0"], + n_clusters=2, + training_sample_per_dataset=2, + ) + + assert seen_paths[0] == "s1.h5" + assert "s1" not in result.metadata["cache_hits"] From 266fc48662f7da68275ffc6ac57dcf9cc060ef90 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 13:31:56 -0700 Subject: [PATCH 021/272] feat: add region-anchored shared clustering workflow --- dimelo/__init__.py | 2 + dimelo/region_analysis.py | 73 +++++++ dimelo/workflows.py | 440 ++++++++++++++++++++++++++++++-------- tests/test_cluster.py | 71 +++--- tests/test_workflows.py | 181 +++++++++++++++- 5 files changed, 642 insertions(+), 125 deletions(-) create mode 100644 dimelo/region_analysis.py diff --git a/dimelo/__init__.py b/dimelo/__init__.py index 3e27921..f3deef6 100644 --- a/dimelo/__init__.py +++ b/dimelo/__init__.py @@ -12,6 +12,7 @@ plot_enrichment_profile, plot_read_browser, plot_reads, + region_analysis, workflows, ) @@ -29,5 +30,6 @@ "plot_enrichment_profile", "plot_read_browser", "plot_reads", + "region_analysis", "workflows", ] diff --git a/dimelo/region_analysis.py b/dimelo/region_analysis.py new file mode 100644 index 0000000..e5e9248 --- /dev/null +++ b/dimelo/region_analysis.py @@ -0,0 +1,73 @@ +from __future__ import annotations + +from pathlib import Path +from typing import Sequence + +import numpy as np + +from . import cluster +from .models import SampleSpec + + +def build_region_feature_table( + *, + samples: Sequence[SampleSpec], + motifs: Sequence[str], + matched_regions: str | Path | list[str | Path] | None, + pileup_paths: dict[str, str | Path] | None = None, +) -> tuple[np.ndarray, list[dict[str, object]]]: + """ + Build one region-level feature row per sample and matched region. + """ + + if not motifs: + raise ValueError("motifs must contain at least one motif.") + if len(motifs) != 1: + raise ValueError( + "build_region_feature_table currently supports exactly one motif for " + "region_anchored mode." + ) + + matrices: list[np.ndarray] = [] + metadata_rows: list[dict[str, object]] = [] + + for sample in samples: + pileup_path = None + if pileup_paths is not None: + pileup_path = pileup_paths.get(sample.sample_id) + if pileup_path is None: + if not sample.metadata or "pileup_path" not in sample.metadata: + raise ValueError( + f"Sample {sample.sample_id!r} is missing a pileup_path for region_anchored mode." + ) + pileup_path = sample.metadata["pileup_path"] + + regions = matched_regions or sample.regions_bed + if regions is None: + raise ValueError( + f"Sample {sample.sample_id!r} requires matched_regions or regions_bed." + ) + + matrix, region_metadata = cluster.region_feature_matrix_from_pileup( + bedmethyl_file=pileup_path, + motif=motifs[0], + regions=regions, + ) + matrices.append(np.asarray(matrix, dtype=np.float32)) + for chrom, start, end, strand in region_metadata: + metadata_rows.append( + { + "sample_id": sample.sample_id, + "condition": sample.condition, + "replicate": sample.replicate, + "region_id": f"{chrom}:{start}-{end}:{strand}", + "chromosome": chrom, + "start": start, + "end": end, + "strand": strand, + } + ) + + if not matrices: + raise ValueError("No region feature rows were generated.") + return np.vstack(matrices).astype(np.float32, copy=False), metadata_rows diff --git a/dimelo/workflows.py b/dimelo/workflows.py index 2ed2b8b..4391e7f 100644 --- a/dimelo/workflows.py +++ b/dimelo/workflows.py @@ -7,7 +7,7 @@ import pandas as pd from .artifacts import resolve_artifact -from . import cluster, distribution, plotting +from . import cluster, distribution, plotting, region_analysis from .models import DatasetArtifact, SampleSpec, SharedClusterModel, SharedClusterResult _SUPPORTED_SIGNAL_NORMALIZATION = {"none", "per_sample_global", "control_regions"} @@ -97,6 +97,53 @@ def _requested_extract_artifact( ) +def _requested_pileup_artifact( + sample: SampleSpec, + *, + motifs: list[str], + matched_regions: Any, + signal_normalization: str, + feature_scaling: str, + cluster_basis: str, +) -> DatasetArtifact: + if not sample.metadata or "pileup_path" not in sample.metadata: + raise ValueError( + f"Sample {sample.sample_id!r} is missing metadata['pileup_path'] for region_anchored mode." + ) + pileup_path = Path(sample.metadata["pileup_path"]) + return DatasetArtifact( + sample_id=sample.sample_id, + artifact_type="pileup", + path=pileup_path, + format=pileup_path.suffix.lstrip(".") or "bed.gz", + params={ + "motifs": motifs, + "matched_regions": _serialize_region_spec(matched_regions), + "signal_normalization": signal_normalization, + "feature_scaling": feature_scaling, + "cluster_basis": cluster_basis, + }, + provenance={ + "pipeline": "parse_bam", + "source_files": [str(pileup_path)], + "source_fingerprints": [_source_fingerprint(pileup_path)], + "upstream_lineage": [], + }, + metadata={ + "schema_version": "artifact-v1", + "package_version": _PACKAGE_VERSION, + }, + ) + + +def _require_pileup_path(sample: SampleSpec) -> str | Path: + if sample.metadata and "pileup_path" in sample.metadata: + return sample.metadata["pileup_path"] + raise ValueError( + f"Sample {sample.sample_id!r} is missing metadata['pileup_path'] for region_anchored mode." + ) + + def _normalize_read_windows( result: cluster.ReadWindowExtractionResult, *, @@ -220,6 +267,142 @@ def _predict_in_chunks(model: Any, feature_matrix: np.ndarray) -> np.ndarray: return np.concatenate(labels, axis=0) +def _build_region_summary(assignments: pd.DataFrame) -> pd.DataFrame: + summary = ( + assignments.groupby( + ["region_id", "sample_id", "condition", "cluster"], + sort=True, + ) + .size() + .reset_index(name="count") + ) + totals = summary.groupby(["region_id", "sample_id", "condition"])["count"].transform("sum") + summary["fraction"] = summary["count"] / totals + return summary + + +def _build_shared_cluster_result( + *, + mode: str, + motifs: list[str], + feature_blocks: list[np.ndarray], + training_blocks: list[np.ndarray], + metadata_rows: list[dict[str, Any]], + feature_names: list[str], + signal_normalization: str, + feature_scaling: str, + cluster_basis: str, + clusterer: str, + n_clusters: int, + training_sample_per_dataset: int, + artifact_policy: str, + random_state: int, + make_plots: bool, + matched_regions: Any, + sample_training_rows: dict[str, int], + sample_dataset_sizes: dict[str, int], + sample_normalization: dict[str, dict[str, float | None]], + cache_hits: dict[str, str], + cache_misses: list[str], + sample_rebuild_decisions: dict[str, str], + region_summaries: pd.DataFrame | None = None, +) -> SharedClusterResult: + full_matrix = np.vstack(feature_blocks) + training_matrix = np.vstack(training_blocks) + if training_matrix.shape[0] < n_clusters: + raise ValueError( + "Pooled training subset has fewer rows than n_clusters. " + "Reduce n_clusters or increase training_sample_per_dataset." + ) + + training_scaled, full_scaled, scaler_meta = _scale_features( + training_matrix, + full_matrix, + feature_scaling=feature_scaling, + ) + clustering_result = cluster.cluster_read_windows( + training_scaled, + method=clusterer, + n_clusters=n_clusters, + random_state=random_state, + ) + label_mapping = cluster.cluster_label_mapping( + clustering_result.labels_raw, + clustering_result.labels_size_ordered, + ) + if not hasattr(clustering_result.model, "predict"): + raise TypeError("Fitted clustering model does not support prediction for full assignment.") + predicted_raw = _predict_in_chunks(clustering_result.model, full_scaled) + predicted_ordered = cluster.apply_cluster_label_mapping(predicted_raw, label_mapping) + + assignments = pd.DataFrame(metadata_rows) + assignments["cluster"] = _cluster_label_strings(predicted_ordered) + + feature_frame = pd.DataFrame(full_matrix, columns=feature_names) + cluster_distribution = distribution.build_cluster_distribution(assignments) + condition_distribution = distribution.build_condition_distribution(cluster_distribution) + cluster_profiles = _cluster_profiles(feature_frame, assignments) + plot_data = { + "cluster_distribution_bar": plotting.prepare_cluster_distribution_bar_data( + cluster_distribution + ), + "cluster_distribution_heatmap": plotting.prepare_cluster_distribution_heatmap_data( + condition_distribution + ), + } + if region_summaries is None and mode == "region_anchored": + region_summaries = _build_region_summary(assignments) + + model = SharedClusterModel( + mode=mode, + motifs=motifs, + feature_names=list(feature_names), + preprocessing={ + "signal_normalization": signal_normalization, + "feature_scaling": feature_scaling, + "cluster_basis": cluster_basis, + **scaler_meta, + }, + estimator=clustering_result.model, + cluster_labels=sorted(assignments["cluster"].unique()), + fit_metadata={ + "clusterer": clusterer, + "n_clusters": n_clusters, + "artifact_policy": artifact_policy, + "training_sample_per_dataset": training_sample_per_dataset, + "training_rows": int(training_scaled.shape[0]), + "sample_training_rows": sample_training_rows, + "metrics": clustering_result.metrics, + }, + ) + return SharedClusterResult( + model=model, + assignments=assignments, + cluster_distribution=cluster_distribution, + condition_distribution=condition_distribution, + distribution_change=None, + cluster_profiles=cluster_profiles, + region_summaries=region_summaries, + plot_data=plot_data, + figures={}, + metadata={ + "mode": mode, + "artifact_policy": artifact_policy, + "cache_hits": cache_hits, + "cache_misses": cache_misses, + "sample_rebuild_decisions": sample_rebuild_decisions, + "signal_normalization": signal_normalization, + "feature_scaling": feature_scaling, + "cluster_basis": cluster_basis, + "make_plots": make_plots, + "matched_regions": matched_regions, + "sample_dataset_sizes": sample_dataset_sizes, + "rows_after_filtering": sample_dataset_sizes, + "sample_normalization": sample_normalization, + }, + ) + + def shared_cluster_distribution( *, samples: Iterable[SampleSpec], @@ -247,8 +430,11 @@ def shared_cluster_distribution( raise ValueError("samples must contain at least one sample.") if not motif_list: raise ValueError("motifs must contain at least one motif.") - if mode != "read_global": - raise NotImplementedError("The first workflow slice implements mode='read_global' only.") + if mode not in {"read_global", "region_anchored"}: + raise NotImplementedError( + "The first workflow slice implements mode='read_global' and " + "mode='region_anchored' only." + ) if len(sample_list) < 2: raise ValueError("shared_cluster_distribution requires at least two datasets.") if clusterer != "minibatch_kmeans": @@ -262,6 +448,145 @@ def shared_cluster_distribution( if cluster_basis not in _SUPPORTED_CLUSTER_BASIS: raise ValueError(f"Unsupported cluster_basis: {cluster_basis}") + if mode == "region_anchored": + pileup_paths: dict[str, str | Path] = {} + cache_hits: dict[str, str] = {} + cache_misses: list[str] = [] + sample_rebuild_decisions: dict[str, str] = {} + + for sample in sample_list: + requested_artifact = _requested_pileup_artifact( + sample, + motifs=motif_list, + matched_regions=matched_regions, + signal_normalization=signal_normalization, + feature_scaling=feature_scaling, + cluster_basis=cluster_basis, + ) + resolved_artifact = resolve_artifact( + requested_artifact, + _coerce_artifacts(sample), + artifact_policy=artifact_policy, + ) + if resolved_artifact is not None: + pileup_paths[sample.sample_id] = resolved_artifact.path + cache_hits[sample.sample_id] = str(resolved_artifact.path) + sample_rebuild_decisions[sample.sample_id] = "cache_hit" + else: + pileup_paths[sample.sample_id] = _require_pileup_path(sample) + cache_misses.append(sample.sample_id) + sample_rebuild_decisions[sample.sample_id] = "rebuilt_from_raw" + + feature_matrix, metadata_rows = region_analysis.build_region_feature_table( + samples=sample_list, + motifs=motif_list, + matched_regions=matched_regions, + pileup_paths=pileup_paths, + ) + sample_ids = [row["sample_id"] for row in metadata_rows] + sample_dataset_sizes = { + sample_id: int(sum(1 for row_sample in sample_ids if row_sample == sample_id)) + for sample_id in {sample.sample_id for sample in sample_list} + } + sample_normalization = { + sample.sample_id: {"global_offset": None} for sample in sample_list + } + region_matrix = np.asarray(feature_matrix, dtype=float) + if signal_normalization in {"per_sample_global", "control_regions"}: + for sample_id in sample_dataset_sizes: + mask = np.array([row["sample_id"] == sample_id for row in metadata_rows], dtype=bool) + if signal_normalization == "control_regions": + sample = next( + sample_item for sample_item in sample_list if sample_item.sample_id == sample_id + ) + control_regions = sample.regions_bed + if control_regions is None or control_regions == matched_regions: + raise ValueError( + "signal_normalization='control_regions' in region_anchored mode " + "requires sample.regions_bed to provide separate control regions." + ) + control_artifact = _requested_pileup_artifact( + sample, + motifs=motif_list, + matched_regions=control_regions, + signal_normalization=signal_normalization, + feature_scaling=feature_scaling, + cluster_basis=cluster_basis, + ) + resolved_control_artifact = resolve_artifact( + control_artifact, + _coerce_artifacts(sample), + artifact_policy=artifact_policy, + ) + control_path = ( + resolved_control_artifact.path + if resolved_control_artifact is not None + else _require_pileup_path(sample) + ) + control_matrix, _ = region_analysis.build_region_feature_table( + samples=[sample], + motifs=motif_list, + matched_regions=control_regions, + pileup_paths={sample.sample_id: control_path}, + ) + offset = float(np.asarray(control_matrix, dtype=float).mean()) + else: + offset = float(region_matrix[mask].mean()) + region_matrix[mask] = region_matrix[mask] - offset + sample_normalization[sample_id] = {"global_offset": offset} + + if cluster_basis == "shape_only": + region_matrix = region_matrix - region_matrix.mean(axis=1, keepdims=True) + feature_names = [f"shape_{idx}" for idx in range(region_matrix.shape[1])] + elif cluster_basis == "level_only": + region_matrix = region_matrix.mean(axis=1, keepdims=True) + feature_names = ["region_mean_mod_fraction"] + else: + feature_names = [f"pos_{idx}" for idx in range(region_matrix.shape[1])] + + feature_blocks: list[np.ndarray] = [] + training_blocks: list[np.ndarray] = [] + sample_training_rows: dict[str, int] = {} + for sample in sample_list: + mask = np.array( + [row["sample_id"] == sample.sample_id for row in metadata_rows], + dtype=bool, + ) + sample_matrix = region_matrix[mask] + feature_blocks.append(sample_matrix) + training_matrix, _ = _sample_training_rows( + sample_matrix, + training_sample_per_dataset=training_sample_per_dataset, + random_state=random_state + len(training_blocks), + ) + training_blocks.append(training_matrix) + sample_training_rows[sample.sample_id] = int(training_matrix.shape[0]) + + return _build_shared_cluster_result( + mode=mode, + motifs=motif_list, + feature_blocks=feature_blocks, + training_blocks=training_blocks, + metadata_rows=metadata_rows, + feature_names=feature_names, + signal_normalization=signal_normalization, + feature_scaling=feature_scaling, + cluster_basis=cluster_basis, + clusterer=clusterer, + n_clusters=n_clusters, + training_sample_per_dataset=training_sample_per_dataset, + artifact_policy=artifact_policy, + random_state=random_state, + make_plots=make_plots, + matched_regions=matched_regions, + sample_training_rows=sample_training_rows, + sample_dataset_sizes=sample_dataset_sizes, + sample_normalization=sample_normalization, + cache_hits=cache_hits, + cache_misses=cache_misses, + sample_rebuild_decisions=sample_rebuild_decisions, + ) + feature_blocks: list[np.ndarray] = [] metadata_rows: list[dict[str, Any]] = [] training_blocks: list[np.ndarray] = [] @@ -371,96 +696,27 @@ def shared_cluster_distribution( if selected_feature_names is None: raise ValueError("No features were generated for the requested samples.") - - full_matrix = np.vstack(feature_blocks) - training_matrix = np.vstack(training_blocks) - if training_matrix.shape[0] < n_clusters: - raise ValueError( - "Pooled training subset has fewer rows than n_clusters. " - "Reduce n_clusters or increase training_sample_per_dataset." - ) - - training_scaled, full_scaled, scaler_meta = _scale_features( - training_matrix, - full_matrix, - feature_scaling=feature_scaling, - ) - clustering_result = cluster.cluster_read_windows( - training_scaled, - method=clusterer, - n_clusters=n_clusters, - random_state=random_state, - ) - label_mapping = cluster.cluster_label_mapping( - clustering_result.labels_raw, - clustering_result.labels_size_ordered, - ) - if not hasattr(clustering_result.model, "predict"): - raise TypeError("Fitted clustering model does not support prediction for full assignment.") - predicted_raw = _predict_in_chunks(clustering_result.model, full_scaled) - predicted_ordered = cluster.apply_cluster_label_mapping(predicted_raw, label_mapping) - - assignments = pd.DataFrame(metadata_rows) - assignments["cluster"] = _cluster_label_strings(predicted_ordered) - - feature_frame = pd.DataFrame(full_matrix, columns=selected_feature_names) - cluster_distribution = distribution.build_cluster_distribution(assignments) - condition_distribution = distribution.build_condition_distribution(cluster_distribution) - cluster_profiles = _cluster_profiles(feature_frame, assignments) - plot_data = { - "cluster_distribution_bar": plotting.prepare_cluster_distribution_bar_data( - cluster_distribution - ), - "cluster_distribution_heatmap": plotting.prepare_cluster_distribution_heatmap_data( - condition_distribution - ), - } - - model = SharedClusterModel( + return _build_shared_cluster_result( mode=mode, motifs=motif_list, + feature_blocks=feature_blocks, + training_blocks=training_blocks, + metadata_rows=metadata_rows, feature_names=list(selected_feature_names), - preprocessing={ - "signal_normalization": signal_normalization, - "feature_scaling": feature_scaling, - "cluster_basis": cluster_basis, - **scaler_meta, - }, - estimator=clustering_result.model, - cluster_labels=sorted(assignments["cluster"].unique()), - fit_metadata={ - "clusterer": clusterer, - "n_clusters": n_clusters, - "artifact_policy": artifact_policy, - "training_sample_per_dataset": training_sample_per_dataset, - "training_rows": int(training_scaled.shape[0]), - "sample_training_rows": sample_training_rows, - "metrics": clustering_result.metrics, - }, - ) - return SharedClusterResult( - model=model, - assignments=assignments, - cluster_distribution=cluster_distribution, - condition_distribution=condition_distribution, - distribution_change=None, - cluster_profiles=cluster_profiles, - region_summaries=None, - plot_data=plot_data, - figures={}, - metadata={ - "mode": mode, - "artifact_policy": artifact_policy, - "cache_hits": cache_hits, - "cache_misses": cache_misses, - "sample_rebuild_decisions": sample_rebuild_decisions, - "signal_normalization": signal_normalization, - "feature_scaling": feature_scaling, - "cluster_basis": cluster_basis, - "make_plots": make_plots, - "matched_regions": matched_regions, - "sample_dataset_sizes": sample_dataset_sizes, - "rows_after_filtering": sample_dataset_sizes, - "sample_normalization": sample_normalization, - }, + signal_normalization=signal_normalization, + feature_scaling=feature_scaling, + cluster_basis=cluster_basis, + clusterer=clusterer, + n_clusters=n_clusters, + training_sample_per_dataset=training_sample_per_dataset, + artifact_policy=artifact_policy, + random_state=random_state, + make_plots=make_plots, + matched_regions=matched_regions, + sample_training_rows=sample_training_rows, + sample_dataset_sizes=sample_dataset_sizes, + sample_normalization=sample_normalization, + cache_hits=cache_hits, + cache_misses=cache_misses, + sample_rebuild_decisions=sample_rebuild_decisions, ) diff --git a/tests/test_cluster.py b/tests/test_cluster.py index 74cc39a..7332993 100644 --- a/tests/test_cluster.py +++ b/tests/test_cluster.py @@ -236,36 +236,36 @@ def fake_loader(**kwargs): assert result.metadata[0]["read_name"] == "keep" - def test_read_window_feature_matrix(): - data = np.array( - [ - [0, 0, 1, 1], - [1, 1, 0, 0], - [0, 1, 0, 1], - ], - dtype=float, - ) - result = cluster.ReadWindowExtractionResult( - data_matrix=data, - val_matrix=None, - metadata=[], - datasets=[], - regions_dict=None, - ) - features, names = cluster.read_window_feature_matrix( - result, - n_pca=1, - autocorr_lags=(1,), - density_windows=(("center", -2, 2),), - require_nonzero_valid=False, - min_valid_fraction=0.0, - ) - assert features.shape[0] == 3 - assert "pca_0" in names - assert "autocorr_1" in names - assert "center" in names - assert "global_mean" in names - assert "iqr" in names +def test_read_window_feature_matrix(): + data = np.array( + [ + [0, 0, 1, 1], + [1, 1, 0, 0], + [0, 1, 0, 1], + ], + dtype=float, + ) + result = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=[], + datasets=[], + regions_dict=None, + ) + features, names = cluster.read_window_feature_matrix( + result, + n_pca=1, + autocorr_lags=(1,), + density_windows=(("center", -2, 2),), + require_nonzero_valid=False, + min_valid_fraction=0.0, + ) + assert features.shape[0] == 3 + assert "pca_0" in names + assert "autocorr_1" in names + assert "center" in names + assert "global_mean" in names + assert "iqr" in names def test_plot_cluster_profiles_motif_index(monkeypatch): @@ -370,3 +370,14 @@ def test_cluster_read_windows_kmeans(): assert result.labels_raw.shape[0] == 20 assert result.labels_size_ordered.shape == result.labels_raw.shape assert "silhouette" in result.metrics + + +def test_cluster_label_mapping_round_trips_labels(): + labels_raw = np.array([3, 3, 7, 7, 7]) + labels_size_ordered = np.array([1, 1, 0, 0, 0]) + + mapping = cluster.cluster_label_mapping(labels_raw, labels_size_ordered) + remapped = cluster.apply_cluster_label_mapping(np.array([7, 3, 9]), mapping) + + assert mapping == {3: 1, 7: 0} + np.testing.assert_array_equal(remapped, np.array([0, 1, -1])) diff --git a/tests/test_workflows.py b/tests/test_workflows.py index 1342757..bfcf0b9 100644 --- a/tests/test_workflows.py +++ b/tests/test_workflows.py @@ -63,10 +63,13 @@ def fake_features(result, **kwargs): def test_shared_cluster_distribution_rejects_unsupported_mode(): - with pytest.raises(NotImplementedError, match="read_global"): + with pytest.raises(NotImplementedError, match="region_anchored"): workflows.shared_cluster_distribution( - samples=[SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5")], - mode="region_anchored", + samples=[ + SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5"), + SampleSpec(sample_id="s2", condition="15min", extract_h5="s2.h5"), + ], + mode="unknown_mode", motifs=["A,0"], ) @@ -80,6 +83,67 @@ def test_shared_cluster_distribution_requires_two_datasets(): ) +def test_shared_cluster_distribution_region_anchored(monkeypatch): + fake_samples = [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + regions_bed="r1.bed", + metadata={"pileup_path": "s1.bed.gz"}, + ), + SampleSpec( + sample_id="s2", + condition="15min", + extract_h5="s2.h5", + regions_bed="r2.bed", + metadata={"pileup_path": "s2.bed.gz"}, + ), + ] + + def fake_region_table(*args, **kwargs): + return np.array([[0.2, 0.8], [0.7, 0.3]]), [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "replicate": None, + "chromosome": "chr1", + "start": 0, + "end": 2, + "strand": "+", + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "15min", + "replicate": None, + "chromosome": "chr1", + "start": 0, + "end": 2, + "strand": "+", + }, + ] + + monkeypatch.setattr(workflows.region_analysis, "build_region_feature_table", fake_region_table) + + result = workflows.shared_cluster_distribution( + samples=fake_samples, + mode="region_anchored", + motifs=["A,0"], + matched_regions="matched.bed", + n_clusters=2, + make_plots=False, + ) + + assert not result.assignments.empty + assert "region_id" in result.assignments.columns + assert result.region_summaries is not None + assert {"region_id", "sample_id", "condition", "cluster", "count", "fraction"} <= set( + result.region_summaries.columns + ) + + def test_shared_cluster_distribution_tracks_condition_replicates(monkeypatch): fake_samples = [ SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5"), @@ -127,6 +191,117 @@ class R: assert set(ns_rows["replicate_n"]) == {2} +def test_shared_cluster_distribution_region_anchored_rejects_multi_motif(monkeypatch): + fake_samples = [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + regions_bed="r1.bed", + metadata={"pileup_path": "s1.bed.gz"}, + ), + SampleSpec( + sample_id="s2", + condition="15min", + extract_h5="s2.h5", + regions_bed="r2.bed", + metadata={"pileup_path": "s2.bed.gz"}, + ), + ] + + with pytest.raises(ValueError, match="exactly one motif"): + workflows.shared_cluster_distribution( + samples=fake_samples, + mode="region_anchored", + motifs=["A,0", "CG,0"], + matched_regions="matched.bed", + ) + + +def test_shared_cluster_distribution_region_anchored_control_regions(monkeypatch): + fake_samples = [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + regions_bed="control-s1.bed", + metadata={"pileup_path": "s1.bed.gz"}, + ), + SampleSpec( + sample_id="s2", + condition="15min", + extract_h5="s2.h5", + regions_bed="control-s2.bed", + metadata={"pileup_path": "s2.bed.gz"}, + ), + ] + + def fake_region_table(*args, **kwargs): + matched_regions = kwargs["matched_regions"] + if matched_regions == "matched.bed": + return np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32), [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "replicate": None, + "chromosome": "chr1", + "start": 0, + "end": 2, + "strand": "+", + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "15min", + "replicate": None, + "chromosome": "chr1", + "start": 0, + "end": 2, + "strand": "+", + }, + ] + if matched_regions == "control-s1.bed": + return np.array([[0.5, 0.5]], dtype=np.float32), [ + { + "region_id": "c1", + "sample_id": "s1", + "condition": "NS", + "replicate": None, + "chromosome": "chr1", + "start": 10, + "end": 12, + "strand": "+", + } + ] + return np.array([[0.25, 0.25]], dtype=np.float32), [ + { + "region_id": "c2", + "sample_id": "s2", + "condition": "15min", + "replicate": None, + "chromosome": "chr1", + "start": 20, + "end": 22, + "strand": "+", + } + ] + + monkeypatch.setattr(workflows.region_analysis, "build_region_feature_table", fake_region_table) + + result = workflows.shared_cluster_distribution( + samples=fake_samples, + mode="region_anchored", + motifs=["A,0"], + matched_regions="matched.bed", + signal_normalization="control_regions", + n_clusters=2, + ) + + assert result.metadata["sample_normalization"]["s1"]["global_offset"] == 0.5 + assert result.metadata["sample_normalization"]["s2"]["global_offset"] == 0.25 + + def test_shared_cluster_distribution_prefers_cached_extract_artifact(monkeypatch): cached_artifact = DatasetArtifact( sample_id="s1", From 558d4d50f35809abd841d7a71e57ed9a791b6e78 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 13:33:01 -0700 Subject: [PATCH 022/272] docs: add shared clustering workflow guide --- README.md | 21 +++++++++ docs/shared-clustering.md | 93 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 114 insertions(+) create mode 100644 docs/shared-clustering.md diff --git a/README.md b/README.md index a9fc91e..078e2d5 100644 --- a/README.md +++ b/README.md @@ -856,6 +856,27 @@ def regions_to_list( `dimelo.cluster` wraps the loading utilities above so you can quickly build matrices for downstream clustering or dimensionality reduction. +For the higher-level shared-boundary workflows added on top of these loaders, see [docs/shared-clustering.md](docs/shared-clustering.md). The short version is: + +- run `parse_bam.extract()` for `mode="read_global"` +- run `parse_bam.pileup()` for `mode="region_anchored"` +- run both when you want region-level summaries plus read-level follow-up + +```python +from dimelo import workflows +from dimelo.models import SampleSpec + +result = workflows.shared_cluster_distribution( + samples=[ + SampleSpec(sample_id="s1", condition="NS", extract_h5="output/s1.extract.h5"), + SampleSpec(sample_id="s2", condition="15min", extract_h5="output/s2.extract.h5"), + ], + mode="read_global", + motifs=["A,0"], + n_clusters=8, +) +``` + ``` from dimelo import cluster diff --git a/docs/shared-clustering.md b/docs/shared-clustering.md new file mode 100644 index 0000000..fd1ebc1 --- /dev/null +++ b/docs/shared-clustering.md @@ -0,0 +1,93 @@ +# Shared Clustering + +`dimelo.workflows.shared_cluster_distribution()` provides a higher-level shared-boundary workflow on top of the existing parsing layer. It does not replace `parse_bam.extract()` or `parse_bam.pileup()`; it consumes those outputs and returns canonical tables that you can plot with Matplotlib, seaborn, Plotly, Altair, or your own stack. + +## Preprocessing Choices + +- Run `parse_bam.extract()` when you want read-level clustering or single-read pattern analysis. +- Run `parse_bam.pileup()` when you want matched-region clustering from pileup-derived summaries. +- Run both when you want region-level summaries plus read-level follow-up on the same samples. + +## Workflow Entry Point + +### Read-global clustering + +```python +from dimelo import workflows +from dimelo.models import SampleSpec + +result = workflows.shared_cluster_distribution( + samples=[ + SampleSpec(sample_id="s1", condition="NS", extract_h5="output/s1.extract.h5"), + SampleSpec(sample_id="s2", condition="15min", extract_h5="output/s2.extract.h5"), + ], + mode="read_global", + motifs=["A,0"], + n_clusters=8, +) +``` + +### Region-anchored clustering + +```python +from dimelo import workflows +from dimelo.models import SampleSpec + +result = workflows.shared_cluster_distribution( + samples=[ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="output/s1.extract.h5", + regions_bed="controls/s1_controls.bed", + metadata={"pileup_path": "output/s1.pileup.sorted.bed.gz"}, + ), + SampleSpec( + sample_id="s2", + condition="15min", + extract_h5="output/s2.extract.h5", + regions_bed="controls/s2_controls.bed", + metadata={"pileup_path": "output/s2.pileup.sorted.bed.gz"}, + ), + ], + mode="region_anchored", + motifs=["A,0"], + matched_regions="matched_regions.bed", + n_clusters=6, +) +``` + +## Canonical Outputs + +The workflow returns a `SharedClusterResult` with canonical tables: + +- `result.assignments` +- `result.cluster_distribution` +- `result.condition_distribution` +- `result.cluster_profiles` +- `result.region_summaries` for `region_anchored` +- `result.plot_data` + +Built-in plotting remains intentionally thin. `result.plot_data["cluster_distribution_bar"]` and `result.plot_data["cluster_distribution_heatmap"]` are plot-ready DataFrames, not renderer-specific figure objects. + +## Custom Plotting + +```python +import seaborn as sns + +bar_data = result.plot_data["cluster_distribution_bar"] +sns.barplot(data=bar_data, x="sample_id", y="fraction", hue="cluster") +``` + +For heatmaps: + +```python +heatmap = result.plot_data["cluster_distribution_heatmap"].set_index("condition") +``` + +## Current V1 Scope + +- `mode="read_global"` supports shared read clustering from extract outputs. +- `mode="region_anchored"` supports matched-region clustering from pileup-derived region vectors. +- The default supported clusterer is `minibatch_kmeans`. +- Results are data-first: tables are the stable contract, while plotting is optional. From 3386ef16021e217410783e3e3cbbde4b03c45121 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 13:52:48 -0700 Subject: [PATCH 023/272] feat: add region contrast models --- dimelo/models.py | 55 ++++++++++++++++++++++++++++++++++++++++++++ tests/test_models.py | 38 ++++++++++++++++++++++++++++++ 2 files changed, 93 insertions(+) diff --git a/dimelo/models.py b/dimelo/models.py index 790d826..00a381a 100644 --- a/dimelo/models.py +++ b/dimelo/models.py @@ -32,6 +32,38 @@ def __post_init__(self) -> None: raise ValueError("DatasetArtifact.provenance cannot be None") +@dataclass +class ContrastSpec: + mode: str + numerator: list[str] | None = None + denominator: list[str] | None = None + background: list[str] | None = None + time_order: list[str] | None = None + pairing_key: str | None = None + reference_condition: str | None = None + metadata: dict[str, Any] | None = None + + def __post_init__(self) -> None: + allowed_modes = { + "single_dataset", + "pairwise", + "matched_pairwise", + "group_vs_group", + "background_adjusted", + "time_course", + } + if self.mode not in allowed_modes: + raise ValueError(f"Unsupported contrast mode: {self.mode}") + if self.mode in {"pairwise", "group_vs_group"} and ( + not self.numerator or not self.denominator + ): + raise ValueError( + "ContrastSpec pairwise/group_vs_group modes require numerator and denominator." + ) + if self.mode == "time_course" and not self.time_order: + raise ValueError("ContrastSpec time_course mode requires time_order.") + + @dataclass class SharedClusterModel: mode: str @@ -72,6 +104,29 @@ def __post_init__(self) -> None: ) +@dataclass +class RegionContrastResult: + regions: pd.DataFrame + summary: pd.DataFrame + contrast: ContrastSpec + plot_data: dict[str, pd.DataFrame | dict[str, Any]] + metadata: dict[str, Any] = field(default_factory=dict) + figures: dict[str, Any] = field(default_factory=dict) + + def __post_init__(self) -> None: + required_fields = { + "regions": self.regions, + "summary": self.summary, + "plot_data": self.plot_data, + } + missing = [name for name, value in required_fields.items() if value is None] + if missing: + raise ValueError( + "RegionContrastResult requires non-None values for: " + f"{', '.join(missing)}" + ) + + @dataclass class CohortSpec: cohort_id: str diff --git a/tests/test_models.py b/tests/test_models.py index c5e26ee..c6e12e0 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -7,8 +7,10 @@ from dimelo.models import ( BatchJob, CohortSpec, + ContrastSpec, DatasetArtifact, SampleSpec, + RegionContrastResult, SharedClusterModel, SharedClusterResult, ) @@ -64,6 +66,25 @@ def test_dataset_artifact_rejects_none_provenance(): ) +def test_contrast_spec_accepts_pairwise_mode(): + contrast = ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + reference_condition="NS", + ) + + assert contrast.mode == "pairwise" + assert contrast.numerator == ["15min"] + assert contrast.denominator == ["NS"] + assert contrast.reference_condition == "NS" + + +def test_contrast_spec_rejects_missing_groups_for_pairwise(): + with pytest.raises(ValueError, match="numerator and denominator"): + ContrastSpec(mode="pairwise") + + def test_shared_cluster_result_supports_plot_data(): model = SharedClusterModel( mode="shared", @@ -129,6 +150,23 @@ def test_shared_cluster_result_rejects_none_core_outputs(field_name): SharedClusterResult(**kwargs) +def test_region_contrast_result_rejects_none_core_tables(): + contrast = ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + reference_condition="NS", + ) + + with pytest.raises(ValueError, match="regions, summary, plot_data"): + RegionContrastResult( + regions=None, + summary=None, + contrast=contrast, + plot_data=None, + ) + + def test_cohort_spec_stores_workflow_and_params(): cohort = CohortSpec( cohort_id="cohort-1", From baeeb21657c32d64d0059b4bfe0c8e45e45c3862 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 13:57:56 -0700 Subject: [PATCH 024/272] fix: tighten region contrast model validation --- dimelo/models.py | 9 +++++++++ tests/test_models.py | 28 ++++++++++++++++++++++++++++ 2 files changed, 37 insertions(+) diff --git a/dimelo/models.py b/dimelo/models.py index 00a381a..a4b9db7 100644 --- a/dimelo/models.py +++ b/dimelo/models.py @@ -60,6 +60,14 @@ def __post_init__(self) -> None: raise ValueError( "ContrastSpec pairwise/group_vs_group modes require numerator and denominator." ) + if self.mode == "matched_pairwise" and not self.pairing_key: + raise ValueError( + "ContrastSpec matched_pairwise mode requires pairing_key." + ) + if self.mode == "background_adjusted" and not self.background: + raise ValueError( + "ContrastSpec background_adjusted mode requires background." + ) if self.mode == "time_course" and not self.time_order: raise ValueError("ContrastSpec time_course mode requires time_order.") @@ -117,6 +125,7 @@ def __post_init__(self) -> None: required_fields = { "regions": self.regions, "summary": self.summary, + "contrast": self.contrast, "plot_data": self.plot_data, } missing = [name for name, value in required_fields.items() if value is None] diff --git a/tests/test_models.py b/tests/test_models.py index c6e12e0..c8d4f6a 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -85,6 +85,24 @@ def test_contrast_spec_rejects_missing_groups_for_pairwise(): ContrastSpec(mode="pairwise") +def test_contrast_spec_rejects_missing_pairing_key_for_matched_pairwise(): + with pytest.raises(ValueError, match="pairing_key"): + ContrastSpec( + mode="matched_pairwise", + numerator=["15min"], + denominator=["NS"], + ) + + +def test_contrast_spec_rejects_missing_background_for_background_adjusted(): + with pytest.raises(ValueError, match="background"): + ContrastSpec( + mode="background_adjusted", + numerator=["15min"], + denominator=["NS"], + ) + + def test_shared_cluster_result_supports_plot_data(): model = SharedClusterModel( mode="shared", @@ -167,6 +185,16 @@ def test_region_contrast_result_rejects_none_core_tables(): ) +def test_region_contrast_result_rejects_none_contrast(): + with pytest.raises(ValueError, match="contrast"): + RegionContrastResult( + regions=pd.DataFrame({"region": ["r1"]}), + summary=pd.DataFrame({"metric": [1.0]}), + contrast=None, + plot_data={"volcano": pd.DataFrame({"x": [1.0]})}, + ) + + def test_cohort_spec_stores_workflow_and_params(): cohort = CohortSpec( cohort_id="cohort-1", From c54610b0720bccef7abd7c1f21170865ac10d4bb Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 14:02:11 -0700 Subject: [PATCH 025/272] fix: harden model constructor validation --- dimelo/models.py | 10 ++++++++-- tests/test_models.py | 36 ++++++++++++++++++++++++++++++++++++ 2 files changed, 44 insertions(+), 2 deletions(-) diff --git a/dimelo/models.py b/dimelo/models.py index a4b9db7..24a7727 100644 --- a/dimelo/models.py +++ b/dimelo/models.py @@ -28,6 +28,8 @@ class DatasetArtifact: metadata: dict[str, Any] = field(default_factory=dict) def __post_init__(self) -> None: + if self.params is None: + raise ValueError("DatasetArtifact.params cannot be None") if self.provenance is None: raise ValueError("DatasetArtifact.provenance cannot be None") @@ -60,9 +62,12 @@ def __post_init__(self) -> None: raise ValueError( "ContrastSpec pairwise/group_vs_group modes require numerator and denominator." ) - if self.mode == "matched_pairwise" and not self.pairing_key: + if self.mode == "matched_pairwise" and ( + not self.numerator or not self.denominator or not self.pairing_key + ): raise ValueError( - "ContrastSpec matched_pairwise mode requires pairing_key." + "ContrastSpec matched_pairwise mode requires numerator, " + "denominator, and pairing_key." ) if self.mode == "background_adjusted" and not self.background: raise ValueError( @@ -98,6 +103,7 @@ class SharedClusterResult: def __post_init__(self) -> None: required_fields = { + "model": self.model, "assignments": self.assignments, "cluster_distribution": self.cluster_distribution, "condition_distribution": self.condition_distribution, diff --git a/tests/test_models.py b/tests/test_models.py index c8d4f6a..9474ecb 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -66,6 +66,18 @@ def test_dataset_artifact_rejects_none_provenance(): ) +def test_dataset_artifact_rejects_none_params(): + with pytest.raises(ValueError, match="params"): + DatasetArtifact( + sample_id="sample-1", + artifact_type="extract", + path=Path("sample-1.h5"), + format="hdf5", + params=None, + provenance={"pipeline": "parse_bam"}, + ) + + def test_contrast_spec_accepts_pairwise_mode(): contrast = ContrastSpec( mode="pairwise", @@ -94,6 +106,14 @@ def test_contrast_spec_rejects_missing_pairing_key_for_matched_pairwise(): ) +def test_contrast_spec_rejects_missing_groups_for_matched_pairwise(): + with pytest.raises(ValueError, match="matched_pairwise mode requires"): + ContrastSpec( + mode="matched_pairwise", + pairing_key="pair-1", + ) + + def test_contrast_spec_rejects_missing_background_for_background_adjusted(): with pytest.raises(ValueError, match="background"): ContrastSpec( @@ -130,6 +150,22 @@ def test_shared_cluster_result_supports_plot_data(): assert result.model is model +def test_shared_cluster_result_rejects_none_model(): + with pytest.raises(ValueError, match="model"): + SharedClusterResult( + model=None, + assignments=pd.DataFrame({"cluster": ["cluster-1"]}), + cluster_distribution=pd.DataFrame({"cluster": ["cluster-1"]}), + condition_distribution=pd.DataFrame({"condition": ["treated"]}), + distribution_change=None, + cluster_profiles=pd.DataFrame({"profile": [1.0]}), + region_summaries=None, + plot_data={"cluster_distribution_bar": {"kind": "bar"}}, + figures={}, + metadata={"notes": "ok"}, + ) + + @pytest.mark.parametrize( "field_name", [ From 065c9009e73d86269f0bff594e316556e7213737 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 14:17:16 -0700 Subject: [PATCH 026/272] test: cover contrast mode validation --- dimelo/models.py | 15 +++++++--- tests/test_models.py | 65 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 76 insertions(+), 4 deletions(-) diff --git a/dimelo/models.py b/dimelo/models.py index 24a7727..0c83e9a 100644 --- a/dimelo/models.py +++ b/dimelo/models.py @@ -32,6 +32,8 @@ def __post_init__(self) -> None: raise ValueError("DatasetArtifact.params cannot be None") if self.provenance is None: raise ValueError("DatasetArtifact.provenance cannot be None") + if self.metadata is None: + raise ValueError("DatasetArtifact.metadata cannot be None") @dataclass @@ -69,10 +71,15 @@ def __post_init__(self) -> None: "ContrastSpec matched_pairwise mode requires numerator, " "denominator, and pairing_key." ) - if self.mode == "background_adjusted" and not self.background: - raise ValueError( - "ContrastSpec background_adjusted mode requires background." - ) + if self.mode == "background_adjusted": + if not self.numerator or not self.denominator: + raise ValueError( + "ContrastSpec background_adjusted mode requires numerator and denominator." + ) + if not self.background: + raise ValueError( + "ContrastSpec background_adjusted mode requires background." + ) if self.mode == "time_course" and not self.time_order: raise ValueError("ContrastSpec time_course mode requires time_order.") diff --git a/tests/test_models.py b/tests/test_models.py index 9474ecb..0cc2ee2 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -54,6 +54,19 @@ def test_dataset_artifact_stores_metadata(): assert artifact.provenance == {"pipeline": "parse_bam"} +def test_dataset_artifact_rejects_none_metadata(): + with pytest.raises(ValueError, match="metadata"): + DatasetArtifact( + sample_id="sample-1", + artifact_type="extract", + path=Path("sample-1.h5"), + format="hdf5", + params={"window_size": 200}, + provenance={"pipeline": "parse_bam"}, + metadata=None, + ) + + def test_dataset_artifact_rejects_none_provenance(): with pytest.raises(ValueError): DatasetArtifact( @@ -92,11 +105,50 @@ def test_contrast_spec_accepts_pairwise_mode(): assert contrast.reference_condition == "NS" +def test_contrast_spec_accepts_group_vs_group_mode(): + contrast = ContrastSpec( + mode="group_vs_group", + numerator=["15min", "30min"], + denominator=["NS", "0min"], + ) + + assert contrast.mode == "group_vs_group" + assert contrast.numerator == ["15min", "30min"] + assert contrast.denominator == ["NS", "0min"] + + +def test_contrast_spec_accepts_background_adjusted_mode(): + contrast = ContrastSpec( + mode="background_adjusted", + numerator=["15min"], + denominator=["NS"], + background=["bg"], + ) + + assert contrast.mode == "background_adjusted" + assert contrast.background == ["bg"] + + +def test_contrast_spec_accepts_time_course_mode(): + contrast = ContrastSpec( + mode="time_course", + time_order=["NS", "15min", "30min"], + ) + + assert contrast.mode == "time_course" + assert contrast.time_order == ["NS", "15min", "30min"] + + def test_contrast_spec_rejects_missing_groups_for_pairwise(): with pytest.raises(ValueError, match="numerator and denominator"): ContrastSpec(mode="pairwise") +def test_contrast_spec_rejects_missing_groups_for_group_vs_group(): + with pytest.raises(ValueError, match="numerator and denominator"): + ContrastSpec(mode="group_vs_group", numerator=["15min"]) + + def test_contrast_spec_rejects_missing_pairing_key_for_matched_pairwise(): with pytest.raises(ValueError, match="pairing_key"): ContrastSpec( @@ -123,6 +175,19 @@ def test_contrast_spec_rejects_missing_background_for_background_adjusted(): ) +def test_contrast_spec_rejects_missing_groups_for_background_adjusted(): + with pytest.raises(ValueError, match="numerator and denominator"): + ContrastSpec( + mode="background_adjusted", + background=["bg"], + ) + + +def test_contrast_spec_rejects_missing_time_order_for_time_course(): + with pytest.raises(ValueError, match="time_order"): + ContrastSpec(mode="time_course") + + def test_shared_cluster_result_supports_plot_data(): model = SharedClusterModel( mode="shared", From bf499880ac635794ec9d5d731bda6276cabb168a Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 14:19:33 -0700 Subject: [PATCH 027/272] feat: add region contrast evidence builders --- dimelo/__init__.py | 2 + dimelo/region_contrasts.py | 106 +++++++++++++++++++++++++ tests/test_region_contrasts.py | 137 +++++++++++++++++++++++++++++++++ 3 files changed, 245 insertions(+) create mode 100644 dimelo/region_contrasts.py create mode 100644 tests/test_region_contrasts.py diff --git a/dimelo/__init__.py b/dimelo/__init__.py index f3deef6..84c4bae 100644 --- a/dimelo/__init__.py +++ b/dimelo/__init__.py @@ -13,6 +13,7 @@ plot_read_browser, plot_reads, region_analysis, + region_contrasts, workflows, ) @@ -31,5 +32,6 @@ "plot_read_browser", "plot_reads", "region_analysis", + "region_contrasts", "workflows", ] diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py new file mode 100644 index 0000000..bf1ad0f --- /dev/null +++ b/dimelo/region_contrasts.py @@ -0,0 +1,106 @@ +from __future__ import annotations + +from functools import partial +from typing import Iterable + +import pandas as pd + +from . import load_processed, utils + + +def validate_region_contrast_request( + *, + analysis_unit: str, + representation: str, + signal_source: str, + test: str, +) -> None: + if analysis_unit != "ensemble_region": + raise ValueError( + "V1 region_contrasts inference requires analysis_unit='ensemble_region'." + ) + if signal_source != "pileup_counts": + raise ValueError( + "V1 region_contrasts inference requires signal_source='pileup_counts'." + ) + if representation not in {"modified_fraction", "modified_count"}: + raise ValueError( + "V1 region_contrasts inference requires representation to be " + "'modified_fraction' or 'modified_count'." + ) + if test not in {"beta_binomial", "effect_size_only"}: + raise ValueError( + "V1 region_contrasts inference requires test to be " + "'beta_binomial' or 'effect_size_only'." + ) + + +def build_region_evidence_table( + *, + samples, + regions, + motifs: Iterable[str], + window_size: int | None = None, + quiet: bool = True, + cores: int | None = None, +) -> pd.DataFrame: + motifs = list(motifs) + if len(motifs) != 1: + raise ValueError("build_region_evidence_table currently supports exactly one motif.") + + motif = motifs[0] + regions_dict = utils.regions_dict_from_input(regions, window_size) + ordered_regions = [ + (chromosome, start, end, strand) + for chromosome, region_list in regions_dict.items() + for start, end, strand in region_list + ] + + rows = [] + for sample in samples: + metadata = sample.metadata or {} + if "pileup_path" not in metadata: + raise ValueError( + f"Sample {sample.sample_id} is missing metadata['pileup_path']." + ) + + pileup_loader = partial( + load_processed.pileup_counts_from_bedmethyl, + bedmethyl_file=metadata["pileup_path"], + motif=motif, + ) + counts_by_region = load_processed.regions_to_list( + function_handle=pileup_loader, + regions=regions, + window_size=window_size, + quiet=quiet, + cores=cores, + ) + + if len(counts_by_region) != len(ordered_regions): + raise ValueError( + "Pileup evidence count length did not match the number of parsed regions." + ) + + for (chromosome, start, end, strand), ( + modified_count, + valid_count, + ) in zip(ordered_regions, counts_by_region): + mod_fraction = 0.0 if valid_count == 0 else modified_count / valid_count + rows.append( + { + "region_id": f"{chromosome}:{start}-{end},{strand}", + "chromosome": chromosome, + "start": start, + "end": end, + "strand": strand, + "sample_id": sample.sample_id, + "condition": sample.condition, + "replicate": sample.replicate, + "modified_count": modified_count, + "valid_count": valid_count, + "mod_fraction": mod_fraction, + } + ) + + return pd.DataFrame(rows) diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py new file mode 100644 index 0000000..1e45d6e --- /dev/null +++ b/tests/test_region_contrasts.py @@ -0,0 +1,137 @@ +import pandas as pd +import pytest + +from dimelo import region_contrasts +from dimelo.models import SampleSpec + + +def test_validate_supported_v1_combination(): + region_contrasts.validate_region_contrast_request( + analysis_unit="ensemble_region", + representation="modified_fraction", + signal_source="pileup_counts", + test="beta_binomial", + ) + + +def test_validate_rejects_unsupported_single_read_beta_binomial(): + with pytest.raises(ValueError, match="analysis_unit='ensemble_region'"): + region_contrasts.validate_region_contrast_request( + analysis_unit="single_read", + representation="read_mod_fraction", + signal_source="pileup_counts", + test="beta_binomial", + ) + + +def test_build_region_evidence_table_from_pileup_counts(monkeypatch): + samples = [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + metadata={"pileup_path": "s1.bed.gz"}, + ), + SampleSpec( + sample_id="s2", + condition="15min", + extract_h5="s2.h5", + replicate=2, + metadata={"pileup_path": "s2.bed.gz"}, + ), + ] + + monkeypatch.setattr( + region_contrasts.utils, + "regions_dict_from_input", + lambda regions, window_size=None: { + "chr1": [(0, 10, "+")], + "chr2": [(20, 30, "-")], + }, + ) + + counts_by_file = { + "s1.bed.gz": [(2, 10), (0, 0)], + "s2.bed.gz": [(7, 10), (8, 10)], + } + + def fake_regions_to_list( + function_handle, + regions, + window_size, + quiet, + cores, + split_large_regions=False, + ): + return counts_by_file[function_handle.keywords["bedmethyl_file"]] + + monkeypatch.setattr( + region_contrasts.load_processed, + "regions_to_list", + fake_regions_to_list, + ) + + evidence = region_contrasts.build_region_evidence_table( + samples=samples, + regions="matched.bed", + motifs=["A,0"], + ) + + expected = pd.DataFrame( + [ + { + "region_id": "chr1:0-10,+", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "s1", + "condition": "NS", + "replicate": None, + "modified_count": 2, + "valid_count": 10, + "mod_fraction": 0.2, + }, + { + "region_id": "chr2:20-30,-", + "chromosome": "chr2", + "start": 20, + "end": 30, + "strand": "-", + "sample_id": "s1", + "condition": "NS", + "replicate": None, + "modified_count": 0, + "valid_count": 0, + "mod_fraction": 0.0, + }, + { + "region_id": "chr1:0-10,+", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "s2", + "condition": "15min", + "replicate": 2, + "modified_count": 7, + "valid_count": 10, + "mod_fraction": 0.7, + }, + { + "region_id": "chr2:20-30,-", + "chromosome": "chr2", + "start": 20, + "end": 30, + "strand": "-", + "sample_id": "s2", + "condition": "15min", + "replicate": 2, + "modified_count": 8, + "valid_count": 10, + "mod_fraction": 0.8, + }, + ] + ) + + pd.testing.assert_frame_equal(evidence.reset_index(drop=True), expected) From f18af40fe1709809476e08d2431f7d64be98f495 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 17:44:29 -0700 Subject: [PATCH 028/272] feat: add effect-size region contrast workflow --- dimelo/region_contrasts.py | 180 ++++++++++++++++++++++++++ tests/test_region_contrasts.py | 230 ++++++++++++++++++++++++++++++++- 2 files changed, 409 insertions(+), 1 deletion(-) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index bf1ad0f..632b8d3 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -1,11 +1,13 @@ from __future__ import annotations from functools import partial +import math from typing import Iterable import pandas as pd from . import load_processed, utils +from .models import ContrastSpec, RegionContrastResult def validate_region_contrast_request( @@ -104,3 +106,181 @@ def build_region_evidence_table( ) return pd.DataFrame(rows) + + +def _zero_safe_divide(numerator: pd.Series, denominator: pd.Series) -> pd.Series: + return numerator.div(denominator.where(denominator != 0), fill_value=0).fillna(0.0) + + +def _pool_region_groups(evidence: pd.DataFrame, contrast: ContrastSpec) -> pd.DataFrame: + if contrast.mode not in {"pairwise", "group_vs_group"}: + raise NotImplementedError( + f"Effect-size pooling is not implemented for contrast mode '{contrast.mode}'." + ) + + pooled_frames = [] + side_specs = { + "numerator": contrast.numerator or [], + "denominator": contrast.denominator or [], + } + + for side, conditions in side_specs.items(): + side_evidence = evidence.loc[evidence["condition"].isin(conditions)].copy() + pooled = ( + side_evidence.groupby( + ["region_id", "chromosome", "start", "end", "strand"], + dropna=False, + sort=False, + as_index=False, + ) + .agg( + modified_count=("modified_count", "sum"), + valid_count=("valid_count", "sum"), + replicate_n=("sample_id", "nunique"), + ) + .assign(contrast_side=side) + ) + pooled["fraction"] = _zero_safe_divide( + pooled["modified_count"], pooled["valid_count"] + ) + pooled_frames.append(pooled) + + return pd.concat(pooled_frames, ignore_index=True) + + +def score_regions( + *, + samples, + regions, + motifs, + contrast: ContrastSpec, + analysis_unit: str = "ensemble_region", + representation: str = "modified_fraction", + signal_source: str = "pileup_counts", + test: str = "beta_binomial", + multiple_testing: str = "fdr_bh", +) -> RegionContrastResult: + validate_region_contrast_request( + analysis_unit=analysis_unit, + representation=representation, + signal_source=signal_source, + test=test, + ) + evidence = build_region_evidence_table( + samples=samples, + regions=regions, + motifs=motifs, + ) + + if test != "effect_size_only": + raise NotImplementedError(f"score_regions does not yet implement test='{test}'.") + + pooled = _pool_region_groups(evidence=evidence, contrast=contrast) + numerator = ( + pooled.loc[pooled["contrast_side"] == "numerator"] + .drop(columns=["contrast_side"]) + .rename( + columns={ + "modified_count": "numerator_modified_count", + "valid_count": "numerator_valid_count", + "replicate_n": "numerator_replicate_n", + "fraction": "fraction", + } + ) + ) + denominator = ( + pooled.loc[pooled["contrast_side"] == "denominator"] + .drop(columns=["contrast_side"]) + .rename( + columns={ + "modified_count": "denominator_modified_count", + "valid_count": "denominator_valid_count", + "replicate_n": "denominator_replicate_n", + "fraction": "reference_fraction", + } + ) + ) + + merged = numerator.merge( + denominator, + on=["region_id", "chromosome", "start", "end", "strand"], + how="outer", + sort=False, + ) + + for column in [ + "numerator_modified_count", + "numerator_valid_count", + "numerator_replicate_n", + "denominator_modified_count", + "denominator_valid_count", + "denominator_replicate_n", + ]: + merged[column] = merged[column].fillna(0) + + merged["fraction"] = merged["fraction"].fillna(0.0) + merged["reference_fraction"] = merged["reference_fraction"].fillna(0.0) + merged["delta_fraction"] = merged["fraction"] - merged["reference_fraction"] + pseudocount = 1e-6 + merged["log2_fc"] = ( + (merged["fraction"] + pseudocount) / (merged["reference_fraction"] + pseudocount) + ).map(math.log2) + merged["abs_delta_fraction"] = merged["delta_fraction"].abs() + + integer_columns = [ + "numerator_modified_count", + "numerator_valid_count", + "numerator_replicate_n", + "denominator_modified_count", + "denominator_valid_count", + "denominator_replicate_n", + ] + merged[integer_columns] = merged[integer_columns].astype(int) + + regions_table = merged.sort_values( + by="abs_delta_fraction", + ascending=False, + kind="mergesort", + ).reset_index(drop=True) + regions_table["rank"] = range(1, len(regions_table) + 1) + + summary_columns = [ + "region_id", + "fraction", + "reference_fraction", + "delta_fraction", + "log2_fc", + "rank", + "numerator_modified_count", + "numerator_valid_count", + "numerator_replicate_n", + "denominator_modified_count", + "denominator_valid_count", + "denominator_replicate_n", + ] + summary = regions_table.loc[:, summary_columns].copy() + + contrast_metadata = contrast.metadata or {} + metadata = { + "contrast_mode": contrast.mode, + "analysis_unit": analysis_unit, + "representation": representation, + "signal_source": signal_source, + "test": test, + "multiple_testing": multiple_testing, + "normalization_mode": contrast_metadata.get("normalization_mode", "none"), + "biological_interpretation": contrast_metadata.get( + "biological_interpretation", + "region-level difference in pooled modified fraction", + ), + "renderer": contrast_metadata.get("renderer", "region_effect_sizes"), + } + + return RegionContrastResult( + regions=regions_table, + summary=summary, + contrast=contrast, + plot_data={"region_effect_sizes": summary.copy()}, + metadata=metadata, + figures={}, + ) diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index 1e45d6e..380e6f1 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -2,7 +2,7 @@ import pytest from dimelo import region_contrasts -from dimelo.models import SampleSpec +from dimelo.models import ContrastSpec, SampleSpec def test_validate_supported_v1_combination(): @@ -135,3 +135,231 @@ def fake_regions_to_list( ) pd.testing.assert_frame_equal(evidence.reset_index(drop=True), expected) + + +def test_score_regions_effect_size_only_pairwise_ranks_largest_delta_first(monkeypatch): + contrast = ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["control"], + ) + evidence = pd.DataFrame( + [ + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "n1", + "condition": "treated", + "replicate": 1, + "modified_count": 8, + "valid_count": 10, + "mod_fraction": 0.8, + }, + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "d1", + "condition": "control", + "replicate": 1, + "modified_count": 2, + "valid_count": 10, + "mod_fraction": 0.2, + }, + { + "region_id": "reg2", + "chromosome": "chr2", + "start": 10, + "end": 20, + "strand": "-", + "sample_id": "n1", + "condition": "treated", + "replicate": 1, + "modified_count": 6, + "valid_count": 10, + "mod_fraction": 0.6, + }, + { + "region_id": "reg2", + "chromosome": "chr2", + "start": 10, + "end": 20, + "strand": "-", + "sample_id": "d1", + "condition": "control", + "replicate": 1, + "modified_count": 4, + "valid_count": 10, + "mod_fraction": 0.4, + }, + ] + ) + + monkeypatch.setattr( + region_contrasts, + "build_region_evidence_table", + lambda **kwargs: evidence.copy(), + ) + + result = region_contrasts.score_regions( + samples=[], + regions="regions.bed", + motifs=["A,0"], + contrast=contrast, + test="effect_size_only", + ) + + expected_summary = pd.DataFrame( + [ + { + "region_id": "reg1", + "fraction": 0.8, + "reference_fraction": 0.2, + "delta_fraction": 0.6, + "rank": 1, + }, + { + "region_id": "reg2", + "fraction": 0.6, + "reference_fraction": 0.4, + "delta_fraction": 0.2, + "rank": 2, + }, + ] + ) + + actual_summary = result.summary[ + [ + "region_id", + "fraction", + "reference_fraction", + "delta_fraction", + "log2_fc", + "rank", + ] + ].reset_index(drop=True) + + pd.testing.assert_frame_equal( + actual_summary.drop(columns=["log2_fc"]), + expected_summary, + ) + assert actual_summary.loc[0, "log2_fc"] == pytest.approx(1.99999459) + assert actual_summary.loc[1, "log2_fc"] == pytest.approx(0.58496124) + assert list(result.regions["region_id"]) == ["reg1", "reg2"] + assert set(result.plot_data) == {"region_effect_sizes"} + assert result.metadata["contrast_mode"] == "pairwise" + + +def test_score_regions_effect_size_only_group_vs_group_pools_conditions(monkeypatch): + contrast = ContrastSpec( + mode="group_vs_group", + numerator=["treated_a", "treated_b"], + denominator=["control_a", "control_b"], + ) + evidence = pd.DataFrame( + [ + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "n1", + "condition": "treated_a", + "replicate": 1, + "modified_count": 4, + "valid_count": 10, + "mod_fraction": 0.4, + }, + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "n2", + "condition": "treated_b", + "replicate": 1, + "modified_count": 8, + "valid_count": 10, + "mod_fraction": 0.8, + }, + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "d1", + "condition": "control_a", + "replicate": 1, + "modified_count": 2, + "valid_count": 10, + "mod_fraction": 0.2, + }, + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "d2", + "condition": "control_b", + "replicate": 1, + "modified_count": 4, + "valid_count": 10, + "mod_fraction": 0.4, + }, + ] + ) + + monkeypatch.setattr( + region_contrasts, + "build_region_evidence_table", + lambda **kwargs: evidence.copy(), + ) + + result = region_contrasts.score_regions( + samples=[], + regions="regions.bed", + motifs=["A,0"], + contrast=contrast, + test="effect_size_only", + ) + + summary_row = result.summary.iloc[0] + assert summary_row["region_id"] == "reg1" + assert summary_row["fraction"] == pytest.approx(0.6) + assert summary_row["reference_fraction"] == pytest.approx(0.3) + assert summary_row["delta_fraction"] == pytest.approx(0.3) + assert summary_row["numerator_replicate_n"] == 2 + assert summary_row["denominator_replicate_n"] == 2 + + +def test_score_regions_effect_size_only_rejects_unsupported_contrast_mode(monkeypatch): + contrast = ContrastSpec( + mode="matched_pairwise", + numerator=["treated"], + denominator=["control"], + pairing_key="donor_id", + ) + + monkeypatch.setattr( + region_contrasts, + "build_region_evidence_table", + lambda **kwargs: pd.DataFrame(), + ) + + with pytest.raises(NotImplementedError, match="matched_pairwise"): + region_contrasts.score_regions( + samples=[], + regions="regions.bed", + motifs=["A,0"], + contrast=contrast, + test="effect_size_only", + ) From 0e63b25b0818e6267b65c9b10a40271b7b077af9 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 17:50:25 -0700 Subject: [PATCH 029/272] fix: harden effect-size region contrasts --- dimelo/region_contrasts.py | 25 ++++- tests/test_region_contrasts.py | 196 +++++++++++++++++++++++++++++++++ 2 files changed, 218 insertions(+), 3 deletions(-) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index 632b8d3..be6e965 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -126,6 +126,13 @@ def _pool_region_groups(evidence: pd.DataFrame, contrast: ContrastSpec) -> pd.Da for side, conditions in side_specs.items(): side_evidence = evidence.loc[evidence["condition"].isin(conditions)].copy() + available_conditions = set(side_evidence["condition"].dropna().unique()) + missing_conditions = sorted(set(conditions) - available_conditions) + if missing_conditions: + missing_display = ", ".join(missing_conditions) + raise ValueError( + f"Missing {side} evidence for requested condition(s): {missing_display}." + ) pooled = ( side_evidence.groupby( ["region_id", "chromosome", "start", "end", "strand"], @@ -157,7 +164,7 @@ def score_regions( analysis_unit: str = "ensemble_region", representation: str = "modified_fraction", signal_source: str = "pileup_counts", - test: str = "beta_binomial", + test: str = "effect_size_only", multiple_testing: str = "fdr_bh", ) -> RegionContrastResult: validate_region_contrast_request( @@ -225,7 +232,6 @@ def score_regions( merged["log2_fc"] = ( (merged["fraction"] + pseudocount) / (merged["reference_fraction"] + pseudocount) ).map(math.log2) - merged["abs_delta_fraction"] = merged["delta_fraction"].abs() integer_columns = [ "numerator_modified_count", @@ -237,8 +243,19 @@ def score_regions( ] merged[integer_columns] = merged[integer_columns].astype(int) + if representation == "modified_count": + merged["count"] = merged["numerator_modified_count"] + merged["reference_count"] = merged["denominator_modified_count"] + merged["delta_count"] = merged["count"] - merged["reference_count"] + merged["log2_fc_count"] = ( + (merged["count"] + pseudocount) / (merged["reference_count"] + pseudocount) + ).map(math.log2) + merged["effect_size"] = merged["delta_count"].abs() + else: + merged["effect_size"] = merged["delta_fraction"].abs() + regions_table = merged.sort_values( - by="abs_delta_fraction", + by="effect_size", ascending=False, kind="mergesort", ).reset_index(drop=True) @@ -258,6 +275,8 @@ def score_regions( "denominator_valid_count", "denominator_replicate_n", ] + if representation == "modified_count": + summary_columns.extend(["count", "reference_count", "delta_count", "log2_fc_count"]) summary = regions_table.loc[:, summary_columns].copy() contrast_metadata = contrast.metadata or {} diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index 380e6f1..fd0ca81 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -1,3 +1,5 @@ +import math + import pandas as pd import pytest @@ -255,6 +257,61 @@ def test_score_regions_effect_size_only_pairwise_ranks_largest_delta_first(monke assert result.metadata["contrast_mode"] == "pairwise" +def test_score_regions_defaults_to_effect_size_only(monkeypatch): + contrast = ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["control"], + ) + evidence = pd.DataFrame( + [ + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "n1", + "condition": "treated", + "replicate": 1, + "modified_count": 8, + "valid_count": 10, + "mod_fraction": 0.8, + }, + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "d1", + "condition": "control", + "replicate": 1, + "modified_count": 2, + "valid_count": 10, + "mod_fraction": 0.2, + }, + ] + ) + + monkeypatch.setattr( + region_contrasts, + "build_region_evidence_table", + lambda **kwargs: evidence.copy(), + ) + + result = region_contrasts.score_regions( + samples=[], + regions="regions.bed", + motifs=["A,0"], + contrast=contrast, + ) + + assert result.summary.loc[0, "region_id"] == "reg1" + assert result.summary.loc[0, "delta_fraction"] == pytest.approx(0.6) + assert result.metadata["test"] == "effect_size_only" + + def test_score_regions_effect_size_only_group_vs_group_pools_conditions(monkeypatch): contrast = ContrastSpec( mode="group_vs_group", @@ -341,6 +398,145 @@ def test_score_regions_effect_size_only_group_vs_group_pools_conditions(monkeypa assert summary_row["denominator_replicate_n"] == 2 +def test_score_regions_rejects_missing_denominator_condition(monkeypatch): + contrast = ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["cntrol"], + ) + evidence = pd.DataFrame( + [ + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "n1", + "condition": "treated", + "replicate": 1, + "modified_count": 8, + "valid_count": 10, + "mod_fraction": 0.8, + }, + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "d1", + "condition": "control", + "replicate": 1, + "modified_count": 2, + "valid_count": 10, + "mod_fraction": 0.2, + }, + ] + ) + + monkeypatch.setattr( + region_contrasts, + "build_region_evidence_table", + lambda **kwargs: evidence.copy(), + ) + + with pytest.raises(ValueError, match="denominator.*cntrol"): + region_contrasts.score_regions( + samples=[], + regions="regions.bed", + motifs=["A,0"], + contrast=contrast, + ) + + +def test_score_regions_modified_count_representation_ranks_by_delta_count(monkeypatch): + contrast = ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["control"], + ) + evidence = pd.DataFrame( + [ + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "n1", + "condition": "treated", + "replicate": 1, + "modified_count": 11, + "valid_count": 20, + "mod_fraction": 0.55, + }, + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "d1", + "condition": "control", + "replicate": 1, + "modified_count": 1, + "valid_count": 10, + "mod_fraction": 0.1, + }, + { + "region_id": "reg2", + "chromosome": "chr2", + "start": 10, + "end": 20, + "strand": "-", + "sample_id": "n1", + "condition": "treated", + "replicate": 1, + "modified_count": 7, + "valid_count": 10, + "mod_fraction": 0.7, + }, + { + "region_id": "reg2", + "chromosome": "chr2", + "start": 10, + "end": 20, + "strand": "-", + "sample_id": "d1", + "condition": "control", + "replicate": 1, + "modified_count": 0, + "valid_count": 5, + "mod_fraction": 0.0, + }, + ] + ) + + monkeypatch.setattr( + region_contrasts, + "build_region_evidence_table", + lambda **kwargs: evidence.copy(), + ) + + result = region_contrasts.score_regions( + samples=[], + regions="regions.bed", + motifs=["A,0"], + contrast=contrast, + representation="modified_count", + ) + + assert list(result.summary["region_id"]) == ["reg1", "reg2"] + assert list(result.summary["rank"]) == [1, 2] + assert result.summary.loc[0, "count"] == 11 + assert result.summary.loc[0, "reference_count"] == 1 + assert result.summary.loc[0, "delta_count"] == 10 + assert result.summary.loc[1, "delta_count"] == 7 + assert result.summary.loc[0, "log2_fc_count"] == pytest.approx(math.log2((11 + 1e-6) / (1 + 1e-6))) + assert result.metadata["representation"] == "modified_count" + + def test_score_regions_effect_size_only_rejects_unsupported_contrast_mode(monkeypatch): contrast = ContrastSpec( mode="matched_pairwise", From 59db7eaa7c3e645fe49018a2880bbdd4b0bfcfb4 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 17:57:03 -0700 Subject: [PATCH 030/272] fix: align region contrast effect-size validation --- dimelo/region_contrasts.py | 8 +--- tests/test_region_contrasts.py | 87 +++++++++++++++++++++++++++++++++- 2 files changed, 88 insertions(+), 7 deletions(-) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index be6e965..a67c5ed 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -30,10 +30,9 @@ def validate_region_contrast_request( "V1 region_contrasts inference requires representation to be " "'modified_fraction' or 'modified_count'." ) - if test not in {"beta_binomial", "effect_size_only"}: + if test != "effect_size_only": raise ValueError( - "V1 region_contrasts inference requires test to be " - "'beta_binomial' or 'effect_size_only'." + "Current region_contrasts scoring support requires test='effect_size_only'." ) @@ -179,9 +178,6 @@ def score_regions( motifs=motifs, ) - if test != "effect_size_only": - raise NotImplementedError(f"score_regions does not yet implement test='{test}'.") - pooled = _pool_region_groups(evidence=evidence, contrast=contrast) numerator = ( pooled.loc[pooled["contrast_side"] == "numerator"] diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index fd0ca81..3ecddc2 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -12,7 +12,7 @@ def test_validate_supported_v1_combination(): analysis_unit="ensemble_region", representation="modified_fraction", signal_source="pileup_counts", - test="beta_binomial", + test="effect_size_only", ) @@ -26,6 +26,39 @@ def test_validate_rejects_unsupported_single_read_beta_binomial(): ) +def test_validate_rejects_unimplemented_beta_binomial_scoring(): + with pytest.raises(ValueError, match="test='effect_size_only'"): + region_contrasts.validate_region_contrast_request( + analysis_unit="ensemble_region", + representation="modified_fraction", + signal_source="pileup_counts", + test="beta_binomial", + ) + + +def test_score_regions_rejects_unimplemented_beta_binomial_scoring(monkeypatch): + contrast = ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["control"], + ) + + monkeypatch.setattr( + region_contrasts, + "build_region_evidence_table", + lambda **kwargs: pd.DataFrame(), + ) + + with pytest.raises(ValueError, match="test='effect_size_only'"): + region_contrasts.score_regions( + samples=[], + regions="regions.bed", + motifs=["A,0"], + contrast=contrast, + test="beta_binomial", + ) + + def test_build_region_evidence_table_from_pileup_counts(monkeypatch): samples = [ SampleSpec( @@ -450,6 +483,58 @@ def test_score_regions_rejects_missing_denominator_condition(monkeypatch): ) +def test_score_regions_rejects_missing_numerator_condition(monkeypatch): + contrast = ContrastSpec( + mode="pairwise", + numerator=["trated"], + denominator=["control"], + ) + evidence = pd.DataFrame( + [ + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "n1", + "condition": "treated", + "replicate": 1, + "modified_count": 8, + "valid_count": 10, + "mod_fraction": 0.8, + }, + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "d1", + "condition": "control", + "replicate": 1, + "modified_count": 2, + "valid_count": 10, + "mod_fraction": 0.2, + }, + ] + ) + + monkeypatch.setattr( + region_contrasts, + "build_region_evidence_table", + lambda **kwargs: evidence.copy(), + ) + + with pytest.raises(ValueError, match="numerator.*trated"): + region_contrasts.score_regions( + samples=[], + regions="regions.bed", + motifs=["A,0"], + contrast=contrast, + ) + + def test_score_regions_modified_count_representation_ranks_by_delta_count(monkeypatch): contrast = ContrastSpec( mode="pairwise", From e52a3cb440a5f1be2fa7224230109de7383de1be Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 17:59:50 -0700 Subject: [PATCH 031/272] feat: add beta-binomial region contrast scoring --- dimelo/region_contrasts.py | 104 ++++++++++++++++++- tests/test_region_contrasts.py | 180 +++++++++++++++++++++++++++------ 2 files changed, 249 insertions(+), 35 deletions(-) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index a67c5ed..ed873be 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -30,9 +30,10 @@ def validate_region_contrast_request( "V1 region_contrasts inference requires representation to be " "'modified_fraction' or 'modified_count'." ) - if test != "effect_size_only": + if test not in {"effect_size_only", "beta_binomial"}: raise ValueError( - "Current region_contrasts scoring support requires test='effect_size_only'." + "Current region_contrasts scoring support requires test in " + "{'effect_size_only', 'beta_binomial'}." ) @@ -111,6 +112,98 @@ def _zero_safe_divide(numerator: pd.Series, denominator: pd.Series) -> pd.Series return numerator.div(denominator.where(denominator != 0), fill_value=0).fillna(0.0) +def _estimate_beta_binomial_prior( + denominator_modified_count: pd.Series, + denominator_valid_count: pd.Series, +) -> tuple[float, float]: + total_modified = float(denominator_modified_count.sum()) + total_unmodified = float( + (denominator_valid_count - denominator_modified_count).clip(lower=0).sum() + ) + return total_modified + 1.0, total_unmodified + 1.0 + + +def _log_beta_function(alpha: float, beta: float) -> float: + return math.lgamma(alpha) + math.lgamma(beta) - math.lgamma(alpha + beta) + + +def _beta_binomial_logpmf(k: int, n: int, alpha: float, beta: float) -> float: + if k < 0 or k > n: + return float("-inf") + return ( + math.lgamma(n + 1) + - math.lgamma(k + 1) + - math.lgamma(n - k + 1) + + _log_beta_function(k + alpha, n - k + beta) + - _log_beta_function(alpha, beta) + ) + + +def _beta_binomial_two_sided_p_value(k: int, n: int, alpha: float, beta: float) -> float: + if n <= 0: + return 1.0 + + support = list(range(n + 1)) + logpmf = [_beta_binomial_logpmf(x, n, alpha, beta) for x in support] + observed_logpmf = logpmf[k] + tail_probability = sum( + math.exp(value) + for value in logpmf + if value <= observed_logpmf + 1e-12 + ) + return min(max(tail_probability, 0.0), 1.0) + + +def _adjust_p_values_bh(p_values: pd.Series) -> pd.Series: + if p_values.empty: + return pd.Series(dtype=float, index=p_values.index) + + ranked = sorted(enumerate(p_values.tolist()), key=lambda item: item[1], reverse=True) + total = len(ranked) + adjusted = [1.0] * total + running_min = 1.0 + + for rank_from_end, (original_index, p_value) in enumerate(ranked, start=1): + rank = total - rank_from_end + 1 + candidate = min(1.0, p_value * total / rank) + running_min = min(running_min, candidate) + adjusted[original_index] = running_min + + return pd.Series(adjusted, index=p_values.index, dtype=float) + + +def _add_beta_binomial_scores( + regions_table: pd.DataFrame, + *, + multiple_testing: str, +) -> pd.DataFrame: + if multiple_testing != "fdr_bh": + raise ValueError( + "Current beta-binomial region contrast scoring requires " + "multiple_testing='fdr_bh'." + ) + + alpha, beta = _estimate_beta_binomial_prior( + regions_table["denominator_modified_count"], + regions_table["denominator_valid_count"], + ) + scored = regions_table.copy() + scored["p_value"] = [ + _beta_binomial_two_sided_p_value( + int(modified_count), + int(valid_count), + alpha, + beta, + ) + for modified_count, valid_count in zip( + scored["numerator_modified_count"], + scored["numerator_valid_count"], + ) + ] + scored["adjusted_p_value"] = _adjust_p_values_bh(scored["p_value"]) + return scored + + def _pool_region_groups(evidence: pd.DataFrame, contrast: ContrastSpec) -> pd.DataFrame: if contrast.mode not in {"pairwise", "group_vs_group"}: raise NotImplementedError( @@ -255,6 +348,11 @@ def score_regions( ascending=False, kind="mergesort", ).reset_index(drop=True) + if test == "beta_binomial": + regions_table = _add_beta_binomial_scores( + regions_table, + multiple_testing=multiple_testing, + ) regions_table["rank"] = range(1, len(regions_table) + 1) summary_columns = [ @@ -271,6 +369,8 @@ def score_regions( "denominator_valid_count", "denominator_replicate_n", ] + if test == "beta_binomial": + summary_columns.extend(["p_value", "adjusted_p_value"]) if representation == "modified_count": summary_columns.extend(["count", "reference_count", "delta_count", "log2_fc_count"]) summary = regions_table.loc[:, summary_columns].copy() diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index 3ecddc2..b2b48f0 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -16,6 +16,15 @@ def test_validate_supported_v1_combination(): ) +def test_validate_accepts_beta_binomial_for_supported_v1_combination(): + region_contrasts.validate_region_contrast_request( + analysis_unit="ensemble_region", + representation="modified_fraction", + signal_source="pileup_counts", + test="beta_binomial", + ) + + def test_validate_rejects_unsupported_single_read_beta_binomial(): with pytest.raises(ValueError, match="analysis_unit='ensemble_region'"): region_contrasts.validate_region_contrast_request( @@ -26,39 +35,6 @@ def test_validate_rejects_unsupported_single_read_beta_binomial(): ) -def test_validate_rejects_unimplemented_beta_binomial_scoring(): - with pytest.raises(ValueError, match="test='effect_size_only'"): - region_contrasts.validate_region_contrast_request( - analysis_unit="ensemble_region", - representation="modified_fraction", - signal_source="pileup_counts", - test="beta_binomial", - ) - - -def test_score_regions_rejects_unimplemented_beta_binomial_scoring(monkeypatch): - contrast = ContrastSpec( - mode="pairwise", - numerator=["treated"], - denominator=["control"], - ) - - monkeypatch.setattr( - region_contrasts, - "build_region_evidence_table", - lambda **kwargs: pd.DataFrame(), - ) - - with pytest.raises(ValueError, match="test='effect_size_only'"): - region_contrasts.score_regions( - samples=[], - regions="regions.bed", - motifs=["A,0"], - contrast=contrast, - test="beta_binomial", - ) - - def test_build_region_evidence_table_from_pileup_counts(monkeypatch): samples = [ SampleSpec( @@ -431,6 +407,144 @@ def test_score_regions_effect_size_only_group_vs_group_pools_conditions(monkeypa assert summary_row["denominator_replicate_n"] == 2 +def test_score_regions_beta_binomial_adds_p_values(monkeypatch): + contrast = ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["control"], + ) + evidence = pd.DataFrame( + [ + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "n1", + "condition": "treated", + "replicate": 1, + "modified_count": 9, + "valid_count": 10, + "mod_fraction": 0.9, + }, + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "d1", + "condition": "control", + "replicate": 1, + "modified_count": 2, + "valid_count": 10, + "mod_fraction": 0.2, + }, + { + "region_id": "reg2", + "chromosome": "chr2", + "start": 10, + "end": 20, + "strand": "-", + "sample_id": "n1", + "condition": "treated", + "replicate": 1, + "modified_count": 5, + "valid_count": 10, + "mod_fraction": 0.5, + }, + { + "region_id": "reg2", + "chromosome": "chr2", + "start": 10, + "end": 20, + "strand": "-", + "sample_id": "d1", + "condition": "control", + "replicate": 1, + "modified_count": 4, + "valid_count": 10, + "mod_fraction": 0.4, + }, + ] + ) + + monkeypatch.setattr( + region_contrasts, + "build_region_evidence_table", + lambda **kwargs: evidence.copy(), + ) + + result = region_contrasts.score_regions( + samples=[], + regions="regions.bed", + motifs=["A,0"], + contrast=contrast, + test="beta_binomial", + ) + + for table in (result.regions, result.summary): + assert "p_value" in table.columns + assert "adjusted_p_value" in table.columns + assert ((table["p_value"] >= 0) & (table["p_value"] <= 1)).all() + assert ((table["adjusted_p_value"] >= 0) & (table["adjusted_p_value"] <= 1)).all() + + +def test_score_regions_beta_binomial_rejects_unsupported_multiple_testing(monkeypatch): + contrast = ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["control"], + ) + evidence = pd.DataFrame( + [ + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "n1", + "condition": "treated", + "replicate": 1, + "modified_count": 9, + "valid_count": 10, + "mod_fraction": 0.9, + }, + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "d1", + "condition": "control", + "replicate": 1, + "modified_count": 2, + "valid_count": 10, + "mod_fraction": 0.2, + }, + ] + ) + + monkeypatch.setattr( + region_contrasts, + "build_region_evidence_table", + lambda **kwargs: evidence.copy(), + ) + + with pytest.raises(ValueError, match="fdr_bh"): + region_contrasts.score_regions( + samples=[], + regions="regions.bed", + motifs=["A,0"], + contrast=contrast, + test="beta_binomial", + multiple_testing="bonferroni", + ) + + def test_score_regions_rejects_missing_denominator_condition(monkeypatch): contrast = ContrastSpec( mode="pairwise", From 6541a307daf3bfff5dab7d867de6ca3b006a0c16 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 18:07:20 -0700 Subject: [PATCH 032/272] fix: correct beta-binomial region scoring --- dimelo/region_contrasts.py | 58 +++++++---- tests/test_region_contrasts.py | 170 +++++++++++++++++++++++++++++++++ 2 files changed, 208 insertions(+), 20 deletions(-) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index ed873be..cdc33f5 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -113,14 +113,20 @@ def _zero_safe_divide(numerator: pd.Series, denominator: pd.Series) -> pd.Series def _estimate_beta_binomial_prior( - denominator_modified_count: pd.Series, - denominator_valid_count: pd.Series, + denominator_modified_count: int, + denominator_valid_count: int, ) -> tuple[float, float]: - total_modified = float(denominator_modified_count.sum()) - total_unmodified = float( - (denominator_valid_count - denominator_modified_count).clip(lower=0).sum() - ) - return total_modified + 1.0, total_unmodified + 1.0 + if denominator_modified_count < 0: + raise ValueError("beta-binomial denominator modified_count must be >= 0.") + if denominator_valid_count < 0: + raise ValueError("beta-binomial denominator valid_count must be >= 0.") + if denominator_modified_count > denominator_valid_count: + raise ValueError( + "beta-binomial denominator modified_count cannot exceed valid_count." + ) + + denominator_unmodified_count = denominator_valid_count - denominator_modified_count + return float(denominator_modified_count + 1), float(denominator_unmodified_count + 1) def _log_beta_function(alpha: float, beta: float) -> float: @@ -140,6 +146,12 @@ def _beta_binomial_logpmf(k: int, n: int, alpha: float, beta: float) -> float: def _beta_binomial_two_sided_p_value(k: int, n: int, alpha: float, beta: float) -> float: + if k < 0: + raise ValueError("beta-binomial modified_count must be >= 0.") + if n < 0: + raise ValueError("beta-binomial valid_count must be >= 0.") + if k > n: + raise ValueError("beta-binomial modified_count cannot exceed valid_count.") if n <= 0: return 1.0 @@ -183,21 +195,21 @@ def _add_beta_binomial_scores( "multiple_testing='fdr_bh'." ) - alpha, beta = _estimate_beta_binomial_prior( - regions_table["denominator_modified_count"], - regions_table["denominator_valid_count"], - ) scored = regions_table.copy() scored["p_value"] = [ _beta_binomial_two_sided_p_value( int(modified_count), int(valid_count), - alpha, - beta, + *_estimate_beta_binomial_prior( + int(reference_modified_count), + int(reference_valid_count), + ), ) - for modified_count, valid_count in zip( + for modified_count, valid_count, reference_modified_count, reference_valid_count in zip( scored["numerator_modified_count"], scored["numerator_valid_count"], + scored["denominator_modified_count"], + scored["denominator_valid_count"], ) ] scored["adjusted_p_value"] = _adjust_p_values_bh(scored["p_value"]) @@ -343,16 +355,22 @@ def score_regions( else: merged["effect_size"] = merged["delta_fraction"].abs() - regions_table = merged.sort_values( - by="effect_size", - ascending=False, - kind="mergesort", - ).reset_index(drop=True) if test == "beta_binomial": regions_table = _add_beta_binomial_scores( - regions_table, + merged, multiple_testing=multiple_testing, ) + regions_table = regions_table.sort_values( + by=["adjusted_p_value", "p_value"], + ascending=[True, True], + kind="mergesort", + ).reset_index(drop=True) + else: + regions_table = merged.sort_values( + by="effect_size", + ascending=False, + kind="mergesort", + ).reset_index(drop=True) regions_table["rank"] = range(1, len(regions_table) + 1) summary_columns = [ diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index b2b48f0..192f08d 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -545,6 +545,176 @@ def test_score_regions_beta_binomial_rejects_unsupported_multiple_testing(monkey ) +def test_score_regions_beta_binomial_uses_row_specific_denominator_counts(monkeypatch): + contrast = ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["control"], + ) + evidence = pd.DataFrame( + [ + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "n1", + "condition": "treated", + "replicate": 1, + "modified_count": 5, + "valid_count": 10, + "mod_fraction": 0.5, + }, + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "d1", + "condition": "control", + "replicate": 1, + "modified_count": 1, + "valid_count": 10, + "mod_fraction": 0.1, + }, + { + "region_id": "reg2", + "chromosome": "chr2", + "start": 10, + "end": 20, + "strand": "-", + "sample_id": "n1", + "condition": "treated", + "replicate": 1, + "modified_count": 5, + "valid_count": 10, + "mod_fraction": 0.5, + }, + { + "region_id": "reg2", + "chromosome": "chr2", + "start": 10, + "end": 20, + "strand": "-", + "sample_id": "d1", + "condition": "control", + "replicate": 1, + "modified_count": 4, + "valid_count": 10, + "mod_fraction": 0.4, + }, + ] + ) + + monkeypatch.setattr( + region_contrasts, + "build_region_evidence_table", + lambda **kwargs: evidence.copy(), + ) + + result = region_contrasts.score_regions( + samples=[], + regions="regions.bed", + motifs=["A,0"], + contrast=contrast, + test="beta_binomial", + ) + + row1 = result.summary.loc[result.summary["region_id"] == "reg1", "p_value"].iloc[0] + row2 = result.summary.loc[result.summary["region_id"] == "reg2", "p_value"].iloc[0] + assert row1 != row2 + + +def test_score_regions_beta_binomial_ranks_by_adjusted_p_value(monkeypatch): + contrast = ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["control"], + ) + evidence = pd.DataFrame( + [ + { + "region_id": "high_effect_low_significance", + "chromosome": "chr1", + "start": 0, + "end": 1, + "strand": "+", + "sample_id": "n1", + "condition": "treated", + "replicate": 1, + "modified_count": 1, + "valid_count": 1, + "mod_fraction": 1.0, + }, + { + "region_id": "high_effect_low_significance", + "chromosome": "chr1", + "start": 0, + "end": 1, + "strand": "+", + "sample_id": "d1", + "condition": "control", + "replicate": 1, + "modified_count": 0, + "valid_count": 1, + "mod_fraction": 0.0, + }, + { + "region_id": "lower_effect_higher_significance", + "chromosome": "chr2", + "start": 10, + "end": 20, + "strand": "-", + "sample_id": "n1", + "condition": "treated", + "replicate": 1, + "modified_count": 18, + "valid_count": 20, + "mod_fraction": 0.9, + }, + { + "region_id": "lower_effect_higher_significance", + "chromosome": "chr2", + "start": 10, + "end": 20, + "strand": "-", + "sample_id": "d1", + "condition": "control", + "replicate": 1, + "modified_count": 10, + "valid_count": 20, + "mod_fraction": 0.5, + }, + ] + ) + + monkeypatch.setattr( + region_contrasts, + "build_region_evidence_table", + lambda **kwargs: evidence.copy(), + ) + + result = region_contrasts.score_regions( + samples=[], + regions="regions.bed", + motifs=["A,0"], + contrast=contrast, + test="beta_binomial", + ) + + assert result.summary.iloc[0]["region_id"] == "lower_effect_higher_significance" + assert result.summary.iloc[0]["adjusted_p_value"] <= result.summary.iloc[1]["adjusted_p_value"] + assert result.summary.iloc[0]["delta_fraction"] < result.summary.iloc[1]["delta_fraction"] + assert result.summary.iloc[0]["rank"] == 1 + + +def test_beta_binomial_two_sided_p_value_rejects_invalid_counts(): + with pytest.raises(ValueError, match="modified_count"): + region_contrasts._beta_binomial_two_sided_p_value(6, 5, 2.0, 2.0) + + def test_score_regions_rejects_missing_denominator_condition(monkeypatch): contrast = ContrastSpec( mode="pairwise", From a5d8f3ad4c758046764bf7cf0d98b817317575ba Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 18:12:07 -0700 Subject: [PATCH 033/272] test: strengthen beta-binomial contrast coverage --- tests/test_region_contrasts.py | 135 +++++++++++++++++++++++++++++++++ 1 file changed, 135 insertions(+) diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index 192f08d..0537ef5 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -710,11 +710,146 @@ def test_score_regions_beta_binomial_ranks_by_adjusted_p_value(monkeypatch): assert result.summary.iloc[0]["rank"] == 1 +def test_score_regions_beta_binomial_uses_p_value_tiebreak_when_adjusted_values_match( + monkeypatch, +): + contrast = ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["control"], + ) + evidence = pd.DataFrame( + [ + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "n1", + "condition": "treated", + "replicate": 1, + "modified_count": 8, + "valid_count": 10, + "mod_fraction": 0.8, + }, + { + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 10, + "strand": "+", + "sample_id": "d1", + "condition": "control", + "replicate": 1, + "modified_count": 2, + "valid_count": 10, + "mod_fraction": 0.2, + }, + { + "region_id": "reg2", + "chromosome": "chr2", + "start": 10, + "end": 20, + "strand": "-", + "sample_id": "n1", + "condition": "treated", + "replicate": 1, + "modified_count": 5, + "valid_count": 10, + "mod_fraction": 0.5, + }, + { + "region_id": "reg2", + "chromosome": "chr2", + "start": 10, + "end": 20, + "strand": "-", + "sample_id": "d1", + "condition": "control", + "replicate": 1, + "modified_count": 4, + "valid_count": 10, + "mod_fraction": 0.4, + }, + ] + ) + + monkeypatch.setattr( + region_contrasts, + "build_region_evidence_table", + lambda **kwargs: evidence.copy(), + ) + + original_add = region_contrasts._add_beta_binomial_scores + + def fake_add_beta_binomial_scores(regions_table, *, multiple_testing): + scored = original_add(regions_table, multiple_testing=multiple_testing) + scored.loc[scored["region_id"] == "reg1", "p_value"] = 0.02 + scored.loc[scored["region_id"] == "reg2", "p_value"] = 0.01 + scored["adjusted_p_value"] = 0.05 + return scored + + monkeypatch.setattr( + region_contrasts, + "_add_beta_binomial_scores", + fake_add_beta_binomial_scores, + ) + + result = region_contrasts.score_regions( + samples=[], + regions="regions.bed", + motifs=["A,0"], + contrast=contrast, + test="beta_binomial", + ) + + assert list(result.summary["region_id"]) == ["reg2", "reg1"] + assert list(result.summary["rank"]) == [1, 2] + + def test_beta_binomial_two_sided_p_value_rejects_invalid_counts(): with pytest.raises(ValueError, match="modified_count"): region_contrasts._beta_binomial_two_sided_p_value(6, 5, 2.0, 2.0) +@pytest.mark.parametrize( + ("denominator_modified_count", "denominator_valid_count"), + [ + (-1, 5), + (3, -1), + (6, 5), + ], +) +def test_estimate_beta_binomial_prior_rejects_invalid_denominator_counts( + denominator_modified_count, denominator_valid_count +): + with pytest.raises(ValueError): + region_contrasts._estimate_beta_binomial_prior( + denominator_modified_count, + denominator_valid_count, + ) + + +@pytest.mark.parametrize( + ("modified_count", "valid_count"), + [ + (-1, 5), + (1, -1), + ], +) +def test_beta_binomial_two_sided_p_value_rejects_negative_counts( + modified_count, valid_count +): + with pytest.raises(ValueError): + region_contrasts._beta_binomial_two_sided_p_value( + modified_count, + valid_count, + 2.0, + 2.0, + ) + + def test_score_regions_rejects_missing_denominator_condition(monkeypatch): contrast = ContrastSpec( mode="pairwise", From 4c99d13b86d073bbeae8448bd18e1c22b643d52b Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 18:13:08 -0700 Subject: [PATCH 034/272] docs: add region contrast workflow guide --- README.md | 11 ++++ docs/region-contrasts.md | 108 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 119 insertions(+) create mode 100644 docs/region-contrasts.md diff --git a/README.md b/README.md index 078e2d5..318fef8 100644 --- a/README.md +++ b/README.md @@ -40,6 +40,8 @@ This README document contains installation instructions and documentation for va -[2.5 Clustering scaffolding](#clustering-scaffolding) +-[2.6 Region contrasts](#region-contrasts) + [3.0 Known Issues](#known-issues) -[3.1 No progress bars](#no-progress-bars) @@ -218,6 +220,15 @@ def extract( override_checks: bool = False,) -> Path, Path: ``` +## Region contrasts + +Two higher-level analysis guides now sit on top of the existing parsing layer: + +- [docs/shared-clustering.md](docs/shared-clustering.md) for shared-boundary clustering workflows +- [docs/region-contrasts.md](docs/region-contrasts.md) for known-region motif-abundance contrasts + +Use `parse_bam.pileup()` when you want defined-region abundance testing, and use `parse_bam.extract()` when you want read-level clustering or single-read follow-up. + For human-readable pileups (bedmethyl files, .bed) and extracted reads (.txt tab-separated values), run with `cleanup=False`. `cleanup=True` will clear these outputs because they can take up a lot of space. ### Parsing outputs diff --git a/docs/region-contrasts.md b/docs/region-contrasts.md new file mode 100644 index 0000000..9d76b75 --- /dev/null +++ b/docs/region-contrasts.md @@ -0,0 +1,108 @@ +# Region Contrasts + +`dimelo.region_contrasts` scores known regions from pileup-backed inputs. It is the defined-region comparison layer for cases where you already know the loci you want to test. + +## When To Use It + +- Use this when you already have a BED or matched region set. +- Use `parse_bam.pileup()` first when you want locus-level motif abundance testing. +- Use `cluster` first when you want read-state or cluster-occupancy follow-up rather than average motif abundance alone. +- Use `region_discovery` later for de novo locus finding once that module is implemented. + +## V1 Supported Path + +- `analysis_unit="ensemble_region"` +- `representation="modified_fraction"` or `"modified_count"` +- `signal_source="pileup_counts"` +- `test="effect_size_only"` or `"beta_binomial"` + +Current v1 behavior: + +- `effect_size_only` supports pooled `pairwise` and `group_vs_group` comparisons. +- `beta_binomial` supports the same pooled comparison modes and adds `p_value` / `adjusted_p_value`. +- `multiple_testing="fdr_bh"` is the only supported correction mode for `beta_binomial`. +- The current beta-binomial path is intentionally simple: pooled region counts with a first-pass per-region predictive test, not replicate-aware hierarchical modeling. + +## Example + +```python +from dimelo import region_contrasts +from dimelo.models import ContrastSpec, SampleSpec + +result = region_contrasts.score_regions( + samples=[ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="output/s1.extract.h5", + metadata={"pileup_path": "output/s1.pileup.sorted.bed.gz"}, + ), + SampleSpec( + sample_id="s2", + condition="15min", + extract_h5="output/s2.extract.h5", + metadata={"pileup_path": "output/s2.pileup.sorted.bed.gz"}, + ), + ], + regions="matched_regions.bed", + motifs=["A,0"], + contrast=ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + reference_condition="NS", + ), + analysis_unit="ensemble_region", + representation="modified_fraction", + signal_source="pileup_counts", + test="beta_binomial", +) +``` + +## Canonical Outputs + +The workflow returns a `RegionContrastResult` with canonical tables: + +- `result.regions` +- `result.summary` +- `result.plot_data` + +For `effect_size_only`, the main effect-size columns are: + +- `fraction` +- `reference_fraction` +- `delta_fraction` +- `log2_fc` +- `rank` + +For `representation="modified_count"`, count-based fields are also included: + +- `count` +- `reference_count` +- `delta_count` +- `log2_fc_count` + +For `beta_binomial`, statistical columns are included in both `result.regions` and `result.summary`: + +- `p_value` +- `adjusted_p_value` + +## Custom Plotting + +The results are data-first. You can use the built-in `plot_data` payloads or ignore them and plot the returned tables directly. + +```python +import seaborn as sns + +sns.scatterplot( + data=result.summary, + x="delta_fraction", + y="adjusted_p_value", +) +``` + +## Preprocessing Reminder + +- Run `parse_bam.pileup()` when you care about motif abundance, defined-region contrasts, or later de novo discovery. +- Run `parse_bam.extract()` when you care about single-read analysis or clustering. +- Run both when you want formal region-level abundance testing plus downstream read-level follow-up on the same samples. From c5718c1ad6a5272d1bb97566c010ce4ab53d50fb Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 19:38:40 -0700 Subject: [PATCH 035/272] feat: add global analysis result model --- dimelo/models.py | 23 +++++++++++++++++++++++ tests/test_models.py | 32 ++++++++++++++++++++++++++++++++ 2 files changed, 55 insertions(+) diff --git a/dimelo/models.py b/dimelo/models.py index 0c83e9a..46c12c0 100644 --- a/dimelo/models.py +++ b/dimelo/models.py @@ -125,6 +125,29 @@ def __post_init__(self) -> None: ) +@dataclass +class GlobalAnalysisResult: + summary: pd.DataFrame + windows: pd.DataFrame | None + normalization_factors: pd.DataFrame + plot_data: dict[str, pd.DataFrame | dict[str, Any]] + metadata: dict[str, Any] = field(default_factory=dict) + figures: dict[str, Any] = field(default_factory=dict) + + def __post_init__(self) -> None: + required_fields = { + "summary": self.summary, + "normalization_factors": self.normalization_factors, + "plot_data": self.plot_data, + } + missing = [name for name, value in required_fields.items() if value is None] + if missing: + raise ValueError( + "GlobalAnalysisResult requires non-None values for: " + f"{', '.join(missing)}" + ) + + @dataclass class RegionContrastResult: regions: pd.DataFrame diff --git a/tests/test_models.py b/tests/test_models.py index 0cc2ee2..b8e0793 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -8,6 +8,7 @@ BatchJob, CohortSpec, ContrastSpec, + GlobalAnalysisResult, DatasetArtifact, SampleSpec, RegionContrastResult, @@ -269,6 +270,37 @@ def test_shared_cluster_result_rejects_none_core_outputs(field_name): SharedClusterResult(**kwargs) +def test_global_analysis_result_supports_summary_windows_and_normalization(): + result = GlobalAnalysisResult( + summary=pd.DataFrame({"sample_id": ["s1"]}), + windows=pd.DataFrame({"window_id": ["chr1:0-1000"]}), + normalization_factors=pd.DataFrame( + {"sample_id": ["s1"], "global_offset": [0.1]} + ), + plot_data={"global_fraction_bar": pd.DataFrame({"sample_id": ["s1"]})}, + metadata={"normalization_mode": "per_sample_global"}, + figures={}, + ) + + assert list(result.summary["sample_id"]) == ["s1"] + assert list(result.windows["window_id"]) == ["chr1:0-1000"] + assert list(result.normalization_factors["sample_id"]) == ["s1"] + + +def test_global_analysis_result_rejects_none_core_outputs(): + with pytest.raises( + ValueError, match="summary, normalization_factors, plot_data" + ): + GlobalAnalysisResult( + summary=None, + windows=None, + normalization_factors=None, + plot_data=None, + metadata={}, + figures={}, + ) + + def test_region_contrast_result_rejects_none_core_tables(): contrast = ContrastSpec( mode="pairwise", From 7569231c8dbd3f90e19abb07690dace8099de293 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 19:42:06 -0700 Subject: [PATCH 036/272] fix: harden global analysis result validation --- dimelo/models.py | 2 ++ tests/test_models.py | 18 ++++++++++++++++++ 2 files changed, 20 insertions(+) diff --git a/dimelo/models.py b/dimelo/models.py index 46c12c0..dd0a1db 100644 --- a/dimelo/models.py +++ b/dimelo/models.py @@ -139,6 +139,8 @@ def __post_init__(self) -> None: "summary": self.summary, "normalization_factors": self.normalization_factors, "plot_data": self.plot_data, + "metadata": self.metadata, + "figures": self.figures, } missing = [name for name, value in required_fields.items() if value is None] if missing: diff --git a/tests/test_models.py b/tests/test_models.py index b8e0793..58da851 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -301,6 +301,24 @@ def test_global_analysis_result_rejects_none_core_outputs(): ) +@pytest.mark.parametrize("field_name", ["metadata", "figures"]) +def test_global_analysis_result_rejects_none_optional_outputs(field_name): + kwargs = { + "summary": pd.DataFrame({"sample_id": ["s1"]}), + "windows": pd.DataFrame({"window_id": ["chr1:0-1000"]}), + "normalization_factors": pd.DataFrame( + {"sample_id": ["s1"], "global_offset": [0.1]} + ), + "plot_data": {"global_fraction_bar": pd.DataFrame({"sample_id": ["s1"]})}, + "metadata": {"normalization_mode": "per_sample_global"}, + "figures": {}, + } + kwargs[field_name] = None + + with pytest.raises(ValueError, match=field_name): + GlobalAnalysisResult(**kwargs) + + def test_region_contrast_result_rejects_none_core_tables(): contrast = ContrastSpec( mode="pairwise", From ca253645840f4e37a3bfe2b94798ebe7a2ffbd76 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 19:44:30 -0700 Subject: [PATCH 037/272] test: strengthen global analysis result coverage --- tests/test_models.py | 31 +++++++++++++++++++------------ 1 file changed, 19 insertions(+), 12 deletions(-) diff --git a/tests/test_models.py b/tests/test_models.py index 58da851..592d96d 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -287,18 +287,25 @@ def test_global_analysis_result_supports_summary_windows_and_normalization(): assert list(result.normalization_factors["sample_id"]) == ["s1"] -def test_global_analysis_result_rejects_none_core_outputs(): - with pytest.raises( - ValueError, match="summary, normalization_factors, plot_data" - ): - GlobalAnalysisResult( - summary=None, - windows=None, - normalization_factors=None, - plot_data=None, - metadata={}, - figures={}, - ) +@pytest.mark.parametrize( + "field_name", + ["summary", "normalization_factors", "plot_data"], +) +def test_global_analysis_result_rejects_none_core_outputs(field_name): + kwargs = { + "summary": pd.DataFrame({"sample_id": ["s1"]}), + "windows": pd.DataFrame({"window_id": ["chr1:0-1000"]}), + "normalization_factors": pd.DataFrame( + {"sample_id": ["s1"], "global_offset": [0.1]} + ), + "plot_data": {"global_fraction_bar": pd.DataFrame({"sample_id": ["s1"]})}, + "metadata": {"normalization_mode": "per_sample_global"}, + "figures": {}, + } + kwargs[field_name] = None + + with pytest.raises(ValueError, match=field_name): + GlobalAnalysisResult(**kwargs) @pytest.mark.parametrize("field_name", ["metadata", "figures"]) From 426720653e06eacd511a726dd9e746cc32a082e9 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 19:47:56 -0700 Subject: [PATCH 038/272] feat: add global pileup summary workflow --- dimelo/__init__.py | 2 + dimelo/global_analysis.py | 94 ++++++++++++++++++++++++++++++++ tests/test_global_analysis.py | 100 ++++++++++++++++++++++++++++++++++ 3 files changed, 196 insertions(+) create mode 100644 dimelo/global_analysis.py create mode 100644 tests/test_global_analysis.py diff --git a/dimelo/__init__.py b/dimelo/__init__.py index 84c4bae..83f23e7 100644 --- a/dimelo/__init__.py +++ b/dimelo/__init__.py @@ -2,6 +2,7 @@ cluster, distribution, export, + global_analysis, load_processed, models, parse_bam, @@ -21,6 +22,7 @@ "cluster", "distribution", "export", + "global_analysis", "load_processed", "models", "parse_bam", diff --git a/dimelo/global_analysis.py b/dimelo/global_analysis.py new file mode 100644 index 0000000..3c44c4c --- /dev/null +++ b/dimelo/global_analysis.py @@ -0,0 +1,94 @@ +from __future__ import annotations + +from pathlib import Path +from typing import Sequence + +import pandas as pd +import pysam + +from . import load_processed, utils +from .models import SampleSpec + + +def _global_counts_from_bedmethyl( + bedmethyl_file: str | Path, + motif: str, + quiet: bool = True, +) -> tuple[int, int]: + """ + Sum modified and valid pileup counts across all contigs for one motif. + """ + + del quiet + + parsed_motif = utils.ParsedMotif(motif) + modified_count = 0 + valid_count = 0 + + with pysam.TabixFile(str(bedmethyl_file)) as tabix_file: + for contig in tabix_file.contigs: + for row in tabix_file.fetch(contig): + keep_basemod, _, modified_in_row, valid_in_row = ( + load_processed.process_pileup_row( + row=row, + parsed_motif=parsed_motif, + region_strand=".", + ) + ) + if keep_basemod: + modified_count += modified_in_row + valid_count += valid_in_row + + return modified_count, valid_count + + +def summarize_global_samples( + samples: Sequence[SampleSpec], + motifs: Sequence[str], + quiet: bool = True, +) -> pd.DataFrame: + """ + Build a long-form table of global motif fractions per sample. + """ + + rows: list[dict[str, object]] = [] + + for sample in samples: + if not sample.metadata or "pileup_path" not in sample.metadata: + raise ValueError( + f"Sample {sample.sample_id!r} is missing metadata['pileup_path'] for global_analysis mode." + ) + + pileup_path = sample.metadata["pileup_path"] + for motif in motifs: + modified_count, valid_count = _global_counts_from_bedmethyl( + bedmethyl_file=pileup_path, + motif=motif, + quiet=quiet, + ) + rows.append( + { + "sample_id": sample.sample_id, + "condition": sample.condition, + "replicate": sample.replicate, + "motif": motif, + "modified_count": modified_count, + "valid_count": valid_count, + "global_fraction": ( + modified_count / valid_count if valid_count else 0.0 + ), + } + ) + + return pd.DataFrame( + rows, + columns=[ + "sample_id", + "condition", + "replicate", + "motif", + "modified_count", + "valid_count", + "global_fraction", + ], + ) diff --git a/tests/test_global_analysis.py b/tests/test_global_analysis.py new file mode 100644 index 0000000..24c5f79 --- /dev/null +++ b/tests/test_global_analysis.py @@ -0,0 +1,100 @@ +import pandas as pd +import pytest + +from dimelo import global_analysis +from dimelo.models import SampleSpec + + +def test_summarize_global_samples_from_pileup(monkeypatch): + samples = [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + metadata={"pileup_path": "s1.bed.gz"}, + ), + SampleSpec( + sample_id="s2", + condition="15min", + extract_h5="s2.h5", + replicate=2, + metadata={"pileup_path": "s2.bed.gz"}, + ), + ] + + counts = { + ("s1.bed.gz", "A,0"): (2, 10), + ("s1.bed.gz", "CG,0"): (1, 4), + ("s2.bed.gz", "A,0"): (3, 6), + ("s2.bed.gz", "CG,0"): (0, 0), + } + + def fake_global_counts_from_bedmethyl(bedmethyl_file, motif, quiet=True): + return counts[(bedmethyl_file, motif)] + + monkeypatch.setattr( + global_analysis, + "_global_counts_from_bedmethyl", + fake_global_counts_from_bedmethyl, + ) + + result = global_analysis.summarize_global_samples( + samples=samples, + motifs=["A,0", "CG,0"], + ) + + expected = pd.DataFrame( + [ + { + "sample_id": "s1", + "condition": "NS", + "replicate": None, + "motif": "A,0", + "modified_count": 2, + "valid_count": 10, + "global_fraction": 0.2, + }, + { + "sample_id": "s1", + "condition": "NS", + "replicate": None, + "motif": "CG,0", + "modified_count": 1, + "valid_count": 4, + "global_fraction": 0.25, + }, + { + "sample_id": "s2", + "condition": "15min", + "replicate": 2, + "motif": "A,0", + "modified_count": 3, + "valid_count": 6, + "global_fraction": 0.5, + }, + { + "sample_id": "s2", + "condition": "15min", + "replicate": 2, + "motif": "CG,0", + "modified_count": 0, + "valid_count": 0, + "global_fraction": 0.0, + }, + ] + ) + + pd.testing.assert_frame_equal(result, expected) + + +def test_summarize_global_samples_requires_pileup_path(): + samples = [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + ) + ] + + with pytest.raises(ValueError, match="missing metadata\\['pileup_path'\\]"): + global_analysis.summarize_global_samples(samples=samples, motifs=["A,0"]) From deaa54978f9f2c5babedd4ff99d0da81de284785 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 19:52:49 -0700 Subject: [PATCH 039/272] fix: preserve missing global fractions --- dimelo/global_analysis.py | 2 +- tests/test_global_analysis.py | 61 ++++++++++++++++++++++++++++++++++- 2 files changed, 61 insertions(+), 2 deletions(-) diff --git a/dimelo/global_analysis.py b/dimelo/global_analysis.py index 3c44c4c..67f8f23 100644 --- a/dimelo/global_analysis.py +++ b/dimelo/global_analysis.py @@ -75,7 +75,7 @@ def summarize_global_samples( "modified_count": modified_count, "valid_count": valid_count, "global_fraction": ( - modified_count / valid_count if valid_count else 0.0 + modified_count / valid_count if valid_count else float("nan") ), } ) diff --git a/tests/test_global_analysis.py b/tests/test_global_analysis.py index 24c5f79..02c6096 100644 --- a/tests/test_global_analysis.py +++ b/tests/test_global_analysis.py @@ -79,7 +79,7 @@ def fake_global_counts_from_bedmethyl(bedmethyl_file, motif, quiet=True): "motif": "CG,0", "modified_count": 0, "valid_count": 0, - "global_fraction": 0.0, + "global_fraction": float("nan"), }, ] ) @@ -87,6 +87,65 @@ def fake_global_counts_from_bedmethyl(bedmethyl_file, motif, quiet=True): pd.testing.assert_frame_equal(result, expected) +def test_global_counts_from_bedmethyl_sums_only_matching_rows(monkeypatch): + rows_by_contig = { + "chr1": ["row-1", "row-2"], + "chr2": ["row-3"], + } + + class FakeTabixFile: + def __init__(self, path): + assert path == "pileup.bed.gz" + self.contigs = tuple(rows_by_contig) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc, tb): + return False + + def fetch(self, contig): + return iter(rows_by_contig[contig]) + + parsed_motifs = [] + + def fake_parsed_motif(motif): + parsed_motifs.append(motif) + return {"motif": motif} + + processed_rows = [] + process_results = { + "row-1": (True, 10, 3, 8), + "row-2": (False, 11, 20, 30), + "row-3": (True, 12, 5, 10), + } + + def fake_process_pileup_row(row, parsed_motif, region_strand, single_strand=False): + processed_rows.append((row, parsed_motif, region_strand, single_strand)) + return process_results[row] + + monkeypatch.setattr(global_analysis.pysam, "TabixFile", FakeTabixFile) + monkeypatch.setattr(global_analysis.utils, "ParsedMotif", fake_parsed_motif) + monkeypatch.setattr( + global_analysis.load_processed, + "process_pileup_row", + fake_process_pileup_row, + ) + + modified_count, valid_count = global_analysis._global_counts_from_bedmethyl( + bedmethyl_file="pileup.bed.gz", + motif="A,0", + ) + + assert (modified_count, valid_count) == (8, 18) + assert parsed_motifs == ["A,0"] + assert processed_rows == [ + ("row-1", {"motif": "A,0"}, ".", False), + ("row-2", {"motif": "A,0"}, ".", False), + ("row-3", {"motif": "A,0"}, ".", False), + ] + + def test_summarize_global_samples_requires_pileup_path(): samples = [ SampleSpec( From 20a551bbdb3908f30e220e24e9a4fc3fe71b5f10 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 19:56:21 -0700 Subject: [PATCH 040/272] feat: add global window summaries --- dimelo/global_analysis.py | 173 +++++++++++++++++++++++++++++++++- tests/test_global_analysis.py | 116 +++++++++++++++++++++++ 2 files changed, 288 insertions(+), 1 deletion(-) diff --git a/dimelo/global_analysis.py b/dimelo/global_analysis.py index 67f8f23..6d6fff1 100644 --- a/dimelo/global_analysis.py +++ b/dimelo/global_analysis.py @@ -1,7 +1,8 @@ from __future__ import annotations +from functools import partial from pathlib import Path -from typing import Sequence +from typing import Iterable, Sequence import pandas as pd import pysam @@ -92,3 +93,173 @@ def summarize_global_samples( "global_fraction", ], ) + + +def tile_genome_windows( + *, + genome_sizes: dict[str, int], + window_size: int, + step_size: int, + include_contigs: Iterable[str] | None = None, + exclude_contigs: Iterable[str] | None = None, +) -> pd.DataFrame: + if window_size <= 0: + raise ValueError("window_size must be positive.") + if step_size <= 0: + raise ValueError("step_size must be positive.") + + include_set = set(include_contigs) if include_contigs is not None else None + exclude_set = set(exclude_contigs or []) + + rows: list[dict[str, object]] = [] + for chromosome, contig_length in genome_sizes.items(): + if include_set is not None and chromosome not in include_set: + continue + if chromosome in exclude_set: + continue + if contig_length <= 0: + continue + + start = 0 + while start < contig_length: + end = min(start + window_size, contig_length) + rows.append( + { + "window_id": f"{chromosome}:{start}-{end}", + "chromosome": chromosome, + "start": start, + "end": end, + "strand": ".", + } + ) + if end >= contig_length: + break + start += step_size + + return pd.DataFrame( + rows, + columns=["window_id", "chromosome", "start", "end", "strand"], + ) + + +def build_window_summary( + *, + samples: Sequence[SampleSpec], + motifs: Sequence[str], + genome_sizes: dict[str, int], + window_size: int, + step_size: int, + include_contigs: Iterable[str] | None = None, + exclude_contigs: Iterable[str] | None = None, + quiet: bool = True, + cores: int | None = None, +) -> pd.DataFrame: + motifs = list(motifs) + if len(motifs) != 1: + raise ValueError("build_window_summary currently supports exactly one motif.") + + motif = motifs[0] + windows = tile_genome_windows( + genome_sizes=genome_sizes, + window_size=window_size, + step_size=step_size, + include_contigs=include_contigs, + exclude_contigs=exclude_contigs, + ) + + region_strings = [ + f"{row.chromosome}:{row.start}-{row.end},{row.strand}" + for row in windows.itertuples(index=False) + ] + + rows: list[dict[str, object]] = [] + for sample in samples: + metadata = sample.metadata or {} + if "pileup_path" not in metadata: + raise ValueError( + f"Sample {sample.sample_id!r} is missing metadata['pileup_path'] for global_analysis mode." + ) + + pileup_loader = partial( + load_processed.pileup_counts_from_bedmethyl, + bedmethyl_file=metadata["pileup_path"], + motif=motif, + ) + counts_by_window = load_processed.regions_to_list( + function_handle=pileup_loader, + regions=region_strings, + window_size=None, + quiet=quiet, + cores=cores, + ) + + if len(counts_by_window) != len(windows): + raise RuntimeError( + "Pileup window count length did not match the number of tiled windows." + ) + + for window_row, (modified_count, valid_count) in zip( + windows.itertuples(index=False), + counts_by_window, + ): + window_fraction = ( + float("nan") + if valid_count == 0 + else modified_count / valid_count + ) + rows.append( + { + "sample_id": sample.sample_id, + "condition": sample.condition, + "replicate": sample.replicate, + "motif": motif, + "window_id": window_row.window_id, + "chromosome": window_row.chromosome, + "start": window_row.start, + "end": window_row.end, + "strand": window_row.strand, + "modified_count": modified_count, + "valid_count": valid_count, + "window_fraction": window_fraction, + } + ) + + return pd.DataFrame( + rows, + columns=[ + "sample_id", + "condition", + "replicate", + "motif", + "window_id", + "chromosome", + "start", + "end", + "strand", + "modified_count", + "valid_count", + "window_fraction", + ], + ) + + +def compute_global_normalization_factors(summary: pd.DataFrame) -> pd.DataFrame: + factors = summary.copy() + factors["reference_fraction"] = factors.groupby("motif", sort=True)[ + "global_fraction" + ].transform("mean") + factors["global_offset"] = ( + factors["global_fraction"] - factors["reference_fraction"] + ) + return factors.loc[ + :, + [ + "sample_id", + "condition", + "replicate", + "motif", + "global_fraction", + "reference_fraction", + "global_offset", + ], + ].copy() diff --git a/tests/test_global_analysis.py b/tests/test_global_analysis.py index 02c6096..a281cc6 100644 --- a/tests/test_global_analysis.py +++ b/tests/test_global_analysis.py @@ -157,3 +157,119 @@ def test_summarize_global_samples_requires_pileup_path(): with pytest.raises(ValueError, match="missing metadata\\['pileup_path'\\]"): global_analysis.summarize_global_samples(samples=samples, motifs=["A,0"]) + + +def test_tile_windows_from_genome_sizes_dict(): + windows = global_analysis.tile_genome_windows( + genome_sizes={"chr1": 2500}, + window_size=1000, + step_size=500, + ) + + assert windows["window_id"].tolist() == [ + "chr1:0-1000", + "chr1:500-1500", + "chr1:1000-2000", + "chr1:1500-2500", + ] + + +def test_build_window_summary_from_regions_to_list(monkeypatch): + samples = [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + metadata={"pileup_path": "s1.bed.gz"}, + ), + ] + windows = pd.DataFrame( + { + "window_id": ["chr1:0-1000", "chr1:500-1500"], + "chromosome": ["chr1", "chr1"], + "start": [0, 500], + "end": [1000, 1500], + "strand": [".", "."], + } + ) + + captured = {} + + def fake_tile_genome_windows( + genome_sizes, + window_size, + step_size, + include_contigs=None, + exclude_contigs=None, + ): + captured["genome_sizes"] = genome_sizes + captured["window_size"] = window_size + captured["step_size"] = step_size + captured["include_contigs"] = include_contigs + captured["exclude_contigs"] = exclude_contigs + return windows + + def fake_regions_to_list( + function_handle, + regions, + window_size=None, + quiet=True, + cores=None, + split_large_regions=False, + ): + captured["function_handle"] = function_handle + captured["regions"] = list(regions) + captured["window_size_arg"] = window_size + captured["quiet"] = quiet + captured["cores"] = cores + captured["split_large_regions"] = split_large_regions + return [(5, 10), (1, 10)] + + monkeypatch.setattr(global_analysis, "tile_genome_windows", fake_tile_genome_windows) + monkeypatch.setattr( + global_analysis.load_processed, + "regions_to_list", + fake_regions_to_list, + ) + + summary = global_analysis.build_window_summary( + samples=samples, + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + window_size=1000, + step_size=500, + ) + + assert captured["genome_sizes"] == {"chr1": 1500} + assert captured["window_size"] == 1000 + assert captured["step_size"] == 500 + assert captured["regions"] == ["chr1:0-1000,.", "chr1:500-1500,."] + assert captured["function_handle"].keywords["bedmethyl_file"] == "s1.bed.gz" + assert captured["function_handle"].keywords["motif"] == "A,0" + assert summary["window_fraction"].tolist() == [0.5, 0.1] + + +def test_compute_global_normalization_factors_from_summary(): + summary = pd.DataFrame( + { + "sample_id": ["s1", "s2"], + "condition": ["NS", "15min"], + "replicate": [None, None], + "motif": ["A,0", "A,0"], + "modified_count": [10, 30], + "valid_count": [100, 100], + "global_fraction": [0.1, 0.3], + } + ) + + factors = global_analysis.compute_global_normalization_factors(summary) + + assert set(factors.columns) >= { + "sample_id", + "motif", + "global_fraction", + "reference_fraction", + "global_offset", + } + assert factors.loc[factors["sample_id"] == "s1", "global_offset"].iloc[0] == pytest.approx(-0.1) + assert factors.loc[factors["sample_id"] == "s2", "global_offset"].iloc[0] == pytest.approx(0.1) From cf11160f46686c6c58210bf577b37eb2f5647ee1 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 20:05:56 -0700 Subject: [PATCH 041/272] fix: zero window fractions at no coverage --- dimelo/global_analysis.py | 4 +--- tests/test_global_analysis.py | 4 ++-- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/dimelo/global_analysis.py b/dimelo/global_analysis.py index 6d6fff1..28c93d9 100644 --- a/dimelo/global_analysis.py +++ b/dimelo/global_analysis.py @@ -203,9 +203,7 @@ def build_window_summary( counts_by_window, ): window_fraction = ( - float("nan") - if valid_count == 0 - else modified_count / valid_count + 0.0 if valid_count == 0 else modified_count / valid_count ) rows.append( { diff --git a/tests/test_global_analysis.py b/tests/test_global_analysis.py index a281cc6..074bdc2 100644 --- a/tests/test_global_analysis.py +++ b/tests/test_global_analysis.py @@ -223,7 +223,7 @@ def fake_regions_to_list( captured["quiet"] = quiet captured["cores"] = cores captured["split_large_regions"] = split_large_regions - return [(5, 10), (1, 10)] + return [(5, 10), (0, 0)] monkeypatch.setattr(global_analysis, "tile_genome_windows", fake_tile_genome_windows) monkeypatch.setattr( @@ -246,7 +246,7 @@ def fake_regions_to_list( assert captured["regions"] == ["chr1:0-1000,.", "chr1:500-1500,."] assert captured["function_handle"].keywords["bedmethyl_file"] == "s1.bed.gz" assert captured["function_handle"].keywords["motif"] == "A,0" - assert summary["window_fraction"].tolist() == [0.5, 0.1] + assert summary["window_fraction"].tolist() == [0.5, 0.0] def test_compute_global_normalization_factors_from_summary(): From 62867a5dc81f5ecb8965026197e0bac0484af1bf Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 20:08:25 -0700 Subject: [PATCH 042/272] feat: add global analysis orchestration --- README.md | 5 ++-- dimelo/global_analysis.py | 51 ++++++++++++++++++++++++++++++++++- docs/global-analysis.md | 43 +++++++++++++++++++++++++++++ tests/test_global_analysis.py | 49 +++++++++++++++++++++++++++++++++ 4 files changed, 145 insertions(+), 3 deletions(-) create mode 100644 docs/global-analysis.md diff --git a/README.md b/README.md index 318fef8..d8f802e 100644 --- a/README.md +++ b/README.md @@ -220,10 +220,11 @@ def extract( override_checks: bool = False,) -> Path, Path: ``` -## Region contrasts +## Analysis Guides -Two higher-level analysis guides now sit on top of the existing parsing layer: +Three higher-level analysis guides now sit on top of the existing parsing layer: +- [docs/global-analysis.md](docs/global-analysis.md) for pileup-backed global summaries and normalization factors - [docs/shared-clustering.md](docs/shared-clustering.md) for shared-boundary clustering workflows - [docs/region-contrasts.md](docs/region-contrasts.md) for known-region motif-abundance contrasts diff --git a/dimelo/global_analysis.py b/dimelo/global_analysis.py index 28c93d9..93c5814 100644 --- a/dimelo/global_analysis.py +++ b/dimelo/global_analysis.py @@ -8,7 +8,7 @@ import pysam from . import load_processed, utils -from .models import SampleSpec +from .models import GlobalAnalysisResult, SampleSpec def _global_counts_from_bedmethyl( @@ -261,3 +261,52 @@ def compute_global_normalization_factors(summary: pd.DataFrame) -> pd.DataFrame: "global_offset", ], ].copy() + + +def run_global_analysis( + *, + samples: Sequence[SampleSpec], + motifs: Iterable[str], + genome_sizes: dict[str, int], + window_size: int, + step_size: int, + include_contigs: Iterable[str] | None = None, + exclude_contigs: Iterable[str] | None = None, + quiet: bool = True, + cores: int | None = None, +) -> GlobalAnalysisResult: + motifs = list(motifs) + summary = summarize_global_samples(samples=samples, motifs=motifs, quiet=quiet) + windows = build_window_summary( + samples=samples, + motifs=motifs, + genome_sizes=genome_sizes, + window_size=window_size, + step_size=step_size, + include_contigs=include_contigs, + exclude_contigs=exclude_contigs, + quiet=quiet, + cores=cores, + ) + normalization_factors = compute_global_normalization_factors(summary) + plot_data = { + "global_fraction_bar": summary.loc[ + :, + ["sample_id", "condition", "motif", "global_fraction"], + ].copy(), + "window_fraction_table": windows.copy(), + } + + return GlobalAnalysisResult( + summary=summary, + windows=windows, + normalization_factors=normalization_factors, + plot_data=plot_data, + metadata={ + "normalization_mode": "per_sample_global", + "window_size": window_size, + "step_size": step_size, + "motifs": motifs, + }, + figures={}, + ) diff --git a/docs/global-analysis.md b/docs/global-analysis.md new file mode 100644 index 0000000..a961484 --- /dev/null +++ b/docs/global-analysis.md @@ -0,0 +1,43 @@ +# Global Analysis + +`dimelo.global_analysis` provides pileup-backed whole-sample summaries and broad tiled-window summaries on top of `parse_bam.pileup()` outputs. + +## What It Covers + +- global motif fractions per sample and condition +- tiled window summaries across genome-size inputs +- reusable normalization factors derived from the global fractions + +## Example + +```python +from dimelo import global_analysis +from dimelo.models import SampleSpec + +result = global_analysis.run_global_analysis( + samples=[ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="output/s1.extract.h5", + metadata={"pileup_path": "output/s1.pileup.sorted.bed.gz"}, + ) + ], + motifs=["A,0"], + genome_sizes={"chr1": 248956422}, + window_size=100000, + step_size=50000, +) +``` + +## Canonical Outputs + +`run_global_analysis(...)` returns a `GlobalAnalysisResult` with data-first tables: + +- `result.summary` +- `result.windows` +- `result.normalization_factors` +- `result.plot_data["global_fraction_bar"]` +- `result.plot_data["window_fraction_table"]` + +The wrapper does not couple the workflow to a plotting backend. If you want to render the results yourself, use the returned tables directly. diff --git a/tests/test_global_analysis.py b/tests/test_global_analysis.py index 074bdc2..b736b95 100644 --- a/tests/test_global_analysis.py +++ b/tests/test_global_analysis.py @@ -273,3 +273,52 @@ def test_compute_global_normalization_factors_from_summary(): } assert factors.loc[factors["sample_id"] == "s1", "global_offset"].iloc[0] == pytest.approx(-0.1) assert factors.loc[factors["sample_id"] == "s2", "global_offset"].iloc[0] == pytest.approx(0.1) + + +def test_run_global_analysis_returns_result(monkeypatch): + samples = [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + metadata={"pileup_path": "s1.bed.gz"}, + ), + ] + + monkeypatch.setattr( + global_analysis, + "summarize_global_samples", + lambda *, samples, motifs, quiet=True: pd.DataFrame( + { + "sample_id": ["s1"], + "condition": ["NS"], + "replicate": [None], + "motif": ["A,0"], + "modified_count": [10], + "valid_count": [100], + "global_fraction": [0.1], + } + ), + ) + monkeypatch.setattr( + global_analysis, + "build_window_summary", + lambda **kwargs: pd.DataFrame({"window_id": ["chr1:0-1000"]}), + ) + monkeypatch.setattr( + global_analysis, + "compute_global_normalization_factors", + lambda summary: pd.DataFrame({"sample_id": ["s1"], "global_offset": [0.0]}), + ) + + result = global_analysis.run_global_analysis( + samples=samples, + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=1000, + step_size=1000, + ) + + assert list(result.summary["sample_id"]) == ["s1"] + assert list(result.windows["window_id"]) == ["chr1:0-1000"] + assert "global_fraction_bar" in result.plot_data From a8fb1cc1c0e8d4461924982c7ac5a20c38700e2b Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 22:18:56 -0700 Subject: [PATCH 043/272] fix: support multi-motif global analysis orchestration --- README.md | 2 +- dimelo/global_analysis.py | 29 +++++++++------ tests/test_global_analysis.py | 69 +++++++++++++++++++++++++++++++++++ 3 files changed, 88 insertions(+), 12 deletions(-) diff --git a/README.md b/README.md index d8f802e..d5aa44e 100644 --- a/README.md +++ b/README.md @@ -40,7 +40,7 @@ This README document contains installation instructions and documentation for va -[2.5 Clustering scaffolding](#clustering-scaffolding) --[2.6 Region contrasts](#region-contrasts) +-[2.6 Analysis guides](#analysis-guides) [3.0 Known Issues](#known-issues) diff --git a/dimelo/global_analysis.py b/dimelo/global_analysis.py index 93c5814..e489e58 100644 --- a/dimelo/global_analysis.py +++ b/dimelo/global_analysis.py @@ -276,18 +276,25 @@ def run_global_analysis( cores: int | None = None, ) -> GlobalAnalysisResult: motifs = list(motifs) + if len(motifs) == 0: + raise ValueError("run_global_analysis requires at least one motif.") + summary = summarize_global_samples(samples=samples, motifs=motifs, quiet=quiet) - windows = build_window_summary( - samples=samples, - motifs=motifs, - genome_sizes=genome_sizes, - window_size=window_size, - step_size=step_size, - include_contigs=include_contigs, - exclude_contigs=exclude_contigs, - quiet=quiet, - cores=cores, - ) + per_motif_windows = [ + build_window_summary( + samples=samples, + motifs=[motif], + genome_sizes=genome_sizes, + window_size=window_size, + step_size=step_size, + include_contigs=include_contigs, + exclude_contigs=exclude_contigs, + quiet=quiet, + cores=cores, + ) + for motif in motifs + ] + windows = pd.concat(per_motif_windows, ignore_index=True) normalization_factors = compute_global_normalization_factors(summary) plot_data = { "global_fraction_bar": summary.loc[ diff --git a/tests/test_global_analysis.py b/tests/test_global_analysis.py index b736b95..f431497 100644 --- a/tests/test_global_analysis.py +++ b/tests/test_global_analysis.py @@ -322,3 +322,72 @@ def test_run_global_analysis_returns_result(monkeypatch): assert list(result.summary["sample_id"]) == ["s1"] assert list(result.windows["window_id"]) == ["chr1:0-1000"] assert "global_fraction_bar" in result.plot_data + + +def test_run_global_analysis_supports_multiple_motifs(monkeypatch): + samples = [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + metadata={"pileup_path": "s1.bed.gz"}, + ), + ] + observed_build_calls = [] + + monkeypatch.setattr( + global_analysis, + "summarize_global_samples", + lambda *, samples, motifs, quiet=True: pd.DataFrame( + { + "sample_id": ["s1", "s1"], + "condition": ["NS", "NS"], + "replicate": [None, None], + "motif": list(motifs), + "modified_count": [10, 20], + "valid_count": [100, 200], + "global_fraction": [0.1, 0.1], + } + ), + ) + + def fake_build_window_summary(**kwargs): + motifs = list(kwargs["motifs"]) + observed_build_calls.append(motifs) + return pd.DataFrame( + { + "window_id": ["chr1:0-1000"], + "motif": motifs, + } + ) + + monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) + monkeypatch.setattr( + global_analysis, + "compute_global_normalization_factors", + lambda summary: pd.DataFrame( + {"sample_id": ["s1", "s1"], "motif": ["A,0", "CG,0"], "global_offset": [0.0, 0.0]} + ), + ) + + result = global_analysis.run_global_analysis( + samples=samples, + motifs=["A,0", "CG,0"], + genome_sizes={"chr1": 1000}, + window_size=1000, + step_size=1000, + ) + + assert observed_build_calls == [["A,0"], ["CG,0"]] + assert result.windows["motif"].tolist() == ["A,0", "CG,0"] + + +def test_run_global_analysis_requires_at_least_one_motif(): + with pytest.raises(ValueError, match="at least one motif"): + global_analysis.run_global_analysis( + samples=[], + motifs=[], + genome_sizes={"chr1": 1000}, + window_size=1000, + step_size=1000, + ) From bd812676f2f2d48335f9f5e40a3d615514388d86 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 22:21:29 -0700 Subject: [PATCH 044/272] feat: add region discovery result model --- dimelo/models.py | 23 +++++++++++++++++++++++ tests/test_models.py | 39 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 62 insertions(+) diff --git a/dimelo/models.py b/dimelo/models.py index dd0a1db..0a2773e 100644 --- a/dimelo/models.py +++ b/dimelo/models.py @@ -174,6 +174,29 @@ def __post_init__(self) -> None: ) +@dataclass +class RegionDiscoveryResult: + hits: pd.DataFrame + windows: pd.DataFrame + contrast: ContrastSpec | None + plot_data: dict[str, pd.DataFrame | dict[str, Any]] + metadata: dict[str, Any] = field(default_factory=dict) + figures: dict[str, Any] = field(default_factory=dict) + + def __post_init__(self) -> None: + required_fields = { + "hits": self.hits, + "windows": self.windows, + "plot_data": self.plot_data, + } + missing = [name for name, value in required_fields.items() if value is None] + if missing: + raise ValueError( + "RegionDiscoveryResult requires non-None values for: " + f"{', '.join(missing)}" + ) + + @dataclass class CohortSpec: cohort_id: str diff --git a/tests/test_models.py b/tests/test_models.py index 592d96d..abd9b6d 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -11,6 +11,7 @@ GlobalAnalysisResult, DatasetArtifact, SampleSpec, + RegionDiscoveryResult, RegionContrastResult, SharedClusterModel, SharedClusterResult, @@ -353,6 +354,44 @@ def test_region_contrast_result_rejects_none_contrast(): ) +def test_region_discovery_result_accepts_tables_and_plot_data(): + result = RegionDiscoveryResult( + hits=pd.DataFrame({"region": ["chr1:0-1000"]}), + windows=pd.DataFrame({"window_id": ["chr1:0-1000"]}), + contrast=None, + plot_data={ + "ranked_hits": pd.DataFrame({"region": ["chr1:0-1000"]}), + "summary": {"kind": "table"}, + }, + metadata={"analysis_unit": "genome"}, + figures={"hit_track": object()}, + ) + + assert list(result.hits["region"]) == ["chr1:0-1000"] + assert list(result.windows["window_id"]) == ["chr1:0-1000"] + assert result.plot_data["summary"] == {"kind": "table"} + assert result.metadata == {"analysis_unit": "genome"} + + +@pytest.mark.parametrize("field_name", ["hits", "windows", "plot_data"]) +def test_region_discovery_result_rejects_missing_required_fields(field_name): + kwargs = { + "hits": pd.DataFrame({"region": ["chr1:0-1000"]}), + "windows": pd.DataFrame({"window_id": ["chr1:0-1000"]}), + "contrast": None, + "plot_data": { + "ranked_hits": pd.DataFrame({"region": ["chr1:0-1000"]}), + "summary": {"kind": "table"}, + }, + "metadata": {"analysis_unit": "genome"}, + "figures": {}, + } + kwargs[field_name] = None + + with pytest.raises(ValueError, match=field_name): + RegionDiscoveryResult(**kwargs) + + def test_cohort_spec_stores_workflow_and_params(): cohort = CohortSpec( cohort_id="cohort-1", From 06b1e4fc8ece4c3f9bbf5374c312422f6d8dc640 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 22:28:04 -0700 Subject: [PATCH 045/272] feat: add deterministic region discovery scan --- dimelo/__init__.py | 2 + dimelo/region_discovery.py | 401 +++++++++++++++++++++++++++++++++ tests/test_region_discovery.py | 367 ++++++++++++++++++++++++++++++ 3 files changed, 770 insertions(+) create mode 100644 dimelo/region_discovery.py create mode 100644 tests/test_region_discovery.py diff --git a/dimelo/__init__.py b/dimelo/__init__.py index 83f23e7..fdf42ec 100644 --- a/dimelo/__init__.py +++ b/dimelo/__init__.py @@ -13,6 +13,7 @@ plot_enrichment_profile, plot_read_browser, plot_reads, + region_discovery, region_analysis, region_contrasts, workflows, @@ -33,6 +34,7 @@ "plot_enrichment_profile", "plot_read_browser", "plot_reads", + "region_discovery", "region_analysis", "region_contrasts", "workflows", diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py new file mode 100644 index 0000000..287b0ce --- /dev/null +++ b/dimelo/region_discovery.py @@ -0,0 +1,401 @@ +from __future__ import annotations + +from typing import Iterable + +import pandas as pd + +from . import global_analysis +from .models import ContrastSpec, RegionDiscoveryResult +from .region_contrasts import ( + _adjust_p_values_bh, + _beta_binomial_two_sided_p_value, + _estimate_beta_binomial_prior, +) + +_WINDOW_KEY_COLUMNS = ["window_id", "chromosome", "start", "end", "strand"] + + +def _validate_motifs(motifs: Iterable[str]) -> list[str]: + motif_list = list(motifs) + if len(motif_list) != 1: + raise ValueError("scan_genome currently supports exactly one motif.") + return motif_list + + +def _safe_fraction(modified_count: pd.Series, valid_count: pd.Series) -> pd.Series: + return modified_count.div(valid_count.where(valid_count != 0), fill_value=0).fillna(0.0) + + +def _aggregate_window_counts(summary: pd.DataFrame) -> pd.DataFrame: + if summary.empty: + return pd.DataFrame(columns=_WINDOW_KEY_COLUMNS + ["modified_count", "valid_count", "window_fraction"]) + + aggregated = ( + summary.groupby(_WINDOW_KEY_COLUMNS, as_index=False, sort=False) + .agg( + modified_count=("modified_count", "sum"), + valid_count=("valid_count", "sum"), + ) + .copy() + ) + aggregated["window_fraction"] = _safe_fraction( + aggregated["modified_count"], aggregated["valid_count"] + ) + return aggregated + + +def _aggregate_condition_counts(summary: pd.DataFrame) -> pd.DataFrame: + if summary.empty: + return pd.DataFrame( + columns=_WINDOW_KEY_COLUMNS + ["condition", "modified_count", "valid_count", "window_fraction"] + ) + + aggregated = ( + summary.groupby(_WINDOW_KEY_COLUMNS + ["condition"], as_index=False, sort=False) + .agg( + modified_count=("modified_count", "sum"), + valid_count=("valid_count", "sum"), + ) + .copy() + ) + aggregated["window_fraction"] = _safe_fraction( + aggregated["modified_count"], aggregated["valid_count"] + ) + return aggregated + + +def _condition_spread_scores(condition_counts: pd.DataFrame) -> pd.DataFrame: + if condition_counts.empty: + return pd.DataFrame(columns=_WINDOW_KEY_COLUMNS + ["score_value"]) + + spread = ( + condition_counts.groupby(_WINDOW_KEY_COLUMNS, as_index=False, sort=False) + .agg( + score_value=("window_fraction", lambda values: float(values.max() - values.min())), + ) + .copy() + ) + return spread + + +def _side_counts( + condition_counts: pd.DataFrame, + *, + conditions: Iterable[str], + side_name: str, +) -> pd.DataFrame: + side_conditions = list(conditions) + if not side_conditions: + return pd.DataFrame(columns=_WINDOW_KEY_COLUMNS + [f"{side_name}_modified_count", f"{side_name}_valid_count"]) + + side = condition_counts.loc[condition_counts["condition"].isin(side_conditions)].copy() + if side.empty: + return pd.DataFrame(columns=_WINDOW_KEY_COLUMNS + [f"{side_name}_modified_count", f"{side_name}_valid_count"]) + + grouped = ( + side.groupby(_WINDOW_KEY_COLUMNS, as_index=False, sort=False) + .agg( + **{ + f"{side_name}_modified_count": ("modified_count", "sum"), + f"{side_name}_valid_count": ("valid_count", "sum"), + } + ) + .copy() + ) + return grouped + + +def _score_with_contrast( + window_totals: pd.DataFrame, + condition_counts: pd.DataFrame, + *, + contrast: ContrastSpec | None, + score: str, +) -> pd.DataFrame: + if score == "beta_binomial": + available_conditions = sorted(condition_counts["condition"].dropna().unique().tolist()) + if contrast is not None and contrast.numerator and contrast.denominator: + numerator_conditions = list(contrast.numerator) + denominator_conditions = list(contrast.denominator) + elif len(available_conditions) >= 2: + numerator_conditions = [available_conditions[0]] + denominator_conditions = [available_conditions[1]] + else: + numerator_conditions = [] + denominator_conditions = [] + + if not numerator_conditions and not denominator_conditions: + scored = window_totals.copy() + scored["score_value"] = 0.0 + scored["p_value"] = 1.0 + scored["adjusted_p_value"] = 1.0 + return scored + + numerator_counts = _side_counts( + condition_counts, conditions=numerator_conditions, side_name="numerator" + ) + denominator_counts = _side_counts( + condition_counts, conditions=denominator_conditions, side_name="denominator" + ) + + scored = window_totals.merge(numerator_counts, on=_WINDOW_KEY_COLUMNS, how="left") + scored = scored.merge(denominator_counts, on=_WINDOW_KEY_COLUMNS, how="left") + + for column in [ + "numerator_modified_count", + "numerator_valid_count", + "denominator_modified_count", + "denominator_valid_count", + ]: + scored[column] = scored[column].fillna(0).astype(int) + + scored["score_value"] = _safe_fraction( + scored["numerator_modified_count"], scored["numerator_valid_count"] + ) - _safe_fraction(scored["denominator_modified_count"], scored["denominator_valid_count"]) + + scored["p_value"] = [ + _beta_binomial_two_sided_p_value( + int(numerator_modified_count), + int(numerator_valid_count), + *_estimate_beta_binomial_prior( + int(denominator_modified_count), + int(denominator_valid_count), + ), + ) + for numerator_modified_count, numerator_valid_count, denominator_modified_count, denominator_valid_count in zip( + scored["numerator_modified_count"], + scored["numerator_valid_count"], + scored["denominator_modified_count"], + scored["denominator_valid_count"], + ) + ] + scored["adjusted_p_value"] = _adjust_p_values_bh(scored["p_value"]) + return scored + + if contrast is None or not contrast.numerator or not contrast.denominator: + spread = _condition_spread_scores(condition_counts) + scored = window_totals.merge(spread, on=_WINDOW_KEY_COLUMNS, how="left") + scored["score_value"] = scored["score_value"].fillna(0.0) + scored["p_value"] = pd.NA + scored["adjusted_p_value"] = pd.NA + return scored + + numerator_counts = _side_counts( + condition_counts, conditions=contrast.numerator, side_name="numerator" + ) + denominator_counts = _side_counts( + condition_counts, conditions=contrast.denominator, side_name="denominator" + ) + + scored = window_totals.merge(numerator_counts, on=_WINDOW_KEY_COLUMNS, how="left") + scored = scored.merge(denominator_counts, on=_WINDOW_KEY_COLUMNS, how="left") + + for column in [ + "numerator_modified_count", + "numerator_valid_count", + "denominator_modified_count", + "denominator_valid_count", + ]: + scored[column] = scored[column].fillna(0).astype(int) + + scored["score_value"] = _safe_fraction( + scored["numerator_modified_count"], scored["numerator_valid_count"] + ) - _safe_fraction(scored["denominator_modified_count"], scored["denominator_valid_count"]) + + if score == "beta_binomial": + scored["p_value"] = [ + _beta_binomial_two_sided_p_value( + int(numerator_modified_count), + int(numerator_valid_count), + *_estimate_beta_binomial_prior( + int(denominator_modified_count), + int(denominator_valid_count), + ), + ) + for numerator_modified_count, numerator_valid_count, denominator_modified_count, denominator_valid_count in zip( + scored["numerator_modified_count"], + scored["numerator_valid_count"], + scored["denominator_modified_count"], + scored["denominator_valid_count"], + ) + ] + else: + scored["p_value"] = pd.NA + scored["adjusted_p_value"] = pd.NA + + return scored + + +def _rank_windows(scored: pd.DataFrame, *, score: str) -> pd.DataFrame: + if scored.empty: + return scored.assign(rank=pd.Series(dtype="float64")) + + if score == "beta_binomial": + ranked = scored.sort_values( + by=["adjusted_p_value", "p_value", "score_value", "chromosome", "start", "end"], + ascending=[True, True, False, True, True, True], + kind="mergesort", + na_position="last", + ).reset_index(drop=True) + else: + ranked = scored.sort_values( + by=["score_value", "chromosome", "start", "end"], + ascending=[False, True, True, True], + kind="mergesort", + na_position="last", + ).reset_index(drop=True) + + ranked["rank"] = range(1, len(ranked) + 1) + return ranked + + +def _apply_min_coverage( + scored: pd.DataFrame, + *, + min_coverage: int, +) -> tuple[pd.DataFrame, pd.DataFrame]: + if scored.empty: + return scored.copy(), scored.copy() + + filtered = scored.copy() + covered = filtered["valid_count"] >= min_coverage + filtered.loc[~covered, ["score_value", "p_value", "adjusted_p_value", "rank"]] = pd.NA + hits = filtered.loc[covered].copy() + return filtered, hits + + +def _merge_adjacent_hits(hits: pd.DataFrame, *, merge_distance: int) -> pd.DataFrame: + if hits.empty or len(hits) == 1: + return hits.copy() + + ordered = hits.sort_values( + by=["chromosome", "start", "end", "rank"], + ascending=[True, True, True, True], + kind="mergesort", + ).reset_index(drop=True) + + merged_rows: list[dict[str, object]] = [] + current = ordered.iloc[0].to_dict() + current["merged_window_count"] = 1 + + def _as_float(value: object) -> float | None: + return None if pd.isna(value) else float(value) + + for _, row in ordered.iloc[1:].iterrows(): + same_chromosome = row["chromosome"] == current["chromosome"] + within_distance = row["start"] <= int(current["end"]) + merge_distance + if same_chromosome and within_distance: + current["end"] = max(int(current["end"]), int(row["end"])) + current["modified_count"] = int(current["modified_count"]) + int(row["modified_count"]) + current["valid_count"] = int(current["valid_count"]) + int(row["valid_count"]) + current_score = _as_float(current.get("score_value")) + row_score = _as_float(row.get("score_value")) + if current_score is None: + current["score_value"] = row_score + elif row_score is not None: + current["score_value"] = max(current_score, row_score) + current_p_value = _as_float(current.get("p_value")) + row_p_value = _as_float(row.get("p_value")) + if current_p_value is None: + current["p_value"] = row_p_value + elif row_p_value is not None: + current["p_value"] = min(current_p_value, row_p_value) + + current_adjusted = _as_float(current.get("adjusted_p_value")) + row_adjusted = _as_float(row.get("adjusted_p_value")) + if current_adjusted is None: + current["adjusted_p_value"] = row_adjusted + elif row_adjusted is not None: + current["adjusted_p_value"] = min(current_adjusted, row_adjusted) + current["rank"] = min(int(current["rank"]), int(row["rank"])) + current["merged_window_count"] += 1 + continue + + merged_rows.append(current) + current = row.to_dict() + current["merged_window_count"] = 1 + + merged_rows.append(current) + merged = pd.DataFrame(merged_rows) + merged["rank"] = range(1, len(merged) + 1) + return merged + + +def scan_genome( + *, + samples, + motifs: Iterable[str], + genome_sizes: dict[str, int], + window_size: int, + step_size: int, + include_contigs: Iterable[str] | None = None, + exclude_contigs: Iterable[str] | None = None, + min_coverage: int = 0, + merge_hits: bool = False, + merge_distance: int = 0, + score: str = "effect_size_only", + contrast: ContrastSpec | None = None, + quiet: bool = True, + cores: int | None = None, +) -> RegionDiscoveryResult: + motif_list = _validate_motifs(motifs) + if score not in {"effect_size_only", "beta_binomial"}: + raise ValueError("scan_genome requires score in {'effect_size_only', 'beta_binomial'}.") + + window_summary = global_analysis.build_window_summary( + samples=samples, + motifs=motif_list, + genome_sizes=genome_sizes, + window_size=window_size, + step_size=step_size, + include_contigs=include_contigs, + exclude_contigs=exclude_contigs, + quiet=quiet, + cores=cores, + ) + + window_totals = _aggregate_window_counts(window_summary) + condition_counts = _aggregate_condition_counts(window_summary) + scored = _score_with_contrast( + window_totals=window_totals, + condition_counts=condition_counts, + contrast=contrast, + score=score, + ) + ranked = _rank_windows(scored, score=score) + window_table, hits = _apply_min_coverage(ranked, min_coverage=min_coverage) + + if merge_hits: + hits = _merge_adjacent_hits(hits, merge_distance=merge_distance) + + plot_data = { + "window_score_table": window_table.copy(), + "top_hits_table": hits.copy(), + } + metadata = { + "analysis_unit": "de_novo_window", + "representation": "modified_fraction", + "signal_source": "pileup_counts", + "score": score, + "window_size": window_size, + "step_size": step_size, + "min_coverage": min_coverage, + "merge_hits": merge_hits, + "merge_distance": merge_distance, + "motifs": motif_list, + "include_contigs": list(include_contigs) if include_contigs is not None else None, + "exclude_contigs": list(exclude_contigs) if exclude_contigs is not None else None, + } + if contrast is not None: + metadata["contrast_mode"] = contrast.mode + metadata["contrast_numerator"] = list(contrast.numerator or []) + metadata["contrast_denominator"] = list(contrast.denominator or []) + + return RegionDiscoveryResult( + hits=hits.reset_index(drop=True), + windows=window_table.reset_index(drop=True), + contrast=contrast, + plot_data=plot_data, + metadata=metadata, + figures={}, + ) diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py new file mode 100644 index 0000000..652a222 --- /dev/null +++ b/tests/test_region_discovery.py @@ -0,0 +1,367 @@ +from __future__ import annotations + +import pandas as pd +import pytest + +from dimelo import global_analysis +from dimelo.models import ContrastSpec, RegionDiscoveryResult, SampleSpec + +from dimelo import region_discovery + + +def _mock_window_summary() -> pd.DataFrame: + return pd.DataFrame( + [ + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-1000", + "chromosome": "chr1", + "start": 0, + "end": 1000, + "strand": ".", + "modified_count": 10, + "valid_count": 20, + "window_fraction": 0.5, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-1000", + "chromosome": "chr1", + "start": 0, + "end": 1000, + "strand": ".", + "modified_count": 18, + "valid_count": 20, + "window_fraction": 0.9, + }, + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-2000", + "chromosome": "chr1", + "start": 1000, + "end": 2000, + "strand": ".", + "modified_count": 12, + "valid_count": 20, + "window_fraction": 0.6, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-2000", + "chromosome": "chr1", + "start": 1000, + "end": 2000, + "strand": ".", + "modified_count": 14, + "valid_count": 20, + "window_fraction": 0.7, + }, + ] + ) + + +def test_scan_genome_basic_behavior_with_mocked_window_summary(monkeypatch): + captured = {} + + def fake_build_window_summary(**kwargs): + captured.update(kwargs) + return _mock_window_summary() + + monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) + + result = region_discovery.scan_genome( + samples=[ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + metadata={"pileup_path": "s1.bed.gz"}, + ), + SampleSpec( + sample_id="s2", + condition="treated", + extract_h5="s2.h5", + metadata={"pileup_path": "s2.bed.gz"}, + ), + ], + motifs=["A,0"], + genome_sizes={"chr1": 2000}, + window_size=1000, + step_size=1000, + contrast=ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["NS"], + reference_condition="NS", + ), + score="effect_size_only", + min_coverage=5, + ) + + assert isinstance(result, RegionDiscoveryResult) + assert captured["motifs"] == ["A,0"] + assert captured["window_size"] == 1000 + assert captured["step_size"] == 1000 + assert list(result.windows["window_id"]) == ["chr1:0-1000", "chr1:1000-2000"] + assert result.windows.loc[0, "score_value"] == pytest.approx(0.4) + assert list(result.hits["rank"]) == [1, 2] + assert list(result.hits["window_id"]) == ["chr1:0-1000", "chr1:1000-2000"] + assert set(result.plot_data) >= {"window_score_table", "top_hits_table"} + assert result.metadata["score"] == "effect_size_only" + + +def test_scan_genome_filters_low_coverage_windows(monkeypatch): + def fake_build_window_summary(**kwargs): + return pd.DataFrame( + [ + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-1000", + "chromosome": "chr1", + "start": 0, + "end": 1000, + "strand": ".", + "modified_count": 10, + "valid_count": 20, + "window_fraction": 0.5, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-1000", + "chromosome": "chr1", + "start": 0, + "end": 1000, + "strand": ".", + "modified_count": 18, + "valid_count": 20, + "window_fraction": 0.9, + }, + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-2000", + "chromosome": "chr1", + "start": 1000, + "end": 2000, + "strand": ".", + "modified_count": 1, + "valid_count": 2, + "window_fraction": 0.5, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-2000", + "chromosome": "chr1", + "start": 1000, + "end": 2000, + "strand": ".", + "modified_count": 1, + "valid_count": 2, + "window_fraction": 0.5, + }, + ] + ) + + monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) + + result = region_discovery.scan_genome( + samples=[ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + metadata={"pileup_path": "s1.bed.gz"}, + ), + SampleSpec( + sample_id="s2", + condition="treated", + extract_h5="s2.h5", + metadata={"pileup_path": "s2.bed.gz"}, + ), + ], + motifs=["A,0"], + genome_sizes={"chr1": 2000}, + window_size=1000, + step_size=1000, + contrast=ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["NS"], + reference_condition="NS", + ), + score="effect_size_only", + min_coverage=10, + ) + + assert list(result.hits["window_id"]) == ["chr1:0-1000"] + low_coverage = result.windows.loc[ + result.windows["window_id"] == "chr1:1000-2000", "score_value" + ] + assert low_coverage.isna().all() + assert result.windows.loc[ + result.windows["window_id"] == "chr1:1000-2000", "rank" + ].isna().all() + + +def test_scan_genome_hands_include_and_exclude_contigs_to_window_builder(monkeypatch): + captured = {} + + def fake_build_window_summary(**kwargs): + captured.update(kwargs) + return pd.DataFrame( + columns=[ + "sample_id", + "condition", + "replicate", + "motif", + "window_id", + "chromosome", + "start", + "end", + "strand", + "modified_count", + "valid_count", + "window_fraction", + ] + ) + + monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) + + region_discovery.scan_genome( + samples=[], + motifs=["A,0"], + genome_sizes={"chr1": 2000, "chr2": 1000}, + window_size=1000, + step_size=500, + include_contigs=["chr1"], + exclude_contigs=["chr2"], + score="effect_size_only", + ) + + assert captured["include_contigs"] == ["chr1"] + assert captured["exclude_contigs"] == ["chr2"] + + +def test_scan_genome_beta_binomial_adds_ranking_fields(monkeypatch): + def fake_build_window_summary(**kwargs): + return pd.DataFrame( + [ + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-1000", + "chromosome": "chr1", + "start": 0, + "end": 1000, + "strand": ".", + "modified_count": 4, + "valid_count": 20, + "window_fraction": 0.2, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-1000", + "chromosome": "chr1", + "start": 0, + "end": 1000, + "strand": ".", + "modified_count": 16, + "valid_count": 20, + "window_fraction": 0.8, + }, + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-2000", + "chromosome": "chr1", + "start": 1000, + "end": 2000, + "strand": ".", + "modified_count": 10, + "valid_count": 20, + "window_fraction": 0.5, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-2000", + "chromosome": "chr1", + "start": 1000, + "end": 2000, + "strand": ".", + "modified_count": 12, + "valid_count": 20, + "window_fraction": 0.6, + }, + ] + ) + + monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) + + result = region_discovery.scan_genome( + samples=[ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + metadata={"pileup_path": "s1.bed.gz"}, + ), + SampleSpec( + sample_id="s2", + condition="treated", + extract_h5="s2.h5", + metadata={"pileup_path": "s2.bed.gz"}, + ), + ], + motifs=["A,0"], + genome_sizes={"chr1": 2000}, + window_size=1000, + step_size=1000, + contrast=ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["NS"], + reference_condition="NS", + ), + score="beta_binomial", + min_coverage=5, + ) + + assert {"score_value", "p_value", "adjusted_p_value", "rank"}.issubset( + result.windows.columns + ) + assert list(result.hits["rank"]) == [1, 2] + assert result.windows.loc[0, "adjusted_p_value"] <= result.windows.loc[1, "adjusted_p_value"] + assert result.hits.loc[0, "score_value"] >= result.hits.loc[1, "score_value"] From b0b1788fe14426e2cdc4ad32f0357a2dbdaf5b89 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 22:36:19 -0700 Subject: [PATCH 046/272] fix: tighten region discovery scan behavior --- dimelo/region_discovery.py | 114 +++++++- tests/test_region_discovery.py | 484 +++++++++++++++++++++++++++++++++ 2 files changed, 587 insertions(+), 11 deletions(-) diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py index 287b0ce..66479d3 100644 --- a/dimelo/region_discovery.py +++ b/dimelo/region_discovery.py @@ -105,6 +105,31 @@ def _side_counts( return grouped +def _validate_contrast_conditions( + *, + condition_counts: pd.DataFrame, + contrast: ContrastSpec | None, +) -> None: + if contrast is None: + return + + available_conditions = set(condition_counts["condition"].dropna().tolist()) + missing: list[str] = [] + for side_name, conditions in ( + ("numerator", contrast.numerator or []), + ("denominator", contrast.denominator or []), + ): + absent = sorted(set(conditions) - available_conditions) + if absent: + missing.append(f"{side_name}: {', '.join(absent)}") + + if missing: + raise ValueError( + "scan_genome contrast requested missing condition(s): " + + "; ".join(missing) + ) + + def _score_with_contrast( window_totals: pd.DataFrame, condition_counts: pd.DataFrame, @@ -151,7 +176,9 @@ def _score_with_contrast( scored["score_value"] = _safe_fraction( scored["numerator_modified_count"], scored["numerator_valid_count"] - ) - _safe_fraction(scored["denominator_modified_count"], scored["denominator_valid_count"]) + ).sub( + _safe_fraction(scored["denominator_modified_count"], scored["denominator_valid_count"]) + ).abs() scored["p_value"] = [ _beta_binomial_two_sided_p_value( @@ -200,7 +227,9 @@ def _score_with_contrast( scored["score_value"] = _safe_fraction( scored["numerator_modified_count"], scored["numerator_valid_count"] - ) - _safe_fraction(scored["denominator_modified_count"], scored["denominator_valid_count"]) + ).sub( + _safe_fraction(scored["denominator_modified_count"], scored["denominator_valid_count"]) + ).abs() if score == "beta_binomial": scored["p_value"] = [ @@ -266,11 +295,21 @@ def _apply_min_coverage( def _merge_adjacent_hits(hits: pd.DataFrame, *, merge_distance: int) -> pd.DataFrame: if hits.empty or len(hits) == 1: - return hits.copy() + merged = hits.copy() + if not merged.empty and "window_id" in merged.columns: + merged["window_id"] = merged.apply( + lambda row: f"{row['chromosome']}:{int(row['start'])}-{int(row['end'])}", + axis=1, + ) + if {"modified_count", "valid_count"}.issubset(merged.columns): + merged["window_fraction"] = _safe_fraction( + merged["modified_count"], merged["valid_count"] + ) + return merged ordered = hits.sort_values( - by=["chromosome", "start", "end", "rank"], - ascending=[True, True, True, True], + by=["chromosome", "strand", "start", "end", "rank"], + ascending=[True, True, True, True, True], kind="mergesort", ).reset_index(drop=True) @@ -281,11 +320,36 @@ def _merge_adjacent_hits(hits: pd.DataFrame, *, merge_distance: int) -> pd.DataF def _as_float(value: object) -> float | None: return None if pd.isna(value) else float(value) + def _finalize_current() -> None: + current["window_id"] = f"{current['chromosome']}:{int(current['start'])}-{int(current['end'])}" + current_valid_count = int(current.get("valid_count", 0)) + current_modified_count = int(current.get("modified_count", 0)) + current["window_fraction"] = ( + 0.0 + if current_valid_count == 0 + else current_modified_count / current_valid_count + ) + if {"numerator_modified_count", "numerator_valid_count", "denominator_modified_count", "denominator_valid_count"}.issubset(current): + numerator_fraction = ( + 0.0 + if int(current["numerator_valid_count"]) == 0 + else int(current["numerator_modified_count"]) / int(current["numerator_valid_count"]) + ) + denominator_fraction = ( + 0.0 + if int(current["denominator_valid_count"]) == 0 + else int(current["denominator_modified_count"]) / int(current["denominator_valid_count"]) + ) + current["score_value"] = abs(numerator_fraction - denominator_fraction) + merged_rows.append(current.copy()) + for _, row in ordered.iloc[1:].iterrows(): same_chromosome = row["chromosome"] == current["chromosome"] + same_strand = row.get("strand") == current.get("strand") within_distance = row["start"] <= int(current["end"]) + merge_distance - if same_chromosome and within_distance: + if same_chromosome and same_strand and within_distance: current["end"] = max(int(current["end"]), int(row["end"])) + current["start"] = min(int(current["start"]), int(row["start"])) current["modified_count"] = int(current["modified_count"]) + int(row["modified_count"]) current["valid_count"] = int(current["valid_count"]) + int(row["valid_count"]) current_score = _as_float(current.get("score_value")) @@ -311,12 +375,17 @@ def _as_float(value: object) -> float | None: current["merged_window_count"] += 1 continue - merged_rows.append(current) + _finalize_current() current = row.to_dict() current["merged_window_count"] = 1 - merged_rows.append(current) + _finalize_current() merged = pd.DataFrame(merged_rows) + merged = merged.sort_values( + by=["chromosome", "strand", "start", "end", "rank"], + ascending=[True, True, True, True, True], + kind="mergesort", + ).reset_index(drop=True) merged["rank"] = range(1, len(merged) + 1) return merged @@ -356,14 +425,37 @@ def scan_genome( window_totals = _aggregate_window_counts(window_summary) condition_counts = _aggregate_condition_counts(window_summary) + _validate_contrast_conditions(condition_counts=condition_counts, contrast=contrast) + + covered_mask = window_totals["valid_count"] >= min_coverage + covered_window_totals = window_totals.loc[covered_mask].copy() + covered_keys = covered_window_totals.loc[:, _WINDOW_KEY_COLUMNS] + covered_condition_counts = condition_counts.merge( + covered_keys, + on=_WINDOW_KEY_COLUMNS, + how="inner", + ) + scored = _score_with_contrast( - window_totals=window_totals, - condition_counts=condition_counts, + window_totals=covered_window_totals, + condition_counts=covered_condition_counts, contrast=contrast, score=score, ) ranked = _rank_windows(scored, score=score) - window_table, hits = _apply_min_coverage(ranked, min_coverage=min_coverage) + scored_columns = [ + column + for column in ranked.columns + if column not in _WINDOW_KEY_COLUMNS + and column not in {"modified_count", "valid_count", "window_fraction"} + ] + window_table = window_totals.merge( + ranked.loc[:, _WINDOW_KEY_COLUMNS + scored_columns], + on=_WINDOW_KEY_COLUMNS, + how="left", + sort=False, + ) + hits = ranked.copy() if merge_hits: hits = _merge_adjacent_hits(hits, merge_distance=merge_distance) diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index 652a222..02c96cf 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -365,3 +365,487 @@ def fake_build_window_summary(**kwargs): assert list(result.hits["rank"]) == [1, 2] assert result.windows.loc[0, "adjusted_p_value"] <= result.windows.loc[1, "adjusted_p_value"] assert result.hits.loc[0, "score_value"] >= result.hits.loc[1, "score_value"] + + +def test_scan_genome_excludes_low_coverage_before_beta_binomial_scoring(monkeypatch): + observed_p_value_calls = [] + observed_bh_inputs = [] + + def fake_build_window_summary(**kwargs): + return pd.DataFrame( + [ + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-1000", + "chromosome": "chr1", + "start": 0, + "end": 1000, + "strand": ".", + "modified_count": 5, + "valid_count": 20, + "window_fraction": 0.25, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-1000", + "chromosome": "chr1", + "start": 0, + "end": 1000, + "strand": ".", + "modified_count": 15, + "valid_count": 20, + "window_fraction": 0.75, + }, + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-2000", + "chromosome": "chr1", + "start": 1000, + "end": 2000, + "strand": ".", + "modified_count": 1, + "valid_count": 1, + "window_fraction": 1.0, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-2000", + "chromosome": "chr1", + "start": 1000, + "end": 2000, + "strand": ".", + "modified_count": 0, + "valid_count": 1, + "window_fraction": 0.0, + }, + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:2000-3000", + "chromosome": "chr1", + "start": 2000, + "end": 3000, + "strand": ".", + "modified_count": 8, + "valid_count": 20, + "window_fraction": 0.4, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:2000-3000", + "chromosome": "chr1", + "start": 2000, + "end": 3000, + "strand": ".", + "modified_count": 12, + "valid_count": 20, + "window_fraction": 0.6, + }, + ] + ) + + def fake_p_value(modified_count, valid_count, alpha, beta): + observed_p_value_calls.append((modified_count, valid_count, alpha, beta)) + return 0.5 + + def fake_bh_adjustment(p_values): + observed_bh_inputs.append(len(p_values)) + return p_values.astype(float) + + monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) + monkeypatch.setattr(region_discovery, "_beta_binomial_two_sided_p_value", fake_p_value) + monkeypatch.setattr(region_discovery, "_adjust_p_values_bh", fake_bh_adjustment) + + result = region_discovery.scan_genome( + samples=[], + motifs=["A,0"], + genome_sizes={"chr1": 3000}, + window_size=1000, + step_size=1000, + contrast=ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["NS"], + reference_condition="NS", + ), + score="beta_binomial", + min_coverage=10, + ) + + assert len(observed_p_value_calls) == 2 + assert observed_bh_inputs == [2] + assert list(result.hits["window_id"]) == ["chr1:0-1000", "chr1:2000-3000"] + + +def test_scan_genome_effect_size_only_ranks_by_absolute_difference(monkeypatch): + def fake_build_window_summary(**kwargs): + return pd.DataFrame( + [ + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-1000", + "chromosome": "chr1", + "start": 0, + "end": 1000, + "strand": ".", + "modified_count": 19, + "valid_count": 20, + "window_fraction": 0.95, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-1000", + "chromosome": "chr1", + "start": 0, + "end": 1000, + "strand": ".", + "modified_count": 1, + "valid_count": 20, + "window_fraction": 0.05, + }, + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-2000", + "chromosome": "chr1", + "start": 1000, + "end": 2000, + "strand": ".", + "modified_count": 5, + "valid_count": 20, + "window_fraction": 0.25, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-2000", + "chromosome": "chr1", + "start": 1000, + "end": 2000, + "strand": ".", + "modified_count": 15, + "valid_count": 20, + "window_fraction": 0.75, + }, + ] + ) + + monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) + + result = region_discovery.scan_genome( + samples=[], + motifs=["A,0"], + genome_sizes={"chr1": 2000}, + window_size=1000, + step_size=1000, + contrast=ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["NS"], + reference_condition="NS", + ), + score="effect_size_only", + min_coverage=1, + ) + + assert list(result.hits["window_id"]) == ["chr1:0-1000", "chr1:1000-2000"] + assert list(result.hits["score_value"]) == [pytest.approx(0.9), pytest.approx(0.5)] + + +def test_scan_genome_raises_for_missing_contrast_condition(monkeypatch): + def fake_build_window_summary(**kwargs): + return pd.DataFrame( + [ + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-1000", + "chromosome": "chr1", + "start": 0, + "end": 1000, + "strand": ".", + "modified_count": 10, + "valid_count": 20, + "window_fraction": 0.5, + } + ] + ) + + monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) + + with pytest.raises(ValueError, match="treated"): + region_discovery.scan_genome( + samples=[], + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=1000, + step_size=1000, + contrast=ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["NS"], + reference_condition="NS", + ), + score="effect_size_only", + min_coverage=1, + ) + + +def test_scan_genome_reranks_hits_after_min_coverage_filtering(monkeypatch): + def fake_build_window_summary(**kwargs): + return pd.DataFrame( + [ + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-1000", + "chromosome": "chr1", + "start": 0, + "end": 1000, + "strand": ".", + "modified_count": 1, + "valid_count": 20, + "window_fraction": 0.05, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-1000", + "chromosome": "chr1", + "start": 0, + "end": 1000, + "strand": ".", + "modified_count": 19, + "valid_count": 20, + "window_fraction": 0.95, + }, + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-2000", + "chromosome": "chr1", + "start": 1000, + "end": 2000, + "strand": ".", + "modified_count": 1, + "valid_count": 1, + "window_fraction": 1.0, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-2000", + "chromosome": "chr1", + "start": 1000, + "end": 2000, + "strand": ".", + "modified_count": 0, + "valid_count": 1, + "window_fraction": 0.0, + }, + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:2000-3000", + "chromosome": "chr1", + "start": 2000, + "end": 3000, + "strand": ".", + "modified_count": 6, + "valid_count": 20, + "window_fraction": 0.3, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:2000-3000", + "chromosome": "chr1", + "start": 2000, + "end": 3000, + "strand": ".", + "modified_count": 14, + "valid_count": 20, + "window_fraction": 0.7, + }, + ] + ) + + monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) + + result = region_discovery.scan_genome( + samples=[], + motifs=["A,0"], + genome_sizes={"chr1": 3000}, + window_size=1000, + step_size=1000, + contrast=ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["NS"], + reference_condition="NS", + ), + score="effect_size_only", + min_coverage=10, + ) + + assert list(result.hits["window_id"]) == ["chr1:0-1000", "chr1:2000-3000"] + assert list(result.hits["rank"]) == [1, 2] + + +def test_scan_genome_merge_hits_keeps_strand_and_recomputes_window_fields(monkeypatch): + def fake_build_window_summary(**kwargs): + return pd.DataFrame( + [ + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-1000", + "chromosome": "chr1", + "start": 0, + "end": 1000, + "strand": "+", + "modified_count": 1, + "valid_count": 10, + "window_fraction": 0.1, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-1000", + "chromosome": "chr1", + "start": 0, + "end": 1000, + "strand": "+", + "modified_count": 1, + "valid_count": 10, + "window_fraction": 0.1, + }, + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-2000", + "chromosome": "chr1", + "start": 1000, + "end": 2000, + "strand": "+", + "modified_count": 4, + "valid_count": 10, + "window_fraction": 0.4, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-2000", + "chromosome": "chr1", + "start": 1000, + "end": 2000, + "strand": "+", + "modified_count": 4, + "valid_count": 10, + "window_fraction": 0.4, + }, + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:2000-3000", + "chromosome": "chr1", + "start": 2000, + "end": 3000, + "strand": "-", + "modified_count": 5, + "valid_count": 10, + "window_fraction": 0.5, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:2000-3000", + "chromosome": "chr1", + "start": 2000, + "end": 3000, + "strand": "-", + "modified_count": 5, + "valid_count": 10, + "window_fraction": 0.5, + }, + ] + ) + + monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) + + result = region_discovery.scan_genome( + samples=[], + motifs=["A,0"], + genome_sizes={"chr1": 3000}, + window_size=1000, + step_size=1000, + contrast=ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["NS"], + reference_condition="NS", + ), + score="effect_size_only", + min_coverage=1, + merge_hits=True, + merge_distance=1000, + ) + + assert list(result.hits["window_id"]) == ["chr1:0-2000", "chr1:2000-3000"] + assert list(result.hits["strand"]) == ["+", "-"] + assert result.hits.loc[0, "window_fraction"] == pytest.approx(0.25) + assert result.hits.loc[0, "merged_window_count"] == 2 + assert list(result.hits["rank"]) == [1, 2] From 8289de8bd95e145ae80e611dae5beafb9eeb2477 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 22:39:53 -0700 Subject: [PATCH 047/272] fix: reject unsupported region discovery contrast modes --- dimelo/region_discovery.py | 4 ++++ tests/test_region_discovery.py | 19 +++++++++++++++++++ 2 files changed, 23 insertions(+) diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py index 66479d3..8510505 100644 --- a/dimelo/region_discovery.py +++ b/dimelo/region_discovery.py @@ -410,6 +410,10 @@ def scan_genome( motif_list = _validate_motifs(motifs) if score not in {"effect_size_only", "beta_binomial"}: raise ValueError("scan_genome requires score in {'effect_size_only', 'beta_binomial'}.") + if contrast is not None and contrast.mode not in {"pairwise", "group_vs_group"}: + raise ValueError( + "scan_genome currently supports only pairwise/group_vs_group contrast modes." + ) window_summary = global_analysis.build_window_summary( samples=samples, diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index 02c96cf..09d1b8d 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -620,6 +620,25 @@ def fake_build_window_summary(**kwargs): ) +def test_scan_genome_rejects_unimplemented_contrast_modes(): + with pytest.raises(ValueError, match="pairwise/group_vs_group"): + region_discovery.scan_genome( + samples=[], + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=1000, + step_size=1000, + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["treated"], + denominator=["NS"], + pairing_key="donor", + ), + score="effect_size_only", + min_coverage=1, + ) + + def test_scan_genome_reranks_hits_after_min_coverage_filtering(monkeypatch): def fake_build_window_summary(**kwargs): return pd.DataFrame( From 764cfc6d113559041ec2207a1bd727dad1e75775 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 22:44:28 -0700 Subject: [PATCH 048/272] feat: add region discovery merge and bed export helpers --- dimelo/region_discovery.py | 246 ++++++++++++++++++++++----------- tests/test_region_discovery.py | 87 ++++++++++++ 2 files changed, 251 insertions(+), 82 deletions(-) diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py index 8510505..e0ffa95 100644 --- a/dimelo/region_discovery.py +++ b/dimelo/region_discovery.py @@ -13,6 +13,8 @@ ) _WINDOW_KEY_COLUMNS = ["window_id", "chromosome", "start", "end", "strand"] +_HIT_SORT_COLUMNS = ["chromosome", "strand", "start", "end", "rank"] +_BED_COLUMNS = ["chrom", "start", "end", "name", "score", "strand"] def _validate_motifs(motifs: Iterable[str]) -> list[str]: @@ -293,101 +295,181 @@ def _apply_min_coverage( return filtered, hits -def _merge_adjacent_hits(hits: pd.DataFrame, *, merge_distance: int) -> pd.DataFrame: - if hits.empty or len(hits) == 1: - merged = hits.copy() - if not merged.empty and "window_id" in merged.columns: - merged["window_id"] = merged.apply( - lambda row: f"{row['chromosome']}:{int(row['start'])}-{int(row['end'])}", - axis=1, - ) - if {"modified_count", "valid_count"}.issubset(merged.columns): - merged["window_fraction"] = _safe_fraction( - merged["modified_count"], merged["valid_count"] - ) - return merged +def _sort_hits_for_deterministic_output(hits: pd.DataFrame) -> pd.DataFrame: + sort_columns = [column for column in _HIT_SORT_COLUMNS if column in hits.columns] + if not sort_columns: + return hits.copy() ordered = hits.sort_values( - by=["chromosome", "strand", "start", "end", "rank"], - ascending=[True, True, True, True, True], + by=sort_columns, + ascending=[True] * len(sort_columns), kind="mergesort", + na_position="last", ).reset_index(drop=True) + return ordered + + +def _merge_value(values: pd.Series, *, prefer: str) -> object: + non_null = values.dropna() + if non_null.empty: + return pd.NA + if prefer == "max": + return non_null.max() + if prefer == "min": + return non_null.min() + raise ValueError(f"Unsupported merge preference: {prefer}") + + +def _build_merged_hit(group: pd.DataFrame) -> dict[str, object]: + merged = group.iloc[0].to_dict() + + if {"chromosome", "start", "end"}.issubset(group.columns): + merged["chromosome"] = group.iloc[0]["chromosome"] + merged["start"] = int(group["start"].min()) + merged["end"] = int(group["end"].max()) + + if "modified_count" in group.columns: + merged["modified_count"] = int(group["modified_count"].fillna(0).sum()) + if "valid_count" in group.columns: + merged["valid_count"] = int(group["valid_count"].fillna(0).sum()) + if {"modified_count", "valid_count"}.issubset(merged): + valid_count = int(merged.get("valid_count", 0)) + modified_count = int(merged.get("modified_count", 0)) + merged["window_fraction"] = 0.0 if valid_count == 0 else modified_count / valid_count + + if "score_value" in group.columns: + merged["score_value"] = _merge_value(group["score_value"], prefer="max") + if "p_value" in group.columns: + merged["p_value"] = _merge_value(group["p_value"], prefer="min") + if "adjusted_p_value" in group.columns: + merged["adjusted_p_value"] = _merge_value(group["adjusted_p_value"], prefer="min") + if "rank" in group.columns: + rank_values = group["rank"].dropna() + if not rank_values.empty: + merged["rank"] = int(rank_values.min()) + + merged_window_count = 0 + if "merged_window_count" in group.columns: + merged_window_count = int(group["merged_window_count"].fillna(1).sum()) + else: + merged_window_count = len(group) + merged["merged_window_count"] = merged_window_count - merged_rows: list[dict[str, object]] = [] - current = ordered.iloc[0].to_dict() - current["merged_window_count"] = 1 - - def _as_float(value: object) -> float | None: - return None if pd.isna(value) else float(value) - - def _finalize_current() -> None: - current["window_id"] = f"{current['chromosome']}:{int(current['start'])}-{int(current['end'])}" - current_valid_count = int(current.get("valid_count", 0)) - current_modified_count = int(current.get("modified_count", 0)) - current["window_fraction"] = ( - 0.0 - if current_valid_count == 0 - else current_modified_count / current_valid_count + if {"chromosome", "start", "end"}.issubset(merged): + merged["window_id"] = f"{merged['chromosome']}:{int(merged['start'])}-{int(merged['end'])}" + + return merged + + +def merge_adjacent_hits(hits: pd.DataFrame, merge_distance: int) -> pd.DataFrame: + if hits.empty: + merged = hits.copy() + if "merged_window_count" not in merged.columns: + merged["merged_window_count"] = pd.Series(dtype="int64") + return merged + + ordered = _sort_hits_for_deterministic_output(hits) + if len(ordered) == 1: + merged = ordered.copy() + merged["merged_window_count"] = ( + merged["merged_window_count"] + if "merged_window_count" in merged.columns + else 1 ) - if {"numerator_modified_count", "numerator_valid_count", "denominator_modified_count", "denominator_valid_count"}.issubset(current): - numerator_fraction = ( - 0.0 - if int(current["numerator_valid_count"]) == 0 - else int(current["numerator_modified_count"]) / int(current["numerator_valid_count"]) + if {"chromosome", "start", "end"}.issubset(merged.columns): + merged["window_id"] = merged.apply( + lambda row: f"{row['chromosome']}:{int(row['start'])}-{int(row['end'])}", + axis=1, ) - denominator_fraction = ( - 0.0 - if int(current["denominator_valid_count"]) == 0 - else int(current["denominator_modified_count"]) / int(current["denominator_valid_count"]) + if {"modified_count", "valid_count"}.issubset(merged.columns): + merged["window_fraction"] = _safe_fraction( + merged["modified_count"], merged["valid_count"] ) - current["score_value"] = abs(numerator_fraction - denominator_fraction) - merged_rows.append(current.copy()) + merged["rank"] = range(1, len(merged) + 1) + return merged + + merged_rows: list[dict[str, object]] = [] + current_group: list[pd.Series] = [ordered.iloc[0]] + + def _can_merge(previous: pd.Series, row: pd.Series) -> bool: + same_chromosome = row.get("chromosome") == previous.get("chromosome") + same_strand = row.get("strand") == previous.get("strand") + within_distance = int(row["start"]) <= int(previous["end"]) + merge_distance + return same_chromosome and same_strand and within_distance for _, row in ordered.iloc[1:].iterrows(): - same_chromosome = row["chromosome"] == current["chromosome"] - same_strand = row.get("strand") == current.get("strand") - within_distance = row["start"] <= int(current["end"]) + merge_distance - if same_chromosome and same_strand and within_distance: - current["end"] = max(int(current["end"]), int(row["end"])) - current["start"] = min(int(current["start"]), int(row["start"])) - current["modified_count"] = int(current["modified_count"]) + int(row["modified_count"]) - current["valid_count"] = int(current["valid_count"]) + int(row["valid_count"]) - current_score = _as_float(current.get("score_value")) - row_score = _as_float(row.get("score_value")) - if current_score is None: - current["score_value"] = row_score - elif row_score is not None: - current["score_value"] = max(current_score, row_score) - current_p_value = _as_float(current.get("p_value")) - row_p_value = _as_float(row.get("p_value")) - if current_p_value is None: - current["p_value"] = row_p_value - elif row_p_value is not None: - current["p_value"] = min(current_p_value, row_p_value) - - current_adjusted = _as_float(current.get("adjusted_p_value")) - row_adjusted = _as_float(row.get("adjusted_p_value")) - if current_adjusted is None: - current["adjusted_p_value"] = row_adjusted - elif row_adjusted is not None: - current["adjusted_p_value"] = min(current_adjusted, row_adjusted) - current["rank"] = min(int(current["rank"]), int(row["rank"])) - current["merged_window_count"] += 1 + if _can_merge(current_group[-1], row): + current_group.append(row) continue + merged_rows.append(_build_merged_hit(pd.DataFrame(current_group))) + current_group = [row] - _finalize_current() - current = row.to_dict() - current["merged_window_count"] = 1 - - _finalize_current() + merged_rows.append(_build_merged_hit(pd.DataFrame(current_group))) merged = pd.DataFrame(merged_rows) - merged = merged.sort_values( - by=["chromosome", "strand", "start", "end", "rank"], - ascending=[True, True, True, True, True], - kind="mergesort", - ).reset_index(drop=True) + merged = _sort_hits_for_deterministic_output(merged) merged["rank"] = range(1, len(merged) + 1) - return merged + + if "window_id" not in merged.columns and {"chromosome", "start", "end"}.issubset(merged.columns): + merged["window_id"] = merged.apply( + lambda row: f"{row['chromosome']}:{int(row['start'])}-{int(row['end'])}", + axis=1, + ) + + if "merged_window_count" not in merged.columns: + merged["merged_window_count"] = 1 + + if {"modified_count", "valid_count"}.issubset(merged.columns) and "window_fraction" not in merged.columns: + merged["window_fraction"] = _safe_fraction(merged["modified_count"], merged["valid_count"]) + + ordered_columns = list(hits.columns) + if "rank" in merged.columns and "rank" not in ordered_columns: + ordered_columns.append("rank") + for column in ["window_id", "window_fraction", "merged_window_count"]: + if column in merged.columns and column not in ordered_columns: + ordered_columns.append(column) + merged = merged.loc[:, [column for column in ordered_columns if column in merged.columns]] + return merged.reset_index(drop=True) + + +def hits_to_bed(hits: pd.DataFrame) -> pd.DataFrame: + if hits.empty: + return pd.DataFrame(columns=_BED_COLUMNS) + + ordered = _sort_hits_for_deterministic_output(hits) + + chrom_column = "chromosome" if "chromosome" in ordered.columns else "chrom" + chrom = ordered[chrom_column] + if "window_id" in ordered.columns: + name = ordered["window_id"] + else: + name = ordered.apply( + lambda row: f"{row.get('chromosome', row.get('chrom'))}:{int(row['start'])}-{int(row['end'])}", + axis=1, + ) + if "score_value" in ordered.columns: + score = ordered["score_value"].fillna(0) + elif "rank" in ordered.columns: + score = ordered["rank"].fillna(0) + else: + score = 0 + strand = ordered["strand"] if "strand" in ordered.columns else "." + strand = strand.where(strand.isin({"+", "-"}), ".") if isinstance(strand, pd.Series) else strand + + bed = pd.DataFrame( + { + "chrom": chrom, + "start": ordered["start"], + "end": ordered["end"], + "name": name, + "score": score, + "strand": strand, + } + ) + return bed.loc[:, _BED_COLUMNS].reset_index(drop=True) + + +def _merge_adjacent_hits(hits: pd.DataFrame, *, merge_distance: int) -> pd.DataFrame: + return merge_adjacent_hits(hits, merge_distance=merge_distance) def scan_genome( @@ -462,7 +544,7 @@ def scan_genome( hits = ranked.copy() if merge_hits: - hits = _merge_adjacent_hits(hits, merge_distance=merge_distance) + hits = merge_adjacent_hits(hits, merge_distance=merge_distance) plot_data = { "window_score_table": window_table.copy(), diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index 09d1b8d..2020bd2 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -72,6 +72,69 @@ def _mock_window_summary() -> pd.DataFrame: ) +def _merge_helper_hits() -> pd.DataFrame: + return pd.DataFrame( + [ + { + "chromosome": "chr2", + "start": 100, + "end": 200, + "strand": "+", + "window_id": "chr2:100-200", + "score_value": 0.3, + "p_value": 0.03, + "adjusted_p_value": 0.06, + "rank": 4, + "modified_count": 3, + "valid_count": 10, + "window_fraction": 0.3, + }, + { + "chromosome": "chr1", + "start": 200, + "end": 300, + "strand": "+", + "window_id": "chr1:200-300", + "score_value": 0.4, + "p_value": 0.04, + "adjusted_p_value": 0.08, + "rank": 2, + "modified_count": 4, + "valid_count": 10, + "window_fraction": 0.4, + }, + { + "chromosome": "chr1", + "start": 0, + "end": 100, + "strand": "+", + "window_id": "chr1:0-100", + "score_value": 0.9, + "p_value": 0.01, + "adjusted_p_value": 0.02, + "rank": 1, + "modified_count": 9, + "valid_count": 10, + "window_fraction": 0.9, + }, + { + "chromosome": "chr1", + "start": 500, + "end": 600, + "strand": "-", + "window_id": "chr1:500-600", + "score_value": 0.8, + "p_value": 0.05, + "adjusted_p_value": 0.07, + "rank": 5, + "modified_count": 8, + "valid_count": 10, + "window_fraction": 0.8, + }, + ] + ) + + def test_scan_genome_basic_behavior_with_mocked_window_summary(monkeypatch): captured = {} @@ -122,6 +185,30 @@ def fake_build_window_summary(**kwargs): assert result.metadata["score"] == "effect_size_only" +def test_merge_adjacent_hits_merges_nearby_windows_deterministically(): + merged = region_discovery.merge_adjacent_hits(_merge_helper_hits(), merge_distance=150) + + assert list(merged["window_id"]) == ["chr1:0-300", "chr1:500-600", "chr2:100-200"] + assert list(merged["rank"]) == [1, 2, 3] + assert list(merged["merged_window_count"]) == [2, 1, 1] + assert list(merged["score_value"]) == [pytest.approx(0.9), pytest.approx(0.8), pytest.approx(0.3)] + assert list(merged["p_value"]) == [pytest.approx(0.01), pytest.approx(0.05), pytest.approx(0.03)] + assert list(merged["adjusted_p_value"]) == [pytest.approx(0.02), pytest.approx(0.07), pytest.approx(0.06)] + assert list(merged["window_fraction"]) == [pytest.approx(13 / 20), pytest.approx(0.8), pytest.approx(0.3)] + + +def test_hits_to_bed_projects_required_columns_in_order(): + merged = region_discovery.merge_adjacent_hits(_merge_helper_hits(), merge_distance=150) + bed = region_discovery.hits_to_bed(merged) + + assert list(bed.columns) == ["chrom", "start", "end", "name", "score", "strand"] + assert bed.to_dict(orient="records") == [ + {"chrom": "chr1", "start": 0, "end": 300, "name": "chr1:0-300", "score": pytest.approx(0.9), "strand": "+"}, + {"chrom": "chr1", "start": 500, "end": 600, "name": "chr1:500-600", "score": pytest.approx(0.8), "strand": "-"}, + {"chrom": "chr2", "start": 100, "end": 200, "name": "chr2:100-200", "score": pytest.approx(0.3), "strand": "+"}, + ] + + def test_scan_genome_filters_low_coverage_windows(monkeypatch): def fake_build_window_summary(**kwargs): return pd.DataFrame( From 7cfcbc2197af5833d71cfc947c25968ea93cc415 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 22:51:11 -0700 Subject: [PATCH 049/272] fix: preserve region discovery merge ranks --- dimelo/region_discovery.py | 70 +++++++++++++++++++---- tests/test_region_discovery.py | 100 ++++++++++++++++++++------------- 2 files changed, 120 insertions(+), 50 deletions(-) diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py index e0ffa95..d88dc57 100644 --- a/dimelo/region_discovery.py +++ b/dimelo/region_discovery.py @@ -13,7 +13,8 @@ ) _WINDOW_KEY_COLUMNS = ["window_id", "chromosome", "start", "end", "strand"] -_HIT_SORT_COLUMNS = ["chromosome", "strand", "start", "end", "rank"] +_MERGE_SORT_COLUMNS = ["chromosome", "strand", "start", "end", "rank"] +_OUTPUT_SORT_COLUMNS = ["rank", "chromosome", "strand", "start", "end"] _BED_COLUMNS = ["chrom", "start", "end", "name", "score", "strand"] @@ -295,8 +296,8 @@ def _apply_min_coverage( return filtered, hits -def _sort_hits_for_deterministic_output(hits: pd.DataFrame) -> pd.DataFrame: - sort_columns = [column for column in _HIT_SORT_COLUMNS if column in hits.columns] +def _sort_hits_for_merge(hits: pd.DataFrame) -> pd.DataFrame: + sort_columns = [column for column in _MERGE_SORT_COLUMNS if column in hits.columns] if not sort_columns: return hits.copy() @@ -309,6 +310,21 @@ def _sort_hits_for_deterministic_output(hits: pd.DataFrame) -> pd.DataFrame: return ordered +def _sort_hits_for_output(hits: pd.DataFrame) -> pd.DataFrame: + sort_columns = [column for column in _OUTPUT_SORT_COLUMNS if column in hits.columns] + if not sort_columns: + return hits.copy() + + ascending = [True] * len(sort_columns) + ordered = hits.sort_values( + by=sort_columns, + ascending=ascending, + kind="mergesort", + na_position="last", + ).reset_index(drop=True) + return ordered + + def _merge_value(values: pd.Series, *, prefer: str) -> object: non_null = values.dropna() if non_null.empty: @@ -348,6 +364,20 @@ def _build_merged_hit(group: pd.DataFrame) -> dict[str, object]: if not rank_values.empty: merged["rank"] = int(rank_values.min()) + contrast_count_fields = [ + "numerator_modified_count", + "numerator_valid_count", + "denominator_modified_count", + "denominator_valid_count", + ] + contrast_counts_present = any( + field in group.columns and group[field].notna().any() for field in contrast_count_fields + ) + if contrast_counts_present: + for field in contrast_count_fields: + if field in group.columns and group[field].notna().any(): + merged[field] = int(group[field].fillna(0).sum()) + merged_window_count = 0 if "merged_window_count" in group.columns: merged_window_count = int(group["merged_window_count"].fillna(1).sum()) @@ -355,6 +385,19 @@ def _build_merged_hit(group: pd.DataFrame) -> dict[str, object]: merged_window_count = len(group) merged["merged_window_count"] = merged_window_count + if contrast_counts_present and all( + field in merged and not pd.isna(merged[field]) for field in contrast_count_fields + ): + numerator_fraction = _safe_fraction( + pd.Series([merged["numerator_modified_count"]], dtype="float64"), + pd.Series([merged["numerator_valid_count"]], dtype="float64"), + ).iloc[0] + denominator_fraction = _safe_fraction( + pd.Series([merged["denominator_modified_count"]], dtype="float64"), + pd.Series([merged["denominator_valid_count"]], dtype="float64"), + ).iloc[0] + merged["score_value"] = abs(float(numerator_fraction) - float(denominator_fraction)) + if {"chromosome", "start", "end"}.issubset(merged): merged["window_id"] = f"{merged['chromosome']}:{int(merged['start'])}-{int(merged['end'])}" @@ -368,7 +411,7 @@ def merge_adjacent_hits(hits: pd.DataFrame, merge_distance: int) -> pd.DataFrame merged["merged_window_count"] = pd.Series(dtype="int64") return merged - ordered = _sort_hits_for_deterministic_output(hits) + ordered = _sort_hits_for_merge(hits) if len(ordered) == 1: merged = ordered.copy() merged["merged_window_count"] = ( @@ -385,7 +428,6 @@ def merge_adjacent_hits(hits: pd.DataFrame, merge_distance: int) -> pd.DataFrame merged["window_fraction"] = _safe_fraction( merged["modified_count"], merged["valid_count"] ) - merged["rank"] = range(1, len(merged) + 1) return merged merged_rows: list[dict[str, object]] = [] @@ -406,8 +448,7 @@ def _can_merge(previous: pd.Series, row: pd.Series) -> bool: merged_rows.append(_build_merged_hit(pd.DataFrame(current_group))) merged = pd.DataFrame(merged_rows) - merged = _sort_hits_for_deterministic_output(merged) - merged["rank"] = range(1, len(merged) + 1) + merged = _sort_hits_for_output(merged) if "window_id" not in merged.columns and {"chromosome", "start", "end"}.issubset(merged.columns): merged["window_id"] = merged.apply( @@ -435,7 +476,7 @@ def hits_to_bed(hits: pd.DataFrame) -> pd.DataFrame: if hits.empty: return pd.DataFrame(columns=_BED_COLUMNS) - ordered = _sort_hits_for_deterministic_output(hits) + ordered = _sort_hits_for_output(hits) chrom_column = "chromosome" if "chromosome" in ordered.columns else "chrom" chrom = ordered[chrom_column] @@ -447,11 +488,16 @@ def hits_to_bed(hits: pd.DataFrame) -> pd.DataFrame: axis=1, ) if "score_value" in ordered.columns: - score = ordered["score_value"].fillna(0) - elif "rank" in ordered.columns: - score = ordered["rank"].fillna(0) + score = ( + ordered["score_value"] + .fillna(0.0) + .mul(1000) + .round() + .clip(lower=0, upper=1000) + .astype(int) + ) else: - score = 0 + score = pd.Series([0] * len(ordered), index=ordered.index, dtype="int64") strand = ordered["strand"] if "strand" in ordered.columns else "." strand = strand.where(strand.isin({"+", "-"}), ".") if isinstance(strand, pd.Series) else strand diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index 2020bd2..858d1c9 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -81,41 +81,49 @@ def _merge_helper_hits() -> pd.DataFrame: "end": 200, "strand": "+", "window_id": "chr2:100-200", - "score_value": 0.3, - "p_value": 0.03, - "adjusted_p_value": 0.06, - "rank": 4, - "modified_count": 3, - "valid_count": 10, - "window_fraction": 0.3, + "score_value": 0.95, + "p_value": 0.01, + "adjusted_p_value": 0.01, + "rank": 1, + "modified_count": 19, + "valid_count": 20, + "window_fraction": 0.95, }, { "chromosome": "chr1", - "start": 200, - "end": 300, + "start": 0, + "end": 100, "strand": "+", - "window_id": "chr1:200-300", - "score_value": 0.4, + "window_id": "chr1:0-100", + "score_value": 0.2, "p_value": 0.04, "adjusted_p_value": 0.08, "rank": 2, - "modified_count": 4, + "modified_count": 2, "valid_count": 10, - "window_fraction": 0.4, + "window_fraction": 0.2, + "numerator_modified_count": 2, + "numerator_valid_count": 4, + "denominator_modified_count": 1, + "denominator_valid_count": 4, }, { "chromosome": "chr1", - "start": 0, - "end": 100, + "start": 101, + "end": 200, "strand": "+", - "window_id": "chr1:0-100", - "score_value": 0.9, - "p_value": 0.01, - "adjusted_p_value": 0.02, - "rank": 1, - "modified_count": 9, + "window_id": "chr1:101-200", + "score_value": 0.4, + "p_value": 0.03, + "adjusted_p_value": 0.06, + "rank": 3, + "modified_count": 6, "valid_count": 10, - "window_fraction": 0.9, + "window_fraction": 0.6, + "numerator_modified_count": 4, + "numerator_valid_count": 6, + "denominator_modified_count": 2, + "denominator_valid_count": 6, }, { "chromosome": "chr1", @@ -126,7 +134,7 @@ def _merge_helper_hits() -> pd.DataFrame: "score_value": 0.8, "p_value": 0.05, "adjusted_p_value": 0.07, - "rank": 5, + "rank": 4, "modified_count": 8, "valid_count": 10, "window_fraction": 0.8, @@ -185,27 +193,43 @@ def fake_build_window_summary(**kwargs): assert result.metadata["score"] == "effect_size_only" -def test_merge_adjacent_hits_merges_nearby_windows_deterministically(): - merged = region_discovery.merge_adjacent_hits(_merge_helper_hits(), merge_distance=150) - - assert list(merged["window_id"]) == ["chr1:0-300", "chr1:500-600", "chr2:100-200"] - assert list(merged["rank"]) == [1, 2, 3] - assert list(merged["merged_window_count"]) == [2, 1, 1] - assert list(merged["score_value"]) == [pytest.approx(0.9), pytest.approx(0.8), pytest.approx(0.3)] - assert list(merged["p_value"]) == [pytest.approx(0.01), pytest.approx(0.05), pytest.approx(0.03)] - assert list(merged["adjusted_p_value"]) == [pytest.approx(0.02), pytest.approx(0.07), pytest.approx(0.06)] - assert list(merged["window_fraction"]) == [pytest.approx(13 / 20), pytest.approx(0.8), pytest.approx(0.3)] +def test_merge_adjacent_hits_preserves_rank_order_and_merges_counts(): + merged = region_discovery.merge_adjacent_hits(_merge_helper_hits(), merge_distance=1) + + assert list(merged["window_id"]) == ["chr2:100-200", "chr1:0-200", "chr1:500-600"] + assert list(merged["rank"]) == [1, 2, 4] + assert list(merged["merged_window_count"]) == [1, 2, 1] + assert list(merged["score_value"]) == [pytest.approx(0.95), pytest.approx(0.3), pytest.approx(0.8)] + assert list(merged["p_value"]) == [pytest.approx(0.01), pytest.approx(0.03), pytest.approx(0.05)] + assert list(merged["adjusted_p_value"]) == [pytest.approx(0.01), pytest.approx(0.06), pytest.approx(0.07)] + assert list(merged["modified_count"]) == [19, 8, 8] + assert list(merged["valid_count"]) == [20, 20, 10] + assert list(merged["window_fraction"]) == [pytest.approx(0.95), pytest.approx(0.4), pytest.approx(0.8)] + assert pd.isna(merged.loc[0, "numerator_modified_count"]) + assert merged.loc[1, "numerator_modified_count"] == 6 + assert pd.isna(merged.loc[2, "numerator_modified_count"]) + assert pd.isna(merged.loc[0, "numerator_valid_count"]) + assert merged.loc[1, "numerator_valid_count"] == 10 + assert pd.isna(merged.loc[2, "numerator_valid_count"]) + assert pd.isna(merged.loc[0, "denominator_modified_count"]) + assert merged.loc[1, "denominator_modified_count"] == 3 + assert pd.isna(merged.loc[2, "denominator_modified_count"]) + assert pd.isna(merged.loc[0, "denominator_valid_count"]) + assert merged.loc[1, "denominator_valid_count"] == 10 + assert pd.isna(merged.loc[2, "denominator_valid_count"]) def test_hits_to_bed_projects_required_columns_in_order(): - merged = region_discovery.merge_adjacent_hits(_merge_helper_hits(), merge_distance=150) + merged = region_discovery.merge_adjacent_hits(_merge_helper_hits(), merge_distance=1) bed = region_discovery.hits_to_bed(merged) assert list(bed.columns) == ["chrom", "start", "end", "name", "score", "strand"] + assert pd.api.types.is_integer_dtype(bed["score"]) + assert bed["score"].between(0, 1000).all() assert bed.to_dict(orient="records") == [ - {"chrom": "chr1", "start": 0, "end": 300, "name": "chr1:0-300", "score": pytest.approx(0.9), "strand": "+"}, - {"chrom": "chr1", "start": 500, "end": 600, "name": "chr1:500-600", "score": pytest.approx(0.8), "strand": "-"}, - {"chrom": "chr2", "start": 100, "end": 200, "name": "chr2:100-200", "score": pytest.approx(0.3), "strand": "+"}, + {"chrom": "chr2", "start": 100, "end": 200, "name": "chr2:100-200", "score": 950, "strand": "+"}, + {"chrom": "chr1", "start": 0, "end": 200, "name": "chr1:0-200", "score": 300, "strand": "+"}, + {"chrom": "chr1", "start": 500, "end": 600, "name": "chr1:500-600", "score": 800, "strand": "-"}, ] @@ -954,4 +978,4 @@ def fake_build_window_summary(**kwargs): assert list(result.hits["strand"]) == ["+", "-"] assert result.hits.loc[0, "window_fraction"] == pytest.approx(0.25) assert result.hits.loc[0, "merged_window_count"] == 2 - assert list(result.hits["rank"]) == [1, 2] + assert list(result.hits["rank"]) == [1, 3] From a57865d10c888102a84c7a0190f7913dd05ed2b2 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 22:55:15 -0700 Subject: [PATCH 050/272] docs: add region discovery workflow guide --- README.md | 1 + dimelo/region_discovery.py | 2 +- docs/region-discovery.md | 53 ++++++++++++++++++++++++++++++++++ tests/test_region_discovery.py | 20 +++++++++++-- 4 files changed, 73 insertions(+), 3 deletions(-) create mode 100644 docs/region-discovery.md diff --git a/README.md b/README.md index d5aa44e..51ada2c 100644 --- a/README.md +++ b/README.md @@ -225,6 +225,7 @@ def extract( Three higher-level analysis guides now sit on top of the existing parsing layer: - [docs/global-analysis.md](docs/global-analysis.md) for pileup-backed global summaries and normalization factors +- [docs/region-discovery.md](docs/region-discovery.md) for de novo locus discovery from tiled pileup scans - [docs/shared-clustering.md](docs/shared-clustering.md) for shared-boundary clustering workflows - [docs/region-contrasts.md](docs/region-contrasts.md) for known-region motif-abundance contrasts diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py index d88dc57..ddeb09f 100644 --- a/dimelo/region_discovery.py +++ b/dimelo/region_discovery.py @@ -597,7 +597,7 @@ def scan_genome( "top_hits_table": hits.copy(), } metadata = { - "analysis_unit": "de_novo_window", + "analysis_unit": "ensemble_region", "representation": "modified_fraction", "signal_source": "pileup_counts", "score": score, diff --git a/docs/region-discovery.md b/docs/region-discovery.md new file mode 100644 index 0000000..efd76a6 --- /dev/null +++ b/docs/region-discovery.md @@ -0,0 +1,53 @@ +# Region Discovery + +`dimelo.region_discovery` is the de novo locus discovery layer. Use it when you do not yet know which genomic intervals matter and you want a deterministic tiled scan over pileup-backed inputs. + +## When To Use Discovery vs Contrasts + +- Use `region_discovery` when you need to find candidate loci first. +- Use `region_contrasts` when you already know the regions and want to test them formally. +- If you already have a BED file or a matched region set, skip discovery and go straight to `region_contrasts`. + +## Minimal Example + +```python +from dimelo import region_discovery +from dimelo.models import SampleSpec + +result = region_discovery.scan_genome( + samples=[ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="output/s1.extract.h5", + metadata={"pileup_path": "output/s1.pileup.sorted.bed.gz"}, + ), + SampleSpec( + sample_id="s2", + condition="treated", + extract_h5="output/s2.extract.h5", + metadata={"pileup_path": "output/s2.pileup.sorted.bed.gz"}, + ), + ], + motifs=["A,0"], + genome_sizes={"chr1": 248956422}, + window_size=2000, + step_size=500, + score="beta_binomial", + min_coverage=10, +) +``` + +The canonical outputs are data-first: + +- `result.windows` +- `result.hits` +- `result.plot_data["window_score_table"]` +- `result.plot_data["top_hits_table"]` + +## Handoff Guidance + +- For formal region testing, convert discovered hits into BED and pass them into `region_contrasts.score_regions(...)`. +- For downstream clustering, use the discovered loci to focus the region set before running the clustering workflow. +- Keep discovery and contrast roles separate: discovery finds candidates, contrasts tests known regions, and clustering explains state mixtures. + diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index 858d1c9..8cfb579 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -189,8 +189,24 @@ def fake_build_window_summary(**kwargs): assert result.windows.loc[0, "score_value"] == pytest.approx(0.4) assert list(result.hits["rank"]) == [1, 2] assert list(result.hits["window_id"]) == ["chr1:0-1000", "chr1:1000-2000"] - assert set(result.plot_data) >= {"window_score_table", "top_hits_table"} - assert result.metadata["score"] == "effect_size_only" + assert set(result.plot_data) == {"window_score_table", "top_hits_table"} + assert result.metadata == { + "analysis_unit": "ensemble_region", + "representation": "modified_fraction", + "signal_source": "pileup_counts", + "score": "effect_size_only", + "window_size": 1000, + "step_size": 1000, + "min_coverage": 5, + "merge_hits": False, + "merge_distance": 0, + "motifs": ["A,0"], + "include_contigs": None, + "exclude_contigs": None, + "contrast_mode": "pairwise", + "contrast_numerator": ["treated"], + "contrast_denominator": ["NS"], + } def test_merge_adjacent_hits_preserves_rank_order_and_merges_counts(): From b94e779472c99ebbed5e235872df29a5a4f19763 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 23:01:36 -0700 Subject: [PATCH 051/272] fix: require explicit contrast for beta-binomial discovery --- dimelo/region_discovery.py | 2 ++ docs/region-discovery.md | 14 ++++++++++++-- tests/test_region_discovery.py | 13 +++++++++++++ 3 files changed, 27 insertions(+), 2 deletions(-) diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py index ddeb09f..590b9ec 100644 --- a/dimelo/region_discovery.py +++ b/dimelo/region_discovery.py @@ -538,6 +538,8 @@ def scan_genome( motif_list = _validate_motifs(motifs) if score not in {"effect_size_only", "beta_binomial"}: raise ValueError("scan_genome requires score in {'effect_size_only', 'beta_binomial'}.") + if score == "beta_binomial" and contrast is None: + raise ValueError("scan_genome score='beta_binomial' requires an explicit contrast.") if contrast is not None and contrast.mode not in {"pairwise", "group_vs_group"}: raise ValueError( "scan_genome currently supports only pairwise/group_vs_group contrast modes." diff --git a/docs/region-discovery.md b/docs/region-discovery.md index efd76a6..0af18e3 100644 --- a/docs/region-discovery.md +++ b/docs/region-discovery.md @@ -12,7 +12,7 @@ ```python from dimelo import region_discovery -from dimelo.models import SampleSpec +from dimelo.models import ContrastSpec, SampleSpec result = region_discovery.scan_genome( samples=[ @@ -33,6 +33,12 @@ result = region_discovery.scan_genome( genome_sizes={"chr1": 248956422}, window_size=2000, step_size=500, + contrast=ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["NS"], + reference_condition="NS", + ), score="beta_binomial", min_coverage=10, ) @@ -47,7 +53,11 @@ The canonical outputs are data-first: ## Handoff Guidance -- For formal region testing, convert discovered hits into BED and pass them into `region_contrasts.score_regions(...)`. +- For formal region testing, convert discovered hits into BED and write them to disk before passing the BED path into `region_contrasts.score_regions(...)`. - For downstream clustering, use the discovered loci to focus the region set before running the clustering workflow. - Keep discovery and contrast roles separate: discovery finds candidates, contrasts tests known regions, and clustering explains state mixtures. +```python +bed_df = region_discovery.hits_to_bed(result.hits) +bed_df.to_csv("discovered_hits.bed", sep="\t", header=False, index=False) +``` diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index 8cfb579..ad69e66 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -766,6 +766,19 @@ def test_scan_genome_rejects_unimplemented_contrast_modes(): ) +def test_scan_genome_beta_binomial_requires_explicit_contrast(): + with pytest.raises(ValueError, match="requires an explicit contrast"): + region_discovery.scan_genome( + samples=[], + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=1000, + step_size=1000, + score="beta_binomial", + min_coverage=1, + ) + + def test_scan_genome_reranks_hits_after_min_coverage_filtering(monkeypatch): def fake_build_window_summary(**kwargs): return pd.DataFrame( From 994bca52c8ecdbcedace8873599f1a0371dd481b Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 31 Mar 2026 23:04:02 -0700 Subject: [PATCH 052/272] test: cover discovery to contrasts handoff --- tests/test_region_discovery.py | 64 +++++++++++++++++++++++++++++++++- 1 file changed, 63 insertions(+), 1 deletion(-) diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index ad69e66..a1c62b9 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -6,7 +6,7 @@ from dimelo import global_analysis from dimelo.models import ContrastSpec, RegionDiscoveryResult, SampleSpec -from dimelo import region_discovery +from dimelo import region_contrasts, region_discovery def _mock_window_summary() -> pd.DataFrame: @@ -249,6 +249,68 @@ def test_hits_to_bed_projects_required_columns_in_order(): ] +def test_discovery_bed_handoff_into_region_contrasts(tmp_path, monkeypatch): + hits = _merge_helper_hits() + bed_df = region_discovery.hits_to_bed(hits) + bed_path = tmp_path / "discovered_hits.bed" + bed_df.to_csv(bed_path, sep="\t", header=False, index=False) + + counts_by_pileup = { + "s1.bed.gz": [(1, 10), (1, 10), (8, 10)], + "s2.bed.gz": [(9, 10), (2, 10), (1, 10)], + } + + def fake_regions_to_list(function_handle, regions, window_size=None, quiet=True, cores=None, split_large_regions=False): + pileup_path = function_handle.keywords["bedmethyl_file"] + regions_dict = region_contrasts.utils.regions_dict_from_input(regions, window_size) + n_regions = sum(len(region_list) for region_list in regions_dict.values()) + base_counts = counts_by_pileup[pileup_path] + if len(base_counts) >= n_regions: + return base_counts[:n_regions] + repeats = (n_regions // len(base_counts)) + 1 + return (base_counts * repeats)[:n_regions] + + monkeypatch.setattr(region_contrasts.load_processed, "regions_to_list", fake_regions_to_list) + + samples = [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + metadata={"pileup_path": "s1.bed.gz"}, + ), + SampleSpec( + sample_id="s2", + condition="treated", + extract_h5="s2.h5", + metadata={"pileup_path": "s2.bed.gz"}, + ), + ] + contrast = ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["NS"], + reference_condition="NS", + ) + + result = region_contrasts.score_regions( + samples=samples, + regions=bed_path, + motifs=["A,0"], + contrast=contrast, + test="effect_size_only", + ) + + assert len(result.regions) == 4 + assert set(result.regions["region_id"]) == { + "chr2:100-200,+", + "chr1:0-100,+", + "chr1:101-200,+", + "chr1:500-600,-", + } + assert list(result.summary["rank"]) == [1, 2, 3, 4] + + def test_scan_genome_filters_low_coverage_windows(monkeypatch): def fake_build_window_summary(**kwargs): return pd.DataFrame( From f087f5fcdbc232a264c38a5549935ccb006281a7 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 11:22:21 -0700 Subject: [PATCH 053/272] docs: add paired region discovery design spec --- ...26-04-01-paired-region-discovery-design.md | 370 ++++++++++++++++++ 1 file changed, 370 insertions(+) create mode 100644 docs/superpowers/specs/2026-04-01-paired-region-discovery-design.md diff --git a/docs/superpowers/specs/2026-04-01-paired-region-discovery-design.md b/docs/superpowers/specs/2026-04-01-paired-region-discovery-design.md new file mode 100644 index 0000000..1186dc8 --- /dev/null +++ b/docs/superpowers/specs/2026-04-01-paired-region-discovery-design.md @@ -0,0 +1,370 @@ +# Paired Region Discovery Design + +## Goal + +Extend `dimelo.region_discovery` with paired discovery modes that support: + +- two-condition matched discovery +- ordered paired time-course discovery + +The paired framework should preserve the current pileup-backed, deterministic tiled-window architecture while making pairing explicit and auditable. + +## Why This Exists + +The current `region_discovery.scan_genome(...)` implementation only supports pooled `pairwise` and `group_vs_group` contrasts. That is adequate for simple discovery, but it is not correct for common experimental designs where samples are matched across conditions: + +- non-targeting versus targeting with matched replicates +- before/after on the same biological sample +- paired time-course trajectories across ordered conditions + +If these are analyzed as pooled groups, the pairing structure is discarded and the result can be misleading. The paired discovery layer should answer a different biological question: + +> Which windows change consistently within matched units? + +## Scope + +This design covers: + +- new paired discovery modes in `region_discovery` +- pairing resolution rules +- paired ranking metrics for two-condition and ordered time-course discovery +- result metadata and output-table requirements + +This design does not cover: + +- mixed-effects or repeated-measures inferential models +- single-read paired discovery +- cluster-occupancy paired discovery +- adaptive candidate interval generation + +## Architectural Rule + +Build one shared paired-discovery framework and expose multiple contrast modes on top of it. + +That means: + +- `matched_pairwise` is a two-condition special case +- paired ordered time-course is another consumer of the same pairing engine +- pairing resolution happens once +- per-window paired summaries are the canonical substrate + +This avoids creating separate, incompatible systems for paired comparisons and paired trajectories. + +## Core User Model + +The user still calls `region_discovery.scan_genome(...)`, but with a paired `ContrastSpec`. + +Examples: + +```python +ContrastSpec( + mode="matched_pairwise", + numerator=["targeting"], + denominator=["nontargeting"], + pairing_key="replicate_id", +) +``` + +```python +ContrastSpec( + mode="time_course", + time_order=["0min", "15min", "30min", "45min"], + pairing_key="sample_id", +) +``` + +The key principle is: + +- pooled modes compare condition groups +- paired modes compare within matched units first, then summarize across units + +## Pairing Resolution + +### Required Input + +Paired discovery requires an explicit `pairing_key`. + +The pairing key should identify the matched biological or technical unit across conditions, for example: + +- replicate identity +- donor identity +- sample identity +- before/after subject identity + +If the requested discovery mode is paired and `pairing_key` is missing, the workflow must fail fast. + +### Default Pairing Policy + +Default policy: + +- `pairing_policy="complete_pairs_only"` + +Behavior: + +- use only matched units that have all required conditions +- drop unmatched units from scoring +- record dropped units in metadata + +This is the most robust default because it preserves paired semantics without making imperfect datasets unusable. + +### Strict Option + +Support: + +- `pairing_policy="error_on_missing"` + +Behavior: + +- fail if any expected matched unit is incomplete + +This is useful for highly controlled analyses where partial data should be treated as an error. + +### Not In V1 + +Do not support a silent fallback from paired discovery to pooled discovery. That would blur the biological interpretation too much. + +## Internal Data Model + +Add a canonical internal paired table concept: + +```text +PairedWindowTable +- window_id +- chromosome +- start +- end +- strand +- pair_id +- condition +- modified_count +- valid_count +- window_fraction +``` + +For paired discovery: + +1. build the ordinary window summary table from `global_analysis.build_window_summary(...)` +2. resolve pair membership from sample metadata using `pairing_key` +3. keep only complete matched units under the active pairing policy +4. compute paired summaries from the per-pair window table + +This table is internal, but it should be conceptually stable because it will support both matched-pairwise and paired time-course modes. + +## Supported Paired Modes + +### `matched_pairwise` + +Use when there are exactly two condition sets to compare within matched pairs. + +Examples: + +- non-targeting versus targeting +- before versus after + +Required `ContrastSpec` fields: + +- `mode="matched_pairwise"` +- `numerator` +- `denominator` +- `pairing_key` + +### `time_course` + +Use when the same matched unit is measured across an ordered series of conditions. + +Examples: + +- `0min -> 15min -> 30min -> 45min` + +Required `ContrastSpec` fields: + +- `mode="time_course"` +- `time_order` +- `pairing_key` + +In the paired-discovery context, `time_course` means ordered paired time-course, not pooled trajectory analysis. + +## Ranking Families + +Two ranking families should be supported. + +### 1. Magnitude-First Ranking + +This emphasizes effect size. + +#### Matched Pairwise + +For each pair and each window: + +- `delta_i = numerator_fraction_i - denominator_fraction_i` + +Canonical summary columns: + +- `mean_delta` +- `mean_abs_delta` +- `median_abs_delta` +- `delta_sd` +- `sign_agreement` +- `n_pairs_used` + +Recommended default ranking: + +- `rank_by="mean_abs_delta"` + +This is the best first-pass default because it is simple, interpretable, and stable for small numbers of pairs. + +#### Paired Time Course + +For each pair and each window: + +- compute trajectory amplitude within that pair: + `trajectory_amplitude_i = max(fractions_i_over_time) - min(fractions_i_over_time)` + +Canonical summary columns: + +- `trajectory_amplitude_mean` +- `trajectory_amplitude_median` +- `trajectory_amplitude_sd` +- `n_pairs_used` + +Recommended default ranking: + +- `rank_by="trajectory_amplitude_mean"` + +This is the right first ranking mode because it is general and does not prematurely force windows into pattern classes. + +### 2. Consistency-Weighted Ranking + +This emphasizes reproducibility across matched units. + +#### Matched Pairwise + +Candidate summary metrics: + +- `consistency_weighted_delta = mean_abs_delta / (delta_sd + epsilon)` +- `mean_abs_delta * sign_agreement` + +#### Paired Time Course + +Candidate summary metrics: + +- `trajectory_amplitude_mean / (trajectory_amplitude_sd + epsilon)` +- trajectory amplitude weighted by pairwise direction agreement between endpoints + +These should be available as alternate ranking modes, but not the default. + +## Recommended V1 Defaults + +### Matched Pairwise + +- default `rank_by="mean_abs_delta"` +- always return: + - `mean_delta` + - `mean_abs_delta` + - `delta_sd` + - `sign_agreement` + - `n_pairs_used` + +### Paired Time Course + +- default `rank_by="trajectory_amplitude_mean"` +- always return: + - `trajectory_amplitude_mean` + - `trajectory_amplitude_sd` + - `n_pairs_used` + +These defaults balance interpretability and robustness. + +## Not In First Paired Implementation + +Do not add these yet: + +- pattern labels like `monotonic_gain`, `transient_peak`, `late_loss` +- paired inferential models +- automatic fallback to pooled modes + +Those can come later once the paired summary tables are stable. + +## Result Contract Additions + +`RegionDiscoveryResult` can remain the same shape, but paired discovery should add metadata fields and columns. + +### Metadata + +Required additions when using paired modes: + +- `pairing_key` +- `pairing_policy` +- `n_pairs_used` +- `n_pairs_dropped` +- `paired_mode` +- `rank_by` + +For time-course: + +- `time_order` + +### Hit/Window Columns + +For matched pairwise windows and hits: + +- `mean_delta` +- `mean_abs_delta` +- `delta_sd` +- `sign_agreement` +- `n_pairs_used` + +For paired time-course windows and hits: + +- `trajectory_amplitude_mean` +- `trajectory_amplitude_sd` +- `n_pairs_used` + +## Error Handling + +The paired workflow must fail fast when: + +- `pairing_key` is missing for paired modes +- required conditions are absent +- `time_order` references conditions not present +- no complete pairs remain after filtering + +It should not silently fall back to pooled analysis. + +If incomplete pairs are dropped under `complete_pairs_only`, the result metadata should clearly report that. + +## Testing Requirements + +Add tests for: + +- paired pair-resolution with complete pairs only +- strict error on missing pairs +- matched-pairwise ranking by `mean_abs_delta` +- paired time-course ranking by trajectory amplitude +- dropped-pair accounting in metadata +- failure when `pairing_key` is omitted +- failure when `time_order` is incomplete or invalid + +Also add one integration test that confirms paired discovery still feeds into: + +- `hits_to_bed(...)` +- `region_contrasts.score_regions(...)` + +## Implementation Shape + +I would implement this in two stages: + +1. paired pair-resolution plus `matched_pairwise` +2. paired ordered `time_course` + +Both stages should reuse the same internal pairing resolver and paired-window table builder. + +## Recommendation + +Implement `matched_pairwise` first, but design the internal table and ranking interfaces so `time_course` can land immediately after with minimal churn. + +That gives you: + +- robust paired discovery for your most common `nontargeting vs targeting` case +- a clean path to ordered paired time-course discovery +- no need to redesign the module later From add5acb9c604032bd8041d3750c0dc119fedcde9 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 11:31:52 -0700 Subject: [PATCH 054/272] feat: add paired region discovery pair resolution --- dimelo/region_discovery.py | 88 +++++++++++++++++- tests/test_region_discovery.py | 162 ++++++++++++++++++++++++++++++++- 2 files changed, 243 insertions(+), 7 deletions(-) diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py index 590b9ec..5e5297a 100644 --- a/dimelo/region_discovery.py +++ b/dimelo/region_discovery.py @@ -133,6 +133,67 @@ def _validate_contrast_conditions( ) +def _pairing_policy_value(pairing_policy: str | None) -> str: + return pairing_policy or "complete_pairs_only" + + +def _is_paired_contrast(contrast: ContrastSpec | None) -> bool: + return contrast is not None and contrast.mode in {"matched_pairwise", "time_course"} + + +def _resolve_pair_ids(samples, pairing_key: str) -> dict[str, object]: + if not pairing_key: + raise ValueError("scan_genome paired discovery requires an explicit pairing_key.") + + pair_ids: dict[str, object] = {} + for sample in samples: + metadata = sample.metadata or {} + if pairing_key not in metadata: + raise ValueError( + f"scan_genome paired discovery requires sample.metadata['{pairing_key}'] for every sample." + ) + pair_ids[sample.sample_id] = metadata[pairing_key] + return pair_ids + + +def _build_paired_window_table( + summary: pd.DataFrame, + *, + samples, + pairing_key: str | None, + required_conditions: list[str], + pairing_policy: str, +) -> tuple[pd.DataFrame, dict[str, int]]: + sample_to_pair = _resolve_pair_ids(samples, pairing_key or "") + + paired = summary.copy() + paired["pair_id"] = paired["sample_id"].map(sample_to_pair) + paired = paired.dropna(subset=["pair_id"]) + + pair_conditions = ( + paired.loc[:, ["pair_id", "condition"]] + .drop_duplicates() + .groupby("pair_id")["condition"] + .agg(lambda values: set(values)) + ) + required_condition_set = set(required_conditions) + complete_pair_ids = [ + pair_id for pair_id, conditions in pair_conditions.items() if required_condition_set.issubset(conditions) + ] + dropped_pair_count = int(len(pair_conditions) - len(complete_pair_ids)) + + if pairing_policy == "error_on_missing" and dropped_pair_count: + raise ValueError("scan_genome paired discovery found incomplete matched units.") + if not complete_pair_ids: + raise ValueError("scan_genome paired discovery found no complete matched units.") + + paired = paired.loc[paired["pair_id"].isin(complete_pair_ids)].copy() + return paired, { + "n_pairs_used": len(complete_pair_ids), + "n_pairs_dropped": dropped_pair_count, + } + + def _score_with_contrast( window_totals: pd.DataFrame, condition_counts: pd.DataFrame, @@ -540,9 +601,14 @@ def scan_genome( raise ValueError("scan_genome requires score in {'effect_size_only', 'beta_binomial'}.") if score == "beta_binomial" and contrast is None: raise ValueError("scan_genome score='beta_binomial' requires an explicit contrast.") - if contrast is not None and contrast.mode not in {"pairwise", "group_vs_group"}: + if contrast is not None and contrast.mode not in { + "pairwise", + "group_vs_group", + "matched_pairwise", + "time_course", + }: raise ValueError( - "scan_genome currently supports only pairwise/group_vs_group contrast modes." + "scan_genome currently supports only pairwise/group_vs_group and paired contrast modes." ) window_summary = global_analysis.build_window_summary( @@ -557,6 +623,20 @@ def scan_genome( cores=cores, ) + pairing_metadata: dict[str, object] = {} + if _is_paired_contrast(contrast): + pairing_policy = _pairing_policy_value(None) + required_conditions = list(contrast.time_order or []) if contrast.mode == "time_course" else list( + dict.fromkeys((contrast.numerator or []) + (contrast.denominator or [])) + ) + window_summary, pairing_metadata = _build_paired_window_table( + window_summary, + samples=samples, + pairing_key=contrast.pairing_key, + required_conditions=required_conditions, + pairing_policy=pairing_policy, + ) + window_totals = _aggregate_window_counts(window_summary) condition_counts = _aggregate_condition_counts(window_summary) _validate_contrast_conditions(condition_counts=condition_counts, contrast=contrast) @@ -616,6 +696,10 @@ def scan_genome( metadata["contrast_mode"] = contrast.mode metadata["contrast_numerator"] = list(contrast.numerator or []) metadata["contrast_denominator"] = list(contrast.denominator or []) + if pairing_metadata: + metadata["pairing_policy"] = _pairing_policy_value(None) + metadata["n_pairs_used"] = pairing_metadata["n_pairs_used"] + metadata["n_pairs_dropped"] = pairing_metadata["n_pairs_dropped"] return RegionDiscoveryResult( hits=hits.reset_index(drop=True), diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index a1c62b9..763a198 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -72,6 +72,118 @@ def _mock_window_summary() -> pd.DataFrame: ) +def _mock_paired_window_summary() -> pd.DataFrame: + return pd.DataFrame( + [ + { + "sample_id": "t1", + "condition": "targeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 10, + "valid_count": 20, + "window_fraction": 0.5, + }, + { + "sample_id": "d1", + "condition": "nontargeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 4, + "valid_count": 20, + "window_fraction": 0.2, + }, + { + "sample_id": "t2", + "condition": "targeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 6, + "valid_count": 20, + "window_fraction": 0.3, + }, + { + "sample_id": "d2", + "condition": "nontargeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 2, + "valid_count": 20, + "window_fraction": 0.1, + }, + { + "sample_id": "t3", + "condition": "targeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 100, + "valid_count": 100, + "window_fraction": 1.0, + }, + ] + ) + + +def _paired_samplespecs() -> list[SampleSpec]: + return [ + SampleSpec( + sample_id="t1", + condition="targeting", + extract_h5="t1.h5", + metadata={"pileup_path": "t1.bed.gz", "pair_id": "pair-1"}, + ), + SampleSpec( + sample_id="d1", + condition="nontargeting", + extract_h5="d1.h5", + metadata={"pileup_path": "d1.bed.gz", "pair_id": "pair-1"}, + ), + SampleSpec( + sample_id="t2", + condition="targeting", + extract_h5="t2.h5", + metadata={"pileup_path": "t2.bed.gz", "pair_id": "pair-2"}, + ), + SampleSpec( + sample_id="d2", + condition="nontargeting", + extract_h5="d2.h5", + metadata={"pileup_path": "d2.bed.gz", "pair_id": "pair-2"}, + ), + SampleSpec( + sample_id="t3", + condition="targeting", + extract_h5="t3.h5", + metadata={"pileup_path": "t3.bed.gz", "pair_id": "pair-3"}, + ), + ] + + def _merge_helper_hits() -> pd.DataFrame: return pd.DataFrame( [ @@ -209,6 +321,49 @@ def fake_build_window_summary(**kwargs): } +def test_scan_genome_matched_pairwise_uses_only_complete_pairs(monkeypatch): + monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_window_summary()) + + result = region_discovery.scan_genome( + samples=_paired_samplespecs(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=500, + step_size=500, + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["targeting"], + denominator=["nontargeting"], + pairing_key="pair_id", + ), + score="effect_size_only", + ) + + assert result.metadata["pairing_policy"] == "complete_pairs_only" + assert result.metadata["n_pairs_used"] == 2 + assert result.metadata["n_pairs_dropped"] == 1 + assert result.windows.loc[0, "valid_count"] == 80 + assert result.windows.loc[0, "score_value"] == pytest.approx(0.25) + + +def test_scan_genome_time_course_errors_on_missing_pairing_key(monkeypatch): + monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_window_summary()) + + with pytest.raises(ValueError, match="pairing_key"): + region_discovery.scan_genome( + samples=_paired_samplespecs(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=500, + step_size=500, + contrast=ContrastSpec( + mode="time_course", + time_order=["0min", "15min"], + ), + score="effect_size_only", + ) + + def test_merge_adjacent_hits_preserves_rank_order_and_merges_counts(): merged = region_discovery.merge_adjacent_hits(_merge_helper_hits(), merge_distance=1) @@ -810,7 +965,7 @@ def fake_build_window_summary(**kwargs): def test_scan_genome_rejects_unimplemented_contrast_modes(): - with pytest.raises(ValueError, match="pairwise/group_vs_group"): + with pytest.raises(ValueError, match="paired contrast modes"): region_discovery.scan_genome( samples=[], motifs=["A,0"], @@ -818,10 +973,7 @@ def test_scan_genome_rejects_unimplemented_contrast_modes(): window_size=1000, step_size=1000, contrast=ContrastSpec( - mode="matched_pairwise", - numerator=["treated"], - denominator=["NS"], - pairing_key="donor", + mode="single_dataset", ), score="effect_size_only", min_coverage=1, From 953ce43cf7fac830bafa86ff307dec6c572698fa Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 11:34:25 -0700 Subject: [PATCH 055/272] fix: aggregate paired region discovery windows --- dimelo/region_discovery.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py index 5e5297a..e6abfcd 100644 --- a/dimelo/region_discovery.py +++ b/dimelo/region_discovery.py @@ -188,6 +188,15 @@ def _build_paired_window_table( raise ValueError("scan_genome paired discovery found no complete matched units.") paired = paired.loc[paired["pair_id"].isin(complete_pair_ids)].copy() + paired = ( + paired.groupby(_WINDOW_KEY_COLUMNS + ["pair_id", "condition"], as_index=False, sort=False) + .agg( + modified_count=("modified_count", "sum"), + valid_count=("valid_count", "sum"), + ) + .copy() + ) + paired["window_fraction"] = _safe_fraction(paired["modified_count"], paired["valid_count"]) return paired, { "n_pairs_used": len(complete_pair_ids), "n_pairs_dropped": dropped_pair_count, From b0650f969d1ad7fd448ebed3956ec9cf7dfe4a4f Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 11:38:54 -0700 Subject: [PATCH 056/272] test: cover paired region discovery regrouping --- tests/test_region_discovery.py | 24 +++++++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index 763a198..92dbc49 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -89,6 +89,20 @@ def _mock_paired_window_summary() -> pd.DataFrame: "valid_count": 20, "window_fraction": 0.5, }, + { + "sample_id": "t1_rep2", + "condition": "targeting", + "replicate": 2, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 4, + "valid_count": 10, + "window_fraction": 0.4, + }, { "sample_id": "d1", "condition": "nontargeting", @@ -157,6 +171,12 @@ def _paired_samplespecs() -> list[SampleSpec]: extract_h5="t1.h5", metadata={"pileup_path": "t1.bed.gz", "pair_id": "pair-1"}, ), + SampleSpec( + sample_id="t1_rep2", + condition="targeting", + extract_h5="t1_rep2.h5", + metadata={"pileup_path": "t1_rep2.bed.gz", "pair_id": "pair-1"}, + ), SampleSpec( sample_id="d1", condition="nontargeting", @@ -342,7 +362,9 @@ def test_scan_genome_matched_pairwise_uses_only_complete_pairs(monkeypatch): assert result.metadata["pairing_policy"] == "complete_pairs_only" assert result.metadata["n_pairs_used"] == 2 assert result.metadata["n_pairs_dropped"] == 1 - assert result.windows.loc[0, "valid_count"] == 80 + assert result.windows.loc[0, "modified_count"] == 26 + assert result.windows.loc[0, "valid_count"] == 90 + assert result.windows.loc[0, "window_fraction"] == pytest.approx(26 / 90) assert result.windows.loc[0, "score_value"] == pytest.approx(0.25) From 3c32cbdb3765c59c8ee9d2c8799cd088d2a905a3 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 11:40:28 -0700 Subject: [PATCH 057/272] test: verify paired helper aggregation --- tests/test_region_discovery.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index 92dbc49..4392297 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -368,6 +368,28 @@ def test_scan_genome_matched_pairwise_uses_only_complete_pairs(monkeypatch): assert result.windows.loc[0, "score_value"] == pytest.approx(0.25) +def test_build_paired_window_table_collapses_duplicate_rows(): + paired_table, pairing_meta = region_discovery._build_paired_window_table( + _mock_paired_window_summary(), + samples=_paired_samplespecs(), + pairing_key="pair_id", + required_conditions=["targeting", "nontargeting"], + pairing_policy="complete_pairs_only", + ) + + collapsed = paired_table.loc[ + (paired_table["window_id"] == "chr1:0-500") + & (paired_table["pair_id"] == "pair-1") + & (paired_table["condition"] == "targeting") + ] + + assert len(collapsed) == 1 + assert collapsed.iloc[0]["modified_count"] == 14 + assert collapsed.iloc[0]["valid_count"] == 30 + assert collapsed.iloc[0]["window_fraction"] == pytest.approx(14 / 30) + assert pairing_meta == {"n_pairs_used": 2, "n_pairs_dropped": 1} + + def test_scan_genome_time_course_errors_on_missing_pairing_key(monkeypatch): monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_window_summary()) From cbe1942cb2752ca31b302a7b19b93435fbf0f67e Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 11:31:52 -0700 Subject: [PATCH 058/272] feat: add paired region discovery pair resolution --- tests/test_region_discovery.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index 4392297..b44f436 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -388,8 +388,6 @@ def test_build_paired_window_table_collapses_duplicate_rows(): assert collapsed.iloc[0]["valid_count"] == 30 assert collapsed.iloc[0]["window_fraction"] == pytest.approx(14 / 30) assert pairing_meta == {"n_pairs_used": 2, "n_pairs_dropped": 1} - - def test_scan_genome_time_course_errors_on_missing_pairing_key(monkeypatch): monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_window_summary()) From de86ef9393de08509b625d3ca9663d138d99412c Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 11:47:26 -0700 Subject: [PATCH 059/272] feat: add matched pairwise region discovery scoring --- dimelo/region_discovery.py | 160 +++++++++++++++++++++++- tests/test_region_discovery.py | 214 ++++++++++++++++++++++++++++++++- 2 files changed, 370 insertions(+), 4 deletions(-) diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py index e6abfcd..350c7f4 100644 --- a/dimelo/region_discovery.py +++ b/dimelo/region_discovery.py @@ -203,6 +203,93 @@ def _build_paired_window_table( } +def _score_matched_pairwise( + paired_window_table: pd.DataFrame, + *, + contrast: ContrastSpec, + rank_by: str = "mean_abs_delta", +) -> pd.DataFrame: + if rank_by != "mean_abs_delta": + raise ValueError("scan_genome matched_pairwise currently supports rank_by='mean_abs_delta'.") + + numerator = paired_window_table.loc[ + paired_window_table["condition"].isin(contrast.numerator or []) + ].copy() + denominator = paired_window_table.loc[ + paired_window_table["condition"].isin(contrast.denominator or []) + ].copy() + + if numerator.empty or denominator.empty: + scored = pd.DataFrame(columns=_WINDOW_KEY_COLUMNS) + scored["mean_delta"] = pd.Series(dtype="float64") + scored["mean_abs_delta"] = pd.Series(dtype="float64") + scored["delta_sd"] = pd.Series(dtype="float64") + scored["sign_agreement"] = pd.Series(dtype="float64") + scored["n_pairs_used"] = pd.Series(dtype="int64") + scored["score_value"] = pd.Series(dtype="float64") + scored["p_value"] = pd.Series(dtype="object") + scored["adjusted_p_value"] = pd.Series(dtype="object") + return scored + + numerator = numerator.rename( + columns={ + "modified_count": "numerator_modified_count", + "valid_count": "numerator_valid_count", + "window_fraction": "numerator_fraction", + } + ) + denominator = denominator.rename( + columns={ + "modified_count": "denominator_modified_count", + "valid_count": "denominator_valid_count", + "window_fraction": "denominator_fraction", + } + ) + + merged = numerator.merge( + denominator[ + _WINDOW_KEY_COLUMNS + + ["pair_id", "denominator_modified_count", "denominator_valid_count", "denominator_fraction"] + ], + on=_WINDOW_KEY_COLUMNS + ["pair_id"], + how="inner", + ) + if merged.empty: + scored = pd.DataFrame(columns=_WINDOW_KEY_COLUMNS) + scored["mean_delta"] = pd.Series(dtype="float64") + scored["mean_abs_delta"] = pd.Series(dtype="float64") + scored["delta_sd"] = pd.Series(dtype="float64") + scored["sign_agreement"] = pd.Series(dtype="float64") + scored["n_pairs_used"] = pd.Series(dtype="int64") + scored["score_value"] = pd.Series(dtype="float64") + scored["p_value"] = pd.Series(dtype="object") + scored["adjusted_p_value"] = pd.Series(dtype="object") + return scored + + merged["delta"] = merged["numerator_fraction"] - merged["denominator_fraction"] + + scored = ( + merged.groupby(_WINDOW_KEY_COLUMNS, as_index=False, sort=False) + .agg( + mean_delta=("delta", "mean"), + mean_abs_delta=("delta", lambda values: float(values.abs().mean())), + delta_sd=("delta", lambda values: float(values.std(ddof=0))), + sign_agreement=( + "delta", + lambda values: float( + max((values.gt(0)).mean(), (values.lt(0)).mean()) if len(values) else 0.0 + ), + ), + n_pairs_used=("pair_id", "nunique"), + ) + .copy() + ) + scored["score_value"] = scored["mean_abs_delta"] + scored["p_value"] = pd.NA + scored["adjusted_p_value"] = pd.NA + return scored + + def _score_with_contrast( window_totals: pd.DataFrame, condition_counts: pd.DataFrame, @@ -602,6 +689,8 @@ def scan_genome( merge_distance: int = 0, score: str = "effect_size_only", contrast: ContrastSpec | None = None, + pairing_policy: str | None = None, + rank_by: str | None = None, quiet: bool = True, cores: int | None = None, ) -> RegionDiscoveryResult: @@ -633,8 +722,9 @@ def scan_genome( ) pairing_metadata: dict[str, object] = {} + active_pairing_policy = _pairing_policy_value(pairing_policy) + active_rank_by = rank_by if _is_paired_contrast(contrast): - pairing_policy = _pairing_policy_value(None) required_conditions = list(contrast.time_order or []) if contrast.mode == "time_course" else list( dict.fromkeys((contrast.numerator or []) + (contrast.denominator or [])) ) @@ -643,8 +733,70 @@ def scan_genome( samples=samples, pairing_key=contrast.pairing_key, required_conditions=required_conditions, - pairing_policy=pairing_policy, + pairing_policy=active_pairing_policy, ) + if contrast.mode == "matched_pairwise": + if score != "effect_size_only": + raise ValueError("scan_genome matched_pairwise currently supports score='effect_size_only'.") + active_rank_by = active_rank_by or "mean_abs_delta" + window_totals = _aggregate_window_counts(window_summary) + scored = _score_matched_pairwise( + window_summary, + contrast=contrast, + rank_by=active_rank_by, + ) + ranked = _rank_windows(scored, score=score) + scored_columns = [ + column + for column in ranked.columns + if column not in _WINDOW_KEY_COLUMNS + and column not in {"modified_count", "valid_count", "window_fraction"} + ] + window_table = window_totals.merge( + ranked.loc[:, _WINDOW_KEY_COLUMNS + scored_columns], + on=_WINDOW_KEY_COLUMNS, + how="left", + sort=False, + ) + hits = ranked.copy() + + if merge_hits: + hits = merge_adjacent_hits(hits, merge_distance=merge_distance) + + plot_data = { + "window_score_table": window_table.copy(), + "top_hits_table": hits.copy(), + } + metadata = { + "analysis_unit": "ensemble_region", + "representation": "modified_fraction", + "signal_source": "pileup_counts", + "score": score, + "window_size": window_size, + "step_size": step_size, + "min_coverage": min_coverage, + "merge_hits": merge_hits, + "merge_distance": merge_distance, + "motifs": motif_list, + "include_contigs": list(include_contigs) if include_contigs is not None else None, + "exclude_contigs": list(exclude_contigs) if exclude_contigs is not None else None, + "contrast_mode": contrast.mode, + "contrast_numerator": list(contrast.numerator or []), + "contrast_denominator": list(contrast.denominator or []), + "pairing_policy": active_pairing_policy, + "n_pairs_used": pairing_metadata["n_pairs_used"], + "n_pairs_dropped": pairing_metadata["n_pairs_dropped"], + "paired_mode": contrast.mode, + "rank_by": active_rank_by, + } + return RegionDiscoveryResult( + hits=hits.reset_index(drop=True), + windows=window_table.reset_index(drop=True), + contrast=contrast, + plot_data=plot_data, + metadata=metadata, + figures={}, + ) window_totals = _aggregate_window_counts(window_summary) condition_counts = _aggregate_condition_counts(window_summary) @@ -706,9 +858,11 @@ def scan_genome( metadata["contrast_numerator"] = list(contrast.numerator or []) metadata["contrast_denominator"] = list(contrast.denominator or []) if pairing_metadata: - metadata["pairing_policy"] = _pairing_policy_value(None) + metadata["pairing_policy"] = active_pairing_policy metadata["n_pairs_used"] = pairing_metadata["n_pairs_used"] metadata["n_pairs_dropped"] = pairing_metadata["n_pairs_dropped"] + metadata["paired_mode"] = contrast.mode if contrast is not None else None + metadata["rank_by"] = active_rank_by return RegionDiscoveryResult( hits=hits.reset_index(drop=True), diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index b44f436..084878f 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -163,6 +163,167 @@ def _mock_paired_window_summary() -> pd.DataFrame: ) +def _mock_paired_pairwise_window_summary() -> pd.DataFrame: + return pd.DataFrame( + [ + { + "sample_id": "t1", + "condition": "targeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 4, + "valid_count": 5, + "window_fraction": 0.8, + }, + { + "sample_id": "t1_rep2", + "condition": "targeting", + "replicate": 2, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 4, + "valid_count": 5, + "window_fraction": 0.8, + }, + { + "sample_id": "d1", + "condition": "nontargeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 4, + "valid_count": 10, + "window_fraction": 0.4, + }, + { + "sample_id": "t2", + "condition": "targeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 7, + "valid_count": 10, + "window_fraction": 0.7, + }, + { + "sample_id": "d2", + "condition": "nontargeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 4, + "valid_count": 10, + "window_fraction": 0.4, + }, + { + "sample_id": "t1", + "condition": "targeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 1, + "valid_count": 5, + "window_fraction": 0.2, + }, + { + "sample_id": "t1_rep2", + "condition": "targeting", + "replicate": 2, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 1, + "valid_count": 5, + "window_fraction": 0.2, + }, + { + "sample_id": "d1", + "condition": "nontargeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 4, + "valid_count": 10, + "window_fraction": 0.4, + }, + { + "sample_id": "t2", + "condition": "targeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 3, + "valid_count": 10, + "window_fraction": 0.3, + }, + { + "sample_id": "d2", + "condition": "nontargeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 4, + "valid_count": 10, + "window_fraction": 0.4, + }, + { + "sample_id": "t3", + "condition": "targeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 5, + "valid_count": 10, + "window_fraction": 0.5, + }, + ] + ) + + def _paired_samplespecs() -> list[SampleSpec]: return [ SampleSpec( @@ -365,7 +526,58 @@ def test_scan_genome_matched_pairwise_uses_only_complete_pairs(monkeypatch): assert result.windows.loc[0, "modified_count"] == 26 assert result.windows.loc[0, "valid_count"] == 90 assert result.windows.loc[0, "window_fraction"] == pytest.approx(26 / 90) - assert result.windows.loc[0, "score_value"] == pytest.approx(0.25) + assert result.windows.loc[0, "score_value"] == pytest.approx(7 / 30) + + +def test_scan_genome_matched_pairwise_ranks_by_mean_abs_delta(monkeypatch): + monkeypatch.setattr( + global_analysis, + "build_window_summary", + lambda **_: _mock_paired_pairwise_window_summary(), + ) + + result = region_discovery.scan_genome( + samples=_paired_samplespecs(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=500, + step_size=500, + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["targeting"], + denominator=["nontargeting"], + pairing_key="pair_id", + ), + score="effect_size_only", + ) + + assert list(result.hits["window_id"]) == ["chr1:0-500", "chr1:500-1000"] + assert result.hits.loc[0, "mean_delta"] == pytest.approx(0.35) + assert result.hits.loc[0, "mean_abs_delta"] == pytest.approx(0.35) + assert result.hits.loc[0, "sign_agreement"] == pytest.approx(1.0) + assert result.metadata["paired_mode"] == "matched_pairwise" + assert result.metadata["rank_by"] == "mean_abs_delta" + + +def test_scan_genome_matched_pairwise_errors_on_missing_pairs_in_strict_mode(monkeypatch): + monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_window_summary()) + + with pytest.raises(ValueError, match="incomplete matched units"): + region_discovery.scan_genome( + samples=_paired_samplespecs(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=500, + step_size=500, + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["targeting"], + denominator=["nontargeting"], + pairing_key="pair_id", + ), + score="effect_size_only", + pairing_policy="error_on_missing", + ) def test_build_paired_window_table_collapses_duplicate_rows(): From f41a44a5fe012ed9fffbf12dabe5b82e10e5937c Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 11:59:01 -0700 Subject: [PATCH 060/272] fix: harden matched pairwise discovery guards --- dimelo/region_discovery.py | 31 ++++++++++++-- tests/test_region_discovery.py | 77 ++++++++++++++++++++++++++++++++++ 2 files changed, 104 insertions(+), 4 deletions(-) diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py index 350c7f4..a18c514 100644 --- a/dimelo/region_discovery.py +++ b/dimelo/region_discovery.py @@ -725,6 +725,13 @@ def scan_genome( active_pairing_policy = _pairing_policy_value(pairing_policy) active_rank_by = rank_by if _is_paired_contrast(contrast): + if contrast.mode == "matched_pairwise": + numerator_conditions = list(contrast.numerator or []) + denominator_conditions = list(contrast.denominator or []) + if len(numerator_conditions) != 1 or len(denominator_conditions) != 1: + raise ValueError( + "scan_genome matched_pairwise requires exactly one numerator and one denominator condition." + ) required_conditions = list(contrast.time_order or []) if contrast.mode == "time_course" else list( dict.fromkeys((contrast.numerator or []) + (contrast.denominator or [])) ) @@ -738,6 +745,8 @@ def scan_genome( if contrast.mode == "matched_pairwise": if score != "effect_size_only": raise ValueError("scan_genome matched_pairwise currently supports score='effect_size_only'.") + if merge_hits: + raise ValueError("scan_genome matched_pairwise does not support merge_hits=True.") active_rank_by = active_rank_by or "mean_abs_delta" window_totals = _aggregate_window_counts(window_summary) scored = _score_matched_pairwise( @@ -758,10 +767,24 @@ def scan_genome( how="left", sort=False, ) - hits = ranked.copy() - - if merge_hits: - hits = merge_adjacent_hits(hits, merge_distance=merge_distance) + covered_mask = window_table["valid_count"] >= min_coverage + paired_score_columns = [ + column + for column in [ + "mean_delta", + "mean_abs_delta", + "delta_sd", + "sign_agreement", + "n_pairs_used", + "score_value", + "p_value", + "adjusted_p_value", + "rank", + ] + if column in window_table.columns + ] + window_table.loc[~covered_mask, paired_score_columns] = pd.NA + hits = _sort_hits_for_output(window_table.loc[covered_mask].copy()) plot_data = { "window_score_table": window_table.copy(), diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index 084878f..3a2218b 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -580,6 +580,83 @@ def test_scan_genome_matched_pairwise_errors_on_missing_pairs_in_strict_mode(mon ) +def test_scan_genome_matched_pairwise_applies_min_coverage_filtering(monkeypatch): + monkeypatch.setattr( + global_analysis, + "build_window_summary", + lambda **_: _mock_paired_pairwise_window_summary(), + ) + + result = region_discovery.scan_genome( + samples=_paired_samplespecs(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=500, + step_size=500, + min_coverage=50, + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["targeting"], + denominator=["nontargeting"], + pairing_key="pair_id", + ), + score="effect_size_only", + ) + + assert result.hits.empty + assert pd.isna(result.windows.loc[0, "rank"]) + assert pd.isna(result.windows.loc[0, "score_value"]) + + +def test_scan_genome_matched_pairwise_rejects_merge_hits(monkeypatch): + monkeypatch.setattr( + global_analysis, + "build_window_summary", + lambda **_: _mock_paired_pairwise_window_summary(), + ) + + with pytest.raises(ValueError, match="does not support merge_hits=True"): + region_discovery.scan_genome( + samples=_paired_samplespecs(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=500, + step_size=500, + merge_hits=True, + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["targeting"], + denominator=["nontargeting"], + pairing_key="pair_id", + ), + score="effect_size_only", + ) + + +def test_scan_genome_matched_pairwise_rejects_multi_condition_sides(monkeypatch): + monkeypatch.setattr( + global_analysis, + "build_window_summary", + lambda **_: _mock_paired_pairwise_window_summary(), + ) + + with pytest.raises(ValueError, match="exactly one numerator and one denominator condition"): + region_discovery.scan_genome( + samples=_paired_samplespecs(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=500, + step_size=500, + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["targeting", "backup"], + denominator=["nontargeting"], + pairing_key="pair_id", + ), + score="effect_size_only", + ) + + def test_build_paired_window_table_collapses_duplicate_rows(): paired_table, pairing_meta = region_discovery._build_paired_window_table( _mock_paired_window_summary(), From af1b18d089006e28466f89ae641d2543656f837f Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 12:01:15 -0700 Subject: [PATCH 061/272] fix: rerank matched pairwise hits after coverage filtering --- dimelo/region_discovery.py | 2 + tests/test_region_discovery.py | 135 +++++++++++++++++++++++++++++++++ 2 files changed, 137 insertions(+) diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py index a18c514..bbf6297 100644 --- a/dimelo/region_discovery.py +++ b/dimelo/region_discovery.py @@ -785,6 +785,8 @@ def scan_genome( ] window_table.loc[~covered_mask, paired_score_columns] = pd.NA hits = _sort_hits_for_output(window_table.loc[covered_mask].copy()) + if not hits.empty: + hits["rank"] = range(1, len(hits) + 1) plot_data = { "window_score_table": window_table.copy(), diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index 3a2218b..6497c32 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -608,6 +608,141 @@ def test_scan_genome_matched_pairwise_applies_min_coverage_filtering(monkeypatch assert pd.isna(result.windows.loc[0, "score_value"]) +def test_scan_genome_matched_pairwise_reranks_surviving_hits_after_coverage_filter(monkeypatch): + monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: pd.DataFrame( + [ + { + "sample_id": "t1", + "condition": "targeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 9, + "valid_count": 10, + "window_fraction": 0.9, + }, + { + "sample_id": "d1", + "condition": "nontargeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 1, + "valid_count": 10, + "window_fraction": 0.1, + }, + { + "sample_id": "t2", + "condition": "targeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 12, + "valid_count": 60, + "window_fraction": 0.2, + }, + { + "sample_id": "d2", + "condition": "nontargeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 6, + "valid_count": 60, + "window_fraction": 0.1, + }, + { + "sample_id": "t1", + "condition": "targeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-1500", + "chromosome": "chr1", + "start": 1000, + "end": 1500, + "strand": ".", + "modified_count": 10, + "valid_count": 60, + "window_fraction": 1 / 6, + }, + { + "sample_id": "d1", + "condition": "nontargeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-1500", + "chromosome": "chr1", + "start": 1000, + "end": 1500, + "strand": ".", + "modified_count": 6, + "valid_count": 60, + "window_fraction": 0.1, + }, + ] + )) + + result = region_discovery.scan_genome( + samples=[ + SampleSpec( + sample_id="t1", + condition="targeting", + extract_h5="t1.h5", + metadata={"pileup_path": "t1.bed.gz", "pair_id": "pair-1"}, + ), + SampleSpec( + sample_id="d1", + condition="nontargeting", + extract_h5="d1.h5", + metadata={"pileup_path": "d1.bed.gz", "pair_id": "pair-1"}, + ), + SampleSpec( + sample_id="t2", + condition="targeting", + extract_h5="t2.h5", + metadata={"pileup_path": "t2.bed.gz", "pair_id": "pair-2"}, + ), + SampleSpec( + sample_id="d2", + condition="nontargeting", + extract_h5="d2.h5", + metadata={"pileup_path": "d2.bed.gz", "pair_id": "pair-2"}, + ), + ], + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + window_size=500, + step_size=500, + min_coverage=50, + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["targeting"], + denominator=["nontargeting"], + pairing_key="pair_id", + ), + score="effect_size_only", + ) + + assert list(result.hits["window_id"]) == ["chr1:500-1000", "chr1:1000-1500"] + assert list(result.hits["rank"]) == [1, 2] + + def test_scan_genome_matched_pairwise_rejects_merge_hits(monkeypatch): monkeypatch.setattr( global_analysis, From 9403db65c544932de63a75d66a0181e9d25b338a Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 12:03:13 -0700 Subject: [PATCH 062/272] fix: keep matched pairwise ranks consistent after filtering --- dimelo/region_discovery.py | 10 +++++++++- tests/test_region_discovery.py | 3 +++ 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py index bbf6297..a199f51 100644 --- a/dimelo/region_discovery.py +++ b/dimelo/region_discovery.py @@ -784,9 +784,17 @@ def scan_genome( if column in window_table.columns ] window_table.loc[~covered_mask, paired_score_columns] = pd.NA - hits = _sort_hits_for_output(window_table.loc[covered_mask].copy()) + covered_hits = ranked.merge( + window_totals.loc[:, _WINDOW_KEY_COLUMNS + ["modified_count", "valid_count", "window_fraction"]], + on=_WINDOW_KEY_COLUMNS, + how="left", + sort=False, + ) + hits = covered_hits.loc[covered_hits["valid_count"] >= min_coverage].copy() if not hits.empty: hits["rank"] = range(1, len(hits) + 1) + rank_lookup = hits.set_index("window_id")["rank"] + window_table["rank"] = window_table["window_id"].map(rank_lookup) plot_data = { "window_score_table": window_table.copy(), diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index 6497c32..fbb500e 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -741,6 +741,9 @@ def test_scan_genome_matched_pairwise_reranks_surviving_hits_after_coverage_filt assert list(result.hits["window_id"]) == ["chr1:500-1000", "chr1:1000-1500"] assert list(result.hits["rank"]) == [1, 2] + covered_windows = result.windows.loc[result.windows["valid_count"] >= 50] + assert list(covered_windows["window_id"]) == list(result.hits["window_id"]) + assert list(covered_windows["rank"]) == list(result.hits["rank"]) def test_scan_genome_matched_pairwise_rejects_merge_hits(monkeypatch): From 19c0f7464337d524ac2469d390e1388163de0266 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 11:47:26 -0700 Subject: [PATCH 063/272] feat: add matched pairwise region discovery scoring --- tests/test_region_discovery.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index fbb500e..a661189 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -815,6 +815,8 @@ def test_build_paired_window_table_collapses_duplicate_rows(): assert collapsed.iloc[0]["valid_count"] == 30 assert collapsed.iloc[0]["window_fraction"] == pytest.approx(14 / 30) assert pairing_meta == {"n_pairs_used": 2, "n_pairs_dropped": 1} + + def test_scan_genome_time_course_errors_on_missing_pairing_key(monkeypatch): monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_window_summary()) From 752879e847c62c9d1a58d287bec281ec0fcae4ba Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 11:59:01 -0700 Subject: [PATCH 064/272] fix: harden matched pairwise discovery guards --- tests/test_region_discovery.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index a661189..d7c746e 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -607,7 +607,6 @@ def test_scan_genome_matched_pairwise_applies_min_coverage_filtering(monkeypatch assert pd.isna(result.windows.loc[0, "rank"]) assert pd.isna(result.windows.loc[0, "score_value"]) - def test_scan_genome_matched_pairwise_reranks_surviving_hits_after_coverage_filter(monkeypatch): monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: pd.DataFrame( [ @@ -744,8 +743,6 @@ def test_scan_genome_matched_pairwise_reranks_surviving_hits_after_coverage_filt covered_windows = result.windows.loc[result.windows["valid_count"] >= 50] assert list(covered_windows["window_id"]) == list(result.hits["window_id"]) assert list(covered_windows["rank"]) == list(result.hits["rank"]) - - def test_scan_genome_matched_pairwise_rejects_merge_hits(monkeypatch): monkeypatch.setattr( global_analysis, From 9d1a79adc25c63883e9cfc39a5a4454f87288117 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 12:01:15 -0700 Subject: [PATCH 065/272] fix: rerank matched pairwise hits after coverage filtering --- tests/test_region_discovery.py | 89 ++++++++++++++++++++++++++++++++++ 1 file changed, 89 insertions(+) diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index d7c746e..52b6591 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -697,6 +697,95 @@ def test_scan_genome_matched_pairwise_reranks_surviving_hits_after_coverage_filt ] )) +def test_scan_genome_matched_pairwise_reranks_surviving_hits_after_coverage_filter(monkeypatch): + monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: pd.DataFrame( + [ + { + "sample_id": "t1", + "condition": "targeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 9, + "valid_count": 10, + "window_fraction": 0.9, + }, + { + "sample_id": "d1", + "condition": "nontargeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 1, + "valid_count": 10, + "window_fraction": 0.1, + }, + { + "sample_id": "t2", + "condition": "targeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 12, + "valid_count": 60, + "window_fraction": 0.2, + }, + { + "sample_id": "d2", + "condition": "nontargeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 6, + "valid_count": 60, + "window_fraction": 0.1, + }, + { + "sample_id": "t1", + "condition": "targeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-1500", + "chromosome": "chr1", + "start": 1000, + "end": 1500, + "strand": ".", + "modified_count": 10, + "valid_count": 60, + "window_fraction": 1 / 6, + }, + { + "sample_id": "d1", + "condition": "nontargeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-1500", + "chromosome": "chr1", + "start": 1000, + "end": 1500, + "strand": ".", + "modified_count": 6, + "valid_count": 60, + "window_fraction": 0.1, + }, + ] + )) result = region_discovery.scan_genome( samples=[ SampleSpec( From 0dadec892bbaaae30a5960e6da3b71ebd50efdd3 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 12:12:40 -0700 Subject: [PATCH 066/272] feat: add paired time-course region discovery --- dimelo/region_discovery.py | 162 ++++++++++++++++ tests/test_region_discovery.py | 327 +++++++++++++++++++++++++++++++++ 2 files changed, 489 insertions(+) diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py index a199f51..ff2d96c 100644 --- a/dimelo/region_discovery.py +++ b/dimelo/region_discovery.py @@ -290,6 +290,69 @@ def _score_matched_pairwise( return scored +def _validate_time_order(paired_window_table: pd.DataFrame, time_order: list[str]) -> None: + available_conditions = set(paired_window_table["condition"].dropna().tolist()) + missing = [condition for condition in time_order if condition not in available_conditions] + if missing: + raise ValueError( + "scan_genome paired time_course requested missing time_order condition(s): " + + ", ".join(missing) + ) + + +def _score_paired_time_course( + paired_window_table: pd.DataFrame, + *, + time_order: list[str], +) -> pd.DataFrame: + if paired_window_table.empty: + scored = pd.DataFrame(columns=_WINDOW_KEY_COLUMNS) + scored["trajectory_amplitude_mean"] = pd.Series(dtype="float64") + scored["trajectory_amplitude_sd"] = pd.Series(dtype="float64") + scored["n_pairs_used"] = pd.Series(dtype="int64") + scored["score_value"] = pd.Series(dtype="float64") + scored["p_value"] = pd.Series(dtype="object") + scored["adjusted_p_value"] = pd.Series(dtype="object") + return scored + + _validate_time_order(paired_window_table, time_order) + + ordered = paired_window_table.copy() + ordered["condition"] = pd.Categorical( + ordered["condition"], + categories=time_order, + ordered=True, + ) + ordered = ordered.sort_values( + by=_WINDOW_KEY_COLUMNS + ["pair_id", "condition"], + ascending=[True] * (len(_WINDOW_KEY_COLUMNS) + 2), + kind="mergesort", + na_position="last", + ).reset_index(drop=True) + + per_pair = ( + ordered.groupby(_WINDOW_KEY_COLUMNS + ["pair_id"], as_index=False, sort=False) + .agg( + trajectory_amplitude=("window_fraction", lambda values: float(values.max() - values.min())), + ) + .copy() + ) + + scored = ( + per_pair.groupby(_WINDOW_KEY_COLUMNS, as_index=False, sort=False) + .agg( + trajectory_amplitude_mean=("trajectory_amplitude", "mean"), + trajectory_amplitude_sd=("trajectory_amplitude", lambda values: float(values.std(ddof=0))), + n_pairs_used=("pair_id", "nunique"), + ) + .copy() + ) + scored["score_value"] = scored["trajectory_amplitude_mean"] + scored["p_value"] = pd.NA + scored["adjusted_p_value"] = pd.NA + return scored + + def _score_with_contrast( window_totals: pd.DataFrame, condition_counts: pd.DataFrame, @@ -725,6 +788,22 @@ def scan_genome( active_pairing_policy = _pairing_policy_value(pairing_policy) active_rank_by = rank_by if _is_paired_contrast(contrast): + if contrast.mode == "time_course": + if not contrast.pairing_key: + raise ValueError("scan_genome paired discovery requires an explicit pairing_key.") + active_rank_by = active_rank_by or "trajectory_amplitude_mean" + if active_rank_by != "trajectory_amplitude_mean": + raise ValueError( + "scan_genome time_course currently supports rank_by='trajectory_amplitude_mean'." + ) + time_order = list(dict.fromkeys(contrast.time_order or [])) + available_conditions = set(window_summary["condition"].dropna().tolist()) + missing_time_order = [condition for condition in time_order if condition not in available_conditions] + if missing_time_order: + raise ValueError( + "scan_genome paired time_course requested missing time_order condition(s): " + + ", ".join(missing_time_order) + ) if contrast.mode == "matched_pairwise": numerator_conditions = list(contrast.numerator or []) denominator_conditions = list(contrast.denominator or []) @@ -830,6 +909,89 @@ def scan_genome( metadata=metadata, figures={}, ) + if contrast.mode == "time_course": + if score != "effect_size_only": + raise ValueError("scan_genome time_course currently supports score='effect_size_only'.") + if merge_hits: + raise ValueError("scan_genome time_course does not support merge_hits=True.") + time_order = list(dict.fromkeys(contrast.time_order or [])) + window_totals = _aggregate_window_counts(window_summary) + scored = _score_paired_time_course(window_summary, time_order=time_order) + ranked = _rank_windows(scored, score=score) + scored_columns = [ + column + for column in ranked.columns + if column not in _WINDOW_KEY_COLUMNS + and column not in {"modified_count", "valid_count", "window_fraction"} + ] + window_table = window_totals.merge( + ranked.loc[:, _WINDOW_KEY_COLUMNS + scored_columns], + on=_WINDOW_KEY_COLUMNS, + how="left", + sort=False, + ) + covered_mask = window_table["valid_count"] >= min_coverage + paired_score_columns = [ + column + for column in [ + "trajectory_amplitude_mean", + "trajectory_amplitude_sd", + "n_pairs_used", + "score_value", + "p_value", + "adjusted_p_value", + "rank", + ] + if column in window_table.columns + ] + window_table.loc[~covered_mask, paired_score_columns] = pd.NA + covered_hits = ranked.merge( + window_totals.loc[:, _WINDOW_KEY_COLUMNS + ["modified_count", "valid_count", "window_fraction"]], + on=_WINDOW_KEY_COLUMNS, + how="left", + sort=False, + ) + hits = covered_hits.loc[covered_hits["valid_count"] >= min_coverage].copy() + if not hits.empty: + hits["rank"] = range(1, len(hits) + 1) + rank_lookup = hits.set_index("window_id")["rank"] + window_table["rank"] = window_table["window_id"].map(rank_lookup) + + plot_data = { + "window_score_table": window_table.copy(), + "top_hits_table": hits.copy(), + } + metadata = { + "analysis_unit": "ensemble_region", + "representation": "modified_fraction", + "signal_source": "pileup_counts", + "score": score, + "window_size": window_size, + "step_size": step_size, + "min_coverage": min_coverage, + "merge_hits": merge_hits, + "merge_distance": merge_distance, + "motifs": motif_list, + "include_contigs": list(include_contigs) if include_contigs is not None else None, + "exclude_contigs": list(exclude_contigs) if exclude_contigs is not None else None, + "contrast_mode": contrast.mode, + "contrast_numerator": list(contrast.numerator or []), + "contrast_denominator": list(contrast.denominator or []), + "pairing_policy": active_pairing_policy, + "n_pairs_used": pairing_metadata["n_pairs_used"], + "n_pairs_dropped": pairing_metadata["n_pairs_dropped"], + "paired_mode": contrast.mode, + "time_order": time_order, + "rank_by": active_rank_by, + } + return RegionDiscoveryResult( + hits=hits.reset_index(drop=True), + windows=window_table.reset_index(drop=True), + contrast=contrast, + plot_data=plot_data, + metadata=metadata, + figures={}, + ) window_totals = _aggregate_window_counts(window_summary) condition_counts = _aggregate_condition_counts(window_summary) diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index 52b6591..4131954 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -903,6 +903,333 @@ def test_build_paired_window_table_collapses_duplicate_rows(): assert pairing_meta == {"n_pairs_used": 2, "n_pairs_dropped": 1} +def _paired_time_course_samplespecs() -> list[SampleSpec]: + return [ + SampleSpec( + sample_id="tp1_0", + condition="0min", + extract_h5="tp1_0.h5", + metadata={"pileup_path": "tp1_0.bed.gz", "pair_id": "pair-1"}, + ), + SampleSpec( + sample_id="tp1_15", + condition="15min", + extract_h5="tp1_15.h5", + metadata={"pileup_path": "tp1_15.bed.gz", "pair_id": "pair-1"}, + ), + SampleSpec( + sample_id="tp1_30", + condition="30min", + extract_h5="tp1_30.h5", + metadata={"pileup_path": "tp1_30.bed.gz", "pair_id": "pair-1"}, + ), + SampleSpec( + sample_id="tp2_0", + condition="0min", + extract_h5="tp2_0.h5", + metadata={"pileup_path": "tp2_0.bed.gz", "pair_id": "pair-2"}, + ), + SampleSpec( + sample_id="tp2_15", + condition="15min", + extract_h5="tp2_15.h5", + metadata={"pileup_path": "tp2_15.bed.gz", "pair_id": "pair-2"}, + ), + SampleSpec( + sample_id="tp2_30", + condition="30min", + extract_h5="tp2_30.h5", + metadata={"pileup_path": "tp2_30.bed.gz", "pair_id": "pair-2"}, + ), + SampleSpec( + sample_id="tp3_0", + condition="0min", + extract_h5="tp3_0.h5", + metadata={"pileup_path": "tp3_0.bed.gz", "pair_id": "pair-3"}, + ), + SampleSpec( + sample_id="tp3_15", + condition="15min", + extract_h5="tp3_15.h5", + metadata={"pileup_path": "tp3_15.bed.gz", "pair_id": "pair-3"}, + ), + ] + + +def _mock_paired_time_course_window_summary() -> pd.DataFrame: + return pd.DataFrame( + [ + { + "sample_id": "tp1_0", + "condition": "0min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 2, + "valid_count": 10, + "window_fraction": 0.2, + }, + { + "sample_id": "tp1_15", + "condition": "15min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 7, + "valid_count": 10, + "window_fraction": 0.7, + }, + { + "sample_id": "tp1_30", + "condition": "30min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 8, + "valid_count": 10, + "window_fraction": 0.8, + }, + { + "sample_id": "tp2_0", + "condition": "0min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 1, + "valid_count": 10, + "window_fraction": 0.1, + }, + { + "sample_id": "tp2_15", + "condition": "15min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 6, + "valid_count": 10, + "window_fraction": 0.6, + }, + { + "sample_id": "tp2_30", + "condition": "30min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 6, + "valid_count": 10, + "window_fraction": 0.6, + }, + { + "sample_id": "tp3_0", + "condition": "0min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 3, + "valid_count": 10, + "window_fraction": 0.3, + }, + { + "sample_id": "tp3_15", + "condition": "15min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 5, + "valid_count": 10, + "window_fraction": 0.5, + }, + { + "sample_id": "tp1_0", + "condition": "0min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 1, + "valid_count": 10, + "window_fraction": 0.1, + }, + { + "sample_id": "tp1_15", + "condition": "15min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 2, + "valid_count": 10, + "window_fraction": 0.2, + }, + { + "sample_id": "tp1_30", + "condition": "30min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 4, + "valid_count": 10, + "window_fraction": 0.4, + }, + { + "sample_id": "tp2_0", + "condition": "0min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 2, + "valid_count": 10, + "window_fraction": 0.2, + }, + { + "sample_id": "tp2_15", + "condition": "15min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 3, + "valid_count": 10, + "window_fraction": 0.3, + }, + { + "sample_id": "tp2_30", + "condition": "30min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 3, + "valid_count": 10, + "window_fraction": 0.3, + }, + { + "sample_id": "tp3_0", + "condition": "0min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 4, + "valid_count": 10, + "window_fraction": 0.4, + }, + { + "sample_id": "tp3_15", + "condition": "15min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 6, + "valid_count": 10, + "window_fraction": 0.6, + }, + ] + ) + + +def test_scan_genome_time_course_ranks_by_trajectory_amplitude_mean(monkeypatch): + monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_time_course_window_summary()) + + result = region_discovery.scan_genome( + samples=_paired_time_course_samplespecs(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=500, + step_size=500, + contrast=ContrastSpec( + mode="time_course", + time_order=["0min", "15min", "30min"], + pairing_key="pair_id", + ), + score="effect_size_only", + ) + + assert result.hits.loc[0, "trajectory_amplitude_mean"] == pytest.approx(0.55) + assert result.hits.loc[0, "trajectory_amplitude_sd"] == pytest.approx(0.05) + assert result.metadata["paired_mode"] == "time_course" + assert result.metadata["time_order"] == ["0min", "15min", "30min"] + assert result.metadata["rank_by"] == "trajectory_amplitude_mean" + + +def test_scan_genome_time_course_errors_when_time_order_conditions_are_missing(monkeypatch): + monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_time_course_window_summary()) + + with pytest.raises(ValueError, match="time_order"): + region_discovery.scan_genome( + samples=_paired_time_course_samplespecs(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=500, + step_size=500, + contrast=ContrastSpec( + mode="time_course", + time_order=["0min", "15min", "60min"], + pairing_key="pair_id", + ), + score="effect_size_only", + ) + + def test_scan_genome_time_course_errors_on_missing_pairing_key(monkeypatch): monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_window_summary()) From ace1eb5322c0f3f1e15e90ad55cf272c6c605bba Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 12:20:02 -0700 Subject: [PATCH 067/272] fix: tighten paired time-course trajectories --- dimelo/region_discovery.py | 30 ++- tests/test_region_discovery.py | 374 +++++++++++++++++++++++++++++++++ 2 files changed, 402 insertions(+), 2 deletions(-) diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py index ff2d96c..86a7985 100644 --- a/dimelo/region_discovery.py +++ b/dimelo/region_discovery.py @@ -315,9 +315,9 @@ def _score_paired_time_course( scored["adjusted_p_value"] = pd.Series(dtype="object") return scored - _validate_time_order(paired_window_table, time_order) + ordered = paired_window_table.loc[paired_window_table["condition"].isin(time_order)].copy() + _validate_time_order(ordered, time_order) - ordered = paired_window_table.copy() ordered["condition"] = pd.Categorical( ordered["condition"], categories=time_order, @@ -330,6 +330,32 @@ def _score_paired_time_course( na_position="last", ).reset_index(drop=True) + complete_trajectories = ( + ordered.drop_duplicates(subset=_WINDOW_KEY_COLUMNS + ["pair_id", "condition"]) + .groupby(_WINDOW_KEY_COLUMNS + ["pair_id"], as_index=False, sort=False) + .agg(trajectory_condition_count=("condition", "nunique")) + ) + complete_trajectory_ids = complete_trajectories.loc[ + complete_trajectories["trajectory_condition_count"] == len(time_order), + _WINDOW_KEY_COLUMNS + ["pair_id"], + ] + if complete_trajectory_ids.empty: + scored = pd.DataFrame(columns=_WINDOW_KEY_COLUMNS) + scored["trajectory_amplitude_mean"] = pd.Series(dtype="float64") + scored["trajectory_amplitude_sd"] = pd.Series(dtype="float64") + scored["n_pairs_used"] = pd.Series(dtype="int64") + scored["score_value"] = pd.Series(dtype="float64") + scored["p_value"] = pd.Series(dtype="object") + scored["adjusted_p_value"] = pd.Series(dtype="object") + return scored + + ordered = ordered.merge( + complete_trajectory_ids, + on=_WINDOW_KEY_COLUMNS + ["pair_id"], + how="inner", + sort=False, + ) + per_pair = ( ordered.groupby(_WINDOW_KEY_COLUMNS + ["pair_id"], as_index=False, sort=False) .agg( diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index 4131954..e407ee9 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -1230,6 +1230,380 @@ def test_scan_genome_time_course_errors_when_time_order_conditions_are_missing(m ) +def test_scan_genome_time_course_filters_incomplete_trajectories_per_window(monkeypatch): + monkeypatch.setattr( + global_analysis, + "build_window_summary", + lambda **_: pd.DataFrame( + [ + { + "sample_id": "tp1_0", + "condition": "0min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 2, + "valid_count": 10, + "window_fraction": 0.2, + }, + { + "sample_id": "tp1_15", + "condition": "15min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 4, + "valid_count": 10, + "window_fraction": 0.4, + }, + { + "sample_id": "tp1_30", + "condition": "30min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 8, + "valid_count": 10, + "window_fraction": 0.8, + }, + { + "sample_id": "tp2_0", + "condition": "0min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 1, + "valid_count": 10, + "window_fraction": 0.1, + }, + { + "sample_id": "tp2_15", + "condition": "15min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 3, + "valid_count": 10, + "window_fraction": 0.3, + }, + { + "sample_id": "tp2_30", + "condition": "30min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 6, + "valid_count": 10, + "window_fraction": 0.6, + }, + { + "sample_id": "tp1_0", + "condition": "0min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 2, + "valid_count": 10, + "window_fraction": 0.2, + }, + { + "sample_id": "tp1_15", + "condition": "15min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 5, + "valid_count": 10, + "window_fraction": 0.5, + }, + { + "sample_id": "tp2_0", + "condition": "0min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 1, + "valid_count": 10, + "window_fraction": 0.1, + }, + { + "sample_id": "tp2_15", + "condition": "15min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 2, + "valid_count": 10, + "window_fraction": 0.2, + }, + { + "sample_id": "tp2_30", + "condition": "30min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 9, + "valid_count": 10, + "window_fraction": 0.9, + }, + ] + ), + ) + + result = region_discovery.scan_genome( + samples=_paired_time_course_samplespecs(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=500, + step_size=500, + contrast=ContrastSpec( + mode="time_course", + time_order=["0min", "15min", "30min"], + pairing_key="pair_id", + ), + score="effect_size_only", + ) + + first_window = result.hits.loc[result.hits["window_id"] == "chr1:0-500"].iloc[0] + second_window = result.hits.loc[result.hits["window_id"] == "chr1:500-1000"].iloc[0] + assert first_window["n_pairs_used"] == 2 + assert second_window["n_pairs_used"] == 1 + assert second_window["trajectory_amplitude_mean"] == pytest.approx(0.8) + + +def test_scan_genome_time_course_ignores_extra_conditions_outside_time_order(monkeypatch): + monkeypatch.setattr( + global_analysis, + "build_window_summary", + lambda **_: pd.DataFrame( + [ + { + "sample_id": "tp1_0", + "condition": "0min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 2, + "valid_count": 10, + "window_fraction": 0.2, + }, + { + "sample_id": "tp1_15", + "condition": "15min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 5, + "valid_count": 10, + "window_fraction": 0.5, + }, + { + "sample_id": "tp1_30", + "condition": "30min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 6, + "valid_count": 10, + "window_fraction": 0.6, + }, + { + "sample_id": "tp1_45", + "condition": "45min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 10, + "valid_count": 10, + "window_fraction": 1.0, + }, + { + "sample_id": "tp2_0", + "condition": "0min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 1, + "valid_count": 10, + "window_fraction": 0.1, + }, + { + "sample_id": "tp2_15", + "condition": "15min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 3, + "valid_count": 10, + "window_fraction": 0.3, + }, + { + "sample_id": "tp2_30", + "condition": "30min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 4, + "valid_count": 10, + "window_fraction": 0.4, + }, + { + "sample_id": "tp2_45", + "condition": "45min", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 0, + "valid_count": 10, + "window_fraction": 0.0, + }, + ] + ), + ) + + result = region_discovery.scan_genome( + samples=[ + SampleSpec( + sample_id="tp1_0", + condition="0min", + extract_h5="tp1_0.h5", + metadata={"pileup_path": "tp1_0.bed.gz", "pair_id": "pair-1"}, + ), + SampleSpec( + sample_id="tp1_15", + condition="15min", + extract_h5="tp1_15.h5", + metadata={"pileup_path": "tp1_15.bed.gz", "pair_id": "pair-1"}, + ), + SampleSpec( + sample_id="tp1_30", + condition="30min", + extract_h5="tp1_30.h5", + metadata={"pileup_path": "tp1_30.bed.gz", "pair_id": "pair-1"}, + ), + SampleSpec( + sample_id="tp1_45", + condition="45min", + extract_h5="tp1_45.h5", + metadata={"pileup_path": "tp1_45.bed.gz", "pair_id": "pair-1"}, + ), + SampleSpec( + sample_id="tp2_0", + condition="0min", + extract_h5="tp2_0.h5", + metadata={"pileup_path": "tp2_0.bed.gz", "pair_id": "pair-2"}, + ), + SampleSpec( + sample_id="tp2_15", + condition="15min", + extract_h5="tp2_15.h5", + metadata={"pileup_path": "tp2_15.bed.gz", "pair_id": "pair-2"}, + ), + SampleSpec( + sample_id="tp2_30", + condition="30min", + extract_h5="tp2_30.h5", + metadata={"pileup_path": "tp2_30.bed.gz", "pair_id": "pair-2"}, + ), + SampleSpec( + sample_id="tp2_45", + condition="45min", + extract_h5="tp2_45.h5", + metadata={"pileup_path": "tp2_45.bed.gz", "pair_id": "pair-2"}, + ), + ], + motifs=["A,0"], + genome_sizes={"chr1": 500}, + window_size=500, + step_size=500, + contrast=ContrastSpec( + mode="time_course", + time_order=["0min", "15min", "30min"], + pairing_key="pair_id", + ), + score="effect_size_only", + ) + + assert result.hits.loc[0, "trajectory_amplitude_mean"] == pytest.approx(0.35) + assert result.hits.loc[0, "trajectory_amplitude_sd"] == pytest.approx(0.05) + + def test_scan_genome_time_course_errors_on_missing_pairing_key(monkeypatch): monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_window_summary()) From ed2009358e5197693041eccd7dc595d568f74537 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 12:12:40 -0700 Subject: [PATCH 068/272] feat: add paired time-course region discovery --- dimelo/region_discovery.py | 2 -- tests/test_region_discovery.py | 3 --- 2 files changed, 5 deletions(-) diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py index 86a7985..a6eb4cd 100644 --- a/dimelo/region_discovery.py +++ b/dimelo/region_discovery.py @@ -317,7 +317,6 @@ def _score_paired_time_course( ordered = paired_window_table.loc[paired_window_table["condition"].isin(time_order)].copy() _validate_time_order(ordered, time_order) - ordered["condition"] = pd.Categorical( ordered["condition"], categories=time_order, @@ -355,7 +354,6 @@ def _score_paired_time_course( how="inner", sort=False, ) - per_pair = ( ordered.groupby(_WINDOW_KEY_COLUMNS + ["pair_id"], as_index=False, sort=False) .agg( diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index e407ee9..3024379 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -1229,7 +1229,6 @@ def test_scan_genome_time_course_errors_when_time_order_conditions_are_missing(m score="effect_size_only", ) - def test_scan_genome_time_course_filters_incomplete_trajectories_per_window(monkeypatch): monkeypatch.setattr( global_analysis, @@ -1602,8 +1601,6 @@ def test_scan_genome_time_course_ignores_extra_conditions_outside_time_order(mon assert result.hits.loc[0, "trajectory_amplitude_mean"] == pytest.approx(0.35) assert result.hits.loc[0, "trajectory_amplitude_sd"] == pytest.approx(0.05) - - def test_scan_genome_time_course_errors_on_missing_pairing_key(monkeypatch): monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_window_summary()) From 35a0954051fd8ccb75cf2658ef59cc4caf9ee5ea Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 12:26:52 -0700 Subject: [PATCH 069/272] docs: add paired region discovery guide --- README.md | 2 +- dimelo/region_discovery.py | 2 + docs/region-discovery.md | 35 ++++++++++++- tests/test_region_discovery.py | 94 +++++++++++++++++++++++++++++++++- 4 files changed, 130 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 51ada2c..73fd3df 100644 --- a/README.md +++ b/README.md @@ -225,7 +225,7 @@ def extract( Three higher-level analysis guides now sit on top of the existing parsing layer: - [docs/global-analysis.md](docs/global-analysis.md) for pileup-backed global summaries and normalization factors -- [docs/region-discovery.md](docs/region-discovery.md) for de novo locus discovery from tiled pileup scans +- [docs/region-discovery.md](docs/region-discovery.md) for de novo and paired locus discovery from tiled pileup scans - [docs/shared-clustering.md](docs/shared-clustering.md) for shared-boundary clustering workflows - [docs/region-contrasts.md](docs/region-contrasts.md) for known-region motif-abundance contrasts diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py index a6eb4cd..6b2bd8d 100644 --- a/dimelo/region_discovery.py +++ b/dimelo/region_discovery.py @@ -919,6 +919,7 @@ def scan_genome( "contrast_mode": contrast.mode, "contrast_numerator": list(contrast.numerator or []), "contrast_denominator": list(contrast.denominator or []), + "pairing_key": contrast.pairing_key, "pairing_policy": active_pairing_policy, "n_pairs_used": pairing_metadata["n_pairs_used"], "n_pairs_dropped": pairing_metadata["n_pairs_dropped"], @@ -1001,6 +1002,7 @@ def scan_genome( "contrast_mode": contrast.mode, "contrast_numerator": list(contrast.numerator or []), "contrast_denominator": list(contrast.denominator or []), + "pairing_key": contrast.pairing_key, "pairing_policy": active_pairing_policy, "n_pairs_used": pairing_metadata["n_pairs_used"], "n_pairs_dropped": pairing_metadata["n_pairs_dropped"], diff --git a/docs/region-discovery.md b/docs/region-discovery.md index 0af18e3..bbfa8a5 100644 --- a/docs/region-discovery.md +++ b/docs/region-discovery.md @@ -1,6 +1,6 @@ # Region Discovery -`dimelo.region_discovery` is the de novo locus discovery layer. Use it when you do not yet know which genomic intervals matter and you want a deterministic tiled scan over pileup-backed inputs. +`dimelo.region_discovery` is the de novo locus discovery layer. Use it when you do not yet know which genomic intervals matter and you want a deterministic tiled scan over pileup-backed inputs. It also supports paired discovery when you have matched samples or ordered time courses and want to keep the output in the same data-first shape as pooled discovery. ## When To Use Discovery vs Contrasts @@ -8,6 +8,16 @@ - Use `region_contrasts` when you already know the regions and want to test them formally. - If you already have a BED file or a matched region set, skip discovery and go straight to `region_contrasts`. +## Paired Discovery + +Paired discovery is still discovery-first. The scan resolves complete matched units from `SampleSpec.metadata[pairing_key]`, filters out incomplete pairs, and returns the same `RegionDiscoveryResult` container as pooled discovery. + +- Use `ContrastSpec(mode="matched_pairwise", numerator=[...], denominator=[...], pairing_key="...")` when you have matched two-condition samples. +- Use `ContrastSpec(mode="time_course", time_order=[...], pairing_key="...")` when you want an ordered trajectory across paired time points. +- Inspect `result.windows` for the full tiled table and `result.hits` for ranked discovery hits. +- Use `result.metadata["pairing_key"]`, `result.metadata["pairing_policy"]`, `result.metadata["n_pairs_used"]`, and `result.metadata["n_pairs_dropped"]` to audit the pairing resolution that was applied. +- `result.plot_data` stays optional; the canonical handoff artifact is still the table data. + ## Minimal Example ```python @@ -54,6 +64,7 @@ The canonical outputs are data-first: ## Handoff Guidance - For formal region testing, convert discovered hits into BED and write them to disk before passing the BED path into `region_contrasts.score_regions(...)`. +- This handoff works the same for paired discovery outputs; the paired score columns stay in `result.hits`, while `hits_to_bed()` projects the ranked loci into a plain BED table for downstream region testing. - For downstream clustering, use the discovered loci to focus the region set before running the clustering workflow. - Keep discovery and contrast roles separate: discovery finds candidates, contrasts tests known regions, and clustering explains state mixtures. @@ -61,3 +72,25 @@ The canonical outputs are data-first: bed_df = region_discovery.hits_to_bed(result.hits) bed_df.to_csv("discovered_hits.bed", sep="\t", header=False, index=False) ``` + +Paired discovery example: + +```python +paired_result = region_discovery.scan_genome( + samples=paired_samples, + motifs=["A,0"], + genome_sizes=genome_sizes, + window_size=2000, + step_size=500, + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["targeting"], + denominator=["nontargeting"], + pairing_key="pair_id", + ), + score="effect_size_only", +) + +paired_bed = region_discovery.hits_to_bed(paired_result.hits) +paired_bed.to_csv("paired_discovered_hits.bed", sep="\t", header=False, index=False) +``` diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index 3024379..2fd2df6 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -1670,7 +1670,14 @@ def test_discovery_bed_handoff_into_region_contrasts(tmp_path, monkeypatch): "s2.bed.gz": [(9, 10), (2, 10), (1, 10)], } - def fake_regions_to_list(function_handle, regions, window_size=None, quiet=True, cores=None, split_large_regions=False): + def fake_regions_to_list( + function_handle, + regions, + window_size=None, + quiet=True, + cores=None, + split_large_regions=False, + ): pileup_path = function_handle.keywords["bedmethyl_file"] regions_dict = region_contrasts.utils.regions_dict_from_input(regions, window_size) n_regions = sum(len(region_list) for region_list in regions_dict.values()) @@ -1721,6 +1728,91 @@ def fake_regions_to_list(function_handle, regions, window_size=None, quiet=True, assert list(result.summary["rank"]) == [1, 2, 3, 4] +def test_paired_discovery_bed_handoff_into_region_contrasts(tmp_path, monkeypatch): + monkeypatch.setattr( + global_analysis, + "build_window_summary", + lambda **_: _mock_paired_pairwise_window_summary(), + ) + + discovery = region_discovery.scan_genome( + samples=_paired_samplespecs(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=500, + step_size=500, + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["targeting"], + denominator=["nontargeting"], + pairing_key="pair_id", + ), + score="effect_size_only", + ) + assert discovery.metadata["pairing_key"] == "pair_id" + + bed_df = region_discovery.hits_to_bed(discovery.hits) + bed_path = tmp_path / "paired_discovered_hits.bed" + bed_df.to_csv(bed_path, sep="\t", header=False, index=False) + + counts_by_pileup = { + "t1.bed.gz": [(8, 10), (7, 10)], + "t2.bed.gz": [(3, 10), (4, 10)], + "d1.bed.gz": [(2, 10), (3, 10)], + "d2.bed.gz": [(1, 10), (2, 10)], + } + + def fake_regions_to_list(function_handle, regions, window_size=None, quiet=True, cores=None, split_large_regions=False): + pileup_path = function_handle.keywords["bedmethyl_file"] + regions_dict = region_contrasts.utils.regions_dict_from_input(regions, window_size) + n_regions = sum(len(region_list) for region_list in regions_dict.values()) + base_counts = counts_by_pileup[pileup_path] + return (base_counts * ((n_regions // len(base_counts)) + 1))[:n_regions] + + monkeypatch.setattr(region_contrasts.load_processed, "regions_to_list", fake_regions_to_list) + + result = region_contrasts.score_regions( + samples=[ + SampleSpec( + sample_id="t1", + condition="targeting", + extract_h5="t1.h5", + metadata={"pileup_path": "t1.bed.gz"}, + ), + SampleSpec( + sample_id="t2", + condition="targeting", + extract_h5="t2.h5", + metadata={"pileup_path": "t2.bed.gz"}, + ), + SampleSpec( + sample_id="d1", + condition="nontargeting", + extract_h5="d1.h5", + metadata={"pileup_path": "d1.bed.gz"}, + ), + SampleSpec( + sample_id="d2", + condition="nontargeting", + extract_h5="d2.h5", + metadata={"pileup_path": "d2.bed.gz"}, + ), + ], + regions=bed_path, + motifs=["A,0"], + contrast=ContrastSpec( + mode="pairwise", + numerator=["targeting"], + denominator=["nontargeting"], + reference_condition="nontargeting", + ), + test="effect_size_only", + ) + + assert len(result.regions) == 2 + assert list(result.summary["rank"]) == [1, 2] + + def test_scan_genome_filters_low_coverage_windows(monkeypatch): def fake_build_window_summary(**kwargs): return pd.DataFrame( From 4039553e16896a504975b2ed7dbc871fe0842265 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 12:29:24 -0700 Subject: [PATCH 070/272] test: cover paired time-course metadata --- tests/test_region_discovery.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index 2fd2df6..dd3009f 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -1206,6 +1206,7 @@ def test_scan_genome_time_course_ranks_by_trajectory_amplitude_mean(monkeypatch) assert result.hits.loc[0, "trajectory_amplitude_mean"] == pytest.approx(0.55) assert result.hits.loc[0, "trajectory_amplitude_sd"] == pytest.approx(0.05) + assert result.metadata["pairing_key"] == "pair_id" assert result.metadata["paired_mode"] == "time_course" assert result.metadata["time_order"] == ["0min", "15min", "30min"] assert result.metadata["rank_by"] == "trajectory_amplitude_mean" From 48afa9f6579ef081a96a05e849a2022d3613acaa Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 12:38:36 -0700 Subject: [PATCH 071/272] fix: tighten paired discovery policy validation --- dimelo/region_discovery.py | 8 ++- tests/test_region_discovery.py | 115 +++++++-------------------------- 2 files changed, 32 insertions(+), 91 deletions(-) diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py index 6b2bd8d..7b17152 100644 --- a/dimelo/region_discovery.py +++ b/dimelo/region_discovery.py @@ -134,7 +134,13 @@ def _validate_contrast_conditions( def _pairing_policy_value(pairing_policy: str | None) -> str: - return pairing_policy or "complete_pairs_only" + active_pairing_policy = pairing_policy or "complete_pairs_only" + if active_pairing_policy not in {"complete_pairs_only", "error_on_missing"}: + raise ValueError( + "scan_genome paired discovery requires pairing_policy in " + "{'complete_pairs_only', 'error_on_missing'}." + ) + return active_pairing_policy def _is_paired_contrast(contrast: ContrastSpec | None) -> bool: diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index dd3009f..5a1d118 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -607,96 +607,6 @@ def test_scan_genome_matched_pairwise_applies_min_coverage_filtering(monkeypatch assert pd.isna(result.windows.loc[0, "rank"]) assert pd.isna(result.windows.loc[0, "score_value"]) -def test_scan_genome_matched_pairwise_reranks_surviving_hits_after_coverage_filter(monkeypatch): - monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: pd.DataFrame( - [ - { - "sample_id": "t1", - "condition": "targeting", - "replicate": 1, - "motif": "A,0", - "window_id": "chr1:0-500", - "chromosome": "chr1", - "start": 0, - "end": 500, - "strand": ".", - "modified_count": 9, - "valid_count": 10, - "window_fraction": 0.9, - }, - { - "sample_id": "d1", - "condition": "nontargeting", - "replicate": 1, - "motif": "A,0", - "window_id": "chr1:0-500", - "chromosome": "chr1", - "start": 0, - "end": 500, - "strand": ".", - "modified_count": 1, - "valid_count": 10, - "window_fraction": 0.1, - }, - { - "sample_id": "t2", - "condition": "targeting", - "replicate": 1, - "motif": "A,0", - "window_id": "chr1:500-1000", - "chromosome": "chr1", - "start": 500, - "end": 1000, - "strand": ".", - "modified_count": 12, - "valid_count": 60, - "window_fraction": 0.2, - }, - { - "sample_id": "d2", - "condition": "nontargeting", - "replicate": 1, - "motif": "A,0", - "window_id": "chr1:500-1000", - "chromosome": "chr1", - "start": 500, - "end": 1000, - "strand": ".", - "modified_count": 6, - "valid_count": 60, - "window_fraction": 0.1, - }, - { - "sample_id": "t1", - "condition": "targeting", - "replicate": 1, - "motif": "A,0", - "window_id": "chr1:1000-1500", - "chromosome": "chr1", - "start": 1000, - "end": 1500, - "strand": ".", - "modified_count": 10, - "valid_count": 60, - "window_fraction": 1 / 6, - }, - { - "sample_id": "d1", - "condition": "nontargeting", - "replicate": 1, - "motif": "A,0", - "window_id": "chr1:1000-1500", - "chromosome": "chr1", - "start": 1000, - "end": 1500, - "strand": ".", - "modified_count": 6, - "valid_count": 60, - "window_fraction": 0.1, - }, - ] - )) - def test_scan_genome_matched_pairwise_reranks_surviving_hits_after_coverage_filter(monkeypatch): monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: pd.DataFrame( [ @@ -832,6 +742,31 @@ def test_scan_genome_matched_pairwise_reranks_surviving_hits_after_coverage_filt covered_windows = result.windows.loc[result.windows["valid_count"] >= 50] assert list(covered_windows["window_id"]) == list(result.hits["window_id"]) assert list(covered_windows["rank"]) == list(result.hits["rank"]) + + +def test_scan_genome_rejects_invalid_pairing_policy(monkeypatch): + monkeypatch.setattr( + global_analysis, + "build_window_summary", + lambda **_: _mock_paired_pairwise_window_summary(), + ) + + with pytest.raises(ValueError, match="pairing_policy"): + region_discovery.scan_genome( + samples=_paired_samplespecs(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=500, + step_size=500, + pairing_policy="complete_pairs_typo", + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["targeting"], + denominator=["nontargeting"], + pairing_key="pair_id", + ), + score="effect_size_only", + ) def test_scan_genome_matched_pairwise_rejects_merge_hits(monkeypatch): monkeypatch.setattr( global_analysis, From b6039cab4a3b1b8b5c56b08d5f4fadaf45842769 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 12:40:57 -0700 Subject: [PATCH 072/272] feat: add region discovery cluster result --- dimelo/__init__.py | 2 + dimelo/models.py | 24 +++++++++++ tests/test_models.py | 96 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 122 insertions(+) diff --git a/dimelo/__init__.py b/dimelo/__init__.py index fdf42ec..bce4756 100644 --- a/dimelo/__init__.py +++ b/dimelo/__init__.py @@ -18,6 +18,7 @@ region_contrasts, workflows, ) +from .models import RegionDiscoveryClusterResult __all__ = [ "cluster", @@ -37,5 +38,6 @@ "region_discovery", "region_analysis", "region_contrasts", + "RegionDiscoveryClusterResult", "workflows", ] diff --git a/dimelo/models.py b/dimelo/models.py index 0a2773e..2de5fee 100644 --- a/dimelo/models.py +++ b/dimelo/models.py @@ -197,6 +197,30 @@ def __post_init__(self) -> None: ) +@dataclass +class RegionDiscoveryClusterResult: + discovery: RegionDiscoveryResult + clustering: SharedClusterResult + selected_regions: pd.DataFrame + metadata: dict[str, Any] = field(default_factory=dict) + figures: dict[str, Any] = field(default_factory=dict) + + def __post_init__(self) -> None: + required_fields = { + "discovery": self.discovery, + "clustering": self.clustering, + "selected_regions": self.selected_regions, + "metadata": self.metadata, + "figures": self.figures, + } + missing = [name for name, value in required_fields.items() if value is None] + if missing: + raise ValueError( + "RegionDiscoveryClusterResult requires non-None values for: " + f"{', '.join(missing)}" + ) + + @dataclass class CohortSpec: cohort_id: str diff --git a/tests/test_models.py b/tests/test_models.py index abd9b6d..bc2bff0 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -12,6 +12,7 @@ DatasetArtifact, SampleSpec, RegionDiscoveryResult, + RegionDiscoveryClusterResult, RegionContrastResult, SharedClusterModel, SharedClusterResult, @@ -392,6 +393,101 @@ def test_region_discovery_result_rejects_missing_required_fields(field_name): RegionDiscoveryResult(**kwargs) +def test_region_discovery_cluster_result_supports_wrapped_outputs(): + discovery = RegionDiscoveryResult( + hits=pd.DataFrame({"region": ["chr1:0-1000"]}), + windows=pd.DataFrame({"window_id": ["chr1:0-1000"]}), + contrast=None, + plot_data={"ranked_hits": pd.DataFrame({"region": ["chr1:0-1000"]})}, + metadata={"analysis_unit": "genome"}, + figures={"hit_track": object()}, + ) + clustering = SharedClusterResult( + model=SharedClusterModel( + mode="shared", + motifs=["A,0"], + feature_names=["A,0_mod_fraction"], + preprocessing={"scale": "standard"}, + estimator=object(), + cluster_labels=["cluster-1"], + fit_metadata={"random_state": 7}, + ), + assignments=pd.DataFrame({"cluster": ["cluster-1"]}), + cluster_distribution=pd.DataFrame({"cluster": ["cluster-1"]}), + condition_distribution=pd.DataFrame({"condition": ["treated"]}), + distribution_change=None, + cluster_profiles=pd.DataFrame({"profile": [1.0]}), + region_summaries=None, + plot_data={"cluster_distribution_bar": {"kind": "bar"}}, + figures={}, + metadata={"notes": "ok"}, + ) + selected_regions = pd.DataFrame( + [{"chromosome": "chr1", "start": 0, "end": 1000}] + ) + + result = RegionDiscoveryClusterResult( + discovery=discovery, + clustering=clustering, + selected_regions=selected_regions, + metadata={"selection_mode": "top_n"}, + figures={"workflow": object()}, + ) + + assert result.discovery is discovery + assert result.clustering is clustering + assert result.selected_regions.equals(selected_regions) + assert result.metadata == {"selection_mode": "top_n"} + + +@pytest.mark.parametrize( + "field_name", + ["discovery", "clustering", "selected_regions", "metadata", "figures"], +) +def test_region_discovery_cluster_result_rejects_missing_required_fields( + field_name, +): + kwargs = { + "discovery": RegionDiscoveryResult( + hits=pd.DataFrame({"region": ["chr1:0-1000"]}), + windows=pd.DataFrame({"window_id": ["chr1:0-1000"]}), + contrast=None, + plot_data={"ranked_hits": pd.DataFrame({"region": ["chr1:0-1000"]})}, + metadata={"analysis_unit": "genome"}, + figures={"hit_track": object()}, + ), + "clustering": SharedClusterResult( + model=SharedClusterModel( + mode="shared", + motifs=["A,0"], + feature_names=["A,0_mod_fraction"], + preprocessing={"scale": "standard"}, + estimator=object(), + cluster_labels=["cluster-1"], + fit_metadata={"random_state": 7}, + ), + assignments=pd.DataFrame({"cluster": ["cluster-1"]}), + cluster_distribution=pd.DataFrame({"cluster": ["cluster-1"]}), + condition_distribution=pd.DataFrame({"condition": ["treated"]}), + distribution_change=None, + cluster_profiles=pd.DataFrame({"profile": [1.0]}), + region_summaries=None, + plot_data={"cluster_distribution_bar": {"kind": "bar"}}, + figures={}, + metadata={"notes": "ok"}, + ), + "selected_regions": pd.DataFrame( + [{"chromosome": "chr1", "start": 0, "end": 1000}] + ), + "metadata": {"selection_mode": "top_n"}, + "figures": {}, + } + kwargs[field_name] = None + + with pytest.raises(ValueError, match=field_name): + RegionDiscoveryClusterResult(**kwargs) + + def test_cohort_spec_stores_workflow_and_params(): cohort = CohortSpec( cohort_id="cohort-1", From 8abbb133236de4b57118eec75c2258e2f56e1cb1 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 12:45:25 -0700 Subject: [PATCH 073/272] fix: tighten discovery cluster result model --- dimelo/__init__.py | 2 -- dimelo/models.py | 10 ++++++++ tests/test_models.py | 58 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 68 insertions(+), 2 deletions(-) diff --git a/dimelo/__init__.py b/dimelo/__init__.py index bce4756..fdf42ec 100644 --- a/dimelo/__init__.py +++ b/dimelo/__init__.py @@ -18,7 +18,6 @@ region_contrasts, workflows, ) -from .models import RegionDiscoveryClusterResult __all__ = [ "cluster", @@ -38,6 +37,5 @@ "region_discovery", "region_analysis", "region_contrasts", - "RegionDiscoveryClusterResult", "workflows", ] diff --git a/dimelo/models.py b/dimelo/models.py index 2de5fee..b8c581d 100644 --- a/dimelo/models.py +++ b/dimelo/models.py @@ -219,6 +219,16 @@ def __post_init__(self) -> None: "RegionDiscoveryClusterResult requires non-None values for: " f"{', '.join(missing)}" ) + if not isinstance(self.discovery, RegionDiscoveryResult): + raise TypeError( + "RegionDiscoveryClusterResult.discovery must be a " + "RegionDiscoveryResult" + ) + if not isinstance(self.clustering, SharedClusterResult): + raise TypeError( + "RegionDiscoveryClusterResult.clustering must be a " + "SharedClusterResult" + ) @dataclass diff --git a/tests/test_models.py b/tests/test_models.py index bc2bff0..78c7e86 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -1,5 +1,6 @@ from pathlib import Path +import dimelo import pandas as pd import pytest @@ -23,6 +24,10 @@ def test_dimelo_package_exports_models(): assert models.SampleSpec is SampleSpec +def test_dimelo_package_root_does_not_export_region_discovery_cluster_result(): + assert not hasattr(dimelo, "RegionDiscoveryClusterResult") + + def test_sample_spec_fields(): sample = SampleSpec( sample_id="sample-1", @@ -488,6 +493,59 @@ def test_region_discovery_cluster_result_rejects_missing_required_fields( RegionDiscoveryClusterResult(**kwargs) +@pytest.mark.parametrize( + ("field_name", "value", "expected_type"), + [ + ("discovery", object(), "RegionDiscoveryResult"), + ("clustering", object(), "SharedClusterResult"), + ], +) +def test_region_discovery_cluster_result_rejects_invalid_wrapper_types( + field_name, + value, + expected_type, +): + kwargs = { + "discovery": RegionDiscoveryResult( + hits=pd.DataFrame({"region": ["chr1:0-1000"]}), + windows=pd.DataFrame({"window_id": ["chr1:0-1000"]}), + contrast=None, + plot_data={"ranked_hits": pd.DataFrame({"region": ["chr1:0-1000"]})}, + metadata={"analysis_unit": "genome"}, + figures={"hit_track": object()}, + ), + "clustering": SharedClusterResult( + model=SharedClusterModel( + mode="shared", + motifs=["A,0"], + feature_names=["A,0_mod_fraction"], + preprocessing={"scale": "standard"}, + estimator=object(), + cluster_labels=["cluster-1"], + fit_metadata={"random_state": 7}, + ), + assignments=pd.DataFrame({"cluster": ["cluster-1"]}), + cluster_distribution=pd.DataFrame({"cluster": ["cluster-1"]}), + condition_distribution=pd.DataFrame({"condition": ["treated"]}), + distribution_change=None, + cluster_profiles=pd.DataFrame({"profile": [1.0]}), + region_summaries=None, + plot_data={"cluster_distribution_bar": {"kind": "bar"}}, + figures={}, + metadata={"notes": "ok"}, + ), + "selected_regions": pd.DataFrame( + [{"chromosome": "chr1", "start": 0, "end": 1000}] + ), + "metadata": {"selection_mode": "top_n"}, + "figures": {}, + } + kwargs[field_name] = value + + with pytest.raises(TypeError, match=expected_type): + RegionDiscoveryClusterResult(**kwargs) + + def test_cohort_spec_stores_workflow_and_params(): cohort = CohortSpec( cohort_id="cohort-1", From b060a616875e98c54b3fc97f43d8cc4acb836601 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 12:47:04 -0700 Subject: [PATCH 074/272] fix: restore discovery cluster result export --- dimelo/__init__.py | 2 ++ tests/test_models.py | 7 ++++--- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/dimelo/__init__.py b/dimelo/__init__.py index fdf42ec..bce4756 100644 --- a/dimelo/__init__.py +++ b/dimelo/__init__.py @@ -18,6 +18,7 @@ region_contrasts, workflows, ) +from .models import RegionDiscoveryClusterResult __all__ = [ "cluster", @@ -37,5 +38,6 @@ "region_discovery", "region_analysis", "region_contrasts", + "RegionDiscoveryClusterResult", "workflows", ] diff --git a/tests/test_models.py b/tests/test_models.py index 78c7e86..99a7856 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -1,6 +1,5 @@ from pathlib import Path -import dimelo import pandas as pd import pytest @@ -24,8 +23,10 @@ def test_dimelo_package_exports_models(): assert models.SampleSpec is SampleSpec -def test_dimelo_package_root_does_not_export_region_discovery_cluster_result(): - assert not hasattr(dimelo, "RegionDiscoveryClusterResult") +def test_dimelo_package_root_exports_region_discovery_cluster_result(): + from dimelo import RegionDiscoveryClusterResult as RootRegionDiscoveryClusterResult + + assert RootRegionDiscoveryClusterResult is RegionDiscoveryClusterResult def test_sample_spec_fields(): From 6cc6e5e49fa31ee8d69ae7aa9900ccf6ef609525 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 12:52:11 -0700 Subject: [PATCH 075/272] feat: add discovery cluster workflow --- dimelo/workflows.py | 84 +++++++++++++++- tests/test_workflows.py | 208 +++++++++++++++++++++++++++++++++++++++- 2 files changed, 289 insertions(+), 3 deletions(-) diff --git a/dimelo/workflows.py b/dimelo/workflows.py index 4391e7f..e1dc14a 100644 --- a/dimelo/workflows.py +++ b/dimelo/workflows.py @@ -7,14 +7,21 @@ import pandas as pd from .artifacts import resolve_artifact -from . import cluster, distribution, plotting, region_analysis -from .models import DatasetArtifact, SampleSpec, SharedClusterModel, SharedClusterResult +from . import cluster, distribution, plotting, region_analysis, region_discovery +from .models import ( + DatasetArtifact, + RegionDiscoveryClusterResult, + SampleSpec, + SharedClusterModel, + SharedClusterResult, +) _SUPPORTED_SIGNAL_NORMALIZATION = {"none", "per_sample_global", "control_regions"} _SUPPORTED_FEATURE_SCALING = {"none", "robust_zscore"} _SUPPORTED_CLUSTER_BASIS = {"shape_only", "shape_plus_level", "level_only"} _PACKAGE_VERSION = "1.0.0" _PREDICTION_CHUNK_SIZE = 100_000 +_DISCOVERY_SELECTION_DEFAULT_TOP_N = 250 _LEVEL_FEATURES = { "global_mean", "global_var", @@ -281,6 +288,79 @@ def _build_region_summary(assignments: pd.DataFrame) -> pd.DataFrame: return summary +def _select_discovery_hits( + hits: pd.DataFrame, + *, + selection_mode: str, + top_n: int | None, +) -> pd.DataFrame: + if selection_mode == "all": + return hits.copy() + if selection_mode != "top_n": + raise ValueError( + f"Unsupported selection mode: {selection_mode!r}. Supported modes are 'top_n' and 'all'." + ) + + resolved_top_n = _DISCOVERY_SELECTION_DEFAULT_TOP_N if top_n is None else int(top_n) + if resolved_top_n < 0: + raise ValueError("selection.top_n must be non-negative.") + return hits.head(resolved_top_n).copy() + + +def discovery_cluster_workflow( + *, + samples: Iterable[SampleSpec], + motifs: Iterable[str], + genome_sizes: dict[str, int], + discovery: dict[str, Any], + clustering: dict[str, Any], + selection: dict[str, Any] | None = None, +) -> RegionDiscoveryClusterResult: + selection_config = dict(selection or {}) + selection_mode = str(selection_config.get("mode", "top_n")) + selection_top_n = selection_config.get("top_n") + + discovery_result = region_discovery.scan_genome( + samples=samples, + motifs=motifs, + genome_sizes=genome_sizes, + **discovery, + ) + selected_hits = _select_discovery_hits( + discovery_result.hits, + selection_mode=selection_mode, + top_n=selection_top_n, + ) + if selected_hits.empty: + raise ValueError("No discovery hits remained after selection.") + + selected_regions = region_discovery.hits_to_bed(selected_hits) + clustering_result = shared_cluster_distribution( + samples=samples, + motifs=motifs, + matched_regions=selected_regions, + **clustering, + ) + resolved_top_n = ( + None + if selection_mode == "all" + else _DISCOVERY_SELECTION_DEFAULT_TOP_N if selection_top_n is None else int(selection_top_n) + ) + return RegionDiscoveryClusterResult( + discovery=discovery_result, + clustering=clustering_result, + selected_regions=selected_regions, + metadata={ + "selection": { + "mode": selection_mode, + "top_n": resolved_top_n, + "discovered_hit_count": int(len(discovery_result.hits)), + "selected_hit_count": int(len(selected_hits)), + } + }, + ) + + def _build_shared_cluster_result( *, mode: str, diff --git a/tests/test_workflows.py b/tests/test_workflows.py index bfcf0b9..f0519b1 100644 --- a/tests/test_workflows.py +++ b/tests/test_workflows.py @@ -4,7 +4,213 @@ from dimelo import workflows from dimelo.models import DatasetArtifact -from dimelo.models import SampleSpec +from dimelo.models import RegionDiscoveryResult, SampleSpec, SharedClusterModel, SharedClusterResult + + +def _workflow_samples(): + return [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + regions_bed="control-s1.bed", + metadata={"pileup_path": "s1.bed.gz"}, + ), + SampleSpec( + sample_id="s2", + condition="15min", + extract_h5="s2.h5", + regions_bed="control-s2.bed", + metadata={"pileup_path": "s2.bed.gz"}, + ), + ] + + +def _mock_discovery_result(*args, **kwargs): + hits = pd.DataFrame( + [ + { + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": "+", + "score_value": 0.9, + "adjusted_p_value": 0.01, + }, + { + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": "-", + "score_value": 0.6, + "adjusted_p_value": 0.02, + }, + { + "window_id": "chr1:1000-1500", + "chromosome": "chr1", + "start": 1000, + "end": 1500, + "strand": "+", + "score_value": 0.2, + "adjusted_p_value": 0.20, + }, + ] + ) + return RegionDiscoveryResult( + hits=hits, + windows=hits.copy(), + contrast=None, + plot_data={}, + metadata={"score": "effect_size_only"}, + ) + + +def _mock_cluster_result(*args, **kwargs): + assignments = pd.DataFrame( + [ + {"sample_id": "s1", "condition": "NS", "cluster": "C0"}, + {"sample_id": "s2", "condition": "15min", "cluster": "C1"}, + ] + ) + return SharedClusterResult( + model=SharedClusterModel( + mode=kwargs["mode"], + motifs=list(kwargs["motifs"]), + feature_names=["f0"], + preprocessing={}, + estimator=object(), + cluster_labels=["C0", "C1"], + fit_metadata={}, + ), + assignments=assignments, + cluster_distribution=pd.DataFrame( + [ + {"sample_id": "s1", "condition": "NS", "cluster": "C0", "count": 1, "fraction": 1.0}, + {"sample_id": "s2", "condition": "15min", "cluster": "C1", "count": 1, "fraction": 1.0}, + ] + ), + condition_distribution=pd.DataFrame( + [ + {"condition": "NS", "cluster": "C0", "fraction": 1.0, "replicate_n": 1}, + {"condition": "15min", "cluster": "C1", "fraction": 1.0, "replicate_n": 1}, + ] + ), + distribution_change=None, + cluster_profiles=pd.DataFrame([{"cluster": "C0", "count": 1, "f0": 0.0}]), + region_summaries=None, + plot_data={}, + metadata={"matched_regions": kwargs.get("matched_regions")}, + ) + + +def test_discovery_cluster_workflow_returns_both_results(monkeypatch): + monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) + + result = workflows.discovery_cluster_workflow( + samples=_workflow_samples(), + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "n_clusters": 2}, + ) + + assert result.discovery.hits.shape[0] == 3 + assert result.clustering.model.mode == "region_anchored" + assert list(result.selected_regions.columns) == ["chrom", "start", "end", "name", "score", "strand"] + assert result.metadata["selection"]["mode"] == "top_n" + assert result.metadata["selection"]["top_n"] == 250 + + +def test_discovery_cluster_workflow_selects_top_n_hits(monkeypatch): + monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) + + result = workflows.discovery_cluster_workflow( + samples=_workflow_samples(), + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "n_clusters": 2}, + selection={"mode": "top_n", "top_n": 1}, + ) + + assert result.selected_regions["name"].tolist() == ["chr1:0-500"] + + +def test_discovery_cluster_workflow_selects_all_hits(monkeypatch): + monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) + + result = workflows.discovery_cluster_workflow( + samples=_workflow_samples(), + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "n_clusters": 2}, + selection={"mode": "all"}, + ) + + assert set(result.selected_regions["name"].tolist()) == { + "chr1:0-500", + "chr1:500-1000", + "chr1:1000-1500", + } + assert result.metadata["selection"]["top_n"] is None + + +def test_discovery_cluster_workflow_passes_selected_regions_into_clustering(monkeypatch): + captured = {} + + def fake_cluster(**kwargs): + captured["matched_regions"] = kwargs["matched_regions"] + return _mock_cluster_result(**kwargs) + + monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr(workflows, "shared_cluster_distribution", fake_cluster) + + result = workflows.discovery_cluster_workflow( + samples=_workflow_samples(), + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "n_clusters": 2}, + selection={"mode": "top_n", "top_n": 2}, + ) + + assert captured["matched_regions"].equals(result.selected_regions) + + +def test_discovery_cluster_workflow_errors_when_no_hits_survive_selection(monkeypatch): + monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) + + with pytest.raises(ValueError, match="No discovery hits remained after selection"): + workflows.discovery_cluster_workflow( + samples=_workflow_samples(), + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "n_clusters": 2}, + selection={"mode": "top_n", "top_n": 0}, + ) + + +def test_discovery_cluster_workflow_rejects_unknown_selection_mode(monkeypatch): + monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) + + with pytest.raises(ValueError, match="Unsupported selection mode"): + workflows.discovery_cluster_workflow( + samples=_workflow_samples(), + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "n_clusters": 2}, + selection={"mode": "invalid"}, + ) def test_shared_cluster_distribution_read_global(monkeypatch): From 4cfdbc8ec85b5fb0349f5bd75def5ccf3bf7f20d Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 12:58:16 -0700 Subject: [PATCH 076/272] fix: serialize discovery cluster matched regions --- dimelo/workflows.py | 19 ++++++- tests/test_workflows.py | 111 +++++++++++++++++++++++++++++++++++++++- 2 files changed, 128 insertions(+), 2 deletions(-) diff --git a/dimelo/workflows.py b/dimelo/workflows.py index e1dc14a..f9a9cc8 100644 --- a/dimelo/workflows.py +++ b/dimelo/workflows.py @@ -307,6 +307,22 @@ def _select_discovery_hits( return hits.head(resolved_top_n).copy() +def _selected_regions_to_region_spec(selected_regions: pd.DataFrame) -> list[str]: + if selected_regions.empty: + return [] + + chrom_column = "chrom" if "chrom" in selected_regions.columns else "chromosome" + region_spec: list[str] = [] + for row in selected_regions.itertuples(index=False): + chrom = getattr(row, chrom_column) + start = int(getattr(row, "start")) + end = int(getattr(row, "end")) + strand = getattr(row, "strand", ".") + strand_value = strand if strand in {"+", "-", "."} else "." + region_spec.append(f"{chrom}:{start}-{end},{strand_value}") + return region_spec + + def discovery_cluster_workflow( *, samples: Iterable[SampleSpec], @@ -335,10 +351,11 @@ def discovery_cluster_workflow( raise ValueError("No discovery hits remained after selection.") selected_regions = region_discovery.hits_to_bed(selected_hits) + matched_regions = _selected_regions_to_region_spec(selected_regions) clustering_result = shared_cluster_distribution( samples=samples, motifs=motifs, - matched_regions=selected_regions, + matched_regions=matched_regions, **clustering, ) resolved_top_n = ( diff --git a/tests/test_workflows.py b/tests/test_workflows.py index f0519b1..039d058 100644 --- a/tests/test_workflows.py +++ b/tests/test_workflows.py @@ -105,6 +105,19 @@ def _mock_cluster_result(*args, **kwargs): ) +def _fake_region_anchored_extract(*args, **kwargs): + regions = kwargs["regions"] + region_list = list(regions) if isinstance(regions, list) else [regions] + metadata = [] + for region in region_list: + chrom_coords, strand = region.split(",") + chrom, coords = chrom_coords.split(":") + start, end = coords.split("-") + metadata.append((chrom, int(start), int(end), strand)) + matrix = np.array([[0.2, 0.8], [0.8, 0.2]], dtype=np.float32) + return matrix[: len(metadata)], metadata + + def test_discovery_cluster_workflow_returns_both_results(monkeypatch): monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) @@ -180,7 +193,8 @@ def fake_cluster(**kwargs): selection={"mode": "top_n", "top_n": 2}, ) - assert captured["matched_regions"].equals(result.selected_regions) + assert captured["matched_regions"] == ["chr1:0-500,+", "chr1:500-1000,-"] + assert list(result.selected_regions["name"]) == ["chr1:0-500", "chr1:500-1000"] def test_discovery_cluster_workflow_errors_when_no_hits_survive_selection(monkeypatch): @@ -213,6 +227,101 @@ def test_discovery_cluster_workflow_rejects_unknown_selection_mode(monkeypatch): ) +def test_discovery_cluster_workflow_region_anchored_uses_serializable_matched_regions(monkeypatch): + captured = {"resolve_params": []} + + def fake_resolve_artifact(requested_artifact, available_artifacts, artifact_policy): + captured["resolve_params"].append(requested_artifact.params["matched_regions"]) + return None + + def fake_region_features(*args, **kwargs): + regions = kwargs["regions"] + captured["regions"] = regions + return _fake_region_anchored_extract(*args, **kwargs) + + monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr(workflows, "resolve_artifact", fake_resolve_artifact) + monkeypatch.setattr( + workflows.cluster, + "region_feature_matrix_from_pileup", + fake_region_features, + ) + + result = workflows.discovery_cluster_workflow( + samples=_workflow_samples(), + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "n_clusters": 2, "make_plots": False}, + selection={"mode": "top_n", "top_n": 2}, + ) + + assert captured["regions"] == ["chr1:0-500,+", "chr1:500-1000,-"] + assert captured["resolve_params"] == [ + ["chr1:0-500,+", "chr1:500-1000,-"], + ["chr1:0-500,+", "chr1:500-1000,-"], + ] + assert result.clustering.metadata["matched_regions"] == ["chr1:0-500,+", "chr1:500-1000,-"] + + +def test_discovery_cluster_workflow_artifact_params_keep_matched_regions_json_serializable(monkeypatch): + captured = {} + region_spec = ["chr1:0-500,+", "chr1:500-1000,-"] + artifact_samples = [] + for sample in _workflow_samples(): + artifact_samples.append( + SampleSpec( + sample_id=sample.sample_id, + condition=sample.condition, + extract_h5=sample.extract_h5, + regions_bed=sample.regions_bed, + metadata={ + "pileup_path": sample.metadata["pileup_path"], + "artifacts": [ + DatasetArtifact( + sample_id=sample.sample_id, + artifact_type="pileup", + path=sample.metadata["pileup_path"], + format="bed.gz", + params={ + "motifs": ["A,0"], + "matched_regions": region_spec, + "signal_normalization": "none", + "feature_scaling": "robust_zscore", + "cluster_basis": "shape_plus_level", + }, + provenance={"pipeline": "parse_bam", "source_files": [], "source_fingerprints": []}, + ) + ], + }, + ) + ) + + def fake_resolve_artifact(requested_artifact, available_artifacts, artifact_policy): + captured.setdefault("params", []).append(requested_artifact.params["matched_regions"]) + return available_artifacts[0] + + monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr(workflows, "resolve_artifact", fake_resolve_artifact) + monkeypatch.setattr( + workflows.cluster, + "region_feature_matrix_from_pileup", + _fake_region_anchored_extract, + ) + + result = workflows.discovery_cluster_workflow( + samples=artifact_samples, + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "n_clusters": 2, "make_plots": False}, + selection={"mode": "top_n", "top_n": 2}, + ) + + assert captured["params"] == [region_spec, region_spec] + assert result.clustering.metadata["cache_hits"] == {"s1": "s1.bed.gz", "s2": "s2.bed.gz"} + + def test_shared_cluster_distribution_read_global(monkeypatch): fake_samples = [ SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5"), From b5ad10979b53e6a2d8a34a11e75ebd036c33fcf3 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 13:03:13 -0700 Subject: [PATCH 077/272] fix: materialize workflow samples iterable --- dimelo/workflows.py | 5 +++-- tests/test_workflows.py | 30 ++++++++++++++++++++++++++++++ 2 files changed, 33 insertions(+), 2 deletions(-) diff --git a/dimelo/workflows.py b/dimelo/workflows.py index f9a9cc8..b7229f0 100644 --- a/dimelo/workflows.py +++ b/dimelo/workflows.py @@ -332,12 +332,13 @@ def discovery_cluster_workflow( clustering: dict[str, Any], selection: dict[str, Any] | None = None, ) -> RegionDiscoveryClusterResult: + sample_list = list(samples) selection_config = dict(selection or {}) selection_mode = str(selection_config.get("mode", "top_n")) selection_top_n = selection_config.get("top_n") discovery_result = region_discovery.scan_genome( - samples=samples, + samples=sample_list, motifs=motifs, genome_sizes=genome_sizes, **discovery, @@ -353,7 +354,7 @@ def discovery_cluster_workflow( selected_regions = region_discovery.hits_to_bed(selected_hits) matched_regions = _selected_regions_to_region_spec(selected_regions) clustering_result = shared_cluster_distribution( - samples=samples, + samples=sample_list, motifs=motifs, matched_regions=matched_regions, **clustering, diff --git a/tests/test_workflows.py b/tests/test_workflows.py index 039d058..817f119 100644 --- a/tests/test_workflows.py +++ b/tests/test_workflows.py @@ -322,6 +322,36 @@ def fake_resolve_artifact(requested_artifact, available_artifacts, artifact_poli assert result.clustering.metadata["cache_hits"] == {"s1": "s1.bed.gz", "s2": "s2.bed.gz"} +def test_discovery_cluster_workflow_materializes_samples_iterable(monkeypatch): + captured = {} + + def fake_discovery(*args, **kwargs): + captured["discovery_sample_ids"] = [sample.sample_id for sample in kwargs["samples"]] + return _mock_discovery_result(*args, **kwargs) + + def fake_cluster(**kwargs): + captured["sample_ids"] = [sample.sample_id for sample in kwargs["samples"]] + return _mock_cluster_result(**kwargs) + + monkeypatch.setattr(workflows.region_discovery, "scan_genome", fake_discovery) + monkeypatch.setattr(workflows, "shared_cluster_distribution", fake_cluster) + + result = workflows.discovery_cluster_workflow( + samples=(sample for sample in _workflow_samples()), + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "n_clusters": 2}, + selection={"mode": "top_n", "top_n": 2}, + ) + + assert result.discovery.hits.shape[0] == 3 + assert result.clustering.model.mode == "region_anchored" + assert captured["discovery_sample_ids"] == ["s1", "s2"] + assert captured["sample_ids"] == ["s1", "s2"] + assert list(result.selected_regions["name"]) == ["chr1:0-500", "chr1:500-1000"] + + def test_shared_cluster_distribution_read_global(monkeypatch): fake_samples = [ SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5"), From e517ef7d30ac424ebcea9822ce6d77b4c556b24e Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 13:06:26 -0700 Subject: [PATCH 078/272] docs: clarify discovery to cluster workflow --- README.md | 2 ++ docs/region-discovery.md | 25 +++++++++++++++++++++++++ docs/shared-clustering.md | 3 +++ tests/test_workflows.py | 1 + 4 files changed, 31 insertions(+) diff --git a/README.md b/README.md index 73fd3df..b278569 100644 --- a/README.md +++ b/README.md @@ -231,6 +231,8 @@ Three higher-level analysis guides now sit on top of the existing parsing layer: Use `parse_bam.pileup()` when you want defined-region abundance testing, and use `parse_bam.extract()` when you want read-level clustering or single-read follow-up. +For an end-to-end discovery-to-clustering run, use `workflows.discovery_cluster_workflow()`. It keeps discovery output in BED-style `selected_regions`, then derives the serializable region spec that `shared_cluster_distribution(..., matched_regions=...)` consumes. + For human-readable pileups (bedmethyl files, .bed) and extracted reads (.txt tab-separated values), run with `cleanup=False`. `cleanup=True` will clear these outputs because they can take up a lot of space. ### Parsing outputs diff --git a/docs/region-discovery.md b/docs/region-discovery.md index bbfa8a5..c0ee02b 100644 --- a/docs/region-discovery.md +++ b/docs/region-discovery.md @@ -68,6 +68,31 @@ The canonical outputs are data-first: - For downstream clustering, use the discovered loci to focus the region set before running the clustering workflow. - Keep discovery and contrast roles separate: discovery finds candidates, contrasts tests known regions, and clustering explains state mixtures. +The combined discovery-to-clustering workflow uses the same handoff, but keeps it in memory: + +- discovery produces ranked hit rows +- `hits_to_bed()` turns those rows into BED-style `selected_regions` +- `discovery_cluster_workflow()` derives a serializable region-spec from those rows and passes it to `shared_cluster_distribution(..., matched_regions=...)` +- the workflow returns the original discovery result, the BED-style `selected_regions` table, and the clustering result together + +```python +from dimelo import workflows + +result = workflows.discovery_cluster_workflow( + samples=samples, + motifs=["A,0"], + genome_sizes={"chr1": 248956422}, + discovery={ + "window_size": 2000, + "step_size": 500, + "score": "beta_binomial", + "contrast": contrast, + }, + clustering={"mode": "region_anchored", "n_clusters": 6}, + selection={"mode": "top_n", "top_n": 250}, +) +``` + ```python bed_df = region_discovery.hits_to_bed(result.hits) bed_df.to_csv("discovered_hits.bed", sep="\t", header=False, index=False) diff --git a/docs/shared-clustering.md b/docs/shared-clustering.md index fd1ebc1..c5eefff 100644 --- a/docs/shared-clustering.md +++ b/docs/shared-clustering.md @@ -57,6 +57,8 @@ result = workflows.shared_cluster_distribution( ) ``` +`shared_cluster_distribution()` expects `matched_regions` to already be a serializable region spec. In the discovery-driven flow, `discovery_cluster_workflow()` is the caller that derives that spec from BED-style discovery rows and forwards it into this workflow. That keeps discovery output human-readable while still feeding clustering the compact region representation it needs. + ## Canonical Outputs The workflow returns a `SharedClusterResult` with canonical tables: @@ -89,5 +91,6 @@ heatmap = result.plot_data["cluster_distribution_heatmap"].set_index("condition" - `mode="read_global"` supports shared read clustering from extract outputs. - `mode="region_anchored"` supports matched-region clustering from pileup-derived region vectors. +- `discovery_cluster_workflow()` composes discovery and `region_anchored` clustering by passing derived matched regions into this workflow. - The default supported clusterer is `minibatch_kmeans`. - Results are data-first: tables are the stable contract, while plotting is optional. diff --git a/tests/test_workflows.py b/tests/test_workflows.py index 817f119..e72a3a0 100644 --- a/tests/test_workflows.py +++ b/tests/test_workflows.py @@ -194,6 +194,7 @@ def fake_cluster(**kwargs): ) assert captured["matched_regions"] == ["chr1:0-500,+", "chr1:500-1000,-"] + assert list(result.selected_regions.columns) == ["chrom", "start", "end", "name", "score", "strand"] assert list(result.selected_regions["name"]) == ["chr1:0-500", "chr1:500-1000"] From b1847a8e2bc6b142c115d38d30e2e2c97cd7371f Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 13:14:54 -0700 Subject: [PATCH 079/272] Fix workflow matched region review regressions --- dimelo/workflows.py | 13 +++++-- tests/test_workflows.py | 80 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 90 insertions(+), 3 deletions(-) diff --git a/dimelo/workflows.py b/dimelo/workflows.py index b7229f0..061e228 100644 --- a/dimelo/workflows.py +++ b/dimelo/workflows.py @@ -31,6 +31,7 @@ "iqr", "global_mod_fraction", } +RegionSpec = str | Path | list[str | Path] | None def _source_fingerprint(path: Path) -> dict[str, Any]: @@ -333,13 +334,14 @@ def discovery_cluster_workflow( selection: dict[str, Any] | None = None, ) -> RegionDiscoveryClusterResult: sample_list = list(samples) + motif_list = list(motifs) selection_config = dict(selection or {}) selection_mode = str(selection_config.get("mode", "top_n")) selection_top_n = selection_config.get("top_n") discovery_result = region_discovery.scan_genome( samples=sample_list, - motifs=motifs, + motifs=motif_list, genome_sizes=genome_sizes, **discovery, ) @@ -355,7 +357,7 @@ def discovery_cluster_workflow( matched_regions = _selected_regions_to_region_spec(selected_regions) clustering_result = shared_cluster_distribution( samples=sample_list, - motifs=motifs, + motifs=motif_list, matched_regions=matched_regions, **clustering, ) @@ -506,7 +508,7 @@ def shared_cluster_distribution( samples: Iterable[SampleSpec], mode: str, motifs: Iterable[str], - matched_regions: str | None = None, + matched_regions: RegionSpec = None, signal_normalization: str = "none", feature_scaling: str = "robust_zscore", cluster_basis: str = "shape_plus_level", @@ -547,6 +549,11 @@ def shared_cluster_distribution( raise ValueError(f"Unsupported cluster_basis: {cluster_basis}") if mode == "region_anchored": + if matched_regions is None: + raise ValueError( + "mode='region_anchored' requires matched_regions; per-sample regions_bed is not used " + "as an implicit fallback." + ) pileup_paths: dict[str, str | Path] = {} cache_hits: dict[str, str] = {} cache_misses: list[str] = [] diff --git a/tests/test_workflows.py b/tests/test_workflows.py index e72a3a0..8a99c76 100644 --- a/tests/test_workflows.py +++ b/tests/test_workflows.py @@ -353,6 +353,33 @@ def fake_cluster(**kwargs): assert list(result.selected_regions["name"]) == ["chr1:0-500", "chr1:500-1000"] +def test_discovery_cluster_workflow_materializes_motif_generator(monkeypatch): + captured = {} + + def fake_discovery(*args, **kwargs): + captured["discovery_motifs"] = list(kwargs["motifs"]) + return _mock_discovery_result(*args, **kwargs) + + def fake_cluster(**kwargs): + captured["clustering_motifs"] = list(kwargs["motifs"]) + return _mock_cluster_result(**kwargs) + + monkeypatch.setattr(workflows.region_discovery, "scan_genome", fake_discovery) + monkeypatch.setattr(workflows, "shared_cluster_distribution", fake_cluster) + + workflows.discovery_cluster_workflow( + samples=_workflow_samples(), + motifs=(motif for motif in ["A,0", "CG,1"]), + genome_sizes={"chr1": 1500}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "n_clusters": 2}, + selection={"mode": "top_n", "top_n": 2}, + ) + + assert captured["discovery_motifs"] == ["A,0", "CG,1"] + assert captured["clustering_motifs"] == ["A,0", "CG,1"] + + def test_shared_cluster_distribution_read_global(monkeypatch): fake_samples = [ SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5"), @@ -490,6 +517,59 @@ def fake_region_table(*args, **kwargs): ) +def test_shared_cluster_distribution_region_anchored_requires_matched_regions(): + with pytest.raises(ValueError, match="requires matched_regions"): + workflows.shared_cluster_distribution( + samples=_workflow_samples(), + mode="region_anchored", + motifs=["A,0"], + make_plots=False, + ) + + +def test_shared_cluster_distribution_region_anchored_accepts_list_matched_regions(monkeypatch): + captured = {} + + def fake_region_table(*args, **kwargs): + captured["matched_regions"] = kwargs["matched_regions"] + return np.array([[0.2, 0.8], [0.7, 0.3]]), [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "replicate": None, + "chromosome": "chr1", + "start": 0, + "end": 2, + "strand": "+", + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "15min", + "replicate": None, + "chromosome": "chr1", + "start": 0, + "end": 2, + "strand": "+", + }, + ] + + monkeypatch.setattr(workflows.region_analysis, "build_region_feature_table", fake_region_table) + + result = workflows.shared_cluster_distribution( + samples=_workflow_samples(), + mode="region_anchored", + motifs=["A,0"], + matched_regions=["chr1:0-2,+", "chr1:2-4,-"], + n_clusters=2, + make_plots=False, + ) + + assert captured["matched_regions"] == ["chr1:0-2,+", "chr1:2-4,-"] + assert not result.assignments.empty + + def test_shared_cluster_distribution_tracks_condition_replicates(monkeypatch): fake_samples = [ SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5"), From 360315b3853e900f5b14cd3962ef1c47fc874572 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 13:22:58 -0700 Subject: [PATCH 080/272] fix: fail fast discovery cluster validation --- dimelo/workflows.py | 86 +++++++++++++++++++++++++++++----------- docs/region-discovery.md | 2 +- tests/test_workflows.py | 30 +++++++++++++- 3 files changed, 93 insertions(+), 25 deletions(-) diff --git a/dimelo/workflows.py b/dimelo/workflows.py index 061e228..c4499dd 100644 --- a/dimelo/workflows.py +++ b/dimelo/workflows.py @@ -295,8 +295,22 @@ def _select_discovery_hits( selection_mode: str, top_n: int | None, ) -> pd.DataFrame: + resolved_top_n = _resolve_discovery_selection_top_n( + selection_mode=selection_mode, + top_n=top_n, + ) if selection_mode == "all": return hits.copy() + return hits.head(resolved_top_n).copy() + + +def _resolve_discovery_selection_top_n( + *, + selection_mode: str, + top_n: int | None, +) -> int | None: + if selection_mode == "all": + return None if selection_mode != "top_n": raise ValueError( f"Unsupported selection mode: {selection_mode!r}. Supported modes are 'top_n' and 'all'." @@ -305,7 +319,35 @@ def _select_discovery_hits( resolved_top_n = _DISCOVERY_SELECTION_DEFAULT_TOP_N if top_n is None else int(top_n) if resolved_top_n < 0: raise ValueError("selection.top_n must be non-negative.") - return hits.head(resolved_top_n).copy() + return resolved_top_n + + +def _validate_shared_cluster_distribution_config( + *, + mode: str, + clusterer: str, + signal_normalization: str, + feature_scaling: str, + cluster_basis: str, + sample_count: int, +) -> None: + if mode not in {"read_global", "region_anchored"}: + raise NotImplementedError( + "The first workflow slice implements mode='read_global' and " + "mode='region_anchored' only." + ) + if sample_count < 2: + raise ValueError("shared_cluster_distribution requires at least two datasets.") + if clusterer != "minibatch_kmeans": + raise NotImplementedError( + "The first workflow slice supports clusterer='minibatch_kmeans' only." + ) + if signal_normalization not in _SUPPORTED_SIGNAL_NORMALIZATION: + raise ValueError(f"Unsupported signal_normalization: {signal_normalization}") + if feature_scaling not in _SUPPORTED_FEATURE_SCALING: + raise ValueError(f"Unsupported feature_scaling: {feature_scaling}") + if cluster_basis not in _SUPPORTED_CLUSTER_BASIS: + raise ValueError(f"Unsupported cluster_basis: {cluster_basis}") def _selected_regions_to_region_spec(selected_regions: pd.DataFrame) -> list[str]: @@ -338,6 +380,18 @@ def discovery_cluster_workflow( selection_config = dict(selection or {}) selection_mode = str(selection_config.get("mode", "top_n")) selection_top_n = selection_config.get("top_n") + resolved_top_n = _resolve_discovery_selection_top_n( + selection_mode=selection_mode, + top_n=selection_top_n, + ) + _validate_shared_cluster_distribution_config( + mode=str(clustering.get("mode", "read_global")), + clusterer=str(clustering.get("clusterer", "minibatch_kmeans")), + signal_normalization=str(clustering.get("signal_normalization", "none")), + feature_scaling=str(clustering.get("feature_scaling", "robust_zscore")), + cluster_basis=str(clustering.get("cluster_basis", "shape_plus_level")), + sample_count=len(sample_list), + ) discovery_result = region_discovery.scan_genome( samples=sample_list, @@ -361,11 +415,6 @@ def discovery_cluster_workflow( matched_regions=matched_regions, **clustering, ) - resolved_top_n = ( - None - if selection_mode == "all" - else _DISCOVERY_SELECTION_DEFAULT_TOP_N if selection_top_n is None else int(selection_top_n) - ) return RegionDiscoveryClusterResult( discovery=discovery_result, clustering=clustering_result, @@ -530,23 +579,14 @@ def shared_cluster_distribution( raise ValueError("samples must contain at least one sample.") if not motif_list: raise ValueError("motifs must contain at least one motif.") - if mode not in {"read_global", "region_anchored"}: - raise NotImplementedError( - "The first workflow slice implements mode='read_global' and " - "mode='region_anchored' only." - ) - if len(sample_list) < 2: - raise ValueError("shared_cluster_distribution requires at least two datasets.") - if clusterer != "minibatch_kmeans": - raise NotImplementedError( - "The first workflow slice supports clusterer='minibatch_kmeans' only." - ) - if signal_normalization not in _SUPPORTED_SIGNAL_NORMALIZATION: - raise ValueError(f"Unsupported signal_normalization: {signal_normalization}") - if feature_scaling not in _SUPPORTED_FEATURE_SCALING: - raise ValueError(f"Unsupported feature_scaling: {feature_scaling}") - if cluster_basis not in _SUPPORTED_CLUSTER_BASIS: - raise ValueError(f"Unsupported cluster_basis: {cluster_basis}") + _validate_shared_cluster_distribution_config( + mode=mode, + clusterer=clusterer, + signal_normalization=signal_normalization, + feature_scaling=feature_scaling, + cluster_basis=cluster_basis, + sample_count=len(sample_list), + ) if mode == "region_anchored": if matched_regions is None: diff --git a/docs/region-discovery.md b/docs/region-discovery.md index c0ee02b..7a3c534 100644 --- a/docs/region-discovery.md +++ b/docs/region-discovery.md @@ -94,7 +94,7 @@ result = workflows.discovery_cluster_workflow( ``` ```python -bed_df = region_discovery.hits_to_bed(result.hits) +bed_df = region_discovery.hits_to_bed(result.discovery.hits) bed_df.to_csv("discovered_hits.bed", sep="\t", header=False, index=False) ``` diff --git a/tests/test_workflows.py b/tests/test_workflows.py index 8a99c76..ca7d9ef 100644 --- a/tests/test_workflows.py +++ b/tests/test_workflows.py @@ -214,7 +214,13 @@ def test_discovery_cluster_workflow_errors_when_no_hits_survive_selection(monkey def test_discovery_cluster_workflow_rejects_unknown_selection_mode(monkeypatch): - monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + called = {"scan_genome": False} + + def fake_scan_genome(*args, **kwargs): + called["scan_genome"] = True + raise AssertionError("scan_genome should not be called for invalid selection config") + + monkeypatch.setattr(workflows.region_discovery, "scan_genome", fake_scan_genome) monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) with pytest.raises(ValueError, match="Unsupported selection mode"): @@ -226,6 +232,28 @@ def test_discovery_cluster_workflow_rejects_unknown_selection_mode(monkeypatch): clustering={"mode": "region_anchored", "n_clusters": 2}, selection={"mode": "invalid"}, ) + assert called["scan_genome"] is False + + +def test_discovery_cluster_workflow_rejects_invalid_clustering_config_before_scan(monkeypatch): + called = {"scan_genome": False} + + def fake_scan_genome(*args, **kwargs): + called["scan_genome"] = True + raise AssertionError("scan_genome should not be called for invalid clustering config") + + monkeypatch.setattr(workflows.region_discovery, "scan_genome", fake_scan_genome) + monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) + + with pytest.raises(NotImplementedError, match="clusterer='minibatch_kmeans' only"): + workflows.discovery_cluster_workflow( + samples=_workflow_samples(), + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "clusterer": "agglomerative", "n_clusters": 2}, + ) + assert called["scan_genome"] is False def test_discovery_cluster_workflow_region_anchored_uses_serializable_matched_regions(monkeypatch): From bfd32b8987b49078e7f0a9c3c2e2d809cf67b5df Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 14:52:52 -0700 Subject: [PATCH 081/272] feat: add discovery cluster contrast result --- dimelo/__init__.py | 3 +- dimelo/models.py | 41 +++++++++ tests/test_models.py | 199 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 242 insertions(+), 1 deletion(-) diff --git a/dimelo/__init__.py b/dimelo/__init__.py index bce4756..9f36017 100644 --- a/dimelo/__init__.py +++ b/dimelo/__init__.py @@ -18,7 +18,7 @@ region_contrasts, workflows, ) -from .models import RegionDiscoveryClusterResult +from .models import RegionDiscoveryClusterContrastResult, RegionDiscoveryClusterResult __all__ = [ "cluster", @@ -38,6 +38,7 @@ "region_discovery", "region_analysis", "region_contrasts", + "RegionDiscoveryClusterContrastResult", "RegionDiscoveryClusterResult", "workflows", ] diff --git a/dimelo/models.py b/dimelo/models.py index b8c581d..292ea55 100644 --- a/dimelo/models.py +++ b/dimelo/models.py @@ -197,6 +197,47 @@ def __post_init__(self) -> None: ) +@dataclass +class RegionDiscoveryClusterContrastResult: + discovery: RegionDiscoveryResult + clustering: SharedClusterResult + contrasts: RegionContrastResult + selected_regions: pd.DataFrame + metadata: dict[str, Any] = field(default_factory=dict) + figures: dict[str, Any] = field(default_factory=dict) + + def __post_init__(self) -> None: + required_fields = { + "discovery": self.discovery, + "clustering": self.clustering, + "contrasts": self.contrasts, + "selected_regions": self.selected_regions, + "metadata": self.metadata, + "figures": self.figures, + } + missing = [name for name, value in required_fields.items() if value is None] + if missing: + raise ValueError( + "RegionDiscoveryClusterContrastResult requires non-None values for: " + f"{', '.join(missing)}" + ) + if not isinstance(self.discovery, RegionDiscoveryResult): + raise TypeError( + "RegionDiscoveryClusterContrastResult.discovery must be a " + "RegionDiscoveryResult" + ) + if not isinstance(self.clustering, SharedClusterResult): + raise TypeError( + "RegionDiscoveryClusterContrastResult.clustering must be a " + "SharedClusterResult" + ) + if not isinstance(self.contrasts, RegionContrastResult): + raise TypeError( + "RegionDiscoveryClusterContrastResult.contrasts must be a " + "RegionContrastResult" + ) + + @dataclass class RegionDiscoveryClusterResult: discovery: RegionDiscoveryResult diff --git a/tests/test_models.py b/tests/test_models.py index 99a7856..b9764f7 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -12,6 +12,7 @@ DatasetArtifact, SampleSpec, RegionDiscoveryResult, + RegionDiscoveryClusterContrastResult, RegionDiscoveryClusterResult, RegionContrastResult, SharedClusterModel, @@ -29,6 +30,14 @@ def test_dimelo_package_root_exports_region_discovery_cluster_result(): assert RootRegionDiscoveryClusterResult is RegionDiscoveryClusterResult +def test_dimelo_package_root_exports_region_discovery_cluster_contrast_result(): + from dimelo import ( + RegionDiscoveryClusterContrastResult as RootRegionDiscoveryClusterContrastResult, + ) + + assert RootRegionDiscoveryClusterContrastResult is RegionDiscoveryClusterContrastResult + + def test_sample_spec_fields(): sample = SampleSpec( sample_id="sample-1", @@ -547,6 +556,196 @@ def test_region_discovery_cluster_result_rejects_invalid_wrapper_types( RegionDiscoveryClusterResult(**kwargs) +def test_region_discovery_cluster_contrast_result_supports_wrapped_outputs(): + discovery = RegionDiscoveryResult( + hits=pd.DataFrame({"region": ["chr1:0-1000"]}), + windows=pd.DataFrame({"window_id": ["chr1:0-1000"]}), + contrast=None, + plot_data={"ranked_hits": pd.DataFrame({"region": ["chr1:0-1000"]})}, + metadata={"analysis_unit": "genome"}, + figures={"hit_track": object()}, + ) + clustering = SharedClusterResult( + model=SharedClusterModel( + mode="shared", + motifs=["A,0"], + feature_names=["A,0_mod_fraction"], + preprocessing={"scale": "standard"}, + estimator=object(), + cluster_labels=["cluster-1"], + fit_metadata={"random_state": 7}, + ), + assignments=pd.DataFrame({"cluster": ["cluster-1"]}), + cluster_distribution=pd.DataFrame({"cluster": ["cluster-1"]}), + condition_distribution=pd.DataFrame({"condition": ["treated"]}), + distribution_change=None, + cluster_profiles=pd.DataFrame({"profile": [1.0]}), + region_summaries=None, + plot_data={"cluster_distribution_bar": {"kind": "bar"}}, + figures={}, + metadata={"notes": "ok"}, + ) + contrasts = RegionContrastResult( + regions=pd.DataFrame({"region": ["chr1:0-1000"]}), + summary=pd.DataFrame({"metric": [1.0]}), + contrast=ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + reference_condition="NS", + ), + plot_data={"volcano": pd.DataFrame({"x": [1.0]})}, + metadata={"notes": "ok"}, + figures={}, + ) + selected_regions = pd.DataFrame( + [{"chromosome": "chr1", "start": 0, "end": 1000}] + ) + + result = RegionDiscoveryClusterContrastResult( + discovery=discovery, + clustering=clustering, + contrasts=contrasts, + selected_regions=selected_regions, + metadata={"contrast_scope": "selected"}, + figures={"workflow": object()}, + ) + + assert result.discovery is discovery + assert result.clustering is clustering + assert result.contrasts is contrasts + assert result.selected_regions.equals(selected_regions) + assert result.metadata == {"contrast_scope": "selected"} + + +@pytest.mark.parametrize( + "field_name", + ["discovery", "clustering", "contrasts", "selected_regions", "metadata", "figures"], +) +def test_region_discovery_cluster_contrast_result_rejects_missing_required_fields( + field_name, +): + kwargs = { + "discovery": RegionDiscoveryResult( + hits=pd.DataFrame({"region": ["chr1:0-1000"]}), + windows=pd.DataFrame({"window_id": ["chr1:0-1000"]}), + contrast=None, + plot_data={"ranked_hits": pd.DataFrame({"region": ["chr1:0-1000"]})}, + metadata={"analysis_unit": "genome"}, + figures={"hit_track": object()}, + ), + "clustering": SharedClusterResult( + model=SharedClusterModel( + mode="shared", + motifs=["A,0"], + feature_names=["A,0_mod_fraction"], + preprocessing={"scale": "standard"}, + estimator=object(), + cluster_labels=["cluster-1"], + fit_metadata={"random_state": 7}, + ), + assignments=pd.DataFrame({"cluster": ["cluster-1"]}), + cluster_distribution=pd.DataFrame({"cluster": ["cluster-1"]}), + condition_distribution=pd.DataFrame({"condition": ["treated"]}), + distribution_change=None, + cluster_profiles=pd.DataFrame({"profile": [1.0]}), + region_summaries=None, + plot_data={"cluster_distribution_bar": {"kind": "bar"}}, + figures={}, + metadata={"notes": "ok"}, + ), + "contrasts": RegionContrastResult( + regions=pd.DataFrame({"region": ["chr1:0-1000"]}), + summary=pd.DataFrame({"metric": [1.0]}), + contrast=ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + reference_condition="NS", + ), + plot_data={"volcano": pd.DataFrame({"x": [1.0]})}, + metadata={"notes": "ok"}, + figures={}, + ), + "selected_regions": pd.DataFrame( + [{"chromosome": "chr1", "start": 0, "end": 1000}] + ), + "metadata": {"contrast_scope": "selected"}, + "figures": {}, + } + kwargs[field_name] = None + + with pytest.raises(ValueError, match=field_name): + RegionDiscoveryClusterContrastResult(**kwargs) + + +@pytest.mark.parametrize( + ("field_name", "value", "expected_type"), + [ + ("discovery", object(), "RegionDiscoveryResult"), + ("clustering", object(), "SharedClusterResult"), + ("contrasts", object(), "RegionContrastResult"), + ], +) +def test_region_discovery_cluster_contrast_result_rejects_invalid_wrapper_types( + field_name, + value, + expected_type, +): + kwargs = { + "discovery": RegionDiscoveryResult( + hits=pd.DataFrame({"region": ["chr1:0-1000"]}), + windows=pd.DataFrame({"window_id": ["chr1:0-1000"]}), + contrast=None, + plot_data={"ranked_hits": pd.DataFrame({"region": ["chr1:0-1000"]})}, + metadata={"analysis_unit": "genome"}, + figures={"hit_track": object()}, + ), + "clustering": SharedClusterResult( + model=SharedClusterModel( + mode="shared", + motifs=["A,0"], + feature_names=["A,0_mod_fraction"], + preprocessing={"scale": "standard"}, + estimator=object(), + cluster_labels=["cluster-1"], + fit_metadata={"random_state": 7}, + ), + assignments=pd.DataFrame({"cluster": ["cluster-1"]}), + cluster_distribution=pd.DataFrame({"cluster": ["cluster-1"]}), + condition_distribution=pd.DataFrame({"condition": ["treated"]}), + distribution_change=None, + cluster_profiles=pd.DataFrame({"profile": [1.0]}), + region_summaries=None, + plot_data={"cluster_distribution_bar": {"kind": "bar"}}, + figures={}, + metadata={"notes": "ok"}, + ), + "contrasts": RegionContrastResult( + regions=pd.DataFrame({"region": ["chr1:0-1000"]}), + summary=pd.DataFrame({"metric": [1.0]}), + contrast=ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + reference_condition="NS", + ), + plot_data={"volcano": pd.DataFrame({"x": [1.0]})}, + metadata={"notes": "ok"}, + figures={}, + ), + "selected_regions": pd.DataFrame( + [{"chromosome": "chr1", "start": 0, "end": 1000}] + ), + "metadata": {"contrast_scope": "selected"}, + "figures": {}, + } + kwargs[field_name] = value + + with pytest.raises(TypeError, match=expected_type): + RegionDiscoveryClusterContrastResult(**kwargs) + + def test_cohort_spec_stores_workflow_and_params(): cohort = CohortSpec( cohort_id="cohort-1", From a5bb4503638de566c28c8299aefcdaa800b6d2a3 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 14:56:38 -0700 Subject: [PATCH 082/272] fix: validate selected discovery regions --- dimelo/models.py | 27 +++++++++++ tests/test_models.py | 111 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 138 insertions(+) diff --git a/dimelo/models.py b/dimelo/models.py index 292ea55..f3ed1f5 100644 --- a/dimelo/models.py +++ b/dimelo/models.py @@ -7,6 +7,29 @@ import pandas as pd +_SELECTED_REGION_CHROM_COLUMNS = {"chrom", "chromosome"} +_SELECTED_REGION_REQUIRED_COLUMNS = {"start", "end"} + + +def _validate_selected_regions_dataframe( + selected_regions: pd.DataFrame, + *, + owner: str, +) -> None: + if not isinstance(selected_regions, pd.DataFrame): + raise TypeError(f"{owner}.selected_regions must be a pandas DataFrame") + + has_chrom_column = bool(_SELECTED_REGION_CHROM_COLUMNS & set(selected_regions.columns)) + has_required_columns = _SELECTED_REGION_REQUIRED_COLUMNS.issubset( + selected_regions.columns + ) + if not has_chrom_column or not has_required_columns: + raise ValueError( + f"{owner}.selected_regions must include 'start', 'end', and either " + "'chrom' or 'chromosome'" + ) + + @dataclass class SampleSpec: sample_id: str @@ -236,6 +259,10 @@ def __post_init__(self) -> None: "RegionDiscoveryClusterContrastResult.contrasts must be a " "RegionContrastResult" ) + _validate_selected_regions_dataframe( + self.selected_regions, + owner="RegionDiscoveryClusterContrastResult", + ) @dataclass diff --git a/tests/test_models.py b/tests/test_models.py index b9764f7..7c2e18b 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -746,6 +746,117 @@ def test_region_discovery_cluster_contrast_result_rejects_invalid_wrapper_types( RegionDiscoveryClusterContrastResult(**kwargs) +def test_region_discovery_cluster_contrast_result_rejects_non_dataframe_selected_regions(): + with pytest.raises(TypeError, match="selected_regions must be a pandas DataFrame"): + RegionDiscoveryClusterContrastResult( + discovery=RegionDiscoveryResult( + hits=pd.DataFrame({"region": ["chr1:0-1000"]}), + windows=pd.DataFrame({"window_id": ["chr1:0-1000"]}), + contrast=None, + plot_data={"ranked_hits": pd.DataFrame({"region": ["chr1:0-1000"]})}, + metadata={"analysis_unit": "genome"}, + figures={"hit_track": object()}, + ), + clustering=SharedClusterResult( + model=SharedClusterModel( + mode="shared", + motifs=["A,0"], + feature_names=["A,0_mod_fraction"], + preprocessing={"scale": "standard"}, + estimator=object(), + cluster_labels=["cluster-1"], + fit_metadata={"random_state": 7}, + ), + assignments=pd.DataFrame({"cluster": ["cluster-1"]}), + cluster_distribution=pd.DataFrame({"cluster": ["cluster-1"]}), + condition_distribution=pd.DataFrame({"condition": ["treated"]}), + distribution_change=None, + cluster_profiles=pd.DataFrame({"profile": [1.0]}), + region_summaries=None, + plot_data={"cluster_distribution_bar": {"kind": "bar"}}, + figures={}, + metadata={"notes": "ok"}, + ), + contrasts=RegionContrastResult( + regions=pd.DataFrame({"region": ["chr1:0-1000"]}), + summary=pd.DataFrame({"metric": [1.0]}), + contrast=ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + reference_condition="NS", + ), + plot_data={"volcano": pd.DataFrame({"x": [1.0]})}, + metadata={"notes": "ok"}, + figures={}, + ), + selected_regions=[{"chrom": "chr1", "start": 0, "end": 1000}], + metadata={"contrast_scope": "selected"}, + ) + + +@pytest.mark.parametrize( + "selected_regions", + [ + pd.DataFrame([{"start": 0, "end": 1000}]), + pd.DataFrame([{"chrom": "chr1", "end": 1000}]), + pd.DataFrame([{"chromosome": "chr1", "start": 0}]), + ], +) +def test_region_discovery_cluster_contrast_result_rejects_invalid_selected_regions_schema( + selected_regions, +): + with pytest.raises( + ValueError, + match="selected_regions must include 'start', 'end', and either 'chrom' or 'chromosome'", + ): + RegionDiscoveryClusterContrastResult( + discovery=RegionDiscoveryResult( + hits=pd.DataFrame({"region": ["chr1:0-1000"]}), + windows=pd.DataFrame({"window_id": ["chr1:0-1000"]}), + contrast=None, + plot_data={"ranked_hits": pd.DataFrame({"region": ["chr1:0-1000"]})}, + metadata={"analysis_unit": "genome"}, + figures={"hit_track": object()}, + ), + clustering=SharedClusterResult( + model=SharedClusterModel( + mode="shared", + motifs=["A,0"], + feature_names=["A,0_mod_fraction"], + preprocessing={"scale": "standard"}, + estimator=object(), + cluster_labels=["cluster-1"], + fit_metadata={"random_state": 7}, + ), + assignments=pd.DataFrame({"cluster": ["cluster-1"]}), + cluster_distribution=pd.DataFrame({"cluster": ["cluster-1"]}), + condition_distribution=pd.DataFrame({"condition": ["treated"]}), + distribution_change=None, + cluster_profiles=pd.DataFrame({"profile": [1.0]}), + region_summaries=None, + plot_data={"cluster_distribution_bar": {"kind": "bar"}}, + figures={}, + metadata={"notes": "ok"}, + ), + contrasts=RegionContrastResult( + regions=pd.DataFrame({"region": ["chr1:0-1000"]}), + summary=pd.DataFrame({"metric": [1.0]}), + contrast=ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + reference_condition="NS", + ), + plot_data={"volcano": pd.DataFrame({"x": [1.0]})}, + metadata={"notes": "ok"}, + figures={}, + ), + selected_regions=selected_regions, + metadata={"contrast_scope": "selected"}, + ) + + def test_cohort_spec_stores_workflow_and_params(): cohort = CohortSpec( cohort_id="cohort-1", From d103873cd8b06337786d7946cf7a0a4c99c9c54d Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 14:59:01 -0700 Subject: [PATCH 083/272] Add chrom alias coverage for selected regions --- tests/test_models.py | 56 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) diff --git a/tests/test_models.py b/tests/test_models.py index 7c2e18b..8154685 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -618,6 +618,62 @@ def test_region_discovery_cluster_contrast_result_supports_wrapped_outputs(): assert result.metadata == {"contrast_scope": "selected"} +def test_region_discovery_cluster_contrast_result_accepts_selected_regions_chrom_alias(): + discovery = RegionDiscoveryResult( + hits=pd.DataFrame({"region": ["chr1:0-1000"]}), + windows=pd.DataFrame({"window_id": ["chr1:0-1000"]}), + contrast=None, + plot_data={"ranked_hits": pd.DataFrame({"region": ["chr1:0-1000"]})}, + metadata={"analysis_unit": "genome"}, + figures={"hit_track": object()}, + ) + clustering = SharedClusterResult( + model=SharedClusterModel( + mode="shared", + motifs=["A,0"], + feature_names=["A,0_mod_fraction"], + preprocessing={"scale": "standard"}, + estimator=object(), + cluster_labels=["cluster-1"], + fit_metadata={"random_state": 7}, + ), + assignments=pd.DataFrame({"cluster": ["cluster-1"]}), + cluster_distribution=pd.DataFrame({"cluster": ["cluster-1"]}), + condition_distribution=pd.DataFrame({"condition": ["treated"]}), + distribution_change=None, + cluster_profiles=pd.DataFrame({"profile": [1.0]}), + region_summaries=None, + plot_data={"cluster_distribution_bar": {"kind": "bar"}}, + figures={}, + metadata={"notes": "ok"}, + ) + contrasts = RegionContrastResult( + regions=pd.DataFrame({"region": ["chr1:0-1000"]}), + summary=pd.DataFrame({"metric": [1.0]}), + contrast=ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + reference_condition="NS", + ), + plot_data={"volcano": pd.DataFrame({"x": [1.0]})}, + metadata={"notes": "ok"}, + figures={}, + ) + selected_regions = pd.DataFrame([{"chrom": "chr1", "start": 0, "end": 1000}]) + + result = RegionDiscoveryClusterContrastResult( + discovery=discovery, + clustering=clustering, + contrasts=contrasts, + selected_regions=selected_regions, + metadata={"contrast_scope": "selected"}, + figures={"workflow": object()}, + ) + + assert result.selected_regions.equals(selected_regions) + + @pytest.mark.parametrize( "field_name", ["discovery", "clustering", "contrasts", "selected_regions", "metadata", "figures"], From 3fb5acd9b37e41721e27d8d82079681d01697b28 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 15:01:02 -0700 Subject: [PATCH 084/272] feat: add discovery cluster contrast workflow --- dimelo/workflows.py | 65 +++++++++++- tests/test_workflows.py | 213 +++++++++++++++++++++++++++++++++++++++- 2 files changed, 275 insertions(+), 3 deletions(-) diff --git a/dimelo/workflows.py b/dimelo/workflows.py index c4499dd..cca7c2a 100644 --- a/dimelo/workflows.py +++ b/dimelo/workflows.py @@ -7,9 +7,17 @@ import pandas as pd from .artifacts import resolve_artifact -from . import cluster, distribution, plotting, region_analysis, region_discovery +from . import ( + cluster, + distribution, + plotting, + region_analysis, + region_contrasts, + region_discovery, +) from .models import ( DatasetArtifact, + RegionDiscoveryClusterContrastResult, RegionDiscoveryClusterResult, SampleSpec, SharedClusterModel, @@ -430,6 +438,61 @@ def discovery_cluster_workflow( ) +def discovery_cluster_contrast_workflow( + *, + samples: Iterable[SampleSpec], + motifs: Iterable[str], + genome_sizes: dict[str, int], + discovery: dict[str, Any], + clustering: dict[str, Any], + contrasts: dict[str, Any], + selection: dict[str, Any] | None = None, +) -> RegionDiscoveryClusterContrastResult: + sample_list = list(samples) + motif_list = list(motifs) + contrast_config = dict(contrasts) + contrast_spec = contrast_config.get("contrast") + if contrast_spec is None: + raise ValueError("discovery_cluster_contrast_workflow requires contrasts['contrast'].") + + region_contrasts.validate_region_contrast_request( + analysis_unit=str(contrast_config.get("analysis_unit", "ensemble_region")), + representation=str(contrast_config.get("representation", "modified_fraction")), + signal_source=str(contrast_config.get("signal_source", "pileup_counts")), + test=str(contrast_config.get("test", "effect_size_only")), + ) + + discovery_cluster_result = discovery_cluster_workflow( + samples=sample_list, + motifs=motif_list, + genome_sizes=genome_sizes, + discovery=discovery, + clustering=clustering, + selection=selection, + ) + selected_region_spec = _selected_regions_to_region_spec( + discovery_cluster_result.selected_regions + ) + contrast_result = region_contrasts.score_regions( + samples=sample_list, + regions=selected_region_spec, + motifs=motif_list, + **contrast_config, + ) + + return RegionDiscoveryClusterContrastResult( + discovery=discovery_cluster_result.discovery, + clustering=discovery_cluster_result.clustering, + contrasts=contrast_result, + selected_regions=discovery_cluster_result.selected_regions, + metadata={ + **discovery_cluster_result.metadata, + "contrast_scope": "selected", + "full_scan_windows": discovery_cluster_result.discovery.windows.copy(), + }, + ) + + def _build_shared_cluster_result( *, mode: str, diff --git a/tests/test_workflows.py b/tests/test_workflows.py index ca7d9ef..9182acc 100644 --- a/tests/test_workflows.py +++ b/tests/test_workflows.py @@ -3,8 +3,14 @@ import pytest from dimelo import workflows -from dimelo.models import DatasetArtifact -from dimelo.models import RegionDiscoveryResult, SampleSpec, SharedClusterModel, SharedClusterResult +from dimelo.models import ContrastSpec, DatasetArtifact +from dimelo.models import ( + RegionContrastResult, + RegionDiscoveryResult, + SampleSpec, + SharedClusterModel, + SharedClusterResult, +) def _workflow_samples(): @@ -105,6 +111,81 @@ def _mock_cluster_result(*args, **kwargs): ) +def _mock_region_contrast_result(*args, **kwargs): + contrast = kwargs["contrast"] + regions = pd.DataFrame( + [ + { + "region_id": "chr1:0-500,+", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": "+", + "fraction": 0.8, + "reference_fraction": 0.2, + "delta_fraction": 0.6, + "log2_fc": 2.0, + "effect_size": 0.6, + "rank": 1, + "numerator_modified_count": 8, + "numerator_valid_count": 10, + "numerator_replicate_n": 1, + "denominator_modified_count": 2, + "denominator_valid_count": 10, + "denominator_replicate_n": 1, + }, + { + "region_id": "chr1:500-1000,-", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": "-", + "fraction": 0.6, + "reference_fraction": 0.3, + "delta_fraction": 0.3, + "log2_fc": 1.0, + "effect_size": 0.3, + "rank": 2, + "numerator_modified_count": 6, + "numerator_valid_count": 10, + "numerator_replicate_n": 1, + "denominator_modified_count": 3, + "denominator_valid_count": 10, + "denominator_replicate_n": 1, + }, + ] + ) + summary = regions[ + [ + "region_id", + "fraction", + "reference_fraction", + "delta_fraction", + "log2_fc", + "rank", + "numerator_modified_count", + "numerator_valid_count", + "numerator_replicate_n", + "denominator_modified_count", + "denominator_valid_count", + "denominator_replicate_n", + ] + ].copy() + return RegionContrastResult( + regions=regions, + summary=summary, + contrast=contrast, + plot_data={"region_effect_sizes": summary.copy()}, + metadata={ + "analysis_unit": kwargs.get("analysis_unit", "ensemble_region"), + "representation": kwargs.get("representation", "modified_fraction"), + "signal_source": kwargs.get("signal_source", "pileup_counts"), + "test": kwargs.get("test", "effect_size_only"), + "multiple_testing": kwargs.get("multiple_testing", "fdr_bh"), + }, + ) + + def _fake_region_anchored_extract(*args, **kwargs): regions = kwargs["regions"] region_list = list(regions) if isinstance(regions, list) else [regions] @@ -408,6 +489,134 @@ def fake_cluster(**kwargs): assert captured["clustering_motifs"] == ["A,0", "CG,1"] +def test_discovery_cluster_contrast_workflow_returns_all_results(monkeypatch): + monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) + monkeypatch.setattr(workflows.region_contrasts, "score_regions", _mock_region_contrast_result) + + result = workflows.discovery_cluster_contrast_workflow( + samples=_workflow_samples(), + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "n_clusters": 2}, + contrasts={ + "contrast": ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + ), + "test": "effect_size_only", + }, + ) + + assert result.discovery.hits.shape[0] == 3 + assert result.clustering.model.mode == "region_anchored" + assert result.contrasts.metadata["test"] == "effect_size_only" + assert result.metadata["contrast_scope"] == "selected" + + +def test_discovery_cluster_contrast_workflow_scores_selected_regions_by_default(monkeypatch): + captured = {} + + def fake_score_regions(**kwargs): + captured["regions"] = kwargs["regions"] + return _mock_region_contrast_result(**kwargs) + + monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) + monkeypatch.setattr(workflows.region_contrasts, "score_regions", fake_score_regions) + + result = workflows.discovery_cluster_contrast_workflow( + samples=_workflow_samples(), + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "n_clusters": 2}, + contrasts={ + "contrast": ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + ), + }, + selection={"mode": "top_n", "top_n": 2}, + ) + + assert captured["regions"] == ["chr1:0-500,+", "chr1:500-1000,-"] + assert result.selected_regions["name"].tolist() == ["chr1:0-500", "chr1:500-1000"] + + +def test_discovery_cluster_contrast_workflow_preserves_full_scan_windows_context(monkeypatch): + monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) + monkeypatch.setattr(workflows.region_contrasts, "score_regions", _mock_region_contrast_result) + + result = workflows.discovery_cluster_contrast_workflow( + samples=_workflow_samples(), + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "n_clusters": 2}, + contrasts={ + "contrast": ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + ), + }, + ) + + assert result.metadata["full_scan_windows"].equals(result.discovery.windows) + + +def test_discovery_cluster_contrast_workflow_rejects_missing_contrast_config(monkeypatch): + monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) + + with pytest.raises(ValueError, match=r"requires contrasts\['contrast'\]"): + workflows.discovery_cluster_contrast_workflow( + samples=_workflow_samples(), + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "n_clusters": 2}, + contrasts={"test": "effect_size_only"}, + ) + + +def test_discovery_cluster_contrast_workflow_fast_fails_invalid_contrast_config_before_scan( + monkeypatch, +): + called = {"scan_genome": False} + + def fake_scan_genome(*args, **kwargs): + called["scan_genome"] = True + raise AssertionError("scan_genome should not be called for invalid contrast config") + + monkeypatch.setattr(workflows.region_discovery, "scan_genome", fake_scan_genome) + monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) + + with pytest.raises(ValueError, match="analysis_unit='ensemble_region'"): + workflows.discovery_cluster_contrast_workflow( + samples=_workflow_samples(), + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "n_clusters": 2}, + contrasts={ + "contrast": ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + ), + "analysis_unit": "single_read", + }, + ) + + assert called["scan_genome"] is False + + def test_shared_cluster_distribution_read_global(monkeypatch): fake_samples = [ SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5"), From 339aee9d540267acabc8e85722d2957a6c37d3b3 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 15:06:17 -0700 Subject: [PATCH 085/272] docs: document discovery cluster contrast workflow --- README.md | 2 ++ docs/region-contrasts.md | 36 ++++++++++++++++++++++++++++++++++++ docs/region-discovery.md | 37 +++++++++++++++++++++++++++++++++++++ docs/shared-clustering.md | 3 +++ tests/test_workflows.py | 2 ++ 5 files changed, 80 insertions(+) diff --git a/README.md b/README.md index b278569..9ca5fec 100644 --- a/README.md +++ b/README.md @@ -233,6 +233,8 @@ Use `parse_bam.pileup()` when you want defined-region abundance testing, and use For an end-to-end discovery-to-clustering run, use `workflows.discovery_cluster_workflow()`. It keeps discovery output in BED-style `selected_regions`, then derives the serializable region spec that `shared_cluster_distribution(..., matched_regions=...)` consumes. +For discovery-to-clustering-to-contrast follow-up, use `workflows.discovery_cluster_contrast_workflow()`. It keeps discovery output in BED-style `selected_regions`, passes the derived serializable region spec into clustering, scores the same selected loci by default, and stores the full discovery scan in `metadata["full_scan_windows"]`. + For human-readable pileups (bedmethyl files, .bed) and extracted reads (.txt tab-separated values), run with `cleanup=False`. `cleanup=True` will clear these outputs because they can take up a lot of space. ### Parsing outputs diff --git a/docs/region-contrasts.md b/docs/region-contrasts.md index 9d76b75..1680762 100644 --- a/docs/region-contrasts.md +++ b/docs/region-contrasts.md @@ -106,3 +106,39 @@ sns.scatterplot( - Run `parse_bam.pileup()` when you care about motif abundance, defined-region contrasts, or later de novo discovery. - Run `parse_bam.extract()` when you care about single-read analysis or clustering. - Run both when you want formal region-level abundance testing plus downstream read-level follow-up on the same samples. + +## Discovery-Driven Follow-Up + +When discovery, clustering, and contrasts are chained together, the combined workflow keeps the selected loci as the follow-up contract: + +```python +from dimelo import workflows + +result = workflows.discovery_cluster_contrast_workflow( + samples=samples, + motifs=["A,0"], + genome_sizes={"chr1": 248956422}, + discovery={ + "window_size": 2000, + "step_size": 500, + "score": "beta_binomial", + "contrast": discovery_contrast, + }, + clustering={ + "mode": "region_anchored", + "n_clusters": 6, + }, + contrasts={ + "contrast": region_contrast, + "test": "beta_binomial", + }, + selection={"mode": "top_n", "top_n": 250}, +) +``` + +The data contract is: + +- `result.selected_regions` is the BED-style follow-up set +- clustering receives a serializable region-spec derived from those rows +- `result.contrasts` scores the same selected loci by default +- `result.metadata["full_scan_windows"]` keeps the full discovery table as context diff --git a/docs/region-discovery.md b/docs/region-discovery.md index 7a3c534..4ad093c 100644 --- a/docs/region-discovery.md +++ b/docs/region-discovery.md @@ -93,6 +93,43 @@ result = workflows.discovery_cluster_workflow( ) ``` +When you want discovery, clustering, and defined-region contrasts in one pass, use `workflows.discovery_cluster_contrast_workflow()`: + +```python +result = workflows.discovery_cluster_contrast_workflow( + samples=samples, + motifs=["A,0"], + genome_sizes={"chr1": 248956422}, + discovery={ + "window_size": 2000, + "step_size": 500, + "score": "beta_binomial", + "contrast": discovery_contrast, + }, + clustering={ + "mode": "region_anchored", + "n_clusters": 6, + }, + contrasts={ + "contrast": region_contrast, + "test": "beta_binomial", + }, + selection={"mode": "top_n", "top_n": 250}, +) + +selected = result.selected_regions +clustered = result.clustering.assignments +scored = result.contrasts.regions +windows = result.metadata["full_scan_windows"] +``` + +The contract is intentionally simple: + +- `result.selected_regions` is the BED-style selected follow-up set +- clustering receives a serializable region-spec derived from those rows +- `result.contrasts` scores the same selected loci by default +- `result.metadata["full_scan_windows"]` carries the full discovery scan for context + ```python bed_df = region_discovery.hits_to_bed(result.discovery.hits) bed_df.to_csv("discovered_hits.bed", sep="\t", header=False, index=False) diff --git a/docs/shared-clustering.md b/docs/shared-clustering.md index c5eefff..502f8d3 100644 --- a/docs/shared-clustering.md +++ b/docs/shared-clustering.md @@ -59,6 +59,8 @@ result = workflows.shared_cluster_distribution( `shared_cluster_distribution()` expects `matched_regions` to already be a serializable region spec. In the discovery-driven flow, `discovery_cluster_workflow()` is the caller that derives that spec from BED-style discovery rows and forwards it into this workflow. That keeps discovery output human-readable while still feeding clustering the compact region representation it needs. +`discovery_cluster_contrast_workflow()` extends the same handoff one step further: it derives the serializable region spec from the BED-style discovery rows, passes that into clustering, and uses the same selected loci as the default follow-up region set for contrasts. + ## Canonical Outputs The workflow returns a `SharedClusterResult` with canonical tables: @@ -92,5 +94,6 @@ heatmap = result.plot_data["cluster_distribution_heatmap"].set_index("condition" - `mode="read_global"` supports shared read clustering from extract outputs. - `mode="region_anchored"` supports matched-region clustering from pileup-derived region vectors. - `discovery_cluster_workflow()` composes discovery and `region_anchored` clustering by passing derived matched regions into this workflow. +- `discovery_cluster_contrast_workflow()` composes discovery, `region_anchored` clustering, and defined-region contrasts on the same selected loci. - The default supported clusterer is `minibatch_kmeans`. - Results are data-first: tables are the stable contract, while plotting is optional. diff --git a/tests/test_workflows.py b/tests/test_workflows.py index 9182acc..11fe81b 100644 --- a/tests/test_workflows.py +++ b/tests/test_workflows.py @@ -514,6 +514,8 @@ def test_discovery_cluster_contrast_workflow_returns_all_results(monkeypatch): assert result.clustering.model.mode == "region_anchored" assert result.contrasts.metadata["test"] == "effect_size_only" assert result.metadata["contrast_scope"] == "selected" + assert list(result.selected_regions.columns) == ["chrom", "start", "end", "name", "score", "strand"] + assert result.metadata["full_scan_windows"].equals(result.discovery.windows) def test_discovery_cluster_contrast_workflow_scores_selected_regions_by_default(monkeypatch): From 59a630e58ed72da894dd9fdda1c58b42a5c99a91 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 15:17:06 -0700 Subject: [PATCH 086/272] Fix discovery cluster contrast region handoff --- README.md | 2 +- dimelo/workflows.py | 96 ++++++++++++++++++++++++++++++--- docs/region-contrasts.md | 4 +- docs/region-discovery.md | 3 +- docs/shared-clustering.md | 4 +- tests/test_workflows.py | 108 ++++++++++++++++++++++++++++++++++++++ 6 files changed, 206 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index 9ca5fec..51c9578 100644 --- a/README.md +++ b/README.md @@ -233,7 +233,7 @@ Use `parse_bam.pileup()` when you want defined-region abundance testing, and use For an end-to-end discovery-to-clustering run, use `workflows.discovery_cluster_workflow()`. It keeps discovery output in BED-style `selected_regions`, then derives the serializable region spec that `shared_cluster_distribution(..., matched_regions=...)` consumes. -For discovery-to-clustering-to-contrast follow-up, use `workflows.discovery_cluster_contrast_workflow()`. It keeps discovery output in BED-style `selected_regions`, passes the derived serializable region spec into clustering, scores the same selected loci by default, and stores the full discovery scan in `metadata["full_scan_windows"]`. +For discovery-to-clustering-to-contrast follow-up, use `workflows.discovery_cluster_contrast_workflow()`. It keeps discovery output in BED-style `selected_regions`, passes the derived serializable region spec into clustering, normalizes clustering-side `region_id` values to the same `chr:start-end,strand` key used by contrasts, scores the same selected loci by default, honors an explicit `contrasts["regions"]` override when provided, and stores the full discovery scan in `metadata["full_scan_windows"]`. For human-readable pileups (bedmethyl files, .bed) and extracted reads (.txt tab-separated values), run with `cleanup=False`. `cleanup=True` will clear these outputs because they can take up a lot of space. diff --git a/dimelo/workflows.py b/dimelo/workflows.py index cca7c2a..7e9e499 100644 --- a/dimelo/workflows.py +++ b/dimelo/workflows.py @@ -374,6 +374,81 @@ def _selected_regions_to_region_spec(selected_regions: pd.DataFrame) -> list[str return region_spec +def _normalize_region_id_value( + row: pd.Series, + *, + default_region_ids: dict[str, str], +) -> Any: + region_id = row.get("region_id") + if pd.isna(region_id): + return region_id + + region_id_str = str(region_id) + if region_id_str in default_region_ids: + return default_region_ids[region_id_str] + + chrom = row.get("chromosome", row.get("chrom")) + start = row.get("start") + end = row.get("end") + if pd.notna(chrom) and pd.notna(start) and pd.notna(end): + strand = row.get("strand", ".") + strand_value = strand if strand in {"+", "-", "."} else "." + return f"{chrom}:{int(start)}-{int(end)},{strand_value}" + + if "," in region_id_str: + region_core, strand = region_id_str.rsplit(",", 1) + strand_value = strand if strand in {"+", "-", "."} else "." + return f"{region_core},{strand_value}" + + strand = row.get("strand") + if pd.notna(strand): + strand_value = str(strand) + if strand_value in {"+", "-", "."}: + return f"{region_id_str},{strand_value}" + + return region_id_str + + +def _normalize_cluster_region_ids( + clustering_result: SharedClusterResult, + *, + default_region_spec: list[str], +) -> SharedClusterResult: + default_region_ids = { + region_id.rsplit(",", 1)[0]: region_id for region_id in default_region_spec + } + + normalized_assignments = clustering_result.assignments.copy() + if "region_id" in normalized_assignments.columns: + normalized_assignments["region_id"] = normalized_assignments.apply( + _normalize_region_id_value, + axis=1, + default_region_ids=default_region_ids, + ) + + normalized_region_summaries = clustering_result.region_summaries + if normalized_region_summaries is not None and "region_id" in normalized_region_summaries.columns: + normalized_region_summaries = normalized_region_summaries.copy() + normalized_region_summaries["region_id"] = normalized_region_summaries.apply( + _normalize_region_id_value, + axis=1, + default_region_ids=default_region_ids, + ) + + return SharedClusterResult( + model=clustering_result.model, + assignments=normalized_assignments, + cluster_distribution=clustering_result.cluster_distribution, + condition_distribution=clustering_result.condition_distribution, + distribution_change=clustering_result.distribution_change, + cluster_profiles=clustering_result.cluster_profiles, + region_summaries=normalized_region_summaries, + plot_data=clustering_result.plot_data, + figures=clustering_result.figures, + metadata=clustering_result.metadata, + ) + + def discovery_cluster_workflow( *, samples: Iterable[SampleSpec], @@ -470,24 +545,33 @@ def discovery_cluster_contrast_workflow( clustering=clustering, selection=selection, ) - selected_region_spec = _selected_regions_to_region_spec( - discovery_cluster_result.selected_regions - ) + selected_region_spec = _selected_regions_to_region_spec(discovery_cluster_result.selected_regions) + contrast_regions = contrast_config.pop("regions", None) + contrast_scope = "selected" + if contrast_regions is None: + contrast_regions = selected_region_spec + else: + contrast_scope = "custom" + contrast_result = region_contrasts.score_regions( samples=sample_list, - regions=selected_region_spec, + regions=contrast_regions, motifs=motif_list, **contrast_config, ) + normalized_clustering = _normalize_cluster_region_ids( + discovery_cluster_result.clustering, + default_region_spec=selected_region_spec, + ) return RegionDiscoveryClusterContrastResult( discovery=discovery_cluster_result.discovery, - clustering=discovery_cluster_result.clustering, + clustering=normalized_clustering, contrasts=contrast_result, selected_regions=discovery_cluster_result.selected_regions, metadata={ **discovery_cluster_result.metadata, - "contrast_scope": "selected", + "contrast_scope": contrast_scope, "full_scan_windows": discovery_cluster_result.discovery.windows.copy(), }, ) diff --git a/docs/region-contrasts.md b/docs/region-contrasts.md index 1680762..b0f6b06 100644 --- a/docs/region-contrasts.md +++ b/docs/region-contrasts.md @@ -109,7 +109,7 @@ sns.scatterplot( ## Discovery-Driven Follow-Up -When discovery, clustering, and contrasts are chained together, the combined workflow keeps the selected loci as the follow-up contract: +When discovery, clustering, and contrasts are chained together, the combined workflow uses the selected loci as the default follow-up contract: ```python from dimelo import workflows @@ -140,5 +140,7 @@ The data contract is: - `result.selected_regions` is the BED-style follow-up set - clustering receives a serializable region-spec derived from those rows +- clustering-side `result.clustering.assignments["region_id"]` and `result.clustering.region_summaries["region_id"]` are normalized to the same `chr:start-end,strand` key used by `result.contrasts` - `result.contrasts` scores the same selected loci by default +- pass `contrasts={"regions": ...}` to override that default and set `result.metadata["contrast_scope"] == "custom"` instead - `result.metadata["full_scan_windows"]` keeps the full discovery table as context diff --git a/docs/region-discovery.md b/docs/region-discovery.md index 4ad093c..d7bf2fa 100644 --- a/docs/region-discovery.md +++ b/docs/region-discovery.md @@ -127,7 +127,8 @@ The contract is intentionally simple: - `result.selected_regions` is the BED-style selected follow-up set - clustering receives a serializable region-spec derived from those rows -- `result.contrasts` scores the same selected loci by default +- clustering-side `region_id` values in the combined result are normalized to the same `chr:start-end,strand` key used by contrasts +- `result.contrasts` scores the same selected loci by default, or `contrasts["regions"]` if you provide an explicit override - `result.metadata["full_scan_windows"]` carries the full discovery scan for context ```python diff --git a/docs/shared-clustering.md b/docs/shared-clustering.md index 502f8d3..254ab7b 100644 --- a/docs/shared-clustering.md +++ b/docs/shared-clustering.md @@ -59,7 +59,7 @@ result = workflows.shared_cluster_distribution( `shared_cluster_distribution()` expects `matched_regions` to already be a serializable region spec. In the discovery-driven flow, `discovery_cluster_workflow()` is the caller that derives that spec from BED-style discovery rows and forwards it into this workflow. That keeps discovery output human-readable while still feeding clustering the compact region representation it needs. -`discovery_cluster_contrast_workflow()` extends the same handoff one step further: it derives the serializable region spec from the BED-style discovery rows, passes that into clustering, and uses the same selected loci as the default follow-up region set for contrasts. +`discovery_cluster_contrast_workflow()` extends the same handoff one step further: it derives the serializable region spec from the BED-style discovery rows, passes that into clustering, normalizes clustering-side `region_id` values to the same `chr:start-end,strand` format used by contrasts, and uses the same selected loci as the default follow-up region set for contrasts unless `contrasts["regions"]` overrides it. ## Canonical Outputs @@ -94,6 +94,6 @@ heatmap = result.plot_data["cluster_distribution_heatmap"].set_index("condition" - `mode="read_global"` supports shared read clustering from extract outputs. - `mode="region_anchored"` supports matched-region clustering from pileup-derived region vectors. - `discovery_cluster_workflow()` composes discovery and `region_anchored` clustering by passing derived matched regions into this workflow. -- `discovery_cluster_contrast_workflow()` composes discovery, `region_anchored` clustering, and defined-region contrasts on the same selected loci. +- `discovery_cluster_contrast_workflow()` composes discovery, `region_anchored` clustering, and defined-region contrasts on the selected loci by default, with an explicit custom contrast-region override. - The default supported clusterer is `minibatch_kmeans`. - Results are data-first: tables are the stable contract, while plotting is optional. diff --git a/tests/test_workflows.py b/tests/test_workflows.py index 11fe81b..125b2de 100644 --- a/tests/test_workflows.py +++ b/tests/test_workflows.py @@ -549,6 +549,114 @@ def fake_score_regions(**kwargs): assert result.selected_regions["name"].tolist() == ["chr1:0-500", "chr1:500-1000"] +def test_discovery_cluster_contrast_workflow_normalizes_clustering_region_ids_for_joining( + monkeypatch, +): + def fake_cluster(**kwargs): + result = _mock_cluster_result(**kwargs) + result.assignments = pd.DataFrame( + [ + { + "region_id": "chr1:0-500", + "sample_id": "s1", + "condition": "NS", + "cluster": "C0", + "strand": "+", + }, + { + "region_id": "chr1:500-1000", + "sample_id": "s2", + "condition": "15min", + "cluster": "C1", + "strand": "-", + }, + ] + ) + result.region_summaries = pd.DataFrame( + [ + { + "region_id": "chr1:0-500", + "sample_id": "s1", + "condition": "NS", + "cluster": "C0", + "count": 1, + "fraction": 1.0, + "strand": "+", + }, + { + "region_id": "chr1:500-1000", + "sample_id": "s2", + "condition": "15min", + "cluster": "C1", + "count": 1, + "fraction": 1.0, + "strand": "-", + }, + ] + ) + return result + + monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr(workflows, "shared_cluster_distribution", fake_cluster) + monkeypatch.setattr(workflows.region_contrasts, "score_regions", _mock_region_contrast_result) + + result = workflows.discovery_cluster_contrast_workflow( + samples=_workflow_samples(), + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "n_clusters": 2}, + contrasts={ + "contrast": ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + ), + }, + selection={"mode": "top_n", "top_n": 2}, + ) + + contrast_region_ids = set(result.contrasts.regions["region_id"]) + assert set(result.clustering.assignments["region_id"]) == contrast_region_ids + assert set(result.clustering.region_summaries["region_id"]) == contrast_region_ids + + +def test_discovery_cluster_contrast_workflow_uses_custom_contrast_regions_when_provided( + monkeypatch, +): + captured = {} + + def fake_score_regions(**kwargs): + captured["regions"] = kwargs["regions"] + return _mock_region_contrast_result(**kwargs) + + monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) + monkeypatch.setattr(workflows.region_contrasts, "score_regions", fake_score_regions) + + custom_regions = ["chr2:0-100,+", "chr2:100-200,-"] + result = workflows.discovery_cluster_contrast_workflow( + samples=_workflow_samples(), + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "n_clusters": 2}, + contrasts={ + "contrast": ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + ), + "regions": custom_regions, + }, + selection={"mode": "top_n", "top_n": 2}, + ) + + assert captured["regions"] == custom_regions + assert result.metadata["contrast_scope"] == "custom" + assert result.selected_regions["name"].tolist() == ["chr1:0-500", "chr1:500-1000"] + + def test_discovery_cluster_contrast_workflow_preserves_full_scan_windows_context(monkeypatch): monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) From ccaec9e4a6de7a25fae4951a5c510fbe0d851e34 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 15:22:39 -0700 Subject: [PATCH 087/272] Fix contrast region summary normalization --- dimelo/workflows.py | 41 +++++++++++++++++++++++++---------------- tests/test_workflows.py | 3 +-- 2 files changed, 26 insertions(+), 18 deletions(-) diff --git a/dimelo/workflows.py b/dimelo/workflows.py index 7e9e499..b337b72 100644 --- a/dimelo/workflows.py +++ b/dimelo/workflows.py @@ -409,6 +409,23 @@ def _normalize_region_id_value( return region_id_str +def _normalize_region_id_frame( + region_frame: pd.DataFrame | None, + *, + default_region_ids: dict[str, str], +) -> pd.DataFrame | None: + if region_frame is None or "region_id" not in region_frame.columns: + return region_frame + + normalized_frame = region_frame.copy() + normalized_frame["region_id"] = normalized_frame.apply( + _normalize_region_id_value, + axis=1, + default_region_ids=default_region_ids, + ) + return normalized_frame + + def _normalize_cluster_region_ids( clustering_result: SharedClusterResult, *, @@ -418,22 +435,14 @@ def _normalize_cluster_region_ids( region_id.rsplit(",", 1)[0]: region_id for region_id in default_region_spec } - normalized_assignments = clustering_result.assignments.copy() - if "region_id" in normalized_assignments.columns: - normalized_assignments["region_id"] = normalized_assignments.apply( - _normalize_region_id_value, - axis=1, - default_region_ids=default_region_ids, - ) - - normalized_region_summaries = clustering_result.region_summaries - if normalized_region_summaries is not None and "region_id" in normalized_region_summaries.columns: - normalized_region_summaries = normalized_region_summaries.copy() - normalized_region_summaries["region_id"] = normalized_region_summaries.apply( - _normalize_region_id_value, - axis=1, - default_region_ids=default_region_ids, - ) + normalized_assignments = _normalize_region_id_frame( + clustering_result.assignments, + default_region_ids=default_region_ids, + ) + normalized_region_summaries = _normalize_region_id_frame( + clustering_result.region_summaries, + default_region_ids=default_region_ids, + ) return SharedClusterResult( model=clustering_result.model, diff --git a/tests/test_workflows.py b/tests/test_workflows.py index 125b2de..bf7f962 100644 --- a/tests/test_workflows.py +++ b/tests/test_workflows.py @@ -581,7 +581,6 @@ def fake_cluster(**kwargs): "cluster": "C0", "count": 1, "fraction": 1.0, - "strand": "+", }, { "region_id": "chr1:500-1000", @@ -590,7 +589,6 @@ def fake_cluster(**kwargs): "cluster": "C1", "count": 1, "fraction": 1.0, - "strand": "-", }, ] ) @@ -619,6 +617,7 @@ def fake_cluster(**kwargs): contrast_region_ids = set(result.contrasts.regions["region_id"]) assert set(result.clustering.assignments["region_id"]) == contrast_region_ids assert set(result.clustering.region_summaries["region_id"]) == contrast_region_ids + assert "strand" not in result.clustering.region_summaries.columns def test_discovery_cluster_contrast_workflow_uses_custom_contrast_regions_when_provided( From 5510eef6a87c95ea0805e47313ab2730b6278505 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 15:27:56 -0700 Subject: [PATCH 088/272] Fix region id normalization for contrast joins --- dimelo/workflows.py | 7 +++++++ tests/test_workflows.py | 14 +++++++------- 2 files changed, 14 insertions(+), 7 deletions(-) diff --git a/dimelo/workflows.py b/dimelo/workflows.py index b337b72..6e5a147 100644 --- a/dimelo/workflows.py +++ b/dimelo/workflows.py @@ -387,6 +387,13 @@ def _normalize_region_id_value( if region_id_str in default_region_ids: return default_region_ids[region_id_str] + if "," not in region_id_str and region_id_str.count(":") >= 2: + region_core, strand = region_id_str.rsplit(":", 1) + strand_value = strand if strand in {"+", "-", "."} else "." + if region_core in default_region_ids: + return default_region_ids[region_core] + return f"{region_core},{strand_value}" + chrom = row.get("chromosome", row.get("chrom")) start = row.get("start") end = row.get("end") diff --git a/tests/test_workflows.py b/tests/test_workflows.py index bf7f962..1867119 100644 --- a/tests/test_workflows.py +++ b/tests/test_workflows.py @@ -557,25 +557,23 @@ def fake_cluster(**kwargs): result.assignments = pd.DataFrame( [ { - "region_id": "chr1:0-500", + "region_id": "chr1:0-500:+", "sample_id": "s1", "condition": "NS", "cluster": "C0", - "strand": "+", }, { - "region_id": "chr1:500-1000", + "region_id": "chr1:500-1000:-", "sample_id": "s2", "condition": "15min", "cluster": "C1", - "strand": "-", }, ] ) result.region_summaries = pd.DataFrame( [ { - "region_id": "chr1:0-500", + "region_id": "chr1:0-500:+", "sample_id": "s1", "condition": "NS", "cluster": "C0", @@ -583,7 +581,7 @@ def fake_cluster(**kwargs): "fraction": 1.0, }, { - "region_id": "chr1:500-1000", + "region_id": "chr1:500-1000:-", "sample_id": "s2", "condition": "15min", "cluster": "C1", @@ -617,7 +615,9 @@ def fake_cluster(**kwargs): contrast_region_ids = set(result.contrasts.regions["region_id"]) assert set(result.clustering.assignments["region_id"]) == contrast_region_ids assert set(result.clustering.region_summaries["region_id"]) == contrast_region_ids - assert "strand" not in result.clustering.region_summaries.columns + assert set(result.clustering.assignments["region_id"]) == set( + result.clustering.region_summaries["region_id"] + ) def test_discovery_cluster_contrast_workflow_uses_custom_contrast_regions_when_provided( From b23f41b7fd5457cb160a48971f6131e9fd39d6c3 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 17:30:19 -0700 Subject: [PATCH 089/272] feat: add cluster occupancy evidence builder --- dimelo/region_contrasts.py | 105 ++++++++++++++++++++++++++++----- tests/test_region_contrasts.py | 82 +++++++++++++++++++++++++ 2 files changed, 173 insertions(+), 14 deletions(-) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index cdc33f5..7d65bfa 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -17,24 +17,48 @@ def validate_region_contrast_request( signal_source: str, test: str, ) -> None: + if analysis_unit == "ensemble_region": + if signal_source != "pileup_counts": + raise ValueError( + "V1 region_contrasts inference requires signal_source='pileup_counts'." + ) + if representation not in {"modified_fraction", "modified_count"}: + raise ValueError( + "V1 region_contrasts inference requires representation to be " + "'modified_fraction' or 'modified_count'." + ) + if test not in {"effect_size_only", "beta_binomial"}: + raise ValueError( + "Current region_contrasts scoring support requires test in " + "{'effect_size_only', 'beta_binomial'}." + ) + return + + if analysis_unit == "cluster_occupancy": + if signal_source != "cluster_occupancy": + raise ValueError( + "V1 region_contrasts inference requires signal_source='cluster_occupancy'." + ) + if representation not in { + "cluster_fraction", + "dominant_cluster", + "cluster_entropy", + }: + raise ValueError( + "V1 region_contrasts inference requires representation to be " + "'cluster_fraction', 'dominant_cluster', or 'cluster_entropy'." + ) + if test not in {"effect_size_only", "fraction_test"}: + raise ValueError( + "Current cluster_occupancy scoring support requires test in " + "{'effect_size_only', 'fraction_test'}." + ) + return + if analysis_unit != "ensemble_region": raise ValueError( "V1 region_contrasts inference requires analysis_unit='ensemble_region'." ) - if signal_source != "pileup_counts": - raise ValueError( - "V1 region_contrasts inference requires signal_source='pileup_counts'." - ) - if representation not in {"modified_fraction", "modified_count"}: - raise ValueError( - "V1 region_contrasts inference requires representation to be " - "'modified_fraction' or 'modified_count'." - ) - if test not in {"effect_size_only", "beta_binomial"}: - raise ValueError( - "Current region_contrasts scoring support requires test in " - "{'effect_size_only', 'beta_binomial'}." - ) def build_region_evidence_table( @@ -108,6 +132,59 @@ def build_region_evidence_table( return pd.DataFrame(rows) +def build_cluster_occupancy_evidence_table( + *, + region_summaries: pd.DataFrame, +) -> pd.DataFrame: + required_columns = {"region_id", "sample_id", "condition", "cluster", "count"} + missing_columns = required_columns - set(region_summaries.columns) + if missing_columns: + missing_display = ", ".join(sorted(missing_columns)) + raise ValueError( + "build_cluster_occupancy_evidence_table requires columns: " + f"{missing_display}." + ) + + evidence = region_summaries.copy() + grouped_keys = ["region_id", "sample_id", "condition"] + totals = evidence.groupby(grouped_keys, dropna=False)["count"].transform("sum") + evidence["fraction"] = ( + evidence["count"].div(totals.where(totals != 0), fill_value=0).fillna(0.0) + ) + + summary = ( + evidence.sort_values( + by=grouped_keys + ["fraction", "cluster"], + ascending=[True, True, True, False, True], + kind="mergesort", + ) + .drop_duplicates(subset=grouped_keys, keep="first") + .loc[:, grouped_keys + ["cluster"]] + .rename(columns={"cluster": "dominant_cluster"}) + ) + + def _cluster_entropy(values: pd.Series) -> float: + probabilities = values.astype(float) + if probabilities.empty: + return 0.0 + probabilities = probabilities[probabilities > 0] + if probabilities.empty: + return 0.0 + return float(-(probabilities * probabilities.map(math.log2)).sum()) + + entropy = ( + evidence.groupby(grouped_keys, dropna=False)["fraction"] + .apply(_cluster_entropy) + .reset_index(name="cluster_entropy") + ) + + return evidence.merge(summary, on=grouped_keys, how="left").merge( + entropy, + on=grouped_keys, + how="left", + ) + + def _zero_safe_divide(numerator: pd.Series, denominator: pd.Series) -> pd.Series: return numerator.div(denominator.where(denominator != 0), fill_value=0).fillna(0.0) diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index 0537ef5..e94202f 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -25,6 +25,25 @@ def test_validate_accepts_beta_binomial_for_supported_v1_combination(): ) +def test_validate_region_contrast_request_accepts_cluster_occupancy_fraction_mode(): + region_contrasts.validate_region_contrast_request( + analysis_unit="cluster_occupancy", + representation="cluster_fraction", + signal_source="cluster_occupancy", + test="effect_size_only", + ) + + +def test_validate_region_contrast_request_rejects_beta_binomial_for_cluster_occupancy(): + with pytest.raises(ValueError, match="cluster_occupancy"): + region_contrasts.validate_region_contrast_request( + analysis_unit="cluster_occupancy", + representation="cluster_fraction", + signal_source="cluster_occupancy", + test="beta_binomial", + ) + + def test_validate_rejects_unsupported_single_read_beta_binomial(): with pytest.raises(ValueError, match="analysis_unit='ensemble_region'"): region_contrasts.validate_region_contrast_request( @@ -35,6 +54,69 @@ def test_validate_rejects_unsupported_single_read_beta_binomial(): ) +def _mock_region_summaries(): + return pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "cluster": "C1", + "count": 6, + "fraction": 0.6, + }, + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "cluster": "C2", + "count": 4, + "fraction": 0.4, + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "15min", + "cluster": "C1", + "count": 1, + "fraction": 0.2, + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "15min", + "cluster": "C2", + "count": 4, + "fraction": 0.8, + }, + { + "region_id": "reg2", + "sample_id": "s1", + "condition": "NS", + "cluster": "C3", + "count": 5, + "fraction": 1.0, + }, + ] + ) + + +def test_build_cluster_occupancy_evidence_table_summarizes_region_sample_clusters(): + evidence = region_contrasts.build_cluster_occupancy_evidence_table( + region_summaries=_mock_region_summaries(), + ) + + assert { + "region_id", + "sample_id", + "condition", + "cluster", + "fraction", + "dominant_cluster", + "cluster_entropy", + } <= set(evidence.columns) + + def test_build_region_evidence_table_from_pileup_counts(monkeypatch): samples = [ SampleSpec( From cc6f03895f1b6b5eed415aca2646c78add59bc76 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 17:37:45 -0700 Subject: [PATCH 090/272] feat: add cluster occupancy region scoring --- dimelo/region_contrasts.py | 397 ++++++++++++++++++++++++++++++++- tests/test_region_contrasts.py | 297 ++++++++++++++++++++++++ 2 files changed, 689 insertions(+), 5 deletions(-) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index 7d65bfa..4bfb3c0 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -5,6 +5,7 @@ from typing import Iterable import pandas as pd +from scipy import stats from . import load_processed, utils from .models import ContrastSpec, RegionContrastResult @@ -48,16 +49,28 @@ def validate_region_contrast_request( "V1 region_contrasts inference requires representation to be " "'cluster_fraction', 'dominant_cluster', or 'cluster_entropy'." ) - if test not in {"effect_size_only", "fraction_test"}: + if representation == "cluster_fraction" and test not in { + "effect_size_only", + "fraction_test", + }: raise ValueError( - "Current cluster_occupancy scoring support requires test in " + "Current cluster_occupancy cluster_fraction scoring support requires " + "test in " "{'effect_size_only', 'fraction_test'}." ) + if representation in {"dominant_cluster", "cluster_entropy"} and test != ( + "effect_size_only" + ): + raise ValueError( + "Current cluster_occupancy descriptive scoring requires " + "representation='cluster_fraction' for inferential tests." + ) return - if analysis_unit != "ensemble_region": + if analysis_unit not in {"ensemble_region", "cluster_occupancy"}: raise ValueError( - "V1 region_contrasts inference requires analysis_unit='ensemble_region'." + "V1 region_contrasts inference requires analysis_unit='ensemble_region' " + "or analysis_unit='cluster_occupancy'." ) @@ -336,6 +349,343 @@ def _pool_region_groups(evidence: pd.DataFrame, contrast: ContrastSpec) -> pd.Da return pd.concat(pooled_frames, ignore_index=True) +def _require_occupancy_columns( + occupancy_table: pd.DataFrame, + *, + required_columns: set[str], +) -> None: + missing_columns = required_columns - set(occupancy_table.columns) + if missing_columns: + missing_display = ", ".join(sorted(missing_columns)) + raise ValueError(f"occupancy_table requires columns: {missing_display}.") + + +def _pool_cluster_occupancy_groups( + evidence: pd.DataFrame, + contrast: ContrastSpec, + *, + value_column: str, + group_columns: list[str], +) -> pd.DataFrame: + if contrast.mode not in {"pairwise", "group_vs_group"}: + raise NotImplementedError( + f"Cluster occupancy scoring is not implemented for contrast mode '{contrast.mode}'." + ) + + pooled_frames = [] + side_specs = { + "numerator": contrast.numerator or [], + "denominator": contrast.denominator or [], + } + + for side, conditions in side_specs.items(): + side_evidence = evidence.loc[evidence["condition"].isin(conditions)].copy() + available_conditions = set(side_evidence["condition"].dropna().unique()) + missing_conditions = sorted(set(conditions) - available_conditions) + if missing_conditions: + missing_display = ", ".join(missing_conditions) + raise ValueError( + f"Missing {side} evidence for requested condition(s): {missing_display}." + ) + + pooled = ( + side_evidence.groupby(group_columns, dropna=False, sort=False) + .agg( + value=(value_column, "mean"), + replicate_n=("sample_id", "nunique"), + sample_values=(value_column, lambda values: tuple(float(v) for v in values)), + ) + .reset_index() + .assign(contrast_side=side) + ) + pooled_frames.append(pooled) + + return pd.concat(pooled_frames, ignore_index=True) + + +def _add_fraction_test_scores( + regions_table: pd.DataFrame, + *, + multiple_testing: str, +) -> pd.DataFrame: + if multiple_testing != "fdr_bh": + raise ValueError( + "Current fraction_test region contrast scoring requires " + "multiple_testing='fdr_bh'." + ) + + def _welch_p_value(row: pd.Series) -> float: + numerator_values = list(row["numerator_sample_values"]) + denominator_values = list(row["denominator_sample_values"]) + if len(numerator_values) < 2 or len(denominator_values) < 2: + return 1.0 + + test_result = stats.ttest_ind( + numerator_values, + denominator_values, + equal_var=False, + ) + p_value = float(test_result.pvalue) + if math.isnan(p_value): + return 1.0 + return min(max(p_value, 0.0), 1.0) + + scored = regions_table.copy() + scored["p_value"] = scored.apply(_welch_p_value, axis=1) + scored["adjusted_p_value"] = _adjust_p_values_bh(scored["p_value"]) + return scored + + +def _dominant_label(values: pd.Series) -> str | None: + non_null = values.dropna() + if non_null.empty: + return None + counts = non_null.value_counts() + max_count = counts.max() + return sorted(counts[counts == max_count].index.tolist())[0] + + +def _score_cluster_occupancy( + *, + evidence: pd.DataFrame, + contrast: ContrastSpec, + representation: str, + test: str, + multiple_testing: str, +) -> tuple[pd.DataFrame, pd.DataFrame]: + pseudocount = 1e-6 + + if representation == "cluster_fraction": + _require_occupancy_columns( + evidence, + required_columns={"region_id", "sample_id", "condition", "cluster", "fraction"}, + ) + pooled = _pool_cluster_occupancy_groups( + evidence, + contrast, + value_column="fraction", + group_columns=["region_id", "cluster"], + ) + numerator = ( + pooled.loc[pooled["contrast_side"] == "numerator"] + .drop(columns=["contrast_side"]) + .rename( + columns={ + "value": "fraction", + "replicate_n": "numerator_replicate_n", + "sample_values": "numerator_sample_values", + } + ) + ) + denominator = ( + pooled.loc[pooled["contrast_side"] == "denominator"] + .drop(columns=["contrast_side"]) + .rename( + columns={ + "value": "reference_fraction", + "replicate_n": "denominator_replicate_n", + "sample_values": "denominator_sample_values", + } + ) + ) + regions_table = numerator.merge( + denominator, + on=["region_id", "cluster"], + how="outer", + sort=False, + ) + regions_table["fraction"] = regions_table["fraction"].fillna(0.0) + regions_table["reference_fraction"] = regions_table["reference_fraction"].fillna(0.0) + regions_table["numerator_replicate_n"] = ( + regions_table["numerator_replicate_n"].fillna(0).astype(int) + ) + regions_table["denominator_replicate_n"] = ( + regions_table["denominator_replicate_n"].fillna(0).astype(int) + ) + regions_table["numerator_sample_values"] = regions_table[ + "numerator_sample_values" + ].apply(lambda values: values if isinstance(values, tuple) else tuple()) + regions_table["denominator_sample_values"] = regions_table[ + "denominator_sample_values" + ].apply(lambda values: values if isinstance(values, tuple) else tuple()) + regions_table["delta_fraction"] = ( + regions_table["fraction"] - regions_table["reference_fraction"] + ) + regions_table["log2_fc"] = ( + (regions_table["fraction"] + pseudocount) + / (regions_table["reference_fraction"] + pseudocount) + ).map(math.log2) + regions_table["effect_size"] = regions_table["delta_fraction"].abs() + + if test == "fraction_test": + regions_table = _add_fraction_test_scores( + regions_table, + multiple_testing=multiple_testing, + ) + regions_table = regions_table.sort_values( + by=["adjusted_p_value", "p_value", "effect_size", "region_id", "cluster"], + ascending=[True, True, False, True, True], + kind="mergesort", + ).reset_index(drop=True) + else: + regions_table = regions_table.sort_values( + by=["effect_size", "delta_fraction", "region_id", "cluster"], + ascending=[False, False, True, True], + kind="mergesort", + ).reset_index(drop=True) + regions_table["rank"] = range(1, len(regions_table) + 1) + + summary_columns = [ + "region_id", + "cluster", + "fraction", + "reference_fraction", + "delta_fraction", + "log2_fc", + "rank", + "numerator_replicate_n", + "denominator_replicate_n", + ] + if test == "fraction_test": + summary_columns.extend(["p_value", "adjusted_p_value"]) + summary = regions_table.loc[:, summary_columns].copy() + return regions_table, summary + + if representation == "dominant_cluster": + _require_occupancy_columns( + evidence, + required_columns={"region_id", "sample_id", "condition", "dominant_cluster"}, + ) + pooled = ( + evidence.loc[:, ["region_id", "sample_id", "condition", "dominant_cluster"]] + .drop_duplicates() + .groupby(["region_id", "condition"], dropna=False, sort=False) + .agg( + dominant_cluster=("dominant_cluster", _dominant_label), + replicate_n=("sample_id", "nunique"), + ) + .reset_index() + ) + numerator = ( + pooled.loc[pooled["condition"].isin(contrast.numerator or [])] + .groupby("region_id", dropna=False, sort=False) + .agg( + dominant_cluster=("dominant_cluster", _dominant_label), + numerator_replicate_n=("replicate_n", "sum"), + ) + .reset_index() + ) + denominator = ( + pooled.loc[pooled["condition"].isin(contrast.denominator or [])] + .groupby("region_id", dropna=False, sort=False) + .agg( + reference_dominant_cluster=("dominant_cluster", _dominant_label), + denominator_replicate_n=("replicate_n", "sum"), + ) + .reset_index() + ) + regions_table = numerator.merge( + denominator, + on="region_id", + how="outer", + sort=False, + ) + regions_table["dominant_cluster_changed"] = ( + regions_table["dominant_cluster"] != regions_table["reference_dominant_cluster"] + ) + regions_table["effect_size"] = regions_table["dominant_cluster_changed"].astype(int) + regions_table = regions_table.sort_values( + by=["effect_size", "region_id"], + ascending=[False, True], + kind="mergesort", + ).reset_index(drop=True) + regions_table["rank"] = range(1, len(regions_table) + 1) + summary = regions_table.loc[ + :, + [ + "region_id", + "dominant_cluster", + "reference_dominant_cluster", + "dominant_cluster_changed", + "rank", + "numerator_replicate_n", + "denominator_replicate_n", + ], + ].copy() + return regions_table, summary + + _require_occupancy_columns( + evidence, + required_columns={"region_id", "sample_id", "condition", "cluster_entropy"}, + ) + pooled = _pool_cluster_occupancy_groups( + evidence.loc[:, ["region_id", "sample_id", "condition", "cluster_entropy"]] + .drop_duplicates(), + contrast, + value_column="cluster_entropy", + group_columns=["region_id"], + ) + numerator = ( + pooled.loc[pooled["contrast_side"] == "numerator"] + .drop(columns=["contrast_side", "sample_values"]) + .rename( + columns={ + "value": "cluster_entropy", + "replicate_n": "numerator_replicate_n", + } + ) + ) + denominator = ( + pooled.loc[pooled["contrast_side"] == "denominator"] + .drop(columns=["contrast_side", "sample_values"]) + .rename( + columns={ + "value": "reference_cluster_entropy", + "replicate_n": "denominator_replicate_n", + } + ) + ) + regions_table = numerator.merge( + denominator, + on="region_id", + how="outer", + sort=False, + ) + regions_table["cluster_entropy"] = regions_table["cluster_entropy"].fillna(0.0) + regions_table["reference_cluster_entropy"] = regions_table[ + "reference_cluster_entropy" + ].fillna(0.0) + regions_table["numerator_replicate_n"] = ( + regions_table["numerator_replicate_n"].fillna(0).astype(int) + ) + regions_table["denominator_replicate_n"] = ( + regions_table["denominator_replicate_n"].fillna(0).astype(int) + ) + regions_table["delta_cluster_entropy"] = ( + regions_table["cluster_entropy"] - regions_table["reference_cluster_entropy"] + ) + regions_table["effect_size"] = regions_table["delta_cluster_entropy"].abs() + regions_table = regions_table.sort_values( + by=["effect_size", "region_id"], + ascending=[False, True], + kind="mergesort", + ).reset_index(drop=True) + regions_table["rank"] = range(1, len(regions_table) + 1) + summary = regions_table.loc[ + :, + [ + "region_id", + "cluster_entropy", + "reference_cluster_entropy", + "delta_cluster_entropy", + "rank", + "numerator_replicate_n", + "denominator_replicate_n", + ], + ].copy() + return regions_table, summary + + def score_regions( *, samples, @@ -347,6 +697,7 @@ def score_regions( signal_source: str = "pileup_counts", test: str = "effect_size_only", multiple_testing: str = "fdr_bh", + occupancy_table: pd.DataFrame | None = None, ) -> RegionContrastResult: validate_region_contrast_request( analysis_unit=analysis_unit, @@ -354,6 +705,43 @@ def score_regions( signal_source=signal_source, test=test, ) + contrast_metadata = contrast.metadata or {} + + if analysis_unit == "cluster_occupancy": + if occupancy_table is None: + raise ValueError( + "cluster_occupancy scoring currently requires occupancy_table." + ) + regions_table, summary = _score_cluster_occupancy( + evidence=occupancy_table.copy(), + contrast=contrast, + representation=representation, + test=test, + multiple_testing=multiple_testing, + ) + metadata = { + "contrast_mode": contrast.mode, + "analysis_unit": analysis_unit, + "representation": representation, + "signal_source": signal_source, + "test": test, + "multiple_testing": multiple_testing, + "normalization_mode": contrast_metadata.get("normalization_mode", "none"), + "biological_interpretation": contrast_metadata.get( + "biological_interpretation", + "region-level difference in sample-level cluster occupancy", + ), + "renderer": contrast_metadata.get("renderer", "region_effect_sizes"), + } + return RegionContrastResult( + regions=regions_table, + summary=summary, + contrast=contrast, + plot_data={"region_effect_sizes": summary.copy()}, + metadata=metadata, + figures={}, + ) + evidence = build_region_evidence_table( samples=samples, regions=regions, @@ -470,7 +858,6 @@ def score_regions( summary_columns.extend(["count", "reference_count", "delta_count", "log2_fc_count"]) summary = regions_table.loc[:, summary_columns].copy() - contrast_metadata = contrast.metadata or {} metadata = { "contrast_mode": contrast.mode, "analysis_unit": analysis_unit, diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index e94202f..7d9186b 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -101,6 +101,128 @@ def _mock_region_summaries(): ) +def _mock_cluster_occupancy_evidence(): + region_summaries = pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "ns1", + "condition": "NS", + "cluster": "C1", + "count": 2, + }, + { + "region_id": "reg1", + "sample_id": "ns1", + "condition": "NS", + "cluster": "C2", + "count": 8, + }, + { + "region_id": "reg1", + "sample_id": "ns2", + "condition": "NS", + "cluster": "C1", + "count": 3, + }, + { + "region_id": "reg1", + "sample_id": "ns2", + "condition": "NS", + "cluster": "C2", + "count": 7, + }, + { + "region_id": "reg1", + "sample_id": "tx1", + "condition": "15min", + "cluster": "C1", + "count": 8, + }, + { + "region_id": "reg1", + "sample_id": "tx1", + "condition": "15min", + "cluster": "C2", + "count": 2, + }, + { + "region_id": "reg1", + "sample_id": "tx2", + "condition": "15min", + "cluster": "C1", + "count": 7, + }, + { + "region_id": "reg1", + "sample_id": "tx2", + "condition": "15min", + "cluster": "C2", + "count": 3, + }, + { + "region_id": "reg2", + "sample_id": "ns1", + "condition": "NS", + "cluster": "C1", + "count": 0, + }, + { + "region_id": "reg2", + "sample_id": "ns1", + "condition": "NS", + "cluster": "C2", + "count": 0, + }, + { + "region_id": "reg2", + "sample_id": "ns2", + "condition": "NS", + "cluster": "C1", + "count": 0, + }, + { + "region_id": "reg2", + "sample_id": "ns2", + "condition": "NS", + "cluster": "C2", + "count": 0, + }, + { + "region_id": "reg2", + "sample_id": "tx1", + "condition": "15min", + "cluster": "C1", + "count": 10, + }, + { + "region_id": "reg2", + "sample_id": "tx1", + "condition": "15min", + "cluster": "C2", + "count": 0, + }, + { + "region_id": "reg2", + "sample_id": "tx2", + "condition": "15min", + "cluster": "C1", + "count": 0, + }, + { + "region_id": "reg2", + "sample_id": "tx2", + "condition": "15min", + "cluster": "C2", + "count": 0, + }, + ] + ) + return region_contrasts.build_cluster_occupancy_evidence_table( + region_summaries=region_summaries, + ) + + def test_build_cluster_occupancy_evidence_table_summarizes_region_sample_clusters(): evidence = region_contrasts.build_cluster_occupancy_evidence_table( region_summaries=_mock_region_summaries(), @@ -117,6 +239,32 @@ def test_build_cluster_occupancy_evidence_table_summarizes_region_sample_cluster } <= set(evidence.columns) +def test_build_cluster_occupancy_evidence_table_computes_fraction_dominant_and_entropy(): + evidence = _mock_cluster_occupancy_evidence() + + reg1_ns1_c1 = evidence[ + (evidence["region_id"] == "reg1") + & (evidence["sample_id"] == "ns1") + & (evidence["cluster"] == "C1") + ].iloc[0] + assert reg1_ns1_c1["fraction"] == pytest.approx(0.2) + assert reg1_ns1_c1["dominant_cluster"] == "C2" + assert reg1_ns1_c1["cluster_entropy"] == pytest.approx( + -(0.2 * math.log2(0.2) + 0.8 * math.log2(0.8)) + ) + + +def test_build_cluster_occupancy_evidence_table_zero_count_groups_stay_zero_entropy(): + evidence = _mock_cluster_occupancy_evidence() + + reg2_ns1 = evidence[ + (evidence["region_id"] == "reg2") & (evidence["sample_id"] == "ns1") + ] + assert list(reg2_ns1["fraction"]) == [0.0, 0.0] + assert reg2_ns1["dominant_cluster"].tolist() == ["C1", "C1"] + assert reg2_ns1["cluster_entropy"].tolist() == [0.0, 0.0] + + def test_build_region_evidence_table_from_pileup_counts(monkeypatch): samples = [ SampleSpec( @@ -1145,3 +1293,152 @@ def test_score_regions_effect_size_only_rejects_unsupported_contrast_mode(monkey contrast=contrast, test="effect_size_only", ) + + +def test_score_regions_cluster_fraction_effect_size_only_ranks_largest_fraction_shift_first(): + result = region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec(mode="pairwise", numerator=["15min"], denominator=["NS"]), + analysis_unit="cluster_occupancy", + representation="cluster_fraction", + signal_source="cluster_occupancy", + test="effect_size_only", + occupancy_table=_mock_cluster_occupancy_evidence(), + ) + + first_row = result.regions.iloc[0] + assert first_row["region_id"] == "reg1" + assert first_row["cluster"] == "C1" + assert first_row["fraction"] == pytest.approx(0.75) + assert first_row["reference_fraction"] == pytest.approx(0.25) + assert first_row["delta_fraction"] == pytest.approx(0.5) + assert first_row["numerator_replicate_n"] == 2 + assert first_row["denominator_replicate_n"] == 2 + assert result.summary.iloc[0]["delta_fraction"] == pytest.approx(0.5) + + +def test_score_regions_cluster_fraction_fraction_test_adds_p_values(): + result = region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec(mode="pairwise", numerator=["15min"], denominator=["NS"]), + analysis_unit="cluster_occupancy", + representation="cluster_fraction", + signal_source="cluster_occupancy", + test="fraction_test", + occupancy_table=_mock_cluster_occupancy_evidence(), + ) + + assert {"p_value", "adjusted_p_value"} <= set(result.regions.columns) + assert ((result.regions["p_value"] >= 0) & (result.regions["p_value"] <= 1)).all() + assert ( + (result.regions["adjusted_p_value"] >= 0) + & (result.regions["adjusted_p_value"] <= 1) + ).all() + + +def test_score_regions_cluster_occupancy_dominant_cluster_returns_descriptive_summary_only(): + result = region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec(mode="pairwise", numerator=["15min"], denominator=["NS"]), + analysis_unit="cluster_occupancy", + representation="dominant_cluster", + signal_source="cluster_occupancy", + test="effect_size_only", + occupancy_table=_mock_cluster_occupancy_evidence(), + ) + + reg1 = result.summary.loc[result.summary["region_id"] == "reg1"].iloc[0] + reg2 = result.summary.loc[result.summary["region_id"] == "reg2"].iloc[0] + assert reg1["dominant_cluster"] == "C1" + assert reg1["reference_dominant_cluster"] == "C2" + assert reg2["dominant_cluster"] == "C1" + assert reg2["reference_dominant_cluster"] == "C1" + assert "p_value" not in result.regions.columns + + +def test_score_regions_cluster_occupancy_cluster_entropy_returns_descriptive_summary_only(): + result = region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec(mode="pairwise", numerator=["15min"], denominator=["NS"]), + analysis_unit="cluster_occupancy", + representation="cluster_entropy", + signal_source="cluster_occupancy", + test="effect_size_only", + occupancy_table=_mock_cluster_occupancy_evidence(), + ) + + reg1 = result.summary.loc[result.summary["region_id"] == "reg1"].iloc[0] + reg2 = result.summary.loc[result.summary["region_id"] == "reg2"].iloc[0] + expected_entropy = ( + -( + 0.8 * math.log2(0.8) + + 0.2 * math.log2(0.2) + + 0.7 * math.log2(0.7) + + 0.3 * math.log2(0.3) + ) + / 2.0 + ) + assert reg1["cluster_entropy"] == pytest.approx(expected_entropy) + assert reg1["reference_cluster_entropy"] == pytest.approx(expected_entropy) + assert reg1["delta_cluster_entropy"] == pytest.approx(0.0) + assert reg2["cluster_entropy"] == pytest.approx(0.0) + assert reg2["reference_cluster_entropy"] == pytest.approx(0.0) + assert "p_value" not in result.regions.columns + + +def test_score_regions_cluster_occupancy_rejects_matched_pairwise(): + with pytest.raises(NotImplementedError, match="matched_pairwise"): + region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["15min"], + denominator=["NS"], + pairing_key="donor_id", + ), + analysis_unit="cluster_occupancy", + representation="cluster_fraction", + signal_source="cluster_occupancy", + test="effect_size_only", + occupancy_table=_mock_cluster_occupancy_evidence(), + ) + + +def test_score_regions_cluster_occupancy_rejects_fraction_test_for_dominant_cluster(): + with pytest.raises(ValueError, match="cluster_fraction"): + region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec(mode="pairwise", numerator=["15min"], denominator=["NS"]), + analysis_unit="cluster_occupancy", + representation="dominant_cluster", + signal_source="cluster_occupancy", + test="fraction_test", + occupancy_table=_mock_cluster_occupancy_evidence(), + ) + + +def test_score_regions_cluster_occupancy_rejects_missing_occupancy_columns(): + with pytest.raises(ValueError, match="occupancy_table requires columns"): + region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec(mode="pairwise", numerator=["15min"], denominator=["NS"]), + analysis_unit="cluster_occupancy", + representation="cluster_fraction", + signal_source="cluster_occupancy", + test="effect_size_only", + occupancy_table=pd.DataFrame({"region_id": ["reg1"]}), + ) From f99b548346af39a14b7e54d3cafc95a8034e73de Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 17:41:34 -0700 Subject: [PATCH 091/272] Fix cluster occupancy contrast mode validation --- dimelo/region_contrasts.py | 13 ++-- tests/test_region_contrasts.py | 115 +++++++++++++++++++++++++++++++++ 2 files changed, 124 insertions(+), 4 deletions(-) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index 4bfb3c0..245bd45 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -360,6 +360,13 @@ def _require_occupancy_columns( raise ValueError(f"occupancy_table requires columns: {missing_display}.") +def _require_supported_cluster_occupancy_mode(contrast: ContrastSpec) -> None: + if contrast.mode not in {"pairwise", "group_vs_group"}: + raise NotImplementedError( + f"Cluster occupancy scoring is not implemented for contrast mode '{contrast.mode}'." + ) + + def _pool_cluster_occupancy_groups( evidence: pd.DataFrame, contrast: ContrastSpec, @@ -367,10 +374,7 @@ def _pool_cluster_occupancy_groups( value_column: str, group_columns: list[str], ) -> pd.DataFrame: - if contrast.mode not in {"pairwise", "group_vs_group"}: - raise NotImplementedError( - f"Cluster occupancy scoring is not implemented for contrast mode '{contrast.mode}'." - ) + _require_supported_cluster_occupancy_mode(contrast) pooled_frames = [] side_specs = { @@ -454,6 +458,7 @@ def _score_cluster_occupancy( multiple_testing: str, ) -> tuple[pd.DataFrame, pd.DataFrame]: pseudocount = 1e-6 + _require_supported_cluster_occupancy_mode(contrast) if representation == "cluster_fraction": _require_occupancy_columns( diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index 7d9186b..69ec9ee 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -223,6 +223,69 @@ def _mock_cluster_occupancy_evidence(): ) +def _mock_group_vs_group_cluster_fraction_evidence(): + return pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "na1", + "condition": "treated_a", + "cluster": "C1", + "fraction": 0.2, + }, + { + "region_id": "reg1", + "sample_id": "na2", + "condition": "treated_a", + "cluster": "C1", + "fraction": 0.4, + }, + { + "region_id": "reg1", + "sample_id": "nb1", + "condition": "treated_b", + "cluster": "C1", + "fraction": 0.8, + }, + { + "region_id": "reg1", + "sample_id": "nb2", + "condition": "treated_b", + "cluster": "C1", + "fraction": 1.0, + }, + { + "region_id": "reg1", + "sample_id": "ca1", + "condition": "control_a", + "cluster": "C1", + "fraction": 0.0, + }, + { + "region_id": "reg1", + "sample_id": "ca2", + "condition": "control_a", + "cluster": "C1", + "fraction": 0.2, + }, + { + "region_id": "reg1", + "sample_id": "cb1", + "condition": "control_b", + "cluster": "C1", + "fraction": 0.4, + }, + { + "region_id": "reg1", + "sample_id": "cb2", + "condition": "control_b", + "cluster": "C1", + "fraction": 0.6, + }, + ] + ) + + def test_build_cluster_occupancy_evidence_table_summarizes_region_sample_clusters(): evidence = region_contrasts.build_cluster_occupancy_evidence_table( region_summaries=_mock_region_summaries(), @@ -1414,6 +1477,32 @@ def test_score_regions_cluster_occupancy_rejects_matched_pairwise(): ) +@pytest.mark.parametrize( + "representation", + ["cluster_fraction", "dominant_cluster", "cluster_entropy"], +) +def test_score_regions_cluster_occupancy_rejects_unsupported_contrast_modes_for_all_representations( + representation, +): + with pytest.raises(NotImplementedError, match="matched_pairwise"): + region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["15min"], + denominator=["NS"], + pairing_key="donor_id", + ), + analysis_unit="cluster_occupancy", + representation=representation, + signal_source="cluster_occupancy", + test="effect_size_only", + occupancy_table=_mock_cluster_occupancy_evidence(), + ) + + def test_score_regions_cluster_occupancy_rejects_fraction_test_for_dominant_cluster(): with pytest.raises(ValueError, match="cluster_fraction"): region_contrasts.score_regions( @@ -1429,6 +1518,32 @@ def test_score_regions_cluster_occupancy_rejects_fraction_test_for_dominant_clus ) +def test_score_regions_cluster_occupancy_group_vs_group_aggregates_condition_groups(): + result = region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec( + mode="group_vs_group", + numerator=["treated_a", "treated_b"], + denominator=["control_a", "control_b"], + ), + analysis_unit="cluster_occupancy", + representation="cluster_fraction", + signal_source="cluster_occupancy", + test="effect_size_only", + occupancy_table=_mock_group_vs_group_cluster_fraction_evidence(), + ) + + row = result.regions.iloc[0] + assert row["fraction"] == pytest.approx(0.6) + assert row["reference_fraction"] == pytest.approx(0.3) + assert row["delta_fraction"] == pytest.approx(0.3) + assert row["numerator_replicate_n"] == 4 + assert row["denominator_replicate_n"] == 4 + assert result.summary.iloc[0]["delta_fraction"] == pytest.approx(0.3) + + def test_score_regions_cluster_occupancy_rejects_missing_occupancy_columns(): with pytest.raises(ValueError, match="occupancy_table requires columns"): region_contrasts.score_regions( From 2f0f3cd2e121f81e079d31a064d99d4fa19d4035 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 17:46:24 -0700 Subject: [PATCH 092/272] Fix cluster occupancy validation and dominant cluster weighting --- dimelo/region_contrasts.py | 28 ++++++------ tests/test_region_contrasts.py | 78 ++++++++++++++++++++++++++++++++++ 2 files changed, 92 insertions(+), 14 deletions(-) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index 245bd45..9260c44 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -159,6 +159,13 @@ def build_cluster_occupancy_evidence_table( ) evidence = region_summaries.copy() + counts = pd.to_numeric(evidence["count"], errors="raise") + invalid_counts = counts.isna() | (counts < 0) | ~counts.map(math.isfinite) + if invalid_counts.any(): + raise ValueError( + "build_cluster_occupancy_evidence_table count values must be finite and >= 0." + ) + grouped_keys = ["region_id", "sample_id", "condition"] totals = evidence.groupby(grouped_keys, dropna=False)["count"].transform("sum") evidence["fraction"] = ( @@ -561,31 +568,24 @@ def _score_cluster_occupancy( evidence, required_columns={"region_id", "sample_id", "condition", "dominant_cluster"}, ) - pooled = ( - evidence.loc[:, ["region_id", "sample_id", "condition", "dominant_cluster"]] - .drop_duplicates() - .groupby(["region_id", "condition"], dropna=False, sort=False) - .agg( - dominant_cluster=("dominant_cluster", _dominant_label), - replicate_n=("sample_id", "nunique"), - ) - .reset_index() - ) + sample_level = evidence.loc[ + :, ["region_id", "sample_id", "condition", "dominant_cluster"] + ].drop_duplicates() numerator = ( - pooled.loc[pooled["condition"].isin(contrast.numerator or [])] + sample_level.loc[sample_level["condition"].isin(contrast.numerator or [])] .groupby("region_id", dropna=False, sort=False) .agg( dominant_cluster=("dominant_cluster", _dominant_label), - numerator_replicate_n=("replicate_n", "sum"), + numerator_replicate_n=("sample_id", "nunique"), ) .reset_index() ) denominator = ( - pooled.loc[pooled["condition"].isin(contrast.denominator or [])] + sample_level.loc[sample_level["condition"].isin(contrast.denominator or [])] .groupby("region_id", dropna=False, sort=False) .agg( reference_dominant_cluster=("dominant_cluster", _dominant_label), - denominator_replicate_n=("replicate_n", "sum"), + denominator_replicate_n=("sample_id", "nunique"), ) .reset_index() ) diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index 69ec9ee..6e5e450 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -328,6 +328,24 @@ def test_build_cluster_occupancy_evidence_table_zero_count_groups_stay_zero_entr assert reg2_ns1["cluster_entropy"].tolist() == [0.0, 0.0] +@pytest.mark.parametrize("count", [-1, float("nan"), float("inf"), float("-inf")]) +def test_build_cluster_occupancy_evidence_table_rejects_invalid_counts(count): + with pytest.raises(ValueError, match="count values must be finite and >= 0"): + region_contrasts.build_cluster_occupancy_evidence_table( + region_summaries=pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "cluster": "C1", + "count": count, + } + ] + ), + ) + + def test_build_region_evidence_table_from_pileup_counts(monkeypatch): samples = [ SampleSpec( @@ -1544,6 +1562,66 @@ def test_score_regions_cluster_occupancy_group_vs_group_aggregates_condition_gro assert result.summary.iloc[0]["delta_fraction"] == pytest.approx(0.3) +def test_score_regions_cluster_occupancy_group_vs_group_uses_sample_weighted_dominant_cluster(): + occupancy_table = pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "na1", + "condition": "treated_a", + "dominant_cluster": "C1", + }, + { + "region_id": "reg1", + "sample_id": "nb1", + "condition": "treated_b", + "dominant_cluster": "C2", + }, + { + "region_id": "reg1", + "sample_id": "nb2", + "condition": "treated_b", + "dominant_cluster": "C2", + }, + { + "region_id": "reg1", + "sample_id": "ca1", + "condition": "control_a", + "dominant_cluster": "C1", + }, + { + "region_id": "reg1", + "sample_id": "ca2", + "condition": "control_a", + "dominant_cluster": "C1", + }, + ] + ) + + result = region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec( + mode="group_vs_group", + numerator=["treated_a", "treated_b"], + denominator=["control_a"], + ), + analysis_unit="cluster_occupancy", + representation="dominant_cluster", + signal_source="cluster_occupancy", + test="effect_size_only", + occupancy_table=occupancy_table, + ) + + row = result.regions.iloc[0] + assert row["dominant_cluster"] == "C2" + assert row["reference_dominant_cluster"] == "C1" + assert row["dominant_cluster_changed"] + assert row["numerator_replicate_n"] == 3 + assert row["denominator_replicate_n"] == 2 + + def test_score_regions_cluster_occupancy_rejects_missing_occupancy_columns(): with pytest.raises(ValueError, match="occupancy_table requires columns"): region_contrasts.score_regions( From 4e42a242a2438157621503063bfb346211db0304 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 17:51:08 -0700 Subject: [PATCH 093/272] Fix cluster occupancy region contrast pooling --- dimelo/region_contrasts.py | 58 ++++++++++++++++ tests/test_region_contrasts.py | 118 +++++++++++++++++++++++++++++++++ 2 files changed, 176 insertions(+) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index 9260c44..3976a81 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -374,6 +374,55 @@ def _require_supported_cluster_occupancy_mode(contrast: ContrastSpec) -> None: ) +def _validate_occupancy_table_numeric_columns(occupancy_table: pd.DataFrame) -> None: + numeric_specs = [ + ( + "fraction", + "occupancy_table fraction values must be finite and between 0 and 1.", + lambda values: values.isna() | ~values.map(math.isfinite) | (values < 0) | (values > 1), + ), + ( + "cluster_entropy", + "occupancy_table cluster_entropy values must be finite and >= 0.", + lambda values: values.isna() | ~values.map(math.isfinite) | (values < 0), + ), + ( + "count", + "occupancy_table count values must be finite and >= 0.", + lambda values: values.isna() | ~values.map(math.isfinite) | (values < 0), + ), + ] + + for column, message, invalid_mask_builder in numeric_specs: + if column not in occupancy_table.columns: + continue + values = pd.to_numeric(occupancy_table[column], errors="coerce") + invalid_values = invalid_mask_builder(values) + if invalid_values.any(): + raise ValueError(message) + + +def _zero_fill_missing_cluster_fraction_rows( + side_evidence: pd.DataFrame, + *, + cluster_universe: pd.DataFrame, +) -> pd.DataFrame: + sample_columns = ["region_id", "sample_id", "condition"] + sample_level = side_evidence.loc[:, sample_columns].drop_duplicates() + if sample_level.empty: + return side_evidence + + complete_index = sample_level.merge(cluster_universe, on="region_id", how="inner") + merged = complete_index.merge( + side_evidence, + on=sample_columns + ["cluster"], + how="left", + sort=False, + ) + merged["fraction"] = merged["fraction"].fillna(0.0) + return merged + + def _pool_cluster_occupancy_groups( evidence: pd.DataFrame, contrast: ContrastSpec, @@ -388,6 +437,9 @@ def _pool_cluster_occupancy_groups( "numerator": contrast.numerator or [], "denominator": contrast.denominator or [], } + cluster_universe = None + if value_column == "fraction": + cluster_universe = evidence.loc[:, ["region_id", "cluster"]].drop_duplicates() for side, conditions in side_specs.items(): side_evidence = evidence.loc[evidence["condition"].isin(conditions)].copy() @@ -398,6 +450,11 @@ def _pool_cluster_occupancy_groups( raise ValueError( f"Missing {side} evidence for requested condition(s): {missing_display}." ) + if value_column == "fraction": + side_evidence = _zero_fill_missing_cluster_fraction_rows( + side_evidence, + cluster_universe=cluster_universe, + ) pooled = ( side_evidence.groupby(group_columns, dropna=False, sort=False) @@ -717,6 +774,7 @@ def score_regions( raise ValueError( "cluster_occupancy scoring currently requires occupancy_table." ) + _validate_occupancy_table_numeric_columns(occupancy_table) regions_table, summary = _score_cluster_occupancy( evidence=occupancy_table.copy(), contrast=contrast, diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index 6e5e450..e9251ce 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -1622,6 +1622,124 @@ def test_score_regions_cluster_occupancy_group_vs_group_uses_sample_weighted_dom assert row["denominator_replicate_n"] == 2 +def test_score_regions_cluster_fraction_treats_missing_sample_cluster_rows_as_zero(): + occupancy_table = pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "ns1", + "condition": "NS", + "cluster": "C1", + "fraction": 1.0, + }, + { + "region_id": "reg1", + "sample_id": "ns2", + "condition": "NS", + "cluster": "C1", + "fraction": 1.0, + }, + { + "region_id": "reg1", + "sample_id": "tx1", + "condition": "15min", + "cluster": "C1", + "fraction": 1.0, + }, + { + "region_id": "reg1", + "sample_id": "tx1", + "condition": "15min", + "cluster": "C2", + "fraction": 0.0, + }, + { + "region_id": "reg1", + "sample_id": "tx2", + "condition": "15min", + "cluster": "C1", + "fraction": 0.0, + }, + { + "region_id": "reg1", + "sample_id": "tx2", + "condition": "15min", + "cluster": "C2", + "fraction": 1.0, + }, + ] + ) + + result = region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec(mode="pairwise", numerator=["15min"], denominator=["NS"]), + analysis_unit="cluster_occupancy", + representation="cluster_fraction", + signal_source="cluster_occupancy", + test="fraction_test", + occupancy_table=occupancy_table, + ) + + c2_row = result.regions.loc[result.regions["cluster"] == "C2"].iloc[0] + assert c2_row["fraction"] == pytest.approx(0.5) + assert c2_row["reference_fraction"] == pytest.approx(0.0) + assert c2_row["numerator_replicate_n"] == 2 + assert c2_row["denominator_replicate_n"] == 2 + assert c2_row["numerator_sample_values"] == (0.0, 1.0) + assert c2_row["denominator_sample_values"] == (0.0, 0.0) + assert c2_row["p_value"] == pytest.approx(0.5) + + +@pytest.mark.parametrize( + ("representation", "column", "value", "message"), + [ + ("cluster_fraction", "fraction", 1.2, "fraction values must be finite and between 0 and 1"), + ("cluster_fraction", "fraction", float("nan"), "fraction values must be finite and between 0 and 1"), + ("cluster_entropy", "cluster_entropy", float("inf"), "cluster_entropy values must be finite and >= 0"), + ("cluster_entropy", "cluster_entropy", -0.1, "cluster_entropy values must be finite and >= 0"), + ], +) +def test_score_regions_cluster_occupancy_rejects_invalid_numeric_values( + representation, + column, + value, + message, +): + occupancy_table = pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + column: value, + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "15min", + column: 0.5 if column == "fraction" else 0.5, + }, + ] + ) + if representation == "cluster_fraction": + occupancy_table["cluster"] = ["C1", "C1"] + + with pytest.raises(ValueError, match=message): + region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec(mode="pairwise", numerator=["15min"], denominator=["NS"]), + analysis_unit="cluster_occupancy", + representation=representation, + signal_source="cluster_occupancy", + test="effect_size_only", + occupancy_table=occupancy_table, + ) + + def test_score_regions_cluster_occupancy_rejects_missing_occupancy_columns(): with pytest.raises(ValueError, match="occupancy_table requires columns"): region_contrasts.score_regions( From cadee6ce0bddfa99458bd34022c8946a7405b150 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 18:00:32 -0700 Subject: [PATCH 094/272] fix: tighten cluster occupancy contrast semantics --- README.md | 4 +- dimelo/region_contrasts.py | 91 ++++++++++++++++++++++++++++------ docs/region-contrasts.md | 72 ++++++++++++++++++++++++++- docs/shared-clustering.md | 5 ++ tests/test_region_contrasts.py | 63 ++++++++++++++++++++++- 5 files changed, 213 insertions(+), 22 deletions(-) diff --git a/README.md b/README.md index 51c9578..fc03710 100644 --- a/README.md +++ b/README.md @@ -227,9 +227,9 @@ Three higher-level analysis guides now sit on top of the existing parsing layer: - [docs/global-analysis.md](docs/global-analysis.md) for pileup-backed global summaries and normalization factors - [docs/region-discovery.md](docs/region-discovery.md) for de novo and paired locus discovery from tiled pileup scans - [docs/shared-clustering.md](docs/shared-clustering.md) for shared-boundary clustering workflows -- [docs/region-contrasts.md](docs/region-contrasts.md) for known-region motif-abundance contrasts +- [docs/region-contrasts.md](docs/region-contrasts.md) for known-region motif-abundance and cluster-occupancy contrasts -Use `parse_bam.pileup()` when you want defined-region abundance testing, and use `parse_bam.extract()` when you want read-level clustering or single-read follow-up. +Use `parse_bam.pileup()` when you want defined-region abundance testing, and use `parse_bam.extract()` when you want read-level clustering or single-read follow-up. When you want occupancy-backed region contrasts, run clustering first and pass `SharedClusterResult.region_summaries` into `region_contrasts.score_regions(..., analysis_unit="cluster_occupancy")`. For an end-to-end discovery-to-clustering run, use `workflows.discovery_cluster_workflow()`. It keeps discovery output in BED-style `selected_regions`, then derives the serializable region spec that `shared_cluster_distribution(..., matched_regions=...)` consumes. diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index 3976a81..77ab816 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -168,6 +168,7 @@ def build_cluster_occupancy_evidence_table( grouped_keys = ["region_id", "sample_id", "condition"] totals = evidence.groupby(grouped_keys, dropna=False)["count"].transform("sum") + evidence["_group_total_count"] = totals evidence["fraction"] = ( evidence["count"].div(totals.where(totals != 0), fill_value=0).fillna(0.0) ) @@ -179,9 +180,11 @@ def build_cluster_occupancy_evidence_table( kind="mergesort", ) .drop_duplicates(subset=grouped_keys, keep="first") - .loc[:, grouped_keys + ["cluster"]] + .loc[:, grouped_keys + ["cluster", "_group_total_count"]] .rename(columns={"cluster": "dominant_cluster"}) ) + summary.loc[summary["_group_total_count"] == 0, "dominant_cluster"] = None + summary = summary.drop(columns="_group_total_count") def _cluster_entropy(values: pd.Series) -> float: probabilities = values.astype(float) @@ -198,10 +201,14 @@ def _cluster_entropy(values: pd.Series) -> float: .reset_index(name="cluster_entropy") ) - return evidence.merge(summary, on=grouped_keys, how="left").merge( - entropy, - on=grouped_keys, - how="left", + return ( + evidence.merge(summary, on=grouped_keys, how="left") + .merge( + entropy, + on=grouped_keys, + how="left", + ) + .drop(columns="_group_total_count") ) @@ -374,6 +381,22 @@ def _require_supported_cluster_occupancy_mode(contrast: ContrastSpec) -> None: ) +def _require_requested_conditions_present( + evidence: pd.DataFrame, + *, + side_specs: dict[str, list[str]], +) -> None: + for side, conditions in side_specs.items(): + side_evidence = evidence.loc[evidence["condition"].isin(conditions)].copy() + available_conditions = set(side_evidence["condition"].dropna().unique()) + missing_conditions = sorted(set(conditions) - available_conditions) + if missing_conditions: + missing_display = ", ".join(missing_conditions) + raise ValueError( + f"Missing {side} evidence for requested condition(s): {missing_display}." + ) + + def _validate_occupancy_table_numeric_columns(occupancy_table: pd.DataFrame) -> None: numeric_specs = [ ( @@ -437,19 +460,16 @@ def _pool_cluster_occupancy_groups( "numerator": contrast.numerator or [], "denominator": contrast.denominator or [], } + _require_requested_conditions_present( + evidence, + side_specs=side_specs, + ) cluster_universe = None if value_column == "fraction": cluster_universe = evidence.loc[:, ["region_id", "cluster"]].drop_duplicates() for side, conditions in side_specs.items(): side_evidence = evidence.loc[evidence["condition"].isin(conditions)].copy() - available_conditions = set(side_evidence["condition"].dropna().unique()) - missing_conditions = sorted(set(conditions) - available_conditions) - if missing_conditions: - missing_display = ", ".join(missing_conditions) - raise ValueError( - f"Missing {side} evidence for requested condition(s): {missing_display}." - ) if value_column == "fraction": side_evidence = _zero_fill_missing_cluster_fraction_rows( side_evidence, @@ -513,6 +533,19 @@ def _dominant_label(values: pd.Series) -> str | None: return sorted(counts[counts == max_count].index.tolist())[0] +def _dominant_clusters_differ( + dominant_cluster: str | None, + reference_dominant_cluster: str | None, +) -> bool: + dominant_missing = pd.isna(dominant_cluster) + reference_missing = pd.isna(reference_dominant_cluster) + if dominant_missing and reference_missing: + return False + if dominant_missing or reference_missing: + return True + return bool(dominant_cluster != reference_dominant_cluster) + + def _score_cluster_occupancy( *, evidence: pd.DataFrame, @@ -625,11 +658,19 @@ def _score_cluster_occupancy( evidence, required_columns={"region_id", "sample_id", "condition", "dominant_cluster"}, ) + side_specs = { + "numerator": contrast.numerator or [], + "denominator": contrast.denominator or [], + } + _require_requested_conditions_present( + evidence, + side_specs=side_specs, + ) sample_level = evidence.loc[ :, ["region_id", "sample_id", "condition", "dominant_cluster"] ].drop_duplicates() numerator = ( - sample_level.loc[sample_level["condition"].isin(contrast.numerator or [])] + sample_level.loc[sample_level["condition"].isin(side_specs["numerator"])] .groupby("region_id", dropna=False, sort=False) .agg( dominant_cluster=("dominant_cluster", _dominant_label), @@ -638,7 +679,7 @@ def _score_cluster_occupancy( .reset_index() ) denominator = ( - sample_level.loc[sample_level["condition"].isin(contrast.denominator or [])] + sample_level.loc[sample_level["condition"].isin(side_specs["denominator"])] .groupby("region_id", dropna=False, sort=False) .agg( reference_dominant_cluster=("dominant_cluster", _dominant_label), @@ -652,8 +693,26 @@ def _score_cluster_occupancy( how="outer", sort=False, ) - regions_table["dominant_cluster_changed"] = ( - regions_table["dominant_cluster"] != regions_table["reference_dominant_cluster"] + missing_region_side = regions_table["numerator_replicate_n"].isna() ^ regions_table[ + "denominator_replicate_n" + ].isna() + if missing_region_side.any(): + raise ValueError( + "Missing dominant_cluster evidence for one or more requested contrast " + "sides at some regions." + ) + regions_table["numerator_replicate_n"] = ( + regions_table["numerator_replicate_n"].fillna(0).astype(int) + ) + regions_table["denominator_replicate_n"] = ( + regions_table["denominator_replicate_n"].fillna(0).astype(int) + ) + regions_table["dominant_cluster_changed"] = regions_table.apply( + lambda row: _dominant_clusters_differ( + row["dominant_cluster"], + row["reference_dominant_cluster"], + ), + axis=1, ) regions_table["effect_size"] = regions_table["dominant_cluster_changed"].astype(int) regions_table = regions_table.sort_values( diff --git a/docs/region-contrasts.md b/docs/region-contrasts.md index b0f6b06..a9a2ba9 100644 --- a/docs/region-contrasts.md +++ b/docs/region-contrasts.md @@ -1,6 +1,6 @@ # Region Contrasts -`dimelo.region_contrasts` scores known regions from pileup-backed inputs. It is the defined-region comparison layer for cases where you already know the loci you want to test. +`dimelo.region_contrasts` scores known regions from pileup-backed inputs or clustering-derived occupancy tables. It is the defined-region comparison layer for cases where you already know the loci you want to test. ## When To Use It @@ -9,19 +9,28 @@ - Use `cluster` first when you want read-state or cluster-occupancy follow-up rather than average motif abundance alone. - Use `region_discovery` later for de novo locus finding once that module is implemented. -## V1 Supported Path +## V1 Supported Paths - `analysis_unit="ensemble_region"` - `representation="modified_fraction"` or `"modified_count"` - `signal_source="pileup_counts"` - `test="effect_size_only"` or `"beta_binomial"` +- `analysis_unit="cluster_occupancy"` +- `signal_source="cluster_occupancy"` +- `representation="cluster_fraction"` with `test="effect_size_only"` or `"fraction_test"` +- `representation="dominant_cluster"` or `"cluster_entropy"` with `test="effect_size_only"` + Current v1 behavior: - `effect_size_only` supports pooled `pairwise` and `group_vs_group` comparisons. - `beta_binomial` supports the same pooled comparison modes and adds `p_value` / `adjusted_p_value`. - `multiple_testing="fdr_bh"` is the only supported correction mode for `beta_binomial`. - The current beta-binomial path is intentionally simple: pooled region counts with a first-pass per-region predictive test, not replicate-aware hierarchical modeling. +- `cluster_occupancy` currently supports `pairwise` and `group_vs_group` only. +- `fraction_test` is only implemented for `representation="cluster_fraction"` and uses sample-level region occupancy fractions rather than pooled reads. +- `dominant_cluster` and `cluster_entropy` are descriptive in v1. They return ranked summaries without p-values. +- Zero-read sample-region groups keep `fraction=0.0`, `cluster_entropy=0.0`, and `dominant_cluster=None` rather than inventing a winning cluster. ## Example @@ -59,6 +68,40 @@ result = region_contrasts.score_regions( ) ``` +## Cluster Occupancy Example + +Use this path after shared clustering when you want to test whether per-region read-state mixtures shift between conditions. + +```python +from dimelo import region_contrasts, workflows +from dimelo.models import ContrastSpec + +cluster_result = workflows.shared_cluster_distribution( + samples=samples, + mode="region_anchored", + motifs=["A,0"], + matched_regions="matched_regions.bed", + n_clusters=6, +) + +occupancy_result = region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + reference_condition="NS", + ), + analysis_unit="cluster_occupancy", + representation="cluster_fraction", + signal_source="cluster_occupancy", + test="fraction_test", + occupancy_table=cluster_result.region_summaries, +) +``` + ## Canonical Outputs The workflow returns a `RegionContrastResult` with canonical tables: @@ -87,6 +130,30 @@ For `beta_binomial`, statistical columns are included in both `result.regions` a - `p_value` - `adjusted_p_value` +For `analysis_unit="cluster_occupancy"`, the main fields depend on representation: + +- `cluster_fraction` + - `cluster` + - `fraction` + - `reference_fraction` + - `delta_fraction` + - `log2_fc` + - `numerator_replicate_n` + - `denominator_replicate_n` + - optional `p_value` / `adjusted_p_value` for `fraction_test` +- `dominant_cluster` + - `dominant_cluster` + - `reference_dominant_cluster` + - `dominant_cluster_changed` + - `numerator_replicate_n` + - `denominator_replicate_n` +- `cluster_entropy` + - `cluster_entropy` + - `reference_cluster_entropy` + - `delta_cluster_entropy` + - `numerator_replicate_n` + - `denominator_replicate_n` + ## Custom Plotting The results are data-first. You can use the built-in `plot_data` payloads or ignore them and plot the returned tables directly. @@ -106,6 +173,7 @@ sns.scatterplot( - Run `parse_bam.pileup()` when you care about motif abundance, defined-region contrasts, or later de novo discovery. - Run `parse_bam.extract()` when you care about single-read analysis or clustering. - Run both when you want formal region-level abundance testing plus downstream read-level follow-up on the same samples. +- Run clustering first when you want occupancy-backed contrasts; then pass `SharedClusterResult.region_summaries` as `occupancy_table`. ## Discovery-Driven Follow-Up diff --git a/docs/shared-clustering.md b/docs/shared-clustering.md index 254ab7b..7925511 100644 --- a/docs/shared-clustering.md +++ b/docs/shared-clustering.md @@ -61,6 +61,8 @@ result = workflows.shared_cluster_distribution( `discovery_cluster_contrast_workflow()` extends the same handoff one step further: it derives the serializable region spec from the BED-style discovery rows, passes that into clustering, normalizes clustering-side `region_id` values to the same `chr:start-end,strand` format used by contrasts, and uses the same selected loci as the default follow-up region set for contrasts unless `contrasts["regions"]` overrides it. +For defined-region occupancy follow-up, pass `result.region_summaries` into `region_contrasts.score_regions(..., analysis_unit="cluster_occupancy", signal_source="cluster_occupancy", occupancy_table=...)`. That keeps the clustering output as the reusable source of truth for per-region read-state mixtures. + ## Canonical Outputs The workflow returns a `SharedClusterResult` with canonical tables: @@ -72,6 +74,8 @@ The workflow returns a `SharedClusterResult` with canonical tables: - `result.region_summaries` for `region_anchored` - `result.plot_data` +`result.region_summaries` is also the standard occupancy handoff into `dimelo.region_contrasts` when you want per-region `cluster_fraction`, `dominant_cluster`, or `cluster_entropy` follow-up instead of only global cluster distributions. + Built-in plotting remains intentionally thin. `result.plot_data["cluster_distribution_bar"]` and `result.plot_data["cluster_distribution_heatmap"]` are plot-ready DataFrames, not renderer-specific figure objects. ## Custom Plotting @@ -95,5 +99,6 @@ heatmap = result.plot_data["cluster_distribution_heatmap"].set_index("condition" - `mode="region_anchored"` supports matched-region clustering from pileup-derived region vectors. - `discovery_cluster_workflow()` composes discovery and `region_anchored` clustering by passing derived matched regions into this workflow. - `discovery_cluster_contrast_workflow()` composes discovery, `region_anchored` clustering, and defined-region contrasts on the selected loci by default, with an explicit custom contrast-region override. +- `result.region_summaries` is the v1 handoff table for `cluster_occupancy` region contrasts. - The default supported clusterer is `minibatch_kmeans`. - Results are data-first: tables are the stable contract, while plotting is optional. diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index e9251ce..b215154 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -324,7 +324,7 @@ def test_build_cluster_occupancy_evidence_table_zero_count_groups_stay_zero_entr (evidence["region_id"] == "reg2") & (evidence["sample_id"] == "ns1") ] assert list(reg2_ns1["fraction"]) == [0.0, 0.0] - assert reg2_ns1["dominant_cluster"].tolist() == ["C1", "C1"] + assert reg2_ns1["dominant_cluster"].isna().all() assert reg2_ns1["cluster_entropy"].tolist() == [0.0, 0.0] @@ -1439,10 +1439,69 @@ def test_score_regions_cluster_occupancy_dominant_cluster_returns_descriptive_su assert reg1["dominant_cluster"] == "C1" assert reg1["reference_dominant_cluster"] == "C2" assert reg2["dominant_cluster"] == "C1" - assert reg2["reference_dominant_cluster"] == "C1" + assert pd.isna(reg2["reference_dominant_cluster"]) + assert reg2["dominant_cluster_changed"] assert "p_value" not in result.regions.columns +def test_score_regions_cluster_occupancy_dominant_cluster_rejects_missing_requested_conditions(): + occupancy_table = pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "tx1", + "condition": "15min", + "dominant_cluster": "C1", + } + ] + ) + + with pytest.raises(ValueError, match="Missing denominator evidence"): + region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec(mode="pairwise", numerator=["15min"], denominator=["NS"]), + analysis_unit="cluster_occupancy", + representation="dominant_cluster", + signal_source="cluster_occupancy", + test="effect_size_only", + occupancy_table=occupancy_table, + ) + + +def test_score_regions_cluster_occupancy_dominant_cluster_rejects_region_specific_missing_side(): + occupancy_table = pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "tx1", + "condition": "15min", + "dominant_cluster": "C1", + }, + { + "region_id": "reg2", + "sample_id": "ns1", + "condition": "NS", + "dominant_cluster": "C2", + }, + ] + ) + + with pytest.raises(ValueError, match="Missing dominant_cluster evidence"): + region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec(mode="pairwise", numerator=["15min"], denominator=["NS"]), + analysis_unit="cluster_occupancy", + representation="dominant_cluster", + signal_source="cluster_occupancy", + test="effect_size_only", + occupancy_table=occupancy_table, + ) + + def test_score_regions_cluster_occupancy_cluster_entropy_returns_descriptive_summary_only(): result = region_contrasts.score_regions( samples=[], From cd8db22e82c7b161c518817eb76142150914c3c2 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 18:19:03 -0700 Subject: [PATCH 095/272] docs: add plotting axis architecture spec --- ...04-01-plotting-axis-architecture-design.md | 538 ++++++++++++++++++ 1 file changed, 538 insertions(+) create mode 100644 docs/superpowers/specs/2026-04-01-plotting-axis-architecture-design.md diff --git a/docs/superpowers/specs/2026-04-01-plotting-axis-architecture-design.md b/docs/superpowers/specs/2026-04-01-plotting-axis-architecture-design.md new file mode 100644 index 0000000..9128544 --- /dev/null +++ b/docs/superpowers/specs/2026-04-01-plotting-axis-architecture-design.md @@ -0,0 +1,538 @@ +# Plotting Axis Architecture Design + +## Purpose + +This design defines a compatibility-safe plotting architecture for `dimelo-toolkit` that: + +- preserves the existing plotting entry points and familiar arguments +- introduces a shared internal model for positional plotting +- supports `5'->3'` orientation consistently across region-aligned plots +- supports both fixed-window and variable-length aggregate region normalization +- keeps single-read plots coordinate-preserving +- keeps plotting data-first so users can use Matplotlib, seaborn, Plotly, Altair, or their own stack + +This is an additive architecture around the current package. It must not require a rewrite of the parsing layer or force existing users to adopt a new plotting API immediately. + +## Compatibility Constraint + +Backward continuity is a hard requirement. + +The update must: + +- keep existing plotters working +- preserve current public plotting signatures unless a change is strictly additive +- preserve familiar flags such as `relative`, `single_strand`, and `regions_5to3prime` +- preserve current behavior by default for legacy plotting entry points +- keep Matplotlib as the built-in default renderer + +The new plotting system becomes the canonical internal model. Existing plotting functions remain supported as wrappers or adapters over that model. + +## Problem Statement + +The package currently has several plotting paths with overlapping ideas: + +- region-relative plotting +- strand-aware plotting +- `regions_5to3prime` flipping +- single-read displays +- aggregate enrichment and depth profiles + +These concepts already exist, but they are distributed across multiple modules and are not expressed as one shared plotting contract. + +The new analysis layers also need more explicit plotting semantics: + +- global summaries +- region discovery scan plots +- known-region contrasts +- clustering summaries +- occupancy follow-up + +Users also need more flexible positional plotting for region-aligned analyses, especially: + +- fixed centered windows +- variable-length region normalization for aggregate plots +- arbitrary segment maps for reference-defined feature structure +- support for both contiguous and non-contiguous feature segments + +The design must make those capabilities available without making single-read plots scientifically misleading. + +## Core Design Rule + +There are three separate concerns that must stay independent: + +1. `plot_family` + What kind of visualization is being produced. + +2. `axis_spec` + How x coordinates are defined and aligned. + +3. `aggregation_spec` + How values are summarized across reads, regions, or conditions. + +The term “normalization” must not be used ambiguously across these concerns. + +## Safe Semantic Boundary + +Single-read plots and aggregate plots must not share the same x-axis freedoms. + +### Single-read plots + +Single-read plots must remain coordinate-preserving. + +Allowed: + +- genomic coordinates +- fixed-window relative coordinates +- `5'->3'` orientation flips for strand-consistent viewing +- segment-based faceting or panel splits + +Not allowed: + +- stretched or continuously scaled x-axes across variable-length regions +- metaregion-style body rescaling on a continuous single-read canvas + +This is required to avoid misleading geometric interpretations of read structure. + +### Aggregate plots + +Aggregate positional plots may use normalized axes because they explicitly represent a summarized metaregion view rather than raw per-read geometry. + +Allowed: + +- genomic or region-oriented axes +- fixed-window aggregation +- scaled contiguous region bodies +- arbitrary segment maps +- contiguous and non-contiguous segment composition +- concatenated or faceted segment layouts + +## Canonical Axis Model + +The canonical internal model should be a shared positional axis system used by plot-data preparation. + +### Axis families + +There are three user-facing axis families: + +1. `fixed_window` + One continuous anchored window around a position, center, or landmark. + +2. `scaled_region` + One contiguous variable-length region body, optionally with fixed flanks. + +3. `segment_map` + One plotted axis assembled from explicit per-region reference segments. + +Internally: + +- `fixed_window` compiles to a one-segment representation +- `scaled_region` compiles to a structured segment representation +- `segment_map` is the canonical general form + +### Orientation + +Orientation is independent of coordinate family. + +Supported values: + +- `genomic` +- `region_5to3` + +`region_5to3` means region-aligned plots are oriented along the reference feature direction. For negative-strand regions, this implies flipping positional coordinates in the derived plot view. + +This is conceptually the generalization of today’s `regions_5to3prime` behavior. + +## Segment Model + +The plotting system must support arbitrary segments keyed directly in reference coordinates. + +The base contract is explicit per-region segment definitions. Feature-derived helpers are convenience layers, not the core contract. + +### Segment fields + +Each segment should support: + +- `segment_id` +- `label` +- `region_id` +- `start_ref` +- `end_ref` +- `mode` + - `raw` + - `scaled` +- `bins` or `bin_width` +- `contiguous_with_previous` +- `plot_gap_after` + +### Contiguous vs non-contiguous segments + +Non-contiguous segments are not a separate analysis mode. They are represented by segment metadata. + +This allows one common substrate to support: + +- `upstream | body | downstream` +- exon-only plots +- motif neighborhoods +- arbitrary user-specified feature composites + +Renderers must be able to express discontinuity either through: + +- separators or gaps on one concatenated axis +- faceted small multiples by segment + +## Aggregation Model + +Aggregate positional plotting must make weighting explicit. + +This is separate from x-axis normalization. + +### Weighting options + +The design should support: + +- `equal_region` + Each region contributes equally after within-region summarization. + +- `equal_observation` + Each observation contributes equally. + +- `coverage_weighted` + Regions are weighted by coverage or another confidence-like quantity. + +The recommended default is `equal_region`. + +### Within-region summary + +The design should support at least: + +- `mean` +- `fraction` +- `density` + +This defines how a region is summarized internally before any cross-region aggregation. + +### Signal normalization + +Signal normalization must be separate from x-axis normalization and weighting. + +The plotting contract should support metadata for at least: + +- `none` +- `per_region` +- `global` +- `control_regions` + +Whether all of these are implemented in the first slice is a separate scope decision. The design requires the conceptual separation now. + +### Order-of-operations clarity + +The plotting system must keep the following choices explicit: + +- normalize each region then average +- average raw signal then normalize once + +These are not interchangeable and should not be hidden behind one plotting flag. + +## Plot Families + +The plotting system should define explicit plot families rather than one generic plotting function. + +### 1. `single_read_raster` + +For read-level displays. + +Typical uses: + +- read rasters +- read event/lollipop plots +- browser-like region views + +Constraints: + +- coordinate-preserving only +- may use `genomic` or `region_5to3` +- may use `fixed_window` +- may use segmented faceting +- must not use continuous scaled metaregion axes + +### 2. `aggregate_profile` + +For aggregated enrichment, depth, abundance, or occupancy-like profiles over aligned regions. + +Typical uses: + +- promoter-centered metaprofiles +- gene-body plots +- upstream/body/downstream summaries +- segment-based aggregate traces + +Capabilities: + +- `fixed_window` +- `segment_map` +- `region_5to3` +- aggregate-only scaled segments +- concatenated or faceted segment layout + +### 3. `aggregate_heatmap` + +For region-by-position summaries. + +Capabilities: + +- same axis semantics as `aggregate_profile` +- rows can represent regions, conditions, clusters, or ranked loci +- supports faceted or concatenated segment layouts + +### 4. `distribution_summary` + +For non-positional summary plots. + +Typical uses: + +- cluster distribution bars +- condition heatmaps +- volcano plots +- rank plots +- occupancy summary charts + +No positional axis normalization applies. + +### 5. `track_scan` + +For genome scan or local discovery tracks. + +Typical uses: + +- region discovery scan tracks +- hit-context plots +- chromosome-level summaries + +These are primarily genomic-coordinate plots. + +## Analysis-to-Plot Mapping + +### `global_analysis` + +Primary plot families: + +- `distribution_summary` +- `track_scan` +- `aggregate_profile` where region-aligned summaries exist + +### `region_discovery` + +Primary plot families: + +- `track_scan` +- `distribution_summary` +- local `aggregate_profile` views for top hits + +### `region_contrasts` + +Primary plot families: + +- `distribution_summary` +- `aggregate_profile` +- `aggregate_heatmap` + +### `shared_clustering` + +Primary plot families: + +- `distribution_summary` +- positional `aggregate_profile` later where region-aligned occupancy summaries are meaningful + +### Legacy read/profile plotting + +Legacy plotting modules should gradually route through the same shared positional data-prep semantics where feasible. + +## API Model + +The advanced plotting API should live primarily in a shared plotting module, with thin wrappers elsewhere. + +Recommended shared objects: + +```python +@dataclass +class AxisSpec: + orientation: str # "genomic" | "region_5to3" + coordinate_mode: str # "fixed_window" | "segment_map" + anchor: str | None = None + upstream_bp: int | None = None + downstream_bp: int | None = None + segments: list["SegmentSpec"] | None = None + + +@dataclass +class SegmentSpec: + segment_id: str + label: str + start_ref: int + end_ref: int + mode: str # "raw" | "scaled" + bins: int | None = None + plot_gap_after: bool = False + contiguous_with_previous: bool = True + + +@dataclass +class AggregationSpec: + weighting: str # "equal_region" | "equal_observation" | "coverage_weighted" + within_region_summary: str # "mean" | "fraction" | "density" + signal_normalization: str # "none" | "per_region" | "global" | "control_regions" + layout: str # "concatenated" | "faceted" + + +@dataclass +class PlotRequest: + plot_family: str + axis: AxisSpec | None = None + aggregation: AggregationSpec | None = None + renderer: str = "matplotlib" +``` + +Recommended shared prep entry points: + +- `prepare_single_read_plot_data(...)` +- `prepare_aggregate_plot_data(...)` + +These prepare data and metadata only. Rendering is a separate thin layer. + +## Data Contract + +Every plot-prep function should return structured plotting payloads rather than figures as the canonical contract. + +Recommended outputs: + +- `plot_table` + Long-form plotting data. + +- `axis_table` + Segment boundaries, axis labels, gap markers, and orientation metadata. + +- `metadata` + Plot semantics, units, normalization mode, weighting mode, and family identifiers. + +- `summary_table` + Optional pre-aggregated values when useful. + +This keeps the plotting system backend-neutral and aligned with the existing data-first direction of the newer workflows. + +## Legacy Wrapper Strategy + +The new plotting architecture should not replace current plotters at once. + +Instead: + +- legacy functions remain public +- legacy flags are translated into the new shared specs internally +- defaults remain behaviorally close to the current package +- advanced users can opt into the richer plotting API directly + +Examples of translation: + +- `regions_5to3prime=True` + -> `AxisSpec(orientation="region_5to3", ...)` + +- `relative=True` with centered windows + -> `AxisSpec(coordinate_mode="fixed_window", ...)` + +- older profile plotting + -> `plot_family="aggregate_profile"` + +### User-facing guidance + +The docs should explicitly map old concepts to new ones: + +- old `regions_5to3prime` + -> new `orientation="region_5to3"` + +- old relative region profile plotting + -> new `fixed_window` + +- new scaled or segmented metaregion plotting + -> aggregate-only advanced capability + +- single-read plots remain geometry-preserving + +## Renderer Strategy + +Built-in rendering should remain Matplotlib-first for compatibility. + +The package should still encourage users to plot returned tables with their own preferred stack. + +So the plotting stack becomes: + +1. canonical plot-data preparation +2. thin built-in Matplotlib rendering +3. optional user-managed rendering elsewhere + +This is consistent with the current direction of `plot_data` in newer workflow results. + +## Module Layout + +Recommended direction: + +- expand [plotting.py](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py) + to hold the shared plot-data preparation core + +- keep existing modules such as: + - [plot_enrichment_profile.py](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plot_enrichment_profile.py) + - [plot_depth_profile.py](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plot_depth_profile.py) + - [plot_reads.py](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plot_reads.py) + as wrappers or adapters during the transition + +- route newer workflow `plot_data` preparation through the shared plotting core where it makes sense + +## Failure and Validation Rules + +The shared plotting layer should validate semantic misuse early. + +Required validations: + +- reject continuous scaled metaregion axes for single-read plots +- reject positional axis specs on non-positional plot families where not applicable +- reject malformed segment maps +- require explicit segment discontinuity metadata for non-contiguous segment layouts +- preserve legacy defaults when wrappers are used without advanced options + +## Testing Requirements + +The implementation plan for this design must include: + +- regression coverage proving existing plotters still work with legacy arguments +- unit tests for shared `AxisSpec` and segment validation +- unit tests for `region_5to3` flipping in plot-data prep +- unit tests proving single-read plotting rejects scaled continuous metaregion axes +- unit tests for aggregate segment-map prep with: + - contiguous segments + - non-contiguous segments + - concatenated layout metadata + - faceted layout metadata +- tests for weighting modes in aggregate profile prep + +## Implementation Order + +Recommended implementation sequence: + +1. Add shared plotting spec dataclasses and validation in `plotting.py`. +2. Add shared positional plot-data prep for `fixed_window`. +3. Add aggregate-only segment-map prep with contiguous and non-contiguous support. +4. Add `region_5to3` orientation handling in the shared prep layer. +5. Route one aggregate legacy plotter through the shared core. +6. Route one single-read legacy plotter through the shared core. +7. Extend newer workflow `plot_data` helpers where useful. +8. Add compatibility docs mapping old plotting flags to the new model. + +## Recommendation + +The package should standardize on a shared plotting axis model while keeping plotting behavior safe and scientifically honest: + +- orientation is general +- scaled axes are aggregate-only +- single-read plots preserve geometry +- legacy plotting calls remain supported +- plotting data stays the canonical contract + +This gives users more expressive aggregate plotting for variable-length features and arbitrary reference-defined segments without breaking the mental model of existing plotting routines. From 769d899d9ba043eeb4320bb8be64e4b1cda401e9 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 18:25:08 -0700 Subject: [PATCH 096/272] feat: add plotting axis spec validation --- dimelo/plotting.py | 63 ++++++++++++++++++++++++++++++++++++++++++ tests/test_plotting.py | 52 ++++++++++++++++++++++++++++++++++ 2 files changed, 115 insertions(+) create mode 100644 tests/test_plotting.py diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 0594a1d..413bc23 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -1,10 +1,73 @@ from __future__ import annotations +from dataclasses import dataclass + import pandas as pd from dimelo.distribution import _require_columns +@dataclass(frozen=True) +class SegmentSpec: + segment_id: str + label: str + start_ref: int + end_ref: int + mode: str = "raw" + bins: int | None = None + plot_gap_after: bool = False + contiguous_with_previous: bool = True + + +@dataclass(frozen=True) +class AxisSpec: + orientation: str + coordinate_mode: str + anchor: str | None = None + upstream_bp: int | None = None + downstream_bp: int | None = None + segments: list[SegmentSpec] | None = None + + +@dataclass(frozen=True) +class AggregationSpec: + weighting: str = "equal_region" + within_region_summary: str = "mean" + signal_normalization: str = "none" + layout: str = "faceted" + + +def validate_axis_spec(axis: AxisSpec, *, plot_family: str) -> None: + if axis.orientation not in {"genomic", "region_5to3"}: + raise ValueError("AxisSpec.orientation must be 'genomic' or 'region_5to3'.") + + if axis.coordinate_mode not in {"fixed_window", "segment_map"}: + raise ValueError("AxisSpec.coordinate_mode must be 'fixed_window' or 'segment_map'.") + + if axis.coordinate_mode == "segment_map" and not axis.segments: + raise ValueError("segment_map requires segments.") + + if plot_family == "single_read_raster" and axis.segments: + if any(segment.mode == "scaled" for segment in axis.segments): + raise ValueError( + "single_read_raster plots must preserve coordinates and cannot use scaled segments." + ) + + +def validate_aggregation_spec(spec: AggregationSpec) -> None: + if spec.weighting not in {"equal_region", "equal_observation", "coverage_weighted"}: + raise ValueError("Unsupported weighting mode.") + + if spec.within_region_summary not in {"mean", "fraction", "density"}: + raise ValueError("Unsupported within_region_summary.") + + if spec.signal_normalization not in {"none", "per_region", "global", "control_regions"}: + raise ValueError("Unsupported signal_normalization.") + + if spec.layout not in {"concatenated", "faceted"}: + raise ValueError("Unsupported layout mode.") + + def prepare_cluster_distribution_bar_data(cluster_distribution: pd.DataFrame) -> pd.DataFrame: _require_columns( cluster_distribution, diff --git a/tests/test_plotting.py b/tests/test_plotting.py new file mode 100644 index 0000000..fe2b535 --- /dev/null +++ b/tests/test_plotting.py @@ -0,0 +1,52 @@ +import pytest + +from dimelo import plotting + + +def test_axis_spec_accepts_fixed_window_region_5to3(): + spec = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=1000, + downstream_bp=1000, + ) + + plotting.validate_axis_spec(spec, plot_family="aggregate_profile") + + +def test_axis_spec_rejects_segment_map_without_segments(): + spec = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="segment_map", + segments=None, + ) + + with pytest.raises(ValueError, match="segment_map requires segments"): + plotting.validate_axis_spec(spec, plot_family="aggregate_profile") + + +def test_single_read_rejects_scaled_segments(): + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="segment_map", + segments=[ + plotting.SegmentSpec( + segment_id="body", + label="Body", + start_ref=100, + end_ref=500, + mode="scaled", + bins=50, + ) + ], + ) + + with pytest.raises(ValueError, match="single_read"): + plotting.validate_axis_spec(axis, plot_family="single_read_raster") + + +def test_aggregation_spec_accepts_equal_region_default(): + spec = plotting.AggregationSpec() + + plotting.validate_aggregation_spec(spec) From 38aed59d110602786b38f28d5e53fc4c393356bc Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 18:35:00 -0700 Subject: [PATCH 097/272] test: add plotting helper regressions --- tests/test_plotting.py | 61 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index fe2b535..7a87761 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -1,4 +1,5 @@ import pytest +import pandas as pd from dimelo import plotting @@ -50,3 +51,63 @@ def test_aggregation_spec_accepts_equal_region_default(): spec = plotting.AggregationSpec() plotting.validate_aggregation_spec(spec) + + +def test_prepare_cluster_distribution_bar_data_handles_empty_input_shape(): + cluster_distribution = pd.DataFrame( + columns=["sample_id", "condition", "cluster", "count", "fraction"] + ) + + result = plotting.prepare_cluster_distribution_bar_data(cluster_distribution) + + assert list(result.columns) == ["sample_id", "condition", "cluster", "count", "fraction"] + assert result.empty + + +def test_prepare_cluster_distribution_bar_data_keeps_stable_sorted_output(): + cluster_distribution = pd.DataFrame( + { + "sample_id": ["s2", "s1", "s1", "s2"], + "condition": ["15min", "NS", "NS", "15min"], + "cluster": ["C0", "C0", "C0", "C1"], + "count": [1, 2, 3, 4], + "fraction": [0.25, 0.66, 0.34, 0.75], + } + ) + + result = plotting.prepare_cluster_distribution_bar_data(cluster_distribution) + + assert list(result["sample_id"]) == ["s1", "s1", "s2", "s2"] + assert list(result["condition"]) == ["NS", "NS", "15min", "15min"] + assert list(result["cluster"]) == ["C0", "C0", "C0", "C1"] + assert list(result["count"]) == [2, 3, 1, 4] + + +def test_prepare_cluster_distribution_heatmap_data_handles_empty_input_shape(): + condition_distribution = pd.DataFrame(columns=["condition", "cluster", "fraction"]) + + result = plotting.prepare_cluster_distribution_heatmap_data(condition_distribution) + + assert list(result.columns) == ["condition"] + assert result.empty + + +def test_prepare_cluster_distribution_heatmap_data_pivots_columns_in_sorted_order(): + condition_distribution = pd.DataFrame( + { + "condition": ["NS", "NS", "15min", "15min"], + "cluster": ["C1", "C0", "C1", "C0"], + "fraction": [0.25, 0.75, 0.75, 0.25], + } + ) + + result = plotting.prepare_cluster_distribution_heatmap_data(condition_distribution) + + assert list(result.columns) == ["condition", "C0", "C1"] + assert list(result["condition"]) == ["15min", "NS"] + fifteen_min = result[result["condition"] == "15min"].iloc[0] + ns_row = result[result["condition"] == "NS"].iloc[0] + assert fifteen_min["C0"] == 0.25 + assert fifteen_min["C1"] == 0.75 + assert ns_row["C0"] == 0.75 + assert ns_row["C1"] == 0.25 From 26232e83822837c304072c7d79622b85e9875c73 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 18:38:14 -0700 Subject: [PATCH 098/272] feat: add fixed-window plotting prep --- dimelo/plotting.py | 107 +++++++++++++++++++++++++++++++++++++++++ tests/test_plotting.py | 68 ++++++++++++++++++++++++++ 2 files changed, 175 insertions(+) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 413bc23..8ef84cd 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -68,6 +68,113 @@ def validate_aggregation_spec(spec: AggregationSpec) -> None: raise ValueError("Unsupported layout mode.") +def _relative_position(position: float, anchor: float) -> float: + return float(position) - float(anchor) + + +def _orient_position(relative_position: float, region_strand: str, orientation: str) -> float: + if orientation == "region_5to3" and region_strand == "-": + return -relative_position + return relative_position + + +def _prepare_fixed_window_plot_data( + table: pd.DataFrame, + *, + axis: AxisSpec, + position_column: str, + anchor_column: str, + region_strand_column: str, +) -> tuple[pd.DataFrame, pd.DataFrame]: + if axis.coordinate_mode != "fixed_window": + raise ValueError("fixed_window prep only supports coordinate_mode='fixed_window'.") + if axis.upstream_bp is None or axis.downstream_bp is None: + raise ValueError("fixed_window prep requires upstream_bp and downstream_bp.") + + _require_columns( + table, + (position_column, anchor_column, region_strand_column), + "plot_table", + ) + + plot_table = table.copy() + relative_position = plot_table[position_column].astype(float) - plot_table[anchor_column].astype(float) + plot_table["plot_x"] = [ + _orient_position(relative_position=rel, region_strand=strand, orientation=axis.orientation) + for rel, strand in zip(relative_position, plot_table[region_strand_column], strict=True) + ] + + axis_table = pd.DataFrame( + [ + { + "segment_id": "window", + "axis_min": -axis.upstream_bp, + "axis_max": axis.downstream_bp, + } + ] + ) + return plot_table, axis_table + + +def prepare_single_read_plot_data( + table: pd.DataFrame, + *, + plot_family: str, + axis: AxisSpec, + position_column: str, + anchor_column: str, + region_strand_column: str, +) -> dict[str, pd.DataFrame | dict[str, object]]: + validate_axis_spec(axis, plot_family=plot_family) + plot_table, axis_table = _prepare_fixed_window_plot_data( + table, + axis=axis, + position_column=position_column, + anchor_column=anchor_column, + region_strand_column=region_strand_column, + ) + metadata = { + "plot_family": plot_family, + "orientation": axis.orientation, + "coordinate_mode": axis.coordinate_mode, + } + return {"plot_table": plot_table, "axis_table": axis_table, "metadata": metadata} + + +def prepare_aggregate_plot_data( + table: pd.DataFrame, + *, + plot_family: str, + axis: AxisSpec, + aggregation: AggregationSpec, + value_column: str, + position_column: str, + anchor_column: str, + region_strand_column: str, +) -> dict[str, pd.DataFrame | dict[str, object]]: + validate_axis_spec(axis, plot_family=plot_family) + validate_aggregation_spec(aggregation) + _require_columns(table, (value_column,), "plot_table") + + plot_table, axis_table = _prepare_fixed_window_plot_data( + table, + axis=axis, + position_column=position_column, + anchor_column=anchor_column, + region_strand_column=region_strand_column, + ) + metadata = { + "plot_family": plot_family, + "orientation": axis.orientation, + "coordinate_mode": axis.coordinate_mode, + "weighting": aggregation.weighting, + "within_region_summary": aggregation.within_region_summary, + "signal_normalization": aggregation.signal_normalization, + "layout": aggregation.layout, + } + return {"plot_table": plot_table, "axis_table": axis_table, "metadata": metadata} + + def prepare_cluster_distribution_bar_data(cluster_distribution: pd.DataFrame) -> pd.DataFrame: _require_columns( cluster_distribution, diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 7a87761..8c5eb1f 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -111,3 +111,71 @@ def test_prepare_cluster_distribution_heatmap_data_pivots_columns_in_sorted_orde assert fifteen_min["C1"] == 0.75 assert ns_row["C0"] == 0.75 assert ns_row["C1"] == 0.25 + + +def test_prepare_single_read_plot_data_flips_negative_regions_to_5to3(): + reads = pd.DataFrame( + [ + { + "region_id": "reg1", + "region_strand": "-", + "event_pos": 110, + "anchor": 100, + "read_id": "r1", + } + ] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="custom", + upstream_bp=20, + downstream_bp=20, + ) + + payload = plotting.prepare_single_read_plot_data( + reads, + plot_family="single_read_raster", + axis=axis, + position_column="event_pos", + anchor_column="anchor", + region_strand_column="region_strand", + ) + + assert payload["plot_table"].loc[0, "plot_x"] == -10 + + +def test_prepare_aggregate_plot_data_retains_metadata_for_fixed_window(): + table = pd.DataFrame( + [ + {"region_id": "reg1", "region_strand": "+", "event_pos": 95, "anchor": 100, "signal": 1.0}, + {"region_id": "reg1", "region_strand": "+", "event_pos": 105, "anchor": 100, "signal": 3.0}, + ] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=10, + downstream_bp=10, + ) + aggregation = plotting.AggregationSpec( + weighting="equal_region", + within_region_summary="mean", + signal_normalization="none", + layout="faceted", + ) + + payload = plotting.prepare_aggregate_plot_data( + table, + plot_family="aggregate_profile", + axis=axis, + aggregation=aggregation, + value_column="signal", + position_column="event_pos", + anchor_column="anchor", + region_strand_column="region_strand", + ) + + assert {"plot_table", "axis_table", "metadata"} <= set(payload) + assert payload["metadata"]["orientation"] == "region_5to3" From d37592cad900cb5695621691c83e568a76b07d07 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 18:53:50 -0700 Subject: [PATCH 099/272] fix: harden fixed-window plotting prep --- dimelo/plotting.py | 46 ++++++++++----- tests/test_plotting.py | 128 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 159 insertions(+), 15 deletions(-) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 8ef84cd..476923d 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -47,6 +47,12 @@ def validate_axis_spec(axis: AxisSpec, *, plot_family: str) -> None: if axis.coordinate_mode == "segment_map" and not axis.segments: raise ValueError("segment_map requires segments.") + if axis.coordinate_mode == "fixed_window": + if axis.upstream_bp is None or axis.downstream_bp is None: + raise ValueError("fixed_window requires upstream_bp and downstream_bp.") + if axis.upstream_bp < 0 or axis.downstream_bp < 0: + raise ValueError("fixed_window upstream_bp and downstream_bp must be non-negative.") + if plot_family == "single_read_raster" and axis.segments: if any(segment.mode == "scaled" for segment in axis.segments): raise ValueError( @@ -73,7 +79,13 @@ def _relative_position(position: float, anchor: float) -> float: def _orient_position(relative_position: float, region_strand: str, orientation: str) -> float: - if orientation == "region_5to3" and region_strand == "-": + if orientation != "region_5to3": + return relative_position + + if region_strand not in {"+", "-"}: + raise ValueError("region_5to3 fixed_window prep requires region_strand values of '+' or '-'.") + + if region_strand == "-": return -relative_position return relative_position @@ -84,25 +96,29 @@ def _prepare_fixed_window_plot_data( axis: AxisSpec, position_column: str, anchor_column: str, - region_strand_column: str, + region_strand_column: str | None = None, ) -> tuple[pd.DataFrame, pd.DataFrame]: if axis.coordinate_mode != "fixed_window": raise ValueError("fixed_window prep only supports coordinate_mode='fixed_window'.") - if axis.upstream_bp is None or axis.downstream_bp is None: - raise ValueError("fixed_window prep requires upstream_bp and downstream_bp.") - _require_columns( - table, - (position_column, anchor_column, region_strand_column), - "plot_table", - ) + _require_columns(table, (position_column, anchor_column), "plot_table") + if axis.orientation == "region_5to3": + if region_strand_column is None: + raise ValueError("region_5to3 fixed_window prep requires region_strand_column.") + _require_columns(table, (region_strand_column,), "plot_table") plot_table = table.copy() relative_position = plot_table[position_column].astype(float) - plot_table[anchor_column].astype(float) - plot_table["plot_x"] = [ - _orient_position(relative_position=rel, region_strand=strand, orientation=axis.orientation) - for rel, strand in zip(relative_position, plot_table[region_strand_column], strict=True) - ] + if axis.orientation == "region_5to3": + plot_table["plot_x"] = [ + _orient_position(relative_position=rel, region_strand=strand, orientation=axis.orientation) + for rel, strand in zip(relative_position, plot_table[region_strand_column], strict=True) + ] + else: + plot_table["plot_x"] = relative_position + + window_mask = plot_table["plot_x"].between(-axis.upstream_bp, axis.downstream_bp) + plot_table = plot_table.loc[window_mask].copy().reset_index(drop=True) axis_table = pd.DataFrame( [ @@ -123,7 +139,7 @@ def prepare_single_read_plot_data( axis: AxisSpec, position_column: str, anchor_column: str, - region_strand_column: str, + region_strand_column: str | None = None, ) -> dict[str, pd.DataFrame | dict[str, object]]: validate_axis_spec(axis, plot_family=plot_family) plot_table, axis_table = _prepare_fixed_window_plot_data( @@ -150,7 +166,7 @@ def prepare_aggregate_plot_data( value_column: str, position_column: str, anchor_column: str, - region_strand_column: str, + region_strand_column: str | None = None, ) -> dict[str, pd.DataFrame | dict[str, object]]: validate_axis_spec(axis, plot_family=plot_family) validate_aggregation_spec(aggregation) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 8c5eb1f..1f1f812 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -145,6 +145,134 @@ def test_prepare_single_read_plot_data_flips_negative_regions_to_5to3(): assert payload["plot_table"].loc[0, "plot_x"] == -10 +def test_prepare_single_read_plot_data_genomic_fixed_window_does_not_require_strand_column(): + reads = pd.DataFrame( + [ + { + "region_id": "reg1", + "event_pos": 110, + "anchor": 100, + "read_id": "r1", + } + ] + ) + axis = plotting.AxisSpec( + orientation="genomic", + coordinate_mode="fixed_window", + anchor="custom", + upstream_bp=20, + downstream_bp=20, + ) + + payload = plotting.prepare_single_read_plot_data( + reads, + plot_family="single_read_raster", + axis=axis, + position_column="event_pos", + anchor_column="anchor", + ) + + assert list(payload["plot_table"]["plot_x"]) == [10.0] + + +def test_prepare_single_read_plot_data_filters_rows_outside_fixed_window_bounds(): + reads = pd.DataFrame( + [ + { + "region_id": "reg1", + "region_strand": "+", + "event_pos": 89, + "anchor": 100, + "read_id": "r0", + }, + { + "region_id": "reg1", + "region_strand": "+", + "event_pos": 95, + "anchor": 100, + "read_id": "r1", + }, + { + "region_id": "reg1", + "region_strand": "+", + "event_pos": 105, + "anchor": 100, + "read_id": "r2", + }, + { + "region_id": "reg1", + "region_strand": "+", + "event_pos": 111, + "anchor": 100, + "read_id": "r3", + }, + ] + ) + axis = plotting.AxisSpec( + orientation="genomic", + coordinate_mode="fixed_window", + anchor="custom", + upstream_bp=10, + downstream_bp=10, + ) + + payload = plotting.prepare_single_read_plot_data( + reads, + plot_family="single_read_raster", + axis=axis, + position_column="event_pos", + anchor_column="anchor", + ) + + assert list(payload["plot_table"]["read_id"]) == ["r1", "r2"] + assert list(payload["plot_table"]["plot_x"]) == [-5.0, 5.0] + + +@pytest.mark.parametrize("upstream_bp, downstream_bp", [(-1, 10), (10, -1)]) +def test_validate_axis_spec_rejects_negative_fixed_window_bounds(upstream_bp, downstream_bp): + axis = plotting.AxisSpec( + orientation="genomic", + coordinate_mode="fixed_window", + anchor="custom", + upstream_bp=upstream_bp, + downstream_bp=downstream_bp, + ) + + with pytest.raises(ValueError, match="non-negative"): + plotting.validate_axis_spec(axis, plot_family="aggregate_profile") + + +def test_prepare_single_read_plot_data_rejects_invalid_region_strand_in_region_5to3(): + reads = pd.DataFrame( + [ + { + "region_id": "reg1", + "region_strand": "?", + "event_pos": 110, + "anchor": 100, + "read_id": "r1", + } + ] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="custom", + upstream_bp=20, + downstream_bp=20, + ) + + with pytest.raises(ValueError, match="region_strand values"): + plotting.prepare_single_read_plot_data( + reads, + plot_family="single_read_raster", + axis=axis, + position_column="event_pos", + anchor_column="anchor", + region_strand_column="region_strand", + ) + + def test_prepare_aggregate_plot_data_retains_metadata_for_fixed_window(): table = pd.DataFrame( [ From 2b36df001dc3e7c428e0a02d752ebf22534ec472 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 18:56:27 -0700 Subject: [PATCH 100/272] feat: add aggregate segment-map plotting prep --- dimelo/plotting.py | 94 +++++++++++++++++++++++++++++---- tests/test_plotting.py | 117 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 202 insertions(+), 9 deletions(-) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 476923d..9c2199b 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -47,6 +47,9 @@ def validate_axis_spec(axis: AxisSpec, *, plot_family: str) -> None: if axis.coordinate_mode == "segment_map" and not axis.segments: raise ValueError("segment_map requires segments.") + if plot_family == "single_read_raster" and axis.coordinate_mode == "segment_map": + raise ValueError("segment_map is aggregate-only for single_read_raster plots.") + if axis.coordinate_mode == "fixed_window": if axis.upstream_bp is None or axis.downstream_bp is None: raise ValueError("fixed_window requires upstream_bp and downstream_bp.") @@ -132,6 +135,62 @@ def _prepare_fixed_window_plot_data( return plot_table, axis_table +def _build_segment_axis_table(segments: list[SegmentSpec]) -> pd.DataFrame: + rows: list[dict[str, object]] = [] + running_start = 0 + + for segment in segments: + span = segment.bins if segment.bins is not None else segment.end_ref - segment.start_ref + rows.append( + { + "segment_id": segment.segment_id, + "label": segment.label, + "start_ref": segment.start_ref, + "end_ref": segment.end_ref, + "mode": segment.mode, + "bins": segment.bins, + "plot_start": running_start, + "plot_end": running_start + span, + "contiguous_with_previous": segment.contiguous_with_previous, + "plot_gap_after": segment.plot_gap_after, + "discontinuity_before": not segment.contiguous_with_previous, + "discontinuity_after": segment.plot_gap_after, + } + ) + running_start += span + + return pd.DataFrame(rows) + + +def _prepare_segment_map_plot_data( + table: pd.DataFrame, + *, + axis: AxisSpec, + segment_id_column: str, + segment_position_column: str, +) -> tuple[pd.DataFrame, pd.DataFrame]: + if not axis.segments: + raise ValueError("segment_map requires segments.") + + _require_columns(table, (segment_id_column, segment_position_column), "plot_table") + + axis_table = _build_segment_axis_table(axis.segments) + plot_table = table.copy() + axis_lookup = axis_table.loc[:, ["segment_id", "plot_start"]].rename( + columns={"segment_id": "_axis_segment_id"} + ) + plot_table = plot_table.merge( + axis_lookup, + left_on=segment_id_column, + right_on="_axis_segment_id", + how="left", + ) + plot_table["plot_x"] = plot_table["plot_start"] + plot_table[segment_position_column].astype(float) + plot_table = plot_table.drop(columns=["_axis_segment_id", "plot_start"]) + + return plot_table, axis_table + + def prepare_single_read_plot_data( table: pd.DataFrame, *, @@ -164,21 +223,36 @@ def prepare_aggregate_plot_data( axis: AxisSpec, aggregation: AggregationSpec, value_column: str, - position_column: str, - anchor_column: str, + position_column: str | None = None, + anchor_column: str | None = None, region_strand_column: str | None = None, + segment_id_column: str | None = None, + segment_position_column: str | None = None, ) -> dict[str, pd.DataFrame | dict[str, object]]: validate_axis_spec(axis, plot_family=plot_family) validate_aggregation_spec(aggregation) _require_columns(table, (value_column,), "plot_table") - plot_table, axis_table = _prepare_fixed_window_plot_data( - table, - axis=axis, - position_column=position_column, - anchor_column=anchor_column, - region_strand_column=region_strand_column, - ) + if axis.coordinate_mode == "segment_map": + if segment_id_column is None or segment_position_column is None: + raise ValueError("segment_map plotting requires segment_id_column and segment_position_column.") + plot_table, axis_table = _prepare_segment_map_plot_data( + table, + axis=axis, + segment_id_column=segment_id_column, + segment_position_column=segment_position_column, + ) + else: + if position_column is None or anchor_column is None: + raise ValueError("fixed_window plotting requires position_column and anchor_column.") + plot_table, axis_table = _prepare_fixed_window_plot_data( + table, + axis=axis, + position_column=position_column, + anchor_column=anchor_column, + region_strand_column=region_strand_column, + ) + metadata = { "plot_family": plot_family, "orientation": axis.orientation, @@ -188,6 +262,8 @@ def prepare_aggregate_plot_data( "signal_normalization": aggregation.signal_normalization, "layout": aggregation.layout, } + if axis.coordinate_mode == "segment_map": + metadata["segment_count"] = len(axis_table) return {"plot_table": plot_table, "axis_table": axis_table, "metadata": metadata} diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 1f1f812..603cf6e 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -307,3 +307,120 @@ def test_prepare_aggregate_plot_data_retains_metadata_for_fixed_window(): assert {"plot_table", "axis_table", "metadata"} <= set(payload) assert payload["metadata"]["orientation"] == "region_5to3" + + +def test_prepare_single_read_plot_data_rejects_segment_map_axes(): + reads = pd.DataFrame( + [ + { + "region_id": "reg1", + "region_strand": "+", + "event_pos": 110, + "anchor": 100, + "read_id": "r1", + } + ] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="segment_map", + segments=[ + plotting.SegmentSpec( + segment_id="body", + label="Body", + start_ref=100, + end_ref=200, + ) + ], + ) + + with pytest.raises(ValueError, match="segment_map is aggregate-only"): + plotting.prepare_single_read_plot_data( + reads, + plot_family="single_read_raster", + axis=axis, + position_column="event_pos", + anchor_column="anchor", + region_strand_column="region_strand", + ) + + +def test_prepare_aggregate_plot_data_builds_concatenated_segment_axis(): + table = pd.DataFrame( + [ + {"region_id": "reg1", "segment_id": "upstream", "segment_pos": 0, "signal": 1.0}, + {"region_id": "reg1", "segment_id": "body", "segment_pos": 10, "signal": 2.0}, + ] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="segment_map", + segments=[ + plotting.SegmentSpec("upstream", "Upstream", 0, 100, "raw", bins=20), + plotting.SegmentSpec("body", "Body", 100, 400, "scaled", bins=50, contiguous_with_previous=True), + ], + ) + aggregation = plotting.AggregationSpec( + weighting="equal_region", + within_region_summary="mean", + signal_normalization="none", + layout="concatenated", + ) + + payload = plotting.prepare_aggregate_plot_data( + table, + plot_family="aggregate_profile", + axis=axis, + aggregation=aggregation, + value_column="signal", + segment_id_column="segment_id", + segment_position_column="segment_pos", + ) + + assert list(payload["axis_table"]["segment_id"]) == ["upstream", "body"] + assert list(payload["axis_table"]["plot_start"]) == [0, 20] + assert list(payload["axis_table"]["plot_end"]) == [20, 70] + assert payload["axis_table"]["plot_start"].is_monotonic_increasing + assert list(payload["plot_table"]["plot_x"]) == [0.0, 30.0] + + +def test_prepare_aggregate_plot_data_marks_non_contiguous_segment_breaks(): + table = pd.DataFrame( + [{"region_id": "reg1", "segment_id": "exon1", "segment_pos": 5, "signal": 1.0}] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="segment_map", + segments=[ + plotting.SegmentSpec("exon1", "Exon 1", 100, 200, "scaled", bins=20), + plotting.SegmentSpec( + "exon3", + "Exon 3", + 500, + 650, + "scaled", + bins=20, + contiguous_with_previous=False, + plot_gap_after=True, + ), + ], + ) + aggregation = plotting.AggregationSpec( + weighting="equal_region", + within_region_summary="mean", + signal_normalization="none", + layout="faceted", + ) + + payload = plotting.prepare_aggregate_plot_data( + table, + plot_family="aggregate_profile", + axis=axis, + aggregation=aggregation, + value_column="signal", + segment_id_column="segment_id", + segment_position_column="segment_pos", + ) + + assert list(payload["axis_table"]["contiguous_with_previous"]) == [True, False] + assert list(payload["axis_table"]["plot_gap_after"]) == [False, True] From 841bece7ec3db8918c26f8336de2e0ca658acd8c Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 19:03:03 -0700 Subject: [PATCH 101/272] fix: validate segment map plot inputs --- dimelo/plotting.py | 25 ++++++++++++++--- tests/test_plotting.py | 61 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 83 insertions(+), 3 deletions(-) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 9c2199b..bfb2936 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -176,17 +176,36 @@ def _prepare_segment_map_plot_data( axis_table = _build_segment_axis_table(axis.segments) plot_table = table.copy() - axis_lookup = axis_table.loc[:, ["segment_id", "plot_start"]].rename( + axis_lookup = axis_table.loc[:, ["segment_id", "plot_start", "plot_end"]].rename( columns={"segment_id": "_axis_segment_id"} ) + axis_lookup["segment_span"] = axis_lookup["plot_end"] - axis_lookup["plot_start"] plot_table = plot_table.merge( axis_lookup, left_on=segment_id_column, right_on="_axis_segment_id", how="left", ) - plot_table["plot_x"] = plot_table["plot_start"] + plot_table[segment_position_column].astype(float) - plot_table = plot_table.drop(columns=["_axis_segment_id", "plot_start"]) + unknown_segment_mask = plot_table["plot_start"].isna() + if unknown_segment_mask.any(): + unknown_segment_ids = sorted(plot_table.loc[unknown_segment_mask, segment_id_column].astype(str).unique()) + raise ValueError( + "segment_map plotting received unknown segment_id values: " + f"{', '.join(unknown_segment_ids)}." + ) + + segment_positions = pd.to_numeric(plot_table[segment_position_column], errors="raise") + invalid_position_mask = (segment_positions < 0) | (segment_positions >= plot_table["segment_span"]) + if invalid_position_mask.any(): + invalid_rows = plot_table.loc[invalid_position_mask, [segment_id_column, segment_position_column, "segment_span"]] + raise ValueError( + "segment_position_column values must stay within the declared segment span " + "for each segment." + f" Invalid rows: {invalid_rows.to_dict(orient='records')}." + ) + + plot_table["plot_x"] = plot_table["plot_start"] + segment_positions + plot_table = plot_table.drop(columns=["_axis_segment_id", "plot_start", "plot_end", "segment_span"]) return plot_table, axis_table diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 603cf6e..1171d8e 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -384,6 +384,67 @@ def test_prepare_aggregate_plot_data_builds_concatenated_segment_axis(): assert list(payload["plot_table"]["plot_x"]) == [0.0, 30.0] +def test_prepare_aggregate_plot_data_rejects_unknown_segment_ids(): + table = pd.DataFrame( + [{"region_id": "reg1", "segment_id": "unknown", "segment_pos": 1, "signal": 1.0}] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="segment_map", + segments=[ + plotting.SegmentSpec("upstream", "Upstream", 0, 100, "raw", bins=20), + ], + ) + aggregation = plotting.AggregationSpec( + weighting="equal_region", + within_region_summary="mean", + signal_normalization="none", + layout="concatenated", + ) + + with pytest.raises(ValueError, match="unknown segment_id values"): + plotting.prepare_aggregate_plot_data( + table, + plot_family="aggregate_profile", + axis=axis, + aggregation=aggregation, + value_column="signal", + segment_id_column="segment_id", + segment_position_column="segment_pos", + ) + + +@pytest.mark.parametrize("segment_pos", [-1, 20]) +def test_prepare_aggregate_plot_data_rejects_segment_positions_outside_declared_span(segment_pos): + table = pd.DataFrame( + [{"region_id": "reg1", "segment_id": "upstream", "segment_pos": segment_pos, "signal": 1.0}] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="segment_map", + segments=[ + plotting.SegmentSpec("upstream", "Upstream", 0, 100, "raw", bins=20), + ], + ) + aggregation = plotting.AggregationSpec( + weighting="equal_region", + within_region_summary="mean", + signal_normalization="none", + layout="concatenated", + ) + + with pytest.raises(ValueError, match="declared segment span"): + plotting.prepare_aggregate_plot_data( + table, + plot_family="aggregate_profile", + axis=axis, + aggregation=aggregation, + value_column="signal", + segment_id_column="segment_id", + segment_position_column="segment_pos", + ) + + def test_prepare_aggregate_plot_data_marks_non_contiguous_segment_breaks(): table = pd.DataFrame( [{"region_id": "reg1", "segment_id": "exon1", "segment_pos": 5, "signal": 1.0}] From aaf192d9053d7a2941347fb768463398b55eae4c Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 19:08:02 -0700 Subject: [PATCH 102/272] fix: harden segment map plotting prep --- dimelo/plotting.py | 17 ++++++++++++ tests/test_plotting.py | 61 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 78 insertions(+) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index bfb2936..c2f1c0b 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -1,5 +1,6 @@ from __future__ import annotations +from collections import Counter from dataclasses import dataclass import pandas as pd @@ -136,6 +137,14 @@ def _prepare_fixed_window_plot_data( def _build_segment_axis_table(segments: list[SegmentSpec]) -> pd.DataFrame: + segment_id_counts = Counter(segment.segment_id for segment in segments) + duplicate_segment_ids = sorted(segment_id for segment_id, count in segment_id_counts.items() if count > 1) + if duplicate_segment_ids: + raise ValueError( + "segment_map axis.segments contains duplicate segment_id values: " + f"{', '.join(duplicate_segment_ids)}." + ) + rows: list[dict[str, object]] = [] running_start = 0 @@ -195,6 +204,14 @@ def _prepare_segment_map_plot_data( ) segment_positions = pd.to_numeric(plot_table[segment_position_column], errors="raise") + missing_position_mask = segment_positions.isna() + if missing_position_mask.any(): + invalid_rows = plot_table.loc[missing_position_mask, [segment_id_column, segment_position_column]] + raise ValueError( + "segment_position_column contains missing or NaN values. " + f"Invalid rows: {invalid_rows.to_dict(orient='records')}." + ) + invalid_position_mask = (segment_positions < 0) | (segment_positions >= plot_table["segment_span"]) if invalid_position_mask.any(): invalid_rows = plot_table.loc[invalid_position_mask, [segment_id_column, segment_position_column, "segment_span"]] diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 1171d8e..22d73af 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -384,6 +384,37 @@ def test_prepare_aggregate_plot_data_builds_concatenated_segment_axis(): assert list(payload["plot_table"]["plot_x"]) == [0.0, 30.0] +def test_prepare_aggregate_plot_data_rejects_duplicate_segment_ids_in_axis_segments(): + table = pd.DataFrame( + [{"region_id": "reg1", "segment_id": "upstream", "segment_pos": 1, "signal": 1.0}] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="segment_map", + segments=[ + plotting.SegmentSpec("upstream", "Upstream A", 0, 100, "raw", bins=20), + plotting.SegmentSpec("upstream", "Upstream B", 100, 200, "raw", bins=20), + ], + ) + aggregation = plotting.AggregationSpec( + weighting="equal_region", + within_region_summary="mean", + signal_normalization="none", + layout="concatenated", + ) + + with pytest.raises(ValueError, match="duplicate segment_id values"): + plotting.prepare_aggregate_plot_data( + table, + plot_family="aggregate_profile", + axis=axis, + aggregation=aggregation, + value_column="signal", + segment_id_column="segment_id", + segment_position_column="segment_pos", + ) + + def test_prepare_aggregate_plot_data_rejects_unknown_segment_ids(): table = pd.DataFrame( [{"region_id": "reg1", "segment_id": "unknown", "segment_pos": 1, "signal": 1.0}] @@ -414,6 +445,36 @@ def test_prepare_aggregate_plot_data_rejects_unknown_segment_ids(): ) +def test_prepare_aggregate_plot_data_rejects_missing_segment_positions(): + table = pd.DataFrame( + [{"region_id": "reg1", "segment_id": "upstream", "segment_pos": float("nan"), "signal": 1.0}] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="segment_map", + segments=[ + plotting.SegmentSpec("upstream", "Upstream", 0, 100, "raw", bins=20), + ], + ) + aggregation = plotting.AggregationSpec( + weighting="equal_region", + within_region_summary="mean", + signal_normalization="none", + layout="concatenated", + ) + + with pytest.raises(ValueError, match="missing or NaN values"): + plotting.prepare_aggregate_plot_data( + table, + plot_family="aggregate_profile", + axis=axis, + aggregation=aggregation, + value_column="signal", + segment_id_column="segment_id", + segment_position_column="segment_pos", + ) + + @pytest.mark.parametrize("segment_pos", [-1, 20]) def test_prepare_aggregate_plot_data_rejects_segment_positions_outside_declared_span(segment_pos): table = pd.DataFrame( From e75897f3dc3675eae08c126284ca7d171e2384f3 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 19:25:40 -0700 Subject: [PATCH 103/272] Harden segment map plotting validation --- dimelo/plotting.py | 60 +++++++++++++++++++++++++++----- tests/test_plotting.py | 79 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 131 insertions(+), 8 deletions(-) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index c2f1c0b..f4c5c23 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -7,6 +7,17 @@ from dimelo.distribution import _require_columns +_SEGMENT_AXIS_INTERNAL_SEGMENT_ID = "__dimelo_segment_axis_segment_id" +_SEGMENT_AXIS_INTERNAL_PLOT_START = "__dimelo_segment_axis_plot_start" +_SEGMENT_AXIS_INTERNAL_PLOT_END = "__dimelo_segment_axis_plot_end" +_SEGMENT_AXIS_INTERNAL_SEGMENT_SPAN = "__dimelo_segment_axis_segment_span" +_SEGMENT_AXIS_INTERNAL_COLUMNS = { + _SEGMENT_AXIS_INTERNAL_SEGMENT_ID, + _SEGMENT_AXIS_INTERNAL_PLOT_START, + _SEGMENT_AXIS_INTERNAL_PLOT_END, + _SEGMENT_AXIS_INTERNAL_SEGMENT_SPAN, +} + @dataclass(frozen=True) class SegmentSpec: @@ -149,6 +160,17 @@ def _build_segment_axis_table(segments: list[SegmentSpec]) -> pd.DataFrame: running_start = 0 for segment in segments: + if segment.bins is not None and segment.bins <= 0: + raise ValueError( + "segment_map axis.segments contains invalid bins values: " + f"{segment.segment_id} has bins={segment.bins!r}." + ) + if segment.mode == "raw" and segment.end_ref <= segment.start_ref: + raise ValueError( + "segment_map axis.segments contains invalid raw span values: " + f"{segment.segment_id} has start_ref={segment.start_ref!r} and end_ref={segment.end_ref!r}." + ) + span = segment.bins if segment.bins is not None else segment.end_ref - segment.start_ref rows.append( { @@ -182,20 +204,32 @@ def _prepare_segment_map_plot_data( raise ValueError("segment_map requires segments.") _require_columns(table, (segment_id_column, segment_position_column), "plot_table") + reserved_columns = _SEGMENT_AXIS_INTERNAL_COLUMNS.intersection(table.columns) + if reserved_columns: + raise ValueError( + "segment_map plotting received plot_table columns reserved for internal use: " + f"{', '.join(sorted(reserved_columns))}." + ) axis_table = _build_segment_axis_table(axis.segments) plot_table = table.copy() axis_lookup = axis_table.loc[:, ["segment_id", "plot_start", "plot_end"]].rename( - columns={"segment_id": "_axis_segment_id"} + columns={ + "segment_id": _SEGMENT_AXIS_INTERNAL_SEGMENT_ID, + "plot_start": _SEGMENT_AXIS_INTERNAL_PLOT_START, + "plot_end": _SEGMENT_AXIS_INTERNAL_PLOT_END, + } + ) + axis_lookup[_SEGMENT_AXIS_INTERNAL_SEGMENT_SPAN] = ( + axis_lookup[_SEGMENT_AXIS_INTERNAL_PLOT_END] - axis_lookup[_SEGMENT_AXIS_INTERNAL_PLOT_START] ) - axis_lookup["segment_span"] = axis_lookup["plot_end"] - axis_lookup["plot_start"] plot_table = plot_table.merge( axis_lookup, left_on=segment_id_column, - right_on="_axis_segment_id", + right_on=_SEGMENT_AXIS_INTERNAL_SEGMENT_ID, how="left", ) - unknown_segment_mask = plot_table["plot_start"].isna() + unknown_segment_mask = plot_table[_SEGMENT_AXIS_INTERNAL_PLOT_START].isna() if unknown_segment_mask.any(): unknown_segment_ids = sorted(plot_table.loc[unknown_segment_mask, segment_id_column].astype(str).unique()) raise ValueError( @@ -212,17 +246,27 @@ def _prepare_segment_map_plot_data( f"Invalid rows: {invalid_rows.to_dict(orient='records')}." ) - invalid_position_mask = (segment_positions < 0) | (segment_positions >= plot_table["segment_span"]) + invalid_position_mask = ( + (segment_positions < 0) | (segment_positions >= plot_table[_SEGMENT_AXIS_INTERNAL_SEGMENT_SPAN]) + ) if invalid_position_mask.any(): - invalid_rows = plot_table.loc[invalid_position_mask, [segment_id_column, segment_position_column, "segment_span"]] + invalid_rows = plot_table.loc[invalid_position_mask, [segment_id_column, segment_position_column]].copy() + invalid_rows["segment_span"] = plot_table.loc[invalid_position_mask, _SEGMENT_AXIS_INTERNAL_SEGMENT_SPAN].values raise ValueError( "segment_position_column values must stay within the declared segment span " "for each segment." f" Invalid rows: {invalid_rows.to_dict(orient='records')}." ) - plot_table["plot_x"] = plot_table["plot_start"] + segment_positions - plot_table = plot_table.drop(columns=["_axis_segment_id", "plot_start", "plot_end", "segment_span"]) + plot_table["plot_x"] = plot_table[_SEGMENT_AXIS_INTERNAL_PLOT_START] + segment_positions + plot_table = plot_table.drop( + columns=[ + _SEGMENT_AXIS_INTERNAL_SEGMENT_ID, + _SEGMENT_AXIS_INTERNAL_PLOT_START, + _SEGMENT_AXIS_INTERNAL_PLOT_END, + _SEGMENT_AXIS_INTERNAL_SEGMENT_SPAN, + ] + ) return plot_table, axis_table diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 22d73af..e53c18d 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -546,3 +546,82 @@ def test_prepare_aggregate_plot_data_marks_non_contiguous_segment_breaks(): assert list(payload["axis_table"]["contiguous_with_previous"]) == [True, False] assert list(payload["axis_table"]["plot_gap_after"]) == [False, True] + + +@pytest.mark.parametrize( + "segment", + [ + plotting.SegmentSpec("bad_bins", "Bad bins", 0, 100, "raw", bins=0), + plotting.SegmentSpec("bad_bins_neg", "Bad bins negative", 0, 100, "scaled", bins=-5), + plotting.SegmentSpec("bad_raw", "Bad raw", 100, 100, "raw"), + plotting.SegmentSpec("bad_raw_reverse", "Bad raw reverse", 200, 100, "raw", bins=20), + ], +) +def test_prepare_aggregate_plot_data_rejects_malformed_segment_spans(segment): + table = pd.DataFrame( + [{"region_id": "reg1", "segment_id": "bad_raw", "segment_pos": 1, "signal": 1.0}] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="segment_map", + segments=[segment], + ) + aggregation = plotting.AggregationSpec( + weighting="equal_region", + within_region_summary="mean", + signal_normalization="none", + layout="concatenated", + ) + + with pytest.raises(ValueError, match="invalid"): + plotting.prepare_aggregate_plot_data( + table, + plot_family="aggregate_profile", + axis=axis, + aggregation=aggregation, + value_column="signal", + segment_id_column="segment_id", + segment_position_column="segment_pos", + ) + + +def test_prepare_aggregate_plot_data_segment_map_keeps_user_plot_columns(): + table = pd.DataFrame( + [ + { + "region_id": "reg1", + "segment_id": "upstream", + "segment_pos": 3, + "plot_start": "user-start", + "plot_end": "user-end", + "signal": 1.0, + } + ] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="segment_map", + segments=[ + plotting.SegmentSpec("upstream", "Upstream", 0, 100, "raw", bins=20), + ], + ) + aggregation = plotting.AggregationSpec( + weighting="equal_region", + within_region_summary="mean", + signal_normalization="none", + layout="concatenated", + ) + + payload = plotting.prepare_aggregate_plot_data( + table, + plot_family="aggregate_profile", + axis=axis, + aggregation=aggregation, + value_column="signal", + segment_id_column="segment_id", + segment_position_column="segment_pos", + ) + + assert list(payload["plot_table"]["plot_start"]) == ["user-start"] + assert list(payload["plot_table"]["plot_end"]) == ["user-end"] + assert list(payload["plot_table"]["plot_x"]) == [3.0] From 11ca0edee59bd2d77d87343a97594a4d46cb16ca Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 19:30:29 -0700 Subject: [PATCH 104/272] Harden segment map validation --- dimelo/plotting.py | 10 +++++++ tests/test_plotting.py | 63 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 73 insertions(+) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index f4c5c23..367a3c0 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -160,11 +160,21 @@ def _build_segment_axis_table(segments: list[SegmentSpec]) -> pd.DataFrame: running_start = 0 for segment in segments: + if segment.mode not in {"raw", "scaled"}: + raise ValueError( + "segment_map axis.segments contains invalid mode values: " + f"{segment.segment_id} has mode={segment.mode!r}; mode must be 'raw' or 'scaled'." + ) if segment.bins is not None and segment.bins <= 0: raise ValueError( "segment_map axis.segments contains invalid bins values: " f"{segment.segment_id} has bins={segment.bins!r}." ) + if segment.mode == "scaled" and segment.bins is None and segment.end_ref <= segment.start_ref: + raise ValueError( + "segment_map axis.segments contains invalid scaled span values: " + f"{segment.segment_id} has start_ref={segment.start_ref!r} and end_ref={segment.end_ref!r}." + ) if segment.mode == "raw" and segment.end_ref <= segment.start_ref: raise ValueError( "segment_map axis.segments contains invalid raw span values: " diff --git a/tests/test_plotting.py b/tests/test_plotting.py index e53c18d..1d967f6 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -585,6 +585,69 @@ def test_prepare_aggregate_plot_data_rejects_malformed_segment_spans(segment): ) +def test_prepare_aggregate_plot_data_rejects_invalid_segment_mode(): + table = pd.DataFrame( + [{"region_id": "reg1", "segment_id": "upstream", "segment_pos": 1, "signal": 1.0}] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="segment_map", + segments=[ + plotting.SegmentSpec("upstream", "Upstream", 0, 100, "bogus", bins=20), + ], + ) + aggregation = plotting.AggregationSpec( + weighting="equal_region", + within_region_summary="mean", + signal_normalization="none", + layout="concatenated", + ) + + with pytest.raises(ValueError, match="mode must be 'raw' or 'scaled'"): + plotting.prepare_aggregate_plot_data( + table, + plot_family="aggregate_profile", + axis=axis, + aggregation=aggregation, + value_column="signal", + segment_id_column="segment_id", + segment_position_column="segment_pos", + ) + + +@pytest.mark.parametrize("start_ref, end_ref", [(100, 100), (200, 100)]) +def test_prepare_aggregate_plot_data_rejects_zero_or_negative_width_scaled_segment_without_bins( + start_ref, end_ref +): + table = pd.DataFrame( + [{"region_id": "reg1", "segment_id": "body", "segment_pos": 1, "signal": 1.0}] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="segment_map", + segments=[ + plotting.SegmentSpec("body", "Body", start_ref, end_ref, "scaled"), + ], + ) + aggregation = plotting.AggregationSpec( + weighting="equal_region", + within_region_summary="mean", + signal_normalization="none", + layout="concatenated", + ) + + with pytest.raises(ValueError, match="invalid scaled span"): + plotting.prepare_aggregate_plot_data( + table, + plot_family="aggregate_profile", + axis=axis, + aggregation=aggregation, + value_column="signal", + segment_id_column="segment_id", + segment_position_column="segment_pos", + ) + + def test_prepare_aggregate_plot_data_segment_map_keeps_user_plot_columns(): table = pd.DataFrame( [ From db7aabc546ad12b01400ba06ca05ef8d1568b881 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 19:35:10 -0700 Subject: [PATCH 105/272] refactor: route aggregate plotter through plotting core --- dimelo/plot_enrichment_profile.py | 57 ++++++++++++++++++++++++++++++- tests/test_plotting.py | 46 +++++++++++++++++++++++-- 2 files changed, 100 insertions(+), 3 deletions(-) diff --git a/dimelo/plot_enrichment_profile.py b/dimelo/plot_enrichment_profile.py index 20a625c..861355e 100644 --- a/dimelo/plot_enrichment_profile.py +++ b/dimelo/plot_enrichment_profile.py @@ -1,9 +1,58 @@ from pathlib import Path import numpy as np +import pandas as pd from matplotlib.axes import Axes -from . import load_processed, utils +from . import load_processed, plotting, utils + + +def _legacy_aggregate_axis_spec( + *, + window_size: int, + relative: bool, + regions_5to3prime: bool, +) -> plotting.AxisSpec: + return plotting.AxisSpec( + orientation="region_5to3" if regions_5to3prime else "genomic", + coordinate_mode="fixed_window", + anchor="center" if relative else "absolute", + upstream_bp=window_size // 2, + downstream_bp=window_size // 2, + ) + + +def _route_legacy_aggregate_axis_through_shared_core( + *, + window_size: int, + relative: bool, + regions_5to3prime: bool, +) -> None: + axis = _legacy_aggregate_axis_spec( + window_size=window_size, + relative=relative, + regions_5to3prime=regions_5to3prime, + ) + aggregation = plotting.AggregationSpec() + plotting.prepare_aggregate_plot_data( + pd.DataFrame( + [ + { + "position": 0, + "anchor": 0, + "region_strand": "-" if regions_5to3prime else "+", + "value": 0.0, + } + ] + ), + plot_family="aggregate_profile", + axis=axis, + aggregation=aggregation, + value_column="value", + position_column="position", + anchor_column="anchor", + region_strand_column="region_strand", + ) def plot_enrichment_profile( @@ -67,6 +116,12 @@ def plot_enrichment_profile( cores=cores, ) + _route_legacy_aggregate_axis_through_shared_core( + window_size=window_size, + relative=relative, + regions_5to3prime=regions_5to3prime, + ) + if relative: offset_center = 0 else: diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 1d967f6..a38d9d2 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -1,7 +1,8 @@ -import pytest import pandas as pd +import numpy as np +import pytest -from dimelo import plotting +from dimelo import plot_enrichment_profile, plotting def test_axis_spec_accepts_fixed_window_region_5to3(): @@ -309,6 +310,47 @@ def test_prepare_aggregate_plot_data_retains_metadata_for_fixed_window(): assert payload["metadata"]["orientation"] == "region_5to3" +def test_legacy_enrichment_profile_routes_regions_5to3prime_through_shared_prep(monkeypatch): + called = {} + + def fake_prepare_aggregate_plot_data(table, *, plot_family, axis, aggregation, **kwargs): + called["table"] = table + called["plot_family"] = plot_family + called["axis"] = axis + called["aggregation"] = aggregation + return { + "plot_table": table.copy(), + "axis_table": pd.DataFrame(), + "metadata": {}, + } + + monkeypatch.setattr(plotting, "prepare_aggregate_plot_data", fake_prepare_aggregate_plot_data) + monkeypatch.setattr( + "dimelo.plot_enrichment_profile.get_enrichment_profiles", + lambda **kwargs: [np.array([0.25, 0.75])], + ) + monkeypatch.setattr( + "dimelo.plot_enrichment_profile.make_enrichment_profile_plot", + lambda **kwargs: object(), + ) + + result = plot_enrichment_profile.plot_enrichment_profile( + mod_file_names=["sample.fake"], + regions_list=["regions.bed"], + motifs=["A"], + sample_names=["sample"], + window_size=10, + regions_5to3prime=True, + ) + + assert result is not None + assert called["plot_family"] == "aggregate_profile" + assert called["axis"].orientation == "region_5to3" + assert called["axis"].coordinate_mode == "fixed_window" + assert called["axis"].anchor == "center" + assert called["aggregation"].layout == "faceted" + + def test_prepare_single_read_plot_data_rejects_segment_map_axes(): reads = pd.DataFrame( [ From 03fe0a8445bbaa44230416ada582e1615bd4348a Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 19:39:43 -0700 Subject: [PATCH 106/272] refactor: route aggregate plotter through plotting core --- dimelo/plot_enrichment_profile.py | 75 ++++++++++++++++++++++++------- tests/test_plotting.py | 23 +++++++++- 2 files changed, 81 insertions(+), 17 deletions(-) diff --git a/dimelo/plot_enrichment_profile.py b/dimelo/plot_enrichment_profile.py index 861355e..626640a 100644 --- a/dimelo/plot_enrichment_profile.py +++ b/dimelo/plot_enrichment_profile.py @@ -17,34 +17,73 @@ def _legacy_aggregate_axis_spec( orientation="region_5to3" if regions_5to3prime else "genomic", coordinate_mode="fixed_window", anchor="center" if relative else "absolute", - upstream_bp=window_size // 2, - downstream_bp=window_size // 2, + upstream_bp=window_size, + downstream_bp=window_size, ) +def _legacy_aggregate_profile_table( + trace_vectors: list[np.ndarray], + sample_names: list[str], + *, + regions_5to3prime: bool, +) -> pd.DataFrame: + rows: list[dict[str, object]] = [] + region_strand = "-" if regions_5to3prime else "+" + + for sample_name, trace_vector in zip(sample_names, trace_vectors, strict=True): + positions = np.arange( + -(len(trace_vector) // 2), + len(trace_vector) // 2 + len(trace_vector) % 2, + ) + for position, value in zip(positions, trace_vector, strict=True): + rows.append( + { + "sample_name": sample_name, + "position": float(position), + "anchor": 0.0, + "region_strand": region_strand, + "value": float(value), + } + ) + + return pd.DataFrame(rows) + + +def _prepare_legacy_aggregate_profile_vectors( + prepared_table: pd.DataFrame, + *, + sample_names: list[str], +) -> list[np.ndarray]: + prepared_vectors: list[np.ndarray] = [] + for sample_name in sample_names: + sample_table = prepared_table.loc[prepared_table["sample_name"] == sample_name].copy() + sample_table = sample_table.sort_values("plot_x") + prepared_vectors.append(sample_table["value"].to_numpy()) + return prepared_vectors + + def _route_legacy_aggregate_axis_through_shared_core( *, window_size: int, relative: bool, regions_5to3prime: bool, -) -> None: + trace_vectors: list[np.ndarray], + sample_names: list[str], +) -> list[np.ndarray]: axis = _legacy_aggregate_axis_spec( window_size=window_size, relative=relative, regions_5to3prime=regions_5to3prime, ) aggregation = plotting.AggregationSpec() - plotting.prepare_aggregate_plot_data( - pd.DataFrame( - [ - { - "position": 0, - "anchor": 0, - "region_strand": "-" if regions_5to3prime else "+", - "value": 0.0, - } - ] - ), + aggregate_table = _legacy_aggregate_profile_table( + trace_vectors, + sample_names, + regions_5to3prime=regions_5to3prime, + ) + prepared_payload = plotting.prepare_aggregate_plot_data( + aggregate_table, plot_family="aggregate_profile", axis=axis, aggregation=aggregation, @@ -53,6 +92,10 @@ def _route_legacy_aggregate_axis_through_shared_core( anchor_column="anchor", region_strand_column="region_strand", ) + return _prepare_legacy_aggregate_profile_vectors( + prepared_payload["plot_table"], + sample_names=sample_names, + ) def plot_enrichment_profile( @@ -116,10 +159,12 @@ def plot_enrichment_profile( cores=cores, ) - _route_legacy_aggregate_axis_through_shared_core( + trace_vectors = _route_legacy_aggregate_axis_through_shared_core( window_size=window_size, relative=relative, regions_5to3prime=regions_5to3prime, + trace_vectors=trace_vectors, + sample_names=sample_names, ) if relative: diff --git a/tests/test_plotting.py b/tests/test_plotting.py index a38d9d2..eb4a886 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -312,6 +312,7 @@ def test_prepare_aggregate_plot_data_retains_metadata_for_fixed_window(): def test_legacy_enrichment_profile_routes_regions_5to3prime_through_shared_prep(monkeypatch): called = {} + captured = {} def fake_prepare_aggregate_plot_data(table, *, plot_family, axis, aggregation, **kwargs): called["table"] = table @@ -319,7 +320,13 @@ def fake_prepare_aggregate_plot_data(table, *, plot_family, axis, aggregation, * called["axis"] = axis called["aggregation"] = aggregation return { - "plot_table": table.copy(), + "plot_table": pd.DataFrame( + { + "sample_name": ["sample", "sample"], + "plot_x": [1.0, 0.0], + "value": [9.0, 8.0], + } + ), "axis_table": pd.DataFrame(), "metadata": {}, } @@ -329,9 +336,16 @@ def fake_prepare_aggregate_plot_data(table, *, plot_family, axis, aggregation, * "dimelo.plot_enrichment_profile.get_enrichment_profiles", lambda **kwargs: [np.array([0.25, 0.75])], ) + + def fake_make_enrichment_profile_plot(*, trace_vectors, sample_names, offset_center=0, **kwargs): + captured["trace_vectors"] = trace_vectors + captured["sample_names"] = sample_names + captured["offset_center"] = offset_center + return object() + monkeypatch.setattr( "dimelo.plot_enrichment_profile.make_enrichment_profile_plot", - lambda **kwargs: object(), + fake_make_enrichment_profile_plot, ) result = plot_enrichment_profile.plot_enrichment_profile( @@ -349,6 +363,11 @@ def fake_prepare_aggregate_plot_data(table, *, plot_family, axis, aggregation, * assert called["axis"].coordinate_mode == "fixed_window" assert called["axis"].anchor == "center" assert called["aggregation"].layout == "faceted" + assert list(called["table"]["sample_name"]) == ["sample", "sample"] + assert list(called["table"]["value"]) == [0.25, 0.75] + assert len(captured["trace_vectors"]) == 1 + assert np.array_equal(captured["trace_vectors"][0], np.array([8.0, 9.0])) + assert captured["sample_names"] == ["sample"] def test_prepare_single_read_plot_data_rejects_segment_map_axes(): From 7e796c7f714955dee7e0b2a6c56fd9343ca4d006 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 19:46:45 -0700 Subject: [PATCH 107/272] refactor: route aggregate plotter through plotting core --- dimelo/plot_enrichment_profile.py | 6 +----- tests/test_plotting.py | 11 +++-------- 2 files changed, 4 insertions(+), 13 deletions(-) diff --git a/dimelo/plot_enrichment_profile.py b/dimelo/plot_enrichment_profile.py index 626640a..600ec50 100644 --- a/dimelo/plot_enrichment_profile.py +++ b/dimelo/plot_enrichment_profile.py @@ -25,11 +25,8 @@ def _legacy_aggregate_axis_spec( def _legacy_aggregate_profile_table( trace_vectors: list[np.ndarray], sample_names: list[str], - *, - regions_5to3prime: bool, ) -> pd.DataFrame: rows: list[dict[str, object]] = [] - region_strand = "-" if regions_5to3prime else "+" for sample_name, trace_vector in zip(sample_names, trace_vectors, strict=True): positions = np.arange( @@ -42,7 +39,7 @@ def _legacy_aggregate_profile_table( "sample_name": sample_name, "position": float(position), "anchor": 0.0, - "region_strand": region_strand, + "region_strand": "+", "value": float(value), } ) @@ -80,7 +77,6 @@ def _route_legacy_aggregate_axis_through_shared_core( aggregate_table = _legacy_aggregate_profile_table( trace_vectors, sample_names, - regions_5to3prime=regions_5to3prime, ) prepared_payload = plotting.prepare_aggregate_plot_data( aggregate_table, diff --git a/tests/test_plotting.py b/tests/test_plotting.py index eb4a886..0727eca 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -319,14 +319,9 @@ def fake_prepare_aggregate_plot_data(table, *, plot_family, axis, aggregation, * called["plot_family"] = plot_family called["axis"] = axis called["aggregation"] = aggregation + assert set(table["region_strand"]) == {"+"} return { - "plot_table": pd.DataFrame( - { - "sample_name": ["sample", "sample"], - "plot_x": [1.0, 0.0], - "value": [9.0, 8.0], - } - ), + "plot_table": table.copy().assign(plot_x=table["position"]), "axis_table": pd.DataFrame(), "metadata": {}, } @@ -366,7 +361,7 @@ def fake_make_enrichment_profile_plot(*, trace_vectors, sample_names, offset_cen assert list(called["table"]["sample_name"]) == ["sample", "sample"] assert list(called["table"]["value"]) == [0.25, 0.75] assert len(captured["trace_vectors"]) == 1 - assert np.array_equal(captured["trace_vectors"][0], np.array([8.0, 9.0])) + assert np.array_equal(captured["trace_vectors"][0], np.array([0.25, 0.75])) assert captured["sample_names"] == ["sample"] From 79eefe2a9e4a58fb0b68e7e038a85828edc6e02e Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 19:51:01 -0700 Subject: [PATCH 108/272] Tighten plotting regression coverage --- tests/test_plotting.py | 44 ++++++++++++++++++++++++++++++++---------- 1 file changed, 34 insertions(+), 10 deletions(-) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 0727eca..44ab3f2 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -310,27 +310,48 @@ def test_prepare_aggregate_plot_data_retains_metadata_for_fixed_window(): assert payload["metadata"]["orientation"] == "region_5to3" -def test_legacy_enrichment_profile_routes_regions_5to3prime_through_shared_prep(monkeypatch): +@pytest.mark.parametrize( + "relative, regions_dict, expected_anchor, expected_offset_center", + [ + (True, None, "center", 0), + (False, {"regions.bed": [(100, 140)]}, "absolute", 120), + ], +) +def test_legacy_enrichment_profile_routes_regions_5to3prime_through_shared_prep( + monkeypatch, + relative, + regions_dict, + expected_anchor, + expected_offset_center, +): called = {} captured = {} - def fake_prepare_aggregate_plot_data(table, *, plot_family, axis, aggregation, **kwargs): + real_prepare_aggregate_plot_data = plotting.prepare_aggregate_plot_data + + def spy_prepare_aggregate_plot_data(table, *, plot_family, axis, aggregation, **kwargs): called["table"] = table called["plot_family"] = plot_family called["axis"] = axis called["aggregation"] = aggregation - assert set(table["region_strand"]) == {"+"} - return { - "plot_table": table.copy().assign(plot_x=table["position"]), - "axis_table": pd.DataFrame(), - "metadata": {}, - } + return real_prepare_aggregate_plot_data( + table, + plot_family=plot_family, + axis=axis, + aggregation=aggregation, + **kwargs, + ) - monkeypatch.setattr(plotting, "prepare_aggregate_plot_data", fake_prepare_aggregate_plot_data) + monkeypatch.setattr(plotting, "prepare_aggregate_plot_data", spy_prepare_aggregate_plot_data) monkeypatch.setattr( "dimelo.plot_enrichment_profile.get_enrichment_profiles", lambda **kwargs: [np.array([0.25, 0.75])], ) + if regions_dict is not None: + monkeypatch.setattr( + "dimelo.plot_enrichment_profile.utils.regions_dict_from_input", + lambda *args, **kwargs: regions_dict, + ) def fake_make_enrichment_profile_plot(*, trace_vectors, sample_names, offset_center=0, **kwargs): captured["trace_vectors"] = trace_vectors @@ -349,6 +370,7 @@ def fake_make_enrichment_profile_plot(*, trace_vectors, sample_names, offset_cen motifs=["A"], sample_names=["sample"], window_size=10, + relative=relative, regions_5to3prime=True, ) @@ -356,13 +378,15 @@ def fake_make_enrichment_profile_plot(*, trace_vectors, sample_names, offset_cen assert called["plot_family"] == "aggregate_profile" assert called["axis"].orientation == "region_5to3" assert called["axis"].coordinate_mode == "fixed_window" - assert called["axis"].anchor == "center" + assert called["axis"].anchor == expected_anchor assert called["aggregation"].layout == "faceted" assert list(called["table"]["sample_name"]) == ["sample", "sample"] assert list(called["table"]["value"]) == [0.25, 0.75] + assert list(called["table"]["region_strand"]) == ["+", "+"] assert len(captured["trace_vectors"]) == 1 assert np.array_equal(captured["trace_vectors"][0], np.array([0.25, 0.75])) assert captured["sample_names"] == ["sample"] + assert captured["offset_center"] == expected_offset_center def test_prepare_single_read_plot_data_rejects_segment_map_axes(): From 5ef9f95bfb42dff2465a0fceb286468dd306128f Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 20:01:40 -0700 Subject: [PATCH 109/272] refactor: route single-read plotter through plotting core --- dimelo/plot_reads.py | 93 +++++++++++++++++++++++++++++++++++++++--- tests/test_plotting.py | 67 +++++++++++++++++++++++++++++- 2 files changed, 152 insertions(+), 8 deletions(-) diff --git a/dimelo/plot_reads.py b/dimelo/plot_reads.py index c6a80f2..1ffec62 100644 --- a/dimelo/plot_reads.py +++ b/dimelo/plot_reads.py @@ -10,13 +10,71 @@ Maybe this is an argument for an internal region class that makes checking easy? I don't know. """ +from collections.abc import Sequence +import math from pathlib import Path import pandas as pd import seaborn as sns from matplotlib.axes import Axes -from . import load_processed, utils +from . import load_processed, plotting, utils + + +def _legacy_single_read_axis_spec( + *, + relative: bool, + regions_5to3prime: bool, + window_size: int | None, + reads: Sequence[Sequence[object]], + regions_dict: dict | None, +) -> plotting.AxisSpec: + if relative: + if window_size is not None: + half_window = window_size + elif regions_dict is not None and len(regions_dict) > 0: + region_start, region_end, _ = next(iter(regions_dict.values()))[0] + half_window = (region_end - region_start) // 2 + else: + half_window = 0 + return plotting.AxisSpec( + orientation="region_5to3" if regions_5to3prime else "genomic", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=half_window, + downstream_bp=half_window, + ) + + absolute_bound = 0.0 + for read_positions in reads: + for position in read_positions: + absolute_bound = max(absolute_bound, abs(float(position))) + + return plotting.AxisSpec( + orientation="genomic", + coordinate_mode="fixed_window", + anchor="absolute", + upstream_bp=math.ceil(absolute_bound), + downstream_bp=math.ceil(absolute_bound), + ) + + +def _legacy_single_read_plot_table( + reads: Sequence[Sequence[object]], + read_names: Sequence[object], + mods: Sequence[object], + *, + relative: bool, + regions_5to3prime: bool, +) -> pd.DataFrame: + plot_table = pd.DataFrame({"read_name": read_names, "mod": mods, "pos": reads}).explode( + "pos" + ) + plot_table = plot_table.reset_index(drop=True) + plot_table["anchor"] = 0.0 + if relative and regions_5to3prime: + plot_table["region_strand"] = "+" + return plot_table def plot_reads( @@ -87,13 +145,36 @@ def plot_reads( ) ) - # Convert data frame where each row represents a read to a data frame where each row represents a single modified position in a read - df = pd.DataFrame({"read_name": read_names, "mod": mods, "pos": reads}).explode( - "pos" + plot_table = _legacy_single_read_plot_table( + reads, + read_names, + mods, + relative=relative, + regions_5to3prime=regions_5to3prime, + ) + axis = _legacy_single_read_axis_spec( + relative=relative, + regions_5to3prime=regions_5to3prime, + window_size=window_size, + reads=reads, + regions_dict=regions_dict, + ) + prep_kwargs: dict[str, str] = { + "position_column": "pos", + "anchor_column": "anchor", + } + if axis.orientation == "region_5to3": + prep_kwargs["region_strand_column"] = "region_strand" + + prepared = plotting.prepare_single_read_plot_data( + plot_table, + plot_family="single_read_raster", + axis=axis, + **prep_kwargs, ) axes = sns.scatterplot( - data=df, - x="pos", + data=prepared["plot_table"], + x="plot_x", y="read_name", hue="mod", # palette=colors, diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 44ab3f2..a924d90 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -1,8 +1,8 @@ -import pandas as pd import numpy as np +import pandas as pd import pytest -from dimelo import plot_enrichment_profile, plotting +from dimelo import plot_enrichment_profile, plot_reads, plotting def test_axis_spec_accepts_fixed_window_region_5to3(): @@ -425,6 +425,69 @@ def test_prepare_single_read_plot_data_rejects_segment_map_axes(): ) +def test_plot_reads_routes_region_5to3prime_into_shared_single_read_prep(monkeypatch): + captured = {} + + def fake_loader(**kwargs): + return ( + [np.array([110.0])], + np.array(["read-1"]), + np.array(["A,0"]), + {"chr1": [(100, 120, "-")]}, + ) + + real_prepare = plotting.prepare_single_read_plot_data + + def spy_prepare(table, *, plot_family, axis, **kwargs): + captured["table"] = table + captured["plot_family"] = plot_family + captured["axis"] = axis + captured["kwargs"] = kwargs + return real_prepare(table, plot_family=plot_family, axis=axis, **kwargs) + + class FakeAxes: + def __init__(self): + self.legend_ = None + self.xlim = None + + def legend(self, *args, **kwargs): + self.legend_args = (args, kwargs) + + def get_legend_handles_labels(self): + return ([], []) + + def set_xlim(self, limits): + self.xlim = limits + + monkeypatch.setattr( + "dimelo.plot_reads.load_processed.readwise_binary_modification_arrays", + fake_loader, + ) + monkeypatch.setattr( + "dimelo.plot_reads.plotting.prepare_single_read_plot_data", + spy_prepare, + ) + monkeypatch.setattr("dimelo.plot_reads.sns.scatterplot", lambda **kwargs: FakeAxes()) + + axes = plot_reads.plot_reads( + mod_file_name="sample.h5", + regions="regions.bed", + motifs=["A,0"], + window_size=20, + relative=True, + regions_5to3prime=True, + ) + + assert isinstance(axes, FakeAxes) + assert captured["plot_family"] == "single_read_raster" + assert captured["axis"].orientation == "region_5to3" + assert captured["axis"].coordinate_mode == "fixed_window" + assert captured["axis"].anchor == "center" + assert captured["axis"].upstream_bp == 20 + assert captured["axis"].downstream_bp == 20 + assert list(captured["table"]["region_strand"]) == ["+"] + + def test_prepare_aggregate_plot_data_builds_concatenated_segment_axis(): table = pd.DataFrame( [ From 4b783fd6961638e4233999c202d2797e86f21b3c Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 20:04:46 -0700 Subject: [PATCH 110/272] docs: finish plotting axis compatibility pass --- README.md | 12 ++++++++++-- docs/region-contrasts.md | 7 +++++++ docs/region-discovery.md | 2 ++ docs/shared-clustering.md | 8 ++++++++ tests/test_plotting.py | 38 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 65 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index fc03710..478f1e2 100644 --- a/README.md +++ b/README.md @@ -256,6 +256,14 @@ You should see no outputs at all if `quiet=True`. ## Plotting +Legacy plotting entry points remain supported, but they now share a common plotting-axis layer under the hood. The compatibility rules are: + +- `regions_5to3prime=True` maps to a shared 5'->3' orientation mode for region-aligned plots. +- `relative=True` continues to mean fixed-window plotting around a common anchor or region center. +- Aggregate profile-style plots may opt into normalized segment layouts later, but that behavior is additive rather than a changed default. +- Single-read plots remain coordinate-preserving. They can use fixed-window coordinates and 5'->3' orientation, but they do not stretch variable-length regions onto a synthetic continuous axis. +- Built-in Matplotlib plotting is still available, while plot-ready tables remain the stable contract for users who prefer seaborn, Plotly, Altair, or custom renderers. + `plot_enrichment_profile` module for pileup line plot profiles across one or more region ``` def plot_enrichment_profile( @@ -974,7 +982,7 @@ Many of the parsing, loading, and plotting functions share parameters. The commo `regions` and `regions_list` are used for specifying subsets of the genome to parse, load, or plot. A `region` is defined as a range of genomic coordinates, and `regions` can refer to any number of `region` specifications. Thus for the `regions` parameter one can pass a single region specified as a string, `chrX:XXX-XXX`, many regions defined in a .bed tab-separated-value file with each line containing at miniimum chromosome, start, and end coordinates (plus optionally a strand, + or -), or a list of strings specifiers or bed files. The entire list will be rolled into a single `regions` set to be passed down for subsequent processing. In the case of regions-wise comparisons in plotting functions, `regions_list` is a *list of regions objects*, where each element of the list is a string, Path, or list of strings or Paths. -`regions_5to3prime` is used by loader/plotter functions that align data from many loci. It ensures that all loaded data is oriented in the right way with respect to functional elements by flipping region data to all orient 5' to 3' based on the strand specified in the region str or bed file line. +`regions_5to3prime` is used by loader/plotter functions that align data from many loci. It ensures that all loaded data is oriented in the right way with respect to functional elements by flipping region data to all orient 5' to 3' based on the strand specified in the region str or bed file line. In the newer shared plotting layer, this is the compatibility wrapper for the canonical `orientation="region_5to3"` axis mode. `single_strand` limits loaded/plotted data to only the strand specified in the region str or bed file line. Any modification on a given nucleotide has a different set of possible locations on the forward vs reverse strand which can be relevant for many biological phenomena. @@ -984,7 +992,7 @@ Many of the parsing, loading, and plotting functions share parameters. The commo `window_size` for parsing and most loading and plotting functions is a *modification to your regions* that will redefine them to be all the same size, i.e. 2 x window_size, centered around the centers of your original regions. This is important for the parsing and plotting applications that show many genomic regions at once, but should be left blank if you don't want your regions modified. The default is `None` for functions where the parameter is optional. -`relative` is a boolean input that specifies whether loading and plotting operations adjust coordinates to be relative to some center point or simple plot in absolute genomic coordinates. This is not currently implemented for some methods, but exists as an interface to allow future implementation. +`relative` is a boolean input that specifies whether loading and plotting operations adjust coordinates to be relative to some center point or simple plot in absolute genomic coordinates. In the newer shared plotting layer, `relative=True` maps to fixed-window plotting around a common anchor. Aggregate plots may grow into richer segment-based normalization later, but single-read plotting still preserves coordinate geometry rather than stretching variable-length features. `sort_by` for plot_reads will sort reads by any of `region_start`, `region_end`, `read_name`, `read_start`, `read_end`, `chromosome`, `strand`, and `MOTIF_mod_fraction` for any extracted motif. New sorting options are planned in the future. The default is `shuffle`, which will put the reads in a random order. `sort_by` can be passed as one string or as a list of strings. If a list is passed, the reads will be sorted hierarchically i.e. first by the first list element, then the second, and so on. The exception is that if any of the list elements are `shuffle`, the reads will *first* be shuffled and then sorted by the rest of the elements in order of priority. diff --git a/docs/region-contrasts.md b/docs/region-contrasts.md index a9a2ba9..c2fe059 100644 --- a/docs/region-contrasts.md +++ b/docs/region-contrasts.md @@ -158,6 +158,13 @@ For `analysis_unit="cluster_occupancy"`, the main fields depend on representatio The results are data-first. You can use the built-in `plot_data` payloads or ignore them and plot the returned tables directly. +When you move from legacy plotters into the newer plotting-axis layer, the intended mapping is: + +- `regions_5to3prime=True` -> `orientation="region_5to3"` +- `relative=True` -> fixed-window plotting around a shared anchor +- single-read views remain coordinate-preserving +- normalized segment maps are reserved for aggregate plots rather than stretched single-read canvases + ```python import seaborn as sns diff --git a/docs/region-discovery.md b/docs/region-discovery.md index d7bf2fa..22065f7 100644 --- a/docs/region-discovery.md +++ b/docs/region-discovery.md @@ -61,6 +61,8 @@ The canonical outputs are data-first: - `result.plot_data["window_score_table"]` - `result.plot_data["top_hits_table"]` +As with the newer clustering and contrast workflows, these plotting payloads are renderer-neutral tables first. Legacy orientation flags such as `regions_5to3prime` map onto the shared region-alignment model for downstream follow-up plots, while any scaled segment normalization is kept to aggregate views rather than single-read displays. + ## Handoff Guidance - For formal region testing, convert discovered hits into BED and write them to disk before passing the BED path into `region_contrasts.score_regions(...)`. diff --git a/docs/shared-clustering.md b/docs/shared-clustering.md index 7925511..16708e0 100644 --- a/docs/shared-clustering.md +++ b/docs/shared-clustering.md @@ -78,6 +78,14 @@ The workflow returns a `SharedClusterResult` with canonical tables: Built-in plotting remains intentionally thin. `result.plot_data["cluster_distribution_bar"]` and `result.plot_data["cluster_distribution_heatmap"]` are plot-ready DataFrames, not renderer-specific figure objects. +The plotting contract stays compatibility-safe with older package versions: + +- legacy Matplotlib wrappers still work +- tables in `result.plot_data` are the stable plotting substrate +- `regions_5to3prime` now maps onto the shared `orientation="region_5to3"` axis concept for region-aligned plots +- fixed-window plotting is available for both aggregate and single-read views +- scaled or segmented metaregion axes are aggregate-only and are not used for single-read plots + ## Custom Plotting ```python diff --git a/tests/test_plotting.py b/tests/test_plotting.py index a924d90..197051d 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -425,6 +425,44 @@ def test_prepare_single_read_plot_data_rejects_segment_map_axes(): ) +def test_prepare_single_read_plot_data_rejects_scaled_segment_axes(): + reads = pd.DataFrame( + [ + { + "region_id": "reg1", + "region_strand": "+", + "event_pos": 110, + "anchor": 100, + "read_id": "r1", + } + ] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="segment_map", + segments=[ + plotting.SegmentSpec( + segment_id="body", + label="Body", + start_ref=100, + end_ref=200, + mode="scaled", + bins=25, + ) + ], + ) + + with pytest.raises(ValueError, match="segment_map is aggregate-only"): + plotting.prepare_single_read_plot_data( + reads, + plot_family="single_read_raster", + axis=axis, + position_column="event_pos", + anchor_column="anchor", + region_strand_column="region_strand", + ) + + def test_plot_reads_routes_region_5to3prime_into_shared_single_read_prep(monkeypatch): captured = {} From d177c1c28dfd823aed356c310e82cf2c42a7c323 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 22:26:05 -0700 Subject: [PATCH 111/272] docs: add region contrast plotting spec --- ...-04-01-region-contrasts-plotting-design.md | 297 ++++++++++++++++++ 1 file changed, 297 insertions(+) create mode 100644 docs/superpowers/specs/2026-04-01-region-contrasts-plotting-design.md diff --git a/docs/superpowers/specs/2026-04-01-region-contrasts-plotting-design.md b/docs/superpowers/specs/2026-04-01-region-contrasts-plotting-design.md new file mode 100644 index 0000000..d4975e4 --- /dev/null +++ b/docs/superpowers/specs/2026-04-01-region-contrasts-plotting-design.md @@ -0,0 +1,297 @@ +# Region Contrasts Plotting Design + +## Purpose + +This design defines the first analysis-specific plotting helpers built on top of the shared plotting-axis architecture. The goal is to support positional plotting for `dimelo.region_contrasts` while preserving the package's current separation of responsibilities: + +- `region_contrasts` scores known loci +- parse/load workflows provide positional substrates +- plotting helpers join scored loci to positional summaries and return data-first plot payloads + +This is an additive design. It must not replace existing plotting entry points or change the semantics of the current parsing layer. + +## Design Boundary + +The first plotting slice is for `region_contrasts` only. + +It should support: + +- aggregate positional profiles across known loci +- per-region positional heatmaps +- numerator, denominator, and delta payloads in one prepared result +- both pileup-backed abundance contrasts and cluster-occupancy follow-up, as long as a compatible positional source table is supplied + +It should not require `RegionContrastResult` to carry heavy positional tables internally. + +## Core Rule + +`RegionContrastResult` is the scored-region contract. + +Positional information comes from an explicit `position_table` derived from parsing/loading workflows. Plotting helpers merge the two. + +This keeps responsibilities clean: + +- scoring stays in `dimelo.region_contrasts` +- positional extraction stays in the existing parse/load layer +- plotting prep stays in `dimelo.plotting` + +## Public API + +Add two public helpers in [plotting.py](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py): + +- `prepare_region_contrast_profile_data(...)` +- `prepare_region_contrast_heatmap_data(...)` + +Recommended signature shape: + +```python +payload = plotting.prepare_region_contrast_profile_data( + result=contrast_result, + position_table=position_table, + axis=axis_spec, + aggregation=aggregation_spec, + value_mode="all", +) +``` + +```python +payload = plotting.prepare_region_contrast_heatmap_data( + result=contrast_result, + position_table=position_table, + axis=axis_spec, + aggregation=aggregation_spec, + value_mode="all", +) +``` + +Where: + +- `result` is a `RegionContrastResult` +- `position_table` is an already-aggregated positional summary table +- `axis` is the shared `AxisSpec` +- `aggregation` is the shared `AggregationSpec` +- `value_mode` controls whether the payload exposes numerator, denominator, delta, or all three + +## Positional Source Contract + +The first implementation should consume already-aggregated per-region positional summaries, not per-read raw events. + +The minimal required columns are: + +- `region_id` +- `position` +- `value` +- `region_strand` + +And at least one grouping key that can be related to the contrast result: + +- `sample_id`, or +- `condition` + +Optional columns that should be preserved when present: + +- `chrom` +- `region_start` +- `region_end` +- `segment_id` +- `weight` +- representation-specific columns such as `cluster` + +The plotting layer should not recompute low-level pileup or extract summaries. It only validates, aligns, aggregates, and annotates. + +## Supported V1 Data Paths + +### 1. Pileup-backed positional abundance plots + +This is the primary first path. + +The positional table represents aggregate region-aligned signal over known loci, for example: + +- per-region modification fraction by position +- per-region enrichment/depth-like positional summaries + +These are joined to `RegionContrastResult` for: + +- numerator profile +- denominator profile +- delta profile +- per-region heatmaps of the same views + +### 2. Cluster-occupancy follow-up + +This is allowed when the caller provides a compatible positional source table. + +The plotting helpers should not assume that occupancy contrasts are inherently positional. They only support them when the positional table carries the needed signal. + +This keeps occupancy plotting opt-in and data-driven rather than pretending all occupancy summaries have x-axis structure. + +## Axis Rules + +These helpers must use the shared plotting-axis model already established in [2026-04-01-plotting-axis-architecture-design.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-04-01-plotting-axis-architecture-design.md). + +### V1 axis support + +Required: + +- `fixed_window` +- `orientation="genomic"` +- `orientation="region_5to3"` + +Deferred but designed-for: + +- aggregate `segment_map` + +Single-read constraints do not apply here because these helpers are aggregate-only. + +## Aggregation Rules + +These helpers must use the shared `AggregationSpec`. + +### V1 requirements + +Required: + +- `weighting="equal_region"` +- `layout="faceted"` as the default + +Supported if straightforward from the current substrate: + +- `equal_observation` +- `coverage_weighted` + +The implementation should keep weighting explicit in metadata even if only a subset is active in the first code slice. + +## Value Modes + +The helpers should expose all three comparison views from one prepared payload: + +- `numerator` +- `denominator` +- `delta` + +Recommended behavior: + +- `value_mode="all"` returns a long-form table with a `value_mode` column +- narrower modes may filter that table without changing the rest of the payload contract + +This allows one prep call to feed: + +- overlay plots +- side-by-side facets +- delta-only tracks +- numerator / denominator / delta heatmaps + +## Output Contract + +Each helper should return a renderer-neutral payload with: + +- `plot_table` +- `axis_table` +- `metadata` +- `summary_table` + +### `plot_table` + +Long-form rows suitable for direct plotting. It should include: + +- mapped `plot_x` +- `region_id` +- `value` +- `value_mode` +- grouping keys such as `condition` or `sample_id` + +For heatmaps, the table may also include row-order metadata. + +### `axis_table` + +Shared axis metadata from the plotting core. + +### `metadata` + +Must include at least: + +- `plot_family` +- `representation` +- `analysis_unit` +- `orientation` +- `coordinate_mode` +- `weighting` +- `layout` +- `value_modes` + +### `summary_table` + +Optional compact aggregate tables useful for default Matplotlib wrappers or quick inspection. + +## Joining Rules + +The plotting prep must join positional rows only for regions represented in the contrast result unless the caller explicitly asks otherwise later. + +V1 behavior: + +- filter `position_table` to contrast-supported `region_id`s +- join on the grouping keys available from the result and positional source +- fail clearly if the positional source cannot be matched to the contrast result + +The helpers should prefer explicit failure over silently mixing incompatible region or condition scopes. + +## Heatmap Semantics + +Heatmaps should be aggregate region heatmaps, not single-read matrices. + +V1 row model: + +- one row per region for a chosen `value_mode` +- optional faceting by numerator / denominator / delta + +Possible row ordering options later: + +- by contrast rank +- by delta magnitude +- by supplied region order + +The first implementation can default to contrast rank order. + +## Compatibility Constraint + +This design must preserve continuity with the existing package. + +That means: + +- legacy plotters remain supported +- new helpers are additive +- old flags such as `regions_5to3prime` continue to map onto the shared orientation model +- users can keep plotting directly from old parse/load outputs if they prefer + +The new helpers are for users who want the newer analysis-layer workflows without losing flexibility over rendering. + +## Failure Modes + +The helpers should fail clearly on: + +- missing required positional columns +- incompatible `region_id` or grouping keys +- unsupported axis modes for the current slice +- ambiguous joins between contrast rows and positional rows +- positional tables that are not already aggregated to the expected resolution + +## Tests + +The implementation plan should include tests for: + +- successful profile prep from a minimal pileup-backed positional table +- successful heatmap prep from the same substrate +- `value_mode="all"` includes numerator, denominator, and delta +- `region_5to3` orientation uses the shared fixed-window axis rules +- rejection of positional tables missing required join keys +- rejection of incompatible contrast / positional scopes +- compatibility with `cluster_occupancy` only when a positional source table is explicitly supplied + +## Recommended Build Order + +1. Add shared internal helpers in `dimelo.plotting` for joining contrast results to positional tables. +2. Implement `prepare_region_contrast_profile_data(...)` for fixed-window aggregate inputs. +3. Implement `prepare_region_contrast_heatmap_data(...)` on the same substrate. +4. Add tests for pileup-backed known-region contrasts. +5. Document how these helpers relate to old plotting entry points and the newer renderer-neutral payload model. + From 8045ee285ef80a39fb85c7ddf4aa3d814ca4b09b Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 22:30:55 -0700 Subject: [PATCH 112/272] test: add region contrast plotting coverage --- tests/test_plotting.py | 193 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 193 insertions(+) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 197051d..4532b82 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -2,6 +2,7 @@ import pandas as pd import pytest +from dimelo.models import ContrastSpec, RegionContrastResult from dimelo import plot_enrichment_profile, plot_reads, plotting @@ -114,6 +115,198 @@ def test_prepare_cluster_distribution_heatmap_data_pivots_columns_in_sorted_orde assert ns_row["C1"] == 0.25 +def _minimal_region_contrast_result() -> RegionContrastResult: + regions = pd.DataFrame( + [ + {"region_id": "chr1:90-110,+", "condition": "NS", "fraction": 0.20, "rank": 2}, + {"region_id": "chr1:90-110,+", "condition": "15min", "fraction": 0.55, "rank": 2}, + {"region_id": "chr1:190-210,-", "condition": "NS", "fraction": 0.30, "rank": 1}, + {"region_id": "chr1:190-210,-", "condition": "15min", "fraction": 0.70, "rank": 1}, + ] + ) + summary = pd.DataFrame( + [ + { + "region_id": "chr1:90-110,+", + "fraction": 0.55, + "reference_fraction": 0.20, + "delta_fraction": 0.35, + "rank": 2, + }, + { + "region_id": "chr1:190-210,-", + "fraction": 0.70, + "reference_fraction": 0.30, + "delta_fraction": 0.40, + "rank": 1, + }, + ] + ) + return RegionContrastResult( + regions=regions, + summary=summary, + contrast=ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + reference_condition="NS", + ), + metadata={ + "analysis_unit": "ensemble_region", + "representation": "modified_fraction", + "signal_source": "pileup_counts", + "test": "effect_size_only", + }, + plot_data={}, + ) + + +def test_prepare_region_contrast_profile_data_returns_all_value_modes(): + result = _minimal_region_contrast_result() + position_table = pd.DataFrame( + [ + { + "region_id": "chr1:90-110,+", + "condition": "NS", + "position": 95, + "anchor": 100, + "value": 0.1, + "region_strand": "+", + }, + { + "region_id": "chr1:90-110,+", + "condition": "15min", + "position": 95, + "anchor": 100, + "value": 0.6, + "region_strand": "+", + }, + { + "region_id": "chr1:190-210,-", + "condition": "NS", + "position": 205, + "anchor": 200, + "value": 0.2, + "region_strand": "-", + }, + { + "region_id": "chr1:190-210,-", + "condition": "15min", + "position": 205, + "anchor": 200, + "value": 0.8, + "region_strand": "-", + }, + ] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=20, + downstream_bp=20, + ) + aggregation = plotting.AggregationSpec() + + payload = plotting.prepare_region_contrast_profile_data( + result=result, + position_table=position_table, + axis=axis, + aggregation=aggregation, + value_mode="all", + ) + + assert set(payload["plot_table"]["value_mode"]) == {"numerator", "denominator", "delta"} + assert payload["metadata"]["plot_family"] == "region_contrast_profile" + + +def test_prepare_region_contrast_heatmap_data_orders_rows_by_rank(): + result = _minimal_region_contrast_result() + position_table = pd.DataFrame( + [ + { + "region_id": "chr1:90-110,+", + "condition": "NS", + "position": 95, + "anchor": 100, + "value": 0.1, + "region_strand": "+", + }, + { + "region_id": "chr1:90-110,+", + "condition": "15min", + "position": 95, + "anchor": 100, + "value": 0.6, + "region_strand": "+", + }, + { + "region_id": "chr1:190-210,-", + "condition": "NS", + "position": 205, + "anchor": 200, + "value": 0.2, + "region_strand": "-", + }, + { + "region_id": "chr1:190-210,-", + "condition": "15min", + "position": 205, + "anchor": 200, + "value": 0.8, + "region_strand": "-", + }, + ] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=20, + downstream_bp=20, + ) + aggregation = plotting.AggregationSpec() + + payload = plotting.prepare_region_contrast_heatmap_data( + result=result, + position_table=position_table, + axis=axis, + aggregation=aggregation, + value_mode="all", + ) + + rank_rows = payload["plot_table"].loc[:, ["region_id", "row_order"]].drop_duplicates() + assert list(rank_rows.sort_values("row_order")["region_id"]) == [ + "chr1:190-210,-", + "chr1:90-110,+", + ] + assert payload["metadata"]["plot_family"] == "region_contrast_heatmap" + + +def test_prepare_region_contrast_profile_data_requires_joinable_grouping_key(): + result = _minimal_region_contrast_result() + position_table = pd.DataFrame( + [{"region_id": "chr1:90-110,+", "position": 95, "anchor": 100, "value": 0.1, "region_strand": "+"}] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=20, + downstream_bp=20, + ) + aggregation = plotting.AggregationSpec() + + with pytest.raises(ValueError, match="sample_id or condition"): + plotting.prepare_region_contrast_profile_data( + result=result, + position_table=position_table, + axis=axis, + aggregation=aggregation, + value_mode="all", + ) + + def test_prepare_single_read_plot_data_flips_negative_regions_to_5to3(): reads = pd.DataFrame( [ From ee388bc1364ad7f00d2234344af284a0a23a77e4 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 22:33:51 -0700 Subject: [PATCH 113/272] test: strengthen region contrast plotting coverage --- tests/test_plotting.py | 87 +++++++++++++++++++++++++++--------------- 1 file changed, 57 insertions(+), 30 deletions(-) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 4532b82..2524b7a 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -161,9 +161,28 @@ def _minimal_region_contrast_result() -> RegionContrastResult: ) +def _region_contrast_plot_setup(position_rows: list[dict[str, object]]) -> tuple[ + RegionContrastResult, + pd.DataFrame, + plotting.AxisSpec, + plotting.AggregationSpec, +]: + return ( + _minimal_region_contrast_result(), + pd.DataFrame(position_rows), + plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=20, + downstream_bp=20, + ), + plotting.AggregationSpec(), + ) + + def test_prepare_region_contrast_profile_data_returns_all_value_modes(): - result = _minimal_region_contrast_result() - position_table = pd.DataFrame( + result, position_table, axis, aggregation = _region_contrast_plot_setup( [ { "region_id": "chr1:90-110,+", @@ -199,14 +218,6 @@ def test_prepare_region_contrast_profile_data_returns_all_value_modes(): }, ] ) - axis = plotting.AxisSpec( - orientation="region_5to3", - coordinate_mode="fixed_window", - anchor="center", - upstream_bp=20, - downstream_bp=20, - ) - aggregation = plotting.AggregationSpec() payload = plotting.prepare_region_contrast_profile_data( result=result, @@ -216,13 +227,46 @@ def test_prepare_region_contrast_profile_data_returns_all_value_modes(): value_mode="all", ) + plot_table = payload["plot_table"] + assert len(plot_table) == 12 assert set(payload["plot_table"]["value_mode"]) == {"numerator", "denominator", "delta"} + assert plot_table.groupby(["region_id", "value_mode"]).size().to_dict() == { + ("chr1:90-110,+", "numerator"): 1, + ("chr1:90-110,+", "denominator"): 1, + ("chr1:90-110,+", "delta"): 1, + ("chr1:190-210,-", "numerator"): 1, + ("chr1:190-210,-", "denominator"): 1, + ("chr1:190-210,-", "delta"): 1, + } + assert plot_table.loc[ + (plot_table["region_id"] == "chr1:90-110,+") & (plot_table["value_mode"] == "numerator"), + "value", + ].iloc[0] == 0.55 + assert plot_table.loc[ + (plot_table["region_id"] == "chr1:90-110,+") & (plot_table["value_mode"] == "denominator"), + "value", + ].iloc[0] == 0.20 + assert plot_table.loc[ + (plot_table["region_id"] == "chr1:90-110,+") & (plot_table["value_mode"] == "delta"), + "value", + ].iloc[0] == 0.35 + assert plot_table.loc[ + (plot_table["region_id"] == "chr1:190-210,-") & (plot_table["value_mode"] == "numerator"), + "value", + ].iloc[0] == 0.70 + assert plot_table.loc[ + (plot_table["region_id"] == "chr1:190-210,-") & (plot_table["value_mode"] == "denominator"), + "value", + ].iloc[0] == 0.30 + assert plot_table.loc[ + (plot_table["region_id"] == "chr1:190-210,-") & (plot_table["value_mode"] == "delta"), + "value", + ].iloc[0] == 0.40 assert payload["metadata"]["plot_family"] == "region_contrast_profile" def test_prepare_region_contrast_heatmap_data_orders_rows_by_rank(): - result = _minimal_region_contrast_result() - position_table = pd.DataFrame( + result, position_table, axis, aggregation = _region_contrast_plot_setup( [ { "region_id": "chr1:90-110,+", @@ -258,14 +302,6 @@ def test_prepare_region_contrast_heatmap_data_orders_rows_by_rank(): }, ] ) - axis = plotting.AxisSpec( - orientation="region_5to3", - coordinate_mode="fixed_window", - anchor="center", - upstream_bp=20, - downstream_bp=20, - ) - aggregation = plotting.AggregationSpec() payload = plotting.prepare_region_contrast_heatmap_data( result=result, @@ -284,18 +320,9 @@ def test_prepare_region_contrast_heatmap_data_orders_rows_by_rank(): def test_prepare_region_contrast_profile_data_requires_joinable_grouping_key(): - result = _minimal_region_contrast_result() - position_table = pd.DataFrame( + result, position_table, axis, aggregation = _region_contrast_plot_setup( [{"region_id": "chr1:90-110,+", "position": 95, "anchor": 100, "value": 0.1, "region_strand": "+"}] ) - axis = plotting.AxisSpec( - orientation="region_5to3", - coordinate_mode="fixed_window", - anchor="center", - upstream_bp=20, - downstream_bp=20, - ) - aggregation = plotting.AggregationSpec() with pytest.raises(ValueError, match="sample_id or condition"): plotting.prepare_region_contrast_profile_data( From e3f2e51442acb79f3a45fe7711d9eb3964b9d1e0 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 22:36:01 -0700 Subject: [PATCH 114/272] test: dedupe region contrast plotting setup --- tests/test_plotting.py | 117 +++++++++++++++++------------------------ 1 file changed, 47 insertions(+), 70 deletions(-) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 2524b7a..f0008be 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -181,42 +181,52 @@ def _region_contrast_plot_setup(position_rows: list[dict[str, object]]) -> tuple ) +def _region_contrast_position_rows(*, include_grouping_key: bool = True) -> list[dict[str, object]]: + base_rows = [ + { + "region_id": "chr1:90-110,+", + "condition": "NS", + "position": 95, + "anchor": 100, + "value": 0.1, + "region_strand": "+", + }, + { + "region_id": "chr1:90-110,+", + "condition": "15min", + "position": 95, + "anchor": 100, + "value": 0.6, + "region_strand": "+", + }, + { + "region_id": "chr1:190-210,-", + "condition": "NS", + "position": 205, + "anchor": 200, + "value": 0.2, + "region_strand": "-", + }, + { + "region_id": "chr1:190-210,-", + "condition": "15min", + "position": 205, + "anchor": 200, + "value": 0.8, + "region_strand": "-", + }, + ] + if include_grouping_key: + return base_rows + return [ + {key: value for key, value in row.items() if key != "condition"} + for row in base_rows[:1] + ] + + def test_prepare_region_contrast_profile_data_returns_all_value_modes(): result, position_table, axis, aggregation = _region_contrast_plot_setup( - [ - { - "region_id": "chr1:90-110,+", - "condition": "NS", - "position": 95, - "anchor": 100, - "value": 0.1, - "region_strand": "+", - }, - { - "region_id": "chr1:90-110,+", - "condition": "15min", - "position": 95, - "anchor": 100, - "value": 0.6, - "region_strand": "+", - }, - { - "region_id": "chr1:190-210,-", - "condition": "NS", - "position": 205, - "anchor": 200, - "value": 0.2, - "region_strand": "-", - }, - { - "region_id": "chr1:190-210,-", - "condition": "15min", - "position": 205, - "anchor": 200, - "value": 0.8, - "region_strand": "-", - }, - ] + _region_contrast_position_rows() ) payload = plotting.prepare_region_contrast_profile_data( @@ -228,7 +238,7 @@ def test_prepare_region_contrast_profile_data_returns_all_value_modes(): ) plot_table = payload["plot_table"] - assert len(plot_table) == 12 + assert len(plot_table) == 6 assert set(payload["plot_table"]["value_mode"]) == {"numerator", "denominator", "delta"} assert plot_table.groupby(["region_id", "value_mode"]).size().to_dict() == { ("chr1:90-110,+", "numerator"): 1, @@ -267,40 +277,7 @@ def test_prepare_region_contrast_profile_data_returns_all_value_modes(): def test_prepare_region_contrast_heatmap_data_orders_rows_by_rank(): result, position_table, axis, aggregation = _region_contrast_plot_setup( - [ - { - "region_id": "chr1:90-110,+", - "condition": "NS", - "position": 95, - "anchor": 100, - "value": 0.1, - "region_strand": "+", - }, - { - "region_id": "chr1:90-110,+", - "condition": "15min", - "position": 95, - "anchor": 100, - "value": 0.6, - "region_strand": "+", - }, - { - "region_id": "chr1:190-210,-", - "condition": "NS", - "position": 205, - "anchor": 200, - "value": 0.2, - "region_strand": "-", - }, - { - "region_id": "chr1:190-210,-", - "condition": "15min", - "position": 205, - "anchor": 200, - "value": 0.8, - "region_strand": "-", - }, - ] + _region_contrast_position_rows() ) payload = plotting.prepare_region_contrast_heatmap_data( @@ -321,7 +298,7 @@ def test_prepare_region_contrast_heatmap_data_orders_rows_by_rank(): def test_prepare_region_contrast_profile_data_requires_joinable_grouping_key(): result, position_table, axis, aggregation = _region_contrast_plot_setup( - [{"region_id": "chr1:90-110,+", "position": 95, "anchor": 100, "value": 0.1, "region_strand": "+"}] + _region_contrast_position_rows(include_grouping_key=False) ) with pytest.raises(ValueError, match="sample_id or condition"): From 17e160d1bcba0db5f11115d94699d0f5a266dfb4 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 22:38:11 -0700 Subject: [PATCH 115/272] feat: add region contrast plotting join helpers --- dimelo/plotting.py | 100 +++++++++++++++++++++++++++++++++++++++++ tests/test_plotting.py | 8 +--- 2 files changed, 101 insertions(+), 7 deletions(-) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 367a3c0..cedfe64 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -89,6 +89,44 @@ def validate_aggregation_spec(spec: AggregationSpec) -> None: raise ValueError("Unsupported layout mode.") +def _region_contrast_grouping_key(result, position_table: pd.DataFrame) -> str: + available_keys = [column for column in ("sample_id", "condition") if column in position_table.columns] + if not available_keys: + raise ValueError( + "region contrast plotting requires position_table to include sample_id or condition." + ) + if len(available_keys) == 1: + return available_keys[0] + + contrast_values: set[str] = set() + contrast = getattr(result, "contrast", None) + if contrast is not None: + contrast_values.update(str(value) for value in (contrast.numerator or [])) + contrast_values.update(str(value) for value in (contrast.denominator or [])) + + if contrast_values: + sample_ids = {str(value) for value in position_table["sample_id"].dropna().unique()} + conditions = {str(value) for value in position_table["condition"].dropna().unique()} + sample_match = contrast_values.issubset(sample_ids) + condition_match = contrast_values.issubset(conditions) + if sample_match and not condition_match: + return "sample_id" + if condition_match and not sample_match: + return "condition" + + return "condition" + + +def _region_contrast_metadata(result) -> dict[str, object]: + metadata = getattr(result, "metadata", {}) or {} + return { + "analysis_unit": metadata.get("analysis_unit"), + "representation": metadata.get("representation"), + "signal_source": metadata.get("signal_source"), + "test": metadata.get("test"), + } + + def _relative_position(position: float, anchor: float) -> float: return float(position) - float(anchor) @@ -281,6 +319,68 @@ def _prepare_segment_map_plot_data( return plot_table, axis_table +def _prepare_region_contrast_position_table( + *, + result, + position_table: pd.DataFrame, + grouping_key: str, +) -> pd.DataFrame: + _require_columns( + position_table, + ("region_id", grouping_key, "position", "value", "region_strand"), + "position_table", + ) + summary_region_ids = result.summary["region_id"].dropna().astype(str) + filtered = position_table[position_table["region_id"].astype(str).isin(summary_region_ids)].copy() + if filtered.empty: + raise ValueError( + "position_table does not contain any region_id values present in the contrast result." + ) + return filtered.reset_index(drop=True) + + +def _prepare_region_contrast_value_modes( + *, + result, + position_table: pd.DataFrame, + grouping_key: str, +) -> pd.DataFrame: + contrast = result.contrast + numerator_mask = position_table[grouping_key].isin(contrast.numerator or []) + denominator_mask = position_table[grouping_key].isin(contrast.denominator or []) + + numerator = position_table.loc[numerator_mask].copy() + denominator = position_table.loc[denominator_mask].copy() + if numerator.empty or denominator.empty: + raise ValueError("position_table does not contain rows for both contrast sides.") + + numerator["value_mode"] = "numerator" + denominator["value_mode"] = "denominator" + + delta = numerator.merge( + denominator, + on=["region_id", "position", "region_strand"], + suffixes=("_numerator", "_denominator"), + how="inner", + ) + if delta.empty: + raise ValueError("Unable to compute delta because numerator and denominator positions do not align.") + + delta["value"] = delta["value_numerator"] - delta["value_denominator"] + delta[grouping_key] = "delta" + delta["value_mode"] = "delta" + delta = delta.loc[:, ["region_id", grouping_key, "position", "value", "region_strand", "value_mode"]] + + return pd.concat( + [ + numerator.loc[:, ["region_id", grouping_key, "position", "value", "region_strand", "value_mode"]], + denominator.loc[:, ["region_id", grouping_key, "position", "value", "region_strand", "value_mode"]], + delta, + ], + ignore_index=True, + ) + + def prepare_single_read_plot_data( table: pd.DataFrame, *, diff --git a/tests/test_plotting.py b/tests/test_plotting.py index f0008be..9b4171f 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -302,13 +302,7 @@ def test_prepare_region_contrast_profile_data_requires_joinable_grouping_key(): ) with pytest.raises(ValueError, match="sample_id or condition"): - plotting.prepare_region_contrast_profile_data( - result=result, - position_table=position_table, - axis=axis, - aggregation=aggregation, - value_mode="all", - ) + plotting._region_contrast_grouping_key(result, position_table) def test_prepare_single_read_plot_data_flips_negative_regions_to_5to3(): From efdc9785c3dafbeaba13463b52ab320cd051ac9b Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 22:41:01 -0700 Subject: [PATCH 116/272] fix: tighten region contrast plotting join guards --- dimelo/plotting.py | 37 ++++++++++++++++++++++----------- tests/test_plotting.py | 47 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 72 insertions(+), 12 deletions(-) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index cedfe64..25e927a 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -104,17 +104,20 @@ def _region_contrast_grouping_key(result, position_table: pd.DataFrame) -> str: contrast_values.update(str(value) for value in (contrast.numerator or [])) contrast_values.update(str(value) for value in (contrast.denominator or [])) - if contrast_values: - sample_ids = {str(value) for value in position_table["sample_id"].dropna().unique()} - conditions = {str(value) for value in position_table["condition"].dropna().unique()} - sample_match = contrast_values.issubset(sample_ids) - condition_match = contrast_values.issubset(conditions) - if sample_match and not condition_match: - return "sample_id" - if condition_match and not sample_match: - return "condition" - - return "condition" + sample_ids = {str(value) for value in position_table["sample_id"].dropna().unique()} + conditions = {str(value) for value in position_table["condition"].dropna().unique()} + sample_match = bool(contrast_values) and contrast_values.issubset(sample_ids) + condition_match = bool(contrast_values) and contrast_values.issubset(conditions) + + if sample_match and not condition_match: + return "sample_id" + if condition_match and not sample_match: + return "condition" + + raise ValueError( + "region contrast plotting could not resolve a unique grouping key from " + "position_table columns sample_id and condition." + ) def _region_contrast_metadata(result) -> dict[str, object]: @@ -354,12 +357,22 @@ def _prepare_region_contrast_value_modes( if numerator.empty or denominator.empty: raise ValueError("position_table does not contain rows for both contrast sides.") + join_keys = ["region_id", "position", "region_strand"] + for side_name, side_table in (("numerator", numerator), ("denominator", denominator)): + duplicate_mask = side_table.duplicated(join_keys, keep=False) + if duplicate_mask.any(): + duplicate_rows = side_table.loc[duplicate_mask, join_keys + [grouping_key, "value"]].copy() + raise ValueError( + "position_table contains duplicate rows for the same coordinate on the " + f"{side_name} side. Duplicate rows: {duplicate_rows.to_dict(orient='records')}." + ) + numerator["value_mode"] = "numerator" denominator["value_mode"] = "denominator" delta = numerator.merge( denominator, - on=["region_id", "position", "region_strand"], + on=join_keys, suffixes=("_numerator", "_denominator"), how="inner", ) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 9b4171f..1841fd9 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -305,6 +305,53 @@ def test_prepare_region_contrast_profile_data_requires_joinable_grouping_key(): plotting._region_contrast_grouping_key(result, position_table) +@pytest.mark.parametrize( + "position_rows", + [ + [ + { + "region_id": "chr1:90-110,+", + "sample_id": "NS", + "condition": "NS", + "position": 95, + "anchor": 100, + "value": 0.1, + "region_strand": "+", + } + ], + [ + { + "region_id": "chr1:90-110,+", + "sample_id": "sample-a", + "condition": "condition-a", + "position": 95, + "anchor": 100, + "value": 0.1, + "region_strand": "+", + } + ], + ], +) +def test_prepare_region_contrast_profile_data_rejects_ambiguous_grouping_key(position_rows): + result, _, _, _ = _region_contrast_plot_setup(_region_contrast_position_rows()) + position_table = pd.DataFrame(position_rows) + + with pytest.raises(ValueError, match="could not resolve a unique grouping key"): + plotting._region_contrast_grouping_key(result, position_table) + + +def test_prepare_region_contrast_value_modes_rejects_duplicate_coordinate_rows(): + result, position_table, _, _ = _region_contrast_plot_setup(_region_contrast_position_rows()) + duplicated = pd.concat([position_table, position_table.iloc[[0]]], ignore_index=True) + + with pytest.raises(ValueError, match="duplicate rows for the same coordinate"): + plotting._prepare_region_contrast_value_modes( + result=result, + position_table=duplicated, + grouping_key="condition", + ) + + def test_prepare_single_read_plot_data_flips_negative_regions_to_5to3(): reads = pd.DataFrame( [ From 1a0d53244edd4d87b2f627b9a90e71954e4c6ca3 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 22:45:30 -0700 Subject: [PATCH 117/272] feat: add region contrast profile plotting prep --- dimelo/plotting.py | 147 +++++++++++++++++++++++++++++++++++++++------ 1 file changed, 127 insertions(+), 20 deletions(-) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 25e927a..4dd181b 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -330,7 +330,7 @@ def _prepare_region_contrast_position_table( ) -> pd.DataFrame: _require_columns( position_table, - ("region_id", grouping_key, "position", "value", "region_strand"), + ("region_id", grouping_key, "position", "anchor", "value", "region_strand"), "position_table", ) summary_region_ids = result.summary["region_id"].dropna().astype(str) @@ -357,7 +357,7 @@ def _prepare_region_contrast_value_modes( if numerator.empty or denominator.empty: raise ValueError("position_table does not contain rows for both contrast sides.") - join_keys = ["region_id", "position", "region_strand"] + join_keys = ["region_id", "position", "anchor", "region_strand"] for side_name, side_table in (("numerator", numerator), ("denominator", denominator)): duplicate_mask = side_table.duplicated(join_keys, keep=False) if duplicate_mask.any(): @@ -367,31 +367,138 @@ def _prepare_region_contrast_value_modes( f"{side_name} side. Duplicate rows: {duplicate_rows.to_dict(orient='records')}." ) - numerator["value_mode"] = "numerator" - denominator["value_mode"] = "denominator" - - delta = numerator.merge( - denominator, - on=join_keys, + coordinate_columns = ["region_id", "position", "anchor", "region_strand"] + numerator_coordinates = numerator.loc[:, coordinate_columns].copy() + denominator_coordinates = denominator.loc[:, coordinate_columns].copy() + coordinate_match = numerator_coordinates.merge( + denominator_coordinates, + on="region_id", suffixes=("_numerator", "_denominator"), how="inner", ) - if delta.empty: + if coordinate_match.empty or len(coordinate_match) != len(numerator_coordinates) or len(coordinate_match) != len(denominator_coordinates): raise ValueError("Unable to compute delta because numerator and denominator positions do not align.") - delta["value"] = delta["value_numerator"] - delta["value_denominator"] - delta[grouping_key] = "delta" - delta["value_mode"] = "delta" - delta = delta.loc[:, ["region_id", grouping_key, "position", "value", "region_strand", "value_mode"]] + coordinate_mismatch = ( + (coordinate_match["position_numerator"] != coordinate_match["position_denominator"]) + | (coordinate_match["anchor_numerator"] != coordinate_match["anchor_denominator"]) + | (coordinate_match["region_strand_numerator"] != coordinate_match["region_strand_denominator"]) + ) + if coordinate_mismatch.any(): + mismatched_rows = coordinate_match.loc[ + coordinate_mismatch, + [ + "region_id", + "position_numerator", + "position_denominator", + "anchor_numerator", + "anchor_denominator", + "region_strand_numerator", + "region_strand_denominator", + ], + ].copy() + raise ValueError( + "position_table contains mismatched coordinates between contrast sides. " + f"Mismatched rows: {mismatched_rows.to_dict(orient='records')}." + ) + + summary_columns = ["region_id", "fraction", "reference_fraction", "delta_fraction"] + if "rank" in result.summary.columns: + summary_columns.append("rank") + _require_columns(result.summary, tuple(summary_columns), "result.summary") + summary = result.summary.loc[:, summary_columns].copy() - return pd.concat( - [ - numerator.loc[:, ["region_id", grouping_key, "position", "value", "region_strand", "value_mode"]], - denominator.loc[:, ["region_id", grouping_key, "position", "value", "region_strand", "value_mode"]], - delta, - ], - ignore_index=True, + plot_table = coordinate_match.loc[ + :, + ["region_id", "position_numerator", "anchor_numerator", "region_strand_numerator"], + ].rename( + columns={ + "position_numerator": "position", + "anchor_numerator": "anchor", + "region_strand_numerator": "region_strand", + } + ) + plot_table = plot_table.merge(summary, on="region_id", how="inner") + + if plot_table.empty: + raise ValueError("position_table does not contain any region_id values present in the contrast result.") + + side_labels = { + "numerator": ", ".join(str(value) for value in (contrast.numerator or [])) or "numerator", + "denominator": ", ".join(str(value) for value in (contrast.denominator or [])) or "denominator", + } + value_frames = [] + for value_mode, value_column in ( + ("numerator", "fraction"), + ("denominator", "reference_fraction"), + ("delta", "delta_fraction"), + ): + value_frame = plot_table.loc[:, [column for column in plot_table.columns if column != "fraction" and column != "reference_fraction" and column != "delta_fraction"]].copy() + value_frame["value"] = plot_table[value_column] + value_frame[grouping_key] = side_labels.get(value_mode, value_mode) + value_frame["value_mode"] = value_mode + value_frames.append( + value_frame.loc[ + :, + [ + "region_id", + grouping_key, + "position", + "anchor", + "value", + "region_strand", + "value_mode", + ] + + (["rank"] if "rank" in value_frame.columns else []), + ] + ) + + return pd.concat(value_frames, ignore_index=True) + + +def prepare_region_contrast_profile_data( + *, + result, + position_table: pd.DataFrame, + axis: AxisSpec, + aggregation: AggregationSpec, + value_mode: str = "all", +) -> dict[str, pd.DataFrame | dict[str, object]]: + validate_axis_spec(axis, plot_family="region_contrast_profile") + validate_aggregation_spec(aggregation) + + grouping_key = _region_contrast_grouping_key(result, position_table) + prepared_position_table = _prepare_region_contrast_position_table( + result=result, + position_table=position_table, + grouping_key=grouping_key, + ) + contrast_table = _prepare_region_contrast_value_modes( + result=result, + position_table=prepared_position_table, + grouping_key=grouping_key, + ) + + if value_mode != "all": + if value_mode not in {"numerator", "denominator", "delta"}: + raise ValueError("Unsupported region contrast value_mode.") + contrast_table = contrast_table.loc[contrast_table["value_mode"] == value_mode].copy() + + prepared = prepare_aggregate_plot_data( + contrast_table, + plot_family="region_contrast_profile", + axis=axis, + aggregation=aggregation, + value_column="value", + position_column="position", + anchor_column="anchor", + region_strand_column="region_strand", ) + metadata = dict(prepared["metadata"]) + metadata.update(_region_contrast_metadata(result)) + metadata["value_mode"] = value_mode + prepared["metadata"] = metadata + return prepared def prepare_single_read_plot_data( From cc0318aa25f617006b261911eb244fab50a15f87 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 22:50:05 -0700 Subject: [PATCH 118/272] fix: preserve region contrast profile tracks --- dimelo/plotting.py | 138 ++++++++++++++++++----------------------- tests/test_plotting.py | 130 +++++++++++++++++++++++++++++++------- 2 files changed, 170 insertions(+), 98 deletions(-) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 4dd181b..4a9b129 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -367,93 +367,79 @@ def _prepare_region_contrast_value_modes( f"{side_name} side. Duplicate rows: {duplicate_rows.to_dict(orient='records')}." ) - coordinate_columns = ["region_id", "position", "anchor", "region_strand"] - numerator_coordinates = numerator.loc[:, coordinate_columns].copy() - denominator_coordinates = denominator.loc[:, coordinate_columns].copy() - coordinate_match = numerator_coordinates.merge( - denominator_coordinates, - on="region_id", - suffixes=("_numerator", "_denominator"), - how="inner", - ) - if coordinate_match.empty or len(coordinate_match) != len(numerator_coordinates) or len(coordinate_match) != len(denominator_coordinates): - raise ValueError("Unable to compute delta because numerator and denominator positions do not align.") - - coordinate_mismatch = ( - (coordinate_match["position_numerator"] != coordinate_match["position_denominator"]) - | (coordinate_match["anchor_numerator"] != coordinate_match["anchor_denominator"]) - | (coordinate_match["region_strand_numerator"] != coordinate_match["region_strand_denominator"]) + coordinate_match = numerator.loc[:, join_keys].merge( + denominator.loc[:, join_keys], + on=join_keys, + how="outer", + indicator=True, ) - if coordinate_mismatch.any(): - mismatched_rows = coordinate_match.loc[ - coordinate_mismatch, - [ - "region_id", - "position_numerator", - "position_denominator", - "anchor_numerator", - "anchor_denominator", - "region_strand_numerator", - "region_strand_denominator", - ], - ].copy() + if not (coordinate_match["_merge"] == "both").all(): + mismatched_rows = coordinate_match.loc[coordinate_match["_merge"] != "both", join_keys + ["_merge"]].copy() raise ValueError( "position_table contains mismatched coordinates between contrast sides. " f"Mismatched rows: {mismatched_rows.to_dict(orient='records')}." ) - summary_columns = ["region_id", "fraction", "reference_fraction", "delta_fraction"] + paired = numerator.merge( + denominator, + on=join_keys, + suffixes=("_numerator", "_denominator"), + how="inner", + ) + if paired.empty or len(paired) != len(numerator) or len(paired) != len(denominator): + raise ValueError("Unable to compute delta because numerator and denominator positions do not align.") + if "rank" in result.summary.columns: - summary_columns.append("rank") - _require_columns(result.summary, tuple(summary_columns), "result.summary") - summary = result.summary.loc[:, summary_columns].copy() + _require_columns(result.summary, ("region_id", "rank"), "result.summary") + rank_table = result.summary.loc[:, ["region_id", "rank"]].drop_duplicates(subset=["region_id"]) + else: + rank_table = None - plot_table = coordinate_match.loc[ - :, - ["region_id", "position_numerator", "anchor_numerator", "region_strand_numerator"], - ].rename( - columns={ - "position_numerator": "position", - "anchor_numerator": "anchor", - "region_strand_numerator": "region_strand", - } - ) - plot_table = plot_table.merge(summary, on="region_id", how="inner") + def _attach_rank(table: pd.DataFrame) -> pd.DataFrame: + if rank_table is None: + return table + return table.merge(rank_table, on="region_id", how="left") - if plot_table.empty: - raise ValueError("position_table does not contain any region_id values present in the contrast result.") + numerator_table = numerator.loc[:, ["region_id", grouping_key, "position", "anchor", "value", "region_strand"]].copy() + numerator_table["value_mode"] = "numerator" + numerator_table = _attach_rank(numerator_table) - side_labels = { - "numerator": ", ".join(str(value) for value in (contrast.numerator or [])) or "numerator", - "denominator": ", ".join(str(value) for value in (contrast.denominator or [])) or "denominator", - } - value_frames = [] - for value_mode, value_column in ( - ("numerator", "fraction"), - ("denominator", "reference_fraction"), - ("delta", "delta_fraction"), - ): - value_frame = plot_table.loc[:, [column for column in plot_table.columns if column != "fraction" and column != "reference_fraction" and column != "delta_fraction"]].copy() - value_frame["value"] = plot_table[value_column] - value_frame[grouping_key] = side_labels.get(value_mode, value_mode) - value_frame["value_mode"] = value_mode - value_frames.append( - value_frame.loc[ - :, - [ - "region_id", - grouping_key, - "position", - "anchor", - "value", - "region_strand", - "value_mode", - ] - + (["rank"] if "rank" in value_frame.columns else []), - ] - ) + denominator_table = denominator.loc[:, ["region_id", grouping_key, "position", "anchor", "value", "region_strand"]].copy() + denominator_table["value_mode"] = "denominator" + denominator_table = _attach_rank(denominator_table) + + delta_table = paired.loc[ + :, + [ + "region_id", + "position", + "anchor", + "region_strand", + "value_numerator", + "value_denominator", + ], + ].copy() + delta_table["value"] = delta_table["value_numerator"] - delta_table["value_denominator"] + delta_table[grouping_key] = "delta" + delta_table["value_mode"] = "delta" + delta_table = delta_table.loc[ + :, + ["region_id", grouping_key, "position", "anchor", "value", "region_strand", "value_mode"] + ] + delta_table = _attach_rank(delta_table) - return pd.concat(value_frames, ignore_index=True) + ordered_columns = ["region_id", grouping_key, "position", "anchor", "value", "region_strand", "value_mode"] + if rank_table is not None: + ordered_columns.append("rank") + + return pd.concat( + [ + numerator_table.loc[:, ordered_columns], + denominator_table.loc[:, ordered_columns], + delta_table.loc[:, ordered_columns], + ], + ignore_index=True, + ) def prepare_region_contrast_profile_data( diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 1841fd9..362e9d1 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -199,10 +199,26 @@ def _region_contrast_position_rows(*, include_grouping_key: bool = True) -> list "value": 0.6, "region_strand": "+", }, + { + "region_id": "chr1:90-110,+", + "condition": "NS", + "position": 105, + "anchor": 100, + "value": 0.2, + "region_strand": "+", + }, + { + "region_id": "chr1:90-110,+", + "condition": "15min", + "position": 105, + "anchor": 100, + "value": 0.7, + "region_strand": "+", + }, { "region_id": "chr1:190-210,-", "condition": "NS", - "position": 205, + "position": 195, "anchor": 200, "value": 0.2, "region_strand": "-", @@ -210,11 +226,27 @@ def _region_contrast_position_rows(*, include_grouping_key: bool = True) -> list { "region_id": "chr1:190-210,-", "condition": "15min", - "position": 205, + "position": 195, "anchor": 200, "value": 0.8, "region_strand": "-", }, + { + "region_id": "chr1:190-210,-", + "condition": "NS", + "position": 205, + "anchor": 200, + "value": 0.3, + "region_strand": "-", + }, + { + "region_id": "chr1:190-210,-", + "condition": "15min", + "position": 205, + "anchor": 200, + "value": 0.9, + "region_strand": "-", + }, ] if include_grouping_key: return base_rows @@ -238,40 +270,94 @@ def test_prepare_region_contrast_profile_data_returns_all_value_modes(): ) plot_table = payload["plot_table"] - assert len(plot_table) == 6 + assert len(plot_table) == 12 assert set(payload["plot_table"]["value_mode"]) == {"numerator", "denominator", "delta"} - assert plot_table.groupby(["region_id", "value_mode"]).size().to_dict() == { - ("chr1:90-110,+", "numerator"): 1, - ("chr1:90-110,+", "denominator"): 1, - ("chr1:90-110,+", "delta"): 1, - ("chr1:190-210,-", "numerator"): 1, - ("chr1:190-210,-", "denominator"): 1, - ("chr1:190-210,-", "delta"): 1, + assert plot_table.groupby(["region_id", "position", "value_mode"]).size().to_dict() == { + ("chr1:90-110,+", 95, "numerator"): 1, + ("chr1:90-110,+", 95, "denominator"): 1, + ("chr1:90-110,+", 95, "delta"): 1, + ("chr1:90-110,+", 105, "numerator"): 1, + ("chr1:90-110,+", 105, "denominator"): 1, + ("chr1:90-110,+", 105, "delta"): 1, + ("chr1:190-210,-", 195, "numerator"): 1, + ("chr1:190-210,-", 195, "denominator"): 1, + ("chr1:190-210,-", 195, "delta"): 1, + ("chr1:190-210,-", 205, "numerator"): 1, + ("chr1:190-210,-", 205, "denominator"): 1, + ("chr1:190-210,-", 205, "delta"): 1, } assert plot_table.loc[ - (plot_table["region_id"] == "chr1:90-110,+") & (plot_table["value_mode"] == "numerator"), + (plot_table["region_id"] == "chr1:90-110,+") + & (plot_table["position"] == 95) + & (plot_table["value_mode"] == "numerator"), + "value", + ].iloc[0] == pytest.approx(0.6) + assert plot_table.loc[ + (plot_table["region_id"] == "chr1:90-110,+") + & (plot_table["position"] == 95) + & (plot_table["value_mode"] == "denominator"), + "value", + ].iloc[0] == pytest.approx(0.1) + assert plot_table.loc[ + (plot_table["region_id"] == "chr1:90-110,+") + & (plot_table["position"] == 95) + & (plot_table["value_mode"] == "delta"), + "value", + ].iloc[0] == pytest.approx(0.5) + assert plot_table.loc[ + (plot_table["region_id"] == "chr1:90-110,+") + & (plot_table["position"] == 105) + & (plot_table["value_mode"] == "numerator"), + "value", + ].iloc[0] == pytest.approx(0.7) + assert plot_table.loc[ + (plot_table["region_id"] == "chr1:90-110,+") + & (plot_table["position"] == 105) + & (plot_table["value_mode"] == "denominator"), + "value", + ].iloc[0] == pytest.approx(0.2) + assert plot_table.loc[ + (plot_table["region_id"] == "chr1:90-110,+") + & (plot_table["position"] == 105) + & (plot_table["value_mode"] == "delta"), + "value", + ].iloc[0] == pytest.approx(0.5) + assert plot_table.loc[ + (plot_table["region_id"] == "chr1:190-210,-") + & (plot_table["position"] == 195) + & (plot_table["value_mode"] == "numerator"), "value", - ].iloc[0] == 0.55 + ].iloc[0] == pytest.approx(0.8) assert plot_table.loc[ - (plot_table["region_id"] == "chr1:90-110,+") & (plot_table["value_mode"] == "denominator"), + (plot_table["region_id"] == "chr1:190-210,-") + & (plot_table["position"] == 195) + & (plot_table["value_mode"] == "denominator"), "value", - ].iloc[0] == 0.20 + ].iloc[0] == pytest.approx(0.2) assert plot_table.loc[ - (plot_table["region_id"] == "chr1:90-110,+") & (plot_table["value_mode"] == "delta"), + (plot_table["region_id"] == "chr1:190-210,-") + & (plot_table["position"] == 195) + & (plot_table["value_mode"] == "delta"), "value", - ].iloc[0] == 0.35 + ].iloc[0] == pytest.approx(0.6) assert plot_table.loc[ - (plot_table["region_id"] == "chr1:190-210,-") & (plot_table["value_mode"] == "numerator"), + (plot_table["region_id"] == "chr1:190-210,-") + & (plot_table["position"] == 205) + & (plot_table["value_mode"] == "numerator"), "value", - ].iloc[0] == 0.70 + ].iloc[0] == pytest.approx(0.9) assert plot_table.loc[ - (plot_table["region_id"] == "chr1:190-210,-") & (plot_table["value_mode"] == "denominator"), + (plot_table["region_id"] == "chr1:190-210,-") + & (plot_table["position"] == 205) + & (plot_table["value_mode"] == "denominator"), "value", - ].iloc[0] == 0.30 + ].iloc[0] == pytest.approx(0.3) assert plot_table.loc[ - (plot_table["region_id"] == "chr1:190-210,-") & (plot_table["value_mode"] == "delta"), + (plot_table["region_id"] == "chr1:190-210,-") + & (plot_table["position"] == 205) + & (plot_table["value_mode"] == "delta"), "value", - ].iloc[0] == 0.40 + ].iloc[0] == pytest.approx(0.6) assert payload["metadata"]["plot_family"] == "region_contrast_profile" From 7ba30ee73c1077998b1e0f92264ca47534853bab Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 22:53:00 -0700 Subject: [PATCH 119/272] fix: collapse region contrast side labels --- dimelo/plotting.py | 18 ++--- tests/test_plotting.py | 178 ++++++++++++++++++++++++++++++++++++++--- 2 files changed, 172 insertions(+), 24 deletions(-) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 4a9b129..b053d21 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -358,14 +358,8 @@ def _prepare_region_contrast_value_modes( raise ValueError("position_table does not contain rows for both contrast sides.") join_keys = ["region_id", "position", "anchor", "region_strand"] - for side_name, side_table in (("numerator", numerator), ("denominator", denominator)): - duplicate_mask = side_table.duplicated(join_keys, keep=False) - if duplicate_mask.any(): - duplicate_rows = side_table.loc[duplicate_mask, join_keys + [grouping_key, "value"]].copy() - raise ValueError( - "position_table contains duplicate rows for the same coordinate on the " - f"{side_name} side. Duplicate rows: {duplicate_rows.to_dict(orient='records')}." - ) + numerator = numerator.loc[:, join_keys + ["value"]].groupby(join_keys, as_index=False, sort=False).mean(numeric_only=True) + denominator = denominator.loc[:, join_keys + ["value"]].groupby(join_keys, as_index=False, sort=False).mean(numeric_only=True) coordinate_match = numerator.loc[:, join_keys].merge( denominator.loc[:, join_keys], @@ -386,7 +380,7 @@ def _prepare_region_contrast_value_modes( suffixes=("_numerator", "_denominator"), how="inner", ) - if paired.empty or len(paired) != len(numerator) or len(paired) != len(denominator): + if paired.empty: raise ValueError("Unable to compute delta because numerator and denominator positions do not align.") if "rank" in result.summary.columns: @@ -400,12 +394,14 @@ def _attach_rank(table: pd.DataFrame) -> pd.DataFrame: return table return table.merge(rank_table, on="region_id", how="left") - numerator_table = numerator.loc[:, ["region_id", grouping_key, "position", "anchor", "value", "region_strand"]].copy() + numerator_table = numerator.loc[:, ["region_id", "position", "anchor", "value", "region_strand"]].copy() numerator_table["value_mode"] = "numerator" + numerator_table[grouping_key] = "numerator" numerator_table = _attach_rank(numerator_table) - denominator_table = denominator.loc[:, ["region_id", grouping_key, "position", "anchor", "value", "region_strand"]].copy() + denominator_table = denominator.loc[:, ["region_id", "position", "anchor", "value", "region_strand"]].copy() denominator_table["value_mode"] = "denominator" + denominator_table[grouping_key] = "denominator" denominator_table = _attach_rank(denominator_table) delta_table = paired.loc[ diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 362e9d1..acff4a6 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -161,6 +161,43 @@ def _minimal_region_contrast_result() -> RegionContrastResult: ) +def _group_vs_group_region_contrast_result() -> RegionContrastResult: + summary = pd.DataFrame( + [ + { + "region_id": "chr1:90-110,+", + "fraction": 0.60, + "reference_fraction": 0.10, + "delta_fraction": 0.50, + "rank": 1, + } + ] + ) + return RegionContrastResult( + regions=pd.DataFrame( + [ + {"region_id": "chr1:90-110,+", "condition": "NS", "fraction": 0.10, "rank": 1}, + {"region_id": "chr1:90-110,+", "condition": "15min", "fraction": 0.50, "rank": 1}, + {"region_id": "chr1:90-110,+", "condition": "30min", "fraction": 0.70, "rank": 1}, + ] + ), + summary=summary, + contrast=ContrastSpec( + mode="group_vs_group", + numerator=["15min", "30min"], + denominator=["NS"], + reference_condition="NS", + ), + metadata={ + "analysis_unit": "ensemble_region", + "representation": "modified_fraction", + "signal_source": "pileup_counts", + "test": "effect_size_only", + }, + plot_data={}, + ) + + def _region_contrast_plot_setup(position_rows: list[dict[str, object]]) -> tuple[ RegionContrastResult, pd.DataFrame, @@ -361,6 +398,113 @@ def test_prepare_region_contrast_profile_data_returns_all_value_modes(): assert payload["metadata"]["plot_family"] == "region_contrast_profile" +def test_prepare_region_contrast_profile_data_collapses_same_coordinate_labels_within_each_side(): + result = _group_vs_group_region_contrast_result() + position_table = pd.DataFrame( + [ + { + "region_id": "chr1:90-110,+", + "condition": "NS", + "position": 95, + "anchor": 100, + "value": 0.1, + "region_strand": "+", + }, + { + "region_id": "chr1:90-110,+", + "condition": "15min", + "position": 95, + "anchor": 100, + "value": 0.5, + "region_strand": "+", + }, + { + "region_id": "chr1:90-110,+", + "condition": "30min", + "position": 95, + "anchor": 100, + "value": 0.7, + "region_strand": "+", + }, + { + "region_id": "chr1:90-110,+", + "condition": "NS", + "position": 105, + "anchor": 100, + "value": 0.2, + "region_strand": "+", + }, + { + "region_id": "chr1:90-110,+", + "condition": "15min", + "position": 105, + "anchor": 100, + "value": 0.6, + "region_strand": "+", + }, + { + "region_id": "chr1:90-110,+", + "condition": "30min", + "position": 105, + "anchor": 100, + "value": 0.8, + "region_strand": "+", + }, + ] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=20, + downstream_bp=20, + ) + aggregation = plotting.AggregationSpec() + + payload = plotting.prepare_region_contrast_profile_data( + result=result, + position_table=position_table, + axis=axis, + aggregation=aggregation, + value_mode="all", + ) + + plot_table = payload["plot_table"] + assert len(plot_table) == 6 + assert plot_table.groupby(["position", "value_mode"]).size().to_dict() == { + (95, "numerator"): 1, + (95, "denominator"): 1, + (95, "delta"): 1, + (105, "numerator"): 1, + (105, "denominator"): 1, + (105, "delta"): 1, + } + assert plot_table.loc[ + (plot_table["position"] == 95) & (plot_table["value_mode"] == "numerator"), + "value", + ].iloc[0] == pytest.approx(0.6) + assert plot_table.loc[ + (plot_table["position"] == 95) & (plot_table["value_mode"] == "denominator"), + "value", + ].iloc[0] == pytest.approx(0.1) + assert plot_table.loc[ + (plot_table["position"] == 95) & (plot_table["value_mode"] == "delta"), + "value", + ].iloc[0] == pytest.approx(0.5) + assert plot_table.loc[ + (plot_table["position"] == 105) & (plot_table["value_mode"] == "numerator"), + "value", + ].iloc[0] == pytest.approx(0.7) + assert plot_table.loc[ + (plot_table["position"] == 105) & (plot_table["value_mode"] == "denominator"), + "value", + ].iloc[0] == pytest.approx(0.2) + assert plot_table.loc[ + (plot_table["position"] == 105) & (plot_table["value_mode"] == "delta"), + "value", + ].iloc[0] == pytest.approx(0.5) + + def test_prepare_region_contrast_heatmap_data_orders_rows_by_rank(): result, position_table, axis, aggregation = _region_contrast_plot_setup( _region_contrast_position_rows() @@ -382,13 +526,19 @@ def test_prepare_region_contrast_heatmap_data_orders_rows_by_rank(): assert payload["metadata"]["plot_family"] == "region_contrast_heatmap" -def test_prepare_region_contrast_profile_data_requires_joinable_grouping_key(): +def test_prepare_region_contrast_profile_data_requires_grouping_key(): result, position_table, axis, aggregation = _region_contrast_plot_setup( _region_contrast_position_rows(include_grouping_key=False) ) with pytest.raises(ValueError, match="sample_id or condition"): - plotting._region_contrast_grouping_key(result, position_table) + plotting.prepare_region_contrast_profile_data( + result=result, + position_table=position_table, + axis=axis, + aggregation=aggregation, + value_mode="all", + ) @pytest.mark.parametrize( @@ -421,20 +571,22 @@ def test_prepare_region_contrast_profile_data_requires_joinable_grouping_key(): def test_prepare_region_contrast_profile_data_rejects_ambiguous_grouping_key(position_rows): result, _, _, _ = _region_contrast_plot_setup(_region_contrast_position_rows()) position_table = pd.DataFrame(position_rows) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=20, + downstream_bp=20, + ) + aggregation = plotting.AggregationSpec() with pytest.raises(ValueError, match="could not resolve a unique grouping key"): - plotting._region_contrast_grouping_key(result, position_table) - - -def test_prepare_region_contrast_value_modes_rejects_duplicate_coordinate_rows(): - result, position_table, _, _ = _region_contrast_plot_setup(_region_contrast_position_rows()) - duplicated = pd.concat([position_table, position_table.iloc[[0]]], ignore_index=True) - - with pytest.raises(ValueError, match="duplicate rows for the same coordinate"): - plotting._prepare_region_contrast_value_modes( + plotting.prepare_region_contrast_profile_data( result=result, - position_table=duplicated, - grouping_key="condition", + position_table=position_table, + axis=axis, + aggregation=aggregation, + value_mode="all", ) From c4f1d6723f02e3afc82a386b92fa4b4a46383a08 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 22:56:26 -0700 Subject: [PATCH 120/272] feat: add region contrast heatmap plotting prep --- dimelo/plotting.py | 48 ++++++++++++++++++++++++++++++++++++++++++ tests/test_plotting.py | 27 ++++++++++++++++++++++++ 2 files changed, 75 insertions(+) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index b053d21..987047f 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -483,6 +483,54 @@ def prepare_region_contrast_profile_data( return prepared +def prepare_region_contrast_heatmap_data( + *, + result, + position_table: pd.DataFrame, + axis: AxisSpec, + aggregation: AggregationSpec, + value_mode: str = "all", +) -> dict[str, pd.DataFrame | dict[str, object]]: + profile_payload = prepare_region_contrast_profile_data( + result=result, + position_table=position_table, + axis=axis, + aggregation=aggregation, + value_mode=value_mode, + ) + + _require_columns(result.summary, ("region_id", "rank"), "result.summary") + row_order = ( + result.summary.loc[:, ["region_id", "rank"]] + .dropna(subset=["region_id", "rank"]) + .drop_duplicates(subset=["region_id"], keep="first") + .sort_values(["rank", "region_id"], kind="stable") + .reset_index(drop=True) + ) + row_order["row_order"] = range(len(row_order)) + + plot_table = profile_payload["plot_table"].merge( + row_order.loc[:, ["region_id", "row_order"]], + on="region_id", + how="left", + ) + if plot_table["row_order"].isna().any(): + missing_region_ids = sorted(plot_table.loc[plot_table["row_order"].isna(), "region_id"].astype(str).unique()) + raise ValueError( + "result.summary does not provide rank values for all plotted regions. " + f"Missing region_id values: {', '.join(missing_region_ids)}." + ) + plot_table = plot_table.sort_values(["row_order", "value_mode", "position"], kind="stable").reset_index(drop=True) + + profile_payload["plot_table"] = plot_table + profile_payload["metadata"] = { + **profile_payload["metadata"], + "plot_family": "region_contrast_heatmap", + } + profile_payload["summary_table"] = row_order + return profile_payload + + def prepare_single_read_plot_data( table: pd.DataFrame, *, diff --git a/tests/test_plotting.py b/tests/test_plotting.py index acff4a6..4bf436f 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -526,6 +526,33 @@ def test_prepare_region_contrast_heatmap_data_orders_rows_by_rank(): assert payload["metadata"]["plot_family"] == "region_contrast_heatmap" +def test_prepare_region_contrast_heatmap_data_requires_both_contrast_sides(): + result, _, axis, aggregation = _region_contrast_plot_setup( + _region_contrast_position_rows() + ) + position_table = pd.DataFrame( + [ + { + "region_id": "chr1:90-110,+", + "condition": "NS", + "position": 95, + "anchor": 100, + "value": 0.1, + "region_strand": "+", + } + ] + ) + + with pytest.raises(ValueError, match="both contrast sides"): + plotting.prepare_region_contrast_heatmap_data( + result=result, + position_table=position_table, + axis=axis, + aggregation=aggregation, + value_mode="all", + ) + + def test_prepare_region_contrast_profile_data_requires_grouping_key(): result, position_table, axis, aggregation = _region_contrast_plot_setup( _region_contrast_position_rows(include_grouping_key=False) From 5c000f2741c5ac4bf086d160b45009c4ab567818 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 22:58:56 -0700 Subject: [PATCH 121/272] fix: validate region contrast heatmap ranks --- dimelo/plotting.py | 38 +++++++++++++++++++++--------- tests/test_plotting.py | 53 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 80 insertions(+), 11 deletions(-) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 987047f..bf986f2 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -500,13 +500,35 @@ def prepare_region_contrast_heatmap_data( ) _require_columns(result.summary, ("region_id", "rank"), "result.summary") - row_order = ( - result.summary.loc[:, ["region_id", "rank"]] - .dropna(subset=["region_id", "rank"]) - .drop_duplicates(subset=["region_id"], keep="first") - .sort_values(["rank", "region_id"], kind="stable") + plot_region_ids = ( + profile_payload["plot_table"].loc[:, ["region_id"]] + .drop_duplicates() .reset_index(drop=True) ) + summary_ranks = ( + result.summary.loc[:, ["region_id", "rank"]] + .dropna(subset=["region_id"]) + .groupby("region_id", as_index=False, sort=False) + .agg( + rank=("rank", "first"), + rank_count=("rank", lambda values: pd.Series(values).dropna().nunique()), + ) + ) + conflicting_rank_ids = sorted(summary_ranks.loc[summary_ranks["rank_count"] != 1, "region_id"].astype(str).unique()) + if conflicting_rank_ids: + raise ValueError( + "result.summary must provide exactly one rank value per plotted region. " + f"Conflicting region_id values: {', '.join(conflicting_rank_ids)}." + ) + + row_order = plot_region_ids.merge(summary_ranks.loc[:, ["region_id", "rank"]], on="region_id", how="left") + missing_rank_ids = sorted(row_order.loc[row_order["rank"].isna(), "region_id"].astype(str).unique()) + if missing_rank_ids: + raise ValueError( + "result.summary does not provide rank values for all plotted regions. " + f"Missing region_id values: {', '.join(missing_rank_ids)}." + ) + row_order = row_order.sort_values(["rank", "region_id"], kind="stable").reset_index(drop=True) row_order["row_order"] = range(len(row_order)) plot_table = profile_payload["plot_table"].merge( @@ -514,12 +536,6 @@ def prepare_region_contrast_heatmap_data( on="region_id", how="left", ) - if plot_table["row_order"].isna().any(): - missing_region_ids = sorted(plot_table.loc[plot_table["row_order"].isna(), "region_id"].astype(str).unique()) - raise ValueError( - "result.summary does not provide rank values for all plotted regions. " - f"Missing region_id values: {', '.join(missing_region_ids)}." - ) plot_table = plot_table.sort_values(["row_order", "value_mode", "position"], kind="stable").reset_index(drop=True) profile_payload["plot_table"] = plot_table diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 4bf436f..de73789 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -509,6 +509,23 @@ def test_prepare_region_contrast_heatmap_data_orders_rows_by_rank(): result, position_table, axis, aggregation = _region_contrast_plot_setup( _region_contrast_position_rows() ) + result.summary = pd.concat( + [ + result.summary, + pd.DataFrame( + [ + { + "region_id": "chr1:290-310,+", + "fraction": 0.15, + "reference_fraction": 0.05, + "delta_fraction": 0.10, + "rank": 3, + } + ] + ), + ], + ignore_index=True, + ) payload = plotting.prepare_region_contrast_heatmap_data( result=result, @@ -523,9 +540,45 @@ def test_prepare_region_contrast_heatmap_data_orders_rows_by_rank(): "chr1:190-210,-", "chr1:90-110,+", ] + assert list(payload["summary_table"]["region_id"]) == [ + "chr1:190-210,-", + "chr1:90-110,+", + ] assert payload["metadata"]["plot_family"] == "region_contrast_heatmap" +def test_prepare_region_contrast_heatmap_data_rejects_conflicting_ranks_for_same_region(): + result, position_table, axis, aggregation = _region_contrast_plot_setup( + _region_contrast_position_rows() + ) + result.summary = pd.concat( + [ + result.summary, + pd.DataFrame( + [ + { + "region_id": "chr1:90-110,+", + "fraction": 0.55, + "reference_fraction": 0.20, + "delta_fraction": 0.35, + "rank": 7, + } + ] + ), + ], + ignore_index=True, + ) + + with pytest.raises(ValueError, match="exactly one rank value per plotted region"): + plotting.prepare_region_contrast_heatmap_data( + result=result, + position_table=position_table, + axis=axis, + aggregation=aggregation, + value_mode="all", + ) + + def test_prepare_region_contrast_heatmap_data_requires_both_contrast_sides(): result, _, axis, aggregation = _region_contrast_plot_setup( _region_contrast_position_rows() From d3a2c46c060b3968c8655f9ff5dbecaf2bfbe256 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 23:01:22 -0700 Subject: [PATCH 122/272] fix: scope region contrast heatmap rank validation --- dimelo/plotting.py | 27 ++++++++++++++++----------- tests/test_plotting.py | 7 +++++++ 2 files changed, 23 insertions(+), 11 deletions(-) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index bf986f2..618a5d4 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -505,24 +505,29 @@ def prepare_region_contrast_heatmap_data( .drop_duplicates() .reset_index(drop=True) ) - summary_ranks = ( - result.summary.loc[:, ["region_id", "rank"]] - .dropna(subset=["region_id"]) - .groupby("region_id", as_index=False, sort=False) - .agg( - rank=("rank", "first"), - rank_count=("rank", lambda values: pd.Series(values).dropna().nunique()), - ) + summary_ranks = plot_region_ids.merge( + result.summary.loc[:, ["region_id", "rank"]], + on="region_id", + how="left", + ) + summary_ranks = summary_ranks.groupby("region_id", as_index=False, sort=False).agg( + rank=( + "rank", + lambda values: ( + lambda non_na: non_na.iloc[0] if not non_na.empty else pd.NA + )(pd.Series(values).dropna()), + ), + rank_count=("rank", lambda values: pd.Series(values).dropna().nunique()), ) - conflicting_rank_ids = sorted(summary_ranks.loc[summary_ranks["rank_count"] != 1, "region_id"].astype(str).unique()) + conflicting_rank_ids = sorted(summary_ranks.loc[summary_ranks["rank_count"] > 1, "region_id"].astype(str).unique()) if conflicting_rank_ids: raise ValueError( "result.summary must provide exactly one rank value per plotted region. " f"Conflicting region_id values: {', '.join(conflicting_rank_ids)}." ) - row_order = plot_region_ids.merge(summary_ranks.loc[:, ["region_id", "rank"]], on="region_id", how="left") - missing_rank_ids = sorted(row_order.loc[row_order["rank"].isna(), "region_id"].astype(str).unique()) + row_order = summary_ranks.loc[:, ["region_id", "rank"]].copy() + missing_rank_ids = sorted(summary_ranks.loc[summary_ranks["rank_count"] == 0, "region_id"].astype(str).unique()) if missing_rank_ids: raise ValueError( "result.summary does not provide rank values for all plotted regions. " diff --git a/tests/test_plotting.py b/tests/test_plotting.py index de73789..a3cfcdf 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -520,6 +520,13 @@ def test_prepare_region_contrast_heatmap_data_orders_rows_by_rank(): "reference_fraction": 0.05, "delta_fraction": 0.10, "rank": 3, + }, + { + "region_id": "chr1:290-310,+", + "fraction": 0.16, + "reference_fraction": 0.05, + "delta_fraction": 0.11, + "rank": 8, } ] ), From d1179983aec817332b450d567cdfa83a7ec5fffd Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 23:03:12 -0700 Subject: [PATCH 123/272] docs: add region contrast plotting guide --- README.md | 2 ++ docs/region-contrasts.md | 34 ++++++++++++++++++++++++++++++++++ 2 files changed, 36 insertions(+) diff --git a/README.md b/README.md index 478f1e2..ebede41 100644 --- a/README.md +++ b/README.md @@ -264,6 +264,8 @@ Legacy plotting entry points remain supported, but they now share a common plott - Single-read plots remain coordinate-preserving. They can use fixed-window coordinates and 5'->3' orientation, but they do not stretch variable-length regions onto a synthetic continuous axis. - Built-in Matplotlib plotting is still available, while plot-ready tables remain the stable contract for users who prefer seaborn, Plotly, Altair, or custom renderers. +Newer region-contrast plotting helpers accept a `RegionContrastResult` plus an explicit `position_table` from the parsing/loading layer. This keeps region scoring and positional extraction separate while still using the shared plotting-axis system. + `plot_enrichment_profile` module for pileup line plot profiles across one or more region ``` def plot_enrichment_profile( diff --git a/docs/region-contrasts.md b/docs/region-contrasts.md index c2fe059..0e4518e 100644 --- a/docs/region-contrasts.md +++ b/docs/region-contrasts.md @@ -175,6 +175,40 @@ sns.scatterplot( ) ``` +For region-contrast-specific plots, use the new plotting helpers with a `RegionContrastResult`, an explicit `position_table`, and the shared axis/aggregation spec: + +```python +from dimelo import plotting + +profile_payload = plotting.prepare_region_contrast_profile_data( + result=result, + position_table=position_table, + axis=plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=2000, + downstream_bp=2000, + ), + aggregation=plotting.AggregationSpec(), +) + +heatmap_payload = plotting.prepare_region_contrast_heatmap_data( + result=result, + position_table=position_table, + axis=plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=2000, + downstream_bp=2000, + ), + aggregation=plotting.AggregationSpec(), +) +``` + +`position_table` must already be an aggregated positional substrate from the parsing/loading layer, not raw per-read events. + ## Preprocessing Reminder - Run `parse_bam.pileup()` when you care about motif abundance, defined-region contrasts, or later de novo discovery. From eded24eb231b7d69e3de24931c45cc52ab8954ce Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 1 Apr 2026 23:04:57 -0700 Subject: [PATCH 124/272] docs: clarify region contrast plotting inputs --- README.md | 2 +- docs/region-contrasts.md | 11 ++++++++++- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index ebede41..a18d22a 100644 --- a/README.md +++ b/README.md @@ -264,7 +264,7 @@ Legacy plotting entry points remain supported, but they now share a common plott - Single-read plots remain coordinate-preserving. They can use fixed-window coordinates and 5'->3' orientation, but they do not stretch variable-length regions onto a synthetic continuous axis. - Built-in Matplotlib plotting is still available, while plot-ready tables remain the stable contract for users who prefer seaborn, Plotly, Altair, or custom renderers. -Newer region-contrast plotting helpers accept a `RegionContrastResult` plus an explicit `position_table` from the parsing/loading layer. This keeps region scoring and positional extraction separate while still using the shared plotting-axis system. +Newer region-contrast plotting helpers accept a `RegionContrastResult` plus an explicit `position_table` from the parsing/loading layer. This keeps region scoring and positional extraction separate while still using the shared plotting-axis system. The current helper contract expects `region_id`, `position`, `anchor`, `value`, `region_strand`, and either `condition` or `sample_id` in that positional table. `plot_enrichment_profile` module for pileup line plot profiles across one or more region ``` diff --git a/docs/region-contrasts.md b/docs/region-contrasts.md index 0e4518e..88269c2 100644 --- a/docs/region-contrasts.md +++ b/docs/region-contrasts.md @@ -207,7 +207,16 @@ heatmap_payload = plotting.prepare_region_contrast_heatmap_data( ) ``` -`position_table` must already be an aggregated positional substrate from the parsing/loading layer, not raw per-read events. +`position_table` must already be an aggregated positional substrate from the parsing/loading layer, not raw per-read events. The current helper contract expects at minimum: + +- `region_id` +- `position` +- `anchor` +- `value` +- `region_strand` +- either `condition` or `sample_id` + +For `prepare_region_contrast_heatmap_data(...)`, `result.summary` must also provide one unambiguous `rank` value per plotted region. ## Preprocessing Reminder From e61708261a90142e1230ab3d9cf17e460a8ba69e Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 10:02:33 -0700 Subject: [PATCH 125/272] docs: add superpowers cleanup spec --- ...6-04-02-superpowers-docs-cleanup-design.md | 191 ++++++++++++++++++ 1 file changed, 191 insertions(+) create mode 100644 docs/superpowers/specs/2026-04-02-superpowers-docs-cleanup-design.md diff --git a/docs/superpowers/specs/2026-04-02-superpowers-docs-cleanup-design.md b/docs/superpowers/specs/2026-04-02-superpowers-docs-cleanup-design.md new file mode 100644 index 0000000..e4fb796 --- /dev/null +++ b/docs/superpowers/specs/2026-04-02-superpowers-docs-cleanup-design.md @@ -0,0 +1,191 @@ +# Superpowers Docs Cleanup Design + +## Purpose + +This design defines the first cleanup pass for the internal planning trail under `docs/superpowers`. + +The goal is to make the accumulated specs and plans: + +- tracked in git +- easy to navigate +- clear about what has been implemented versus what remains follow-on work + +This is a docs-first cleanup slice. It does not yet change package code or user-facing APIs. + +## Problem + +The repository now contains a substantial internal design and planning trail: + +- specs under `docs/superpowers/specs` +- plans under `docs/superpowers/plans` + +Some of the plan files exist on disk but are still untracked. The docs set is also missing a simple navigation layer, so it is difficult to tell: + +- which specs belong to which plans +- which plans were executed already +- which slices are still only planned +- which later plans supersede or extend earlier ones + +The cleanup should preserve this history without requiring every historical file to be rewritten. + +## Core Design Rule + +Status should be tracked centrally, not embedded into every spec and plan file. + +This avoids: + +- rewriting historical design docs +- duplicating status information across many files +- future drift between per-file annotations + +The first cleanup slice should therefore introduce one central index file instead of editing every existing file header. + +## Scope + +This cleanup slice should do three things: + +1. track the currently untracked plan files in git +2. add a central navigation/index document for `docs/superpowers` +3. map specs and plans to current implementation status in that index + +It should not: + +- rewrite the historical spec content +- merge or delete old spec/plan files +- introduce a heavy metadata system +- touch code outside documentation cleanup + +## Recommended File Structure + +Add one central index file: + +- [README.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md) + +Keep the existing layout: + +- `docs/superpowers/specs/` +- `docs/superpowers/plans/` + +Do not reorganize those directories in this slice. + +## Index Content + +The new central index should have four sections: + +### 1. Overview + +Briefly explain what `docs/superpowers` contains: + +- specs are design documents +- plans are executable implementation breakdowns +- statuses in the index reflect the current branch/repo state + +### 2. Specs + +List the existing specs grouped by theme, with a short description and one of: + +- `implemented` +- `partially implemented` +- `planned` + +### 3. Plans + +List the implementation plans grouped by theme, with a short description and one of: + +- `implemented` +- `partially implemented` +- `not started` + +### 4. Current Themes + +Group related work so the trail is readable, for example: + +- shared clustering +- region contrasts +- region discovery +- global analysis +- plotting architecture + +This section can point users to the most relevant spec/plan sequence for each theme. + +## Status Semantics + +The cleanup should use lightweight status labels only. + +Recommended meanings: + +- `implemented` + The planned slice has been completed and corresponding code/docs are in the repo. + +- `partially implemented` + Some downstream or follow-on pieces exist, but the spec/plan family is not fully exhausted. + +- `planned` + The design exists, but implementation for that slice has not yet landed. + +- `not started` + A plan exists but has not been executed. + +These labels should be applied only in the central index. + +## Treatment of Existing Untracked Plans + +The current untracked files under `docs/superpowers/plans` should be committed rather than removed. + +Rationale: + +- they correspond to real design/implementation work +- they are useful historical context +- they make the executed development trail auditable + +This cleanup slice should not try to prune them aggressively. + +## Minimal Editing Principle + +This slice should prefer: + +- adding one new index +- committing the existing plan files as-is + +over: + +- editing every plan/spec header +- retrofitting status fields into older docs +- renaming the existing files + +That keeps the cleanup low-risk and easy to maintain. + +## Implementation Notes + +The index should reflect the current codebase state on the branch where the cleanup is executed. + +That means it should call out, at minimum, the slices that have clearly landed: + +- shared clustering foundations +- region contrasts foundations +- global analysis foundations +- region discovery foundations +- discovery to clustering workflow +- discovery to clustering to contrasts workflow +- cluster occupancy region contrasts +- plotting axis architecture +- region contrasts plotting + +If a broader feature area still has follow-on work remaining, mark the family as `partially implemented` rather than overstating completion. + +## Tests / Verification + +This is docs-only cleanup, so verification can stay lightweight: + +- confirm the new index references the actual existing files +- confirm the untracked plan files are now staged/committed +- confirm there are no broken file paths in the index text + +## Recommended Build Order + +1. Add `docs/superpowers/README.md`. +2. Populate it with grouped spec/plan links and lightweight status labels. +3. Add the currently untracked plan docs to git. +4. Verify the index paths match the actual repo contents. +5. Commit the docs cleanup slice. + From 17915c03db9acee818246f7dad46820e000aa72f Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 10:43:43 -0700 Subject: [PATCH 126/272] docs: add superpowers docs index --- docs/superpowers/README.md | 72 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 docs/superpowers/README.md diff --git a/docs/superpowers/README.md b/docs/superpowers/README.md new file mode 100644 index 0000000..a0273f8 --- /dev/null +++ b/docs/superpowers/README.md @@ -0,0 +1,72 @@ +# Superpowers Docs Index + +This directory tracks internal design and implementation work for the current branch. + +- `specs/` contains design documents. +- `plans/` contains executable implementation breakdowns. +- Status is tracked here centrally so historical docs can remain stable snapshots. + +## Status Labels + +- `implemented`: the planned slice has landed in the repo. +- `partially implemented`: some related work has landed, but the broader feature family still has follow-on work. +- `planned`: the design exists, but the slice is not yet implemented. +- `not started`: a plan exists, but execution has not started. + +## Specs + +### Shared Clustering + +- [2026-03-31-shared-cluster-distribution-design.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md) - shared-boundary clustering architecture and artifact model. Status: `partially implemented` + +### Region Analysis + +- [2026-03-31-region-analysis-architecture-design.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-03-31-region-analysis-architecture-design.md) - common architecture for region discovery, global analysis, and contrasts. Status: `partially implemented` +- [2026-03-31-pre-plan-decisions-addendum.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-03-31-pre-plan-decisions-addendum.md) - cross-cutting policy decisions for shared clustering and region analysis follow-on work. Status: `partially implemented` +- [2026-04-01-paired-region-discovery-design.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-04-01-paired-region-discovery-design.md) - paired discovery support for matched and ordered comparisons. Status: `implemented` + +### Plotting + +- [2026-04-01-plotting-axis-architecture-design.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-04-01-plotting-axis-architecture-design.md) - shared plotting-axis and renderer-neutral payload architecture. Status: `implemented` +- [2026-04-01-region-contrasts-plotting-design.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-04-01-region-contrasts-plotting-design.md) - plotting prep for region contrast profiles and heatmaps. Status: `implemented` + +### Cleanup And Docs + +- [2026-04-02-superpowers-docs-cleanup-design.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-04-02-superpowers-docs-cleanup-design.md) - central index and status-map cleanup for internal planning docs. Status: `partially implemented` + +## Plans + +### Shared Clustering + +- [2026-03-31-shared-clustering-foundations.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-shared-clustering-foundations.md) - shared clustering models, artifacts, plotting payloads, and workflows. Status: `implemented` + +### Region Analysis + +- [2026-03-31-global-analysis-foundations.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-global-analysis-foundations.md) - global analysis models, workflows, and artifact plumbing. Status: `implemented` +- [2026-03-31-region-contrasts-foundations.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-region-contrasts-foundations.md) - defined-region contrast foundations and scoring paths. Status: `implemented` +- [2026-04-01-cluster-occupancy-region-contrasts.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-cluster-occupancy-region-contrasts.md) - cluster-occupancy evidence and scoring for region contrasts. Status: `implemented` + +### Region Discovery + +- [2026-03-31-region-discovery-foundations.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-region-discovery-foundations.md) - genome scan foundations, result models, and plotting payloads. Status: `implemented` +- [2026-04-01-paired-region-discovery.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-paired-region-discovery.md) - paired discovery support for matched pairwise and paired time-course scans. Status: `implemented` +- [2026-04-01-region-discovery-cluster-workflow.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-region-discovery-cluster-workflow.md) - workflow that chains discovery into shared clustering. Status: `implemented` +- [2026-04-01-discovery-cluster-contrast-workflow.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-discovery-cluster-contrast-workflow.md) - workflow that chains discovery, clustering, and contrasts. Status: `implemented` + +### Plotting + +- [2026-04-01-plotting-axis-architecture.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-plotting-axis-architecture.md) - shared plotting-axis implementation slice. Status: `implemented` +- [2026-04-01-region-contrasts-plotting.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md) - region contrast plotting prep for profiles and heatmaps. Status: `implemented` + +### Cleanup And Docs + +- [2026-04-02-superpowers-docs-cleanup.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-02-superpowers-docs-cleanup.md) - central docs index and tracked-plan cleanup. Status: `partially implemented` + +## Current Themes + +- Shared clustering: start with the shared clustering design spec, then the foundations plan, then the discovery-to-clustering workflows. +- Region contrasts: start with the region analysis architecture spec, then the contrasts foundations plan, cluster-occupancy follow-on work, and the region-contrasts plotting plan. +- Region discovery: use the region analysis architecture spec, the paired discovery spec, and the discovery workflow plans together. +- Global analysis: use the region analysis architecture spec first, then the global analysis foundations plan. +- Plotting: start with the plotting-axis spec, then the plotting-axis implementation plan and the region-contrasts plotting plan. +- Docs cleanup: use the docs cleanup design and plan for the central status map and tracked historical plans. From 03477aeecdf8718adb7ea13d390ad0af819a55b4 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 10:46:23 -0700 Subject: [PATCH 127/272] docs: make superpowers index links portable --- docs/superpowers/README.md | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/docs/superpowers/README.md b/docs/superpowers/README.md index a0273f8..7377803 100644 --- a/docs/superpowers/README.md +++ b/docs/superpowers/README.md @@ -17,50 +17,50 @@ This directory tracks internal design and implementation work for the current br ### Shared Clustering -- [2026-03-31-shared-cluster-distribution-design.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md) - shared-boundary clustering architecture and artifact model. Status: `partially implemented` +- [2026-03-31-shared-cluster-distribution-design.md](specs/2026-03-31-shared-cluster-distribution-design.md) - shared-boundary clustering architecture and artifact model. Status: `partially implemented` ### Region Analysis -- [2026-03-31-region-analysis-architecture-design.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-03-31-region-analysis-architecture-design.md) - common architecture for region discovery, global analysis, and contrasts. Status: `partially implemented` -- [2026-03-31-pre-plan-decisions-addendum.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-03-31-pre-plan-decisions-addendum.md) - cross-cutting policy decisions for shared clustering and region analysis follow-on work. Status: `partially implemented` -- [2026-04-01-paired-region-discovery-design.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-04-01-paired-region-discovery-design.md) - paired discovery support for matched and ordered comparisons. Status: `implemented` +- [2026-03-31-region-analysis-architecture-design.md](specs/2026-03-31-region-analysis-architecture-design.md) - common architecture for region discovery, global analysis, and contrasts. Status: `partially implemented` +- [2026-03-31-pre-plan-decisions-addendum.md](specs/2026-03-31-pre-plan-decisions-addendum.md) - cross-cutting policy decisions for shared clustering and region analysis follow-on work. Status: `partially implemented` +- [2026-04-01-paired-region-discovery-design.md](specs/2026-04-01-paired-region-discovery-design.md) - paired discovery support for matched and ordered comparisons. Status: `implemented` ### Plotting -- [2026-04-01-plotting-axis-architecture-design.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-04-01-plotting-axis-architecture-design.md) - shared plotting-axis and renderer-neutral payload architecture. Status: `implemented` -- [2026-04-01-region-contrasts-plotting-design.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-04-01-region-contrasts-plotting-design.md) - plotting prep for region contrast profiles and heatmaps. Status: `implemented` +- [2026-04-01-plotting-axis-architecture-design.md](specs/2026-04-01-plotting-axis-architecture-design.md) - shared plotting-axis and renderer-neutral payload architecture. Status: `implemented` +- [2026-04-01-region-contrasts-plotting-design.md](specs/2026-04-01-region-contrasts-plotting-design.md) - plotting prep for region contrast profiles and heatmaps. Status: `implemented` ### Cleanup And Docs -- [2026-04-02-superpowers-docs-cleanup-design.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-04-02-superpowers-docs-cleanup-design.md) - central index and status-map cleanup for internal planning docs. Status: `partially implemented` +- [2026-04-02-superpowers-docs-cleanup-design.md](specs/2026-04-02-superpowers-docs-cleanup-design.md) - central index and status-map cleanup for internal planning docs. Status: `partially implemented` ## Plans ### Shared Clustering -- [2026-03-31-shared-clustering-foundations.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-shared-clustering-foundations.md) - shared clustering models, artifacts, plotting payloads, and workflows. Status: `implemented` +- [2026-03-31-shared-clustering-foundations.md](plans/2026-03-31-shared-clustering-foundations.md) - shared clustering models, artifacts, plotting payloads, and workflows. Status: `implemented` ### Region Analysis -- [2026-03-31-global-analysis-foundations.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-global-analysis-foundations.md) - global analysis models, workflows, and artifact plumbing. Status: `implemented` -- [2026-03-31-region-contrasts-foundations.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-region-contrasts-foundations.md) - defined-region contrast foundations and scoring paths. Status: `implemented` -- [2026-04-01-cluster-occupancy-region-contrasts.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-cluster-occupancy-region-contrasts.md) - cluster-occupancy evidence and scoring for region contrasts. Status: `implemented` +- [2026-03-31-global-analysis-foundations.md](plans/2026-03-31-global-analysis-foundations.md) - global analysis models, workflows, and artifact plumbing. Status: `implemented` +- [2026-03-31-region-contrasts-foundations.md](plans/2026-03-31-region-contrasts-foundations.md) - defined-region contrast foundations and scoring paths. Status: `implemented` +- [2026-04-01-cluster-occupancy-region-contrasts.md](plans/2026-04-01-cluster-occupancy-region-contrasts.md) - cluster-occupancy evidence and scoring for region contrasts. Status: `implemented` ### Region Discovery -- [2026-03-31-region-discovery-foundations.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-region-discovery-foundations.md) - genome scan foundations, result models, and plotting payloads. Status: `implemented` -- [2026-04-01-paired-region-discovery.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-paired-region-discovery.md) - paired discovery support for matched pairwise and paired time-course scans. Status: `implemented` -- [2026-04-01-region-discovery-cluster-workflow.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-region-discovery-cluster-workflow.md) - workflow that chains discovery into shared clustering. Status: `implemented` -- [2026-04-01-discovery-cluster-contrast-workflow.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-discovery-cluster-contrast-workflow.md) - workflow that chains discovery, clustering, and contrasts. Status: `implemented` +- [2026-03-31-region-discovery-foundations.md](plans/2026-03-31-region-discovery-foundations.md) - genome scan foundations, result models, and plotting payloads. Status: `implemented` +- [2026-04-01-paired-region-discovery.md](plans/2026-04-01-paired-region-discovery.md) - paired discovery support for matched pairwise and paired time-course scans. Status: `implemented` +- [2026-04-01-region-discovery-cluster-workflow.md](plans/2026-04-01-region-discovery-cluster-workflow.md) - workflow that chains discovery into shared clustering. Status: `implemented` +- [2026-04-01-discovery-cluster-contrast-workflow.md](plans/2026-04-01-discovery-cluster-contrast-workflow.md) - workflow that chains discovery, clustering, and contrasts. Status: `implemented` ### Plotting -- [2026-04-01-plotting-axis-architecture.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-plotting-axis-architecture.md) - shared plotting-axis implementation slice. Status: `implemented` -- [2026-04-01-region-contrasts-plotting.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md) - region contrast plotting prep for profiles and heatmaps. Status: `implemented` +- [2026-04-01-plotting-axis-architecture.md](plans/2026-04-01-plotting-axis-architecture.md) - shared plotting-axis implementation slice. Status: `implemented` +- [2026-04-01-region-contrasts-plotting.md](plans/2026-04-01-region-contrasts-plotting.md) - region contrast plotting prep for profiles and heatmaps. Status: `implemented` ### Cleanup And Docs -- [2026-04-02-superpowers-docs-cleanup.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-02-superpowers-docs-cleanup.md) - central docs index and tracked-plan cleanup. Status: `partially implemented` +- [2026-04-02-superpowers-docs-cleanup.md](plans/2026-04-02-superpowers-docs-cleanup.md) - central docs index and tracked-plan cleanup. Status: `partially implemented` ## Current Themes From 6b8a3e5484ed62ef7648e87c7bd39a5204150d27 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 10:47:42 -0700 Subject: [PATCH 128/272] docs: track superpowers implementation plans --- .../2026-03-31-global-analysis-foundations.md | 688 ++++++++++++++++ ...2026-03-31-region-contrasts-foundations.md | 763 ++++++++++++++++++ ...2026-03-31-region-discovery-foundations.md | 199 +++++ ...4-01-cluster-occupancy-region-contrasts.md | 296 +++++++ ...-01-discovery-cluster-contrast-workflow.md | 351 ++++++++ .../2026-04-01-paired-region-discovery.md | 588 ++++++++++++++ .../2026-04-01-plotting-axis-architecture.md | 749 +++++++++++++++++ .../2026-04-01-region-contrasts-plotting.md | 576 +++++++++++++ ...04-01-region-discovery-cluster-workflow.md | 270 +++++++ .../2026-04-02-superpowers-docs-cleanup.md | 236 ++++++ 10 files changed, 4716 insertions(+) create mode 100644 docs/superpowers/plans/2026-03-31-global-analysis-foundations.md create mode 100644 docs/superpowers/plans/2026-03-31-region-contrasts-foundations.md create mode 100644 docs/superpowers/plans/2026-03-31-region-discovery-foundations.md create mode 100644 docs/superpowers/plans/2026-04-01-cluster-occupancy-region-contrasts.md create mode 100644 docs/superpowers/plans/2026-04-01-discovery-cluster-contrast-workflow.md create mode 100644 docs/superpowers/plans/2026-04-01-paired-region-discovery.md create mode 100644 docs/superpowers/plans/2026-04-01-plotting-axis-architecture.md create mode 100644 docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md create mode 100644 docs/superpowers/plans/2026-04-01-region-discovery-cluster-workflow.md create mode 100644 docs/superpowers/plans/2026-04-02-superpowers-docs-cleanup.md diff --git a/docs/superpowers/plans/2026-03-31-global-analysis-foundations.md b/docs/superpowers/plans/2026-03-31-global-analysis-foundations.md new file mode 100644 index 0000000..3f1fffd --- /dev/null +++ b/docs/superpowers/plans/2026-03-31-global-analysis-foundations.md @@ -0,0 +1,688 @@ +# Global Analysis Foundations Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Add a first `global_analysis` layer that produces pileup-backed global summaries, window-level summaries, and reusable normalization factors without changing the current parsing architecture. + +**Architecture:** Build `dimelo.global_analysis` directly on top of `parse_bam.pileup()` outputs and existing `load_processed` pileup parsing helpers. Keep the v1 scope narrow: one result type, one global-summary path, one tiled-window path, and one normalization workflow that later modules can consume. + +**Tech Stack:** Python 3.11, pandas, numpy, pysam, pytest + +--- + +## File Map + +- `dimelo/models.py` + Add `GlobalAnalysisResult` as the canonical data-first output contract. +- `dimelo/global_analysis.py` + New module for whole-pileup summaries, genome tiling, window summaries, and normalization-factor computation. +- `dimelo/__init__.py` + Export `global_analysis` once the module exists. +- `tests/test_models.py` + Add model-level validation for `GlobalAnalysisResult`. +- `tests/test_global_analysis.py` + Add focused tests for summary, tiling, window aggregation, and normalization behavior. +- `docs/global-analysis.md` + Add the user-facing guide for broad summaries and preprocessing handoff. +- `README.md` + Link the new guide from the analysis section. + +Scope note: + +- This plan intentionally covers `global_analysis` foundations only. +- It does not implement `region_discovery`. +- It does not change `parse_bam.pileup()` or `load_processed.pileup_counts_from_bedmethyl()` semantics. +- It keeps plotting data-first and renderer-thin. + +### Task 1: Add Global Analysis Result Model + +**Files:** +- Modify: `dimelo/models.py` +- Modify: `tests/test_models.py` + +- [ ] **Step 1: Write the failing tests** + +```python +# tests/test_models.py +from dimelo.models import GlobalAnalysisResult + + +def test_global_analysis_result_supports_summary_windows_and_normalization(): + result = GlobalAnalysisResult( + summary=pd.DataFrame({"sample_id": ["s1"]}), + windows=pd.DataFrame({"window_id": ["chr1:0-1000"]}), + normalization_factors=pd.DataFrame({"sample_id": ["s1"], "global_offset": [0.1]}), + plot_data={"global_fraction_bar": pd.DataFrame({"sample_id": ["s1"]})}, + metadata={"normalization_mode": "per_sample_global"}, + figures={}, + ) + + assert list(result.summary["sample_id"]) == ["s1"] + assert list(result.windows["window_id"]) == ["chr1:0-1000"] + assert list(result.normalization_factors["sample_id"]) == ["s1"] + + +def test_global_analysis_result_rejects_none_core_outputs(): + with pytest.raises(ValueError, match="summary, normalization_factors, plot_data"): + GlobalAnalysisResult( + summary=None, + windows=None, + normalization_factors=None, + plot_data=None, + metadata={}, + figures={}, + ) +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `pytest tests/test_models.py::test_global_analysis_result_supports_summary_windows_and_normalization tests/test_models.py::test_global_analysis_result_rejects_none_core_outputs -q` +Expected: FAIL with `ImportError` or `AttributeError` because `GlobalAnalysisResult` does not exist yet + +- [ ] **Step 3: Write minimal implementation** + +```python +# dimelo/models.py +@dataclass +class GlobalAnalysisResult: + summary: pd.DataFrame + windows: pd.DataFrame | None + normalization_factors: pd.DataFrame + plot_data: dict[str, pd.DataFrame | dict[str, Any]] + metadata: dict[str, Any] = field(default_factory=dict) + figures: dict[str, Any] = field(default_factory=dict) + + def __post_init__(self) -> None: + required_fields = { + "summary": self.summary, + "normalization_factors": self.normalization_factors, + "plot_data": self.plot_data, + } + missing = [name for name, value in required_fields.items() if value is None] + if missing: + raise ValueError( + "GlobalAnalysisResult requires non-None values for: " + f"{', '.join(missing)}" + ) +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `pytest tests/test_models.py::test_global_analysis_result_supports_summary_windows_and_normalization tests/test_models.py::test_global_analysis_result_rejects_none_core_outputs -q` +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add dimelo/models.py tests/test_models.py +git commit -m "feat: add global analysis result model" +``` + +### Task 2: Add Whole-Pileup Global Summary Functions + +**Files:** +- Create: `dimelo/global_analysis.py` +- Modify: `dimelo/__init__.py` +- Create: `tests/test_global_analysis.py` + +- [ ] **Step 1: Write the failing tests** + +```python +# tests/test_global_analysis.py +import pandas as pd + +from dimelo import global_analysis +from dimelo.models import SampleSpec + + +def test_summarize_global_samples_from_pileup(monkeypatch): + samples = [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + metadata={"pileup_path": "s1.bed.gz"}, + ), + SampleSpec( + sample_id="s2", + condition="15min", + extract_h5="s2.h5", + metadata={"pileup_path": "s2.bed.gz"}, + ), + ] + + counts = { + ("s1.bed.gz", "A,0"): (10, 100), + ("s1.bed.gz", "CG,0"): (20, 200), + ("s2.bed.gz", "A,0"): (30, 100), + ("s2.bed.gz", "CG,0"): (40, 200), + } + + monkeypatch.setattr( + global_analysis, + "_global_counts_from_bedmethyl", + lambda bedmethyl_file, motif, quiet=True: counts[(bedmethyl_file, motif)], + ) + + summary = global_analysis.summarize_global_samples( + samples=samples, + motifs=["A,0", "CG,0"], + ) + + assert set(summary.columns) >= { + "sample_id", + "condition", + "motif", + "modified_count", + "valid_count", + "global_fraction", + } + assert summary.loc[(summary["sample_id"] == "s2") & (summary["motif"] == "A,0"), "global_fraction"].iloc[0] == 0.3 + + +def test_summarize_global_samples_requires_pileup_path(): + with pytest.raises(ValueError, match="pileup_path"): + global_analysis.summarize_global_samples( + samples=[SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5")], + motifs=["A,0"], + ) +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `pytest tests/test_global_analysis.py::test_summarize_global_samples_from_pileup tests/test_global_analysis.py::test_summarize_global_samples_requires_pileup_path -q` +Expected: FAIL with `ModuleNotFoundError: No module named 'dimelo.global_analysis'` + +- [ ] **Step 3: Write minimal implementation** + +```python +# dimelo/global_analysis.py +from __future__ import annotations + +from pathlib import Path +from typing import Iterable + +import pandas as pd +import pysam + +from . import load_processed, utils + + +def _global_counts_from_bedmethyl( + bedmethyl_file: str | Path, + motif: str, + quiet: bool = True, +) -> tuple[int, int]: + parsed_motif = utils.ParsedMotif(motif) + tabix = pysam.TabixFile(str(bedmethyl_file)) + + modified_count = 0 + valid_count = 0 + for contig in tabix.contigs: + for row in tabix.fetch(contig): + keep_basemod, _, modified_in_row, valid_in_row = load_processed.process_pileup_row( + row, + parsed_motif, + ".", + False, + ) + if keep_basemod: + modified_count += modified_in_row + valid_count += valid_in_row + return modified_count, valid_count + + +def summarize_global_samples( + *, + samples, + motifs: Iterable[str], + quiet: bool = True, +) -> pd.DataFrame: + rows = [] + for sample in samples: + metadata = sample.metadata or {} + if "pileup_path" not in metadata: + raise ValueError( + f"Sample {sample.sample_id} is missing metadata['pileup_path']." + ) + for motif in motifs: + modified_count, valid_count = _global_counts_from_bedmethyl( + metadata["pileup_path"], + motif, + quiet=quiet, + ) + global_fraction = 0.0 if valid_count == 0 else modified_count / valid_count + rows.append( + { + "sample_id": sample.sample_id, + "condition": sample.condition, + "replicate": sample.replicate, + "motif": motif, + "modified_count": modified_count, + "valid_count": valid_count, + "global_fraction": global_fraction, + } + ) + return pd.DataFrame(rows) +``` + +```python +# dimelo/__init__.py +from . import global_analysis + +__all__.append("global_analysis") +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `pytest tests/test_global_analysis.py::test_summarize_global_samples_from_pileup tests/test_global_analysis.py::test_summarize_global_samples_requires_pileup_path -q` +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add dimelo/global_analysis.py dimelo/__init__.py tests/test_global_analysis.py +git commit -m "feat: add global pileup summary workflow" +``` + +### Task 3: Add Window Summaries And Normalization Factors + +**Files:** +- Modify: `dimelo/global_analysis.py` +- Modify: `tests/test_global_analysis.py` + +- [ ] **Step 1: Write the failing tests** + +```python +# tests/test_global_analysis.py +def test_tile_windows_from_genome_sizes_dict(): + windows = global_analysis.tile_genome_windows( + genome_sizes={"chr1": 2500}, + window_size=1000, + step_size=500, + ) + + assert windows["window_id"].tolist() == [ + "chr1:0-1000", + "chr1:500-1500", + "chr1:1000-2000", + "chr1:1500-2500", + ] + + +def test_build_window_summary_from_regions_to_list(monkeypatch): + samples = [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + metadata={"pileup_path": "s1.bed.gz"}, + ), + ] + windows = pd.DataFrame( + { + "window_id": ["chr1:0-1000", "chr1:500-1500"], + "chromosome": ["chr1", "chr1"], + "start": [0, 500], + "end": [1000, 1500], + "strand": [".", "."], + } + ) + + monkeypatch.setattr( + global_analysis, + "tile_genome_windows", + lambda genome_sizes, window_size, step_size, include_contigs=None, exclude_contigs=None: windows, + ) + monkeypatch.setattr( + global_analysis.load_processed, + "regions_to_list", + lambda function_handle, regions, window_size, quiet, cores, split_large_regions=False: [(5, 10), (1, 10)], + ) + + summary = global_analysis.build_window_summary( + samples=samples, + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + window_size=1000, + step_size=500, + ) + + assert summary["window_fraction"].tolist() == [0.5, 0.1] + + +def test_compute_global_normalization_factors_from_summary(): + summary = pd.DataFrame( + { + "sample_id": ["s1", "s2"], + "condition": ["NS", "15min"], + "replicate": [None, None], + "motif": ["A,0", "A,0"], + "modified_count": [10, 30], + "valid_count": [100, 100], + "global_fraction": [0.1, 0.3], + } + ) + + factors = global_analysis.compute_global_normalization_factors(summary) + + assert set(factors.columns) >= { + "sample_id", + "motif", + "global_fraction", + "reference_fraction", + "global_offset", + } + assert factors.loc[factors["sample_id"] == "s1", "global_offset"].iloc[0] == pytest.approx(-0.1) + assert factors.loc[factors["sample_id"] == "s2", "global_offset"].iloc[0] == pytest.approx(0.1) +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `pytest tests/test_global_analysis.py::test_tile_windows_from_genome_sizes_dict tests/test_global_analysis.py::test_build_window_summary_from_regions_to_list tests/test_global_analysis.py::test_compute_global_normalization_factors_from_summary -q` +Expected: FAIL because the functions do not exist yet + +- [ ] **Step 3: Write minimal implementation** + +```python +# dimelo/global_analysis.py +from functools import partial + +import numpy as np + + +def tile_genome_windows( + *, + genome_sizes: dict[str, int], + window_size: int, + step_size: int, + include_contigs: Iterable[str] | None = None, + exclude_contigs: Iterable[str] | None = None, +) -> pd.DataFrame: + if window_size <= 0 or step_size <= 0: + raise ValueError("window_size and step_size must be positive.") + + include = set(include_contigs or genome_sizes.keys()) + exclude = set(exclude_contigs or []) + rows = [] + for chromosome, contig_length in genome_sizes.items(): + if chromosome not in include or chromosome in exclude: + continue + start = 0 + while start < contig_length: + end = min(start + window_size, contig_length) + rows.append( + { + "window_id": f"{chromosome}:{start}-{end}", + "chromosome": chromosome, + "start": start, + "end": end, + "strand": ".", + } + ) + if end == contig_length: + break + start += step_size + return pd.DataFrame(rows) + + +def build_window_summary( + *, + samples, + motifs: Iterable[str], + genome_sizes: dict[str, int], + window_size: int, + step_size: int, + include_contigs: Iterable[str] | None = None, + exclude_contigs: Iterable[str] | None = None, + quiet: bool = True, + cores: int | None = None, +) -> pd.DataFrame: + motifs = list(motifs) + if len(motifs) != 1: + raise ValueError("build_window_summary currently supports exactly one motif.") + + motif = motifs[0] + windows = tile_genome_windows( + genome_sizes=genome_sizes, + window_size=window_size, + step_size=step_size, + include_contigs=include_contigs, + exclude_contigs=exclude_contigs, + ) + region_strings = [ + f"{row.chromosome}:{row.start}-{row.end},{row.strand}" + for row in windows.itertuples(index=False) + ] + + rows = [] + for sample in samples: + metadata = sample.metadata or {} + if "pileup_path" not in metadata: + raise ValueError( + f"Sample {sample.sample_id} is missing metadata['pileup_path']." + ) + pileup_loader = partial( + load_processed.pileup_counts_from_bedmethyl, + bedmethyl_file=metadata["pileup_path"], + motif=motif, + ) + counts_by_window = load_processed.regions_to_list( + function_handle=pileup_loader, + regions=region_strings, + window_size=None, + quiet=quiet, + cores=cores, + ) + for window_row, (modified_count, valid_count) in zip( + windows.itertuples(index=False), + counts_by_window, + ): + window_fraction = 0.0 if valid_count == 0 else modified_count / valid_count + rows.append( + { + "sample_id": sample.sample_id, + "condition": sample.condition, + "replicate": sample.replicate, + "motif": motif, + "window_id": window_row.window_id, + "chromosome": window_row.chromosome, + "start": window_row.start, + "end": window_row.end, + "modified_count": modified_count, + "valid_count": valid_count, + "window_fraction": window_fraction, + } + ) + return pd.DataFrame(rows) + + +def compute_global_normalization_factors(summary: pd.DataFrame) -> pd.DataFrame: + grouped_reference = ( + summary.groupby("motif", sort=True)["global_fraction"] + .mean() + .rename("reference_fraction") + .reset_index() + ) + merged = summary.merge(grouped_reference, on="motif", how="left") + merged["global_offset"] = merged["global_fraction"] - merged["reference_fraction"] + return merged.loc[ + :, + ["sample_id", "condition", "replicate", "motif", "global_fraction", "reference_fraction", "global_offset"], + ].copy() +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `pytest tests/test_global_analysis.py::test_tile_windows_from_genome_sizes_dict tests/test_global_analysis.py::test_build_window_summary_from_regions_to_list tests/test_global_analysis.py::test_compute_global_normalization_factors_from_summary -q` +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add dimelo/global_analysis.py tests/test_global_analysis.py +git commit -m "feat: add global window summaries and normalization" +``` + +### Task 4: Add Global Analysis Result Builder And Docs + +**Files:** +- Modify: `dimelo/global_analysis.py` +- Modify: `tests/test_global_analysis.py` +- Create: `docs/global-analysis.md` +- Modify: `README.md` + +- [ ] **Step 1: Write the failing test** + +```python +# tests/test_global_analysis.py +def test_run_global_analysis_returns_result(monkeypatch): + samples = [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + metadata={"pileup_path": "s1.bed.gz"}, + ), + ] + + monkeypatch.setattr( + global_analysis, + "summarize_global_samples", + lambda samples, motifs, quiet=True: pd.DataFrame( + { + "sample_id": ["s1"], + "condition": ["NS"], + "replicate": [None], + "motif": ["A,0"], + "modified_count": [10], + "valid_count": [100], + "global_fraction": [0.1], + } + ), + ) + monkeypatch.setattr( + global_analysis, + "build_window_summary", + lambda **kwargs: pd.DataFrame({"window_id": ["chr1:0-1000"]}), + ) + + result = global_analysis.run_global_analysis( + samples=samples, + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=1000, + step_size=1000, + ) + + assert list(result.summary["sample_id"]) == ["s1"] + assert list(result.windows["window_id"]) == ["chr1:0-1000"] + assert "global_fraction_bar" in result.plot_data +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `pytest tests/test_global_analysis.py::test_run_global_analysis_returns_result -q` +Expected: FAIL with `AttributeError` because `run_global_analysis` does not exist yet + +- [ ] **Step 3: Write minimal implementation and docs** + +```python +# dimelo/global_analysis.py +from .models import GlobalAnalysisResult + + +def run_global_analysis( + *, + samples, + motifs: Iterable[str], + genome_sizes: dict[str, int], + window_size: int, + step_size: int, + include_contigs: Iterable[str] | None = None, + exclude_contigs: Iterable[str] | None = None, + quiet: bool = True, + cores: int | None = None, +) -> GlobalAnalysisResult: + summary = summarize_global_samples(samples=samples, motifs=motifs, quiet=quiet) + windows = build_window_summary( + samples=samples, + motifs=motifs, + genome_sizes=genome_sizes, + window_size=window_size, + step_size=step_size, + include_contigs=include_contigs, + exclude_contigs=exclude_contigs, + quiet=quiet, + cores=cores, + ) + normalization_factors = compute_global_normalization_factors(summary) + plot_data = { + "global_fraction_bar": summary.loc[ + :, + ["sample_id", "condition", "motif", "global_fraction"], + ].copy(), + "window_fraction_table": windows.copy(), + } + return GlobalAnalysisResult( + summary=summary, + windows=windows, + normalization_factors=normalization_factors, + plot_data=plot_data, + metadata={ + "normalization_mode": "per_sample_global", + "window_size": window_size, + "step_size": step_size, + "motifs": list(motifs), + }, + figures={}, + ) +``` + +```markdown +# Global Analysis + +`dimelo.global_analysis` provides broad pileup-backed summaries on top of `parse_bam.pileup()` outputs. + +## What It Covers + +- whole-pileup motif abundance summaries +- tiled window summaries across broad genomic space +- reusable per-sample global normalization offsets + +## Example + +```python +from dimelo import global_analysis +from dimelo.models import SampleSpec + +result = global_analysis.run_global_analysis( + samples=[ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="output/s1.extract.h5", + metadata={"pileup_path": "output/s1.pileup.sorted.bed.gz"}, + ) + ], + motifs=["A,0"], + genome_sizes={"chr1": 248956422}, + window_size=100000, + step_size=50000, +) +``` + +The canonical outputs are `result.summary`, `result.windows`, and `result.normalization_factors`. +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `pytest tests/test_global_analysis.py -q` +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add dimelo/global_analysis.py tests/test_global_analysis.py docs/global-analysis.md README.md +git commit -m "docs: add global analysis workflow guide" +``` diff --git a/docs/superpowers/plans/2026-03-31-region-contrasts-foundations.md b/docs/superpowers/plans/2026-03-31-region-contrasts-foundations.md new file mode 100644 index 0000000..ae9f163 --- /dev/null +++ b/docs/superpowers/plans/2026-03-31-region-contrasts-foundations.md @@ -0,0 +1,763 @@ +# Region Contrasts Foundations Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Add a stable, backward-compatible `region_contrasts` layer for known-region comparisons over pileup-backed counts, including explicit contrast models, effect-size summaries, and a first beta-binomial testing path. + +**Architecture:** Build `dimelo.region_contrasts` on top of the existing `parse_bam.pileup()` and `load_processed.pileup_counts_from_bedmethyl()` flow without changing parsing semantics. Keep the v1 scope intentionally narrow: fully support only `analysis_unit="ensemble_region"` + `signal_source="pileup_counts"` with `effect_size_only` and `beta_binomial`, while validating and rejecting unsupported combinations explicitly. + +**Tech Stack:** Python 3.11, pandas, numpy, scipy, pytest + +--- + +Scope note: + +- This plan intentionally covers the first executable `region_contrasts` slice only. +- It does not implement `region_discovery`, single-read contrasts, cluster-occupancy contrasts, or time-course inference. +- It preserves continuity by consuming existing pileup outputs rather than altering `parse_bam` or `load_processed` semantics. + +### Task 1: Add Contrast Models And Result Types + +**Files:** +- Modify: `dimelo/models.py` +- Modify: `tests/test_models.py` + +- [ ] **Step 1: Write the failing tests** + +```python +# tests/test_models.py +from dimelo.models import ContrastSpec, RegionContrastResult + + +def test_contrast_spec_accepts_pairwise_mode(): + contrast = ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + reference_condition="NS", + ) + assert contrast.mode == "pairwise" + assert contrast.numerator == ["15min"] + + +def test_contrast_spec_rejects_missing_groups_for_pairwise(): + try: + ContrastSpec(mode="pairwise") + except ValueError as exc: + assert "numerator" in str(exc) + else: + raise AssertionError("Expected ContrastSpec to validate pairwise groups") + + +def test_region_contrast_result_requires_regions_and_summary(): + contrast = ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + reference_condition="NS", + ) + try: + RegionContrastResult( + regions=None, + summary=None, + contrast=contrast, + plot_data={}, + metadata={}, + figures={}, + ) + except ValueError as exc: + assert "regions" in str(exc) + assert "summary" in str(exc) + else: + raise AssertionError("Expected RegionContrastResult to require core tables") +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `pytest tests/test_models.py -q` +Expected: FAIL with `ImportError` or `AttributeError` for missing `ContrastSpec` / `RegionContrastResult` + +- [ ] **Step 3: Write minimal implementation** + +```python +# dimelo/models.py +from dataclasses import dataclass, field +from typing import Any + + +@dataclass +class ContrastSpec: + mode: str + numerator: list[str] | None = None + denominator: list[str] | None = None + background: list[str] | None = None + time_order: list[str] | None = None + pairing_key: str | None = None + reference_condition: str | None = None + metadata: dict[str, Any] | None = None + + def __post_init__(self) -> None: + if self.mode not in { + "single_dataset", + "pairwise", + "matched_pairwise", + "group_vs_group", + "background_adjusted", + "time_course", + }: + raise ValueError(f"Unsupported contrast mode: {self.mode}") + if self.mode in {"pairwise", "group_vs_group"}: + if not self.numerator or not self.denominator: + raise ValueError( + "ContrastSpec pairwise/group_vs_group modes require numerator and denominator." + ) + if self.mode == "time_course" and not self.time_order: + raise ValueError("ContrastSpec time_course mode requires time_order.") + + +@dataclass +class RegionContrastResult: + regions: pd.DataFrame + summary: pd.DataFrame + contrast: ContrastSpec + plot_data: dict[str, pd.DataFrame | dict[str, Any]] + metadata: dict[str, Any] = field(default_factory=dict) + figures: dict[str, Any] = field(default_factory=dict) + + def __post_init__(self) -> None: + required_fields = { + "regions": self.regions, + "summary": self.summary, + "plot_data": self.plot_data, + } + missing = [name for name, value in required_fields.items() if value is None] + if missing: + raise ValueError( + "RegionContrastResult requires non-None values for: " + f"{', '.join(missing)}" + ) +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `pytest tests/test_models.py -q` +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add dimelo/models.py tests/test_models.py +git commit -m "feat: add region contrast models" +``` + +### Task 2: Add Region Contrast Validation And Evidence Table Construction + +**Files:** +- Create: `dimelo/region_contrasts.py` +- Create: `tests/test_region_contrasts.py` +- Modify: `dimelo/__init__.py` + +- [ ] **Step 1: Write the failing tests** + +```python +# tests/test_region_contrasts.py +import pandas as pd +import pytest + +from dimelo.models import ContrastSpec, SampleSpec +from dimelo import region_contrasts + + +def test_validate_supported_v1_combination(): + region_contrasts.validate_region_contrast_request( + analysis_unit="ensemble_region", + representation="modified_fraction", + signal_source="pileup_counts", + test="beta_binomial", + ) + + +def test_validate_rejects_unsupported_single_read_beta_binomial(): + with pytest.raises(ValueError, match="ensemble_region"): + region_contrasts.validate_region_contrast_request( + analysis_unit="single_read", + representation="read_mod_fraction", + signal_source="pileup_counts", + test="beta_binomial", + ) + + +def test_build_region_evidence_table_from_pileup_counts(monkeypatch): + fake_samples = [ + SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5", metadata={"pileup_path": "s1.bed.gz"}), + SampleSpec(sample_id="s2", condition="15min", extract_h5="s2.h5", metadata={"pileup_path": "s2.bed.gz"}), + ] + + monkeypatch.setattr( + region_contrasts.utils, + "regions_dict_from_input", + lambda regions, window_size=None: {"chr1": [(0, 10, "+")], "chr2": [(20, 30, "-")]}, + ) + counts_by_file = { + "s1.bed.gz": [(2, 10), (6, 10)], + "s2.bed.gz": [(7, 10), (8, 10)], + } + monkeypatch.setattr( + region_contrasts.load_processed, + "regions_to_list", + lambda function_handle, regions, window_size, quiet, cores, split_large_regions=False: counts_by_file[function_handle.keywords["bedmethyl_file"]], + ) + + evidence = region_contrasts.build_region_evidence_table( + samples=fake_samples, + regions="matched.bed", + motifs=["A,0"], + ) + + assert list(evidence.columns[:7]) == [ + "region_id", + "chromosome", + "start", + "end", + "strand", + "sample_id", + "condition", + ] + assert set(evidence["modified_count"]) == {2, 6, 7, 8} + assert set(evidence["valid_count"]) == {10} + assert "mod_fraction" in evidence.columns +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `pytest tests/test_region_contrasts.py -q` +Expected: FAIL with `ModuleNotFoundError: No module named 'dimelo.region_contrasts'` + +- [ ] **Step 3: Write minimal implementation** + +```python +# dimelo/region_contrasts.py +from __future__ import annotations + +from functools import partial + +import pandas as pd + +from . import load_processed, utils + + +def validate_region_contrast_request( + *, + analysis_unit: str, + representation: str, + signal_source: str, + test: str, +) -> None: + if analysis_unit != "ensemble_region": + raise ValueError("V1 inferential region_contrasts requires analysis_unit='ensemble_region'.") + if signal_source != "pileup_counts": + raise ValueError("V1 inferential region_contrasts requires signal_source='pileup_counts'.") + if representation not in {"modified_fraction", "modified_count"}: + raise ValueError("V1 inferential region_contrasts requires modified_fraction or modified_count.") + if test not in {"beta_binomial", "effect_size_only"}: + raise ValueError("Unsupported region contrast test.") + + +def build_region_evidence_table( + *, + samples, + regions, + motifs, + window_size=None, + quiet: bool = True, + cores=None, +): + if len(motifs) != 1: + raise ValueError("build_region_evidence_table currently supports exactly one motif.") + motif = motifs[0] + regions_dict = utils.regions_dict_from_input(regions, window_size) + region_metadata = [ + (chromosome, start, end, strand) + for chromosome, region_list in regions_dict.items() + for start, end, strand in region_list + ] + rows = [] + for sample in samples: + if not sample.metadata or "pileup_path" not in sample.metadata: + raise ValueError(f"Sample {sample.sample_id!r} is missing metadata['pileup_path'].") + loader = partial( + load_processed.pileup_counts_from_bedmethyl, + bedmethyl_file=sample.metadata["pileup_path"], + motif=motif, + window_size=window_size, + quiet=quiet, + cores=cores, + ) + per_region_counts = load_processed.regions_to_list( + function_handle=loader, + regions=regions, + window_size=window_size, + quiet=quiet, + cores=cores, + split_large_regions=False, + ) + for (chrom, start, end, strand), (modified_count, valid_count) in zip( + region_metadata, per_region_counts + ): + mod_fraction = 0.0 if valid_count == 0 else modified_count / valid_count + rows.append( + { + "region_id": f"{chrom}:{start}-{end}:{strand}", + "chromosome": chrom, + "start": start, + "end": end, + "strand": strand, + "sample_id": sample.sample_id, + "condition": sample.condition, + "replicate": sample.replicate, + "modified_count": int(modified_count), + "valid_count": int(valid_count), + "mod_fraction": float(mod_fraction), + } + ) + return pd.DataFrame(rows) +``` + +```python +# dimelo/__init__.py +from . import ( + cluster, + distribution, + export, + load_processed, + models, + parse_bam, + plotting, + plot_depth_histogram, + plot_depth_profile, + plot_enrichment, + plot_enrichment_profile, + plot_read_browser, + plot_reads, + region_analysis, + region_contrasts, + workflows, +) + +__all__ = [ + "cluster", + "distribution", + "export", + "load_processed", + "models", + "parse_bam", + "plotting", + "plot_depth_histogram", + "plot_depth_profile", + "plot_enrichment", + "plot_enrichment_profile", + "plot_read_browser", + "plot_reads", + "region_analysis", + "region_contrasts", + "workflows", +] +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `pytest tests/test_region_contrasts.py -q` +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add dimelo/region_contrasts.py dimelo/__init__.py tests/test_region_contrasts.py +git commit -m "feat: add region contrast evidence builders" +``` + +### Task 3: Add Effect-Size Region Scoring Workflow + +**Files:** +- Modify: `dimelo/region_contrasts.py` +- Modify: `tests/test_region_contrasts.py` + +- [ ] **Step 1: Write the failing tests** + +```python +# tests/test_region_contrasts.py +from dimelo.models import ContrastSpec + + +def test_score_regions_effect_size_pairwise(monkeypatch): + evidence = pd.DataFrame( + { + "region_id": ["reg1", "reg1", "reg2", "reg2"], + "chromosome": ["chr1", "chr1", "chr2", "chr2"], + "start": [0, 0, 20, 20], + "end": [10, 10, 30, 30], + "strand": ["+", "+", "-", "-"], + "sample_id": ["s1", "s2", "s1", "s2"], + "condition": ["NS", "15min", "NS", "15min"], + "replicate": [1, 1, 1, 1], + "modified_count": [2, 8, 6, 6], + "valid_count": [10, 10, 10, 10], + "mod_fraction": [0.2, 0.8, 0.6, 0.6], + } + ) + monkeypatch.setattr(region_contrasts, "build_region_evidence_table", lambda **kwargs: evidence) + + result = region_contrasts.score_regions( + samples=[], + regions="matched.bed", + motifs=["A,0"], + contrast=ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + reference_condition="NS", + ), + analysis_unit="ensemble_region", + representation="modified_fraction", + signal_source="pileup_counts", + test="effect_size_only", + ) + + assert set(result.regions.columns) >= { + "region_id", + "fraction", + "reference_fraction", + "delta_fraction", + "log2_fc", + "rank", + } + top = result.regions.sort_values("rank").iloc[0] + assert top["region_id"] == "reg1" + assert top["delta_fraction"] > 0 +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `pytest tests/test_region_contrasts.py::test_score_regions_effect_size_pairwise -q` +Expected: FAIL with `AttributeError` for missing `score_regions` + +- [ ] **Step 3: Write minimal implementation** + +```python +# dimelo/region_contrasts.py +from .models import ContrastSpec, RegionContrastResult + + +def _pool_region_groups(evidence: pd.DataFrame, contrast: ContrastSpec) -> pd.DataFrame: + if contrast.mode not in {"pairwise", "group_vs_group"}: + raise NotImplementedError( + "V1 effect-size region_contrasts supports pairwise and group_vs_group only." + ) + condition_groups = { + "numerator": set(contrast.numerator or []), + "denominator": set(contrast.denominator or []), + } + pooled_rows = [] + for label, conditions in condition_groups.items(): + subset = evidence[evidence["condition"].isin(conditions)].copy() + grouped = ( + subset.groupby(["region_id", "chromosome", "start", "end", "strand"], sort=True) + .agg( + modified_count=("modified_count", "sum"), + valid_count=("valid_count", "sum"), + replicate_n=("sample_id", "nunique"), + ) + .reset_index() + ) + grouped["group"] = label + grouped["fraction"] = grouped["modified_count"] / grouped["valid_count"].where( + grouped["valid_count"] > 0, + 1, + ) + pooled_rows.append(grouped) + return pd.concat(pooled_rows, ignore_index=True) + + +def score_regions( + *, + samples, + regions, + motifs, + contrast: ContrastSpec, + analysis_unit: str = "ensemble_region", + representation: str = "modified_fraction", + signal_source: str = "pileup_counts", + test: str = "beta_binomial", + multiple_testing: str = "fdr_bh", +): + validate_region_contrast_request( + analysis_unit=analysis_unit, + representation=representation, + signal_source=signal_source, + test=test, + ) + evidence = build_region_evidence_table(samples=samples, regions=regions, motifs=motifs) + pooled = _pool_region_groups(evidence, contrast) + numerator = pooled[pooled["group"] == "numerator"].rename( + columns={ + "modified_count": "modified_count", + "valid_count": "valid_count", + "fraction": "fraction", + "replicate_n": "replicate_n", + } + ) + denominator = pooled[pooled["group"] == "denominator"].rename( + columns={ + "modified_count": "reference_modified_count", + "valid_count": "reference_valid_count", + "fraction": "reference_fraction", + "replicate_n": "reference_replicate_n", + } + ) + merged = numerator.merge( + denominator, + on=["region_id", "chromosome", "start", "end", "strand"], + how="left", + ) + merged["delta_fraction"] = merged["fraction"] - merged["reference_fraction"] + merged["log2_fc"] = np.log2( + (merged["fraction"] + 1e-6) / (merged["reference_fraction"] + 1e-6) + ) + merged["rank"] = ( + merged["delta_fraction"].abs().rank(method="first", ascending=False).astype(int) + ) + summary = merged.loc[:, ["region_id", "fraction", "reference_fraction", "delta_fraction", "log2_fc", "rank"]] + return RegionContrastResult( + regions=merged.sort_values("rank", kind="stable").reset_index(drop=True), + summary=summary.sort_values("rank", kind="stable").reset_index(drop=True), + contrast=contrast, + plot_data={"region_effect_sizes": summary.copy()}, + metadata={ + "contrast_mode": contrast.mode, + "analysis_unit": analysis_unit, + "representation": representation, + "signal_source": signal_source, + "test": test, + "normalization_mode": "none", + "biological_interpretation": "Region-level motif abundance contrast.", + "renderer": None, + }, + figures={}, + ) +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `pytest tests/test_region_contrasts.py::test_score_regions_effect_size_pairwise -q` +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add dimelo/region_contrasts.py tests/test_region_contrasts.py +git commit -m "feat: add effect-size region contrast workflow" +``` + +### Task 4: Add Beta-Binomial Testing For Pooled Region Counts + +**Files:** +- Modify: `dimelo/region_contrasts.py` +- Modify: `tests/test_region_contrasts.py` + +- [ ] **Step 1: Write the failing tests** + +```python +# tests/test_region_contrasts.py + +def test_score_regions_beta_binomial_adds_pvalues(monkeypatch): + evidence = pd.DataFrame( + { + "region_id": ["reg1", "reg1", "reg2", "reg2"], + "chromosome": ["chr1", "chr1", "chr2", "chr2"], + "start": [0, 0, 20, 20], + "end": [10, 10, 30, 30], + "strand": ["+", "+", "-", "-"], + "sample_id": ["s1", "s2", "s1", "s2"], + "condition": ["NS", "15min", "NS", "15min"], + "replicate": [1, 1, 1, 1], + "modified_count": [1, 9, 5, 6], + "valid_count": [10, 10, 10, 10], + "mod_fraction": [0.1, 0.9, 0.5, 0.6], + } + ) + monkeypatch.setattr(region_contrasts, "build_region_evidence_table", lambda **kwargs: evidence) + + result = region_contrasts.score_regions( + samples=[], + regions="matched.bed", + motifs=["A,0"], + contrast=ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + reference_condition="NS", + ), + analysis_unit="ensemble_region", + representation="modified_fraction", + signal_source="pileup_counts", + test="beta_binomial", + ) + + assert "p_value" in result.regions.columns + assert "adjusted_p_value" in result.regions.columns + assert result.regions["p_value"].between(0, 1).all() +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `pytest tests/test_region_contrasts.py::test_score_regions_beta_binomial_adds_pvalues -q` +Expected: FAIL because p-value columns do not exist + +- [ ] **Step 3: Write minimal implementation** + +```python +# dimelo/region_contrasts.py +from scipy.stats import betabinom + + +def _estimate_beta_binomial_prior(reference_modified: pd.Series, reference_valid: pd.Series) -> tuple[float, float]: + fractions = np.divide( + reference_modified, + reference_valid, + out=np.zeros_like(reference_modified, dtype=float), + where=reference_valid > 0, + ) + mean = float(fractions.mean()) + var = float(fractions.var(ddof=0)) + if var <= 0: + concentration = 100.0 + else: + max_var = max(mean * (1.0 - mean), 1e-9) + shrink = min(max(var / max_var, 1e-6), 0.99) + concentration = max((1.0 / shrink) - 1.0, 1.0) + alpha = max(mean * concentration, 1e-6) + beta = max((1.0 - mean) * concentration, 1e-6) + return alpha, beta + + +def _adjust_pvalues_bh(p_values: pd.Series) -> pd.Series: + order = np.argsort(p_values.to_numpy()) + ranked = p_values.to_numpy()[order] + n = len(ranked) + adjusted = np.empty(n, dtype=float) + running = 1.0 + for i in range(n - 1, -1, -1): + rank = i + 1 + running = min(running, ranked[i] * n / rank) + adjusted[i] = running + out = np.empty(n, dtype=float) + out[order] = adjusted + return pd.Series(out, index=p_values.index) + + +def _beta_binomial_pvalues(merged: pd.DataFrame) -> pd.Series: + alpha, beta = _estimate_beta_binomial_prior( + merged["reference_modified_count"], + merged["reference_valid_count"], + ) + pmf = betabinom.pmf(merged["modified_count"], merged["valid_count"], alpha, beta) + p_values = 1.0 - betabinom.cdf( + merged["modified_count"] - 1, + merged["valid_count"], + alpha, + beta, + ) + return pd.Series(np.clip(np.maximum(pmf, p_values), 0.0, 1.0), index=merged.index) +``` + +Add to `score_regions(...)`: + +```python + if test == "beta_binomial": + merged["p_value"] = _beta_binomial_pvalues(merged) + if multiple_testing != "fdr_bh": + raise ValueError("V1 beta-binomial region_contrasts supports multiple_testing='fdr_bh' only.") + merged["adjusted_p_value"] = _adjust_pvalues_bh(merged["p_value"]) + else: + merged["p_value"] = pd.NA + merged["adjusted_p_value"] = pd.NA +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `pytest tests/test_region_contrasts.py::test_score_regions_beta_binomial_adds_pvalues -q` +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add dimelo/region_contrasts.py tests/test_region_contrasts.py +git commit -m "feat: add beta-binomial region contrast scoring" +``` + +### Task 5: Add User-Facing Docs For Known-Region Contrasts + +**Files:** +- Create: `docs/region-contrasts.md` +- Modify: `README.md` + +- [ ] **Step 1: Write the docs content** + +```markdown +# Region Contrasts + +`dimelo.region_contrasts` scores known regions from pileup-backed inputs. + +## When To Use It + +- use this when you already know the regions you want to compare +- use `region_discovery` later for unknown loci +- use `cluster` first if you want read-state or cluster-occupancy summaries instead of average motif abundance + +## V1 Supported Path + +- `analysis_unit="ensemble_region"` +- `representation="modified_fraction"` or `"modified_count"` +- `signal_source="pileup_counts"` +- `test="effect_size_only"` or `"beta_binomial"` + +## Example + +```python +from dimelo import region_contrasts +from dimelo.models import ContrastSpec, SampleSpec + +result = region_contrasts.score_regions( + samples=[ + SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5", metadata={"pileup_path": "s1.bed.gz"}), + SampleSpec(sample_id="s2", condition="15min", extract_h5="s2.h5", metadata={"pileup_path": "s2.bed.gz"}), + ], + regions="matched_regions.bed", + motifs=["A,0"], + contrast=ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + reference_condition="NS", + ), + analysis_unit="ensemble_region", + representation="modified_fraction", + signal_source="pileup_counts", + test="beta_binomial", +) +``` + +The canonical outputs are `result.regions`, `result.summary`, and `result.plot_data`. +``` + +- [ ] **Step 2: Save the docs and link them from the README clustering/analysis section** + +Run: `sed -n '1,220p' docs/region-contrasts.md` +Expected: shows the new guide with the v1 support matrix and example + +- [ ] **Step 3: Commit** + +```bash +git add docs/region-contrasts.md README.md +git commit -m "docs: add region contrast workflow guide" +``` diff --git a/docs/superpowers/plans/2026-03-31-region-discovery-foundations.md b/docs/superpowers/plans/2026-03-31-region-discovery-foundations.md new file mode 100644 index 0000000..9a8abf4 --- /dev/null +++ b/docs/superpowers/plans/2026-03-31-region-discovery-foundations.md @@ -0,0 +1,199 @@ +# Region Discovery Foundations Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Add a first `region_discovery` layer for deterministic de novo locus finding from pileup-backed inputs, with clean handoff into downstream known-region workflows. + +**Architecture:** Build `dimelo.region_discovery` on top of existing parsing + loader behavior (`parse_bam.pileup`, `load_processed.pileup_counts_from_bedmethyl`, `load_processed.regions_to_list`) and the new `global_analysis` windowing utilities. Keep v1 deterministic and tiled. + +**Tech Stack:** Python 3.11, pandas, numpy, pytest + +--- + +## File Map + +- `dimelo/models.py` + Add `RegionDiscoveryResult` as the canonical data-first result container. +- `dimelo/region_discovery.py` + New module for scanning, ranking, hit merging, and BED export. +- `dimelo/__init__.py` + Export `region_discovery`. +- `tests/test_models.py` + Add model-level validation for `RegionDiscoveryResult`. +- `tests/test_region_discovery.py` + Add focused tests for scan, filtering, ranking, merge, and export helpers. +- `docs/region-discovery.md` + Add user-facing guide for de novo discovery and handoff. +- `README.md` + Link the new guide from the analysis guides section. + +Scope note: + +- This plan covers `region_discovery` foundations only. +- It does not implement `region_contrasts` inferential expansions. +- It does not modify existing parse/load semantics. +- It keeps outputs data-first and plotting-optional. + +### Task 1: Add RegionDiscoveryResult Model + +**Files:** +- Modify: `dimelo/models.py` +- Modify: `tests/test_models.py` + +- [ ] **Step 1: Write failing tests** + - Add a test that constructs `RegionDiscoveryResult` with `hits`, `windows`, `plot_data`, and metadata. + - Add a test that rejects `None` for required fields (`hits`, `windows`, `plot_data`). + +- [ ] **Step 2: Verify tests fail** + - Run: + - `pytest tests/test_models.py::test_region_discovery_result_accepts_tables_and_plot_data tests/test_models.py::test_region_discovery_result_rejects_missing_required_fields -q` + +- [ ] **Step 3: Implement minimal model** + - Add dataclass: + - `hits: pd.DataFrame` + - `windows: pd.DataFrame` + - `contrast: ContrastSpec | None` + - `plot_data: dict[str, pd.DataFrame | dict[str, Any]]` + - `metadata: dict[str, Any] = field(default_factory=dict)` + - `figures: dict[str, Any] = field(default_factory=dict)` + - Add `__post_init__` required field checks. + +- [ ] **Step 4: Verify tests pass** + - Re-run the focused tests above. + +- [ ] **Step 5: Commit** + - `git add dimelo/models.py tests/test_models.py` + - `git commit -m "feat: add region discovery result model"` + +### Task 2: Add Deterministic Genome Scan And Window Scoring + +**Files:** +- Create: `dimelo/region_discovery.py` +- Modify: `dimelo/__init__.py` +- Create: `tests/test_region_discovery.py` + +- [ ] **Step 1: Write failing tests** + - Add tests for: + - `scan_genome(...)` basic behavior with a mocked window summary table. + - `scan_genome(...)` minimum coverage filtering. + - `scan_genome(...)` contig include/exclude handoff to tiled window builder. + - significance ranking fields (`score_value`, `p_value`, `adjusted_p_value`, `rank`). + +- [ ] **Step 2: Verify tests fail** + - Run the focused test subset from `tests/test_region_discovery.py`. + +- [ ] **Step 3: Implement minimal discovery scan** + - Add in `dimelo/region_discovery.py`: + - `scan_genome(...)` + - uses `global_analysis.build_window_summary(...)` + - requires exactly one motif in v1 + - supports `window_size`, `step_size`, `include_contigs`, `exclude_contigs` + - applies `min_coverage` filter (`valid_count >= min_coverage`) + - computes a simple v1 discovery score: + - default `score="effect_size_only"`: rank by window fraction across contrast groups + - support `score="beta_binomial"` pooled approximation for matched group comparisons + - computes BH-adjusted p-values when p-values are present + - returns a `RegionDiscoveryResult` with: + - `windows`: per-window evidence table + - `hits`: ranked significant windows + - `plot_data`: at least `window_score_table`, `top_hits_table` + - metadata with scan policy and thresholds + - Keep deterministic ordering with stable sort keys. + +- [ ] **Step 4: Verify tests pass** + - Run: + - `pytest tests/test_region_discovery.py -q` + +- [ ] **Step 5: Commit** + - `git add dimelo/region_discovery.py dimelo/__init__.py tests/test_region_discovery.py` + - `git commit -m "feat: add deterministic region discovery scan"` + +### Task 3: Add Hit Merging And BED Export Helpers + +**Files:** +- Modify: `dimelo/region_discovery.py` +- Modify: `tests/test_region_discovery.py` + +- [ ] **Step 1: Write failing tests** + - Add tests for: + - `merge_adjacent_hits(...)` merges neighboring significant windows by chromosome and merge distance. + - `merge_adjacent_hits(...)` preserves score/rank summary fields deterministically. + - `hits_to_bed(...)` exports required BED columns and ordering. + +- [ ] **Step 2: Verify tests fail** + - Run focused tests for merge/export helpers. + +- [ ] **Step 3: Implement minimal helpers** + - Add: + - `merge_adjacent_hits(hits: pd.DataFrame, merge_distance: int) -> pd.DataFrame` + - `hits_to_bed(hits: pd.DataFrame) -> pd.DataFrame` + - Ensure merge happens after per-window scoring/FDR as per spec policy. + +- [ ] **Step 4: Verify tests pass** + - Run: + - `pytest tests/test_region_discovery.py -q` + +- [ ] **Step 5: Commit** + - `git add dimelo/region_discovery.py tests/test_region_discovery.py` + - `git commit -m "feat: add region discovery merge and bed export helpers"` + +### Task 4: Add User Guide And End-to-End Result Wrapper Polish + +**Files:** +- Modify: `dimelo/region_discovery.py` +- Modify: `tests/test_region_discovery.py` +- Create: `docs/region-discovery.md` +- Modify: `README.md` + +- [ ] **Step 1: Write failing tests** + - Add/extend a test to verify `scan_genome(...)` returns `RegionDiscoveryResult` with expected `plot_data` keys and metadata policy fields. + +- [ ] **Step 2: Verify tests fail** + - Run the focused test(s) first. + +- [ ] **Step 3: Implement wrapper polish and docs** + - Ensure `scan_genome(...)` includes metadata fields for: + - `analysis_unit` + - `representation` + - `signal_source` + - `score` + - `window_size` + - `step_size` + - `min_coverage` + - `merge_hits` + - `merge_distance` + - Add `docs/region-discovery.md` with: + - when to use discovery vs contrasts + - minimal usage example + - handoff to `region_contrasts`/clustering + - Link the guide from README analysis guides. + +- [ ] **Step 4: Verify tests pass** + - Run: + - `pytest tests/test_region_discovery.py tests/test_models.py -q` + +- [ ] **Step 5: Commit** + - `git add dimelo/region_discovery.py tests/test_region_discovery.py docs/region-discovery.md README.md` + - `git commit -m "docs: add region discovery workflow guide"` + +--- + +## Verification And Review Gates + +- After each task: + - Run the task-focused pytest subset. + - Run spec-compliance review. + - Run code-quality review. +- After Task 4: + - Run: + - `pytest tests/test_region_discovery.py tests/test_models.py tests/test_global_analysis.py tests/test_region_contrasts.py tests/test_workflows.py -q` + +## V1 Defaults To Preserve + +- deterministic tiled-window discovery +- canonical contigs by default with include/exclude override +- minimum coverage threshold before scoring +- FDR on raw windows before merge +- merge significant windows afterward with fixed merge distance +- data-first result tables with optional Matplotlib-agnostic plot payloads +- additive architecture around existing parsing/load modules diff --git a/docs/superpowers/plans/2026-04-01-cluster-occupancy-region-contrasts.md b/docs/superpowers/plans/2026-04-01-cluster-occupancy-region-contrasts.md new file mode 100644 index 0000000..23c947b --- /dev/null +++ b/docs/superpowers/plans/2026-04-01-cluster-occupancy-region-contrasts.md @@ -0,0 +1,296 @@ +# Cluster Occupancy Region Contrasts Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Extend `dimelo.region_contrasts` to support region-level cluster occupancy contrasts over sample-level occupancy summaries, including per-cluster fractions plus descriptive dominant-cluster and entropy outputs, with inferential support for per-cluster fractions in `pairwise` and `group_vs_group` modes. + +**Architecture:** Keep the current `score_regions(...)` entry point and extend it with a second validated path for `analysis_unit="cluster_occupancy"`. Build one occupancy evidence table from clustering-derived region summaries, then score per-cluster fraction contrasts across `region x sample` observations while also emitting descriptive dominant-cluster and entropy summaries in the result tables. + +**Tech Stack:** Python, pandas, existing dimelo contrast models, pytest + +--- + +### Task 1: Extend Validation And Occupancy Evidence Builders + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/region_contrasts.py` +- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_contrasts.py` + +- [ ] **Step 1: Write the failing validation and evidence-table tests** + +```python +def test_validate_region_contrast_request_accepts_cluster_occupancy_fraction_mode(): + region_contrasts.validate_region_contrast_request( + analysis_unit="cluster_occupancy", + representation="cluster_fraction", + signal_source="cluster_occupancy", + test="effect_size_only", + ) + + +def test_validate_region_contrast_request_rejects_beta_binomial_for_cluster_occupancy(): + with pytest.raises(ValueError, match="cluster_occupancy"): + region_contrasts.validate_region_contrast_request( + analysis_unit="cluster_occupancy", + representation="cluster_fraction", + signal_source="cluster_occupancy", + test="beta_binomial", + ) + + +def test_build_cluster_occupancy_evidence_table_summarizes_region_sample_clusters(): + evidence = region_contrasts.build_cluster_occupancy_evidence_table( + region_summaries=_mock_region_summaries(), + ) + assert {"region_id", "sample_id", "condition", "cluster", "fraction"} <= set(evidence.columns) + assert "dominant_cluster" in evidence.columns + assert "cluster_entropy" in evidence.columns +``` + +- [ ] **Step 2: Run the targeted tests to verify they fail** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_region_contrasts.py -q` +Expected: FAIL with missing builder / validation support + +- [ ] **Step 3: Extend request validation** + +```python +def validate_region_contrast_request(...): + if analysis_unit == "ensemble_region": + ... + return + if analysis_unit == "cluster_occupancy": + if signal_source != "cluster_occupancy": + raise ValueError(...) + if representation not in {"cluster_fraction", "dominant_cluster", "cluster_entropy"}: + raise ValueError(...) + if test not in {"effect_size_only", "fraction_test"}: + raise ValueError(...) + return + raise ValueError(...) +``` + +- [ ] **Step 4: Add the occupancy evidence builder** + +```python +def build_cluster_occupancy_evidence_table(*, region_summaries: pd.DataFrame) -> pd.DataFrame: + required = {"region_id", "sample_id", "condition", "cluster", "count", "fraction"} + missing = required - set(region_summaries.columns) + if missing: + raise ValueError(...) + + evidence = region_summaries.copy() + totals = evidence.groupby(["region_id", "sample_id", "condition"])["count"].transform("sum") + evidence["fraction"] = evidence["count"].div(totals.where(totals != 0), fill_value=0).fillna(0.0) + + dominant = ( + evidence.sort_values(["region_id", "sample_id", "condition", "fraction", "cluster"], + ascending=[True, True, True, False, True]) + .drop_duplicates(["region_id", "sample_id", "condition"]) + .loc[:, ["region_id", "sample_id", "condition", "cluster"]] + .rename(columns={"cluster": "dominant_cluster"}) + ) + entropy = ( + evidence.groupby(["region_id", "sample_id", "condition"], as_index=False) + .agg(cluster_entropy=("fraction", lambda values: float(-(values * np.log2(values.where(values > 0, 1))).sum()))) + ) + return evidence.merge(dominant, ...).merge(entropy, ...) +``` + +- [ ] **Step 5: Run the targeted tests to verify they pass** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_region_contrasts.py -q` +Expected: PASS + +- [ ] **Step 6: Commit** + +```bash +git add dimelo/region_contrasts.py tests/test_region_contrasts.py +git commit -m "feat: add cluster occupancy contrast evidence builders" +``` + +### Task 2: Add Sample-Level Occupancy Scoring + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/region_contrasts.py` +- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_contrasts.py` + +- [ ] **Step 1: Write the failing scoring tests** + +```python +def test_score_regions_cluster_fraction_effect_size_only_ranks_largest_fraction_shift_first(): + result = region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec(mode="pairwise", numerator=["15min"], denominator=["NS"]), + analysis_unit="cluster_occupancy", + representation="cluster_fraction", + signal_source="cluster_occupancy", + test="effect_size_only", + occupancy_table=_mock_cluster_occupancy_evidence(), + ) + assert result.regions.iloc[0]["cluster"] == "C1" + assert "delta_fraction" in result.regions.columns + + +def test_score_regions_cluster_fraction_fraction_test_adds_p_values(): + result = region_contrasts.score_regions( + ..., + analysis_unit="cluster_occupancy", + representation="cluster_fraction", + signal_source="cluster_occupancy", + test="fraction_test", + occupancy_table=_mock_cluster_occupancy_evidence(), + ) + assert {"p_value", "adjusted_p_value"} <= set(result.regions.columns) + + +def test_score_regions_cluster_entropy_returns_descriptive_summary_only(): + result = region_contrasts.score_regions( + ..., + analysis_unit="cluster_occupancy", + representation="cluster_entropy", + signal_source="cluster_occupancy", + test="effect_size_only", + occupancy_table=_mock_cluster_occupancy_evidence(), + ) + assert "cluster_entropy" in result.regions.columns + assert "p_value" not in result.regions.columns +``` + +- [ ] **Step 2: Run the targeted tests to verify they fail** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_region_contrasts.py -q` +Expected: FAIL with unsupported cluster occupancy path + +- [ ] **Step 3: Implement occupancy scoring helpers** + +```python +def _pool_cluster_occupancy_groups(...): + ... + + +def _add_fraction_test_scores(regions_table: pd.DataFrame, *, multiple_testing: str) -> pd.DataFrame: + ... + + +def _score_cluster_occupancy(...): + if representation == "cluster_fraction": + ... + elif representation == "dominant_cluster": + ... + else: + ... +``` + +Rules for v1: +- inferential support only for `representation="cluster_fraction"` +- only `pairwise` and `group_vs_group` +- sample-level region occupancy is the unit; do not pool reads as pseudo-replicates +- `dominant_cluster` and `cluster_entropy` remain descriptive + +- [ ] **Step 4: Extend score_regions(...) with the new path** + +```python +def score_regions(..., occupancy_table: pd.DataFrame | None = None, ...): + validate_region_contrast_request(...) + if analysis_unit == "cluster_occupancy": + evidence = occupancy_table if occupancy_table is not None else build_cluster_occupancy_evidence_table(...) + ... + return RegionContrastResult(...) + ... +``` + +- [ ] **Step 5: Add rejection-path tests** + +```python +def test_score_regions_cluster_occupancy_rejects_matched_pairwise(): + ... + + +def test_score_regions_cluster_occupancy_rejects_beta_binomial(): + ... + + +def test_score_regions_cluster_occupancy_rejects_missing_occupancy_columns(): + ... +``` + +- [ ] **Step 6: Run the targeted tests to verify they pass** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_region_contrasts.py -q` +Expected: PASS + +- [ ] **Step 7: Commit** + +```bash +git add dimelo/region_contrasts.py tests/test_region_contrasts.py +git commit -m "feat: add cluster occupancy region scoring" +``` + +### Task 3: Document Occupancy Contrasts And Verify The Slice + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/shared-clustering.md` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` +- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_contrasts.py` + +- [ ] **Step 1: Add one occupancy-driven example** + +```python +result = region_contrasts.score_regions( + samples=samples, + regions=selected_regions, + motifs=["A,0"], + contrast=ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + ), + analysis_unit="cluster_occupancy", + representation="cluster_fraction", + signal_source="cluster_occupancy", + test="fraction_test", + occupancy_table=occupancy_table, +) +``` + +- [ ] **Step 2: Make the v1 occupancy contract explicit** + +```markdown +- sample-level `region x sample` occupancy summaries are the unit of comparison +- `cluster_fraction` supports `effect_size_only` and `fraction_test` +- `dominant_cluster` and `cluster_entropy` are descriptive-only in v1 +- supported contrast modes are `pairwise` and `group_vs_group` +``` + +- [ ] **Step 3: Add/adjust one metadata test if needed** + +```python +def test_score_regions_cluster_occupancy_metadata_marks_signal_source(): + ... + assert result.metadata["analysis_unit"] == "cluster_occupancy" + assert result.metadata["signal_source"] == "cluster_occupancy" +``` + +- [ ] **Step 4: Run the verification slice** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_region_contrasts.py tests/test_workflows.py -q` +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add docs/region-contrasts.md docs/shared-clustering.md README.md tests/test_region_contrasts.py +git commit -m "docs: add cluster occupancy contrast guide" +``` + +--- + +## Self-Review + +- Spec coverage: this plan adds the occupancy evidence builder, scoring path, inference/descriptive split, and docs for the new cluster-occupancy contrasts. +- Placeholder scan: every task names exact files, tests, and commands; there are no TODO placeholders. +- Type consistency: the same API terms are used throughout: `analysis_unit="cluster_occupancy"`, `representation in {"cluster_fraction", "dominant_cluster", "cluster_entropy"}`, `signal_source="cluster_occupancy"`, and `test in {"effect_size_only", "fraction_test"}`. diff --git a/docs/superpowers/plans/2026-04-01-discovery-cluster-contrast-workflow.md b/docs/superpowers/plans/2026-04-01-discovery-cluster-contrast-workflow.md new file mode 100644 index 0000000..cf32528 --- /dev/null +++ b/docs/superpowers/plans/2026-04-01-discovery-cluster-contrast-workflow.md @@ -0,0 +1,351 @@ +# Discovery Cluster Contrast Workflow Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Add one end-to-end workflow that discovers loci, clusters the selected loci, runs defined-region contrasts on that same selected set, and returns all four outputs together with the full scan table as context. + +**Architecture:** Extend the current `discovery_cluster_workflow(...)` path instead of inventing a parallel orchestration stack. Add one wrapper result model for the combined outputs, then add one workflow entry point in `dimelo.workflows` that composes the existing `region_discovery.scan_genome(...)`, `shared_cluster_distribution(...)`, and `region_contrasts.score_regions(...)` functions in that order, using the selected loci as the default contrast region set. + +**Tech Stack:** Python dataclasses, pandas, existing dimelo discovery/clustering/contrast modules, pytest + +--- + +### Task 1: Add The Combined Result Model + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/models.py` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/__init__.py` +- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_models.py` + +- [ ] **Step 1: Write the failing model tests** + +```python +def test_region_discovery_cluster_contrast_result_requires_non_none_values(): + with pytest.raises(ValueError, match="discovery"): + RegionDiscoveryClusterContrastResult( + discovery=None, + clustering=_dummy_shared_cluster_result(), + contrasts=_dummy_region_contrast_result(), + selected_regions=pd.DataFrame([{"chrom": "chr1", "start": 0, "end": 100}]), + metadata={}, + ) + + +def test_region_discovery_cluster_contrast_result_validates_wrapped_types(): + with pytest.raises(TypeError, match="RegionDiscoveryResult"): + RegionDiscoveryClusterContrastResult( + discovery={}, + clustering=_dummy_shared_cluster_result(), + contrasts=_dummy_region_contrast_result(), + selected_regions=pd.DataFrame([{"chrom": "chr1", "start": 0, "end": 100}]), + metadata={}, + ) + + +def test_region_discovery_cluster_contrast_result_accepts_valid_payloads(): + result = RegionDiscoveryClusterContrastResult( + discovery=_dummy_region_discovery_result(), + clustering=_dummy_shared_cluster_result(), + contrasts=_dummy_region_contrast_result(), + selected_regions=pd.DataFrame([{"chrom": "chr1", "start": 0, "end": 100}]), + metadata={"contrast_scope": "selected"}, + ) + assert result.metadata["contrast_scope"] == "selected" +``` + +- [ ] **Step 2: Run the model tests to verify they fail** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_models.py -q` +Expected: FAIL with `NameError` / import errors for `RegionDiscoveryClusterContrastResult` + +- [ ] **Step 3: Write the minimal model implementation** + +```python +@dataclass +class RegionDiscoveryClusterContrastResult: + discovery: RegionDiscoveryResult + clustering: SharedClusterResult + contrasts: RegionContrastResult + selected_regions: pd.DataFrame + metadata: dict[str, Any] = field(default_factory=dict) + figures: dict[str, Any] = field(default_factory=dict) + + def __post_init__(self) -> None: + required_fields = { + "discovery": self.discovery, + "clustering": self.clustering, + "contrasts": self.contrasts, + "selected_regions": self.selected_regions, + "metadata": self.metadata, + "figures": self.figures, + } + missing = [name for name, value in required_fields.items() if value is None] + if missing: + raise ValueError( + "RegionDiscoveryClusterContrastResult requires non-None values for: " + f"{', '.join(missing)}" + ) + if not isinstance(self.discovery, RegionDiscoveryResult): + raise TypeError( + "RegionDiscoveryClusterContrastResult.discovery must be a RegionDiscoveryResult" + ) + if not isinstance(self.clustering, SharedClusterResult): + raise TypeError( + "RegionDiscoveryClusterContrastResult.clustering must be a SharedClusterResult" + ) + if not isinstance(self.contrasts, RegionContrastResult): + raise TypeError( + "RegionDiscoveryClusterContrastResult.contrasts must be a RegionContrastResult" + ) +``` + +- [ ] **Step 4: Export the new model from the package root** + +```python +from .models import RegionDiscoveryClusterContrastResult +... +__all__ = [ + ... + "RegionDiscoveryClusterContrastResult", +] +``` + +- [ ] **Step 5: Run the model tests to verify they pass** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_models.py -q` +Expected: PASS + +- [ ] **Step 6: Commit** + +```bash +git add dimelo/models.py dimelo/__init__.py tests/test_models.py +git commit -m "feat: add discovery cluster contrast result" +``` + +### Task 2: Add The End-To-End Workflow + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/workflows.py` +- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_workflows.py` + +- [ ] **Step 1: Write the failing workflow tests** + +```python +def test_discovery_cluster_contrast_workflow_returns_all_results(monkeypatch): + monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) + monkeypatch.setattr(workflows.region_contrasts, "score_regions", _mock_region_contrast_result) + + result = workflows.discovery_cluster_contrast_workflow( + samples=_workflow_samples(), + motifs=["A,0"], + genome_sizes={"chr1": 1500}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "n_clusters": 2}, + contrasts={ + "contrast": ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + ), + "test": "effect_size_only", + }, + ) + + assert result.discovery.hits.shape[0] == 3 + assert result.clustering.model.mode == "region_anchored" + assert result.contrasts.metadata["test"] == "effect_size_only" + assert result.metadata["contrast_scope"] == "selected" +``` + +```python +def test_discovery_cluster_contrast_workflow_scores_selected_regions_by_default(monkeypatch): + captured = {} + ... + def fake_score_regions(**kwargs): + captured["regions"] = kwargs["regions"] + return _mock_region_contrast_result(**kwargs) + + ... + result = workflows.discovery_cluster_contrast_workflow(...) + assert captured["regions"] == ["chr1:0-500,+", "chr1:500-1000,-"] + assert result.selected_regions["name"].tolist() == ["chr1:0-500", "chr1:500-1000"] +``` + +```python +def test_discovery_cluster_contrast_workflow_rejects_missing_contrast_config(monkeypatch): + ... + with pytest.raises(ValueError, match="requires contrasts\\['contrast'\\]"): + workflows.discovery_cluster_contrast_workflow(...) +``` + +- [ ] **Step 2: Run the workflow tests to verify they fail** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_workflows.py -q` +Expected: FAIL with missing `discovery_cluster_contrast_workflow` + +- [ ] **Step 3: Implement the orchestration workflow** + +```python +def discovery_cluster_contrast_workflow( + *, + samples: Iterable[SampleSpec], + motifs: Iterable[str], + genome_sizes: dict[str, int], + discovery: dict[str, Any], + clustering: dict[str, Any], + contrasts: dict[str, Any], + selection: dict[str, Any] | None = None, +) -> RegionDiscoveryClusterContrastResult: + sample_list = list(samples) + motif_list = list(motifs) + contrast_config = dict(contrasts) + if "contrast" not in contrast_config: + raise ValueError("discovery_cluster_contrast_workflow requires contrasts['contrast'].") + + discovery_cluster_result = discovery_cluster_workflow( + samples=sample_list, + motifs=motif_list, + genome_sizes=genome_sizes, + discovery=discovery, + clustering=clustering, + selection=selection, + ) + selected_region_spec = _selected_regions_to_region_spec( + discovery_cluster_result.selected_regions + ) + contrast_result = region_contrasts.score_regions( + samples=sample_list, + regions=selected_region_spec, + motifs=motif_list, + **contrast_config, + ) + return RegionDiscoveryClusterContrastResult( + discovery=discovery_cluster_result.discovery, + clustering=discovery_cluster_result.clustering, + contrasts=contrast_result, + selected_regions=discovery_cluster_result.selected_regions, + metadata={ + **discovery_cluster_result.metadata, + "contrast_scope": "selected", + "full_scan_windows": discovery_cluster_result.discovery.windows.copy(), + }, + ) +``` + +- [ ] **Step 4: Add the remaining workflow tests** + +```python +def test_discovery_cluster_contrast_workflow_preserves_full_scan_windows_context(monkeypatch): + ... + result = workflows.discovery_cluster_contrast_workflow(...) + assert result.metadata["full_scan_windows"].equals(result.discovery.windows) +``` + +```python +def test_discovery_cluster_contrast_workflow_fast_fails_invalid_contrast_before_reuse(monkeypatch): + called = {"scan": False} + def fake_scan_genome(**kwargs): + called["scan"] = True + return _mock_discovery_result() + + monkeypatch.setattr(workflows.region_discovery, "scan_genome", fake_scan_genome) + with pytest.raises(ValueError, match="analysis_unit='ensemble_region'"): + workflows.discovery_cluster_contrast_workflow( + ..., + contrasts={ + "contrast": ContrastSpec(mode="pairwise", numerator=["15min"], denominator=["NS"]), + "analysis_unit": "single_read", + }, + ) + assert called["scan"] is False +``` + +- [ ] **Step 5: Run the workflow tests to verify they pass** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_workflows.py -q` +Expected: PASS + +- [ ] **Step 6: Commit** + +```bash +git add dimelo/workflows.py tests/test_workflows.py +git commit -m "feat: add discovery cluster contrast workflow" +``` + +### Task 3: Document The New Handoff And Run The Broader Slice + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-discovery.md` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/shared-clustering.md` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` +- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_workflows.py` + +- [ ] **Step 1: Add one end-to-end doc example** + +```python +result = workflows.discovery_cluster_contrast_workflow( + samples=samples, + motifs=["A,0"], + genome_sizes={"chr1": 248_956_422}, + discovery={ + "window_size": 2000, + "step_size": 500, + "score": "beta_binomial", + "contrast": discovery_contrast, + }, + clustering={ + "mode": "region_anchored", + "n_clusters": 6, + }, + contrasts={ + "contrast": region_contrast, + "test": "beta_binomial", + }, + selection={"mode": "top_n", "top_n": 250}, +) + +selected = result.selected_regions +clustered = result.clustering.assignments +scored = result.contrasts.regions +windows = result.metadata["full_scan_windows"] +``` + +- [ ] **Step 2: Clarify the contract in docs** + +```markdown +- `result.selected_regions` is the BED-style selected follow-up set +- clustering receives a serializable region-spec derived from those rows +- `result.contrasts` scores the same selected loci by default +- `result.metadata["full_scan_windows"]` carries the full discovery scan for context +``` + +- [ ] **Step 3: Add/adjust one test if docs exposed a missing behavior** + +```python +def test_discovery_cluster_contrast_workflow_metadata_marks_selected_scope(monkeypatch): + ... + result = workflows.discovery_cluster_contrast_workflow(...) + assert result.metadata["contrast_scope"] == "selected" +``` + +- [ ] **Step 4: Run the broader verification slice** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_models.py tests/test_region_contrasts.py tests/test_region_discovery.py tests/test_workflows.py -q` +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add docs/region-contrasts.md docs/region-discovery.md docs/shared-clustering.md README.md tests/test_workflows.py +git commit -m "docs: add discovery cluster contrast workflow guide" +``` + +--- + +## Self-Review + +- Spec coverage: this plan adds the combined result object, the selected-set-first orchestration workflow, validation for contrast config, and docs for the end-to-end discovery -> cluster -> contrast path. +- Placeholder scan: every task includes concrete files, tests, commands, and implementation snippets; there are no TODO placeholders. +- Type consistency: the plan consistently uses `RegionDiscoveryClusterContrastResult`, `discovery_cluster_contrast_workflow`, `selected_regions`, and `full_scan_windows` across tasks. diff --git a/docs/superpowers/plans/2026-04-01-paired-region-discovery.md b/docs/superpowers/plans/2026-04-01-paired-region-discovery.md new file mode 100644 index 0000000..faaf81f --- /dev/null +++ b/docs/superpowers/plans/2026-04-01-paired-region-discovery.md @@ -0,0 +1,588 @@ +# Paired Region Discovery Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Extend `dimelo.region_discovery.scan_genome(...)` with explicit paired discovery support for matched two-condition scans and ordered paired time-course scans. + +**Architecture:** Keep the current tiled pileup-backed discovery path intact, then add a shared pairing layer inside `dimelo.region_discovery` that resolves complete matched units and builds an internal per-window paired table. Implement `matched_pairwise` first and `time_course` second, both returning the existing `RegionDiscoveryResult` shape with paired metadata and paired score columns. + +**Tech Stack:** Python 3.11, pandas, pytest + +--- + +## File Map + +- `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/region_discovery.py` + Add pairing-resolution helpers, paired-window table helpers, `matched_pairwise` scoring, paired `time_course` scoring, and paired metadata emission. +- `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_discovery.py` + Add regression tests for complete-pair filtering, strict missing-pair errors, paired ranking columns, paired metadata, time-order validation, and downstream handoff. +- `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-discovery.md` + Document when to use pooled discovery vs paired discovery, required sample metadata, and paired examples. +- `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` + Update the discovery guide link text to mention paired discovery support. + +Scope note: + +- This plan only extends `region_discovery`. +- It does not add paired inferential models. +- It does not change `parse_bam`, `global_analysis`, `region_contrasts`, or existing pooled discovery semantics. +- It keeps `RegionDiscoveryResult` data-first and plotting-optional. + +### Task 1: Add Pair Resolution And Paired-Window Helpers + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/region_discovery.py` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_discovery.py` + +- [ ] **Step 1: Write the failing tests** + +```python +def test_scan_genome_matched_pairwise_uses_only_complete_pairs(monkeypatch): + monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_window_summary()) + + result = region_discovery.scan_genome( + samples=_paired_samplespecs(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=500, + step_size=500, + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["targeting"], + denominator=["nontargeting"], + pairing_key="pair_id", + ), + score="effect_size_only", + ) + + assert result.metadata["pairing_policy"] == "complete_pairs_only" + assert result.metadata["n_pairs_used"] == 2 + assert result.metadata["n_pairs_dropped"] == 1 + + +def test_scan_genome_time_course_errors_on_missing_pairing_key(monkeypatch): + monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_window_summary()) + + with pytest.raises(ValueError, match="pairing_key"): + region_discovery.scan_genome( + samples=_paired_samplespecs(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=500, + step_size=500, + contrast=ContrastSpec( + mode="time_course", + time_order=["0min", "15min"], + ), + score="effect_size_only", + ) +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: + +```bash +pytest tests/test_region_discovery.py::test_scan_genome_matched_pairwise_uses_only_complete_pairs tests/test_region_discovery.py::test_scan_genome_time_course_errors_on_missing_pairing_key -q +``` + +Expected: FAIL because `scan_genome(...)` still rejects paired contrast modes and has no paired metadata or pairing validation path. + +- [ ] **Step 3: Write minimal implementation** + +```python +def _pairing_policy_value(pairing_policy: str | None) -> str: + return pairing_policy or "complete_pairs_only" + + +def _is_paired_contrast(contrast: ContrastSpec | None) -> bool: + return contrast is not None and contrast.mode in {"matched_pairwise", "time_course"} + + +def _resolve_pair_ids(samples, pairing_key: str) -> dict[str, object]: + pair_ids: dict[str, object] = {} + for sample in samples: + metadata = sample.metadata or {} + if pairing_key not in metadata: + raise ValueError( + f"scan_genome paired discovery requires sample.metadata['{pairing_key}'] for every sample." + ) + pair_ids[sample.sample_id] = metadata[pairing_key] + return pair_ids + + +def _build_paired_window_table( + summary: pd.DataFrame, + *, + samples, + pairing_key: str, + required_conditions: list[str], + pairing_policy: str, +) -> tuple[pd.DataFrame, dict[str, int]]: + sample_to_pair = _resolve_pair_ids(samples, pairing_key) + paired = summary.copy() + paired["pair_id"] = paired["sample_id"].map(sample_to_pair) + paired = paired.dropna(subset=["pair_id"]) + + present = ( + paired.loc[:, ["pair_id", "condition"]] + .drop_duplicates() + .groupby("pair_id")["condition"] + .agg(lambda values: set(values)) + ) + complete_pair_ids = sorted( + pair_id for pair_id, values in present.items() if set(required_conditions).issubset(values) + ) + dropped_pair_count = int(len(present) - len(complete_pair_ids)) + + if pairing_policy == "error_on_missing" and dropped_pair_count: + raise ValueError("scan_genome paired discovery found incomplete matched units.") + if not complete_pair_ids: + raise ValueError("scan_genome paired discovery found no complete matched units.") + + paired = paired.loc[paired["pair_id"].isin(complete_pair_ids)].copy() + aggregated = ( + paired.groupby(_WINDOW_KEY_COLUMNS + ["pair_id", "condition"], as_index=False, sort=False) + .agg(modified_count=("modified_count", "sum"), valid_count=("valid_count", "sum")) + .copy() + ) + aggregated["window_fraction"] = _safe_fraction( + aggregated["modified_count"], aggregated["valid_count"] + ) + return aggregated, { + "n_pairs_used": len(complete_pair_ids), + "n_pairs_dropped": dropped_pair_count, + } +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: + +```bash +pytest tests/test_region_discovery.py::test_scan_genome_matched_pairwise_uses_only_complete_pairs tests/test_region_discovery.py::test_scan_genome_time_course_errors_on_missing_pairing_key -q +``` + +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add tests/test_region_discovery.py dimelo/region_discovery.py +git commit -m "feat: add paired region discovery pair resolution" +``` + +### Task 2: Add `matched_pairwise` Scoring And Paired Metadata + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/region_discovery.py` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_discovery.py` + +- [ ] **Step 1: Write the failing tests** + +```python +def test_scan_genome_matched_pairwise_ranks_by_mean_abs_delta(monkeypatch): + monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_pairwise_window_summary()) + + result = region_discovery.scan_genome( + samples=_paired_samplespecs(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=500, + step_size=500, + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["targeting"], + denominator=["nontargeting"], + pairing_key="pair_id", + ), + score="effect_size_only", + ) + + assert list(result.hits["window_id"]) == ["chr1:0-500", "chr1:500-1000"] + assert result.hits.loc[0, "mean_delta"] == pytest.approx(0.35) + assert result.hits.loc[0, "mean_abs_delta"] == pytest.approx(0.35) + assert result.hits.loc[0, "sign_agreement"] == pytest.approx(1.0) + assert result.metadata["paired_mode"] == "matched_pairwise" + assert result.metadata["rank_by"] == "mean_abs_delta" + + +def test_scan_genome_matched_pairwise_errors_on_missing_pairs_in_strict_mode(monkeypatch): + monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_window_summary()) + + with pytest.raises(ValueError, match="incomplete matched units"): + region_discovery.scan_genome( + samples=_paired_samplespecs(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=500, + step_size=500, + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["targeting"], + denominator=["nontargeting"], + pairing_key="pair_id", + ), + score="effect_size_only", + pairing_policy="error_on_missing", + ) +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: + +```bash +pytest tests/test_region_discovery.py::test_scan_genome_matched_pairwise_ranks_by_mean_abs_delta tests/test_region_discovery.py::test_scan_genome_matched_pairwise_errors_on_missing_pairs_in_strict_mode -q +``` + +Expected: FAIL because paired windows are not yet summarized into `mean_delta`, `mean_abs_delta`, `delta_sd`, or `sign_agreement`. + +- [ ] **Step 3: Write minimal implementation** + +```python +def _score_matched_pairwise( + paired_window_table: pd.DataFrame, + *, + contrast: ContrastSpec, +) -> pd.DataFrame: + numerator = paired_window_table.loc[ + paired_window_table["condition"].isin(contrast.numerator) + ].copy() + denominator = paired_window_table.loc[ + paired_window_table["condition"].isin(contrast.denominator) + ].copy() + + numerator = numerator.rename( + columns={ + "modified_count": "numerator_modified_count", + "valid_count": "numerator_valid_count", + "window_fraction": "numerator_fraction", + } + ) + denominator = denominator.rename( + columns={ + "modified_count": "denominator_modified_count", + "valid_count": "denominator_valid_count", + "window_fraction": "denominator_fraction", + } + ) + + merged = numerator.merge( + denominator[ + _WINDOW_KEY_COLUMNS + + ["pair_id", "denominator_modified_count", "denominator_valid_count", "denominator_fraction"] + ], + on=_WINDOW_KEY_COLUMNS + ["pair_id"], + how="inner", + ) + merged["delta"] = merged["numerator_fraction"] - merged["denominator_fraction"] + + scored = ( + merged.groupby(_WINDOW_KEY_COLUMNS, as_index=False, sort=False) + .agg( + mean_delta=("delta", "mean"), + mean_abs_delta=("delta", lambda values: float(values.abs().mean())), + delta_sd=("delta", lambda values: float(values.std(ddof=0))), + sign_agreement=( + "delta", + lambda values: float( + max((values.gt(0)).mean(), (values.lt(0)).mean()) if len(values) else 0.0 + ), + ), + n_pairs_used=("pair_id", "nunique"), + ) + .copy() + ) + scored["score_value"] = scored["mean_abs_delta"] + scored["p_value"] = pd.NA + scored["adjusted_p_value"] = pd.NA + return scored + + +def scan_genome(..., pairing_policy: str | None = None, rank_by: str | None = None, ...): + ... + if contrast is not None and contrast.mode == "matched_pairwise": + paired_table, pairing_meta = _build_paired_window_table( + window_summary, + samples=samples, + pairing_key=contrast.pairing_key, + required_conditions=list(contrast.numerator or []) + list(contrast.denominator or []), + pairing_policy=_pairing_policy_value(pairing_policy), + ) + ranked = _rank_windows( + _score_matched_pairwise(paired_table, contrast=contrast), + score="effect_size_only", + primary_score_column="mean_abs_delta", + ) +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: + +```bash +pytest tests/test_region_discovery.py::test_scan_genome_matched_pairwise_ranks_by_mean_abs_delta tests/test_region_discovery.py::test_scan_genome_matched_pairwise_errors_on_missing_pairs_in_strict_mode -q +``` + +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add tests/test_region_discovery.py dimelo/region_discovery.py +git commit -m "feat: add matched pairwise region discovery scoring" +``` + +### Task 3: Add Paired Ordered `time_course` Discovery + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/region_discovery.py` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_discovery.py` + +- [ ] **Step 1: Write the failing tests** + +```python +def test_scan_genome_time_course_ranks_by_trajectory_amplitude_mean(monkeypatch): + monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_time_course_window_summary()) + + result = region_discovery.scan_genome( + samples=_paired_time_course_samplespecs(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=500, + step_size=500, + contrast=ContrastSpec( + mode="time_course", + time_order=["0min", "15min", "30min"], + pairing_key="pair_id", + ), + score="effect_size_only", + ) + + assert result.hits.loc[0, "trajectory_amplitude_mean"] == pytest.approx(0.55) + assert result.hits.loc[0, "trajectory_amplitude_sd"] == pytest.approx(0.05) + assert result.metadata["paired_mode"] == "time_course" + assert result.metadata["time_order"] == ["0min", "15min", "30min"] + assert result.metadata["rank_by"] == "trajectory_amplitude_mean" + + +def test_scan_genome_time_course_errors_when_time_order_conditions_are_missing(monkeypatch): + monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_time_course_window_summary()) + + with pytest.raises(ValueError, match="time_order"): + region_discovery.scan_genome( + samples=_paired_time_course_samplespecs(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=500, + step_size=500, + contrast=ContrastSpec( + mode="time_course", + time_order=["0min", "15min", "60min"], + pairing_key="pair_id", + ), + score="effect_size_only", + ) +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: + +```bash +pytest tests/test_region_discovery.py::test_scan_genome_time_course_ranks_by_trajectory_amplitude_mean tests/test_region_discovery.py::test_scan_genome_time_course_errors_when_time_order_conditions_are_missing -q +``` + +Expected: FAIL because `time_course` is still rejected by `scan_genome(...)`. + +- [ ] **Step 3: Write minimal implementation** + +```python +def _validate_time_order(paired_window_table: pd.DataFrame, time_order: list[str]) -> None: + available = set(paired_window_table["condition"].dropna().tolist()) + missing = [condition for condition in time_order if condition not in available] + if missing: + raise ValueError( + "scan_genome paired time_course requested missing time_order condition(s): " + + ", ".join(missing) + ) + + +def _score_paired_time_course( + paired_window_table: pd.DataFrame, + *, + time_order: list[str], +) -> pd.DataFrame: + _validate_time_order(paired_window_table, time_order) + ordered = paired_window_table.copy() + ordered["condition"] = pd.Categorical( + ordered["condition"], + categories=time_order, + ordered=True, + ) + ordered = ordered.sort_values(_WINDOW_KEY_COLUMNS + ["pair_id", "condition"]) + + per_pair = ( + ordered.groupby(_WINDOW_KEY_COLUMNS + ["pair_id"], as_index=False, sort=False) + .agg( + trajectory_amplitude=("window_fraction", lambda values: float(values.max() - values.min())), + ) + .copy() + ) + scored = ( + per_pair.groupby(_WINDOW_KEY_COLUMNS, as_index=False, sort=False) + .agg( + trajectory_amplitude_mean=("trajectory_amplitude", "mean"), + trajectory_amplitude_median=("trajectory_amplitude", "median"), + trajectory_amplitude_sd=("trajectory_amplitude", lambda values: float(values.std(ddof=0))), + n_pairs_used=("pair_id", "nunique"), + ) + .copy() + ) + scored["score_value"] = scored["trajectory_amplitude_mean"] + scored["p_value"] = pd.NA + scored["adjusted_p_value"] = pd.NA + return scored +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: + +```bash +pytest tests/test_region_discovery.py::test_scan_genome_time_course_ranks_by_trajectory_amplitude_mean tests/test_region_discovery.py::test_scan_genome_time_course_errors_when_time_order_conditions_are_missing -q +``` + +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add tests/test_region_discovery.py dimelo/region_discovery.py +git commit -m "feat: add paired time-course region discovery" +``` + +### Task 4: Add Downstream Handoff Coverage And User Docs + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_discovery.py` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-discovery.md` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` + +- [ ] **Step 1: Write the failing tests** + +```python +def test_paired_discovery_hits_to_bed_and_region_contrasts_handoff(monkeypatch, tmp_path): + monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_pairwise_window_summary()) + + discovery = region_discovery.scan_genome( + samples=_paired_samplespecs(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + window_size=500, + step_size=500, + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["targeting"], + denominator=["nontargeting"], + pairing_key="pair_id", + ), + score="effect_size_only", + ) + + bed = region_discovery.hits_to_bed(discovery.hits.head(1)) + assert list(bed.columns) == ["chrom", "start", "end", "name", "score", "strand"] + assert bed.loc[0, "name"] == "chr1:0-500" +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: + +```bash +pytest tests/test_region_discovery.py::test_paired_discovery_hits_to_bed_and_region_contrasts_handoff -q +``` + +Expected: FAIL because the paired hit columns and metadata are not yet exercised through the downstream handoff path. + +- [ ] **Step 3: Implement wrapper polish and docs** + +```python +metadata.update( + { + "pairing_key": contrast.pairing_key, + "pairing_policy": active_pairing_policy, + "n_pairs_used": pairing_meta["n_pairs_used"], + "n_pairs_dropped": pairing_meta["n_pairs_dropped"], + "paired_mode": contrast.mode, + "rank_by": active_rank_by, + } +) +if contrast.mode == "time_course": + metadata["time_order"] = list(contrast.time_order or []) +``` + +```markdown +## Paired discovery + +Use paired discovery when your samples are matched across conditions and pooling would hide the design: + +- nontargeting versus targeting with matched replicates +- before/after on the same sample +- ordered time courses across the same matched units + +`scan_genome(...)` now supports: + +- `ContrastSpec(mode="matched_pairwise", ...)` +- `ContrastSpec(mode="time_course", ...)` + +For paired modes, every `SampleSpec.metadata` entry must include the requested `pairing_key`. +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: + +```bash +pytest tests/test_region_discovery.py tests/test_global_analysis.py tests/test_region_contrasts.py -q +``` + +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add tests/test_region_discovery.py docs/region-discovery.md README.md dimelo/region_discovery.py +git commit -m "docs: add paired region discovery guide" +``` + +--- + +## Verification And Review Gates + +- After each task: + - Run the task-focused pytest subset. + - Confirm existing pooled discovery tests still pass. + - Review for continuity with current `scan_genome(...)` behavior. +- After Task 4: + - Run: + +```bash +pytest tests/test_region_discovery.py tests/test_global_analysis.py tests/test_region_contrasts.py tests/test_models.py tests/test_workflows.py -q +``` + +- If the full subset fails: + - fix regressions before proceeding + - do not merge a paired mode that changes current pooled semantics + +## V1 Defaults To Preserve + +- pooled `pairwise` and `group_vs_group` behavior stays unchanged +- paired discovery requires explicit `pairing_key` +- default `pairing_policy="complete_pairs_only"` +- strict `pairing_policy="error_on_missing"` is opt-in +- `matched_pairwise` ranks by `mean_abs_delta` +- paired `time_course` ranks by `trajectory_amplitude_mean` +- no silent fallback from paired discovery to pooled discovery +- `RegionDiscoveryResult` remains data-first with optional figures diff --git a/docs/superpowers/plans/2026-04-01-plotting-axis-architecture.md b/docs/superpowers/plans/2026-04-01-plotting-axis-architecture.md new file mode 100644 index 0000000..feac139 --- /dev/null +++ b/docs/superpowers/plans/2026-04-01-plotting-axis-architecture.md @@ -0,0 +1,749 @@ +# Plotting Axis Architecture Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Add a shared plotting-axis core that supports compatibility-safe `5'->3'` orientation, fixed-window prep, aggregate segment-map prep, and legacy wrapper integration without breaking existing plotting entry points. + +**Architecture:** Extend `dimelo/plotting.py` into the canonical plot-data preparation core with explicit axis and aggregation specs. Keep legacy plotting modules public and behaviorally stable by translating existing arguments such as `relative` and `regions_5to3prime` into the new shared prep layer. Restrict scaled/segment-normalized axes to aggregate plots, while keeping single-read plotting coordinate-preserving. + +**Tech Stack:** Python 3.11, `dataclasses`, `pandas`, existing `dimelo` plotting/load utilities, `pytest` + +--- + +## File Map + +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` + - Add shared plotting spec dataclasses, validation, and plot-data prep helpers. +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plot_enrichment_profile.py` + - Route one aggregate legacy plotter through the shared plotting core without changing public defaults. +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plot_reads.py` + - Route one single-read legacy plotter through the shared plotting core without allowing scaled continuous axes. +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md` + - Document aggregate positional plotting semantics and compatibility notes. +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/shared-clustering.md` + - Document how the shared plotting layer applies to workflow `plot_data`. +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` + - Add compatibility mapping between old plotting flags and new axis concepts. +- Create: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` + - Add focused tests for spec validation and plot-data preparation. +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/test/dimelo_test.py` + - Preserve regression coverage for existing plotter entry points where needed. + +### Task 1: Add Shared Plotting Specs And Validation + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` +- Create: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` + +- [ ] **Step 1: Write the failing tests for axis and aggregation spec validation** + +```python +from dataclasses import replace + +import pytest + +from dimelo import plotting + + +def test_axis_spec_accepts_fixed_window_region_5to3(): + spec = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=1000, + downstream_bp=1000, + ) + + plotting.validate_axis_spec(spec, plot_family="aggregate_profile") + + +def test_axis_spec_rejects_segment_map_without_segments(): + spec = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="segment_map", + segments=None, + ) + + with pytest.raises(ValueError, match="segment_map requires segments"): + plotting.validate_axis_spec(spec, plot_family="aggregate_profile") + + +def test_single_read_rejects_scaled_segments(): + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="segment_map", + segments=[ + plotting.SegmentSpec( + segment_id="body", + label="Body", + start_ref=100, + end_ref=500, + mode="scaled", + bins=50, + ) + ], + ) + + with pytest.raises(ValueError, match="single_read"): + plotting.validate_axis_spec(axis, plot_family="single_read_raster") + + +def test_aggregation_spec_accepts_equal_region_default(): + spec = plotting.AggregationSpec( + weighting="equal_region", + within_region_summary="mean", + signal_normalization="none", + layout="faceted", + ) + + plotting.validate_aggregation_spec(spec) +``` + +- [ ] **Step 2: Run the new tests to verify they fail** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -q` + +Expected: FAIL with import or attribute errors for `AxisSpec`, `SegmentSpec`, `AggregationSpec`, or validation helpers not yet existing. + +- [ ] **Step 3: Add the shared plotting spec dataclasses and validation helpers** + +```python +from dataclasses import dataclass + + +@dataclass(frozen=True) +class SegmentSpec: + segment_id: str + label: str + start_ref: int + end_ref: int + mode: str # "raw" | "scaled" + bins: int | None = None + plot_gap_after: bool = False + contiguous_with_previous: bool = True + + +@dataclass(frozen=True) +class AxisSpec: + orientation: str # "genomic" | "region_5to3" + coordinate_mode: str # "fixed_window" | "segment_map" + anchor: str | None = None + upstream_bp: int | None = None + downstream_bp: int | None = None + segments: list[SegmentSpec] | None = None + + +@dataclass(frozen=True) +class AggregationSpec: + weighting: str # "equal_region" | "equal_observation" | "coverage_weighted" + within_region_summary: str # "mean" | "fraction" | "density" + signal_normalization: str # "none" | "per_region" | "global" | "control_regions" + layout: str # "concatenated" | "faceted" + + +def validate_axis_spec(axis: AxisSpec, *, plot_family: str) -> None: + if axis.orientation not in {"genomic", "region_5to3"}: + raise ValueError("AxisSpec.orientation must be 'genomic' or 'region_5to3'.") + if axis.coordinate_mode not in {"fixed_window", "segment_map"}: + raise ValueError("AxisSpec.coordinate_mode must be 'fixed_window' or 'segment_map'.") + if axis.coordinate_mode == "segment_map" and not axis.segments: + raise ValueError("AxisSpec coordinate_mode='segment_map' requires segments.") + if plot_family == "single_read_raster" and axis.segments: + if any(segment.mode == "scaled" for segment in axis.segments): + raise ValueError( + "single_read_raster plots must preserve coordinates and cannot use scaled segments." + ) + + +def validate_aggregation_spec(spec: AggregationSpec) -> None: + if spec.weighting not in {"equal_region", "equal_observation", "coverage_weighted"}: + raise ValueError("Unsupported weighting mode.") + if spec.within_region_summary not in {"mean", "fraction", "density"}: + raise ValueError("Unsupported within_region_summary.") + if spec.signal_normalization not in {"none", "per_region", "global", "control_regions"}: + raise ValueError("Unsupported signal_normalization.") + if spec.layout not in {"concatenated", "faceted"}: + raise ValueError("Unsupported layout mode.") +``` + +- [ ] **Step 4: Run the spec-validation tests to verify they pass** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -q` + +Expected: PASS for the new validation tests. + +- [ ] **Step 5: Commit the shared plotting spec scaffolding** + +```bash +git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py +git commit -m "feat: add plotting axis spec validation" +``` + +### Task 2: Implement Fixed-Window Plot Data Prep + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` + +- [ ] **Step 1: Write failing tests for fixed-window orientation prep** + +```python +import pandas as pd + +from dimelo import plotting + + +def test_prepare_single_read_plot_data_flips_negative_regions_to_5to3(): + reads = pd.DataFrame( + [ + { + "region_id": "reg1", + "region_strand": "-", + "event_pos": 110, + "anchor": 100, + "read_id": "r1", + } + ] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="custom", + upstream_bp=20, + downstream_bp=20, + ) + + payload = plotting.prepare_single_read_plot_data( + reads, + plot_family="single_read_raster", + axis=axis, + position_column="event_pos", + anchor_column="anchor", + region_strand_column="region_strand", + ) + + assert payload["plot_table"].loc[0, "plot_x"] == -10 + + +def test_prepare_aggregate_plot_data_retains_metadata_for_fixed_window(): + table = pd.DataFrame( + [ + {"region_id": "reg1", "region_strand": "+", "event_pos": 95, "anchor": 100, "signal": 1.0}, + {"region_id": "reg1", "region_strand": "+", "event_pos": 105, "anchor": 100, "signal": 3.0}, + ] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=10, + downstream_bp=10, + ) + aggregation = plotting.AggregationSpec( + weighting="equal_region", + within_region_summary="mean", + signal_normalization="none", + layout="faceted", + ) + + payload = plotting.prepare_aggregate_plot_data( + table, + plot_family="aggregate_profile", + axis=axis, + aggregation=aggregation, + value_column="signal", + position_column="event_pos", + anchor_column="anchor", + region_strand_column="region_strand", + ) + + assert {"plot_table", "axis_table", "metadata"} <= set(payload) + assert payload["metadata"]["orientation"] == "region_5to3" +``` + +- [ ] **Step 2: Run the fixed-window tests to verify they fail** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k fixed_window -q` + +Expected: FAIL because `prepare_single_read_plot_data()` and `prepare_aggregate_plot_data()` do not yet exist. + +- [ ] **Step 3: Implement shared fixed-window prep helpers** + +```python +def _relative_position(position: float, anchor: float) -> float: + return float(position) - float(anchor) + + +def _orient_position(relative_position: float, region_strand: str, orientation: str) -> float: + if orientation == "region_5to3" and region_strand == "-": + return -relative_position + return relative_position + + +def prepare_single_read_plot_data( + table: pd.DataFrame, + *, + plot_family: str, + axis: AxisSpec, + position_column: str, + anchor_column: str, + region_strand_column: str, +) -> dict[str, pd.DataFrame | dict[str, object]]: + validate_axis_spec(axis, plot_family=plot_family) + if axis.coordinate_mode != "fixed_window": + raise ValueError("single_read_raster currently supports fixed_window only.") + + plot_table = table.copy() + plot_table["plot_x"] = plot_table.apply( + lambda row: _orient_position( + _relative_position(row[position_column], row[anchor_column]), + row[region_strand_column], + axis.orientation, + ), + axis=1, + ) + axis_table = pd.DataFrame( + [{"axis_min": -axis.upstream_bp, "axis_max": axis.downstream_bp, "segment_id": "window"}] + ) + metadata = {"plot_family": plot_family, "orientation": axis.orientation, "coordinate_mode": axis.coordinate_mode} + return {"plot_table": plot_table, "axis_table": axis_table, "metadata": metadata} + + +def prepare_aggregate_plot_data( + table: pd.DataFrame, + *, + plot_family: str, + axis: AxisSpec, + aggregation: AggregationSpec, + value_column: str, + position_column: str, + anchor_column: str, + region_strand_column: str, +) -> dict[str, pd.DataFrame | dict[str, object]]: + validate_axis_spec(axis, plot_family=plot_family) + validate_aggregation_spec(aggregation) + plot_table = table.copy() + plot_table["plot_x"] = plot_table.apply( + lambda row: _orient_position( + _relative_position(row[position_column], row[anchor_column]), + row[region_strand_column], + axis.orientation, + ), + axis=1, + ) + axis_table = pd.DataFrame( + [{"axis_min": -axis.upstream_bp, "axis_max": axis.downstream_bp, "segment_id": "window"}] + ) + metadata = { + "plot_family": plot_family, + "orientation": axis.orientation, + "coordinate_mode": axis.coordinate_mode, + "weighting": aggregation.weighting, + "within_region_summary": aggregation.within_region_summary, + } + return {"plot_table": plot_table, "axis_table": axis_table, "metadata": metadata} +``` + +- [ ] **Step 4: Run the fixed-window tests to verify they pass** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k fixed_window -q` + +Expected: PASS. + +- [ ] **Step 5: Commit the fixed-window prep slice** + +```bash +git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py +git commit -m "feat: add fixed-window plotting prep" +``` + +### Task 3: Implement Aggregate Segment-Map Prep + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` + +- [ ] **Step 1: Write failing tests for contiguous and non-contiguous aggregate segment maps** + +```python +import pandas as pd + +from dimelo import plotting + + +def test_prepare_aggregate_plot_data_builds_concatenated_segment_axis(): + table = pd.DataFrame( + [ + {"region_id": "reg1", "segment_id": "upstream", "segment_pos": 0, "signal": 1.0}, + {"region_id": "reg1", "segment_id": "body", "segment_pos": 10, "signal": 2.0}, + ] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="segment_map", + segments=[ + plotting.SegmentSpec("upstream", "Upstream", 0, 100, "raw", bins=20), + plotting.SegmentSpec("body", "Body", 100, 400, "scaled", bins=50, contiguous_with_previous=True), + ], + ) + aggregation = plotting.AggregationSpec( + weighting="equal_region", + within_region_summary="mean", + signal_normalization="none", + layout="concatenated", + ) + + payload = plotting.prepare_aggregate_plot_data( + table, + plot_family="aggregate_profile", + axis=axis, + aggregation=aggregation, + value_column="signal", + segment_id_column="segment_id", + segment_position_column="segment_pos", + ) + + assert payload["axis_table"]["segment_id"].tolist() == ["upstream", "body"] + assert payload["axis_table"]["plot_start"].is_monotonic_increasing + + +def test_prepare_aggregate_plot_data_marks_non_contiguous_segment_breaks(): + table = pd.DataFrame( + [{"region_id": "reg1", "segment_id": "exon1", "segment_pos": 5, "signal": 1.0}] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="segment_map", + segments=[ + plotting.SegmentSpec("exon1", "Exon 1", 100, 200, "scaled", bins=20), + plotting.SegmentSpec( + "exon3", + "Exon 3", + 500, + 650, + "scaled", + bins=20, + contiguous_with_previous=False, + plot_gap_after=True, + ), + ], + ) + aggregation = plotting.AggregationSpec( + weighting="equal_region", + within_region_summary="mean", + signal_normalization="none", + layout="faceted", + ) + + payload = plotting.prepare_aggregate_plot_data( + table, + plot_family="aggregate_profile", + axis=axis, + aggregation=aggregation, + value_column="signal", + segment_id_column="segment_id", + segment_position_column="segment_pos", + ) + + assert payload["axis_table"].loc[1, "contiguous_with_previous"] is False +``` + +- [ ] **Step 2: Run the segment-map tests to verify they fail** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k segment -q` + +Expected: FAIL because segment-map prep is not yet implemented. + +- [ ] **Step 3: Implement aggregate-only segment-map preparation** + +```python +def _build_segment_axis_table(segments: list[SegmentSpec]) -> pd.DataFrame: + rows = [] + running_start = 0 + for segment in segments: + span = segment.bins if segment.bins is not None else segment.end_ref - segment.start_ref + rows.append( + { + "segment_id": segment.segment_id, + "label": segment.label, + "plot_start": running_start, + "plot_end": running_start + span, + "contiguous_with_previous": segment.contiguous_with_previous, + "plot_gap_after": segment.plot_gap_after, + "mode": segment.mode, + } + ) + running_start += span + return pd.DataFrame(rows) + + +def prepare_aggregate_plot_data(..., segment_id_column: str | None = None, segment_position_column: str | None = None) -> dict[str, pd.DataFrame | dict[str, object]]: + validate_axis_spec(axis, plot_family=plot_family) + validate_aggregation_spec(aggregation) + + if axis.coordinate_mode == "segment_map": + if not axis.segments: + raise ValueError("segment_map requires segments.") + axis_table = _build_segment_axis_table(axis.segments) + if segment_id_column is None or segment_position_column is None: + raise ValueError("segment_map plotting requires segment_id_column and segment_position_column.") + plot_table = table.copy() + plot_table = plot_table.merge( + axis_table.loc[:, ["segment_id", "plot_start"]], + on="segment_id", + how="left", + ) + plot_table["plot_x"] = plot_table["plot_start"] + plot_table[segment_position_column] + metadata = { + "plot_family": plot_family, + "orientation": axis.orientation, + "coordinate_mode": axis.coordinate_mode, + "layout": aggregation.layout, + } + return {"plot_table": plot_table, "axis_table": axis_table, "metadata": metadata} +``` + +- [ ] **Step 4: Run the segment-map tests to verify they pass** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k segment -q` + +Expected: PASS. + +- [ ] **Step 5: Commit the aggregate segment-map slice** + +```bash +git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py +git commit -m "feat: add aggregate segment-map plotting prep" +``` + +### Task 4: Route One Aggregate Legacy Plotter Through The Shared Core + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plot_enrichment_profile.py` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/test/dimelo_test.py` + +- [ ] **Step 1: Write a regression test that legacy `regions_5to3prime` maps through the new axis logic** + +```python +def test_legacy_enrichment_profile_retains_regions_5to3prime_behavior(monkeypatch): + called = {} + + def fake_prepare_aggregate_plot_data(*args, **kwargs): + called["axis"] = kwargs["axis"] + return { + "plot_table": kwargs["table"].copy() if "table" in kwargs else args[0].copy(), + "axis_table": pd.DataFrame(), + "metadata": {}, + } + + monkeypatch.setattr("dimelo.plotting.prepare_aggregate_plot_data", fake_prepare_aggregate_plot_data) + # call the lowest-level trace helper with regions_5to3prime=True + # and assert the translated axis carries orientation='region_5to3' +``` + +- [ ] **Step 2: Run the regression test to verify it fails** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k enrichment_profile -q` + +Expected: FAIL because the legacy plotter does not yet call the shared prep layer. + +- [ ] **Step 3: Translate legacy aggregate plotter arguments into shared specs** + +```python +axis = plotting.AxisSpec( + orientation="region_5to3" if regions_5to3prime else "genomic", + coordinate_mode="fixed_window" if relative else "fixed_window", + anchor="center" if relative else "absolute", + upstream_bp=window_size // 2 if window_size else None, + downstream_bp=window_size // 2 if window_size else None, +) +aggregation = plotting.AggregationSpec( + weighting="equal_region", + within_region_summary="mean", + signal_normalization="none", + layout="faceted", +) +payload = plotting.prepare_aggregate_plot_data( + table=trace_table, + plot_family="aggregate_profile", + axis=axis, + aggregation=aggregation, + value_column="mod_fraction", + position_column="position", + anchor_column="center", + region_strand_column="region_strand", +) +``` + +- [ ] **Step 4: Run the aggregate wrapper tests** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k enrichment_profile -q` + +Expected: PASS. + +- [ ] **Step 5: Commit the aggregate wrapper integration** + +```bash +git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plot_enrichment_profile.py \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/test/dimelo_test.py +git commit -m "refactor: route aggregate plotter through plotting core" +``` + +### Task 5: Route One Single-Read Legacy Plotter Through The Shared Core + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plot_reads.py` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/test/dimelo_test.py` + +- [ ] **Step 1: Write a failing regression test for single-read compatibility** + +```python +def test_legacy_plot_reads_translates_regions_5to3prime_to_axis_orientation(monkeypatch): + called = {} + + def fake_prepare_single_read_plot_data(*args, **kwargs): + called["axis"] = kwargs["axis"] + return {"plot_table": pd.DataFrame(), "axis_table": pd.DataFrame(), "metadata": {}} + + monkeypatch.setattr("dimelo.plotting.prepare_single_read_plot_data", fake_prepare_single_read_plot_data) + # invoke the legacy read plotting prep/helper and assert: + # called["axis"].orientation == "region_5to3" + + +def test_prepare_single_read_plot_data_rejects_scaled_segment_axes(): + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="segment_map", + segments=[ + plotting.SegmentSpec("body", "Body", 10, 100, "scaled", bins=20) + ], + ) + with pytest.raises(ValueError, match="single_read_raster"): + plotting.prepare_single_read_plot_data( + pd.DataFrame(), + plot_family="single_read_raster", + axis=axis, + position_column="position", + anchor_column="anchor", + region_strand_column="region_strand", + ) +``` + +- [ ] **Step 2: Run the single-read tests to verify they fail** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k single_read -q` + +Expected: FAIL because the legacy single-read plotter is not yet routed through the shared prep helper. + +- [ ] **Step 3: Translate legacy single-read plot arguments into shared fixed-window prep** + +```python +axis = plotting.AxisSpec( + orientation="region_5to3" if regions_5to3prime else "genomic", + coordinate_mode="fixed_window", + anchor="center" if relative else "absolute", + upstream_bp=window_size // 2 if window_size else None, + downstream_bp=window_size // 2 if window_size else None, +) +payload = plotting.prepare_single_read_plot_data( + table=read_table, + plot_family="single_read_raster", + axis=axis, + position_column="plot_position", + anchor_column="region_center", + region_strand_column="region_strand", +) +``` + +- [ ] **Step 4: Run the single-read compatibility tests** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k single_read -q` + +Expected: PASS. + +- [ ] **Step 5: Commit the single-read wrapper integration** + +```bash +git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plot_reads.py \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/test/dimelo_test.py +git commit -m "refactor: route single-read plotter through plotting core" +``` + +### Task 6: Update User-Facing Plotting Documentation And Run Final Verification + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/shared-clustering.md` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` + +- [ ] **Step 1: Write a failing documentation-backed test for compatibility mapping if needed** + +```python +def test_plotting_core_exports_shared_specs(): + assert hasattr(plotting, "AxisSpec") + assert hasattr(plotting, "prepare_single_read_plot_data") + assert hasattr(plotting, "prepare_aggregate_plot_data") +``` + +- [ ] **Step 2: Run the focused plotting suite before doc edits** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -q` + +Expected: PASS before final docs, confirming the plotting core is stable. + +- [ ] **Step 3: Update the docs with the compatibility mapping and safe-use rules** + +```markdown +- `regions_5to3prime=True` maps to `AxisSpec(orientation="region_5to3")` +- fixed-window positional plotting is available for both aggregate and single-read views +- scaled or segmented metaregion plotting is aggregate-only +- single-read plots preserve geometry and reject continuous scaled axes +- `result.plot_data` remains the canonical renderer-neutral contract +``` + +- [ ] **Step 4: Run the branch verification slice** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_contrasts.py /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_workflows.py -q` + +Expected: PASS with no new failures. Existing non-blocking warnings are acceptable if unchanged and understood. + +- [ ] **Step 5: Commit docs and final verification state** + +```bash +git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/shared-clustering.md \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md +git commit -m "docs: add shared plotting axis guidance" +``` + +## Self-Review + +### Spec coverage + +- Shared axis and aggregation specs: covered by Task 1. +- Fixed-window prep with `region_5to3`: covered by Task 2. +- Aggregate-only segment maps, including contiguous and non-contiguous segments: covered by Task 3. +- Compatibility-safe legacy wrappers: covered by Tasks 4 and 5. +- Documentation and compatibility guidance: covered by Task 6. + +No spec sections are currently unassigned. + +### Placeholder scan + +- No `TBD` or `TODO` placeholders remain. +- Each task includes concrete file paths, test cases, commands, and commit steps. + +### Type consistency + +- `AxisSpec`, `SegmentSpec`, `AggregationSpec`, `prepare_single_read_plot_data`, and `prepare_aggregate_plot_data` are defined once and reused consistently across tasks. +- `single_read_raster` is consistently treated as coordinate-preserving. +- `segment_map` remains aggregate-enabled, with scaled segments blocked for single-read usage. diff --git a/docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md b/docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md new file mode 100644 index 0000000..b77d813 --- /dev/null +++ b/docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md @@ -0,0 +1,576 @@ +# Region Contrasts Plotting Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Add fixed-window, data-first plotting helpers for `dimelo.region_contrasts` that prepare profile and heatmap payloads from a `RegionContrastResult` plus an explicit positional source table. + +**Architecture:** Extend [plotting.py](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py) with a small internal join/validation layer for contrast results and positional source tables, then expose two public helpers: one for aggregate profiles and one for heatmaps. Keep `region_contrasts` unchanged; plotting prep consumes existing `RegionContrastResult` tables and parse/load-derived positional summaries, uses the shared `AxisSpec` / `AggregationSpec` fixed-window path, and returns renderer-neutral payloads. + +**Tech Stack:** Python 3.11, pandas, pytest, existing `dimelo.plotting` shared axis helpers, existing `RegionContrastResult` models + +--- + +## File Structure + +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` + - Add internal helpers for validating/joining `RegionContrastResult` against a positional source table. + - Add `prepare_region_contrast_profile_data(...)`. + - Add `prepare_region_contrast_heatmap_data(...)`. +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` + - Add regression tests for the new plot-prep helpers. + - Cover both numerator/denominator/delta payload generation and failure modes. +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md` + - Document the new helper APIs and the required `position_table` contract. +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` + - Add a short compatibility note pointing users from `region_contrasts` into the new plotting helpers. + +### Task 1: Add minimal failing tests for contrast-to-position joins + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` +- Reference: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/models.py` +- Reference: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` + +- [ ] **Step 1: Write the failing tests for a minimal profile payload** + +Add these tests near the other plotting helper tests in `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py`: + +```python +from dimelo.models import ContrastSpec, RegionContrastResult + + +def _minimal_region_contrast_result() -> RegionContrastResult: + regions = pd.DataFrame( + [ + {"region_id": "chr1:90-110,+", "condition": "NS", "fraction": 0.20, "rank": 2}, + {"region_id": "chr1:90-110,+", "condition": "15min", "fraction": 0.55, "rank": 2}, + {"region_id": "chr1:190-210,-", "condition": "NS", "fraction": 0.30, "rank": 1}, + {"region_id": "chr1:190-210,-", "condition": "15min", "fraction": 0.70, "rank": 1}, + ] + ) + summary = pd.DataFrame( + [ + { + "region_id": "chr1:90-110,+", + "fraction": 0.55, + "reference_fraction": 0.20, + "delta_fraction": 0.35, + "rank": 2, + }, + { + "region_id": "chr1:190-210,-", + "fraction": 0.70, + "reference_fraction": 0.30, + "delta_fraction": 0.40, + "rank": 1, + }, + ] + ) + return RegionContrastResult( + regions=regions, + summary=summary, + contrast=ContrastSpec( + mode="pairwise", + numerator=["15min"], + denominator=["NS"], + reference_condition="NS", + ), + metadata={ + "analysis_unit": "ensemble_region", + "representation": "modified_fraction", + "signal_source": "pileup_counts", + "test": "effect_size_only", + }, + plot_data={}, + ) + + +def test_prepare_region_contrast_profile_data_returns_all_value_modes(): + result = _minimal_region_contrast_result() + position_table = pd.DataFrame( + [ + {"region_id": "chr1:90-110,+", "condition": "NS", "position": 95, "anchor": 100, "value": 0.1, "region_strand": "+"}, + {"region_id": "chr1:90-110,+", "condition": "15min", "position": 95, "anchor": 100, "value": 0.6, "region_strand": "+"}, + {"region_id": "chr1:190-210,-", "condition": "NS", "position": 205, "anchor": 200, "value": 0.2, "region_strand": "-"}, + {"region_id": "chr1:190-210,-", "condition": "15min", "position": 205, "anchor": 200, "value": 0.8, "region_strand": "-"}, + ] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=20, + downstream_bp=20, + ) + aggregation = plotting.AggregationSpec() + + payload = plotting.prepare_region_contrast_profile_data( + result=result, + position_table=position_table, + axis=axis, + aggregation=aggregation, + value_mode="all", + ) + + assert set(payload["plot_table"]["value_mode"]) == {"numerator", "denominator", "delta"} + assert payload["metadata"]["plot_family"] == "region_contrast_profile" +``` + +- [ ] **Step 2: Add the failing heatmap and validation tests** + +Append these tests in the same file: + +```python +def test_prepare_region_contrast_heatmap_data_orders_rows_by_rank(): + result = _minimal_region_contrast_result() + position_table = pd.DataFrame( + [ + {"region_id": "chr1:90-110,+", "condition": "NS", "position": 95, "anchor": 100, "value": 0.1, "region_strand": "+"}, + {"region_id": "chr1:90-110,+", "condition": "15min", "position": 95, "anchor": 100, "value": 0.6, "region_strand": "+"}, + {"region_id": "chr1:190-210,-", "condition": "NS", "position": 205, "anchor": 200, "value": 0.2, "region_strand": "-"}, + {"region_id": "chr1:190-210,-", "condition": "15min", "position": 205, "anchor": 200, "value": 0.8, "region_strand": "-"}, + ] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=20, + downstream_bp=20, + ) + aggregation = plotting.AggregationSpec() + + payload = plotting.prepare_region_contrast_heatmap_data( + result=result, + position_table=position_table, + axis=axis, + aggregation=aggregation, + value_mode="all", + ) + + rank_rows = payload["plot_table"].loc[:, ["region_id", "row_order"]].drop_duplicates() + assert list(rank_rows.sort_values("row_order")["region_id"]) == [ + "chr1:190-210,-", + "chr1:90-110,+", + ] + assert payload["metadata"]["plot_family"] == "region_contrast_heatmap" + + +def test_prepare_region_contrast_profile_data_requires_joinable_grouping_key(): + result = _minimal_region_contrast_result() + position_table = pd.DataFrame( + [ + {"region_id": "chr1:90-110,+", "position": 95, "anchor": 100, "value": 0.1, "region_strand": "+"} + ] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=20, + downstream_bp=20, + ) + aggregation = plotting.AggregationSpec() + + with pytest.raises(ValueError, match="sample_id or condition"): + plotting.prepare_region_contrast_profile_data( + result=result, + position_table=position_table, + axis=axis, + aggregation=aggregation, + value_mode="all", + ) +``` + +- [ ] **Step 3: Run the new tests to verify they fail** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k "region_contrast_profile_data or region_contrast_heatmap_data" -q +``` + +Expected: FAIL with `AttributeError` or `NameError` because the new plotting helpers do not exist yet. + +- [ ] **Step 4: Commit the failing-test scaffold** + +```bash +git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py +git commit -m "test: add region contrast plotting coverage" +``` + +### Task 2: Implement shared join and normalization helpers + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` +- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` + +- [ ] **Step 1: Add a contrast-result metadata reader and join-key validator** + +Insert small internal helpers in `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` below the existing validation helpers: + +```python +def _region_contrast_grouping_key(result, position_table: pd.DataFrame) -> str: + available = [column for column in ("sample_id", "condition") if column in position_table.columns] + if not available: + raise ValueError( + "region contrast plotting requires position_table to include sample_id or condition." + ) + if "condition" in available: + return "condition" + return "sample_id" + + +def _region_contrast_metadata(result) -> dict[str, object]: + return { + "analysis_unit": result.metadata.get("analysis_unit"), + "representation": result.metadata.get("representation"), + "signal_source": result.metadata.get("signal_source"), + "test": result.metadata.get("test"), + } +``` + +- [ ] **Step 2: Add a helper that validates and filters a positional source table** + +Add this helper in the same file: + +```python +def _prepare_region_contrast_position_table( + *, + result, + position_table: pd.DataFrame, + grouping_key: str, +) -> pd.DataFrame: + _require_columns( + position_table, + ("region_id", grouping_key, "position", "value", "region_strand"), + "position_table", + ) + filtered = position_table[position_table["region_id"].isin(result.summary["region_id"])].copy() + if filtered.empty: + raise ValueError("position_table does not contain any region_id values present in the contrast result.") + return filtered.reset_index(drop=True) +``` + +- [ ] **Step 3: Add a side-merging helper for numerator, denominator, and delta** + +Add this helper in the same file: + +```python +def _prepare_region_contrast_value_modes( + *, + result, + position_table: pd.DataFrame, + grouping_key: str, +) -> pd.DataFrame: + contrast = result.contrast + numerator_mask = position_table[grouping_key].isin(contrast.numerator or []) + denominator_mask = position_table[grouping_key].isin(contrast.denominator or []) + + numerator = position_table.loc[numerator_mask].copy() + denominator = position_table.loc[denominator_mask].copy() + if numerator.empty or denominator.empty: + raise ValueError("position_table does not contain rows for both contrast sides.") + + numerator["value_mode"] = "numerator" + denominator["value_mode"] = "denominator" + + delta = numerator.merge( + denominator, + on=["region_id", "position", "region_strand"], + suffixes=("_numerator", "_denominator"), + how="inner", + ) + if delta.empty: + raise ValueError("Unable to compute delta because numerator and denominator positions do not align.") + + delta = delta.rename( + columns={ + "position": "position", + "region_strand": "region_strand", + } + ) + delta["value"] = delta["value_numerator"] - delta["value_denominator"] + delta[grouping_key] = "delta" + delta["value_mode"] = "delta" + delta = delta.loc[:, ["region_id", grouping_key, "position", "value", "region_strand"]] + + return pd.concat( + [ + numerator.loc[:, ["region_id", grouping_key, "position", "value", "region_strand", "value_mode"]], + denominator.loc[:, ["region_id", grouping_key, "position", "value", "region_strand", "value_mode"]], + delta, + ], + ignore_index=True, + ) +``` + +- [ ] **Step 4: Run the targeted tests to verify the join layer works** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k "region_contrast_profile_data_requires_joinable_grouping_key" -q +``` + +Expected: PASS for the validation test, while the helper-existence tests still fail. + +- [ ] **Step 5: Commit the join/validation layer** + +```bash +git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py +git commit -m "feat: add region contrast plotting join helpers" +``` + +### Task 3: Implement `prepare_region_contrast_profile_data(...)` + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` +- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` + +- [ ] **Step 1: Add the public helper using the shared fixed-window prep** + +Add this function in `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` near the other public plotting helpers: + +```python +def prepare_region_contrast_profile_data( + *, + result, + position_table: pd.DataFrame, + axis: AxisSpec, + aggregation: AggregationSpec, + value_mode: str = "all", +) -> dict[str, pd.DataFrame | dict[str, object]]: + validate_axis_spec(axis, plot_family="aggregate_profile") + validate_aggregation_spec(aggregation) + grouping_key = _region_contrast_grouping_key(result, position_table) + filtered = _prepare_region_contrast_position_table( + result=result, + position_table=position_table, + grouping_key=grouping_key, + ) + valued = _prepare_region_contrast_value_modes( + result=result, + position_table=filtered, + grouping_key=grouping_key, + ) + if value_mode != "all": + valued = valued.loc[valued["value_mode"] == value_mode].copy() + + valued["anchor"] = valued["position"] + prepared = prepare_aggregate_plot_data( + valued, + plot_family="aggregate_profile", + axis=axis, + aggregation=aggregation, + value_column="value", + position_column="position", + anchor_column="anchor", + region_strand_column="region_strand", + ) + prepared["metadata"] = { + **prepared["metadata"], + **_region_contrast_metadata(result), + "plot_family": "region_contrast_profile", + "value_modes": sorted(valued["value_mode"].unique()), + } + prepared["summary_table"] = ( + prepared["plot_table"] + .groupby(["value_mode", "plot_x"], as_index=False)["value"] + .mean() + ) + return prepared +``` + +- [ ] **Step 2: Fix the anchor handling so the profile prep uses the real fixed-window contract** + +Replace the temporary `valued["anchor"] = valued["position"]` line with: + +```python +_require_columns(filtered, ("anchor",), "position_table") +valued = valued.merge( + filtered.loc[:, ["region_id", grouping_key, "position", "anchor"]].drop_duplicates(), + on=["region_id", grouping_key, "position"], + how="left", +) +``` + +This keeps the helper aligned with the actual fixed-window substrate instead of collapsing all `plot_x` values to zero. + +- [ ] **Step 3: Run the targeted profile tests** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k "prepare_region_contrast_profile_data" -q +``` + +Expected: PASS for the profile tests. + +- [ ] **Step 4: Commit the profile helper** + +```bash +git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py +git commit -m "feat: add region contrast profile plotting prep" +``` + +### Task 4: Implement `prepare_region_contrast_heatmap_data(...)` + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` +- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` + +- [ ] **Step 1: Add the heatmap helper on top of the same substrate** + +Add this function in `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py`: + +```python +def prepare_region_contrast_heatmap_data( + *, + result, + position_table: pd.DataFrame, + axis: AxisSpec, + aggregation: AggregationSpec, + value_mode: str = "all", +) -> dict[str, pd.DataFrame | dict[str, object]]: + profile_payload = prepare_region_contrast_profile_data( + result=result, + position_table=position_table, + axis=axis, + aggregation=aggregation, + value_mode=value_mode, + ) + rank_lookup = ( + result.summary.loc[:, ["region_id", "rank"]] + .drop_duplicates() + .sort_values(["rank", "region_id"], kind="stable") + .reset_index(drop=True) + ) + rank_lookup["row_order"] = range(len(rank_lookup)) + plot_table = profile_payload["plot_table"].merge(rank_lookup, on="region_id", how="left") + profile_payload["plot_table"] = plot_table + profile_payload["metadata"] = { + **profile_payload["metadata"], + "plot_family": "region_contrast_heatmap", + } + profile_payload["summary_table"] = rank_lookup + return profile_payload +``` + +- [ ] **Step 2: Add a failure-mode test for missing contrast-side rows** + +Extend `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` with: + +```python +def test_prepare_region_contrast_heatmap_data_requires_both_contrast_sides(): + result = _minimal_region_contrast_result() + position_table = pd.DataFrame( + [ + {"region_id": "chr1:90-110,+", "condition": "NS", "position": 95, "anchor": 100, "value": 0.1, "region_strand": "+"} + ] + ) + axis = plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=20, + downstream_bp=20, + ) + aggregation = plotting.AggregationSpec() + + with pytest.raises(ValueError, match="both contrast sides"): + plotting.prepare_region_contrast_heatmap_data( + result=result, + position_table=position_table, + axis=axis, + aggregation=aggregation, + value_mode="all", + ) +``` + +- [ ] **Step 3: Run the full plotting suite** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -q +``` + +Expected: PASS, including the new heatmap coverage. + +- [ ] **Step 4: Commit the heatmap helper** + +```bash +git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py +git commit -m "feat: add region contrast heatmap plotting prep" +``` + +### Task 5: Document the new plotting helpers and verify the slice + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` +- Verify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` +- Verify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_contrasts.py` +- Verify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_workflows.py` + +- [ ] **Step 1: Add a region-contrasts plotting example** + +Append a short section to `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md`: + +```python +profile_payload = plotting.prepare_region_contrast_profile_data( + result=result, + position_table=position_table, + axis=plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=2000, + downstream_bp=2000, + ), + aggregation=plotting.AggregationSpec(), + value_mode="all", +) +``` + +Add one sentence clarifying that `position_table` must already be an aggregated positional substrate from the parsing/loading layer. + +- [ ] **Step 2: Add a short README compatibility note** + +Add one short paragraph to `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` under the plotting section explaining: + +```text +Newer region-contrast plotting helpers accept a RegionContrastResult plus an explicit position_table from the parsing/loading layer. This keeps region scoring and positional extraction separate while still using the shared plotting-axis system. +``` + +- [ ] **Step 3: Run the final verification set** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_contrasts.py /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_workflows.py -q +``` + +Expected: PASS. If warnings appear, note them in the summary only if they are new or blocking. + +- [ ] **Step 4: Commit the docs and final verification slice** + +```bash +git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md /Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py +git commit -m "docs: add region contrast plotting guide" +``` + +## Self-Review + +- Spec coverage: + - public helpers: Task 3 and Task 4 + - explicit `position_table`: Task 1 and Task 2 + - numerator/denominator/delta payloads: Task 2 and Task 3 + - fixed-window aggregate-only scope: Task 3 and Task 4 + - compatibility/docs: Task 5 +- Placeholder scan: + - no `TODO`, `TBD`, or deferred implementation steps are left in the task bodies +- Type consistency: + - `prepare_region_contrast_profile_data(...)` and `prepare_region_contrast_heatmap_data(...)` are used consistently across tests, code steps, and docs + diff --git a/docs/superpowers/plans/2026-04-01-region-discovery-cluster-workflow.md b/docs/superpowers/plans/2026-04-01-region-discovery-cluster-workflow.md new file mode 100644 index 0000000..7c8590d --- /dev/null +++ b/docs/superpowers/plans/2026-04-01-region-discovery-cluster-workflow.md @@ -0,0 +1,270 @@ +# Region Discovery To Cluster Workflow Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Add one end-to-end workflow that runs region discovery, selects discovered loci, clusters those loci with the shared clustering engine, and returns both the discovery and clustering results. + +**Architecture:** Build a thin orchestration layer in `dimelo.workflows` that composes the existing `dimelo.region_discovery.scan_genome(...)` and `dimelo.workflows.shared_cluster_distribution(...)` entry points. Keep the result data-first by introducing a small wrapper model that stores both outputs plus the exact discovered-region subset passed into clustering. + +**Tech Stack:** Python dataclasses, pandas, existing dimelo pileup/extract workflows, pytest + +--- + +### Task 1: Add The Combined Result Model + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/models.py` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/__init__.py` +- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_models.py` + +- [ ] **Step 1: Write the failing tests** + +```python +def test_region_discovery_cluster_result_requires_non_none_values(): + with pytest.raises(ValueError, match="discovery"): + RegionDiscoveryClusterResult( + discovery=None, + clustering=_dummy_shared_cluster_result(), + selected_regions=pd.DataFrame(), + metadata={}, + ) + + +def test_region_discovery_cluster_result_accepts_valid_payloads(): + result = RegionDiscoveryClusterResult( + discovery=_dummy_region_discovery_result(), + clustering=_dummy_shared_cluster_result(), + selected_regions=pd.DataFrame([{"chromosome": "chr1", "start": 0, "end": 100}]), + metadata={"selection_mode": "top_n"}, + ) + assert list(result.selected_regions.columns) == ["chromosome", "start", "end"] +``` + +- [ ] **Step 2: Run tests to verify they fail** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_models.py -q` +Expected: FAIL with `NameError` or import errors for `RegionDiscoveryClusterResult` + +- [ ] **Step 3: Write the minimal model implementation** + +```python +@dataclass +class RegionDiscoveryClusterResult: + discovery: RegionDiscoveryResult + clustering: SharedClusterResult + selected_regions: pd.DataFrame + metadata: dict[str, Any] = field(default_factory=dict) + figures: dict[str, Any] = field(default_factory=dict) + + def __post_init__(self) -> None: + required_fields = { + "discovery": self.discovery, + "clustering": self.clustering, + "selected_regions": self.selected_regions, + "metadata": self.metadata, + "figures": self.figures, + } + missing = [name for name, value in required_fields.items() if value is None] + if missing: + raise ValueError( + "RegionDiscoveryClusterResult requires non-None values for: " + f"{', '.join(missing)}" + ) +``` + +- [ ] **Step 4: Export the model** + +```python +from .models import ( + ... + RegionDiscoveryClusterResult, +) +``` + +- [ ] **Step 5: Run tests to verify they pass** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_models.py -q` +Expected: PASS + +- [ ] **Step 6: Commit** + +```bash +git add dimelo/models.py dimelo/__init__.py tests/test_models.py +git commit -m "feat: add discovery to cluster workflow result model" +``` + +### Task 2: Implement The Discovery To Cluster Workflow + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/workflows.py` +- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_workflows.py` + +- [ ] **Step 1: Write the failing workflow tests** + +```python +def test_region_discovery_cluster_workflow_returns_both_results(monkeypatch): + monkeypatch.setattr(region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) + + result = workflows.discovery_cluster_workflow( + samples=_workflow_samples(), + motifs=["A,0"], + genome_sizes={"chr1": 1000}, + discovery={"window_size": 500, "step_size": 500}, + clustering={"mode": "region_anchored", "n_clusters": 2}, + ) + + assert result.discovery.hits.shape[0] == 2 + assert result.clustering.model.mode == "region_anchored" + assert list(result.selected_regions.columns) == ["chromosome", "start", "end", "name", "score", "strand"] + + +def test_region_discovery_cluster_workflow_selects_top_n_hits(monkeypatch): + ... + result = workflows.discovery_cluster_workflow( + ..., + selection={"mode": "top_n", "top_n": 1}, + ) + assert result.selected_regions["name"].tolist() == ["chr1:0-500"] +``` + +- [ ] **Step 2: Run the targeted tests to verify they fail** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_workflows.py -q` +Expected: FAIL with missing `discovery_cluster_workflow` + +- [ ] **Step 3: Implement selection helpers and the orchestration entry point** + +```python +def _select_discovery_hits( + discovery: RegionDiscoveryResult, + *, + selection_mode: str, + top_n: int | None, + score_threshold: float | None, + adjusted_p_value_max: float | None, +) -> pd.DataFrame: + hits = discovery.hits.copy() + ... + return region_discovery.hits_to_bed(selected_hits) + + +def discovery_cluster_workflow( + *, + samples: Iterable[SampleSpec], + motifs: Iterable[str], + genome_sizes: dict[str, int], + discovery: dict[str, Any], + clustering: dict[str, Any], + selection: dict[str, Any] | None = None, +) -> RegionDiscoveryClusterResult: + discovery_result = region_discovery.scan_genome(...) + selected_regions = _select_discovery_hits(...) + region_spec = _selected_regions_to_region_spec(selected_regions) + clustering_result = shared_cluster_distribution( + samples=samples, + motifs=motifs, + matched_regions=region_spec, + **clustering, + ) + return RegionDiscoveryClusterResult( + discovery=discovery_result, + clustering=clustering_result, + selected_regions=selected_regions, + metadata={...}, + ) +``` + +- [ ] **Step 4: Cover error handling in tests** + +```python +def test_region_discovery_cluster_workflow_errors_when_no_hits_survive_selection(monkeypatch): + ... + with pytest.raises(ValueError, match="No discovery hits remained after selection"): + workflows.discovery_cluster_workflow(...) + + +def test_region_discovery_cluster_workflow_rejects_unknown_selection_mode(monkeypatch): + ... + with pytest.raises(ValueError, match="Unsupported selection mode"): + workflows.discovery_cluster_workflow(...) +``` + +- [ ] **Step 5: Run targeted workflow tests** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_workflows.py -q` +Expected: PASS + +- [ ] **Step 6: Commit** + +```bash +git add dimelo/workflows.py tests/test_workflows.py +git commit -m "feat: add discovery to cluster workflow" +``` + +### Task 3: Document And Verify The Integrated User Flow + +**Files:** +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-discovery.md` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/shared-clustering.md` +- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` +- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_workflows.py` + +- [ ] **Step 1: Add one integration test that uses real discovery hit rows as the clustering region input** + +```python +def test_region_discovery_cluster_workflow_passes_selected_regions_into_clustering(monkeypatch): + captured = {} + ... + def _fake_cluster(**kwargs): + captured["matched_regions"] = kwargs["matched_regions"] + return _mock_cluster_result(**kwargs) + + monkeypatch.setattr(workflows, "shared_cluster_distribution", _fake_cluster) + result = workflows.discovery_cluster_workflow(...) + + assert captured["matched_regions"] == ["chr1:0-500,+", "chr1:500-1000,-"] + assert result.selected_regions["name"].tolist() == ["chr1:0-500", "chr1:500-1000"] +``` + +- [ ] **Step 2: Document the default behavior** + +```markdown +from dimelo import workflows + +result = workflows.discovery_cluster_workflow( + samples=samples, + motifs=["A,0"], + genome_sizes={"chr1": 248956422}, + discovery={"window_size": 2000, "step_size": 500, "score": "beta_binomial", "contrast": contrast}, + clustering={"mode": "region_anchored", "n_clusters": 6}, + selection={"mode": "top_n", "top_n": 250}, +) +``` + +Explain: +- `discovery` config is passed to `scan_genome(...)` +- `selection` defaults to top-ranked hits +- `clustering` config is passed to `shared_cluster_distribution(...)` +- the workflow returns the BED-style `selected_regions` table, but passes a serializable region-spec derived from that table into `matched_regions` +- the result keeps `discovery`, `selected_regions`, and `clustering` together + +- [ ] **Step 3: Run the full verification slice** + +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_models.py tests/test_region_discovery.py tests/test_workflows.py -q` +Expected: PASS + +- [ ] **Step 4: Commit** + +```bash +git add docs/region-discovery.md docs/shared-clustering.md README.md tests/test_workflows.py +git commit -m "docs: add discovery to cluster workflow guide" +``` + +--- + +## Self-Review + +- Spec coverage: this plan adds the combined return type, the orchestration workflow, selection policy, error handling, and the user-facing docs for the one-call discovery-to-cluster path. +- Placeholder scan: every task names exact files, targeted tests, and concrete implementation points; there are no TODO placeholders. +- Type consistency: `RegionDiscoveryClusterResult`, `discovery_cluster_workflow`, and `selected_regions` are used consistently across tasks. diff --git a/docs/superpowers/plans/2026-04-02-superpowers-docs-cleanup.md b/docs/superpowers/plans/2026-04-02-superpowers-docs-cleanup.md new file mode 100644 index 0000000..3073c68 --- /dev/null +++ b/docs/superpowers/plans/2026-04-02-superpowers-docs-cleanup.md @@ -0,0 +1,236 @@ +# Superpowers Docs Cleanup Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Track the existing internal plan docs in git and add a central `docs/superpowers` index that maps specs and plans to their current implementation status. + +**Architecture:** Keep the existing `docs/superpowers/specs` and `docs/superpowers/plans` directories unchanged, then add one central [README.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md) that explains the layout, groups the existing work by theme, and labels status centrally. This is a docs-only cleanup slice; it should not rewrite historical spec/plan content or touch runtime code. + +**Tech Stack:** Markdown docs, git, existing `docs/superpowers/specs` and `docs/superpowers/plans` content + +--- + +## File Structure + +- Create: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md` + - Central index for specs, plans, themes, and status labels. +- Stage existing untracked files under `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/` + - No content edits required unless a broken filename/path is discovered. +- Verify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/` +- Verify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/` + +### Task 1: Create the central `docs/superpowers` index + +**Files:** +- Create: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md` +- Reference: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-04-02-superpowers-docs-cleanup-design.md` +- Reference: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/` +- Reference: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/` + +- [ ] **Step 1: Write the new index file** + +Create `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md` with this exact starter structure: + +```md +# Superpowers Docs Index + +This directory tracks internal design and implementation work for the current branch. + +- `specs/` contains design documents. +- `plans/` contains executable implementation breakdowns. +- Status is tracked here centrally so historical docs can remain stable snapshots. + +## Status Labels + +- `implemented`: the planned slice has landed in the repo. +- `partially implemented`: some related work has landed, but the broader feature family still has follow-on work. +- `planned`: the design exists, but the slice is not yet implemented. +- `not started`: a plan exists, but execution has not started. + +## Specs + +## Plans + +## Current Themes +``` + +- [ ] **Step 2: Fill the `Specs` section with grouped entries** + +Populate `## Specs` with grouped bullets for: + +- shared clustering +- region analysis +- plotting +- cleanup/docs + +Use this style: + +```md +### Shared Clustering + +- [2026-03-31-shared-cluster-distribution-design.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md) - shared-boundary clustering architecture and artifact model. Status: `partially implemented` +``` + +Include at least these specs: + +- `2026-03-31-shared-cluster-distribution-design.md` +- `2026-03-31-region-analysis-architecture-design.md` +- `2026-03-31-pre-plan-decisions-addendum.md` +- `2026-04-01-paired-region-discovery-design.md` +- `2026-04-01-plotting-axis-architecture-design.md` +- `2026-04-01-region-contrasts-plotting-design.md` +- `2026-04-02-superpowers-docs-cleanup-design.md` + +- [ ] **Step 3: Fill the `Plans` section with grouped entries** + +Populate `## Plans` with grouped bullets for all current plan files in `docs/superpowers/plans/`, using this style: + +```md +### Plotting + +- [2026-04-01-plotting-axis-architecture.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-plotting-axis-architecture.md) - shared plotting-axis implementation slice. Status: `implemented` +``` + +List all current plan files: + +- `2026-03-31-global-analysis-foundations.md` +- `2026-03-31-region-contrasts-foundations.md` +- `2026-03-31-region-discovery-foundations.md` +- `2026-03-31-shared-clustering-foundations.md` +- `2026-04-01-cluster-occupancy-region-contrasts.md` +- `2026-04-01-discovery-cluster-contrast-workflow.md` +- `2026-04-01-paired-region-discovery.md` +- `2026-04-01-plotting-axis-architecture.md` +- `2026-04-01-region-contrasts-plotting.md` +- `2026-04-01-region-discovery-cluster-workflow.md` +- `2026-04-02-superpowers-docs-cleanup.md` + +- [ ] **Step 4: Fill the `Current Themes` section** + +Add a short theme map that points readers to the most relevant spec/plan chains, for example: + +```md +## Current Themes + +- Shared clustering: start with the shared clustering design spec, then the foundations plan. +- Region contrasts: start with the region analysis architecture spec, then the contrasts foundations plan and the region-contrasts plotting plan. +- Region discovery: use the region analysis architecture spec, the paired discovery spec, and the discovery workflow plans together. +- Plotting: start with the plotting-axis spec, then the plotting-axis implementation plan and the region-contrasts plotting plan. +``` + +- [ ] **Step 5: Commit the new index** + +```bash +git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md +git commit -m "docs: add superpowers docs index" +``` + +### Task 2: Stage and track the existing untracked plan files + +**Files:** +- Stage: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-global-analysis-foundations.md` +- Stage: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-region-contrasts-foundations.md` +- Stage: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-region-discovery-foundations.md` +- Stage: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-cluster-occupancy-region-contrasts.md` +- Stage: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-discovery-cluster-contrast-workflow.md` +- Stage: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-paired-region-discovery.md` +- Stage: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-plotting-axis-architecture.md` +- Stage: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md` +- Stage: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-region-discovery-cluster-workflow.md` + +- [ ] **Step 1: Confirm the currently untracked plan set** + +Run: + +```bash +git status --short /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans +``` + +Expected: the plan files above appear as untracked (`??`). + +- [ ] **Step 2: Stage the plan files without editing them** + +Run: + +```bash +git add \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-global-analysis-foundations.md \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-region-contrasts-foundations.md \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-region-discovery-foundations.md \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-cluster-occupancy-region-contrasts.md \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-discovery-cluster-contrast-workflow.md \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-paired-region-discovery.md \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-plotting-axis-architecture.md \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-region-discovery-cluster-workflow.md \ + /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-02-superpowers-docs-cleanup.md +``` + +- [ ] **Step 3: Commit the tracked plan artifacts** + +```bash +git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans +git commit -m "docs: track superpowers implementation plans" +``` + +### Task 3: Verify the index and status map against the repo + +**Files:** +- Verify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md` +- Verify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/` +- Verify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/` + +- [ ] **Step 1: Check that every linked file in the index exists** + +Run: + +```bash +rg -o '/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/[^)]+' /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md +``` + +Then verify those paths exist with: + +```bash +test -f /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md +``` + +Expected: every file referenced by the index exists on disk. + +- [ ] **Step 2: Check that the plans are no longer untracked** + +Run: + +```bash +git status --short /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers +``` + +Expected: no `??` entries remain for the tracked plan docs. + +- [ ] **Step 3: Review status labels for obvious misstatements** + +Manually confirm the index does not mark unfinished families as fully complete. In particular: + +- plotting should reflect that the axis core and region-contrast plotting slices are implemented +- region discovery should remain `partially implemented` if follow-on contrast modes or plotting slices still remain +- global analysis should remain `partially implemented` unless the family is truly complete + +- [ ] **Step 4: Commit any index corrections from verification** + +```bash +git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md +git commit -m "docs: verify superpowers docs status index" +``` + +If no corrections were needed, skip this commit. + +## Self-Review + +- Spec coverage: + - central index: Task 1 + - tracking untracked plans: Task 2 + - central status map and verification: Task 3 +- Placeholder scan: + - no `TODO`, `TBD`, or deferred implementation text remains in the task steps +- Type consistency: + - all referenced paths use the existing `docs/superpowers/specs` and `docs/superpowers/plans` layout + From 98e761f1fb77c5971cc30376c9ad6fe3dd671a8a Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 10:50:44 -0700 Subject: [PATCH 129/272] docs: verify superpowers docs status index --- docs/superpowers/README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/superpowers/README.md b/docs/superpowers/README.md index 7377803..1878851 100644 --- a/docs/superpowers/README.md +++ b/docs/superpowers/README.md @@ -32,7 +32,7 @@ This directory tracks internal design and implementation work for the current br ### Cleanup And Docs -- [2026-04-02-superpowers-docs-cleanup-design.md](specs/2026-04-02-superpowers-docs-cleanup-design.md) - central index and status-map cleanup for internal planning docs. Status: `partially implemented` +- [2026-04-02-superpowers-docs-cleanup-design.md](specs/2026-04-02-superpowers-docs-cleanup-design.md) - central index and status-map cleanup for internal planning docs. Status: `implemented` ## Plans @@ -42,7 +42,7 @@ This directory tracks internal design and implementation work for the current br ### Region Analysis -- [2026-03-31-global-analysis-foundations.md](plans/2026-03-31-global-analysis-foundations.md) - global analysis models, workflows, and artifact plumbing. Status: `implemented` +- [2026-03-31-global-analysis-foundations.md](plans/2026-03-31-global-analysis-foundations.md) - global analysis models, workflows, and artifact plumbing. Status: `partially implemented` - [2026-03-31-region-contrasts-foundations.md](plans/2026-03-31-region-contrasts-foundations.md) - defined-region contrast foundations and scoring paths. Status: `implemented` - [2026-04-01-cluster-occupancy-region-contrasts.md](plans/2026-04-01-cluster-occupancy-region-contrasts.md) - cluster-occupancy evidence and scoring for region contrasts. Status: `implemented` @@ -60,7 +60,7 @@ This directory tracks internal design and implementation work for the current br ### Cleanup And Docs -- [2026-04-02-superpowers-docs-cleanup.md](plans/2026-04-02-superpowers-docs-cleanup.md) - central docs index and tracked-plan cleanup. Status: `partially implemented` +- [2026-04-02-superpowers-docs-cleanup.md](plans/2026-04-02-superpowers-docs-cleanup.md) - central docs index and tracked-plan cleanup. Status: `implemented` ## Current Themes From f349516dcd8c2b9bf5b8c7b8bf71277ecf6961d7 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 10:54:08 -0700 Subject: [PATCH 130/272] docs: add docs integration cleanup spec --- ...-02-docs-and-integration-cleanup-design.md | 164 ++++++++++++++++++ 1 file changed, 164 insertions(+) create mode 100644 docs/superpowers/specs/2026-04-02-docs-and-integration-cleanup-design.md diff --git a/docs/superpowers/specs/2026-04-02-docs-and-integration-cleanup-design.md b/docs/superpowers/specs/2026-04-02-docs-and-integration-cleanup-design.md new file mode 100644 index 0000000..2954052 --- /dev/null +++ b/docs/superpowers/specs/2026-04-02-docs-and-integration-cleanup-design.md @@ -0,0 +1,164 @@ +# Docs And Integration Cleanup Design + +## Purpose + +This design defines the next cleanup slice after the `docs/superpowers` index work. + +The goal is to bundle: + +- historical docs path portability cleanup +- targeted codebase integration cleanup around the recently implemented analysis and plotting work + +This is still a cleanup slice, not a feature-building slice. It should improve clarity, portability, and discoverability of work that already landed. + +## Core Direction + +Cleanup should be docs-led. + +The order is: + +1. normalize historical docs so they are portable in the repository +2. perform a narrow integration cleanup around the completed code/docs surface + +This keeps the cleanup low-risk and prevents it from turning into an unfocused refactor. + +## Scope + +This bundled cleanup should include two phases. + +### Phase A: Historical docs normalization + +Normalize machine-specific path leakage in tracked historical docs under: + +- `docs/superpowers/specs/` +- `docs/superpowers/plans/` + +This means: + +- replace machine-local absolute paths with repo-relative or plain repo paths where appropriate +- preserve the original meaning of the documents +- avoid changing the substantive design or implementation content + +This phase is about portability and maintainability of the internal planning trail, not rewriting history. + +### Phase B: Codebase integration cleanup + +Perform a targeted cleanup around the already-implemented analysis and plotting work. + +This should focus on: + +- public surface discoverability +- docs cross-linking +- lightweight consistency fixes around recently added helpers + +It should not introduce new analysis features or broader architecture changes. + +## Out Of Scope + +This cleanup slice should not: + +- redesign existing features +- add new analysis workflows +- rename large parts of the codebase for style reasons alone +- refactor internals that are not causing integration friction +- rewrite historical docs for prose polish beyond what is needed for path portability + +## Phase A Design: Historical Docs Portability + +The tracked historical plan/spec docs currently contain many machine-local absolute paths. + +That is acceptable during active execution, but once the docs are committed as repo artifacts they should be portable enough to read in: + +- GitHub +- local clones on other machines +- future branches + +### Recommended path policy + +For historical docs: + +- use repo-relative markdown links where links are useful +- use plain repo-relative paths in code blocks and command examples when a clickable link is not needed +- avoid machine-local absolute paths unless a document explicitly needs to show an environment-specific example + +### Editing rule + +This phase should make the smallest possible content changes: + +- path normalization only +- no semantic rewrites unless a path reference becomes misleading when converted + +## Phase B Design: Integration Cleanup + +The codebase side should prioritize discoverability over internal churn. + +### Primary targets + +1. public surface and discoverability + - ensure docs point users to the new helpers and workflows clearly + - ensure exports/import surfaces are coherent where users would reasonably expect them + - ensure recent helper behavior is described accurately in the main documentation trail + +2. lightweight consistency cleanup + - only when needed to reduce confusion around completed work + - examples: small naming inconsistencies, stale references, or thin integration gaps across docs/tests + +### Not the focus + +This is not the pass for: + +- broad internal refactors +- large module reorganizations +- cleanup motivated only by aesthetic preference + +## Recommended Files To Inspect + +The implementation plan should likely touch or inspect: + +- `docs/superpowers/specs/` +- `docs/superpowers/plans/` +- [README.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md) +- [docs/region-contrasts.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md) +- [docs/shared-clustering.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/shared-clustering.md) +- [docs/region-discovery.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-discovery.md) +- [docs/global-analysis.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/global-analysis.md) +- [dimelo/__init__.py](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/__init__.py) +- [dimelo/plotting.py](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py) + +The implementation plan does not need to modify all of them. This list exists to constrain where the integration cleanup should look. + +## Status / Navigation Interaction + +The new central index in `docs/superpowers/README.md` should remain the status source of truth. + +This cleanup may update it if: + +- normalized paths require link fixes +- status wording needs correction after integration cleanup + +But it should not replace the central-index model introduced in the prior cleanup slice. + +## Verification + +The implementation plan should include two kinds of verification. + +### Docs verification + +- no remaining machine-local absolute paths in tracked `docs/superpowers` historical docs, unless intentionally preserved +- no broken links introduced by normalization +- no remaining untracked plan/spec artifacts related to this cleanup + +### Code/docs integration verification + +- any touched docs reference real current helpers/workflows +- any touched exports or helper references resolve in the repo +- if tests are touched, run the relevant focused test subset + +## Recommended Build Order + +1. Normalize path references in tracked `docs/superpowers/specs` and `docs/superpowers/plans`. +2. Verify no broken relative links were introduced. +3. Inspect the public docs surface for stale or missing integration points around completed work. +4. Apply only the smallest integration cleanup needed for discoverability and consistency. +5. Re-verify docs references and any touched code/test surfaces. + From 84e1d01d2a647de218444fac80b1789411492930 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 11:00:47 -0700 Subject: [PATCH 131/272] docs: normalize superpowers doc paths --- ...4-01-cluster-occupancy-region-contrasts.md | 16 +- ...-01-discovery-cluster-contrast-workflow.md | 20 +- .../2026-04-01-paired-region-discovery.md | 26 +- .../2026-04-01-plotting-axis-architecture.md | 104 ++++---- .../2026-04-01-region-contrasts-plotting.md | 72 ++--- ...04-01-region-discovery-cluster-workflow.md | 18 +- ...2026-04-02-docs-and-integration-cleanup.md | 252 ++++++++++++++++++ .../2026-04-02-superpowers-docs-cleanup.md | 82 +++--- ...04-01-plotting-axis-architecture-design.md | 8 +- ...-04-01-region-contrasts-plotting-design.md | 4 +- ...-02-docs-and-integration-cleanup-design.md | 14 +- ...6-04-02-superpowers-docs-cleanup-design.md | 2 +- 12 files changed, 435 insertions(+), 183 deletions(-) create mode 100644 docs/superpowers/plans/2026-04-02-docs-and-integration-cleanup.md diff --git a/docs/superpowers/plans/2026-04-01-cluster-occupancy-region-contrasts.md b/docs/superpowers/plans/2026-04-01-cluster-occupancy-region-contrasts.md index 23c947b..7f89c20 100644 --- a/docs/superpowers/plans/2026-04-01-cluster-occupancy-region-contrasts.md +++ b/docs/superpowers/plans/2026-04-01-cluster-occupancy-region-contrasts.md @@ -13,8 +13,8 @@ ### Task 1: Extend Validation And Occupancy Evidence Builders **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/region_contrasts.py` -- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_contrasts.py` +- Modify: `dimelo/region_contrasts.py` +- Test: `tests/test_region_contrasts.py` - [ ] **Step 1: Write the failing validation and evidence-table tests** @@ -112,8 +112,8 @@ git commit -m "feat: add cluster occupancy contrast evidence builders" ### Task 2: Add Sample-Level Occupancy Scoring **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/region_contrasts.py` -- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_contrasts.py` +- Modify: `dimelo/region_contrasts.py` +- Test: `tests/test_region_contrasts.py` - [ ] **Step 1: Write the failing scoring tests** @@ -232,10 +232,10 @@ git commit -m "feat: add cluster occupancy region scoring" ### Task 3: Document Occupancy Contrasts And Verify The Slice **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/shared-clustering.md` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` -- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_contrasts.py` +- Modify: `docs/region-contrasts.md` +- Modify: `docs/shared-clustering.md` +- Modify: `README.md` +- Test: `tests/test_region_contrasts.py` - [ ] **Step 1: Add one occupancy-driven example** diff --git a/docs/superpowers/plans/2026-04-01-discovery-cluster-contrast-workflow.md b/docs/superpowers/plans/2026-04-01-discovery-cluster-contrast-workflow.md index cf32528..1cba180 100644 --- a/docs/superpowers/plans/2026-04-01-discovery-cluster-contrast-workflow.md +++ b/docs/superpowers/plans/2026-04-01-discovery-cluster-contrast-workflow.md @@ -13,9 +13,9 @@ ### Task 1: Add The Combined Result Model **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/models.py` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/__init__.py` -- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_models.py` +- Modify: `dimelo/models.py` +- Modify: `dimelo/__init__.py` +- Test: `tests/test_models.py` - [ ] **Step 1: Write the failing model tests** @@ -125,8 +125,8 @@ git commit -m "feat: add discovery cluster contrast result" ### Task 2: Add The End-To-End Workflow **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/workflows.py` -- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_workflows.py` +- Modify: `dimelo/workflows.py` +- Test: `tests/test_workflows.py` - [ ] **Step 1: Write the failing workflow tests** @@ -276,11 +276,11 @@ git commit -m "feat: add discovery cluster contrast workflow" ### Task 3: Document The New Handoff And Run The Broader Slice **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-discovery.md` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/shared-clustering.md` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` -- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_workflows.py` +- Modify: `docs/region-contrasts.md` +- Modify: `docs/region-discovery.md` +- Modify: `docs/shared-clustering.md` +- Modify: `README.md` +- Test: `tests/test_workflows.py` - [ ] **Step 1: Add one end-to-end doc example** diff --git a/docs/superpowers/plans/2026-04-01-paired-region-discovery.md b/docs/superpowers/plans/2026-04-01-paired-region-discovery.md index faaf81f..a73cb23 100644 --- a/docs/superpowers/plans/2026-04-01-paired-region-discovery.md +++ b/docs/superpowers/plans/2026-04-01-paired-region-discovery.md @@ -12,13 +12,13 @@ ## File Map -- `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/region_discovery.py` +- `dimelo/region_discovery.py` Add pairing-resolution helpers, paired-window table helpers, `matched_pairwise` scoring, paired `time_course` scoring, and paired metadata emission. -- `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_discovery.py` +- `tests/test_region_discovery.py` Add regression tests for complete-pair filtering, strict missing-pair errors, paired ranking columns, paired metadata, time-order validation, and downstream handoff. -- `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-discovery.md` +- `docs/region-discovery.md` Document when to use pooled discovery vs paired discovery, required sample metadata, and paired examples. -- `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` +- `README.md` Update the discovery guide link text to mention paired discovery support. Scope note: @@ -31,8 +31,8 @@ Scope note: ### Task 1: Add Pair Resolution And Paired-Window Helpers **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/region_discovery.py` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_discovery.py` +- Modify: `dimelo/region_discovery.py` +- Modify: `tests/test_region_discovery.py` - [ ] **Step 1: Write the failing tests** @@ -175,8 +175,8 @@ git commit -m "feat: add paired region discovery pair resolution" ### Task 2: Add `matched_pairwise` Scoring And Paired Metadata **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/region_discovery.py` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_discovery.py` +- Modify: `dimelo/region_discovery.py` +- Modify: `tests/test_region_discovery.py` - [ ] **Step 1: Write the failing tests** @@ -337,8 +337,8 @@ git commit -m "feat: add matched pairwise region discovery scoring" ### Task 3: Add Paired Ordered `time_course` Discovery **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/region_discovery.py` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_discovery.py` +- Modify: `dimelo/region_discovery.py` +- Modify: `tests/test_region_discovery.py` - [ ] **Step 1: Write the failing tests** @@ -466,9 +466,9 @@ git commit -m "feat: add paired time-course region discovery" ### Task 4: Add Downstream Handoff Coverage And User Docs **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_discovery.py` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-discovery.md` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` +- Modify: `tests/test_region_discovery.py` +- Modify: `docs/region-discovery.md` +- Modify: `README.md` - [ ] **Step 1: Write the failing tests** diff --git a/docs/superpowers/plans/2026-04-01-plotting-axis-architecture.md b/docs/superpowers/plans/2026-04-01-plotting-axis-architecture.md index feac139..750dd1e 100644 --- a/docs/superpowers/plans/2026-04-01-plotting-axis-architecture.md +++ b/docs/superpowers/plans/2026-04-01-plotting-axis-architecture.md @@ -12,28 +12,28 @@ ## File Map -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` +- Modify: `dimelo/plotting.py` - Add shared plotting spec dataclasses, validation, and plot-data prep helpers. -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plot_enrichment_profile.py` +- Modify: `dimelo/plot_enrichment_profile.py` - Route one aggregate legacy plotter through the shared plotting core without changing public defaults. -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plot_reads.py` +- Modify: `dimelo/plot_reads.py` - Route one single-read legacy plotter through the shared plotting core without allowing scaled continuous axes. -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md` +- Modify: `docs/region-contrasts.md` - Document aggregate positional plotting semantics and compatibility notes. -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/shared-clustering.md` +- Modify: `docs/shared-clustering.md` - Document how the shared plotting layer applies to workflow `plot_data`. -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` +- Modify: `README.md` - Add compatibility mapping between old plotting flags and new axis concepts. -- Create: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` +- Create: `tests/test_plotting.py` - Add focused tests for spec validation and plot-data preparation. -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/test/dimelo_test.py` +- Modify: `dimelo/test/dimelo_test.py` - Preserve regression coverage for existing plotter entry points where needed. ### Task 1: Add Shared Plotting Specs And Validation **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` -- Create: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` +- Modify: `dimelo/plotting.py` +- Create: `tests/test_plotting.py` - [ ] **Step 1: Write the failing tests for axis and aggregation spec validation** @@ -101,7 +101,7 @@ def test_aggregation_spec_accepts_equal_region_default(): - [ ] **Step 2: Run the new tests to verify they fail** -Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -q` +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -q` Expected: FAIL with import or attribute errors for `AxisSpec`, `SegmentSpec`, `AggregationSpec`, or validation helpers not yet existing. @@ -168,23 +168,23 @@ def validate_aggregation_spec(spec: AggregationSpec) -> None: - [ ] **Step 4: Run the spec-validation tests to verify they pass** -Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -q` +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -q` Expected: PASS for the new validation tests. - [ ] **Step 5: Commit the shared plotting spec scaffolding** ```bash -git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py +git add dimelo/plotting.py \ + tests/test_plotting.py git commit -m "feat: add plotting axis spec validation" ``` ### Task 2: Implement Fixed-Window Plot Data Prep **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` +- Modify: `dimelo/plotting.py` +- Modify: `tests/test_plotting.py` - [ ] **Step 1: Write failing tests for fixed-window orientation prep** @@ -264,7 +264,7 @@ def test_prepare_aggregate_plot_data_retains_metadata_for_fixed_window(): - [ ] **Step 2: Run the fixed-window tests to verify they fail** -Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k fixed_window -q` +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k fixed_window -q` Expected: FAIL because `prepare_single_read_plot_data()` and `prepare_aggregate_plot_data()` do not yet exist. @@ -347,23 +347,23 @@ def prepare_aggregate_plot_data( - [ ] **Step 4: Run the fixed-window tests to verify they pass** -Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k fixed_window -q` +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k fixed_window -q` Expected: PASS. - [ ] **Step 5: Commit the fixed-window prep slice** ```bash -git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py +git add dimelo/plotting.py \ + tests/test_plotting.py git commit -m "feat: add fixed-window plotting prep" ``` ### Task 3: Implement Aggregate Segment-Map Prep **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` +- Modify: `dimelo/plotting.py` +- Modify: `tests/test_plotting.py` - [ ] **Step 1: Write failing tests for contiguous and non-contiguous aggregate segment maps** @@ -452,7 +452,7 @@ def test_prepare_aggregate_plot_data_marks_non_contiguous_segment_breaks(): - [ ] **Step 2: Run the segment-map tests to verify they fail** -Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k segment -q` +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k segment -q` Expected: FAIL because segment-map prep is not yet implemented. @@ -507,24 +507,24 @@ def prepare_aggregate_plot_data(..., segment_id_column: str | None = None, segme - [ ] **Step 4: Run the segment-map tests to verify they pass** -Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k segment -q` +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k segment -q` Expected: PASS. - [ ] **Step 5: Commit the aggregate segment-map slice** ```bash -git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py +git add dimelo/plotting.py \ + tests/test_plotting.py git commit -m "feat: add aggregate segment-map plotting prep" ``` ### Task 4: Route One Aggregate Legacy Plotter Through The Shared Core **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plot_enrichment_profile.py` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/test/dimelo_test.py` +- Modify: `dimelo/plot_enrichment_profile.py` +- Modify: `tests/test_plotting.py` +- Modify: `dimelo/test/dimelo_test.py` - [ ] **Step 1: Write a regression test that legacy `regions_5to3prime` maps through the new axis logic** @@ -547,7 +547,7 @@ def test_legacy_enrichment_profile_retains_regions_5to3prime_behavior(monkeypatc - [ ] **Step 2: Run the regression test to verify it fails** -Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k enrichment_profile -q` +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k enrichment_profile -q` Expected: FAIL because the legacy plotter does not yet call the shared prep layer. @@ -581,25 +581,25 @@ payload = plotting.prepare_aggregate_plot_data( - [ ] **Step 4: Run the aggregate wrapper tests** -Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k enrichment_profile -q` +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k enrichment_profile -q` Expected: PASS. - [ ] **Step 5: Commit the aggregate wrapper integration** ```bash -git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plot_enrichment_profile.py \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/test/dimelo_test.py +git add dimelo/plot_enrichment_profile.py \ + tests/test_plotting.py \ + dimelo/test/dimelo_test.py git commit -m "refactor: route aggregate plotter through plotting core" ``` ### Task 5: Route One Single-Read Legacy Plotter Through The Shared Core **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plot_reads.py` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/test/dimelo_test.py` +- Modify: `dimelo/plot_reads.py` +- Modify: `tests/test_plotting.py` +- Modify: `dimelo/test/dimelo_test.py` - [ ] **Step 1: Write a failing regression test for single-read compatibility** @@ -637,7 +637,7 @@ def test_prepare_single_read_plot_data_rejects_scaled_segment_axes(): - [ ] **Step 2: Run the single-read tests to verify they fail** -Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k single_read -q` +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k single_read -q` Expected: FAIL because the legacy single-read plotter is not yet routed through the shared prep helper. @@ -663,26 +663,26 @@ payload = plotting.prepare_single_read_plot_data( - [ ] **Step 4: Run the single-read compatibility tests** -Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k single_read -q` +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k single_read -q` Expected: PASS. - [ ] **Step 5: Commit the single-read wrapper integration** ```bash -git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plot_reads.py \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/test/dimelo_test.py +git add dimelo/plot_reads.py \ + tests/test_plotting.py \ + dimelo/test/dimelo_test.py git commit -m "refactor: route single-read plotter through plotting core" ``` ### Task 6: Update User-Facing Plotting Documentation And Run Final Verification **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/shared-clustering.md` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` +- Modify: `docs/region-contrasts.md` +- Modify: `docs/shared-clustering.md` +- Modify: `README.md` +- Modify: `tests/test_plotting.py` - [ ] **Step 1: Write a failing documentation-backed test for compatibility mapping if needed** @@ -695,7 +695,7 @@ def test_plotting_core_exports_shared_specs(): - [ ] **Step 2: Run the focused plotting suite before doc edits** -Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -q` +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -q` Expected: PASS before final docs, confirming the plotting core is stable. @@ -711,17 +711,17 @@ Expected: PASS before final docs, confirming the plotting core is stable. - [ ] **Step 4: Run the branch verification slice** -Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_contrasts.py /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_workflows.py -q` +Run: `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py tests/test_region_contrasts.py tests/test_workflows.py -q` Expected: PASS with no new failures. Existing non-blocking warnings are acceptable if unchanged and understood. - [ ] **Step 5: Commit docs and final verification state** ```bash -git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/shared-clustering.md \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md +git add tests/test_plotting.py \ + docs/region-contrasts.md \ + docs/shared-clustering.md \ + README.md git commit -m "docs: add shared plotting axis guidance" ``` diff --git a/docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md b/docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md index b77d813..7239768 100644 --- a/docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md +++ b/docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md @@ -4,7 +4,7 @@ **Goal:** Add fixed-window, data-first plotting helpers for `dimelo.region_contrasts` that prepare profile and heatmap payloads from a `RegionContrastResult` plus an explicit positional source table. -**Architecture:** Extend [plotting.py](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py) with a small internal join/validation layer for contrast results and positional source tables, then expose two public helpers: one for aggregate profiles and one for heatmaps. Keep `region_contrasts` unchanged; plotting prep consumes existing `RegionContrastResult` tables and parse/load-derived positional summaries, uses the shared `AxisSpec` / `AggregationSpec` fixed-window path, and returns renderer-neutral payloads. +**Architecture:** Extend [plotting.py](../../../dimelo/plotting.py) with a small internal join/validation layer for contrast results and positional source tables, then expose two public helpers: one for aggregate profiles and one for heatmaps. Keep `region_contrasts` unchanged; plotting prep consumes existing `RegionContrastResult` tables and parse/load-derived positional summaries, uses the shared `AxisSpec` / `AggregationSpec` fixed-window path, and returns renderer-neutral payloads. **Tech Stack:** Python 3.11, pandas, pytest, existing `dimelo.plotting` shared axis helpers, existing `RegionContrastResult` models @@ -12,28 +12,28 @@ ## File Structure -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` +- Modify: `dimelo/plotting.py` - Add internal helpers for validating/joining `RegionContrastResult` against a positional source table. - Add `prepare_region_contrast_profile_data(...)`. - Add `prepare_region_contrast_heatmap_data(...)`. -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` +- Modify: `tests/test_plotting.py` - Add regression tests for the new plot-prep helpers. - Cover both numerator/denominator/delta payload generation and failure modes. -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md` +- Modify: `docs/region-contrasts.md` - Document the new helper APIs and the required `position_table` contract. -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` +- Modify: `README.md` - Add a short compatibility note pointing users from `region_contrasts` into the new plotting helpers. ### Task 1: Add minimal failing tests for contrast-to-position joins **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` -- Reference: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/models.py` -- Reference: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` +- Modify: `tests/test_plotting.py` +- Reference: `dimelo/models.py` +- Reference: `dimelo/plotting.py` - [ ] **Step 1: Write the failing tests for a minimal profile payload** -Add these tests near the other plotting helper tests in `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py`: +Add these tests near the other plotting helper tests in `tests/test_plotting.py`: ```python from dimelo.models import ContrastSpec, RegionContrastResult @@ -187,7 +187,7 @@ def test_prepare_region_contrast_profile_data_requires_joinable_grouping_key(): Run: ```bash -MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k "region_contrast_profile_data or region_contrast_heatmap_data" -q +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "region_contrast_profile_data or region_contrast_heatmap_data" -q ``` Expected: FAIL with `AttributeError` or `NameError` because the new plotting helpers do not exist yet. @@ -195,19 +195,19 @@ Expected: FAIL with `AttributeError` or `NameError` because the new plotting hel - [ ] **Step 4: Commit the failing-test scaffold** ```bash -git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py +git add tests/test_plotting.py git commit -m "test: add region contrast plotting coverage" ``` ### Task 2: Implement shared join and normalization helpers **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` -- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` +- Modify: `dimelo/plotting.py` +- Test: `tests/test_plotting.py` - [ ] **Step 1: Add a contrast-result metadata reader and join-key validator** -Insert small internal helpers in `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` below the existing validation helpers: +Insert small internal helpers in `dimelo/plotting.py` below the existing validation helpers: ```python def _region_contrast_grouping_key(result, position_table: pd.DataFrame) -> str: @@ -310,7 +310,7 @@ def _prepare_region_contrast_value_modes( Run: ```bash -MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k "region_contrast_profile_data_requires_joinable_grouping_key" -q +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "region_contrast_profile_data_requires_joinable_grouping_key" -q ``` Expected: PASS for the validation test, while the helper-existence tests still fail. @@ -318,19 +318,19 @@ Expected: PASS for the validation test, while the helper-existence tests still f - [ ] **Step 5: Commit the join/validation layer** ```bash -git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py +git add dimelo/plotting.py tests/test_plotting.py git commit -m "feat: add region contrast plotting join helpers" ``` ### Task 3: Implement `prepare_region_contrast_profile_data(...)` **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` -- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` +- Modify: `dimelo/plotting.py` +- Test: `tests/test_plotting.py` - [ ] **Step 1: Add the public helper using the shared fixed-window prep** -Add this function in `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` near the other public plotting helpers: +Add this function in `dimelo/plotting.py` near the other public plotting helpers: ```python def prepare_region_contrast_profile_data( @@ -402,7 +402,7 @@ This keeps the helper aligned with the actual fixed-window substrate instead of Run: ```bash -MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -k "prepare_region_contrast_profile_data" -q +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "prepare_region_contrast_profile_data" -q ``` Expected: PASS for the profile tests. @@ -410,19 +410,19 @@ Expected: PASS for the profile tests. - [ ] **Step 4: Commit the profile helper** ```bash -git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py +git add dimelo/plotting.py tests/test_plotting.py git commit -m "feat: add region contrast profile plotting prep" ``` ### Task 4: Implement `prepare_region_contrast_heatmap_data(...)` **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py` -- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` +- Modify: `dimelo/plotting.py` +- Test: `tests/test_plotting.py` - [ ] **Step 1: Add the heatmap helper on top of the same substrate** -Add this function in `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py`: +Add this function in `dimelo/plotting.py`: ```python def prepare_region_contrast_heatmap_data( @@ -459,7 +459,7 @@ def prepare_region_contrast_heatmap_data( - [ ] **Step 2: Add a failure-mode test for missing contrast-side rows** -Extend `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` with: +Extend `tests/test_plotting.py` with: ```python def test_prepare_region_contrast_heatmap_data_requires_both_contrast_sides(): @@ -493,7 +493,7 @@ def test_prepare_region_contrast_heatmap_data_requires_both_contrast_sides(): Run: ```bash -MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py -q +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -q ``` Expected: PASS, including the new heatmap coverage. @@ -501,22 +501,22 @@ Expected: PASS, including the new heatmap coverage. - [ ] **Step 4: Commit the heatmap helper** ```bash -git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py +git add dimelo/plotting.py tests/test_plotting.py git commit -m "feat: add region contrast heatmap plotting prep" ``` ### Task 5: Document the new plotting helpers and verify the slice **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` -- Verify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py` -- Verify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_contrasts.py` -- Verify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_workflows.py` +- Modify: `docs/region-contrasts.md` +- Modify: `README.md` +- Verify: `tests/test_plotting.py` +- Verify: `tests/test_region_contrasts.py` +- Verify: `tests/test_workflows.py` - [ ] **Step 1: Add a region-contrasts plotting example** -Append a short section to `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md`: +Append a short section to `docs/region-contrasts.md`: ```python profile_payload = plotting.prepare_region_contrast_profile_data( @@ -538,7 +538,7 @@ Add one sentence clarifying that `position_table` must already be an aggregated - [ ] **Step 2: Add a short README compatibility note** -Add one short paragraph to `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` under the plotting section explaining: +Add one short paragraph to `README.md` under the plotting section explaining: ```text Newer region-contrast plotting helpers accept a RegionContrastResult plus an explicit position_table from the parsing/loading layer. This keeps region scoring and positional extraction separate while still using the shared plotting-axis system. @@ -549,7 +549,7 @@ Newer region-contrast plotting helpers accept a RegionContrastResult plus an exp Run: ```bash -MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_region_contrasts.py /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_workflows.py -q +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py tests/test_region_contrasts.py tests/test_workflows.py -q ``` Expected: PASS. If warnings appear, note them in the summary only if they are new or blocking. @@ -557,7 +557,7 @@ Expected: PASS. If warnings appear, note them in the summary only if they are ne - [ ] **Step 4: Commit the docs and final verification slice** ```bash -git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md /Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py /Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_plotting.py +git add docs/region-contrasts.md README.md dimelo/plotting.py tests/test_plotting.py git commit -m "docs: add region contrast plotting guide" ``` diff --git a/docs/superpowers/plans/2026-04-01-region-discovery-cluster-workflow.md b/docs/superpowers/plans/2026-04-01-region-discovery-cluster-workflow.md index 7c8590d..ac02050 100644 --- a/docs/superpowers/plans/2026-04-01-region-discovery-cluster-workflow.md +++ b/docs/superpowers/plans/2026-04-01-region-discovery-cluster-workflow.md @@ -13,9 +13,9 @@ ### Task 1: Add The Combined Result Model **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/models.py` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/__init__.py` -- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_models.py` +- Modify: `dimelo/models.py` +- Modify: `dimelo/__init__.py` +- Test: `tests/test_models.py` - [ ] **Step 1: Write the failing tests** @@ -96,8 +96,8 @@ git commit -m "feat: add discovery to cluster workflow result model" ### Task 2: Implement The Discovery To Cluster Workflow **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/workflows.py` -- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_workflows.py` +- Modify: `dimelo/workflows.py` +- Test: `tests/test_workflows.py` - [ ] **Step 1: Write the failing workflow tests** @@ -205,10 +205,10 @@ git commit -m "feat: add discovery to cluster workflow" ### Task 3: Document And Verify The Integrated User Flow **Files:** -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-discovery.md` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/shared-clustering.md` -- Modify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md` -- Test: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/tests/test_workflows.py` +- Modify: `docs/region-discovery.md` +- Modify: `docs/shared-clustering.md` +- Modify: `README.md` +- Test: `tests/test_workflows.py` - [ ] **Step 1: Add one integration test that uses real discovery hit rows as the clustering region input** diff --git a/docs/superpowers/plans/2026-04-02-docs-and-integration-cleanup.md b/docs/superpowers/plans/2026-04-02-docs-and-integration-cleanup.md new file mode 100644 index 0000000..a080fa5 --- /dev/null +++ b/docs/superpowers/plans/2026-04-02-docs-and-integration-cleanup.md @@ -0,0 +1,252 @@ +# Docs And Integration Cleanup Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Normalize machine-specific paths in tracked historical `docs/superpowers` docs, then perform a narrow discoverability-focused integration cleanup around the already-implemented analysis and plotting work. + +**Architecture:** Execute this cleanup in two phases. Phase A normalizes tracked spec/plan docs so they are portable in the repo without changing their meaning. Phase B applies only the smallest public-surface cleanup needed to make the recently completed work easier to find and understand. The central status source of truth remains [docs/superpowers/README.md](../README.md). + +**Tech Stack:** Markdown docs, existing repo documentation, lightweight Python/package surface inspection where needed + +--- + +## File Structure + +- Modify: `docs/superpowers/specs/` + - Normalize machine-local path references to repo-relative or plain repo paths. +- Modify: `docs/superpowers/plans/` + - Normalize machine-local path references to repo-relative or plain repo paths. +- Modify: `docs/superpowers/README.md` + - Only if link/status corrections are needed after normalization. +- Modify if needed for integration cleanup: + - `README.md` + - `docs/region-contrasts.md` + - `docs/shared-clustering.md` + - `docs/region-discovery.md` + - `docs/global-analysis.md` + - `dimelo/__init__.py` + +### Task 1: Normalize machine-specific paths in tracked `docs/superpowers` docs + +**Files:** +- Modify: `docs/superpowers/specs/*.md` +- Modify: `docs/superpowers/plans/*.md` + +- [ ] **Step 1: Inventory the remaining machine-local path references** + +Run: + +```bash +rg -n "/Users/[^/]+/Documents/GitHub/dimelo-toolkit" docs/superpowers/specs docs/superpowers/plans +``` + +Expected: a list of tracked historical docs that still contain machine-local absolute paths. + +- [ ] **Step 2: Normalize Markdown links to repo-relative links** + +For Markdown links inside tracked superpowers docs, convert forms like: + +```md +[plotting.py](../../../dimelo/plotting.py) +``` + +to: + +```md +[plotting.py](../../../dimelo/plotting.py) +``` + +or the correct relative form from the document location. + +- [ ] **Step 3: Normalize plain path mentions and command snippets** + +For plain path references or shell commands inside tracked superpowers docs, replace machine-local prefixes with repo-relative or repo-root-style paths. For example: + +```text +docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md +``` + +becomes: + +```text +docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md +``` + +Do this conservatively: preserve the original meaning and command intent, only remove machine-specific leakage. + +- [ ] **Step 4: Run a second grep to confirm the path leak is gone** + +Run: + +```bash +rg -n "/Users/[^/]+/Documents/GitHub/dimelo-toolkit" docs/superpowers/specs docs/superpowers/plans +``` + +Expected: no output, unless an intentionally preserved example remains and is documented in the final summary. + +- [ ] **Step 5: Commit the normalization pass** + +```bash +git add docs/superpowers/specs docs/superpowers/plans +git commit -m "docs: normalize superpowers doc paths" +``` + +### Task 2: Verify and repair `docs/superpowers` navigation after normalization + +**Files:** +- Modify if needed: `docs/superpowers/README.md` +- Verify: `docs/superpowers/specs/` +- Verify: `docs/superpowers/plans/` + +- [ ] **Step 1: Verify the central index links still resolve** + +Run: + +```bash +for f in $(rg -o "\\((specs|plans)/[^)]+" docs/superpowers/README.md | tr -d "("); do test -f "docs/superpowers/$f" || echo "MISSING $f"; done +``` + +Expected: no output. + +- [ ] **Step 2: Fix any broken links or stale status wording in the index** + +If the verification step reports missing links or if the normalization changed path conventions enough to make the README confusing, update `docs/superpowers/README.md` minimally. + +Keep edits narrow: + +- link correction +- wording clarification +- status correction if a recent implementation slice is now clearly misclassified + +- [ ] **Step 3: Verify the `docs/superpowers` tree is fully tracked** + +Run: + +```bash +git status --short docs/superpowers +``` + +Expected: no `??` entries remain under `docs/superpowers`. + +- [ ] **Step 4: Commit the index repair pass if needed** + +```bash +git add docs/superpowers/README.md +git commit -m "docs: refresh superpowers index links" +``` + +If no README changes were needed, skip this commit. + +### Task 3: Apply narrow discoverability-focused integration cleanup + +**Files:** +- Inspect: `README.md` +- Inspect: `docs/region-contrasts.md` +- Inspect: `docs/shared-clustering.md` +- Inspect: `docs/region-discovery.md` +- Inspect: `docs/global-analysis.md` +- Inspect: `dimelo/__init__.py` +- Modify only if needed: the minimum subset of the above + +- [ ] **Step 1: Inventory obvious discoverability gaps around completed work** + +Check for: + +- recently added helpers/workflows not mentioned where users would look +- stale references to “later” work that is now implemented +- missing package exports for helpers users reasonably expect to import directly + +Run these focused inspections: + +```bash +rg -n "prepare_region_contrast_profile_data|prepare_region_contrast_heatmap_data|global_analysis|region_discovery|shared_cluster_distribution" README.md docs/*.md dimelo/__init__.py +``` + +- [ ] **Step 2: Apply only the minimum integration cleanup needed** + +Examples of acceptable changes: + +- add one missing cross-link in `README.md` +- fix stale wording in an analysis guide +- expose an already-implemented helper in `dimelo/__init__.py` if that is an obvious user-facing expectation + +Examples of disallowed changes: + +- broad module refactors +- new plotting features +- renaming stable APIs for style alone + +- [ ] **Step 3: Verify touched docs or exports** + +If only docs changed, run: + +```bash +rg -n "prepare_region_contrast_profile_data|prepare_region_contrast_heatmap_data|shared_cluster_distribution|global_analysis|region_discovery" README.md docs/*.md +``` + +If `dimelo/__init__.py` changed, also run: + +```bash +python3.11 - <<'PY' +import dimelo +print("dimelo import ok") +PY +``` + +Expected: docs references resolve sensibly, and `dimelo` still imports if exports changed. + +- [ ] **Step 4: Commit the integration cleanup** + +```bash +git add README.md docs dimelo/__init__.py +git commit -m "docs: tighten analysis discoverability" +``` + +Only include files actually changed. + +### Task 4: Final verification and cleanup summary + +**Files:** +- Verify: `docs/superpowers/` +- Verify any files touched in Task 3 + +- [ ] **Step 1: Confirm no machine-local path leaks remain in tracked superpowers docs** + +Run: + +```bash +rg -n "/Users/[^/]+/Documents/GitHub/dimelo-toolkit" docs/superpowers/specs docs/superpowers/plans docs/superpowers/README.md +``` + +Expected: no output unless an intentional exception is documented. + +- [ ] **Step 2: Confirm the working tree is clean** + +Run: + +```bash +git status --short +``` + +Expected: no unexpected modified/untracked files remain from this cleanup slice. + +- [ ] **Step 3: Commit any final small verification-driven fix** + +```bash +git add -A +git commit -m "docs: finalize cleanup verification" +``` + +Only do this if verification required one last small correction. Otherwise skip. + +## Self-Review + +- Spec coverage: + - historical path portability: Task 1 + - index/navigation verification: Task 2 + - public-surface discoverability cleanup: Task 3 + - final verification: Task 4 +- Placeholder scan: + - no `TODO`, `TBD`, or “fix later” steps remain +- Type consistency: + - all path references use the current `docs/superpowers` layout and the current repo root diff --git a/docs/superpowers/plans/2026-04-02-superpowers-docs-cleanup.md b/docs/superpowers/plans/2026-04-02-superpowers-docs-cleanup.md index 3073c68..bca3385 100644 --- a/docs/superpowers/plans/2026-04-02-superpowers-docs-cleanup.md +++ b/docs/superpowers/plans/2026-04-02-superpowers-docs-cleanup.md @@ -4,7 +4,7 @@ **Goal:** Track the existing internal plan docs in git and add a central `docs/superpowers` index that maps specs and plans to their current implementation status. -**Architecture:** Keep the existing `docs/superpowers/specs` and `docs/superpowers/plans` directories unchanged, then add one central [README.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md) that explains the layout, groups the existing work by theme, and labels status centrally. This is a docs-only cleanup slice; it should not rewrite historical spec/plan content or touch runtime code. +**Architecture:** Keep the existing `docs/superpowers/specs` and `docs/superpowers/plans` directories unchanged, then add one central [README.md](../README.md) that explains the layout, groups the existing work by theme, and labels status centrally. This is a docs-only cleanup slice; it should not rewrite historical spec/plan content or touch runtime code. **Tech Stack:** Markdown docs, git, existing `docs/superpowers/specs` and `docs/superpowers/plans` content @@ -12,24 +12,24 @@ ## File Structure -- Create: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md` +- Create: `docs/superpowers/README.md` - Central index for specs, plans, themes, and status labels. -- Stage existing untracked files under `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/` +- Stage existing untracked files under `docs/superpowers/plans/` - No content edits required unless a broken filename/path is discovered. -- Verify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/` -- Verify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/` +- Verify: `docs/superpowers/specs/` +- Verify: `docs/superpowers/plans/` ### Task 1: Create the central `docs/superpowers` index **Files:** -- Create: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md` -- Reference: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-04-02-superpowers-docs-cleanup-design.md` -- Reference: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/` -- Reference: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/` +- Create: `docs/superpowers/README.md` +- Reference: `docs/superpowers/specs/2026-04-02-superpowers-docs-cleanup-design.md` +- Reference: `docs/superpowers/specs/` +- Reference: `docs/superpowers/plans/` - [ ] **Step 1: Write the new index file** -Create `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md` with this exact starter structure: +Create `docs/superpowers/README.md` with this exact starter structure: ```md # Superpowers Docs Index @@ -68,7 +68,7 @@ Use this style: ```md ### Shared Clustering -- [2026-03-31-shared-cluster-distribution-design.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-03-31-shared-cluster-distribution-design.md) - shared-boundary clustering architecture and artifact model. Status: `partially implemented` +- [2026-03-31-shared-cluster-distribution-design.md](../specs/2026-03-31-shared-cluster-distribution-design.md) - shared-boundary clustering architecture and artifact model. Status: `partially implemented` ``` Include at least these specs: @@ -88,7 +88,7 @@ Populate `## Plans` with grouped bullets for all current plan files in `docs/sup ```md ### Plotting -- [2026-04-01-plotting-axis-architecture.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-plotting-axis-architecture.md) - shared plotting-axis implementation slice. Status: `implemented` +- [2026-04-01-plotting-axis-architecture.md](2026-04-01-plotting-axis-architecture.md) - shared plotting-axis implementation slice. Status: `implemented` ``` List all current plan files: @@ -121,29 +121,29 @@ Add a short theme map that points readers to the most relevant spec/plan chains, - [ ] **Step 5: Commit the new index** ```bash -git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md +git add docs/superpowers/README.md git commit -m "docs: add superpowers docs index" ``` ### Task 2: Stage and track the existing untracked plan files **Files:** -- Stage: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-global-analysis-foundations.md` -- Stage: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-region-contrasts-foundations.md` -- Stage: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-region-discovery-foundations.md` -- Stage: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-cluster-occupancy-region-contrasts.md` -- Stage: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-discovery-cluster-contrast-workflow.md` -- Stage: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-paired-region-discovery.md` -- Stage: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-plotting-axis-architecture.md` -- Stage: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md` -- Stage: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-region-discovery-cluster-workflow.md` +- Stage: `docs/superpowers/plans/2026-03-31-global-analysis-foundations.md` +- Stage: `docs/superpowers/plans/2026-03-31-region-contrasts-foundations.md` +- Stage: `docs/superpowers/plans/2026-03-31-region-discovery-foundations.md` +- Stage: `docs/superpowers/plans/2026-04-01-cluster-occupancy-region-contrasts.md` +- Stage: `docs/superpowers/plans/2026-04-01-discovery-cluster-contrast-workflow.md` +- Stage: `docs/superpowers/plans/2026-04-01-paired-region-discovery.md` +- Stage: `docs/superpowers/plans/2026-04-01-plotting-axis-architecture.md` +- Stage: `docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md` +- Stage: `docs/superpowers/plans/2026-04-01-region-discovery-cluster-workflow.md` - [ ] **Step 1: Confirm the currently untracked plan set** Run: ```bash -git status --short /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans +git status --short docs/superpowers/plans ``` Expected: the plan files above appear as untracked (`??`). @@ -154,44 +154,44 @@ Run: ```bash git add \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-global-analysis-foundations.md \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-region-contrasts-foundations.md \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-03-31-region-discovery-foundations.md \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-cluster-occupancy-region-contrasts.md \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-discovery-cluster-contrast-workflow.md \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-paired-region-discovery.md \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-plotting-axis-architecture.md \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-region-discovery-cluster-workflow.md \ - /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-02-superpowers-docs-cleanup.md + docs/superpowers/plans/2026-03-31-global-analysis-foundations.md \ + docs/superpowers/plans/2026-03-31-region-contrasts-foundations.md \ + docs/superpowers/plans/2026-03-31-region-discovery-foundations.md \ + docs/superpowers/plans/2026-04-01-cluster-occupancy-region-contrasts.md \ + docs/superpowers/plans/2026-04-01-discovery-cluster-contrast-workflow.md \ + docs/superpowers/plans/2026-04-01-paired-region-discovery.md \ + docs/superpowers/plans/2026-04-01-plotting-axis-architecture.md \ + docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md \ + docs/superpowers/plans/2026-04-01-region-discovery-cluster-workflow.md \ + docs/superpowers/plans/2026-04-02-superpowers-docs-cleanup.md ``` - [ ] **Step 3: Commit the tracked plan artifacts** ```bash -git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans +git add docs/superpowers/plans git commit -m "docs: track superpowers implementation plans" ``` ### Task 3: Verify the index and status map against the repo **Files:** -- Verify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md` -- Verify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/` -- Verify: `/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/` +- Verify: `docs/superpowers/README.md` +- Verify: `docs/superpowers/specs/` +- Verify: `docs/superpowers/plans/` - [ ] **Step 1: Check that every linked file in the index exists** Run: ```bash -rg -o '/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/[^)]+' /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md +rg -o 'docs/superpowers/[^)]+' docs/superpowers/README.md ``` Then verify those paths exist with: ```bash -test -f /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md +test -f docs/superpowers/README.md ``` Expected: every file referenced by the index exists on disk. @@ -201,7 +201,7 @@ Expected: every file referenced by the index exists on disk. Run: ```bash -git status --short /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers +git status --short docs/superpowers ``` Expected: no `??` entries remain for the tracked plan docs. @@ -217,7 +217,7 @@ Manually confirm the index does not mark unfinished families as fully complete. - [ ] **Step 4: Commit any index corrections from verification** ```bash -git add /Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md +git add docs/superpowers/README.md git commit -m "docs: verify superpowers docs status index" ``` diff --git a/docs/superpowers/specs/2026-04-01-plotting-axis-architecture-design.md b/docs/superpowers/specs/2026-04-01-plotting-axis-architecture-design.md index 9128544..ce0007b 100644 --- a/docs/superpowers/specs/2026-04-01-plotting-axis-architecture-design.md +++ b/docs/superpowers/specs/2026-04-01-plotting-axis-architecture-design.md @@ -474,13 +474,13 @@ This is consistent with the current direction of `plot_data` in newer workflow r Recommended direction: -- expand [plotting.py](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py) +- expand [plotting.py](../../../dimelo/plotting.py) to hold the shared plot-data preparation core - keep existing modules such as: - - [plot_enrichment_profile.py](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plot_enrichment_profile.py) - - [plot_depth_profile.py](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plot_depth_profile.py) - - [plot_reads.py](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plot_reads.py) + - [plot_enrichment_profile.py](../../../dimelo/plot_enrichment_profile.py) + - [plot_depth_profile.py](../../../dimelo/plot_depth_profile.py) + - [plot_reads.py](../../../dimelo/plot_reads.py) as wrappers or adapters during the transition - route newer workflow `plot_data` preparation through the shared plotting core where it makes sense diff --git a/docs/superpowers/specs/2026-04-01-region-contrasts-plotting-design.md b/docs/superpowers/specs/2026-04-01-region-contrasts-plotting-design.md index d4975e4..60d1565 100644 --- a/docs/superpowers/specs/2026-04-01-region-contrasts-plotting-design.md +++ b/docs/superpowers/specs/2026-04-01-region-contrasts-plotting-design.md @@ -37,7 +37,7 @@ This keeps responsibilities clean: ## Public API -Add two public helpers in [plotting.py](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py): +Add two public helpers in [plotting.py](../../../dimelo/plotting.py): - `prepare_region_contrast_profile_data(...)` - `prepare_region_contrast_heatmap_data(...)` @@ -127,7 +127,7 @@ This keeps occupancy plotting opt-in and data-driven rather than pretending all ## Axis Rules -These helpers must use the shared plotting-axis model already established in [2026-04-01-plotting-axis-architecture-design.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/specs/2026-04-01-plotting-axis-architecture-design.md). +These helpers must use the shared plotting-axis model already established in [2026-04-01-plotting-axis-architecture-design.md](2026-04-01-plotting-axis-architecture-design.md). ### V1 axis support diff --git a/docs/superpowers/specs/2026-04-02-docs-and-integration-cleanup-design.md b/docs/superpowers/specs/2026-04-02-docs-and-integration-cleanup-design.md index 2954052..8edfd2c 100644 --- a/docs/superpowers/specs/2026-04-02-docs-and-integration-cleanup-design.md +++ b/docs/superpowers/specs/2026-04-02-docs-and-integration-cleanup-design.md @@ -117,13 +117,13 @@ The implementation plan should likely touch or inspect: - `docs/superpowers/specs/` - `docs/superpowers/plans/` -- [README.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/README.md) -- [docs/region-contrasts.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-contrasts.md) -- [docs/shared-clustering.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/shared-clustering.md) -- [docs/region-discovery.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/region-discovery.md) -- [docs/global-analysis.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/global-analysis.md) -- [dimelo/__init__.py](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/__init__.py) -- [dimelo/plotting.py](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py) +- [README.md](../../../README.md) +- [docs/region-contrasts.md](../../region-contrasts.md) +- [docs/shared-clustering.md](../../shared-clustering.md) +- [docs/region-discovery.md](../../region-discovery.md) +- [docs/global-analysis.md](../../global-analysis.md) +- [dimelo/__init__.py](../../../dimelo/__init__.py) +- [dimelo/plotting.py](../../../dimelo/plotting.py) The implementation plan does not need to modify all of them. This list exists to constrain where the integration cleanup should look. diff --git a/docs/superpowers/specs/2026-04-02-superpowers-docs-cleanup-design.md b/docs/superpowers/specs/2026-04-02-superpowers-docs-cleanup-design.md index e4fb796..f6728bb 100644 --- a/docs/superpowers/specs/2026-04-02-superpowers-docs-cleanup-design.md +++ b/docs/superpowers/specs/2026-04-02-superpowers-docs-cleanup-design.md @@ -59,7 +59,7 @@ It should not: Add one central index file: -- [README.md](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/README.md) +- [README.md](../README.md) Keep the existing layout: From e276937292a95414e8655770e1af6e942481ec73 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 11:04:21 -0700 Subject: [PATCH 132/272] docs: fix cleanup plan normalization examples --- .../plans/2026-04-02-docs-and-integration-cleanup.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/superpowers/plans/2026-04-02-docs-and-integration-cleanup.md b/docs/superpowers/plans/2026-04-02-docs-and-integration-cleanup.md index a080fa5..8baa6ef 100644 --- a/docs/superpowers/plans/2026-04-02-docs-and-integration-cleanup.md +++ b/docs/superpowers/plans/2026-04-02-docs-and-integration-cleanup.md @@ -47,7 +47,7 @@ Expected: a list of tracked historical docs that still contain machine-local abs For Markdown links inside tracked superpowers docs, convert forms like: ```md -[plotting.py](../../../dimelo/plotting.py) +[plotting.py](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py) ``` to: @@ -63,7 +63,7 @@ or the correct relative form from the document location. For plain path references or shell commands inside tracked superpowers docs, replace machine-local prefixes with repo-relative or repo-root-style paths. For example: ```text -docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md +/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md ``` becomes: From 736fdd52758fced82f39a953a5335d6b5a214f25 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 11:05:56 -0700 Subject: [PATCH 133/272] docs: refresh superpowers index links --- docs/superpowers/README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/docs/superpowers/README.md b/docs/superpowers/README.md index 1878851..f865fb0 100644 --- a/docs/superpowers/README.md +++ b/docs/superpowers/README.md @@ -33,6 +33,7 @@ This directory tracks internal design and implementation work for the current br ### Cleanup And Docs - [2026-04-02-superpowers-docs-cleanup-design.md](specs/2026-04-02-superpowers-docs-cleanup-design.md) - central index and status-map cleanup for internal planning docs. Status: `implemented` +- [2026-04-02-docs-and-integration-cleanup-design.md](specs/2026-04-02-docs-and-integration-cleanup-design.md) - path portability and discoverability cleanup for tracked superpowers docs and related integration surfaces. Status: `partially implemented` ## Plans @@ -61,6 +62,7 @@ This directory tracks internal design and implementation work for the current br ### Cleanup And Docs - [2026-04-02-superpowers-docs-cleanup.md](plans/2026-04-02-superpowers-docs-cleanup.md) - central docs index and tracked-plan cleanup. Status: `implemented` +- [2026-04-02-docs-and-integration-cleanup.md](plans/2026-04-02-docs-and-integration-cleanup.md) - historical path normalization plus narrow discoverability cleanup around completed analysis and plotting work. Status: `partially implemented` ## Current Themes @@ -69,4 +71,4 @@ This directory tracks internal design and implementation work for the current br - Region discovery: use the region analysis architecture spec, the paired discovery spec, and the discovery workflow plans together. - Global analysis: use the region analysis architecture spec first, then the global analysis foundations plan. - Plotting: start with the plotting-axis spec, then the plotting-axis implementation plan and the region-contrasts plotting plan. -- Docs cleanup: use the docs cleanup design and plan for the central status map and tracked historical plans. +- Docs cleanup: use the docs cleanup design and plan for the central status map and tracked historical plans, then the docs-and-integration cleanup design and plan for portability and discoverability follow-on work. From b0c9219bb26180f2ff79c25bdd5ee2ffeeb912e6 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 11:08:08 -0700 Subject: [PATCH 134/272] docs: tighten analysis discoverability --- docs/region-contrasts.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/region-contrasts.md b/docs/region-contrasts.md index 88269c2..11a3119 100644 --- a/docs/region-contrasts.md +++ b/docs/region-contrasts.md @@ -7,7 +7,7 @@ - Use this when you already have a BED or matched region set. - Use `parse_bam.pileup()` first when you want locus-level motif abundance testing. - Use `cluster` first when you want read-state or cluster-occupancy follow-up rather than average motif abundance alone. -- Use `region_discovery` later for de novo locus finding once that module is implemented. +- Use `region_discovery` when you do not yet know the loci and want de novo locus finding before follow-up contrasts. ## V1 Supported Paths From 6a5b57709d8ac62674e4d3777dddbb8882ec0df2 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 11:10:05 -0700 Subject: [PATCH 135/272] docs: remove remaining local path examples --- .../plans/2026-04-02-docs-and-integration-cleanup.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/superpowers/plans/2026-04-02-docs-and-integration-cleanup.md b/docs/superpowers/plans/2026-04-02-docs-and-integration-cleanup.md index 8baa6ef..8869790 100644 --- a/docs/superpowers/plans/2026-04-02-docs-and-integration-cleanup.md +++ b/docs/superpowers/plans/2026-04-02-docs-and-integration-cleanup.md @@ -47,7 +47,7 @@ Expected: a list of tracked historical docs that still contain machine-local abs For Markdown links inside tracked superpowers docs, convert forms like: ```md -[plotting.py](/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/plotting.py) +[plotting.py](/absolute/path/to/dimelo-toolkit/dimelo/plotting.py) ``` to: @@ -63,7 +63,7 @@ or the correct relative form from the document location. For plain path references or shell commands inside tracked superpowers docs, replace machine-local prefixes with repo-relative or repo-root-style paths. For example: ```text -/Users/ngamarra/Documents/GitHub/dimelo-toolkit/docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md +/absolute/path/to/dimelo-toolkit/docs/superpowers/plans/2026-04-01-region-contrasts-plotting.md ``` becomes: From 0dda8261d4f729301c66b96d2837ed9859aa06c9 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 11:11:30 -0700 Subject: [PATCH 136/272] docs: generalize cleanup path verification --- .../plans/2026-04-02-docs-and-integration-cleanup.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/superpowers/plans/2026-04-02-docs-and-integration-cleanup.md b/docs/superpowers/plans/2026-04-02-docs-and-integration-cleanup.md index 8869790..6a30715 100644 --- a/docs/superpowers/plans/2026-04-02-docs-and-integration-cleanup.md +++ b/docs/superpowers/plans/2026-04-02-docs-and-integration-cleanup.md @@ -215,7 +215,7 @@ Only include files actually changed. Run: ```bash -rg -n "/Users/[^/]+/Documents/GitHub/dimelo-toolkit" docs/superpowers/specs docs/superpowers/plans docs/superpowers/README.md +rg -n "/Users/[^/]+/Documents/GitHub/[^/]+" docs/superpowers/specs docs/superpowers/plans docs/superpowers/README.md ``` Expected: no output unless an intentional exception is documented. From 3fffead610e38101790a7f9850b054e39eb39a6f Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 14:54:36 -0700 Subject: [PATCH 137/272] docs: add region discovery plotting spec --- ...-04-02-region-discovery-plotting-design.md | 288 ++++++++++++++++++ 1 file changed, 288 insertions(+) create mode 100644 docs/superpowers/specs/2026-04-02-region-discovery-plotting-design.md diff --git a/docs/superpowers/specs/2026-04-02-region-discovery-plotting-design.md b/docs/superpowers/specs/2026-04-02-region-discovery-plotting-design.md new file mode 100644 index 0000000..5fd7112 --- /dev/null +++ b/docs/superpowers/specs/2026-04-02-region-discovery-plotting-design.md @@ -0,0 +1,288 @@ +# Region Discovery Plotting Design + +## Goal + +Add a small, data-first plotting-prep layer for `dimelo.region_discovery` that makes discovery results easier to inspect without coupling the analysis API to a specific renderer. The first slice should help users answer two questions: + +- where are the interesting windows across the genome scan? +- what does the local scored neighborhood around the top hits look like? + +The new helpers should sit on top of the existing `RegionDiscoveryResult` contract rather than expanding `scan_genome()` itself. + +## Scope + +This design covers: + +- renderer-neutral plotting prep for discovery scan overviews +- renderer-neutral plotting prep for local top-hit context views +- per-contig organization as the default scan layout +- continued use of `RegionDiscoveryResult.windows` and `RegionDiscoveryResult.hits` as the source of truth + +This design does not cover: + +- Matplotlib or seaborn renderer functions +- cumulative genome axes across contigs +- normalized region-axis plotting +- direct single-read plotting +- segment-map or metaregion plotting semantics + +## User-Facing API + +Add two public helpers in [plotting.py](../../../dimelo/plotting.py): + +- `prepare_region_discovery_scan_data(...)` +- `prepare_region_discovery_hit_context_data(...)` + +These should accept a [RegionDiscoveryResult](../../../dimelo/models.py) and return renderer-neutral payload dictionaries with plot-ready tables plus metadata. + +## Design Principles + +### Keep discovery plotting genome-native + +Discovery is still a tiled genome scan. The first plotting helpers should preserve genomic structure rather than forcing the result into a normalized region axis. The primary organization is: + +- per-contig scan windows +- ranked hit overlays +- local window neighborhoods around selected hits + +### Keep `scan_genome()` focused on analysis + +`scan_genome()` already returns `result.windows`, `result.hits`, and lightweight `plot_data`. The richer plotting helpers should live in [plotting.py](../../../dimelo/plotting.py), not inside [region_discovery.py](../../../dimelo/region_discovery.py). That keeps analysis and plotting concerns separate and matches the newer `region_contrasts` plotting architecture. + +### Prefer result-centric helpers + +The primary public input should be `RegionDiscoveryResult`, not raw tables. Internally, the helpers can still work against `result.windows` and `result.hits`, but the public API should stay aligned with the analysis workflow output. + +## Plot Family 1: Scan Overview + +### Purpose + +Prepare data for genome-scan views that show the scored window landscape and optionally overlay ranked discovery hits. + +### Public Entry Point + +```python +payload = plotting.prepare_region_discovery_scan_data( + result=result, + contigs=None, + top_n_hits=100, + score_column=None, + include_all_windows=True, +) +``` + +### Inputs + +- `result: RegionDiscoveryResult` +- `contigs: list[str] | None` + - optional filter and ordering override for contigs to include +- `top_n_hits: int | None` + - optional cap on hit overlays used for display +- `score_column: str | None` + - defaults to the canonical discovery score field for the result shape +- `include_all_windows: bool` + - when `True`, return the full filtered `scan_table` + - when `False`, allow callers to request a lighter payload later + +### Outputs + +Return a dictionary with: + +- `scan_table` + - one row per scanned window + - minimally includes: + - `contig` + - `start` + - `end` + - `score_value` or the chosen score field + - any rank/effect columns already present in `result.windows` + - `is_hit` +- `hit_table` + - one row per displayed hit + - top-N filtered if requested +- `metadata` + - includes: + - `contig_order` + - `score_column` + - `score_mode` + - `contrast_mode` + - `merge_hits` + - `top_n_hits` + +### Default layout semantics + +The helper should default to per-contig organization, not a cumulative genome coordinate. Renderers are expected to facet or panel by contig by default. + +### Derived columns + +The helper should add: + +- `contig` + - normalized alias of the discovery `chromosome` field for plotting clarity +- `window_midpoint` + - useful for line/scatter/track renderers +- `is_hit` + - `True` for windows that correspond to the overlay hit set + +The helper should not mutate or reinterpret the discovery score itself. + +## Plot Family 2: Hit Context + +### Purpose + +Prepare local drill-down tables around selected hits so users can inspect the scored neighborhood before exporting BEDs or moving into clustering and contrasts. + +### Public Entry Point + +```python +payload = plotting.prepare_region_discovery_hit_context_data( + result=result, + top_n=12, + hit_ids=None, + padding_windows=5, + padding_bp=None, +) +``` + +### Inputs + +- `result: RegionDiscoveryResult` +- `top_n: int | None` + - number of ranked hits to include by default +- `hit_ids: list[str] | None` + - explicit hit/window selection override +- `padding_windows: int | None` + - include this many neighboring windows on each side of each selected hit +- `padding_bp: int | None` + - optional physical-distance expansion alternative + +The first implementation should support `top_n` and `padding_windows` first. `hit_ids` and `padding_bp` can be part of the public contract now if the implementation still keeps the first slice modest. + +### Outputs + +Return a dictionary with: + +- `context_table` + - local windows surrounding each selected hit + - includes: + - `contig` + - `start` + - `end` + - `window_midpoint` + - score columns + - `selected_hit_id` + - `selected_hit_rank` + - `relative_window_offset` + - `is_selected_hit` +- `selected_hits` + - the anchor hits used for the context extraction +- `metadata` + - includes: + - `selection_mode` + - `top_n` + - `padding_windows` + - `padding_bp` + - `score_column` + +### Layout semantics + +This payload is designed for small multiples or per-hit panels. Each selected hit becomes a local plotting context, usually faceted by `selected_hit_id` or `selected_hit_rank`. + +## Defaults And Validation + +### Score column selection + +If `score_column` is omitted, use: + +- `score_value` when present +- otherwise the canonical primary score column for the result shape + +If no usable score column exists, raise a clear error instead of guessing silently. + +### Empty results + +If `result.windows` or `result.hits` is empty: + +- return empty plot tables with stable columns +- preserve metadata +- do not raise unless required input structure is missing + +### Contig filtering + +If `contigs` is provided: + +- filter both windows and hits to the requested contigs +- preserve the given order in `metadata["contig_order"]` +- error only if none of the requested contigs are present + +### Hit selection + +For hit-context prep: + +- `top_n` should use the ranked order already present in `result.hits` +- if both `top_n` and explicit IDs are provided later, explicit IDs should win +- if no hits are available, return an empty stable payload + +## Relationship To Existing `plot_data` + +The helpers should treat the discovery result tables as the canonical source of truth: + +- `result.windows` +- `result.hits` + +Existing lightweight `result.plot_data["window_score_table"]` and `result.plot_data["top_hits_table"]` can remain available, but they should not block the helper design. The new helpers may reuse them internally if that is clean, but the public contract should not depend on those specific precomputed payload names. + +## Backward Compatibility + +This design is additive. + +- it does not change `scan_genome()` signatures +- it does not change `RegionDiscoveryResult` +- it does not remove existing `plot_data` +- it does not change older plotting modules + +This keeps the discovery workflow stable while making downstream plotting more coherent. + +## Testing + +Add focused tests in [tests/test_plotting.py](../../../tests/test_plotting.py) for: + +- stable scan payload columns +- per-contig ordering behavior +- top-N hit overlay filtering +- local hit-context extraction using neighboring windows +- empty-result behavior +- explicit score-column validation + +Use mocked or synthetic `RegionDiscoveryResult` objects rather than full end-to-end discovery runs for most helper tests. + +## Documentation + +Update: + +- [docs/region-discovery.md](../../../docs/region-discovery.md) +- [README.md](../../../README.md) + +Document: + +- the two new helpers +- the per-contig default +- the difference between scan overview prep and hit-context prep +- that discovery plotting remains data-first and renderer-neutral + +## Recommended Implementation Order + +1. Add plotting helper tests for scan overview prep +2. Implement `prepare_region_discovery_scan_data(...)` +3. Add plotting helper tests for hit-context prep +4. Implement `prepare_region_discovery_hit_context_data(...)` +5. Update docs + +## Recommendation + +Build `region_discovery` plotting as a result-centric, data-prep-only layer with two helpers: + +- `prepare_region_discovery_scan_data(...)` +- `prepare_region_discovery_hit_context_data(...)` + +Keep the first slice genome-native, per-contig by default, and centered on discovery windows and hits rather than normalized positional region views. From 4d36a503687850bf888facd227c229d9d3d6f394 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 14:56:20 -0700 Subject: [PATCH 138/272] docs: add region discovery plotting plan --- .../2026-04-02-region-discovery-plotting.md | 616 ++++++++++++++++++ 1 file changed, 616 insertions(+) create mode 100644 docs/superpowers/plans/2026-04-02-region-discovery-plotting.md diff --git a/docs/superpowers/plans/2026-04-02-region-discovery-plotting.md b/docs/superpowers/plans/2026-04-02-region-discovery-plotting.md new file mode 100644 index 0000000..fd9b7d9 --- /dev/null +++ b/docs/superpowers/plans/2026-04-02-region-discovery-plotting.md @@ -0,0 +1,616 @@ +# Region Discovery Plotting Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Add renderer-neutral plotting-prep helpers for `dimelo.region_discovery` scan overviews and local top-hit context views. + +**Architecture:** Extend the shared plotting module with two result-centric helpers that consume `RegionDiscoveryResult` and emit stable payload dictionaries. Keep the implementation additive: no `scan_genome()` signature changes, no renderer coupling, and no normalized region-axis logic for this slice. + +**Tech Stack:** Python 3.11, pandas, pytest, existing `dimelo.plotting` and `dimelo.models` modules + +--- + +## File Map + +- Modify: `dimelo/plotting.py` + - add internal validation and extraction helpers for `RegionDiscoveryResult` + - add `prepare_region_discovery_scan_data(...)` + - add `prepare_region_discovery_hit_context_data(...)` +- Modify: `tests/test_plotting.py` + - add focused discovery plotting helper coverage using synthetic `RegionDiscoveryResult` objects +- Modify: `docs/region-discovery.md` + - document the new plotting-prep helpers and their data-first outputs +- Modify: `README.md` + - add one short note under plotting/analysis guides for discovery plotting helpers + +## Task 1: Add Failing Tests For Discovery Scan Plot Prep + +**Files:** +- Modify: `tests/test_plotting.py` +- Reference: `dimelo/models.py` +- Reference: `dimelo/plotting.py` + +- [ ] **Step 1: Write the failing scan-prep tests** + +Add these tests near the other plotting helper tests in `tests/test_plotting.py`: + +```python +from dimelo.models import RegionDiscoveryResult + + +def _make_region_discovery_result() -> RegionDiscoveryResult: + windows = pd.DataFrame( + [ + { + "window_id": "chr1:0-100:+", + "chromosome": "chr1", + "start": 0, + "end": 100, + "strand": "+", + "score_value": 0.2, + "rank": 3, + }, + { + "window_id": "chr1:100-200:+", + "chromosome": "chr1", + "start": 100, + "end": 200, + "strand": "+", + "score_value": 0.9, + "rank": 1, + }, + { + "window_id": "chr2:0-100:+", + "chromosome": "chr2", + "start": 0, + "end": 100, + "strand": "+", + "score_value": 0.5, + "rank": 2, + }, + ] + ) + hits = windows.loc[windows["rank"] <= 2].copy() + return RegionDiscoveryResult( + windows=windows, + hits=hits, + plot_data={ + "window_score_table": windows.copy(), + "top_hits_table": hits.copy(), + }, + metadata={ + "score": "effect_size_only", + "contrast_mode": "pairwise", + "merge_hits": False, + }, + ) + + +def test_prepare_region_discovery_scan_data_returns_expected_tables(): + result = _make_region_discovery_result() + + payload = plotting.prepare_region_discovery_scan_data(result=result) + + assert set(payload) == {"scan_table", "hit_table", "metadata"} + assert list(payload["scan_table"]["contig"]) == ["chr1", "chr1", "chr2"] + assert list(payload["hit_table"]["rank"]) == [1, 2] + assert payload["scan_table"]["is_hit"].tolist() == [False, True, True] + assert payload["metadata"]["contig_order"] == ["chr1", "chr2"] + assert payload["metadata"]["score_column"] == "score_value" + + +def test_prepare_region_discovery_scan_data_filters_contigs_in_requested_order(): + result = _make_region_discovery_result() + + payload = plotting.prepare_region_discovery_scan_data( + result=result, + contigs=["chr2", "chr1"], + ) + + assert payload["metadata"]["contig_order"] == ["chr2", "chr1"] + assert payload["scan_table"]["contig"].tolist() == ["chr2", "chr1", "chr1"] + + +def test_prepare_region_discovery_scan_data_limits_hit_overlay(): + result = _make_region_discovery_result() + + payload = plotting.prepare_region_discovery_scan_data( + result=result, + top_n_hits=1, + ) + + assert payload["hit_table"]["rank"].tolist() == [1] + assert payload["scan_table"]["is_hit"].tolist() == [False, True, False] +``` + +- [ ] **Step 2: Run the new scan-prep tests to verify they fail** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "region_discovery_scan_data" -q +``` + +Expected: FAIL because `prepare_region_discovery_scan_data(...)` does not yet exist. + +- [ ] **Step 3: Commit the failing tests** + +```bash +git add tests/test_plotting.py +git commit -m "test: add region discovery scan plotting coverage" +``` + +## Task 2: Implement Discovery Scan Plot Prep + +**Files:** +- Modify: `dimelo/plotting.py` +- Modify: `tests/test_plotting.py` + +- [ ] **Step 1: Add the internal discovery scan helpers** + +Add these internal helpers in `dimelo/plotting.py` near the other plot-data validation utilities: + +```python +def _validate_region_discovery_result(result): + if result is None: + raise ValueError("plotting helpers require a RegionDiscoveryResult.") + if not hasattr(result, "windows") or not hasattr(result, "hits") or not hasattr(result, "metadata"): + raise TypeError("plotting helpers require a RegionDiscoveryResult-like object.") + + +def _select_discovery_score_column(windows: pd.DataFrame, score_column: str | None) -> str: + if score_column is not None: + if score_column not in windows.columns: + raise ValueError(f"Unknown discovery score column: {score_column}") + return score_column + if "score_value" in windows.columns: + return "score_value" + raise ValueError("Could not infer a discovery score column from RegionDiscoveryResult.windows.") + + +def _empty_discovery_scan_table(score_column: str) -> pd.DataFrame: + return pd.DataFrame( + columns=[ + "window_id", + "contig", + "start", + "end", + "strand", + score_column, + "window_midpoint", + "is_hit", + ] + ) +``` + +- [ ] **Step 2: Add `prepare_region_discovery_scan_data(...)`** + +Add this public function in `dimelo/plotting.py` near the other public plotting helpers: + +```python +def prepare_region_discovery_scan_data( + *, + result, + contigs: list[str] | None = None, + top_n_hits: int | None = 100, + score_column: str | None = None, + include_all_windows: bool = True, +): + _validate_region_discovery_result(result) + + windows = result.windows.copy() + hits = result.hits.copy() + active_score_column = _select_discovery_score_column(windows, score_column) + + if windows.empty: + empty_scan = _empty_discovery_scan_table(active_score_column) + empty_hits = pd.DataFrame(columns=["window_id", "contig", "start", "end", "strand", active_score_column]) + return { + "scan_table": empty_scan, + "hit_table": empty_hits, + "metadata": { + "contig_order": [], + "score_column": active_score_column, + "score_mode": result.metadata.get("score"), + "contrast_mode": result.metadata.get("contrast_mode"), + "merge_hits": result.metadata.get("merge_hits"), + "top_n_hits": top_n_hits, + }, + } + + windows["contig"] = windows["chromosome"] + hits["contig"] = hits["chromosome"] + + if contigs is not None: + windows = windows.loc[windows["contig"].isin(contigs)].copy() + hits = hits.loc[hits["contig"].isin(contigs)].copy() + if windows.empty: + raise ValueError("Requested contigs are not present in RegionDiscoveryResult.windows.") + contig_order = list(contigs) + else: + contig_order = windows["contig"].drop_duplicates().tolist() + + if top_n_hits is not None and not hits.empty and "rank" in hits.columns: + hits = hits.sort_values("rank", kind="stable").head(top_n_hits).copy() + + hit_window_ids = set(hits.get("window_id", pd.Series(dtype="object")).tolist()) + windows["window_midpoint"] = (windows["start"] + windows["end"]) / 2.0 + windows["is_hit"] = windows["window_id"].isin(hit_window_ids) + + scan_table = windows if include_all_windows else windows.loc[windows["is_hit"]].copy() + scan_table = scan_table.sort_values(["contig", "start", "end"], kind="stable").reset_index(drop=True) + hit_table = hits.sort_values(["rank", "contig", "start", "end"], kind="stable").reset_index(drop=True) + + return { + "scan_table": scan_table, + "hit_table": hit_table, + "metadata": { + "contig_order": contig_order, + "score_column": active_score_column, + "score_mode": result.metadata.get("score"), + "contrast_mode": result.metadata.get("contrast_mode"), + "merge_hits": result.metadata.get("merge_hits"), + "top_n_hits": top_n_hits, + }, + } +``` + +- [ ] **Step 3: Run the scan-prep tests to verify they pass** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "region_discovery_scan_data" -q +``` + +Expected: PASS. + +- [ ] **Step 4: Commit the scan-prep implementation** + +```bash +git add dimelo/plotting.py tests/test_plotting.py +git commit -m "feat: add region discovery scan plotting prep" +``` + +## Task 3: Add Failing Tests For Hit-Context Plot Prep + +**Files:** +- Modify: `tests/test_plotting.py` +- Reference: `dimelo/plotting.py` + +- [ ] **Step 1: Add the failing hit-context tests** + +Append these tests in `tests/test_plotting.py` near the new discovery scan tests: + +```python +def test_prepare_region_discovery_hit_context_data_uses_top_ranked_hits(): + result = _make_region_discovery_result() + + payload = plotting.prepare_region_discovery_hit_context_data( + result=result, + top_n=1, + padding_windows=1, + ) + + assert set(payload) == {"context_table", "selected_hits", "metadata"} + assert payload["selected_hits"]["rank"].tolist() == [1] + assert payload["context_table"]["selected_hit_rank"].nunique() == 1 + assert payload["context_table"]["selected_hit_rank"].iloc[0] == 1 + assert payload["context_table"]["is_selected_hit"].sum() == 1 + + +def test_prepare_region_discovery_hit_context_data_adds_relative_window_offsets(): + result = _make_region_discovery_result() + + payload = plotting.prepare_region_discovery_hit_context_data( + result=result, + top_n=1, + padding_windows=1, + ) + + assert sorted(payload["context_table"]["relative_window_offset"].tolist()) == [-1, 0] + + +def test_prepare_region_discovery_hit_context_data_returns_empty_payload_for_no_hits(): + result = RegionDiscoveryResult( + windows=_make_region_discovery_result().windows, + hits=pd.DataFrame(columns=_make_region_discovery_result().hits.columns), + plot_data={}, + metadata={"score": "effect_size_only", "contrast_mode": "pairwise", "merge_hits": False}, + ) + + payload = plotting.prepare_region_discovery_hit_context_data(result=result) + + assert payload["context_table"].empty + assert payload["selected_hits"].empty + assert payload["metadata"]["selection_mode"] == "top_n" +``` + +- [ ] **Step 2: Run the hit-context tests to verify they fail** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "region_discovery_hit_context_data" -q +``` + +Expected: FAIL because `prepare_region_discovery_hit_context_data(...)` does not yet exist. + +- [ ] **Step 3: Commit the failing hit-context tests** + +```bash +git add tests/test_plotting.py +git commit -m "test: add region discovery hit context coverage" +``` + +## Task 4: Implement Discovery Hit-Context Plot Prep + +**Files:** +- Modify: `dimelo/plotting.py` +- Modify: `tests/test_plotting.py` + +- [ ] **Step 1: Add the hit selection helper** + +Insert this helper in `dimelo/plotting.py` near the discovery scan helpers: + +```python +def _select_region_discovery_hits( + hits: pd.DataFrame, + *, + top_n: int | None, +): + if hits.empty: + return hits.copy(), "top_n" + if "rank" in hits.columns: + selected = hits.sort_values("rank", kind="stable") + else: + selected = hits.copy() + if top_n is not None: + selected = selected.head(top_n) + return selected.copy(), "top_n" +``` + +- [ ] **Step 2: Add `prepare_region_discovery_hit_context_data(...)`** + +Add this public function in `dimelo/plotting.py` near the scan helper: + +```python +def prepare_region_discovery_hit_context_data( + *, + result, + top_n: int | None = 12, + hit_ids: list[str] | None = None, + padding_windows: int | None = 5, + padding_bp: int | None = None, + score_column: str | None = None, +): + _validate_region_discovery_result(result) + + windows = result.windows.copy() + hits = result.hits.copy() + active_score_column = _select_discovery_score_column(windows, score_column) + + if hits.empty or windows.empty: + return { + "context_table": pd.DataFrame( + columns=[ + "window_id", + "contig", + "start", + "end", + "strand", + active_score_column, + "window_midpoint", + "selected_hit_id", + "selected_hit_rank", + "relative_window_offset", + "is_selected_hit", + ] + ), + "selected_hits": hits.copy(), + "metadata": { + "selection_mode": "top_n" if hit_ids is None else "explicit_ids", + "top_n": top_n, + "padding_windows": padding_windows, + "padding_bp": padding_bp, + "score_column": active_score_column, + }, + } + + windows = windows.sort_values(["chromosome", "start", "end"], kind="stable").reset_index(drop=True) + windows["contig"] = windows["chromosome"] + windows["window_midpoint"] = (windows["start"] + windows["end"]) / 2.0 + + if hit_ids is not None: + selected_hits = hits.loc[hits["window_id"].isin(hit_ids)].copy() + selection_mode = "explicit_ids" + else: + selected_hits, selection_mode = _select_region_discovery_hits(hits, top_n=top_n) + + if selected_hits.empty: + return { + "context_table": pd.DataFrame(columns=list(windows.columns) + ["selected_hit_id", "selected_hit_rank", "relative_window_offset", "is_selected_hit"]), + "selected_hits": selected_hits, + "metadata": { + "selection_mode": selection_mode, + "top_n": top_n, + "padding_windows": padding_windows, + "padding_bp": padding_bp, + "score_column": active_score_column, + }, + } + + context_frames = [] + for _, hit in selected_hits.sort_values("rank", kind="stable").iterrows(): + same_contig = windows.loc[windows["contig"] == hit["chromosome"]].reset_index(drop=True) + hit_positions = same_contig.index[same_contig["window_id"] == hit["window_id"]].tolist() + if not hit_positions: + continue + hit_position = hit_positions[0] + start_index = max(0, hit_position - int(padding_windows or 0)) + end_index = min(len(same_contig), hit_position + int(padding_windows or 0) + 1) + context = same_contig.iloc[start_index:end_index].copy() + context["selected_hit_id"] = hit["window_id"] + context["selected_hit_rank"] = hit.get("rank") + context["relative_window_offset"] = range(start_index - hit_position, end_index - hit_position) + context["is_selected_hit"] = context["window_id"] == hit["window_id"] + context_frames.append(context) + + context_table = ( + pd.concat(context_frames, ignore_index=True) + if context_frames + else pd.DataFrame(columns=list(windows.columns) + ["selected_hit_id", "selected_hit_rank", "relative_window_offset", "is_selected_hit"]) + ) + + return { + "context_table": context_table, + "selected_hits": selected_hits.sort_values("rank", kind="stable").reset_index(drop=True), + "metadata": { + "selection_mode": selection_mode, + "top_n": top_n, + "padding_windows": padding_windows, + "padding_bp": padding_bp, + "score_column": active_score_column, + }, + } +``` + +- [ ] **Step 3: Run the hit-context tests to verify they pass** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "region_discovery_hit_context_data" -q +``` + +Expected: PASS. + +- [ ] **Step 4: Run the combined discovery plotting subset** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "region_discovery_scan_data or region_discovery_hit_context_data" -q +``` + +Expected: PASS. + +- [ ] **Step 5: Commit the hit-context implementation** + +```bash +git add dimelo/plotting.py tests/test_plotting.py +git commit -m "feat: add region discovery hit context plotting prep" +``` + +## Task 5: Document The New Discovery Plotting Helpers + +**Files:** +- Modify: `docs/region-discovery.md` +- Modify: `README.md` +- Verify: `tests/test_plotting.py` + +- [ ] **Step 1: Add a short discovery plotting section to the guide** + +Append a short section to `docs/region-discovery.md` with an example like: + +```python +from dimelo import plotting + +scan_payload = plotting.prepare_region_discovery_scan_data( + result=result, + top_n_hits=50, +) + +context_payload = plotting.prepare_region_discovery_hit_context_data( + result=result, + top_n=12, + padding_windows=5, +) +``` + +Explain briefly: + +- scan payloads stay per-contig by default +- hit-context payloads are intended for small multiple panels +- both helpers are data-prep only and renderer-neutral + +- [ ] **Step 2: Add one short README note** + +Add one short paragraph to `README.md` under the plotting or analysis-guides area explaining: + +- `region_discovery` now has renderer-neutral scan and hit-context plotting helpers +- they consume `RegionDiscoveryResult` +- they prepare per-contig scan tables rather than cumulative genome axes by default + +- [ ] **Step 3: Run the touched plotting test file** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -q +``` + +Expected: PASS. + +- [ ] **Step 4: Commit the docs pass** + +```bash +git add docs/region-discovery.md README.md tests/test_plotting.py dimelo/plotting.py +git commit -m "docs: add region discovery plotting guide" +``` + +## Final Verification + +**Files:** +- Verify: `dimelo/plotting.py` +- Verify: `tests/test_plotting.py` +- Verify: `docs/region-discovery.md` +- Verify: `README.md` + +- [ ] **Step 1: Run the focused plotting verification** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -q +``` + +Expected: PASS. + +- [ ] **Step 2: Confirm the working tree is clean** + +Run: + +```bash +git status --short +``` + +Expected: no output. + +- [ ] **Step 3: Summarize outcomes** + +Capture in the handoff: + +- which public helpers were added +- which tests were added +- that discovery plotting remains data-first and per-contig by default + +## Self-Review + +Spec coverage check: + +- scan-overview helper: covered in Tasks 1-2 +- hit-context helper: covered in Tasks 3-4 +- per-contig default and metadata: covered in Tasks 1-2 and Task 5 docs +- additive/no-renderer design: preserved throughout, with no `scan_genome()` changes + +Placeholder scan: + +- no `TODO`, `TBD`, or undefined implementation steps remain +- each task includes exact files, code snippets, commands, and expected outcomes + +Type consistency: + +- both helpers are named consistently with the approved spec +- `RegionDiscoveryResult` remains the public input +- payload keys stay aligned with the spec: `scan_table`, `hit_table`, `context_table`, `selected_hits`, `metadata` From f18576a698ad1f92731eebddbfb83911d357e6f3 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 14:59:27 -0700 Subject: [PATCH 139/272] test: add region discovery scan plotting coverage --- tests/test_plotting.py | 88 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 87 insertions(+), 1 deletion(-) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index a3cfcdf..e25fcea 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -2,7 +2,7 @@ import pandas as pd import pytest -from dimelo.models import ContrastSpec, RegionContrastResult +from dimelo.models import ContrastSpec, RegionContrastResult, RegionDiscoveryResult from dimelo import plot_enrichment_profile, plot_reads, plotting @@ -293,6 +293,92 @@ def _region_contrast_position_rows(*, include_grouping_key: bool = True) -> list ] +def _make_region_discovery_result() -> RegionDiscoveryResult: + windows = pd.DataFrame( + [ + { + "window_id": "chr1:0-100:+", + "chromosome": "chr1", + "start": 0, + "end": 100, + "strand": "+", + "score_value": 0.2, + "rank": 3, + }, + { + "window_id": "chr1:100-200:+", + "chromosome": "chr1", + "start": 100, + "end": 200, + "strand": "+", + "score_value": 0.9, + "rank": 1, + }, + { + "window_id": "chr2:0-100:+", + "chromosome": "chr2", + "start": 0, + "end": 100, + "strand": "+", + "score_value": 0.5, + "rank": 2, + }, + ] + ) + hits = windows.loc[windows["rank"] <= 2].copy() + return RegionDiscoveryResult( + windows=windows, + hits=hits, + contrast=None, + plot_data={ + "window_score_table": windows.copy(), + "top_hits_table": hits.copy(), + }, + metadata={ + "score": "effect_size_only", + "contrast_mode": "pairwise", + "merge_hits": False, + }, + ) + + +def test_prepare_region_discovery_scan_data_returns_expected_tables(): + result = _make_region_discovery_result() + + payload = plotting.prepare_region_discovery_scan_data(result=result) + + assert set(payload) == {"scan_table", "hit_table", "metadata"} + assert list(payload["scan_table"]["contig"]) == ["chr1", "chr1", "chr2"] + assert list(payload["hit_table"]["rank"]) == [1, 2] + assert payload["scan_table"]["is_hit"].tolist() == [False, True, True] + assert payload["metadata"]["contig_order"] == ["chr1", "chr2"] + assert payload["metadata"]["score_column"] == "score_value" + + +def test_prepare_region_discovery_scan_data_filters_contigs_in_requested_order(): + result = _make_region_discovery_result() + + payload = plotting.prepare_region_discovery_scan_data( + result=result, + contigs=["chr2", "chr1"], + ) + + assert payload["metadata"]["contig_order"] == ["chr2", "chr1"] + assert payload["scan_table"]["contig"].tolist() == ["chr2", "chr1", "chr1"] + + +def test_prepare_region_discovery_scan_data_limits_hit_overlay(): + result = _make_region_discovery_result() + + payload = plotting.prepare_region_discovery_scan_data( + result=result, + top_n_hits=1, + ) + + assert payload["hit_table"]["rank"].tolist() == [1] + assert payload["scan_table"]["is_hit"].tolist() == [False, True, False] + + def test_prepare_region_contrast_profile_data_returns_all_value_modes(): result, position_table, axis, aggregation = _region_contrast_plot_setup( _region_contrast_position_rows() From f7d3cf047a639a3ebf3b9d41502a0c6173cab327 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 15:02:18 -0700 Subject: [PATCH 140/272] test: tighten region discovery scan filter coverage --- tests/test_plotting.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index e25fcea..eb41164 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -360,11 +360,14 @@ def test_prepare_region_discovery_scan_data_filters_contigs_in_requested_order() payload = plotting.prepare_region_discovery_scan_data( result=result, - contigs=["chr2", "chr1"], + contigs=["chr2"], ) - assert payload["metadata"]["contig_order"] == ["chr2", "chr1"] - assert payload["scan_table"]["contig"].tolist() == ["chr2", "chr1", "chr1"] + assert payload["metadata"]["contig_order"] == ["chr2"] + assert payload["scan_table"]["contig"].tolist() == ["chr2"] + assert payload["hit_table"]["contig"].tolist() == ["chr2"] + assert "chr1" not in payload["scan_table"]["contig"].tolist() + assert "chr1" not in payload["hit_table"]["contig"].tolist() def test_prepare_region_discovery_scan_data_limits_hit_overlay(): From 2d6bd8658a3112051c676154ebd50d327900baeb Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 15:07:03 -0700 Subject: [PATCH 141/272] feat: add region discovery scan plotting prep --- dimelo/plotting.py | 151 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 151 insertions(+) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 618a5d4..aec19b0 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -130,6 +130,68 @@ def _region_contrast_metadata(result) -> dict[str, object]: } +def _validate_region_discovery_result(result) -> None: + if result is None: + raise ValueError("plotting helpers require a RegionDiscoveryResult.") + if not hasattr(result, "windows") or not hasattr(result, "hits") or not hasattr(result, "metadata"): + raise TypeError("plotting helpers require a RegionDiscoveryResult-like object.") + + +def _select_discovery_score_column(windows: pd.DataFrame, score_column: str | None) -> str: + if score_column is not None: + if score_column not in windows.columns: + raise ValueError(f"Unknown discovery score column: {score_column}") + return score_column + if "score_value" in windows.columns or windows.empty: + return "score_value" + raise ValueError("Could not infer a discovery score column from RegionDiscoveryResult.windows.") + + +def _empty_discovery_scan_table(score_column: str) -> pd.DataFrame: + return pd.DataFrame( + columns=[ + "window_id", + "contig", + "start", + "end", + "strand", + score_column, + "window_midpoint", + "is_hit", + ] + ) + + +def _discovery_contig_column(table: pd.DataFrame, *, owner: str) -> str: + if "chromosome" in table.columns: + return "chromosome" + if "chrom" in table.columns: + return "chrom" + raise ValueError(f"{owner} must include either 'chromosome' or 'chrom'.") + + +def _sort_discovery_table( + table: pd.DataFrame, + *, + contig_order: list[str], + sort_columns: list[str], +) -> pd.DataFrame: + if table.empty: + return table.reset_index(drop=True) + + sorted_table = table.copy() + sorted_table["__dimelo_contig_order"] = pd.Categorical( + sorted_table["contig"], + categories=contig_order, + ordered=True, + ) + sorted_table = sorted_table.sort_values( + ["__dimelo_contig_order", *sort_columns], + kind="stable", + ).drop(columns="__dimelo_contig_order") + return sorted_table.reset_index(drop=True) + + def _relative_position(position: float, anchor: float) -> float: return float(position) - float(anchor) @@ -552,6 +614,95 @@ def prepare_region_contrast_heatmap_data( return profile_payload +def prepare_region_discovery_scan_data( + *, + result, + contigs: list[str] | None = None, + top_n_hits: int | None = 100, + score_column: str | None = None, + include_all_windows: bool = True, +) -> dict[str, pd.DataFrame | dict[str, object]]: + _validate_region_discovery_result(result) + + windows = result.windows.copy() + hits = result.hits.copy() + active_score_column = _select_discovery_score_column(windows, score_column) + + if windows.empty: + empty_scan = _empty_discovery_scan_table(active_score_column) + empty_hits = pd.DataFrame( + columns=["window_id", "contig", "start", "end", "strand", active_score_column] + ) + return { + "scan_table": empty_scan, + "hit_table": empty_hits, + "metadata": { + "contig_order": [], + "score_column": active_score_column, + "score_mode": result.metadata.get("score"), + "contrast_mode": result.metadata.get("contrast_mode"), + "merge_hits": result.metadata.get("merge_hits"), + "top_n_hits": top_n_hits, + }, + } + + _require_columns(windows, ("window_id", "start", "end", "strand"), "result.windows") + windows_contig_column = _discovery_contig_column(windows, owner="result.windows") + windows["contig"] = windows[windows_contig_column] + + if hits.empty: + hits = pd.DataFrame(columns=windows.columns) + else: + _require_columns(hits, ("window_id", "start", "end", "strand"), "result.hits") + hits_contig_column = _discovery_contig_column(hits, owner="result.hits") + hits["contig"] = hits[hits_contig_column] + + if contigs is not None: + windows = windows.loc[windows["contig"].isin(contigs)].copy() + hits = hits.loc[hits["contig"].isin(contigs)].copy() + if windows.empty: + raise ValueError("Requested contigs are not present in RegionDiscoveryResult.windows.") + contig_order = list(contigs) + else: + contig_order = windows["contig"].drop_duplicates().tolist() + + if top_n_hits is not None and top_n_hits >= 0 and not hits.empty and "rank" in hits.columns: + hits = hits.sort_values(["rank"], kind="stable").head(top_n_hits).copy() + + hit_window_ids = set(hits.get("window_id", pd.Series(dtype="object")).tolist()) + windows["window_midpoint"] = (windows["start"] + windows["end"]) / 2.0 + windows["is_hit"] = windows["window_id"].isin(hit_window_ids) + + scan_table = windows if include_all_windows else windows.loc[windows["is_hit"]].copy() + scan_table = _sort_discovery_table( + scan_table, + contig_order=contig_order, + sort_columns=["start", "end"], + ) + + hit_sort_columns = ["start", "end"] + if "rank" in hits.columns: + hit_sort_columns = ["rank", *hit_sort_columns] + hit_table = _sort_discovery_table( + hits, + contig_order=contig_order, + sort_columns=hit_sort_columns, + ) + + return { + "scan_table": scan_table, + "hit_table": hit_table, + "metadata": { + "contig_order": contig_order, + "score_column": active_score_column, + "score_mode": result.metadata.get("score"), + "contrast_mode": result.metadata.get("contrast_mode"), + "merge_hits": result.metadata.get("merge_hits"), + "top_n_hits": top_n_hits, + }, + } + + def prepare_single_read_plot_data( table: pd.DataFrame, *, From 0ab687e955b7f0962b62d3390f1f57d9864866a5 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 15:11:03 -0700 Subject: [PATCH 142/272] fix: harden discovery scan plotting prep --- dimelo/plotting.py | 16 +++++++++++++++- tests/test_plotting.py | 41 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 56 insertions(+), 1 deletion(-) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index aec19b0..8f05d49 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -623,6 +623,8 @@ def prepare_region_discovery_scan_data( include_all_windows: bool = True, ) -> dict[str, pd.DataFrame | dict[str, object]]: _validate_region_discovery_result(result) + if top_n_hits is not None and top_n_hits < 0: + raise ValueError("top_n_hits must be non-negative.") windows = result.windows.copy() hits = result.hits.copy() @@ -666,9 +668,21 @@ def prepare_region_discovery_scan_data( else: contig_order = windows["contig"].drop_duplicates().tolist() - if top_n_hits is not None and top_n_hits >= 0 and not hits.empty and "rank" in hits.columns: + if top_n_hits is not None and not hits.empty and "rank" in hits.columns: hits = hits.sort_values(["rank"], kind="stable").head(top_n_hits).copy() + filtered_window_ids = set(windows["window_id"].tolist()) + missing_hit_window_ids = sorted( + str(window_id) + for window_id in hits["window_id"].dropna().unique() + if window_id not in filtered_window_ids + ) + if missing_hit_window_ids: + raise ValueError( + "result.hits contains window_id values not present in the filtered windows table: " + f"{', '.join(missing_hit_window_ids)}." + ) + hit_window_ids = set(hits.get("window_id", pd.Series(dtype="object")).tolist()) windows["window_midpoint"] = (windows["start"] + windows["end"]) / 2.0 windows["is_hit"] = windows["window_id"].isin(hit_window_ids) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index eb41164..859df75 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -382,6 +382,47 @@ def test_prepare_region_discovery_scan_data_limits_hit_overlay(): assert payload["scan_table"]["is_hit"].tolist() == [False, True, False] +def test_prepare_region_discovery_scan_data_rejects_negative_top_n_hits(): + result = _make_region_discovery_result() + + with pytest.raises(ValueError, match="top_n_hits must be non-negative"): + plotting.prepare_region_discovery_scan_data( + result=result, + top_n_hits=-1, + ) + + +def test_prepare_region_discovery_scan_data_rejects_hits_missing_from_filtered_windows(): + result = _make_region_discovery_result() + inconsistent_hit = pd.DataFrame( + [ + { + "window_id": "chr2:100-200:+", + "chromosome": "chr2", + "start": 100, + "end": 200, + "strand": "+", + "score_value": 0.8, + "rank": 1, + } + ] + ) + inconsistent_result = RegionDiscoveryResult( + windows=result.windows.copy(), + hits=pd.concat([result.hits, inconsistent_hit], ignore_index=True), + contrast=result.contrast, + plot_data=result.plot_data, + metadata=result.metadata, + figures=result.figures, + ) + + with pytest.raises(ValueError, match="result.hits contains window_id values not present in the filtered windows table"): + plotting.prepare_region_discovery_scan_data( + result=inconsistent_result, + contigs=["chr2"], + ) + + def test_prepare_region_contrast_profile_data_returns_all_value_modes(): result, position_table, axis, aggregation = _region_contrast_plot_setup( _region_contrast_position_rows() From 8248ff14bff29805c57eb41c3350965a60c06c56 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 15:12:27 -0700 Subject: [PATCH 143/272] test: add region discovery hit context coverage --- tests/test_plotting.py | 45 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 859df75..5d43df8 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -423,6 +423,51 @@ def test_prepare_region_discovery_scan_data_rejects_hits_missing_from_filtered_w ) +def test_prepare_region_discovery_hit_context_data_uses_top_ranked_hits(): + result = _make_region_discovery_result() + + payload = plotting.prepare_region_discovery_hit_context_data( + result=result, + top_n=1, + padding_windows=1, + ) + + assert set(payload) == {"context_table", "selected_hits", "metadata"} + assert payload["selected_hits"]["rank"].tolist() == [1] + assert payload["context_table"]["selected_hit_rank"].nunique() == 1 + assert payload["context_table"]["selected_hit_rank"].iloc[0] == 1 + assert payload["context_table"]["is_selected_hit"].sum() == 1 + + +def test_prepare_region_discovery_hit_context_data_adds_relative_window_offsets(): + result = _make_region_discovery_result() + + payload = plotting.prepare_region_discovery_hit_context_data( + result=result, + top_n=1, + padding_windows=1, + ) + + assert sorted(payload["context_table"]["relative_window_offset"].tolist()) == [-1, 0] + + +def test_prepare_region_discovery_hit_context_data_returns_empty_payload_for_no_hits(): + base_result = _make_region_discovery_result() + result = RegionDiscoveryResult( + windows=base_result.windows.copy(), + hits=pd.DataFrame(columns=base_result.hits.columns), + contrast=None, + plot_data={}, + metadata={"score": "effect_size_only", "contrast_mode": "pairwise", "merge_hits": False}, + ) + + payload = plotting.prepare_region_discovery_hit_context_data(result=result) + + assert payload["context_table"].empty + assert payload["selected_hits"].empty + assert payload["metadata"]["selection_mode"] == "top_n" + + def test_prepare_region_contrast_profile_data_returns_all_value_modes(): result, position_table, axis, aggregation = _region_contrast_plot_setup( _region_contrast_position_rows() From 5aece12482027075db4e0b591f9d723323eb29bc Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 15:16:33 -0700 Subject: [PATCH 144/272] test: tighten discovery hit context coverage --- tests/test_plotting.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 5d43df8..c5b3bd2 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -433,7 +433,10 @@ def test_prepare_region_discovery_hit_context_data_uses_top_ranked_hits(): ) assert set(payload) == {"context_table", "selected_hits", "metadata"} + assert payload["selected_hits"]["window_id"].tolist() == ["chr1:100-200:+"] assert payload["selected_hits"]["rank"].tolist() == [1] + assert payload["context_table"]["selected_hit_id"].tolist() == ["chr1:100-200:+", "chr1:100-200:+"] + assert payload["context_table"]["window_id"].tolist() == ["chr1:0-100:+", "chr1:100-200:+"] assert payload["context_table"]["selected_hit_rank"].nunique() == 1 assert payload["context_table"]["selected_hit_rank"].iloc[0] == 1 assert payload["context_table"]["is_selected_hit"].sum() == 1 @@ -448,7 +451,8 @@ def test_prepare_region_discovery_hit_context_data_adds_relative_window_offsets( padding_windows=1, ) - assert sorted(payload["context_table"]["relative_window_offset"].tolist()) == [-1, 0] + assert payload["context_table"]["window_id"].tolist() == ["chr1:0-100:+", "chr1:100-200:+"] + assert payload["context_table"]["relative_window_offset"].tolist() == [-1, 0] def test_prepare_region_discovery_hit_context_data_returns_empty_payload_for_no_hits(): From b5334c122b204f26b65f47a746f3b3be2d2b62da Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 15:18:30 -0700 Subject: [PATCH 145/272] feat: add region discovery hit context plotting prep --- dimelo/plotting.py | 134 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 134 insertions(+) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 8f05d49..49d747e 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -192,6 +192,25 @@ def _sort_discovery_table( return sorted_table.reset_index(drop=True) +def _select_region_discovery_hits( + hits: pd.DataFrame, + *, + top_n: int | None, +) -> tuple[pd.DataFrame, str]: + if top_n is not None and top_n < 0: + raise ValueError("top_n must be non-negative.") + if hits.empty: + return hits.copy(), "top_n" + + if "rank" in hits.columns: + selected = hits.sort_values(["rank"], kind="stable") + else: + selected = hits.copy() + if top_n is not None: + selected = selected.head(top_n) + return selected.copy().reset_index(drop=True), "top_n" + + def _relative_position(position: float, anchor: float) -> float: return float(position) - float(anchor) @@ -717,6 +736,121 @@ def prepare_region_discovery_scan_data( } +def prepare_region_discovery_hit_context_data( + *, + result, + top_n: int | None = 12, + hit_ids: list[str] | None = None, + padding_windows: int | None = 5, + padding_bp: int | None = None, + score_column: str | None = None, +) -> dict[str, pd.DataFrame | dict[str, object]]: + _validate_region_discovery_result(result) + if padding_windows is not None and padding_windows < 0: + raise ValueError("padding_windows must be non-negative.") + + windows = result.windows.copy() + hits = result.hits.copy() + active_score_column = _select_discovery_score_column(windows, score_column) + + context_columns = [ + "window_id", + "contig", + "start", + "end", + "strand", + active_score_column, + "window_midpoint", + "selected_hit_id", + "selected_hit_rank", + "relative_window_offset", + "is_selected_hit", + ] + selection_mode = "top_n" if hit_ids is None else "explicit_ids" + + if hits.empty or windows.empty: + return { + "context_table": pd.DataFrame(columns=context_columns), + "selected_hits": hits.copy().reset_index(drop=True), + "metadata": { + "selection_mode": selection_mode, + "top_n": top_n, + "padding_windows": padding_windows, + "padding_bp": padding_bp, + "score_column": active_score_column, + }, + } + + _require_columns(windows, ("window_id", "start", "end", "strand"), "result.windows") + _require_columns(hits, ("window_id", "start", "end", "strand"), "result.hits") + windows_contig_column = _discovery_contig_column(windows, owner="result.windows") + hits_contig_column = _discovery_contig_column(hits, owner="result.hits") + windows["contig"] = windows[windows_contig_column] + hits["contig"] = hits[hits_contig_column] + windows["window_midpoint"] = (windows["start"] + windows["end"]) / 2.0 + + contig_order = windows["contig"].drop_duplicates().tolist() + windows = _sort_discovery_table( + windows, + contig_order=contig_order, + sort_columns=["start", "end"], + ) + + if hit_ids is not None: + selected_hits = hits.loc[hits["window_id"].isin(hit_ids)].copy().reset_index(drop=True) + else: + selected_hits, selection_mode = _select_region_discovery_hits(hits, top_n=top_n) + + if selected_hits.empty: + return { + "context_table": pd.DataFrame(columns=context_columns), + "selected_hits": selected_hits, + "metadata": { + "selection_mode": selection_mode, + "top_n": top_n, + "padding_windows": padding_windows, + "padding_bp": padding_bp, + "score_column": active_score_column, + }, + } + + context_frames: list[pd.DataFrame] = [] + padding = int(padding_windows or 0) + + for _, hit in selected_hits.iterrows(): + same_contig = windows.loc[windows["contig"] == hit["contig"]].reset_index(drop=True) + hit_positions = same_contig.index[same_contig["window_id"] == hit["window_id"]].tolist() + if not hit_positions: + continue + + hit_position = hit_positions[0] + start_index = max(0, hit_position - padding) + end_index = min(len(same_contig), hit_position + padding + 1) + context = same_contig.iloc[start_index:end_index].copy() + context["selected_hit_id"] = hit["window_id"] + context["selected_hit_rank"] = hit.get("rank") + context["relative_window_offset"] = list(range(start_index - hit_position, end_index - hit_position)) + context["is_selected_hit"] = context["window_id"] == hit["window_id"] + context_frames.append(context) + + if context_frames: + context_table = pd.concat(context_frames, ignore_index=True) + else: + context_table = pd.DataFrame(columns=context_columns) + + return { + "context_table": context_table, + "selected_hits": selected_hits, + "metadata": { + "selection_mode": selection_mode, + "top_n": top_n, + "padding_windows": padding_windows, + "padding_bp": padding_bp, + "score_column": active_score_column, + }, + } + + def prepare_single_read_plot_data( table: pd.DataFrame, *, From 3adb01d2f8d629239ef925f47dba1f92cfe8769c Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 15:22:24 -0700 Subject: [PATCH 146/272] fix: harden discovery hit context prep --- dimelo/plotting.py | 14 ++++++++++++++ tests/test_plotting.py | 44 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 58 insertions(+) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 49d747e..aac28da 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -746,6 +746,8 @@ def prepare_region_discovery_hit_context_data( score_column: str | None = None, ) -> dict[str, pd.DataFrame | dict[str, object]]: _validate_region_discovery_result(result) + if padding_bp is not None: + raise ValueError("padding_bp is not supported for region discovery hit context prep.") if padding_windows is not None and padding_windows < 0: raise ValueError("padding_windows must be non-negative.") @@ -814,6 +816,18 @@ def prepare_region_discovery_hit_context_data( }, } + available_window_ids = set(windows["window_id"].dropna().tolist()) + missing_selected_hit_ids = sorted( + str(window_id) + for window_id in selected_hits["window_id"].dropna().unique() + if window_id not in available_window_ids + ) + if missing_selected_hit_ids: + raise ValueError( + "selected hits contain window_id values not present in result.windows: " + f"{', '.join(missing_selected_hit_ids)}." + ) + context_frames: list[pd.DataFrame] = [] padding = int(padding_windows or 0) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index c5b3bd2..97e199d 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -472,6 +472,50 @@ def test_prepare_region_discovery_hit_context_data_returns_empty_payload_for_no_ assert payload["metadata"]["selection_mode"] == "top_n" +def test_prepare_region_discovery_hit_context_data_rejects_padding_bp(): + result = _make_region_discovery_result() + + with pytest.raises(ValueError, match="padding_bp is not supported"): + plotting.prepare_region_discovery_hit_context_data( + result=result, + padding_bp=100, + ) + + +def test_prepare_region_discovery_hit_context_data_rejects_selected_hits_missing_from_windows(): + result = _make_region_discovery_result() + inconsistent_hit = pd.DataFrame( + [ + { + "window_id": "chr1:200-300:+", + "chromosome": "chr1", + "start": 200, + "end": 300, + "strand": "+", + "score_value": 0.7, + "rank": 0, + } + ] + ) + inconsistent_result = RegionDiscoveryResult( + windows=result.windows.copy(), + hits=pd.concat([result.hits, inconsistent_hit], ignore_index=True), + contrast=result.contrast, + plot_data=result.plot_data, + metadata=result.metadata, + figures=result.figures, + ) + + with pytest.raises( + ValueError, + match="selected hits contain window_id values not present in result.windows", + ): + plotting.prepare_region_discovery_hit_context_data( + result=inconsistent_result, + top_n=1, + ) + + def test_prepare_region_contrast_profile_data_returns_all_value_modes(): result, position_table, axis, aggregation = _region_contrast_plot_setup( _region_contrast_position_rows() From 7e6a6710e2c28760a1961edd4da8d041b842c365 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 15:23:53 -0700 Subject: [PATCH 147/272] docs: add region discovery plotting guide --- README.md | 2 ++ docs/region-discovery.md | 22 ++++++++++++++++++++++ 2 files changed, 24 insertions(+) diff --git a/README.md b/README.md index a18d22a..31fdd91 100644 --- a/README.md +++ b/README.md @@ -235,6 +235,8 @@ For an end-to-end discovery-to-clustering run, use `workflows.discovery_cluster_ For discovery-to-clustering-to-contrast follow-up, use `workflows.discovery_cluster_contrast_workflow()`. It keeps discovery output in BED-style `selected_regions`, passes the derived serializable region spec into clustering, normalizes clustering-side `region_id` values to the same `chr:start-end,strand` key used by contrasts, scores the same selected loci by default, honors an explicit `contrasts["regions"]` override when provided, and stores the full discovery scan in `metadata["full_scan_windows"]`. +`region_discovery` also exposes renderer-neutral plotting prep helpers that consume `RegionDiscoveryResult`: `prepare_region_discovery_scan_data(...)` prepares per-contig scan and hit tables by default, and `prepare_region_discovery_hit_context_data(...)` prepares local hit-context tables for small-multiple follow-up views. + For human-readable pileups (bedmethyl files, .bed) and extracted reads (.txt tab-separated values), run with `cleanup=False`. `cleanup=True` will clear these outputs because they can take up a lot of space. ### Parsing outputs diff --git a/docs/region-discovery.md b/docs/region-discovery.md index 22065f7..0d89b46 100644 --- a/docs/region-discovery.md +++ b/docs/region-discovery.md @@ -63,6 +63,28 @@ The canonical outputs are data-first: As with the newer clustering and contrast workflows, these plotting payloads are renderer-neutral tables first. Legacy orientation flags such as `regions_5to3prime` map onto the shared region-alignment model for downstream follow-up plots, while any scaled segment normalization is kept to aggregate views rather than single-read displays. +## Plotting Prep Helpers + +Use the shared plotting helpers when you want plot-ready discovery tables without committing to a specific renderer: + +```python +from dimelo import plotting + +scan_payload = plotting.prepare_region_discovery_scan_data( + result=result, + top_n_hits=50, +) + +context_payload = plotting.prepare_region_discovery_hit_context_data( + result=result, + top_n=12, + padding_windows=5, +) +``` + +- `prepare_region_discovery_scan_data(...)` consumes a `RegionDiscoveryResult` and returns renderer-neutral `scan_table`, `hit_table`, and `metadata` payloads. Scan payloads stay per-contig by default rather than projecting windows onto a cumulative genome axis. +- `prepare_region_discovery_hit_context_data(...)` consumes the same `RegionDiscoveryResult` and returns renderer-neutral `context_table`, `selected_hits`, and `metadata` payloads for small-multiple or local hit-context views. + ## Handoff Guidance - For formal region testing, convert discovered hits into BED and write them to disk before passing the BED path into `region_contrasts.score_regions(...)`. From dba6636e195dc8539ac951fcda555b759fddbc50 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 16:03:46 -0700 Subject: [PATCH 148/272] docs: add global analysis plotting spec --- ...6-04-02-global-analysis-plotting-design.md | 304 ++++++++++++++++++ 1 file changed, 304 insertions(+) create mode 100644 docs/superpowers/specs/2026-04-02-global-analysis-plotting-design.md diff --git a/docs/superpowers/specs/2026-04-02-global-analysis-plotting-design.md b/docs/superpowers/specs/2026-04-02-global-analysis-plotting-design.md new file mode 100644 index 0000000..4366c32 --- /dev/null +++ b/docs/superpowers/specs/2026-04-02-global-analysis-plotting-design.md @@ -0,0 +1,304 @@ +# Global Analysis Plotting Design + +## Goal + +Add a renderer-neutral plotting-prep layer for `dimelo.global_analysis` that makes both whole-sample summaries and tiled-window outputs easier to visualize without coupling the analysis API to a specific plotting backend. + +The first slice should help users answer two questions: + +- how do global motif fractions and normalization offsets vary across samples and conditions? +- how do tiled genome windows vary across contigs at broad scale? + +The plotting layer should remain additive and data-first, using the existing `GlobalAnalysisResult` outputs as the source of truth. + +## Scope + +This design covers: + +- plotting-prep helpers for whole-sample global summaries +- plotting-prep helpers for tiled-window broad genome views +- per-contig organization as the default window layout +- condition-level aggregation alongside per-sample summaries + +This design does not cover: + +- renderer functions +- cumulative genome axes across contigs +- normalized region-axis or segment-map plotting +- direct integration with discovery hit overlays +- any new normalization method beyond what `GlobalAnalysisResult` already provides + +## User-Facing API + +Add two public helpers in [plotting.py](../../../dimelo/plotting.py): + +- `prepare_global_analysis_summary_data(...)` +- `prepare_global_analysis_window_data(...)` + +These helpers should consume a [GlobalAnalysisResult](../../../dimelo/models.py) and return renderer-neutral payload dictionaries with plot-ready tables plus metadata. + +## Design Principles + +### Keep the analysis layer authoritative + +The plotting helpers should expose and reshape the values already computed by [global_analysis.py](../../../dimelo/global_analysis.py). They should not invent new biological normalization logic or re-derive alternative summary quantities beyond simple aggregations. + +### Separate summary and window concerns + +`GlobalAnalysisResult` naturally splits into: + +- global per-sample summary values and normalization factors +- tiled broad-window values across contigs + +The plotting API should mirror that split rather than combining both families behind a single mode switch. + +### Keep window views genome-native + +Broad window plots should stay per-contig by default. The helper should not flatten contigs into one synthetic cumulative axis in the first slice. + +## Plot Family 1: Global Summary + +### Purpose + +Prepare whole-sample and condition-level plotting payloads for global motif fractions and normalization offsets. + +### Public Entry Point + +```python +payload = plotting.prepare_global_analysis_summary_data( + result=result, + motifs=None, + aggregate_conditions=True, +) +``` + +### Inputs + +- `result: GlobalAnalysisResult` +- `motifs: list[str] | None` + - optional motif filter +- `aggregate_conditions: bool` + - when `True`, prepare condition-level summaries in addition to sample-level rows + +### Outputs + +Return a dictionary with: + +- `sample_summary` + - one row per sample and motif + - includes: + - `sample_id` + - `condition` + - `replicate` + - `motif` + - `global_fraction` +- `condition_summary` + - one row per condition and motif + - includes aggregated summaries such as: + - `condition` + - `motif` + - `global_fraction_mean` + - `global_fraction_median` + - `sample_n` + - this table may be empty when `aggregate_conditions=False` +- `normalization_table` + - sample-level normalization factors + - includes: + - `sample_id` + - `condition` + - `replicate` + - `motif` + - `global_fraction` + - `reference_fraction` + - `global_offset` +- `metadata` + - includes: + - `motifs` + - `aggregate_conditions` + +### Aggregation rules + +The helper should: + +- preserve per-sample rows directly from `result.summary` +- preserve sample-level normalization rows directly from `result.normalization_factors` +- compute condition-level summaries by grouping per sample, not by inventing new weighted schemes + +The first implementation should use simple unweighted condition-level summaries, with mean, median, and sample count as the primary outputs. + +## Plot Family 2: Broad Window Views + +### Purpose + +Prepare tiled-window plotting payloads for broad genome inspection by sample or condition. + +### Public Entry Point + +```python +payload = plotting.prepare_global_analysis_window_data( + result=result, + contigs=None, + motifs=None, + aggregate_conditions=False, +) +``` + +### Inputs + +- `result: GlobalAnalysisResult` +- `contigs: list[str] | None` + - optional filter and ordering override +- `motifs: list[str] | None` + - optional motif filter +- `aggregate_conditions: bool` + - when `True`, provide condition-level window summaries in addition to sample-level windows + +### Outputs + +Return a dictionary with: + +- `window_table` + - sample-level tiled windows + - includes: + - `sample_id` + - `condition` + - `replicate` + - `motif` + - `contig` + - `start` + - `end` + - `window_midpoint` + - `window_fraction` +- `condition_window_table` + - optional condition-level aggregation of windows + - includes: + - `condition` + - `motif` + - `contig` + - `start` + - `end` + - `window_midpoint` + - `window_fraction_mean` + - `window_fraction_median` + - `sample_n` + - may be empty when `aggregate_conditions=False` +- `metadata` + - includes: + - `contig_order` + - `motifs` + - `aggregate_conditions` + +### Default layout semantics + +The helper should default to per-contig organization, not cumulative genome coordinates. Renderers are expected to facet or panel by contig by default. + +### Derived columns + +The helper should add: + +- `contig` + - normalized alias of the `chromosome` field +- `window_midpoint` + - `(start + end) / 2` + +The helper should not alter the underlying window values beyond optional condition-level aggregation. + +## Defaults And Validation + +### Result validation + +Helpers should validate they received a `GlobalAnalysisResult`-like object with the required attributes: + +- `summary` +- `windows` +- `normalization_factors` +- `metadata` + +### Motif filtering + +If `motifs` is provided: + +- filter the relevant tables to those motifs +- raise a clear error if none of the requested motifs are present + +### Contig filtering + +If `contigs` is provided: + +- filter the window table and condition-window table to those contigs +- preserve the given order in `metadata["contig_order"]` +- raise only if none of the requested contigs are present + +### Empty results + +If the underlying tables are empty: + +- return empty stable tables with expected columns +- preserve metadata where possible +- do not raise unless required structure is missing + +## Relationship To Existing `plot_data` + +`GlobalAnalysisResult.plot_data` currently includes lightweight payloads: + +- `global_fraction_bar` +- `window_fraction_table` + +The new helpers should not depend on those names as their public contract. They may reuse the underlying tables internally if clean, but the canonical inputs remain: + +- `result.summary` +- `result.windows` +- `result.normalization_factors` + +## Backward Compatibility + +This design is additive. + +- it does not change `run_global_analysis()` +- it does not change `GlobalAnalysisResult` +- it does not remove existing `plot_data` +- it does not introduce renderer-specific coupling + +## Testing + +Add focused tests in [tests/test_plotting.py](../../../tests/test_plotting.py) for: + +- stable summary payload columns +- condition-level aggregation behavior for summary data +- stable window payload columns +- per-contig ordering behavior +- motif and contig filtering +- empty-result behavior + +Use synthetic `GlobalAnalysisResult` fixtures for most helper tests rather than full end-to-end global-analysis runs. + +## Documentation + +Update: + +- [docs/global-analysis.md](../../../docs/global-analysis.md) +- [README.md](../../../README.md) + +Document: + +- the two new helpers +- the distinction between sample-level and condition-level summaries +- the per-contig default for window payloads +- that the helpers remain data-prep only and renderer-neutral + +## Recommended Implementation Order + +1. Add plotting helper tests for global summary prep +2. Implement `prepare_global_analysis_summary_data(...)` +3. Add plotting helper tests for broad window prep +4. Implement `prepare_global_analysis_window_data(...)` +5. Update docs + +## Recommendation + +Build `global_analysis` plotting as a simple, result-centric extension of the current data-first architecture: + +- `prepare_global_analysis_summary_data(...)` +- `prepare_global_analysis_window_data(...)` + +Keep the first slice additive, per-contig by default for window views, and explicitly expose both per-sample and condition-level summaries so users can move quickly between QC-style inspection and broader comparison views. From 3bdaa40967d8968521e54057ced66063589f3f83 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 16:05:20 -0700 Subject: [PATCH 149/272] docs: add global analysis plotting plan --- .../2026-04-02-global-analysis-plotting.md | 684 ++++++++++++++++++ 1 file changed, 684 insertions(+) create mode 100644 docs/superpowers/plans/2026-04-02-global-analysis-plotting.md diff --git a/docs/superpowers/plans/2026-04-02-global-analysis-plotting.md b/docs/superpowers/plans/2026-04-02-global-analysis-plotting.md new file mode 100644 index 0000000..de7876d --- /dev/null +++ b/docs/superpowers/plans/2026-04-02-global-analysis-plotting.md @@ -0,0 +1,684 @@ +# Global Analysis Plotting Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Add renderer-neutral plotting-prep helpers for `dimelo.global_analysis` summary and broad-window views. + +**Architecture:** Extend the shared plotting module with two result-centric helpers that consume `GlobalAnalysisResult` and emit stable payload dictionaries. Keep the implementation additive and data-first: no `run_global_analysis()` changes, no renderer coupling, and per-contig broad-window organization by default. + +**Tech Stack:** Python 3.11, pandas, pytest, existing `dimelo.plotting`, `dimelo.global_analysis`, and `dimelo.models` modules + +--- + +## File Map + +- Modify: `dimelo/plotting.py` + - add internal validation/helpers for `GlobalAnalysisResult` + - add `prepare_global_analysis_summary_data(...)` + - add `prepare_global_analysis_window_data(...)` +- Modify: `tests/test_plotting.py` + - add focused plotting helper coverage using synthetic `GlobalAnalysisResult` fixtures +- Modify: `docs/global-analysis.md` + - document the new plotting-prep helpers and their data-first outputs +- Modify: `README.md` + - add one short note about the new global-analysis plotting helpers + +## Task 1: Add Failing Tests For Global Summary Plot Prep + +**Files:** +- Modify: `tests/test_plotting.py` +- Reference: `dimelo/models.py` +- Reference: `dimelo/plotting.py` + +- [ ] **Step 1: Write the failing summary-prep tests** + +Add these tests near the other plotting helper tests in `tests/test_plotting.py`: + +```python +from dimelo.models import GlobalAnalysisResult + + +def _make_global_analysis_result() -> GlobalAnalysisResult: + summary = pd.DataFrame( + [ + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "modified_count": 10, + "valid_count": 20, + "global_fraction": 0.5, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "modified_count": 16, + "valid_count": 20, + "global_fraction": 0.8, + }, + { + "sample_id": "s3", + "condition": "treated", + "replicate": 2, + "motif": "A,0", + "modified_count": 12, + "valid_count": 20, + "global_fraction": 0.6, + }, + ] + ) + normalization_factors = pd.DataFrame( + [ + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "global_fraction": 0.5, + "reference_fraction": 0.6333333333, + "global_offset": -0.1333333333, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "global_fraction": 0.8, + "reference_fraction": 0.6333333333, + "global_offset": 0.1666666667, + }, + { + "sample_id": "s3", + "condition": "treated", + "replicate": 2, + "motif": "A,0", + "global_fraction": 0.6, + "reference_fraction": 0.6333333333, + "global_offset": -0.0333333333, + }, + ] + ) + windows = pd.DataFrame( + columns=[ + "sample_id", + "condition", + "replicate", + "motif", + "window_id", + "chromosome", + "start", + "end", + "strand", + "modified_count", + "valid_count", + "window_fraction", + ] + ) + return GlobalAnalysisResult( + summary=summary, + windows=windows, + normalization_factors=normalization_factors, + plot_data={ + "global_fraction_bar": summary.copy(), + "window_fraction_table": windows.copy(), + }, + metadata={"window_size": 100000, "step_size": 50000}, + ) + + +def test_prepare_global_analysis_summary_data_returns_expected_tables(): + result = _make_global_analysis_result() + + payload = plotting.prepare_global_analysis_summary_data(result=result) + + assert set(payload) == {"sample_summary", "condition_summary", "normalization_table", "metadata"} + assert payload["sample_summary"]["sample_id"].tolist() == ["s1", "s2", "s3"] + assert payload["normalization_table"]["sample_id"].tolist() == ["s1", "s2", "s3"] + assert payload["condition_summary"]["condition"].tolist() == ["NS", "treated"] + assert payload["condition_summary"]["sample_n"].tolist() == [1, 2] + assert payload["metadata"]["motifs"] == ["A,0"] + + +def test_prepare_global_analysis_summary_data_computes_condition_means(): + result = _make_global_analysis_result() + + payload = plotting.prepare_global_analysis_summary_data(result=result) + condition_summary = payload["condition_summary"].set_index("condition") + + assert condition_summary.loc["NS", "global_fraction_mean"] == pytest.approx(0.5) + assert condition_summary.loc["treated", "global_fraction_mean"] == pytest.approx(0.7) + assert condition_summary.loc["treated", "global_fraction_median"] == pytest.approx(0.7) + + +def test_prepare_global_analysis_summary_data_filters_motifs(): + result = _make_global_analysis_result() + + payload = plotting.prepare_global_analysis_summary_data( + result=result, + motifs=["A,0"], + ) + + assert payload["sample_summary"]["motif"].unique().tolist() == ["A,0"] + assert payload["normalization_table"]["motif"].unique().tolist() == ["A,0"] +``` + +- [ ] **Step 2: Run the new summary-prep tests to verify they fail** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "global_analysis_summary_data" -q +``` + +Expected: FAIL because `prepare_global_analysis_summary_data(...)` does not yet exist. + +- [ ] **Step 3: Commit the failing tests** + +```bash +git add tests/test_plotting.py +git commit -m "test: add global analysis summary plotting coverage" +``` + +## Task 2: Implement Global Summary Plot Prep + +**Files:** +- Modify: `dimelo/plotting.py` +- Modify: `tests/test_plotting.py` + +- [ ] **Step 1: Add the internal global-analysis helpers** + +Add these internal helpers in `dimelo/plotting.py` near the other result-validation utilities: + +```python +def _validate_global_analysis_result(result) -> None: + if result is None: + raise ValueError("plotting helpers require a GlobalAnalysisResult.") + required_attrs = ("summary", "windows", "normalization_factors", "metadata") + if not all(hasattr(result, attr) for attr in required_attrs): + raise TypeError("plotting helpers require a GlobalAnalysisResult-like object.") + + +def _filter_motif_table(table: pd.DataFrame, motifs: list[str] | None, *, owner: str) -> pd.DataFrame: + if motifs is None: + return table.copy() + filtered = table.loc[table["motif"].isin(motifs)].copy() + if filtered.empty: + raise ValueError(f"Requested motifs are not present in {owner}.") + return filtered +``` + +- [ ] **Step 2: Add `prepare_global_analysis_summary_data(...)`** + +Add this public function in `dimelo/plotting.py` near the other public plotting helpers: + +```python +def prepare_global_analysis_summary_data( + *, + result, + motifs: list[str] | None = None, + aggregate_conditions: bool = True, +) -> dict[str, pd.DataFrame | dict[str, object]]: + _validate_global_analysis_result(result) + + sample_summary = _filter_motif_table(result.summary, motifs, owner="result.summary") + normalization_table = _filter_motif_table( + result.normalization_factors, + motifs, + owner="result.normalization_factors", + ) + + if sample_summary.empty: + condition_summary = pd.DataFrame( + columns=[ + "condition", + "motif", + "global_fraction_mean", + "global_fraction_median", + "sample_n", + ] + ) + motif_values: list[str] = [] if motifs is None else list(motifs) + else: + motif_values = sample_summary["motif"].drop_duplicates().tolist() + if aggregate_conditions: + condition_summary = ( + sample_summary.groupby(["condition", "motif"], as_index=False, sort=False) + .agg( + global_fraction_mean=("global_fraction", "mean"), + global_fraction_median=("global_fraction", "median"), + sample_n=("sample_id", "nunique"), + ) + .copy() + ) + else: + condition_summary = pd.DataFrame( + columns=[ + "condition", + "motif", + "global_fraction_mean", + "global_fraction_median", + "sample_n", + ] + ) + + return { + "sample_summary": sample_summary.reset_index(drop=True), + "condition_summary": condition_summary.reset_index(drop=True), + "normalization_table": normalization_table.reset_index(drop=True), + "metadata": { + "motifs": motif_values, + "aggregate_conditions": aggregate_conditions, + }, + } +``` + +- [ ] **Step 3: Run the summary-prep tests to verify they pass** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "global_analysis_summary_data" -q +``` + +Expected: PASS. + +- [ ] **Step 4: Commit the summary-prep implementation** + +```bash +git add dimelo/plotting.py tests/test_plotting.py +git commit -m "feat: add global analysis summary plotting prep" +``` + +## Task 3: Add Failing Tests For Global Window Plot Prep + +**Files:** +- Modify: `tests/test_plotting.py` +- Reference: `dimelo/plotting.py` + +- [ ] **Step 1: Add the failing window-prep tests** + +Append these tests in `tests/test_plotting.py` near the new global summary tests: + +```python +def _make_global_window_result() -> GlobalAnalysisResult: + result = _make_global_analysis_result() + result.windows = pd.DataFrame( + [ + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-100", + "chromosome": "chr1", + "start": 0, + "end": 100, + "strand": ".", + "modified_count": 5, + "valid_count": 10, + "window_fraction": 0.5, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-100", + "chromosome": "chr1", + "start": 0, + "end": 100, + "strand": ".", + "modified_count": 8, + "valid_count": 10, + "window_fraction": 0.8, + }, + { + "sample_id": "s3", + "condition": "treated", + "replicate": 2, + "motif": "A,0", + "window_id": "chr2:0-100", + "chromosome": "chr2", + "start": 0, + "end": 100, + "strand": ".", + "modified_count": 6, + "valid_count": 10, + "window_fraction": 0.6, + }, + ] + ) + result.plot_data["window_fraction_table"] = result.windows.copy() + return result + + +def test_prepare_global_analysis_window_data_returns_expected_tables(): + result = _make_global_window_result() + + payload = plotting.prepare_global_analysis_window_data(result=result) + + assert set(payload) == {"window_table", "condition_window_table", "metadata"} + assert payload["window_table"]["contig"].tolist() == ["chr1", "chr1", "chr2"] + assert payload["window_table"]["window_midpoint"].tolist() == [50.0, 50.0, 50.0] + assert payload["metadata"]["contig_order"] == ["chr1", "chr2"] + + +def test_prepare_global_analysis_window_data_filters_contigs_in_requested_order(): + result = _make_global_window_result() + + payload = plotting.prepare_global_analysis_window_data( + result=result, + contigs=["chr2"], + ) + + assert payload["metadata"]["contig_order"] == ["chr2"] + assert payload["window_table"]["contig"].tolist() == ["chr2"] + + +def test_prepare_global_analysis_window_data_aggregates_conditions(): + result = _make_global_window_result() + + payload = plotting.prepare_global_analysis_window_data( + result=result, + aggregate_conditions=True, + ) + + condition_rows = payload["condition_window_table"] + ns_row = condition_rows.loc[condition_rows["condition"] == "NS"].iloc[0] + treated_chr1 = condition_rows.loc[ + (condition_rows["condition"] == "treated") + & (condition_rows["contig"] == "chr1") + ].iloc[0] + + assert ns_row["window_fraction_mean"] == pytest.approx(0.5) + assert treated_chr1["window_fraction_mean"] == pytest.approx(0.8) +``` + +- [ ] **Step 2: Run the new window-prep tests to verify they fail** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "global_analysis_window_data" -q +``` + +Expected: FAIL because `prepare_global_analysis_window_data(...)` does not yet exist. + +- [ ] **Step 3: Commit the failing window-prep tests** + +```bash +git add tests/test_plotting.py +git commit -m "test: add global analysis window plotting coverage" +``` + +## Task 4: Implement Global Window Plot Prep + +**Files:** +- Modify: `dimelo/plotting.py` +- Modify: `tests/test_plotting.py` + +- [ ] **Step 1: Add `prepare_global_analysis_window_data(...)`** + +Add this public function in `dimelo/plotting.py` near the new summary helper: + +```python +def prepare_global_analysis_window_data( + *, + result, + contigs: list[str] | None = None, + motifs: list[str] | None = None, + aggregate_conditions: bool = False, +) -> dict[str, pd.DataFrame | dict[str, object]]: + _validate_global_analysis_result(result) + + window_table = _filter_motif_table(result.windows, motifs, owner="result.windows") + + if window_table.empty: + condition_window_table = pd.DataFrame( + columns=[ + "condition", + "motif", + "contig", + "start", + "end", + "window_midpoint", + "window_fraction_mean", + "window_fraction_median", + "sample_n", + ] + ) + return { + "window_table": pd.DataFrame( + columns=[ + "sample_id", + "condition", + "replicate", + "motif", + "window_id", + "contig", + "start", + "end", + "strand", + "window_fraction", + "window_midpoint", + ] + ), + "condition_window_table": condition_window_table, + "metadata": { + "contig_order": [], + "motifs": [] if motifs is None else list(motifs), + "aggregate_conditions": aggregate_conditions, + }, + } + + window_table = window_table.copy() + window_table["contig"] = window_table["chromosome"] + + if contigs is not None: + window_table = window_table.loc[window_table["contig"].isin(contigs)].copy() + if window_table.empty: + raise ValueError("Requested contigs are not present in result.windows.") + contig_order = list(contigs) + else: + contig_order = window_table["contig"].drop_duplicates().tolist() + + window_table["window_midpoint"] = (window_table["start"] + window_table["end"]) / 2.0 + window_table = _sort_discovery_table( + window_table, + contig_order=contig_order, + sort_columns=["start", "end", "sample_id"], + ) + + if aggregate_conditions: + condition_window_table = ( + window_table.groupby( + ["condition", "motif", "contig", "start", "end", "window_midpoint"], + as_index=False, + sort=False, + ) + .agg( + window_fraction_mean=("window_fraction", "mean"), + window_fraction_median=("window_fraction", "median"), + sample_n=("sample_id", "nunique"), + ) + .copy() + ) + condition_window_table = _sort_discovery_table( + condition_window_table, + contig_order=contig_order, + sort_columns=["start", "end", "condition"], + ) + else: + condition_window_table = pd.DataFrame( + columns=[ + "condition", + "motif", + "contig", + "start", + "end", + "window_midpoint", + "window_fraction_mean", + "window_fraction_median", + "sample_n", + ] + ) + + return { + "window_table": window_table.reset_index(drop=True), + "condition_window_table": condition_window_table.reset_index(drop=True), + "metadata": { + "contig_order": contig_order, + "motifs": window_table["motif"].drop_duplicates().tolist(), + "aggregate_conditions": aggregate_conditions, + }, + } +``` + +- [ ] **Step 2: Run the window-prep tests to verify they pass** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "global_analysis_window_data" -q +``` + +Expected: PASS. + +- [ ] **Step 3: Run the combined global-analysis plotting subset** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "global_analysis_summary_data or global_analysis_window_data" -q +``` + +Expected: PASS. + +- [ ] **Step 4: Commit the window-prep implementation** + +```bash +git add dimelo/plotting.py tests/test_plotting.py +git commit -m "feat: add global analysis window plotting prep" +``` + +## Task 5: Document The New Global Analysis Plotting Helpers + +**Files:** +- Modify: `docs/global-analysis.md` +- Modify: `README.md` +- Verify: `tests/test_plotting.py` + +- [ ] **Step 1: Add a short global-analysis plotting section to the guide** + +Append a short section to `docs/global-analysis.md` with an example like: + +```python +from dimelo import plotting + +summary_payload = plotting.prepare_global_analysis_summary_data( + result=result, + aggregate_conditions=True, +) + +window_payload = plotting.prepare_global_analysis_window_data( + result=result, + aggregate_conditions=True, +) +``` + +Explain briefly: + +- summary payloads include sample-level and condition-level views +- normalization values are exposed through `normalization_table` +- window payloads stay per-contig by default +- both helpers are data-prep only and renderer-neutral + +- [ ] **Step 2: Add one short README note** + +Add one short paragraph to `README.md` near the analysis guides or plotting section explaining: + +- `global_analysis` now has renderer-neutral summary and broad-window plotting helpers +- they consume `GlobalAnalysisResult` +- broad-window payloads stay per-contig by default + +- [ ] **Step 3: Run the touched plotting test file** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -q +``` + +Expected: PASS. + +- [ ] **Step 4: Commit the docs pass** + +```bash +git add docs/global-analysis.md README.md tests/test_plotting.py dimelo/plotting.py +git commit -m "docs: add global analysis plotting guide" +``` + +## Final Verification + +**Files:** +- Verify: `dimelo/plotting.py` +- Verify: `tests/test_plotting.py` +- Verify: `docs/global-analysis.md` +- Verify: `README.md` + +- [ ] **Step 1: Run the focused plotting verification** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl XDG_CACHE_HOME=/tmp/xdg-cache PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -q +``` + +Expected: PASS. + +- [ ] **Step 2: Confirm the working tree is clean** + +Run: + +```bash +git status --short +``` + +Expected: no output. + +- [ ] **Step 3: Summarize outcomes** + +Capture in the handoff: + +- which public helpers were added +- which payload tables they return +- that summary helpers expose both sample-level and condition-level views +- that broad-window helpers stay per-contig by default + +## Self-Review + +Spec coverage check: + +- summary helper with sample and condition views: covered in Tasks 1-2 +- normalization-table exposure: covered in Task 2 and Task 5 docs +- broad-window helper with per-contig default: covered in Tasks 3-4 and Task 5 docs +- additive/data-first behavior: preserved throughout with no `run_global_analysis()` changes + +Placeholder scan: + +- no `TODO`, `TBD`, or undefined steps remain +- each task includes exact files, commands, and implementation guidance + +Type consistency: + +- helper names match the approved spec +- payload keys remain aligned with the design: + - `sample_summary` + - `condition_summary` + - `normalization_table` + - `window_table` + - `condition_window_table` + - `metadata` From 94fd3325a92fdb1ec3b8304d4497888c4999ac77 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 16:08:54 -0700 Subject: [PATCH 150/272] test: add global analysis summary plotting coverage --- tests/test_plotting.py | 134 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 133 insertions(+), 1 deletion(-) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 97e199d..0b6590f 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -2,7 +2,12 @@ import pandas as pd import pytest -from dimelo.models import ContrastSpec, RegionContrastResult, RegionDiscoveryResult +from dimelo.models import ( + ContrastSpec, + GlobalAnalysisResult, + RegionContrastResult, + RegionDiscoveryResult, +) from dimelo import plot_enrichment_profile, plot_reads, plotting @@ -342,6 +347,97 @@ def _make_region_discovery_result() -> RegionDiscoveryResult: ) +def _make_global_analysis_result() -> GlobalAnalysisResult: + summary = pd.DataFrame( + [ + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "modified_count": 10, + "valid_count": 20, + "global_fraction": 0.5, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "modified_count": 16, + "valid_count": 20, + "global_fraction": 0.8, + }, + { + "sample_id": "s3", + "condition": "treated", + "replicate": 2, + "motif": "A,0", + "modified_count": 12, + "valid_count": 20, + "global_fraction": 0.6, + }, + ] + ) + normalization_factors = pd.DataFrame( + [ + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "global_fraction": 0.5, + "reference_fraction": 0.6333333333, + "global_offset": -0.1333333333, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "global_fraction": 0.8, + "reference_fraction": 0.6333333333, + "global_offset": 0.1666666667, + }, + { + "sample_id": "s3", + "condition": "treated", + "replicate": 2, + "motif": "A,0", + "global_fraction": 0.6, + "reference_fraction": 0.6333333333, + "global_offset": -0.0333333333, + }, + ] + ) + windows = pd.DataFrame( + columns=[ + "sample_id", + "condition", + "replicate", + "motif", + "window_id", + "chromosome", + "start", + "end", + "strand", + "modified_count", + "valid_count", + "window_fraction", + ] + ) + return GlobalAnalysisResult( + summary=summary, + windows=windows, + normalization_factors=normalization_factors, + plot_data={ + "global_fraction_bar": summary.copy(), + "window_fraction_table": windows.copy(), + }, + metadata={"window_size": 100000, "step_size": 50000}, + ) + + def test_prepare_region_discovery_scan_data_returns_expected_tables(): result = _make_region_discovery_result() @@ -472,6 +568,42 @@ def test_prepare_region_discovery_hit_context_data_returns_empty_payload_for_no_ assert payload["metadata"]["selection_mode"] == "top_n" +def test_prepare_global_analysis_summary_data_returns_expected_tables(): + result = _make_global_analysis_result() + + payload = plotting.prepare_global_analysis_summary_data(result=result) + + assert set(payload) == {"sample_summary", "condition_summary", "normalization_table", "metadata"} + assert payload["sample_summary"]["sample_id"].tolist() == ["s1", "s2", "s3"] + assert payload["normalization_table"]["sample_id"].tolist() == ["s1", "s2", "s3"] + assert payload["condition_summary"]["condition"].tolist() == ["NS", "treated"] + assert payload["condition_summary"]["sample_n"].tolist() == [1, 2] + assert payload["metadata"]["motifs"] == ["A,0"] + + +def test_prepare_global_analysis_summary_data_computes_condition_means(): + result = _make_global_analysis_result() + + payload = plotting.prepare_global_analysis_summary_data(result=result) + condition_summary = payload["condition_summary"].set_index("condition") + + assert condition_summary.loc["NS", "global_fraction_mean"] == pytest.approx(0.5) + assert condition_summary.loc["treated", "global_fraction_mean"] == pytest.approx(0.7) + assert condition_summary.loc["treated", "global_fraction_median"] == pytest.approx(0.7) + + +def test_prepare_global_analysis_summary_data_filters_motifs(): + result = _make_global_analysis_result() + + payload = plotting.prepare_global_analysis_summary_data( + result=result, + motifs=["A,0"], + ) + + assert payload["sample_summary"]["motif"].unique().tolist() == ["A,0"] + assert payload["normalization_table"]["motif"].unique().tolist() == ["A,0"] + + def test_prepare_region_discovery_hit_context_data_rejects_padding_bp(): result = _make_region_discovery_result() From 964deaa65c96c9d1b998289809ef147d569e41ed Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 16:10:39 -0700 Subject: [PATCH 151/272] test: tighten global analysis motif filtering coverage --- tests/test_plotting.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 0b6590f..5f1fef0 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -377,6 +377,15 @@ def _make_global_analysis_result() -> GlobalAnalysisResult: "valid_count": 20, "global_fraction": 0.6, }, + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "CG,0", + "modified_count": 4, + "valid_count": 20, + "global_fraction": 0.2, + }, ] ) normalization_factors = pd.DataFrame( @@ -408,6 +417,15 @@ def _make_global_analysis_result() -> GlobalAnalysisResult: "reference_fraction": 0.6333333333, "global_offset": -0.0333333333, }, + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "CG,0", + "global_fraction": 0.2, + "reference_fraction": 0.2, + "global_offset": 0.0, + }, ] ) windows = pd.DataFrame( @@ -602,6 +620,8 @@ def test_prepare_global_analysis_summary_data_filters_motifs(): assert payload["sample_summary"]["motif"].unique().tolist() == ["A,0"] assert payload["normalization_table"]["motif"].unique().tolist() == ["A,0"] + assert "CG,0" not in payload["sample_summary"]["motif"].tolist() + assert "CG,0" not in payload["normalization_table"]["motif"].tolist() def test_prepare_region_discovery_hit_context_data_rejects_padding_bp(): From 51b54dc250a020abd3e579f88c7bc47bc83aa542 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 16:13:27 -0700 Subject: [PATCH 152/272] feat: add global analysis summary plotting prep --- dimelo/plotting.py | 81 ++++++++++++++++++++++++++++++++++++++++++ tests/test_plotting.py | 21 ++++++----- 2 files changed, 93 insertions(+), 9 deletions(-) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index aac28da..6c8693c 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -130,6 +130,25 @@ def _region_contrast_metadata(result) -> dict[str, object]: } +def _validate_global_analysis_result(result) -> None: + if result is None: + raise ValueError("plotting helpers require a GlobalAnalysisResult.") + required_attrs = ("summary", "windows", "normalization_factors", "metadata") + if not all(hasattr(result, attr) for attr in required_attrs): + raise TypeError("plotting helpers require a GlobalAnalysisResult-like object.") + + +def _filter_motif_table(table: pd.DataFrame, motifs: list[str] | None, *, owner: str) -> pd.DataFrame: + _require_columns(table, ("motif",), owner) + if motifs is None: + return table.copy() + + filtered = table.loc[table["motif"].isin(motifs)].copy() + if filtered.empty: + raise ValueError(f"Requested motifs are not present in {owner}.") + return filtered + + def _validate_region_discovery_result(result) -> None: if result is None: raise ValueError("plotting helpers require a RegionDiscoveryResult.") @@ -633,6 +652,68 @@ def prepare_region_contrast_heatmap_data( return profile_payload +def prepare_global_analysis_summary_data( + *, + result, + motifs: list[str] | None = None, + aggregate_conditions: bool = True, +) -> dict[str, pd.DataFrame | dict[str, object]]: + _validate_global_analysis_result(result) + + sample_summary = _filter_motif_table(result.summary, motifs, owner="result.summary") + normalization_table = _filter_motif_table( + result.normalization_factors, + motifs, + owner="result.normalization_factors", + ) + + if sample_summary.empty: + condition_summary = pd.DataFrame( + columns=[ + "condition", + "motif", + "global_fraction_mean", + "global_fraction_median", + "sample_n", + ] + ) + motif_values = list(motifs) if motifs is not None else [] + else: + motif_values = sample_summary["motif"].drop_duplicates().tolist() + if aggregate_conditions: + condition_summary = ( + sample_summary.groupby(["condition", "motif"], as_index=False, sort=False) + .agg( + global_fraction_mean=("global_fraction", "mean"), + global_fraction_median=("global_fraction", "median"), + sample_n=("sample_id", "nunique"), + ) + .copy() + ) + else: + condition_summary = pd.DataFrame( + columns=[ + "condition", + "motif", + "global_fraction_mean", + "global_fraction_median", + "sample_n", + ] + ) + + return { + "sample_summary": sample_summary.reset_index(drop=True), + "condition_summary": condition_summary.reset_index(drop=True), + "normalization_table": normalization_table.reset_index(drop=True), + "metadata": { + "motifs": motif_values, + "window_size": result.metadata.get("window_size"), + "step_size": result.metadata.get("step_size"), + "aggregate_conditions": aggregate_conditions, + }, + } + + def prepare_region_discovery_scan_data( *, result, diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 5f1fef0..5eaa96a 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -592,22 +592,25 @@ def test_prepare_global_analysis_summary_data_returns_expected_tables(): payload = plotting.prepare_global_analysis_summary_data(result=result) assert set(payload) == {"sample_summary", "condition_summary", "normalization_table", "metadata"} - assert payload["sample_summary"]["sample_id"].tolist() == ["s1", "s2", "s3"] - assert payload["normalization_table"]["sample_id"].tolist() == ["s1", "s2", "s3"] - assert payload["condition_summary"]["condition"].tolist() == ["NS", "treated"] - assert payload["condition_summary"]["sample_n"].tolist() == [1, 2] - assert payload["metadata"]["motifs"] == ["A,0"] + assert payload["sample_summary"]["sample_id"].tolist() == ["s1", "s2", "s3", "s1"] + assert payload["normalization_table"]["sample_id"].tolist() == ["s1", "s2", "s3", "s1"] + assert ( + payload["condition_summary"][["condition", "motif"]].apply(tuple, axis=1).tolist() + == [("NS", "A,0"), ("treated", "A,0"), ("NS", "CG,0")] + ) + assert payload["condition_summary"]["sample_n"].tolist() == [1, 2, 1] + assert payload["metadata"]["motifs"] == ["A,0", "CG,0"] def test_prepare_global_analysis_summary_data_computes_condition_means(): result = _make_global_analysis_result() payload = plotting.prepare_global_analysis_summary_data(result=result) - condition_summary = payload["condition_summary"].set_index("condition") + condition_summary = payload["condition_summary"].set_index(["condition", "motif"]) - assert condition_summary.loc["NS", "global_fraction_mean"] == pytest.approx(0.5) - assert condition_summary.loc["treated", "global_fraction_mean"] == pytest.approx(0.7) - assert condition_summary.loc["treated", "global_fraction_median"] == pytest.approx(0.7) + assert condition_summary.loc[("NS", "A,0"), "global_fraction_mean"] == pytest.approx(0.5) + assert condition_summary.loc[("treated", "A,0"), "global_fraction_mean"] == pytest.approx(0.7) + assert condition_summary.loc[("treated", "A,0"), "global_fraction_median"] == pytest.approx(0.7) def test_prepare_global_analysis_summary_data_filters_motifs(): From 9e74de8dc0bc9b66a4d6c224d336be4667ece051 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 16:16:32 -0700 Subject: [PATCH 153/272] fix: harden global analysis summary plotting prep --- dimelo/plotting.py | 24 ++++++++++++++++++++++++ tests/test_plotting.py | 12 ++++++++++++ 2 files changed, 36 insertions(+) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 6c8693c..8710654 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -659,6 +659,30 @@ def prepare_global_analysis_summary_data( aggregate_conditions: bool = True, ) -> dict[str, pd.DataFrame | dict[str, object]]: _validate_global_analysis_result(result) + _require_columns( + result.summary, + ( + "sample_id", + "condition", + "motif", + "modified_count", + "valid_count", + "global_fraction", + ), + "result.summary", + ) + _require_columns( + result.normalization_factors, + ( + "sample_id", + "condition", + "motif", + "global_fraction", + "reference_fraction", + "global_offset", + ), + "result.normalization_factors", + ) sample_summary = _filter_motif_table(result.summary, motifs, owner="result.summary") normalization_table = _filter_motif_table( diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 5eaa96a..2877bd8 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -627,6 +627,18 @@ def test_prepare_global_analysis_summary_data_filters_motifs(): assert "CG,0" not in payload["normalization_table"]["motif"].tolist() +def test_prepare_global_analysis_summary_data_skips_condition_aggregation_when_disabled(): + result = _make_global_analysis_result() + + payload = plotting.prepare_global_analysis_summary_data( + result=result, + aggregate_conditions=False, + ) + + assert payload["condition_summary"].empty + assert payload["metadata"]["aggregate_conditions"] is False + + def test_prepare_region_discovery_hit_context_data_rejects_padding_bp(): result = _make_region_discovery_result() From 51bb02eb90c9e1e869d8798b4612b2e05338b46b Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 16:18:52 -0700 Subject: [PATCH 154/272] test: add global analysis window plotting coverage --- tests/test_plotting.py | 94 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 94 insertions(+) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 2877bd8..0381e66 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -456,6 +456,58 @@ def _make_global_analysis_result() -> GlobalAnalysisResult: ) +def _make_global_window_result() -> GlobalAnalysisResult: + result = _make_global_analysis_result() + result.windows = pd.DataFrame( + [ + { + "sample_id": "s1", + "condition": "NS", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-100", + "chromosome": "chr1", + "start": 0, + "end": 100, + "strand": ".", + "modified_count": 5, + "valid_count": 10, + "window_fraction": 0.5, + }, + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-100", + "chromosome": "chr1", + "start": 0, + "end": 100, + "strand": ".", + "modified_count": 8, + "valid_count": 10, + "window_fraction": 0.8, + }, + { + "sample_id": "s3", + "condition": "treated", + "replicate": 2, + "motif": "A,0", + "window_id": "chr2:0-100", + "chromosome": "chr2", + "start": 0, + "end": 100, + "strand": ".", + "modified_count": 6, + "valid_count": 10, + "window_fraction": 0.6, + }, + ] + ) + result.plot_data["window_fraction_table"] = result.windows.copy() + return result + + def test_prepare_region_discovery_scan_data_returns_expected_tables(): result = _make_region_discovery_result() @@ -639,6 +691,48 @@ def test_prepare_global_analysis_summary_data_skips_condition_aggregation_when_d assert payload["metadata"]["aggregate_conditions"] is False +def test_prepare_global_analysis_window_data_returns_expected_tables(): + result = _make_global_window_result() + + payload = plotting.prepare_global_analysis_window_data(result=result) + + assert set(payload) == {"window_table", "condition_window_table", "metadata"} + assert payload["window_table"]["contig"].tolist() == ["chr1", "chr1", "chr2"] + assert payload["window_table"]["window_midpoint"].tolist() == [50.0, 50.0, 50.0] + assert payload["metadata"]["contig_order"] == ["chr1", "chr2"] + + +def test_prepare_global_analysis_window_data_filters_contigs_in_requested_order(): + result = _make_global_window_result() + + payload = plotting.prepare_global_analysis_window_data( + result=result, + contigs=["chr2"], + ) + + assert payload["metadata"]["contig_order"] == ["chr2"] + assert payload["window_table"]["contig"].tolist() == ["chr2"] + + +def test_prepare_global_analysis_window_data_aggregates_conditions(): + result = _make_global_window_result() + + payload = plotting.prepare_global_analysis_window_data( + result=result, + aggregate_conditions=True, + ) + + condition_rows = payload["condition_window_table"] + ns_row = condition_rows.loc[condition_rows["condition"] == "NS"].iloc[0] + treated_chr1 = condition_rows.loc[ + (condition_rows["condition"] == "treated") + & (condition_rows["contig"] == "chr1") + ].iloc[0] + + assert ns_row["window_fraction_mean"] == pytest.approx(0.5) + assert treated_chr1["window_fraction_mean"] == pytest.approx(0.8) + + def test_prepare_region_discovery_hit_context_data_rejects_padding_bp(): result = _make_region_discovery_result() From 5c8999ccf6576e971bba20e45cfe0befaacbc4ad Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 16:21:11 -0700 Subject: [PATCH 155/272] test: tighten global analysis window coverage --- tests/test_plotting.py | 22 +++++++++++++++++++--- 1 file changed, 19 insertions(+), 3 deletions(-) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 0381e66..06ebc34 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -488,6 +488,20 @@ def _make_global_window_result() -> GlobalAnalysisResult: "valid_count": 10, "window_fraction": 0.8, }, + { + "sample_id": "s3", + "condition": "treated", + "replicate": 2, + "motif": "A,0", + "window_id": "chr1:0-100", + "chromosome": "chr1", + "start": 0, + "end": 100, + "strand": ".", + "modified_count": 4, + "valid_count": 10, + "window_fraction": 0.4, + }, { "sample_id": "s3", "condition": "treated", @@ -697,8 +711,9 @@ def test_prepare_global_analysis_window_data_returns_expected_tables(): payload = plotting.prepare_global_analysis_window_data(result=result) assert set(payload) == {"window_table", "condition_window_table", "metadata"} - assert payload["window_table"]["contig"].tolist() == ["chr1", "chr1", "chr2"] - assert payload["window_table"]["window_midpoint"].tolist() == [50.0, 50.0, 50.0] + assert payload["window_table"]["contig"].tolist() == ["chr1", "chr1", "chr1", "chr2"] + assert payload["window_table"]["window_midpoint"].tolist() == [50.0, 50.0, 50.0, 50.0] + assert payload["condition_window_table"].empty assert payload["metadata"]["contig_order"] == ["chr1", "chr2"] @@ -730,7 +745,8 @@ def test_prepare_global_analysis_window_data_aggregates_conditions(): ].iloc[0] assert ns_row["window_fraction_mean"] == pytest.approx(0.5) - assert treated_chr1["window_fraction_mean"] == pytest.approx(0.8) + assert treated_chr1["window_fraction_mean"] == pytest.approx(0.6) + assert treated_chr1["sample_n"] == 2 def test_prepare_region_discovery_hit_context_data_rejects_padding_bp(): From 861fa8317e3b2ff2074f73a02d392da093540a55 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 16:22:59 -0700 Subject: [PATCH 156/272] feat: add global analysis window plotting prep --- dimelo/plotting.py | 125 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 125 insertions(+) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 8710654..4b06bad 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -738,6 +738,131 @@ def prepare_global_analysis_summary_data( } +def prepare_global_analysis_window_data( + *, + result, + contigs: list[str] | None = None, + motifs: list[str] | None = None, + aggregate_conditions: bool = False, +) -> dict[str, pd.DataFrame | dict[str, object]]: + _validate_global_analysis_result(result) + + condition_window_columns = [ + "condition", + "motif", + "contig", + "start", + "end", + "window_midpoint", + "window_fraction_mean", + "window_fraction_median", + "sample_n", + ] + empty_window_columns = [ + "sample_id", + "condition", + "replicate", + "motif", + "window_id", + "contig", + "start", + "end", + "strand", + "window_fraction", + "window_midpoint", + ] + + if result.windows is None: + return { + "window_table": pd.DataFrame(columns=empty_window_columns), + "condition_window_table": pd.DataFrame(columns=condition_window_columns), + "metadata": { + "contig_order": [], + "motifs": [] if motifs is None else list(motifs), + "aggregate_conditions": aggregate_conditions, + }, + } + + _require_columns( + result.windows, + ( + "sample_id", + "condition", + "replicate", + "motif", + "window_id", + "chromosome", + "start", + "end", + "strand", + "window_fraction", + ), + "result.windows", + ) + window_table = _filter_motif_table(result.windows, motifs, owner="result.windows") + + if window_table.empty: + return { + "window_table": pd.DataFrame(columns=empty_window_columns), + "condition_window_table": pd.DataFrame(columns=condition_window_columns), + "metadata": { + "contig_order": [], + "motifs": [] if motifs is None else list(motifs), + "aggregate_conditions": aggregate_conditions, + }, + } + + window_table = window_table.copy() + window_table["contig"] = window_table["chromosome"] + + if contigs is not None: + window_table = window_table.loc[window_table["contig"].isin(contigs)].copy() + if window_table.empty: + raise ValueError("Requested contigs are not present in result.windows.") + contig_order = list(contigs) + else: + contig_order = window_table["contig"].drop_duplicates().tolist() + + window_table["window_midpoint"] = (window_table["start"] + window_table["end"]) / 2.0 + window_table = _sort_discovery_table( + window_table, + contig_order=contig_order, + sort_columns=["start", "end", "sample_id"], + ) + + if aggregate_conditions: + condition_window_table = ( + window_table.groupby( + ["condition", "motif", "contig", "start", "end", "window_midpoint"], + as_index=False, + sort=False, + ) + .agg( + window_fraction_mean=("window_fraction", "mean"), + window_fraction_median=("window_fraction", "median"), + sample_n=("sample_id", "nunique"), + ) + .copy() + ) + condition_window_table = _sort_discovery_table( + condition_window_table, + contig_order=contig_order, + sort_columns=["start", "end", "condition"], + ) + else: + condition_window_table = pd.DataFrame(columns=condition_window_columns) + + return { + "window_table": window_table.reset_index(drop=True), + "condition_window_table": condition_window_table.reset_index(drop=True), + "metadata": { + "contig_order": contig_order, + "motifs": window_table["motif"].drop_duplicates().tolist(), + "aggregate_conditions": aggregate_conditions, + }, + } + + def prepare_region_discovery_scan_data( *, result, From da95cbb4f9f5df278bb2609fc19374c58d2d23d7 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 16:28:25 -0700 Subject: [PATCH 157/272] fix: harden global analysis window plotting prep --- dimelo/plotting.py | 25 ++++++++++++++++++++++--- tests/test_plotting.py | 40 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 62 insertions(+), 3 deletions(-) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 4b06bad..8289a2a 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -791,7 +791,6 @@ def prepare_global_analysis_window_data( "replicate", "motif", "window_id", - "chromosome", "start", "end", "strand", @@ -813,7 +812,8 @@ def prepare_global_analysis_window_data( } window_table = window_table.copy() - window_table["contig"] = window_table["chromosome"] + windows_contig_column = _discovery_contig_column(window_table, owner="result.windows") + window_table["contig"] = window_table[windows_contig_column] if contigs is not None: window_table = window_table.loc[window_table["contig"].isin(contigs)].copy() @@ -831,8 +831,27 @@ def prepare_global_analysis_window_data( ) if aggregate_conditions: - condition_window_table = ( + sample_window_table = ( window_table.groupby( + [ + "sample_id", + "condition", + "replicate", + "motif", + "window_id", + "contig", + "start", + "end", + "window_midpoint", + ], + as_index=False, + sort=False, + ) + .agg(window_fraction=("window_fraction", "mean")) + .copy() + ) + condition_window_table = ( + sample_window_table.groupby( ["condition", "motif", "contig", "start", "end", "window_midpoint"], as_index=False, sort=False, diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 06ebc34..b00f807 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -749,6 +749,46 @@ def test_prepare_global_analysis_window_data_aggregates_conditions(): assert treated_chr1["sample_n"] == 2 +def test_prepare_global_analysis_window_data_aggregates_per_sample_windows_with_chrom_alias(): + result = _make_global_window_result() + duplicate_sample_window = pd.DataFrame( + [ + { + "sample_id": "s2", + "condition": "treated", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-100", + "chromosome": "chr1", + "start": 0, + "end": 100, + "strand": ".", + "modified_count": 2, + "valid_count": 10, + "window_fraction": 0.2, + } + ] + ) + result.windows = pd.concat([result.windows, duplicate_sample_window], ignore_index=True).rename( + columns={"chromosome": "chrom"} + ) + result.plot_data["window_fraction_table"] = result.windows.copy() + + payload = plotting.prepare_global_analysis_window_data( + result=result, + aggregate_conditions=True, + ) + + treated_chr1 = payload["condition_window_table"].loc[ + (payload["condition_window_table"]["condition"] == "treated") + & (payload["condition_window_table"]["contig"] == "chr1") + ].iloc[0] + + assert treated_chr1["window_fraction_mean"] == pytest.approx(0.45) + assert treated_chr1["window_fraction_median"] == pytest.approx(0.45) + assert treated_chr1["sample_n"] == 2 + + def test_prepare_region_discovery_hit_context_data_rejects_padding_bp(): result = _make_region_discovery_result() From 3d6e93499ecff824a6c195f7e95cbfe2dcb31e9e Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 16:30:03 -0700 Subject: [PATCH 158/272] fix: align global window aggregation semantics --- dimelo/plotting.py | 1 - tests/test_plotting.py | 4 ++-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 8289a2a..8f0e9e2 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -836,7 +836,6 @@ def prepare_global_analysis_window_data( [ "sample_id", "condition", - "replicate", "motif", "window_id", "contig", diff --git a/tests/test_plotting.py b/tests/test_plotting.py index b00f807..c4c2229 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -749,14 +749,14 @@ def test_prepare_global_analysis_window_data_aggregates_conditions(): assert treated_chr1["sample_n"] == 2 -def test_prepare_global_analysis_window_data_aggregates_per_sample_windows_with_chrom_alias(): +def test_prepare_global_analysis_window_data_aggregates_per_sample_windows_across_replicates_with_chrom_alias(): result = _make_global_window_result() duplicate_sample_window = pd.DataFrame( [ { "sample_id": "s2", "condition": "treated", - "replicate": 1, + "replicate": 2, "motif": "A,0", "window_id": "chr1:0-100", "chromosome": "chr1", From 2b00bd639bb4e92989129cbabc09056d3a9af904 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 16:32:22 -0700 Subject: [PATCH 159/272] docs: add global analysis plotting guide --- README.md | 2 ++ docs/global-analysis.md | 21 +++++++++++++++++++++ 2 files changed, 23 insertions(+) diff --git a/README.md b/README.md index 31fdd91..44865ee 100644 --- a/README.md +++ b/README.md @@ -237,6 +237,8 @@ For discovery-to-clustering-to-contrast follow-up, use `workflows.discovery_clus `region_discovery` also exposes renderer-neutral plotting prep helpers that consume `RegionDiscoveryResult`: `prepare_region_discovery_scan_data(...)` prepares per-contig scan and hit tables by default, and `prepare_region_discovery_hit_context_data(...)` prepares local hit-context tables for small-multiple follow-up views. +`global_analysis` now exposes renderer-neutral plotting prep helpers that consume `GlobalAnalysisResult`: `prepare_global_analysis_summary_data(...)` prepares sample-level summaries, optional condition-level views, and normalization tables, while `prepare_global_analysis_window_data(...)` prepares broad-window payloads that stay per-contig by default. + For human-readable pileups (bedmethyl files, .bed) and extracted reads (.txt tab-separated values), run with `cleanup=False`. `cleanup=True` will clear these outputs because they can take up a lot of space. ### Parsing outputs diff --git a/docs/global-analysis.md b/docs/global-analysis.md index a961484..e851ce8 100644 --- a/docs/global-analysis.md +++ b/docs/global-analysis.md @@ -41,3 +41,24 @@ result = global_analysis.run_global_analysis( - `result.plot_data["window_fraction_table"]` The wrapper does not couple the workflow to a plotting backend. If you want to render the results yourself, use the returned tables directly. + +## Plotting Prep Helpers + +Use the shared plotting helpers when you want plot-ready global-analysis tables without committing to a specific renderer: + +```python +from dimelo import plotting + +summary_payload = plotting.prepare_global_analysis_summary_data( + result=result, + aggregate_conditions=True, +) + +window_payload = plotting.prepare_global_analysis_window_data( + result=result, + aggregate_conditions=True, +) +``` + +- `prepare_global_analysis_summary_data(...)` consumes a `GlobalAnalysisResult` and returns renderer-neutral `sample_summary`, `condition_summary`, `normalization_table`, and `metadata` payloads. The summary payload exposes both sample-level rows and optional condition-level views, while normalization values stay available through `normalization_table`. +- `prepare_global_analysis_window_data(...)` consumes the same `GlobalAnalysisResult` and returns renderer-neutral `window_table`, `condition_window_table`, and `metadata` payloads. Broad-window payloads stay per-contig by default rather than flattening onto a cumulative genome axis. From d20c03ebae7e262f5432fa80441dd84ea9574974 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 18:52:55 -0700 Subject: [PATCH 160/272] docs: add docs coherence cleanup spec --- ...cs-coherence-and-discoverability-design.md | 178 ++++++++++++++++++ 1 file changed, 178 insertions(+) create mode 100644 docs/superpowers/specs/2026-04-02-docs-coherence-and-discoverability-design.md diff --git a/docs/superpowers/specs/2026-04-02-docs-coherence-and-discoverability-design.md b/docs/superpowers/specs/2026-04-02-docs-coherence-and-discoverability-design.md new file mode 100644 index 0000000..7586ad0 --- /dev/null +++ b/docs/superpowers/specs/2026-04-02-docs-coherence-and-discoverability-design.md @@ -0,0 +1,178 @@ +# Docs Coherence And Discoverability Design + +## Goal + +Make the current branch documentation coherent and consistent across the internal planning docs, user-facing guides, and the small package surface users are expected to import from. + +This is a cleanup slice, not a feature slice. The goal is to make the repository easier to understand after the large amount of recent implementation work, without changing analysis behavior. + +## Scope + +This design covers: + +- internal status-map accuracy in [docs/superpowers/README.md](../README.md) +- consistency across user-facing guides: + - [README.md](../../../README.md) + - [docs/global-analysis.md](../../../docs/global-analysis.md) + - [docs/region-discovery.md](../../../docs/region-discovery.md) + - [docs/region-contrasts.md](../../../docs/region-contrasts.md) + - [docs/shared-clustering.md](../../../docs/shared-clustering.md) +- small package-surface cleanup in [dimelo/__init__.py](../../../dimelo/__init__.py) only if docs and the current public import story are clearly misaligned + +This design does not cover: + +- new analysis features +- new plotting features +- API redesign +- broad refactors +- rewriting the historical specs/plans themselves beyond status-map updates + +## Why This Pass Is Needed + +The branch now has: + +- multiple new analysis layers +- multiple new plotting-prep helper families +- discovery-to-clustering and discovery-to-clustering-to-contrast workflows +- internal planning docs that were cleaned up once already, but are now behind again + +The implementation is ahead of the documentation in a few places. The repo needs one coherence pass so a user or future contributor can understand: + +- what is implemented now +- which docs correspond to which module/workflow +- how the modules fit together +- which plotting helpers exist for which analysis families + +## Definition Of “Coherent And Consistent” + +This pass should satisfy four tests. + +### 1. Status-map accuracy + +[docs/superpowers/README.md](../README.md) should: + +- include the newest plotting specs/plans +- stop omitting implemented slices +- label implemented vs partially implemented work in a way that matches repo reality + +The status map should remain lightweight. It is an index, not a changelog. + +### 2. User-flow consistency + +The user-facing docs should tell one consistent story: + +- `parse_bam` remains the preprocessing/materialization foundation +- `global_analysis`, `region_discovery`, `region_contrasts`, and `shared_clustering` are the higher-level analysis layers +- plotting is data-first +- helper coverage differs by analysis family, and the docs should say so honestly + +### 3. Cross-link and naming consistency + +The same helpers and workflows should be named the same way everywhere they appear. In practice, this means consistently using names such as: + +- `shared_cluster_distribution(...)` +- `discovery_cluster_workflow(...)` +- `discovery_cluster_contrast_workflow(...)` +- `prepare_region_contrast_profile_data(...)` +- `prepare_region_contrast_heatmap_data(...)` +- `prepare_region_discovery_scan_data(...)` +- `prepare_region_discovery_hit_context_data(...)` +- `prepare_global_analysis_summary_data(...)` +- `prepare_global_analysis_window_data(...)` + +### 4. Package discoverability consistency + +If the docs imply that users should import a module or helper from top-level `dimelo`, the top-level package surface should support that expectation, but only where the fix is small and obvious. + +This does not mean re-exporting every helper automatically. It means removing clear documentation/import mismatches if they exist. + +## Recommended Cleanup Structure + +The cleanup should proceed in three layers. + +### Layer 1: Internal status/docs map + +Update [docs/superpowers/README.md](../README.md) to: + +- add the missing plotting specs/plans +- refresh the status labels for the slices that have landed +- keep the wording concise + +This is the source of truth for planning status and should reflect the current branch state. + +### Layer 2: User-facing guide consistency + +Sweep the main user-facing docs: + +- [README.md](../../../README.md) +- [docs/global-analysis.md](../../../docs/global-analysis.md) +- [docs/region-discovery.md](../../../docs/region-discovery.md) +- [docs/region-contrasts.md](../../../docs/region-contrasts.md) +- [docs/shared-clustering.md](../../../docs/shared-clustering.md) + +Focus on: + +- stale “future” wording for already implemented work +- inconsistent helper/workflow naming +- inconsistent descriptions of module roles +- inconsistent plotting-helper coverage claims +- missing short cross-links where users would reasonably look first + +This should be a targeted consistency sweep, not a rewrite. + +### Layer 3: Small package-surface cleanup + +Inspect [dimelo/__init__.py](../../../dimelo/__init__.py) after the docs sweep. + +Allowed changes: + +- exposing a clearly user-facing module that the docs already treat as a top-level import +- fixing an obvious export omission that makes the docs misleading + +Disallowed changes: + +- broad export churn +- re-exporting many helpers just for convenience +- changing public import style for aesthetic reasons + +## Expected Outcomes + +After the pass: + +- the internal docs index reflects the actual implemented state +- the top-level README and guide docs tell the same architecture story +- plotting coverage is described consistently: + - `region_contrasts` plotting prep exists + - `region_discovery` plotting prep exists + - `global_analysis` plotting prep exists + - `shared_clustering` still has lighter plotting coverage by comparison +- if a small `__init__.py` fix is needed, the docs and package surface agree + +## Non-Goals + +This pass should not try to solve every remaining gap in the branch. In particular, it should not turn into: + +- a renderer implementation slice +- a `shared_clustering` plotting expansion +- a `single_read` contrast design +- a general docs rewrite + +Those are follow-on projects and should remain separate. + +## Validation + +The cleanup should validate: + +- the internal index links still resolve +- the repo docs do not contain stale contradictory statements about which modules are implemented +- any changed top-level exports still allow `import dimelo` cleanly + +## Recommendation + +Do this as a docs-first coherence sweep with three ordered layers: + +1. internal status-map update +2. user-facing guide consistency sweep +3. minimal package-surface cleanup only if the docs clearly demand it + +That keeps the pass focused and lets us build the next implementation plan from a clean, accurate documentation state. From 0131e7fd87805d4971904e8814497c3d79a39945 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 18:54:54 -0700 Subject: [PATCH 161/272] docs: add docs coherence cleanup plan --- ...4-02-docs-coherence-and-discoverability.md | 261 ++++++++++++++++++ 1 file changed, 261 insertions(+) create mode 100644 docs/superpowers/plans/2026-04-02-docs-coherence-and-discoverability.md diff --git a/docs/superpowers/plans/2026-04-02-docs-coherence-and-discoverability.md b/docs/superpowers/plans/2026-04-02-docs-coherence-and-discoverability.md new file mode 100644 index 0000000..ff8e829 --- /dev/null +++ b/docs/superpowers/plans/2026-04-02-docs-coherence-and-discoverability.md @@ -0,0 +1,261 @@ +# Docs Coherence And Discoverability Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Make the internal and user-facing docs coherent with the current branch state, and apply only minimal package-surface cleanup where the docs clearly demand it. + +**Architecture:** Execute this as a docs-first cleanup in three layers: refresh the internal status map, sweep the main user-facing guides for naming and flow consistency, then inspect the top-level package surface for any small discoverability mismatch exposed by the docs pass. Keep the slice additive and non-behavioral. + +**Tech Stack:** Markdown docs, existing Python package surface, lightweight repo inspection + +--- + +## File Map + +- Modify: `docs/superpowers/README.md` + - refresh status-map entries and add missing spec/plan links +- Modify as needed: + - `README.md` + - `docs/global-analysis.md` + - `docs/region-discovery.md` + - `docs/region-contrasts.md` + - `docs/shared-clustering.md` + - only for wording, cross-link, and role-consistency cleanup +- Modify only if clearly needed: + - `dimelo/__init__.py` + - only for a small discoverability/export mismatch exposed by the docs + +## Task 1: Refresh The Internal Status Map + +**Files:** +- Modify: `docs/superpowers/README.md` +- Verify: `docs/superpowers/specs/` +- Verify: `docs/superpowers/plans/` + +- [ ] **Step 1: Inventory missing or stale entries** + +Inspect the current index and repo contents: + +```bash +sed -n '1,260p' docs/superpowers/README.md +ls docs/superpowers/specs docs/superpowers/plans +``` + +Expected findings: + +- the internal index is missing the newest plotting specs/plans +- status labels may understate work that is already implemented + +- [ ] **Step 2: Update the status map minimally** + +Edit `docs/superpowers/README.md` to: + +- add: + - `specs/2026-04-02-region-discovery-plotting-design.md` + - `specs/2026-04-02-global-analysis-plotting-design.md` + - `specs/2026-04-02-docs-coherence-and-discoverability-design.md` + - `plans/2026-04-02-region-discovery-plotting.md` + - `plans/2026-04-02-global-analysis-plotting.md` +- refresh status labels where current branch reality clearly differs +- update the `Current Themes` section only as needed to reflect the newer plotting helper coverage + +Keep the file concise. Do not turn it into a changelog. + +- [ ] **Step 3: Verify index links resolve** + +Run: + +```bash +for f in $(rg -o "\\((specs|plans)/[^)]+" docs/superpowers/README.md | tr -d "("); do test -f "docs/superpowers/$f" || echo "MISSING $f"; done +``` + +Expected: no output. + +- [ ] **Step 4: Commit the status-map refresh** + +```bash +git add docs/superpowers/README.md +git commit -m "docs: refresh superpowers status map" +``` + +## Task 2: Sweep User-Facing Guides For Consistency + +**Files:** +- Modify as needed: + - `README.md` + - `docs/global-analysis.md` + - `docs/region-discovery.md` + - `docs/region-contrasts.md` + - `docs/shared-clustering.md` + +- [ ] **Step 1: Inventory stale wording and naming drift** + +Run focused searches: + +```bash +rg -n "once implemented|later for|not yet|planned|prepare_region_contrast_|prepare_region_discovery_|prepare_global_analysis_|shared_cluster_distribution|discovery_cluster_workflow|discovery_cluster_contrast_workflow" README.md docs/*.md +``` + +Inspect the matching sections and note only concrete consistency issues such as: + +- stale “future” wording +- inconsistent helper names +- inconsistent module-role descriptions +- missing short cross-links where users would naturally look + +- [ ] **Step 2: Apply a narrow consistency sweep** + +Edit only the minimum subset of the user-facing guides needed so they: + +- tell one consistent story about the analysis stack +- use the same helper/workflow names everywhere +- describe plotting-helper coverage honestly +- avoid implying that already-shipped helpers or workflows are still future work + +Allowed changes: + +- wording cleanup +- short cross-link additions +- short clarifications of current helper coverage + +Disallowed changes: + +- major rewrites +- new feature documentation beyond what is already implemented +- API renames for style + +- [ ] **Step 3: Verify the guide sweep** + +Run: + +```bash +rg -n "prepare_region_contrast_|prepare_region_discovery_|prepare_global_analysis_|shared_cluster_distribution|discovery_cluster_workflow|discovery_cluster_contrast_workflow" README.md docs/*.md +``` + +Expected: matches should reflect the intended current helper/workflow names consistently. + +- [ ] **Step 4: Commit the docs consistency sweep** + +```bash +git add README.md docs/global-analysis.md docs/region-discovery.md docs/region-contrasts.md docs/shared-clustering.md +git commit -m "docs: align analysis guide naming" +``` + +Only include files actually changed. + +## Task 3: Apply Small Package-Surface Cleanup If Needed + +**Files:** +- Inspect: `dimelo/__init__.py` +- Modify only if clearly needed: `dimelo/__init__.py` + +- [ ] **Step 1: Check whether the docs expose an import mismatch** + +Inspect the top-level package surface: + +```bash +sed -n '1,220p' dimelo/__init__.py +``` + +Compare that with the docs updated in Task 2. + +Only proceed if there is a concrete mismatch such as: + +- docs telling users to import a top-level module that is not actually exposed +- docs implying a clearly user-facing module path that the package does not support + +- [ ] **Step 2: Make the minimum export fix if needed** + +If and only if a concrete mismatch exists, update `dimelo/__init__.py` minimally. + +Allowed: + +- add one missing module export already treated as top-level in the docs + +Disallowed: + +- broad re-export churn +- exporting helper functions just for convenience +- aesthetic reshaping of `__all__` + +- [ ] **Step 3: Verify imports if `__init__.py` changed** + +Run: + +```bash +python3.11 - <<'PY' +import dimelo +print("dimelo import ok") +PY +``` + +Expected: `dimelo import ok` + +- [ ] **Step 4: Commit the package-surface cleanup if needed** + +```bash +git add dimelo/__init__.py +git commit -m "docs: align package surface with guides" +``` + +If no package-surface fix was needed, skip this commit. + +## Final Verification + +**Files:** +- Verify: `docs/superpowers/README.md` +- Verify any touched user-facing docs +- Verify `dimelo/__init__.py` if changed + +- [ ] **Step 1: Confirm the internal index resolves** + +Run: + +```bash +for f in $(rg -o "\\((specs|plans)/[^)]+" docs/superpowers/README.md | tr -d "("); do test -f "docs/superpowers/$f" || echo "MISSING $f"; done +``` + +Expected: no output. + +- [ ] **Step 2: Confirm the working tree is clean** + +Run: + +```bash +git status --short +``` + +Expected: no output. + +- [ ] **Step 3: Summarize the coherence outcomes** + +Capture in the handoff: + +- which status-map entries were added or corrected +- which user-facing docs were adjusted +- whether any package-surface change was needed +- the main remaining next-step categories after docs are coherent + +## Self-Review + +Spec coverage check: + +- internal status-map accuracy: covered in Task 1 +- user-facing guide consistency: covered in Task 2 +- small package-surface cleanup only if needed: covered in Task 3 +- validation and clean-state closeout: covered in Final Verification + +Placeholder scan: + +- no `TODO`, `TBD`, or undefined steps remain +- each task includes exact files, commands, and narrow allowed scope + +Type consistency: + +- all referenced helper/workflow names match the current approved naming: + - `shared_cluster_distribution(...)` + - `discovery_cluster_workflow(...)` + - `discovery_cluster_contrast_workflow(...)` + - `prepare_region_contrast_*` + - `prepare_region_discovery_*` + - `prepare_global_analysis_*` From 4ac6e2fe4a60a55ee90aedb20f1ee29a3aab88ec Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 19:08:11 -0700 Subject: [PATCH 162/272] docs: refresh superpowers status map --- docs/superpowers/README.md | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/docs/superpowers/README.md b/docs/superpowers/README.md index f865fb0..41a1b37 100644 --- a/docs/superpowers/README.md +++ b/docs/superpowers/README.md @@ -29,11 +29,14 @@ This directory tracks internal design and implementation work for the current br - [2026-04-01-plotting-axis-architecture-design.md](specs/2026-04-01-plotting-axis-architecture-design.md) - shared plotting-axis and renderer-neutral payload architecture. Status: `implemented` - [2026-04-01-region-contrasts-plotting-design.md](specs/2026-04-01-region-contrasts-plotting-design.md) - plotting prep for region contrast profiles and heatmaps. Status: `implemented` +- [2026-04-02-region-discovery-plotting-design.md](specs/2026-04-02-region-discovery-plotting-design.md) - plotting prep for discovery scan-overview and hit-context payloads. Status: `implemented` +- [2026-04-02-global-analysis-plotting-design.md](specs/2026-04-02-global-analysis-plotting-design.md) - plotting prep for global summary and broad-window payloads. Status: `implemented` ### Cleanup And Docs - [2026-04-02-superpowers-docs-cleanup-design.md](specs/2026-04-02-superpowers-docs-cleanup-design.md) - central index and status-map cleanup for internal planning docs. Status: `implemented` -- [2026-04-02-docs-and-integration-cleanup-design.md](specs/2026-04-02-docs-and-integration-cleanup-design.md) - path portability and discoverability cleanup for tracked superpowers docs and related integration surfaces. Status: `partially implemented` +- [2026-04-02-docs-and-integration-cleanup-design.md](specs/2026-04-02-docs-and-integration-cleanup-design.md) - path portability and discoverability cleanup for tracked superpowers docs and related integration surfaces. Status: `implemented` +- [2026-04-02-docs-coherence-and-discoverability-design.md](specs/2026-04-02-docs-coherence-and-discoverability-design.md) - coherence pass across internal and user-facing docs plus narrow discoverability cleanup. Status: `partially implemented` ## Plans @@ -43,7 +46,7 @@ This directory tracks internal design and implementation work for the current br ### Region Analysis -- [2026-03-31-global-analysis-foundations.md](plans/2026-03-31-global-analysis-foundations.md) - global analysis models, workflows, and artifact plumbing. Status: `partially implemented` +- [2026-03-31-global-analysis-foundations.md](plans/2026-03-31-global-analysis-foundations.md) - global analysis models, workflows, and artifact plumbing. Status: `implemented` - [2026-03-31-region-contrasts-foundations.md](plans/2026-03-31-region-contrasts-foundations.md) - defined-region contrast foundations and scoring paths. Status: `implemented` - [2026-04-01-cluster-occupancy-region-contrasts.md](plans/2026-04-01-cluster-occupancy-region-contrasts.md) - cluster-occupancy evidence and scoring for region contrasts. Status: `implemented` @@ -58,11 +61,14 @@ This directory tracks internal design and implementation work for the current br - [2026-04-01-plotting-axis-architecture.md](plans/2026-04-01-plotting-axis-architecture.md) - shared plotting-axis implementation slice. Status: `implemented` - [2026-04-01-region-contrasts-plotting.md](plans/2026-04-01-region-contrasts-plotting.md) - region contrast plotting prep for profiles and heatmaps. Status: `implemented` +- [2026-04-02-region-discovery-plotting.md](plans/2026-04-02-region-discovery-plotting.md) - region discovery plotting prep for per-contig scans and local hit-context views. Status: `implemented` +- [2026-04-02-global-analysis-plotting.md](plans/2026-04-02-global-analysis-plotting.md) - global analysis plotting prep for summary and broad-window payloads. Status: `implemented` ### Cleanup And Docs - [2026-04-02-superpowers-docs-cleanup.md](plans/2026-04-02-superpowers-docs-cleanup.md) - central docs index and tracked-plan cleanup. Status: `implemented` -- [2026-04-02-docs-and-integration-cleanup.md](plans/2026-04-02-docs-and-integration-cleanup.md) - historical path normalization plus narrow discoverability cleanup around completed analysis and plotting work. Status: `partially implemented` +- [2026-04-02-docs-and-integration-cleanup.md](plans/2026-04-02-docs-and-integration-cleanup.md) - historical path normalization plus narrow discoverability cleanup around completed analysis and plotting work. Status: `implemented` +- [2026-04-02-docs-coherence-and-discoverability.md](plans/2026-04-02-docs-coherence-and-discoverability.md) - coherence pass across internal and user-facing docs plus narrow package-surface cleanup if needed. Status: `partially implemented` ## Current Themes @@ -70,5 +76,5 @@ This directory tracks internal design and implementation work for the current br - Region contrasts: start with the region analysis architecture spec, then the contrasts foundations plan, cluster-occupancy follow-on work, and the region-contrasts plotting plan. - Region discovery: use the region analysis architecture spec, the paired discovery spec, and the discovery workflow plans together. - Global analysis: use the region analysis architecture spec first, then the global analysis foundations plan. -- Plotting: start with the plotting-axis spec, then the plotting-axis implementation plan and the region-contrasts plotting plan. -- Docs cleanup: use the docs cleanup design and plan for the central status map and tracked historical plans, then the docs-and-integration cleanup design and plan for portability and discoverability follow-on work. +- Plotting: start with the plotting-axis spec, then the plotting-axis implementation plan, then the region-contrasts, region-discovery, and global-analysis plotting plans for helper-level coverage. +- Docs cleanup: use the docs cleanup design and plan for the central status map and tracked historical plans, then the docs-and-integration and docs-coherence follow-on docs passes for portability and discoverability cleanup. From 48b2166db9fd50555863ee02d2b2ee467f76ebbc Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 19:11:13 -0700 Subject: [PATCH 163/272] docs: align analysis guide naming --- README.md | 2 ++ docs/global-analysis.md | 2 ++ docs/region-contrasts.md | 2 ++ docs/region-discovery.md | 2 ++ docs/shared-clustering.md | 2 ++ 5 files changed, 10 insertions(+) diff --git a/README.md b/README.md index 44865ee..1c8ae98 100644 --- a/README.md +++ b/README.md @@ -239,6 +239,8 @@ For discovery-to-clustering-to-contrast follow-up, use `workflows.discovery_clus `global_analysis` now exposes renderer-neutral plotting prep helpers that consume `GlobalAnalysisResult`: `prepare_global_analysis_summary_data(...)` prepares sample-level summaries, optional condition-level views, and normalization tables, while `prepare_global_analysis_window_data(...)` prepares broad-window payloads that stay per-contig by default. +`region_contrasts` uses the same data-prep-first plotting layer: `prepare_region_contrast_profile_data(...)` and `prepare_region_contrast_heatmap_data(...)` consume a `RegionContrastResult` plus an explicit positional table, while shared clustering currently keeps lighter plotting coverage through plot-ready tables in `result.plot_data`. + For human-readable pileups (bedmethyl files, .bed) and extracted reads (.txt tab-separated values), run with `cleanup=False`. `cleanup=True` will clear these outputs because they can take up a lot of space. ### Parsing outputs diff --git a/docs/global-analysis.md b/docs/global-analysis.md index e851ce8..6f30ea1 100644 --- a/docs/global-analysis.md +++ b/docs/global-analysis.md @@ -62,3 +62,5 @@ window_payload = plotting.prepare_global_analysis_window_data( - `prepare_global_analysis_summary_data(...)` consumes a `GlobalAnalysisResult` and returns renderer-neutral `sample_summary`, `condition_summary`, `normalization_table`, and `metadata` payloads. The summary payload exposes both sample-level rows and optional condition-level views, while normalization values stay available through `normalization_table`. - `prepare_global_analysis_window_data(...)` consumes the same `GlobalAnalysisResult` and returns renderer-neutral `window_table`, `condition_window_table`, and `metadata` payloads. Broad-window payloads stay per-contig by default rather than flattening onto a cumulative genome axis. + +For defined-region follow-up, pair these global summaries with [region contrasts](region-contrasts.md). For de novo locus finding first, use [region discovery](region-discovery.md). diff --git a/docs/region-contrasts.md b/docs/region-contrasts.md index 11a3119..a853237 100644 --- a/docs/region-contrasts.md +++ b/docs/region-contrasts.md @@ -218,6 +218,8 @@ heatmap_payload = plotting.prepare_region_contrast_heatmap_data( For `prepare_region_contrast_heatmap_data(...)`, `result.summary` must also provide one unambiguous `rank` value per plotted region. +For de novo locus finding before this stage, use [region discovery](region-discovery.md). For broad whole-sample summaries and normalization factors, use [global analysis](global-analysis.md). + ## Preprocessing Reminder - Run `parse_bam.pileup()` when you care about motif abundance, defined-region contrasts, or later de novo discovery. diff --git a/docs/region-discovery.md b/docs/region-discovery.md index 0d89b46..47a73b2 100644 --- a/docs/region-discovery.md +++ b/docs/region-discovery.md @@ -85,6 +85,8 @@ context_payload = plotting.prepare_region_discovery_hit_context_data( - `prepare_region_discovery_scan_data(...)` consumes a `RegionDiscoveryResult` and returns renderer-neutral `scan_table`, `hit_table`, and `metadata` payloads. Scan payloads stay per-contig by default rather than projecting windows onto a cumulative genome axis. - `prepare_region_discovery_hit_context_data(...)` consumes the same `RegionDiscoveryResult` and returns renderer-neutral `context_table`, `selected_hits`, and `metadata` payloads for small-multiple or local hit-context views. +For broad whole-sample summaries instead of locus discovery, use [global analysis](global-analysis.md). For defined-region testing after discovery, use [region contrasts](region-contrasts.md). + ## Handoff Guidance - For formal region testing, convert discovered hits into BED and write them to disk before passing the BED path into `region_contrasts.score_regions(...)`. diff --git a/docs/shared-clustering.md b/docs/shared-clustering.md index 16708e0..caf0235 100644 --- a/docs/shared-clustering.md +++ b/docs/shared-clustering.md @@ -78,6 +78,8 @@ The workflow returns a `SharedClusterResult` with canonical tables: Built-in plotting remains intentionally thin. `result.plot_data["cluster_distribution_bar"]` and `result.plot_data["cluster_distribution_heatmap"]` are plot-ready DataFrames, not renderer-specific figure objects. +This is lighter plotting coverage than the newer analysis-specific helpers in `region_contrasts`, `region_discovery`, and `global_analysis`, which now expose dedicated renderer-neutral plotting-prep functions around their result objects. + The plotting contract stays compatibility-safe with older package versions: - legacy Matplotlib wrappers still work From 6385ef744a7d27aa1d7c993719e9d162b8cff7c6 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 19:25:38 -0700 Subject: [PATCH 164/272] docs: add shared clustering plotting spec --- ...04-02-shared-clustering-plotting-design.md | 269 ++++++++++++++++++ 1 file changed, 269 insertions(+) create mode 100644 docs/superpowers/specs/2026-04-02-shared-clustering-plotting-design.md diff --git a/docs/superpowers/specs/2026-04-02-shared-clustering-plotting-design.md b/docs/superpowers/specs/2026-04-02-shared-clustering-plotting-design.md new file mode 100644 index 0000000..1b25626 --- /dev/null +++ b/docs/superpowers/specs/2026-04-02-shared-clustering-plotting-design.md @@ -0,0 +1,269 @@ +# Shared Clustering Plotting Design + +## Goal + +Add a richer, renderer-neutral plotting-prep layer for `dimelo.workflows.shared_cluster_distribution()` that standardizes the main `SharedClusterResult` plotting families: + +- distribution and change views +- cluster profile views +- region-level occupancy views + +This should deepen the current lightweight `result.plot_data` contract without replacing it. + +## Scope + +This design covers: + +- plotting-prep helpers for `SharedClusterResult` +- distribution and change payloads from: + - `cluster_distribution` + - `condition_distribution` + - `distribution_change` +- cluster profile payloads from `cluster_profiles` +- region-level occupancy payloads from `region_summaries` +- optional condition-level aggregation for region occupancy + +This design does not cover: + +- renderer implementations +- new clustering logic +- new region statistics +- new occupancy models +- normalized region-axis plotting + +## User-Facing API + +Add three public helpers in [plotting.py](../../../dimelo/plotting.py): + +- `prepare_shared_cluster_distribution_data(...)` +- `prepare_shared_cluster_profile_data(...)` +- `prepare_shared_cluster_region_data(...)` + +All three should accept a [SharedClusterResult](../../../dimelo/models.py) and return renderer-neutral payload dictionaries with plot-ready tables plus metadata. + +## Design Principles + +### Keep `SharedClusterResult` authoritative + +The helpers should use the existing `SharedClusterResult` tables as the source of truth. They should not derive new biological interpretations or replace the workflow’s current `plot_data`. + +### Keep the helpers family-specific + +The plotting families are different enough that one generic mode-switched helper would become opaque. The API should follow the same pattern already used for `region_contrasts`, `region_discovery`, and `global_analysis`: multiple small public helpers with shared internals. + +### Preserve the existing lightweight `plot_data` + +The current `SharedClusterResult.plot_data` should remain available. The new helper layer is additive and richer, not a replacement. + +## Plot Family 1: Distribution And Change Views + +### Purpose + +Prepare plot-ready tables for sample-level distributions, condition-level distributions, and condition-change summaries. + +### Public Entry Point + +```python +payload = plotting.prepare_shared_cluster_distribution_data(result=result) +``` + +### Outputs + +Return a dictionary with: + +- `sample_distribution` + - rows from `result.cluster_distribution` +- `condition_distribution` + - rows from `result.condition_distribution` +- `distribution_change` + - rows from `result.distribution_change` + - may be empty if no reference condition/change table exists +- `metadata` + - includes: + - `mode` + - `motifs` + - `reference_condition` + +### Intended use + +This should support: + +- cluster-fraction bars by sample +- condition-level heatmaps +- change/delta heatmaps or scatter summaries + +## Plot Family 2: Cluster Profile Views + +### Purpose + +Prepare plot-ready tables for visualizing the feature profile of each cluster. + +### Public Entry Point + +```python +payload = plotting.prepare_shared_cluster_profile_data(result=result) +``` + +### Outputs + +Return a dictionary with: + +- `profile_table` + - rows from `result.cluster_profiles` + - standardized so cluster identifier and feature columns are easy to consume +- `metadata` + - includes: + - `mode` + - `motifs` + - `feature_names` + +### Intended use + +This should support: + +- per-cluster profile panels +- line/scatter plots over feature dimensions +- summary comparisons of cluster centroids or average patterns + +The helper should not assume any one renderer or feature geometry. + +## Plot Family 3: Region Occupancy Views + +### Purpose + +Prepare plot-ready tables for region-level occupancy inspection from `result.region_summaries`. + +### Public Entry Point + +```python +payload = plotting.prepare_shared_cluster_region_data( + result=result, + aggregate_conditions=True, +) +``` + +### Inputs + +- `result: SharedClusterResult` +- `aggregate_conditions: bool` + - when `True`, provide condition-level region summaries in addition to sample-level rows + +### Outputs + +Return a dictionary with: + +- `region_table` + - sample-level rows from `result.region_summaries` +- `condition_region_table` + - optional condition-level aggregation over `region_table` + - may be empty when `aggregate_conditions=False` +- `metadata` + - includes: + - `mode` + - `motifs` + - `aggregate_conditions` + +### Aggregation rules + +This helper should only aggregate what `result.region_summaries` already contains. It should not invent a new occupancy model. + +When condition aggregation is enabled, aggregate from sample-level region rows first so the summary semantics match the reported counts. + +## Defaults And Validation + +### Result validation + +Helpers should validate they received a `SharedClusterResult`-like object with the required attributes for the requested family. + +Examples: + +- distribution helper requires: + - `cluster_distribution` + - `condition_distribution` + - `metadata` +- profile helper requires: + - `cluster_profiles` + - `model` +- region helper requires: + - `region_summaries` + - `metadata` + +### Empty tables + +If a relevant table is empty or absent: + +- return stable empty tables with expected columns +- preserve metadata where possible +- do not raise unless required structure is missing for the helper contract + +### Region helper mode handling + +If `result.region_summaries` is `None`, the region helper should return stable empty outputs rather than failing, because `read_global` clustering does not always produce region summaries. + +## Relationship To Existing `plot_data` + +`SharedClusterResult.plot_data` currently includes lightweight payloads such as: + +- `cluster_distribution_bar` +- `cluster_distribution_heatmap` + +Those should remain in place. + +The new helpers should: + +- preserve compatibility with the existing workflow outputs +- provide a more structured, result-centric plotting-prep interface +- avoid depending on the existing lightweight `plot_data` keys as their public contract + +## Backward Compatibility + +This design is additive. + +- it does not change `shared_cluster_distribution()` +- it does not change `SharedClusterResult` +- it does not remove existing `result.plot_data` + +## Testing + +Add focused tests in [tests/test_plotting.py](../../../tests/test_plotting.py) for: + +- stable distribution payload keys and table propagation +- empty change-table behavior +- profile-table passthrough and metadata +- region helper empty behavior when `region_summaries` is `None` +- condition-level region aggregation behavior + +Use synthetic `SharedClusterResult` fixtures rather than end-to-end clustering runs for most helper tests. + +## Documentation + +Update: + +- [docs/shared-clustering.md](../../../docs/shared-clustering.md) +- [README.md](../../../README.md) + +Document: + +- the three new helpers +- the distinction between the old lightweight `result.plot_data` and the richer helper layer +- the fact that `shared_clustering` now has dedicated renderer-neutral helper prep, not just raw workflow payloads + +## Recommended Implementation Order + +1. Add plotting helper tests for distribution/change prep +2. Implement `prepare_shared_cluster_distribution_data(...)` +3. Add plotting helper tests for profile prep +4. Implement `prepare_shared_cluster_profile_data(...)` +5. Add plotting helper tests for region prep +6. Implement `prepare_shared_cluster_region_data(...)` +7. Update docs + +## Recommendation + +Build `shared_clustering` plotting as a result-centric, data-first layer with three helper families: + +- `prepare_shared_cluster_distribution_data(...)` +- `prepare_shared_cluster_profile_data(...)` +- `prepare_shared_cluster_region_data(...)` + +That brings `shared_clustering` into line with the richer plotting-prep coverage now available for `region_contrasts`, `region_discovery`, and `global_analysis`, while preserving the existing lightweight `result.plot_data` contract. From 927e859ad99bcab1bcec57c402f5b27cc8a43246 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 21:01:35 -0700 Subject: [PATCH 165/272] docs: add shared clustering plotting plan --- .../2026-04-02-shared-clustering-plotting.md | 691 ++++++++++++++++++ 1 file changed, 691 insertions(+) create mode 100644 docs/superpowers/plans/2026-04-02-shared-clustering-plotting.md diff --git a/docs/superpowers/plans/2026-04-02-shared-clustering-plotting.md b/docs/superpowers/plans/2026-04-02-shared-clustering-plotting.md new file mode 100644 index 0000000..bca97ee --- /dev/null +++ b/docs/superpowers/plans/2026-04-02-shared-clustering-plotting.md @@ -0,0 +1,691 @@ +# Shared Clustering Plotting Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Add renderer-neutral plotting-prep helpers for `dimelo.shared_clustering` distribution/change views, cluster-profile views, and region-occupancy views. + +**Architecture:** Extend the shared plotting module with three result-centric helpers that consume `SharedClusterResult` and emit stable payload dictionaries. Keep the implementation additive and data-first: preserve the existing lightweight `result.plot_data`, avoid clustering logic changes, and only aggregate from canonical `SharedClusterResult` tables already produced by `dimelo.workflows`. + +**Tech Stack:** Python 3.11, pandas, pytest, existing `dimelo.plotting`, `dimelo.workflows`, `dimelo.distribution`, and `dimelo.models` modules + +--- + +## File Map + +- Modify: `dimelo/plotting.py` + - add `SharedClusterResult` validation/helpers + - add `prepare_shared_cluster_distribution_data(...)` + - add `prepare_shared_cluster_profile_data(...)` + - add `prepare_shared_cluster_region_data(...)` +- Modify: `tests/test_plotting.py` + - add focused plotting helper coverage using synthetic `SharedClusterResult` fixtures +- Modify: `tests/test_workflows.py` + - verify shared-clustering workflow outputs remain compatible with the new helper layer +- Modify: `docs/shared-clustering.md` + - document the new plotting-prep helpers and how they relate to existing `result.plot_data` +- Modify: `README.md` + - add one short note about shared-clustering plotting-prep helpers + +## Task 1: Add Failing Tests For Distribution And Change Plot Prep + +**Files:** +- Modify: `tests/test_plotting.py` +- Reference: `dimelo/models.py` +- Reference: `dimelo/plotting.py` + +- [ ] **Step 1: Write the failing distribution/change tests** + +Add these tests near the other plotting helper tests in `tests/test_plotting.py`: + +```python +from dimelo.models import SharedClusterModel, SharedClusterResult + + +def _make_shared_cluster_result() -> SharedClusterResult: + model = SharedClusterModel( + mode="region_anchored", + motifs=["A,0"], + feature_names=["f0", "f1"], + preprocessing={"signal_normalization": "none"}, + estimator=object(), + cluster_labels=["C0", "C1"], + fit_metadata={"clusterer": "minibatch_kmeans", "n_clusters": 2}, + ) + assignments = pd.DataFrame( + [ + {"sample_id": "s1", "condition": "NS", "cluster": "C0"}, + {"sample_id": "s1", "condition": "NS", "cluster": "C1"}, + {"sample_id": "s2", "condition": "treated", "cluster": "C1"}, + ] + ) + cluster_distribution = pd.DataFrame( + [ + {"sample_id": "s1", "condition": "NS", "cluster": "C0", "count": 2, "fraction": 2 / 3}, + {"sample_id": "s1", "condition": "NS", "cluster": "C1", "count": 1, "fraction": 1 / 3}, + {"sample_id": "s2", "condition": "treated", "cluster": "C0", "count": 1, "fraction": 1 / 4}, + {"sample_id": "s2", "condition": "treated", "cluster": "C1", "count": 3, "fraction": 3 / 4}, + ] + ) + condition_distribution = pd.DataFrame( + [ + {"condition": "NS", "cluster": "C0", "count": 2, "fraction": 2 / 3, "replicate_n": 1}, + {"condition": "NS", "cluster": "C1", "count": 1, "fraction": 1 / 3, "replicate_n": 1}, + {"condition": "treated", "cluster": "C0", "count": 1, "fraction": 1 / 4, "replicate_n": 1}, + {"condition": "treated", "cluster": "C1", "count": 3, "fraction": 3 / 4, "replicate_n": 1}, + ] + ) + distribution_change = pd.DataFrame( + [ + { + "condition": "treated", + "cluster": "C0", + "count": 1, + "fraction": 1 / 4, + "replicate_n": 1, + "reference_fraction": 2 / 3, + "delta_fraction": -5 / 12, + "log2_fc": -1.415037499278844, + }, + { + "condition": "treated", + "cluster": "C1", + "count": 3, + "fraction": 3 / 4, + "replicate_n": 1, + "reference_fraction": 1 / 3, + "delta_fraction": 5 / 12, + "log2_fc": 1.1699250014423124, + }, + ] + ) + cluster_profiles = pd.DataFrame( + [ + {"cluster": "C0", "count": 3, "f0": 0.1, "f1": 0.2}, + {"cluster": "C1", "count": 4, "f0": 0.8, "f1": 0.9}, + ] + ) + region_summaries = pd.DataFrame( + [ + {"region_id": "reg1", "sample_id": "s1", "condition": "NS", "cluster": "C0", "count": 2, "fraction": 2 / 3}, + {"region_id": "reg1", "sample_id": "s1", "condition": "NS", "cluster": "C1", "count": 1, "fraction": 1 / 3}, + {"region_id": "reg1", "sample_id": "s2", "condition": "treated", "cluster": "C0", "count": 1, "fraction": 1 / 4}, + {"region_id": "reg1", "sample_id": "s2", "condition": "treated", "cluster": "C1", "count": 3, "fraction": 3 / 4}, + ] + ) + return SharedClusterResult( + model=model, + assignments=assignments, + cluster_distribution=cluster_distribution, + condition_distribution=condition_distribution, + distribution_change=distribution_change, + cluster_profiles=cluster_profiles, + region_summaries=region_summaries, + plot_data={ + "cluster_distribution_bar": cluster_distribution.copy(), + "cluster_distribution_heatmap": pd.DataFrame( + [{"condition": "NS", "C0": 2 / 3, "C1": 1 / 3}, {"condition": "treated", "C0": 1 / 4, "C1": 3 / 4}] + ), + }, + metadata={"mode": "region_anchored"}, + ) + + +def test_prepare_shared_cluster_distribution_data_returns_distribution_payload(): + result = _make_shared_cluster_result() + + payload = plotting.prepare_shared_cluster_distribution_data(result=result) + + assert set(payload) == { + "sample_distribution", + "condition_distribution", + "distribution_change", + "metadata", + } + assert payload["sample_distribution"]["sample_id"].tolist() == ["s1", "s1", "s2", "s2"] + assert payload["condition_distribution"]["condition"].tolist() == ["NS", "NS", "treated", "treated"] + assert payload["distribution_change"]["condition"].tolist() == ["treated", "treated"] + assert payload["metadata"]["mode"] == "region_anchored" + + +def test_prepare_shared_cluster_distribution_data_handles_missing_change_table(): + result = _make_shared_cluster_result() + result.distribution_change = None + + payload = plotting.prepare_shared_cluster_distribution_data(result=result) + + assert list(payload["distribution_change"].columns) == [ + "condition", + "cluster", + "count", + "fraction", + "replicate_n", + "reference_fraction", + "delta_fraction", + "log2_fc", + ] + assert payload["distribution_change"].empty +``` + +- [ ] **Step 2: Run the new distribution/change tests to verify they fail** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "shared_cluster_distribution_data" -q +``` + +Expected: FAIL because `prepare_shared_cluster_distribution_data(...)` does not yet exist. + +- [ ] **Step 3: Commit the failing tests** + +```bash +git add tests/test_plotting.py +git commit -m "test: add shared clustering distribution plotting coverage" +``` + +## Task 2: Implement Distribution And Change Plot Prep + +**Files:** +- Modify: `dimelo/plotting.py` +- Modify: `tests/test_plotting.py` + +- [ ] **Step 1: Add the internal shared-clustering validation helpers** + +Add these helpers in `dimelo/plotting.py` near the other result-validation utilities: + +```python +def _validate_shared_cluster_result(result) -> None: + if result is None: + raise ValueError("plotting helpers require a SharedClusterResult.") + required_attrs = ( + "cluster_distribution", + "condition_distribution", + "cluster_profiles", + "plot_data", + "metadata", + ) + if not all(hasattr(result, attr) for attr in required_attrs): + raise TypeError("plotting helpers require a SharedClusterResult-like object.") + + +def _empty_distribution_change_table() -> pd.DataFrame: + return pd.DataFrame( + columns=[ + "condition", + "cluster", + "count", + "fraction", + "replicate_n", + "reference_fraction", + "delta_fraction", + "log2_fc", + ] + ) +``` + +- [ ] **Step 2: Add `prepare_shared_cluster_distribution_data(...)`** + +Add this public function in `dimelo/plotting.py` near the other public plotting helpers: + +```python +def prepare_shared_cluster_distribution_data( + *, + result, +) -> dict[str, pd.DataFrame | dict[str, object]]: + _validate_shared_cluster_result(result) + + sample_distribution = prepare_cluster_distribution_bar_data(result.cluster_distribution) + condition_distribution = ( + result.condition_distribution.loc[ + :, ["condition", "cluster", "count", "fraction", "replicate_n"] + ] + .sort_values(["condition", "cluster"], kind="stable") + .reset_index(drop=True) + ) + distribution_change = ( + _empty_distribution_change_table() + if result.distribution_change is None + else result.distribution_change.sort_values(["condition", "cluster"], kind="stable").reset_index(drop=True) + ) + metadata = { + "mode": result.model.mode, + "cluster_labels": list(result.model.cluster_labels), + "has_distribution_change": not distribution_change.empty, + } + return { + "sample_distribution": sample_distribution, + "condition_distribution": condition_distribution, + "distribution_change": distribution_change, + "metadata": metadata, + } +``` + +- [ ] **Step 3: Run the distribution/change tests to verify they pass** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "shared_cluster_distribution_data" -q +``` + +Expected: PASS. + +- [ ] **Step 4: Commit the implementation** + +```bash +git add dimelo/plotting.py tests/test_plotting.py +git commit -m "feat: add shared clustering distribution plotting prep" +``` + +## Task 3: Add Failing Tests For Cluster Profile Plot Prep + +**Files:** +- Modify: `tests/test_plotting.py` +- Reference: `dimelo/plotting.py` + +- [ ] **Step 1: Write the failing cluster-profile tests** + +Add these tests in `tests/test_plotting.py` below the distribution helper coverage: + +```python +def test_prepare_shared_cluster_profile_data_returns_long_form_profiles(): + result = _make_shared_cluster_result() + + payload = plotting.prepare_shared_cluster_profile_data(result=result) + + assert set(payload) == {"profile_table", "metadata"} + assert set(payload["profile_table"].columns) == {"cluster", "feature", "value", "count"} + assert payload["profile_table"]["cluster"].tolist() == ["C0", "C0", "C1", "C1"] + assert payload["profile_table"]["feature"].tolist() == ["f0", "f1", "f0", "f1"] + assert payload["metadata"]["feature_names"] == ["f0", "f1"] + + +def test_prepare_shared_cluster_profile_data_respects_feature_subset(): + result = _make_shared_cluster_result() + + payload = plotting.prepare_shared_cluster_profile_data(result=result, features=["f1"]) + + assert payload["profile_table"]["feature"].unique().tolist() == ["f1"] + assert payload["profile_table"]["cluster"].tolist() == ["C0", "C1"] +``` + +- [ ] **Step 2: Run the new cluster-profile tests to verify they fail** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "shared_cluster_profile_data" -q +``` + +Expected: FAIL because `prepare_shared_cluster_profile_data(...)` does not yet exist. + +- [ ] **Step 3: Commit the failing tests** + +```bash +git add tests/test_plotting.py +git commit -m "test: add shared clustering profile plotting coverage" +``` + +## Task 4: Implement Cluster Profile Plot Prep + +**Files:** +- Modify: `dimelo/plotting.py` +- Modify: `tests/test_plotting.py` + +- [ ] **Step 1: Add the cluster-profile helper** + +Add this public function in `dimelo/plotting.py`: + +```python +def prepare_shared_cluster_profile_data( + *, + result, + features: list[str] | None = None, +) -> dict[str, pd.DataFrame | dict[str, object]]: + _validate_shared_cluster_result(result) + cluster_profiles = result.cluster_profiles.copy() + if cluster_profiles.empty: + return { + "profile_table": pd.DataFrame(columns=["cluster", "feature", "value", "count"]), + "metadata": {"feature_names": [], "cluster_labels": list(result.model.cluster_labels)}, + } + + feature_names = [column for column in cluster_profiles.columns if column not in {"cluster", "count"}] + if features is not None: + missing = [feature for feature in features if feature not in feature_names] + if missing: + raise ValueError(f"Requested features are not present in cluster_profiles: {', '.join(missing)}") + feature_names = [feature for feature in feature_names if feature in features] + + profile_table = ( + cluster_profiles.loc[:, ["cluster", "count", *feature_names]] + .melt(id_vars=["cluster", "count"], var_name="feature", value_name="value") + .sort_values(["cluster", "feature"], kind="stable") + .reset_index(drop=True) + ) + return { + "profile_table": profile_table, + "metadata": { + "feature_names": feature_names, + "cluster_labels": list(result.model.cluster_labels), + }, + } +``` + +- [ ] **Step 2: Run the cluster-profile tests to verify they pass** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "shared_cluster_profile_data" -q +``` + +Expected: PASS. + +- [ ] **Step 3: Commit the implementation** + +```bash +git add dimelo/plotting.py tests/test_plotting.py +git commit -m "feat: add shared clustering profile plotting prep" +``` + +## Task 5: Add Failing Tests For Region Occupancy Plot Prep + +**Files:** +- Modify: `tests/test_plotting.py` +- Modify: `tests/test_workflows.py` +- Reference: `dimelo/workflows.py` + +- [ ] **Step 1: Write the failing region-occupancy tests** + +Add these tests in `tests/test_plotting.py`: + +```python +def test_prepare_shared_cluster_region_data_returns_sample_and_condition_tables(): + result = _make_shared_cluster_result() + + payload = plotting.prepare_shared_cluster_region_data(result=result) + + assert set(payload) == {"region_table", "condition_region_table", "metadata"} + assert payload["region_table"]["sample_id"].tolist() == ["s1", "s1", "s2", "s2"] + assert payload["condition_region_table"]["condition"].tolist() == ["NS", "NS", "treated", "treated"] + assert payload["metadata"]["mode"] == "region_anchored" + + +def test_prepare_shared_cluster_region_data_can_disable_condition_aggregation(): + result = _make_shared_cluster_result() + + payload = plotting.prepare_shared_cluster_region_data( + result=result, + aggregate_conditions=False, + ) + + assert payload["condition_region_table"].empty + + +def test_prepare_shared_cluster_region_data_rejects_missing_region_summaries(): + result = _make_shared_cluster_result() + result.region_summaries = None + + with pytest.raises(ValueError, match="region_summaries"): + plotting.prepare_shared_cluster_region_data(result=result) +``` + +Add this workflow compatibility test in `tests/test_workflows.py` near the existing shared-clustering workflow tests: + +```python +def test_shared_cluster_distribution_region_anchored_region_summaries_feed_region_plotting(monkeypatch): + fake_samples = [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + regions_bed="r1.bed", + metadata={"pileup_path": "s1.bed.gz"}, + ), + SampleSpec( + sample_id="s2", + condition="treated", + extract_h5="s2.h5", + regions_bed="r2.bed", + metadata={"pileup_path": "s2.bed.gz"}, + ), + ] + + def fake_region_table(*args, **kwargs): + return np.array([[0.1, 0.9], [0.9, 0.1]]), [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "replicate": None, + "chromosome": "chr1", + "start": 0, + "end": 2, + "strand": "+", + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "treated", + "replicate": None, + "chromosome": "chr1", + "start": 0, + "end": 2, + "strand": "+", + }, + ] + + monkeypatch.setattr(workflows.region_analysis, "build_region_feature_table", fake_region_table) + + result = workflows.shared_cluster_distribution( + samples=fake_samples, + mode="region_anchored", + motifs=["A,0"], + matched_regions="matched.bed", + n_clusters=2, + make_plots=False, + ) + + payload = plotting.prepare_shared_cluster_region_data(result=result) + + assert not payload["region_table"].empty + assert list(payload["condition_region_table"]["condition"].unique()) == ["NS", "treated"] +``` + +- [ ] **Step 2: Run the new region-occupancy tests to verify they fail** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py tests/test_workflows.py -k "shared_cluster_region_data" -q +``` + +Expected: FAIL because `prepare_shared_cluster_region_data(...)` does not yet exist. + +- [ ] **Step 3: Commit the failing tests** + +```bash +git add tests/test_plotting.py tests/test_workflows.py +git commit -m "test: add shared clustering region plotting coverage" +``` + +## Task 6: Implement Region Occupancy Plot Prep And Workflow Alignment + +**Files:** +- Modify: `dimelo/plotting.py` +- Modify: `tests/test_plotting.py` +- Modify: `tests/test_workflows.py` + +- [ ] **Step 1: Add the region-occupancy helper** + +Add this public function in `dimelo/plotting.py`: + +```python +def prepare_shared_cluster_region_data( + *, + result, + aggregate_conditions: bool = True, +) -> dict[str, pd.DataFrame | dict[str, object]]: + _validate_shared_cluster_result(result) + if result.region_summaries is None: + raise ValueError("SharedClusterResult.region_summaries is required for region plotting.") + + region_table = result.region_summaries.sort_values( + ["region_id", "sample_id", "cluster"], + kind="stable", + ).reset_index(drop=True) + + if aggregate_conditions and not region_table.empty: + condition_region_table = ( + region_table.groupby(["region_id", "condition", "cluster"], as_index=False, sort=False) + .agg( + count=("count", "sum"), + fraction_mean=("fraction", "mean"), + fraction_median=("fraction", "median"), + sample_n=("sample_id", "nunique"), + ) + .sort_values(["region_id", "condition", "cluster"], kind="stable") + .reset_index(drop=True) + ) + else: + condition_region_table = pd.DataFrame( + columns=[ + "region_id", + "condition", + "cluster", + "count", + "fraction_mean", + "fraction_median", + "sample_n", + ] + ) + + return { + "region_table": region_table, + "condition_region_table": condition_region_table, + "metadata": { + "mode": result.model.mode, + "cluster_labels": list(result.model.cluster_labels), + "has_condition_aggregation": aggregate_conditions, + }, + } +``` + +- [ ] **Step 2: Keep workflow compatibility explicit in tests** + +Do not change `dimelo/workflows.py` unless a test reveals a real mismatch. If the new helper works directly on existing `SharedClusterResult.region_summaries`, keep the workflow untouched and preserve the additive boundary. + +- [ ] **Step 3: Run the region-occupancy tests to verify they pass** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py tests/test_workflows.py -k "shared_cluster_region_data or region_summaries_feed_region_plotting" -q +``` + +Expected: PASS. + +- [ ] **Step 4: Commit the implementation** + +```bash +git add dimelo/plotting.py tests/test_plotting.py tests/test_workflows.py +git commit -m "feat: add shared clustering region plotting prep" +``` + +## Task 7: Document The New Shared Clustering Plotting Helpers + +**Files:** +- Modify: `docs/shared-clustering.md` +- Modify: `README.md` + +- [ ] **Step 1: Update the shared clustering guide** + +Add a short “Plotting Prep Helpers” section to `docs/shared-clustering.md` that documents the three new helpers and keeps the continuity note about existing lightweight `result.plot_data`: + +```md +## Plotting Prep Helpers + +`SharedClusterResult` now has three renderer-neutral plotting helpers in `dimelo.plotting`: + +- `prepare_shared_cluster_distribution_data(result=...)` +- `prepare_shared_cluster_profile_data(result=...)` +- `prepare_shared_cluster_region_data(result=...)` + +These helpers sit on top of the canonical result tables: + +- `result.cluster_distribution` +- `result.condition_distribution` +- `result.distribution_change` +- `result.cluster_profiles` +- `result.region_summaries` + +The older lightweight payloads in `result.plot_data["cluster_distribution_bar"]` and +`result.plot_data["cluster_distribution_heatmap"]` remain supported for backward familiarity. +``` + +- [ ] **Step 2: Add a short README note** + +Add one short paragraph in `README.md` near the other workflow/plotting summaries: + +```md +Shared clustering also has renderer-neutral plotting prep in `dimelo.plotting`. Use +`prepare_shared_cluster_distribution_data(...)` for sample/condition cluster fractions, +`prepare_shared_cluster_profile_data(...)` for cluster feature summaries, and +`prepare_shared_cluster_region_data(...)` for region-level occupancy tables. +``` + +- [ ] **Step 3: Commit the docs** + +```bash +git add docs/shared-clustering.md README.md +git commit -m "docs: add shared clustering plotting guide" +``` + +## Task 8: Run Final Verification + +**Files:** +- Reference: `dimelo/plotting.py` +- Reference: `tests/test_plotting.py` +- Reference: `tests/test_workflows.py` +- Reference: `docs/shared-clustering.md` +- Reference: `README.md` + +- [ ] **Step 1: Run the focused plotting and workflow tests** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl XDG_CACHE_HOME=/tmp/xdg-cache PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py tests/test_workflows.py -q +``` + +Expected: PASS with no new failures. Existing non-blocking warnings are acceptable if they are unchanged. + +- [ ] **Step 2: Run a quick git status check** + +Run: + +```bash +git status --short +``` + +Expected: clean working tree. + +- [ ] **Step 3: Self-review against the spec** + +Check the completed work against `docs/superpowers/specs/2026-04-02-shared-clustering-plotting-design.md`: + +- distribution/change helper present and additive +- cluster-profile helper present and data-first +- region-occupancy helper present with optional condition aggregation +- existing `result.plot_data` preserved +- docs updated without claiming renderer support + +- [ ] **Step 4: Commit any final doc/test touch-ups if needed** + +```bash +git add dimelo/plotting.py tests/test_plotting.py tests/test_workflows.py docs/shared-clustering.md README.md +git commit -m "fix: tighten shared clustering plotting prep" +``` + +Only make this commit if the self-review or verification uncovered a small follow-up patch. From 1ccc7ebb2d6e7a2bd2864442c67ed3ee27802b06 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 21:27:27 -0700 Subject: [PATCH 166/272] test: add shared clustering distribution plotting coverage --- tests/test_plotting.py | 211 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 211 insertions(+) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index c4c2229..31dae26 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -7,6 +7,8 @@ GlobalAnalysisResult, RegionContrastResult, RegionDiscoveryResult, + SharedClusterModel, + SharedClusterResult, ) from dimelo import plot_enrichment_profile, plot_reads, plotting @@ -120,6 +122,215 @@ def test_prepare_cluster_distribution_heatmap_data_pivots_columns_in_sorted_orde assert ns_row["C1"] == 0.25 +def _make_shared_cluster_result() -> SharedClusterResult: + model = SharedClusterModel( + mode="region_anchored", + motifs=["A,0"], + feature_names=["f0", "f1"], + preprocessing={"signal_normalization": "none"}, + estimator=object(), + cluster_labels=["C0", "C1"], + fit_metadata={"clusterer": "minibatch_kmeans", "n_clusters": 2}, + ) + assignments = pd.DataFrame( + [ + {"sample_id": "s1", "condition": "NS", "cluster": "C0"}, + {"sample_id": "s1", "condition": "NS", "cluster": "C1"}, + {"sample_id": "s2", "condition": "treated", "cluster": "C1"}, + ] + ) + cluster_distribution = pd.DataFrame( + [ + { + "sample_id": "s1", + "condition": "NS", + "cluster": "C0", + "count": 2, + "fraction": 2 / 3, + }, + { + "sample_id": "s1", + "condition": "NS", + "cluster": "C1", + "count": 1, + "fraction": 1 / 3, + }, + { + "sample_id": "s2", + "condition": "treated", + "cluster": "C0", + "count": 1, + "fraction": 1 / 4, + }, + { + "sample_id": "s2", + "condition": "treated", + "cluster": "C1", + "count": 3, + "fraction": 3 / 4, + }, + ] + ) + condition_distribution = pd.DataFrame( + [ + { + "condition": "NS", + "cluster": "C0", + "count": 2, + "fraction": 2 / 3, + "replicate_n": 1, + }, + { + "condition": "NS", + "cluster": "C1", + "count": 1, + "fraction": 1 / 3, + "replicate_n": 1, + }, + { + "condition": "treated", + "cluster": "C0", + "count": 1, + "fraction": 1 / 4, + "replicate_n": 1, + }, + { + "condition": "treated", + "cluster": "C1", + "count": 3, + "fraction": 3 / 4, + "replicate_n": 1, + }, + ] + ) + distribution_change = pd.DataFrame( + [ + { + "condition": "treated", + "cluster": "C0", + "count": 1, + "fraction": 1 / 4, + "replicate_n": 1, + "reference_fraction": 2 / 3, + "delta_fraction": -5 / 12, + "log2_fc": -1.415037499278844, + }, + { + "condition": "treated", + "cluster": "C1", + "count": 3, + "fraction": 3 / 4, + "replicate_n": 1, + "reference_fraction": 1 / 3, + "delta_fraction": 5 / 12, + "log2_fc": 1.1699250014423124, + }, + ] + ) + cluster_profiles = pd.DataFrame( + [ + {"cluster": "C0", "count": 3, "f0": 0.1, "f1": 0.2}, + {"cluster": "C1", "count": 4, "f0": 0.8, "f1": 0.9}, + ] + ) + region_summaries = pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "cluster": "C0", + "count": 2, + "fraction": 2 / 3, + }, + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "cluster": "C1", + "count": 1, + "fraction": 1 / 3, + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "treated", + "cluster": "C0", + "count": 1, + "fraction": 1 / 4, + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "treated", + "cluster": "C1", + "count": 3, + "fraction": 3 / 4, + }, + ] + ) + return SharedClusterResult( + model=model, + assignments=assignments, + cluster_distribution=cluster_distribution, + condition_distribution=condition_distribution, + distribution_change=distribution_change, + cluster_profiles=cluster_profiles, + region_summaries=region_summaries, + plot_data={ + "cluster_distribution_bar": cluster_distribution.copy(), + "cluster_distribution_heatmap": pd.DataFrame( + [ + {"condition": "NS", "C0": 2 / 3, "C1": 1 / 3}, + {"condition": "treated", "C0": 1 / 4, "C1": 3 / 4}, + ] + ), + }, + metadata={"mode": "region_anchored"}, + ) + + +def test_prepare_shared_cluster_distribution_data_returns_distribution_payload(): + result = _make_shared_cluster_result() + + payload = plotting.prepare_shared_cluster_distribution_data(result=result) + + assert set(payload) == { + "sample_distribution", + "condition_distribution", + "distribution_change", + "metadata", + } + assert payload["sample_distribution"]["sample_id"].tolist() == ["s1", "s1", "s2", "s2"] + assert payload["condition_distribution"]["condition"].tolist() == [ + "NS", + "NS", + "treated", + "treated", + ] + assert payload["distribution_change"]["condition"].tolist() == ["treated", "treated"] + assert payload["metadata"]["mode"] == "region_anchored" + + +def test_prepare_shared_cluster_distribution_data_handles_missing_change_table(): + result = _make_shared_cluster_result() + result.distribution_change = None + + payload = plotting.prepare_shared_cluster_distribution_data(result=result) + + assert list(payload["distribution_change"].columns) == [ + "condition", + "cluster", + "count", + "fraction", + "replicate_n", + "reference_fraction", + "delta_fraction", + "log2_fc", + ] + assert payload["distribution_change"].empty + + def _minimal_region_contrast_result() -> RegionContrastResult: regions = pd.DataFrame( [ From 36cd168264ba46e2fea3bec0c5fb098740aa8a72 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 21:54:59 -0700 Subject: [PATCH 167/272] test: tighten shared clustering distribution fixture --- tests/test_plotting.py | 114 ++++++++++++++++------------------------- 1 file changed, 45 insertions(+), 69 deletions(-) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 31dae26..6264e51 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -132,13 +132,6 @@ def _make_shared_cluster_result() -> SharedClusterResult: cluster_labels=["C0", "C1"], fit_metadata={"clusterer": "minibatch_kmeans", "n_clusters": 2}, ) - assignments = pd.DataFrame( - [ - {"sample_id": "s1", "condition": "NS", "cluster": "C0"}, - {"sample_id": "s1", "condition": "NS", "cluster": "C1"}, - {"sample_id": "s2", "condition": "treated", "cluster": "C1"}, - ] - ) cluster_distribution = pd.DataFrame( [ { @@ -227,65 +220,15 @@ def _make_shared_cluster_result() -> SharedClusterResult: }, ] ) - cluster_profiles = pd.DataFrame( - [ - {"cluster": "C0", "count": 3, "f0": 0.1, "f1": 0.2}, - {"cluster": "C1", "count": 4, "f0": 0.8, "f1": 0.9}, - ] - ) - region_summaries = pd.DataFrame( - [ - { - "region_id": "reg1", - "sample_id": "s1", - "condition": "NS", - "cluster": "C0", - "count": 2, - "fraction": 2 / 3, - }, - { - "region_id": "reg1", - "sample_id": "s1", - "condition": "NS", - "cluster": "C1", - "count": 1, - "fraction": 1 / 3, - }, - { - "region_id": "reg1", - "sample_id": "s2", - "condition": "treated", - "cluster": "C0", - "count": 1, - "fraction": 1 / 4, - }, - { - "region_id": "reg1", - "sample_id": "s2", - "condition": "treated", - "cluster": "C1", - "count": 3, - "fraction": 3 / 4, - }, - ] - ) return SharedClusterResult( model=model, - assignments=assignments, + assignments=pd.DataFrame(columns=["sample_id", "condition", "cluster"]), cluster_distribution=cluster_distribution, condition_distribution=condition_distribution, distribution_change=distribution_change, - cluster_profiles=cluster_profiles, - region_summaries=region_summaries, - plot_data={ - "cluster_distribution_bar": cluster_distribution.copy(), - "cluster_distribution_heatmap": pd.DataFrame( - [ - {"condition": "NS", "C0": 2 / 3, "C1": 1 / 3}, - {"condition": "treated", "C0": 1 / 4, "C1": 3 / 4}, - ] - ), - }, + cluster_profiles=pd.DataFrame(columns=["cluster", "count", "f0", "f1"]), + region_summaries=None, + plot_data={}, metadata={"mode": "region_anchored"}, ) @@ -294,6 +237,9 @@ def test_prepare_shared_cluster_distribution_data_returns_distribution_payload() result = _make_shared_cluster_result() payload = plotting.prepare_shared_cluster_distribution_data(result=result) + sample_distribution = payload["sample_distribution"] + condition_distribution = payload["condition_distribution"] + distribution_change = payload["distribution_change"] assert set(payload) == { "sample_distribution", @@ -301,14 +247,29 @@ def test_prepare_shared_cluster_distribution_data_returns_distribution_payload() "distribution_change", "metadata", } - assert payload["sample_distribution"]["sample_id"].tolist() == ["s1", "s1", "s2", "s2"] - assert payload["condition_distribution"]["condition"].tolist() == [ - "NS", - "NS", - "treated", - "treated", - ] - assert payload["distribution_change"]["condition"].tolist() == ["treated", "treated"] + assert sample_distribution["sample_id"].tolist() == ["s1", "s1", "s2", "s2"] + assert sample_distribution["condition"].tolist() == ["NS", "NS", "treated", "treated"] + assert sample_distribution["cluster"].tolist() == ["C0", "C1", "C0", "C1"] + assert sample_distribution["count"].tolist() == [2, 1, 1, 3] + assert sample_distribution["fraction"].tolist() == pytest.approx( + [2 / 3, 1 / 3, 1 / 4, 3 / 4] + ) + assert condition_distribution["condition"].tolist() == ["NS", "NS", "treated", "treated"] + assert condition_distribution["cluster"].tolist() == ["C0", "C1", "C0", "C1"] + assert condition_distribution["count"].tolist() == [2, 1, 1, 3] + assert condition_distribution["fraction"].tolist() == pytest.approx( + [2 / 3, 1 / 3, 1 / 4, 3 / 4] + ) + assert condition_distribution["replicate_n"].tolist() == [1, 1, 1, 1] + assert distribution_change["condition"].tolist() == ["treated", "treated"] + assert distribution_change["cluster"].tolist() == ["C0", "C1"] + assert distribution_change["count"].tolist() == [1, 3] + assert distribution_change["fraction"].tolist() == pytest.approx([1 / 4, 3 / 4]) + assert distribution_change["reference_fraction"].tolist() == pytest.approx([2 / 3, 1 / 3]) + assert distribution_change["delta_fraction"].tolist() == pytest.approx([-5 / 12, 5 / 12]) + assert distribution_change["log2_fc"].tolist() == pytest.approx( + [-1.415037499278844, 1.1699250014423124] + ) assert payload["metadata"]["mode"] == "region_anchored" @@ -317,6 +278,8 @@ def test_prepare_shared_cluster_distribution_data_handles_missing_change_table() result.distribution_change = None payload = plotting.prepare_shared_cluster_distribution_data(result=result) + sample_distribution = payload["sample_distribution"] + condition_distribution = payload["condition_distribution"] assert list(payload["distribution_change"].columns) == [ "condition", @@ -329,6 +292,19 @@ def test_prepare_shared_cluster_distribution_data_handles_missing_change_table() "log2_fc", ] assert payload["distribution_change"].empty + assert sample_distribution["sample_id"].tolist() == ["s1", "s1", "s2", "s2"] + assert sample_distribution["cluster"].tolist() == ["C0", "C1", "C0", "C1"] + assert sample_distribution["count"].tolist() == [2, 1, 1, 3] + assert sample_distribution["fraction"].tolist() == pytest.approx( + [2 / 3, 1 / 3, 1 / 4, 3 / 4] + ) + assert condition_distribution["condition"].tolist() == ["NS", "NS", "treated", "treated"] + assert condition_distribution["cluster"].tolist() == ["C0", "C1", "C0", "C1"] + assert condition_distribution["count"].tolist() == [2, 1, 1, 3] + assert condition_distribution["fraction"].tolist() == pytest.approx( + [2 / 3, 1 / 3, 1 / 4, 3 / 4] + ) + assert condition_distribution["replicate_n"].tolist() == [1, 1, 1, 1] def _minimal_region_contrast_result() -> RegionContrastResult: From d81a51b577a433057b910cdb27d1b7225cb1ecb5 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 22:02:46 -0700 Subject: [PATCH 168/272] feat: add shared clustering distribution plotting prep --- dimelo/plotting.py | 98 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 98 insertions(+) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 8f0e9e2..5f5650e 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -138,6 +138,35 @@ def _validate_global_analysis_result(result) -> None: raise TypeError("plotting helpers require a GlobalAnalysisResult-like object.") +def _validate_shared_cluster_result(result) -> None: + if result is None: + raise ValueError("plotting helpers require a SharedClusterResult.") + required_attrs = ( + "cluster_distribution", + "condition_distribution", + "cluster_profiles", + "plot_data", + "metadata", + ) + if not all(hasattr(result, attr) for attr in required_attrs): + raise TypeError("plotting helpers require a SharedClusterResult-like object.") + + +def _empty_distribution_change_table() -> pd.DataFrame: + return pd.DataFrame( + columns=[ + "condition", + "cluster", + "count", + "fraction", + "replicate_n", + "reference_fraction", + "delta_fraction", + "log2_fc", + ] + ) + + def _filter_motif_table(table: pd.DataFrame, motifs: list[str] | None, *, owner: str) -> pd.DataFrame: _require_columns(table, ("motif",), owner) if motifs is None: @@ -1228,3 +1257,72 @@ def prepare_cluster_distribution_heatmap_data(condition_distribution: pd.DataFra ) heatmap.columns.name = None return heatmap + + +def prepare_shared_cluster_distribution_data( + *, + result, +) -> dict[str, pd.DataFrame | dict[str, object]]: + _validate_shared_cluster_result(result) + + sample_distribution = prepare_cluster_distribution_bar_data(result.cluster_distribution) + + _require_columns( + result.condition_distribution, + ("condition", "cluster", "count", "fraction", "replicate_n"), + "result.condition_distribution", + ) + condition_distribution = ( + result.condition_distribution.loc[ + :, ["condition", "cluster", "count", "fraction", "replicate_n"] + ] + .sort_values(["condition", "cluster"], kind="stable") + .reset_index(drop=True) + ) + + if result.distribution_change is None: + distribution_change = _empty_distribution_change_table() + else: + _require_columns( + result.distribution_change, + ( + "condition", + "cluster", + "count", + "fraction", + "replicate_n", + "reference_fraction", + "delta_fraction", + "log2_fc", + ), + "result.distribution_change", + ) + distribution_change = ( + result.distribution_change.loc[ + :, + [ + "condition", + "cluster", + "count", + "fraction", + "replicate_n", + "reference_fraction", + "delta_fraction", + "log2_fc", + ], + ] + .sort_values(["condition", "cluster"], kind="stable") + .reset_index(drop=True) + ) + + metadata = { + "mode": result.model.mode, + "cluster_labels": list(result.model.cluster_labels), + "has_distribution_change": not distribution_change.empty, + } + return { + "sample_distribution": sample_distribution, + "condition_distribution": condition_distribution, + "distribution_change": distribution_change, + "metadata": metadata, + } From eb7ccd2e9fac006c0199943032b5192a43e4d1d8 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 22:10:37 -0700 Subject: [PATCH 169/272] feat: tighten shared clustering result validation --- dimelo/plotting.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 5f5650e..d926ad9 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -142,6 +142,7 @@ def _validate_shared_cluster_result(result) -> None: if result is None: raise ValueError("plotting helpers require a SharedClusterResult.") required_attrs = ( + "model", "cluster_distribution", "condition_distribution", "cluster_profiles", @@ -150,6 +151,8 @@ def _validate_shared_cluster_result(result) -> None: ) if not all(hasattr(result, attr) for attr in required_attrs): raise TypeError("plotting helpers require a SharedClusterResult-like object.") + if not hasattr(result.model, "mode") or not hasattr(result.model, "cluster_labels"): + raise TypeError("plotting helpers require a SharedClusterResult-like object.") def _empty_distribution_change_table() -> pd.DataFrame: From f8357dfa52c575f6806b7e397e01ff796d4f5bf7 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 22:13:05 -0700 Subject: [PATCH 170/272] test: add shared clustering profile plotting coverage --- tests/test_plotting.py | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 6264e51..fc493b7 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -307,6 +307,38 @@ def test_prepare_shared_cluster_distribution_data_handles_missing_change_table() assert condition_distribution["replicate_n"].tolist() == [1, 1, 1, 1] +def _make_shared_cluster_profile_result() -> SharedClusterResult: + result = _make_shared_cluster_result() + result.cluster_profiles = pd.DataFrame( + [ + {"cluster": "C0", "count": 3, "f0": 0.1, "f1": 0.2}, + {"cluster": "C1", "count": 4, "f0": 0.8, "f1": 0.9}, + ] + ) + return result + + +def test_prepare_shared_cluster_profile_data_returns_long_form_profiles(): + result = _make_shared_cluster_profile_result() + + payload = plotting.prepare_shared_cluster_profile_data(result=result) + + assert set(payload) == {"profile_table", "metadata"} + assert set(payload["profile_table"].columns) == {"cluster", "feature", "value", "count"} + assert payload["profile_table"]["cluster"].tolist() == ["C0", "C0", "C1", "C1"] + assert payload["profile_table"]["feature"].tolist() == ["f0", "f1", "f0", "f1"] + assert payload["metadata"]["feature_names"] == ["f0", "f1"] + + +def test_prepare_shared_cluster_profile_data_respects_feature_subset(): + result = _make_shared_cluster_profile_result() + + payload = plotting.prepare_shared_cluster_profile_data(result=result, features=["f1"]) + + assert payload["profile_table"]["feature"].unique().tolist() == ["f1"] + assert payload["profile_table"]["cluster"].tolist() == ["C0", "C1"] + + def _minimal_region_contrast_result() -> RegionContrastResult: regions = pd.DataFrame( [ From 14ad4f89cf705d6153ff0a71df2795583333179b Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 22:15:14 -0700 Subject: [PATCH 171/272] test: tighten shared clustering profile fixture --- tests/test_plotting.py | 52 ++++++++++++++++++++++++++++++++---------- 1 file changed, 40 insertions(+), 12 deletions(-) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index fc493b7..6a012b0 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -308,25 +308,50 @@ def test_prepare_shared_cluster_distribution_data_handles_missing_change_table() def _make_shared_cluster_profile_result() -> SharedClusterResult: - result = _make_shared_cluster_result() - result.cluster_profiles = pd.DataFrame( - [ - {"cluster": "C0", "count": 3, "f0": 0.1, "f1": 0.2}, - {"cluster": "C1", "count": 4, "f0": 0.8, "f1": 0.9}, - ] + return SharedClusterResult( + model=SharedClusterModel( + mode="region_anchored", + motifs=["A,0"], + feature_names=["f0", "f1"], + preprocessing={"signal_normalization": "none"}, + estimator=object(), + cluster_labels=["C0", "C1"], + fit_metadata={"clusterer": "minibatch_kmeans", "n_clusters": 2}, + ), + assignments=pd.DataFrame(columns=["sample_id", "condition", "cluster"]), + cluster_distribution=pd.DataFrame( + columns=["sample_id", "condition", "cluster", "count", "fraction"] + ), + condition_distribution=pd.DataFrame( + columns=["condition", "cluster", "count", "fraction", "replicate_n"] + ), + distribution_change=None, + cluster_profiles=pd.DataFrame( + [ + {"cluster": "C0", "count": 3, "f0": 0.1, "f1": 0.2}, + {"cluster": "C1", "count": 4, "f0": 0.8, "f1": 0.9}, + ] + ), + region_summaries=None, + plot_data={}, + metadata={"mode": "region_anchored"}, ) - return result def test_prepare_shared_cluster_profile_data_returns_long_form_profiles(): result = _make_shared_cluster_profile_result() payload = plotting.prepare_shared_cluster_profile_data(result=result) + profile_table = payload["profile_table"] assert set(payload) == {"profile_table", "metadata"} - assert set(payload["profile_table"].columns) == {"cluster", "feature", "value", "count"} - assert payload["profile_table"]["cluster"].tolist() == ["C0", "C0", "C1", "C1"] - assert payload["profile_table"]["feature"].tolist() == ["f0", "f1", "f0", "f1"] + assert set(profile_table.columns) == {"cluster", "feature", "value", "count"} + assert profile_table.to_dict("records") == [ + {"cluster": "C0", "feature": "f0", "value": pytest.approx(0.1), "count": 3}, + {"cluster": "C0", "feature": "f1", "value": pytest.approx(0.2), "count": 3}, + {"cluster": "C1", "feature": "f0", "value": pytest.approx(0.8), "count": 4}, + {"cluster": "C1", "feature": "f1", "value": pytest.approx(0.9), "count": 4}, + ] assert payload["metadata"]["feature_names"] == ["f0", "f1"] @@ -334,9 +359,12 @@ def test_prepare_shared_cluster_profile_data_respects_feature_subset(): result = _make_shared_cluster_profile_result() payload = plotting.prepare_shared_cluster_profile_data(result=result, features=["f1"]) + profile_table = payload["profile_table"] - assert payload["profile_table"]["feature"].unique().tolist() == ["f1"] - assert payload["profile_table"]["cluster"].tolist() == ["C0", "C1"] + assert profile_table.to_dict("records") == [ + {"cluster": "C0", "feature": "f1", "value": pytest.approx(0.2), "count": 3}, + {"cluster": "C1", "feature": "f1", "value": pytest.approx(0.9), "count": 4}, + ] def _minimal_region_contrast_result() -> RegionContrastResult: From b9a60be38e3d7fb85a1f8d1cb23a07f766e2f2c7 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 22:17:42 -0700 Subject: [PATCH 172/272] feat: add shared clustering profile plotting prep --- dimelo/plotting.py | 46 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index d926ad9..48305e4 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -1329,3 +1329,49 @@ def prepare_shared_cluster_distribution_data( "distribution_change": distribution_change, "metadata": metadata, } + + +def prepare_shared_cluster_profile_data( + *, + result, + features: list[str] | None = None, +) -> dict[str, pd.DataFrame | dict[str, object]]: + _validate_shared_cluster_result(result) + + cluster_profiles = result.cluster_profiles.copy() + if cluster_profiles.empty: + return { + "profile_table": pd.DataFrame(columns=["cluster", "feature", "value", "count"]), + "metadata": { + "feature_names": [], + "cluster_labels": list(result.model.cluster_labels), + }, + } + + _require_columns(cluster_profiles, ("cluster", "count"), "result.cluster_profiles") + + feature_names = [ + column for column in cluster_profiles.columns if column not in {"cluster", "count"} + ] + if features is not None: + missing = [feature for feature in features if feature not in feature_names] + if missing: + raise ValueError( + "Requested features are not present in cluster_profiles: " + f"{', '.join(missing)}" + ) + feature_names = [feature for feature in feature_names if feature in features] + + profile_table = ( + cluster_profiles.loc[:, ["cluster", "count", *feature_names]] + .melt(id_vars=["cluster", "count"], var_name="feature", value_name="value") + .sort_values(["cluster", "feature"], kind="stable") + .reset_index(drop=True) + ) + return { + "profile_table": profile_table, + "metadata": { + "feature_names": feature_names, + "cluster_labels": list(result.model.cluster_labels), + }, + } From 17e1e2128ca6b0ff7d6fe0d4590390367961e387 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 22:19:44 -0700 Subject: [PATCH 173/272] feat: tighten shared clustering profile feature validation --- dimelo/plotting.py | 34 ++++++++++++++++++---------------- 1 file changed, 18 insertions(+), 16 deletions(-) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 48305e4..a92715f 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -1337,22 +1337,13 @@ def prepare_shared_cluster_profile_data( features: list[str] | None = None, ) -> dict[str, pd.DataFrame | dict[str, object]]: _validate_shared_cluster_result(result) + if not hasattr(result.model, "feature_names"): + raise TypeError("plotting helpers require a SharedClusterResult-like object.") cluster_profiles = result.cluster_profiles.copy() - if cluster_profiles.empty: - return { - "profile_table": pd.DataFrame(columns=["cluster", "feature", "value", "count"]), - "metadata": { - "feature_names": [], - "cluster_labels": list(result.model.cluster_labels), - }, - } + feature_names = list(result.model.feature_names) - _require_columns(cluster_profiles, ("cluster", "count"), "result.cluster_profiles") - - feature_names = [ - column for column in cluster_profiles.columns if column not in {"cluster", "count"} - ] + requested_features = feature_names if features is not None: missing = [feature for feature in features if feature not in feature_names] if missing: @@ -1360,10 +1351,21 @@ def prepare_shared_cluster_profile_data( "Requested features are not present in cluster_profiles: " f"{', '.join(missing)}" ) - feature_names = [feature for feature in feature_names if feature in features] + requested_features = [feature for feature in feature_names if feature in features] + + _require_columns(cluster_profiles, ("cluster", "count", *feature_names), "result.cluster_profiles") + + if cluster_profiles.empty: + return { + "profile_table": pd.DataFrame(columns=["cluster", "feature", "value", "count"]), + "metadata": { + "feature_names": requested_features, + "cluster_labels": list(result.model.cluster_labels), + }, + } profile_table = ( - cluster_profiles.loc[:, ["cluster", "count", *feature_names]] + cluster_profiles.loc[:, ["cluster", "count", *requested_features]] .melt(id_vars=["cluster", "count"], var_name="feature", value_name="value") .sort_values(["cluster", "feature"], kind="stable") .reset_index(drop=True) @@ -1371,7 +1373,7 @@ def prepare_shared_cluster_profile_data( return { "profile_table": profile_table, "metadata": { - "feature_names": feature_names, + "feature_names": requested_features, "cluster_labels": list(result.model.cluster_labels), }, } From 51bc3042d01f65159c73e6b44aee4daee92bceee Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 22:21:52 -0700 Subject: [PATCH 174/272] test: add shared clustering region plotting coverage --- tests/test_plotting.py | 96 +++++++++++++++++++++++++++++++++++++++++ tests/test_workflows.py | 63 ++++++++++++++++++++++++++- 2 files changed, 158 insertions(+), 1 deletion(-) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 6a012b0..93503c4 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -367,6 +367,102 @@ def test_prepare_shared_cluster_profile_data_respects_feature_subset(): ] +def _make_shared_cluster_region_result() -> SharedClusterResult: + return SharedClusterResult( + model=SharedClusterModel( + mode="region_anchored", + motifs=["A,0"], + feature_names=["f0", "f1"], + preprocessing={"signal_normalization": "none"}, + estimator=object(), + cluster_labels=["C0", "C1"], + fit_metadata={"clusterer": "minibatch_kmeans", "n_clusters": 2}, + ), + assignments=pd.DataFrame(columns=["sample_id", "condition", "cluster"]), + cluster_distribution=pd.DataFrame( + columns=["sample_id", "condition", "cluster", "count", "fraction"] + ), + condition_distribution=pd.DataFrame( + columns=["condition", "cluster", "count", "fraction", "replicate_n"] + ), + distribution_change=None, + cluster_profiles=pd.DataFrame(columns=["cluster", "count", "f0", "f1"]), + region_summaries=pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "cluster": "C0", + "count": 2, + "fraction": 2 / 3, + }, + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "cluster": "C1", + "count": 1, + "fraction": 1 / 3, + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "treated", + "cluster": "C0", + "count": 1, + "fraction": 1 / 4, + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "treated", + "cluster": "C1", + "count": 3, + "fraction": 3 / 4, + }, + ] + ), + plot_data={}, + metadata={"mode": "region_anchored"}, + ) + + +def test_prepare_shared_cluster_region_data_returns_sample_and_condition_tables(): + result = _make_shared_cluster_region_result() + + payload = plotting.prepare_shared_cluster_region_data(result=result) + + assert set(payload) == {"region_table", "condition_region_table", "metadata"} + assert payload["region_table"]["sample_id"].tolist() == ["s1", "s1", "s2", "s2"] + assert payload["condition_region_table"]["condition"].tolist() == [ + "NS", + "NS", + "treated", + "treated", + ] + assert payload["metadata"]["mode"] == "region_anchored" + + +def test_prepare_shared_cluster_region_data_can_disable_condition_aggregation(): + result = _make_shared_cluster_region_result() + + payload = plotting.prepare_shared_cluster_region_data( + result=result, + aggregate_conditions=False, + ) + + assert payload["condition_region_table"].empty + + +def test_prepare_shared_cluster_region_data_rejects_missing_region_summaries(): + result = _make_shared_cluster_region_result() + result.region_summaries = None + + with pytest.raises(ValueError, match="region_summaries"): + plotting.prepare_shared_cluster_region_data(result=result) + + def _minimal_region_contrast_result() -> RegionContrastResult: regions = pd.DataFrame( [ diff --git a/tests/test_workflows.py b/tests/test_workflows.py index 1867119..2f03709 100644 --- a/tests/test_workflows.py +++ b/tests/test_workflows.py @@ -2,7 +2,7 @@ import pandas as pd import pytest -from dimelo import workflows +from dimelo import plotting, workflows from dimelo.models import ContrastSpec, DatasetArtifact from dimelo.models import ( RegionContrastResult, @@ -863,6 +863,67 @@ def fake_region_table(*args, **kwargs): ) +def test_shared_cluster_region_data_region_anchored_region_summaries_feed_region_plotting( + monkeypatch, +): + fake_samples = [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + regions_bed="r1.bed", + metadata={"pileup_path": "s1.bed.gz"}, + ), + SampleSpec( + sample_id="s2", + condition="treated", + extract_h5="s2.h5", + regions_bed="r2.bed", + metadata={"pileup_path": "s2.bed.gz"}, + ), + ] + + def fake_region_table(*args, **kwargs): + return np.array([[0.1, 0.9], [0.9, 0.1]]), [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "replicate": None, + "chromosome": "chr1", + "start": 0, + "end": 2, + "strand": "+", + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "treated", + "replicate": None, + "chromosome": "chr1", + "start": 0, + "end": 2, + "strand": "+", + }, + ] + + monkeypatch.setattr(workflows.region_analysis, "build_region_feature_table", fake_region_table) + + result = workflows.shared_cluster_distribution( + samples=fake_samples, + mode="region_anchored", + motifs=["A,0"], + matched_regions="matched.bed", + n_clusters=2, + make_plots=False, + ) + + payload = plotting.prepare_shared_cluster_region_data(result=result) + + assert not payload["region_table"].empty + assert list(payload["condition_region_table"]["condition"].unique()) == ["NS", "treated"] + + def test_shared_cluster_distribution_region_anchored_requires_matched_regions(): with pytest.raises(ValueError, match="requires matched_regions"): workflows.shared_cluster_distribution( From 22105a482aaf7ee82cd43c1ea5ef910364c58634 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 22:24:53 -0700 Subject: [PATCH 175/272] test: tighten shared clustering region assertions --- tests/test_plotting.py | 79 +++++++++++++++++++++++++++++++++++++---- tests/test_workflows.py | 19 ++++++++-- 2 files changed, 90 insertions(+), 8 deletions(-) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 93503c4..e785fe7 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -434,12 +434,79 @@ def test_prepare_shared_cluster_region_data_returns_sample_and_condition_tables( payload = plotting.prepare_shared_cluster_region_data(result=result) assert set(payload) == {"region_table", "condition_region_table", "metadata"} - assert payload["region_table"]["sample_id"].tolist() == ["s1", "s1", "s2", "s2"] - assert payload["condition_region_table"]["condition"].tolist() == [ - "NS", - "NS", - "treated", - "treated", + region_table = payload["region_table"] + condition_region_table = payload["condition_region_table"] + assert region_table.to_dict("records") == [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "cluster": "C0", + "count": 2, + "fraction": pytest.approx(2 / 3), + }, + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "cluster": "C1", + "count": 1, + "fraction": pytest.approx(1 / 3), + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "treated", + "cluster": "C0", + "count": 1, + "fraction": pytest.approx(1 / 4), + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "treated", + "cluster": "C1", + "count": 3, + "fraction": pytest.approx(3 / 4), + }, + ] + assert condition_region_table.to_dict("records") == [ + { + "region_id": "reg1", + "condition": "NS", + "cluster": "C0", + "count": 2, + "fraction_mean": pytest.approx(2 / 3), + "fraction_median": pytest.approx(2 / 3), + "sample_n": 1, + }, + { + "region_id": "reg1", + "condition": "NS", + "cluster": "C1", + "count": 1, + "fraction_mean": pytest.approx(1 / 3), + "fraction_median": pytest.approx(1 / 3), + "sample_n": 1, + }, + { + "region_id": "reg1", + "condition": "treated", + "cluster": "C0", + "count": 1, + "fraction_mean": pytest.approx(1 / 4), + "fraction_median": pytest.approx(1 / 4), + "sample_n": 1, + }, + { + "region_id": "reg1", + "condition": "treated", + "cluster": "C1", + "count": 3, + "fraction_mean": pytest.approx(3 / 4), + "fraction_median": pytest.approx(3 / 4), + "sample_n": 1, + }, ] assert payload["metadata"]["mode"] == "region_anchored" diff --git a/tests/test_workflows.py b/tests/test_workflows.py index 2f03709..dc84256 100644 --- a/tests/test_workflows.py +++ b/tests/test_workflows.py @@ -920,8 +920,23 @@ def fake_region_table(*args, **kwargs): payload = plotting.prepare_shared_cluster_region_data(result=result) - assert not payload["region_table"].empty - assert list(payload["condition_region_table"]["condition"].unique()) == ["NS", "treated"] + assert payload["region_table"].iloc[0].to_dict() == { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "cluster": "C0", + "count": 1, + "fraction": pytest.approx(1.0), + } + assert payload["condition_region_table"].iloc[0].to_dict() == { + "region_id": "reg1", + "condition": "NS", + "cluster": "C0", + "count": 1, + "fraction_mean": pytest.approx(1.0), + "fraction_median": pytest.approx(1.0), + "sample_n": 1, + } def test_shared_cluster_distribution_region_anchored_requires_matched_regions(): From e27d19753d58b6ac9ffbc64de96134ed280bd925 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 22:26:18 -0700 Subject: [PATCH 176/272] feat: add shared clustering region plotting prep --- dimelo/plotting.py | 58 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index a92715f..3a5165d 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -1377,3 +1377,61 @@ def prepare_shared_cluster_profile_data( "cluster_labels": list(result.model.cluster_labels), }, } + + +def prepare_shared_cluster_region_data( + *, + result, + aggregate_conditions: bool = True, +) -> dict[str, pd.DataFrame | dict[str, object]]: + _validate_shared_cluster_result(result) + if result.region_summaries is None: + raise ValueError("SharedClusterResult.region_summaries is required for region plotting.") + + _require_columns( + result.region_summaries, + ("region_id", "sample_id", "condition", "cluster", "count", "fraction"), + "result.region_summaries", + ) + region_table = ( + result.region_summaries.loc[ + :, ["region_id", "sample_id", "condition", "cluster", "count", "fraction"] + ] + .sort_values(["region_id", "sample_id", "cluster"], kind="stable") + .reset_index(drop=True) + ) + + if aggregate_conditions and not region_table.empty: + condition_region_table = ( + region_table.groupby(["region_id", "condition", "cluster"], as_index=False, sort=False) + .agg( + count=("count", "sum"), + fraction_mean=("fraction", "mean"), + fraction_median=("fraction", "median"), + sample_n=("sample_id", "nunique"), + ) + .sort_values(["region_id", "condition", "cluster"], kind="stable") + .reset_index(drop=True) + ) + else: + condition_region_table = pd.DataFrame( + columns=[ + "region_id", + "condition", + "cluster", + "count", + "fraction_mean", + "fraction_median", + "sample_n", + ] + ) + + return { + "region_table": region_table, + "condition_region_table": condition_region_table, + "metadata": { + "mode": result.model.mode, + "cluster_labels": list(result.model.cluster_labels), + "has_condition_aggregation": aggregate_conditions, + }, + } From 18257f71609a1dcbc752448132d944ccd1b6a959 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 2 Apr 2026 22:28:06 -0700 Subject: [PATCH 177/272] docs: add shared clustering plotting guide --- README.md | 2 ++ docs/shared-clustering.md | 19 +++++++++++++++++++ 2 files changed, 21 insertions(+) diff --git a/README.md b/README.md index 1c8ae98..fce4fee 100644 --- a/README.md +++ b/README.md @@ -241,6 +241,8 @@ For discovery-to-clustering-to-contrast follow-up, use `workflows.discovery_clus `region_contrasts` uses the same data-prep-first plotting layer: `prepare_region_contrast_profile_data(...)` and `prepare_region_contrast_heatmap_data(...)` consume a `RegionContrastResult` plus an explicit positional table, while shared clustering currently keeps lighter plotting coverage through plot-ready tables in `result.plot_data`. +Shared clustering also has renderer-neutral plotting prep in `dimelo.plotting`. Use `prepare_shared_cluster_distribution_data(...)` for sample/condition cluster fractions, `prepare_shared_cluster_profile_data(...)` for cluster feature summaries, and `prepare_shared_cluster_region_data(...)` for region-level occupancy tables. The older lightweight `result.plot_data["cluster_distribution_bar"]` and `result.plot_data["cluster_distribution_heatmap"]` payloads remain supported. + For human-readable pileups (bedmethyl files, .bed) and extracted reads (.txt tab-separated values), run with `cleanup=False`. `cleanup=True` will clear these outputs because they can take up a lot of space. ### Parsing outputs diff --git a/docs/shared-clustering.md b/docs/shared-clustering.md index caf0235..ac61bca 100644 --- a/docs/shared-clustering.md +++ b/docs/shared-clustering.md @@ -80,6 +80,25 @@ Built-in plotting remains intentionally thin. `result.plot_data["cluster_distrib This is lighter plotting coverage than the newer analysis-specific helpers in `region_contrasts`, `region_discovery`, and `global_analysis`, which now expose dedicated renderer-neutral plotting-prep functions around their result objects. +## Plotting Prep Helpers + +`SharedClusterResult` now has three renderer-neutral plotting helpers in `dimelo.plotting`: + +- `prepare_shared_cluster_distribution_data(result=...)` +- `prepare_shared_cluster_profile_data(result=...)` +- `prepare_shared_cluster_region_data(result=...)` + +These helpers sit on top of the canonical result tables: + +- `result.cluster_distribution` +- `result.condition_distribution` +- `result.distribution_change` +- `result.cluster_profiles` +- `result.region_summaries` + +The older lightweight payloads in `result.plot_data["cluster_distribution_bar"]` and +`result.plot_data["cluster_distribution_heatmap"]` remain supported for backward familiarity. + The plotting contract stays compatibility-safe with older package versions: - legacy Matplotlib wrappers still work From 577514828dba08078f14d52ab030d54615bc3975 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Fri, 3 Apr 2026 15:21:07 -0700 Subject: [PATCH 178/272] docs: add single-read region contrast design --- ...-03-single-read-region-contrasts-design.md | 384 ++++++++++++++++++ 1 file changed, 384 insertions(+) create mode 100644 docs/superpowers/specs/2026-04-03-single-read-region-contrasts-design.md diff --git a/docs/superpowers/specs/2026-04-03-single-read-region-contrasts-design.md b/docs/superpowers/specs/2026-04-03-single-read-region-contrasts-design.md new file mode 100644 index 0000000..c634fa8 --- /dev/null +++ b/docs/superpowers/specs/2026-04-03-single-read-region-contrasts-design.md @@ -0,0 +1,384 @@ +# Single-Read Region Contrasts Design + +## Summary + +Extend `dimelo.region_contrasts` with a first `analysis_unit="single_read"` family for +defined-region comparison on extract-backed read data. + +The first version should support two parallel representations: + +- `representation="read_mod_fraction"` +- `representation="read_window_features"` + +Both representations should remain inside `region_contrasts.score_regions(...)`, +reuse the existing explicit `contrast + analysis_unit + representation` contract, +and keep the inferential unit at the sample level rather than treating reads as +independent biological replicates. + +## Goals + +- Add a first `single_read` analysis path to `region_contrasts` without creating a new top-level module. +- Support direct read-level defined-region comparison on top of the existing extract-backed workflows. +- Make it explicit what kind of read quantity is being contrasted. +- Preserve the current `region_contrasts` mental model: + one entry point, explicit contrast semantics, explicit unit of analysis. +- Support two first-class `single_read` representations in parallel: + - `read_mod_fraction` + - `read_window_features` +- Keep the inferential unit sample-aware rather than pooling reads as if they were replicates. +- Support built-in read-window features by default while allowing user-supplied feature tables. +- Support `pairwise`, `group_vs_group`, and `matched_pairwise` in the first version. +- Preserve continuity with the current extract-backed clustering/window feature logic. + +## Non-Goals + +- Create a separate `read_contrasts` module in v1. +- Add `single_read` support for every possible representation in the first release. +- Treat reads as the formal inferential unit across conditions. +- Add time-course or background-adjusted `single_read` contrasts in the first version. +- Build full single-read positional plotting in this slice. +- Replace or redefine existing `ensemble_region` or `cluster_occupancy` behavior. + +## Why `single_read` Belongs Inside `region_contrasts` + +`single_read` is still a defined-region contrast problem: + +- the loci are already known +- the user still needs explicit contrast semantics +- the user still needs explicit unit and representation semantics + +So the right public API is still: + +```python +region_contrasts.score_regions(...) +``` + +with a new: + +- `analysis_unit="single_read"` + +This keeps the package coherent: + +- `ensemble_region` asks whether locus-aggregated abundance changed +- `single_read` asks whether read-level behavior within known loci changed +- `cluster_occupancy` asks whether the mixture of inferred read states changed + +## First-Version Representations + +### `representation="read_mod_fraction"` + +Each read contributes one scalar value per `region x sample`: + +- modified motifs / valid motifs on that read within that region + +This representation is for asking: + +- did the distribution of per-read modification levels shift? +- did read-level heterogeneity change even when the locus average looked similar? + +This is the strongest first `single_read` path because it is: + +- easy to interpret +- close to the current motif-abundance framing +- a natural bridge between `ensemble_region` and richer read-structure analyses + +### `representation="read_window_features"` + +Each read contributes a feature vector per `region x sample`. + +The default first source of features should be the current built-in feature set already +used in clustering/window workflows. The API should also allow a validated user-supplied +feature table override. + +This representation is for asking: + +- did structured read-level summaries change? +- did central-versus-flank, density-like, or shape-like read summaries reorganize? + +This representation should be more flexible than `read_mod_fraction`, but also more +conservative in what it claims inferentially in v1. + +## Supported Contrast Modes In v1 + +The first `single_read` release should support: + +- `pairwise` +- `group_vs_group` +- `matched_pairwise` + +It should not yet support: + +- `time_course` +- `background_adjusted` +- more complex repeated-measures or mixed-model paths + +### Why `matched_pairwise` Is Included Early + +`single_read` summaries become scientifically much cleaner once the inferential unit +stays at the sample level. That makes matched before/after and targeting versus +nontargeting comparisons natural extensions of the first sample-aware design. + +## Replication And Statistical Unit + +The central statistical rule is: + +- reads are observational units +- samples remain the inferential units + +The implementation should therefore follow this pattern: + +1. compute read-level values within each `region x sample` +2. summarize those read-level values into sample-level region statistics +3. compare those sample-level summaries across contrast sides + +This avoids the major failure mode of pooled-read inference: + +- pretending thousands of reads are thousands of biological replicates + +### Consequence + +`analysis_unit="single_read"` does **not** mean: + +- every read is treated as an independent test unit across conditions + +It means: + +- read-level observations are used to build sample-aware contrast summaries + +## Evidence Model + +### Shared Required Columns + +Both `single_read` representations should compile into an evidence table that preserves: + +- `region_id` +- `sample_id` +- `condition` +- `read_id` +- optional `replicate` +- optional pairing metadata copied from the sample metadata when needed + +The evidence table then diverges by representation. + +### `read_mod_fraction` Evidence + +Required columns: + +- `region_id` +- `sample_id` +- `condition` +- `read_id` +- `modified_count` +- `valid_count` +- `read_mod_fraction` + +Optional columns: + +- `replicate` +- sample metadata fields used by pairing or grouping + +### `read_window_features` Evidence + +Required columns: + +- `region_id` +- `sample_id` +- `condition` +- `read_id` +- one or more feature columns + +Optional columns: + +- `replicate` +- sample metadata fields used by pairing or grouping + +## Feature Source Contract + +### Built-In Default + +If the user does not supply a feature table, `single_read` feature contrasts should use +the current built-in feature set already used in extract-backed clustering/window workflows. + +This preserves continuity with the package’s current feature engineering path. + +### User-Supplied Override + +If the user supplies `feature_table=...`, the contrast layer should validate and use that +table instead of the built-in features. + +Required constraints for user feature tables: + +- same `region_id` +- same `sample_id` +- same `condition` +- same `read_id` +- explicit feature columns + +The downstream contrast logic should not need to care whether the feature rows came from +built-in extraction or user-supplied features once validation is complete. + +## API Shape + +The public API should remain: + +```python +result = region_contrasts.score_regions( + samples=samples, + regions=regions, + contrast=contrast_spec, + analysis_unit="single_read", + representation="read_mod_fraction", + signal_source="extract_reads", + test="sample_distribution_shift", +) +``` + +and: + +```python +result = region_contrasts.score_regions( + samples=samples, + regions=regions, + contrast=contrast_spec, + analysis_unit="single_read", + representation="read_window_features", + signal_source="extract_features", + test="feature_summary_shift", + feature_table=user_feature_table, # optional +) +``` + +### Required Validation Rules + +`analysis_unit="single_read"` should require: + +- a supported `representation` +- a supported `signal_source` +- a supported `test` +- only supported contrast modes + +## v1 Support Matrix + +### `analysis_unit="single_read"` + +#### `representation="read_mod_fraction"` + +Allowed: + +- `signal_source="extract_reads"` +- `test="effect_size_only"` +- `test="sample_distribution_shift"` +- `contrast.mode in {"pairwise", "group_vs_group", "matched_pairwise"}` + +#### `representation="read_window_features"` + +Allowed: + +- `signal_source="extract_features"` +- `test="effect_size_only"` +- `test="feature_summary_shift"` +- `contrast.mode in {"pairwise", "group_vs_group", "matched_pairwise"}` +- built-in features by default +- user-supplied `feature_table` override + +Disallowed in v1: + +- `time_course` +- `background_adjusted` +- `beta_binomial` +- pooled-read inferential tests + +## Statistical Meaning + +### `read_mod_fraction` + +This representation should support the stronger first inferential `single_read` path. + +Suggested v1 outputs: + +- sample-level mean read fraction +- sample-level median read fraction +- sample-level variance or spread summary +- contrast-side deltas across sample summaries + +`test="sample_distribution_shift"` should be defined at the sample-summary level rather +than on pooled reads. + +### `read_window_features` + +This representation should start more conservatively. + +Suggested v1 outputs: + +- per-feature sample-level means +- per-feature sample-level medians +- per-feature effect-size summaries across contrast sides + +`test="feature_summary_shift"` should primarily be a sample-summary comparison path in v1. +It may be descriptive or lightly inferential, but it should not overstate multivariate +read-feature inference. + +## Result Contract + +`RegionContrastResult` should remain the top-level return type. + +For `analysis_unit="single_read"`, result metadata must explicitly carry: + +- `analysis_unit` +- `representation` +- `signal_source` +- `test` +- `contrast.mode` + +The result tables should make it obvious that the path is sample-aware: + +- read-level evidence table retained where appropriate for traceability +- sample-level summary table +- contrast summary table + +The summary outputs should not look interchangeable with `ensemble_region` summaries. + +## Continuity Requirements + +This extension must remain additive around the current parsing and extract-backed workflow model. + +Required constraints: + +- do not redefine `parse_bam.extract()` +- do not change existing `ensemble_region` or `cluster_occupancy` scoring semantics +- reuse the current extract-backed read or feature outputs where possible +- treat built-in read-window features as the default path for continuity +- keep the explicit `analysis_unit` and `representation` contract rather than inferring behavior + +## Testing Requirements + +The implementation plan for this spec must include: + +- validation tests for legal and illegal `single_read` combinations +- tests for `read_mod_fraction` evidence building +- tests for `read_window_features` evidence building +- tests for built-in feature-source behavior +- tests for user-supplied feature-table validation +- tests for `pairwise`, `group_vs_group`, and `matched_pairwise` +- tests that prove sample-aware summaries are used rather than pooled-read inference +- docs updates describing what these contrasts mean biologically + +## Recommended Implementation Order + +1. add request validation for `analysis_unit="single_read"` +2. implement `read_mod_fraction` evidence building +3. implement `read_mod_fraction` sample-aware scoring +4. implement `read_window_features` evidence building using the built-in feature set +5. add user-supplied `feature_table` support +6. implement `matched_pairwise` support for both tracks +7. update docs and examples + +## Open Items Explicitly Deferred + +These are intentionally not part of the first implementation plan: + +- time-course `single_read` contrasts +- background-adjusted `single_read` contrasts +- full multivariate inferential modeling for feature vectors +- single-read positional plotting +- additional `single_read` representations beyond `read_mod_fraction` and `read_window_features` From 7cff34bcf7014be84e6c47f29bb10ae03a605c18 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Fri, 3 Apr 2026 15:24:09 -0700 Subject: [PATCH 179/272] docs: add single-read contrast plan --- ...2026-04-03-single-read-region-contrasts.md | 860 ++++++++++++++++++ 1 file changed, 860 insertions(+) create mode 100644 docs/superpowers/plans/2026-04-03-single-read-region-contrasts.md diff --git a/docs/superpowers/plans/2026-04-03-single-read-region-contrasts.md b/docs/superpowers/plans/2026-04-03-single-read-region-contrasts.md new file mode 100644 index 0000000..53fee66 --- /dev/null +++ b/docs/superpowers/plans/2026-04-03-single-read-region-contrasts.md @@ -0,0 +1,860 @@ +# Single-Read Region Contrasts Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Extend `dimelo.region_contrasts` with a first `analysis_unit="single_read"` family covering `read_mod_fraction` and `read_window_features` for defined-region contrasts. + +**Architecture:** Keep all new behavior inside `region_contrasts.score_regions(...)` by adding explicit request validation, read-level evidence builders, and sample-aware scoring paths. Build `read_mod_fraction` first, then add `read_window_features` using the current built-in feature set by default and a validated user-supplied `feature_table` override, while keeping the inferential boundary at the sample level. + +**Tech Stack:** Python 3.11, pandas, scipy, pytest, existing `dimelo.region_contrasts`, `dimelo.region_analysis`, `dimelo.cluster`, `dimelo.models`, and docs modules + +--- + +## File Map + +- Modify: `dimelo/region_contrasts.py` + - extend request validation for `analysis_unit="single_read"` + - add read-level evidence builders + - add sample-aware scoring paths for `read_mod_fraction` + - add feature-table validation and scoring for `read_window_features` +- Modify: `tests/test_region_contrasts.py` + - add validation coverage + - add synthetic evidence/scoring coverage for both single-read representations + - add matched-pairwise coverage +- Modify: `docs/region-contrasts.md` + - document `single_read` semantics, supported modes, and v1 constraints +- Modify: `README.md` + - add one short note describing the new `single_read` contrast family + +## Task 1: Add Failing Validation Tests For `analysis_unit=\"single_read\"` + +**Files:** +- Modify: `tests/test_region_contrasts.py` +- Reference: `dimelo/region_contrasts.py` + +- [ ] **Step 1: Write the failing validation tests** + +Add these tests near the existing validation coverage in `tests/test_region_contrasts.py`: + +```python +def test_validate_region_contrast_request_accepts_single_read_mod_fraction(): + region_contrasts.validate_region_contrast_request( + analysis_unit="single_read", + representation="read_mod_fraction", + signal_source="extract_reads", + test="sample_distribution_shift", + ) + + +def test_validate_region_contrast_request_accepts_single_read_window_features(): + region_contrasts.validate_region_contrast_request( + analysis_unit="single_read", + representation="read_window_features", + signal_source="extract_features", + test="feature_summary_shift", + ) + + +def test_validate_region_contrast_request_rejects_single_read_wrong_signal_source(): + with pytest.raises(ValueError, match="extract_reads"): + region_contrasts.validate_region_contrast_request( + analysis_unit="single_read", + representation="read_mod_fraction", + signal_source="pileup_counts", + test="sample_distribution_shift", + ) + + +def test_validate_region_contrast_request_rejects_single_read_unknown_representation(): + with pytest.raises(ValueError, match="read_mod_fraction"): + region_contrasts.validate_region_contrast_request( + analysis_unit="single_read", + representation="read_shape", + signal_source="extract_reads", + test="sample_distribution_shift", + ) + + +def test_validate_region_contrast_request_rejects_single_read_unknown_test(): + with pytest.raises(ValueError, match="sample_distribution_shift"): + region_contrasts.validate_region_contrast_request( + analysis_unit="single_read", + representation="read_mod_fraction", + signal_source="extract_reads", + test="beta_binomial", + ) +``` + +- [ ] **Step 2: Run the validation tests to verify they fail** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_region_contrasts.py -k "single_read and validate_region_contrast_request" -q +``` + +Expected: FAIL because `single_read` is not yet accepted by `validate_region_contrast_request(...)`. + +- [ ] **Step 3: Commit the failing tests** + +```bash +git add tests/test_region_contrasts.py +git commit -m "test: add single-read contrast validation coverage" +``` + +## Task 2: Implement `single_read` Request Validation + +**Files:** +- Modify: `dimelo/region_contrasts.py` +- Modify: `tests/test_region_contrasts.py` + +- [ ] **Step 1: Extend `validate_region_contrast_request(...)`** + +Add a `single_read` branch in `dimelo/region_contrasts.py`: + +```python + if analysis_unit == "single_read": + if representation == "read_mod_fraction": + if signal_source != "extract_reads": + raise ValueError( + "Current single_read read_mod_fraction support requires " + "signal_source='extract_reads'." + ) + if test not in {"effect_size_only", "sample_distribution_shift"}: + raise ValueError( + "Current single_read read_mod_fraction scoring support requires " + "test in {'effect_size_only', 'sample_distribution_shift'}." + ) + return + + if representation == "read_window_features": + if signal_source != "extract_features": + raise ValueError( + "Current single_read read_window_features support requires " + "signal_source='extract_features'." + ) + if test not in {"effect_size_only", "feature_summary_shift"}: + raise ValueError( + "Current single_read read_window_features support requires " + "test in {'effect_size_only', 'feature_summary_shift'}." + ) + return + + raise ValueError( + "Current single_read support requires representation='read_mod_fraction' " + "or 'read_window_features'." + ) +``` + +Update the final error message so unsupported units mention `single_read`: + +```python + if analysis_unit not in {"ensemble_region", "cluster_occupancy", "single_read"}: + raise ValueError( + "V1 region_contrasts inference requires analysis_unit='ensemble_region', " + "'cluster_occupancy', or 'single_read'." + ) +``` + +- [ ] **Step 2: Run the validation tests to verify they pass** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_region_contrasts.py -k "single_read and validate_region_contrast_request" -q +``` + +Expected: PASS. + +- [ ] **Step 3: Commit the validation implementation** + +```bash +git add dimelo/region_contrasts.py tests/test_region_contrasts.py +git commit -m "feat: add single-read contrast request validation" +``` + +## Task 3: Add Failing Tests For `read_mod_fraction` Evidence Building + +**Files:** +- Modify: `tests/test_region_contrasts.py` +- Reference: `dimelo/region_contrasts.py` + +- [ ] **Step 1: Write the failing `read_mod_fraction` evidence tests** + +Add a small synthetic helper and tests in `tests/test_region_contrasts.py`: + +```python +def _single_read_samples(): + return [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + replicate=1, + metadata={"extract_path": "s1.tsv"}, + ), + SampleSpec( + sample_id="s2", + condition="treated", + extract_h5="s2.h5", + replicate=1, + metadata={"extract_path": "s2.tsv"}, + ), + ] + + +def test_build_single_read_mod_fraction_evidence_table(): + samples = _single_read_samples() + extract_table = pd.DataFrame( + [ + {"region_id": "reg1", "sample_id": "s1", "condition": "NS", "read_id": "r1", "modified_count": 2, "valid_count": 4}, + {"region_id": "reg1", "sample_id": "s1", "condition": "NS", "read_id": "r2", "modified_count": 1, "valid_count": 4}, + {"region_id": "reg1", "sample_id": "s2", "condition": "treated", "read_id": "r3", "modified_count": 4, "valid_count": 4}, + ] + ) + + result = region_contrasts.build_single_read_mod_fraction_evidence_table( + extract_table=extract_table + ) + + assert result.to_dict("records") == [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "read_id": "r1", + "modified_count": 2, + "valid_count": 4, + "read_mod_fraction": pytest.approx(0.5), + }, + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "read_id": "r2", + "modified_count": 1, + "valid_count": 4, + "read_mod_fraction": pytest.approx(0.25), + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "treated", + "read_id": "r3", + "modified_count": 4, + "valid_count": 4, + "read_mod_fraction": pytest.approx(1.0), + }, + ] + + +def test_build_single_read_mod_fraction_evidence_table_rejects_missing_columns(): + with pytest.raises(ValueError, match="modified_count"): + region_contrasts.build_single_read_mod_fraction_evidence_table( + extract_table=pd.DataFrame([{"region_id": "reg1", "sample_id": "s1"}]) + ) +``` + +- [ ] **Step 2: Run the evidence tests to verify they fail** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_region_contrasts.py -k "single_read_mod_fraction_evidence" -q +``` + +Expected: FAIL because the evidence builder does not yet exist. + +- [ ] **Step 3: Commit the failing tests** + +```bash +git add tests/test_region_contrasts.py +git commit -m "test: add single-read mod-fraction evidence coverage" +``` + +## Task 4: Implement `read_mod_fraction` Evidence And Sample-Aware Scoring + +**Files:** +- Modify: `dimelo/region_contrasts.py` +- Modify: `tests/test_region_contrasts.py` + +- [ ] **Step 1: Add the evidence builder** + +Add this helper in `dimelo/region_contrasts.py` near the other evidence builders: + +```python +def build_single_read_mod_fraction_evidence_table( + *, + extract_table: pd.DataFrame, +) -> pd.DataFrame: + required_columns = { + "region_id", + "sample_id", + "condition", + "read_id", + "modified_count", + "valid_count", + } + missing_columns = required_columns - set(extract_table.columns) + if missing_columns: + missing_display = ", ".join(sorted(missing_columns)) + raise ValueError( + "build_single_read_mod_fraction_evidence_table requires columns: " + f"{missing_display}." + ) + + evidence = extract_table.loc[ + :, + [ + "region_id", + "sample_id", + "condition", + "read_id", + "modified_count", + "valid_count", + ], + ].copy() + evidence["read_mod_fraction"] = evidence["modified_count"].div( + evidence["valid_count"].where(evidence["valid_count"] != 0), + fill_value=0, + ).fillna(0.0) + return evidence +``` + +- [ ] **Step 2: Add failing scoring tests for `read_mod_fraction`** + +Add these tests in `tests/test_region_contrasts.py`: + +```python +def test_score_regions_single_read_mod_fraction_effect_size_only(): + evidence = pd.DataFrame( + [ + {"region_id": "reg1", "sample_id": "s1", "condition": "NS", "read_id": "r1", "modified_count": 1, "valid_count": 4, "read_mod_fraction": 0.25}, + {"region_id": "reg1", "sample_id": "s1", "condition": "NS", "read_id": "r2", "modified_count": 2, "valid_count": 4, "read_mod_fraction": 0.50}, + {"region_id": "reg1", "sample_id": "s2", "condition": "treated", "read_id": "r3", "modified_count": 4, "valid_count": 4, "read_mod_fraction": 1.00}, + {"region_id": "reg1", "sample_id": "s3", "condition": "treated", "read_id": "r4", "modified_count": 3, "valid_count": 4, "read_mod_fraction": 0.75}, + ] + ) + + result = region_contrasts.score_regions( + samples=[], + regions=None, + contrast=ContrastSpec(mode="group_vs_group", numerator=["treated"], denominator=["NS"]), + analysis_unit="single_read", + representation="read_mod_fraction", + signal_source="extract_reads", + test="effect_size_only", + read_table=evidence, + ) + + row = result.summary.iloc[0] + assert row["region_id"] == "reg1" + assert row["sample_summary_numerator_mean"] == pytest.approx(0.875) + assert row["sample_summary_denominator_mean"] == pytest.approx(0.375) + assert row["delta_summary_mean"] == pytest.approx(0.5) +``` + +- [ ] **Step 3: Implement the sample-aware scoring path** + +Add internal helpers in `dimelo/region_contrasts.py`: + +```python +def _summarize_single_read_mod_fraction_by_sample(evidence: pd.DataFrame) -> pd.DataFrame: + return ( + evidence.groupby(["region_id", "sample_id", "condition"], as_index=False, sort=False) + .agg( + read_n=("read_id", "nunique"), + sample_summary_mean=("read_mod_fraction", "mean"), + sample_summary_median=("read_mod_fraction", "median"), + sample_summary_var=("read_mod_fraction", "var"), + ) + .fillna({"sample_summary_var": 0.0}) + ) + + +def _score_single_read_mod_fraction( + *, + evidence: pd.DataFrame, + contrast: ContrastSpec, + test: str, +) -> tuple[pd.DataFrame, pd.DataFrame]: + sample_summary = _summarize_single_read_mod_fraction_by_sample(evidence) + pooled = _pool_region_groups( + sample_summary.rename(columns={"sample_summary_mean": "mod_fraction"})[ + ["region_id", "sample_id", "condition", "mod_fraction"] + ], + contrast=contrast, + ) + pooled = pooled.rename( + columns={ + "fraction": "sample_summary_mean", + "reference_fraction": "sample_summary_reference_mean", + "delta_fraction": "delta_summary_mean", + } + ) + summary = pooled.sort_values("region_id", kind="stable").reset_index(drop=True) + return evidence, summary +``` + +Wire it into `score_regions(...)` behind: + +```python +if analysis_unit == "single_read" and representation == "read_mod_fraction": + if read_table is None: + raise ValueError("single_read read_mod_fraction scoring currently requires read_table.") + evidence = build_single_read_mod_fraction_evidence_table(extract_table=read_table) + regions_table, summary = _score_single_read_mod_fraction( + evidence=evidence, + contrast=contrast, + test=test, + ) +``` + +Keep `test="sample_distribution_shift"` mapped to the same first sample-aware summary path in v1. + +- [ ] **Step 4: Run the `read_mod_fraction` tests to verify they pass** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_region_contrasts.py -k "single_read_mod_fraction" -q +``` + +Expected: PASS. + +- [ ] **Step 5: Commit the implementation** + +```bash +git add dimelo/region_contrasts.py tests/test_region_contrasts.py +git commit -m "feat: add single-read mod-fraction contrasts" +``` + +## Task 5: Add Failing Tests For `read_window_features` + +**Files:** +- Modify: `tests/test_region_contrasts.py` +- Reference: `dimelo/region_contrasts.py` + +- [ ] **Step 1: Write the failing feature-evidence and scoring tests** + +Add these tests: + +```python +def test_build_single_read_feature_evidence_table_accepts_user_features(): + feature_table = pd.DataFrame( + [ + {"region_id": "reg1", "sample_id": "s1", "condition": "NS", "read_id": "r1", "f0": 0.1, "f1": 0.2}, + {"region_id": "reg1", "sample_id": "s2", "condition": "treated", "read_id": "r2", "f0": 0.8, "f1": 0.9}, + ] + ) + + result = region_contrasts.build_single_read_feature_evidence_table(feature_table=feature_table) + + assert result.to_dict("records") == feature_table.to_dict("records") + + +def test_build_single_read_feature_evidence_table_rejects_missing_read_id(): + with pytest.raises(ValueError, match="read_id"): + region_contrasts.build_single_read_feature_evidence_table( + feature_table=pd.DataFrame([{"region_id": "reg1", "sample_id": "s1", "condition": "NS", "f0": 0.1}]) + ) + + +def test_score_regions_single_read_window_features_effect_size_only(): + feature_table = pd.DataFrame( + [ + {"region_id": "reg1", "sample_id": "s1", "condition": "NS", "read_id": "r1", "f0": 0.1, "f1": 0.2}, + {"region_id": "reg1", "sample_id": "s1", "condition": "NS", "read_id": "r2", "f0": 0.2, "f1": 0.3}, + {"region_id": "reg1", "sample_id": "s2", "condition": "treated", "read_id": "r3", "f0": 0.8, "f1": 0.9}, + {"region_id": "reg1", "sample_id": "s3", "condition": "treated", "read_id": "r4", "f0": 0.7, "f1": 0.8}, + ] + ) + + result = region_contrasts.score_regions( + samples=[], + regions=None, + contrast=ContrastSpec(mode="group_vs_group", numerator=["treated"], denominator=["NS"]), + analysis_unit="single_read", + representation="read_window_features", + signal_source="extract_features", + test="effect_size_only", + feature_table=feature_table, + ) + + row = result.summary.iloc[0] + assert row["region_id"] == "reg1" + assert row["f0_delta_mean"] == pytest.approx(0.6) + assert row["f1_delta_mean"] == pytest.approx(0.6) +``` + +- [ ] **Step 2: Run the feature tests to verify they fail** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_region_contrasts.py -k "single_read_feature or single_read_window_features" -q +``` + +Expected: FAIL because the feature evidence builder and scoring path do not yet exist. + +- [ ] **Step 3: Commit the failing tests** + +```bash +git add tests/test_region_contrasts.py +git commit -m "test: add single-read feature contrast coverage" +``` + +## Task 6: Implement `read_window_features` With Built-In Default And User Override + +**Files:** +- Modify: `dimelo/region_contrasts.py` +- Modify: `tests/test_region_contrasts.py` + +- [ ] **Step 1: Add the user-feature evidence builder** + +Add this helper: + +```python +def build_single_read_feature_evidence_table( + *, + feature_table: pd.DataFrame, +) -> pd.DataFrame: + required_columns = {"region_id", "sample_id", "condition", "read_id"} + missing_columns = required_columns - set(feature_table.columns) + if missing_columns: + missing_display = ", ".join(sorted(missing_columns)) + raise ValueError( + "build_single_read_feature_evidence_table requires columns: " + f"{missing_display}." + ) + + feature_columns = [ + column for column in feature_table.columns if column not in required_columns + ] + if not feature_columns: + raise ValueError( + "build_single_read_feature_evidence_table requires at least one feature column." + ) + return feature_table.loc[:, ["region_id", "sample_id", "condition", "read_id", *feature_columns]].copy() +``` + +- [ ] **Step 2: Add a built-in feature-source shim** + +Add a narrow internal function that is easy to replace later with the real built-in feature extraction path: + +```python +def _load_builtin_single_read_feature_table(*, samples, regions, motifs): + raise NotImplementedError( + "Built-in single_read feature loading is not implemented yet." + ) +``` + +Then wire `score_regions(...)` so: + +- if `representation="read_window_features"` and `feature_table is not None`, use the user table +- if `feature_table is None`, call `_load_builtin_single_read_feature_table(...)` + +This keeps the built-in default contract explicit in the code and easy to patch in tests. + +- [ ] **Step 3: Implement feature-summary scoring** + +Add helpers: + +```python +def _summarize_single_read_features_by_sample(evidence: pd.DataFrame) -> pd.DataFrame: + group_columns = ["region_id", "sample_id", "condition"] + feature_columns = [ + column for column in evidence.columns if column not in {"region_id", "sample_id", "condition", "read_id"} + ] + return ( + evidence.groupby(group_columns, as_index=False, sort=False)[feature_columns] + .mean() + ) + + +def _score_single_read_features( + *, + evidence: pd.DataFrame, + contrast: ContrastSpec, +) -> tuple[pd.DataFrame, pd.DataFrame]: + sample_summary = _summarize_single_read_features_by_sample(evidence) + feature_columns = [ + column for column in sample_summary.columns if column not in {"region_id", "sample_id", "condition"} + ] + summary_rows = [] + for region_id, region_table in sample_summary.groupby("region_id", sort=False): + numerator_table = region_table[region_table["condition"].isin(contrast.numerator)] + denominator_table = region_table[region_table["condition"].isin(contrast.denominator)] + row = {"region_id": region_id} + for feature_name in feature_columns: + numerator_mean = numerator_table[feature_name].mean() + denominator_mean = denominator_table[feature_name].mean() + row[f"{feature_name}_numerator_mean"] = numerator_mean + row[f"{feature_name}_denominator_mean"] = denominator_mean + row[f"{feature_name}_delta_mean"] = numerator_mean - denominator_mean + summary_rows.append(row) + return evidence, pd.DataFrame(summary_rows) +``` + +- [ ] **Step 4: Add a failing built-in-default test, then implement it with a patched loader** + +Add this test: + +```python +def test_score_regions_single_read_window_features_uses_builtin_loader(monkeypatch): + feature_table = pd.DataFrame( + [ + {"region_id": "reg1", "sample_id": "s1", "condition": "NS", "read_id": "r1", "f0": 0.1}, + {"region_id": "reg1", "sample_id": "s2", "condition": "treated", "read_id": "r2", "f0": 0.9}, + ] + ) + + monkeypatch.setattr( + region_contrasts, + "_load_builtin_single_read_feature_table", + lambda **kwargs: feature_table, + ) + + result = region_contrasts.score_regions( + samples=[], + regions="regions.bed", + contrast=ContrastSpec(mode="pairwise", numerator=["treated"], denominator=["NS"]), + analysis_unit="single_read", + representation="read_window_features", + signal_source="extract_features", + test="feature_summary_shift", + motifs=["A,0"], + ) + + assert result.summary.iloc[0]["f0_delta_mean"] == pytest.approx(0.8) +``` + +- [ ] **Step 5: Run the feature tests to verify they pass** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_region_contrasts.py -k "single_read_feature or single_read_window_features" -q +``` + +Expected: PASS. + +- [ ] **Step 6: Commit the feature implementation** + +```bash +git add dimelo/region_contrasts.py tests/test_region_contrasts.py +git commit -m "feat: add single-read feature contrasts" +``` + +## Task 7: Add `matched_pairwise` Coverage For Both Tracks + +**Files:** +- Modify: `tests/test_region_contrasts.py` +- Modify: `dimelo/region_contrasts.py` + +- [ ] **Step 1: Write the failing matched-pairwise tests** + +Add these tests: + +```python +def test_score_regions_single_read_mod_fraction_supports_matched_pairwise(): + evidence = pd.DataFrame( + [ + {"region_id": "reg1", "sample_id": "s1_before", "condition": "before", "read_id": "r1", "modified_count": 1, "valid_count": 4, "read_mod_fraction": 0.25, "pair_id": "p1"}, + {"region_id": "reg1", "sample_id": "s1_after", "condition": "after", "read_id": "r2", "modified_count": 4, "valid_count": 4, "read_mod_fraction": 1.0, "pair_id": "p1"}, + {"region_id": "reg1", "sample_id": "s2_before", "condition": "before", "read_id": "r3", "modified_count": 2, "valid_count": 4, "read_mod_fraction": 0.5, "pair_id": "p2"}, + {"region_id": "reg1", "sample_id": "s2_after", "condition": "after", "read_id": "r4", "modified_count": 3, "valid_count": 4, "read_mod_fraction": 0.75, "pair_id": "p2"}, + ] + ) + + result = region_contrasts.score_regions( + samples=[], + regions=None, + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["after"], + denominator=["before"], + pairing_key="pair_id", + ), + analysis_unit="single_read", + representation="read_mod_fraction", + signal_source="extract_reads", + test="sample_distribution_shift", + read_table=evidence, + ) + + assert result.summary.iloc[0]["delta_summary_mean"] > 0 + + +def test_score_regions_single_read_window_features_supports_matched_pairwise(): + feature_table = pd.DataFrame( + [ + {"region_id": "reg1", "sample_id": "s1_before", "condition": "before", "read_id": "r1", "pair_id": "p1", "f0": 0.1}, + {"region_id": "reg1", "sample_id": "s1_after", "condition": "after", "read_id": "r2", "pair_id": "p1", "f0": 0.9}, + {"region_id": "reg1", "sample_id": "s2_before", "condition": "before", "read_id": "r3", "pair_id": "p2", "f0": 0.2}, + {"region_id": "reg1", "sample_id": "s2_after", "condition": "after", "read_id": "r4", "pair_id": "p2", "f0": 0.8}, + ] + ) + + result = region_contrasts.score_regions( + samples=[], + regions=None, + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["after"], + denominator=["before"], + pairing_key="pair_id", + ), + analysis_unit="single_read", + representation="read_window_features", + signal_source="extract_features", + test="feature_summary_shift", + feature_table=feature_table, + ) + + assert result.summary.iloc[0]["f0_delta_mean"] > 0 +``` + +- [ ] **Step 2: Implement matched-pairwise support conservatively** + +Use sample-summary level tables only. Do not add pooled-read logic. The minimal first pass should: + +- preserve `pairing_key` columns from the incoming read or feature table +- carry them through sample summaries +- compute deltas using only complete pairs + +Add a narrow helper if needed: + +```python +def _require_pairing_column(frame: pd.DataFrame, pairing_key: str) -> None: + if pairing_key not in frame.columns: + raise ValueError( + f"matched_pairwise single_read scoring requires column {pairing_key!r}." + ) +``` + +- [ ] **Step 3: Run the matched-pairwise tests to verify they pass** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_region_contrasts.py -k "matched_pairwise and single_read" -q +``` + +Expected: PASS. + +- [ ] **Step 4: Commit the matched-pairwise support** + +```bash +git add dimelo/region_contrasts.py tests/test_region_contrasts.py +git commit -m "feat: add matched single-read contrasts" +``` + +## Task 8: Document The New `single_read` Contrast Family + +**Files:** +- Modify: `docs/region-contrasts.md` +- Modify: `README.md` + +- [ ] **Step 1: Update the region contrasts guide** + +Add a short section to `docs/region-contrasts.md`: + +```md +## Single-Read Contrasts + +`region_contrasts` now supports `analysis_unit="single_read"` for defined-region +comparison on extract-backed read data. + +First-version representations: + +- `representation="read_mod_fraction"` with `signal_source="extract_reads"` +- `representation="read_window_features"` with `signal_source="extract_features"` + +Supported contrast modes in v1: + +- `pairwise` +- `group_vs_group` +- `matched_pairwise` + +Important: reads remain observational units, but samples remain the inferential units. +The v1 single-read paths summarize reads within each `region x sample` before comparing +conditions. +``` + +- [ ] **Step 2: Add a short README note** + +Add one short paragraph near the `region_contrasts` overview in `README.md`: + +```md +`region_contrasts` also now supports `analysis_unit="single_read"` for extract-backed +defined-region comparison. Use `representation="read_mod_fraction"` for per-read motif +fractions or `representation="read_window_features"` for feature-vector summaries, with +sample-aware summaries rather than pooled-read inference. +``` + +- [ ] **Step 3: Commit the docs** + +```bash +git add docs/region-contrasts.md README.md +git commit -m "docs: add single-read contrast guide" +``` + +## Task 9: Run Final Verification + +**Files:** +- Reference: `dimelo/region_contrasts.py` +- Reference: `tests/test_region_contrasts.py` +- Reference: `docs/region-contrasts.md` +- Reference: `README.md` + +- [ ] **Step 1: Run the full region contrast test file** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_region_contrasts.py -q +``` + +Expected: PASS. + +- [ ] **Step 2: Run a targeted workflow/plotting regression subset** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl XDG_CACHE_HOME=/tmp/xdg-cache PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py tests/test_workflows.py -q +``` + +Expected: PASS with no new failures. + +- [ ] **Step 3: Run a quick git status check** + +Run: + +```bash +git status --short +``` + +Expected: clean working tree. + +- [ ] **Step 4: Self-review against the spec** + +Check the completed work against `docs/superpowers/specs/2026-04-03-single-read-region-contrasts-design.md`: + +- `analysis_unit="single_read"` added inside `region_contrasts` +- `read_mod_fraction` implemented +- `read_window_features` implemented +- built-in feature default and user override supported +- sample-aware summaries preserved +- v1 support remains bounded to `pairwise`, `group_vs_group`, and `matched_pairwise` +- no time-course or background-adjusted work accidentally added + +- [ ] **Step 5: Commit any final touch-ups if needed** + +```bash +git add dimelo/region_contrasts.py tests/test_region_contrasts.py docs/region-contrasts.md README.md +git commit -m "fix: tighten single-read contrast support" +``` + +Only make this commit if verification or self-review uncovered a small follow-up patch. From 32efc9ee277e4c31ec9c2cd96ad67e2bb921e78f Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sat, 4 Apr 2026 13:06:01 -0700 Subject: [PATCH 180/272] test: add single-read contrast validation coverage --- tests/test_region_contrasts.py | 48 ++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index b215154..4b0fc99 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -44,6 +44,54 @@ def test_validate_region_contrast_request_rejects_beta_binomial_for_cluster_occu ) +def test_validate_region_contrast_request_accepts_single_read_mod_fraction(): + region_contrasts.validate_region_contrast_request( + analysis_unit="single_read", + representation="read_mod_fraction", + signal_source="extract_reads", + test="sample_distribution_shift", + ) + + +def test_validate_region_contrast_request_accepts_single_read_window_features(): + region_contrasts.validate_region_contrast_request( + analysis_unit="single_read", + representation="read_window_features", + signal_source="extract_features", + test="feature_summary_shift", + ) + + +def test_validate_region_contrast_request_rejects_single_read_wrong_signal_source(): + with pytest.raises(ValueError, match="extract_reads"): + region_contrasts.validate_region_contrast_request( + analysis_unit="single_read", + representation="read_mod_fraction", + signal_source="pileup_counts", + test="sample_distribution_shift", + ) + + +def test_validate_region_contrast_request_rejects_single_read_unknown_representation(): + with pytest.raises(ValueError, match="read_mod_fraction"): + region_contrasts.validate_region_contrast_request( + analysis_unit="single_read", + representation="read_shape", + signal_source="extract_reads", + test="sample_distribution_shift", + ) + + +def test_validate_region_contrast_request_rejects_single_read_unknown_test(): + with pytest.raises(ValueError, match="sample_distribution_shift"): + region_contrasts.validate_region_contrast_request( + analysis_unit="single_read", + representation="read_mod_fraction", + signal_source="extract_reads", + test="beta_binomial", + ) + + def test_validate_rejects_unsupported_single_read_beta_binomial(): with pytest.raises(ValueError, match="analysis_unit='ensemble_region'"): region_contrasts.validate_region_contrast_request( From d02d13206bfaba981a5b5251601dbdb8f392565a Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sat, 4 Apr 2026 13:08:13 -0700 Subject: [PATCH 181/272] feat: add single-read contrast request validation --- dimelo/region_contrasts.py | 36 ++++++++++++++++++++++++++++++++++-- 1 file changed, 34 insertions(+), 2 deletions(-) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index 77ab816..44aa7fa 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -67,10 +67,42 @@ def validate_region_contrast_request( ) return - if analysis_unit not in {"ensemble_region", "cluster_occupancy"}: + if analysis_unit == "single_read": + if representation == "read_mod_fraction": + if signal_source != "extract_reads": + raise ValueError( + "Current single_read read_mod_fraction support requires " + "signal_source='extract_reads'." + ) + if test not in {"effect_size_only", "sample_distribution_shift"}: + raise ValueError( + "Current single_read read_mod_fraction scoring support requires " + "test in {'effect_size_only', 'sample_distribution_shift'}." + ) + return + + if representation == "read_window_features": + if signal_source != "extract_features": + raise ValueError( + "Current single_read read_window_features support requires " + "signal_source='extract_features'." + ) + if test not in {"effect_size_only", "feature_summary_shift"}: + raise ValueError( + "Current single_read read_window_features support requires " + "test in {'effect_size_only', 'feature_summary_shift'}." + ) + return + + raise ValueError( + "Current single_read support requires representation='read_mod_fraction' " + "or 'read_window_features'." + ) + + if analysis_unit not in {"ensemble_region", "cluster_occupancy", "single_read"}: raise ValueError( "V1 region_contrasts inference requires analysis_unit='ensemble_region' " - "or analysis_unit='cluster_occupancy'." + "'cluster_occupancy', or 'single_read'." ) From 09c9762304ce49b61fa219842ee51610fcd4a073 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sat, 4 Apr 2026 13:10:57 -0700 Subject: [PATCH 182/272] feat: clean up single-read validation error text --- dimelo/region_contrasts.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index 44aa7fa..7209010 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -102,7 +102,8 @@ def validate_region_contrast_request( if analysis_unit not in {"ensemble_region", "cluster_occupancy", "single_read"}: raise ValueError( "V1 region_contrasts inference requires analysis_unit='ensemble_region' " - "'cluster_occupancy', or 'single_read'." + "or analysis_unit='cluster_occupancy' " + "or analysis_unit='single_read'." ) From 4e34001db3f380f3725b043a54d3376fc3d27290 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sat, 4 Apr 2026 13:12:34 -0700 Subject: [PATCH 183/272] test: add single-read mod-fraction evidence coverage --- tests/test_region_contrasts.py | 72 ++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index 4b0fc99..565c209 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -394,6 +394,78 @@ def test_build_cluster_occupancy_evidence_table_rejects_invalid_counts(count): ) +def test_build_single_read_mod_fraction_evidence_table(): + extract_table = pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "read_id": "r1", + "modified_count": 2, + "valid_count": 4, + }, + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "read_id": "r2", + "modified_count": 1, + "valid_count": 4, + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "treated", + "read_id": "r3", + "modified_count": 4, + "valid_count": 4, + }, + ] + ) + + result = region_contrasts.build_single_read_mod_fraction_evidence_table( + extract_table=extract_table + ) + + assert result.to_dict("records") == [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "read_id": "r1", + "modified_count": 2, + "valid_count": 4, + "read_mod_fraction": pytest.approx(0.5), + }, + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "read_id": "r2", + "modified_count": 1, + "valid_count": 4, + "read_mod_fraction": pytest.approx(0.25), + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "treated", + "read_id": "r3", + "modified_count": 4, + "valid_count": 4, + "read_mod_fraction": pytest.approx(1.0), + }, + ] + + +def test_build_single_read_mod_fraction_evidence_table_rejects_missing_columns(): + with pytest.raises(ValueError, match="modified_count"): + region_contrasts.build_single_read_mod_fraction_evidence_table( + extract_table=pd.DataFrame([{"region_id": "reg1", "sample_id": "s1"}]) + ) + + def test_build_region_evidence_table_from_pileup_counts(monkeypatch): samples = [ SampleSpec( From d0bdaf980f89ad9a7a84658507e2e2369d048a7c Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sat, 4 Apr 2026 13:18:58 -0700 Subject: [PATCH 184/272] feat: add single-read mod-fraction contrasts --- dimelo/region_contrasts.py | 209 +++++++++++++++++++++++++++++++++ tests/test_region_contrasts.py | 61 ++++++++++ 2 files changed, 270 insertions(+) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index 7209010..4660153 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -178,6 +178,44 @@ def build_region_evidence_table( return pd.DataFrame(rows) +def build_single_read_mod_fraction_evidence_table( + *, + extract_table: pd.DataFrame, +) -> pd.DataFrame: + required_columns = { + "region_id", + "sample_id", + "condition", + "read_id", + "modified_count", + "valid_count", + } + missing_columns = required_columns - set(extract_table.columns) + if missing_columns: + missing_display = ", ".join(sorted(missing_columns)) + raise ValueError( + "build_single_read_mod_fraction_evidence_table requires columns: " + f"{missing_display}." + ) + + evidence = extract_table.loc[ + :, + [ + "region_id", + "sample_id", + "condition", + "read_id", + "modified_count", + "valid_count", + ], + ].copy() + evidence["read_mod_fraction"] = evidence["modified_count"].div( + evidence["valid_count"].where(evidence["valid_count"] != 0), + fill_value=0, + ).fillna(0.0) + return evidence + + def build_cluster_occupancy_evidence_table( *, region_summaries: pd.DataFrame, @@ -524,6 +562,138 @@ def _pool_cluster_occupancy_groups( return pd.concat(pooled_frames, ignore_index=True) +def _summarize_single_read_mod_fraction_by_sample(evidence: pd.DataFrame) -> pd.DataFrame: + return ( + evidence.groupby(["region_id", "sample_id", "condition"], as_index=False, sort=False) + .agg( + read_n=("read_id", "nunique"), + sample_summary_mean=("read_mod_fraction", "mean"), + sample_summary_median=("read_mod_fraction", "median"), + sample_summary_var=("read_mod_fraction", "var"), + ) + .fillna({"sample_summary_var": 0.0}) + ) + + +def _score_single_read_mod_fraction( + *, + evidence: pd.DataFrame, + contrast: ContrastSpec, + test: str, +) -> tuple[pd.DataFrame, pd.DataFrame]: + if contrast.mode not in {"pairwise", "group_vs_group"}: + raise NotImplementedError( + "Single-read mod-fraction scoring is not implemented for contrast mode " + f"'{contrast.mode}'." + ) + + sample_summary = _summarize_single_read_mod_fraction_by_sample(evidence) + side_specs = { + "numerator": contrast.numerator or [], + "denominator": contrast.denominator or [], + } + _require_requested_conditions_present( + sample_summary, + side_specs=side_specs, + ) + + pooled_frames = [] + for side, conditions in side_specs.items(): + side_evidence = sample_summary.loc[sample_summary["condition"].isin(conditions)].copy() + pooled = ( + side_evidence.groupby("region_id", dropna=False, sort=False) + .agg( + sample_summary_mean=("sample_summary_mean", "mean"), + read_n=("read_n", "sum"), + replicate_n=("sample_id", "nunique"), + sample_values=("sample_summary_mean", lambda values: tuple(float(v) for v in values)), + ) + .reset_index() + .assign(contrast_side=side) + ) + pooled_frames.append(pooled) + + pooled = pd.concat(pooled_frames, ignore_index=True) + numerator = ( + pooled.loc[pooled["contrast_side"] == "numerator"] + .drop(columns=["contrast_side", "sample_values"]) + .rename( + columns={ + "sample_summary_mean": "sample_summary_numerator_mean", + "read_n": "numerator_read_n", + "replicate_n": "numerator_replicate_n", + } + ) + ) + denominator = ( + pooled.loc[pooled["contrast_side"] == "denominator"] + .drop(columns=["contrast_side", "sample_values"]) + .rename( + columns={ + "sample_summary_mean": "sample_summary_denominator_mean", + "read_n": "denominator_read_n", + "replicate_n": "denominator_replicate_n", + } + ) + ) + + regions_table = numerator.merge( + denominator, + on="region_id", + how="outer", + sort=False, + ) + regions_table["sample_summary_numerator_mean"] = regions_table[ + "sample_summary_numerator_mean" + ].fillna(0.0) + regions_table["sample_summary_denominator_mean"] = regions_table[ + "sample_summary_denominator_mean" + ].fillna(0.0) + regions_table["numerator_read_n"] = regions_table["numerator_read_n"].fillna(0).astype(int) + regions_table["denominator_read_n"] = ( + regions_table["denominator_read_n"].fillna(0).astype(int) + ) + regions_table["numerator_replicate_n"] = ( + regions_table["numerator_replicate_n"].fillna(0).astype(int) + ) + regions_table["denominator_replicate_n"] = ( + regions_table["denominator_replicate_n"].fillna(0).astype(int) + ) + regions_table["delta_summary_mean"] = ( + regions_table["sample_summary_numerator_mean"] + - regions_table["sample_summary_denominator_mean"] + ) + pseudocount = 1e-6 + regions_table["log2_fc"] = ( + (regions_table["sample_summary_numerator_mean"] + pseudocount) + / (regions_table["sample_summary_denominator_mean"] + pseudocount) + ).map(math.log2) + regions_table["effect_size"] = regions_table["delta_summary_mean"].abs() + regions_table = regions_table.sort_values( + by=["effect_size", "delta_summary_mean", "region_id"], + ascending=[False, False, True], + kind="mergesort", + ).reset_index(drop=True) + regions_table["rank"] = range(1, len(regions_table) + 1) + + summary = regions_table.loc[ + :, + [ + "region_id", + "sample_summary_numerator_mean", + "sample_summary_denominator_mean", + "delta_summary_mean", + "log2_fc", + "rank", + "numerator_read_n", + "denominator_read_n", + "numerator_replicate_n", + "denominator_replicate_n", + ], + ].copy() + return regions_table, summary + + def _add_fraction_test_scores( regions_table: pd.DataFrame, *, @@ -852,6 +1022,7 @@ def score_regions( test: str = "effect_size_only", multiple_testing: str = "fdr_bh", occupancy_table: pd.DataFrame | None = None, + read_table: pd.DataFrame | None = None, ) -> RegionContrastResult: validate_region_contrast_request( analysis_unit=analysis_unit, @@ -861,6 +1032,44 @@ def score_regions( ) contrast_metadata = contrast.metadata or {} + if analysis_unit == "single_read": + if representation != "read_mod_fraction": + raise NotImplementedError( + f"Single-read representation '{representation}' is not implemented yet." + ) + if read_table is None: + raise ValueError( + "single_read read_mod_fraction scoring currently requires read_table." + ) + evidence = build_single_read_mod_fraction_evidence_table(extract_table=read_table) + regions_table, summary = _score_single_read_mod_fraction( + evidence=evidence, + contrast=contrast, + test=test, + ) + metadata = { + "contrast_mode": contrast.mode, + "analysis_unit": analysis_unit, + "representation": representation, + "signal_source": signal_source, + "test": test, + "multiple_testing": multiple_testing, + "normalization_mode": contrast_metadata.get("normalization_mode", "none"), + "biological_interpretation": contrast_metadata.get( + "biological_interpretation", + "region-level difference in sample-level read modification fraction", + ), + "renderer": contrast_metadata.get("renderer", "region_effect_sizes"), + } + return RegionContrastResult( + regions=regions_table, + summary=summary, + contrast=contrast, + plot_data={"region_effect_sizes": summary.copy()}, + metadata=metadata, + figures={}, + ) + if analysis_unit == "cluster_occupancy": if occupancy_table is None: raise ValueError( diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index 565c209..d273b77 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -466,6 +466,67 @@ def test_build_single_read_mod_fraction_evidence_table_rejects_missing_columns() ) +def test_score_regions_single_read_mod_fraction_effect_size_only(): + evidence = pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "read_id": "r1", + "modified_count": 1, + "valid_count": 4, + "read_mod_fraction": 0.25, + }, + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "read_id": "r2", + "modified_count": 2, + "valid_count": 4, + "read_mod_fraction": 0.50, + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "treated", + "read_id": "r3", + "modified_count": 4, + "valid_count": 4, + "read_mod_fraction": 1.00, + }, + { + "region_id": "reg1", + "sample_id": "s3", + "condition": "treated", + "read_id": "r4", + "modified_count": 3, + "valid_count": 4, + "read_mod_fraction": 0.75, + }, + ] + ) + + result = region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec(mode="group_vs_group", numerator=["treated"], denominator=["NS"]), + analysis_unit="single_read", + representation="read_mod_fraction", + signal_source="extract_reads", + test="effect_size_only", + read_table=evidence, + ) + + row = result.summary.iloc[0] + assert row["region_id"] == "reg1" + assert row["sample_summary_numerator_mean"] == pytest.approx(0.875) + assert row["sample_summary_denominator_mean"] == pytest.approx(0.375) + assert row["delta_summary_mean"] == pytest.approx(0.5) + + def test_build_region_evidence_table_from_pileup_counts(monkeypatch): samples = [ SampleSpec( From 74d66c0c89b9720c01a7345b447907d59ddb3824 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sat, 4 Apr 2026 13:21:28 -0700 Subject: [PATCH 185/272] feat: tighten single-read mod-fraction validation --- dimelo/region_contrasts.py | 23 ++++++++++++++++++----- tests/test_region_contrasts.py | 33 +++++++++++++++++++++++++++++++++ 2 files changed, 51 insertions(+), 5 deletions(-) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index 4660153..6fa5238 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -209,6 +209,24 @@ def build_single_read_mod_fraction_evidence_table( "valid_count", ], ].copy() + evidence["modified_count"] = pd.to_numeric(evidence["modified_count"], errors="coerce") + evidence["valid_count"] = pd.to_numeric(evidence["valid_count"], errors="coerce") + invalid_counts = ( + evidence["modified_count"].isna() + | evidence["valid_count"].isna() + | ~evidence["modified_count"].map(math.isfinite) + | ~evidence["valid_count"].map(math.isfinite) + | (evidence["modified_count"] < 0) + | (evidence["valid_count"] < 0) + | (evidence["modified_count"] > evidence["valid_count"]) + ) + if invalid_counts.any(): + raise ValueError( + "build_single_read_mod_fraction_evidence_table modified_count and " + "valid_count must be finite, >= 0, and modified_count <= valid_count." + ) + evidence["modified_count"] = evidence["modified_count"].astype(int) + evidence["valid_count"] = evidence["valid_count"].astype(int) evidence["read_mod_fraction"] = evidence["modified_count"].div( evidence["valid_count"].where(evidence["valid_count"] != 0), fill_value=0, @@ -568,10 +586,7 @@ def _summarize_single_read_mod_fraction_by_sample(evidence: pd.DataFrame) -> pd. .agg( read_n=("read_id", "nunique"), sample_summary_mean=("read_mod_fraction", "mean"), - sample_summary_median=("read_mod_fraction", "median"), - sample_summary_var=("read_mod_fraction", "var"), ) - .fillna({"sample_summary_var": 0.0}) ) @@ -579,7 +594,6 @@ def _score_single_read_mod_fraction( *, evidence: pd.DataFrame, contrast: ContrastSpec, - test: str, ) -> tuple[pd.DataFrame, pd.DataFrame]: if contrast.mode not in {"pairwise", "group_vs_group"}: raise NotImplementedError( @@ -1045,7 +1059,6 @@ def score_regions( regions_table, summary = _score_single_read_mod_fraction( evidence=evidence, contrast=contrast, - test=test, ) metadata = { "contrast_mode": contrast.mode, diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index d273b77..8406169 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -466,6 +466,39 @@ def test_build_single_read_mod_fraction_evidence_table_rejects_missing_columns() ) +@pytest.mark.parametrize( + ("modified_count", "valid_count"), + [ + (-1, 4), + (1, -1), + (float("nan"), 4), + (1, float("nan")), + (float("inf"), 4), + (1, float("inf")), + (5, 4), + ], +) +def test_build_single_read_mod_fraction_evidence_table_rejects_invalid_counts( + modified_count, + valid_count, +): + with pytest.raises(ValueError, match="modified_count and valid_count"): + region_contrasts.build_single_read_mod_fraction_evidence_table( + extract_table=pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "read_id": "r1", + "modified_count": modified_count, + "valid_count": valid_count, + } + ] + ) + ) + + def test_score_regions_single_read_mod_fraction_effect_size_only(): evidence = pd.DataFrame( [ From 080ec4fc151fa3c49e5050b4b60c2cfea6ed8ebe Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sat, 4 Apr 2026 13:23:53 -0700 Subject: [PATCH 186/272] feat: reject fractional single-read counts --- dimelo/region_contrasts.py | 4 +++- tests/test_region_contrasts.py | 2 ++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index 6fa5238..9d7d2fb 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -216,6 +216,8 @@ def build_single_read_mod_fraction_evidence_table( | evidence["valid_count"].isna() | ~evidence["modified_count"].map(math.isfinite) | ~evidence["valid_count"].map(math.isfinite) + | (evidence["modified_count"] % 1 != 0) + | (evidence["valid_count"] % 1 != 0) | (evidence["modified_count"] < 0) | (evidence["valid_count"] < 0) | (evidence["modified_count"] > evidence["valid_count"]) @@ -223,7 +225,7 @@ def build_single_read_mod_fraction_evidence_table( if invalid_counts.any(): raise ValueError( "build_single_read_mod_fraction_evidence_table modified_count and " - "valid_count must be finite, >= 0, and modified_count <= valid_count." + "valid_count must be finite integers, >= 0, and modified_count <= valid_count." ) evidence["modified_count"] = evidence["modified_count"].astype(int) evidence["valid_count"] = evidence["valid_count"].astype(int) diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index 8406169..c1eabc3 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -471,6 +471,8 @@ def test_build_single_read_mod_fraction_evidence_table_rejects_missing_columns() [ (-1, 4), (1, -1), + (1.5, 4), + (1, 4.5), (float("nan"), 4), (1, float("nan")), (float("inf"), 4), From c82b0c2f15fe5894e85bd351a6d3fc8d5c9aa8b9 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sat, 4 Apr 2026 13:25:27 -0700 Subject: [PATCH 187/272] test: add single-read feature contrast coverage --- tests/test_region_contrasts.py | 94 ++++++++++++++++++++++++++++++++++ 1 file changed, 94 insertions(+) diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index c1eabc3..c39e8de 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -562,6 +562,100 @@ def test_score_regions_single_read_mod_fraction_effect_size_only(): assert row["delta_summary_mean"] == pytest.approx(0.5) +def test_build_single_read_feature_evidence_table_accepts_user_features(): + feature_table = pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "read_id": "r1", + "f0": 0.1, + "f1": 0.2, + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "treated", + "read_id": "r2", + "f0": 0.8, + "f1": 0.9, + }, + ] + ) + + result = region_contrasts.build_single_read_feature_evidence_table( + feature_table=feature_table + ) + + assert result.to_dict("records") == feature_table.to_dict("records") + + +def test_build_single_read_feature_evidence_table_rejects_missing_read_id(): + with pytest.raises(ValueError, match="read_id"): + region_contrasts.build_single_read_feature_evidence_table( + feature_table=pd.DataFrame( + [{"region_id": "reg1", "sample_id": "s1", "condition": "NS", "f0": 0.1}] + ) + ) + + +def test_score_regions_single_read_window_features_effect_size_only(): + feature_table = pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "read_id": "r1", + "f0": 0.1, + "f1": 0.2, + }, + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "read_id": "r2", + "f0": 0.2, + "f1": 0.3, + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "treated", + "read_id": "r3", + "f0": 0.8, + "f1": 0.9, + }, + { + "region_id": "reg1", + "sample_id": "s3", + "condition": "treated", + "read_id": "r4", + "f0": 0.7, + "f1": 0.8, + }, + ] + ) + + result = region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec(mode="group_vs_group", numerator=["treated"], denominator=["NS"]), + analysis_unit="single_read", + representation="read_window_features", + signal_source="extract_features", + test="effect_size_only", + feature_table=feature_table, + ) + + row = result.summary.iloc[0] + assert row["region_id"] == "reg1" + assert row["f0_delta_mean"] == pytest.approx(0.6) + assert row["f1_delta_mean"] == pytest.approx(0.6) + + def test_build_region_evidence_table_from_pileup_counts(monkeypatch): samples = [ SampleSpec( From d52bb11a12ac1702e163e86aef7914a991c4978d Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sat, 4 Apr 2026 13:31:05 -0700 Subject: [PATCH 188/272] feat: add single-read feature contrasts --- dimelo/region_contrasts.py | 201 +++++++++++++++++++++++++++------ tests/test_region_contrasts.py | 40 +++++++ 2 files changed, 209 insertions(+), 32 deletions(-) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index 9d7d2fb..8b16973 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -236,6 +236,38 @@ def build_single_read_mod_fraction_evidence_table( return evidence +def build_single_read_feature_evidence_table( + *, + feature_table: pd.DataFrame, +) -> pd.DataFrame: + required_columns = {"region_id", "sample_id", "condition", "read_id"} + missing_columns = required_columns - set(feature_table.columns) + if missing_columns: + missing_display = ", ".join(sorted(missing_columns)) + raise ValueError( + "build_single_read_feature_evidence_table requires columns: " + f"{missing_display}." + ) + + feature_columns = [ + column for column in feature_table.columns if column not in required_columns + ] + if not feature_columns: + raise ValueError( + "build_single_read_feature_evidence_table requires at least one feature column." + ) + return feature_table.loc[ + :, + ["region_id", "sample_id", "condition", "read_id", *feature_columns], + ].copy() + + +def _load_builtin_single_read_feature_table(*, samples, regions, motifs): + raise NotImplementedError( + "Built-in single_read feature loading is not implemented yet." + ) + + def build_cluster_occupancy_evidence_table( *, region_summaries: pd.DataFrame, @@ -710,6 +742,72 @@ def _score_single_read_mod_fraction( return regions_table, summary +def _summarize_single_read_features_by_sample(evidence: pd.DataFrame) -> pd.DataFrame: + group_columns = ["region_id", "sample_id", "condition"] + feature_columns = [ + column + for column in evidence.columns + if column not in {"region_id", "sample_id", "condition", "read_id"} + ] + return evidence.groupby(group_columns, as_index=False, sort=False)[feature_columns].mean() + + +def _score_single_read_features( + *, + evidence: pd.DataFrame, + contrast: ContrastSpec, +) -> tuple[pd.DataFrame, pd.DataFrame]: + if contrast.mode not in {"pairwise", "group_vs_group"}: + raise NotImplementedError( + "Single-read feature scoring is not implemented for contrast mode " + f"'{contrast.mode}'." + ) + + sample_summary = _summarize_single_read_features_by_sample(evidence) + side_specs = { + "numerator": contrast.numerator or [], + "denominator": contrast.denominator or [], + } + _require_requested_conditions_present( + sample_summary, + side_specs=side_specs, + ) + + feature_columns = [ + column + for column in sample_summary.columns + if column not in {"region_id", "sample_id", "condition"} + ] + summary_rows = [] + for region_id, region_table in sample_summary.groupby("region_id", sort=False): + numerator_table = region_table[region_table["condition"].isin(contrast.numerator)] + denominator_table = region_table[region_table["condition"].isin(contrast.denominator)] + row = {"region_id": region_id} + effect_sizes = [] + for feature_name in feature_columns: + numerator_mean = float(numerator_table[feature_name].mean()) + denominator_mean = float(denominator_table[feature_name].mean()) + delta_mean = numerator_mean - denominator_mean + row[f"{feature_name}_numerator_mean"] = numerator_mean + row[f"{feature_name}_denominator_mean"] = denominator_mean + row[f"{feature_name}_delta_mean"] = delta_mean + effect_sizes.append(abs(delta_mean)) + row["effect_size"] = max(effect_sizes, default=0.0) + summary_rows.append(row) + + summary = pd.DataFrame(summary_rows) + if summary.empty: + summary = pd.DataFrame(columns=["region_id", "effect_size"]) + else: + summary = summary.sort_values( + by=["effect_size", "region_id"], + ascending=[False, True], + kind="mergesort", + ).reset_index(drop=True) + summary["rank"] = range(1, len(summary) + 1) + return evidence, summary.drop(columns="effect_size", errors="ignore") + + def _add_fraction_test_scores( regions_table: pd.DataFrame, *, @@ -1039,6 +1137,7 @@ def score_regions( multiple_testing: str = "fdr_bh", occupancy_table: pd.DataFrame | None = None, read_table: pd.DataFrame | None = None, + feature_table: pd.DataFrame | None = None, ) -> RegionContrastResult: validate_region_contrast_request( analysis_unit=analysis_unit, @@ -1049,40 +1148,78 @@ def score_regions( contrast_metadata = contrast.metadata or {} if analysis_unit == "single_read": - if representation != "read_mod_fraction": - raise NotImplementedError( - f"Single-read representation '{representation}' is not implemented yet." + if representation == "read_mod_fraction": + if read_table is None: + raise ValueError( + "single_read read_mod_fraction scoring currently requires read_table." + ) + evidence = build_single_read_mod_fraction_evidence_table(extract_table=read_table) + regions_table, summary = _score_single_read_mod_fraction( + evidence=evidence, + contrast=contrast, ) - if read_table is None: - raise ValueError( - "single_read read_mod_fraction scoring currently requires read_table." + metadata = { + "contrast_mode": contrast.mode, + "analysis_unit": analysis_unit, + "representation": representation, + "signal_source": signal_source, + "test": test, + "multiple_testing": multiple_testing, + "normalization_mode": contrast_metadata.get("normalization_mode", "none"), + "biological_interpretation": contrast_metadata.get( + "biological_interpretation", + "region-level difference in sample-level read modification fraction", + ), + "renderer": contrast_metadata.get("renderer", "region_effect_sizes"), + } + return RegionContrastResult( + regions=regions_table, + summary=summary, + contrast=contrast, + plot_data={"region_effect_sizes": summary.copy()}, + metadata=metadata, + figures={}, ) - evidence = build_single_read_mod_fraction_evidence_table(extract_table=read_table) - regions_table, summary = _score_single_read_mod_fraction( - evidence=evidence, - contrast=contrast, - ) - metadata = { - "contrast_mode": contrast.mode, - "analysis_unit": analysis_unit, - "representation": representation, - "signal_source": signal_source, - "test": test, - "multiple_testing": multiple_testing, - "normalization_mode": contrast_metadata.get("normalization_mode", "none"), - "biological_interpretation": contrast_metadata.get( - "biological_interpretation", - "region-level difference in sample-level read modification fraction", - ), - "renderer": contrast_metadata.get("renderer", "region_effect_sizes"), - } - return RegionContrastResult( - regions=regions_table, - summary=summary, - contrast=contrast, - plot_data={"region_effect_sizes": summary.copy()}, - metadata=metadata, - figures={}, + + if representation == "read_window_features": + if feature_table is None: + feature_table = _load_builtin_single_read_feature_table( + samples=samples, + regions=regions, + motifs=motifs, + ) + evidence = build_single_read_feature_evidence_table( + feature_table=feature_table + ) + regions_table, summary = _score_single_read_features( + evidence=evidence, + contrast=contrast, + ) + metadata = { + "contrast_mode": contrast.mode, + "analysis_unit": analysis_unit, + "representation": representation, + "signal_source": signal_source, + "test": test, + "multiple_testing": multiple_testing, + "normalization_mode": contrast_metadata.get("normalization_mode", "none"), + "biological_interpretation": contrast_metadata.get( + "biological_interpretation", + "region-level difference in sample-level read feature summaries", + ), + "renderer": contrast_metadata.get("renderer", "region_effect_sizes"), + } + return RegionContrastResult( + regions=regions_table, + summary=summary, + contrast=contrast, + plot_data={"region_effect_sizes": summary.copy()}, + metadata=metadata, + figures={}, + ) + + raise NotImplementedError( + f"Single-read representation '{representation}' is not implemented yet." ) if analysis_unit == "cluster_occupancy": diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index c39e8de..008bcbc 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -656,6 +656,46 @@ def test_score_regions_single_read_window_features_effect_size_only(): assert row["f1_delta_mean"] == pytest.approx(0.6) +def test_score_regions_single_read_window_features_uses_builtin_loader(monkeypatch): + feature_table = pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "read_id": "r1", + "f0": 0.1, + }, + { + "region_id": "reg1", + "sample_id": "s2", + "condition": "treated", + "read_id": "r2", + "f0": 0.9, + }, + ] + ) + + monkeypatch.setattr( + region_contrasts, + "_load_builtin_single_read_feature_table", + lambda **kwargs: feature_table, + ) + + result = region_contrasts.score_regions( + samples=[], + regions="regions.bed", + motifs=["A,0"], + contrast=ContrastSpec(mode="pairwise", numerator=["treated"], denominator=["NS"]), + analysis_unit="single_read", + representation="read_window_features", + signal_source="extract_features", + test="feature_summary_shift", + ) + + assert result.summary.iloc[0]["f0_delta_mean"] == pytest.approx(0.8) + + def test_build_region_evidence_table_from_pileup_counts(monkeypatch): samples = [ SampleSpec( From 7f4d3fad8bae08da756197b14408c512794e041c Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sat, 4 Apr 2026 13:37:26 -0700 Subject: [PATCH 189/272] feat: add single-read feature contrasts --- dimelo/region_contrasts.py | 87 ++++++++++++++++++++++++++++++++-- tests/test_region_contrasts.py | 80 +++++++++++++++++++++++-------- 2 files changed, 141 insertions(+), 26 deletions(-) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index 8b16973..5d61956 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -7,7 +7,7 @@ import pandas as pd from scipy import stats -from . import load_processed, utils +from . import cluster, load_processed, utils from .models import ContrastSpec, RegionContrastResult @@ -256,16 +256,93 @@ def build_single_read_feature_evidence_table( raise ValueError( "build_single_read_feature_evidence_table requires at least one feature column." ) - return feature_table.loc[ + evidence = feature_table.loc[ :, ["region_id", "sample_id", "condition", "read_id", *feature_columns], ].copy() + evidence.loc[:, feature_columns] = evidence.loc[:, feature_columns].apply( + pd.to_numeric, + errors="coerce", + ) + finite_feature_values = evidence.loc[:, feature_columns].apply( + lambda column: column.map(math.isfinite) + ) + invalid_feature_values = evidence.loc[:, feature_columns].isna() | ~finite_feature_values + if invalid_feature_values.to_numpy().any(): + raise ValueError( + "build_single_read_feature_evidence_table feature columns must be numeric " + "and finite." + ) + return evidence def _load_builtin_single_read_feature_table(*, samples, regions, motifs): - raise NotImplementedError( - "Built-in single_read feature loading is not implemented yet." - ) + if not samples: + raise ValueError( + "Built-in single_read feature loading requires at least one sample." + ) + + selected_feature_names: list[str] | None = None + sample_frames: list[pd.DataFrame] = [] + for sample in samples: + extracted = cluster.extract_read_windows( + hdf5_file=sample.extract_h5, + motifs=motifs, + regions=regions, + ) + feature_matrix, feature_names = cluster.read_window_feature_matrix(extracted) + feature_rows = list(feature_matrix) + feature_names = list(feature_names) + if selected_feature_names is None: + selected_feature_names = feature_names + elif selected_feature_names != feature_names: + raise ValueError( + "Built-in single_read feature loading requires matching feature names " + "across samples." + ) + + if len(extracted.metadata) != len(feature_rows): + raise ValueError( + "Built-in single_read feature loading requires one metadata row per " + "feature row." + ) + + rows = [] + for metadata, feature_values in zip(extracted.metadata, feature_rows): + chromosome = metadata.get("chromosome") + start = metadata.get("region_start") + end = metadata.get("region_end") + read_id = metadata.get("read_name") + if chromosome is None or start is None or end is None: + raise ValueError( + "Built-in single_read feature loading requires metadata with " + "chromosome, region_start, and region_end." + ) + if read_id is None: + raise ValueError( + "Built-in single_read feature loading requires metadata with read_name." + ) + strand = metadata.get("region_strand") or "+" + row = { + "region_id": f"{chromosome}:{int(start)}-{int(end)},{strand}", + "sample_id": sample.sample_id, + "condition": sample.condition, + "read_id": read_id, + } + row.update( + { + feature_name: float(feature_value) + for feature_name, feature_value in zip(feature_names, feature_values) + } + ) + rows.append(row) + sample_frames.append(pd.DataFrame(rows)) + + if not sample_frames: + return pd.DataFrame( + columns=["region_id", "sample_id", "condition", "read_id", *(selected_feature_names or [])] + ) + return pd.concat(sample_frames, ignore_index=True) def build_cluster_occupancy_evidence_table( diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index 008bcbc..56cc7fc 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -1,4 +1,5 @@ import math +from types import SimpleNamespace import pandas as pd import pytest @@ -600,6 +601,23 @@ def test_build_single_read_feature_evidence_table_rejects_missing_read_id(): ) +def test_build_single_read_feature_evidence_table_rejects_non_numeric_features(): + with pytest.raises(ValueError, match="numeric"): + region_contrasts.build_single_read_feature_evidence_table( + feature_table=pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1", + "condition": "NS", + "read_id": "r1", + "f0": "high", + } + ] + ) + ) + + def test_score_regions_single_read_window_features_effect_size_only(): feature_table = pd.DataFrame( [ @@ -657,33 +675,53 @@ def test_score_regions_single_read_window_features_effect_size_only(): def test_score_regions_single_read_window_features_uses_builtin_loader(monkeypatch): - feature_table = pd.DataFrame( - [ - { - "region_id": "reg1", - "sample_id": "s1", - "condition": "NS", - "read_id": "r1", - "f0": 0.1, - }, - { - "region_id": "reg1", - "sample_id": "s2", - "condition": "treated", - "read_id": "r2", - "f0": 0.9, - }, - ] - ) + extracted_by_path = { + "ns.h5": SimpleNamespace( + metadata=[ + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 10, + "region_strand": "+", + } + ] + ), + "treated.h5": SimpleNamespace( + metadata=[ + { + "read_name": "r2", + "chromosome": "chr1", + "region_start": 0, + "region_end": 10, + "region_strand": "+", + } + ] + ), + } + + feature_rows_by_path = { + "ns.h5": ([[0.1]], ["f0"]), + "treated.h5": ([[0.9]], ["f0"]), + } monkeypatch.setattr( region_contrasts, - "_load_builtin_single_read_feature_table", - lambda **kwargs: feature_table, + "cluster", + SimpleNamespace( + extract_read_windows=lambda **kwargs: extracted_by_path[kwargs["hdf5_file"]], + read_window_feature_matrix=lambda extracted: feature_rows_by_path[ + "ns.h5" if extracted is extracted_by_path["ns.h5"] else "treated.h5" + ], + ), + raising=False, ) result = region_contrasts.score_regions( - samples=[], + samples=[ + SampleSpec(sample_id="s1", condition="NS", extract_h5="ns.h5"), + SampleSpec(sample_id="s2", condition="treated", extract_h5="treated.h5"), + ], regions="regions.bed", motifs=["A,0"], contrast=ContrastSpec(mode="pairwise", numerator=["treated"], denominator=["NS"]), From ecd209c688a1d24cbaf19fd81eb4cf59bf6caec9 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 8 Apr 2026 19:51:39 -0700 Subject: [PATCH 190/272] test: add single-read matched pairwise coverage --- tests/test_region_contrasts.py | 120 +++++++++++++++++++++++++++++++++ 1 file changed, 120 insertions(+) diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index 56cc7fc..7cc0261 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -563,6 +563,72 @@ def test_score_regions_single_read_mod_fraction_effect_size_only(): assert row["delta_summary_mean"] == pytest.approx(0.5) +def test_score_regions_single_read_mod_fraction_supports_matched_pairwise(): + evidence = pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1_before", + "condition": "before", + "read_id": "r1", + "modified_count": 1, + "valid_count": 4, + "read_mod_fraction": 0.25, + "pair_id": "p1", + }, + { + "region_id": "reg1", + "sample_id": "s1_after", + "condition": "after", + "read_id": "r2", + "modified_count": 4, + "valid_count": 4, + "read_mod_fraction": 1.0, + "pair_id": "p1", + }, + { + "region_id": "reg1", + "sample_id": "s2_before", + "condition": "before", + "read_id": "r3", + "modified_count": 2, + "valid_count": 4, + "read_mod_fraction": 0.5, + "pair_id": "p2", + }, + { + "region_id": "reg1", + "sample_id": "s2_after", + "condition": "after", + "read_id": "r4", + "modified_count": 3, + "valid_count": 4, + "read_mod_fraction": 0.75, + "pair_id": "p2", + }, + ] + ) + + result = region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["after"], + denominator=["before"], + pairing_key="pair_id", + ), + analysis_unit="single_read", + representation="read_mod_fraction", + signal_source="extract_reads", + test="sample_distribution_shift", + read_table=evidence, + ) + + assert result.summary.iloc[0]["delta_summary_mean"] > 0 + + def test_build_single_read_feature_evidence_table_accepts_user_features(): feature_table = pd.DataFrame( [ @@ -674,6 +740,60 @@ def test_score_regions_single_read_window_features_effect_size_only(): assert row["f1_delta_mean"] == pytest.approx(0.6) +def test_score_regions_single_read_window_features_supports_matched_pairwise(): + feature_table = pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1_before", + "condition": "before", + "read_id": "r1", + "f0": 0.1, + }, + { + "region_id": "reg1", + "sample_id": "s1_after", + "condition": "after", + "read_id": "r2", + "f0": 0.9, + }, + { + "region_id": "reg1", + "sample_id": "s2_before", + "condition": "before", + "read_id": "r3", + "f0": 0.2, + }, + { + "region_id": "reg1", + "sample_id": "s2_after", + "condition": "after", + "read_id": "r4", + "f0": 0.8, + }, + ] + ) + + result = region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["after"], + denominator=["before"], + pairing_key="pair_id", + ), + analysis_unit="single_read", + representation="read_window_features", + signal_source="extract_features", + test="feature_summary_shift", + feature_table=feature_table, + ) + + assert result.summary.iloc[0]["f0_delta_mean"] > 0 + + def test_score_regions_single_read_window_features_uses_builtin_loader(monkeypatch): extracted_by_path = { "ns.h5": SimpleNamespace( From ca0e789a5f3c731204bfbe919044ef27b1f483cd Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 8 Apr 2026 19:56:08 -0700 Subject: [PATCH 191/272] feat: add matched single-read contrasts --- dimelo/region_contrasts.py | 309 ++++++++++++++++++++++++++++++--- tests/test_region_contrasts.py | 116 ++++++++++++- 2 files changed, 395 insertions(+), 30 deletions(-) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index 5d61956..b0965a2 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -181,6 +181,7 @@ def build_region_evidence_table( def build_single_read_mod_fraction_evidence_table( *, extract_table: pd.DataFrame, + pairing_key: str | None = None, ) -> pd.DataFrame: required_columns = { "region_id", @@ -190,6 +191,8 @@ def build_single_read_mod_fraction_evidence_table( "modified_count", "valid_count", } + if pairing_key: + required_columns.add(pairing_key) missing_columns = required_columns - set(extract_table.columns) if missing_columns: missing_display = ", ".join(sorted(missing_columns)) @@ -198,16 +201,19 @@ def build_single_read_mod_fraction_evidence_table( f"{missing_display}." ) + selected_columns = [ + "region_id", + "sample_id", + "condition", + "read_id", + "modified_count", + "valid_count", + ] + if pairing_key: + selected_columns.append(pairing_key) evidence = extract_table.loc[ :, - [ - "region_id", - "sample_id", - "condition", - "read_id", - "modified_count", - "valid_count", - ], + selected_columns, ].copy() evidence["modified_count"] = pd.to_numeric(evidence["modified_count"], errors="coerce") evidence["valid_count"] = pd.to_numeric(evidence["valid_count"], errors="coerce") @@ -239,8 +245,11 @@ def build_single_read_mod_fraction_evidence_table( def build_single_read_feature_evidence_table( *, feature_table: pd.DataFrame, + pairing_key: str | None = None, ) -> pd.DataFrame: required_columns = {"region_id", "sample_id", "condition", "read_id"} + if pairing_key: + required_columns.add(pairing_key) missing_columns = required_columns - set(feature_table.columns) if missing_columns: missing_display = ", ".join(sorted(missing_columns)) @@ -250,16 +259,19 @@ def build_single_read_feature_evidence_table( ) feature_columns = [ - column for column in feature_table.columns if column not in required_columns + column + for column in feature_table.columns + if column not in required_columns ] if not feature_columns: raise ValueError( "build_single_read_feature_evidence_table requires at least one feature column." ) - evidence = feature_table.loc[ - :, - ["region_id", "sample_id", "condition", "read_id", *feature_columns], - ].copy() + selected_columns = ["region_id", "sample_id", "condition", "read_id"] + if pairing_key: + selected_columns.append(pairing_key) + selected_columns.extend(feature_columns) + evidence = feature_table.loc[:, selected_columns].copy() evidence.loc[:, feature_columns] = evidence.loc[:, feature_columns].apply( pd.to_numeric, errors="coerce", @@ -276,6 +288,13 @@ def build_single_read_feature_evidence_table( return evidence +def _require_single_read_pairing_key(frame: pd.DataFrame, pairing_key: str) -> None: + if pairing_key not in frame.columns: + raise ValueError( + f"single_read matched_pairwise scoring requires column {pairing_key!r}." + ) + + def _load_builtin_single_read_feature_table(*, samples, regions, motifs): if not samples: raise ValueError( @@ -691,14 +710,67 @@ def _pool_cluster_occupancy_groups( return pd.concat(pooled_frames, ignore_index=True) -def _summarize_single_read_mod_fraction_by_sample(evidence: pd.DataFrame) -> pd.DataFrame: - return ( - evidence.groupby(["region_id", "sample_id", "condition"], as_index=False, sort=False) - .agg( - read_n=("read_id", "nunique"), - sample_summary_mean=("read_mod_fraction", "mean"), +def _summarize_single_read_mod_fraction_by_sample( + evidence: pd.DataFrame, + *, + pairing_key: str | None = None, +) -> pd.DataFrame: + group_columns = ["region_id", "sample_id", "condition"] + if pairing_key: + _require_single_read_pairing_key(evidence, pairing_key) + group_columns.append(pairing_key) + + return evidence.groupby(group_columns, as_index=False, sort=False).agg( + read_n=("read_id", "nunique"), + sample_summary_mean=("read_mod_fraction", "mean"), + ) + + +def _summarize_single_read_mod_fraction_by_pair( + sample_summary: pd.DataFrame, + *, + pairing_key: str, +) -> pd.DataFrame: + pair_columns = ["region_id", pairing_key, "condition"] + return sample_summary.groupby(pair_columns, as_index=False, sort=False).agg( + sample_summary_mean=("sample_summary_mean", "mean"), + read_n=("read_n", "sum"), + sample_n=("sample_id", "nunique"), + ) + + +def _select_complete_matched_pairs( + pair_summary: pd.DataFrame, + *, + pairing_key: str, + contrast: ContrastSpec, +) -> pd.DataFrame: + required_conditions = list( + dict.fromkeys((contrast.numerator or []) + (contrast.denominator or [])) + ) + required_condition_set = set(required_conditions) + pair_conditions = ( + pair_summary.loc[:, ["region_id", pairing_key, "condition"]] + .drop_duplicates() + .groupby(["region_id", pairing_key])["condition"] + .agg(lambda values: set(values)) + ) + complete_pair_index = [ + pair_index + for pair_index, conditions in pair_conditions.items() + if required_condition_set.issubset(conditions) + ] + if not complete_pair_index: + raise ValueError( + "single_read matched_pairwise scoring found no complete matched pairs." ) + + complete_pairs = pd.MultiIndex.from_tuples( + complete_pair_index, + names=["region_id", pairing_key], ) + paired_index = pd.MultiIndex.from_frame(pair_summary.loc[:, ["region_id", pairing_key]]) + return pair_summary.loc[paired_index.isin(complete_pairs)].copy() def _score_single_read_mod_fraction( @@ -706,13 +778,17 @@ def _score_single_read_mod_fraction( evidence: pd.DataFrame, contrast: ContrastSpec, ) -> tuple[pd.DataFrame, pd.DataFrame]: - if contrast.mode not in {"pairwise", "group_vs_group"}: + if contrast.mode not in {"pairwise", "group_vs_group", "matched_pairwise"}: raise NotImplementedError( "Single-read mod-fraction scoring is not implemented for contrast mode " f"'{contrast.mode}'." ) - sample_summary = _summarize_single_read_mod_fraction_by_sample(evidence) + pairing_key = contrast.pairing_key if contrast.mode == "matched_pairwise" else None + sample_summary = _summarize_single_read_mod_fraction_by_sample( + evidence, + pairing_key=pairing_key, + ) side_specs = { "numerator": contrast.numerator or [], "denominator": contrast.denominator or [], @@ -722,6 +798,97 @@ def _score_single_read_mod_fraction( side_specs=side_specs, ) + if contrast.mode == "matched_pairwise": + pair_summary = _summarize_single_read_mod_fraction_by_pair( + sample_summary, + pairing_key=pairing_key or "", + ) + pair_summary = _select_complete_matched_pairs( + pair_summary, + pairing_key=pairing_key or "", + contrast=contrast, + ) + + numerator = ( + pair_summary.loc[pair_summary["condition"].isin(side_specs["numerator"])] + .drop(columns=["condition"]) + .rename( + columns={ + "sample_summary_mean": "sample_summary_numerator_mean", + "read_n": "numerator_read_n", + "sample_n": "numerator_sample_n", + } + ) + ) + denominator = ( + pair_summary.loc[pair_summary["condition"].isin(side_specs["denominator"])] + .drop(columns=["condition"]) + .rename( + columns={ + "sample_summary_mean": "sample_summary_denominator_mean", + "read_n": "denominator_read_n", + "sample_n": "denominator_sample_n", + } + ) + ) + regions_table = numerator.merge( + denominator, + on=["region_id", pairing_key], + how="inner", + sort=False, + ) + if regions_table.empty: + raise ValueError( + "single_read matched_pairwise scoring found no complete matched pairs." + ) + regions_table["delta_summary_mean"] = ( + regions_table["sample_summary_numerator_mean"] + - regions_table["sample_summary_denominator_mean"] + ) + regions_table["log2_fc"] = ( + (regions_table["sample_summary_numerator_mean"] + 1e-6) + / (regions_table["sample_summary_denominator_mean"] + 1e-6) + ).map(math.log2) + regions_table = ( + regions_table.groupby("region_id", as_index=False, sort=False) + .agg( + sample_summary_numerator_mean=("sample_summary_numerator_mean", "mean"), + sample_summary_denominator_mean=("sample_summary_denominator_mean", "mean"), + delta_summary_mean=("delta_summary_mean", "mean"), + numerator_read_n=("numerator_read_n", "sum"), + denominator_read_n=("denominator_read_n", "sum"), + numerator_replicate_n=("numerator_sample_n", "size"), + denominator_replicate_n=("denominator_sample_n", "size"), + ) + ) + regions_table["log2_fc"] = ( + (regions_table["sample_summary_numerator_mean"] + 1e-6) + / (regions_table["sample_summary_denominator_mean"] + 1e-6) + ).map(math.log2) + regions_table["effect_size"] = regions_table["delta_summary_mean"].abs() + regions_table = regions_table.sort_values( + by=["effect_size", "delta_summary_mean", "region_id"], + ascending=[False, False, True], + kind="mergesort", + ).reset_index(drop=True) + regions_table["rank"] = range(1, len(regions_table) + 1) + summary = regions_table.loc[ + :, + [ + "region_id", + "sample_summary_numerator_mean", + "sample_summary_denominator_mean", + "delta_summary_mean", + "log2_fc", + "rank", + "numerator_read_n", + "denominator_read_n", + "numerator_replicate_n", + "denominator_replicate_n", + ], + ].copy() + return regions_table, summary + pooled_frames = [] for side, conditions in side_specs.items(): side_evidence = sample_summary.loc[sample_summary["condition"].isin(conditions)].copy() @@ -819,12 +986,21 @@ def _score_single_read_mod_fraction( return regions_table, summary -def _summarize_single_read_features_by_sample(evidence: pd.DataFrame) -> pd.DataFrame: +def _summarize_single_read_features_by_sample( + evidence: pd.DataFrame, + *, + pairing_key: str | None = None, +) -> pd.DataFrame: group_columns = ["region_id", "sample_id", "condition"] + excluded_columns = {"region_id", "sample_id", "condition", "read_id"} + if pairing_key: + _require_single_read_pairing_key(evidence, pairing_key) + group_columns.append(pairing_key) + excluded_columns.add(pairing_key) feature_columns = [ column for column in evidence.columns - if column not in {"region_id", "sample_id", "condition", "read_id"} + if column not in excluded_columns ] return evidence.groupby(group_columns, as_index=False, sort=False)[feature_columns].mean() @@ -834,13 +1010,17 @@ def _score_single_read_features( evidence: pd.DataFrame, contrast: ContrastSpec, ) -> tuple[pd.DataFrame, pd.DataFrame]: - if contrast.mode not in {"pairwise", "group_vs_group"}: + if contrast.mode not in {"pairwise", "group_vs_group", "matched_pairwise"}: raise NotImplementedError( "Single-read feature scoring is not implemented for contrast mode " f"'{contrast.mode}'." ) - sample_summary = _summarize_single_read_features_by_sample(evidence) + pairing_key = contrast.pairing_key if contrast.mode == "matched_pairwise" else None + sample_summary = _summarize_single_read_features_by_sample( + evidence, + pairing_key=pairing_key, + ) side_specs = { "numerator": contrast.numerator or [], "denominator": contrast.denominator or [], @@ -853,8 +1033,77 @@ def _score_single_read_features( feature_columns = [ column for column in sample_summary.columns - if column not in {"region_id", "sample_id", "condition"} + if column not in {"region_id", "sample_id", "condition", pairing_key} ] + if contrast.mode == "matched_pairwise": + pair_columns = ["region_id", pairing_key, "condition"] + pair_summary = sample_summary.groupby(pair_columns, as_index=False, sort=False)[ + feature_columns + ].mean() + pair_summary = _select_complete_matched_pairs( + pair_summary, + pairing_key=pairing_key or "", + contrast=contrast, + ) + + numerator = ( + pair_summary.loc[pair_summary["condition"].isin(side_specs["numerator"])] + .drop(columns=["condition"]) + .rename( + columns={ + feature_name: f"{feature_name}_numerator_mean" + for feature_name in feature_columns + } + ) + ) + denominator = ( + pair_summary.loc[pair_summary["condition"].isin(side_specs["denominator"])] + .drop(columns=["condition"]) + .rename( + columns={ + feature_name: f"{feature_name}_denominator_mean" + for feature_name in feature_columns + } + ) + ) + regions_table = numerator.merge( + denominator, + on=["region_id", pairing_key], + how="inner", + sort=False, + ) + if regions_table.empty: + raise ValueError( + "single_read matched_pairwise scoring found no complete matched pairs." + ) + + summary_rows = [] + for region_id, region_table in regions_table.groupby("region_id", sort=False): + row = {"region_id": region_id} + effect_sizes = [] + for feature_name in feature_columns: + numerator_mean = float(region_table[f"{feature_name}_numerator_mean"].mean()) + denominator_mean = float(region_table[f"{feature_name}_denominator_mean"].mean()) + delta_mean = numerator_mean - denominator_mean + row[f"{feature_name}_numerator_mean"] = numerator_mean + row[f"{feature_name}_denominator_mean"] = denominator_mean + row[f"{feature_name}_delta_mean"] = delta_mean + effect_sizes.append(abs(delta_mean)) + row["effect_size"] = max(effect_sizes, default=0.0) + summary_rows.append(row) + + summary = pd.DataFrame(summary_rows) + if summary.empty: + summary = pd.DataFrame(columns=["region_id", "effect_size"]) + else: + summary = summary.sort_values( + by=["effect_size", "region_id"], + ascending=[False, True], + kind="mergesort", + ).reset_index(drop=True) + summary["rank"] = range(1, len(summary) + 1) + return evidence, summary.drop(columns="effect_size", errors="ignore") + summary_rows = [] for region_id, region_table in sample_summary.groupby("region_id", sort=False): numerator_table = region_table[region_table["condition"].isin(contrast.numerator)] @@ -1230,7 +1479,10 @@ def score_regions( raise ValueError( "single_read read_mod_fraction scoring currently requires read_table." ) - evidence = build_single_read_mod_fraction_evidence_table(extract_table=read_table) + evidence = build_single_read_mod_fraction_evidence_table( + extract_table=read_table, + pairing_key=contrast.pairing_key if contrast.mode == "matched_pairwise" else None, + ) regions_table, summary = _score_single_read_mod_fraction( evidence=evidence, contrast=contrast, @@ -1266,7 +1518,8 @@ def score_regions( motifs=motifs, ) evidence = build_single_read_feature_evidence_table( - feature_table=feature_table + feature_table=feature_table, + pairing_key=contrast.pairing_key if contrast.mode == "matched_pairwise" else None, ) regions_table, summary = _score_single_read_features( evidence=evidence, diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index 7cc0261..e329dd5 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -606,6 +606,16 @@ def test_score_regions_single_read_mod_fraction_supports_matched_pairwise(): "read_mod_fraction": 0.75, "pair_id": "p2", }, + { + "region_id": "reg1", + "sample_id": "s3_after", + "condition": "after", + "read_id": "r5", + "modified_count": 4, + "valid_count": 4, + "read_mod_fraction": 1.0, + "pair_id": "p3", + }, ] ) @@ -626,7 +636,12 @@ def test_score_regions_single_read_mod_fraction_supports_matched_pairwise(): read_table=evidence, ) - assert result.summary.iloc[0]["delta_summary_mean"] > 0 + row = result.summary.iloc[0] + assert row["sample_summary_numerator_mean"] == pytest.approx(0.875) + assert row["sample_summary_denominator_mean"] == pytest.approx(0.375) + assert row["delta_summary_mean"] == pytest.approx(0.5) + assert row["numerator_replicate_n"] == 2 + assert row["denominator_replicate_n"] == 2 def test_build_single_read_feature_evidence_table_accepts_user_features(): @@ -749,6 +764,7 @@ def test_score_regions_single_read_window_features_supports_matched_pairwise(): "condition": "before", "read_id": "r1", "f0": 0.1, + "pair_id": "p1", }, { "region_id": "reg1", @@ -756,6 +772,7 @@ def test_score_regions_single_read_window_features_supports_matched_pairwise(): "condition": "after", "read_id": "r2", "f0": 0.9, + "pair_id": "p1", }, { "region_id": "reg1", @@ -763,6 +780,7 @@ def test_score_regions_single_read_window_features_supports_matched_pairwise(): "condition": "before", "read_id": "r3", "f0": 0.2, + "pair_id": "p2", }, { "region_id": "reg1", @@ -770,6 +788,15 @@ def test_score_regions_single_read_window_features_supports_matched_pairwise(): "condition": "after", "read_id": "r4", "f0": 0.8, + "pair_id": "p2", + }, + { + "region_id": "reg1", + "sample_id": "s3_after", + "condition": "after", + "read_id": "r5", + "f0": 0.5, + "pair_id": "p3", }, ] ) @@ -791,7 +818,92 @@ def test_score_regions_single_read_window_features_supports_matched_pairwise(): feature_table=feature_table, ) - assert result.summary.iloc[0]["f0_delta_mean"] > 0 + row = result.summary.iloc[0] + assert row["f0_numerator_mean"] == pytest.approx(0.85) + assert row["f0_denominator_mean"] == pytest.approx(0.15) + assert row["f0_delta_mean"] == pytest.approx(0.7) + + +@pytest.mark.parametrize( + "representation,table_factory", + [ + ("read_mod_fraction", "read_table"), + ("read_window_features", "feature_table"), + ], +) +def test_score_regions_single_read_matched_pairwise_requires_pairing_key_column( + representation, + table_factory, +): + contrast = ContrastSpec( + mode="matched_pairwise", + numerator=["after"], + denominator=["before"], + pairing_key="pair_id", + ) + if table_factory == "read_table": + evidence_kwargs = { + "read_table": pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1_before", + "condition": "before", + "read_id": "r1", + "modified_count": 1, + "valid_count": 4, + "read_mod_fraction": 0.25, + }, + { + "region_id": "reg1", + "sample_id": "s1_after", + "condition": "after", + "read_id": "r2", + "modified_count": 4, + "valid_count": 4, + "read_mod_fraction": 1.0, + }, + ] + ) + } + signal_source = "extract_reads" + test_name = "sample_distribution_shift" + else: + evidence_kwargs = { + "feature_table": pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1_before", + "condition": "before", + "read_id": "r1", + "f0": 0.1, + }, + { + "region_id": "reg1", + "sample_id": "s1_after", + "condition": "after", + "read_id": "r2", + "f0": 0.9, + }, + ] + ) + } + signal_source = "extract_features" + test_name = "feature_summary_shift" + + with pytest.raises(ValueError, match="pair_id"): + region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=contrast, + analysis_unit="single_read", + representation=representation, + signal_source=signal_source, + test=test_name, + **evidence_kwargs, + ) def test_score_regions_single_read_window_features_uses_builtin_loader(monkeypatch): From 7e214126bc6cd9d08d1b53f86b40502477fc2ac3 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 8 Apr 2026 19:56:53 -0700 Subject: [PATCH 192/272] test: align single-read validation expectation --- tests/test_region_contrasts.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index e329dd5..27dba23 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -94,7 +94,7 @@ def test_validate_region_contrast_request_rejects_single_read_unknown_test(): def test_validate_rejects_unsupported_single_read_beta_binomial(): - with pytest.raises(ValueError, match="analysis_unit='ensemble_region'"): + with pytest.raises(ValueError, match="extract_reads"): region_contrasts.validate_region_contrast_request( analysis_unit="single_read", representation="read_mod_fraction", From 33a000851aedb2b44172dc09ef4fac2a7e3f52f4 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 8 Apr 2026 20:02:11 -0700 Subject: [PATCH 193/272] fix: harden matched single-read pairing --- dimelo/region_contrasts.py | 16 ++ tests/test_region_contrasts.py | 288 +++++++++++++++++++++++++++++++-- 2 files changed, 289 insertions(+), 15 deletions(-) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index b0965a2..6a08290 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -293,6 +293,18 @@ def _require_single_read_pairing_key(frame: pd.DataFrame, pairing_key: str) -> N raise ValueError( f"single_read matched_pairwise scoring requires column {pairing_key!r}." ) + if frame[pairing_key].isna().any(): + raise ValueError( + f"single_read matched_pairwise scoring requires non-null values in column {pairing_key!r}." + ) + + +def _require_single_read_matched_binary_sides(contrast: ContrastSpec) -> None: + if len(contrast.numerator or []) != 1 or len(contrast.denominator or []) != 1: + raise ValueError( + "single_read matched_pairwise scoring currently requires exactly one " + "numerator and one denominator condition." + ) def _load_builtin_single_read_feature_table(*, samples, regions, motifs): @@ -785,6 +797,8 @@ def _score_single_read_mod_fraction( ) pairing_key = contrast.pairing_key if contrast.mode == "matched_pairwise" else None + if contrast.mode == "matched_pairwise": + _require_single_read_matched_binary_sides(contrast) sample_summary = _summarize_single_read_mod_fraction_by_sample( evidence, pairing_key=pairing_key, @@ -1017,6 +1031,8 @@ def _score_single_read_features( ) pairing_key = contrast.pairing_key if contrast.mode == "matched_pairwise" else None + if contrast.mode == "matched_pairwise": + _require_single_read_matched_binary_sides(contrast) sample_summary = _summarize_single_read_features_by_sample( evidence, pairing_key=pairing_key, diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index 27dba23..3009ff6 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -571,9 +571,9 @@ def test_score_regions_single_read_mod_fraction_supports_matched_pairwise(): "sample_id": "s1_before", "condition": "before", "read_id": "r1", - "modified_count": 1, + "modified_count": 0, "valid_count": 4, - "read_mod_fraction": 0.25, + "read_mod_fraction": 0.0, "pair_id": "p1", }, { @@ -591,9 +591,9 @@ def test_score_regions_single_read_mod_fraction_supports_matched_pairwise(): "sample_id": "s2_before", "condition": "before", "read_id": "r3", - "modified_count": 2, + "modified_count": 4, "valid_count": 4, - "read_mod_fraction": 0.5, + "read_mod_fraction": 1.0, "pair_id": "p2", }, { @@ -601,6 +601,46 @@ def test_score_regions_single_read_mod_fraction_supports_matched_pairwise(): "sample_id": "s2_after", "condition": "after", "read_id": "r4", + "modified_count": 4, + "valid_count": 4, + "read_mod_fraction": 1.0, + "pair_id": "p2", + }, + { + "region_id": "reg1", + "sample_id": "s1_before", + "condition": "before", + "read_id": "r5", + "modified_count": 0, + "valid_count": 4, + "read_mod_fraction": 0.0, + "pair_id": "p1", + }, + { + "region_id": "reg1", + "sample_id": "s1_before", + "condition": "before", + "read_id": "r6", + "modified_count": 0, + "valid_count": 4, + "read_mod_fraction": 0.0, + "pair_id": "p1", + }, + { + "region_id": "reg1", + "sample_id": "s2_after", + "condition": "after", + "read_id": "r7", + "modified_count": 4, + "valid_count": 4, + "read_mod_fraction": 1.0, + "pair_id": "p2", + }, + { + "region_id": "reg1", + "sample_id": "s2_after", + "condition": "after", + "read_id": "r8", "modified_count": 3, "valid_count": 4, "read_mod_fraction": 0.75, @@ -637,9 +677,9 @@ def test_score_regions_single_read_mod_fraction_supports_matched_pairwise(): ) row = result.summary.iloc[0] - assert row["sample_summary_numerator_mean"] == pytest.approx(0.875) - assert row["sample_summary_denominator_mean"] == pytest.approx(0.375) - assert row["delta_summary_mean"] == pytest.approx(0.5) + assert row["sample_summary_numerator_mean"] == pytest.approx(0.9583333333333333) + assert row["sample_summary_denominator_mean"] == pytest.approx(0.5) + assert row["delta_summary_mean"] == pytest.approx(0.45833333333333326) assert row["numerator_replicate_n"] == 2 assert row["denominator_replicate_n"] == 2 @@ -763,7 +803,7 @@ def test_score_regions_single_read_window_features_supports_matched_pairwise(): "sample_id": "s1_before", "condition": "before", "read_id": "r1", - "f0": 0.1, + "f0": 0.0, "pair_id": "p1", }, { @@ -771,7 +811,7 @@ def test_score_regions_single_read_window_features_supports_matched_pairwise(): "sample_id": "s1_after", "condition": "after", "read_id": "r2", - "f0": 0.9, + "f0": 1.0, "pair_id": "p1", }, { @@ -779,7 +819,7 @@ def test_score_regions_single_read_window_features_supports_matched_pairwise(): "sample_id": "s2_before", "condition": "before", "read_id": "r3", - "f0": 0.2, + "f0": 1.0, "pair_id": "p2", }, { @@ -787,14 +827,46 @@ def test_score_regions_single_read_window_features_supports_matched_pairwise(): "sample_id": "s2_after", "condition": "after", "read_id": "r4", - "f0": 0.8, + "f0": 0.6, + "pair_id": "p2", + }, + { + "region_id": "reg1", + "sample_id": "s1_before", + "condition": "before", + "read_id": "r5", + "f0": 0.0, + "pair_id": "p1", + }, + { + "region_id": "reg1", + "sample_id": "s1_before", + "condition": "before", + "read_id": "r6", + "f0": 0.0, + "pair_id": "p1", + }, + { + "region_id": "reg1", + "sample_id": "s2_after", + "condition": "after", + "read_id": "r7", + "f0": 0.6, + "pair_id": "p2", + }, + { + "region_id": "reg1", + "sample_id": "s2_after", + "condition": "after", + "read_id": "r8", + "f0": 0.6, "pair_id": "p2", }, { "region_id": "reg1", "sample_id": "s3_after", "condition": "after", - "read_id": "r5", + "read_id": "r9", "f0": 0.5, "pair_id": "p3", }, @@ -819,9 +891,9 @@ def test_score_regions_single_read_window_features_supports_matched_pairwise(): ) row = result.summary.iloc[0] - assert row["f0_numerator_mean"] == pytest.approx(0.85) - assert row["f0_denominator_mean"] == pytest.approx(0.15) - assert row["f0_delta_mean"] == pytest.approx(0.7) + assert row["f0_numerator_mean"] == pytest.approx(0.8) + assert row["f0_denominator_mean"] == pytest.approx(0.5) + assert row["f0_delta_mean"] == pytest.approx(0.3) @pytest.mark.parametrize( @@ -906,6 +978,192 @@ def test_score_regions_single_read_matched_pairwise_requires_pairing_key_column( ) +@pytest.mark.parametrize( + "representation,table_factory,signal_source,test_name", + [ + ("read_mod_fraction", "read_table", "extract_reads", "sample_distribution_shift"), + ("read_window_features", "feature_table", "extract_features", "feature_summary_shift"), + ], +) +def test_score_regions_single_read_matched_pairwise_requires_non_null_pairing_keys( + representation, + table_factory, + signal_source, + test_name, +): + contrast = ContrastSpec( + mode="matched_pairwise", + numerator=["after"], + denominator=["before"], + pairing_key="pair_id", + ) + if table_factory == "read_table": + evidence_kwargs = { + "read_table": pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1_before", + "condition": "before", + "read_id": "r1", + "modified_count": 1, + "valid_count": 4, + "read_mod_fraction": 0.25, + "pair_id": None, + }, + { + "region_id": "reg1", + "sample_id": "s1_after", + "condition": "after", + "read_id": "r2", + "modified_count": 4, + "valid_count": 4, + "read_mod_fraction": 1.0, + "pair_id": "p1", + }, + ] + ) + } + else: + evidence_kwargs = { + "feature_table": pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1_before", + "condition": "before", + "read_id": "r1", + "f0": 0.1, + "pair_id": None, + }, + { + "region_id": "reg1", + "sample_id": "s1_after", + "condition": "after", + "read_id": "r2", + "f0": 0.9, + "pair_id": "p1", + }, + ] + ) + } + + with pytest.raises(ValueError, match="non-null"): + region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=contrast, + analysis_unit="single_read", + representation=representation, + signal_source=signal_source, + test=test_name, + **evidence_kwargs, + ) + + +@pytest.mark.parametrize( + "representation,table_factory,signal_source,test_name", + [ + ("read_mod_fraction", "read_table", "extract_reads", "sample_distribution_shift"), + ("read_window_features", "feature_table", "extract_features", "feature_summary_shift"), + ], +) +def test_score_regions_single_read_matched_pairwise_rejects_multi_condition_sides( + representation, + table_factory, + signal_source, + test_name, +): + contrast = ContrastSpec( + mode="matched_pairwise", + numerator=["after", "later"], + denominator=["before"], + pairing_key="pair_id", + ) + if table_factory == "read_table": + evidence_kwargs = { + "read_table": pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1_before", + "condition": "before", + "read_id": "r1", + "modified_count": 1, + "valid_count": 4, + "read_mod_fraction": 0.25, + "pair_id": "p1", + }, + { + "region_id": "reg1", + "sample_id": "s1_after", + "condition": "after", + "read_id": "r2", + "modified_count": 4, + "valid_count": 4, + "read_mod_fraction": 1.0, + "pair_id": "p1", + }, + { + "region_id": "reg1", + "sample_id": "s1_later", + "condition": "later", + "read_id": "r3", + "modified_count": 3, + "valid_count": 4, + "read_mod_fraction": 0.75, + "pair_id": "p1", + }, + ] + ) + } + else: + evidence_kwargs = { + "feature_table": pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1_before", + "condition": "before", + "read_id": "r1", + "f0": 0.1, + "pair_id": "p1", + }, + { + "region_id": "reg1", + "sample_id": "s1_after", + "condition": "after", + "read_id": "r2", + "f0": 0.9, + "pair_id": "p1", + }, + { + "region_id": "reg1", + "sample_id": "s1_later", + "condition": "later", + "read_id": "r3", + "f0": 0.7, + "pair_id": "p1", + }, + ] + ) + } + + with pytest.raises(ValueError, match="exactly one numerator and one denominator"): + region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=contrast, + analysis_unit="single_read", + representation=representation, + signal_source=signal_source, + test=test_name, + **evidence_kwargs, + ) + + def test_score_regions_single_read_window_features_uses_builtin_loader(monkeypatch): extracted_by_path = { "ns.h5": SimpleNamespace( From 3bd965f4891623b790e06470ef134591e3c619e2 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 8 Apr 2026 20:05:54 -0700 Subject: [PATCH 194/272] fix: enforce matched single-read pair integrity --- dimelo/region_contrasts.py | 40 +++++++ tests/test_region_contrasts.py | 204 +++++++++++++++++++++++++++++++++ 2 files changed, 244 insertions(+) diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index 6a08290..90b01d4 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -307,6 +307,38 @@ def _require_single_read_matched_binary_sides(contrast: ContrastSpec) -> None: ) +def _validate_single_read_matched_sample_summary( + sample_summary: pd.DataFrame, + *, + pairing_key: str, +) -> None: + sample_pair_counts = ( + sample_summary.loc[:, ["sample_id", pairing_key]] + .drop_duplicates() + .groupby("sample_id", dropna=False)[pairing_key] + .nunique(dropna=False) + ) + if (sample_pair_counts > 1).any(): + raise ValueError( + "single_read matched_pairwise scoring requires each sample_id to map " + "to exactly one pairing key." + ) + + side_counts = ( + sample_summary.groupby( + ["region_id", pairing_key, "condition"], + dropna=False, + sort=False, + )["sample_id"] + .nunique() + ) + if (side_counts > 1).any(): + raise ValueError( + "single_read matched_pairwise scoring requires exactly one sample " + "per region, pair, and condition." + ) + + def _load_builtin_single_read_feature_table(*, samples, regions, motifs): if not samples: raise ValueError( @@ -813,6 +845,10 @@ def _score_single_read_mod_fraction( ) if contrast.mode == "matched_pairwise": + _validate_single_read_matched_sample_summary( + sample_summary, + pairing_key=pairing_key or "", + ) pair_summary = _summarize_single_read_mod_fraction_by_pair( sample_summary, pairing_key=pairing_key or "", @@ -1052,6 +1088,10 @@ def _score_single_read_features( if column not in {"region_id", "sample_id", "condition", pairing_key} ] if contrast.mode == "matched_pairwise": + _validate_single_read_matched_sample_summary( + sample_summary, + pairing_key=pairing_key or "", + ) pair_columns = ["region_id", pairing_key, "condition"] pair_summary = sample_summary.groupby(pair_columns, as_index=False, sort=False)[ feature_columns diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index 3009ff6..4da4d20 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -1164,6 +1164,210 @@ def test_score_regions_single_read_matched_pairwise_rejects_multi_condition_side ) +@pytest.mark.parametrize( + "representation,table_factory,signal_source,test_name", + [ + ("read_mod_fraction", "read_table", "extract_reads", "sample_distribution_shift"), + ("read_window_features", "feature_table", "extract_features", "feature_summary_shift"), + ], +) +def test_score_regions_single_read_matched_pairwise_rejects_multiple_samples_on_one_side( + representation, + table_factory, + signal_source, + test_name, +): + contrast = ContrastSpec( + mode="matched_pairwise", + numerator=["after"], + denominator=["before"], + pairing_key="pair_id", + ) + if table_factory == "read_table": + evidence_kwargs = { + "read_table": pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1_before", + "condition": "before", + "read_id": "r1", + "modified_count": 1, + "valid_count": 4, + "read_mod_fraction": 0.25, + "pair_id": "p1", + }, + { + "region_id": "reg1", + "sample_id": "s1_after_a", + "condition": "after", + "read_id": "r2", + "modified_count": 4, + "valid_count": 4, + "read_mod_fraction": 1.0, + "pair_id": "p1", + }, + { + "region_id": "reg1", + "sample_id": "s1_after_b", + "condition": "after", + "read_id": "r3", + "modified_count": 3, + "valid_count": 4, + "read_mod_fraction": 0.75, + "pair_id": "p1", + }, + ] + ) + } + else: + evidence_kwargs = { + "feature_table": pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "s1_before", + "condition": "before", + "read_id": "r1", + "f0": 0.1, + "pair_id": "p1", + }, + { + "region_id": "reg1", + "sample_id": "s1_after_a", + "condition": "after", + "read_id": "r2", + "f0": 0.9, + "pair_id": "p1", + }, + { + "region_id": "reg1", + "sample_id": "s1_after_b", + "condition": "after", + "read_id": "r3", + "f0": 0.7, + "pair_id": "p1", + }, + ] + ) + } + + with pytest.raises(ValueError, match="exactly one sample per region, pair, and condition"): + region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=contrast, + analysis_unit="single_read", + representation=representation, + signal_source=signal_source, + test=test_name, + **evidence_kwargs, + ) + + +@pytest.mark.parametrize( + "representation,table_factory,signal_source,test_name", + [ + ("read_mod_fraction", "read_table", "extract_reads", "sample_distribution_shift"), + ("read_window_features", "feature_table", "extract_features", "feature_summary_shift"), + ], +) +def test_score_regions_single_read_matched_pairwise_rejects_sample_ids_mapped_to_multiple_pairs( + representation, + table_factory, + signal_source, + test_name, +): + contrast = ContrastSpec( + mode="matched_pairwise", + numerator=["after"], + denominator=["before"], + pairing_key="pair_id", + ) + if table_factory == "read_table": + evidence_kwargs = { + "read_table": pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "shared_sample", + "condition": "before", + "read_id": "r1", + "modified_count": 1, + "valid_count": 4, + "read_mod_fraction": 0.25, + "pair_id": "p1", + }, + { + "region_id": "reg1", + "sample_id": "shared_sample", + "condition": "before", + "read_id": "r2", + "modified_count": 2, + "valid_count": 4, + "read_mod_fraction": 0.5, + "pair_id": "p2", + }, + { + "region_id": "reg1", + "sample_id": "s1_after", + "condition": "after", + "read_id": "r3", + "modified_count": 4, + "valid_count": 4, + "read_mod_fraction": 1.0, + "pair_id": "p1", + }, + ] + ) + } + else: + evidence_kwargs = { + "feature_table": pd.DataFrame( + [ + { + "region_id": "reg1", + "sample_id": "shared_sample", + "condition": "before", + "read_id": "r1", + "f0": 0.1, + "pair_id": "p1", + }, + { + "region_id": "reg1", + "sample_id": "shared_sample", + "condition": "before", + "read_id": "r2", + "f0": 0.2, + "pair_id": "p2", + }, + { + "region_id": "reg1", + "sample_id": "s1_after", + "condition": "after", + "read_id": "r3", + "f0": 0.9, + "pair_id": "p1", + }, + ] + ) + } + + with pytest.raises(ValueError, match="sample_id to map to exactly one pairing key"): + region_contrasts.score_regions( + samples=[], + regions=None, + motifs=[], + contrast=contrast, + analysis_unit="single_read", + representation=representation, + signal_source=signal_source, + test=test_name, + **evidence_kwargs, + ) + + def test_score_regions_single_read_window_features_uses_builtin_loader(monkeypatch): extracted_by_path = { "ns.h5": SimpleNamespace( From 8171b44c723dc732b200bc1eb9543ada39bb0843 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 8 Apr 2026 20:08:23 -0700 Subject: [PATCH 195/272] docs: add single-read contrast guide --- README.md | 6 ++++++ docs/region-contrasts.md | 21 +++++++++++++++++++++ 2 files changed, 27 insertions(+) diff --git a/README.md b/README.md index fce4fee..fb6ac08 100644 --- a/README.md +++ b/README.md @@ -241,6 +241,12 @@ For discovery-to-clustering-to-contrast follow-up, use `workflows.discovery_clus `region_contrasts` uses the same data-prep-first plotting layer: `prepare_region_contrast_profile_data(...)` and `prepare_region_contrast_heatmap_data(...)` consume a `RegionContrastResult` plus an explicit positional table, while shared clustering currently keeps lighter plotting coverage through plot-ready tables in `result.plot_data`. +`region_contrasts` also now supports `analysis_unit="single_read"` for +extract-backed defined-region comparison. Use `representation="read_mod_fraction"` +for per-read motif fractions or `representation="read_window_features"` for +feature-vector summaries, with sample-aware summaries rather than pooled-read +inference. + Shared clustering also has renderer-neutral plotting prep in `dimelo.plotting`. Use `prepare_shared_cluster_distribution_data(...)` for sample/condition cluster fractions, `prepare_shared_cluster_profile_data(...)` for cluster feature summaries, and `prepare_shared_cluster_region_data(...)` for region-level occupancy tables. The older lightweight `result.plot_data["cluster_distribution_bar"]` and `result.plot_data["cluster_distribution_heatmap"]` payloads remain supported. For human-readable pileups (bedmethyl files, .bed) and extracted reads (.txt tab-separated values), run with `cleanup=False`. `cleanup=True` will clear these outputs because they can take up a lot of space. diff --git a/docs/region-contrasts.md b/docs/region-contrasts.md index a853237..9806810 100644 --- a/docs/region-contrasts.md +++ b/docs/region-contrasts.md @@ -102,6 +102,27 @@ occupancy_result = region_contrasts.score_regions( ) ``` +## Single-Read Contrasts + +`region_contrasts` now also supports `analysis_unit="single_read"` for +defined-region comparison on extract-backed read data. + +First-version representations: + +- `representation="read_mod_fraction"` with `signal_source="extract_reads"` +- `representation="read_window_features"` with `signal_source="extract_features"` + +Supported contrast modes in v1: + +- `pairwise` +- `group_vs_group` +- `matched_pairwise` + +Important: reads remain observational units, but samples remain the inferential +units. The current single-read paths summarize reads within each `region x sample` +before comparing conditions, and `matched_pairwise` keeps that same boundary while +requiring explicit, non-null pairing metadata and complete pairs only. + ## Canonical Outputs The workflow returns a `RegionContrastResult` with canonical tables: From a9c7b504671dc9f008b5274454b8751626d17518 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 8 Apr 2026 20:09:40 -0700 Subject: [PATCH 196/272] fix: tighten single-read contrast support --- docs/superpowers/README.md | 3 +++ tests/test_workflows.py | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/docs/superpowers/README.md b/docs/superpowers/README.md index 41a1b37..d3c7fe0 100644 --- a/docs/superpowers/README.md +++ b/docs/superpowers/README.md @@ -24,6 +24,7 @@ This directory tracks internal design and implementation work for the current br - [2026-03-31-region-analysis-architecture-design.md](specs/2026-03-31-region-analysis-architecture-design.md) - common architecture for region discovery, global analysis, and contrasts. Status: `partially implemented` - [2026-03-31-pre-plan-decisions-addendum.md](specs/2026-03-31-pre-plan-decisions-addendum.md) - cross-cutting policy decisions for shared clustering and region analysis follow-on work. Status: `partially implemented` - [2026-04-01-paired-region-discovery-design.md](specs/2026-04-01-paired-region-discovery-design.md) - paired discovery support for matched and ordered comparisons. Status: `implemented` +- [2026-04-03-single-read-region-contrasts-design.md](specs/2026-04-03-single-read-region-contrasts-design.md) - first `single_read` contrast family for defined-region read-level summaries. Status: `implemented` ### Plotting @@ -49,6 +50,7 @@ This directory tracks internal design and implementation work for the current br - [2026-03-31-global-analysis-foundations.md](plans/2026-03-31-global-analysis-foundations.md) - global analysis models, workflows, and artifact plumbing. Status: `implemented` - [2026-03-31-region-contrasts-foundations.md](plans/2026-03-31-region-contrasts-foundations.md) - defined-region contrast foundations and scoring paths. Status: `implemented` - [2026-04-01-cluster-occupancy-region-contrasts.md](plans/2026-04-01-cluster-occupancy-region-contrasts.md) - cluster-occupancy evidence and scoring for region contrasts. Status: `implemented` +- [2026-04-03-single-read-region-contrasts.md](plans/2026-04-03-single-read-region-contrasts.md) - `single_read` evidence builders and sample-aware scoring for read-level region contrasts. Status: `implemented` ### Region Discovery @@ -74,6 +76,7 @@ This directory tracks internal design and implementation work for the current br - Shared clustering: start with the shared clustering design spec, then the foundations plan, then the discovery-to-clustering workflows. - Region contrasts: start with the region analysis architecture spec, then the contrasts foundations plan, cluster-occupancy follow-on work, and the region-contrasts plotting plan. +- Single-read contrasts: use the single-read region-contrasts design and plan after the region-contrasts foundations work when you need extract-backed defined-region comparison. - Region discovery: use the region analysis architecture spec, the paired discovery spec, and the discovery workflow plans together. - Global analysis: use the region analysis architecture spec first, then the global analysis foundations plan. - Plotting: start with the plotting-axis spec, then the plotting-axis implementation plan, then the region-contrasts, region-discovery, and global-analysis plotting plans for helper-level coverage. diff --git a/tests/test_workflows.py b/tests/test_workflows.py index dc84256..48c1ef4 100644 --- a/tests/test_workflows.py +++ b/tests/test_workflows.py @@ -706,7 +706,7 @@ def fake_scan_genome(*args, **kwargs): monkeypatch.setattr(workflows.region_discovery, "scan_genome", fake_scan_genome) monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) - with pytest.raises(ValueError, match="analysis_unit='ensemble_region'"): + with pytest.raises(ValueError, match="read_mod_fraction"): workflows.discovery_cluster_contrast_workflow( samples=_workflow_samples(), motifs=["A,0"], From ff6b59b6daaa6086f780d714ca7cdbd4404e6815 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 8 Apr 2026 20:16:38 -0700 Subject: [PATCH 197/272] docs: add matplotlib renderer design spec --- .../2026-04-08-matplotlib-renderers-design.md | 249 ++++++++++++++++++ 1 file changed, 249 insertions(+) create mode 100644 docs/superpowers/specs/2026-04-08-matplotlib-renderers-design.md diff --git a/docs/superpowers/specs/2026-04-08-matplotlib-renderers-design.md b/docs/superpowers/specs/2026-04-08-matplotlib-renderers-design.md new file mode 100644 index 0000000..99be738 --- /dev/null +++ b/docs/superpowers/specs/2026-04-08-matplotlib-renderers-design.md @@ -0,0 +1,249 @@ +# Matplotlib Renderers Design + +## Summary + +Add a first built-in Matplotlib renderer layer on top of the existing renderer-neutral +plot-preparation payloads. + +The goal is to give users a familiar, backward-compatible plotting path without +breaking the data-first architecture that now underpins `region_contrasts`, +`region_discovery`, and `global_analysis`. + +This renderer slice should: + +- keep `dimelo.plotting` as the renderer-neutral prep layer +- add a separate Matplotlib-specific module for figure construction +- support optional file export helpers +- avoid moving biological aggregation logic back into renderer functions + +## Goals + +- Add thin Matplotlib renderers for the most mature plotting payloads. +- Preserve the data-first contract: prep helpers remain the source of truth. +- Provide a simple built-in plotting path for users who prefer Matplotlib. +- Support convenient figure export to image or PDF files. +- Keep the renderer implementation small, explicit, and easy to test. + +## Non-Goals + +- Build a backend plugin/registry system in this slice. +- Add Plotly, Altair, or other non-Matplotlib renderers in this slice. +- Rework the renderer-neutral payload schemas. +- Add new biological summaries or plotting prep behavior just to support rendering. +- Cover every analysis family at once. + +## Why A Separate Matplotlib Module + +The repo now has a clear prep layer in `dimelo.plotting`: + +- prep helpers validate inputs +- prep helpers align coordinates and aggregation semantics +- prep helpers return payload dictionaries/tables + +If Matplotlib rendering is added into the same module, that clean separation will erode +quickly. A separate module keeps responsibilities explicit: + +- `dimelo.plotting`: data prep and renderer-neutral payloads +- `dimelo.plotting_matplotlib`: figure construction and file export + +This also keeps future renderer additions straightforward. + +## First-Version Scope + +The first renderer slice should cover: + +- `region_contrasts` + - profile renderer + - heatmap renderer +- `region_discovery` + - scan renderer + - hit-context renderer +- `global_analysis` + - summary renderer + - window renderer + +It should not yet cover: + +- `shared_clustering` +- full legacy wrapper migration +- new single-read Matplotlib renderers beyond what already exists in legacy plotting modules + +## Public API + +Add a new module: + +- `dimelo.plotting_matplotlib` + +It should expose: + +```python +plot_region_contrast_profile_matplotlib(payload, *, value_mode="delta", ax=None, title=None) +plot_region_contrast_heatmap_matplotlib(payload, *, value_mode="delta", ax=None, title=None) +plot_region_discovery_scan_matplotlib(payload, *, axes=None, title=None) +plot_region_discovery_hit_context_matplotlib(payload, *, axes=None, title=None) +plot_global_analysis_summary_matplotlib(payload, *, level="condition", ax=None, title=None) +plot_global_analysis_window_matplotlib(payload, *, axes=None, title=None) +save_figure(fig, path, *, dpi=300, bbox_inches="tight", transparent=False) +``` + +Exact argument names may vary slightly, but the public contract should stay: + +- renderer takes one prepared payload +- optional Matplotlib axes can be injected +- renderer returns figure/axes +- export helper takes a figure and destination path + +## Renderer Contracts + +### General Rules + +Each renderer should: + +- accept a prepared payload dict from `dimelo.plotting` +- validate only the keys/shapes it needs +- avoid mutating the payload +- avoid recomputing biological summaries already expressed in payload tables +- return `(fig, ax)` or `(fig, axes)` depending on the layout + +Each renderer should not: + +- call `prepare_*` internally from result objects +- infer new biological quantities +- write files automatically + +### Region Contrast Profile Renderer + +Input: + +- payload from `prepare_region_contrast_profile_data(...)` + +Responsibilities: + +- render numerator / denominator / delta views from prepared profile rows +- respect axis labels and metadata from the payload +- support a `value_mode` switch: + - `numerator` + - `denominator` + - `delta` + +The renderer should assume the payload already contains the aligned plot table. + +### Region Contrast Heatmap Renderer + +Input: + +- payload from `prepare_region_contrast_heatmap_data(...)` + +Responsibilities: + +- render a per-region heatmap for one `value_mode` +- preserve region rank order from the payload +- use payload axis metadata for x labels or range annotations where appropriate + +### Region Discovery Scan Renderer + +Input: + +- payload from `prepare_region_discovery_scan_data(...)` + +Responsibilities: + +- render per-contig score tracks by default +- overlay or highlight hits when `hit_table` is non-empty +- keep contigs separated rather than forcing a cumulative pseudo-genome axis + +### Region Discovery Hit-Context Renderer + +Input: + +- payload from `prepare_region_discovery_hit_context_data(...)` + +Responsibilities: + +- render local scored neighborhoods around selected hits +- support small-multiple style layouts by hit + +### Global Analysis Summary Renderer + +Input: + +- payload from `prepare_global_analysis_summary_data(...)` + +Responsibilities: + +- render sample-level or condition-level global summaries +- expose `level="sample"` or `level="condition"` +- optionally show normalization-side quantities from the payload tables + +### Global Analysis Window Renderer + +Input: + +- payload from `prepare_global_analysis_window_data(...)` + +Responsibilities: + +- render per-contig broad-window summaries +- support both sample-level and condition-level window tables where present + +## File Export Helper + +Add: + +```python +save_figure(fig, path, *, dpi=300, bbox_inches="tight", transparent=False) +``` + +Responsibilities: + +- create parent directories if needed +- call `fig.savefig(...)` +- leave closing policy to the caller + +This helper is intentionally thin. It exists for convenience and consistency, not to +become an output manager. + +## Testing Strategy + +Tests should verify: + +- renderer returns Matplotlib figure/axes objects +- renderer handles empty or minimal valid payloads where appropriate +- renderer uses the expected payload table for the selected mode/level +- `save_figure(...)` writes a file successfully + +Tests should not try to enforce pixel-perfect rendering. + +## Documentation Expectations + +User-facing docs should describe the new layer as: + +- optional +- Matplotlib-specific +- built on top of the existing prep payloads + +The docs should preserve the current message: + +- prep helpers are still the canonical interface +- users can still ignore built-in renderers and use their own plotting stack + +## Compatibility + +This slice should be additive: + +- existing payload-prep helpers stay unchanged +- existing legacy Matplotlib plotters remain available +- the new module adds a more coherent built-in rendering surface without removing older paths + +## Implementation Order + +Recommended order: + +1. add `dimelo.plotting_matplotlib` module +2. implement `save_figure(...)` +3. implement region-contrast renderers +4. implement region-discovery renderers +5. implement global-analysis renderers +6. add focused renderer tests +7. update docs and README + From 94f6bce67c098b6f7e58cd0ad740914c9a8e5bbd Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 8 Apr 2026 20:19:23 -0700 Subject: [PATCH 198/272] docs: add matplotlib renderer plan --- .../plans/2026-04-08-matplotlib-renderers.md | 649 ++++++++++++++++++ 1 file changed, 649 insertions(+) create mode 100644 docs/superpowers/plans/2026-04-08-matplotlib-renderers.md diff --git a/docs/superpowers/plans/2026-04-08-matplotlib-renderers.md b/docs/superpowers/plans/2026-04-08-matplotlib-renderers.md new file mode 100644 index 0000000..2570f4f --- /dev/null +++ b/docs/superpowers/plans/2026-04-08-matplotlib-renderers.md @@ -0,0 +1,649 @@ +# Matplotlib Renderers Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Add a first built-in Matplotlib renderer layer and figure export helper on top of the existing renderer-neutral plotting payloads for `region_contrasts`, `region_discovery`, and `global_analysis`. + +**Architecture:** Keep `dimelo.plotting` as the renderer-neutral prep layer and add a new `dimelo.plotting_matplotlib` module that only consumes prepared payloads and returns Matplotlib figure objects. The renderer layer stays thin: no new biological aggregation, no result-to-payload shortcuts, and only small optional export helpers for writing PNG/PDF outputs. + +**Tech Stack:** Python 3.11, matplotlib, pandas, pathlib, pytest, existing `dimelo.plotting`, user docs in `docs/` + +--- + +## File Map + +- Create: `dimelo/plotting_matplotlib.py` + - thin Matplotlib renderers over existing payload dictionaries + - `save_figure(...)` convenience helper +- Modify: `dimelo/__init__.py` + - export `plotting_matplotlib` +- Modify: `tests/test_plotting.py` + - add focused renderer and export coverage +- Modify: `README.md` + - document the optional Matplotlib renderer layer +- Modify: `docs/region-contrasts.md` + - add short renderer example for contrast payloads +- Modify: `docs/region-discovery.md` + - add short renderer example for discovery payloads +- Modify: `docs/global-analysis.md` + - add short renderer example for global-analysis payloads + +## Task 1: Add Failing Tests For The New Matplotlib Module Skeleton + +**Files:** +- Modify: `tests/test_plotting.py` +- Reference: `dimelo/plotting_matplotlib.py` + +- [ ] **Step 1: Write failing tests for module import and `save_figure(...)`** + +Add these tests near the existing plotting coverage in `tests/test_plotting.py`: + +```python +def test_plotting_matplotlib_module_exports_save_figure(): + from dimelo import plotting_matplotlib + + assert hasattr(plotting_matplotlib, "save_figure") + + +def test_save_figure_writes_png(tmp_path): + from matplotlib import pyplot as plt + from dimelo import plotting_matplotlib + + fig, ax = plt.subplots() + ax.plot([0, 1], [0, 1]) + + output_path = tmp_path / "figure.png" + plotting_matplotlib.save_figure(fig, output_path) + + assert output_path.exists() + assert output_path.stat().st_size > 0 +``` + +- [ ] **Step 2: Run the focused tests to verify they fail** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "plotting_matplotlib_module_exports_save_figure or save_figure_writes_png" -q +``` + +Expected: FAIL because `dimelo.plotting_matplotlib` does not yet exist. + +- [ ] **Step 3: Commit the failing tests** + +```bash +git add tests/test_plotting.py +git commit -m "test: add matplotlib renderer export coverage" +``` + +## Task 2: Create `dimelo.plotting_matplotlib` And `save_figure(...)` + +**Files:** +- Create: `dimelo/plotting_matplotlib.py` +- Modify: `dimelo/__init__.py` +- Modify: `tests/test_plotting.py` + +- [ ] **Step 1: Create the new module with a thin export helper** + +Create `dimelo/plotting_matplotlib.py` with: + +```python +from __future__ import annotations + +from pathlib import Path + +import matplotlib.pyplot as plt + + +def save_figure( + fig, + path, + *, + dpi: int = 300, + bbox_inches: str = "tight", + transparent: bool = False, +) -> Path: + output_path = Path(path) + output_path.parent.mkdir(parents=True, exist_ok=True) + fig.savefig( + output_path, + dpi=dpi, + bbox_inches=bbox_inches, + transparent=transparent, + ) + return output_path +``` + +- [ ] **Step 2: Export the new module from the package** + +Update `dimelo/__init__.py` to import and export `plotting_matplotlib`: + +```python +from . import ( + ... + plotting, + plotting_matplotlib, + ... +) + +__all__ = [ + ... + "plotting", + "plotting_matplotlib", + ... +] +``` + +- [ ] **Step 3: Run the focused tests to verify they pass** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "plotting_matplotlib_module_exports_save_figure or save_figure_writes_png" -q +``` + +Expected: PASS. + +- [ ] **Step 4: Commit the module skeleton** + +```bash +git add dimelo/plotting_matplotlib.py dimelo/__init__.py tests/test_plotting.py +git commit -m "feat: add matplotlib renderer module" +``` + +## Task 3: Add Failing Tests For Region Contrast Matplotlib Renderers + +**Files:** +- Modify: `tests/test_plotting.py` +- Reference: `dimelo/plotting.py` +- Reference: `dimelo/plotting_matplotlib.py` + +- [ ] **Step 1: Add failing tests for profile and heatmap renderers** + +Add tests using the existing `prepare_region_contrast_profile_data(...)` and +`prepare_region_contrast_heatmap_data(...)` fixtures/patterns: + +```python +def test_plot_region_contrast_profile_matplotlib_returns_figure_and_axis(): + from dimelo import plotting, plotting_matplotlib + + result = _mock_region_contrast_result_for_plotting() + position_table = _mock_region_contrast_position_table() + payload = plotting.prepare_region_contrast_profile_data( + result=result, + position_table=position_table, + axis=plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=100, + downstream_bp=100, + ), + aggregation=plotting.AggregationSpec(), + ) + + fig, ax = plotting_matplotlib.plot_region_contrast_profile_matplotlib(payload) + + assert fig is not None + assert ax is not None + + +def test_plot_region_contrast_heatmap_matplotlib_returns_figure_and_axis(): + from dimelo import plotting, plotting_matplotlib + + result = _mock_region_contrast_result_for_plotting() + position_table = _mock_region_contrast_position_table() + payload = plotting.prepare_region_contrast_heatmap_data( + result=result, + position_table=position_table, + axis=plotting.AxisSpec( + orientation="region_5to3", + coordinate_mode="fixed_window", + anchor="center", + upstream_bp=100, + downstream_bp=100, + ), + aggregation=plotting.AggregationSpec(), + ) + + fig, ax = plotting_matplotlib.plot_region_contrast_heatmap_matplotlib(payload) + + assert fig is not None + assert ax is not None +``` + +- [ ] **Step 2: Run the focused tests to verify they fail** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "plot_region_contrast_profile_matplotlib or plot_region_contrast_heatmap_matplotlib" -q +``` + +Expected: FAIL because the renderers do not yet exist. + +- [ ] **Step 3: Commit the failing tests** + +```bash +git add tests/test_plotting.py +git commit -m "test: add region contrast matplotlib coverage" +``` + +## Task 4: Implement Region Contrast Matplotlib Renderers + +**Files:** +- Modify: `dimelo/plotting_matplotlib.py` +- Modify: `tests/test_plotting.py` + +- [ ] **Step 1: Add minimal helper utilities for Matplotlib payload validation** + +Add small internal helpers in `dimelo/plotting_matplotlib.py`: + +```python +def _require_payload_keys(payload: dict, keys: tuple[str, ...], *, owner: str) -> None: + missing = [key for key in keys if key not in payload] + if missing: + missing_display = ", ".join(missing) + raise ValueError(f"{owner} requires payload keys: {missing_display}.") + + +def _make_axis(ax=None, *, figsize=(6, 4)): + if ax is not None: + return ax.figure, ax + fig, created_ax = plt.subplots(figsize=figsize) + return fig, created_ax +``` + +- [ ] **Step 2: Implement `plot_region_contrast_profile_matplotlib(...)`** + +Implement a thin line renderer over `payload["plot_table"]`: + +```python +def plot_region_contrast_profile_matplotlib( + payload, + *, + value_mode: str = "delta", + ax=None, + title: str | None = None, +): + _require_payload_keys(payload, ("plot_table", "metadata"), owner="plot_region_contrast_profile_matplotlib") + plot_table = payload["plot_table"] + if value_mode not in {"numerator", "denominator", "delta"}: + raise ValueError("value_mode must be 'numerator', 'denominator', or 'delta'.") + value_column = { + "numerator": "numerator_value", + "denominator": "denominator_value", + "delta": "delta_value", + }[value_mode] + fig, ax = _make_axis(ax=ax) + if not plot_table.empty: + grouped = plot_table.groupby("plot_position", sort=True)[value_column].mean().reset_index() + ax.plot(grouped["plot_position"], grouped[value_column]) + ax.set_xlabel("Position") + ax.set_ylabel(value_mode.replace("_", " ").title()) + if title: + ax.set_title(title) + return fig, ax +``` + +- [ ] **Step 3: Implement `plot_region_contrast_heatmap_matplotlib(...)`** + +Implement a thin heatmap renderer using `imshow`: + +```python +def plot_region_contrast_heatmap_matplotlib( + payload, + *, + value_mode: str = "delta", + ax=None, + title: str | None = None, +): + _require_payload_keys(payload, ("plot_table", "metadata"), owner="plot_region_contrast_heatmap_matplotlib") + plot_table = payload["plot_table"] + if value_mode not in {"numerator", "denominator", "delta"}: + raise ValueError("value_mode must be 'numerator', 'denominator', or 'delta'.") + value_column = { + "numerator": "numerator_value", + "denominator": "denominator_value", + "delta": "delta_value", + }[value_mode] + fig, ax = _make_axis(ax=ax, figsize=(7, 5)) + if not plot_table.empty: + matrix = plot_table.pivot(index="region_id", columns="plot_position", values=value_column) + image = ax.imshow(matrix.to_numpy(), aspect="auto", interpolation="nearest") + fig.colorbar(image, ax=ax) + ax.set_xlabel("Position") + ax.set_ylabel("Region") + if title: + ax.set_title(title) + return fig, ax +``` + +- [ ] **Step 4: Run the focused tests to verify they pass** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "plot_region_contrast_profile_matplotlib or plot_region_contrast_heatmap_matplotlib" -q +``` + +Expected: PASS. + +- [ ] **Step 5: Commit the region-contrast renderers** + +```bash +git add dimelo/plotting_matplotlib.py tests/test_plotting.py +git commit -m "feat: add region contrast matplotlib renderers" +``` + +## Task 5: Add Discovery Renderer Tests And Implementations + +**Files:** +- Modify: `tests/test_plotting.py` +- Modify: `dimelo/plotting_matplotlib.py` + +- [ ] **Step 1: Add failing tests for discovery scan and hit-context renderers** + +Add: + +```python +def test_plot_region_discovery_scan_matplotlib_returns_figure_and_axes(): + from dimelo import plotting, plotting_matplotlib + + payload = plotting.prepare_region_discovery_scan_data(_mock_region_discovery_result()) + fig, axes = plotting_matplotlib.plot_region_discovery_scan_matplotlib(payload) + + assert fig is not None + assert axes is not None + + +def test_plot_region_discovery_hit_context_matplotlib_returns_figure_and_axes(): + from dimelo import plotting, plotting_matplotlib + + payload = plotting.prepare_region_discovery_hit_context_data( + _mock_region_discovery_result(), + top_n=2, + ) + fig, axes = plotting_matplotlib.plot_region_discovery_hit_context_matplotlib(payload) + + assert fig is not None + assert axes is not None +``` + +- [ ] **Step 2: Run the focused discovery renderer tests to verify they fail** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "plot_region_discovery_scan_matplotlib or plot_region_discovery_hit_context_matplotlib" -q +``` + +Expected: FAIL. + +- [ ] **Step 3: Implement the two discovery renderers** + +Add thin per-contig and small-multiple renderers: + +```python +def plot_region_discovery_scan_matplotlib(payload, *, axes=None, title: str | None = None): + _require_payload_keys(payload, ("scan_table", "hit_table", "metadata"), owner="plot_region_discovery_scan_matplotlib") + scan_table = payload["scan_table"] + contigs = payload["metadata"].get("contig_order") or list(scan_table["contig"].dropna().unique()) + if axes is None: + fig, axes = plt.subplots(len(contigs) or 1, 1, figsize=(8, max(3, 2 * max(len(contigs), 1))), squeeze=False) + axes = axes.ravel() + else: + fig = axes[0].figure if isinstance(axes, (list, tuple)) else axes.figure + axes = axes if isinstance(axes, (list, tuple)) else [axes] + for ax, contig in zip(axes, contigs): + contig_table = scan_table.loc[scan_table["contig"] == contig] + ax.plot(contig_table["window_midpoint"], contig_table[payload["metadata"]["score_column"]]) + ax.set_title(str(contig)) + if title: + fig.suptitle(title) + return fig, axes + + +def plot_region_discovery_hit_context_matplotlib(payload, *, axes=None, title: str | None = None): + _require_payload_keys(payload, ("context_table", "selected_hits", "metadata"), owner="plot_region_discovery_hit_context_matplotlib") + context_table = payload["context_table"] + hit_ids = list(context_table["selected_region_id"].dropna().unique()) if not context_table.empty else [] + if axes is None: + fig, axes = plt.subplots(len(hit_ids) or 1, 1, figsize=(8, max(3, 2 * max(len(hit_ids), 1))), squeeze=False) + axes = axes.ravel() + else: + fig = axes[0].figure if isinstance(axes, (list, tuple)) else axes.figure + axes = axes if isinstance(axes, (list, tuple)) else [axes] + score_column = payload["metadata"]["score_column"] + for ax, hit_id in zip(axes, hit_ids): + hit_table = context_table.loc[context_table["selected_region_id"] == hit_id] + ax.plot(hit_table["window_midpoint"], hit_table[score_column]) + ax.set_title(str(hit_id)) + if title: + fig.suptitle(title) + return fig, axes +``` + +- [ ] **Step 4: Run the focused discovery tests to verify they pass** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "plot_region_discovery_scan_matplotlib or plot_region_discovery_hit_context_matplotlib" -q +``` + +Expected: PASS. + +- [ ] **Step 5: Commit the discovery renderers** + +```bash +git add dimelo/plotting_matplotlib.py tests/test_plotting.py +git commit -m "feat: add discovery matplotlib renderers" +``` + +## Task 6: Add Global Analysis Renderer Tests And Implementations + +**Files:** +- Modify: `tests/test_plotting.py` +- Modify: `dimelo/plotting_matplotlib.py` + +- [ ] **Step 1: Add failing tests for summary and window renderers** + +Add: + +```python +def test_plot_global_analysis_summary_matplotlib_returns_figure_and_axis(): + from dimelo import plotting, plotting_matplotlib + + payload = plotting.prepare_global_analysis_summary_data(_mock_global_analysis_result()) + fig, ax = plotting_matplotlib.plot_global_analysis_summary_matplotlib(payload) + + assert fig is not None + assert ax is not None + + +def test_plot_global_analysis_window_matplotlib_returns_figure_and_axes(): + from dimelo import plotting, plotting_matplotlib + + payload = plotting.prepare_global_analysis_window_data(_mock_global_analysis_result()) + fig, axes = plotting_matplotlib.plot_global_analysis_window_matplotlib(payload) + + assert fig is not None + assert axes is not None +``` + +- [ ] **Step 2: Run the focused tests to verify they fail** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "plot_global_analysis_summary_matplotlib or plot_global_analysis_window_matplotlib" -q +``` + +Expected: FAIL. + +- [ ] **Step 3: Implement the two global-analysis renderers** + +Add: + +```python +def plot_global_analysis_summary_matplotlib( + payload, + *, + level: str = "condition", + ax=None, + title: str | None = None, +): + _require_payload_keys(payload, ("sample_summary", "condition_summary", "normalization_table", "metadata"), owner="plot_global_analysis_summary_matplotlib") + if level not in {"sample", "condition"}: + raise ValueError("level must be 'sample' or 'condition'.") + table = payload["sample_summary"] if level == "sample" else payload["condition_summary"] + fig, ax = _make_axis(ax=ax) + if not table.empty: + x_column = "sample_id" if level == "sample" else "condition" + ax.bar(table[x_column].astype(str), table["global_fraction"]) + ax.tick_params(axis="x", rotation=45) + ax.set_ylabel("Global Fraction") + if title: + ax.set_title(title) + return fig, ax + + +def plot_global_analysis_window_matplotlib(payload, *, axes=None, title: str | None = None): + _require_payload_keys(payload, ("window_table", "metadata"), owner="plot_global_analysis_window_matplotlib") + window_table = payload["window_table"] + contigs = payload["metadata"].get("contig_order") or list(window_table["contig"].dropna().unique()) + if axes is None: + fig, axes = plt.subplots(len(contigs) or 1, 1, figsize=(8, max(3, 2 * max(len(contigs), 1))), squeeze=False) + axes = axes.ravel() + else: + fig = axes[0].figure if isinstance(axes, (list, tuple)) else axes.figure + axes = axes if isinstance(axes, (list, tuple)) else [axes] + for ax, contig in zip(axes, contigs): + contig_table = window_table.loc[window_table["contig"] == contig] + ax.plot(contig_table["window_midpoint"], contig_table["window_fraction"]) + ax.set_title(str(contig)) + if title: + fig.suptitle(title) + return fig, axes +``` + +- [ ] **Step 4: Run the focused tests to verify they pass** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "plot_global_analysis_summary_matplotlib or plot_global_analysis_window_matplotlib" -q +``` + +Expected: PASS. + +- [ ] **Step 5: Commit the global-analysis renderers** + +```bash +git add dimelo/plotting_matplotlib.py tests/test_plotting.py +git commit -m "feat: add global analysis matplotlib renderers" +``` + +## Task 7: Add User-Facing Docs For The Renderer Layer + +**Files:** +- Modify: `README.md` +- Modify: `docs/region-contrasts.md` +- Modify: `docs/region-discovery.md` +- Modify: `docs/global-analysis.md` + +- [ ] **Step 1: Add a short README paragraph** + +Add a short note near the plotting/helper overview: + +```md +For users who want built-in figures instead of only payload tables, `dimelo.plotting_matplotlib` +provides thin Matplotlib renderers on top of the prepared payloads plus `save_figure(...)` +for writing PNG/PDF outputs. The payload-prep helpers remain the canonical interface. +``` + +- [ ] **Step 2: Add one short example to each analysis guide** + +Add renderer examples like: + +```python +from dimelo import plotting, plotting_matplotlib + +payload = plotting.prepare_region_discovery_scan_data(result) +fig, axes = plotting_matplotlib.plot_region_discovery_scan_matplotlib(payload) +plotting_matplotlib.save_figure(fig, "discovery-scan.png") +``` + +Repeat the same pattern for: +- `region-contrasts.md` +- `region-discovery.md` +- `global-analysis.md` + +- [ ] **Step 3: Commit the docs** + +```bash +git add README.md docs/region-contrasts.md docs/region-discovery.md docs/global-analysis.md +git commit -m "docs: add matplotlib renderer examples" +``` + +## Task 8: Final Verification + +**Files:** +- Reference: `dimelo/plotting_matplotlib.py` +- Reference: `tests/test_plotting.py` +- Reference: `README.md` +- Reference: `docs/region-contrasts.md` +- Reference: `docs/region-discovery.md` +- Reference: `docs/global-analysis.md` + +- [ ] **Step 1: Run plotting coverage** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl XDG_CACHE_HOME=/tmp/xdg-cache PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -q +``` + +Expected: PASS. + +- [ ] **Step 2: Run workflow regression subset** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl XDG_CACHE_HOME=/tmp/xdg-cache PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_workflows.py -q +``` + +Expected: PASS with no new failures. + +- [ ] **Step 3: Run a clean status check** + +Run: + +```bash +git status --short +``` + +Expected: clean working tree. + +- [ ] **Step 4: Self-review against the spec** + +Check the completed work against `docs/superpowers/specs/2026-04-08-matplotlib-renderers-design.md`: + +- separate `plotting_matplotlib` module added +- prep layer still lives in `dimelo.plotting` +- renderers cover `region_contrasts`, `region_discovery`, and `global_analysis` +- export helper exists +- no new biological prep logic was moved into renderer functions +- docs describe the renderer layer as optional and Matplotlib-specific + +- [ ] **Step 5: Commit any final touch-up if needed** + +```bash +git add dimelo/plotting_matplotlib.py dimelo/__init__.py tests/test_plotting.py README.md docs/region-contrasts.md docs/region-discovery.md docs/global-analysis.md +git commit -m "fix: tighten matplotlib renderer support" +``` + +Only make this commit if verification or self-review uncovers a small follow-up patch. + From e34cc70761951065a72f7fff29dca3eb0dae3860 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 8 Apr 2026 20:22:51 -0700 Subject: [PATCH 199/272] test: add matplotlib renderer export coverage --- tests/test_plotting.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index e785fe7..2046794 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -273,6 +273,26 @@ def test_prepare_shared_cluster_distribution_data_returns_distribution_payload() assert payload["metadata"]["mode"] == "region_anchored" +def test_plotting_matplotlib_module_exports_save_figure(): + from dimelo import plotting_matplotlib + + assert hasattr(plotting_matplotlib, "save_figure") + + +def test_save_figure_writes_png(tmp_path): + from matplotlib import pyplot as plt + from dimelo import plotting_matplotlib + + fig, ax = plt.subplots() + ax.plot([0, 1], [0, 1]) + + output_path = tmp_path / "figure.png" + plotting_matplotlib.save_figure(fig, output_path) + + assert output_path.exists() + assert output_path.stat().st_size > 0 + + def test_prepare_shared_cluster_distribution_data_handles_missing_change_table(): result = _make_shared_cluster_result() result.distribution_change = None From 6977c3c5fd5e95d1d6fb7192ec18cc49f704ce2e Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 8 Apr 2026 20:23:51 -0700 Subject: [PATCH 200/272] feat: add matplotlib renderer module --- dimelo/__init__.py | 2 ++ dimelo/plotting_matplotlib.py | 22 ++++++++++++++++++++++ 2 files changed, 24 insertions(+) create mode 100644 dimelo/plotting_matplotlib.py diff --git a/dimelo/__init__.py b/dimelo/__init__.py index 9f36017..2ec7673 100644 --- a/dimelo/__init__.py +++ b/dimelo/__init__.py @@ -7,6 +7,7 @@ models, parse_bam, plotting, + plotting_matplotlib, plot_depth_histogram, plot_depth_profile, plot_enrichment, @@ -29,6 +30,7 @@ "models", "parse_bam", "plotting", + "plotting_matplotlib", "plot_depth_histogram", "plot_depth_profile", "plot_enrichment", diff --git a/dimelo/plotting_matplotlib.py b/dimelo/plotting_matplotlib.py new file mode 100644 index 0000000..27eab49 --- /dev/null +++ b/dimelo/plotting_matplotlib.py @@ -0,0 +1,22 @@ +from __future__ import annotations + +from pathlib import Path + + +def save_figure( + fig, + path, + *, + dpi: int = 300, + bbox_inches: str = "tight", + transparent: bool = False, +) -> Path: + output_path = Path(path) + output_path.parent.mkdir(parents=True, exist_ok=True) + fig.savefig( + output_path, + dpi=dpi, + bbox_inches=bbox_inches, + transparent=transparent, + ) + return output_path From 71a0b58b45e7d910cab05035c94a95e412805da8 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 8 Apr 2026 20:26:15 -0700 Subject: [PATCH 201/272] test: add region contrast matplotlib coverage --- tests/test_plotting.py | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 2046794..5aee90f 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -1368,6 +1368,26 @@ def test_prepare_region_contrast_profile_data_returns_all_value_modes(): assert payload["metadata"]["plot_family"] == "region_contrast_profile" +def test_plot_region_contrast_profile_matplotlib_returns_figure_and_axis(): + from dimelo import plotting_matplotlib + + result, position_table, axis, aggregation = _region_contrast_plot_setup( + _region_contrast_position_rows() + ) + + payload = plotting.prepare_region_contrast_profile_data( + result=result, + position_table=position_table, + axis=axis, + aggregation=aggregation, + ) + + fig, ax = plotting_matplotlib.plot_region_contrast_profile_matplotlib(payload) + + assert fig is not None + assert ax is not None + + def test_prepare_region_contrast_profile_data_collapses_same_coordinate_labels_within_each_side(): result = _group_vs_group_region_contrast_result() position_table = pd.DataFrame( @@ -1524,6 +1544,26 @@ def test_prepare_region_contrast_heatmap_data_orders_rows_by_rank(): assert payload["metadata"]["plot_family"] == "region_contrast_heatmap" +def test_plot_region_contrast_heatmap_matplotlib_returns_figure_and_axis(): + from dimelo import plotting_matplotlib + + result, position_table, axis, aggregation = _region_contrast_plot_setup( + _region_contrast_position_rows() + ) + + payload = plotting.prepare_region_contrast_heatmap_data( + result=result, + position_table=position_table, + axis=axis, + aggregation=aggregation, + ) + + fig, ax = plotting_matplotlib.plot_region_contrast_heatmap_matplotlib(payload) + + assert fig is not None + assert ax is not None + + def test_prepare_region_contrast_heatmap_data_rejects_conflicting_ranks_for_same_region(): result, position_table, axis, aggregation = _region_contrast_plot_setup( _region_contrast_position_rows() From fa0b32b3b690784edca56a8ec17aabce2061174b Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 8 Apr 2026 20:27:34 -0700 Subject: [PATCH 202/272] feat: add region contrast matplotlib renderers --- dimelo/plotting_matplotlib.py | 108 ++++++++++++++++++++++++++++++++++ 1 file changed, 108 insertions(+) diff --git a/dimelo/plotting_matplotlib.py b/dimelo/plotting_matplotlib.py index 27eab49..8e1d3e5 100644 --- a/dimelo/plotting_matplotlib.py +++ b/dimelo/plotting_matplotlib.py @@ -1,7 +1,10 @@ from __future__ import annotations +from collections.abc import Mapping from pathlib import Path +import pandas as pd + def save_figure( fig, @@ -20,3 +23,108 @@ def save_figure( transparent=transparent, ) return output_path + + +def _require_payload_table(payload: Mapping[str, object], key: str) -> pd.DataFrame: + if key not in payload: + raise ValueError(f"plot payload is missing required key: {key}") + table = payload[key] + if not isinstance(table, pd.DataFrame): + raise TypeError(f"plot payload key {key!r} must be a pandas DataFrame.") + return table + + +def _import_pyplot(): + from matplotlib import pyplot as plt + + return plt + + +def plot_region_contrast_profile_matplotlib(payload: Mapping[str, object]): + plot_table = _require_payload_table(payload, "plot_table") + metadata = payload.get("metadata", {}) if isinstance(payload.get("metadata", {}), Mapping) else {} + + plt = _import_pyplot() + fig, ax = plt.subplots(figsize=(8, 4)) + + if plot_table.empty: + ax.set_title("Region contrast profile") + ax.set_xlabel("position") + ax.set_ylabel("value") + return fig, ax + + x_column = "plot_x" if "plot_x" in plot_table.columns else "position" + y_column = "value" + + if "value_mode" in plot_table.columns: + for value_mode, subset in plot_table.groupby("value_mode", sort=False): + subset = subset.sort_values([x_column, "region_id"], kind="stable") + ax.plot(subset[x_column], subset[y_column], marker="o", linewidth=1.5, label=str(value_mode)) + ax.legend(title="value_mode") + else: + plot_table = plot_table.sort_values([x_column, "region_id"], kind="stable") + ax.plot(plot_table[x_column], plot_table[y_column], marker="o", linewidth=1.5) + + axis_table = payload.get("axis_table") + if isinstance(axis_table, pd.DataFrame) and not axis_table.empty and {"axis_min", "axis_max"}.issubset(axis_table.columns): + ax.set_xlim(axis_table["axis_min"].min(), axis_table["axis_max"].max()) + + ax.set_title("Region contrast profile") + ax.set_xlabel("position" if x_column == "position" else x_column) + ax.set_ylabel("value") + + if metadata.get("orientation") == "region_5to3": + ax.set_xlabel("oriented position") + + return fig, ax + + +def plot_region_contrast_heatmap_matplotlib(payload: Mapping[str, object]): + plot_table = _require_payload_table(payload, "plot_table") + summary_table = _require_payload_table(payload, "summary_table") + + plt = _import_pyplot() + fig, ax = plt.subplots(figsize=(8, 4)) + + if plot_table.empty: + ax.set_title("Region contrast heatmap") + ax.set_xlabel("position") + ax.set_ylabel("region") + return fig, ax + + x_column = "plot_x" if "plot_x" in plot_table.columns else "position" + y_column = "row_order" if "row_order" in plot_table.columns else "region_id" + + heatmap_table = plot_table.loc[:, [x_column, y_column, "value"]].copy() + heatmap = heatmap_table.pivot_table( + index=y_column, + columns=x_column, + values="value", + aggfunc="mean", + ).sort_index(axis=0).sort_index(axis=1) + + image = ax.imshow( + heatmap.to_numpy(), + aspect="auto", + origin="lower", + interpolation="nearest", + ) + ax.figure.colorbar(image, ax=ax, label="value") + + if y_column == "row_order" and "region_id" in summary_table.columns: + summary_lookup = ( + summary_table.loc[:, ["region_id", "row_order"]] + .drop_duplicates() + .sort_values("row_order", kind="stable") + ) + ax.set_yticks(range(len(summary_lookup))) + ax.set_yticklabels(summary_lookup["region_id"].astype(str).tolist()) + else: + ax.set_ylabel("region") + + ax.set_xticks(range(len(heatmap.columns))) + ax.set_xticklabels([str(value) for value in heatmap.columns.tolist()], rotation=45, ha="right") + ax.set_title("Region contrast heatmap") + ax.set_xlabel("position" if x_column == "position" else x_column) + + return fig, ax From 9af4ff6dba6cbc75456f0fa3ab14fcc671b79dfb Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 8 Apr 2026 20:36:55 -0700 Subject: [PATCH 203/272] fix: honor region contrast renderer contracts --- dimelo/plotting_matplotlib.py | 125 +++++++++++++++++++++++++--------- tests/test_plotting.py | 83 ++++++++++++++++++++-- 2 files changed, 172 insertions(+), 36 deletions(-) diff --git a/dimelo/plotting_matplotlib.py b/dimelo/plotting_matplotlib.py index 8e1d3e5..bb39fae 100644 --- a/dimelo/plotting_matplotlib.py +++ b/dimelo/plotting_matplotlib.py @@ -25,6 +25,12 @@ def save_figure( return output_path +def _require_payload_keys(payload: Mapping[str, object], keys: tuple[str, ...], *, owner: str) -> None: + missing = [key for key in keys if key not in payload] + if missing: + raise ValueError(f"{owner} payload is missing required keys: {', '.join(missing)}") + + def _require_payload_table(payload: Mapping[str, object], key: str) -> pd.DataFrame: if key not in payload: raise ValueError(f"plot payload is missing required key: {key}") @@ -40,38 +46,70 @@ def _import_pyplot(): return plt -def plot_region_contrast_profile_matplotlib(payload: Mapping[str, object]): +def _make_axis(*, ax=None, figsize=(8, 4)): + plt = _import_pyplot() + if ax is not None: + return ax.figure, ax + fig, created_ax = plt.subplots(figsize=figsize) + return fig, created_ax + + +def _prepare_region_contrast_value_mode_table( + plot_table: pd.DataFrame, + *, + value_mode: str, +) -> pd.DataFrame: + if value_mode not in {"numerator", "denominator", "delta"}: + raise ValueError("Unsupported region contrast value_mode.") + + if "value_mode" not in plot_table.columns: + return plot_table.copy() + + filtered = plot_table.loc[plot_table["value_mode"] == value_mode].copy() + if filtered.empty: + raise ValueError(f"plot payload does not contain rows for value_mode={value_mode!r}.") + return filtered + + +def plot_region_contrast_profile_matplotlib( + payload: Mapping[str, object], + *, + value_mode: str = "delta", + ax=None, + title: str | None = None, +): + _require_payload_keys( + payload, + ("plot_table", "metadata"), + owner="plot_region_contrast_profile_matplotlib", + ) plot_table = _require_payload_table(payload, "plot_table") metadata = payload.get("metadata", {}) if isinstance(payload.get("metadata", {}), Mapping) else {} + plot_table = _prepare_region_contrast_value_mode_table(plot_table, value_mode=value_mode) - plt = _import_pyplot() - fig, ax = plt.subplots(figsize=(8, 4)) + fig, ax = _make_axis(ax=ax, figsize=(8, 4)) if plot_table.empty: - ax.set_title("Region contrast profile") + ax.set_title(title or "Region contrast profile") ax.set_xlabel("position") - ax.set_ylabel("value") + ax.set_ylabel(value_mode.replace("_", " ").title()) return fig, ax x_column = "plot_x" if "plot_x" in plot_table.columns else "position" - y_column = "value" - - if "value_mode" in plot_table.columns: - for value_mode, subset in plot_table.groupby("value_mode", sort=False): - subset = subset.sort_values([x_column, "region_id"], kind="stable") - ax.plot(subset[x_column], subset[y_column], marker="o", linewidth=1.5, label=str(value_mode)) - ax.legend(title="value_mode") - else: - plot_table = plot_table.sort_values([x_column, "region_id"], kind="stable") - ax.plot(plot_table[x_column], plot_table[y_column], marker="o", linewidth=1.5) + grouped = ( + plot_table.loc[:, [x_column, "value"]] + .groupby(x_column, as_index=False, sort=True) + .mean(numeric_only=True) + ) + ax.plot(grouped[x_column], grouped["value"], marker="o", linewidth=1.5) axis_table = payload.get("axis_table") if isinstance(axis_table, pd.DataFrame) and not axis_table.empty and {"axis_min", "axis_max"}.issubset(axis_table.columns): ax.set_xlim(axis_table["axis_min"].min(), axis_table["axis_max"].max()) - ax.set_title("Region contrast profile") + ax.set_title(title or "Region contrast profile") ax.set_xlabel("position" if x_column == "position" else x_column) - ax.set_ylabel("value") + ax.set_ylabel(value_mode.replace("_", " ").title()) if metadata.get("orientation") == "region_5to3": ax.set_xlabel("oriented position") @@ -79,15 +117,28 @@ def plot_region_contrast_profile_matplotlib(payload: Mapping[str, object]): return fig, ax -def plot_region_contrast_heatmap_matplotlib(payload: Mapping[str, object]): +def plot_region_contrast_heatmap_matplotlib( + payload: Mapping[str, object], + *, + value_mode: str = "delta", + ax=None, + title: str | None = None, +): + _require_payload_keys( + payload, + ("plot_table", "metadata"), + owner="plot_region_contrast_heatmap_matplotlib", + ) plot_table = _require_payload_table(payload, "plot_table") - summary_table = _require_payload_table(payload, "summary_table") + summary_table = payload.get("summary_table") + if summary_table is not None and not isinstance(summary_table, pd.DataFrame): + raise TypeError("plot payload key 'summary_table' must be a pandas DataFrame.") + plot_table = _prepare_region_contrast_value_mode_table(plot_table, value_mode=value_mode) - plt = _import_pyplot() - fig, ax = plt.subplots(figsize=(8, 4)) + fig, ax = _make_axis(ax=ax, figsize=(8, 4)) if plot_table.empty: - ax.set_title("Region contrast heatmap") + ax.set_title(title or "Region contrast heatmap") ax.set_xlabel("position") ax.set_ylabel("region") return fig, ax @@ -111,20 +162,32 @@ def plot_region_contrast_heatmap_matplotlib(payload: Mapping[str, object]): ) ax.figure.colorbar(image, ax=ax, label="value") - if y_column == "row_order" and "region_id" in summary_table.columns: - summary_lookup = ( - summary_table.loc[:, ["region_id", "row_order"]] - .drop_duplicates() - .sort_values("row_order", kind="stable") - ) - ax.set_yticks(range(len(summary_lookup))) - ax.set_yticklabels(summary_lookup["region_id"].astype(str).tolist()) + if y_column == "row_order": + if isinstance(summary_table, pd.DataFrame) and {"region_id", "row_order"}.issubset(summary_table.columns): + summary_lookup = ( + summary_table.loc[:, ["region_id", "row_order"]] + .drop_duplicates() + .sort_values("row_order", kind="stable") + ) + elif "region_id" in plot_table.columns: + summary_lookup = ( + plot_table.loc[:, ["region_id", "row_order"]] + .drop_duplicates() + .sort_values("row_order", kind="stable") + ) + else: + summary_lookup = None + if summary_lookup is not None: + ax.set_yticks(range(len(summary_lookup))) + ax.set_yticklabels(summary_lookup["region_id"].astype(str).tolist()) + else: + ax.set_ylabel("region") else: ax.set_ylabel("region") ax.set_xticks(range(len(heatmap.columns))) ax.set_xticklabels([str(value) for value in heatmap.columns.tolist()], rotation=45, ha="right") - ax.set_title("Region contrast heatmap") + ax.set_title(title or "Region contrast heatmap") ax.set_xlabel("position" if x_column == "position" else x_column) return fig, ax diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 5aee90f..7d00a01 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -1368,8 +1368,9 @@ def test_prepare_region_contrast_profile_data_returns_all_value_modes(): assert payload["metadata"]["plot_family"] == "region_contrast_profile" -def test_plot_region_contrast_profile_matplotlib_returns_figure_and_axis(): +def test_plot_region_contrast_profile_matplotlib_defaults_to_delta_and_honors_ax_title(): from dimelo import plotting_matplotlib + from matplotlib import pyplot as plt result, position_table, axis, aggregation = _region_contrast_plot_setup( _region_contrast_position_rows() @@ -1380,12 +1381,31 @@ def test_plot_region_contrast_profile_matplotlib_returns_figure_and_axis(): position_table=position_table, axis=axis, aggregation=aggregation, + value_mode="all", ) - fig, ax = plotting_matplotlib.plot_region_contrast_profile_matplotlib(payload) + x_column = "plot_x" if "plot_x" in payload["plot_table"].columns else "position" + expected = ( + payload["plot_table"] + .loc[lambda table: table["value_mode"] == "delta", [x_column, "value"]] + .groupby(x_column, as_index=False, sort=True) + .mean(numeric_only=True) + ) - assert fig is not None - assert ax is not None + fig, provided_ax = plt.subplots() + fig, ax = plotting_matplotlib.plot_region_contrast_profile_matplotlib( + payload, + ax=provided_ax, + title="Custom region contrast profile", + ) + + assert fig is provided_ax.figure + assert ax is provided_ax + assert ax.get_title() == "Custom region contrast profile" + assert len(ax.lines) == 1 + np.testing.assert_allclose(np.asarray(ax.lines[0].get_xdata()), expected[x_column].to_numpy()) + np.testing.assert_allclose(np.asarray(ax.lines[0].get_ydata()), expected["value"].to_numpy()) + plt.close(fig) def test_prepare_region_contrast_profile_data_collapses_same_coordinate_labels_within_each_side(): @@ -1544,8 +1564,50 @@ def test_prepare_region_contrast_heatmap_data_orders_rows_by_rank(): assert payload["metadata"]["plot_family"] == "region_contrast_heatmap" -def test_plot_region_contrast_heatmap_matplotlib_returns_figure_and_axis(): +def test_plot_region_contrast_heatmap_matplotlib_defaults_to_delta_and_honors_ax_title(): + from dimelo import plotting_matplotlib + from matplotlib import pyplot as plt + + result, position_table, axis, aggregation = _region_contrast_plot_setup( + _region_contrast_position_rows() + ) + + payload = plotting.prepare_region_contrast_heatmap_data( + result=result, + position_table=position_table, + axis=axis, + aggregation=aggregation, + value_mode="all", + ) + + x_column = "plot_x" if "plot_x" in payload["plot_table"].columns else "position" + expected = ( + payload["plot_table"] + .loc[lambda table: table["value_mode"] == "delta", [x_column, "row_order", "value"]] + .pivot_table(index="row_order", columns=x_column, values="value", aggfunc="mean") + .sort_index(axis=0) + .sort_index(axis=1) + .to_numpy() + ) + + fig, provided_ax = plt.subplots() + fig, ax = plotting_matplotlib.plot_region_contrast_heatmap_matplotlib( + payload, + ax=provided_ax, + title="Custom region contrast heatmap", + ) + + assert fig is provided_ax.figure + assert ax is provided_ax + assert ax.get_title() == "Custom region contrast heatmap" + assert len(ax.images) == 1 + np.testing.assert_allclose(np.asarray(ax.images[0].get_array()), expected) + plt.close(fig) + + +def test_plot_region_contrast_heatmap_matplotlib_accepts_minimal_payload_without_summary_table(): from dimelo import plotting_matplotlib + from matplotlib import pyplot as plt result, position_table, axis, aggregation = _region_contrast_plot_setup( _region_contrast_position_rows() @@ -1556,12 +1618,23 @@ def test_plot_region_contrast_heatmap_matplotlib_returns_figure_and_axis(): position_table=position_table, axis=axis, aggregation=aggregation, + value_mode="all", ) + payload = { + "plot_table": payload["plot_table"].copy(), + "metadata": dict(payload["metadata"]), + } fig, ax = plotting_matplotlib.plot_region_contrast_heatmap_matplotlib(payload) assert fig is not None assert ax is not None + assert len(ax.images) == 1 + assert [tick.get_text() for tick in ax.get_yticklabels()] == [ + "chr1:190-210,-", + "chr1:90-110,+", + ] + plt.close(fig) def test_prepare_region_contrast_heatmap_data_rejects_conflicting_ranks_for_same_region(): From 5fcee1241122f317dfa79d7178bd0ec44c601267 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 8 Apr 2026 20:39:09 -0700 Subject: [PATCH 204/272] test: add region discovery and global analysis matplotlib coverage --- tests/test_plotting.py | 47 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 7d00a01..317faf7 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -1082,6 +1082,31 @@ def test_prepare_region_discovery_hit_context_data_returns_empty_payload_for_no_ assert payload["metadata"]["selection_mode"] == "top_n" +def test_plot_region_discovery_scan_matplotlib_returns_figure_and_axes(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_region_discovery_scan_data(result=_make_region_discovery_result()) + + fig, axes = plotting_matplotlib.plot_region_discovery_scan_matplotlib(payload) + + assert fig is not None + assert axes is not None + + +def test_plot_region_discovery_hit_context_matplotlib_returns_figure_and_axes(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_region_discovery_hit_context_data( + result=_make_region_discovery_result(), + top_n=2, + ) + + fig, axes = plotting_matplotlib.plot_region_discovery_hit_context_matplotlib(payload) + + assert fig is not None + assert axes is not None + + def test_prepare_global_analysis_summary_data_returns_expected_tables(): result = _make_global_analysis_result() @@ -1135,6 +1160,17 @@ def test_prepare_global_analysis_summary_data_skips_condition_aggregation_when_d assert payload["metadata"]["aggregate_conditions"] is False +def test_plot_global_analysis_summary_matplotlib_returns_figure_and_axis(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_global_analysis_summary_data(result=_make_global_analysis_result()) + + fig, ax = plotting_matplotlib.plot_global_analysis_summary_matplotlib(payload) + + assert fig is not None + assert ax is not None + + def test_prepare_global_analysis_window_data_returns_expected_tables(): result = _make_global_window_result() @@ -1147,6 +1183,17 @@ def test_prepare_global_analysis_window_data_returns_expected_tables(): assert payload["metadata"]["contig_order"] == ["chr1", "chr2"] +def test_plot_global_analysis_window_matplotlib_returns_figure_and_axes(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_global_analysis_window_data(result=_make_global_window_result()) + + fig, axes = plotting_matplotlib.plot_global_analysis_window_matplotlib(payload) + + assert fig is not None + assert axes is not None + + def test_prepare_global_analysis_window_data_filters_contigs_in_requested_order(): result = _make_global_window_result() From b57d483ccbdc7aba5f9aac0ca2fc67020ad05797 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 8 Apr 2026 20:41:12 -0700 Subject: [PATCH 205/272] feat: add matplotlib discovery and global renderers --- dimelo/plotting_matplotlib.py | 211 ++++++++++++++++++++++++++++++++++ 1 file changed, 211 insertions(+) diff --git a/dimelo/plotting_matplotlib.py b/dimelo/plotting_matplotlib.py index bb39fae..a5d33ed 100644 --- a/dimelo/plotting_matplotlib.py +++ b/dimelo/plotting_matplotlib.py @@ -54,6 +54,30 @@ def _make_axis(*, ax=None, figsize=(8, 4)): return fig, created_ax +def _make_axes(*, axes=None, n_axes: int, figsize=(8, 4)): + plt = _import_pyplot() + n_axes = max(int(n_axes), 1) + if axes is not None: + if isinstance(axes, (list, tuple)): + normalized_axes = list(axes) + else: + try: + normalized_axes = list(axes.ravel()) + except AttributeError: + normalized_axes = [axes] + if not normalized_axes: + raise ValueError("axes must contain at least one Matplotlib axis.") + return normalized_axes[0].figure, normalized_axes + + fig, created_axes = plt.subplots( + n_axes, + 1, + figsize=(figsize[0], max(figsize[1], 2.5 * n_axes)), + squeeze=False, + ) + return fig, list(created_axes.ravel()) + + def _prepare_region_contrast_value_mode_table( plot_table: pd.DataFrame, *, @@ -191,3 +215,190 @@ def plot_region_contrast_heatmap_matplotlib( ax.set_xlabel("position" if x_column == "position" else x_column) return fig, ax + + +def plot_region_discovery_scan_matplotlib( + payload: Mapping[str, object], + *, + axes=None, + title: str | None = None, +): + _require_payload_keys( + payload, + ("scan_table", "hit_table", "metadata"), + owner="plot_region_discovery_scan_matplotlib", + ) + scan_table = _require_payload_table(payload, "scan_table") + hit_table = _require_payload_table(payload, "hit_table") + metadata = payload.get("metadata", {}) if isinstance(payload.get("metadata", {}), Mapping) else {} + score_column = str(metadata.get("score_column") or "score_value") + contigs = list(metadata.get("contig_order") or scan_table.get("contig", pd.Series(dtype="object")).dropna().unique()) + + fig, axes = _make_axes(axes=axes, n_axes=len(contigs) or 1, figsize=(8, 3)) + + if not contigs: + axes[0].set_title(title or "Region discovery scan") + axes[0].set_xlabel("Window midpoint") + axes[0].set_ylabel(score_column.replace("_", " ").title()) + return fig, axes + + for index, contig in enumerate(contigs): + ax = axes[index] + contig_table = scan_table.loc[scan_table["contig"] == contig] + if not contig_table.empty: + ax.plot( + contig_table["window_midpoint"], + contig_table[score_column], + marker="o", + linewidth=1.5, + ) + contig_hits = hit_table.loc[hit_table["contig"] == contig] if not hit_table.empty else hit_table + if not contig_hits.empty and {"start", "end"}.issubset(contig_hits.columns): + for _, hit in contig_hits.iterrows(): + ax.axvspan(float(hit["start"]), float(hit["end"]), color="tab:red", alpha=0.15) + ax.set_title(str(contig)) + ax.set_xlabel("Window midpoint") + ax.set_ylabel(score_column.replace("_", " ").title()) + + for ax in axes[len(contigs):]: + ax.set_visible(False) + + if title: + fig.suptitle(title) + return fig, axes + + +def plot_region_discovery_hit_context_matplotlib( + payload: Mapping[str, object], + *, + axes=None, + title: str | None = None, +): + _require_payload_keys( + payload, + ("context_table", "selected_hits", "metadata"), + owner="plot_region_discovery_hit_context_matplotlib", + ) + context_table = _require_payload_table(payload, "context_table") + selected_hits = _require_payload_table(payload, "selected_hits") + metadata = payload.get("metadata", {}) if isinstance(payload.get("metadata", {}), Mapping) else {} + score_column = str(metadata.get("score_column") or "score_value") + hit_ids = list( + selected_hits.get("window_id", pd.Series(dtype="object")).dropna().astype(str).tolist() + ) + + fig, axes = _make_axes(axes=axes, n_axes=len(hit_ids) or 1, figsize=(8, 3)) + + if not hit_ids: + axes[0].set_title(title or "Region discovery hit context") + axes[0].set_xlabel("Window midpoint") + axes[0].set_ylabel(score_column.replace("_", " ").title()) + return fig, axes + + for index, hit_id in enumerate(hit_ids): + ax = axes[index] + hit_context = context_table.loc[context_table["selected_hit_id"].astype(str) == hit_id] + if not hit_context.empty: + ax.plot( + hit_context["window_midpoint"], + hit_context[score_column], + marker="o", + linewidth=1.5, + ) + selected_rows = hit_context.loc[hit_context["is_selected_hit"]] + if not selected_rows.empty: + ax.scatter( + selected_rows["window_midpoint"], + selected_rows[score_column], + color="tab:red", + zorder=3, + ) + ax.set_title(hit_id) + ax.set_xlabel("Window midpoint") + ax.set_ylabel(score_column.replace("_", " ").title()) + + for ax in axes[len(hit_ids):]: + ax.set_visible(False) + + if title: + fig.suptitle(title) + return fig, axes + + +def plot_global_analysis_summary_matplotlib( + payload: Mapping[str, object], + *, + level: str = "condition", + ax=None, + title: str | None = None, +): + _require_payload_keys( + payload, + ("sample_summary", "condition_summary", "normalization_table", "metadata"), + owner="plot_global_analysis_summary_matplotlib", + ) + if level not in {"sample", "condition"}: + raise ValueError("level must be 'sample' or 'condition'.") + + table = _require_payload_table(payload, "sample_summary" if level == "sample" else "condition_summary") + fig, ax = _make_axis(ax=ax, figsize=(8, 4)) + + if not table.empty: + if level == "sample": + x_values = table["sample_id"].astype(str) + y_values = table["global_fraction"] + else: + x_values = table["condition"].astype(str) + y_values = table["global_fraction_mean"] + ax.bar(x_values, y_values) + ax.tick_params(axis="x", rotation=45) + + ax.set_ylabel("Global Fraction") + ax.set_xlabel("Sample" if level == "sample" else "Condition") + ax.set_title(title or "Global analysis summary") + return fig, ax + + +def plot_global_analysis_window_matplotlib( + payload: Mapping[str, object], + *, + axes=None, + title: str | None = None, +): + _require_payload_keys( + payload, + ("window_table", "metadata"), + owner="plot_global_analysis_window_matplotlib", + ) + window_table = _require_payload_table(payload, "window_table") + metadata = payload.get("metadata", {}) if isinstance(payload.get("metadata", {}), Mapping) else {} + contigs = list(metadata.get("contig_order") or window_table.get("contig", pd.Series(dtype="object")).dropna().unique()) + + fig, axes = _make_axes(axes=axes, n_axes=len(contigs) or 1, figsize=(8, 3)) + + if not contigs: + axes[0].set_title(title or "Global analysis window") + axes[0].set_xlabel("Window midpoint") + axes[0].set_ylabel("Window Fraction") + return fig, axes + + for index, contig in enumerate(contigs): + ax = axes[index] + contig_table = window_table.loc[window_table["contig"] == contig] + if not contig_table.empty: + grouped = ( + contig_table.loc[:, ["window_midpoint", "window_fraction"]] + .groupby("window_midpoint", as_index=False, sort=True) + .mean(numeric_only=True) + ) + ax.plot(grouped["window_midpoint"], grouped["window_fraction"], marker="o", linewidth=1.5) + ax.set_title(str(contig)) + ax.set_xlabel("Window midpoint") + ax.set_ylabel("Window Fraction") + + for ax in axes[len(contigs):]: + ax.set_visible(False) + + if title: + fig.suptitle(title) + return fig, axes From a86d30c9563d7652a0e3b15e4d4e35a3111fbcdd Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 8 Apr 2026 20:44:16 -0700 Subject: [PATCH 206/272] docs: add matplotlib renderer guide examples --- README.md | 2 ++ docs/global-analysis.md | 9 +++++++++ docs/region-contrasts.md | 12 ++++++++++++ docs/region-discovery.md | 9 +++++++++ 4 files changed, 32 insertions(+) diff --git a/README.md b/README.md index fb6ac08..46799f3 100644 --- a/README.md +++ b/README.md @@ -241,6 +241,8 @@ For discovery-to-clustering-to-contrast follow-up, use `workflows.discovery_clus `region_contrasts` uses the same data-prep-first plotting layer: `prepare_region_contrast_profile_data(...)` and `prepare_region_contrast_heatmap_data(...)` consume a `RegionContrastResult` plus an explicit positional table, while shared clustering currently keeps lighter plotting coverage through plot-ready tables in `result.plot_data`. +For users who want built-in figures instead of only payload tables, `dimelo.plotting_matplotlib` provides an optional Matplotlib renderer layer on top of those prepared payloads, plus `save_figure(...)` for PNG/PDF export. + `region_contrasts` also now supports `analysis_unit="single_read"` for extract-backed defined-region comparison. Use `representation="read_mod_fraction"` for per-read motif fractions or `representation="read_window_features"` for diff --git a/docs/global-analysis.md b/docs/global-analysis.md index 6f30ea1..756dcb2 100644 --- a/docs/global-analysis.md +++ b/docs/global-analysis.md @@ -60,6 +60,15 @@ window_payload = plotting.prepare_global_analysis_window_data( ) ``` +If you want a built-in Matplotlib figure after preparing the payload, pass it through `dimelo.plotting_matplotlib`: + +```python +from dimelo import plotting_matplotlib + +fig, ax = plotting_matplotlib.plot_global_analysis_summary_matplotlib(summary_payload) +plotting_matplotlib.save_figure(fig, "global-analysis-summary.png") +``` + - `prepare_global_analysis_summary_data(...)` consumes a `GlobalAnalysisResult` and returns renderer-neutral `sample_summary`, `condition_summary`, `normalization_table`, and `metadata` payloads. The summary payload exposes both sample-level rows and optional condition-level views, while normalization values stay available through `normalization_table`. - `prepare_global_analysis_window_data(...)` consumes the same `GlobalAnalysisResult` and returns renderer-neutral `window_table`, `condition_window_table`, and `metadata` payloads. Broad-window payloads stay per-contig by default rather than flattening onto a cumulative genome axis. diff --git a/docs/region-contrasts.md b/docs/region-contrasts.md index 9806810..ab0789a 100644 --- a/docs/region-contrasts.md +++ b/docs/region-contrasts.md @@ -228,6 +228,18 @@ heatmap_payload = plotting.prepare_region_contrast_heatmap_data( ) ``` +If you want a built-in Matplotlib figure after preparing the payload, pass it through `dimelo.plotting_matplotlib`: + +```python +from dimelo import plotting_matplotlib + +fig, ax = plotting_matplotlib.plot_region_contrast_profile_matplotlib( + profile_payload, + value_mode="delta", +) +plotting_matplotlib.save_figure(fig, "region-contrast-profile.png") +``` + `position_table` must already be an aggregated positional substrate from the parsing/loading layer, not raw per-read events. The current helper contract expects at minimum: - `region_id` diff --git a/docs/region-discovery.md b/docs/region-discovery.md index 47a73b2..cd439b7 100644 --- a/docs/region-discovery.md +++ b/docs/region-discovery.md @@ -82,6 +82,15 @@ context_payload = plotting.prepare_region_discovery_hit_context_data( ) ``` +If you want a built-in Matplotlib figure after preparing the payload, pass it through `dimelo.plotting_matplotlib`: + +```python +from dimelo import plotting_matplotlib + +fig, axes = plotting_matplotlib.plot_region_discovery_scan_matplotlib(scan_payload) +plotting_matplotlib.save_figure(fig, "region-discovery-scan.png") +``` + - `prepare_region_discovery_scan_data(...)` consumes a `RegionDiscoveryResult` and returns renderer-neutral `scan_table`, `hit_table`, and `metadata` payloads. Scan payloads stay per-contig by default rather than projecting windows onto a cumulative genome axis. - `prepare_region_discovery_hit_context_data(...)` consumes the same `RegionDiscoveryResult` and returns renderer-neutral `context_table`, `selected_hits`, and `metadata` payloads for small-multiple or local hit-context views. From 3e140dc4bf3b592af298d3182b0735356a37c73a Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Fri, 10 Apr 2026 13:18:35 -0700 Subject: [PATCH 207/272] docs: add shared clustering matplotlib renderer spec --- ...-clustering-matplotlib-renderers-design.md | 201 ++++++++++++++++++ 1 file changed, 201 insertions(+) create mode 100644 docs/superpowers/specs/2026-04-10-shared-clustering-matplotlib-renderers-design.md diff --git a/docs/superpowers/specs/2026-04-10-shared-clustering-matplotlib-renderers-design.md b/docs/superpowers/specs/2026-04-10-shared-clustering-matplotlib-renderers-design.md new file mode 100644 index 0000000..3b6688b --- /dev/null +++ b/docs/superpowers/specs/2026-04-10-shared-clustering-matplotlib-renderers-design.md @@ -0,0 +1,201 @@ +# Shared Clustering Matplotlib Renderers Design + +## Summary + +Add a `shared_clustering` Matplotlib renderer slice on top of the existing +renderer-neutral payloads in `dimelo.plotting`. + +The goal is to close the built-in renderer gap that remains after the first +Matplotlib slice landed for: + +- `region_contrasts` +- `region_discovery` +- `global_analysis` + +This slice should keep the same architecture: + +- `dimelo.plotting` remains the source of truth for payload preparation +- `dimelo.plotting_matplotlib` remains a thin figure-construction layer +- only small prep-layer adjustments are allowed when current payloads are + awkward to render cleanly + +## Goals + +- Add built-in Matplotlib renderers for the three main `shared_clustering` + plotting families: + - distribution/change + - cluster profiles + - region occupancy +- Keep the renderer layer thin and payload-driven. +- Preserve compatibility with the existing lightweight `result.plot_data` + tables. +- Make condition-level occupancy the default visual story while preserving + sample-level detail in the payload and renderer options. + +## Non-Goals + +- Add new clustering outputs or new clustering algorithms. +- Add new occupancy metrics or new feature extraction logic. +- Rework `SharedClusterResult` semantics. +- Replace the renderer-neutral prep helpers. +- Add non-Matplotlib backends in this slice. + +## Why This Slice Now + +`shared_clustering` now has the renderer-neutral prep layer that the other +analysis families already use: + +- `prepare_shared_cluster_distribution_data(...)` +- `prepare_shared_cluster_profile_data(...)` +- `prepare_shared_cluster_region_data(...)` + +What it does not yet have is the same built-in plotting path that now exists +for the other major result objects. That makes it the most obvious plotting +consistency gap in the repo. + +## Public API + +Add these functions to `dimelo.plotting_matplotlib`: + +```python +plot_shared_cluster_distribution_matplotlib(payload, *, level="condition", ax=None, title=None) +plot_shared_cluster_change_matplotlib(payload, *, ax=None, title=None) +plot_shared_cluster_profile_heatmap_matplotlib(payload, *, ax=None, title=None) +plot_shared_cluster_profile_series_matplotlib(payload, *, ax=None, title=None) +plot_shared_cluster_region_matplotlib(payload, *, level="condition", ax=None, title=None) +``` + +Public contract: + +- renderer takes one prepared payload +- optional Matplotlib axis can be injected +- renderer returns `(fig, ax)` +- renderers do not mutate payloads +- renderers do not recompute clustering results + +## Renderer Families + +### Distribution Renderer + +Input: + +- payload from `prepare_shared_cluster_distribution_data(...)` + +Responsibilities: + +- render sample-level or condition-level cluster fractions +- default to `level="condition"` +- use condition/sample labels from the prepared payload + +This renderer should expose the current cluster-distribution story in a built-in +bar-like form without changing the payload contract. + +### Change Renderer + +Input: + +- payload from `prepare_shared_cluster_distribution_data(...)` + +Responsibilities: + +- render `distribution_change` as a cluster-by-condition-change heatmap or + equivalent matrix-style view +- preserve stable cluster ordering from the payload + +This should give users an immediate built-in view of condition-level occupancy +shifts. + +### Profile Heatmap Renderer + +Input: + +- payload from `prepare_shared_cluster_profile_data(...)` + +Responsibilities: + +- render cluster-by-feature summaries as a heatmap +- act as the default first-class profile view +- preserve cluster and feature ordering from the payload + +This is the best default because profile tables are naturally matrix-shaped and +scale better than many overlaid series. + +### Profile Series Renderer + +Input: + +- payload from `prepare_shared_cluster_profile_data(...)` + +Responsibilities: + +- render a simple per-cluster profile series across features +- serve as the lighter alternate view for small feature sets + +This renderer should stay simple and not attempt to solve every profile layout. + +### Region Occupancy Renderer + +Input: + +- payload from `prepare_shared_cluster_region_data(...)` + +Responsibilities: + +- default to `level="condition"` +- render condition-aggregated region occupancy as a heatmap +- support `level="sample"` to render the sample-level region table instead + +This preserves the recommended interpretation split: + +- default figure tells the condition-level biological story +- sample-level occupancy remains available for replicate inspection and QC + +## Allowed Prep-Layer Adjustments + +Small prep changes are allowed only if rendering exposes a real payload friction. +Examples of acceptable changes: + +- explicit metadata for default sort or label order +- stable ordering columns that are already implicit in the payload +- a small long-to-wide convenience field when it prevents renderer-side data + reshaping from becoming too opaque + +Not acceptable: + +- new clustering outputs +- new summary statistics +- new biological interpretation layers + +## Testing Strategy + +Tests should verify: + +- each renderer returns Matplotlib figure/axis objects +- each renderer consumes the expected payload family +- default level selection behaves as intended +- simple sample/condition switching works where supported +- empty or minimal valid payloads are handled where the prep layer allows them + +Tests should not try to enforce pixel-perfect output. + +## Documentation Expectations + +User-facing docs should describe these renderers as: + +- optional built-in Matplotlib views on top of prepared clustering payloads +- consistent with the earlier Matplotlib renderer slice +- complementary to the older lightweight `result.plot_data` tables, not a + replacement for them + +## Recommendation + +Implement this as one bounded slice: + +1. add failing renderer tests +2. allow only narrowly justified prep tweaks if the payloads are awkward +3. add the five renderers above +4. document the new built-in views in `docs/shared-clustering.md` and + `README.md` + +This keeps the plotting architecture coherent while filling the last major +built-in renderer gap among the current high-level analysis families. From 2d28a1b6a9e7c634ba5560943247e33cb09d0541 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Fri, 10 Apr 2026 13:20:29 -0700 Subject: [PATCH 208/272] docs: add shared clustering renderer plan --- ...-shared-clustering-matplotlib-renderers.md | 637 ++++++++++++++++++ 1 file changed, 637 insertions(+) create mode 100644 docs/superpowers/plans/2026-04-10-shared-clustering-matplotlib-renderers.md diff --git a/docs/superpowers/plans/2026-04-10-shared-clustering-matplotlib-renderers.md b/docs/superpowers/plans/2026-04-10-shared-clustering-matplotlib-renderers.md new file mode 100644 index 0000000..0859b0b --- /dev/null +++ b/docs/superpowers/plans/2026-04-10-shared-clustering-matplotlib-renderers.md @@ -0,0 +1,637 @@ +# Shared Clustering Matplotlib Renderers Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Add built-in Matplotlib renderers for `shared_clustering` distribution/change, cluster profiles, and region occupancy on top of the existing renderer-neutral payloads. + +**Architecture:** Keep `dimelo.plotting` as the source of truth for clustering plot payloads and extend `dimelo.plotting_matplotlib` with thin renderers that only consume prepared tables. Allow only narrowly scoped prep-layer adjustments if current payloads are awkward to render cleanly; do not add new clustering outputs or new analysis behavior. + +**Tech Stack:** Python 3.11, matplotlib, pandas, pytest, existing `dimelo.plotting`, existing `dimelo.plotting_matplotlib`, user docs in `docs/` + +--- + +## File Map + +- Modify: `dimelo/plotting_matplotlib.py` + - add the five `shared_clustering` Matplotlib renderers + - reuse existing axis/payload helpers where possible +- Modify: `dimelo/plotting.py` + - only if a small payload-shape tweak is needed for renderability +- Modify: `tests/test_plotting.py` + - add focused renderer coverage for the new functions +- Modify: `README.md` + - document the optional shared-clustering Matplotlib renderer layer +- Modify: `docs/shared-clustering.md` + - add short renderer examples and clarify default condition-level occupancy view + +## Task 1: Add Failing Tests For Shared-Cluster Distribution And Change Renderers + +**Files:** +- Modify: `tests/test_plotting.py` +- Reference: `dimelo/plotting.py` +- Reference: `dimelo/plotting_matplotlib.py` + +- [ ] **Step 1: Write failing tests for distribution and change renderers** + +Add tests near the existing `prepare_shared_cluster_distribution_data(...)` coverage: + +```python +def test_plot_shared_cluster_distribution_matplotlib_returns_figure_and_axis(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_distribution_data( + result=_make_shared_cluster_result() + ) + + fig, ax = plotting_matplotlib.plot_shared_cluster_distribution_matplotlib(payload) + + assert fig is not None + assert ax is not None + + +def test_plot_shared_cluster_change_matplotlib_returns_figure_and_axis(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_distribution_data( + result=_make_shared_cluster_result() + ) + + fig, ax = plotting_matplotlib.plot_shared_cluster_change_matplotlib(payload) + + assert fig is not None + assert ax is not None +``` + +- [ ] **Step 2: Run the focused tests to verify they fail** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "plot_shared_cluster_distribution_matplotlib or plot_shared_cluster_change_matplotlib" -q +``` + +Expected: FAIL because the two renderer functions do not yet exist. + +- [ ] **Step 3: Commit the failing tests** + +```bash +git add tests/test_plotting.py +git commit -m "test: add shared clustering distribution renderer coverage" +``` + +## Task 2: Implement Shared-Cluster Distribution And Change Renderers + +**Files:** +- Modify: `dimelo/plotting_matplotlib.py` +- Modify: `tests/test_plotting.py` + +- [ ] **Step 1: Add thin distribution and change renderers** + +Add the new public functions in `dimelo/plotting_matplotlib.py`: + +```python +def plot_shared_cluster_distribution_matplotlib( + payload: Mapping[str, object], + *, + level: str = "condition", + ax=None, + title: str | None = None, +): + _require_payload_keys( + payload, + ("sample_distribution", "condition_distribution", "metadata"), + owner="plot_shared_cluster_distribution_matplotlib", + ) + if level not in {"sample", "condition"}: + raise ValueError("level must be 'sample' or 'condition'.") + + table = _require_payload_table( + payload, + "sample_distribution" if level == "sample" else "condition_distribution", + ) + fig, ax = _make_axis(ax=ax, figsize=(8, 4)) + + if not table.empty: + x_column = "sample_id" if level == "sample" else "condition" + pivot = ( + table.pivot_table( + index=x_column, + columns="cluster", + values="fraction", + aggfunc="mean", + fill_value=0.0, + ) + .sort_index(axis=0) + .sort_index(axis=1) + ) + pivot.plot(kind="bar", stacked=True, ax=ax, legend=True) + ax.tick_params(axis="x", rotation=45) + + ax.set_xlabel("Sample" if level == "sample" else "Condition") + ax.set_ylabel("Fraction") + ax.set_title(title or "Shared cluster distribution") + return fig, ax + + +def plot_shared_cluster_change_matplotlib( + payload: Mapping[str, object], + *, + ax=None, + title: str | None = None, +): + _require_payload_keys( + payload, + ("distribution_change", "metadata"), + owner="plot_shared_cluster_change_matplotlib", + ) + change_table = _require_payload_table(payload, "distribution_change") + fig, ax = _make_axis(ax=ax, figsize=(8, 4)) + + if not change_table.empty: + matrix = ( + change_table.pivot_table( + index="condition", + columns="cluster", + values="delta_fraction", + aggfunc="mean", + fill_value=0.0, + ) + .sort_index(axis=0) + .sort_index(axis=1) + ) + image = ax.imshow( + matrix.to_numpy(), + aspect="auto", + origin="lower", + interpolation="nearest", + ) + ax.figure.colorbar(image, ax=ax, label="Delta Fraction") + ax.set_xticks(range(len(matrix.columns))) + ax.set_xticklabels([str(value) for value in matrix.columns.tolist()], rotation=45, ha="right") + ax.set_yticks(range(len(matrix.index))) + ax.set_yticklabels([str(value) for value in matrix.index.tolist()]) + + ax.set_xlabel("Cluster") + ax.set_ylabel("Condition") + ax.set_title(title or "Shared cluster change") + return fig, ax +``` + +- [ ] **Step 2: Run the focused tests to verify they pass** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "plot_shared_cluster_distribution_matplotlib or plot_shared_cluster_change_matplotlib" -q +``` + +Expected: PASS. + +- [ ] **Step 3: Commit the distribution and change renderers** + +```bash +git add dimelo/plotting_matplotlib.py tests/test_plotting.py +git commit -m "feat: add shared clustering distribution renderers" +``` + +## Task 3: Add Failing Tests For Shared-Cluster Profile Renderers + +**Files:** +- Modify: `tests/test_plotting.py` +- Reference: `dimelo/plotting.py` +- Reference: `dimelo/plotting_matplotlib.py` + +- [ ] **Step 1: Write failing tests for profile heatmap and profile-series renderers** + +Add tests near the existing `prepare_shared_cluster_profile_data(...)` coverage: + +```python +def test_plot_shared_cluster_profile_heatmap_matplotlib_returns_figure_and_axis(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_profile_data( + result=_make_shared_cluster_profile_result() + ) + + fig, ax = plotting_matplotlib.plot_shared_cluster_profile_heatmap_matplotlib(payload) + + assert fig is not None + assert ax is not None + + +def test_plot_shared_cluster_profile_series_matplotlib_returns_figure_and_axis(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_profile_data( + result=_make_shared_cluster_profile_result() + ) + + fig, ax = plotting_matplotlib.plot_shared_cluster_profile_series_matplotlib(payload) + + assert fig is not None + assert ax is not None +``` + +- [ ] **Step 2: Run the focused tests to verify they fail** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "plot_shared_cluster_profile_heatmap_matplotlib or plot_shared_cluster_profile_series_matplotlib" -q +``` + +Expected: FAIL because the profile renderer functions do not yet exist. + +- [ ] **Step 3: Commit the failing tests** + +```bash +git add tests/test_plotting.py +git commit -m "test: add shared clustering profile renderer coverage" +``` + +## Task 4: Implement Shared-Cluster Profile Renderers + +**Files:** +- Modify: `dimelo/plotting_matplotlib.py` +- Modify: `dimelo/plotting.py` only if a small metadata tweak is clearly needed +- Modify: `tests/test_plotting.py` + +- [ ] **Step 1: Add the profile heatmap and series renderers** + +Implement the two profile renderers in `dimelo/plotting_matplotlib.py`: + +```python +def plot_shared_cluster_profile_heatmap_matplotlib( + payload: Mapping[str, object], + *, + ax=None, + title: str | None = None, +): + _require_payload_keys( + payload, + ("profile_table", "metadata"), + owner="plot_shared_cluster_profile_heatmap_matplotlib", + ) + profile_table = _require_payload_table(payload, "profile_table") + fig, ax = _make_axis(ax=ax, figsize=(8, 4)) + + if not profile_table.empty: + matrix = ( + profile_table.pivot_table( + index="cluster", + columns="feature", + values="value", + aggfunc="mean", + ) + .sort_index(axis=0) + .sort_index(axis=1) + ) + image = ax.imshow( + matrix.to_numpy(), + aspect="auto", + origin="lower", + interpolation="nearest", + ) + ax.figure.colorbar(image, ax=ax, label="Value") + ax.set_xticks(range(len(matrix.columns))) + ax.set_xticklabels([str(value) for value in matrix.columns.tolist()], rotation=45, ha="right") + ax.set_yticks(range(len(matrix.index))) + ax.set_yticklabels([str(value) for value in matrix.index.tolist()]) + + ax.set_xlabel("Feature") + ax.set_ylabel("Cluster") + ax.set_title(title or "Shared cluster profiles") + return fig, ax + + +def plot_shared_cluster_profile_series_matplotlib( + payload: Mapping[str, object], + *, + ax=None, + title: str | None = None, +): + _require_payload_keys( + payload, + ("profile_table", "metadata"), + owner="plot_shared_cluster_profile_series_matplotlib", + ) + profile_table = _require_payload_table(payload, "profile_table") + fig, ax = _make_axis(ax=ax, figsize=(8, 4)) + + if not profile_table.empty: + feature_order = list(payload.get("metadata", {}).get("feature_names", [])) + if not feature_order: + feature_order = sorted(profile_table["feature"].dropna().astype(str).unique()) + feature_lookup = {feature: index for index, feature in enumerate(feature_order)} + + for cluster, cluster_table in profile_table.groupby("cluster", sort=False): + cluster_table = cluster_table.copy() + cluster_table["feature_order"] = cluster_table["feature"].map(feature_lookup) + cluster_table = cluster_table.sort_values("feature_order", kind="stable") + ax.plot( + cluster_table["feature_order"], + cluster_table["value"], + marker="o", + linewidth=1.5, + label=str(cluster), + ) + + ax.set_xticks(range(len(feature_order))) + ax.set_xticklabels(feature_order, rotation=45, ha="right") + ax.legend(title="Cluster") + + ax.set_xlabel("Feature") + ax.set_ylabel("Value") + ax.set_title(title or "Shared cluster profile series") + return fig, ax +``` + +- [ ] **Step 2: Run the focused tests to verify they pass** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "plot_shared_cluster_profile_heatmap_matplotlib or plot_shared_cluster_profile_series_matplotlib" -q +``` + +Expected: PASS. + +- [ ] **Step 3: Commit the profile renderers** + +```bash +git add dimelo/plotting_matplotlib.py dimelo/plotting.py tests/test_plotting.py +git commit -m "feat: add shared clustering profile renderers" +``` + +## Task 5: Add Failing Tests For Shared-Cluster Region Renderers + +**Files:** +- Modify: `tests/test_plotting.py` +- Reference: `dimelo/plotting.py` +- Reference: `dimelo/plotting_matplotlib.py` + +- [ ] **Step 1: Write failing tests for the region occupancy renderer** + +Add tests near the existing `prepare_shared_cluster_region_data(...)` coverage: + +```python +def test_plot_shared_cluster_region_matplotlib_defaults_to_condition_level(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_region_data( + result=_make_shared_cluster_region_result() + ) + + fig, ax = plotting_matplotlib.plot_shared_cluster_region_matplotlib(payload) + + assert fig is not None + assert ax is not None + + +def test_plot_shared_cluster_region_matplotlib_supports_sample_level(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_region_data( + result=_make_shared_cluster_region_result() + ) + + fig, ax = plotting_matplotlib.plot_shared_cluster_region_matplotlib( + payload, + level="sample", + ) + + assert fig is not None + assert ax is not None +``` + +- [ ] **Step 2: Run the focused tests to verify they fail** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "plot_shared_cluster_region_matplotlib" -q +``` + +Expected: FAIL because the region renderer does not yet exist. + +- [ ] **Step 3: Commit the failing tests** + +```bash +git add tests/test_plotting.py +git commit -m "test: add shared clustering region renderer coverage" +``` + +## Task 6: Implement Shared-Cluster Region Renderer And Any Minimal Prep Fix + +**Files:** +- Modify: `dimelo/plotting_matplotlib.py` +- Modify: `dimelo/plotting.py` only if a minimal payload tweak is needed +- Modify: `tests/test_plotting.py` + +- [ ] **Step 1: Implement the condition-default region occupancy renderer** + +Implement the renderer in `dimelo/plotting_matplotlib.py`: + +```python +def plot_shared_cluster_region_matplotlib( + payload: Mapping[str, object], + *, + level: str = "condition", + ax=None, + title: str | None = None, +): + _require_payload_keys( + payload, + ("region_table", "condition_region_table", "metadata"), + owner="plot_shared_cluster_region_matplotlib", + ) + if level not in {"sample", "condition"}: + raise ValueError("level must be 'sample' or 'condition'.") + + table = _require_payload_table( + payload, + "condition_region_table" if level == "condition" else "region_table", + ) + fig, ax = _make_axis(ax=ax, figsize=(8, 4)) + + if not table.empty: + value_column = "fraction_mean" if level == "condition" else "fraction" + row_columns = ["region_id", "condition"] if level == "condition" else ["region_id", "sample_id"] + heatmap = table.copy() + heatmap["row_id"] = heatmap[row_columns].astype(str).agg(" | ".join, axis=1) + matrix = ( + heatmap.pivot_table( + index="row_id", + columns="cluster", + values=value_column, + aggfunc="mean", + fill_value=0.0, + ) + .sort_index(axis=0) + .sort_index(axis=1) + ) + image = ax.imshow( + matrix.to_numpy(), + aspect="auto", + origin="lower", + interpolation="nearest", + ) + ax.figure.colorbar(image, ax=ax, label=value_column.replace("_", " ").title()) + ax.set_xticks(range(len(matrix.columns))) + ax.set_xticklabels([str(value) for value in matrix.columns.tolist()], rotation=45, ha="right") + ax.set_yticks(range(len(matrix.index))) + ax.set_yticklabels([str(value) for value in matrix.index.tolist()]) + + ax.set_xlabel("Cluster") + ax.set_ylabel("Region / Condition" if level == "condition" else "Region / Sample") + ax.set_title(title or "Shared cluster region occupancy") + return fig, ax +``` + +- [ ] **Step 2: Add only a minimal prep-layer tweak if the renderer work proves one is necessary** + +If the renderer implementation exposes a real payload friction, keep any prep-layer change small and explicit. An acceptable example is adding a stable metadata ordering field in `prepare_shared_cluster_region_data(...)`: + +```python +return { + "region_table": region_table, + "condition_region_table": condition_region_table, + "metadata": { + "mode": result.model.mode, + "cluster_labels": list(result.model.cluster_labels), + "has_condition_aggregation": aggregate_conditions, + "region_order": region_table["region_id"].drop_duplicates().tolist(), + }, +} +``` + +Do not add new region statistics or new occupancy summaries here. + +- [ ] **Step 3: Run the focused tests to verify they pass** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "plot_shared_cluster_region_matplotlib" -q +``` + +Expected: PASS. + +- [ ] **Step 4: Commit the region renderer** + +```bash +git add dimelo/plotting_matplotlib.py dimelo/plotting.py tests/test_plotting.py +git commit -m "feat: add shared clustering region renderer" +``` + +## Task 7: Add User-Facing Docs For Shared-Clustering Matplotlib Renderers + +**Files:** +- Modify: `README.md` +- Modify: `docs/shared-clustering.md` + +- [ ] **Step 1: Add a short README note for shared-clustering renderers** + +Add a short note near the existing Matplotlib renderer overview: + +```md +`shared_clustering` also supports built-in Matplotlib rendering through +`dimelo.plotting_matplotlib`, including cluster-distribution, profile, and +region-occupancy views on top of the prepared clustering payloads. +``` + +- [ ] **Step 2: Add short examples to `docs/shared-clustering.md`** + +Add examples like: + +```python +from dimelo import plotting, plotting_matplotlib + +distribution_payload = plotting.prepare_shared_cluster_distribution_data(result=result) +fig, ax = plotting_matplotlib.plot_shared_cluster_distribution_matplotlib(distribution_payload) +plotting_matplotlib.save_figure(fig, "shared-cluster-distribution.png") +``` + +```python +profile_payload = plotting.prepare_shared_cluster_profile_data(result=result) +fig, ax = plotting_matplotlib.plot_shared_cluster_profile_heatmap_matplotlib(profile_payload) +``` + +```python +region_payload = plotting.prepare_shared_cluster_region_data(result=result) +fig, ax = plotting_matplotlib.plot_shared_cluster_region_matplotlib( + region_payload, + level="condition", +) +``` + +Keep the docs explicit that: + +- condition-level region occupancy is the default rendering view +- sample-level occupancy is still available with `level="sample"` +- the older `result.plot_data` tables remain supported + +- [ ] **Step 3: Commit the docs** + +```bash +git add README.md docs/shared-clustering.md +git commit -m "docs: add shared clustering renderer examples" +``` + +## Task 8: Final Verification And Self-Review + +**Files:** +- Reference: `dimelo/plotting_matplotlib.py` +- Reference: `dimelo/plotting.py` +- Reference: `tests/test_plotting.py` +- Reference: `README.md` +- Reference: `docs/shared-clustering.md` + +- [ ] **Step 1: Run the full plotting coverage** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl XDG_CACHE_HOME=/tmp/xdg-cache PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -q +``` + +Expected: PASS. + +- [ ] **Step 2: Run the workflow regression subset** + +Run: + +```bash +MPLCONFIGDIR=/tmp/mpl XDG_CACHE_HOME=/tmp/xdg-cache PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_workflows.py -q +``` + +Expected: PASS with no new failures. + +- [ ] **Step 3: Run a clean status check** + +Run: + +```bash +git status --short +``` + +Expected: clean working tree. + +- [ ] **Step 4: Self-review against the spec** + +Check the completed work against `docs/superpowers/specs/2026-04-10-shared-clustering-matplotlib-renderers-design.md`: + +- separate `shared_clustering` Matplotlib renderers exist in `dimelo.plotting_matplotlib` +- renderers cover distribution/change, profiles, and region occupancy +- default region occupancy view is condition-level +- only minimal prep-layer changes, if any, were introduced +- docs describe the renderer layer as optional and payload-driven + +- [ ] **Step 5: Commit a small follow-up only if verification finds a real issue** + +```bash +git add dimelo/plotting_matplotlib.py dimelo/plotting.py tests/test_plotting.py README.md docs/shared-clustering.md +git commit -m "fix: tighten shared clustering renderer support" +``` + +Only make this commit if verification or self-review uncovers a small real follow-up patch. From 672d07efa5d41fbc9a7d99059e549dfbf03bbb5a Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Fri, 10 Apr 2026 13:23:33 -0700 Subject: [PATCH 209/272] test: add shared clustering distribution renderer coverage --- tests/test_plotting.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 317faf7..7ccf7b7 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -327,6 +327,28 @@ def test_prepare_shared_cluster_distribution_data_handles_missing_change_table() assert condition_distribution["replicate_n"].tolist() == [1, 1, 1, 1] +def test_plot_shared_cluster_distribution_matplotlib_returns_figure_and_axis(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_distribution_data(result=_make_shared_cluster_result()) + + fig, ax = plotting_matplotlib.plot_shared_cluster_distribution_matplotlib(payload) + + assert fig is not None + assert ax is not None + + +def test_plot_shared_cluster_change_matplotlib_returns_figure_and_axis(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_distribution_data(result=_make_shared_cluster_result()) + + fig, ax = plotting_matplotlib.plot_shared_cluster_change_matplotlib(payload) + + assert fig is not None + assert ax is not None + + def _make_shared_cluster_profile_result() -> SharedClusterResult: return SharedClusterResult( model=SharedClusterModel( From ecb02f783a0f89a5c8761515aa9dbf7155423811 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Fri, 10 Apr 2026 13:27:31 -0700 Subject: [PATCH 210/272] feat: add shared clustering distribution renderers --- dimelo/plotting_matplotlib.py | 93 +++++++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) diff --git a/dimelo/plotting_matplotlib.py b/dimelo/plotting_matplotlib.py index a5d33ed..f53636c 100644 --- a/dimelo/plotting_matplotlib.py +++ b/dimelo/plotting_matplotlib.py @@ -325,6 +325,99 @@ def plot_region_discovery_hit_context_matplotlib( return fig, axes +def plot_shared_cluster_distribution_matplotlib( + payload: Mapping[str, object], + *, + level: str = "condition", + ax=None, + title: str | None = None, +): + _require_payload_keys( + payload, + ("sample_distribution", "condition_distribution", "metadata"), + owner="plot_shared_cluster_distribution_matplotlib", + ) + if level not in {"sample", "condition"}: + raise ValueError("level must be 'sample' or 'condition'.") + + table = _require_payload_table( + payload, + "sample_distribution" if level == "sample" else "condition_distribution", + ) + fig, ax = _make_axis(ax=ax, figsize=(8, 4)) + + if not table.empty: + x_column = "sample_id" if level == "sample" else "condition" + pivot = ( + table.pivot_table( + index=x_column, + columns="cluster", + values="fraction", + aggfunc="mean", + fill_value=0.0, + ) + .sort_index(axis=0) + .sort_index(axis=1) + ) + pivot.plot(kind="bar", stacked=True, ax=ax) + ax.tick_params(axis="x", rotation=45) + + ax.set_xlabel("Sample" if level == "sample" else "Condition") + ax.set_ylabel("Fraction") + ax.set_title(title or "Shared cluster distribution") + return fig, ax + + +def plot_shared_cluster_change_matplotlib( + payload: Mapping[str, object], + *, + ax=None, + title: str | None = None, +): + _require_payload_keys( + payload, + ("distribution_change", "metadata"), + owner="plot_shared_cluster_change_matplotlib", + ) + change_table = _require_payload_table(payload, "distribution_change") + fig, ax = _make_axis(ax=ax, figsize=(8, 4)) + + if not change_table.empty: + matrix = ( + change_table.pivot_table( + index="condition", + columns="cluster", + values="delta_fraction", + aggfunc="mean", + fill_value=0.0, + ) + .sort_index(axis=0) + .sort_index(axis=1) + ) + max_abs = float(matrix.abs().to_numpy().max()) if not matrix.empty else 0.0 + if max_abs == 0.0: + max_abs = 1.0 + image = ax.imshow( + matrix.to_numpy(), + aspect="auto", + origin="lower", + interpolation="nearest", + cmap="coolwarm", + vmin=-max_abs, + vmax=max_abs, + ) + ax.figure.colorbar(image, ax=ax, label="Delta Fraction") + ax.set_xticks(range(len(matrix.columns))) + ax.set_xticklabels([str(value) for value in matrix.columns.tolist()], rotation=45, ha="right") + ax.set_yticks(range(len(matrix.index))) + ax.set_yticklabels([str(value) for value in matrix.index.tolist()]) + + ax.set_xlabel("Cluster") + ax.set_ylabel("Condition") + ax.set_title(title or "Shared cluster change") + return fig, ax + + def plot_global_analysis_summary_matplotlib( payload: Mapping[str, object], *, From 67cfa6257c6a8f506580247b0130723b2b64a267 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Fri, 10 Apr 2026 13:33:14 -0700 Subject: [PATCH 211/272] fix: tighten shared clustering renderer contracts --- dimelo/plotting_matplotlib.py | 61 +++++++++++++++++------------------ tests/test_plotting.py | 20 +++++++++++- 2 files changed, 48 insertions(+), 33 deletions(-) diff --git a/dimelo/plotting_matplotlib.py b/dimelo/plotting_matplotlib.py index f53636c..eb09d9f 100644 --- a/dimelo/plotting_matplotlib.py +++ b/dimelo/plotting_matplotlib.py @@ -78,6 +78,16 @@ def _make_axes(*, axes=None, n_axes: int, figsize=(8, 4)): return fig, list(created_axes.ravel()) +def _ordered_cluster_labels(metadata: Mapping[str, object], observed_clusters: pd.Index) -> list[object]: + cluster_labels = list(metadata.get("cluster_labels") or []) + if not cluster_labels: + return list(observed_clusters) + + ordered_clusters = [cluster for cluster in cluster_labels if cluster in set(observed_clusters)] + ordered_clusters.extend([cluster for cluster in observed_clusters if cluster not in cluster_labels]) + return ordered_clusters + + def _prepare_region_contrast_value_mode_table( plot_table: pd.DataFrame, *, @@ -332,11 +342,7 @@ def plot_shared_cluster_distribution_matplotlib( ax=None, title: str | None = None, ): - _require_payload_keys( - payload, - ("sample_distribution", "condition_distribution", "metadata"), - owner="plot_shared_cluster_distribution_matplotlib", - ) + _require_payload_keys(payload, ("metadata",), owner="plot_shared_cluster_distribution_matplotlib") if level not in {"sample", "condition"}: raise ValueError("level must be 'sample' or 'condition'.") @@ -344,21 +350,19 @@ def plot_shared_cluster_distribution_matplotlib( payload, "sample_distribution" if level == "sample" else "condition_distribution", ) + metadata = payload.get("metadata") + if not isinstance(metadata, Mapping): + raise TypeError("plot payload key 'metadata' must be a mapping.") + fig, ax = _make_axis(ax=ax, figsize=(8, 4)) if not table.empty: x_column = "sample_id" if level == "sample" else "condition" - pivot = ( - table.pivot_table( - index=x_column, - columns="cluster", - values="fraction", - aggfunc="mean", - fill_value=0.0, - ) - .sort_index(axis=0) - .sort_index(axis=1) - ) + value_table = table.loc[:, [x_column, "cluster", "fraction"]].copy() + if value_table.duplicated([x_column, "cluster"]).any(): + raise ValueError("plot payload contains duplicate cluster fractions for the same x value.") + pivot = value_table.set_index([x_column, "cluster"])["fraction"].unstack("cluster", fill_value=0.0) + pivot = pivot.reindex(columns=_ordered_cluster_labels(metadata, pivot.columns), fill_value=0.0) pivot.plot(kind="bar", stacked=True, ax=ax) ax.tick_params(axis="x", rotation=45) @@ -374,26 +378,19 @@ def plot_shared_cluster_change_matplotlib( ax=None, title: str | None = None, ): - _require_payload_keys( - payload, - ("distribution_change", "metadata"), - owner="plot_shared_cluster_change_matplotlib", - ) + _require_payload_keys(payload, ("metadata",), owner="plot_shared_cluster_change_matplotlib") change_table = _require_payload_table(payload, "distribution_change") + metadata = payload.get("metadata") + if not isinstance(metadata, Mapping): + raise TypeError("plot payload key 'metadata' must be a mapping.") fig, ax = _make_axis(ax=ax, figsize=(8, 4)) if not change_table.empty: - matrix = ( - change_table.pivot_table( - index="condition", - columns="cluster", - values="delta_fraction", - aggfunc="mean", - fill_value=0.0, - ) - .sort_index(axis=0) - .sort_index(axis=1) - ) + value_table = change_table.loc[:, ["condition", "cluster", "delta_fraction"]].copy() + if value_table.duplicated(["condition", "cluster"]).any(): + raise ValueError("plot payload contains duplicate delta fractions for the same condition.") + matrix = value_table.set_index(["condition", "cluster"])["delta_fraction"].unstack("cluster", fill_value=0.0) + matrix = matrix.reindex(columns=_ordered_cluster_labels(metadata, matrix.columns), fill_value=0.0) max_abs = float(matrix.abs().to_numpy().max()) if not matrix.empty else 0.0 if max_abs == 0.0: max_abs = 1.0 diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 7ccf7b7..7269f96 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -129,7 +129,7 @@ def _make_shared_cluster_result() -> SharedClusterResult: feature_names=["f0", "f1"], preprocessing={"signal_normalization": "none"}, estimator=object(), - cluster_labels=["C0", "C1"], + cluster_labels=["C1", "C0"], fit_metadata={"clusterer": "minibatch_kmeans", "n_clusters": 2}, ) cluster_distribution = pd.DataFrame( @@ -336,6 +336,15 @@ def test_plot_shared_cluster_distribution_matplotlib_returns_figure_and_axis(): assert fig is not None assert ax is not None + assert [text.get_text() for text in ax.get_legend().texts] == ["C1", "C0"] + + duplicate_payload = dict(payload) + duplicate_payload["condition_distribution"] = pd.concat( + [payload["condition_distribution"], payload["condition_distribution"].iloc[[0]]], + ignore_index=True, + ) + with pytest.raises(ValueError, match="duplicate cluster fractions"): + plotting_matplotlib.plot_shared_cluster_distribution_matplotlib(duplicate_payload) def test_plot_shared_cluster_change_matplotlib_returns_figure_and_axis(): @@ -347,6 +356,15 @@ def test_plot_shared_cluster_change_matplotlib_returns_figure_and_axis(): assert fig is not None assert ax is not None + assert [tick.get_text() for tick in ax.get_xticklabels()] == ["C1", "C0"] + + duplicate_payload = dict(payload) + duplicate_payload["distribution_change"] = pd.concat( + [payload["distribution_change"], payload["distribution_change"].iloc[[0]]], + ignore_index=True, + ) + with pytest.raises(ValueError, match="duplicate delta fractions"): + plotting_matplotlib.plot_shared_cluster_change_matplotlib(duplicate_payload) def _make_shared_cluster_profile_result() -> SharedClusterResult: From 20018b631298a1c29b672b6c8cc5169277593e9b Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Fri, 10 Apr 2026 13:40:08 -0700 Subject: [PATCH 212/272] fix: preserve shared cluster payload order --- dimelo/plotting_matplotlib.py | 17 +++-- tests/test_plotting.py | 127 +++++++++++++++++++++++++++++++++- 2 files changed, 137 insertions(+), 7 deletions(-) diff --git a/dimelo/plotting_matplotlib.py b/dimelo/plotting_matplotlib.py index eb09d9f..02fa6ec 100644 --- a/dimelo/plotting_matplotlib.py +++ b/dimelo/plotting_matplotlib.py @@ -78,16 +78,21 @@ def _make_axes(*, axes=None, n_axes: int, figsize=(8, 4)): return fig, list(created_axes.ravel()) -def _ordered_cluster_labels(metadata: Mapping[str, object], observed_clusters: pd.Index) -> list[object]: +def _ordered_cluster_labels(metadata: Mapping[str, object], observed_clusters: list[object]) -> list[object]: cluster_labels = list(metadata.get("cluster_labels") or []) if not cluster_labels: return list(observed_clusters) - ordered_clusters = [cluster for cluster in cluster_labels if cluster in set(observed_clusters)] + observed_cluster_set = set(observed_clusters) + ordered_clusters = [cluster for cluster in cluster_labels if cluster in observed_cluster_set] ordered_clusters.extend([cluster for cluster in observed_clusters if cluster not in cluster_labels]) return ordered_clusters +def _ordered_unique_values(table: pd.DataFrame, column: str) -> list[object]: + return table.loc[:, column].drop_duplicates().tolist() + + def _prepare_region_contrast_value_mode_table( plot_table: pd.DataFrame, *, @@ -361,8 +366,10 @@ def plot_shared_cluster_distribution_matplotlib( value_table = table.loc[:, [x_column, "cluster", "fraction"]].copy() if value_table.duplicated([x_column, "cluster"]).any(): raise ValueError("plot payload contains duplicate cluster fractions for the same x value.") + x_order = _ordered_unique_values(value_table, x_column) + cluster_order = _ordered_cluster_labels(metadata, _ordered_unique_values(value_table, "cluster")) pivot = value_table.set_index([x_column, "cluster"])["fraction"].unstack("cluster", fill_value=0.0) - pivot = pivot.reindex(columns=_ordered_cluster_labels(metadata, pivot.columns), fill_value=0.0) + pivot = pivot.reindex(index=x_order, columns=cluster_order, fill_value=0.0) pivot.plot(kind="bar", stacked=True, ax=ax) ax.tick_params(axis="x", rotation=45) @@ -389,8 +396,10 @@ def plot_shared_cluster_change_matplotlib( value_table = change_table.loc[:, ["condition", "cluster", "delta_fraction"]].copy() if value_table.duplicated(["condition", "cluster"]).any(): raise ValueError("plot payload contains duplicate delta fractions for the same condition.") + condition_order = _ordered_unique_values(value_table, "condition") + cluster_order = _ordered_cluster_labels(metadata, _ordered_unique_values(value_table, "cluster")) matrix = value_table.set_index(["condition", "cluster"])["delta_fraction"].unstack("cluster", fill_value=0.0) - matrix = matrix.reindex(columns=_ordered_cluster_labels(metadata, matrix.columns), fill_value=0.0) + matrix = matrix.reindex(index=condition_order, columns=cluster_order, fill_value=0.0) max_abs = float(matrix.abs().to_numpy().max()) if not matrix.empty else 0.0 if max_abs == 0.0: max_abs = 1.0 diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 7269f96..ba59b7f 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -331,12 +331,86 @@ def test_plot_shared_cluster_distribution_matplotlib_returns_figure_and_axis(): from dimelo import plotting_matplotlib payload = plotting.prepare_shared_cluster_distribution_data(result=_make_shared_cluster_result()) + payload = dict(payload) + payload["metadata"] = {**payload["metadata"], "cluster_labels": ["C1"]} + payload["sample_distribution"] = pd.DataFrame( + [ + { + "sample_id": "s2", + "condition": "treated", + "cluster": "C3", + "count": 1, + "fraction": 0.25, + }, + { + "sample_id": "s1", + "condition": "NS", + "cluster": "C20", + "count": 2, + "fraction": 0.75, + }, + { + "sample_id": "s2", + "condition": "treated", + "cluster": "C20", + "count": 3, + "fraction": 0.75, + }, + { + "sample_id": "s1", + "condition": "NS", + "cluster": "C3", + "count": 1, + "fraction": 0.25, + }, + ] + ) + payload["condition_distribution"] = pd.DataFrame( + [ + { + "condition": "treated", + "cluster": "C3", + "count": 1, + "fraction": 0.25, + "replicate_n": 1, + }, + { + "condition": "treated", + "cluster": "C20", + "count": 3, + "fraction": 0.75, + "replicate_n": 1, + }, + { + "condition": "NS", + "cluster": "C3", + "count": 1, + "fraction": 0.25, + "replicate_n": 1, + }, + { + "condition": "NS", + "cluster": "C20", + "count": 2, + "fraction": 0.75, + "replicate_n": 1, + }, + ] + ) + + fig, ax = plotting_matplotlib.plot_shared_cluster_distribution_matplotlib(payload, level="sample") + + assert fig is not None + assert ax is not None + assert [text.get_text() for text in ax.get_legend().texts] == ["C3", "C20"] + assert [tick.get_text() for tick in ax.get_xticklabels() if tick.get_text()] == ["s2", "s1"] - fig, ax = plotting_matplotlib.plot_shared_cluster_distribution_matplotlib(payload) + fig, ax = plotting_matplotlib.plot_shared_cluster_distribution_matplotlib(payload, level="condition") assert fig is not None assert ax is not None - assert [text.get_text() for text in ax.get_legend().texts] == ["C1", "C0"] + assert [text.get_text() for text in ax.get_legend().texts] == ["C3", "C20"] + assert [tick.get_text() for tick in ax.get_xticklabels() if tick.get_text()] == ["treated", "NS"] duplicate_payload = dict(payload) duplicate_payload["condition_distribution"] = pd.concat( @@ -351,12 +425,59 @@ def test_plot_shared_cluster_change_matplotlib_returns_figure_and_axis(): from dimelo import plotting_matplotlib payload = plotting.prepare_shared_cluster_distribution_data(result=_make_shared_cluster_result()) + payload = dict(payload) + payload["metadata"] = {**payload["metadata"], "cluster_labels": ["C1"]} + payload["distribution_change"] = pd.DataFrame( + [ + { + "condition": "treated", + "cluster": "C3", + "count": 1, + "fraction": 0.25, + "replicate_n": 1, + "reference_fraction": 0.5, + "delta_fraction": -0.25, + "log2_fc": -1.0, + }, + { + "condition": "treated", + "cluster": "C20", + "count": 3, + "fraction": 0.75, + "replicate_n": 1, + "reference_fraction": 0.5, + "delta_fraction": 0.25, + "log2_fc": 1.0, + }, + { + "condition": "baseline", + "cluster": "C3", + "count": 2, + "fraction": 0.5, + "replicate_n": 1, + "reference_fraction": 0.5, + "delta_fraction": 0.0, + "log2_fc": 0.0, + }, + { + "condition": "baseline", + "cluster": "C20", + "count": 2, + "fraction": 0.5, + "replicate_n": 1, + "reference_fraction": 0.5, + "delta_fraction": 0.0, + "log2_fc": 0.0, + }, + ] + ) fig, ax = plotting_matplotlib.plot_shared_cluster_change_matplotlib(payload) assert fig is not None assert ax is not None - assert [tick.get_text() for tick in ax.get_xticklabels()] == ["C1", "C0"] + assert [tick.get_text() for tick in ax.get_xticklabels()] == ["C3", "C20"] + assert [tick.get_text() for tick in ax.get_yticklabels()] == ["treated", "baseline"] duplicate_payload = dict(payload) duplicate_payload["distribution_change"] = pd.concat( From 2b8866bd791fea1dc9fa6c1cfe351d3bfb45dbcc Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Fri, 10 Apr 2026 13:48:04 -0700 Subject: [PATCH 213/272] fix: honor prepared shared cluster display order --- dimelo/plotting.py | 13 ++ dimelo/plotting_matplotlib.py | 29 +++- tests/test_plotting.py | 281 ++++++++++++++++++---------------- 3 files changed, 190 insertions(+), 133 deletions(-) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 3a5165d..1da2c2f 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -170,6 +170,12 @@ def _empty_distribution_change_table() -> pd.DataFrame: ) +def _ordered_non_null_values(table: pd.DataFrame, column: str) -> list[object]: + if column not in table.columns: + return [] + return table.loc[table[column].notna(), column].drop_duplicates().tolist() + + def _filter_motif_table(table: pd.DataFrame, motifs: list[str] | None, *, owner: str) -> pd.DataFrame: _require_columns(table, ("motif",), owner) if motifs is None: @@ -1268,6 +1274,7 @@ def prepare_shared_cluster_distribution_data( ) -> dict[str, pd.DataFrame | dict[str, object]]: _validate_shared_cluster_result(result) + sample_order = _ordered_non_null_values(result.cluster_distribution, "sample_id") sample_distribution = prepare_cluster_distribution_bar_data(result.cluster_distribution) _require_columns( @@ -1275,6 +1282,7 @@ def prepare_shared_cluster_distribution_data( ("condition", "cluster", "count", "fraction", "replicate_n"), "result.condition_distribution", ) + condition_order = _ordered_non_null_values(result.condition_distribution, "condition") condition_distribution = ( result.condition_distribution.loc[ :, ["condition", "cluster", "count", "fraction", "replicate_n"] @@ -1285,6 +1293,7 @@ def prepare_shared_cluster_distribution_data( if result.distribution_change is None: distribution_change = _empty_distribution_change_table() + change_condition_order: list[object] = [] else: _require_columns( result.distribution_change, @@ -1300,6 +1309,7 @@ def prepare_shared_cluster_distribution_data( ), "result.distribution_change", ) + change_condition_order = _ordered_non_null_values(result.distribution_change, "condition") distribution_change = ( result.distribution_change.loc[ :, @@ -1321,6 +1331,9 @@ def prepare_shared_cluster_distribution_data( metadata = { "mode": result.model.mode, "cluster_labels": list(result.model.cluster_labels), + "sample_order": sample_order, + "condition_order": condition_order, + "change_condition_order": change_condition_order, "has_distribution_change": not distribution_change.empty, } return { diff --git a/dimelo/plotting_matplotlib.py b/dimelo/plotting_matplotlib.py index 02fa6ec..60d918a 100644 --- a/dimelo/plotting_matplotlib.py +++ b/dimelo/plotting_matplotlib.py @@ -93,6 +93,21 @@ def _ordered_unique_values(table: pd.DataFrame, column: str) -> list[object]: return table.loc[:, column].drop_duplicates().tolist() +def _ordered_axis_values( + metadata: Mapping[str, object], + key: str, + observed_values: list[object], +) -> list[object]: + configured_values = list(metadata.get(key) or []) + if not configured_values: + return list(observed_values) + + observed_value_set = set(observed_values) + ordered_values = [value for value in configured_values if value in observed_value_set] + ordered_values.extend([value for value in observed_values if value not in configured_values]) + return ordered_values + + def _prepare_region_contrast_value_mode_table( plot_table: pd.DataFrame, *, @@ -366,7 +381,11 @@ def plot_shared_cluster_distribution_matplotlib( value_table = table.loc[:, [x_column, "cluster", "fraction"]].copy() if value_table.duplicated([x_column, "cluster"]).any(): raise ValueError("plot payload contains duplicate cluster fractions for the same x value.") - x_order = _ordered_unique_values(value_table, x_column) + x_order = _ordered_axis_values( + metadata, + "sample_order" if level == "sample" else "condition_order", + _ordered_unique_values(value_table, x_column), + ) cluster_order = _ordered_cluster_labels(metadata, _ordered_unique_values(value_table, "cluster")) pivot = value_table.set_index([x_column, "cluster"])["fraction"].unstack("cluster", fill_value=0.0) pivot = pivot.reindex(index=x_order, columns=cluster_order, fill_value=0.0) @@ -396,7 +415,11 @@ def plot_shared_cluster_change_matplotlib( value_table = change_table.loc[:, ["condition", "cluster", "delta_fraction"]].copy() if value_table.duplicated(["condition", "cluster"]).any(): raise ValueError("plot payload contains duplicate delta fractions for the same condition.") - condition_order = _ordered_unique_values(value_table, "condition") + condition_order = _ordered_axis_values( + metadata, + "change_condition_order", + _ordered_unique_values(value_table, "condition"), + ) cluster_order = _ordered_cluster_labels(metadata, _ordered_unique_values(value_table, "cluster")) matrix = value_table.set_index(["condition", "cluster"])["delta_fraction"].unstack("cluster", fill_value=0.0) matrix = matrix.reindex(index=condition_order, columns=cluster_order, fill_value=0.0) @@ -406,7 +429,7 @@ def plot_shared_cluster_change_matplotlib( image = ax.imshow( matrix.to_numpy(), aspect="auto", - origin="lower", + origin="upper", interpolation="nearest", cmap="coolwarm", vmin=-max_abs, diff --git a/tests/test_plotting.py b/tests/test_plotting.py index ba59b7f..572154f 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -233,6 +233,137 @@ def _make_shared_cluster_result() -> SharedClusterResult: ) +def _make_shared_cluster_result_with_explicit_display_order() -> SharedClusterResult: + model = SharedClusterModel( + mode="region_anchored", + motifs=["A,0"], + feature_names=["f0", "f1"], + preprocessing={"signal_normalization": "none"}, + estimator=object(), + cluster_labels=["C1", "C0"], + fit_metadata={"clusterer": "minibatch_kmeans", "n_clusters": 2}, + ) + cluster_distribution = pd.DataFrame( + [ + { + "sample_id": "s2", + "condition": "treated", + "cluster": "C1", + "count": 3, + "fraction": 3 / 4, + }, + { + "sample_id": "s2", + "condition": "treated", + "cluster": "C0", + "count": 1, + "fraction": 1 / 4, + }, + { + "sample_id": "s1", + "condition": "NS", + "cluster": "C1", + "count": 1, + "fraction": 1 / 3, + }, + { + "sample_id": "s1", + "condition": "NS", + "cluster": "C0", + "count": 2, + "fraction": 2 / 3, + }, + ] + ) + condition_distribution = pd.DataFrame( + [ + { + "condition": "treated", + "cluster": "C1", + "count": 3, + "fraction": 3 / 4, + "replicate_n": 1, + }, + { + "condition": "treated", + "cluster": "C0", + "count": 1, + "fraction": 1 / 4, + "replicate_n": 1, + }, + { + "condition": "NS", + "cluster": "C1", + "count": 1, + "fraction": 1 / 3, + "replicate_n": 1, + }, + { + "condition": "NS", + "cluster": "C0", + "count": 2, + "fraction": 2 / 3, + "replicate_n": 1, + }, + ] + ) + distribution_change = pd.DataFrame( + [ + { + "condition": "treated", + "cluster": "C1", + "count": 3, + "fraction": 3 / 4, + "replicate_n": 1, + "reference_fraction": 1 / 3, + "delta_fraction": 5 / 12, + "log2_fc": 1.1699250014423124, + }, + { + "condition": "treated", + "cluster": "C0", + "count": 1, + "fraction": 1 / 4, + "replicate_n": 1, + "reference_fraction": 2 / 3, + "delta_fraction": -5 / 12, + "log2_fc": -1.415037499278844, + }, + { + "condition": "baseline", + "cluster": "C1", + "count": 2, + "fraction": 1 / 2, + "replicate_n": 1, + "reference_fraction": 1 / 2, + "delta_fraction": 0.0, + "log2_fc": 0.0, + }, + { + "condition": "baseline", + "cluster": "C0", + "count": 2, + "fraction": 1 / 2, + "replicate_n": 1, + "reference_fraction": 1 / 2, + "delta_fraction": 0.0, + "log2_fc": 0.0, + }, + ] + ) + return SharedClusterResult( + model=model, + assignments=pd.DataFrame(columns=["sample_id", "condition", "cluster"]), + cluster_distribution=cluster_distribution, + condition_distribution=condition_distribution, + distribution_change=distribution_change, + cluster_profiles=pd.DataFrame(columns=["cluster", "count", "f0", "f1"]), + region_summaries=None, + plot_data={}, + metadata={"mode": "region_anchored"}, + ) + + def test_prepare_shared_cluster_distribution_data_returns_distribution_payload(): result = _make_shared_cluster_result() @@ -271,6 +402,10 @@ def test_prepare_shared_cluster_distribution_data_returns_distribution_payload() [-1.415037499278844, 1.1699250014423124] ) assert payload["metadata"]["mode"] == "region_anchored" + assert payload["metadata"]["cluster_labels"] == ["C1", "C0"] + assert payload["metadata"]["sample_order"] == ["s1", "s2"] + assert payload["metadata"]["condition_order"] == ["NS", "treated"] + assert payload["metadata"]["change_condition_order"] == ["treated"] def test_plotting_matplotlib_module_exports_save_figure(): @@ -330,162 +465,48 @@ def test_prepare_shared_cluster_distribution_data_handles_missing_change_table() def test_plot_shared_cluster_distribution_matplotlib_returns_figure_and_axis(): from dimelo import plotting_matplotlib - payload = plotting.prepare_shared_cluster_distribution_data(result=_make_shared_cluster_result()) - payload = dict(payload) - payload["metadata"] = {**payload["metadata"], "cluster_labels": ["C1"]} - payload["sample_distribution"] = pd.DataFrame( - [ - { - "sample_id": "s2", - "condition": "treated", - "cluster": "C3", - "count": 1, - "fraction": 0.25, - }, - { - "sample_id": "s1", - "condition": "NS", - "cluster": "C20", - "count": 2, - "fraction": 0.75, - }, - { - "sample_id": "s2", - "condition": "treated", - "cluster": "C20", - "count": 3, - "fraction": 0.75, - }, - { - "sample_id": "s1", - "condition": "NS", - "cluster": "C3", - "count": 1, - "fraction": 0.25, - }, - ] - ) - payload["condition_distribution"] = pd.DataFrame( - [ - { - "condition": "treated", - "cluster": "C3", - "count": 1, - "fraction": 0.25, - "replicate_n": 1, - }, - { - "condition": "treated", - "cluster": "C20", - "count": 3, - "fraction": 0.75, - "replicate_n": 1, - }, - { - "condition": "NS", - "cluster": "C3", - "count": 1, - "fraction": 0.25, - "replicate_n": 1, - }, - { - "condition": "NS", - "cluster": "C20", - "count": 2, - "fraction": 0.75, - "replicate_n": 1, - }, - ] + payload = plotting.prepare_shared_cluster_distribution_data( + result=_make_shared_cluster_result_with_explicit_display_order() ) fig, ax = plotting_matplotlib.plot_shared_cluster_distribution_matplotlib(payload, level="sample") assert fig is not None assert ax is not None - assert [text.get_text() for text in ax.get_legend().texts] == ["C3", "C20"] + assert payload["metadata"]["sample_order"] == ["s2", "s1"] + assert [text.get_text() for text in ax.get_legend().texts] == ["C1", "C0"] assert [tick.get_text() for tick in ax.get_xticklabels() if tick.get_text()] == ["s2", "s1"] fig, ax = plotting_matplotlib.plot_shared_cluster_distribution_matplotlib(payload, level="condition") assert fig is not None assert ax is not None - assert [text.get_text() for text in ax.get_legend().texts] == ["C3", "C20"] + assert payload["metadata"]["condition_order"] == ["treated", "NS"] + assert [text.get_text() for text in ax.get_legend().texts] == ["C1", "C0"] assert [tick.get_text() for tick in ax.get_xticklabels() if tick.get_text()] == ["treated", "NS"] - duplicate_payload = dict(payload) - duplicate_payload["condition_distribution"] = pd.concat( - [payload["condition_distribution"], payload["condition_distribution"].iloc[[0]]], - ignore_index=True, - ) - with pytest.raises(ValueError, match="duplicate cluster fractions"): - plotting_matplotlib.plot_shared_cluster_distribution_matplotlib(duplicate_payload) - def test_plot_shared_cluster_change_matplotlib_returns_figure_and_axis(): from dimelo import plotting_matplotlib - payload = plotting.prepare_shared_cluster_distribution_data(result=_make_shared_cluster_result()) - payload = dict(payload) - payload["metadata"] = {**payload["metadata"], "cluster_labels": ["C1"]} - payload["distribution_change"] = pd.DataFrame( - [ - { - "condition": "treated", - "cluster": "C3", - "count": 1, - "fraction": 0.25, - "replicate_n": 1, - "reference_fraction": 0.5, - "delta_fraction": -0.25, - "log2_fc": -1.0, - }, - { - "condition": "treated", - "cluster": "C20", - "count": 3, - "fraction": 0.75, - "replicate_n": 1, - "reference_fraction": 0.5, - "delta_fraction": 0.25, - "log2_fc": 1.0, - }, - { - "condition": "baseline", - "cluster": "C3", - "count": 2, - "fraction": 0.5, - "replicate_n": 1, - "reference_fraction": 0.5, - "delta_fraction": 0.0, - "log2_fc": 0.0, - }, - { - "condition": "baseline", - "cluster": "C20", - "count": 2, - "fraction": 0.5, - "replicate_n": 1, - "reference_fraction": 0.5, - "delta_fraction": 0.0, - "log2_fc": 0.0, - }, - ] + payload = plotting.prepare_shared_cluster_distribution_data( + result=_make_shared_cluster_result_with_explicit_display_order() ) fig, ax = plotting_matplotlib.plot_shared_cluster_change_matplotlib(payload) assert fig is not None assert ax is not None - assert [tick.get_text() for tick in ax.get_xticklabels()] == ["C3", "C20"] - assert [tick.get_text() for tick in ax.get_yticklabels()] == ["treated", "baseline"] + image = ax.images[0] - duplicate_payload = dict(payload) - duplicate_payload["distribution_change"] = pd.concat( - [payload["distribution_change"], payload["distribution_change"].iloc[[0]]], - ignore_index=True, + assert payload["metadata"]["change_condition_order"] == ["treated", "baseline"] + assert [tick.get_text() for tick in ax.get_xticklabels()] == ["C1", "C0"] + assert [tick.get_text() for tick in ax.get_yticklabels()] == ["treated", "baseline"] + assert image.origin == "upper" + np.testing.assert_allclose( + np.asarray(image.get_array()), + np.array([[5 / 12, -5 / 12], [0.0, 0.0]]), ) - with pytest.raises(ValueError, match="duplicate delta fractions"): - plotting_matplotlib.plot_shared_cluster_change_matplotlib(duplicate_payload) def _make_shared_cluster_profile_result() -> SharedClusterResult: From 0cbb0214c0b35378da863e955d168dbe9ce0faa6 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Fri, 10 Apr 2026 16:41:42 -0700 Subject: [PATCH 214/272] Fix shared cluster prepared payload ordering --- dimelo/plotting.py | 7 ----- dimelo/plotting_matplotlib.py | 27 ++-------------- tests/test_plotting.py | 58 +++++++++++++++++++++++++++++------ 3 files changed, 50 insertions(+), 42 deletions(-) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 1da2c2f..6596860 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -1274,7 +1274,6 @@ def prepare_shared_cluster_distribution_data( ) -> dict[str, pd.DataFrame | dict[str, object]]: _validate_shared_cluster_result(result) - sample_order = _ordered_non_null_values(result.cluster_distribution, "sample_id") sample_distribution = prepare_cluster_distribution_bar_data(result.cluster_distribution) _require_columns( @@ -1282,7 +1281,6 @@ def prepare_shared_cluster_distribution_data( ("condition", "cluster", "count", "fraction", "replicate_n"), "result.condition_distribution", ) - condition_order = _ordered_non_null_values(result.condition_distribution, "condition") condition_distribution = ( result.condition_distribution.loc[ :, ["condition", "cluster", "count", "fraction", "replicate_n"] @@ -1293,7 +1291,6 @@ def prepare_shared_cluster_distribution_data( if result.distribution_change is None: distribution_change = _empty_distribution_change_table() - change_condition_order: list[object] = [] else: _require_columns( result.distribution_change, @@ -1309,7 +1306,6 @@ def prepare_shared_cluster_distribution_data( ), "result.distribution_change", ) - change_condition_order = _ordered_non_null_values(result.distribution_change, "condition") distribution_change = ( result.distribution_change.loc[ :, @@ -1331,9 +1327,6 @@ def prepare_shared_cluster_distribution_data( metadata = { "mode": result.model.mode, "cluster_labels": list(result.model.cluster_labels), - "sample_order": sample_order, - "condition_order": condition_order, - "change_condition_order": change_condition_order, "has_distribution_change": not distribution_change.empty, } return { diff --git a/dimelo/plotting_matplotlib.py b/dimelo/plotting_matplotlib.py index 60d918a..4b7bac3 100644 --- a/dimelo/plotting_matplotlib.py +++ b/dimelo/plotting_matplotlib.py @@ -93,21 +93,6 @@ def _ordered_unique_values(table: pd.DataFrame, column: str) -> list[object]: return table.loc[:, column].drop_duplicates().tolist() -def _ordered_axis_values( - metadata: Mapping[str, object], - key: str, - observed_values: list[object], -) -> list[object]: - configured_values = list(metadata.get(key) or []) - if not configured_values: - return list(observed_values) - - observed_value_set = set(observed_values) - ordered_values = [value for value in configured_values if value in observed_value_set] - ordered_values.extend([value for value in observed_values if value not in configured_values]) - return ordered_values - - def _prepare_region_contrast_value_mode_table( plot_table: pd.DataFrame, *, @@ -381,11 +366,7 @@ def plot_shared_cluster_distribution_matplotlib( value_table = table.loc[:, [x_column, "cluster", "fraction"]].copy() if value_table.duplicated([x_column, "cluster"]).any(): raise ValueError("plot payload contains duplicate cluster fractions for the same x value.") - x_order = _ordered_axis_values( - metadata, - "sample_order" if level == "sample" else "condition_order", - _ordered_unique_values(value_table, x_column), - ) + x_order = _ordered_unique_values(value_table, x_column) cluster_order = _ordered_cluster_labels(metadata, _ordered_unique_values(value_table, "cluster")) pivot = value_table.set_index([x_column, "cluster"])["fraction"].unstack("cluster", fill_value=0.0) pivot = pivot.reindex(index=x_order, columns=cluster_order, fill_value=0.0) @@ -415,11 +396,7 @@ def plot_shared_cluster_change_matplotlib( value_table = change_table.loc[:, ["condition", "cluster", "delta_fraction"]].copy() if value_table.duplicated(["condition", "cluster"]).any(): raise ValueError("plot payload contains duplicate delta fractions for the same condition.") - condition_order = _ordered_axis_values( - metadata, - "change_condition_order", - _ordered_unique_values(value_table, "condition"), - ) + condition_order = _ordered_unique_values(value_table, "condition") cluster_order = _ordered_cluster_labels(metadata, _ordered_unique_values(value_table, "cluster")) matrix = value_table.set_index(["condition", "cluster"])["delta_fraction"].unstack("cluster", fill_value=0.0) matrix = matrix.reindex(index=condition_order, columns=cluster_order, fill_value=0.0) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 572154f..c02a05e 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -403,9 +403,9 @@ def test_prepare_shared_cluster_distribution_data_returns_distribution_payload() ) assert payload["metadata"]["mode"] == "region_anchored" assert payload["metadata"]["cluster_labels"] == ["C1", "C0"] - assert payload["metadata"]["sample_order"] == ["s1", "s2"] - assert payload["metadata"]["condition_order"] == ["NS", "treated"] - assert payload["metadata"]["change_condition_order"] == ["treated"] + assert "sample_order" not in payload["metadata"] + assert "condition_order" not in payload["metadata"] + assert "change_condition_order" not in payload["metadata"] def test_plotting_matplotlib_module_exports_save_figure(): @@ -468,22 +468,41 @@ def test_plot_shared_cluster_distribution_matplotlib_returns_figure_and_axis(): payload = plotting.prepare_shared_cluster_distribution_data( result=_make_shared_cluster_result_with_explicit_display_order() ) + assert payload["sample_distribution"]["sample_id"].tolist() == ["s1", "s1", "s2", "s2"] + assert payload["condition_distribution"]["condition"].tolist() == [ + "NS", + "NS", + "treated", + "treated", + ] fig, ax = plotting_matplotlib.plot_shared_cluster_distribution_matplotlib(payload, level="sample") assert fig is not None assert ax is not None - assert payload["metadata"]["sample_order"] == ["s2", "s1"] assert [text.get_text() for text in ax.get_legend().texts] == ["C1", "C0"] - assert [tick.get_text() for tick in ax.get_xticklabels() if tick.get_text()] == ["s2", "s1"] + assert [tick.get_text() for tick in ax.get_xticklabels() if tick.get_text()] == ["s1", "s2"] fig, ax = plotting_matplotlib.plot_shared_cluster_distribution_matplotlib(payload, level="condition") assert fig is not None assert ax is not None - assert payload["metadata"]["condition_order"] == ["treated", "NS"] assert [text.get_text() for text in ax.get_legend().texts] == ["C1", "C0"] - assert [tick.get_text() for tick in ax.get_xticklabels() if tick.get_text()] == ["treated", "NS"] + assert [tick.get_text() for tick in ax.get_xticklabels() if tick.get_text()] == ["NS", "treated"] + + +def test_plot_shared_cluster_distribution_matplotlib_rejects_duplicate_x_cluster_rows(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_distribution_data(result=_make_shared_cluster_result()) + duplicate_row = payload["sample_distribution"].iloc[[0]] + payload["sample_distribution"] = pd.concat( + [payload["sample_distribution"], duplicate_row], + ignore_index=True, + ) + + with pytest.raises(ValueError, match="duplicate cluster fractions"): + plotting_matplotlib.plot_shared_cluster_distribution_matplotlib(payload, level="sample") def test_plot_shared_cluster_change_matplotlib_returns_figure_and_axis(): @@ -492,6 +511,12 @@ def test_plot_shared_cluster_change_matplotlib_returns_figure_and_axis(): payload = plotting.prepare_shared_cluster_distribution_data( result=_make_shared_cluster_result_with_explicit_display_order() ) + assert payload["distribution_change"]["condition"].tolist() == [ + "baseline", + "baseline", + "treated", + "treated", + ] fig, ax = plotting_matplotlib.plot_shared_cluster_change_matplotlib(payload) @@ -499,15 +524,28 @@ def test_plot_shared_cluster_change_matplotlib_returns_figure_and_axis(): assert ax is not None image = ax.images[0] - assert payload["metadata"]["change_condition_order"] == ["treated", "baseline"] assert [tick.get_text() for tick in ax.get_xticklabels()] == ["C1", "C0"] - assert [tick.get_text() for tick in ax.get_yticklabels()] == ["treated", "baseline"] + assert [tick.get_text() for tick in ax.get_yticklabels()] == ["baseline", "treated"] assert image.origin == "upper" np.testing.assert_allclose( np.asarray(image.get_array()), - np.array([[5 / 12, -5 / 12], [0.0, 0.0]]), + np.array([[0.0, 0.0], [5 / 12, -5 / 12]]), + ) + + +def test_plot_shared_cluster_change_matplotlib_rejects_duplicate_condition_cluster_rows(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_distribution_data(result=_make_shared_cluster_result()) + duplicate_row = payload["distribution_change"].iloc[[0]] + payload["distribution_change"] = pd.concat( + [payload["distribution_change"], duplicate_row], + ignore_index=True, ) + with pytest.raises(ValueError, match="duplicate delta fractions"): + plotting_matplotlib.plot_shared_cluster_change_matplotlib(payload) + def _make_shared_cluster_profile_result() -> SharedClusterResult: return SharedClusterResult( From 9a4230d3d4163a54256eec1f461d6b33c20d8098 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Fri, 10 Apr 2026 16:49:29 -0700 Subject: [PATCH 215/272] test: add shared clustering profile renderer coverage --- tests/test_plotting.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index c02a05e..c93becd 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -607,6 +607,28 @@ def test_prepare_shared_cluster_profile_data_respects_feature_subset(): ] +def test_plot_shared_cluster_profile_heatmap_matplotlib_returns_figure_and_axis(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_profile_data(result=_make_shared_cluster_profile_result()) + + fig, ax = plotting_matplotlib.plot_shared_cluster_profile_heatmap_matplotlib(payload) + + assert fig is not None + assert ax is not None + + +def test_plot_shared_cluster_profile_series_matplotlib_returns_figure_and_axis(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_profile_data(result=_make_shared_cluster_profile_result()) + + fig, ax = plotting_matplotlib.plot_shared_cluster_profile_series_matplotlib(payload) + + assert fig is not None + assert ax is not None + + def _make_shared_cluster_region_result() -> SharedClusterResult: return SharedClusterResult( model=SharedClusterModel( From e34995406e2ecb63b2f6e12fdb3e76e84f2b15d8 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Fri, 10 Apr 2026 16:53:42 -0700 Subject: [PATCH 216/272] Fix sparse shared cluster change heatmap --- dimelo/plotting_matplotlib.py | 7 ++++--- tests/test_plotting.py | 24 ++++++++++++++++++++++++ 2 files changed, 28 insertions(+), 3 deletions(-) diff --git a/dimelo/plotting_matplotlib.py b/dimelo/plotting_matplotlib.py index 4b7bac3..b3b2f7c 100644 --- a/dimelo/plotting_matplotlib.py +++ b/dimelo/plotting_matplotlib.py @@ -398,9 +398,10 @@ def plot_shared_cluster_change_matplotlib( raise ValueError("plot payload contains duplicate delta fractions for the same condition.") condition_order = _ordered_unique_values(value_table, "condition") cluster_order = _ordered_cluster_labels(metadata, _ordered_unique_values(value_table, "cluster")) - matrix = value_table.set_index(["condition", "cluster"])["delta_fraction"].unstack("cluster", fill_value=0.0) - matrix = matrix.reindex(index=condition_order, columns=cluster_order, fill_value=0.0) - max_abs = float(matrix.abs().to_numpy().max()) if not matrix.empty else 0.0 + matrix = value_table.set_index(["condition", "cluster"])["delta_fraction"].unstack("cluster") + matrix = matrix.reindex(index=condition_order, columns=cluster_order) + finite_values = pd.Series(matrix.abs().to_numpy().ravel()).dropna() + max_abs = float(finite_values.max()) if not finite_values.empty else 0.0 if max_abs == 0.0: max_abs = 1.0 image = ax.imshow( diff --git a/tests/test_plotting.py b/tests/test_plotting.py index c93becd..3f45b7a 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -547,6 +547,30 @@ def test_plot_shared_cluster_change_matplotlib_rejects_duplicate_condition_clust plotting_matplotlib.plot_shared_cluster_change_matplotlib(payload) +def test_plot_shared_cluster_change_matplotlib_preserves_sparse_missing_pairs(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_distribution_data( + result=_make_shared_cluster_result_with_explicit_display_order() + ) + payload["distribution_change"] = payload["distribution_change"].iloc[[1, 2]].reset_index(drop=True) + + fig, ax = plotting_matplotlib.plot_shared_cluster_change_matplotlib(payload) + + assert fig is not None + assert ax is not None + image = ax.images[0] + matrix = np.asarray(image.get_array()) + + assert [tick.get_text() for tick in ax.get_xticklabels()] == ["C1", "C0"] + assert [tick.get_text() for tick in ax.get_yticklabels()] == ["baseline", "treated"] + assert image.origin == "upper" + assert np.isnan(matrix[0, 1]) + assert np.isnan(matrix[1, 0]) + assert matrix[0, 0] == pytest.approx(0.0) + assert matrix[1, 1] == pytest.approx(-5 / 12) + + def _make_shared_cluster_profile_result() -> SharedClusterResult: return SharedClusterResult( model=SharedClusterModel( From a44a535f7699edb52ae0123420e6da3bb7a306d5 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sat, 11 Apr 2026 14:11:03 -0700 Subject: [PATCH 217/272] fix: preserve sparse shared cluster change axes --- dimelo/plotting.py | 1 + dimelo/plotting_matplotlib.py | 13 +++++++-- tests/test_plotting.py | 50 +++++++++++++++++++++++++++++++++++ 3 files changed, 62 insertions(+), 2 deletions(-) diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 6596860..69ba170 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -1328,6 +1328,7 @@ def prepare_shared_cluster_distribution_data( "mode": result.model.mode, "cluster_labels": list(result.model.cluster_labels), "has_distribution_change": not distribution_change.empty, + "change_condition_order": distribution_change["condition"].drop_duplicates().tolist(), } return { "sample_distribution": sample_distribution, diff --git a/dimelo/plotting_matplotlib.py b/dimelo/plotting_matplotlib.py index b3b2f7c..0e17d6f 100644 --- a/dimelo/plotting_matplotlib.py +++ b/dimelo/plotting_matplotlib.py @@ -396,8 +396,17 @@ def plot_shared_cluster_change_matplotlib( value_table = change_table.loc[:, ["condition", "cluster", "delta_fraction"]].copy() if value_table.duplicated(["condition", "cluster"]).any(): raise ValueError("plot payload contains duplicate delta fractions for the same condition.") - condition_order = _ordered_unique_values(value_table, "condition") - cluster_order = _ordered_cluster_labels(metadata, _ordered_unique_values(value_table, "cluster")) + condition_order = list(metadata.get("change_condition_order") or []) + if not condition_order: + condition_order = _ordered_unique_values(value_table, "condition") + observed_clusters = _ordered_unique_values(value_table, "cluster") + cluster_order = list(metadata.get("cluster_labels") or []) + if cluster_order: + cluster_order.extend( + [cluster for cluster in observed_clusters if cluster not in cluster_order] + ) + else: + cluster_order = observed_clusters matrix = value_table.set_index(["condition", "cluster"])["delta_fraction"].unstack("cluster") matrix = matrix.reindex(index=condition_order, columns=cluster_order) finite_values = pd.Series(matrix.abs().to_numpy().ravel()).dropna() diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 3f45b7a..ffdcd3c 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -571,6 +571,56 @@ def test_plot_shared_cluster_change_matplotlib_preserves_sparse_missing_pairs(): assert matrix[1, 1] == pytest.approx(-5 / 12) +def test_plot_shared_cluster_change_matplotlib_preserves_missing_condition_row(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_distribution_data( + result=_make_shared_cluster_result_with_explicit_display_order() + ) + payload["distribution_change"] = payload["distribution_change"].loc[ + payload["distribution_change"]["condition"] == "treated" + ].reset_index(drop=True) + + fig, ax = plotting_matplotlib.plot_shared_cluster_change_matplotlib(payload) + + assert fig is not None + assert ax is not None + image = ax.images[0] + matrix = np.asarray(image.get_array()) + + assert [tick.get_text() for tick in ax.get_yticklabels()] == ["baseline", "treated"] + assert image.origin == "upper" + assert np.isnan(matrix[0, 0]) + assert np.isnan(matrix[0, 1]) + assert matrix[1, 0] == pytest.approx(5 / 12) + assert matrix[1, 1] == pytest.approx(-5 / 12) + + +def test_plot_shared_cluster_change_matplotlib_preserves_missing_cluster_column(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_distribution_data( + result=_make_shared_cluster_result_with_explicit_display_order() + ) + payload["distribution_change"] = payload["distribution_change"].loc[ + payload["distribution_change"]["cluster"] == "C1" + ].reset_index(drop=True) + + fig, ax = plotting_matplotlib.plot_shared_cluster_change_matplotlib(payload) + + assert fig is not None + assert ax is not None + image = ax.images[0] + matrix = np.asarray(image.get_array()) + + assert [tick.get_text() for tick in ax.get_xticklabels()] == ["C1", "C0"] + assert image.origin == "upper" + assert matrix[0, 0] == pytest.approx(0.0) + assert matrix[1, 0] == pytest.approx(5 / 12) + assert np.isnan(matrix[0, 1]) + assert np.isnan(matrix[1, 1]) + + def _make_shared_cluster_profile_result() -> SharedClusterResult: return SharedClusterResult( model=SharedClusterModel( From 7f7d1704af79fcf47584292dd1f39a05e17f601e Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sat, 11 Apr 2026 14:18:55 -0700 Subject: [PATCH 218/272] feat: add shared cluster profile renderers --- dimelo/plotting_matplotlib.py | 137 ++++++++++++++++++++++++++++++ tests/test_plotting.py | 152 ++++++++++++++++++++++++++++++++++ 2 files changed, 289 insertions(+) diff --git a/dimelo/plotting_matplotlib.py b/dimelo/plotting_matplotlib.py index 0e17d6f..dfc3272 100644 --- a/dimelo/plotting_matplotlib.py +++ b/dimelo/plotting_matplotlib.py @@ -434,6 +434,143 @@ def plot_shared_cluster_change_matplotlib( return fig, ax +def plot_shared_cluster_profile_heatmap_matplotlib( + payload: Mapping[str, object], + *, + ax=None, + title: str | None = None, +): + _require_payload_keys( + payload, + ("profile_table", "metadata"), + owner="plot_shared_cluster_profile_heatmap_matplotlib", + ) + profile_table = _require_payload_table(payload, "profile_table") + metadata = payload.get("metadata") + if not isinstance(metadata, Mapping): + raise TypeError("plot payload key 'metadata' must be a mapping.") + fig, ax = _make_axis(ax=ax, figsize=(8, 4)) + + value_table = profile_table.loc[:, ["cluster", "feature", "value"]].copy() + if value_table.duplicated(["cluster", "feature"]).any(): + raise ValueError("plot payload contains duplicate profile values for the same cluster and feature.") + + feature_order = list(metadata.get("feature_names") or []) + observed_features = _ordered_unique_values(value_table, "feature") + if feature_order: + feature_order.extend([feature for feature in observed_features if feature not in feature_order]) + else: + feature_order = observed_features + + observed_clusters = _ordered_unique_values(value_table, "cluster") + cluster_order = list(metadata.get("cluster_labels") or []) + if cluster_order: + cluster_order.extend([cluster for cluster in observed_clusters if cluster not in cluster_order]) + else: + cluster_order = observed_clusters + + if feature_order: + ax.set_xticks(range(len(feature_order))) + ax.set_xticklabels([str(value) for value in feature_order], rotation=45, ha="right") + if cluster_order: + ax.set_yticks(range(len(cluster_order))) + ax.set_yticklabels([str(value) for value in cluster_order]) + + if feature_order and cluster_order: + if value_table.empty: + matrix = pd.DataFrame(index=cluster_order, columns=feature_order, dtype=float) + else: + matrix = value_table.set_index(["cluster", "feature"])["value"].unstack("feature") + matrix = matrix.reindex(index=cluster_order, columns=feature_order) + if matrix.notna().any().any(): + image = ax.imshow( + matrix.to_numpy(), + aspect="auto", + origin="upper", + interpolation="nearest", + ) + ax.figure.colorbar(image, ax=ax, label="Value") + ax.set_xticks(range(len(matrix.columns))) + ax.set_xticklabels([str(value) for value in matrix.columns.tolist()], rotation=45, ha="right") + ax.set_yticks(range(len(matrix.index))) + ax.set_yticklabels([str(value) for value in matrix.index.tolist()]) + + ax.set_xlabel("Feature") + ax.set_ylabel("Cluster") + ax.set_title(title or "Shared cluster profiles") + return fig, ax + + +def plot_shared_cluster_profile_series_matplotlib( + payload: Mapping[str, object], + *, + ax=None, + title: str | None = None, +): + _require_payload_keys( + payload, + ("profile_table", "metadata"), + owner="plot_shared_cluster_profile_series_matplotlib", + ) + profile_table = _require_payload_table(payload, "profile_table") + metadata = payload.get("metadata") + if not isinstance(metadata, Mapping): + raise TypeError("plot payload key 'metadata' must be a mapping.") + fig, ax = _make_axis(ax=ax, figsize=(8, 4)) + + value_table = profile_table.loc[:, ["cluster", "feature", "value"]].copy() + if value_table.duplicated(["cluster", "feature"]).any(): + raise ValueError("plot payload contains duplicate profile values for the same cluster and feature.") + + feature_order = list(metadata.get("feature_names") or []) + observed_features = _ordered_unique_values(value_table, "feature") + if feature_order: + feature_order.extend([feature for feature in observed_features if feature not in feature_order]) + else: + feature_order = observed_features + feature_lookup = {feature: index for index, feature in enumerate(feature_order)} + + observed_clusters = _ordered_unique_values(value_table, "cluster") + cluster_order = list(metadata.get("cluster_labels") or []) + if cluster_order: + cluster_order.extend([cluster for cluster in observed_clusters if cluster not in cluster_order]) + else: + cluster_order = observed_clusters + + for cluster in cluster_order: + cluster_table = value_table.loc[value_table["cluster"] == cluster, ["feature", "value"]].copy() + if feature_order: + cluster_table["feature_order"] = cluster_table["feature"].map(feature_lookup) + cluster_table = cluster_table.sort_values("feature_order", kind="stable") + cluster_series = cluster_table.set_index("feature_order")["value"].reindex( + range(len(feature_order)) + ) + cluster_series = cluster_series.astype(float) + x_values = cluster_series.index.tolist() + y_values = cluster_series.to_numpy() + else: + x_values = [] + y_values = [] + ax.plot( + x_values, + y_values, + marker="o", + linewidth=1.5, + label=str(cluster), + ) + + if feature_order: + ax.set_xticks(range(len(feature_order))) + ax.set_xticklabels(feature_order, rotation=45, ha="right") + if ax.lines: + ax.legend(title="Cluster") + + ax.set_xlabel("Feature") + ax.set_ylabel("Value") + ax.set_title(title or "Shared cluster profile series") + return fig, ax + + def plot_global_analysis_summary_matplotlib( payload: Mapping[str, object], *, diff --git a/tests/test_plotting.py b/tests/test_plotting.py index ffdcd3c..291d60e 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -652,6 +652,37 @@ def _make_shared_cluster_profile_result() -> SharedClusterResult: ) +def _make_shared_cluster_profile_result_with_explicit_display_order() -> SharedClusterResult: + return SharedClusterResult( + model=SharedClusterModel( + mode="region_anchored", + motifs=["A,0"], + feature_names=["f1", "f0"], + preprocessing={"signal_normalization": "none"}, + estimator=object(), + cluster_labels=["C1", "C0"], + fit_metadata={"clusterer": "minibatch_kmeans", "n_clusters": 2}, + ), + assignments=pd.DataFrame(columns=["sample_id", "condition", "cluster"]), + cluster_distribution=pd.DataFrame( + columns=["sample_id", "condition", "cluster", "count", "fraction"] + ), + condition_distribution=pd.DataFrame( + columns=["condition", "cluster", "count", "fraction", "replicate_n"] + ), + distribution_change=None, + cluster_profiles=pd.DataFrame( + [ + {"cluster": "C0", "count": 3, "f0": 0.1, "f1": 0.2}, + {"cluster": "C1", "count": 4, "f0": 0.8, "f1": 0.9}, + ] + ), + region_summaries=None, + plot_data={}, + metadata={"mode": "region_anchored"}, + ) + + def test_prepare_shared_cluster_profile_data_returns_long_form_profiles(): result = _make_shared_cluster_profile_result() @@ -692,6 +723,58 @@ def test_plot_shared_cluster_profile_heatmap_matplotlib_returns_figure_and_axis( assert ax is not None +def test_plot_shared_cluster_profile_heatmap_matplotlib_preserves_payload_order(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_profile_data( + result=_make_shared_cluster_profile_result_with_explicit_display_order() + ) + + fig, ax = plotting_matplotlib.plot_shared_cluster_profile_heatmap_matplotlib(payload) + + assert fig is not None + assert ax is not None + image = ax.images[0] + + assert [tick.get_text() for tick in ax.get_xticklabels()] == ["f1", "f0"] + assert [tick.get_text() for tick in ax.get_yticklabels()] == ["C1", "C0"] + assert image.origin == "upper" + np.testing.assert_allclose( + np.asarray(image.get_array()), + np.array([[0.9, 0.8], [0.2, 0.1]]), + ) + + +def test_plot_shared_cluster_profile_heatmap_matplotlib_rejects_duplicate_cluster_feature_rows(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_profile_data(result=_make_shared_cluster_profile_result()) + duplicate_row = payload["profile_table"].iloc[[0]] + payload["profile_table"] = pd.concat( + [payload["profile_table"], duplicate_row], + ignore_index=True, + ) + + with pytest.raises(ValueError, match="duplicate profile values"): + plotting_matplotlib.plot_shared_cluster_profile_heatmap_matplotlib(payload) + + +def test_plot_shared_cluster_profile_heatmap_matplotlib_handles_empty_payload(): + from dimelo import plotting_matplotlib + + result = _make_shared_cluster_profile_result() + result.cluster_profiles = pd.DataFrame(columns=["cluster", "count", "f0", "f1"]) + payload = plotting.prepare_shared_cluster_profile_data(result=result) + + fig, ax = plotting_matplotlib.plot_shared_cluster_profile_heatmap_matplotlib(payload) + + assert fig is not None + assert ax is not None + assert len(ax.images) == 0 + assert [tick.get_text() for tick in ax.get_xticklabels()] == ["f0", "f1"] + assert [tick.get_text() for tick in ax.get_yticklabels()] == ["C0", "C1"] + + def test_plot_shared_cluster_profile_series_matplotlib_returns_figure_and_axis(): from dimelo import plotting_matplotlib @@ -703,6 +786,75 @@ def test_plot_shared_cluster_profile_series_matplotlib_returns_figure_and_axis() assert ax is not None +def test_plot_shared_cluster_profile_series_matplotlib_preserves_payload_order(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_profile_data( + result=_make_shared_cluster_profile_result_with_explicit_display_order() + ) + + fig, ax = plotting_matplotlib.plot_shared_cluster_profile_series_matplotlib(payload) + + assert fig is not None + assert ax is not None + assert [tick.get_text() for tick in ax.get_xticklabels()] == ["f1", "f0"] + assert [line.get_label() for line in ax.lines] == ["C1", "C0"] + np.testing.assert_allclose(ax.lines[0].get_xdata(), np.array([0, 1])) + np.testing.assert_allclose(ax.lines[0].get_ydata(), np.array([0.9, 0.8])) + np.testing.assert_allclose(ax.lines[1].get_xdata(), np.array([0, 1])) + np.testing.assert_allclose(ax.lines[1].get_ydata(), np.array([0.2, 0.1])) + + +def test_plot_shared_cluster_profile_series_matplotlib_rejects_duplicate_cluster_feature_rows(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_profile_data(result=_make_shared_cluster_profile_result()) + duplicate_row = payload["profile_table"].iloc[[0]] + payload["profile_table"] = pd.concat( + [payload["profile_table"], duplicate_row], + ignore_index=True, + ) + + with pytest.raises(ValueError, match="duplicate profile values"): + plotting_matplotlib.plot_shared_cluster_profile_series_matplotlib(payload) + + +def test_plot_shared_cluster_profile_series_matplotlib_preserves_missing_cluster_line(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_profile_data( + result=_make_shared_cluster_profile_result_with_explicit_display_order() + ) + payload["profile_table"] = payload["profile_table"].loc[ + payload["profile_table"]["cluster"] == "C1" + ].reset_index(drop=True) + + fig, ax = plotting_matplotlib.plot_shared_cluster_profile_series_matplotlib(payload) + + assert fig is not None + assert ax is not None + assert [line.get_label() for line in ax.lines] == ["C1", "C0"] + np.testing.assert_allclose(ax.lines[0].get_ydata(), np.array([0.9, 0.8])) + assert np.isnan(ax.lines[1].get_ydata()).all() + + +def test_plot_shared_cluster_profile_series_matplotlib_handles_empty_payload(): + from dimelo import plotting_matplotlib + + result = _make_shared_cluster_profile_result() + result.cluster_profiles = pd.DataFrame(columns=["cluster", "count", "f0", "f1"]) + payload = plotting.prepare_shared_cluster_profile_data(result=result) + + fig, ax = plotting_matplotlib.plot_shared_cluster_profile_series_matplotlib(payload) + + assert fig is not None + assert ax is not None + assert [tick.get_text() for tick in ax.get_xticklabels()] == ["f0", "f1"] + assert [line.get_label() for line in ax.lines] == ["C0", "C1"] + assert np.isnan(ax.lines[0].get_ydata()).all() + assert np.isnan(ax.lines[1].get_ydata()).all() + + def _make_shared_cluster_region_result() -> SharedClusterResult: return SharedClusterResult( model=SharedClusterModel( From 0c03c9f8a3aa4e5180111469cef7c811af0309e9 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sat, 11 Apr 2026 14:19:37 -0700 Subject: [PATCH 219/272] test: add shared clustering region renderer coverage --- tests/test_plotting.py | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 291d60e..0d9f6c3 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -1018,6 +1018,31 @@ def test_prepare_shared_cluster_region_data_rejects_missing_region_summaries(): plotting.prepare_shared_cluster_region_data(result=result) +def test_plot_shared_cluster_region_matplotlib_defaults_to_condition_level(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_region_data(result=_make_shared_cluster_region_result()) + + fig, ax = plotting_matplotlib.plot_shared_cluster_region_matplotlib(payload) + + assert fig is not None + assert ax is not None + + +def test_plot_shared_cluster_region_matplotlib_supports_sample_level(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_region_data(result=_make_shared_cluster_region_result()) + + fig, ax = plotting_matplotlib.plot_shared_cluster_region_matplotlib( + payload, + level="sample", + ) + + assert fig is not None + assert ax is not None + + def _minimal_region_contrast_result() -> RegionContrastResult: regions = pd.DataFrame( [ From 693ddfeb5b1ee45b550476e20ad6d120a7ac10f6 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sat, 11 Apr 2026 14:23:52 -0700 Subject: [PATCH 220/272] feat: add shared clustering region renderer --- dimelo/plotting_matplotlib.py | 64 +++++++++++++++++++++++++++++++++++ tests/test_plotting.py | 32 ++++++++++++++++++ 2 files changed, 96 insertions(+) diff --git a/dimelo/plotting_matplotlib.py b/dimelo/plotting_matplotlib.py index dfc3272..15514c5 100644 --- a/dimelo/plotting_matplotlib.py +++ b/dimelo/plotting_matplotlib.py @@ -571,6 +571,70 @@ def plot_shared_cluster_profile_series_matplotlib( return fig, ax +def plot_shared_cluster_region_matplotlib( + payload: Mapping[str, object], + *, + level: str = "condition", + ax=None, + title: str | None = None, +): + _require_payload_keys( + payload, + ("region_table", "condition_region_table", "metadata"), + owner="plot_shared_cluster_region_matplotlib", + ) + if level not in {"sample", "condition"}: + raise ValueError("level must be 'sample' or 'condition'.") + + table = _require_payload_table( + payload, + "condition_region_table" if level == "condition" else "region_table", + ) + metadata = payload.get("metadata") + if not isinstance(metadata, Mapping): + raise TypeError("plot payload key 'metadata' must be a mapping.") + fig, ax = _make_axis(ax=ax, figsize=(8, 4)) + + value_column = "fraction_mean" if level == "condition" else "fraction" + label_column = "condition" if level == "condition" else "sample_id" + value_table = table.loc[:, ["region_id", label_column, "cluster", value_column]].copy() + value_table["row_id"] = value_table.loc[:, ["region_id", label_column]].astype(str).agg(" | ".join, axis=1) + if value_table.duplicated(["row_id", "cluster"]).any(): + raise ValueError("plot payload contains duplicate region occupancy values for the same row and cluster.") + + row_order = _ordered_unique_values(value_table, "row_id") + observed_clusters = _ordered_unique_values(value_table, "cluster") + cluster_order = list(metadata.get("cluster_labels") or []) + if cluster_order: + cluster_order.extend([cluster for cluster in observed_clusters if cluster not in cluster_order]) + else: + cluster_order = observed_clusters + + if cluster_order: + ax.set_xticks(range(len(cluster_order))) + ax.set_xticklabels([str(value) for value in cluster_order], rotation=45, ha="right") + if row_order: + ax.set_yticks(range(len(row_order))) + ax.set_yticklabels([str(value) for value in row_order]) + + if row_order and cluster_order: + matrix = value_table.set_index(["row_id", "cluster"])[value_column].unstack("cluster") + matrix = matrix.reindex(index=row_order, columns=cluster_order) + if matrix.notna().any().any(): + image = ax.imshow( + matrix.to_numpy(), + aspect="auto", + origin="upper", + interpolation="nearest", + ) + ax.figure.colorbar(image, ax=ax, label=value_column.replace("_", " ").title()) + + ax.set_xlabel("Cluster") + ax.set_ylabel("Region / Condition" if level == "condition" else "Region / Sample") + ax.set_title(title or "Shared cluster region occupancy") + return fig, ax + + def plot_global_analysis_summary_matplotlib( payload: Mapping[str, object], *, diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 0d9f6c3..756180c 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -1027,6 +1027,15 @@ def test_plot_shared_cluster_region_matplotlib_defaults_to_condition_level(): assert fig is not None assert ax is not None + image = ax.images[0] + + assert [tick.get_text() for tick in ax.get_xticklabels()] == ["C0", "C1"] + assert [tick.get_text() for tick in ax.get_yticklabels()] == ["reg1 | NS", "reg1 | treated"] + assert image.origin == "upper" + np.testing.assert_allclose( + np.asarray(image.get_array()), + np.array([[2 / 3, 1 / 3], [1 / 4, 3 / 4]]), + ) def test_plot_shared_cluster_region_matplotlib_supports_sample_level(): @@ -1041,6 +1050,29 @@ def test_plot_shared_cluster_region_matplotlib_supports_sample_level(): assert fig is not None assert ax is not None + image = ax.images[0] + + assert [tick.get_text() for tick in ax.get_xticklabels()] == ["C0", "C1"] + assert [tick.get_text() for tick in ax.get_yticklabels()] == ["reg1 | s1", "reg1 | s2"] + assert image.origin == "upper" + np.testing.assert_allclose( + np.asarray(image.get_array()), + np.array([[2 / 3, 1 / 3], [1 / 4, 3 / 4]]), + ) + + +def test_plot_shared_cluster_region_matplotlib_rejects_duplicate_row_cluster_values(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_shared_cluster_region_data(result=_make_shared_cluster_region_result()) + duplicate_row = payload["condition_region_table"].iloc[[0]] + payload["condition_region_table"] = pd.concat( + [payload["condition_region_table"], duplicate_row], + ignore_index=True, + ) + + with pytest.raises(ValueError, match="duplicate region occupancy values"): + plotting_matplotlib.plot_shared_cluster_region_matplotlib(payload) def _minimal_region_contrast_result() -> RegionContrastResult: From c0862a5f6f9f8cb351e2ed996492d045a031783a Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sat, 11 Apr 2026 14:24:17 -0700 Subject: [PATCH 221/272] docs: add shared clustering renderer examples --- README.md | 4 +++ docs/shared-clustering.md | 65 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 69 insertions(+) diff --git a/README.md b/README.md index 46799f3..4184579 100644 --- a/README.md +++ b/README.md @@ -243,6 +243,10 @@ For discovery-to-clustering-to-contrast follow-up, use `workflows.discovery_clus For users who want built-in figures instead of only payload tables, `dimelo.plotting_matplotlib` provides an optional Matplotlib renderer layer on top of those prepared payloads, plus `save_figure(...)` for PNG/PDF export. +`shared_clustering` also supports built-in Matplotlib rendering through +`dimelo.plotting_matplotlib`, including cluster-distribution, profile, and +region-occupancy views on top of the prepared clustering payloads. + `region_contrasts` also now supports `analysis_unit="single_read"` for extract-backed defined-region comparison. Use `representation="read_mod_fraction"` for per-read motif fractions or `representation="read_window_features"` for diff --git a/docs/shared-clustering.md b/docs/shared-clustering.md index ac61bca..2031047 100644 --- a/docs/shared-clustering.md +++ b/docs/shared-clustering.md @@ -107,6 +107,71 @@ The plotting contract stays compatibility-safe with older package versions: - fixed-window plotting is available for both aggregate and single-read views - scaled or segmented metaregion axes are aggregate-only and are not used for single-read plots +## Built-In Matplotlib Renderers + +`dimelo.plotting_matplotlib` also provides an optional built-in renderer layer on +top of these prepared payloads. This is a convenience layer, not a replacement +for the stable tables in `result.plot_data` or the renderer-neutral prep helpers. + +Cluster distribution example: + +```python +from dimelo import plotting, plotting_matplotlib + +distribution_payload = plotting.prepare_shared_cluster_distribution_data(result=result) +fig, ax = plotting_matplotlib.plot_shared_cluster_distribution_matplotlib( + distribution_payload, + level="sample", +) +plotting_matplotlib.save_figure(fig, "shared-cluster-distribution.png") +``` + +Condition-level cluster-change heatmap: + +```python +fig, ax = plotting_matplotlib.plot_shared_cluster_change_matplotlib( + distribution_payload, +) +``` + +Cluster profile heatmap example: + +```python +profile_payload = plotting.prepare_shared_cluster_profile_data(result=result) +fig, ax = plotting_matplotlib.plot_shared_cluster_profile_heatmap_matplotlib(profile_payload) +``` + +Cluster profile series example: + +```python +fig, ax = plotting_matplotlib.plot_shared_cluster_profile_series_matplotlib(profile_payload) +``` + +Region occupancy example: + +```python +region_payload = plotting.prepare_shared_cluster_region_data(result=result) +fig, ax = plotting_matplotlib.plot_shared_cluster_region_matplotlib( + region_payload, + level="condition", +) +``` + +The default region occupancy view is condition-level because it is usually the +main biological summary. Sample-level occupancy remains available when you want +replicate inspection or QC: + +```python +fig, ax = plotting_matplotlib.plot_shared_cluster_region_matplotlib( + region_payload, + level="sample", +) +``` + +The older `result.plot_data["cluster_distribution_bar"]` and +`result.plot_data["cluster_distribution_heatmap"]` payloads remain supported for +users updating from earlier package versions. + ## Custom Plotting ```python From 612529573dc8effced477ddb42676493d4cd9c55 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sat, 11 Apr 2026 14:26:11 -0700 Subject: [PATCH 222/272] fix: tighten shared clustering renderer support --- tests/test_plotting.py | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 756180c..2a5a13b 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -13,6 +13,16 @@ from dimelo import plot_enrichment_profile, plot_reads, plotting +@pytest.fixture(autouse=True) +def _close_matplotlib_figures(): + yield + try: + from matplotlib import pyplot as plt + except ImportError: + return + plt.close("all") + + def test_axis_spec_accepts_fixed_window_region_5to3(): spec = plotting.AxisSpec( orientation="region_5to3", @@ -403,9 +413,9 @@ def test_prepare_shared_cluster_distribution_data_returns_distribution_payload() ) assert payload["metadata"]["mode"] == "region_anchored" assert payload["metadata"]["cluster_labels"] == ["C1", "C0"] + assert payload["metadata"]["change_condition_order"] == ["treated"] assert "sample_order" not in payload["metadata"] assert "condition_order" not in payload["metadata"] - assert "change_condition_order" not in payload["metadata"] def test_plotting_matplotlib_module_exports_save_figure(): From 5c9ca8b02a2da77b0895e0ce9216076e4c19db3a Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sat, 11 Apr 2026 14:30:14 -0700 Subject: [PATCH 223/272] docs: align shared clustering plotting docs --- README.md | 2 +- docs/shared-clustering.md | 6 ++++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 4184579..8e8c8f4 100644 --- a/README.md +++ b/README.md @@ -239,7 +239,7 @@ For discovery-to-clustering-to-contrast follow-up, use `workflows.discovery_clus `global_analysis` now exposes renderer-neutral plotting prep helpers that consume `GlobalAnalysisResult`: `prepare_global_analysis_summary_data(...)` prepares sample-level summaries, optional condition-level views, and normalization tables, while `prepare_global_analysis_window_data(...)` prepares broad-window payloads that stay per-contig by default. -`region_contrasts` uses the same data-prep-first plotting layer: `prepare_region_contrast_profile_data(...)` and `prepare_region_contrast_heatmap_data(...)` consume a `RegionContrastResult` plus an explicit positional table, while shared clustering currently keeps lighter plotting coverage through plot-ready tables in `result.plot_data`. +`region_contrasts` uses the same data-prep-first plotting layer: `prepare_region_contrast_profile_data(...)` and `prepare_region_contrast_heatmap_data(...)` consume a `RegionContrastResult` plus an explicit positional table, and shared clustering now exposes the same style of renderer-neutral prep helpers on top of its canonical result tables. For users who want built-in figures instead of only payload tables, `dimelo.plotting_matplotlib` provides an optional Matplotlib renderer layer on top of those prepared payloads, plus `save_figure(...)` for PNG/PDF export. diff --git a/docs/shared-clustering.md b/docs/shared-clustering.md index 2031047..b69fed7 100644 --- a/docs/shared-clustering.md +++ b/docs/shared-clustering.md @@ -76,9 +76,11 @@ The workflow returns a `SharedClusterResult` with canonical tables: `result.region_summaries` is also the standard occupancy handoff into `dimelo.region_contrasts` when you want per-region `cluster_fraction`, `dominant_cluster`, or `cluster_entropy` follow-up instead of only global cluster distributions. -Built-in plotting remains intentionally thin. `result.plot_data["cluster_distribution_bar"]` and `result.plot_data["cluster_distribution_heatmap"]` are plot-ready DataFrames, not renderer-specific figure objects. +Shared clustering now follows the same layered plotting structure as the other newer analysis families: -This is lighter plotting coverage than the newer analysis-specific helpers in `region_contrasts`, `region_discovery`, and `global_analysis`, which now expose dedicated renderer-neutral plotting-prep functions around their result objects. +- canonical tables on the result object +- renderer-neutral prep helpers in `dimelo.plotting` +- optional built-in Matplotlib renderers in `dimelo.plotting_matplotlib` ## Plotting Prep Helpers From 11b715d5c629b91af16c90730a75a42089a4acfe Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sun, 12 Apr 2026 13:31:42 -0700 Subject: [PATCH 224/272] docs: add shared cluster tests design spec --- .../2026-04-12-shared-cluster-tests-design.md | 449 ++++++++++++++++++ 1 file changed, 449 insertions(+) create mode 100644 docs/superpowers/specs/2026-04-12-shared-cluster-tests-design.md diff --git a/docs/superpowers/specs/2026-04-12-shared-cluster-tests-design.md b/docs/superpowers/specs/2026-04-12-shared-cluster-tests-design.md new file mode 100644 index 0000000..4984575 --- /dev/null +++ b/docs/superpowers/specs/2026-04-12-shared-cluster-tests-design.md @@ -0,0 +1,449 @@ +# Shared Cluster Tests Design + +## Summary + +Add a new inference layer for shared clustering that stays separate from +`workflows.shared_cluster_distribution(...)` and consumes an existing +`SharedClusterResult`. + +This layer should answer two related but distinct questions: + +- global cluster-composition change across conditions or timepoints +- per-region occupancy change through the existing `region_contrasts` path + +The new work in this spec is the global composition side. Region-level occupancy +inference should remain in `region_contrasts.score_regions(...)`, which already +accepts `analysis_unit="cluster_occupancy"` and consumes +`SharedClusterResult.region_summaries`. + +## Goals + +- Add a user-facing inference entry point for global shared-cluster composition. +- Reuse the existing `ContrastSpec` model for package-wide consistency. +- Keep replicate-aware testing as the default inferential path. +- Support pooled count tests such as chi-squared only as explicit screening + options. +- Support both pairwise/group contrasts and ordered time-course contrasts. +- Support both unpaired and paired designs through explicit `pairing_key` + declarations. +- Return a result object shaped similarly to current contrast-style results. +- Provide renderer-neutral `plot_data` payloads for summary and per-cluster + follow-up views. + +## Non-Goals + +- Do not add inferential testing directly into `shared_cluster_distribution(...)`. +- Do not replace or subsume `region_contrasts` region-level occupancy inference. +- Do not add formal v1 testing for `dominant_cluster` or `cluster_entropy`. +- Do not implement a batch multi-contrast API in v1. +- Do not add Matplotlib renderers in the same slice unless a later plan + explicitly calls for them. +- Do not add model-heavy compositional methods such as Dirichlet-multinomial + regression in v1. + +## Why A Separate Shared-Cluster Test Layer + +`SharedClusterResult` is currently descriptive. It stores assignments, +distribution summaries, feature profiles, and optional region occupancy tables. +That is the correct boundary for the clustering workflow itself. + +Formal testing should sit downstream for the same reasons the plotting layer now +sits downstream: + +- clustering should remain a reusable descriptive artifact +- testing has different assumptions and failure modes than clustering +- users should be able to choose descriptive use only, inferential use only, or + both + +The design should therefore add a new analysis helper rather than overloading +the workflow that constructs `SharedClusterResult`. + +## Recommended API Shape + +Add a new public entry point: + +```python +shared_cluster_tests( + *, + result: SharedClusterResult, + contrast: ContrastSpec, + test: str = "permutation", + multiple_testing: str = "fdr_bh", + n_permutations: int = 1000, + random_state: int | None = 42, + include_pairwise: bool = False, +) -> SharedClusterContrastResult +``` + +Exact keyword names can vary slightly, but the public contract should stay: + +- one `SharedClusterResult` per call +- one `ContrastSpec` per call +- explicit test selection +- optional paired structure declared explicitly inside `ContrastSpec` +- one result object with canonical tables plus `plot_data` + +## Why Reuse `ContrastSpec` + +The package already has a contrast vocabulary in `dimelo.models.ContrastSpec`: + +- `pairwise` +- `matched_pairwise` +- `group_vs_group` +- `time_course` +- `pairing_key` + +Reusing `ContrastSpec` is the least confusing option because users do not need a +second contrast schema for shared-clustering inference. + +Shared-cluster testing should still validate which modes are supported. In v1: + +- supported: + - `pairwise` + - `matched_pairwise` + - `group_vs_group` + - `time_course` +- unsupported: + - `background_adjusted` + - `single_dataset` + +`ContrastSpec.pairing_key` should be the only pairing declaration surface for +shared-cluster testing. The inference entry point should not add a second +parallel `pairing_key` argument. + +## Analysis Boundaries + +### Global Composition Testing + +This new layer should test condition- or time-associated changes in overall +cluster composition using: + +- `result.cluster_distribution` for sample-level cluster fractions +- `result.condition_distribution` for descriptive summaries + +The biological question is: + +- do samples differ consistently in their cluster mixture? + +This is distinct from per-region occupancy testing. + +### Region Occupancy Testing + +Region occupancy inference should remain in `region_contrasts.score_regions(...)` +with: + +- `analysis_unit="cluster_occupancy"` +- `signal_source="cluster_occupancy"` +- `occupancy_table=result.region_summaries` + +For v1 robustness: + +- formal inference remains focused on `representation="cluster_fraction"` +- `dominant_cluster` and `cluster_entropy` remain descriptive + +This preserves existing architecture and avoids a confusing “one function does +everything” surface. + +## Statistical Policy + +### Default Inference Policy + +Formal inference should be replicate-aware by default. + +Reasoning: + +- pooled read counts are not biological replicates +- pooled tests can become misleadingly significant with deep read counts +- sample-level cluster fractions better reflect biological variability + +Therefore: + +- default v1 global test path should operate at the sample level +- pooled count tests are allowed only as explicit screening options + +### Pooled Screening Tests + +Allowed only when the user explicitly requests them: + +- `chi_squared` +- `g_test` + +These tests should be clearly labeled in result metadata as pooled count +screening analyses, not the default primary inference result when replicates are +available. + +### Replicate-Aware Primary Tests + +The recommended v1 primary test family is permutation-based inference on +sample-level cluster fractions. + +Reasoning: + +- more robust than asymptotic pooled-count tests +- more flexible for awkward cluster-fraction distributions +- easier to extend to paired and time-course designs +- easier to explain than model-heavy compositional approaches + +V1 should support: + +- omnibus permutation testing for global composition change +- per-cluster permutation follow-up tests + +### Deferred Model-Based Methods + +The following should be deferred to a later version: + +- Dirichlet-multinomial regression +- multinomial logistic regression +- more complex mixed models for repeated measures + +Those methods may become useful later, but they add implementation and +interpretation complexity that is unnecessary for the first version. + +## Supported Contrast Families + +### Pairwise And Group-Vs-Group + +Support: + +- unpaired `pairwise` +- paired `matched_pairwise` +- `group_vs_group` + +The default result should include: + +- omnibus composition-level inference +- per-cluster follow-up inference + +### Time-Course + +Support ordered time-course testing in v1. + +This should include two distinct outputs: + +- ordered trend test +- omnibus “any timepoint differs” test + +Optional pairwise follow-up may be included when explicitly requested, but it +should not be the primary headline result. + +### Paired Longitudinal Designs + +Paired time-course support should be allowed when a valid explicit pairing +structure is supplied. + +The implementation does not need to solve every longitudinal model in v1; it +does need to: + +- validate matched structure explicitly +- apply a paired-compatible permutation or resampling scheme +- fail clearly when the requested design is unsupported by the observed sample + layout + +## Pairing Declaration + +Pairing should be declared explicitly through a `pairing_key`, not inferred from +sample IDs and not hidden inside condition group definitions. + +The least confusing and most robust policy is: + +- unpaired analyses: `pairing_key is None` +- paired analyses: `pairing_key` names a metadata field or canonical sample + column identifying matched subjects/blocks + +The implementation should validate: + +- all requested paired samples have non-null pairing keys +- each matched pair/block has the required conditions or timepoints +- no ambiguous duplicate mapping exists within a pair/block for the requested + test + +## Result Object Shape + +Add a new result model: + +```python +SharedClusterContrastResult +``` + +It should follow the same broad style as current contrast-style outputs: + +- `summary` +- `details` +- optional `pairwise` +- `plot_data` +- `metadata` + +### `summary` + +This is the headline table. + +For pairwise/group contrasts it should usually have one row per contrast. + +Recommended fields: + +- `contrast_id` +- `mode` +- `test` +- `composition_effect_size` +- `effect_size_metric` +- `omnibus_p_value` +- `omnibus_adjusted_p_value` when relevant +- `trend_p_value` when relevant +- `top_cluster` +- `top_cluster_delta_fraction` +- `numerator_replicate_n` +- `denominator_replicate_n` +- `rank` + +### `details` + +This is the main per-cluster follow-up table. + +Recommended fields for pairwise/group contrasts: + +- `cluster` +- `fraction` +- `reference_fraction` +- `delta_fraction` +- `log2_fc` +- `effect_size` +- `p_value` +- `adjusted_p_value` +- `numerator_replicate_n` +- `denominator_replicate_n` +- `rank` + +For time-course, `details` may additionally include: + +- `timepoint` +- `mean_fraction` +- `trend_statistic` +- `trend_p_value` + +### `pairwise` + +Optional table produced only when requested for time-course or multi-group +follow-up. + +This should stay secondary. Users should not have to read `pairwise` to answer +the primary question. + +### `metadata` + +This should capture: + +- test family +- permutation count +- random seed when used +- multiple-testing policy +- whether the analysis is pooled or replicate-aware +- whether the design is paired +- warnings about missing replicates, degenerate clusters, or unsupported + follow-up paths + +## Effect Size Policy + +The most interpretable top-level effect size for global composition is a single +overall composition-distance metric. + +V1 should use a simple, explainable measure such as: + +- total variation distance / L1-derived composition distance + +This is preferable to leading with only a p-value or only the top changed +cluster. + +The top-level summary should therefore combine: + +- one overall composition effect size +- one overall inferential result +- one concise cluster-level highlight such as `top_cluster` + +## Plot Data + +The result should include renderer-neutral `plot_data`. + +V1 should provide payloads for both: + +- global summary views +- per-cluster follow-up views + +Recommended payload families: + +- `summary_table` + - headline contrast-level rows for report-card style summaries +- `cluster_effect_table` + - per-cluster fractions, deltas, effect sizes, p-values, adjusted p-values +- `time_course_table` + - per-timepoint cluster fractions when `contrast.mode == "time_course"` +- optional `pairwise_table` + - only when pairwise follow-up is explicitly requested + +These payloads should remain renderer-neutral so later Matplotlib or external +plotting code can consume them directly. + +## Validation Rules + +The implementation should fail early and clearly for: + +- unsupported `ContrastSpec.mode` +- missing required tables on `SharedClusterResult` +- missing requested conditions or timepoints +- paired analyses without valid `pairing_key` +- paired analyses with incomplete or ambiguous matching +- replicate-aware tests requested with too few replicates +- unsupported `multiple_testing` policy +- unsupported `test` choice for the requested contrast/design + +Where possible, the function should return descriptive effect sizes even when a +formal p-value path is unavailable, but only if that behavior is explicit in the +API and metadata. + +## Documentation Expectations + +User-facing docs should make three boundaries explicit: + +- `shared_cluster_distribution(...)` remains descriptive +- `shared_cluster_tests(...)` handles global composition inference +- `region_contrasts.score_regions(..., analysis_unit="cluster_occupancy")` + remains the route for per-region occupancy inference + +The docs should also be explicit that: + +- pooled chi-squared or G-test is screening-oriented +- replicate-aware tests are the default inferential path +- region-level formal testing in v1 focuses on `cluster_fraction` + +## Implementation Order + +Recommended order: + +1. add the new result model +2. add failing tests for global shared-cluster inference entry point +3. implement validation and sample-level summary helpers +4. implement pairwise/group replicate-aware permutation tests +5. implement pooled chi-squared / G-test screening option +6. implement time-course omnibus and trend paths +7. add `plot_data` +8. add docs + +## Recommended Approach + +Three approaches were considered: + +1. add a dedicated `shared_cluster_tests(...)` layer +2. extend `shared_cluster_distribution(...)` directly with testing +3. fold global composition testing into `region_contrasts` + +Approach 1 is recommended because it: + +- preserves the descriptive boundary of clustering +- matches the existing result-centric architecture +- keeps global composition and per-region occupancy conceptually separate +- allows reuse of `ContrastSpec` without overloading unrelated region-level + semantics + +Approaches 2 and 3 would be more confusing because they would mix descriptive +workflow construction with inference, or mix global and region-level biology +under one API surface. From e663a448468f3aba9f504a59da9b9791303da5bd Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sun, 12 Apr 2026 13:37:34 -0700 Subject: [PATCH 225/272] docs: add shared cluster tests implementation plan --- .../plans/2026-04-12-shared-cluster-tests.md | 783 ++++++++++++++++++ 1 file changed, 783 insertions(+) create mode 100644 docs/superpowers/plans/2026-04-12-shared-cluster-tests.md diff --git a/docs/superpowers/plans/2026-04-12-shared-cluster-tests.md b/docs/superpowers/plans/2026-04-12-shared-cluster-tests.md new file mode 100644 index 0000000..d80a560 --- /dev/null +++ b/docs/superpowers/plans/2026-04-12-shared-cluster-tests.md @@ -0,0 +1,783 @@ +# Shared Cluster Tests Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Add a new result-centric inference layer for global shared-cluster composition that consumes `SharedClusterResult`, reuses `ContrastSpec`, supports replicate-aware permutation testing plus optional pooled chi-squared / G-test screening, and returns contrast-style result tables plus plot-ready payloads. + +**Architecture:** Keep `workflows.shared_cluster_distribution(...)` descriptive and add a separate `dimelo.shared_cluster_tests` module. The new module should consume existing shared-clustering tables, derive sample-level evidence, and return a `SharedClusterContrastResult` with `summary`, `details`, optional `pairwise`, `plot_data`, and `metadata`. Region-level occupancy inference remains in `dimelo.region_contrasts`, while a small workflow tweak propagates `SampleSpec.metadata` into shared-cluster assignments so `ContrastSpec.pairing_key` has a reliable metadata source. + +**Tech Stack:** Python 3.11, pandas, numpy, scipy.stats, pytest, existing `dimelo.models`, `dimelo.workflows`, `dimelo.region_contrasts`, `dimelo.plotting`-style result conventions + +--- + +## File Map + +- Create: `dimelo/shared_cluster_tests.py` + - public `shared_cluster_tests(...)` + - contrast-mode validation + - sample-level evidence builders + - permutation, chi-squared, and G-test scoring helpers + - result assembly and `plot_data` +- Modify: `dimelo/models.py` + - add `SharedClusterContrastResult` +- Modify: `dimelo/__init__.py` + - export `shared_cluster_tests` +- Modify: `dimelo/workflows.py` + - propagate `SampleSpec.metadata` keys into shared-cluster assignment rows +- Create: `tests/test_shared_cluster_tests.py` + - focused inference-layer coverage +- Modify: `tests/test_models.py` + - result-model validation coverage +- Modify: `tests/test_workflows.py` + - workflow metadata propagation coverage for paired designs +- Modify: `README.md` + - mention `shared_cluster_tests(...)` and the boundary vs `region_contrasts` +- Modify: `docs/shared-clustering.md` + - add user-facing examples and inference-boundary guidance + +## Task 1: Add Failing Tests For The Result Model And Module Skeleton + +**Files:** +- Create: `tests/test_shared_cluster_tests.py` +- Modify: `tests/test_models.py` +- Reference: `dimelo/shared_cluster_tests.py` +- Reference: `dimelo/models.py` + +- [ ] **Step 1: Write the failing module-import and result-model tests** + +Add this near the existing result-model coverage in `tests/test_models.py`: + +```python +from dimelo.models import SharedClusterContrastResult + + +def test_shared_cluster_contrast_result_requires_summary_details_and_plot_data(): + with pytest.raises(ValueError, match="SharedClusterContrastResult requires non-None values"): + SharedClusterContrastResult( + summary=None, + details=pd.DataFrame(), + plot_data={}, + ) +``` + +Create `tests/test_shared_cluster_tests.py` with: + +```python +import pandas as pd + + +def test_shared_cluster_tests_module_exports_entry_point(): + from dimelo import shared_cluster_tests + + assert hasattr(shared_cluster_tests, "shared_cluster_tests") + + +def test_shared_cluster_tests_rejects_unsupported_contrast_mode(): + from dimelo import shared_cluster_tests + from dimelo.models import ContrastSpec + + result = _make_shared_cluster_test_result() + + with pytest.raises(NotImplementedError, match="background_adjusted"): + shared_cluster_tests.shared_cluster_tests( + result=result, + contrast=ContrastSpec( + mode="background_adjusted", + numerator=["treated"], + denominator=["NS"], + background=["bg"], + ), + ) +``` + +- [ ] **Step 2: Run the focused tests to verify they fail** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_models.py tests/test_shared_cluster_tests.py -k "shared_cluster_contrast_result or shared_cluster_tests_module_exports_entry_point or shared_cluster_tests_rejects_unsupported_contrast_mode" -q +``` + +Expected: FAIL because `SharedClusterContrastResult` and `dimelo.shared_cluster_tests` do not yet exist. + +- [ ] **Step 3: Commit the failing tests** + +```bash +git add tests/test_models.py tests/test_shared_cluster_tests.py +git commit -m "test: add shared cluster tests skeleton coverage" +``` + +## Task 2: Add `SharedClusterContrastResult` And The Module Skeleton + +**Files:** +- Create: `dimelo/shared_cluster_tests.py` +- Modify: `dimelo/models.py` +- Modify: `dimelo/__init__.py` +- Modify: `tests/test_models.py` +- Modify: `tests/test_shared_cluster_tests.py` + +- [ ] **Step 1: Add the new result model** + +Add this dataclass in `dimelo/models.py` near the other result models: + +```python +@dataclass +class SharedClusterContrastResult: + summary: pd.DataFrame + details: pd.DataFrame + pairwise: pd.DataFrame | None = None + plot_data: dict[str, pd.DataFrame | dict[str, Any]] = field(default_factory=dict) + metadata: dict[str, Any] = field(default_factory=dict) + + def __post_init__(self) -> None: + required_fields = { + "summary": self.summary, + "details": self.details, + "plot_data": self.plot_data, + "metadata": self.metadata, + } + missing = [name for name, value in required_fields.items() if value is None] + if missing: + raise ValueError( + "SharedClusterContrastResult requires non-None values for: " + f"{', '.join(missing)}" + ) +``` + +- [ ] **Step 2: Create the module skeleton and export it** + +Create `dimelo/shared_cluster_tests.py` with: + +```python +from __future__ import annotations + +from dimelo.models import ContrastSpec, SharedClusterContrastResult + + +def _require_supported_shared_cluster_mode(contrast: ContrastSpec) -> None: + supported = {"pairwise", "matched_pairwise", "group_vs_group", "time_course"} + if contrast.mode not in supported: + raise NotImplementedError( + f"Shared cluster tests are not implemented for contrast mode '{contrast.mode}'." + ) + + +def shared_cluster_tests( + *, + result, + contrast: ContrastSpec, + test: str = "permutation", + multiple_testing: str = "fdr_bh", + n_permutations: int = 1000, + random_state: int | None = 42, + include_pairwise: bool = False, +) -> SharedClusterContrastResult: + _require_supported_shared_cluster_mode(contrast) + raise NotImplementedError("shared_cluster_tests is not implemented yet.") +``` + +Update `dimelo/__init__.py`: + +```python +from . import ( + ... + shared_cluster_tests, + ... +) + +__all__ = [ + ... + "shared_cluster_tests", + ... +] +``` + +- [ ] **Step 3: Run the focused tests to verify they pass** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_models.py tests/test_shared_cluster_tests.py -k "shared_cluster_contrast_result or shared_cluster_tests_module_exports_entry_point or shared_cluster_tests_rejects_unsupported_contrast_mode" -q +``` + +Expected: PASS. + +- [ ] **Step 4: Commit the skeleton** + +```bash +git add dimelo/models.py dimelo/shared_cluster_tests.py dimelo/__init__.py tests/test_models.py tests/test_shared_cluster_tests.py +git commit -m "feat: add shared cluster tests module skeleton" +``` + +## Task 3: Add Failing Tests For Pairing-Metadata Propagation From Workflows + +**Files:** +- Modify: `tests/test_workflows.py` +- Modify: `dimelo/workflows.py` +- Reference: `dimelo/shared_cluster_tests.py` + +- [ ] **Step 1: Write the failing workflow metadata propagation test** + +Add this near the existing shared-clustering workflow tests in `tests/test_workflows.py`: + +```python +def test_shared_cluster_distribution_propagates_sample_metadata_into_assignments(monkeypatch): + monkeypatch.setattr(workflows.cluster, "extract_read_windows", _fake_extract_result) + monkeypatch.setattr(workflows.cluster, "read_window_feature_matrix", _fake_feature_matrix) + monkeypatch.setattr(workflows.cluster, "cluster_read_windows", _fake_cluster_fit_result) + + result = workflows.shared_cluster_distribution( + samples=[ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + metadata={"subject_id": "mouse-1"}, + ), + SampleSpec( + sample_id="s2", + condition="treated", + extract_h5="s2.h5", + metadata={"subject_id": "mouse-2"}, + ), + ], + mode="read_global", + motifs=["A,0"], + n_clusters=2, + ) + + assert "subject_id" in result.assignments.columns + assert set(result.assignments["subject_id"]) == {"mouse-1", "mouse-2"} +``` + +- [ ] **Step 2: Run the focused test to verify it fails** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_workflows.py -k "propagates_sample_metadata_into_assignments" -q +``` + +Expected: FAIL because `SampleSpec.metadata` is not yet propagated into shared-cluster assignments. + +- [ ] **Step 3: Implement the minimal workflow tweak** + +Update the metadata-row construction in `dimelo/workflows.py`: + +```python + for metadata in extracted.metadata: + row = { + "sample_id": sample.sample_id, + "condition": sample.condition, + "replicate": sample.replicate, + } + if sample.metadata: + row.update(sample.metadata) + row.update(metadata) + metadata_rows.append(row) +``` + +For the region-anchored path, add the same metadata merge before +`_build_shared_cluster_result(...)` by enriching `metadata_rows` by `sample_id`. + +- [ ] **Step 4: Run the focused test to verify it passes** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_workflows.py -k "propagates_sample_metadata_into_assignments" -q +``` + +Expected: PASS. + +- [ ] **Step 5: Commit the workflow metadata support** + +```bash +git add dimelo/workflows.py tests/test_workflows.py +git commit -m "feat: propagate shared cluster sample metadata" +``` + +## Task 4: Add Failing Tests For Pairwise And Group Permutation Inference + +**Files:** +- Modify: `tests/test_shared_cluster_tests.py` +- Reference: `dimelo/shared_cluster_tests.py` + +- [ ] **Step 1: Add a compact shared-cluster inference fixture** + +Add this helper in `tests/test_shared_cluster_tests.py`: + +```python +def _make_shared_cluster_test_result() -> SharedClusterResult: + return SharedClusterResult( + model=SharedClusterModel( + mode="read_global", + motifs=["A,0"], + feature_names=["f0", "f1"], + preprocessing={"signal_normalization": "none"}, + estimator=object(), + cluster_labels=["C0", "C1"], + fit_metadata={"clusterer": "minibatch_kmeans", "n_clusters": 2}, + ), + assignments=pd.DataFrame( + { + "sample_id": ["s1", "s2", "s3", "s4"], + "condition": ["NS", "NS", "treated", "treated"], + "subject_id": ["p1", "p2", "p1", "p2"], + "cluster": ["C0", "C0", "C1", "C1"], + } + ), + cluster_distribution=pd.DataFrame( + [ + {"sample_id": "s1", "condition": "NS", "cluster": "C0", "count": 80, "fraction": 0.80}, + {"sample_id": "s1", "condition": "NS", "cluster": "C1", "count": 20, "fraction": 0.20}, + {"sample_id": "s2", "condition": "NS", "cluster": "C0", "count": 75, "fraction": 0.75}, + {"sample_id": "s2", "condition": "NS", "cluster": "C1", "count": 25, "fraction": 0.25}, + {"sample_id": "s3", "condition": "treated", "cluster": "C0", "count": 30, "fraction": 0.30}, + {"sample_id": "s3", "condition": "treated", "cluster": "C1", "count": 70, "fraction": 0.70}, + {"sample_id": "s4", "condition": "treated", "cluster": "C0", "count": 25, "fraction": 0.25}, + {"sample_id": "s4", "condition": "treated", "cluster": "C1", "count": 75, "fraction": 0.75}, + ] + ), + condition_distribution=pd.DataFrame( + [ + {"condition": "NS", "cluster": "C0", "count": 155, "fraction": 0.775, "replicate_n": 2}, + {"condition": "NS", "cluster": "C1", "count": 45, "fraction": 0.225, "replicate_n": 2}, + {"condition": "treated", "cluster": "C0", "count": 55, "fraction": 0.275, "replicate_n": 2}, + {"condition": "treated", "cluster": "C1", "count": 145, "fraction": 0.725, "replicate_n": 2}, + ] + ), + distribution_change=None, + cluster_profiles=pd.DataFrame(columns=["cluster", "count", "f0", "f1"]), + region_summaries=None, + plot_data={}, + metadata={}, + ) +``` + +- [ ] **Step 2: Write failing pairwise and matched-pairwise tests** + +Add these tests: + +```python +def test_shared_cluster_tests_pairwise_returns_summary_details_and_plot_data(): + from dimelo import shared_cluster_tests + from dimelo.models import ContrastSpec + + result = shared_cluster_tests.shared_cluster_tests( + result=_make_shared_cluster_test_result(), + contrast=ContrastSpec(mode="pairwise", numerator=["treated"], denominator=["NS"]), + test="permutation", + n_permutations=50, + random_state=7, + ) + + assert set(result.summary.columns) >= { + "contrast_id", "composition_effect_size", "omnibus_p_value", "top_cluster" + } + assert set(result.details.columns) >= { + "cluster", "fraction", "reference_fraction", "delta_fraction", "p_value", "adjusted_p_value" + } + assert set(result.plot_data) >= {"summary_table", "cluster_effect_table"} + + +def test_shared_cluster_tests_matched_pairwise_uses_contrast_pairing_key(): + from dimelo import shared_cluster_tests + from dimelo.models import ContrastSpec + + result = shared_cluster_tests.shared_cluster_tests( + result=_make_shared_cluster_test_result(), + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["treated"], + denominator=["NS"], + pairing_key="subject_id", + ), + test="permutation", + n_permutations=50, + random_state=7, + ) + + assert result.metadata["paired"] is True + assert result.metadata["pairing_key"] == "subject_id" +``` + +- [ ] **Step 3: Run the focused tests to verify they fail** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_shared_cluster_tests.py -k "pairwise_returns_summary_details_and_plot_data or matched_pairwise_uses_contrast_pairing_key" -q +``` + +Expected: FAIL because `shared_cluster_tests(...)` is still a stub. + +- [ ] **Step 4: Implement pairwise/group permutation helpers** + +In `dimelo/shared_cluster_tests.py`, add the following minimal helper set: + +```python +def _sample_fraction_table(result) -> pd.DataFrame: + required = {"sample_id", "condition", "cluster", "fraction"} + missing = required - set(result.cluster_distribution.columns) + if missing: + raise ValueError(f"Shared cluster tests require cluster_distribution columns: {', '.join(sorted(missing))}.") + return result.cluster_distribution.loc[:, ["sample_id", "condition", "cluster", "fraction"]].copy() + + +def _cluster_order(result) -> list[str]: + return list(result.model.cluster_labels) + + +def _composition_effect_size(summary_table: pd.DataFrame) -> float: + return float(summary_table["delta_fraction"].abs().sum() / 2.0) +``` + +Then implement the pairwise/group path to: + +- build sample-level cluster fraction evidence +- compute condition means +- compute per-cluster `fraction`, `reference_fraction`, `delta_fraction`, `log2_fc` +- compute omnibus statistic from the L1 / total-variation shift +- compute permutation p-values +- add BH-adjusted per-cluster p-values +- assemble `summary`, `details`, `plot_data`, and `metadata` + +- [ ] **Step 5: Run the focused tests to verify they pass** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_shared_cluster_tests.py -k "pairwise_returns_summary_details_and_plot_data or matched_pairwise_uses_contrast_pairing_key" -q +``` + +Expected: PASS. + +- [ ] **Step 6: Commit the pairwise/group inference path** + +```bash +git add dimelo/shared_cluster_tests.py tests/test_shared_cluster_tests.py +git commit -m "feat: add shared cluster pairwise inference" +``` + +## Task 5: Add Failing Tests For Pooled Screening Tests + +**Files:** +- Modify: `tests/test_shared_cluster_tests.py` +- Reference: `dimelo/shared_cluster_tests.py` + +- [ ] **Step 1: Write failing chi-squared and G-test coverage** + +Add: + +```python +def test_shared_cluster_tests_supports_chi_squared_screen(): + from dimelo import shared_cluster_tests + from dimelo.models import ContrastSpec + + result = shared_cluster_tests.shared_cluster_tests( + result=_make_shared_cluster_test_result(), + contrast=ContrastSpec(mode="pairwise", numerator=["treated"], denominator=["NS"]), + test="chi_squared", + ) + + assert result.metadata["inference_level"] == "pooled_screen" + assert result.summary.loc[0, "test"] == "chi_squared" + + +def test_shared_cluster_tests_supports_g_test_screen(): + from dimelo import shared_cluster_tests + from dimelo.models import ContrastSpec + + result = shared_cluster_tests.shared_cluster_tests( + result=_make_shared_cluster_test_result(), + contrast=ContrastSpec(mode="pairwise", numerator=["treated"], denominator=["NS"]), + test="g_test", + ) + + assert result.summary.loc[0, "test"] == "g_test" + assert 0.0 <= result.summary.loc[0, "omnibus_p_value"] <= 1.0 +``` + +- [ ] **Step 2: Run the focused tests to verify they fail** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_shared_cluster_tests.py -k "chi_squared_screen or g_test_screen" -q +``` + +Expected: FAIL because pooled screening tests are not yet implemented. + +- [ ] **Step 3: Implement pooled count screening** + +Add helpers in `dimelo/shared_cluster_tests.py`: + +```python +def _pooled_count_table(result, contrast: ContrastSpec) -> pd.DataFrame: + table = result.cluster_distribution.loc[:, ["sample_id", "condition", "cluster", "count"]].copy() + return table +``` + +Then implement: + +- pooled numerator and denominator cluster-count vectors +- `scipy.stats.chi2_contingency(...)` for `chi_squared` +- `scipy.stats.power_divergence(..., lambda_="log-likelihood")` or equivalent for `g_test` +- summary row with pooled-screen metadata +- per-cluster descriptive `details` rows without replicate-aware p-values + +- [ ] **Step 4: Run the focused tests to verify they pass** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_shared_cluster_tests.py -k "chi_squared_screen or g_test_screen" -q +``` + +Expected: PASS. + +- [ ] **Step 5: Commit the pooled screening path** + +```bash +git add dimelo/shared_cluster_tests.py tests/test_shared_cluster_tests.py +git commit -m "feat: add shared cluster pooled screening tests" +``` + +## Task 6: Add Failing Tests For Time-Course Inference + +**Files:** +- Modify: `tests/test_shared_cluster_tests.py` +- Reference: `dimelo/shared_cluster_tests.py` + +- [ ] **Step 1: Add a compact time-course fixture and failing tests** + +Add: + +```python +def _make_shared_cluster_time_course_result() -> SharedClusterResult: + result = _make_shared_cluster_test_result() + result.cluster_distribution = pd.DataFrame( + [ + {"sample_id": "t0_a", "condition": "t0", "cluster": "C0", "count": 80, "fraction": 0.80}, + {"sample_id": "t0_a", "condition": "t0", "cluster": "C1", "count": 20, "fraction": 0.20}, + {"sample_id": "t1_a", "condition": "t1", "cluster": "C0", "count": 55, "fraction": 0.55}, + {"sample_id": "t1_a", "condition": "t1", "cluster": "C1", "count": 45, "fraction": 0.45}, + {"sample_id": "t2_a", "condition": "t2", "cluster": "C0", "count": 25, "fraction": 0.25}, + {"sample_id": "t2_a", "condition": "t2", "cluster": "C1", "count": 75, "fraction": 0.75}, + ] + ) + return result + + +def test_shared_cluster_tests_time_course_returns_omnibus_and_trend_outputs(): + from dimelo import shared_cluster_tests + from dimelo.models import ContrastSpec + + result = shared_cluster_tests.shared_cluster_tests( + result=_make_shared_cluster_time_course_result(), + contrast=ContrastSpec(mode="time_course", time_order=["t0", "t1", "t2"]), + test="permutation", + n_permutations=50, + random_state=7, + ) + + assert {"omnibus_p_value", "trend_p_value", "composition_effect_size"} <= set(result.summary.columns) + assert "time_course_table" in result.plot_data + + +def test_shared_cluster_tests_time_course_optional_pairwise_follow_up(): + from dimelo import shared_cluster_tests + from dimelo.models import ContrastSpec + + result = shared_cluster_tests.shared_cluster_tests( + result=_make_shared_cluster_time_course_result(), + contrast=ContrastSpec(mode="time_course", time_order=["t0", "t1", "t2"]), + test="permutation", + include_pairwise=True, + n_permutations=20, + random_state=7, + ) + + assert result.pairwise is not None +``` + +- [ ] **Step 2: Run the focused tests to verify they fail** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_shared_cluster_tests.py -k "time_course_returns_omnibus_and_trend_outputs or time_course_optional_pairwise_follow_up" -q +``` + +Expected: FAIL because time-course inference is not yet implemented. + +- [ ] **Step 3: Implement time-course support** + +In `dimelo/shared_cluster_tests.py`, add: + +- a time-order validator +- an omnibus permutation statistic across timepoints +- a trend statistic using ordered time indices +- optional pairwise follow-up expansion when `include_pairwise=True` + +Use helper signatures like: + +```python +def _require_time_order_present(table: pd.DataFrame, time_order: list[str]) -> None: + ... + + +def _score_time_course( + *, + sample_table: pd.DataFrame, + contrast: ContrastSpec, + n_permutations: int, + random_state: int | None, + include_pairwise: bool, +) -> SharedClusterContrastResult: + ... +``` + +- [ ] **Step 4: Run the focused tests to verify they pass** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_shared_cluster_tests.py -k "time_course_returns_omnibus_and_trend_outputs or time_course_optional_pairwise_follow_up" -q +``` + +Expected: PASS. + +- [ ] **Step 5: Commit the time-course path** + +```bash +git add dimelo/shared_cluster_tests.py tests/test_shared_cluster_tests.py +git commit -m "feat: add shared cluster time course inference" +``` + +## Task 7: Add User-Facing Docs + +**Files:** +- Modify: `README.md` +- Modify: `docs/shared-clustering.md` + +- [ ] **Step 1: Add a short README note** + +Add near the existing shared-clustering analysis guide text: + +```md +Global shared-cluster composition inference is available through +`dimelo.shared_cluster_tests.shared_cluster_tests(...)`, which consumes a +`SharedClusterResult` plus a `ContrastSpec`. Per-region occupancy inference +continues to live in `region_contrasts.score_regions(..., analysis_unit="cluster_occupancy")`. +``` + +- [ ] **Step 2: Add shared-clustering guide examples** + +Add examples in `docs/shared-clustering.md`: + +```python +from dimelo import shared_cluster_tests +from dimelo.models import ContrastSpec + +contrast_result = shared_cluster_tests.shared_cluster_tests( + result=result, + contrast=ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["NS"], + ), +) +``` + +And a paired example: + +```python +contrast_result = shared_cluster_tests.shared_cluster_tests( + result=result, + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["treated"], + denominator=["NS"], + pairing_key="subject_id", + ), +) +``` + +Also add boundary text that: + +- `shared_cluster_tests(...)` is for global composition +- `region_contrasts.score_regions(...)` remains the route for region occupancy +- pooled chi-squared / G-test is screening-oriented + +- [ ] **Step 3: Commit the docs** + +```bash +git add README.md docs/shared-clustering.md +git commit -m "docs: add shared cluster tests guide" +``` + +## Task 8: Final Verification And Self-Review + +**Files:** +- Reference: `dimelo/shared_cluster_tests.py` +- Reference: `dimelo/models.py` +- Reference: `dimelo/workflows.py` +- Reference: `tests/test_models.py` +- Reference: `tests/test_shared_cluster_tests.py` +- Reference: `tests/test_workflows.py` +- Reference: `README.md` +- Reference: `docs/shared-clustering.md` + +- [ ] **Step 1: Run the focused shared-cluster inference suite** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_shared_cluster_tests.py -q +``` + +Expected: PASS. + +- [ ] **Step 2: Run the model and workflow regression subset** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_models.py tests/test_workflows.py -k "shared_cluster_contrast_result or shared_cluster_distribution" -q +``` + +Expected: PASS. + +- [ ] **Step 3: Run a clean status check** + +Run: + +```bash +git status --short +``` + +Expected: clean working tree. + +- [ ] **Step 4: Self-review against the spec** + +Confirm explicitly that: + +- `shared_cluster_distribution(...)` remains descriptive +- `shared_cluster_tests(...)` consumes `SharedClusterResult` +- `ContrastSpec` is reused rather than replaced +- replicate-aware permutation is the default path +- pooled chi-squared / G-test is explicit and labeled as screening +- pairwise, matched pairwise, group-vs-group, and time-course are covered +- `region_contrasts` remains the occupancy-inference route +- `plot_data` exists for both summary and per-cluster follow-up + +- [ ] **Step 5: Commit a small follow-up only if verification finds a real issue** + +```bash +git add dimelo/shared_cluster_tests.py dimelo/models.py dimelo/workflows.py tests/test_models.py tests/test_shared_cluster_tests.py tests/test_workflows.py README.md docs/shared-clustering.md +git commit -m "fix: tighten shared cluster tests support" +``` + +Only make this commit if final verification or self-review uncovers a concrete follow-up issue. From a31ce635818250cb68c02821ee614c466b8bfadc Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sun, 12 Apr 2026 13:42:07 -0700 Subject: [PATCH 226/272] test: add shared cluster tests skeleton coverage --- tests/test_models.py | 13 ++++++++ tests/test_shared_cluster_tests.py | 51 ++++++++++++++++++++++++++++++ 2 files changed, 64 insertions(+) create mode 100644 tests/test_shared_cluster_tests.py diff --git a/tests/test_models.py b/tests/test_models.py index 8154685..b2081ec 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -17,6 +17,7 @@ RegionContrastResult, SharedClusterModel, SharedClusterResult, + SharedClusterContrastResult, ) @@ -287,6 +288,18 @@ def test_shared_cluster_result_rejects_none_core_outputs(field_name): SharedClusterResult(**kwargs) +def test_shared_cluster_contrast_result_requires_summary_details_and_plot_data(): + with pytest.raises( + ValueError, + match="SharedClusterContrastResult requires non-None values", + ): + SharedClusterContrastResult( + summary=None, + details=pd.DataFrame(), + plot_data={}, + ) + + def test_global_analysis_result_supports_summary_windows_and_normalization(): result = GlobalAnalysisResult( summary=pd.DataFrame({"sample_id": ["s1"]}), diff --git a/tests/test_shared_cluster_tests.py b/tests/test_shared_cluster_tests.py new file mode 100644 index 0000000..7ca43e1 --- /dev/null +++ b/tests/test_shared_cluster_tests.py @@ -0,0 +1,51 @@ +import pandas as pd +import pytest + +from dimelo.models import ContrastSpec, SharedClusterModel, SharedClusterResult + + +def _make_shared_cluster_test_result() -> SharedClusterResult: + model = SharedClusterModel( + mode="shared", + motifs=["A,0"], + feature_names=["A,0_mod_fraction"], + preprocessing={"scale": "standard"}, + estimator=object(), + cluster_labels=["cluster-1"], + fit_metadata={"random_state": 7}, + ) + return SharedClusterResult( + model=model, + assignments=pd.DataFrame({"cluster": ["cluster-1"]}), + cluster_distribution=pd.DataFrame({"cluster": ["cluster-1"]}), + condition_distribution=pd.DataFrame({"condition": ["treated"]}), + distribution_change=None, + cluster_profiles=pd.DataFrame({"profile": [1.0]}), + region_summaries=None, + plot_data={"cluster_distribution_bar": {"kind": "bar"}}, + figures={}, + metadata={"notes": "ok"}, + ) + + +def test_shared_cluster_tests_module_exports_entry_point(): + from dimelo import shared_cluster_tests + + assert hasattr(shared_cluster_tests, "shared_cluster_tests") + + +def test_shared_cluster_tests_rejects_unsupported_contrast_mode(): + from dimelo import shared_cluster_tests + + result = _make_shared_cluster_test_result() + + with pytest.raises(NotImplementedError, match="background_adjusted"): + shared_cluster_tests.shared_cluster_tests( + result=result, + contrast=ContrastSpec( + mode="background_adjusted", + numerator=["treated"], + denominator=["NS"], + background=["bg"], + ), + ) From 4529ad4718fd693376637c993003c57e68e651bb Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sun, 12 Apr 2026 13:48:15 -0700 Subject: [PATCH 227/272] feat: add shared cluster tests module skeleton --- dimelo/__init__.py | 9 ++++++++- dimelo/models.py | 25 +++++++++++++++++++++++++ dimelo/shared_cluster_tests.py | 25 +++++++++++++++++++++++++ tests/test_models.py | 1 + 4 files changed, 59 insertions(+), 1 deletion(-) create mode 100644 dimelo/shared_cluster_tests.py diff --git a/dimelo/__init__.py b/dimelo/__init__.py index 2ec7673..14d88b4 100644 --- a/dimelo/__init__.py +++ b/dimelo/__init__.py @@ -17,9 +17,14 @@ region_discovery, region_analysis, region_contrasts, + shared_cluster_tests, workflows, ) -from .models import RegionDiscoveryClusterContrastResult, RegionDiscoveryClusterResult +from .models import ( + RegionDiscoveryClusterContrastResult, + RegionDiscoveryClusterResult, + SharedClusterContrastResult, +) __all__ = [ "cluster", @@ -40,7 +45,9 @@ "region_discovery", "region_analysis", "region_contrasts", + "shared_cluster_tests", "RegionDiscoveryClusterContrastResult", "RegionDiscoveryClusterResult", + "SharedClusterContrastResult", "workflows", ] diff --git a/dimelo/models.py b/dimelo/models.py index f3ed1f5..971abb7 100644 --- a/dimelo/models.py +++ b/dimelo/models.py @@ -148,6 +148,31 @@ def __post_init__(self) -> None: ) +@dataclass +class SharedClusterContrastResult: + summary: pd.DataFrame + details: pd.DataFrame + pairwise: pd.DataFrame | None = None + plot_data: dict[str, pd.DataFrame | dict[str, Any]] = field(default_factory=dict) + figures: dict[str, Any] = field(default_factory=dict) + metadata: dict[str, Any] = field(default_factory=dict) + + def __post_init__(self) -> None: + required_fields = { + "summary": self.summary, + "details": self.details, + "plot_data": self.plot_data, + "figures": self.figures, + "metadata": self.metadata, + } + missing = [name for name, value in required_fields.items() if value is None] + if missing: + raise ValueError( + "SharedClusterContrastResult requires non-None values for: " + f"{', '.join(missing)}" + ) + + @dataclass class GlobalAnalysisResult: summary: pd.DataFrame diff --git a/dimelo/shared_cluster_tests.py b/dimelo/shared_cluster_tests.py new file mode 100644 index 0000000..4e52971 --- /dev/null +++ b/dimelo/shared_cluster_tests.py @@ -0,0 +1,25 @@ +from __future__ import annotations + +from dimelo.models import ContrastSpec, SharedClusterContrastResult, SharedClusterResult + + +def _require_supported_shared_cluster_mode(contrast: ContrastSpec) -> None: + supported = {"pairwise", "matched_pairwise", "group_vs_group", "time_course"} + if contrast.mode not in supported: + raise NotImplementedError( + f"Shared cluster tests are not implemented for contrast mode '{contrast.mode}'." + ) + + +def shared_cluster_tests( + *, + result: SharedClusterResult, + contrast: ContrastSpec, + test: str = "permutation", + multiple_testing: str = "fdr_bh", + n_permutations: int = 1000, + random_state: int | None = 42, + include_pairwise: bool = False, +) -> SharedClusterContrastResult: + _require_supported_shared_cluster_mode(contrast) + raise NotImplementedError("shared_cluster_tests is not implemented yet.") diff --git a/tests/test_models.py b/tests/test_models.py index b2081ec..d20e12c 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -297,6 +297,7 @@ def test_shared_cluster_contrast_result_requires_summary_details_and_plot_data() summary=None, details=pd.DataFrame(), plot_data={}, + figures={}, ) From df0c5f406c20067d8a6905e9375d63e66f4bb621 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Sun, 12 Apr 2026 13:56:20 -0700 Subject: [PATCH 228/272] feat: propagate shared cluster sample metadata --- dimelo/workflows.py | 17 ++++ tests/test_workflows.py | 214 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 231 insertions(+) diff --git a/dimelo/workflows.py b/dimelo/workflows.py index 6e5a147..f65bbea 100644 --- a/dimelo/workflows.py +++ b/dimelo/workflows.py @@ -76,6 +76,18 @@ def _coerce_artifacts(sample: SampleSpec) -> list[DatasetArtifact]: return coerced +def _merge_sample_metadata( + row: dict[str, Any], + sample_metadata: dict[str, Any] | None, +) -> dict[str, Any]: + if not sample_metadata: + return row + for key, value in sample_metadata.items(): + if key not in row: + row[key] = value + return row + + def _requested_extract_artifact( sample: SampleSpec, *, @@ -791,6 +803,10 @@ def shared_cluster_distribution( matched_regions=matched_regions, pileup_paths=pileup_paths, ) + sample_by_id = {sample.sample_id: sample for sample in sample_list} + for row in metadata_rows: + sample = sample_by_id[row["sample_id"]] + _merge_sample_metadata(row, sample.metadata) sample_ids = [row["sample_id"] for row in metadata_rows] sample_dataset_sizes = { sample_id: int(sum(1 for row_sample in sample_ids if row_sample == sample_id)) @@ -999,6 +1015,7 @@ def shared_cluster_distribution( "condition": sample.condition, "replicate": sample.replicate, } + _merge_sample_metadata(row, sample.metadata) row.update(metadata) metadata_rows.append(row) diff --git a/tests/test_workflows.py b/tests/test_workflows.py index 48c1ef4..5a4ea3a 100644 --- a/tests/test_workflows.py +++ b/tests/test_workflows.py @@ -781,6 +781,220 @@ def fake_features(result, **kwargs): assert set(result.metadata["cache_misses"]) == {"s1", "s2"} +def test_shared_cluster_distribution_propagates_sample_metadata_into_assignments_read_global( + monkeypatch, +): + fake_samples = [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + metadata={ + "subject_id": "mouse-1", + "sample_id": "overwrite-attempt", + "condition": "overwrite-attempt", + "replicate": 99, + "read_name": "overwrite-attempt", + "chromosome": "wrong-chr", + "region_start": 999, + "region_end": 1000, + }, + ), + SampleSpec( + sample_id="s2", + condition="15min", + extract_h5="s2.h5", + metadata={ + "subject_id": "mouse-2", + "sample_id": "overwrite-attempt", + "condition": "overwrite-attempt", + "replicate": 88, + "read_name": "overwrite-attempt", + "chromosome": "wrong-chr", + "region_start": 999, + "region_end": 1000, + }, + ), + ] + + def fake_extract(*args, **kwargs): + hdf5_file = kwargs["hdf5_file"] + + class R: + if hdf5_file == "s1.h5": + data_matrix = np.array([[0.0, 0.0, 0.1, 0.1], [0.0, 0.1, 0.0, 0.1]]) + metadata = [ + {"read_name": "s1-r1", "chromosome": "chr1", "region_start": 0, "region_end": 4}, + {"read_name": "s1-r2", "chromosome": "chr1", "region_start": 10, "region_end": 14}, + ] + else: + data_matrix = np.array([[1.0, 0.9, 1.0, 0.9], [0.9, 1.0, 0.9, 1.0]]) + metadata = [ + {"read_name": "s2-r1", "chromosome": "chr1", "region_start": 20, "region_end": 24}, + {"read_name": "s2-r2", "chromosome": "chr1", "region_start": 30, "region_end": 34}, + ] + val_matrix = np.ones((2, 4), dtype=float) + datasets = [] + regions_dict = None + + return R() + + monkeypatch.setattr(workflows.cluster, "extract_read_windows", fake_extract) + monkeypatch.setattr( + workflows.cluster, + "read_window_feature_matrix", + lambda result, **kwargs: (result.data_matrix, ["f0", "f1", "f2", "f3"]), + ) + + result = workflows.shared_cluster_distribution( + samples=fake_samples, + mode="read_global", + motifs=["A,0"], + n_clusters=2, + training_sample_per_dataset=2, + ) + + assert "subject_id" in result.assignments.columns + by_read_name = result.assignments.set_index("read_name")[ + ["subject_id", "sample_id", "condition", "region_start", "region_end"] + ].to_dict("index") + assert by_read_name == { + "s1-r1": { + "subject_id": "mouse-1", + "sample_id": "s1", + "condition": "NS", + "region_start": 0, + "region_end": 4, + }, + "s1-r2": { + "subject_id": "mouse-1", + "sample_id": "s1", + "condition": "NS", + "region_start": 10, + "region_end": 14, + }, + "s2-r1": { + "subject_id": "mouse-2", + "sample_id": "s2", + "condition": "15min", + "region_start": 20, + "region_end": 24, + }, + "s2-r2": { + "subject_id": "mouse-2", + "sample_id": "s2", + "condition": "15min", + "region_start": 30, + "region_end": 34, + }, + } + assert set(result.assignments["replicate"]) == {None} + assert set(result.assignments["chromosome"]) == {"chr1"} + + +def test_shared_cluster_distribution_propagates_sample_metadata_into_assignments_region_anchored( + monkeypatch, +): + fake_samples = [ + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + regions_bed="r1.bed", + metadata={ + "pileup_path": "s1.bed.gz", + "subject_id": "mouse-1", + "sample_id": "overwrite-attempt", + "condition": "overwrite-attempt", + "replicate": 99, + "region_id": "wrong-region", + "chromosome": "wrong-chr", + "start": 999, + "end": 1000, + "strand": "-", + }, + ), + SampleSpec( + sample_id="s2", + condition="15min", + extract_h5="s2.h5", + regions_bed="r2.bed", + metadata={ + "pileup_path": "s2.bed.gz", + "subject_id": "mouse-2", + "sample_id": "overwrite-attempt", + "condition": "overwrite-attempt", + "replicate": 88, + "region_id": "wrong-region", + "chromosome": "wrong-chr", + "start": 999, + "end": 1000, + "strand": "-", + }, + ), + ] + + def fake_region_table(*args, **kwargs): + return np.array([[0.2, 0.8], [0.7, 0.3]], dtype=np.float32), [ + { + "sample_id": "s1", + "condition": "NS", + "replicate": None, + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 2, + "strand": "+", + }, + { + "sample_id": "s2", + "condition": "15min", + "replicate": None, + "region_id": "reg1", + "chromosome": "chr1", + "start": 0, + "end": 2, + "strand": "+", + }, + ] + + monkeypatch.setattr(workflows.region_analysis, "build_region_feature_table", fake_region_table) + + result = workflows.shared_cluster_distribution( + samples=fake_samples, + mode="region_anchored", + motifs=["A,0"], + matched_regions="matched.bed", + n_clusters=2, + make_plots=False, + ) + + assert "subject_id" in result.assignments.columns + by_region = result.assignments.set_index(["sample_id", "region_id"])[ + ["subject_id", "condition", "replicate", "chromosome", "start", "end", "strand"] + ].to_dict("index") + assert by_region == { + ("s1", "reg1"): { + "subject_id": "mouse-1", + "condition": "NS", + "replicate": None, + "chromosome": "chr1", + "start": 0, + "end": 2, + "strand": "+", + }, + ("s2", "reg1"): { + "subject_id": "mouse-2", + "condition": "15min", + "replicate": None, + "chromosome": "chr1", + "start": 0, + "end": 2, + "strand": "+", + }, + } + + def test_shared_cluster_distribution_rejects_unsupported_mode(): with pytest.raises(NotImplementedError, match="region_anchored"): workflows.shared_cluster_distribution( From 9738e4de7a45da115a0529aa63cbc6f9bafa3bca Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 14:11:49 -0700 Subject: [PATCH 229/272] feat: complete shared cluster inference v1 scope --- README.md | 9 + dimelo/shared_cluster_tests.py | 791 ++++++++++++++++++++++++++++- docs/shared-clustering.md | 66 +++ docs/superpowers/README.md | 2 + tests/test_shared_cluster_tests.py | 199 +++++++- 5 files changed, 1048 insertions(+), 19 deletions(-) diff --git a/README.md b/README.md index 8e8c8f4..313a916 100644 --- a/README.md +++ b/README.md @@ -255,6 +255,15 @@ inference. Shared clustering also has renderer-neutral plotting prep in `dimelo.plotting`. Use `prepare_shared_cluster_distribution_data(...)` for sample/condition cluster fractions, `prepare_shared_cluster_profile_data(...)` for cluster feature summaries, and `prepare_shared_cluster_region_data(...)` for region-level occupancy tables. The older lightweight `result.plot_data["cluster_distribution_bar"]` and `result.plot_data["cluster_distribution_heatmap"]` payloads remain supported. +Global shared-cluster composition inference is available through +`dimelo.shared_cluster_tests.shared_cluster_tests(...)`, which consumes a +`SharedClusterResult` plus a `ContrastSpec`. Use this for global composition +shifts (`pairwise`, `matched_pairwise`, `group_vs_group`, `time_course`), and +keep per-region occupancy inference in +`region_contrasts.score_regions(..., analysis_unit="cluster_occupancy")`. +Pooled `chi_squared` and `g_test` modes are screening-oriented and should not +replace replicate-aware permutation analyses when replicates are available. + For human-readable pileups (bedmethyl files, .bed) and extracted reads (.txt tab-separated values), run with `cleanup=False`. `cleanup=True` will clear these outputs because they can take up a lot of space. ### Parsing outputs diff --git a/dimelo/shared_cluster_tests.py b/dimelo/shared_cluster_tests.py index 4e52971..4102df6 100644 --- a/dimelo/shared_cluster_tests.py +++ b/dimelo/shared_cluster_tests.py @@ -1,16 +1,678 @@ from __future__ import annotations +from itertools import combinations +from typing import Any + +import numpy as np +import pandas as pd +from scipy import stats + from dimelo.models import ContrastSpec, SharedClusterContrastResult, SharedClusterResult +_SUPPORTED_SHARED_CLUSTER_MODES = { + "pairwise", + "matched_pairwise", + "group_vs_group", + "time_course", +} + +_SUPPORTED_POOLED_SCREEN_TESTS = {"chi_squared", "g_test"} + def _require_supported_shared_cluster_mode(contrast: ContrastSpec) -> None: - supported = {"pairwise", "matched_pairwise", "group_vs_group", "time_course"} - if contrast.mode not in supported: + if contrast.mode not in _SUPPORTED_SHARED_CLUSTER_MODES: raise NotImplementedError( f"Shared cluster tests are not implemented for contrast mode '{contrast.mode}'." ) +def _require_requested_conditions_present( + sample_table: pd.DataFrame, + *, + side_specs: dict[str, list[str]], +) -> None: + available_conditions = set(sample_table["condition"].dropna().unique()) + for side, conditions in side_specs.items(): + missing = sorted(set(conditions) - available_conditions) + if missing: + raise ValueError( + f"Missing {side} evidence for requested condition(s): {', '.join(missing)}." + ) + + +def _require_time_order_present(sample_table: pd.DataFrame, time_order: list[str]) -> None: + available_conditions = set(sample_table["condition"].dropna().unique()) + missing = [condition for condition in time_order if condition not in available_conditions] + if missing: + raise ValueError( + "Shared cluster time_course requested missing time_order condition(s): " + + ", ".join(missing) + ) + + +def _sample_fraction_table(result: SharedClusterResult) -> pd.DataFrame: + required = {"sample_id", "condition", "cluster", "fraction"} + missing = required - set(result.cluster_distribution.columns) + if missing: + raise ValueError( + "Shared cluster tests require cluster_distribution columns: " + + ", ".join(sorted(missing)) + + "." + ) + return result.cluster_distribution.loc[ + :, ["sample_id", "condition", "cluster", "fraction"] + ].copy() + + +def _condition_count_table(result: SharedClusterResult) -> pd.DataFrame: + required = {"condition", "cluster", "count", "fraction"} + missing = required - set(result.condition_distribution.columns) + if missing: + raise ValueError( + "Shared cluster tests require condition_distribution columns: " + + ", ".join(sorted(missing)) + + "." + ) + return result.condition_distribution.loc[ + :, ["condition", "cluster", "count", "fraction"] + ].copy() + + +def _cluster_order(result: SharedClusterResult) -> list[str]: + cluster_labels = list(result.model.cluster_labels) + if cluster_labels: + return cluster_labels + return ( + result.cluster_distribution["cluster"].drop_duplicates().astype(str).sort_values().tolist() + ) + + +def _composition_effect_size(summary_table: pd.DataFrame) -> float: + return float(summary_table["delta_fraction"].abs().sum() / 2.0) + + +def _composition_effect_size_from_vectors(observed: np.ndarray, reference: np.ndarray) -> float: + return float(np.abs(observed - reference).sum() / 2.0) + + +def _trend_statistic(timepoint_fractions: np.ndarray) -> float: + if timepoint_fractions.shape[0] < 2: + return 0.0 + + positions = np.arange(timepoint_fractions.shape[0], dtype=float) + slopes = [ + np.polyfit(positions, timepoint_fractions[:, cluster_index], 1)[0] + for cluster_index in range(timepoint_fractions.shape[1]) + ] + return float(np.abs(slopes).sum() / 2.0) + + +def _adjust_p_values_bh(p_values: pd.Series) -> pd.Series: + if p_values.empty: + return pd.Series(dtype=float, index=p_values.index) + + numeric = pd.to_numeric(p_values, errors="coerce") + valid_mask = numeric.notna() + if not valid_mask.any(): + return pd.Series(np.nan, index=p_values.index, dtype=float) + + valid_values = numeric[valid_mask].to_numpy(dtype=float) + order = np.argsort(valid_values, kind="mergesort") + ranked = valid_values[order] + adjusted = np.empty_like(ranked) + running_min = 1.0 + total = len(ranked) + + for index in range(total - 1, -1, -1): + rank = index + 1 + candidate = min(1.0, ranked[index] * total / rank) + running_min = min(running_min, candidate) + adjusted[index] = running_min + + restored = np.full(len(p_values), np.nan, dtype=float) + restored_indices = np.flatnonzero(valid_mask.to_numpy()) + restored[restored_indices[order]] = adjusted + return pd.Series(restored, index=p_values.index, dtype=float) + + +def _contrast_id(contrast: ContrastSpec) -> str: + numerator = "+".join(contrast.numerator or []) + denominator = "+".join(contrast.denominator or []) + if contrast.mode == "time_course": + time_order = "+".join(contrast.time_order or []) + return f"time_course:{time_order}" + return f"{numerator}_vs_{denominator}" + + +def _sample_cluster_matrix(result: SharedClusterResult) -> pd.DataFrame: + sample_table = _sample_fraction_table(result) + cluster_order = _cluster_order(result) + sample_info = sample_table.loc[:, ["sample_id", "condition"]].drop_duplicates() + matrix = ( + sample_table.pivot_table( + index="sample_id", + columns="cluster", + values="fraction", + aggfunc="first", + fill_value=0.0, + ) + .reindex(columns=cluster_order, fill_value=0.0) + .reset_index() + ) + return sample_info.merge(matrix, on="sample_id", how="left") + + +def _add_pairing_metadata( + sample_matrix: pd.DataFrame, + *, + assignments: pd.DataFrame, + pairing_key: str, +) -> pd.DataFrame: + if pairing_key not in assignments.columns: + raise ValueError( + f"Shared cluster matched_pairwise requires assignments column {pairing_key!r}." + ) + + pairing = assignments.loc[:, ["sample_id", pairing_key]].drop_duplicates() + pair_counts = pairing.groupby("sample_id", dropna=False)[pairing_key].nunique(dropna=False) + if (pair_counts > 1).any(): + raise ValueError( + "Shared cluster matched_pairwise requires each sample_id to map to exactly one pairing key." + ) + if pairing[pairing_key].isna().any(): + raise ValueError( + f"Shared cluster matched_pairwise requires non-null values in column {pairing_key!r}." + ) + return sample_matrix.merge(pairing, on="sample_id", how="left") + + +def _prepare_unpaired_group_table( + result: SharedClusterResult, + *, + contrast: ContrastSpec, +) -> tuple[pd.DataFrame, list[str]]: + sample_matrix = _sample_cluster_matrix(result) + cluster_order = _cluster_order(result) + side_specs = { + "numerator": contrast.numerator or [], + "denominator": contrast.denominator or [], + } + _require_requested_conditions_present(sample_matrix, side_specs=side_specs) + requested_conditions = set(side_specs["numerator"]) | set(side_specs["denominator"]) + filtered = sample_matrix.loc[sample_matrix["condition"].isin(requested_conditions)].copy() + filtered["contrast_side"] = np.where( + filtered["condition"].isin(side_specs["numerator"]), + "numerator", + "denominator", + ) + return filtered, cluster_order + + +def _prepare_paired_group_table( + result: SharedClusterResult, + *, + contrast: ContrastSpec, +) -> tuple[pd.DataFrame, list[str]]: + if len(contrast.numerator or []) != 1 or len(contrast.denominator or []) != 1: + raise ValueError( + "Shared cluster matched_pairwise currently requires exactly one numerator " + "and one denominator condition." + ) + + sample_matrix = _sample_cluster_matrix(result) + sample_matrix = _add_pairing_metadata( + sample_matrix, + assignments=result.assignments, + pairing_key=contrast.pairing_key or "", + ) + cluster_order = _cluster_order(result) + side_specs = { + "numerator": contrast.numerator or [], + "denominator": contrast.denominator or [], + } + _require_requested_conditions_present(sample_matrix, side_specs=side_specs) + requested_conditions = set(side_specs["numerator"]) | set(side_specs["denominator"]) + filtered = sample_matrix.loc[sample_matrix["condition"].isin(requested_conditions)].copy() + filtered["contrast_side"] = np.where( + filtered["condition"].isin(side_specs["numerator"]), + "numerator", + "denominator", + ) + + grouped = ( + filtered.groupby([contrast.pairing_key, "contrast_side"], as_index=False, sort=False)[ + cluster_order + ] + .mean() + ) + side_sets = ( + grouped.loc[:, [contrast.pairing_key, "contrast_side"]] + .drop_duplicates() + .groupby(contrast.pairing_key)["contrast_side"] + .agg(lambda values: set(values)) + ) + complete_pairs = [ + pair_id for pair_id, sides in side_sets.items() if {"numerator", "denominator"} <= sides + ] + if not complete_pairs: + raise ValueError("Shared cluster matched_pairwise found no complete matched units.") + + return grouped.loc[grouped[contrast.pairing_key].isin(complete_pairs)].copy(), cluster_order + + +def _permutation_p_value(observed: float, permuted: np.ndarray) -> float: + return float((1 + np.count_nonzero(permuted >= observed - 1e-12)) / (len(permuted) + 1)) + + +def _run_unpaired_permutations( + values: np.ndarray, + *, + n_numerator: int, + n_permutations: int, + random_state: int | None, +) -> tuple[np.ndarray, np.ndarray]: + rng = np.random.default_rng(random_state) + cluster_stats = np.zeros((n_permutations, values.shape[1]), dtype=float) + omnibus_stats = np.zeros(n_permutations, dtype=float) + + for permutation_index in range(n_permutations): + permuted_indices = rng.permutation(values.shape[0]) + numerator = values[permuted_indices[:n_numerator]] + denominator = values[permuted_indices[n_numerator:]] + delta = numerator.mean(axis=0) - denominator.mean(axis=0) + cluster_stats[permutation_index] = np.abs(delta) + omnibus_stats[permutation_index] = np.abs(delta).sum() / 2.0 + + return cluster_stats, omnibus_stats + + +def _run_paired_permutations( + pair_deltas: np.ndarray, + *, + n_permutations: int, + random_state: int | None, +) -> tuple[np.ndarray, np.ndarray]: + rng = np.random.default_rng(random_state) + cluster_stats = np.zeros((n_permutations, pair_deltas.shape[1]), dtype=float) + omnibus_stats = np.zeros(n_permutations, dtype=float) + + for permutation_index in range(n_permutations): + signs = rng.choice(np.array([-1.0, 1.0]), size=pair_deltas.shape[0])[:, None] + delta = (pair_deltas * signs).mean(axis=0) + cluster_stats[permutation_index] = np.abs(delta) + omnibus_stats[permutation_index] = np.abs(delta).sum() / 2.0 + + return cluster_stats, omnibus_stats + + +def _score_unpaired_group( + group_table: pd.DataFrame, + *, + cluster_order: list[str], + n_permutations: int, + random_state: int | None, +) -> tuple[pd.DataFrame, dict[str, Any]]: + numerator = group_table.loc[group_table["contrast_side"] == "numerator", cluster_order] + denominator = group_table.loc[group_table["contrast_side"] == "denominator", cluster_order] + if numerator.empty or denominator.empty: + raise ValueError("Shared cluster tests require evidence for both contrast sides.") + + observed_fraction = numerator.mean(axis=0) + reference_fraction = denominator.mean(axis=0) + delta = observed_fraction - reference_fraction + details = pd.DataFrame( + { + "cluster": cluster_order, + "fraction": observed_fraction.to_numpy(dtype=float), + "reference_fraction": reference_fraction.to_numpy(dtype=float), + "delta_fraction": delta.to_numpy(dtype=float), + } + ) + + perm_cluster, perm_omnibus = _run_unpaired_permutations( + group_table.loc[:, cluster_order].to_numpy(dtype=float), + n_numerator=len(numerator), + n_permutations=n_permutations, + random_state=random_state, + ) + return details, { + "permuted_cluster_stats": perm_cluster, + "permuted_omnibus_stats": perm_omnibus, + "paired": False, + "n_numerator": int(len(numerator)), + "n_denominator": int(len(denominator)), + } + + +def _score_paired_group( + pair_table: pd.DataFrame, + *, + cluster_order: list[str], + contrast: ContrastSpec, + n_permutations: int, + random_state: int | None, +) -> tuple[pd.DataFrame, dict[str, Any]]: + pair_key = contrast.pairing_key or "" + numerator = ( + pair_table.loc[pair_table["contrast_side"] == "numerator"] + .set_index(pair_key) + .reindex(columns=cluster_order) + .sort_index() + ) + denominator = ( + pair_table.loc[pair_table["contrast_side"] == "denominator"] + .set_index(pair_key) + .reindex(columns=cluster_order) + .sort_index() + ) + common_pairs = numerator.index.intersection(denominator.index) + if common_pairs.empty: + raise ValueError("Shared cluster matched_pairwise found no complete matched units.") + + numerator = numerator.loc[common_pairs] + denominator = denominator.loc[common_pairs] + observed_fraction = numerator.mean(axis=0) + reference_fraction = denominator.mean(axis=0) + delta = observed_fraction - reference_fraction + details = pd.DataFrame( + { + "cluster": cluster_order, + "fraction": observed_fraction.to_numpy(dtype=float), + "reference_fraction": reference_fraction.to_numpy(dtype=float), + "delta_fraction": delta.to_numpy(dtype=float), + } + ) + + pair_deltas = numerator.to_numpy(dtype=float) - denominator.to_numpy(dtype=float) + perm_cluster, perm_omnibus = _run_paired_permutations( + pair_deltas, + n_permutations=n_permutations, + random_state=random_state, + ) + return details, { + "permuted_cluster_stats": perm_cluster, + "permuted_omnibus_stats": perm_omnibus, + "paired": True, + "n_pairs_used": int(len(common_pairs)), + } + + +def _finalize_details( + details: pd.DataFrame, + *, + permuted_cluster_stats: np.ndarray, +) -> pd.DataFrame: + finalized = details.copy() + finalized["log2_fc"] = np.log2( + (finalized["fraction"] + 1e-9) / (finalized["reference_fraction"] + 1e-9) + ) + finalized["effect_size"] = finalized["delta_fraction"].abs() + finalized["p_value"] = [ + _permutation_p_value( + float(observed), + permuted_cluster_stats[:, cluster_index], + ) + for cluster_index, observed in enumerate(finalized["effect_size"]) + ] + finalized["adjusted_p_value"] = _adjust_p_values_bh(finalized["p_value"]) + finalized = finalized.sort_values( + ["adjusted_p_value", "p_value", "effect_size", "cluster"], + ascending=[True, True, False, True], + kind="stable", + ).reset_index(drop=True) + finalized["rank"] = np.arange(1, len(finalized) + 1, dtype=int) + return finalized + + +def _build_summary( + details: pd.DataFrame, + *, + contrast: ContrastSpec, + omnibus_p_value: float, + stats_metadata: dict[str, Any], + test: str, + trend_p_value: float | None = None, +) -> pd.DataFrame: + top_cluster_row = details.sort_values( + ["effect_size", "p_value", "cluster"], + ascending=[False, True, True], + kind="stable", + ).iloc[0] + summary_row: dict[str, Any] = { + "contrast_id": _contrast_id(contrast), + "contrast_mode": contrast.mode, + "test": test, + "numerator_conditions": "+".join(contrast.numerator or []), + "denominator_conditions": "+".join(contrast.denominator or []), + "composition_effect_size": _composition_effect_size(details), + "omnibus_p_value": float(omnibus_p_value), + "top_cluster": top_cluster_row["cluster"], + "top_cluster_delta_fraction": float(top_cluster_row["delta_fraction"]), + "effect_size_metric": "total_variation_distance", + "paired": bool(stats_metadata["paired"]), + } + if trend_p_value is not None: + summary_row["trend_p_value"] = float(trend_p_value) + + for key, value in stats_metadata.items(): + if key.startswith("n_"): + summary_row[key] = value + return pd.DataFrame([summary_row]) + + +def _build_pooled_omnibus_p_value( + *, + result: SharedClusterResult, + contrast: ContrastSpec, + test: str, +) -> float: + if test not in _SUPPORTED_POOLED_SCREEN_TESTS: + raise ValueError( + "shared_cluster_tests currently requires test='permutation', " + "'chi_squared', or 'g_test'." + ) + + condition_table = _condition_count_table(result) + side_specs = { + "numerator": contrast.numerator or [], + "denominator": contrast.denominator or [], + } + _require_requested_conditions_present(condition_table, side_specs=side_specs) + requested_conditions = side_specs["numerator"] + side_specs["denominator"] + filtered = condition_table.loc[condition_table["condition"].isin(requested_conditions)].copy() + contingency = ( + filtered.pivot_table( + index="condition", + columns="cluster", + values="count", + aggfunc="sum", + fill_value=0, + ) + .reindex(index=requested_conditions, columns=_cluster_order(result), fill_value=0) + .astype(float) + ) + if contingency.shape[0] < 2 or contingency.shape[1] < 2: + raise ValueError("shared_cluster_tests pooled screening requires at least 2x2 counts.") + + if test == "chi_squared": + _, omnibus_p_value, _, _ = stats.chi2_contingency( + contingency.to_numpy(dtype=float), + correction=False, + ) + else: + _, omnibus_p_value, _, _ = stats.chi2_contingency( + contingency.to_numpy(dtype=float), + correction=False, + lambda_="log-likelihood", + ) + return float(omnibus_p_value) + + +def _score_time_course( + *, + result: SharedClusterResult, + contrast: ContrastSpec, + n_permutations: int, + random_state: int | None, + include_pairwise: bool, +) -> SharedClusterContrastResult: + time_order = list(dict.fromkeys(contrast.time_order or [])) + if not time_order: + raise ValueError("Shared cluster time_course requires contrast.time_order.") + + sample_matrix = _sample_cluster_matrix(result) + _require_time_order_present(sample_matrix, time_order) + cluster_order = _cluster_order(result) + + filtered = sample_matrix.loc[sample_matrix["condition"].isin(time_order)].copy() + filtered["condition"] = pd.Categorical(filtered["condition"], categories=time_order, ordered=True) + filtered = filtered.sort_values(["condition", "sample_id"], kind="stable").reset_index(drop=True) + + grouped = ( + filtered.groupby("condition", sort=False, observed=False)[cluster_order] + .mean() + .reindex(time_order) + ) + counts = ( + filtered.groupby("condition", sort=False, observed=False)["sample_id"] + .nunique() + .reindex(time_order) + ) + time_course_table = grouped.reset_index(names="timepoint") + time_course_table["n_samples"] = counts.to_numpy(dtype=int) + + observed_matrix = grouped.to_numpy(dtype=float) + observed_first = observed_matrix[0] + observed_last = observed_matrix[-1] + observed_delta = observed_last - observed_first + observed_omnibus = _composition_effect_size_from_vectors(observed_last, observed_first) + observed_trend = _trend_statistic(observed_matrix) + + rng = np.random.default_rng(random_state) + permuted_cluster_stats = np.zeros((n_permutations, len(cluster_order)), dtype=float) + permuted_omnibus_stats = np.zeros(n_permutations, dtype=float) + permuted_trend_stats = np.zeros(n_permutations, dtype=float) + condition_values = filtered["condition"].to_numpy() + value_matrix = filtered.loc[:, cluster_order].to_numpy(dtype=float) + + for permutation_index in range(n_permutations): + permuted_conditions = rng.permutation(condition_values) + permuted = pd.DataFrame(value_matrix, columns=cluster_order) + permuted["condition"] = permuted_conditions + permuted_grouped = ( + permuted.groupby("condition", sort=False, observed=False)[cluster_order] + .mean() + .reindex(time_order) + ) + permuted_matrix = permuted_grouped.to_numpy(dtype=float) + permuted_delta = permuted_matrix[-1] - permuted_matrix[0] + permuted_cluster_stats[permutation_index] = np.abs(permuted_delta) + permuted_omnibus_stats[permutation_index] = _composition_effect_size_from_vectors( + permuted_matrix[-1], + permuted_matrix[0], + ) + permuted_trend_stats[permutation_index] = _trend_statistic(permuted_matrix) + + details = pd.DataFrame( + { + "cluster": cluster_order, + "fraction": observed_last, + "reference_fraction": observed_first, + "delta_fraction": observed_delta, + } + ) + details = _finalize_details(details, permuted_cluster_stats=permuted_cluster_stats) + + omnibus_p_value = _permutation_p_value(observed_omnibus, permuted_omnibus_stats) + trend_p_value = _permutation_p_value(observed_trend, permuted_trend_stats) + summary = _build_summary( + details, + contrast=contrast, + omnibus_p_value=omnibus_p_value, + stats_metadata={ + "paired": False, + "n_timepoints": int(len(time_order)), + "n_samples": int(filtered["sample_id"].nunique()), + }, + test="permutation", + trend_p_value=trend_p_value, + ) + summary["test"] = "permutation" + summary["trend_p_value"] = float(trend_p_value) + + pairwise = None + plot_data: dict[str, pd.DataFrame | dict[str, Any]] = { + "summary_table": summary.copy(), + "cluster_effect_table": details.copy(), + "time_course_table": time_course_table.copy(), + } + + if include_pairwise: + pairwise_rows = [] + for left_timepoint, right_timepoint in zip(time_order[:-1], time_order[1:]): + pair_table = filtered.loc[ + filtered["condition"].isin([left_timepoint, right_timepoint]) + ].copy() + pair_table["contrast_side"] = np.where( + pair_table["condition"] == left_timepoint, + "numerator", + "denominator", + ) + pair_details, stats_metadata = _score_unpaired_group( + pair_table, + cluster_order=cluster_order, + n_permutations=n_permutations, + random_state=random_state, + ) + pair_details = _finalize_details( + pair_details, + permuted_cluster_stats=stats_metadata["permuted_cluster_stats"], + ) + pair_omnibus = _permutation_p_value( + _composition_effect_size(pair_details), + stats_metadata["permuted_omnibus_stats"], + ) + pair_summary = _build_summary( + pair_details, + contrast=ContrastSpec( + mode="pairwise", + numerator=[left_timepoint], + denominator=[right_timepoint], + ), + omnibus_p_value=pair_omnibus, + stats_metadata=stats_metadata, + test="permutation", + ) + row = pair_summary.iloc[0].to_dict() + row["left_timepoint"] = left_timepoint + row["right_timepoint"] = right_timepoint + pairwise_rows.append(row) + + pairwise = pd.DataFrame(pairwise_rows) + plot_data["pairwise_table"] = pairwise.copy() + + metadata: dict[str, Any] = { + "contrast_mode": contrast.mode, + "contrast_id": _contrast_id(contrast), + "paired": False, + "pairing_key": None, + "test": "permutation", + "multiple_testing": "fdr_bh", + "n_permutations": int(n_permutations), + "random_state": random_state, + "inference_level": "replicate_aware", + "n_timepoints": int(len(time_order)), + "n_samples": int(filtered["sample_id"].nunique()), + } + return SharedClusterContrastResult( + summary=summary, + details=details, + pairwise=pairwise, + plot_data=plot_data, + metadata=metadata, + ) + + def shared_cluster_tests( *, result: SharedClusterResult, @@ -22,4 +684,127 @@ def shared_cluster_tests( include_pairwise: bool = False, ) -> SharedClusterContrastResult: _require_supported_shared_cluster_mode(contrast) - raise NotImplementedError("shared_cluster_tests is not implemented yet.") + if multiple_testing != "fdr_bh": + raise ValueError("shared_cluster_tests currently requires multiple_testing='fdr_bh'.") + if n_permutations <= 0: + raise ValueError("shared_cluster_tests requires n_permutations > 0.") + + if contrast.mode == "time_course": + if test != "permutation": + raise ValueError("shared_cluster_tests time_course currently requires test='permutation'.") + return _score_time_course( + result=result, + contrast=contrast, + n_permutations=n_permutations, + random_state=random_state, + include_pairwise=include_pairwise, + ) + + if test == "permutation": + if contrast.mode == "matched_pairwise": + pair_table, cluster_order = _prepare_paired_group_table(result, contrast=contrast) + details, stats_metadata = _score_paired_group( + pair_table, + cluster_order=cluster_order, + contrast=contrast, + n_permutations=n_permutations, + random_state=random_state, + ) + sample_plot_table = pair_table.copy() + else: + group_table, cluster_order = _prepare_unpaired_group_table(result, contrast=contrast) + details, stats_metadata = _score_unpaired_group( + group_table, + cluster_order=cluster_order, + n_permutations=n_permutations, + random_state=random_state, + ) + sample_plot_table = group_table.copy() + + details = _finalize_details( + details, + permuted_cluster_stats=stats_metadata["permuted_cluster_stats"], + ) + omnibus_p_value = _permutation_p_value( + _composition_effect_size(details), + stats_metadata["permuted_omnibus_stats"], + ) + summary = _build_summary( + details, + contrast=contrast, + omnibus_p_value=omnibus_p_value, + stats_metadata=stats_metadata, + test=test, + ) + metadata: dict[str, Any] = { + "contrast_mode": contrast.mode, + "contrast_id": _contrast_id(contrast), + "paired": bool(stats_metadata["paired"]), + "pairing_key": contrast.pairing_key if contrast.mode == "matched_pairwise" else None, + "test": test, + "multiple_testing": multiple_testing, + "n_permutations": int(n_permutations), + "random_state": random_state, + "inference_level": "replicate_aware", + } + metadata.update({key: value for key, value in stats_metadata.items() if key.startswith("n_")}) + plot_data = { + "summary_table": summary.copy(), + "cluster_effect_table": details.copy(), + "sample_fraction_table": sample_plot_table, + } + return SharedClusterContrastResult( + summary=summary, + details=details, + plot_data=plot_data, + metadata=metadata, + ) + + if test not in _SUPPORTED_POOLED_SCREEN_TESTS: + raise ValueError( + "shared_cluster_tests currently requires test='permutation', " + "'chi_squared', or 'g_test'." + ) + + group_table, cluster_order = _prepare_unpaired_group_table(result, contrast=contrast) + details, stats_metadata = _score_unpaired_group( + group_table, + cluster_order=cluster_order, + n_permutations=n_permutations, + random_state=random_state, + ) + details = _finalize_details( + details, + permuted_cluster_stats=stats_metadata["permuted_cluster_stats"], + ) + omnibus_p_value = _build_pooled_omnibus_p_value(result=result, contrast=contrast, test=test) + summary = _build_summary( + details, + contrast=contrast, + omnibus_p_value=omnibus_p_value, + stats_metadata=stats_metadata, + test=test, + ) + metadata: dict[str, Any] = { + "contrast_mode": contrast.mode, + "contrast_id": _contrast_id(contrast), + "paired": bool(stats_metadata["paired"]), + "pairing_key": None, + "test": test, + "multiple_testing": multiple_testing, + "n_permutations": int(n_permutations), + "random_state": random_state, + "inference_level": "pooled_screen", + } + metadata.update({key: value for key, value in stats_metadata.items() if key.startswith("n_")}) + plot_data = { + "summary_table": summary.copy(), + "cluster_effect_table": details.copy(), + "sample_fraction_table": group_table.copy(), + } + return SharedClusterContrastResult( + summary=summary, + details=details, + plot_data=plot_data, + metadata=metadata, + ) diff --git a/docs/shared-clustering.md b/docs/shared-clustering.md index b69fed7..06c1ab3 100644 --- a/docs/shared-clustering.md +++ b/docs/shared-clustering.md @@ -189,6 +189,72 @@ For heatmaps: heatmap = result.plot_data["cluster_distribution_heatmap"].set_index("condition") ``` +## Global Composition Inference + +Shared clustering now includes a dedicated inference helper for global +composition changes: + +```python +from dimelo import shared_cluster_tests +from dimelo.models import ContrastSpec + +contrast_result = shared_cluster_tests.shared_cluster_tests( + result=result, + contrast=ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["NS"], + ), + test="permutation", +) +``` + +Matched pairwise example: + +```python +contrast_result = shared_cluster_tests.shared_cluster_tests( + result=result, + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["treated"], + denominator=["NS"], + pairing_key="subject_id", + ), + test="permutation", +) +``` + +Time-course example: + +```python +contrast_result = shared_cluster_tests.shared_cluster_tests( + result=result, + contrast=ContrastSpec(mode="time_course", time_order=["t0", "t1", "t2"]), + test="permutation", + include_pairwise=True, +) +``` + +Pooled screening example: + +```python +screen_result = shared_cluster_tests.shared_cluster_tests( + result=result, + contrast=ContrastSpec(mode="pairwise", numerator=["treated"], denominator=["NS"]), + test="chi_squared", +) +``` + +Inference boundary: + +- `shared_cluster_tests(...)` is for global cluster-composition inference from + `SharedClusterResult`. +- `region_contrasts.score_regions(..., analysis_unit="cluster_occupancy")` + remains the path for region-level occupancy inference. +- Pooled `chi_squared` and `g_test` are screening-oriented outputs; use + replicate-aware permutation paths as the primary inferential mode when + replicate structure exists. + ## Current V1 Scope - `mode="read_global"` supports shared read clustering from extract outputs. diff --git a/docs/superpowers/README.md b/docs/superpowers/README.md index d3c7fe0..3f60afb 100644 --- a/docs/superpowers/README.md +++ b/docs/superpowers/README.md @@ -18,6 +18,7 @@ This directory tracks internal design and implementation work for the current br ### Shared Clustering - [2026-03-31-shared-cluster-distribution-design.md](specs/2026-03-31-shared-cluster-distribution-design.md) - shared-boundary clustering architecture and artifact model. Status: `partially implemented` +- [2026-04-12-shared-cluster-tests-design.md](specs/2026-04-12-shared-cluster-tests-design.md) - global shared-cluster composition inference layer that consumes `SharedClusterResult` and `ContrastSpec`. Status: `partially implemented` ### Region Analysis @@ -44,6 +45,7 @@ This directory tracks internal design and implementation work for the current br ### Shared Clustering - [2026-03-31-shared-clustering-foundations.md](plans/2026-03-31-shared-clustering-foundations.md) - shared clustering models, artifacts, plotting payloads, and workflows. Status: `implemented` +- [2026-04-12-shared-cluster-tests.md](plans/2026-04-12-shared-cluster-tests.md) - shared-cluster global composition inference with permutation paths plus pooled screening options. Status: `partially implemented` ### Region Analysis diff --git a/tests/test_shared_cluster_tests.py b/tests/test_shared_cluster_tests.py index 7ca43e1..4e7f3bf 100644 --- a/tests/test_shared_cluster_tests.py +++ b/tests/test_shared_cluster_tests.py @@ -5,29 +5,86 @@ def _make_shared_cluster_test_result() -> SharedClusterResult: - model = SharedClusterModel( - mode="shared", - motifs=["A,0"], - feature_names=["A,0_mod_fraction"], - preprocessing={"scale": "standard"}, - estimator=object(), - cluster_labels=["cluster-1"], - fit_metadata={"random_state": 7}, - ) return SharedClusterResult( - model=model, - assignments=pd.DataFrame({"cluster": ["cluster-1"]}), - cluster_distribution=pd.DataFrame({"cluster": ["cluster-1"]}), - condition_distribution=pd.DataFrame({"condition": ["treated"]}), + model=SharedClusterModel( + mode="read_global", + motifs=["A,0"], + feature_names=["f0", "f1"], + preprocessing={"signal_normalization": "none"}, + estimator=object(), + cluster_labels=["C0", "C1"], + fit_metadata={"clusterer": "minibatch_kmeans", "n_clusters": 2}, + ), + assignments=pd.DataFrame( + { + "sample_id": ["s1", "s2", "s3", "s4"], + "condition": ["NS", "NS", "treated", "treated"], + "subject_id": ["p1", "p2", "p1", "p2"], + "cluster": ["C0", "C0", "C1", "C1"], + } + ), + cluster_distribution=pd.DataFrame( + [ + {"sample_id": "s1", "condition": "NS", "cluster": "C0", "count": 80, "fraction": 0.80}, + {"sample_id": "s1", "condition": "NS", "cluster": "C1", "count": 20, "fraction": 0.20}, + {"sample_id": "s2", "condition": "NS", "cluster": "C0", "count": 75, "fraction": 0.75}, + {"sample_id": "s2", "condition": "NS", "cluster": "C1", "count": 25, "fraction": 0.25}, + {"sample_id": "s3", "condition": "treated", "cluster": "C0", "count": 30, "fraction": 0.30}, + {"sample_id": "s3", "condition": "treated", "cluster": "C1", "count": 70, "fraction": 0.70}, + {"sample_id": "s4", "condition": "treated", "cluster": "C0", "count": 25, "fraction": 0.25}, + {"sample_id": "s4", "condition": "treated", "cluster": "C1", "count": 75, "fraction": 0.75}, + ] + ), + condition_distribution=pd.DataFrame( + [ + {"condition": "NS", "cluster": "C0", "count": 155, "fraction": 0.775, "replicate_n": 2}, + {"condition": "NS", "cluster": "C1", "count": 45, "fraction": 0.225, "replicate_n": 2}, + {"condition": "treated", "cluster": "C0", "count": 55, "fraction": 0.275, "replicate_n": 2}, + {"condition": "treated", "cluster": "C1", "count": 145, "fraction": 0.725, "replicate_n": 2}, + ] + ), distribution_change=None, - cluster_profiles=pd.DataFrame({"profile": [1.0]}), + cluster_profiles=pd.DataFrame(columns=["cluster", "count", "f0", "f1"]), region_summaries=None, - plot_data={"cluster_distribution_bar": {"kind": "bar"}}, + plot_data={}, figures={}, - metadata={"notes": "ok"}, + metadata={}, ) +def _make_shared_cluster_time_course_result() -> SharedClusterResult: + result = _make_shared_cluster_test_result() + result.assignments = pd.DataFrame( + { + "sample_id": ["t0_a", "t1_a", "t2_a"], + "condition": ["t0", "t1", "t2"], + "subject_id": ["p1", "p1", "p1"], + "cluster": ["C0", "C0", "C1"], + } + ) + result.cluster_distribution = pd.DataFrame( + [ + {"sample_id": "t0_a", "condition": "t0", "cluster": "C0", "count": 80, "fraction": 0.80}, + {"sample_id": "t0_a", "condition": "t0", "cluster": "C1", "count": 20, "fraction": 0.20}, + {"sample_id": "t1_a", "condition": "t1", "cluster": "C0", "count": 55, "fraction": 0.55}, + {"sample_id": "t1_a", "condition": "t1", "cluster": "C1", "count": 45, "fraction": 0.45}, + {"sample_id": "t2_a", "condition": "t2", "cluster": "C0", "count": 25, "fraction": 0.25}, + {"sample_id": "t2_a", "condition": "t2", "cluster": "C1", "count": 75, "fraction": 0.75}, + ] + ) + result.condition_distribution = pd.DataFrame( + [ + {"condition": "t0", "cluster": "C0", "count": 80, "fraction": 0.80, "replicate_n": 1}, + {"condition": "t0", "cluster": "C1", "count": 20, "fraction": 0.20, "replicate_n": 1}, + {"condition": "t1", "cluster": "C0", "count": 55, "fraction": 0.55, "replicate_n": 1}, + {"condition": "t1", "cluster": "C1", "count": 45, "fraction": 0.45, "replicate_n": 1}, + {"condition": "t2", "cluster": "C0", "count": 25, "fraction": 0.25, "replicate_n": 1}, + {"condition": "t2", "cluster": "C1", "count": 75, "fraction": 0.75, "replicate_n": 1}, + ] + ) + return result + + def test_shared_cluster_tests_module_exports_entry_point(): from dimelo import shared_cluster_tests @@ -49,3 +106,113 @@ def test_shared_cluster_tests_rejects_unsupported_contrast_mode(): background=["bg"], ), ) + + +def test_shared_cluster_tests_pairwise_returns_summary_details_and_plot_data(): + from dimelo import shared_cluster_tests + from dimelo.models import ContrastSpec + + result = shared_cluster_tests.shared_cluster_tests( + result=_make_shared_cluster_test_result(), + contrast=ContrastSpec(mode="pairwise", numerator=["treated"], denominator=["NS"]), + test="permutation", + n_permutations=50, + random_state=7, + ) + + assert set(result.summary.columns) >= { + "contrast_id", + "composition_effect_size", + "omnibus_p_value", + "top_cluster", + } + assert set(result.details.columns) >= { + "cluster", + "fraction", + "reference_fraction", + "delta_fraction", + "p_value", + "adjusted_p_value", + } + assert set(result.plot_data) >= {"summary_table", "cluster_effect_table"} + + +def test_shared_cluster_tests_matched_pairwise_uses_contrast_pairing_key(): + from dimelo import shared_cluster_tests + from dimelo.models import ContrastSpec + + result = shared_cluster_tests.shared_cluster_tests( + result=_make_shared_cluster_test_result(), + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["treated"], + denominator=["NS"], + pairing_key="subject_id", + ), + test="permutation", + n_permutations=50, + random_state=7, + ) + + assert result.metadata["paired"] is True + assert result.metadata["pairing_key"] == "subject_id" + + +def test_shared_cluster_tests_supports_chi_squared_screen(): + from dimelo import shared_cluster_tests + + result = shared_cluster_tests.shared_cluster_tests( + result=_make_shared_cluster_test_result(), + contrast=ContrastSpec(mode="pairwise", numerator=["treated"], denominator=["NS"]), + test="chi_squared", + ) + + assert result.metadata["inference_level"] == "pooled_screen" + assert result.summary.loc[0, "test"] == "chi_squared" + assert 0.0 <= result.summary.loc[0, "omnibus_p_value"] <= 1.0 + + +def test_shared_cluster_tests_supports_g_test_screen(): + from dimelo import shared_cluster_tests + + result = shared_cluster_tests.shared_cluster_tests( + result=_make_shared_cluster_test_result(), + contrast=ContrastSpec(mode="pairwise", numerator=["treated"], denominator=["NS"]), + test="g_test", + ) + + assert result.metadata["inference_level"] == "pooled_screen" + assert result.summary.loc[0, "test"] == "g_test" + assert 0.0 <= result.summary.loc[0, "omnibus_p_value"] <= 1.0 + + +def test_shared_cluster_tests_time_course_returns_omnibus_and_trend_outputs(): + from dimelo import shared_cluster_tests + + result = shared_cluster_tests.shared_cluster_tests( + result=_make_shared_cluster_time_course_result(), + contrast=ContrastSpec(mode="time_course", time_order=["t0", "t1", "t2"]), + test="permutation", + n_permutations=50, + random_state=7, + ) + + assert {"omnibus_p_value", "trend_p_value", "composition_effect_size"} <= set( + result.summary.columns + ) + assert "time_course_table" in result.plot_data + + +def test_shared_cluster_tests_time_course_optional_pairwise_follow_up(): + from dimelo import shared_cluster_tests + + result = shared_cluster_tests.shared_cluster_tests( + result=_make_shared_cluster_time_course_result(), + contrast=ContrastSpec(mode="time_course", time_order=["t0", "t1", "t2"]), + test="permutation", + include_pairwise=True, + n_permutations=20, + random_state=7, + ) + + assert result.pairwise is not None From 8baefd2070cb10c7fd0639d2688b6dcfaceeff1c Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 14:12:02 -0700 Subject: [PATCH 230/272] docs: add sprint 1 parser cleanup kickoff --- .../2026-04-13-sprint1-parser-kickoff.md | 77 +++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 docs/superpowers/plans/2026-04-13-sprint1-parser-kickoff.md diff --git a/docs/superpowers/plans/2026-04-13-sprint1-parser-kickoff.md b/docs/superpowers/plans/2026-04-13-sprint1-parser-kickoff.md new file mode 100644 index 0000000..1454eae --- /dev/null +++ b/docs/superpowers/plans/2026-04-13-sprint1-parser-kickoff.md @@ -0,0 +1,77 @@ +# Sprint 1 Parser Kickoff + +**Goal:** Start the legacy cleanup sprint by inventorying parser debt in `dimelo/parse_bam.py` and `dimelo/run_modkit.py`, then move the highest-risk parser work into small, testable fixes. + +**Scope:** This kickoff only covers the legacy parser lane in the `codex/legacy-cleanup` worktree. It does not touch the main workspace checkout. + +--- + +## TODO Inventory + +I found `31` `TODO` markers in the two files in scope. + +### Correctness-Risk + +- `dimelo/parse_bam.py:802` - thresholding behavior is still ambiguous; the comment asks whether the method should threshold without binarization. +- `dimelo/parse_bam.py:979` - vector length is derived from `max(valid_coordinates_list) + 1`; the comment notes this should switch to `read_end - read_start`, which would change output padding semantics and requires reference regeneration. +- `dimelo/parse_bam.py:1049` - the comment explicitly asks to verify that read position is in the correct reference coordinate system. +- `dimelo/parse_bam.py:1055` - read start/end logic is still a placeholder for future true modkit-provided coordinates. +- `dimelo/parse_bam.py:1063` - same placeholder logic for read end calculation. + +### API/Design Cleanup + +- `dimelo/parse_bam.py:83` - `regions` is still a TODO in the public docstring. +- `dimelo/parse_bam.py:111` - typed-path handling has a cluster of mypy issues that need a coherent fix. +- `dimelo/parse_bam.py:157` - cleanup naming and flow are confusing; the comment calls out different usage between cleanup and extract. +- `dimelo/parse_bam.py:191` - region-specifier construction should be a method or merged into prep logic. +- `dimelo/parse_bam.py:210` - extract and pileup diverge mainly on printing vs. raising, and the comment suggests unifying that behavior. +- `dimelo/parse_bam.py:245` - question about whether this method should store and use its output. +- `dimelo/parse_bam.py:332` - `regions` is still a TODO in the extract docstring. +- `dimelo/parse_bam.py:360` - second cluster of path/type issues in the extract path. +- `dimelo/parse_bam.py:386` - intermediate mod-specific `.txt` files are still an open API/design question. +- `dimelo/parse_bam.py:480` - same question about whether the progress-run output needs to be retained. +- `dimelo/parse_bam.py:703` - the region-command builder may need to be split into conversion plus command construction. +- `dimelo/parse_bam.py:745` - the HDF5 file layout still needs a clearer documented key/value map. +- `dimelo/parse_bam.py:769` - second cluster of type/path issues in the HDF5 conversion path. +- `dimelo/parse_bam.py:1146` - `input_file` may be the wrong abstraction for this helper’s defaulting behavior. +- `dimelo/run_modkit.py:128` - the type annotation on `finding_progress_dict` is still called out as uncertain. + +### Code-Structure Cleanup + +- `dimelo/parse_bam.py:273` - cleanup could be centralized instead of duplicated. +- `dimelo/parse_bam.py:782` - the function calls around the HDF5 write path can likely be consolidated. +- `dimelo/parse_bam.py:783` - both files may be opened together instead of separately. +- `dimelo/parse_bam.py:817` - repeated dataset handling could loop over a dict. +- `dimelo/parse_bam.py:903` - repeated dataset handling could loop over a dict here too. +- `dimelo/parse_bam.py:935` - read-name initialization could move out of the hot loop. +- `dimelo/parse_bam.py:952` - chunk accounting should probably use `read_counter % chunk_size`. +- `dimelo/parse_bam.py:969` - CSV parsing should use the `csv` module. +- `dimelo/parse_bam.py:999` - gzip compression for vectors should be factored into a shared helper. +- `dimelo/parse_bam.py:1085` - there is another consolidation opportunity in the final write path. +- `dimelo/parse_bam.py:1106` - gzip compression should be shared across the write code path. + +## Sprint 1 Execution Order + +1. Lock down the correctness-risk items first with targeted tests around coordinate handling, vector length, and threshold semantics in `dimelo/parse_bam.py`. +2. Triage the public API/design debt next by clarifying the `regions` docstrings, path typing, and helper responsibilities in the parser and `run_modkit.py`. +3. Consolidate the repeated HDF5 write-path structure only after the behavior is pinned down by tests. +4. Re-run the parser-focused regression subset after each slice so the cleanup stays incremental instead of turning into a rewrite. + +## Baseline Test + +- Command: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 /Users/ngamarra/.pyenv/versions/3.11.3/bin/python3.11 -m pytest tests/test_distribution.py tests/test_cluster.py -q +``` + +- Result: + +```text +20 passed, 2 warnings in 10.79s +``` + +The warnings were non-fatal: + +- `tests/test_cluster.py::test_plot_region_cluster_profiles_motif_index` emitted a `tight_layout` warning from `dimelo/cluster.py:1865`. +- `tests/test_cluster.py::test_cluster_read_windows_kmeans` emitted the usual `joblib` physical-core detection warning. From 3497a10b531190392cc456efc006b51675f80bcf Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 14:13:12 -0700 Subject: [PATCH 231/272] refactor: type progress tracking in run_modkit --- dimelo/run_modkit.py | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/dimelo/run_modkit.py b/dimelo/run_modkit.py index 00fffef..933a984 100644 --- a/dimelo/run_modkit.py +++ b/dimelo/run_modkit.py @@ -9,12 +9,13 @@ import subprocess import sys from pathlib import Path -from typing import Optional, cast +from typing import Optional, TypeAlias, cast from tqdm.auto import tqdm # This should be updated in tandem with the environment.yml nanoporetech::modkit version EXPECTED_MODKIT_VERSION = "0.2.4" +FindingProgressDict: TypeAlias = dict[str, tuple[int, int]] def ensure_modkit_available(quiet: bool = False) -> None: """ @@ -125,8 +126,7 @@ def run_with_progress_bars( pbar_contigs: Optional[tqdm] = None pbar_chr: Optional[tqdm] = None - # TODO: Is this the correct type annotation? I think it is, based on approx. line 280 - finding_progress_dict: dict[str, tuple[int, int]] = {} + finding_progress_dict: FindingProgressDict = {} in_contig_progress = (0, 1) total_contigs = 0 @@ -322,21 +322,21 @@ def run_with_progress_bars( def update_progress_bars( - pbar_pre, - pbar_contigs, - pbar_chr, - tail_buffer, - contigs_progress_regex, - single_contig_regex, - find_motifs_regex, - load_fasta_regex, - region_parsing_started, - in_contig_progress, - finding_progress_dict, - ref_genome, - input_file, - motifs, -): + pbar_pre: Optional[tqdm], + pbar_contigs: Optional[tqdm], + pbar_chr: Optional[tqdm], + tail_buffer: str, + contigs_progress_regex: str, + single_contig_regex: str, + find_motifs_regex: str, + load_fasta_regex: str, + region_parsing_started: bool, + in_contig_progress: tuple[int, int], + finding_progress_dict: FindingProgressDict, + ref_genome: Path, + input_file: Path, + motifs: list[str], +) -> tuple[bool, tuple[int, int]]: # We check these in the reverse order from that in which they occur, which I guess will save a tiny # amount of processing time because we don't check for previous steps when on later steps # Once we are in the contig progress stage, step 1 is done by definition From 94999b0a49503a4bd4cc09c628e7e6c93c6974a8 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 14:15:03 -0700 Subject: [PATCH 232/272] docs: clarify parse_bam region selector parameters --- dimelo/parse_bam.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index 973b5e0..ccb4689 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -80,7 +80,11 @@ def pileup( output_directory: optional str or Path pointing to an output directory. If left as None, outputs will be stored in a new folder within the input directory. - regions: TODO + regions: optional region selector passed through to modkit via an include-bed + file. This may be a BED file path, a single region file, or a list of + region files/paths that define the loci to process. When paired with + ``window_size``, the provided regions are expanded around their centers + before being passed to modkit. motifs: a list of strings specifying which base modifications to look for. The basemods are each specified as {sequence_motif},{position_of_modification}. For example, a methylated adenine is specified as 'A,0' and CpG methylation @@ -329,7 +333,11 @@ def extract( output_directory: optional str or Path pointing to an output directory. If left as None, outputs will be stored in a new folder within the input directory. - regions: TODO + regions: optional region selector passed through to modkit via an include-bed + file. This may be a BED file path, a single region file, or a list of + region files/paths that define the loci to process. When paired with + ``window_size``, the provided regions are expanded around their centers + before being passed to modkit. motifs: a list of strings specifying which base modifications to look for. The basemods are each specified as {sequence_motif},{position_of_modification}. For example, a methylated adenine is specified as 'A,0' and CpG methylation From c8d23e85d15b023afc17bf2db73ec698aa77dd58 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 14:16:03 -0700 Subject: [PATCH 233/272] docs: document parse_bam hdf5 dataset semantics --- dimelo/parse_bam.py | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index ccb4689..06d58d0 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -741,17 +741,18 @@ def read_by_base_txt_to_hdf5( all the data from a specified motif into an hdf5 file. If a thresh is specified, it also binarizes the mod calls. - If the h5 file does not exist it will be created and datasets will be added for read_name, - chromosome, read_start, read_end, strand, motif, mod_vector, and val_vector. - - All the datasets (exception threshold) are parallel arrays of length num_reads - - Each read's position data is defined in genomic reference coordinates on the positive strand - (i.e. the read_start is the leftmost aligned position, read_end is the rightmost, vectors - are left to right along genomic coordinates) - - TODO: Make a nice key:value map of the h5 file structure, make sure start and end are documented - as reconstructions NOT original cigarstring alignment info. mention pysam + If the h5 file does not exist it will be created with top-level datasets named + ``read_name``, ``chromosome``, ``read_start``, ``read_end``, ``strand``, ``motif``, + ``mod_vector``, and ``val_vector``. Each dataset stores one value per read, so the arrays + are parallel and have length ``num_reads``. The optional ``threshold`` dataset stores the + scalar threshold used for binarization and is not part of the per-read arrays. + + Each read's position data is stored in genomic reference coordinates on the positive strand + convention. ``read_start`` and ``read_end`` are reconstructed from the aligned modkit extract + coordinates, not copied from the original BAM CIGAR string or any raw alignment tag. In this + representation, ``read_start`` is the leftmost aligned reference position for the read and + ``read_end`` is the rightmost aligned reference position observed while iterating through the + read. The modification vectors are ordered left to right along genomic coordinates. Args: input_txt: a string or Path pointing to a modkit extracted base-by-base modifications From c84f4b6a2025700921197fecefa916682b11882f Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 14:23:26 -0700 Subject: [PATCH 234/272] fix: cap check_bam_format validation at configured read limit --- dimelo/parse_bam.py | 27 ++++++++++++++++----------- tests/test_parse_bam.py | 31 +++++++++++++++++++++++++++++++ 2 files changed, 47 insertions(+), 11 deletions(-) create mode 100644 tests/test_parse_bam.py diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index 06d58d0..c41aca6 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -1,4 +1,5 @@ import gzip +import itertools import multiprocessing import os import subprocess @@ -578,7 +579,11 @@ def check_bam_format( input_bam = pysam.AlignmentFile(bam_file) try: - for counter, read in enumerate(input_bam.fetch()): + reads_checked = 0 + for counter, read in enumerate( + itertools.islice(input_bam.fetch(), NUM_READS_TO_CHECK) + ): + reads_checked = counter + 1 read_dict = read.to_dict() for tag_string in read_dict["tags"]: tag = tag_string.split(",")[0].split(":")[0] @@ -625,22 +630,22 @@ def check_bam_format( # ) if all(basemods_found_dict.values()): return - if counter >= NUM_READS_TO_CHECK: - missing_bases = [] - for base, found in basemods_found_dict.items(): - if not found: - missing_bases.append(base) - print( - f""" -WARNING: no modified appropriately-coded values found for {missing_bases} in the first {counter} reads. + if reads_checked == NUM_READS_TO_CHECK: + missing_bases = [] + for base, found in basemods_found_dict.items(): + if not found: + missing_bases.append(base) + print( + f""" +WARNING: no modified appropriately-coded values found for {missing_bases} in the first {reads_checked} reads. Do you expect this file to contain these modifications? parse_bam is looking for {motifs} but for {missing_bases} found only found {[f"{base}+{mod_codes}" for base, mod_codes in mod_codes_found_dict.items()]}. Consider passing only the motifs and mod codes (e.g. m,h,a) that you expect to be present in your file. You can use modkit adjust-mods --convert [OPTIONS] to update or consolidate mod codes. See https://github.com/nanoporetech/modkit/blob/master/book/src/advanced_usage.md """ - ) - return + ) + return except ValueError as e: if "fetch called on bamfile without index" in str(e): raise ValueError( diff --git a/tests/test_parse_bam.py b/tests/test_parse_bam.py new file mode 100644 index 0000000..e323c9c --- /dev/null +++ b/tests/test_parse_bam.py @@ -0,0 +1,31 @@ +from dimelo import parse_bam + + +class _FakeRead: + def to_dict(self): + return {"tags": []} + + +class _FakeAlignmentFile: + def __init__(self, read_count): + self.read_count = read_count + self.reads_yielded = 0 + + def fetch(self): + for _ in range(self.read_count): + self.reads_yielded += 1 + yield _FakeRead() + + +def test_check_bam_format_consumes_at_most_the_first_100_reads(monkeypatch): + fake_alignment_file = _FakeAlignmentFile(parse_bam.NUM_READS_TO_CHECK + 1) + + monkeypatch.setattr( + parse_bam.pysam, + "AlignmentFile", + lambda *args, **kwargs: fake_alignment_file, + ) + + parse_bam.check_bam_format("dummy.bam", motifs=["A,0", "CG,0"]) + + assert fake_alignment_file.reads_yielded == parse_bam.NUM_READS_TO_CHECK From 2133657b42725d3697c09e7a464e14bf0d44605f Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 14:27:51 -0700 Subject: [PATCH 235/272] fix: keep check_bam_format validating malformed tags across read cap --- dimelo/parse_bam.py | 2 -- tests/test_parse_bam.py | 34 +++++++++++++++++++++++++++++++++- 2 files changed, 33 insertions(+), 3 deletions(-) diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index c41aca6..d89ea92 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -628,8 +628,6 @@ def check_bam_format( # raise ValueError( # f'Base modification name unexpected: {tag_value[2]} to modify {tag_value[0]}, should be in set {valid_mod_codes}. \n\nIf you know what your mod names correspond to in terms of the latest .bam standard, consider using "modkit adjust-mods {str(bam_file)} new_file.bam --convert 5mC_name m --convert N6mA_name a --convert other_basemod_name correct_label" and then trying with the new file. Note: currently supported mod names are {utils.BASEMOD_NAMES_DICT}' # ) - if all(basemods_found_dict.values()): - return if reads_checked == NUM_READS_TO_CHECK: missing_bases = [] for base, found in basemods_found_dict.items(): diff --git a/tests/test_parse_bam.py b/tests/test_parse_bam.py index e323c9c..164ebdd 100644 --- a/tests/test_parse_bam.py +++ b/tests/test_parse_bam.py @@ -1,9 +1,14 @@ +import pytest + from dimelo import parse_bam class _FakeRead: + def __init__(self, tags=None): + self._tags = tags or [] + def to_dict(self): - return {"tags": []} + return {"tags": self._tags} class _FakeAlignmentFile: @@ -17,6 +22,15 @@ def fetch(self): yield _FakeRead() +class _TagSequenceAlignmentFile: + def __init__(self, reads): + self._reads = reads + + def fetch(self): + for read in self._reads: + yield read + + def test_check_bam_format_consumes_at_most_the_first_100_reads(monkeypatch): fake_alignment_file = _FakeAlignmentFile(parse_bam.NUM_READS_TO_CHECK + 1) @@ -29,3 +43,21 @@ def test_check_bam_format_consumes_at_most_the_first_100_reads(monkeypatch): parse_bam.check_bam_format("dummy.bam", motifs=["A,0", "CG,0"]) assert fake_alignment_file.reads_yielded == parse_bam.NUM_READS_TO_CHECK + + +def test_check_bam_format_raises_on_malformed_tags_after_motifs_are_found(monkeypatch): + fake_alignment_file = _TagSequenceAlignmentFile( + [ + _FakeRead(["MM:Z:A+a?;C+m?"]), + _FakeRead(["Mm:Z:A+a?"]), + ] + ) + + monkeypatch.setattr( + parse_bam.pysam, + "AlignmentFile", + lambda *args, **kwargs: fake_alignment_file, + ) + + with pytest.raises(ValueError, match="Mm and Ml instead of MM and ML"): + parse_bam.check_bam_format("dummy.bam", motifs=["A,0", "CG,0"]) From 6c35d6ece06008d3dde7ca129cae314ec0954b98 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 14:30:00 -0700 Subject: [PATCH 236/272] fix: accept tuple region collections in regions_dict_from_input --- dimelo/utils.py | 5 +++-- tests/test_utils_regions.py | 11 +++++++++++ 2 files changed, 14 insertions(+), 2 deletions(-) create mode 100644 tests/test_utils_regions.py diff --git a/dimelo/utils.py b/dimelo/utils.py index 91a2661..c13be1c 100644 --- a/dimelo/utils.py +++ b/dimelo/utils.py @@ -1,5 +1,6 @@ import multiprocessing from collections import defaultdict +from collections.abc import Sequence from pathlib import Path import numpy as np @@ -133,7 +134,7 @@ def process_chunks_from_regions_dict( def regions_dict_from_input( - regions: str | Path | list[str | Path] | None = None, + regions: str | Path | Sequence[str | Path] | None = None, window_size: int | None = None, ) -> dict: """ @@ -152,7 +153,7 @@ def regions_dict_from_input( "Invalid window_size. To disable windowing, set window_size to None or do not pass a value (the default is None)." ) - if isinstance(regions, list): + if isinstance(regions, Sequence) and not isinstance(regions, (str, Path)): for region in regions: add_region_to_dict(region, window_size, regions_dict) else: diff --git a/tests/test_utils_regions.py b/tests/test_utils_regions.py new file mode 100644 index 0000000..e11e8ff --- /dev/null +++ b/tests/test_utils_regions.py @@ -0,0 +1,11 @@ +from dimelo import utils + + +def test_regions_dict_from_input_accepts_tuple_region_collections(): + tuple_regions = ("chr2:5-10,+", "chr1:0-3,-") + list_regions = ["chr2:5-10,+", "chr1:0-3,-"] + + tuple_result = utils.regions_dict_from_input(tuple_regions) + list_result = utils.regions_dict_from_input(list_regions) + + assert tuple_result == list_result From 076a070ef5ef6c823eda5727469e64cd8fdb3663 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 14:37:20 -0700 Subject: [PATCH 237/272] fix: align extract vectors to read span metadata --- dimelo/parse_bam.py | 12 +-- tests/test_parse_bam_vectors.py | 131 ++++++++++++++++++++++++++++++++ 2 files changed, 133 insertions(+), 10 deletions(-) create mode 100644 tests/test_parse_bam_vectors.py diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index d89ea92..eaff3f3 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -988,12 +988,7 @@ def read_by_base_txt_to_hdf5( if read_name != fields[0]: # Record the previous read details unless this is the first line if line_index > 1: - # TODO: Replace this with read_end-read_start; this will pad vectors and require - # regenerating test reference data - if len(valid_coordinates_list) > 0: - read_len_along_ref = max(valid_coordinates_list) + 1 - else: - read_len_along_ref = read_len + read_len_along_ref = max(read_end - read_start, 1) # Populate mod vector array appropriately based on thresh settings mod_vector = np.zeros(read_len_along_ref, dtype=np.uint8) @@ -1097,10 +1092,7 @@ def read_by_base_txt_to_hdf5( # TODO: try to consolidate if len(read_name) > 0: # Build the vectors - if len(valid_coordinates_list) > 0: - read_len_along_ref = max(valid_coordinates_list) + 1 - else: - read_len_along_ref = read_len + read_len_along_ref = max(read_end - read_start, 1) # Populate mod vector array appropriately based on thresh settings mod_vector = np.zeros(read_len_along_ref, dtype=np.uint8) diff --git a/tests/test_parse_bam_vectors.py b/tests/test_parse_bam_vectors.py new file mode 100644 index 0000000..9cc16b9 --- /dev/null +++ b/tests/test_parse_bam_vectors.py @@ -0,0 +1,131 @@ +import gzip +from pathlib import Path + +import h5py +import numpy as np + +from dimelo import parse_bam + + +def _make_extract_line( + read_name: str, + pos_in_read: int, + pos_in_genome: int, + chromosome: str, + strand: str, + read_len: int, + prob: float, + mod_code: str, + canonical_base: str, +) -> str: + fields = [ + read_name, + str(pos_in_read), + str(pos_in_genome), + chromosome, + ".", + strand, + ".", + ".", + ".", + str(read_len), + str(prob), + mod_code, + ".", + ".", + ".", + canonical_base, + ] + return "\t".join(fields) + + +def _write_extract_file(path: Path) -> None: + header = "\t".join(f"col{i}" for i in range(16)) + lines = [ + header, + _make_extract_line( + "read_sparse", + pos_in_read=0, + pos_in_genome=100, + chromosome="chr1", + strand="+", + read_len=10, + prob=0.10, + mod_code="a", + canonical_base="A", + ), + _make_extract_line( + "read_sparse", + pos_in_read=8, + pos_in_genome=108, + chromosome="chr1", + strand="+", + read_len=10, + prob=0.90, + mod_code="a", + canonical_base="A", + ), + _make_extract_line( + "read_no_hits", + pos_in_read=0, + pos_in_genome=200, + chromosome="chr1", + strand="+", + read_len=10, + prob=0.20, + mod_code="m", + canonical_base="C", + ), + _make_extract_line( + "read_no_hits", + pos_in_read=9, + pos_in_genome=210, + chromosome="chr1", + strand="+", + read_len=10, + prob=0.30, + mod_code="m", + canonical_base="C", + ), + ] + path.write_text("\n".join(lines) + "\n") + + +def _decode_vector(dataset, index: int) -> np.ndarray: + raw_bytes = np.asarray(dataset[index], dtype=np.uint8).tobytes() + return np.frombuffer(gzip.decompress(raw_bytes), dtype=np.uint8) + + +def test_read_by_base_txt_to_hdf5_uses_dense_span_vectors(tmp_path): + input_txt = tmp_path / "extract.txt" + output_h5 = tmp_path / "reads.h5" + _write_extract_file(input_txt) + + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=None, + quiet=True, + ) + + with h5py.File(output_h5, "r") as h5: + sparse_index = 0 + sparse_span = int(h5["read_end"][sparse_index] - h5["read_start"][sparse_index]) + sparse_mod_vector = _decode_vector(h5["mod_vector"], sparse_index) + sparse_val_vector = _decode_vector(h5["val_vector"], sparse_index) + + no_hits_index = 1 + no_hits_span = int(h5["read_end"][no_hits_index] - h5["read_start"][no_hits_index]) + no_hits_mod_vector = _decode_vector(h5["mod_vector"], no_hits_index) + no_hits_val_vector = _decode_vector(h5["val_vector"], no_hits_index) + + assert sparse_span == 10 + assert len(sparse_mod_vector) == sparse_span + assert len(sparse_val_vector) == sparse_span + + assert no_hits_span == 11 + assert len(no_hits_mod_vector) == no_hits_span + assert len(no_hits_val_vector) == no_hits_span + assert np.all(no_hits_mod_vector == 0) + assert np.all(no_hits_val_vector == 0) From 50393747a4a24a209470efccc06e0267239cc6b9 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 14:58:18 -0700 Subject: [PATCH 238/272] fix: enforce binary-on-write threshold semantics --- dimelo/load_processed.py | 7 +-- dimelo/parse_bam.py | 39 +++++++------- tests/test_parse_bam_vectors.py | 90 ++++++++++++++++++++++++++++++++- 3 files changed, 112 insertions(+), 24 deletions(-) diff --git a/dimelo/load_processed.py b/dimelo/load_processed.py index b14e4f0..44ee3dc 100644 --- a/dimelo/load_processed.py +++ b/dimelo/load_processed.py @@ -645,9 +645,10 @@ def read_vectors_from_hdf5( a list. The bytes are then decoded for the array entries, which are manually compressed because h5py wasn't behaving. - There's some adjustment for the raw probability (no thresh) to match modkit extract outputs. - Specifically, the 0-255 8bit int has 0.5 added before dividing by 256, giving mod qualities - between 0.001953 and 0.99805 for bases in valid motifs. (Invalid positions have zeros.) + Thresholded files are loaded as binary arrays when the stored threshold metadata is present. + Unthresholded files preserve the raw modkit probability encoding, where the 0-255 8bit int + has 0.5 added before dividing by 256, giving mod qualities between 0.001953 and 0.99805 + for bases in valid motifs. (Invalid positions have zeros.) After this processing, we calculate modification fractions, sort, and return. diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index eaff3f3..3ee4bdc 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -426,11 +426,10 @@ def extract( print(f"Allocating requested {cores} cores.") cores_command_list = ["--threads", str(cores)] - mod_thresh_command_list: list[str] = [] if thresh is None: if not quiet: print( - "No valid base modification threshold provided. Raw probs will be saved." + "No valid base modification threshold provided. Raw probabilities will be saved." ) adjusted_threshold = None else: @@ -439,13 +438,10 @@ def extract( print( f"WARNING: thresh {thresh} is very low and may lead to unexpected behavior. Typical thresholds are at least 0.5 or 128." ) - for motif in motifs: - parsed_motif = utils.ParsedMotif(motif) - for mod_code in parsed_motif.mod_codes: - mod_thresh_command_list = mod_thresh_command_list + [ - "--mod-thresholds", - f"{mod_code}:{adjusted_threshold}", - ] + if not quiet: + print( + "Threshold provided. The extract text will stay probability-valued and read_by_base_txt_to_hdf5 will binarize at write time." + ) if log: if not quiet: @@ -740,9 +736,9 @@ def read_by_base_txt_to_hdf5( chunk_size: int = 1000, ) -> None: """ - Takes in a txt file generated by modkit extract and appends - all the data from a specified motif into an hdf5 file. If a thresh is specified, it - also binarizes the mod calls. + Takes in a txt file generated by modkit extract and appends all the data from a + specified motif into an hdf5 file. If a thresh is specified, the mod calls are + binarized at write time and the threshold is stored alongside the vectors. If the h5 file does not exist it will be created with top-level datasets named ``read_name``, ``chromosome``, ``read_start``, ``read_end``, ``strand``, ``motif``, @@ -768,7 +764,8 @@ def read_by_base_txt_to_hdf5( a methylated adenine is specified as 'A,0' or 'A,0,a' and CpG methylation is specified as 'CG,0' or 'CG,0,m'. thresh: a floating point threshold for base modification calling, between zero and one. - If specified as None, raw probabilities will be saved in the .h5 output. + If specified as None, raw probabilities will be saved in the .h5 output. If set, + the stored mod_vector values are binary 0/1 values at motif-valid coordinates. quiet: if True, this suppresses outputs compress_level: gzip compression level for datasets, specifically for vectors for now chunk_size: size of write chunks in reads @@ -796,7 +793,7 @@ def read_by_base_txt_to_hdf5( with input_txt.open() as txt: # Check file length for line_index, line in enumerate(txt): - fields = line.split("\t") + fields = line.rstrip("\n").split("\t") if line_index > 0 and read_name != fields[0]: read_name = fields[0] num_reads += 1 @@ -810,9 +807,9 @@ def read_by_base_txt_to_hdf5( # h5py does not appear to otherwise support vlen binary dt_vlen = h5py.vlen_dtype(np.dtype("uint8")) - ## Format threshold value and create dataset to store whether this data is thresholded (binary) or raw (float16) - # TODO: should this method thresholding without binarization - # None becomes NaN + ## Format threshold value and create dataset to store whether this data is thresholded (binary) or raw. + # Option 1: thresholded outputs are written as binary 0/1 vectors and the threshold dataset + # records the cutoff used. Raw-probability outputs are preserved only when thresh is None. threshold_to_store = np.nan if thresh is None else thresh if "threshold" in h5: threshold_from_existing = h5["threshold"][()] @@ -979,7 +976,7 @@ def read_by_base_txt_to_hdf5( # Loop through txt file for line_index, line in iterator: # TODO: use csv module - fields = line.split("\t") + fields = line.rstrip("\n").split("\t") pos_in_genome = int(fields[2]) canonical_base = fields[15] prob = float(fields[10]) @@ -990,7 +987,8 @@ def read_by_base_txt_to_hdf5( if line_index > 1: read_len_along_ref = max(read_end - read_start, 1) - # Populate mod vector array appropriately based on thresh settings + # Populate mod vector array appropriately based on thresh settings. + # Option 1: when thresh is provided, write binary 0/1 values; otherwise preserve raw probs. mod_vector = np.zeros(read_len_along_ref, dtype=np.uint8) if thresh is None: # We subtract 0.25 because in modkit they add 0.5, but our elements are zero when the @@ -1094,7 +1092,8 @@ def read_by_base_txt_to_hdf5( # Build the vectors read_len_along_ref = max(read_end - read_start, 1) - # Populate mod vector array appropriately based on thresh settings + # Populate mod vector array appropriately based on thresh settings. + # Option 1: when thresh is provided, write binary 0/1 values; otherwise preserve raw probs. mod_vector = np.zeros(read_len_along_ref, dtype=np.uint8) if thresh is None: # We subtract 0.25 because in modkit they add 0.5, but our elements are zero when the diff --git a/tests/test_parse_bam_vectors.py b/tests/test_parse_bam_vectors.py index 9cc16b9..0a0d7e4 100644 --- a/tests/test_parse_bam_vectors.py +++ b/tests/test_parse_bam_vectors.py @@ -4,7 +4,7 @@ import h5py import numpy as np -from dimelo import parse_bam +from dimelo import load_processed, parse_bam def _make_extract_line( @@ -129,3 +129,91 @@ def test_read_by_base_txt_to_hdf5_uses_dense_span_vectors(tmp_path): assert len(no_hits_val_vector) == no_hits_span assert np.all(no_hits_mod_vector == 0) assert np.all(no_hits_val_vector == 0) + + +def test_read_by_base_txt_to_hdf5_thresholds_at_write_time(tmp_path): + input_txt = tmp_path / "extract.txt" + output_h5 = tmp_path / "reads_thresholded.h5" + _write_extract_file(input_txt) + + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=0.5, + quiet=True, + ) + + with h5py.File(output_h5, "r") as h5: + assert np.isclose(h5["threshold"][()], 0.5) + + sparse_index = 0 + sparse_mod_vector = _decode_vector(h5["mod_vector"], sparse_index) + sparse_val_vector = _decode_vector(h5["val_vector"], sparse_index) + + assert set(np.unique(sparse_mod_vector)).issubset({0, 1}) + assert set(np.unique(sparse_val_vector)).issubset({0, 1}) + np.testing.assert_array_equal( + sparse_mod_vector, + np.array([0, 0, 0, 0, 0, 0, 0, 0, 1, 0], dtype=np.uint8), + ) + np.testing.assert_array_equal( + sparse_val_vector, + np.array([1, 0, 0, 0, 0, 0, 0, 0, 1, 0], dtype=np.uint8), + ) + + +def test_read_vectors_from_hdf5_loads_thresholded_vectors_as_binary(tmp_path): + input_txt = tmp_path / "extract.txt" + output_h5 = tmp_path / "reads_thresholded.h5" + _write_extract_file(input_txt) + + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=0.5, + quiet=True, + ) + + read_tuples, datasets, _ = load_processed.read_vectors_from_hdf5( + file=output_h5, + motifs=["A,0"], + calculate_mod_fractions=False, + quiet=True, + ) + + mod_vector_index = datasets.index("mod_vector") + val_vector_index = datasets.index("val_vector") + read_name_index = datasets.index("read_name") + + assert len(read_tuples) == 2 + assert all(read_tuple[mod_vector_index].dtype == np.bool_ for read_tuple in read_tuples) + assert all(read_tuple[val_vector_index].dtype == np.bool_ for read_tuple in read_tuples) + + reads_by_name = { + read_tuple[read_name_index]: read_tuple for read_tuple in read_tuples + } + + sparse_read = reads_by_name["read_sparse"] + no_hits_read = reads_by_name["read_no_hits"] + + np.testing.assert_array_equal( + sparse_read[mod_vector_index], + np.array([False, False, False, False, False, False, False, False, True, False]), + ) + np.testing.assert_array_equal( + sparse_read[val_vector_index], + np.array([True, False, False, False, False, False, False, False, True, False]), + ) + assert not np.any(no_hits_read[mod_vector_index]) + assert not np.any(no_hits_read[val_vector_index]) + + mod_positions, _, _, _ = load_processed.readwise_binary_modification_arrays( + file=output_h5, + motifs=["A,0"], + regions="chr1:95-220", + thresh=None, + quiet=True, + ) + assert len(mod_positions) == 1 From 34daa9dc007969507e60ca1e0c9b3f319af84fc8 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 15:03:31 -0700 Subject: [PATCH 239/272] fix: stabilize extract read coordinate reconstruction --- dimelo/parse_bam.py | 227 ++++++++++++++------------------ tests/test_parse_bam_vectors.py | 102 ++++++++++++++ 2 files changed, 198 insertions(+), 131 deletions(-) diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index 3ee4bdc..0aa43db 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -944,11 +944,10 @@ def read_by_base_txt_to_hdf5( # TODO: initialize read name to actual first read so we can get rid of the logic in the loop read_name = "" read_chrom = "" - read_len = 0 ref_strand = "" read_start = 0 read_end = 0 - valid_coordinates_list: list[int] = [] + valid_genomic_positions_list: list[int] = [] mod_values_list: list[float] = [] # Count reads for batched write @@ -961,6 +960,70 @@ def read_by_base_txt_to_hdf5( # TODO: replace in loop with read_counter%chunk_size as appropriate reads_in_chunk = 0 + def flush_current_read() -> None: + nonlocal read_counter, reads_in_chunk, chunk_datasets_contents + + if len(read_name) == 0: + return + + read_len_along_ref = max(read_end - read_start, 1) + + # Populate mod vector array appropriately based on thresh settings. + # Option 1: when thresh is provided, write binary 0/1 values; otherwise preserve raw probs. + mod_vector = np.zeros(read_len_along_ref, dtype=np.uint8) + valid_vector = np.zeros(read_len_along_ref, dtype=np.uint8) + + if len(valid_genomic_positions_list) > 0: + valid_coordinates = ( + np.asarray(valid_genomic_positions_list, dtype=int) - read_start + ) + mod_values = np.asarray(mod_values_list, dtype=float) + in_bounds = (valid_coordinates >= 0) & ( + valid_coordinates < read_len_along_ref + ) + valid_coordinates = valid_coordinates[in_bounds] + mod_values = mod_values[in_bounds] + + if thresh is None: + # We subtract 0.25 because in modkit they add 0.5, but our elements are zero when the + # base motif isn't present, so to get things to round to the right integers to match the + # original .bam file, subtracting 0.25 is good. Anything from 0.001 to 0.4999 would work I think + mod_vector[valid_coordinates] = np.rint( + mod_values * 256 - 0.25 + ).astype(np.uint8) + else: + mod_vector[valid_coordinates] = mod_values.astype(np.uint8) + valid_vector[valid_coordinates] = 1 + + # TODO: consolidate compression into a function shared across + mod_vector_compressed = np.frombuffer( + gzip.compress(mod_vector.tobytes(), compresslevel=compress_level), + dtype=np.uint8, + ) + valid_vector_compressed = np.frombuffer( + gzip.compress(valid_vector.tobytes(), compresslevel=compress_level), + dtype=np.uint8, + ) + + chunk_datasets_contents["read_name"].append(read_name) + chunk_datasets_contents["chromosome"].append(read_chrom) + chunk_datasets_contents["read_start"].append(read_start) + chunk_datasets_contents["read_end"].append(read_end) + chunk_datasets_contents["strand"].append(ref_strand) + chunk_datasets_contents["motif"].append(motif) + chunk_datasets_contents["mod_vector"].append(mod_vector_compressed) + chunk_datasets_contents["val_vector"].append(valid_vector_compressed) + + read_counter += 1 + reads_in_chunk += 1 + if reads_in_chunk >= chunk_size: + start_index = old_size + read_counter - reads_in_chunk + end_index = old_size + read_counter + for dataset, entry in chunk_datasets_contents.items(): + h5[dataset][start_index:end_index] = entry + chunk_datasets_contents = defaultdict(list) + reads_in_chunk = 0 + # Setting up progress bars if not in quiet mode # Skip header iterator = enumerate(txt) @@ -974,103 +1037,47 @@ def read_by_base_txt_to_hdf5( ) # Loop through txt file - for line_index, line in iterator: + for _, line in iterator: # TODO: use csv module fields = line.rstrip("\n").split("\t") pos_in_genome = int(fields[2]) canonical_base = fields[15] prob = float(fields[10]) mod_code = fields[11] + pos_in_read = int(fields[1]) + line_read_len = int(fields[9]) + line_ref_strand = fields[5] + # TODO: verify that read position is in the right (ref) coordinate system + if line_ref_strand == "+": + pos_in_read_ref = pos_in_read + elif line_ref_strand == "-": + pos_in_read_ref = line_read_len - pos_in_read - 1 + else: + raise ValueError( + f"Unexpected strand '{line_ref_strand}' in modkit extract row." + ) + start_candidate = pos_in_genome - pos_in_read_ref + end_candidate = start_candidate + line_read_len if read_name != fields[0]: - # Record the previous read details unless this is the first line - if line_index > 1: - read_len_along_ref = max(read_end - read_start, 1) - - # Populate mod vector array appropriately based on thresh settings. - # Option 1: when thresh is provided, write binary 0/1 values; otherwise preserve raw probs. - mod_vector = np.zeros(read_len_along_ref, dtype=np.uint8) - if thresh is None: - # We subtract 0.25 because in modkit they add 0.5, but our elements are zero when the - # base motif isn't present, so to get things to round to the right integers to match the - # original .bam file, subtracting 0.25 is good. Anything from 0.001 to 0.4999 would work I think - mod_vector[valid_coordinates_list] = np.rint( - np.array(mod_values_list) * 256 - 0.25 - ).astype(np.uint8) - else: - mod_vector[valid_coordinates_list] = np.array( - mod_values_list - ).astype(np.uint8) - # TODO: consolidate compression into a function shared across - mod_vector_compressed = np.frombuffer( - gzip.compress( - mod_vector.tobytes(), compresslevel=compress_level - ), - dtype=np.uint8, - ) - - # Populate valid vector array - valid_vector = np.zeros(read_len_along_ref, dtype=np.uint8) - valid_vector[valid_coordinates_list] = 1 - valid_vector_compressed = np.frombuffer( - gzip.compress( - valid_vector.tobytes(), compresslevel=compress_level - ), - dtype=np.uint8, - ) - - chunk_datasets_contents["read_name"].append(read_name) - chunk_datasets_contents["chromosome"].append(read_chrom) - chunk_datasets_contents["read_start"].append(read_start) - chunk_datasets_contents["read_end"].append(read_end) - chunk_datasets_contents["strand"].append(ref_strand) - chunk_datasets_contents["motif"].append(motif) - chunk_datasets_contents["mod_vector"].append( - mod_vector_compressed - ) - chunk_datasets_contents["val_vector"].append( - valid_vector_compressed - ) - - # Write chunk if enough reads have built up - reads_in_chunk += 1 - if reads_in_chunk >= chunk_size: - for dataset, entry in chunk_datasets_contents.items(): - start_index = ( - old_size + (read_counter // chunk_size) * chunk_size - ) - end_index = old_size + read_counter + 1 - h5[dataset][start_index:end_index] = entry - chunk_datasets_contents = defaultdict(list) - reads_in_chunk = 0 - read_counter += 1 + flush_current_read() ## Set up for next read # Metadata read_name = fields[0] read_chrom = fields[3] - read_len = int(fields[9]) - ref_strand = fields[5] - # TODO: verify that read position is in the right (ref) coordinate system - if ref_strand == "+": - pos_in_read_ref = int(fields[1]) - elif ref_strand == "-": - pos_in_read_ref = read_len - int(fields[1]) - 1 - # Calculate read start (leftmost position on ref genome) - # TODO: logic can be replaced when we switch to true read start/end from modkit - read_start = pos_in_genome - pos_in_read_ref + ref_strand = line_ref_strand + read_start = start_candidate + read_end = end_candidate # Instantiate lists mod_values_list = [] - valid_coordinates_list = [] - - # Adjust the read_end (rightmost position on ref genome) each time there's a new mod - # This will lead to the most accurate end positions for gapped reads - # TODO: logic can be replaced when we switch to true read start/end from modkit - if ref_strand == "+": - pos_in_read_ref = int(fields[1]) - elif ref_strand == "-": - pos_in_read_ref = read_len - int(fields[1]) - 1 - read_end = pos_in_genome + (read_len - pos_in_read_ref) + valid_genomic_positions_list = [] + + # keep read extents in reference coordinates by using inferred starts/ends from + # each line, which is robust even when rows are not ordered by genomic position + read_start = min(read_start, start_candidate) + read_end = max(read_end, end_candidate) + # Regardless of whether its a new read or not, # add modification to vector if motif type is correct # for the motif in question @@ -1078,7 +1085,7 @@ def read_by_base_txt_to_hdf5( canonical_base == parsed_motif.modified_base and mod_code in parsed_motif.mod_codes ): - valid_coordinates_list.append(pos_in_genome - read_start) + valid_genomic_positions_list.append(pos_in_genome) if thresh is None: mod_values_list.append(prob) elif prob >= thresh: @@ -1086,54 +1093,12 @@ def read_by_base_txt_to_hdf5( else: mod_values_list.append(0) - # Save the last read - # TODO: try to consolidate - if len(read_name) > 0: - # Build the vectors - read_len_along_ref = max(read_end - read_start, 1) - - # Populate mod vector array appropriately based on thresh settings. - # Option 1: when thresh is provided, write binary 0/1 values; otherwise preserve raw probs. - mod_vector = np.zeros(read_len_along_ref, dtype=np.uint8) - if thresh is None: - # We subtract 0.25 because in modkit they add 0.5, but our elements are zero when the - # base motif isn't present, so to get things to round to the right integers to match the - # original .bam file, subtracting 0.25 is good. Anything from 0.001 to 0.4999 would work I think - mod_vector[valid_coordinates_list] = np.rint( - np.array(mod_values_list) * 256 - 0.25 - ).astype(np.uint8) - else: - mod_vector[valid_coordinates_list] = np.array( - mod_values_list - ).astype(np.uint8) - # TODO: consolidate compression into a function shared across - mod_vector_compressed = np.frombuffer( - gzip.compress(mod_vector.tobytes(), compresslevel=compress_level), - dtype=np.uint8, - ) - - # Populate valid vector array - valid_vector = np.zeros(read_len_along_ref, dtype=np.uint8) - valid_vector[valid_coordinates_list] = 1 - valid_vector_compressed = np.frombuffer( - gzip.compress(valid_vector.tobytes(), compresslevel=compress_level), - dtype=np.uint8, - ) - - chunk_datasets_contents["read_name"].append(read_name) - chunk_datasets_contents["chromosome"].append(read_chrom) - chunk_datasets_contents["read_start"].append(read_start) - chunk_datasets_contents["read_end"].append(read_end) - chunk_datasets_contents["strand"].append(ref_strand) - chunk_datasets_contents["motif"].append(motif) - chunk_datasets_contents["mod_vector"].append(mod_vector_compressed) - chunk_datasets_contents["val_vector"].append(valid_vector_compressed) - + flush_current_read() + if reads_in_chunk > 0: + start_index = old_size + read_counter - reads_in_chunk + end_index = old_size + read_counter for dataset, entry in chunk_datasets_contents.items(): - start_index = old_size + (read_counter // chunk_size) * chunk_size - end_index = old_size + read_counter + 1 h5[dataset][start_index:end_index] = entry - read_counter += 1 return diff --git a/tests/test_parse_bam_vectors.py b/tests/test_parse_bam_vectors.py index 0a0d7e4..ecae881 100644 --- a/tests/test_parse_bam_vectors.py +++ b/tests/test_parse_bam_vectors.py @@ -91,6 +91,60 @@ def _write_extract_file(path: Path) -> None: path.write_text("\n".join(lines) + "\n") +def _write_coordinate_stress_extract_file(path: Path) -> None: + header = "\t".join(f"col{i}" for i in range(16)) + lines = [ + header, + # plus strand read with inferred start drift across rows (tests coordinate robustness) + _make_extract_line( + "read_plus_drift", + pos_in_read=1, + pos_in_genome=102, + chromosome="chr2", + strand="+", + read_len=10, + prob=0.90, + mod_code="a", + canonical_base="A", + ), + _make_extract_line( + "read_plus_drift", + pos_in_read=0, + pos_in_genome=100, + chromosome="chr2", + strand="+", + read_len=10, + prob=0.80, + mod_code="a", + canonical_base="A", + ), + # minus strand read where reference-oriented positions should still map left-to-right + _make_extract_line( + "read_minus", + pos_in_read=1, + pos_in_genome=208, + chromosome="chr2", + strand="-", + read_len=10, + prob=0.70, + mod_code="a", + canonical_base="A", + ), + _make_extract_line( + "read_minus", + pos_in_read=9, + pos_in_genome=200, + chromosome="chr2", + strand="-", + read_len=10, + prob=0.95, + mod_code="a", + canonical_base="A", + ), + ] + path.write_text("\n".join(lines) + "\n") + + def _decode_vector(dataset, index: int) -> np.ndarray: raw_bytes = np.asarray(dataset[index], dtype=np.uint8).tobytes() return np.frombuffer(gzip.decompress(raw_bytes), dtype=np.uint8) @@ -217,3 +271,51 @@ def test_read_vectors_from_hdf5_loads_thresholded_vectors_as_binary(tmp_path): quiet=True, ) assert len(mod_positions) == 1 + + +def test_read_by_base_txt_to_hdf5_reconstructs_coordinates_robustly(tmp_path): + input_txt = tmp_path / "extract.coordinate_stress.txt" + output_h5 = tmp_path / "reads.coordinate_stress.h5" + _write_coordinate_stress_extract_file(input_txt) + + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=0.5, + quiet=True, + ) + + with h5py.File(output_h5, "r") as h5: + read_names = [ + name.decode() if isinstance(name, bytes) else str(name) + for name in h5["read_name"][:] + ] + read_name_to_index = {name: idx for idx, name in enumerate(read_names)} + + plus_idx = read_name_to_index["read_plus_drift"] + minus_idx = read_name_to_index["read_minus"] + + assert int(h5["read_start"][plus_idx]) == 100 + assert int(h5["read_end"][plus_idx]) == 111 + plus_mod = _decode_vector(h5["mod_vector"], plus_idx) + plus_val = _decode_vector(h5["val_vector"], plus_idx) + assert len(plus_mod) == 11 + np.testing.assert_array_equal( + plus_mod, np.array([1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], dtype=np.uint8) + ) + np.testing.assert_array_equal( + plus_val, np.array([1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], dtype=np.uint8) + ) + + assert int(h5["read_start"][minus_idx]) == 200 + assert int(h5["read_end"][minus_idx]) == 210 + minus_mod = _decode_vector(h5["mod_vector"], minus_idx) + minus_val = _decode_vector(h5["val_vector"], minus_idx) + assert len(minus_mod) == 10 + np.testing.assert_array_equal( + minus_mod, np.array([1, 0, 0, 0, 0, 0, 0, 0, 1, 0], dtype=np.uint8) + ) + np.testing.assert_array_equal( + minus_val, np.array([1, 0, 0, 0, 0, 0, 0, 0, 1, 0], dtype=np.uint8) + ) From fc379391bc0e452412587c61a5c6a621889812b9 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 15:07:48 -0700 Subject: [PATCH 240/272] refactor: tighten parser path coercion and remove stale TODOs --- dimelo/parse_bam.py | 41 +++++++++++------------------------------ 1 file changed, 11 insertions(+), 30 deletions(-) diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index 0aa43db..e7a568d 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -112,25 +112,16 @@ def pileup( Path object pointing to 'regions.processed.bed', the `--include-bed` file used for `modkit pileup` """ - """ - TODO: There are a lot of issues that are all related here: - dimelo/parse_bam.py:150: error: Incompatible types in assignment (expression has type "Path | None", variable has type "str | Path") [assignment] - dimelo/parse_bam.py:169: error: Argument "input_file" to "prep_outputs" has incompatible type "str | Path"; expected "Path" [arg-type] - dimelo/parse_bam.py:256: error: Argument "input_file" to "run_with_progress_bars" has incompatible type "str | Path"; expected "Path" [arg-type] - dimelo/parse_bam.py:257: error: Argument "ref_genome" to "run_with_progress_bars" has incompatible type "str | Path"; expected "Path" [arg-type] - - I'm not sure of the most elegant way to fix it. Come back and address. - """ - ## Verify and prepare inputs and outputs run_modkit.ensure_modkit_available(quiet=quiet) - run_modkit.ensure_modkit_available(quiet=quiet) - input_file, ref_genome, output_directory = utils.sanitize_path_args( input_file, ref_genome, output_directory ) + input_file = Path(input_file) + ref_genome = Path(ref_genome) + output_directory = None if output_directory is None else Path(output_directory) try: verify_inputs(input_file, motifs, ref_genome) @@ -365,21 +356,14 @@ def extract( Path object pointing to 'regions.processed.bed', the `--include-bed` file used for `modkit extract` """ - """ - TODO: There are a lot of issues that are all related here: - dimelo/parse_bam.py:374: error: Incompatible types in assignment (expression has type "Path | None", variable has type "str | Path") [assignment] - dimelo/parse_bam.py:393: error: Argument "input_file" to "prep_outputs" has incompatible type "str | Path"; expected "Path" [arg-type] - dimelo/parse_bam.py:480: error: Argument "input_file" to "run_with_progress_bars" has incompatible type "str | Path"; expected "Path" [arg-type] - dimelo/parse_bam.py:481: error: Argument "ref_genome" to "run_with_progress_bars" has incompatible type "str | Path"; expected "Path" [arg-type] - - I'm not sure of the most elegant way to fix it. Come back and address. - """ - ## Verify and prepare inputs and outputs input_file, ref_genome, output_directory = utils.sanitize_path_args( input_file, ref_genome, output_directory ) + input_file = Path(input_file) + ref_genome = Path(ref_genome) + output_directory = None if output_directory is None else Path(output_directory) try: verify_inputs(input_file, motifs, ref_genome) @@ -773,16 +757,10 @@ def read_by_base_txt_to_hdf5( Returns: None - """ - """ - TODO: There are some issues that are all related here: - dimelo/parse_bam.py:718: error: Incompatible types in assignment (expression has type "Path | None", variable has type "str | Path") [assignment] - dimelo/parse_bam.py:725: error: Item "str" of "str | Path" has no attribute "open" [union-attr] - dimelo/parse_bam.py:890: error: Item "str" of "str | Path" has no attribute "name" [union-attr] - - I'm not sure of the most elegant way to fix it. Come back and address. """ input_txt, output_h5 = utils.sanitize_path_args(input_txt, output_h5) + input_txt = Path(input_txt) + output_h5 = Path(output_h5) parsed_motif = utils.ParsedMotif(motif) @@ -792,11 +770,14 @@ def read_by_base_txt_to_hdf5( # TODO: Consider opening both files at once with input_txt.open() as txt: # Check file length + line_index = -1 for line_index, line in enumerate(txt): fields = line.rstrip("\n").split("\t") if line_index > 0 and read_name != fields[0]: read_name = fields[0] num_reads += 1 + if line_index < 0: + raise ValueError(f"modkit extract output is empty: {input_txt}") num_lines = line_index txt.seek(0) From 745cec905d15673fb4ce7a8c9cbd51ac222fc5b0 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 15:08:37 -0700 Subject: [PATCH 241/272] refactor: unify parser thread allocation logic --- dimelo/parse_bam.py | 57 ++++++++++++++++------------------------- tests/test_parse_bam.py | 24 +++++++++++++++++ 2 files changed, 46 insertions(+), 35 deletions(-) diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index e7a568d..088358f 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -25,6 +25,26 @@ # Specifies how many reads to check for the base modifications of interest. NUM_READS_TO_CHECK = 100 + +def _threads_command_list(cores: int | None, quiet: bool) -> list[str]: + cores_avail = multiprocessing.cpu_count() + if cores is None: + if not quiet: + print( + f"No specified number of cores requested. {cores_avail} available on machine, allocating all." + ) + return ["--threads", str(cores_avail)] + if cores > cores_avail: + if not quiet: + print( + f"Warning: {cores} cores request, {cores_avail} available. Allocating {cores_avail}" + ) + return ["--threads", str(cores_avail)] + if not quiet: + print(f"Allocating requested {cores} cores.") + return ["--threads", str(cores)] + + """ User-facing parse operations: pileup and extract """ @@ -184,24 +204,7 @@ def pileup( else: log_command_list = [] - # TODO: This should be a method, like create_region_specifier, or just combined into a prep method for the start... - cores_avail = multiprocessing.cpu_count() - if cores is None: - if not quiet: - print( - f"No specified number of cores requested. {cores_avail} available on machine, allocating all." - ) - cores_command_list = ["--threads", str(cores_avail)] - elif cores > cores_avail: - if not quiet: - print( - f"Warning: {cores} cores request, {cores_avail} available. Allocating {cores_avail}" - ) - cores_command_list = ["--threads", str(cores_avail)] - else: - if not quiet: - print(f"Allocating requested {cores} cores.") - cores_command_list = ["--threads", str(cores)] + cores_command_list = _threads_command_list(cores=cores, quiet=quiet) # TODO: This is SO SO SO similar to extract; just the ValueError vs. printing. I think this can be resolved mod_thresh_command_list: list[str] = [] @@ -392,23 +395,7 @@ def extract( window_size, ) - cores_avail = multiprocessing.cpu_count() - if cores is None: - if not quiet: - print( - f"No specified number of cores requested. {cores_avail} available on machine, allocating all." - ) - cores_command_list = ["--threads", str(cores_avail)] - elif cores > cores_avail: - if not quiet: - print( - f"Warning: {cores} cores request, {cores_avail} available. Allocating {cores_avail}" - ) - cores_command_list = ["--threads", str(cores_avail)] - else: - if not quiet: - print(f"Allocating requested {cores} cores.") - cores_command_list = ["--threads", str(cores)] + cores_command_list = _threads_command_list(cores=cores, quiet=quiet) if thresh is None: if not quiet: diff --git a/tests/test_parse_bam.py b/tests/test_parse_bam.py index 164ebdd..1705296 100644 --- a/tests/test_parse_bam.py +++ b/tests/test_parse_bam.py @@ -61,3 +61,27 @@ def test_check_bam_format_raises_on_malformed_tags_after_motifs_are_found(monkey with pytest.raises(ValueError, match="Mm and Ml instead of MM and ML"): parse_bam.check_bam_format("dummy.bam", motifs=["A,0", "CG,0"]) + + +def test_threads_command_list_defaults_to_all_available_cores(monkeypatch): + monkeypatch.setattr(parse_bam.multiprocessing, "cpu_count", lambda: 12) + + command = parse_bam._threads_command_list(cores=None, quiet=True) + + assert command == ["--threads", "12"] + + +def test_threads_command_list_caps_requested_cores_to_available(monkeypatch): + monkeypatch.setattr(parse_bam.multiprocessing, "cpu_count", lambda: 8) + + command = parse_bam._threads_command_list(cores=32, quiet=True) + + assert command == ["--threads", "8"] + + +def test_threads_command_list_uses_requested_cores_when_available(monkeypatch): + monkeypatch.setattr(parse_bam.multiprocessing, "cpu_count", lambda: 16) + + command = parse_bam._threads_command_list(cores=6, quiet=True) + + assert command == ["--threads", "6"] From a7056b6497ef0bb3e2f876c98efb6a91819c6396 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 15:09:50 -0700 Subject: [PATCH 242/272] fix: handle empty-region readwise extraction gracefully --- dimelo/load_processed.py | 8 ++++++++ tests/test_parse_bam_vectors.py | 29 +++++++++++++++++++++++++++++ 2 files changed, 37 insertions(+) diff --git a/dimelo/load_processed.py b/dimelo/load_processed.py index 44ee3dc..3276ce5 100644 --- a/dimelo/load_processed.py +++ b/dimelo/load_processed.py @@ -1001,6 +1001,14 @@ def readwise_binary_modification_arrays( read_start_index = datasets.index("read_start") region_strand_index = datasets.index("region_strand") + if len(sorted_read_data_converted) == 0: + return ( + np.array([], dtype=int), + np.array([], dtype=int), + np.array([], dtype=str), + regions_dict, + ) + # Check this .h5 file was created with a threshold, i.e. that the mod calls are binarized if thresh is None: if not (sorted_read_data_converted[0][mod_vector_index].dtype == np.bool_): diff --git a/tests/test_parse_bam_vectors.py b/tests/test_parse_bam_vectors.py index ecae881..ade25b8 100644 --- a/tests/test_parse_bam_vectors.py +++ b/tests/test_parse_bam_vectors.py @@ -319,3 +319,32 @@ def test_read_by_base_txt_to_hdf5_reconstructs_coordinates_robustly(tmp_path): np.testing.assert_array_equal( minus_val, np.array([1, 0, 0, 0, 0, 0, 0, 0, 1, 0], dtype=np.uint8) ) + + +def test_readwise_binary_modification_arrays_returns_empty_for_empty_region(tmp_path): + input_txt = tmp_path / "extract.txt" + output_h5 = tmp_path / "reads_thresholded.h5" + _write_extract_file(input_txt) + + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=0.5, + quiet=True, + ) + + mod_positions, read_ids, motifs, regions_dict = ( + load_processed.readwise_binary_modification_arrays( + file=output_h5, + motifs=["A,0"], + regions="chr1:1000-1010", + thresh=None, + quiet=True, + ) + ) + + assert mod_positions.size == 0 + assert read_ids.size == 0 + assert motifs.size == 0 + assert regions_dict == {"chr1": [(1000, 1010, ".")]} From befed1a1f565a07bd30037a66753297ccdb92c39 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 15:10:54 -0700 Subject: [PATCH 243/272] fix: keep load_processed subset operations safe on empty selections --- dimelo/load_processed.py | 20 +++++++++++++------- tests/test_parse_bam_vectors.py | 27 +++++++++++++++++++++++++++ 2 files changed, 40 insertions(+), 7 deletions(-) diff --git a/dimelo/load_processed.py b/dimelo/load_processed.py index 3276ce5..30c1d6f 100644 --- a/dimelo/load_processed.py +++ b/dimelo/load_processed.py @@ -745,11 +745,14 @@ def read_vectors_from_hdf5( ) ) if subset_parameters is not None: - relevant_read_indices = np.sort( - utils.random_sample( - relevant_read_indices, **subset_parameters + if len(relevant_read_indices) > 0: + relevant_read_indices = np.sort( + utils.random_sample( + relevant_read_indices, **subset_parameters + ) ) - ) + else: + relevant_read_indices = np.array([], dtype=int) read_tuples_raw += list( zip( *( @@ -773,9 +776,12 @@ def read_vectors_from_hdf5( regions_dict = None relevant_read_indices = np.flatnonzero(np.isin(read_motifs, motifs)) if subset_parameters is not None: - relevant_read_indices = np.sort( - utils.random_sample(relevant_read_indices, **subset_parameters) - ) + if len(relevant_read_indices) > 0: + relevant_read_indices = np.sort( + utils.random_sample(relevant_read_indices, **subset_parameters) + ) + else: + relevant_read_indices = np.array([], dtype=int) read_tuples_raw = list( zip( *( diff --git a/tests/test_parse_bam_vectors.py b/tests/test_parse_bam_vectors.py index ade25b8..3896ae5 100644 --- a/tests/test_parse_bam_vectors.py +++ b/tests/test_parse_bam_vectors.py @@ -348,3 +348,30 @@ def test_readwise_binary_modification_arrays_returns_empty_for_empty_region(tmp_ assert read_ids.size == 0 assert motifs.size == 0 assert regions_dict == {"chr1": [(1000, 1010, ".")]} + + +def test_read_vectors_from_hdf5_subset_empty_region_returns_empty(tmp_path): + input_txt = tmp_path / "extract.txt" + output_h5 = tmp_path / "reads_thresholded.h5" + _write_extract_file(input_txt) + + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=0.5, + quiet=True, + ) + + read_tuples, datasets, regions_dict = load_processed.read_vectors_from_hdf5( + file=output_h5, + motifs=["A,0"], + regions="chr1:1000-1010", + subset_parameters={"n": 1}, + calculate_mod_fractions=False, + quiet=True, + ) + + assert read_tuples == [] + assert "mod_vector" in datasets + assert regions_dict == {"chr1": [(1000, 1010, ".")]} From 57b1b39f3c3148905f350f1da5c1abdfb646f8c4 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 15:13:24 -0700 Subject: [PATCH 244/272] fix: disambiguate read ids across overlapping regions --- dimelo/load_processed.py | 29 ++++++++++++++++------------- tests/test_parse_bam_vectors.py | 28 ++++++++++++++++++++++++++++ 2 files changed, 44 insertions(+), 13 deletions(-) diff --git a/dimelo/load_processed.py b/dimelo/load_processed.py index 30c1d6f..a19eded 100644 --- a/dimelo/load_processed.py +++ b/dimelo/load_processed.py @@ -1024,21 +1024,24 @@ def readwise_binary_modification_arrays( else: thresh = utils.adjust_threshold(thresh) + read_identity_to_int: dict[tuple, int] = {} read_ints_list = [] + for read_data in sorted_read_data_converted: + read_identity = ( + read_data[read_name_index], + read_data[region_start_index], + read_data[region_end_index], + read_data[region_strand_index], + ) + if read_identity not in read_identity_to_int: + read_identity_to_int[read_identity] = len(read_identity_to_int) + read_ints_list.append(read_identity_to_int[read_identity]) + read_ints = np.array(read_ints_list) + + read_ids_by_mod_pos: list[int] = [] mod_coords_list = [] motifs_list = [] - read_names = np.array( - [read_data[read_name_index] for read_data in sorted_read_data_converted] - ) - # TODO: handle the case where a read shows up in more than one different region - _, unique_first_indices = np.unique(read_names, return_index=True) - unique_in_order = read_names[np.sort(unique_first_indices)] - string_to_int = { - read_name: index for index, read_name in enumerate(unique_in_order) - } - read_ints = np.array([string_to_int[read_name] for read_name in read_names]) - for read_int, read_data in zip(read_ints, sorted_read_data_converted): if thresh is None: mod_pos_in_read = np.flatnonzero(read_data[mod_vector_index]) @@ -1072,12 +1075,12 @@ def readwise_binary_modification_arrays( mod_pos_record = mod_pos_in_read + read_data[read_start_index] mod_coords_list += list(mod_pos_record) - read_ints_list += [read_int] * len(mod_pos_record) + read_ids_by_mod_pos += [read_int] * len(mod_pos_record) motifs_list += [read_data[motif_index]] * len(mod_pos_record) return ( np.array(mod_coords_list), - np.array(read_ints_list), + np.array(read_ids_by_mod_pos), np.array(motifs_list), regions_dict, ) diff --git a/tests/test_parse_bam_vectors.py b/tests/test_parse_bam_vectors.py index 3896ae5..c819a55 100644 --- a/tests/test_parse_bam_vectors.py +++ b/tests/test_parse_bam_vectors.py @@ -375,3 +375,31 @@ def test_read_vectors_from_hdf5_subset_empty_region_returns_empty(tmp_path): assert read_tuples == [] assert "mod_vector" in datasets assert regions_dict == {"chr1": [(1000, 1010, ".")]} + + +def test_readwise_binary_modification_arrays_splits_duplicate_read_names_by_region( + tmp_path, +): + input_txt = tmp_path / "extract.txt" + output_h5 = tmp_path / "reads_thresholded.h5" + _write_extract_file(input_txt) + + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=0.5, + quiet=True, + ) + + _, read_ids, motifs, regions_dict = load_processed.readwise_binary_modification_arrays( + file=output_h5, + motifs=["A,0"], + regions=["chr1:95-105", "chr1:100-110"], + thresh=None, + quiet=True, + ) + + assert set(read_ids.tolist()) == {0, 1} + assert motifs.size == read_ids.size == 2 + assert regions_dict == {"chr1": [(95, 105, "."), (100, 110, ".")]} From a625de1899d51e806b7a26bab6a518e7c048a915 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 15:14:13 -0700 Subject: [PATCH 245/272] fix: validate load_processed subset parameter contract --- dimelo/load_processed.py | 8 ++++++++ tests/test_parse_bam_vectors.py | 25 +++++++++++++++++++++++++ 2 files changed, 33 insertions(+) diff --git a/dimelo/load_processed.py b/dimelo/load_processed.py index a19eded..c22f7c7 100644 --- a/dimelo/load_processed.py +++ b/dimelo/load_processed.py @@ -692,6 +692,14 @@ def read_vectors_from_hdf5( TODO: The way the subsetting is implemented is confusing, in that you need to pass all but one of the available parameters. """ + if subset_parameters is not None: + if not isinstance(subset_parameters, dict): + raise ValueError("subset_parameters must be provided as a dictionary.") + if "n" not in subset_parameters and "frac" not in subset_parameters: + raise ValueError( + "subset_parameters must include at least one of 'n' or 'frac'." + ) + with h5py.File(file, "r") as h5: datasets: list[str] = [ name for name, obj in h5.items() if isinstance(obj, h5py.Dataset) diff --git a/tests/test_parse_bam_vectors.py b/tests/test_parse_bam_vectors.py index c819a55..293484b 100644 --- a/tests/test_parse_bam_vectors.py +++ b/tests/test_parse_bam_vectors.py @@ -3,6 +3,7 @@ import h5py import numpy as np +import pytest from dimelo import load_processed, parse_bam @@ -403,3 +404,27 @@ def test_readwise_binary_modification_arrays_splits_duplicate_read_names_by_regi assert set(read_ids.tolist()) == {0, 1} assert motifs.size == read_ids.size == 2 assert regions_dict == {"chr1": [(95, 105, "."), (100, 110, ".")]} + + +def test_read_vectors_from_hdf5_rejects_subset_without_n_or_frac(tmp_path): + input_txt = tmp_path / "extract.txt" + output_h5 = tmp_path / "reads_thresholded.h5" + _write_extract_file(input_txt) + + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=0.5, + quiet=True, + ) + + with pytest.raises(ValueError, match="subset_parameters must include"): + load_processed.read_vectors_from_hdf5( + file=output_h5, + motifs=["A,0"], + regions="chr1:95-110", + subset_parameters={}, + calculate_mod_fractions=False, + quiet=True, + ) From f2d8ed30cf3779bd7cb6b50a88122b72130edc94 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 15:15:06 -0700 Subject: [PATCH 246/272] refactor: share extract vector compression helper --- dimelo/load_processed.py | 2 -- dimelo/parse_bam.py | 21 ++++++++++++++------- 2 files changed, 14 insertions(+), 9 deletions(-) diff --git a/dimelo/load_processed.py b/dimelo/load_processed.py index c22f7c7..a2adc5d 100644 --- a/dimelo/load_processed.py +++ b/dimelo/load_processed.py @@ -689,8 +689,6 @@ def read_vectors_from_hdf5( a list of strings, naming the datasets returned. a regions_dict, containing lists of (region_start,region_end) coordinates by chromosome/contig. - TODO: The way the subsetting is implemented is confusing, in that you need to pass all but one of - the available parameters. """ if subset_parameters is not None: if not isinstance(subset_parameters, dict): diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index 088358f..16bae7e 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -45,6 +45,16 @@ def _threads_command_list(cores: int | None, quiet: bool) -> list[str]: return ["--threads", str(cores)] +def _compress_uint8_vector( + vector: np.ndarray, + compress_level: int, +) -> np.ndarray: + return np.frombuffer( + gzip.compress(vector.tobytes(), compresslevel=compress_level), + dtype=np.uint8, + ) + + """ User-facing parse operations: pileup and extract """ @@ -963,14 +973,11 @@ def flush_current_read() -> None: mod_vector[valid_coordinates] = mod_values.astype(np.uint8) valid_vector[valid_coordinates] = 1 - # TODO: consolidate compression into a function shared across - mod_vector_compressed = np.frombuffer( - gzip.compress(mod_vector.tobytes(), compresslevel=compress_level), - dtype=np.uint8, + mod_vector_compressed = _compress_uint8_vector( + mod_vector, compress_level=compress_level ) - valid_vector_compressed = np.frombuffer( - gzip.compress(valid_vector.tobytes(), compresslevel=compress_level), - dtype=np.uint8, + valid_vector_compressed = _compress_uint8_vector( + valid_vector, compress_level=compress_level ) chunk_datasets_contents["read_name"].append(read_name) From f5793b5bbd973c562410a818648ec00629d12399 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 15:16:32 -0700 Subject: [PATCH 247/272] fix: reject invalid subset array override in loaders --- dimelo/load_processed.py | 4 ++++ tests/test_parse_bam_vectors.py | 24 ++++++++++++++++++++++++ 2 files changed, 28 insertions(+) diff --git a/dimelo/load_processed.py b/dimelo/load_processed.py index a2adc5d..8d08e36 100644 --- a/dimelo/load_processed.py +++ b/dimelo/load_processed.py @@ -693,6 +693,10 @@ def read_vectors_from_hdf5( if subset_parameters is not None: if not isinstance(subset_parameters, dict): raise ValueError("subset_parameters must be provided as a dictionary.") + if "array" in subset_parameters: + raise ValueError( + "subset_parameters cannot include 'array'; it is provided internally." + ) if "n" not in subset_parameters and "frac" not in subset_parameters: raise ValueError( "subset_parameters must include at least one of 'n' or 'frac'." diff --git a/tests/test_parse_bam_vectors.py b/tests/test_parse_bam_vectors.py index 293484b..7e95f3c 100644 --- a/tests/test_parse_bam_vectors.py +++ b/tests/test_parse_bam_vectors.py @@ -428,3 +428,27 @@ def test_read_vectors_from_hdf5_rejects_subset_without_n_or_frac(tmp_path): calculate_mod_fractions=False, quiet=True, ) + + +def test_read_vectors_from_hdf5_rejects_subset_with_array_key(tmp_path): + input_txt = tmp_path / "extract.txt" + output_h5 = tmp_path / "reads_thresholded.h5" + _write_extract_file(input_txt) + + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=0.5, + quiet=True, + ) + + with pytest.raises(ValueError, match="cannot include 'array'"): + load_processed.read_vectors_from_hdf5( + file=output_h5, + motifs=["A,0"], + regions="chr1:95-110", + subset_parameters={"array": np.array([0]), "n": 1}, + calculate_mod_fractions=False, + quiet=True, + ) From 526d01b0315b50613674e8b680279cf9cb3ff7ee Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 17:32:32 -0700 Subject: [PATCH 248/272] feat: wire loader progress bars and readwise pass-through options --- dimelo/load_processed.py | 125 +++++++++++++++++++------------- tests/test_parse_bam_vectors.py | 51 +++++++++++++ 2 files changed, 127 insertions(+), 49 deletions(-) diff --git a/dimelo/load_processed.py b/dimelo/load_processed.py index 8d08e36..103bec7 100644 --- a/dimelo/load_processed.py +++ b/dimelo/load_processed.py @@ -626,7 +626,7 @@ def read_vectors_from_hdf5( single_strand: bool = False, sort_by: str | list[str] = ["chromosome", "region_start", "read_start"], calculate_mod_fractions: bool = True, - quiet: bool = True, # currently unused; change to default False when pbars are implemented + quiet: bool = True, cores: int | None = None, # currently unused subset_parameters: dict | None = None, span_full_window: bool = False, @@ -652,7 +652,7 @@ def read_vectors_from_hdf5( After this processing, we calculate modification fractions, sort, and return. - TODO: Implement progress bars and parallelization as with pileup loaders + TODO: Implement parallelization as with pileup loaders Args: file: Path to an hdf5 (.h5) file containing modification data for single reads, @@ -676,7 +676,7 @@ def read_vectors_from_hdf5( sort_by: Read properties by which to sort, either one string or a list of strings. Options include chromosome, region_start, region_end, read_start, read_end, and motif. More to be added in future. - quiet: silences progress bars (currently unused) + quiet: silences progress bars cores: cores across which to parallelize processes (currently unused) subset_parameters: Parameters to pass to the utils.random_sample() method, to subset the reads to be returned. If not None, at least one of n or frac must be provided. The array @@ -736,52 +736,67 @@ def read_vectors_from_hdf5( window_size=window_size, ) read_tuples_raw = [] - for chrom, region_list in regions_dict.items(): - for region_start, region_end, region_strand in region_list: - # Find the read indices that we want to load - # TODO: consider building this up and then loading all at the end, chunked - # TODO: consolidate logic into clear variables - relevant_read_indices = np.flatnonzero( - (read_ends > region_start) - & (read_starts < region_end) - & (read_starts <= region_start if span_full_window else True) - & (read_ends >= region_end if span_full_window else True) - & np.isin(read_motifs, motifs) - & (read_chromosomes == chrom) - & ( - (not single_strand) - | (region_strand not in ["+", "-"]) - | (ref_strands == region_strand) - ) + region_jobs = [ + (chrom, region_start, region_end, region_strand) + for chrom, region_list in regions_dict.items() + for region_start, region_end, region_strand in region_list + ] + region_iterator = ( + tqdm( + region_jobs, + total=len(region_jobs), + disable=quiet, + desc="Loading read vectors", + leave=False, + ) + if len(region_jobs) > 0 + else region_jobs + ) + for chrom, region_start, region_end, region_strand in region_iterator: + # Find the read indices that we want to load + # TODO: consider building this up and then loading all at the end, chunked + # TODO: consolidate logic into clear variables + relevant_read_indices = np.flatnonzero( + (read_ends > region_start) + & (read_starts < region_end) + & (read_starts <= region_start if span_full_window else True) + & (read_ends >= region_end if span_full_window else True) + & np.isin(read_motifs, motifs) + & (read_chromosomes == chrom) + & ( + (not single_strand) + | (region_strand not in ["+", "-"]) + | (ref_strands == region_strand) ) - if subset_parameters is not None: - if len(relevant_read_indices) > 0: - relevant_read_indices = np.sort( - utils.random_sample( - relevant_read_indices, **subset_parameters - ) + ) + if subset_parameters is not None: + if len(relevant_read_indices) > 0: + relevant_read_indices = np.sort( + utils.random_sample( + relevant_read_indices, **subset_parameters ) - else: - relevant_read_indices = np.array([], dtype=int) - read_tuples_raw += list( - zip( - *( - retrieve_h5_data( - h5=h5, - dataset=dataset, - indices=relevant_read_indices, - compressed=dataset in compressed_binary_datasets, - dtype=np.uint8, - decompressor=gzip.decompress, - binarized=binarized, - ) - for dataset in readwise_datasets - ), - [region_start for _ in relevant_read_indices], - [region_end for _ in relevant_read_indices], - [region_strand for _ in relevant_read_indices], ) + else: + relevant_read_indices = np.array([], dtype=int) + read_tuples_raw += list( + zip( + *( + retrieve_h5_data( + h5=h5, + dataset=dataset, + indices=relevant_read_indices, + compressed=dataset in compressed_binary_datasets, + dtype=np.uint8, + decompressor=gzip.decompress, + binarized=binarized, + ) + for dataset in readwise_datasets + ), + [region_start for _ in relevant_read_indices], + [region_end for _ in relevant_read_indices], + [region_strand for _ in relevant_read_indices], ) + ) else: regions_dict = None relevant_read_indices = np.flatnonzero(np.isin(read_motifs, motifs)) @@ -933,7 +948,7 @@ def readwise_binary_modification_arrays( sort_by: str | list[str] = ["chromosome", "region_start", "read_start"], thresh: float | None = None, relative: bool = True, - quiet: bool = True, # currently unused; change to default False when pbars are implemented + quiet: bool = True, cores: int | None = None, # currently unused subset_parameters: dict | None = None, ) -> tuple[list[np.ndarray], np.ndarray[int], np.ndarray[str], dict | None]: @@ -951,7 +966,7 @@ def readwise_binary_modification_arrays( coordinates. If positions are relative, regions_5to3prime can be used to show all regions as upstream-to-downstream along their respective strands. - TODO: Implement progress bars and parallelization as with pileup loaders + TODO: Implement parallelization as with pileup loaders Args: file: Path to an hdf5 (.h5) file containing modification data for single reads, @@ -981,7 +996,7 @@ def readwise_binary_modification_arrays( in the genomes, centered at the center of the region. If False, absolute coordinates are provided. There is not currently a check for all reads being on the same chromosome if relative=False, but this could create unexpected behaviour for a the standard visualizations. - quiet: silences progress bars (currently unused) + quiet: silences progress bars cores: cores across which to parallelize processes (currently unused) subset_parameters: Parameters to pass to the utils.random_sample() method, to subset the reads to be returned. If not None, at least one of n or frac must be provided. The array @@ -1008,6 +1023,8 @@ def readwise_binary_modification_arrays( window_size=window_size, single_strand=single_strand, sort_by=sort_by, + quiet=quiet, + subset_parameters=subset_parameters, ) read_name_index = datasets.index("read_name") mod_vector_index = datasets.index("mod_vector") @@ -1052,7 +1069,17 @@ def readwise_binary_modification_arrays( mod_coords_list = [] motifs_list = [] - for read_int, read_data in zip(read_ints, sorted_read_data_converted): + read_iterator = zip(read_ints, sorted_read_data_converted) + if len(sorted_read_data_converted) > 0: + read_iterator = tqdm( + read_iterator, + total=len(sorted_read_data_converted), + disable=quiet, + desc="Extracting readwise modifications", + leave=False, + ) + + for read_int, read_data in read_iterator: if thresh is None: mod_pos_in_read = np.flatnonzero(read_data[mod_vector_index]) else: diff --git a/tests/test_parse_bam_vectors.py b/tests/test_parse_bam_vectors.py index 7e95f3c..54b78db 100644 --- a/tests/test_parse_bam_vectors.py +++ b/tests/test_parse_bam_vectors.py @@ -452,3 +452,54 @@ def test_read_vectors_from_hdf5_rejects_subset_with_array_key(tmp_path): calculate_mod_fractions=False, quiet=True, ) + + +def test_readwise_binary_modification_arrays_passes_subset_and_quiet(monkeypatch): + captured_kwargs = {} + + def _fake_read_vectors_from_hdf5(**kwargs): + captured_kwargs.update(kwargs) + return ( + [ + ( + "read1", + np.array([True, False], dtype=np.bool_), + "A,0", + 100, + 110, + 100, + ".", + ) + ], + [ + "read_name", + "mod_vector", + "motif", + "region_start", + "region_end", + "read_start", + "region_strand", + ], + {"chr1": [(100, 110, ".")]}, + ) + + monkeypatch.setattr( + load_processed, "read_vectors_from_hdf5", _fake_read_vectors_from_hdf5 + ) + + mod_positions, read_ids, motifs, regions_dict = ( + load_processed.readwise_binary_modification_arrays( + file=Path("dummy.h5"), + motifs=["A,0"], + regions="chr1:100-110", + subset_parameters={"n": 1}, + quiet=False, + ) + ) + + assert captured_kwargs["quiet"] is False + assert captured_kwargs["subset_parameters"] == {"n": 1} + assert mod_positions.tolist() == [-5] + assert read_ids.tolist() == [0] + assert motifs.tolist() == ["A,0"] + assert regions_dict == {"chr1": [(100, 110, ".")]} From c0d0d70dde417500165ae3192039cd19e54ae2da Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 17:33:26 -0700 Subject: [PATCH 249/272] refactor: centralize loader subset index handling --- dimelo/load_processed.py | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/dimelo/load_processed.py b/dimelo/load_processed.py index 103bec7..59ac02d 100644 --- a/dimelo/load_processed.py +++ b/dimelo/load_processed.py @@ -21,6 +21,18 @@ # the reasonable upper bound) and 10x fewer cores (which is about the reasonable lower bound). DEFAULT_CHUNK_SIZE = 1_000_000 + +def _subset_indices( + indices: np.ndarray, + subset_parameters: dict | None, +) -> np.ndarray: + if subset_parameters is None: + return indices + if len(indices) == 0: + return np.array([], dtype=int) + return np.sort(utils.random_sample(indices, **subset_parameters)) + + ################################################################################################################ #### Loader wrappers #### ################################################################################################################ @@ -754,8 +766,6 @@ def read_vectors_from_hdf5( ) for chrom, region_start, region_end, region_strand in region_iterator: # Find the read indices that we want to load - # TODO: consider building this up and then loading all at the end, chunked - # TODO: consolidate logic into clear variables relevant_read_indices = np.flatnonzero( (read_ends > region_start) & (read_starts < region_end) @@ -769,15 +779,9 @@ def read_vectors_from_hdf5( | (ref_strands == region_strand) ) ) - if subset_parameters is not None: - if len(relevant_read_indices) > 0: - relevant_read_indices = np.sort( - utils.random_sample( - relevant_read_indices, **subset_parameters - ) - ) - else: - relevant_read_indices = np.array([], dtype=int) + relevant_read_indices = _subset_indices( + relevant_read_indices, subset_parameters=subset_parameters + ) read_tuples_raw += list( zip( *( @@ -800,13 +804,9 @@ def read_vectors_from_hdf5( else: regions_dict = None relevant_read_indices = np.flatnonzero(np.isin(read_motifs, motifs)) - if subset_parameters is not None: - if len(relevant_read_indices) > 0: - relevant_read_indices = np.sort( - utils.random_sample(relevant_read_indices, **subset_parameters) - ) - else: - relevant_read_indices = np.array([], dtype=int) + relevant_read_indices = _subset_indices( + relevant_read_indices, subset_parameters=subset_parameters + ) read_tuples_raw = list( zip( *( From 35524e5b549303dad51f15f116a8b3a41c7ebccf Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 17:35:44 -0700 Subject: [PATCH 250/272] refactor: separate region bed normalization from command assembly --- dimelo/parse_bam.py | 49 +++++++++++++++++++++++++---------------- tests/test_parse_bam.py | 24 ++++++++++++++++++++ 2 files changed, 54 insertions(+), 19 deletions(-) diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index 16bae7e..4dc53a7 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -681,30 +681,41 @@ def get_alignment_quality( def create_region_command_list( - output_path, - regions, - window_size, -): + output_path: Path, + regions: str | Path | list[str | Path] | None, + window_size: int | None, +) -> tuple[list[str], Path | None]: """ - Creates commands to pass to modkit for specifying genomic regions. - - TODO: Split into two function? Convert to bed, then construct commands + Create modkit `--include-bed` arguments and the processed BED path, if regions are provided. """ - if regions is not None: - bed_filepath_processed = output_path / "regions.processed.bed" - regions_dict = utils.regions_dict_from_input( - regions, - window_size, - ) - utils.bed_from_regions_dict(regions_dict, bed_filepath_processed) - region_specifier = ["--include-bed", str(bed_filepath_processed)] + bed_filepath_processed = _regions_to_processed_bed( + output_path=output_path, + regions=regions, + window_size=window_size, + ) + if bed_filepath_processed is None: + return [], None + return ["--include-bed", str(bed_filepath_processed)], bed_filepath_processed - else: - bed_filepath_processed = None - region_specifier = [] - return region_specifier, bed_filepath_processed +def _regions_to_processed_bed( + output_path: Path, + regions: str | Path | list[str | Path] | None, + window_size: int | None, +) -> Path | None: + """ + Build a normalized BED file from region inputs for downstream modkit calls. + """ + if regions is None: + return None + bed_filepath_processed = output_path / "regions.processed.bed" + regions_dict = utils.regions_dict_from_input( + regions, + window_size, + ) + utils.bed_from_regions_dict(regions_dict, bed_filepath_processed) + return bed_filepath_processed def read_by_base_txt_to_hdf5( diff --git a/tests/test_parse_bam.py b/tests/test_parse_bam.py index 1705296..f8423e4 100644 --- a/tests/test_parse_bam.py +++ b/tests/test_parse_bam.py @@ -1,4 +1,5 @@ import pytest +from pathlib import Path from dimelo import parse_bam @@ -85,3 +86,26 @@ def test_threads_command_list_uses_requested_cores_when_available(monkeypatch): command = parse_bam._threads_command_list(cores=6, quiet=True) assert command == ["--threads", "6"] + + +def test_create_region_command_list_returns_empty_without_regions(tmp_path): + command, bed_path = parse_bam.create_region_command_list( + output_path=tmp_path, + regions=None, + window_size=None, + ) + + assert command == [] + assert bed_path is None + + +def test_create_region_command_list_writes_processed_bed(tmp_path): + command, bed_path = parse_bam.create_region_command_list( + output_path=tmp_path, + regions="chr1:10-20", + window_size=None, + ) + + assert bed_path == Path(tmp_path) / "regions.processed.bed" + assert command == ["--include-bed", str(bed_path)] + assert bed_path.exists() From 7600c1aee3aa0978681966b949379b6236fdd375 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 17:37:32 -0700 Subject: [PATCH 251/272] feat: add optional parallel readwise extraction across reads --- dimelo/load_processed.py | 143 +++++++++++++++++++++++--------- tests/test_parse_bam_vectors.py | 36 ++++++++ 2 files changed, 140 insertions(+), 39 deletions(-) diff --git a/dimelo/load_processed.py b/dimelo/load_processed.py index 59ac02d..4414dd0 100644 --- a/dimelo/load_processed.py +++ b/dimelo/load_processed.py @@ -33,6 +33,61 @@ def _subset_indices( return np.sort(utils.random_sample(indices, **subset_parameters)) +def _readwise_mod_positions_for_read( + *, + read_int: int, + read_data: tuple, + mod_vector_index: int, + motif_index: int, + region_start_index: int, + region_end_index: int, + read_start_index: int, + region_strand_index: int, + thresh: float | None, + relative: bool, + regions_5to3prime: bool, +) -> tuple[list[int], list[int], list[str]]: + if thresh is None: + mod_pos_in_read = np.flatnonzero(read_data[mod_vector_index]) + else: + mod_pos_in_read = np.flatnonzero(read_data[mod_vector_index] > thresh) + + if relative: + if regions_5to3prime and read_data[region_strand_index] == "-": + # Here we want to show the regions each along their 5 prime to 3 prime direction + # This means that negative strand regions need to be flipped + mod_pos_record = -( + mod_pos_in_read + + read_data[read_start_index] + - (read_data[region_start_index] + read_data[region_end_index]) // 2 + ) + else: + # This is the default case: just make the coordinates relative using + # the reference genome coordinate system. Normal, easy, chill, nice. + mod_pos_record = ( + mod_pos_in_read + + read_data[read_start_index] + - (read_data[region_start_index] + read_data[region_end_index]) // 2 + ) + else: + # If we aren't using relative coordinates, then I think the 5prime to 3prime argument + # can just be ignored, and I think it's nicer if that's silent - less clutter in the output + # Basically if you are keeping different regions separate using other metadata (such as + # just keeping their actual real genomic coordinates) it is superfluous to do the 5to3 flip. + mod_pos_record = mod_pos_in_read + read_data[read_start_index] + + n_positions = len(mod_pos_record) + return ( + list(mod_pos_record), + [read_int] * n_positions, + [read_data[motif_index]] * n_positions, + ) + + +def _readwise_mod_positions_from_payload(payload: dict) -> tuple[list[int], list[int], list[str]]: + return _readwise_mod_positions_for_read(**payload) + + ################################################################################################################ #### Loader wrappers #### ################################################################################################################ @@ -1069,51 +1124,61 @@ def readwise_binary_modification_arrays( mod_coords_list = [] motifs_list = [] - read_iterator = zip(read_ints, sorted_read_data_converted) - if len(sorted_read_data_converted) > 0: + n_reads = len(sorted_read_data_converted) + cores_to_run = 1 if cores is None else max(1, min(cores, n_reads)) + + read_payloads = ( + { + "read_int": read_int, + "read_data": read_data, + "mod_vector_index": mod_vector_index, + "motif_index": motif_index, + "region_start_index": region_start_index, + "region_end_index": region_end_index, + "read_start_index": read_start_index, + "region_strand_index": region_strand_index, + "thresh": thresh, + "relative": relative, + "regions_5to3prime": regions_5to3prime, + } + for read_int, read_data in zip(read_ints, sorted_read_data_converted) + ) + + if cores_to_run > 1: + with concurrent.futures.ThreadPoolExecutor( + max_workers=cores_to_run + ) as executor: + read_iterator = executor.map( + _readwise_mod_positions_from_payload, + read_payloads, + ) + read_iterator = tqdm( + read_iterator, + total=n_reads, + disable=quiet, + desc="Extracting readwise modifications", + leave=False, + ) + for mod_pos_record, read_ids, motif_labels in read_iterator: + mod_coords_list += mod_pos_record + read_ids_by_mod_pos += read_ids + motifs_list += motif_labels + else: + read_iterator = map( + _readwise_mod_positions_from_payload, + read_payloads, + ) read_iterator = tqdm( read_iterator, - total=len(sorted_read_data_converted), + total=n_reads, disable=quiet, desc="Extracting readwise modifications", leave=False, ) - - for read_int, read_data in read_iterator: - if thresh is None: - mod_pos_in_read = np.flatnonzero(read_data[mod_vector_index]) - else: - mod_pos_in_read = np.flatnonzero(read_data[mod_vector_index] > thresh) - - if relative: - if regions_5to3prime and read_data[region_strand_index] == "-": - # Here we want to show the regions each along their 5 prime to 3 prime direction - # This means that negative strand regions need to be flipped - mod_pos_record = -( - mod_pos_in_read - + read_data[read_start_index] - - (read_data[region_start_index] + read_data[region_end_index]) - // 2 - ) - else: - # This is the default case: just make the coordinates relative using - # the reference genome coordinate system. Normal, easy, chill, nice. - mod_pos_record = ( - mod_pos_in_read - + read_data[read_start_index] - - (read_data[region_start_index] + read_data[region_end_index]) - // 2 - ) - else: - # If we aren't using relative coordinates, then I think the 5prime to 3prime argument - # can just be ignored, and I think it's nicer if that's silent - less clutter in the output - # Basically if you are keeping different regions separate using other metadata (such as - # just keeping their actual real genomic coordinates) it is superfluous to do the 5to3 flip. - mod_pos_record = mod_pos_in_read + read_data[read_start_index] - - mod_coords_list += list(mod_pos_record) - read_ids_by_mod_pos += [read_int] * len(mod_pos_record) - motifs_list += [read_data[motif_index]] * len(mod_pos_record) + for mod_pos_record, read_ids, motif_labels in read_iterator: + mod_coords_list += mod_pos_record + read_ids_by_mod_pos += read_ids + motifs_list += motif_labels return ( np.array(mod_coords_list), diff --git a/tests/test_parse_bam_vectors.py b/tests/test_parse_bam_vectors.py index 54b78db..1bd2e5b 100644 --- a/tests/test_parse_bam_vectors.py +++ b/tests/test_parse_bam_vectors.py @@ -503,3 +503,39 @@ def _fake_read_vectors_from_hdf5(**kwargs): assert read_ids.tolist() == [0] assert motifs.tolist() == ["A,0"] assert regions_dict == {"chr1": [(100, 110, ".")]} + + +def test_readwise_binary_modification_arrays_parallel_matches_serial(tmp_path): + input_txt = tmp_path / "extract.txt" + output_h5 = tmp_path / "reads_thresholded.h5" + _write_extract_file(input_txt) + + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=0.5, + quiet=True, + ) + + serial = load_processed.readwise_binary_modification_arrays( + file=output_h5, + motifs=["A,0"], + regions="chr1:95-220", + thresh=None, + quiet=True, + cores=1, + ) + parallel = load_processed.readwise_binary_modification_arrays( + file=output_h5, + motifs=["A,0"], + regions="chr1:95-220", + thresh=None, + quiet=True, + cores=2, + ) + + np.testing.assert_array_equal(serial[0], parallel[0]) + np.testing.assert_array_equal(serial[1], parallel[1]) + np.testing.assert_array_equal(serial[2], parallel[2]) + assert serial[3] == parallel[3] From 6495c155398554e004029ee47a1d7d2963358563 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 17:41:46 -0700 Subject: [PATCH 252/272] feat: parallelize loader region index selection via cores --- dimelo/load_processed.py | 78 +++++++++++++++++++++++++-------- tests/test_parse_bam_vectors.py | 46 +++++++++++++++++++ 2 files changed, 106 insertions(+), 18 deletions(-) diff --git a/dimelo/load_processed.py b/dimelo/load_processed.py index 4414dd0..ad46c79 100644 --- a/dimelo/load_processed.py +++ b/dimelo/load_processed.py @@ -33,6 +33,34 @@ def _subset_indices( return np.sort(utils.random_sample(indices, **subset_parameters)) +def _region_job_to_read_indices( + region_job: tuple[str, int, int, str], + *, + read_chromosomes: np.ndarray, + read_starts: np.ndarray, + read_ends: np.ndarray, + read_motifs: np.ndarray, + ref_strands: np.ndarray, + motifs: list[str], + single_strand: bool, + span_full_window: bool, +) -> np.ndarray: + chrom, region_start, region_end, region_strand = region_job + return np.flatnonzero( + (read_ends > region_start) + & (read_starts < region_end) + & (read_starts <= region_start if span_full_window else True) + & (read_ends >= region_end if span_full_window else True) + & np.isin(read_motifs, motifs) + & (read_chromosomes == chrom) + & ( + (not single_strand) + | (region_strand not in ["+", "-"]) + | (ref_strands == region_strand) + ) + ) + + def _readwise_mod_positions_for_read( *, read_int: int, @@ -744,7 +772,7 @@ def read_vectors_from_hdf5( include chromosome, region_start, region_end, read_start, read_end, and motif. More to be added in future. quiet: silences progress bars - cores: cores across which to parallelize processes (currently unused) + cores: if >1 and regions are provided, region index-selection work is parallelized subset_parameters: Parameters to pass to the utils.random_sample() method, to subset the reads to be returned. If not None, at least one of n or frac must be provided. The array parameter should not be provided here. @@ -808,32 +836,46 @@ def read_vectors_from_hdf5( for chrom, region_list in regions_dict.items() for region_start, region_end, region_strand in region_list ] + cores_to_run = ( + 1 + if cores is None + else max(1, min(cores, len(region_jobs))) + ) + region_to_indices = partial( + _region_job_to_read_indices, + read_chromosomes=read_chromosomes, + read_starts=read_starts, + read_ends=read_ends, + read_motifs=read_motifs, + ref_strands=ref_strands, + motifs=motifs, + single_strand=single_strand, + span_full_window=span_full_window, + ) + if cores_to_run > 1 and len(region_jobs) > 1: + with concurrent.futures.ThreadPoolExecutor( + max_workers=cores_to_run + ) as executor: + region_results = list(executor.map(region_to_indices, region_jobs)) + else: + region_results = [region_to_indices(job) for job in region_jobs] region_iterator = ( tqdm( - region_jobs, + zip(region_jobs, region_results), total=len(region_jobs), disable=quiet, desc="Loading read vectors", leave=False, ) if len(region_jobs) > 0 - else region_jobs + else [] ) - for chrom, region_start, region_end, region_strand in region_iterator: - # Find the read indices that we want to load - relevant_read_indices = np.flatnonzero( - (read_ends > region_start) - & (read_starts < region_end) - & (read_starts <= region_start if span_full_window else True) - & (read_ends >= region_end if span_full_window else True) - & np.isin(read_motifs, motifs) - & (read_chromosomes == chrom) - & ( - (not single_strand) - | (region_strand not in ["+", "-"]) - | (ref_strands == region_strand) - ) - ) + for ( + chrom, + region_start, + region_end, + region_strand, + ), relevant_read_indices in region_iterator: relevant_read_indices = _subset_indices( relevant_read_indices, subset_parameters=subset_parameters ) diff --git a/tests/test_parse_bam_vectors.py b/tests/test_parse_bam_vectors.py index 1bd2e5b..2e0746b 100644 --- a/tests/test_parse_bam_vectors.py +++ b/tests/test_parse_bam_vectors.py @@ -151,6 +151,17 @@ def _decode_vector(dataset, index: int) -> np.ndarray: return np.frombuffer(gzip.decompress(raw_bytes), dtype=np.uint8) +def _assert_read_tuples_equal(left: list[tuple], right: list[tuple]) -> None: + assert len(left) == len(right) + for left_tuple, right_tuple in zip(left, right, strict=True): + assert len(left_tuple) == len(right_tuple) + for left_value, right_value in zip(left_tuple, right_tuple, strict=True): + if isinstance(left_value, np.ndarray): + np.testing.assert_array_equal(left_value, right_value) + else: + assert left_value == right_value + + def test_read_by_base_txt_to_hdf5_uses_dense_span_vectors(tmp_path): input_txt = tmp_path / "extract.txt" output_h5 = tmp_path / "reads.h5" @@ -539,3 +550,38 @@ def test_readwise_binary_modification_arrays_parallel_matches_serial(tmp_path): np.testing.assert_array_equal(serial[1], parallel[1]) np.testing.assert_array_equal(serial[2], parallel[2]) assert serial[3] == parallel[3] + + +def test_read_vectors_from_hdf5_parallel_region_selection_matches_serial(tmp_path): + input_txt = tmp_path / "extract.txt" + output_h5 = tmp_path / "reads_thresholded.h5" + _write_extract_file(input_txt) + + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=0.5, + quiet=True, + ) + + serial = load_processed.read_vectors_from_hdf5( + file=output_h5, + motifs=["A,0"], + regions=["chr1:95-105", "chr1:100-110"], + quiet=True, + calculate_mod_fractions=False, + cores=1, + ) + parallel = load_processed.read_vectors_from_hdf5( + file=output_h5, + motifs=["A,0"], + regions=["chr1:95-105", "chr1:100-110"], + quiet=True, + calculate_mod_fractions=False, + cores=2, + ) + + _assert_read_tuples_equal(serial[0], parallel[0]) + assert serial[1] == parallel[1] + assert serial[2] == parallel[2] From 9e215394b612fdfdc8343b2ba310b22e6688ac48 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 17:43:16 -0700 Subject: [PATCH 253/272] refactor: consolidate parser hdf5 dataset and chunk writes --- dimelo/parse_bam.py | 158 +++++++++++++++----------------------------- 1 file changed, 55 insertions(+), 103 deletions(-) diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index 4dc53a7..cb7c530 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -812,7 +812,6 @@ def read_by_base_txt_to_hdf5( h5.create_dataset("threshold", data=threshold_to_store) ## Create read metadata datasets - # TODO: loop through dict instead? if "read_name" in h5: old_size = h5["read_name"].shape[0] h5["read_name"].resize((old_size + num_reads,)) @@ -826,106 +825,57 @@ def read_by_base_txt_to_hdf5( compression="gzip", compression_opts=9, ) - if "chromosome" in h5: - if old_size != h5["chromosome"].shape[0]: - print("size mismatch: read_name:chromosome") - else: - h5["chromosome"].resize((old_size + num_reads,)) - else: - h5.create_dataset( - "chromosome", - (num_reads,), - maxshape=(None,), - dtype=dt_str, - compression="gzip", - compression_opts=9, - ) - if "read_start" in h5: - if old_size != h5["read_start"].shape[0]: - print("size mismatch", "read_name", "read_start") - else: - h5["read_start"].resize((old_size + num_reads,)) - else: - h5.create_dataset( - "read_start", - (num_reads,), - maxshape=(None,), - dtype="i", - compression="gzip", - compression_opts=9, - ) - if "read_end" in h5: - if old_size != h5["read_end"].shape[0]: - print("size mismatch", "read_name", "read_end") - else: - h5["read_end"].resize((old_size + num_reads,)) - else: - h5.create_dataset( - "read_end", - (num_reads,), - maxshape=(None,), - dtype="i", - compression="gzip", - compression_opts=9, - ) - if "strand" in h5: - if old_size != h5["strand"].shape[0]: - print("size mismatch", "read_name", "strand") - else: - h5["strand"].resize((old_size + num_reads,)) - else: + def ensure_dataset_capacity( + *, + name: str, + dtype, + mismatch_message: str, + compression: str | None = None, + compression_opts: int | None = None, + ) -> None: + if name in h5: + if old_size != h5[name].shape[0]: + print(mismatch_message) + else: + h5[name].resize((old_size + num_reads,)) + return + + create_kwargs: dict[str, object] = { + "maxshape": (None,), + "dtype": dtype, + } + if compression is not None: + create_kwargs["compression"] = compression + if compression_opts is not None: + create_kwargs["compression_opts"] = compression_opts + h5.create_dataset( - "strand", + name, (num_reads,), - maxshape=(None,), - dtype=dt_str, - compression="gzip", - compression_opts=9, + **create_kwargs, ) - if "motif" in h5: - if old_size != h5["motif"].shape[0]: - print("size mismatch", "read_name", "motif") - else: - h5["motif"].resize((old_size + num_reads,)) - else: - h5.create_dataset( - "motif", - (num_reads,), - maxshape=(None,), - dtype=dt_str, + + for dataset_name, dataset_dtype, mismatch_message in [ + ("chromosome", dt_str, "size mismatch: read_name:chromosome"), + ("read_start", "i", "size mismatch read_name:read_start"), + ("read_end", "i", "size mismatch read_name:read_end"), + ("strand", dt_str, "size mismatch read_name:strand"), + ("motif", dt_str, "size mismatch read_name:motif"), + ]: + ensure_dataset_capacity( + name=dataset_name, + dtype=dataset_dtype, + mismatch_message=mismatch_message, compression="gzip", compression_opts=9, ) ## Create the vector datasets. These will contain raw bytes formatted into a uint8 array - # TODO: loop through dict instead - if "mod_vector" in h5: - if old_size != h5["mod_vector"].shape[0]: - print("size mismatch read_name:mod_vector") - else: - h5["mod_vector"].resize((old_size + num_reads,)) - else: - h5.create_dataset( - "mod_vector", - (num_reads,), - maxshape=(None,), - dtype=dt_vlen, - # compression='gzip', # we are handling compression ourselves because hdf5 is bad at it - # compression_opts=9, - ) - if "val_vector" in h5: - if old_size != h5["val_vector"].shape[0]: - print("size mismatch read_name:val_vector") - else: - h5["val_vector"].resize((old_size + num_reads,)) - else: - h5.create_dataset( - "val_vector", - (num_reads,), - maxshape=(None,), + for dataset_name in ["mod_vector", "val_vector"]: + ensure_dataset_capacity( + name=dataset_name, dtype=dt_vlen, - # compression='gzip', # we are handling compression ourselves because hdf5 is bad at it - # compression_opts=9, + mismatch_message=f"size mismatch read_name:{dataset_name}", ) ## Add data to datasets from txt file @@ -949,6 +899,17 @@ def read_by_base_txt_to_hdf5( # TODO: replace in loop with read_counter%chunk_size as appropriate reads_in_chunk = 0 + def flush_pending_chunk_to_h5() -> None: + nonlocal reads_in_chunk, chunk_datasets_contents + if reads_in_chunk <= 0: + return + start_index = old_size + read_counter - reads_in_chunk + end_index = old_size + read_counter + for dataset, entry in chunk_datasets_contents.items(): + h5[dataset][start_index:end_index] = entry + chunk_datasets_contents = defaultdict(list) + reads_in_chunk = 0 + def flush_current_read() -> None: nonlocal read_counter, reads_in_chunk, chunk_datasets_contents @@ -1003,12 +964,7 @@ def flush_current_read() -> None: read_counter += 1 reads_in_chunk += 1 if reads_in_chunk >= chunk_size: - start_index = old_size + read_counter - reads_in_chunk - end_index = old_size + read_counter - for dataset, entry in chunk_datasets_contents.items(): - h5[dataset][start_index:end_index] = entry - chunk_datasets_contents = defaultdict(list) - reads_in_chunk = 0 + flush_pending_chunk_to_h5() # Setting up progress bars if not in quiet mode # Skip header @@ -1080,11 +1036,7 @@ def flush_current_read() -> None: mod_values_list.append(0) flush_current_read() - if reads_in_chunk > 0: - start_index = old_size + read_counter - reads_in_chunk - end_index = old_size + read_counter - for dataset, entry in chunk_datasets_contents.items(): - h5[dataset][start_index:end_index] = entry + flush_pending_chunk_to_h5() return From 2f305fe97c3e629631b8107f6b5ddb474c1ee5c7 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 17:44:50 -0700 Subject: [PATCH 254/272] feat: add pileup loader aliases for clearer public api --- dimelo/load_processed.py | 56 ++++++++++++++++++- tests/test_load_processed_aliases.py | 81 ++++++++++++++++++++++++++++ 2 files changed, 135 insertions(+), 2 deletions(-) create mode 100644 tests/test_load_processed_aliases.py diff --git a/dimelo/load_processed.py b/dimelo/load_processed.py index ad46c79..5404a9a 100644 --- a/dimelo/load_processed.py +++ b/dimelo/load_processed.py @@ -242,7 +242,7 @@ def pileup_counts_from_bedmethyl( If no regions are specified, returns the sum total for the motif of interest across the entire bedmethyl file. - TODO: Consider renaming this method, e.g. counts_from_pileup + Preferred alias: `counts_from_pileup`. Args: bedmethyl_file: Path to bedmethyl file @@ -354,7 +354,7 @@ def pileup_vectors_from_bedmethyl( A region must be provided because otherwise there is no way to know what vector to return. However, a region can be a whole chromosome if desired. - TODO: Consider renaming this method, e.g. vectors_from_pileup + Preferred alias: `vectors_from_pileup`. Args: bedmethyl_file: Path to bedmethyl file @@ -443,6 +443,58 @@ def pileup_vectors_from_bedmethyl( return modified_base_counts, valid_base_counts +def counts_from_pileup( + bedmethyl_file: str | Path, + motif: str, + regions: str | Path | list[str | Path], + window_size: int | None = None, + single_strand: bool = False, + quiet: bool = False, + cores: int | None = None, + chunk_size: int = DEFAULT_CHUNK_SIZE, +) -> tuple[int, int]: + """ + Preferred alias for `pileup_counts_from_bedmethyl`. + """ + return pileup_counts_from_bedmethyl( + bedmethyl_file=bedmethyl_file, + motif=motif, + regions=regions, + window_size=window_size, + single_strand=single_strand, + quiet=quiet, + cores=cores, + chunk_size=chunk_size, + ) + + +def vectors_from_pileup( + bedmethyl_file: str | Path, + motif: str, + regions: str | Path | list[str | Path], + window_size: int | None = None, + single_strand: bool = False, + regions_5to3prime: bool = False, + quiet: bool = False, + cores: int | None = None, + chunk_size: int = DEFAULT_CHUNK_SIZE, +) -> tuple[np.ndarray, np.ndarray]: + """ + Preferred alias for `pileup_vectors_from_bedmethyl`. + """ + return pileup_vectors_from_bedmethyl( + bedmethyl_file=bedmethyl_file, + motif=motif, + regions=regions, + window_size=window_size, + single_strand=single_strand, + regions_5to3prime=regions_5to3prime, + quiet=quiet, + cores=cores, + chunk_size=chunk_size, + ) + + def counts_from_fake(*args, **kwargs) -> tuple[int, int]: """ Test helper function. diff --git a/tests/test_load_processed_aliases.py b/tests/test_load_processed_aliases.py new file mode 100644 index 0000000..1999bdb --- /dev/null +++ b/tests/test_load_processed_aliases.py @@ -0,0 +1,81 @@ +import numpy as np + +from dimelo import load_processed + + +def test_counts_from_pileup_alias_forwards_arguments(monkeypatch): + captured = {} + + def _fake_counts_from_bedmethyl(**kwargs): + captured.update(kwargs) + return (3, 9) + + monkeypatch.setattr( + load_processed, + "pileup_counts_from_bedmethyl", + _fake_counts_from_bedmethyl, + ) + + result = load_processed.counts_from_pileup( + bedmethyl_file="reads.bed.gz", + motif="A,0", + regions="chr1:10-20", + window_size=50, + single_strand=True, + quiet=True, + cores=2, + chunk_size=123, + ) + + assert result == (3, 9) + assert captured == { + "bedmethyl_file": "reads.bed.gz", + "motif": "A,0", + "regions": "chr1:10-20", + "window_size": 50, + "single_strand": True, + "quiet": True, + "cores": 2, + "chunk_size": 123, + } + + +def test_vectors_from_pileup_alias_forwards_arguments(monkeypatch): + captured = {} + expected = (np.array([1, 2, 3]), np.array([4, 5, 6])) + + def _fake_vectors_from_bedmethyl(**kwargs): + captured.update(kwargs) + return expected + + monkeypatch.setattr( + load_processed, + "pileup_vectors_from_bedmethyl", + _fake_vectors_from_bedmethyl, + ) + + result = load_processed.vectors_from_pileup( + bedmethyl_file="reads.bed.gz", + motif="CG,0", + regions="chr2:100-200", + window_size=25, + single_strand=False, + regions_5to3prime=True, + quiet=False, + cores=4, + chunk_size=999, + ) + + np.testing.assert_array_equal(result[0], expected[0]) + np.testing.assert_array_equal(result[1], expected[1]) + assert captured == { + "bedmethyl_file": "reads.bed.gz", + "motif": "CG,0", + "regions": "chr2:100-200", + "window_size": 25, + "single_strand": False, + "regions_5to3prime": True, + "quiet": False, + "cores": 4, + "chunk_size": 999, + } From 7a79aa59a0eddb0903df23215f9754c73847b8ce Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 17:48:12 -0700 Subject: [PATCH 255/272] refactor: make prep_output_directory default dir explicit --- dimelo/parse_bam.py | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index cb7c530..eebd328 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -168,7 +168,7 @@ def pileup( prep_output_directory( output_directory=output_directory, output_name=output_name, - input_file=input_file, + default_directory=input_file.parent, output_file_names=[ "pileup.bed", "pileup.sorted.bed", @@ -393,7 +393,7 @@ def extract( output_path, (output_reads_path,) = prep_output_directory( output_directory=output_directory, output_name=output_name, - input_file=input_file, + default_directory=input_file.parent, output_file_names=["reads.combined_basemods.h5"], ) @@ -1043,21 +1043,19 @@ def flush_current_read() -> None: def prep_output_directory( output_directory: Path | None, output_name: str, - input_file: Path, + default_directory: Path, output_file_names: list[str], ) -> tuple[Path, list[Path]]: """ As a side effect, if files exist that match the requested outputs, they are deleted. - TODO: Is it kind of silly that this takes in input_file? Maybe should take in some generic default parameter, or this default should be set outside this method? - Args: output_directory: Path pointing to an output directory. If left as None, outputs will be stored in a new folder within the input directory. output_name: a string that will be used to create an output folder containing the intermediate and final outputs, along with any logs. - input_file: Path to input file; used to define default output directory + default_directory: default output directory when output_directory is None output_file_names: list of names of desired output files Returns: @@ -1065,7 +1063,7 @@ def prep_output_directory( * List of Paths to requested output files """ if output_directory is None: - output_directory = input_file.parent + output_directory = default_directory print(f"No output directory provided, using input directory {output_directory}") output_path = output_directory / output_name From 5509edf64177076c62e49fdb481cbb17e51050d7 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 17:50:52 -0700 Subject: [PATCH 256/272] refactor: refresh loader parallelization docs and fake-read naming --- dimelo/load_processed.py | 48 +++++++++++++++++++--------------------- 1 file changed, 23 insertions(+), 25 deletions(-) diff --git a/dimelo/load_processed.py b/dimelo/load_processed.py index 5404a9a..b21acf8 100644 --- a/dimelo/load_processed.py +++ b/dimelo/load_processed.py @@ -774,7 +774,7 @@ def read_vectors_from_hdf5( sort_by: str | list[str] = ["chromosome", "region_start", "read_start"], calculate_mod_fractions: bool = True, quiet: bool = True, - cores: int | None = None, # currently unused + cores: int | None = None, subset_parameters: dict | None = None, span_full_window: bool = False, ) -> tuple[list[tuple], list[str], dict | None]: @@ -799,8 +799,6 @@ def read_vectors_from_hdf5( After this processing, we calculate modification fractions, sort, and return. - TODO: Implement parallelization as with pileup loaders - Args: file: Path to an hdf5 (.h5) file containing modification data for single reads, stored in datasets read_name, chromosome, read_start, @@ -824,7 +822,8 @@ def read_vectors_from_hdf5( include chromosome, region_start, region_end, read_start, read_end, and motif. More to be added in future. quiet: silences progress bars - cores: if >1 and regions are provided, region index-selection work is parallelized + cores: if >1 and regions are provided, parallelize per-region read-index + selection before h5 retrieval subset_parameters: Parameters to pass to the utils.random_sample() method, to subset the reads to be returned. If not None, at least one of n or frac must be provided. The array parameter should not be provided here. @@ -1098,7 +1097,7 @@ def readwise_binary_modification_arrays( thresh: float | None = None, relative: bool = True, quiet: bool = True, - cores: int | None = None, # currently unused + cores: int | None = None, subset_parameters: dict | None = None, ) -> tuple[list[np.ndarray], np.ndarray[int], np.ndarray[str], dict | None]: """ @@ -1115,8 +1114,6 @@ def readwise_binary_modification_arrays( coordinates. If positions are relative, regions_5to3prime can be used to show all regions as upstream-to-downstream along their respective strands. - TODO: Implement parallelization as with pileup loaders - Args: file: Path to an hdf5 (.h5) file containing modification data for single reads, stored in datasets read_name, chromosome, read_start, @@ -1146,7 +1143,8 @@ def readwise_binary_modification_arrays( There is not currently a check for all reads being on the same chromosome if relative=False, but this could create unexpected behaviour for a the standard visualizations. quiet: silences progress bars - cores: cores across which to parallelize processes (currently unused) + cores: cores across which per-read modification position extraction is + parallelized subset_parameters: Parameters to pass to the utils.random_sample() method, to subset the reads to be returned. If not None, at least one of n or frac must be provided. The array parameter should not be provided here. @@ -1298,25 +1296,25 @@ def reads_from_fake( """ Helper function to support testing. - TODO: What does the bed file represent in this method? This one is breaking my brain a bit. - TODO: Variable names in this method stink. - TODO: Currently assumes mod calling (thresholding probabilities) was already performed elsewhere - Args: file: Path to file containing modification data for single reads - bed_file: Path to bed file specifying regions (WHAT DO THESE REPRESENT???) - mod_names: types of modification to extract data for + regions: Placeholder for a regions input, kept for signature compatibility with + non-stub loaders. It is intentionally unused by this synthetic data helper. + motifs: types of modification to extract data for Returns: - Returns three parallel arrays, of length (N_READS * len(mod_names)), containing the following for each index: + Returns three parallel arrays, of length (N_READS * len(motifs)), containing the following for each index: * array of positions at which the specified modification was found in a read * unique integer ID for the read * modification represented by the positions - For example, if called on a dataset with a single read and two modification types, each array would have two entries. The unique IDs would be the same, as both entries would represent the same single read. The mods and positions would be different, as they would extact different mods. + For example, if called on a dataset with a single read and two modification + types, each array would have two entries. The unique IDs would be the same, + as both entries would represent the same single read. The mods and positions + would be different, as they would extract different mods. """ - reads = [] - read_names = [] - mods = [] + read_positions = [] + read_ids_by_mod = [] + motif_labels = [] for mod_name in motifs: match mod_name: case "A,0": @@ -1333,13 +1331,13 @@ def reads_from_fake( ] case _: raise ValueError(f"No stub settings for requested mod {mod_name}") - reads += mod_reads - read_names.append(np.arange(len(mod_reads))) - mods.append([mod_name] * len(mod_reads)) + read_positions += mod_reads + read_ids_by_mod.append(np.arange(len(mod_reads))) + motif_labels.append([mod_name] * len(mod_reads)) - read_names = np.concatenate(read_names) - mods = np.concatenate(mods) - return reads, read_names, mods, {} + read_ids_by_mod = np.concatenate(read_ids_by_mod) + motif_labels = np.concatenate(motif_labels) + return read_positions, read_ids_by_mod, motif_labels, {} # def convert_bytes(item): From dbda12b519367d90243eddf60fa5a95e49c8eecb Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 17:53:05 -0700 Subject: [PATCH 257/272] refactor: clean stale parse_bam todo debt and path cleanup --- dimelo/parse_bam.py | 29 ++++++++++------------------- 1 file changed, 10 insertions(+), 19 deletions(-) diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index eebd328..5e58d4f 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -1,7 +1,6 @@ import gzip import itertools import multiprocessing -import os import subprocess from collections import defaultdict from pathlib import Path @@ -55,6 +54,11 @@ def _compress_uint8_vector( ) +def _unlink_existing(*paths: Path) -> None: + for path in paths: + path.unlink(missing_ok=True) + + """ User-facing parse operations: pileup and extract """ @@ -180,7 +184,6 @@ def pileup( ## Build up the command list to be sent to modkit, then run modkit - # TODO: This is mildly confusing. I get what it's doing, but it's hard to follow / names are bad. Also, why is it used in cleanup here, but not in extract? region_command_list, processed_regions_path = create_region_command_list( output_path, regions, @@ -216,7 +219,6 @@ def pileup( cores_command_list = _threads_command_list(cores=cores, quiet=quiet) - # TODO: This is SO SO SO similar to extract; just the ValueError vs. printing. I think this can be resolved mod_thresh_command_list: list[str] = [] if thresh is None: if not quiet: @@ -251,8 +253,7 @@ def pileup( + log_command_list ) - # TODO: Do we need to store and use the output from this method? Previously was being printed immediately afterward. - _ = run_modkit.run_with_progress_bars( + run_modkit.run_with_progress_bars( command_list=pileup_command_list, input_file=input_file, ref_genome=ref_genome, @@ -268,7 +269,6 @@ def pileup( expect_done=True, quiet=quiet, ) - # print(done_string) ## Sort, compress, and index the output bedmethyl file @@ -279,12 +279,8 @@ def pileup( pysam.tabix_compress(output_bedmethyl_sorted, output_pileup_path, force=True) pysam.tabix_index(str(output_pileup_path), preset="bed", force=True) - # TODO: Can cleanup be consolidated? if cleanup: - if output_bedmethyl.exists(): - output_bedmethyl.unlink() - if output_bedmethyl_sorted.exists(): - output_bedmethyl_sorted.unlink() + _unlink_existing(output_bedmethyl, output_bedmethyl_sorted) return output_pileup_path, processed_regions_path @@ -389,7 +385,6 @@ def extract( f'{e}\nIf you are confident that your inputs are ok, pass "override_checks=True" to convert to warning and proceed with processing.' ) from e - # TODO: Add intermediate mod-specific .txt files? output_path, (output_reads_path,) = prep_output_directory( output_directory=output_directory, output_name=output_name, @@ -450,8 +445,7 @@ def extract( output_txt = Path(output_path) / (f"reads.{motif}.txt") - if os.path.exists(output_txt): - os.remove(output_txt) + output_txt.unlink(missing_ok=True) extract_command_list = ( ["modkit", "extract", input_file, output_txt] @@ -463,9 +457,7 @@ def extract( + filter_command_list ) - # TODO: Do we need to store and use the output from this method? Previously was being printed immediately afterward. - # This is something the user might want to see - it's the end-of-process message for modkit, says e.g. how many reads were processed and stuff - _ = run_modkit.run_with_progress_bars( + run_modkit.run_with_progress_bars( command_list=extract_command_list, input_file=input_file, ref_genome=ref_genome, @@ -481,7 +473,6 @@ def extract( expect_done=False, quiet=quiet, ) - # print(done_string) # Create the compressed and indexed output read_by_base_txt_to_hdf5( @@ -493,7 +484,7 @@ def extract( ) # Delete intermediate file if cleanup: - os.remove(output_txt) + output_txt.unlink() return output_reads_path, processed_regions_path From 7b8b284c81bf03c222751def89dd92791223481e Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 18:13:08 -0700 Subject: [PATCH 258/272] refactor: use csv parsing and clarify chunk flow in read_by_base --- dimelo/parse_bam.py | 62 +++++++++++++++++++++------------------------ 1 file changed, 29 insertions(+), 33 deletions(-) diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index 5e58d4f..f23a49d 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -1,3 +1,4 @@ +import csv import gzip import itertools import multiprocessing @@ -765,13 +766,11 @@ def read_by_base_txt_to_hdf5( read_name = "" num_reads = 0 - # TODO: I think the function calls can be consolidated; lots of repetition - # TODO: Consider opening both files at once - with input_txt.open() as txt: + with input_txt.open(newline="") as txt: + reader = csv.reader(txt, delimiter="\t") # Check file length line_index = -1 - for line_index, line in enumerate(txt): - fields = line.rstrip("\n").split("\t") + for line_index, fields in enumerate(reader): if line_index > 0 and read_name != fields[0]: read_name = fields[0] num_reads += 1 @@ -871,8 +870,7 @@ def ensure_dataset_capacity( ## Add data to datasets from txt file # Initialize loop vars - these will go into datasets - # TODO: initialize read name to actual first read so we can get rid of the logic in the loop - read_name = "" + read_name: str | None = None read_chrom = "" ref_strand = "" read_start = 0 @@ -884,27 +882,26 @@ def ensure_dataset_capacity( read_counter = 0 # Keys (strings): dataset names, values: lists of dataset values by read; string or ints or arrays # Contents reset at the end of each chunk, after writing to h5 - chunk_datasets_contents: defaultdict[str, list[str | int | np.ndarray]] = ( + chunk_rows: defaultdict[str, list[str | int | np.ndarray]] = ( defaultdict(list) ) - # TODO: replace in loop with read_counter%chunk_size as appropriate - reads_in_chunk = 0 + chunk_row_count = 0 def flush_pending_chunk_to_h5() -> None: - nonlocal reads_in_chunk, chunk_datasets_contents - if reads_in_chunk <= 0: + nonlocal chunk_row_count, chunk_rows + if chunk_row_count <= 0: return - start_index = old_size + read_counter - reads_in_chunk + start_index = old_size + read_counter - chunk_row_count end_index = old_size + read_counter - for dataset, entry in chunk_datasets_contents.items(): + for dataset, entry in chunk_rows.items(): h5[dataset][start_index:end_index] = entry - chunk_datasets_contents = defaultdict(list) - reads_in_chunk = 0 + chunk_rows = defaultdict(list) + chunk_row_count = 0 def flush_current_read() -> None: - nonlocal read_counter, reads_in_chunk, chunk_datasets_contents + nonlocal read_counter, chunk_row_count, chunk_rows - if len(read_name) == 0: + if read_name is None: return read_len_along_ref = max(read_end - read_start, 1) @@ -943,24 +940,25 @@ def flush_current_read() -> None: valid_vector, compress_level=compress_level ) - chunk_datasets_contents["read_name"].append(read_name) - chunk_datasets_contents["chromosome"].append(read_chrom) - chunk_datasets_contents["read_start"].append(read_start) - chunk_datasets_contents["read_end"].append(read_end) - chunk_datasets_contents["strand"].append(ref_strand) - chunk_datasets_contents["motif"].append(motif) - chunk_datasets_contents["mod_vector"].append(mod_vector_compressed) - chunk_datasets_contents["val_vector"].append(valid_vector_compressed) + chunk_rows["read_name"].append(read_name) + chunk_rows["chromosome"].append(read_chrom) + chunk_rows["read_start"].append(read_start) + chunk_rows["read_end"].append(read_end) + chunk_rows["strand"].append(ref_strand) + chunk_rows["motif"].append(motif) + chunk_rows["mod_vector"].append(mod_vector_compressed) + chunk_rows["val_vector"].append(valid_vector_compressed) read_counter += 1 - reads_in_chunk += 1 - if reads_in_chunk >= chunk_size: + chunk_row_count += 1 + if chunk_row_count >= chunk_size: flush_pending_chunk_to_h5() # Setting up progress bars if not in quiet mode # Skip header - iterator = enumerate(txt) - next(iterator) + reader = csv.reader(txt, delimiter="\t") + next(reader) + iterator = reader if not quiet: iterator = tqdm( iterator, @@ -970,9 +968,7 @@ def flush_current_read() -> None: ) # Loop through txt file - for _, line in iterator: - # TODO: use csv module - fields = line.rstrip("\n").split("\t") + for fields in iterator: pos_in_genome = int(fields[2]) canonical_base = fields[15] prob = float(fields[10]) From 7ec18f9c027bf1e9cad908d4a0d5a49f4c1fea65 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 18:16:02 -0700 Subject: [PATCH 259/272] fix: validate extract coordinate conversion bounds --- dimelo/parse_bam.py | 36 ++++++++++++++++++++++++--------- tests/test_parse_bam_vectors.py | 30 +++++++++++++++++++++++++++ 2 files changed, 57 insertions(+), 9 deletions(-) diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index f23a49d..5dd391b 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -60,6 +60,28 @@ def _unlink_existing(*paths: Path) -> None: path.unlink(missing_ok=True) +def _reference_oriented_read_offset( + *, + pos_in_read: int, + read_length: int, + ref_strand: str, +) -> int: + """ + Convert modkit's read-oriented position into a left-to-right reference offset. + """ + if read_length <= 0: + raise ValueError(f"read length must be positive; got {read_length}.") + if pos_in_read < 0 or pos_in_read >= read_length: + raise ValueError( + f"pos_in_read {pos_in_read} is out of bounds for read length {read_length}." + ) + if ref_strand == "+": + return pos_in_read + if ref_strand == "-": + return read_length - pos_in_read - 1 + raise ValueError(f"Unexpected strand '{ref_strand}' in modkit extract row.") + + """ User-facing parse operations: pileup and extract """ @@ -976,15 +998,11 @@ def flush_current_read() -> None: pos_in_read = int(fields[1]) line_read_len = int(fields[9]) line_ref_strand = fields[5] - # TODO: verify that read position is in the right (ref) coordinate system - if line_ref_strand == "+": - pos_in_read_ref = pos_in_read - elif line_ref_strand == "-": - pos_in_read_ref = line_read_len - pos_in_read - 1 - else: - raise ValueError( - f"Unexpected strand '{line_ref_strand}' in modkit extract row." - ) + pos_in_read_ref = _reference_oriented_read_offset( + pos_in_read=pos_in_read, + read_length=line_read_len, + ref_strand=line_ref_strand, + ) start_candidate = pos_in_genome - pos_in_read_ref end_candidate = start_candidate + line_read_len diff --git a/tests/test_parse_bam_vectors.py b/tests/test_parse_bam_vectors.py index 2e0746b..2cef2f0 100644 --- a/tests/test_parse_bam_vectors.py +++ b/tests/test_parse_bam_vectors.py @@ -333,6 +333,36 @@ def test_read_by_base_txt_to_hdf5_reconstructs_coordinates_robustly(tmp_path): ) +def test_read_by_base_txt_to_hdf5_rejects_out_of_bounds_pos_in_read(tmp_path): + input_txt = tmp_path / "extract.bad_position.txt" + output_h5 = tmp_path / "reads.bad_position.h5" + header = "\t".join(f"col{i}" for i in range(16)) + lines = [ + header, + _make_extract_line( + "read_bad", + pos_in_read=10, + pos_in_genome=110, + chromosome="chr2", + strand="+", + read_len=10, + prob=0.80, + mod_code="a", + canonical_base="A", + ), + ] + input_txt.write_text("\n".join(lines) + "\n") + + with pytest.raises(ValueError, match="out of bounds for read length"): + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=0.5, + quiet=True, + ) + + def test_readwise_binary_modification_arrays_returns_empty_for_empty_region(tmp_path): input_txt = tmp_path / "extract.txt" output_h5 = tmp_path / "reads_thresholded.h5" From 5223158f3a458c1439f2e5e2810cbb438eb9c937 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 18:22:23 -0700 Subject: [PATCH 260/272] refactor: clarify loader subset and h5 tuple assembly --- dimelo/load_processed.py | 231 ++++++++++++++++++++++++--------------- 1 file changed, 143 insertions(+), 88 deletions(-) diff --git a/dimelo/load_processed.py b/dimelo/load_processed.py index b21acf8..5504748 100644 --- a/dimelo/load_processed.py +++ b/dimelo/load_processed.py @@ -116,6 +116,97 @@ def _readwise_mod_positions_from_payload(payload: dict) -> tuple[list[int], list return _readwise_mod_positions_for_read(**payload) +def _validate_subset_parameters(subset_parameters: dict | None) -> None: + if subset_parameters is None: + return + if not isinstance(subset_parameters, dict): + raise ValueError("subset_parameters must be provided as a dictionary.") + if "array" in subset_parameters: + raise ValueError( + "subset_parameters cannot include 'array'; it is provided internally." + ) + if "n" not in subset_parameters and "frac" not in subset_parameters: + raise ValueError( + "subset_parameters must include at least one of 'n' or 'frac'." + ) + + +def _load_read_tuples_for_indices( + *, + h5: h5py.File, + readwise_datasets: list[str], + compressed_binary_datasets: list[str], + binarized: bool, + relevant_read_indices: np.ndarray, + region_start: int, + region_end: int, + region_strand: str, +) -> list[tuple]: + n_reads = len(relevant_read_indices) + return list( + zip( + *( + retrieve_h5_data( + h5=h5, + dataset=dataset, + indices=relevant_read_indices, + compressed=dataset in compressed_binary_datasets, + dtype=np.uint8, + decompressor=gzip.decompress, + binarized=binarized, + ) + for dataset in readwise_datasets + ), + [region_start] * n_reads, + [region_end] * n_reads, + [region_strand] * n_reads, + ) + ) + + +def _normalize_sort_by( + sort_by: str | tuple[str, str] | list[str | tuple[str, str]], +) -> list[tuple[str, str]]: + if not isinstance(sort_by, list): + sort_by = [sort_by] + + sort_by_normalized: list[tuple[str, str]] = [] + for item in sort_by: + if isinstance(item, tuple): + field, order = item + if order not in ["asc", "desc"]: + raise ValueError( + f"Sort order must be 'asc' or 'desc', got '{order}' for field '{field}'" + ) + sort_by_normalized.append((field, order)) + else: + sort_by_normalized.append((item, "asc")) + return sort_by_normalized + + +def _assign_region_scoped_read_ints( + *, + read_data: list[tuple], + read_name_index: int, + region_start_index: int, + region_end_index: int, + region_strand_index: int, +) -> np.ndarray: + read_identity_to_int: dict[tuple, int] = {} + read_ints: list[int] = [] + for row in read_data: + read_identity = ( + row[read_name_index], + row[region_start_index], + row[region_end_index], + row[region_strand_index], + ) + if read_identity not in read_identity_to_int: + read_identity_to_int[read_identity] = len(read_identity_to_int) + read_ints.append(read_identity_to_int[read_identity]) + return np.array(read_ints) + + ################################################################################################################ #### Loader wrappers #### ################################################################################################################ @@ -771,7 +862,11 @@ def read_vectors_from_hdf5( regions: str | Path | list[str | Path] | None = None, window_size: int | None = None, single_strand: bool = False, - sort_by: str | list[str] = ["chromosome", "region_start", "read_start"], + sort_by: str | tuple[str, str] | list[str | tuple[str, str]] = [ + "chromosome", + "region_start", + "read_start", + ], calculate_mod_fractions: bool = True, quiet: bool = True, cores: int | None = None, @@ -836,17 +931,7 @@ def read_vectors_from_hdf5( a regions_dict, containing lists of (region_start,region_end) coordinates by chromosome/contig. """ - if subset_parameters is not None: - if not isinstance(subset_parameters, dict): - raise ValueError("subset_parameters must be provided as a dictionary.") - if "array" in subset_parameters: - raise ValueError( - "subset_parameters cannot include 'array'; it is provided internally." - ) - if "n" not in subset_parameters and "frac" not in subset_parameters: - raise ValueError( - "subset_parameters must include at least one of 'n' or 'frac'." - ) + _validate_subset_parameters(subset_parameters) with h5py.File(file, "r") as h5: datasets: list[str] = [ @@ -930,24 +1015,15 @@ def read_vectors_from_hdf5( relevant_read_indices = _subset_indices( relevant_read_indices, subset_parameters=subset_parameters ) - read_tuples_raw += list( - zip( - *( - retrieve_h5_data( - h5=h5, - dataset=dataset, - indices=relevant_read_indices, - compressed=dataset in compressed_binary_datasets, - dtype=np.uint8, - decompressor=gzip.decompress, - binarized=binarized, - ) - for dataset in readwise_datasets - ), - [region_start for _ in relevant_read_indices], - [region_end for _ in relevant_read_indices], - [region_strand for _ in relevant_read_indices], - ) + read_tuples_raw += _load_read_tuples_for_indices( + h5=h5, + readwise_datasets=readwise_datasets, + compressed_binary_datasets=compressed_binary_datasets, + binarized=binarized, + relevant_read_indices=relevant_read_indices, + region_start=region_start, + region_end=region_end, + region_strand=region_strand, ) else: regions_dict = None @@ -955,24 +1031,15 @@ def read_vectors_from_hdf5( relevant_read_indices = _subset_indices( relevant_read_indices, subset_parameters=subset_parameters ) - read_tuples_raw = list( - zip( - *( - retrieve_h5_data( - h5=h5, - dataset=dataset, - indices=relevant_read_indices, - compressed=dataset in compressed_binary_datasets, - dtype=np.uint8, - decompressor=gzip.decompress, - binarized=binarized, - ) - for dataset in readwise_datasets - ), - [-1 for _ in relevant_read_indices], - [-1 for _ in relevant_read_indices], - ["." for _ in relevant_read_indices], - ) + read_tuples_raw = _load_read_tuples_for_indices( + h5=h5, + readwise_datasets=readwise_datasets, + compressed_binary_datasets=compressed_binary_datasets, + binarized=binarized, + relevant_read_indices=relevant_read_indices, + region_start=-1, + region_end=-1, + region_strand=".", ) # We add region information (start, end, and strand; chromosome is already present!) # so that it is possible to sort by and process based on these @@ -984,11 +1051,13 @@ def read_vectors_from_hdf5( convert_bytes_to_strings(tup) for tup in read_tuples_raw ] else: + mod_vector_index = readwise_datasets.index("mod_vector") + val_vector_index = readwise_datasets.index("val_vector") read_tuples_processed = [ adjust_mod_probs_in_tuples( convert_bytes_to_strings(tup), - readwise_datasets.index("mod_vector"), - readwise_datasets.index("val_vector"), + mod_vector_index, + val_vector_index, ) for tup in read_tuples_raw ] @@ -1003,15 +1072,19 @@ def read_vectors_from_hdf5( mod_fractions_by_read_name_by_motif: defaultdict[ str, defaultdict[str, float] ] = defaultdict(lambda: defaultdict(lambda: 0.0)) + motif_index = readwise_datasets.index("motif") + mod_vector_index = readwise_datasets.index("mod_vector") + val_vector_index = readwise_datasets.index("val_vector") + read_name_index = readwise_datasets.index("read_name") for motif in motifs: for read_tuple in read_tuples_processed: - if read_tuple[readwise_datasets.index("motif")] == motif: - mod_sum = np.sum(read_tuple[readwise_datasets.index("mod_vector")]) - val_sum = np.sum(read_tuple[readwise_datasets.index("val_vector")]) + if read_tuple[motif_index] == motif: + mod_sum = np.sum(read_tuple[mod_vector_index]) + val_sum = np.sum(read_tuple[val_vector_index]) mod_fraction = mod_sum / val_sum if val_sum > 0 else 0 - mod_fractions_by_read_name_by_motif[ - read_tuple[readwise_datasets.index("read_name")] - ][motif] = mod_fraction + mod_fractions_by_read_name_by_motif[read_tuple[read_name_index]][ + motif + ] = mod_fraction read_tuples_all = [] for read_tuple in read_tuples_processed: @@ -1022,7 +1095,7 @@ def read_vectors_from_hdf5( + tuple( mod_frac for mod_frac in mod_fractions_by_read_name_by_motif[ - read_tuple[readwise_datasets.index("read_name")] + read_tuple[read_name_index] ].values() ) ) @@ -1039,23 +1112,7 @@ def read_vectors_from_hdf5( # - "field" or ["field1", "field2"] -> [("field1", "asc"), ("field2", "asc")] # - [("field1", "desc"), "field2"] -> [("field1", "desc"), ("field2", "asc")] - # Enforce that sort_by is a list - if not isinstance(sort_by, list): - sort_by = [sort_by] - - # Parse into (field, order) tuples - sort_by_normalized = [] - for item in sort_by: - if isinstance(item, tuple): - field, order = item - if order not in ["asc", "desc"]: - raise ValueError( - f"Sort order must be 'asc' or 'desc', got '{order}' for field '{field}'" - ) - sort_by_normalized.append((field, order)) - else: - # Default to ascending order - sort_by_normalized.append((item, "asc")) + sort_by_normalized = _normalize_sort_by(sort_by) # If 'shuffle' appears anywhere in sort_by, we first shuffle the list if any(field == "shuffle" for field, _ in sort_by_normalized): @@ -1093,7 +1150,11 @@ def readwise_binary_modification_arrays( window_size: int | None = None, regions_5to3prime: bool = False, single_strand: bool = False, - sort_by: str | list[str] = ["chromosome", "region_start", "read_start"], + sort_by: str | tuple[str, str] | list[str | tuple[str, str]] = [ + "chromosome", + "region_start", + "read_start", + ], thresh: float | None = None, relative: bool = True, quiet: bool = True, @@ -1198,19 +1259,13 @@ def readwise_binary_modification_arrays( else: thresh = utils.adjust_threshold(thresh) - read_identity_to_int: dict[tuple, int] = {} - read_ints_list = [] - for read_data in sorted_read_data_converted: - read_identity = ( - read_data[read_name_index], - read_data[region_start_index], - read_data[region_end_index], - read_data[region_strand_index], - ) - if read_identity not in read_identity_to_int: - read_identity_to_int[read_identity] = len(read_identity_to_int) - read_ints_list.append(read_identity_to_int[read_identity]) - read_ints = np.array(read_ints_list) + read_ints = _assign_region_scoped_read_ints( + read_data=sorted_read_data_converted, + read_name_index=read_name_index, + region_start_index=region_start_index, + region_end_index=region_end_index, + region_strand_index=region_strand_index, + ) read_ids_by_mod_pos: list[int] = [] mod_coords_list = [] From bc874ae18bc3e8771e2b0a57316ceda6dca7631f Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 18:26:40 -0700 Subject: [PATCH 261/272] refactor: clean plotting todo debt and typing reassignments --- dimelo/plot_depth_histogram.py | 24 ++++++++--------- dimelo/plot_depth_profile.py | 22 +++++++++------- dimelo/plot_enrichment.py | 35 +++++++++---------------- dimelo/plot_enrichment_profile.py | 43 +++++++++---------------------- dimelo/plot_reads.py | 33 ++++-------------------- 5 files changed, 53 insertions(+), 104 deletions(-) diff --git a/dimelo/plot_depth_histogram.py b/dimelo/plot_depth_histogram.py index 95b1f09..9bc4b7a 100644 --- a/dimelo/plot_depth_histogram.py +++ b/dimelo/plot_depth_histogram.py @@ -108,14 +108,15 @@ def by_regions( See plot_depth_histogram for details. """ - if sample_names is None: - sample_names = regions_list + sample_names_for_plot = ( + sample_names if sample_names is not None else [str(region) for region in regions_list] + ) n_beds = len(regions_list) return plot_depth_histogram( mod_file_names=[mod_file_name] * n_beds, regions_list=regions_list, motifs=[motif] * n_beds, - sample_names=[f"{sample_name} depth" for sample_name in sample_names], + sample_names=[f"{sample_name} depth" for sample_name in sample_names_for_plot], **kwargs, ) @@ -134,14 +135,17 @@ def by_dataset( See plot_depth_histogram for details. """ - if sample_names is None: - sample_names = mod_file_names + sample_names_for_plot = ( + sample_names + if sample_names is not None + else [str(mod_file) for mod_file in mod_file_names] + ) n_mod_files = len(mod_file_names) return plot_depth_histogram( mod_file_names=mod_file_names, regions_list=[regions] * n_mod_files, motifs=[motif] * n_mod_files, - sample_names=[f"{sample_name} depth" for sample_name in sample_names], + sample_names=[f"{sample_name} depth" for sample_name in sample_names_for_plot], **kwargs, ) @@ -171,8 +175,6 @@ def get_depth_counts( the region of interest, False means we always grab both strands within the regions one_depth_per_region: if True, each region will only report a single depth value, averaging across all non-zero depths. If False depths will be reported separately for all nonzero count positions in each region for a more granular view of depth distribution. - regions_5to3prime: True means negative strand regions get flipped, False means no flipping - smooth_window: size of the moving window to use for smoothing. If set to None, no smoothing is performed quiet: disables progress bars cores: CPU cores across which to parallelize processing @@ -181,12 +183,10 @@ def get_depth_counts( """ if not utils.check_len_equal(mod_file_names, regions_list, motifs): raise ValueError("Unequal number of inputs") - # TODO: redefinition error; still need to figure out how to do this elegantly in a way mypy likes - # dimelo/plot_depth_histogram.py:53: error: Item "str" of "str | Path" has no attribute "suffix" [union-attr] - mod_file_names = [Path(fn) for fn in mod_file_names] + mod_file_paths = [Path(fn) for fn in mod_file_names] depth_vectors = [] - for mod_file, regions, motif in zip(mod_file_names, regions_list, motifs): + for mod_file, regions, motif in zip(mod_file_paths, regions_list, motifs): match mod_file.suffix: case ".gz": pileup_vectors_list = load_processed.regions_to_list( diff --git a/dimelo/plot_depth_profile.py b/dimelo/plot_depth_profile.py index f13962f..35570be 100644 --- a/dimelo/plot_depth_profile.py +++ b/dimelo/plot_depth_profile.py @@ -101,14 +101,15 @@ def by_regions( See plot_depth_profile for details. """ - if sample_names is None: - sample_names = regions_list + sample_names_for_plot = ( + sample_names if sample_names is not None else [str(region) for region in regions_list] + ) n_beds = len(regions_list) return plot_depth_profile( mod_file_names=[mod_file_name] * n_beds, regions_list=regions_list, motifs=[motif] * n_beds, - sample_names=[f"{sample_name} depth" for sample_name in sample_names], + sample_names=[f"{sample_name} depth" for sample_name in sample_names_for_plot], **kwargs, ) @@ -127,14 +128,17 @@ def by_dataset( See plot_depth_profile for details. """ - if sample_names is None: - sample_names = mod_file_names + sample_names_for_plot = ( + sample_names + if sample_names is not None + else [str(mod_file) for mod_file in mod_file_names] + ) n_mod_files = len(mod_file_names) return plot_depth_profile( mod_file_names=mod_file_names, regions_list=[regions] * n_mod_files, motifs=[motif] * n_mod_files, - sample_names=[f"{sample_name} depth" for sample_name in sample_names], + sample_names=[f"{sample_name} depth" for sample_name in sample_names_for_plot], **kwargs, ) @@ -173,12 +177,10 @@ def get_depth_profiles( """ if not utils.check_len_equal(mod_file_names, regions_list, motifs): raise ValueError("Unequal number of inputs") - # TODO: redefinition error; still need to figure out how to do this elegantly in a way mypy likes - # dimelo/plot_depth_profile.py:53: error: Item "str" of "str | Path" has no attribute "suffix" [union-attr] - mod_file_names = [Path(fn) for fn in mod_file_names] + mod_file_paths = [Path(fn) for fn in mod_file_names] trace_vectors = [] - for mod_file, regions, motif in zip(mod_file_names, regions_list, motifs): + for mod_file, regions, motif in zip(mod_file_paths, regions_list, motifs): match mod_file.suffix: case ".gz": _, valid_base_counts = load_processed.pileup_vectors_from_bedmethyl( diff --git a/dimelo/plot_enrichment.py b/dimelo/plot_enrichment.py index d747b91..4f114e2 100644 --- a/dimelo/plot_enrichment.py +++ b/dimelo/plot_enrichment.py @@ -81,16 +81,6 @@ def by_modification( **kwargs, ) - -""" -TODO: Re-assignment issue: -dimelo/plot_enrichment.py:115: error: Incompatible types in assignment (expression has type "list[str | Path | list[str | Path]]", variable has type "list[str] | None") [assignment] -dimelo/plot_enrichment.py:121: error: Argument "sample_names" to "plot_enrichment" has incompatible type "list[str] | None"; expected "list[str]" [arg-type] -dimelo/plot_enrichment.py:141: error: Incompatible types in assignment (expression has type "list[str | Path]", variable has type "list[str] | None") [assignment] -dimelo/plot_enrichment.py:147: error: Argument "sample_names" to "plot_enrichment" has incompatible type "list[str] | None"; expected "list[str]" [arg-type] -""" - - def by_regions( mod_file_name: str | Path, regions_list: list[str | Path | list[str | Path]], @@ -105,14 +95,15 @@ def by_regions( See plot_enrichment for details. """ - if sample_names is None: - sample_names = regions_list + sample_names_for_plot = ( + sample_names if sample_names is not None else [str(region) for region in regions_list] + ) n_beds = len(regions_list) return plot_enrichment( mod_file_names=[mod_file_name] * n_beds, regions_list=regions_list, motifs=[motif] * n_beds, - sample_names=sample_names, + sample_names=sample_names_for_plot, **kwargs, ) @@ -131,14 +122,17 @@ def by_dataset( See plot_enrichment for details. """ - if sample_names is None: - sample_names = mod_file_names + sample_names_for_plot = ( + sample_names + if sample_names is not None + else [str(mod_file) for mod_file in mod_file_names] + ) n_mod_files = len(mod_file_names) return plot_enrichment( mod_file_names=mod_file_names, regions_list=[regions] * n_mod_files, motifs=[motif] * n_mod_files, - sample_names=sample_names, + sample_names=sample_names_for_plot, **kwargs, ) @@ -158,9 +152,6 @@ def get_enrichments( This helper function can be useful during plot prototyping, when repeatedly building plots from the same data. Its outputs can be passed as the first argument to make_enrichment_plot(). - TODO: I feel like this should be able to take in data directly as vectors/other datatypes, not just read from files. - TODO: Style-wise, is it cleaner to have it be a match statement or calling a method from a global dict? Cleaner here with a dict, cleaner overall with the match statements? - Args: mod_file_names: list of paths to modified base pileup data files regions_list: list of paths to bed files specifying regions to extract @@ -176,12 +167,10 @@ def get_enrichments( """ if not utils.check_len_equal(mod_file_names, regions_list, motifs): raise ValueError("Unequal number of inputs") - # TODO: redefinition error; still need to figure out how to do this elegantly in a way mypy likes - # dimelo/plot_enrichment.py:45: error: Item "str" of "str | Path" has no attribute "suffix" [union-attr] - mod_file_names = [Path(fn) for fn in mod_file_names] + mod_file_paths = [Path(fn) for fn in mod_file_names] mod_fractions = [] - for mod_file, regions, motif in zip(mod_file_names, regions_list, motifs): + for mod_file, regions, motif in zip(mod_file_paths, regions_list, motifs): match mod_file.suffix: case ".gz": n_mod, n_total = load_processed.pileup_counts_from_bedmethyl( diff --git a/dimelo/plot_enrichment_profile.py b/dimelo/plot_enrichment_profile.py index 600ec50..3c6c70c 100644 --- a/dimelo/plot_enrichment_profile.py +++ b/dimelo/plot_enrichment_profile.py @@ -117,11 +117,6 @@ def plot_enrichment_profile( This is the most flexible method for enrichment profile plotting. For most use cases, consider using one of the plot_enrichment_profile.by_* methods. - TODO: I think it's reasonable for smoothing min_periods to be always set to 1 for this method, as it's a visualization tool, not quantitative. Is this unreasonable? - TODO: Should the more restrictive meta versions allow *args, or only **kwargs? - No, we want to be able to pass kwargs down to the line plotter, I think. Especially if we swap it out for one that takes more different standard args. - TODO: It's mildly confusing that there are required args that are only seen as *args or **kwargs in the more restrictive meta versions... But this is so much cleaner... - Args: mod_file_names: list of paths to modified base data files bed_file_names: list of paths to bed files specifying centered equal-length regions @@ -207,18 +202,6 @@ def by_modification( **kwargs, ) - -""" -TODO: Re-assignment issue: -dimelo/plot_enrichment_profile.py:142: error: Incompatible types in assignment (expression has type "list[str | Path | list[str | Path]]", variable has type "list[str] | None") [assignment] -dimelo/plot_enrichment_profile.py:148: error: Argument "sample_names" to "plot_enrichment_profile" has incompatible type "list[str] | None"; expected "list[str]" [arg-type] -dimelo/plot_enrichment_profile.py:168: error: Incompatible types in assignment (expression has type "list[str | Path]", variable has type "list[str] | None") [assignment] -dimelo/plot_enrichment_profile.py:174: error: Argument "sample_names" to "plot_enrichment_profile" has incompatible type "list[str] | None"; expected "list[str]" [arg-type] - -If sample names is None we assign it non-None values, so it's not clear what the problem is to me. We could make an intermediate dummy variable I guess? If that is the complaint? -""" - - def by_regions( mod_file_name: str | Path, regions_list: list[str | Path | list[str | Path]], @@ -233,14 +216,15 @@ def by_regions( See plot_enrichment_profile for details. """ - if sample_names is None: - sample_names = regions_list + sample_names_for_plot = ( + sample_names if sample_names is not None else [str(region) for region in regions_list] + ) n_beds = len(regions_list) return plot_enrichment_profile( mod_file_names=[mod_file_name] * n_beds, regions_list=regions_list, motifs=[motif] * n_beds, - sample_names=sample_names, + sample_names=sample_names_for_plot, **kwargs, ) @@ -259,14 +243,17 @@ def by_dataset( See plot_enrichment_profile for details. """ - if sample_names is None: - sample_names = mod_file_names + sample_names_for_plot = ( + sample_names + if sample_names is not None + else [str(mod_file) for mod_file in mod_file_names] + ) n_mod_files = len(mod_file_names) return plot_enrichment_profile( mod_file_names=mod_file_names, regions_list=[regions] * n_mod_files, motifs=[motif] * n_mod_files, - sample_names=sample_names, + sample_names=sample_names_for_plot, **kwargs, ) @@ -288,10 +275,6 @@ def get_enrichment_profiles( This helper function can be useful during plot prototyping, when repeatedly building plots from the same data. Its outputs can be passed as the first argument to make_enrichment_profile_plot(). - TODO: I feel like this should be able to take in data directly as vectors/other datatypes, not just read from files. - TODO: Style-wise, is it cleaner to have it be a match statement or calling a method from a global dict? Cleaner here with a dict, cleaner overall with the match statements? - TODO: I think it's reasonable for smoothing min_periods to be always set to 1 for this method, as it's a visualization tool, not quantitative. Is this unreasonable? - Args: mod_file_names: list of paths to modified base data files bed_file_names: list of paths to bed files specifying centered equal-length regions @@ -309,12 +292,10 @@ def get_enrichment_profiles( """ if not utils.check_len_equal(mod_file_names, regions_list, motifs): raise ValueError("Unequal number of inputs") - # TODO: redefinition error; still need to figure out how to do this elegantly in a way mypy likes - # dimelo/plot_enrichment_profile.py:53: error: Item "str" of "str | Path" has no attribute "suffix" [union-attr] - mod_file_names = [Path(fn) for fn in mod_file_names] + mod_file_paths = [Path(fn) for fn in mod_file_names] trace_vectors = [] - for mod_file, regions, motif in zip(mod_file_names, regions_list, motifs): + for mod_file, regions, motif in zip(mod_file_paths, regions_list, motifs): match mod_file.suffix: case ".gz": modified_base_counts, valid_base_counts = ( diff --git a/dimelo/plot_reads.py b/dimelo/plot_reads.py index 1ffec62..194303c 100644 --- a/dimelo/plot_reads.py +++ b/dimelo/plot_reads.py @@ -1,14 +1,4 @@ -""" -I'm conflicted about how to handle some of this. - -There are two different ways of doing single read plotting: "rectangular" and "whole read". -"rectangular" means displaying exactly the requested region. -"whole read" means displaying the entirety of any read overlapping the requested region. -Probably need separate methods for all of this? Is there shared functionality? Do they live in the same file? Etc. - -I'm beginning to lose the thread of where we check for regions making sense. -Maybe this is an argument for an internal region class that makes checking easy? I don't know. -""" +"""Single-read plotting entrypoints and legacy axis routing helpers.""" from collections.abc import Sequence import math @@ -92,10 +82,6 @@ def plot_reads( """ Plots centered single reads as a scatterplot, cut off at the boundaries of the requested regions? - TODO: I feel like this should be able to take in data directly as vectors/other datatypes, not just read from files. - TODO: Style-wise, is it cleaner to have it be a match statement or calling a method from a global dict? Cleaner here with a dict, cleaner overall with the match statements? - TODO: So far, this is the only method to do plotting without utility methods. Is this reasonable? Is it that unique? - Args: mod_file_name: path to file containing modification data for single reads regions: path to bed file specifying regions to extract @@ -120,10 +106,7 @@ def plot_reads( merged_palette = {**utils.DEFAULT_COLORS, **palette} match mod_file_name.suffix: - # TODO: Fix how the fake reads options work, and make sure they have the same interface as the real ones. - # dimelo/plot_reads.py:63: error: Argument "regions" to "reads_from_fake" has incompatible type "str | Path | list[str | Path]"; expected "Path" [arg-type] - # Will also fix the following error: - # dimelo/plot_reads.py:68: error: Incompatible types in assignment (expression has type "dict[Any, Any] | None", variable has type "dict[Any, Any]") [assignment] + # Keep fake-file handling aligned with the non-fake return contract. case ".fake": reads, read_names, mods, regions_dict = load_processed.reads_from_fake( file=mod_file_name, @@ -190,8 +173,7 @@ def plot_reads( # Retrieve legend handles and labels handles, labels = axes.get_legend_handles_labels() - # Update legend properties - # TODO: Do we need to do this now and after? + # Update legend properties. if legend is not None: legend.set_title("Mod") @@ -200,15 +182,10 @@ def plot_reads( if hasattr(handle, "set_markersize"): handle.set_markersize(10) # Set a larger marker size for legend - # Re-apply the legend with updated handles - # TODO: Is this step necessary? + # Re-apply the legend with updated marker size. axes.legend(handles, labels, title="Mod") - # TODO: Technically, regions_dict can be None by this point. In that scenario, it will error out when checking the length. - # It can be None according to type hints but in the actual logical flow I believe it cannot be None - # However, we can easily just check whether it is None here as well, in case we change behavior elsewhere. - # Identified with mypy through the following error: - # dimelo/plot_reads.py:101: error: Argument 1 to "len" has incompatible type "dict[Any, Any] | None"; expected "Sized" [arg-type] + # regions_dict may be absent for some loader paths, so guard before reading bounds. if relative and regions_dict is not None and len(regions_dict) > 0: region1_start, region1_end, _ = next(iter(regions_dict.values()))[0] effective_window_size = (region1_end - region1_start) // 2 From 5d99f2b79b3f28716feacc1e9049806472b9c288 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 18:29:59 -0700 Subject: [PATCH 262/272] test: harden parser and loader contract regressions --- tests/test_parse_bam_vectors.py | 112 ++++++++++++++++++++++++++++++++ 1 file changed, 112 insertions(+) diff --git a/tests/test_parse_bam_vectors.py b/tests/test_parse_bam_vectors.py index 2cef2f0..c456829 100644 --- a/tests/test_parse_bam_vectors.py +++ b/tests/test_parse_bam_vectors.py @@ -363,6 +363,66 @@ def test_read_by_base_txt_to_hdf5_rejects_out_of_bounds_pos_in_read(tmp_path): ) +def test_read_by_base_txt_to_hdf5_rejects_invalid_strand(tmp_path): + input_txt = tmp_path / "extract.bad_strand.txt" + output_h5 = tmp_path / "reads.bad_strand.h5" + header = "\t".join(f"col{i}" for i in range(16)) + lines = [ + header, + _make_extract_line( + "read_bad_strand", + pos_in_read=2, + pos_in_genome=102, + chromosome="chr2", + strand="?", + read_len=10, + prob=0.80, + mod_code="a", + canonical_base="A", + ), + ] + input_txt.write_text("\n".join(lines) + "\n") + + with pytest.raises(ValueError, match="Unexpected strand"): + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=0.5, + quiet=True, + ) + + +def test_read_by_base_txt_to_hdf5_rejects_non_positive_read_length(tmp_path): + input_txt = tmp_path / "extract.bad_read_length.txt" + output_h5 = tmp_path / "reads.bad_read_length.h5" + header = "\t".join(f"col{i}" for i in range(16)) + lines = [ + header, + _make_extract_line( + "read_bad_length", + pos_in_read=0, + pos_in_genome=100, + chromosome="chr2", + strand="+", + read_len=0, + prob=0.80, + mod_code="a", + canonical_base="A", + ), + ] + input_txt.write_text("\n".join(lines) + "\n") + + with pytest.raises(ValueError, match="read length must be positive"): + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=0.5, + quiet=True, + ) + + def test_readwise_binary_modification_arrays_returns_empty_for_empty_region(tmp_path): input_txt = tmp_path / "extract.txt" output_h5 = tmp_path / "reads_thresholded.h5" @@ -471,6 +531,30 @@ def test_read_vectors_from_hdf5_rejects_subset_without_n_or_frac(tmp_path): ) +def test_read_vectors_from_hdf5_rejects_non_dict_subset_parameters(tmp_path): + input_txt = tmp_path / "extract.txt" + output_h5 = tmp_path / "reads_thresholded.h5" + _write_extract_file(input_txt) + + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=0.5, + quiet=True, + ) + + with pytest.raises(ValueError, match="provided as a dictionary"): + load_processed.read_vectors_from_hdf5( + file=output_h5, + motifs=["A,0"], + regions="chr1:95-110", + subset_parameters=1, + calculate_mod_fractions=False, + quiet=True, + ) + + def test_read_vectors_from_hdf5_rejects_subset_with_array_key(tmp_path): input_txt = tmp_path / "extract.txt" output_h5 = tmp_path / "reads_thresholded.h5" @@ -495,6 +579,34 @@ def test_read_vectors_from_hdf5_rejects_subset_with_array_key(tmp_path): ) +def test_read_vectors_from_hdf5_accepts_tuple_sort_by(tmp_path): + input_txt = tmp_path / "extract.txt" + output_h5 = tmp_path / "reads_thresholded.h5" + _write_extract_file(input_txt) + + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=0.5, + quiet=True, + ) + + read_tuples, datasets, _ = load_processed.read_vectors_from_hdf5( + file=output_h5, + motifs=["A,0"], + sort_by=("read_start", "desc"), + calculate_mod_fractions=False, + quiet=True, + ) + + read_name_index = datasets.index("read_name") + assert [read_tuple[read_name_index] for read_tuple in read_tuples] == [ + "read_no_hits", + "read_sparse", + ] + + def test_readwise_binary_modification_arrays_passes_subset_and_quiet(monkeypatch): captured_kwargs = {} From 622355de7bf562bdef427061a4f4ab95d2180c92 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 18:32:50 -0700 Subject: [PATCH 263/272] docs: add legacy cleanup integration split plan --- .../2026-04-13-legacy-cleanup-integration.md | 92 +++++++++++++++++++ 1 file changed, 92 insertions(+) create mode 100644 docs/superpowers/plans/2026-04-13-legacy-cleanup-integration.md diff --git a/docs/superpowers/plans/2026-04-13-legacy-cleanup-integration.md b/docs/superpowers/plans/2026-04-13-legacy-cleanup-integration.md new file mode 100644 index 0000000..30d39b1 --- /dev/null +++ b/docs/superpowers/plans/2026-04-13-legacy-cleanup-integration.md @@ -0,0 +1,92 @@ +# Legacy Cleanup Integration + +**Date:** 2026-04-13 +**Branch:** `codex/legacy-cleanup` +**Range for this cleanup track:** `8baefd2..HEAD` + +## Goal + +Package the parser/loader legacy-cleanup sprint into reviewable PR slices with clear risk boundaries and a repeatable verification matrix. + +## Scope Summary + +Track-level diff (`8baefd2..HEAD`): + +- `13 files changed` +- `1755 insertions(+), 697 deletions(-)` +- Core files touched: + - `dimelo/parse_bam.py` + - `dimelo/load_processed.py` + - `dimelo/run_modkit.py` + - `dimelo/utils.py` + - `dimelo/plot_*.py` (debt-only cleanup) + - parser/loader-focused tests + +## What Landed + +### Parser lane + +- Clarified and stabilized threshold semantics in extract conversion. +- Fixed extract coordinate reconstruction and added explicit bounds validation. +- Consolidated chunk/dataset write flow and CSV row parsing in `read_by_base_txt_to_hdf5`. +- Simplified parser helper contracts (`prep_output_directory`, path coercion, thread-command handling). +- Removed stale TODO debt and repeated cleanup code paths. + +### Loader lane + +- Hardened subset contract validation (`dict` only, must include `n`/`frac`, reject `array`). +- Fixed empty-region behavior and empty-subset safety. +- Disambiguated duplicate read names across overlapping regions. +- Added optional parallel paths for region selection and readwise processing. +- Added loader progress wiring and public alias helpers: + - `counts_from_pileup` + - `vectors_from_pileup` + +### Plotting/util lane + +- Cleanup-only removal of stale TODO/type-reassignment debt in plotting helpers. +- No intentional behavior changes in plotting outputs. + +### Hardening tests lane + +- Added parser guardrail tests: + - invalid strand row raises + - non-positive read length raises + - out-of-bounds `pos_in_read` raises +- Added loader contract tests: + - `subset_parameters` non-dict rejection + - tuple-form `sort_by` path normalization/ordering + +## Verification Matrix + +All commands below passed on `codex/legacy-cleanup` after lane completion: + +1. `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 /Users/ngamarra/.pyenv/versions/3.11.3/bin/python3.11 -m pytest tests/test_parse_bam.py tests/test_parse_bam_vectors.py tests/test_utils_regions.py -q` + `25 passed` +2. `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 /Users/ngamarra/.pyenv/versions/3.11.3/bin/python3.11 -m pytest tests/test_distribution.py tests/test_cluster.py -q` + `20 passed, 2 warnings` (existing `tight_layout` and joblib core-detection warnings) +3. `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 /Users/ngamarra/.pyenv/versions/3.11.3/bin/python3.11 -m pytest tests/test_region_contrasts.py -k "read_mod_fraction" -q` + `19 passed, 65 deselected` +4. `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 /Users/ngamarra/.pyenv/versions/3.11.3/bin/python3.11 -m pytest tests/test_workflows.py -k "read_mod_fraction or shared_cluster" -q` + `14 passed, 18 deselected, 1 warning` (existing joblib core-detection warning) + +## PR Split Recommendation + +Split this cleanup track into **3 thematic PRs** (recommended) to keep review focused: + +1. **PR A: Parser correctness + parser refactor** + - `parse_bam.py`, `run_modkit.py`, parser tests, `utils.py` parser-adjacent fixes. + - Include coordinate and threshold semantics changes with their tests. +2. **PR B: Loader contract + parallelization + aliases** + - `load_processed.py`, loader tests, `test_load_processed_aliases.py`. + - Keep API alias additions with loader behavior fixes and parallel parity tests. +3. **PR C: Plotting debt cleanup** + - `plot_depth_histogram.py`, `plot_depth_profile.py`, `plot_enrichment.py`, `plot_enrichment_profile.py`, `plot_reads.py`. + - Pure cleanup/debt removal; no functional change intent. + +Hardening tests can remain with PR A/PR B where they logically belong (preferred), rather than a separate PR. + +## Integration Decision + +Proceed with the 3-PR split above. +If reviewer throughput is constrained, fallback to a 2-PR split by combining PR C into PR B. From 46ccf4d56079e1bd99648bf4b480d6e74f13e822 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Mon, 13 Apr 2026 14:11:49 -0700 Subject: [PATCH 264/272] feat: complete shared cluster inference v1 scope --- README.md | 9 + dimelo/shared_cluster_tests.py | 791 ++++++++++++++++++++++++++++- docs/shared-clustering.md | 66 +++ docs/superpowers/README.md | 2 + tests/test_shared_cluster_tests.py | 199 +++++++- 5 files changed, 1048 insertions(+), 19 deletions(-) diff --git a/README.md b/README.md index 8e8c8f4..313a916 100644 --- a/README.md +++ b/README.md @@ -255,6 +255,15 @@ inference. Shared clustering also has renderer-neutral plotting prep in `dimelo.plotting`. Use `prepare_shared_cluster_distribution_data(...)` for sample/condition cluster fractions, `prepare_shared_cluster_profile_data(...)` for cluster feature summaries, and `prepare_shared_cluster_region_data(...)` for region-level occupancy tables. The older lightweight `result.plot_data["cluster_distribution_bar"]` and `result.plot_data["cluster_distribution_heatmap"]` payloads remain supported. +Global shared-cluster composition inference is available through +`dimelo.shared_cluster_tests.shared_cluster_tests(...)`, which consumes a +`SharedClusterResult` plus a `ContrastSpec`. Use this for global composition +shifts (`pairwise`, `matched_pairwise`, `group_vs_group`, `time_course`), and +keep per-region occupancy inference in +`region_contrasts.score_regions(..., analysis_unit="cluster_occupancy")`. +Pooled `chi_squared` and `g_test` modes are screening-oriented and should not +replace replicate-aware permutation analyses when replicates are available. + For human-readable pileups (bedmethyl files, .bed) and extracted reads (.txt tab-separated values), run with `cleanup=False`. `cleanup=True` will clear these outputs because they can take up a lot of space. ### Parsing outputs diff --git a/dimelo/shared_cluster_tests.py b/dimelo/shared_cluster_tests.py index 4e52971..4102df6 100644 --- a/dimelo/shared_cluster_tests.py +++ b/dimelo/shared_cluster_tests.py @@ -1,16 +1,678 @@ from __future__ import annotations +from itertools import combinations +from typing import Any + +import numpy as np +import pandas as pd +from scipy import stats + from dimelo.models import ContrastSpec, SharedClusterContrastResult, SharedClusterResult +_SUPPORTED_SHARED_CLUSTER_MODES = { + "pairwise", + "matched_pairwise", + "group_vs_group", + "time_course", +} + +_SUPPORTED_POOLED_SCREEN_TESTS = {"chi_squared", "g_test"} + def _require_supported_shared_cluster_mode(contrast: ContrastSpec) -> None: - supported = {"pairwise", "matched_pairwise", "group_vs_group", "time_course"} - if contrast.mode not in supported: + if contrast.mode not in _SUPPORTED_SHARED_CLUSTER_MODES: raise NotImplementedError( f"Shared cluster tests are not implemented for contrast mode '{contrast.mode}'." ) +def _require_requested_conditions_present( + sample_table: pd.DataFrame, + *, + side_specs: dict[str, list[str]], +) -> None: + available_conditions = set(sample_table["condition"].dropna().unique()) + for side, conditions in side_specs.items(): + missing = sorted(set(conditions) - available_conditions) + if missing: + raise ValueError( + f"Missing {side} evidence for requested condition(s): {', '.join(missing)}." + ) + + +def _require_time_order_present(sample_table: pd.DataFrame, time_order: list[str]) -> None: + available_conditions = set(sample_table["condition"].dropna().unique()) + missing = [condition for condition in time_order if condition not in available_conditions] + if missing: + raise ValueError( + "Shared cluster time_course requested missing time_order condition(s): " + + ", ".join(missing) + ) + + +def _sample_fraction_table(result: SharedClusterResult) -> pd.DataFrame: + required = {"sample_id", "condition", "cluster", "fraction"} + missing = required - set(result.cluster_distribution.columns) + if missing: + raise ValueError( + "Shared cluster tests require cluster_distribution columns: " + + ", ".join(sorted(missing)) + + "." + ) + return result.cluster_distribution.loc[ + :, ["sample_id", "condition", "cluster", "fraction"] + ].copy() + + +def _condition_count_table(result: SharedClusterResult) -> pd.DataFrame: + required = {"condition", "cluster", "count", "fraction"} + missing = required - set(result.condition_distribution.columns) + if missing: + raise ValueError( + "Shared cluster tests require condition_distribution columns: " + + ", ".join(sorted(missing)) + + "." + ) + return result.condition_distribution.loc[ + :, ["condition", "cluster", "count", "fraction"] + ].copy() + + +def _cluster_order(result: SharedClusterResult) -> list[str]: + cluster_labels = list(result.model.cluster_labels) + if cluster_labels: + return cluster_labels + return ( + result.cluster_distribution["cluster"].drop_duplicates().astype(str).sort_values().tolist() + ) + + +def _composition_effect_size(summary_table: pd.DataFrame) -> float: + return float(summary_table["delta_fraction"].abs().sum() / 2.0) + + +def _composition_effect_size_from_vectors(observed: np.ndarray, reference: np.ndarray) -> float: + return float(np.abs(observed - reference).sum() / 2.0) + + +def _trend_statistic(timepoint_fractions: np.ndarray) -> float: + if timepoint_fractions.shape[0] < 2: + return 0.0 + + positions = np.arange(timepoint_fractions.shape[0], dtype=float) + slopes = [ + np.polyfit(positions, timepoint_fractions[:, cluster_index], 1)[0] + for cluster_index in range(timepoint_fractions.shape[1]) + ] + return float(np.abs(slopes).sum() / 2.0) + + +def _adjust_p_values_bh(p_values: pd.Series) -> pd.Series: + if p_values.empty: + return pd.Series(dtype=float, index=p_values.index) + + numeric = pd.to_numeric(p_values, errors="coerce") + valid_mask = numeric.notna() + if not valid_mask.any(): + return pd.Series(np.nan, index=p_values.index, dtype=float) + + valid_values = numeric[valid_mask].to_numpy(dtype=float) + order = np.argsort(valid_values, kind="mergesort") + ranked = valid_values[order] + adjusted = np.empty_like(ranked) + running_min = 1.0 + total = len(ranked) + + for index in range(total - 1, -1, -1): + rank = index + 1 + candidate = min(1.0, ranked[index] * total / rank) + running_min = min(running_min, candidate) + adjusted[index] = running_min + + restored = np.full(len(p_values), np.nan, dtype=float) + restored_indices = np.flatnonzero(valid_mask.to_numpy()) + restored[restored_indices[order]] = adjusted + return pd.Series(restored, index=p_values.index, dtype=float) + + +def _contrast_id(contrast: ContrastSpec) -> str: + numerator = "+".join(contrast.numerator or []) + denominator = "+".join(contrast.denominator or []) + if contrast.mode == "time_course": + time_order = "+".join(contrast.time_order or []) + return f"time_course:{time_order}" + return f"{numerator}_vs_{denominator}" + + +def _sample_cluster_matrix(result: SharedClusterResult) -> pd.DataFrame: + sample_table = _sample_fraction_table(result) + cluster_order = _cluster_order(result) + sample_info = sample_table.loc[:, ["sample_id", "condition"]].drop_duplicates() + matrix = ( + sample_table.pivot_table( + index="sample_id", + columns="cluster", + values="fraction", + aggfunc="first", + fill_value=0.0, + ) + .reindex(columns=cluster_order, fill_value=0.0) + .reset_index() + ) + return sample_info.merge(matrix, on="sample_id", how="left") + + +def _add_pairing_metadata( + sample_matrix: pd.DataFrame, + *, + assignments: pd.DataFrame, + pairing_key: str, +) -> pd.DataFrame: + if pairing_key not in assignments.columns: + raise ValueError( + f"Shared cluster matched_pairwise requires assignments column {pairing_key!r}." + ) + + pairing = assignments.loc[:, ["sample_id", pairing_key]].drop_duplicates() + pair_counts = pairing.groupby("sample_id", dropna=False)[pairing_key].nunique(dropna=False) + if (pair_counts > 1).any(): + raise ValueError( + "Shared cluster matched_pairwise requires each sample_id to map to exactly one pairing key." + ) + if pairing[pairing_key].isna().any(): + raise ValueError( + f"Shared cluster matched_pairwise requires non-null values in column {pairing_key!r}." + ) + return sample_matrix.merge(pairing, on="sample_id", how="left") + + +def _prepare_unpaired_group_table( + result: SharedClusterResult, + *, + contrast: ContrastSpec, +) -> tuple[pd.DataFrame, list[str]]: + sample_matrix = _sample_cluster_matrix(result) + cluster_order = _cluster_order(result) + side_specs = { + "numerator": contrast.numerator or [], + "denominator": contrast.denominator or [], + } + _require_requested_conditions_present(sample_matrix, side_specs=side_specs) + requested_conditions = set(side_specs["numerator"]) | set(side_specs["denominator"]) + filtered = sample_matrix.loc[sample_matrix["condition"].isin(requested_conditions)].copy() + filtered["contrast_side"] = np.where( + filtered["condition"].isin(side_specs["numerator"]), + "numerator", + "denominator", + ) + return filtered, cluster_order + + +def _prepare_paired_group_table( + result: SharedClusterResult, + *, + contrast: ContrastSpec, +) -> tuple[pd.DataFrame, list[str]]: + if len(contrast.numerator or []) != 1 or len(contrast.denominator or []) != 1: + raise ValueError( + "Shared cluster matched_pairwise currently requires exactly one numerator " + "and one denominator condition." + ) + + sample_matrix = _sample_cluster_matrix(result) + sample_matrix = _add_pairing_metadata( + sample_matrix, + assignments=result.assignments, + pairing_key=contrast.pairing_key or "", + ) + cluster_order = _cluster_order(result) + side_specs = { + "numerator": contrast.numerator or [], + "denominator": contrast.denominator or [], + } + _require_requested_conditions_present(sample_matrix, side_specs=side_specs) + requested_conditions = set(side_specs["numerator"]) | set(side_specs["denominator"]) + filtered = sample_matrix.loc[sample_matrix["condition"].isin(requested_conditions)].copy() + filtered["contrast_side"] = np.where( + filtered["condition"].isin(side_specs["numerator"]), + "numerator", + "denominator", + ) + + grouped = ( + filtered.groupby([contrast.pairing_key, "contrast_side"], as_index=False, sort=False)[ + cluster_order + ] + .mean() + ) + side_sets = ( + grouped.loc[:, [contrast.pairing_key, "contrast_side"]] + .drop_duplicates() + .groupby(contrast.pairing_key)["contrast_side"] + .agg(lambda values: set(values)) + ) + complete_pairs = [ + pair_id for pair_id, sides in side_sets.items() if {"numerator", "denominator"} <= sides + ] + if not complete_pairs: + raise ValueError("Shared cluster matched_pairwise found no complete matched units.") + + return grouped.loc[grouped[contrast.pairing_key].isin(complete_pairs)].copy(), cluster_order + + +def _permutation_p_value(observed: float, permuted: np.ndarray) -> float: + return float((1 + np.count_nonzero(permuted >= observed - 1e-12)) / (len(permuted) + 1)) + + +def _run_unpaired_permutations( + values: np.ndarray, + *, + n_numerator: int, + n_permutations: int, + random_state: int | None, +) -> tuple[np.ndarray, np.ndarray]: + rng = np.random.default_rng(random_state) + cluster_stats = np.zeros((n_permutations, values.shape[1]), dtype=float) + omnibus_stats = np.zeros(n_permutations, dtype=float) + + for permutation_index in range(n_permutations): + permuted_indices = rng.permutation(values.shape[0]) + numerator = values[permuted_indices[:n_numerator]] + denominator = values[permuted_indices[n_numerator:]] + delta = numerator.mean(axis=0) - denominator.mean(axis=0) + cluster_stats[permutation_index] = np.abs(delta) + omnibus_stats[permutation_index] = np.abs(delta).sum() / 2.0 + + return cluster_stats, omnibus_stats + + +def _run_paired_permutations( + pair_deltas: np.ndarray, + *, + n_permutations: int, + random_state: int | None, +) -> tuple[np.ndarray, np.ndarray]: + rng = np.random.default_rng(random_state) + cluster_stats = np.zeros((n_permutations, pair_deltas.shape[1]), dtype=float) + omnibus_stats = np.zeros(n_permutations, dtype=float) + + for permutation_index in range(n_permutations): + signs = rng.choice(np.array([-1.0, 1.0]), size=pair_deltas.shape[0])[:, None] + delta = (pair_deltas * signs).mean(axis=0) + cluster_stats[permutation_index] = np.abs(delta) + omnibus_stats[permutation_index] = np.abs(delta).sum() / 2.0 + + return cluster_stats, omnibus_stats + + +def _score_unpaired_group( + group_table: pd.DataFrame, + *, + cluster_order: list[str], + n_permutations: int, + random_state: int | None, +) -> tuple[pd.DataFrame, dict[str, Any]]: + numerator = group_table.loc[group_table["contrast_side"] == "numerator", cluster_order] + denominator = group_table.loc[group_table["contrast_side"] == "denominator", cluster_order] + if numerator.empty or denominator.empty: + raise ValueError("Shared cluster tests require evidence for both contrast sides.") + + observed_fraction = numerator.mean(axis=0) + reference_fraction = denominator.mean(axis=0) + delta = observed_fraction - reference_fraction + details = pd.DataFrame( + { + "cluster": cluster_order, + "fraction": observed_fraction.to_numpy(dtype=float), + "reference_fraction": reference_fraction.to_numpy(dtype=float), + "delta_fraction": delta.to_numpy(dtype=float), + } + ) + + perm_cluster, perm_omnibus = _run_unpaired_permutations( + group_table.loc[:, cluster_order].to_numpy(dtype=float), + n_numerator=len(numerator), + n_permutations=n_permutations, + random_state=random_state, + ) + return details, { + "permuted_cluster_stats": perm_cluster, + "permuted_omnibus_stats": perm_omnibus, + "paired": False, + "n_numerator": int(len(numerator)), + "n_denominator": int(len(denominator)), + } + + +def _score_paired_group( + pair_table: pd.DataFrame, + *, + cluster_order: list[str], + contrast: ContrastSpec, + n_permutations: int, + random_state: int | None, +) -> tuple[pd.DataFrame, dict[str, Any]]: + pair_key = contrast.pairing_key or "" + numerator = ( + pair_table.loc[pair_table["contrast_side"] == "numerator"] + .set_index(pair_key) + .reindex(columns=cluster_order) + .sort_index() + ) + denominator = ( + pair_table.loc[pair_table["contrast_side"] == "denominator"] + .set_index(pair_key) + .reindex(columns=cluster_order) + .sort_index() + ) + common_pairs = numerator.index.intersection(denominator.index) + if common_pairs.empty: + raise ValueError("Shared cluster matched_pairwise found no complete matched units.") + + numerator = numerator.loc[common_pairs] + denominator = denominator.loc[common_pairs] + observed_fraction = numerator.mean(axis=0) + reference_fraction = denominator.mean(axis=0) + delta = observed_fraction - reference_fraction + details = pd.DataFrame( + { + "cluster": cluster_order, + "fraction": observed_fraction.to_numpy(dtype=float), + "reference_fraction": reference_fraction.to_numpy(dtype=float), + "delta_fraction": delta.to_numpy(dtype=float), + } + ) + + pair_deltas = numerator.to_numpy(dtype=float) - denominator.to_numpy(dtype=float) + perm_cluster, perm_omnibus = _run_paired_permutations( + pair_deltas, + n_permutations=n_permutations, + random_state=random_state, + ) + return details, { + "permuted_cluster_stats": perm_cluster, + "permuted_omnibus_stats": perm_omnibus, + "paired": True, + "n_pairs_used": int(len(common_pairs)), + } + + +def _finalize_details( + details: pd.DataFrame, + *, + permuted_cluster_stats: np.ndarray, +) -> pd.DataFrame: + finalized = details.copy() + finalized["log2_fc"] = np.log2( + (finalized["fraction"] + 1e-9) / (finalized["reference_fraction"] + 1e-9) + ) + finalized["effect_size"] = finalized["delta_fraction"].abs() + finalized["p_value"] = [ + _permutation_p_value( + float(observed), + permuted_cluster_stats[:, cluster_index], + ) + for cluster_index, observed in enumerate(finalized["effect_size"]) + ] + finalized["adjusted_p_value"] = _adjust_p_values_bh(finalized["p_value"]) + finalized = finalized.sort_values( + ["adjusted_p_value", "p_value", "effect_size", "cluster"], + ascending=[True, True, False, True], + kind="stable", + ).reset_index(drop=True) + finalized["rank"] = np.arange(1, len(finalized) + 1, dtype=int) + return finalized + + +def _build_summary( + details: pd.DataFrame, + *, + contrast: ContrastSpec, + omnibus_p_value: float, + stats_metadata: dict[str, Any], + test: str, + trend_p_value: float | None = None, +) -> pd.DataFrame: + top_cluster_row = details.sort_values( + ["effect_size", "p_value", "cluster"], + ascending=[False, True, True], + kind="stable", + ).iloc[0] + summary_row: dict[str, Any] = { + "contrast_id": _contrast_id(contrast), + "contrast_mode": contrast.mode, + "test": test, + "numerator_conditions": "+".join(contrast.numerator or []), + "denominator_conditions": "+".join(contrast.denominator or []), + "composition_effect_size": _composition_effect_size(details), + "omnibus_p_value": float(omnibus_p_value), + "top_cluster": top_cluster_row["cluster"], + "top_cluster_delta_fraction": float(top_cluster_row["delta_fraction"]), + "effect_size_metric": "total_variation_distance", + "paired": bool(stats_metadata["paired"]), + } + if trend_p_value is not None: + summary_row["trend_p_value"] = float(trend_p_value) + + for key, value in stats_metadata.items(): + if key.startswith("n_"): + summary_row[key] = value + return pd.DataFrame([summary_row]) + + +def _build_pooled_omnibus_p_value( + *, + result: SharedClusterResult, + contrast: ContrastSpec, + test: str, +) -> float: + if test not in _SUPPORTED_POOLED_SCREEN_TESTS: + raise ValueError( + "shared_cluster_tests currently requires test='permutation', " + "'chi_squared', or 'g_test'." + ) + + condition_table = _condition_count_table(result) + side_specs = { + "numerator": contrast.numerator or [], + "denominator": contrast.denominator or [], + } + _require_requested_conditions_present(condition_table, side_specs=side_specs) + requested_conditions = side_specs["numerator"] + side_specs["denominator"] + filtered = condition_table.loc[condition_table["condition"].isin(requested_conditions)].copy() + contingency = ( + filtered.pivot_table( + index="condition", + columns="cluster", + values="count", + aggfunc="sum", + fill_value=0, + ) + .reindex(index=requested_conditions, columns=_cluster_order(result), fill_value=0) + .astype(float) + ) + if contingency.shape[0] < 2 or contingency.shape[1] < 2: + raise ValueError("shared_cluster_tests pooled screening requires at least 2x2 counts.") + + if test == "chi_squared": + _, omnibus_p_value, _, _ = stats.chi2_contingency( + contingency.to_numpy(dtype=float), + correction=False, + ) + else: + _, omnibus_p_value, _, _ = stats.chi2_contingency( + contingency.to_numpy(dtype=float), + correction=False, + lambda_="log-likelihood", + ) + return float(omnibus_p_value) + + +def _score_time_course( + *, + result: SharedClusterResult, + contrast: ContrastSpec, + n_permutations: int, + random_state: int | None, + include_pairwise: bool, +) -> SharedClusterContrastResult: + time_order = list(dict.fromkeys(contrast.time_order or [])) + if not time_order: + raise ValueError("Shared cluster time_course requires contrast.time_order.") + + sample_matrix = _sample_cluster_matrix(result) + _require_time_order_present(sample_matrix, time_order) + cluster_order = _cluster_order(result) + + filtered = sample_matrix.loc[sample_matrix["condition"].isin(time_order)].copy() + filtered["condition"] = pd.Categorical(filtered["condition"], categories=time_order, ordered=True) + filtered = filtered.sort_values(["condition", "sample_id"], kind="stable").reset_index(drop=True) + + grouped = ( + filtered.groupby("condition", sort=False, observed=False)[cluster_order] + .mean() + .reindex(time_order) + ) + counts = ( + filtered.groupby("condition", sort=False, observed=False)["sample_id"] + .nunique() + .reindex(time_order) + ) + time_course_table = grouped.reset_index(names="timepoint") + time_course_table["n_samples"] = counts.to_numpy(dtype=int) + + observed_matrix = grouped.to_numpy(dtype=float) + observed_first = observed_matrix[0] + observed_last = observed_matrix[-1] + observed_delta = observed_last - observed_first + observed_omnibus = _composition_effect_size_from_vectors(observed_last, observed_first) + observed_trend = _trend_statistic(observed_matrix) + + rng = np.random.default_rng(random_state) + permuted_cluster_stats = np.zeros((n_permutations, len(cluster_order)), dtype=float) + permuted_omnibus_stats = np.zeros(n_permutations, dtype=float) + permuted_trend_stats = np.zeros(n_permutations, dtype=float) + condition_values = filtered["condition"].to_numpy() + value_matrix = filtered.loc[:, cluster_order].to_numpy(dtype=float) + + for permutation_index in range(n_permutations): + permuted_conditions = rng.permutation(condition_values) + permuted = pd.DataFrame(value_matrix, columns=cluster_order) + permuted["condition"] = permuted_conditions + permuted_grouped = ( + permuted.groupby("condition", sort=False, observed=False)[cluster_order] + .mean() + .reindex(time_order) + ) + permuted_matrix = permuted_grouped.to_numpy(dtype=float) + permuted_delta = permuted_matrix[-1] - permuted_matrix[0] + permuted_cluster_stats[permutation_index] = np.abs(permuted_delta) + permuted_omnibus_stats[permutation_index] = _composition_effect_size_from_vectors( + permuted_matrix[-1], + permuted_matrix[0], + ) + permuted_trend_stats[permutation_index] = _trend_statistic(permuted_matrix) + + details = pd.DataFrame( + { + "cluster": cluster_order, + "fraction": observed_last, + "reference_fraction": observed_first, + "delta_fraction": observed_delta, + } + ) + details = _finalize_details(details, permuted_cluster_stats=permuted_cluster_stats) + + omnibus_p_value = _permutation_p_value(observed_omnibus, permuted_omnibus_stats) + trend_p_value = _permutation_p_value(observed_trend, permuted_trend_stats) + summary = _build_summary( + details, + contrast=contrast, + omnibus_p_value=omnibus_p_value, + stats_metadata={ + "paired": False, + "n_timepoints": int(len(time_order)), + "n_samples": int(filtered["sample_id"].nunique()), + }, + test="permutation", + trend_p_value=trend_p_value, + ) + summary["test"] = "permutation" + summary["trend_p_value"] = float(trend_p_value) + + pairwise = None + plot_data: dict[str, pd.DataFrame | dict[str, Any]] = { + "summary_table": summary.copy(), + "cluster_effect_table": details.copy(), + "time_course_table": time_course_table.copy(), + } + + if include_pairwise: + pairwise_rows = [] + for left_timepoint, right_timepoint in zip(time_order[:-1], time_order[1:]): + pair_table = filtered.loc[ + filtered["condition"].isin([left_timepoint, right_timepoint]) + ].copy() + pair_table["contrast_side"] = np.where( + pair_table["condition"] == left_timepoint, + "numerator", + "denominator", + ) + pair_details, stats_metadata = _score_unpaired_group( + pair_table, + cluster_order=cluster_order, + n_permutations=n_permutations, + random_state=random_state, + ) + pair_details = _finalize_details( + pair_details, + permuted_cluster_stats=stats_metadata["permuted_cluster_stats"], + ) + pair_omnibus = _permutation_p_value( + _composition_effect_size(pair_details), + stats_metadata["permuted_omnibus_stats"], + ) + pair_summary = _build_summary( + pair_details, + contrast=ContrastSpec( + mode="pairwise", + numerator=[left_timepoint], + denominator=[right_timepoint], + ), + omnibus_p_value=pair_omnibus, + stats_metadata=stats_metadata, + test="permutation", + ) + row = pair_summary.iloc[0].to_dict() + row["left_timepoint"] = left_timepoint + row["right_timepoint"] = right_timepoint + pairwise_rows.append(row) + + pairwise = pd.DataFrame(pairwise_rows) + plot_data["pairwise_table"] = pairwise.copy() + + metadata: dict[str, Any] = { + "contrast_mode": contrast.mode, + "contrast_id": _contrast_id(contrast), + "paired": False, + "pairing_key": None, + "test": "permutation", + "multiple_testing": "fdr_bh", + "n_permutations": int(n_permutations), + "random_state": random_state, + "inference_level": "replicate_aware", + "n_timepoints": int(len(time_order)), + "n_samples": int(filtered["sample_id"].nunique()), + } + return SharedClusterContrastResult( + summary=summary, + details=details, + pairwise=pairwise, + plot_data=plot_data, + metadata=metadata, + ) + + def shared_cluster_tests( *, result: SharedClusterResult, @@ -22,4 +684,127 @@ def shared_cluster_tests( include_pairwise: bool = False, ) -> SharedClusterContrastResult: _require_supported_shared_cluster_mode(contrast) - raise NotImplementedError("shared_cluster_tests is not implemented yet.") + if multiple_testing != "fdr_bh": + raise ValueError("shared_cluster_tests currently requires multiple_testing='fdr_bh'.") + if n_permutations <= 0: + raise ValueError("shared_cluster_tests requires n_permutations > 0.") + + if contrast.mode == "time_course": + if test != "permutation": + raise ValueError("shared_cluster_tests time_course currently requires test='permutation'.") + return _score_time_course( + result=result, + contrast=contrast, + n_permutations=n_permutations, + random_state=random_state, + include_pairwise=include_pairwise, + ) + + if test == "permutation": + if contrast.mode == "matched_pairwise": + pair_table, cluster_order = _prepare_paired_group_table(result, contrast=contrast) + details, stats_metadata = _score_paired_group( + pair_table, + cluster_order=cluster_order, + contrast=contrast, + n_permutations=n_permutations, + random_state=random_state, + ) + sample_plot_table = pair_table.copy() + else: + group_table, cluster_order = _prepare_unpaired_group_table(result, contrast=contrast) + details, stats_metadata = _score_unpaired_group( + group_table, + cluster_order=cluster_order, + n_permutations=n_permutations, + random_state=random_state, + ) + sample_plot_table = group_table.copy() + + details = _finalize_details( + details, + permuted_cluster_stats=stats_metadata["permuted_cluster_stats"], + ) + omnibus_p_value = _permutation_p_value( + _composition_effect_size(details), + stats_metadata["permuted_omnibus_stats"], + ) + summary = _build_summary( + details, + contrast=contrast, + omnibus_p_value=omnibus_p_value, + stats_metadata=stats_metadata, + test=test, + ) + metadata: dict[str, Any] = { + "contrast_mode": contrast.mode, + "contrast_id": _contrast_id(contrast), + "paired": bool(stats_metadata["paired"]), + "pairing_key": contrast.pairing_key if contrast.mode == "matched_pairwise" else None, + "test": test, + "multiple_testing": multiple_testing, + "n_permutations": int(n_permutations), + "random_state": random_state, + "inference_level": "replicate_aware", + } + metadata.update({key: value for key, value in stats_metadata.items() if key.startswith("n_")}) + plot_data = { + "summary_table": summary.copy(), + "cluster_effect_table": details.copy(), + "sample_fraction_table": sample_plot_table, + } + return SharedClusterContrastResult( + summary=summary, + details=details, + plot_data=plot_data, + metadata=metadata, + ) + + if test not in _SUPPORTED_POOLED_SCREEN_TESTS: + raise ValueError( + "shared_cluster_tests currently requires test='permutation', " + "'chi_squared', or 'g_test'." + ) + + group_table, cluster_order = _prepare_unpaired_group_table(result, contrast=contrast) + details, stats_metadata = _score_unpaired_group( + group_table, + cluster_order=cluster_order, + n_permutations=n_permutations, + random_state=random_state, + ) + details = _finalize_details( + details, + permuted_cluster_stats=stats_metadata["permuted_cluster_stats"], + ) + omnibus_p_value = _build_pooled_omnibus_p_value(result=result, contrast=contrast, test=test) + summary = _build_summary( + details, + contrast=contrast, + omnibus_p_value=omnibus_p_value, + stats_metadata=stats_metadata, + test=test, + ) + metadata: dict[str, Any] = { + "contrast_mode": contrast.mode, + "contrast_id": _contrast_id(contrast), + "paired": bool(stats_metadata["paired"]), + "pairing_key": None, + "test": test, + "multiple_testing": multiple_testing, + "n_permutations": int(n_permutations), + "random_state": random_state, + "inference_level": "pooled_screen", + } + metadata.update({key: value for key, value in stats_metadata.items() if key.startswith("n_")}) + plot_data = { + "summary_table": summary.copy(), + "cluster_effect_table": details.copy(), + "sample_fraction_table": group_table.copy(), + } + return SharedClusterContrastResult( + summary=summary, + details=details, + plot_data=plot_data, + metadata=metadata, + ) diff --git a/docs/shared-clustering.md b/docs/shared-clustering.md index b69fed7..06c1ab3 100644 --- a/docs/shared-clustering.md +++ b/docs/shared-clustering.md @@ -189,6 +189,72 @@ For heatmaps: heatmap = result.plot_data["cluster_distribution_heatmap"].set_index("condition") ``` +## Global Composition Inference + +Shared clustering now includes a dedicated inference helper for global +composition changes: + +```python +from dimelo import shared_cluster_tests +from dimelo.models import ContrastSpec + +contrast_result = shared_cluster_tests.shared_cluster_tests( + result=result, + contrast=ContrastSpec( + mode="pairwise", + numerator=["treated"], + denominator=["NS"], + ), + test="permutation", +) +``` + +Matched pairwise example: + +```python +contrast_result = shared_cluster_tests.shared_cluster_tests( + result=result, + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["treated"], + denominator=["NS"], + pairing_key="subject_id", + ), + test="permutation", +) +``` + +Time-course example: + +```python +contrast_result = shared_cluster_tests.shared_cluster_tests( + result=result, + contrast=ContrastSpec(mode="time_course", time_order=["t0", "t1", "t2"]), + test="permutation", + include_pairwise=True, +) +``` + +Pooled screening example: + +```python +screen_result = shared_cluster_tests.shared_cluster_tests( + result=result, + contrast=ContrastSpec(mode="pairwise", numerator=["treated"], denominator=["NS"]), + test="chi_squared", +) +``` + +Inference boundary: + +- `shared_cluster_tests(...)` is for global cluster-composition inference from + `SharedClusterResult`. +- `region_contrasts.score_regions(..., analysis_unit="cluster_occupancy")` + remains the path for region-level occupancy inference. +- Pooled `chi_squared` and `g_test` are screening-oriented outputs; use + replicate-aware permutation paths as the primary inferential mode when + replicate structure exists. + ## Current V1 Scope - `mode="read_global"` supports shared read clustering from extract outputs. diff --git a/docs/superpowers/README.md b/docs/superpowers/README.md index d3c7fe0..3f60afb 100644 --- a/docs/superpowers/README.md +++ b/docs/superpowers/README.md @@ -18,6 +18,7 @@ This directory tracks internal design and implementation work for the current br ### Shared Clustering - [2026-03-31-shared-cluster-distribution-design.md](specs/2026-03-31-shared-cluster-distribution-design.md) - shared-boundary clustering architecture and artifact model. Status: `partially implemented` +- [2026-04-12-shared-cluster-tests-design.md](specs/2026-04-12-shared-cluster-tests-design.md) - global shared-cluster composition inference layer that consumes `SharedClusterResult` and `ContrastSpec`. Status: `partially implemented` ### Region Analysis @@ -44,6 +45,7 @@ This directory tracks internal design and implementation work for the current br ### Shared Clustering - [2026-03-31-shared-clustering-foundations.md](plans/2026-03-31-shared-clustering-foundations.md) - shared clustering models, artifacts, plotting payloads, and workflows. Status: `implemented` +- [2026-04-12-shared-cluster-tests.md](plans/2026-04-12-shared-cluster-tests.md) - shared-cluster global composition inference with permutation paths plus pooled screening options. Status: `partially implemented` ### Region Analysis diff --git a/tests/test_shared_cluster_tests.py b/tests/test_shared_cluster_tests.py index 7ca43e1..4e7f3bf 100644 --- a/tests/test_shared_cluster_tests.py +++ b/tests/test_shared_cluster_tests.py @@ -5,29 +5,86 @@ def _make_shared_cluster_test_result() -> SharedClusterResult: - model = SharedClusterModel( - mode="shared", - motifs=["A,0"], - feature_names=["A,0_mod_fraction"], - preprocessing={"scale": "standard"}, - estimator=object(), - cluster_labels=["cluster-1"], - fit_metadata={"random_state": 7}, - ) return SharedClusterResult( - model=model, - assignments=pd.DataFrame({"cluster": ["cluster-1"]}), - cluster_distribution=pd.DataFrame({"cluster": ["cluster-1"]}), - condition_distribution=pd.DataFrame({"condition": ["treated"]}), + model=SharedClusterModel( + mode="read_global", + motifs=["A,0"], + feature_names=["f0", "f1"], + preprocessing={"signal_normalization": "none"}, + estimator=object(), + cluster_labels=["C0", "C1"], + fit_metadata={"clusterer": "minibatch_kmeans", "n_clusters": 2}, + ), + assignments=pd.DataFrame( + { + "sample_id": ["s1", "s2", "s3", "s4"], + "condition": ["NS", "NS", "treated", "treated"], + "subject_id": ["p1", "p2", "p1", "p2"], + "cluster": ["C0", "C0", "C1", "C1"], + } + ), + cluster_distribution=pd.DataFrame( + [ + {"sample_id": "s1", "condition": "NS", "cluster": "C0", "count": 80, "fraction": 0.80}, + {"sample_id": "s1", "condition": "NS", "cluster": "C1", "count": 20, "fraction": 0.20}, + {"sample_id": "s2", "condition": "NS", "cluster": "C0", "count": 75, "fraction": 0.75}, + {"sample_id": "s2", "condition": "NS", "cluster": "C1", "count": 25, "fraction": 0.25}, + {"sample_id": "s3", "condition": "treated", "cluster": "C0", "count": 30, "fraction": 0.30}, + {"sample_id": "s3", "condition": "treated", "cluster": "C1", "count": 70, "fraction": 0.70}, + {"sample_id": "s4", "condition": "treated", "cluster": "C0", "count": 25, "fraction": 0.25}, + {"sample_id": "s4", "condition": "treated", "cluster": "C1", "count": 75, "fraction": 0.75}, + ] + ), + condition_distribution=pd.DataFrame( + [ + {"condition": "NS", "cluster": "C0", "count": 155, "fraction": 0.775, "replicate_n": 2}, + {"condition": "NS", "cluster": "C1", "count": 45, "fraction": 0.225, "replicate_n": 2}, + {"condition": "treated", "cluster": "C0", "count": 55, "fraction": 0.275, "replicate_n": 2}, + {"condition": "treated", "cluster": "C1", "count": 145, "fraction": 0.725, "replicate_n": 2}, + ] + ), distribution_change=None, - cluster_profiles=pd.DataFrame({"profile": [1.0]}), + cluster_profiles=pd.DataFrame(columns=["cluster", "count", "f0", "f1"]), region_summaries=None, - plot_data={"cluster_distribution_bar": {"kind": "bar"}}, + plot_data={}, figures={}, - metadata={"notes": "ok"}, + metadata={}, ) +def _make_shared_cluster_time_course_result() -> SharedClusterResult: + result = _make_shared_cluster_test_result() + result.assignments = pd.DataFrame( + { + "sample_id": ["t0_a", "t1_a", "t2_a"], + "condition": ["t0", "t1", "t2"], + "subject_id": ["p1", "p1", "p1"], + "cluster": ["C0", "C0", "C1"], + } + ) + result.cluster_distribution = pd.DataFrame( + [ + {"sample_id": "t0_a", "condition": "t0", "cluster": "C0", "count": 80, "fraction": 0.80}, + {"sample_id": "t0_a", "condition": "t0", "cluster": "C1", "count": 20, "fraction": 0.20}, + {"sample_id": "t1_a", "condition": "t1", "cluster": "C0", "count": 55, "fraction": 0.55}, + {"sample_id": "t1_a", "condition": "t1", "cluster": "C1", "count": 45, "fraction": 0.45}, + {"sample_id": "t2_a", "condition": "t2", "cluster": "C0", "count": 25, "fraction": 0.25}, + {"sample_id": "t2_a", "condition": "t2", "cluster": "C1", "count": 75, "fraction": 0.75}, + ] + ) + result.condition_distribution = pd.DataFrame( + [ + {"condition": "t0", "cluster": "C0", "count": 80, "fraction": 0.80, "replicate_n": 1}, + {"condition": "t0", "cluster": "C1", "count": 20, "fraction": 0.20, "replicate_n": 1}, + {"condition": "t1", "cluster": "C0", "count": 55, "fraction": 0.55, "replicate_n": 1}, + {"condition": "t1", "cluster": "C1", "count": 45, "fraction": 0.45, "replicate_n": 1}, + {"condition": "t2", "cluster": "C0", "count": 25, "fraction": 0.25, "replicate_n": 1}, + {"condition": "t2", "cluster": "C1", "count": 75, "fraction": 0.75, "replicate_n": 1}, + ] + ) + return result + + def test_shared_cluster_tests_module_exports_entry_point(): from dimelo import shared_cluster_tests @@ -49,3 +106,113 @@ def test_shared_cluster_tests_rejects_unsupported_contrast_mode(): background=["bg"], ), ) + + +def test_shared_cluster_tests_pairwise_returns_summary_details_and_plot_data(): + from dimelo import shared_cluster_tests + from dimelo.models import ContrastSpec + + result = shared_cluster_tests.shared_cluster_tests( + result=_make_shared_cluster_test_result(), + contrast=ContrastSpec(mode="pairwise", numerator=["treated"], denominator=["NS"]), + test="permutation", + n_permutations=50, + random_state=7, + ) + + assert set(result.summary.columns) >= { + "contrast_id", + "composition_effect_size", + "omnibus_p_value", + "top_cluster", + } + assert set(result.details.columns) >= { + "cluster", + "fraction", + "reference_fraction", + "delta_fraction", + "p_value", + "adjusted_p_value", + } + assert set(result.plot_data) >= {"summary_table", "cluster_effect_table"} + + +def test_shared_cluster_tests_matched_pairwise_uses_contrast_pairing_key(): + from dimelo import shared_cluster_tests + from dimelo.models import ContrastSpec + + result = shared_cluster_tests.shared_cluster_tests( + result=_make_shared_cluster_test_result(), + contrast=ContrastSpec( + mode="matched_pairwise", + numerator=["treated"], + denominator=["NS"], + pairing_key="subject_id", + ), + test="permutation", + n_permutations=50, + random_state=7, + ) + + assert result.metadata["paired"] is True + assert result.metadata["pairing_key"] == "subject_id" + + +def test_shared_cluster_tests_supports_chi_squared_screen(): + from dimelo import shared_cluster_tests + + result = shared_cluster_tests.shared_cluster_tests( + result=_make_shared_cluster_test_result(), + contrast=ContrastSpec(mode="pairwise", numerator=["treated"], denominator=["NS"]), + test="chi_squared", + ) + + assert result.metadata["inference_level"] == "pooled_screen" + assert result.summary.loc[0, "test"] == "chi_squared" + assert 0.0 <= result.summary.loc[0, "omnibus_p_value"] <= 1.0 + + +def test_shared_cluster_tests_supports_g_test_screen(): + from dimelo import shared_cluster_tests + + result = shared_cluster_tests.shared_cluster_tests( + result=_make_shared_cluster_test_result(), + contrast=ContrastSpec(mode="pairwise", numerator=["treated"], denominator=["NS"]), + test="g_test", + ) + + assert result.metadata["inference_level"] == "pooled_screen" + assert result.summary.loc[0, "test"] == "g_test" + assert 0.0 <= result.summary.loc[0, "omnibus_p_value"] <= 1.0 + + +def test_shared_cluster_tests_time_course_returns_omnibus_and_trend_outputs(): + from dimelo import shared_cluster_tests + + result = shared_cluster_tests.shared_cluster_tests( + result=_make_shared_cluster_time_course_result(), + contrast=ContrastSpec(mode="time_course", time_order=["t0", "t1", "t2"]), + test="permutation", + n_permutations=50, + random_state=7, + ) + + assert {"omnibus_p_value", "trend_p_value", "composition_effect_size"} <= set( + result.summary.columns + ) + assert "time_course_table" in result.plot_data + + +def test_shared_cluster_tests_time_course_optional_pairwise_follow_up(): + from dimelo import shared_cluster_tests + + result = shared_cluster_tests.shared_cluster_tests( + result=_make_shared_cluster_time_course_result(), + contrast=ContrastSpec(mode="time_course", time_order=["t0", "t1", "t2"]), + test="permutation", + include_pairwise=True, + n_permutations=20, + random_state=7, + ) + + assert result.pairwise is not None From 7ecdacb097029a1ead42f312e30c38429c501761 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 14 Apr 2026 15:31:08 -0700 Subject: [PATCH 265/272] feat: advance clustering, parser, loader, and workflow reliability --- .gitignore | 2 + dimelo/cluster.py | 138 ++- dimelo/global_analysis.py | 71 +- dimelo/load_processed.py | 1369 +++++++++++++++------------- dimelo/parse_bam.py | 1294 +++++++++++++++++--------- dimelo/plot_read_browser.py | 135 ++- dimelo/plotting.py | 39 +- dimelo/region_analysis.py | 151 ++- dimelo/region_discovery.py | 49 +- dimelo/shared_cluster_tests.py | 54 +- dimelo/utils.py | 50 +- dimelo/workflows.py | 77 +- tests/test_cluster.py | 22 +- tests/test_global_analysis.py | 97 +- tests/test_load_processed.py | 405 ++++++++ tests/test_parse_bam.py | 444 +++++++-- tests/test_plot_read_browser.py | 132 +++ tests/test_region_analysis.py | 107 +++ tests/test_shared_cluster_tests.py | 27 + 19 files changed, 3285 insertions(+), 1378 deletions(-) create mode 100644 tests/test_load_processed.py create mode 100644 tests/test_plot_read_browser.py create mode 100644 tests/test_region_analysis.py diff --git a/.gitignore b/.gitignore index f6236ed..f8245de 100644 --- a/.gitignore +++ b/.gitignore @@ -62,3 +62,5 @@ dimelo/test/output # Checkpoint files .ipynb_checkpoints/ +# Local worktrees +.worktrees/ diff --git a/dimelo/cluster.py b/dimelo/cluster.py index f750724..e3fe01f 100644 --- a/dimelo/cluster.py +++ b/dimelo/cluster.py @@ -91,6 +91,7 @@ def region_feature_matrix_from_pileup( split_large_regions: bool = False, quiet: bool = False, cores: int | None = None, + regions_executor=None, ) -> tuple[np.ndarray, list[RegionMetadata]]: """ Convert every region in a pileup into a vector of modification fractions suitable for clustering. @@ -119,32 +120,35 @@ def region_feature_matrix_from_pileup( raise ValueError("regions must be provided when building a clustering matrix.") regions_dict = utils.regions_dict_from_input(regions, window_size) - region_metadata = [ - (chromosome, start, end, strand) - for chromosome, region_list in regions_dict.items() - for start, end, strand in region_list - ] + region_metadata: list[RegionMetadata] = [] + region_strings: list[str] = [] + for chromosome, region_list in regions_dict.items(): + for start, end, strand in region_list: + region_metadata.append((chromosome, start, end, strand)) + region_strings.append(f"{chromosome}:{start}-{end},{strand}") if len(region_metadata) == 0: raise ValueError("No regions were found to build clustering features.") loader = partial( - load_processed.pileup_vectors_from_bedmethyl, + _pileup_fraction_vector_from_bedmethyl, bedmethyl_file=bedmethyl_file, motif=motif, window_size=window_size, single_strand=single_strand, regions_5to3prime=regions_5to3prime, + pseudo_count=pseudo_count, quiet=quiet, cores=cores, chunk_size=chunk_size, ) per_region_vectors = load_processed.regions_to_list( function_handle=loader, - regions=regions, + regions=region_strings, window_size=window_size, quiet=quiet, cores=cores, split_large_regions=split_large_regions, + executor=regions_executor, ) if len(per_region_vectors) != len(region_metadata): @@ -155,33 +159,75 @@ def region_feature_matrix_from_pileup( feature_vectors = [] expected_length: int | None = None - for modified_vec, valid_vec in per_region_vectors: - modified = np.asarray(modified_vec, dtype=np.float64) - valid = np.asarray(valid_vec, dtype=np.float64) - if modified.shape != valid.shape: - raise ValueError("Modified and valid vectors must have matching shapes.") + for vector in per_region_vectors: + # Backward-compatible path if upstream loaders still return (modified, valid). + if isinstance(vector, tuple) and len(vector) == 2: + modified = np.asarray(vector[0], dtype=np.float32) + valid = np.asarray(vector[1], dtype=np.float32) + if modified.shape != valid.shape: + raise ValueError("Modified and valid vectors must have matching shapes.") + denominator = valid + (2 * pseudo_count) + with np.errstate(divide="ignore", invalid="ignore"): + fraction = np.divide( + modified + pseudo_count, + denominator, + out=np.zeros_like(modified), + where=denominator > 0, + ) + else: + fraction = np.asarray(vector, dtype=np.float32) + if expected_length is None: - expected_length = modified.shape[0] - elif modified.shape[0] != expected_length: + expected_length = fraction.shape[0] + elif fraction.shape[0] != expected_length: raise ValueError( "All regions must have the same length. " "Pass window_size to enforce length-matched regions." ) - - denominator = valid + (2 * pseudo_count) - with np.errstate(divide="ignore", invalid="ignore"): - fraction = np.divide( - modified + pseudo_count, - denominator, - out=np.zeros_like(modified), - where=denominator > 0, - ) feature_vectors.append(fraction) - feature_matrix = np.vstack(feature_vectors) + feature_matrix = np.vstack(feature_vectors).astype(np.float32, copy=False) return feature_matrix, region_metadata +def _pileup_fraction_vector_from_bedmethyl( + *, + bedmethyl_file: str | Path, + motif: str, + regions: str | Path | list[str | Path], + window_size: int | None = None, + single_strand: bool = False, + regions_5to3prime: bool = False, + pseudo_count: float = 1e-3, + quiet: bool = False, + cores: int | None = None, + chunk_size: int = load_processed.DEFAULT_CHUNK_SIZE, +) -> np.ndarray: + modified_vec, valid_vec = load_processed.pileup_vectors_from_bedmethyl( + bedmethyl_file=bedmethyl_file, + motif=motif, + regions=regions, + window_size=window_size, + single_strand=single_strand, + regions_5to3prime=regions_5to3prime, + quiet=quiet, + cores=cores, + chunk_size=chunk_size, + ) + modified = np.asarray(modified_vec, dtype=np.float32) + valid = np.asarray(valid_vec, dtype=np.float32) + if modified.shape != valid.shape: + raise ValueError("Modified and valid vectors must have matching shapes.") + denominator = valid + (2 * pseudo_count) + with np.errstate(divide="ignore", invalid="ignore"): + return np.divide( + modified + pseudo_count, + denominator, + out=np.zeros_like(modified), + where=denominator > 0, + ) + + def read_mod_fraction_table( hdf5_file: str | Path, motifs: Sequence[str], @@ -1613,19 +1659,45 @@ def _smooth(M: np.ndarray) -> np.ndarray: # Filter by beds if provided keep_idx = np.arange(len(meta)) if bed_filters: - keep_mask = [] - for i, m in enumerate(meta): + interval_rows = [] + for idx, m in enumerate(meta): try: chrom = m.get("chromosome") - rs = int(m.get("region_start", -1)) - re = int(m.get("region_end", -1)) + start_bp = int(m.get("region_start", -1)) + end_bp = int(m.get("region_end", -1)) except Exception: - keep_mask.append(False) continue - pr_row = pr.PyRanges(pd.DataFrame({"Chromosome": [chrom], "Start": [rs], "End": [re]})) - ok = all(len(pr_row.join(bf)) > 0 for bf in bed_filters) - keep_mask.append(ok) - keep_idx = np.flatnonzero(keep_mask) + if chrom is None or start_bp < 0 or end_bp <= start_bp: + continue + interval_rows.append( + { + "read_idx": idx, + "Chromosome": chrom, + "Start": start_bp, + "End": end_bp, + } + ) + + if interval_rows: + intervals = pd.DataFrame(interval_rows) + candidate_indices = intervals["read_idx"].to_numpy(dtype=int) + for bed_filter in bed_filters: + if candidate_indices.size == 0: + break + candidate_df = intervals.loc[ + intervals["read_idx"].isin(candidate_indices), + ["read_idx", "Chromosome", "Start", "End"], + ] + joined = pr.PyRanges(candidate_df).join(bed_filter) + if joined.df.empty: + candidate_indices = np.array([], dtype=int) + break + candidate_indices = joined.df["read_idx"].drop_duplicates().to_numpy(dtype=int) + + keep_idx = np.sort(candidate_indices) + else: + keep_idx = np.array([], dtype=int) + X = X[keep_idx] meta = [meta[i] for i in keep_idx] diff --git a/dimelo/global_analysis.py b/dimelo/global_analysis.py index e489e58..ad0c12f 100644 --- a/dimelo/global_analysis.py +++ b/dimelo/global_analysis.py @@ -11,36 +11,62 @@ from .models import GlobalAnalysisResult, SampleSpec -def _global_counts_from_bedmethyl( +def _global_counts_for_motifs_from_bedmethyl( bedmethyl_file: str | Path, - motif: str, + motifs: Sequence[str], quiet: bool = True, -) -> tuple[int, int]: +) -> dict[str, tuple[int, int]]: """ - Sum modified and valid pileup counts across all contigs for one motif. + Sum modified and valid pileup counts across all contigs for all motifs in one pass. """ del quiet - parsed_motif = utils.ParsedMotif(motif) - modified_count = 0 - valid_count = 0 + unique_motifs = list(dict.fromkeys(motifs)) + if len(unique_motifs) == 0: + return {} + + parsed_motifs = { + motif: utils.ParsedMotif(motif) for motif in unique_motifs + } + counts_by_motif = {motif: [0, 0] for motif in unique_motifs} with pysam.TabixFile(str(bedmethyl_file)) as tabix_file: for contig in tabix_file.contigs: for row in tabix_file.fetch(contig): - keep_basemod, _, modified_in_row, valid_in_row = ( - load_processed.process_pileup_row( - row=row, - parsed_motif=parsed_motif, - region_strand=".", + for motif, parsed_motif in parsed_motifs.items(): + keep_basemod, _, modified_in_row, valid_in_row = ( + load_processed.process_pileup_row( + row=row, + parsed_motif=parsed_motif, + region_strand=".", + ) ) - ) - if keep_basemod: - modified_count += modified_in_row - valid_count += valid_in_row + if keep_basemod: + counts_by_motif[motif][0] += modified_in_row + counts_by_motif[motif][1] += valid_in_row - return modified_count, valid_count + return { + motif: (modified_count, valid_count) + for motif, (modified_count, valid_count) in counts_by_motif.items() + } + + +def _global_counts_from_bedmethyl( + bedmethyl_file: str | Path, + motif: str, + quiet: bool = True, +) -> tuple[int, int]: + """ + Sum modified and valid pileup counts across all contigs for one motif. + """ + + counts_by_motif = _global_counts_for_motifs_from_bedmethyl( + bedmethyl_file=bedmethyl_file, + motifs=[motif], + quiet=quiet, + ) + return counts_by_motif[motif] def summarize_global_samples( @@ -61,12 +87,13 @@ def summarize_global_samples( ) pileup_path = sample.metadata["pileup_path"] + counts_by_motif = _global_counts_for_motifs_from_bedmethyl( + bedmethyl_file=pileup_path, + motifs=motifs, + quiet=quiet, + ) for motif in motifs: - modified_count, valid_count = _global_counts_from_bedmethyl( - bedmethyl_file=pileup_path, - motif=motif, - quiet=quiet, - ) + modified_count, valid_count = counts_by_motif[motif] rows.append( { "sample_id": sample.sample_id, diff --git a/dimelo/load_processed.py b/dimelo/load_processed.py index 5504748..176e819 100644 --- a/dimelo/load_processed.py +++ b/dimelo/load_processed.py @@ -1,7 +1,7 @@ import concurrent.futures import gzip import multiprocessing -from collections import defaultdict +import os from functools import partial from multiprocessing import shared_memory from pathlib import Path @@ -20,192 +20,14 @@ # on 32 cores is fairly similar, but sitting in the middle of the range should support 10x more cores (beyond # the reasonable upper bound) and 10x fewer cores (which is about the reasonable lower bound). DEFAULT_CHUNK_SIZE = 1_000_000 - - -def _subset_indices( - indices: np.ndarray, - subset_parameters: dict | None, -) -> np.ndarray: - if subset_parameters is None: - return indices - if len(indices) == 0: - return np.array([], dtype=int) - return np.sort(utils.random_sample(indices, **subset_parameters)) - - -def _region_job_to_read_indices( - region_job: tuple[str, int, int, str], - *, - read_chromosomes: np.ndarray, - read_starts: np.ndarray, - read_ends: np.ndarray, - read_motifs: np.ndarray, - ref_strands: np.ndarray, - motifs: list[str], - single_strand: bool, - span_full_window: bool, -) -> np.ndarray: - chrom, region_start, region_end, region_strand = region_job - return np.flatnonzero( - (read_ends > region_start) - & (read_starts < region_end) - & (read_starts <= region_start if span_full_window else True) - & (read_ends >= region_end if span_full_window else True) - & np.isin(read_motifs, motifs) - & (read_chromosomes == chrom) - & ( - (not single_strand) - | (region_strand not in ["+", "-"]) - | (ref_strands == region_strand) - ) - ) - - -def _readwise_mod_positions_for_read( - *, - read_int: int, - read_data: tuple, - mod_vector_index: int, - motif_index: int, - region_start_index: int, - region_end_index: int, - read_start_index: int, - region_strand_index: int, - thresh: float | None, - relative: bool, - regions_5to3prime: bool, -) -> tuple[list[int], list[int], list[str]]: - if thresh is None: - mod_pos_in_read = np.flatnonzero(read_data[mod_vector_index]) - else: - mod_pos_in_read = np.flatnonzero(read_data[mod_vector_index] > thresh) - - if relative: - if regions_5to3prime and read_data[region_strand_index] == "-": - # Here we want to show the regions each along their 5 prime to 3 prime direction - # This means that negative strand regions need to be flipped - mod_pos_record = -( - mod_pos_in_read - + read_data[read_start_index] - - (read_data[region_start_index] + read_data[region_end_index]) // 2 - ) - else: - # This is the default case: just make the coordinates relative using - # the reference genome coordinate system. Normal, easy, chill, nice. - mod_pos_record = ( - mod_pos_in_read - + read_data[read_start_index] - - (read_data[region_start_index] + read_data[region_end_index]) // 2 - ) - else: - # If we aren't using relative coordinates, then I think the 5prime to 3prime argument - # can just be ignored, and I think it's nicer if that's silent - less clutter in the output - # Basically if you are keeping different regions separate using other metadata (such as - # just keeping their actual real genomic coordinates) it is superfluous to do the 5to3 flip. - mod_pos_record = mod_pos_in_read + read_data[read_start_index] - - n_positions = len(mod_pos_record) - return ( - list(mod_pos_record), - [read_int] * n_positions, - [read_data[motif_index]] * n_positions, - ) - - -def _readwise_mod_positions_from_payload(payload: dict) -> tuple[list[int], list[int], list[str]]: - return _readwise_mod_positions_for_read(**payload) - - -def _validate_subset_parameters(subset_parameters: dict | None) -> None: - if subset_parameters is None: - return - if not isinstance(subset_parameters, dict): - raise ValueError("subset_parameters must be provided as a dictionary.") - if "array" in subset_parameters: - raise ValueError( - "subset_parameters cannot include 'array'; it is provided internally." - ) - if "n" not in subset_parameters and "frac" not in subset_parameters: - raise ValueError( - "subset_parameters must include at least one of 'n' or 'frac'." - ) - - -def _load_read_tuples_for_indices( - *, - h5: h5py.File, - readwise_datasets: list[str], - compressed_binary_datasets: list[str], - binarized: bool, - relevant_read_indices: np.ndarray, - region_start: int, - region_end: int, - region_strand: str, -) -> list[tuple]: - n_reads = len(relevant_read_indices) - return list( - zip( - *( - retrieve_h5_data( - h5=h5, - dataset=dataset, - indices=relevant_read_indices, - compressed=dataset in compressed_binary_datasets, - dtype=np.uint8, - decompressor=gzip.decompress, - binarized=binarized, - ) - for dataset in readwise_datasets - ), - [region_start] * n_reads, - [region_end] * n_reads, - [region_strand] * n_reads, - ) - ) - - -def _normalize_sort_by( - sort_by: str | tuple[str, str] | list[str | tuple[str, str]], -) -> list[tuple[str, str]]: - if not isinstance(sort_by, list): - sort_by = [sort_by] - - sort_by_normalized: list[tuple[str, str]] = [] - for item in sort_by: - if isinstance(item, tuple): - field, order = item - if order not in ["asc", "desc"]: - raise ValueError( - f"Sort order must be 'asc' or 'desc', got '{order}' for field '{field}'" - ) - sort_by_normalized.append((field, order)) - else: - sort_by_normalized.append((item, "asc")) - return sort_by_normalized - - -def _assign_region_scoped_read_ints( - *, - read_data: list[tuple], - read_name_index: int, - region_start_index: int, - region_end_index: int, - region_strand_index: int, -) -> np.ndarray: - read_identity_to_int: dict[tuple, int] = {} - read_ints: list[int] = [] - for row in read_data: - read_identity = ( - row[read_name_index], - row[region_start_index], - row[region_end_index], - row[region_strand_index], - ) - if read_identity not in read_identity_to_int: - read_identity_to_int[read_identity] = len(read_identity_to_int) - read_ints.append(read_identity_to_int[read_identity]) - return np.array(read_ints) - +AUTO_PARALLEL_MIN_TASKS = 64 +AUTO_PARALLEL_TASKS_PER_CORE = 16 +AUTO_PARALLEL_BATCHES_PER_WORKER = 8 +AUTO_PARALLEL_CHUNKS_PER_TASK = 8 +AUTO_PARALLEL_MEMORY_FRACTION = 0.5 +AUTO_PARALLEL_PROCESS_OVERHEAD_BYTES = 64 * 1024 * 1024 +_CGROUP_MEMORY_SENTINEL_LIMIT = 1 << 60 +_TABIX_CACHE: dict[str, pysam.TabixFile] = {} ################################################################################################################ #### Loader wrappers #### @@ -219,6 +41,7 @@ def regions_to_list( quiet: bool = True, cores: int | None = None, split_large_regions: bool = False, + executor: concurrent.futures.Executor | None = None, **kwargs, ): """ @@ -256,37 +79,73 @@ def regions_to_list( for start, end, strand in region_list ] - cores_to_run = utils.cores_to_run(cores) + cores_to_run = _resolve_cores_for_task_count( + requested_cores=cores, + task_count=len(region_strings), + ) # quiet and cores logic below is driven by the following: # If the parallelization is within regions: # (1) progress bars should happen within regions if at all, because we assume regions are # large if they make sense to parallelize # (2) the cores_to_run will be allocated to within-region parallelization, and the top-level # jobs sequence is run sequentially - with concurrent.futures.ProcessPoolExecutor( - max_workers=1 if split_large_regions else cores_to_run - ) as executor: - # Use functools.partial to pre-fill arguments + # For single-core, avoid process-pool startup and run regions directly. + if not split_large_regions and cores_to_run == 1: process_partial = partial( apply_loader_function_to_region, function_handle=function_handle, - quiet=quiet or not split_large_regions, - cores=cores_to_run - if split_large_regions - else 1, # if parallelization is within region + quiet=quiet, + cores=1, **kwargs, ) - results = list( + return list( tqdm( - executor.map(process_partial, region_strings), + map(process_partial, region_strings), total=len(region_strings), desc="Loading data", - disable=quiet or split_large_regions, + disable=quiet, leave=False, ) ) - return results + process_partial = partial( + apply_loader_function_to_region_batch, + function_handle=function_handle, + quiet=quiet or not split_large_regions, + cores=cores_to_run + if split_large_regions + else 1, # if parallelization is within region + **kwargs, + ) + + # Keep enough tasks per worker to amortize process overhead on large region lists. + if split_large_regions: + batch_size = 1 + else: + target_batches = max(1, cores_to_run * AUTO_PARALLEL_BATCHES_PER_WORKER) + batch_size = max(1, len(region_strings) // target_batches) + region_batches = list(_iter_batches(region_strings, batch_size=batch_size)) + + def _collect(mapped_batches) -> list: + return [ + item + for batch in tqdm( + mapped_batches, + total=len(region_batches), + desc="Loading data", + disable=quiet or split_large_regions, + leave=False, + ) + for item in batch + ] + + if executor is not None and not split_large_regions: + return _collect(executor.map(process_partial, region_batches)) + + with concurrent.futures.ProcessPoolExecutor( + max_workers=1 if split_large_regions else cores_to_run + ) as local_executor: + return _collect(local_executor.map(process_partial, region_batches)) def apply_loader_function_to_region(region_string, function_handle, **kwargs): @@ -304,6 +163,278 @@ def apply_loader_function_to_region(region_string, function_handle, **kwargs): return function_handle(regions=region_string, **kwargs) +def apply_loader_function_to_region_batch(region_batch, function_handle, **kwargs): + return [function_handle(regions=region_string, **kwargs) for region_string in region_batch] + + +def _iter_batches(items: list[str], *, batch_size: int): + for idx in range(0, len(items), batch_size): + yield items[idx : idx + batch_size] + + +def _parallel_chunk_batch_size(*, task_count: int, workers: int) -> int: + target_tasks = max(1, workers * AUTO_PARALLEL_CHUNKS_PER_TASK) + return max(1, task_count // target_tasks) + + +def _get_tabix_file(path: str | Path) -> pysam.TabixFile: + key = str(path) + cached = _TABIX_CACHE.get(key) + if cached is None: + cached = pysam.TabixFile(key) + _TABIX_CACHE[key] = cached + return cached + + +def _clear_tabix_cache() -> None: + _TABIX_CACHE.clear() + + +def _resolve_cores_for_task_count(*, requested_cores: int | None, task_count: int) -> int: + """ + Resolve worker count for loader-style fanout. + + If cores are explicitly requested, honor that request. For automatic mode (cores=None), + avoid expensive multiprocessing startup for small task batches. + """ + resolved = utils.cores_to_run(requested_cores) + if requested_cores is not None: + return resolved + + cores_by_tasks = 1 + if task_count >= AUTO_PARALLEL_MIN_TASKS: + cores_by_tasks = max(1, task_count // AUTO_PARALLEL_TASKS_PER_CORE) + + return max(1, min(resolved, cores_by_tasks)) + + +def _parse_positive_int(value: str | None) -> int | None: + if value is None: + return None + text = str(value).strip() + if not text: + return None + digits = [] + for char in text: + if char.isdigit(): + digits.append(char) + else: + break + if not digits: + return None + parsed = int("".join(digits)) + return parsed if parsed > 0 else None + + +def _cgroup_memory_limit_bytes() -> int | None: + candidates: list[int] = [] + for candidate_path in ( + "/sys/fs/cgroup/memory.max", + "/sys/fs/cgroup/memory/memory.limit_in_bytes", + ): + try: + value = Path(candidate_path).read_text(encoding="utf-8").strip() + except Exception: + continue + if not value or value.lower() == "max": + continue + parsed = _parse_positive_int(value) + if parsed is None or parsed >= _CGROUP_MEMORY_SENTINEL_LIMIT: + continue + candidates.append(parsed) + if not candidates: + return None + return min(candidates) + + +def _slurm_memory_limit_bytes() -> int | None: + mem_per_node_mb = _parse_positive_int(os.environ.get("SLURM_MEM_PER_NODE")) + mem_per_cpu_mb = _parse_positive_int(os.environ.get("SLURM_MEM_PER_CPU")) + cpus_per_task = _parse_positive_int(os.environ.get("SLURM_CPUS_PER_TASK")) + cpus_on_node = _parse_positive_int(os.environ.get("SLURM_CPUS_ON_NODE")) + + candidates: list[int] = [] + if mem_per_node_mb is not None: + candidates.append(mem_per_node_mb * 1024 * 1024) + if mem_per_cpu_mb is not None: + cpus = cpus_per_task or cpus_on_node + if cpus is not None: + candidates.append(mem_per_cpu_mb * cpus * 1024 * 1024) + + if not candidates: + return None + return min(candidates) + + +def _available_memory_bytes() -> int | None: + override = _parse_positive_int(os.environ.get("DIMELO_AVAILABLE_MEMORY_BYTES")) + if override is not None: + return override + + candidates: list[int] = [] + try: + import psutil # type: ignore + + candidates.append(int(psutil.virtual_memory().available)) + except Exception: + pass + + cgroup_limit = _cgroup_memory_limit_bytes() + if cgroup_limit is not None: + candidates.append(cgroup_limit) + + slurm_limit = _slurm_memory_limit_bytes() + if slurm_limit is not None: + candidates.append(slurm_limit) + + if not candidates: + return None + return min(candidates) + + +def _memory_limited_cores( + *, + requested_cores: int | None, + task_count: int, + bytes_per_task: int, + extra_shared_bytes: int = 0, +) -> int: + """ + Resolve worker count using CPU availability, task fanout, and available memory. + + Explicit cores override auto-tuning and are always returned unchanged. + """ + baseline = _resolve_cores_for_task_count( + requested_cores=requested_cores, + task_count=task_count, + ) + if requested_cores is not None: + return baseline + + available = _available_memory_bytes() + if available is None: + return baseline + + budget = int(available * AUTO_PARALLEL_MEMORY_FRACTION) - max(0, int(extra_shared_bytes)) + if budget <= 0: + return 1 + + per_worker = max(1, int(bytes_per_task)) + AUTO_PARALLEL_PROCESS_OVERHEAD_BYTES + memory_cap = max(1, budget // per_worker) + return max(1, min(baseline, memory_cap)) + + +def _pileup_counts_from_bedmethyl_single_core( + *, + bedmethyl_file: str | Path, + parsed_motif: utils.ParsedMotif, + chunks_list: list[dict], + single_strand: bool, + quiet: bool, +) -> tuple[int, int]: + """Single-process fallback used when only one core is requested.""" + source_tabix = _get_tabix_file(bedmethyl_file) + total_valid = 0 + total_modified = 0 + + for chunk in tqdm( + chunks_list, + total=len(chunks_list), + disable=quiet, + desc="Loading data", + leave=False, + ): + chromosome = chunk["chromosome"] + subregion_start = chunk["subregion_start"] + subregion_end = chunk["subregion_end"] + strand = chunk["strand"] + + if chromosome not in source_tabix.contigs: + continue + + for row in source_tabix.fetch(chromosome, max(subregion_start, 0), subregion_end): + keep_basemod, _, modified_in_row, valid_in_row = process_pileup_row( + row=row, + parsed_motif=parsed_motif, + region_strand=strand, + single_strand=single_strand, + ) + if keep_basemod: + total_valid += valid_in_row + total_modified += modified_in_row + + return total_modified, total_valid + + +def _pileup_vectors_from_bedmethyl_single_core( + *, + bedmethyl_file: str | Path, + parsed_motif: utils.ParsedMotif, + chunks_list: list[dict], + region_len: int, + single_strand: bool, + regions_5to3prime: bool, + quiet: bool, +) -> tuple[np.ndarray, np.ndarray]: + """Single-process fallback used when only one core is requested.""" + source_tabix = _get_tabix_file(bedmethyl_file) + valid_base_counts = np.zeros(region_len, dtype=np.int32) + modified_base_counts = np.zeros(region_len, dtype=np.int32) + + for chunk in tqdm( + chunks_list, + total=len(chunks_list), + disable=quiet, + desc="Loading data", + leave=False, + ): + chromosome = chunk["chromosome"] + region_start = chunk["region_start"] + region_end = chunk["region_end"] + subregion_start = chunk["subregion_start"] + subregion_end = chunk["subregion_end"] + strand = chunk["strand"] + + flip_coords = regions_5to3prime and strand == "-" + if flip_coords: + subregion_offset = region_end - subregion_end + else: + subregion_offset = subregion_start - region_start + + if region_end - region_start > region_len: + print( + f"WARNING: You have specified a region at {chromosome}:{region_start}-{region_end} that is longer than the first region; the end of the region will be skipped. To make a profile plot with differently-sized region, consider using the window_size parameter to make a profile across centered windows." + ) + + subregion_len = subregion_end - subregion_start + valid_base_subregion = np.zeros(subregion_len, dtype=np.int32) + modified_base_subregion = np.zeros(subregion_len, dtype=np.int32) + + if chromosome in source_tabix.contigs: + for row in source_tabix.fetch(chromosome, max(subregion_start, 0), subregion_end): + keep_basemod, genomic_coord, modified_in_row, valid_in_row = process_pileup_row( + row=row, + parsed_motif=parsed_motif, + region_strand=strand, + single_strand=single_strand, + ) + if keep_basemod: + if flip_coords: + pileup_coord_in_subregion = subregion_end - genomic_coord - 1 + else: + pileup_coord_in_subregion = genomic_coord - subregion_start + if pileup_coord_in_subregion < subregion_len: + valid_base_subregion[pileup_coord_in_subregion] += valid_in_row + modified_base_subregion[pileup_coord_in_subregion] += modified_in_row + + valid_base_counts[subregion_offset : subregion_offset + subregion_len] += valid_base_subregion + modified_base_counts[ + subregion_offset : subregion_offset + subregion_len + ] += modified_base_subregion + + return modified_base_counts, valid_base_counts + + ################################################################################################################ #### Pileup loaders #### ################################################################################################################ @@ -333,7 +464,7 @@ def pileup_counts_from_bedmethyl( If no regions are specified, returns the sum total for the motif of interest across the entire bedmethyl file. - Preferred alias: `counts_from_pileup`. + TODO: Consider renaming this method, e.g. counts_from_pileup Args: bedmethyl_file: Path to bedmethyl file @@ -357,32 +488,38 @@ def pileup_counts_from_bedmethyl( regions_dict, chunk_size=chunk_size ) - cores_to_run = utils.cores_to_run(cores) - - # Initialize shared memory as length-one numpy arrays to make it easy to map to buffer in subprocesses - shm_valid = shared_memory.SharedMemory( - create=True, size=np.dtype(np.int32).itemsize - ) - shm_modified = shared_memory.SharedMemory( - create=True, size=np.dtype(np.int32).itemsize + cores_to_run = _memory_limited_cores( + requested_cores=cores, + task_count=len(chunks_list), + bytes_per_task=0, ) - manager = multiprocessing.Manager() - lock = manager.Lock() + if cores_to_run == 1: + return _pileup_counts_from_bedmethyl_single_core( + bedmethyl_file=bedmethyl_file, + parsed_motif=parsed_motif, + chunks_list=chunks_list, + single_strand=single_strand, + quiet=quiet, + ) + batch_size = _parallel_chunk_batch_size( + task_count=len(chunks_list), + workers=cores_to_run, + ) + chunk_batches = list(_iter_batches(chunks_list, batch_size=batch_size)) + modified_base_count = 0 + valid_base_count = 0 with concurrent.futures.ProcessPoolExecutor(max_workers=cores_to_run) as executor: futures = [ executor.submit( - pileup_counts_process_chunk, + pileup_counts_process_chunk_batch_local, bedmethyl_file, parsed_motif, - chunk, - shm_modified.name, - shm_valid.name, - lock, + chunk_batch, single_strand, ) - for chunk in chunks_list + for chunk_batch in chunk_batches ] for future in tqdm( concurrent.futures.as_completed(futures), @@ -392,23 +529,12 @@ def pileup_counts_from_bedmethyl( leave=False, ): try: - future.result() + modified_in_batch, valid_in_batch = future.result() + modified_base_count += int(modified_in_batch) + valid_base_count += int(valid_in_batch) except Exception as err: raise RuntimeError("pileup_counts_process_chunk failed.") from err - # Directly convert shared memory buffers to integers - modified_base_count = int.from_bytes( - shm_modified.buf[:4], byteorder="little", signed=True - ) - valid_base_count = int.from_bytes( - shm_valid.buf[:4], byteorder="little", signed=True - ) - # Close and unlink shared memory - not fully handled by garbage collection otherwise - shm_modified.close() - shm_modified.unlink() - shm_valid.close() - shm_valid.unlink() - return modified_base_count, valid_base_count @@ -445,7 +571,7 @@ def pileup_vectors_from_bedmethyl( A region must be provided because otherwise there is no way to know what vector to return. However, a region can be a whole chromosome if desired. - Preferred alias: `vectors_from_pileup`. + TODO: Consider renaming this method, e.g. vectors_from_pileup Args: bedmethyl_file: Path to bedmethyl file @@ -469,14 +595,39 @@ def pileup_vectors_from_bedmethyl( chunks_list = utils.process_chunks_from_regions_dict( regions_dict, chunk_size=chunk_size ) - - cores_to_run = utils.cores_to_run(cores) - # Peek at a region to figure out what size the vectors should be first_key = next(iter(regions_dict)) first_tuple = regions_dict[first_key][0] region_len = first_tuple[1] - first_tuple[0] + max_chunk_span = max( + ( + max(0, int(chunk["subregion_end"]) - int(chunk["subregion_start"])) + for chunk in chunks_list + ), + default=0, + ) + per_worker_bytes = 2 * max_chunk_span * np.dtype(np.int32).itemsize + shared_bytes = 2 * region_len * np.dtype(np.int32).itemsize + cores_to_run = _memory_limited_cores( + requested_cores=cores, + task_count=len(chunks_list), + bytes_per_task=per_worker_bytes, + extra_shared_bytes=shared_bytes, + ) + + # Avoid process-pool/shared-memory startup overhead for single-core workloads. + if cores_to_run == 1: + return _pileup_vectors_from_bedmethyl_single_core( + bedmethyl_file=bedmethyl_file, + parsed_motif=parsed_motif, + chunks_list=chunks_list, + region_len=region_len, + single_strand=single_strand, + regions_5to3prime=regions_5to3prime, + quiet=quiet, + ) + # Initialize shared memory as numpy arrays to make it easy to map to buffer in subprocesses shm_valid = shared_memory.SharedMemory( create=True, size=(region_len) * np.dtype(np.int32).itemsize @@ -488,13 +639,18 @@ def pileup_vectors_from_bedmethyl( manager = multiprocessing.Manager() lock = manager.Lock() + batch_size = _parallel_chunk_batch_size( + task_count=len(chunks_list), + workers=cores_to_run, + ) + chunk_batches = list(_iter_batches(chunks_list, batch_size=batch_size)) with concurrent.futures.ProcessPoolExecutor(max_workers=cores_to_run) as executor: futures = [ executor.submit( - pileup_vectors_process_chunk, + pileup_vectors_process_chunk_batch, bedmethyl_file, parsed_motif, - chunk, + chunk_batch, region_len, shm_modified.name, shm_valid.name, @@ -502,7 +658,7 @@ def pileup_vectors_from_bedmethyl( single_strand, regions_5to3prime, ) - for chunk in chunks_list + for chunk_batch in chunk_batches ] for future in tqdm( concurrent.futures.as_completed(futures), @@ -534,58 +690,6 @@ def pileup_vectors_from_bedmethyl( return modified_base_counts, valid_base_counts -def counts_from_pileup( - bedmethyl_file: str | Path, - motif: str, - regions: str | Path | list[str | Path], - window_size: int | None = None, - single_strand: bool = False, - quiet: bool = False, - cores: int | None = None, - chunk_size: int = DEFAULT_CHUNK_SIZE, -) -> tuple[int, int]: - """ - Preferred alias for `pileup_counts_from_bedmethyl`. - """ - return pileup_counts_from_bedmethyl( - bedmethyl_file=bedmethyl_file, - motif=motif, - regions=regions, - window_size=window_size, - single_strand=single_strand, - quiet=quiet, - cores=cores, - chunk_size=chunk_size, - ) - - -def vectors_from_pileup( - bedmethyl_file: str | Path, - motif: str, - regions: str | Path | list[str | Path], - window_size: int | None = None, - single_strand: bool = False, - regions_5to3prime: bool = False, - quiet: bool = False, - cores: int | None = None, - chunk_size: int = DEFAULT_CHUNK_SIZE, -) -> tuple[np.ndarray, np.ndarray]: - """ - Preferred alias for `pileup_vectors_from_bedmethyl`. - """ - return pileup_vectors_from_bedmethyl( - bedmethyl_file=bedmethyl_file, - motif=motif, - regions=regions, - window_size=window_size, - single_strand=single_strand, - regions_5to3prime=regions_5to3prime, - quiet=quiet, - cores=cores, - chunk_size=chunk_size, - ) - - def counts_from_fake(*args, **kwargs) -> tuple[int, int]: """ Test helper function. @@ -627,34 +731,28 @@ def pileup_vectors_process_chunk( single_strand, regions_5to3prime, ) -> None: - """ - Helper function to allow pileup_vectors_from_bedmethyl to operate in a parallized fashion. - - Sum up modified and valid counts for a subregion chunk in a bedmethyl file. - - Args: - bedmethyl_file: Path to bedmethyl file - parsed_motif: ParsedMotif object - chunk: a dict containing subregion chunk information - shm_name_modified: the name string for the shared memory location containing the modified counts array - shm_name_valid: the name string for the shared memory location containing the valid counts array - lock: a manager.Lock object to allow synchronization in accessing shared memory - single_strand: True if only single-strand mods are desired - regions_5to3prime: True means negative strand regions get flipped, False means no flipping - - Returns: - None. Counts are added to arrays in-place to shared memory. - """ - source_tabix = pysam.TabixFile(str(bedmethyl_file)) - existing_valid = shared_memory.SharedMemory(name=shm_name_valid) - existing_modified = shared_memory.SharedMemory(name=shm_name_modified) - valid_base_counts = np.ndarray( - (region_len,), dtype=np.int32, buffer=existing_valid.buf - ) - modified_base_counts = np.ndarray( - (region_len,), dtype=np.int32, buffer=existing_modified.buf + pileup_vectors_process_chunk_batch( + bedmethyl_file=bedmethyl_file, + parsed_motif=parsed_motif, + chunk_batch=[chunk], + region_len=region_len, + shm_name_modified=shm_name_modified, + shm_name_valid=shm_name_valid, + lock=lock, + single_strand=single_strand, + regions_5to3prime=regions_5to3prime, ) + +def _pileup_vectors_local_contribution( + *, + source_tabix: pysam.TabixFile, + parsed_motif: utils.ParsedMotif, + chunk: dict, + region_len: int, + single_strand: bool, + regions_5to3prime: bool, +) -> tuple[int, np.ndarray, np.ndarray] | None: chromosome = chunk["chromosome"] region_start = chunk["region_start"] region_end = chunk["region_end"] @@ -663,7 +761,6 @@ def pileup_vectors_process_chunk( strand = chunk["strand"] flip_coords = regions_5to3prime and strand == "-" - if flip_coords: subregion_offset = region_end - subregion_end else: @@ -674,122 +771,140 @@ def pileup_vectors_process_chunk( f"WARNING: You have specified a region at {chromosome}:{region_start}-{region_end} that is longer than the first region; the end of the region will be skipped. To make a profile plot with differently-sized region, consider using the window_size parameter to make a profile across centered windows." ) - valid_base_subregion = np.zeros(subregion_end - subregion_start, dtype=int) - modified_base_subregion = np.zeros(subregion_end - subregion_start, dtype=int) + subregion_span = subregion_end - subregion_start + valid_base_subregion = np.zeros(subregion_span, dtype=np.int32) + modified_base_subregion = np.zeros(subregion_span, dtype=np.int32) - # tabix throws and error if the contig is not present - # by the current design, this should be silent - if chromosome in source_tabix.contigs: - for row in source_tabix.fetch( - chromosome, max(subregion_start, 0), subregion_end - ): - ( - keep_basemod, - genomic_coord, - modified_in_row, - valid_in_row, - ) = process_pileup_row( - row=row, - parsed_motif=parsed_motif, - region_strand=strand, - single_strand=single_strand, - ) - if keep_basemod: - if flip_coords: - # We want to flip the coordinates for this region so that it is recorded along the 5 prime to 3 prime direction - # This will enable analyses where the orientation of protein binding / transcriptional dynamics / etc is relevant for our pileup signal - pileup_coord_in_subregion = subregion_end - genomic_coord - 1 - else: - # Normal coordinates are the default. This will be used both for the '+' case and the '.' (no strand specified) case - pileup_coord_in_subregion = genomic_coord - subregion_start - if pileup_coord_in_subregion < (subregion_end - subregion_start): - valid_base_subregion[pileup_coord_in_subregion] += valid_in_row - modified_base_subregion[pileup_coord_in_subregion] += ( - modified_in_row - ) + if chromosome not in source_tabix.contigs: + return subregion_offset, valid_base_subregion, modified_base_subregion - with lock: - valid_base_counts[ - subregion_offset : subregion_offset + abs(subregion_end - subregion_start) - ] += valid_base_subregion - modified_base_counts[ - subregion_offset : subregion_offset + abs(subregion_end - subregion_start) - ] += modified_base_subregion - # Close the file descriptor/handle to the shared memory - existing_modified.close() - existing_valid.close() + for row in source_tabix.fetch(chromosome, max(subregion_start, 0), subregion_end): + keep_basemod, genomic_coord, modified_in_row, valid_in_row = process_pileup_row( + row=row, + parsed_motif=parsed_motif, + region_strand=strand, + single_strand=single_strand, + ) + if not keep_basemod: + continue + if flip_coords: + pileup_coord_in_subregion = subregion_end - genomic_coord - 1 + else: + pileup_coord_in_subregion = genomic_coord - subregion_start + if pileup_coord_in_subregion < subregion_span: + valid_base_subregion[pileup_coord_in_subregion] += valid_in_row + modified_base_subregion[pileup_coord_in_subregion] += modified_in_row + return subregion_offset, valid_base_subregion, modified_base_subregion -def pileup_counts_process_chunk( + +def pileup_vectors_process_chunk_batch( bedmethyl_file, parsed_motif, - chunk, + chunk_batch, + region_len, shm_name_modified, shm_name_valid, lock, single_strand, + regions_5to3prime, ) -> None: """ - Helper function to allow pileup_counts_from_bedmethyl to operate in a parallized fashion. + Worker helper that processes a batch of chunks and acquires the shared-memory lock once. + """ + source_tabix = _get_tabix_file(bedmethyl_file) + existing_valid = shared_memory.SharedMemory(name=shm_name_valid) + existing_modified = shared_memory.SharedMemory(name=shm_name_modified) + valid_base_counts = np.ndarray((region_len,), dtype=np.int32, buffer=existing_valid.buf) + modified_base_counts = np.ndarray((region_len,), dtype=np.int32, buffer=existing_modified.buf) + + updates: list[tuple[int, np.ndarray, np.ndarray]] = [] + for chunk in chunk_batch: + contribution = _pileup_vectors_local_contribution( + source_tabix=source_tabix, + parsed_motif=parsed_motif, + chunk=chunk, + region_len=region_len, + single_strand=single_strand, + regions_5to3prime=regions_5to3prime, + ) + if contribution is not None: + updates.append(contribution) + + if updates: + with lock: + for subregion_offset, valid_base_subregion, modified_base_subregion in updates: + subregion_span = len(valid_base_subregion) + valid_base_counts[subregion_offset : subregion_offset + subregion_span] += ( + valid_base_subregion + ) + modified_base_counts[ + subregion_offset : subregion_offset + subregion_span + ] += modified_base_subregion - Sum up modified and valid counts for a subregion chunk in a bedmethyl file. + existing_modified.close() + existing_valid.close() - Args: - bedmethyl_file: Path to bedmethyl file - parsed_motif: ParsedMotif object - chunk: a dict containing subregion chunk information - shm_name_modified: the name string for the shared memory location containing the modified counts sum - shm_name_valid: the name string for the shared memory location containing the valid counts sum - lock: a manager.Lock object to allow synchronization in accessing shared memory - single_strand: True if only single-strand mods are desired - Returns: - None. Counts are added in-place to shared memory. - """ - source_tabix = pysam.TabixFile(str(bedmethyl_file)) +def pileup_counts_process_chunk( + bedmethyl_file, + parsed_motif, + chunk, + shm_name_modified, + shm_name_valid, + lock, + single_strand, +) -> None: + modified_subregion_counts, valid_subregion_counts = pileup_counts_process_chunk_batch_local( + bedmethyl_file=bedmethyl_file, + parsed_motif=parsed_motif, + chunk_batch=[chunk], + single_strand=single_strand, + ) existing_valid = shared_memory.SharedMemory(name=shm_name_valid) existing_modified = shared_memory.SharedMemory(name=shm_name_modified) valid_base_counts = np.ndarray((1,), dtype=np.int32, buffer=existing_valid.buf) - modified_base_counts = np.ndarray( - (1,), dtype=np.int32, buffer=existing_modified.buf - ) - - chromosome = chunk["chromosome"] - subregion_start = chunk["subregion_start"] - subregion_end = chunk["subregion_end"] - strand = chunk["strand"] + modified_base_counts = np.ndarray((1,), dtype=np.int32, buffer=existing_modified.buf) + with lock: + valid_base_counts[0] += valid_subregion_counts + modified_base_counts[0] += modified_subregion_counts + existing_valid.close() + existing_modified.close() - valid_base_subregion_counts = 0 - modified_base_subregion_counts = 0 - # tabix throws and error if the contig is not present - # by the current design, this should be silent - if chromosome in source_tabix.contigs: - for row in source_tabix.fetch( - chromosome, max(subregion_start, 0), subregion_end - ): - ( - keep_basemod, - _, - modified_in_row, - valid_in_row, - ) = process_pileup_row( +def pileup_counts_process_chunk_batch_local( + bedmethyl_file, + parsed_motif, + chunk_batch, + single_strand, +) -> tuple[int, int]: + """ + Worker helper for counts mode that accumulates locally and returns one tuple per batch. + """ + source_tabix = _get_tabix_file(bedmethyl_file) + valid_total = 0 + modified_total = 0 + + for chunk in chunk_batch: + chromosome = chunk["chromosome"] + subregion_start = chunk["subregion_start"] + subregion_end = chunk["subregion_end"] + strand = chunk["strand"] + + if chromosome not in source_tabix.contigs: + continue + for row in source_tabix.fetch(chromosome, max(subregion_start, 0), subregion_end): + keep_basemod, _, modified_in_row, valid_in_row = process_pileup_row( row=row, parsed_motif=parsed_motif, region_strand=strand, single_strand=single_strand, ) if keep_basemod: - valid_base_subregion_counts += valid_in_row - modified_base_subregion_counts += modified_in_row - - with lock: - valid_base_counts[0] += valid_base_subregion_counts - modified_base_counts[0] += modified_base_subregion_counts + valid_total += valid_in_row + modified_total += modified_in_row - # Close the file descriptor/handle to the shared memory - existing_valid.close() - existing_modified.close() + return modified_total, valid_total def process_pileup_row( @@ -816,39 +931,35 @@ def process_pileup_row( """ tabix_fields = row.split("\t") pileup_basemod = tabix_fields[3] - pileup_strand = tabix_fields[5] - - if single_strand and pileup_strand.strip() != region_strand: - # We are on the wrong strand, can't keep this position - keep_basemod = False - elif len(pileup_basemod.split(",")) == 3: - pileup_modname, pileup_motif, pileup_mod_coord = pileup_basemod.split(",") - if ( + + if single_strand and tabix_fields[5] != region_strand: + # We are on the wrong strand, can't keep this position. + return (False, 0, 0, 0) + + pileup_basemod_parts = pileup_basemod.split(",") + if len(pileup_basemod_parts) == 3: + pileup_modname, pileup_motif, pileup_mod_coord = pileup_basemod_parts + keep_basemod = ( pileup_motif == parsed_motif.motif_seq and int(pileup_mod_coord) == parsed_motif.modified_pos and pileup_modname in parsed_motif.mod_codes - ): - keep_basemod = True - else: - keep_basemod = False - elif len(pileup_basemod.split(",")) == 1: + ) + elif len(pileup_basemod_parts) == 1: keep_basemod = pileup_basemod in parsed_motif.mod_codes else: raise ValueError( f"Unexpected format in bedmethyl file: {row} contains {pileup_basemod} which cannot be parsed." ) - pileup_info = tabix_fields[9].split(" ") + if not keep_basemod: + return (False, 0, 0, 0) + + pileup_info = tabix_fields[9].split() genomic_coord = int(tabix_fields[1]) valid_in_row = int(pileup_info[0]) modified_in_row = int(pileup_info[2]) - return ( - keep_basemod, - genomic_coord, - modified_in_row, - valid_in_row, - ) + return (True, genomic_coord, modified_in_row, valid_in_row) ################################################################################################################ @@ -862,14 +973,10 @@ def read_vectors_from_hdf5( regions: str | Path | list[str | Path] | None = None, window_size: int | None = None, single_strand: bool = False, - sort_by: str | tuple[str, str] | list[str | tuple[str, str]] = [ - "chromosome", - "region_start", - "read_start", - ], + sort_by: str | list[str] = ["chromosome", "region_start", "read_start"], calculate_mod_fractions: bool = True, - quiet: bool = True, - cores: int | None = None, + quiet: bool = True, # currently unused; change to default False when pbars are implemented + cores: int | None = None, # currently unused subset_parameters: dict | None = None, span_full_window: bool = False, ) -> tuple[list[tuple], list[str], dict | None]: @@ -887,13 +994,14 @@ def read_vectors_from_hdf5( a list. The bytes are then decoded for the array entries, which are manually compressed because h5py wasn't behaving. - Thresholded files are loaded as binary arrays when the stored threshold metadata is present. - Unthresholded files preserve the raw modkit probability encoding, where the 0-255 8bit int - has 0.5 added before dividing by 256, giving mod qualities between 0.001953 and 0.99805 - for bases in valid motifs. (Invalid positions have zeros.) + There's some adjustment for the raw probability (no thresh) to match modkit extract outputs. + Specifically, the 0-255 8bit int has 0.5 added before dividing by 256, giving mod qualities + between 0.001953 and 0.99805 for bases in valid motifs. (Invalid positions have zeros.) After this processing, we calculate modification fractions, sort, and return. + TODO: Implement progress bars and parallelization as with pileup loaders + Args: file: Path to an hdf5 (.h5) file containing modification data for single reads, stored in datasets read_name, chromosome, read_start, @@ -916,9 +1024,8 @@ def read_vectors_from_hdf5( sort_by: Read properties by which to sort, either one string or a list of strings. Options include chromosome, region_start, region_end, read_start, read_end, and motif. More to be added in future. - quiet: silences progress bars - cores: if >1 and regions are provided, parallelize per-region read-index - selection before h5 retrieval + quiet: silences progress bars (currently unused) + cores: cores across which to parallelize processes (currently unused) subset_parameters: Parameters to pass to the utils.random_sample() method, to subset the reads to be returned. If not None, at least one of n or frac must be provided. The array parameter should not be provided here. @@ -930,9 +1037,9 @@ def read_vectors_from_hdf5( a list of strings, naming the datasets returned. a regions_dict, containing lists of (region_start,region_end) coordinates by chromosome/contig. + TODO: The way the subsetting is implemented is confusing, in that you need to pass all but one of + the available parameters. """ - _validate_subset_parameters(subset_parameters) - with h5py.File(file, "r") as h5: datasets: list[str] = [ name for name, obj in h5.items() if isinstance(obj, h5py.Dataset) @@ -967,79 +1074,74 @@ def read_vectors_from_hdf5( window_size=window_size, ) read_tuples_raw = [] - region_jobs = [ - (chrom, region_start, region_end, region_strand) - for chrom, region_list in regions_dict.items() - for region_start, region_end, region_strand in region_list - ] - cores_to_run = ( - 1 - if cores is None - else max(1, min(cores, len(region_jobs))) - ) - region_to_indices = partial( - _region_job_to_read_indices, - read_chromosomes=read_chromosomes, - read_starts=read_starts, - read_ends=read_ends, - read_motifs=read_motifs, - ref_strands=ref_strands, - motifs=motifs, - single_strand=single_strand, - span_full_window=span_full_window, - ) - if cores_to_run > 1 and len(region_jobs) > 1: - with concurrent.futures.ThreadPoolExecutor( - max_workers=cores_to_run - ) as executor: - region_results = list(executor.map(region_to_indices, region_jobs)) - else: - region_results = [region_to_indices(job) for job in region_jobs] - region_iterator = ( - tqdm( - zip(region_jobs, region_results), - total=len(region_jobs), - disable=quiet, - desc="Loading read vectors", - leave=False, - ) - if len(region_jobs) > 0 - else [] - ) - for ( - chrom, - region_start, - region_end, - region_strand, - ), relevant_read_indices in region_iterator: - relevant_read_indices = _subset_indices( - relevant_read_indices, subset_parameters=subset_parameters - ) - read_tuples_raw += _load_read_tuples_for_indices( - h5=h5, - readwise_datasets=readwise_datasets, - compressed_binary_datasets=compressed_binary_datasets, - binarized=binarized, - relevant_read_indices=relevant_read_indices, - region_start=region_start, - region_end=region_end, - region_strand=region_strand, - ) + for chrom, region_list in regions_dict.items(): + for region_start, region_end, region_strand in region_list: + # Find the read indices that we want to load + # TODO: consider building this up and then loading all at the end, chunked + # TODO: consolidate logic into clear variables + relevant_read_indices = np.flatnonzero( + (read_ends > region_start) + & (read_starts < region_end) + & (read_starts <= region_start if span_full_window else True) + & (read_ends >= region_end if span_full_window else True) + & np.isin(read_motifs, motifs) + & (read_chromosomes == chrom) + & ( + (not single_strand) + | (region_strand not in ["+", "-"]) + | (ref_strands == region_strand) + ) + ) + if subset_parameters is not None: + relevant_read_indices = np.sort( + utils.random_sample( + relevant_read_indices, **subset_parameters + ) + ) + read_tuples_raw += list( + zip( + *( + retrieve_h5_data( + h5=h5, + dataset=dataset, + indices=relevant_read_indices, + compressed=dataset in compressed_binary_datasets, + dtype=np.uint8, + decompressor=gzip.decompress, + binarized=binarized, + ) + for dataset in readwise_datasets + ), + [region_start for _ in relevant_read_indices], + [region_end for _ in relevant_read_indices], + [region_strand for _ in relevant_read_indices], + ) + ) else: regions_dict = None relevant_read_indices = np.flatnonzero(np.isin(read_motifs, motifs)) - relevant_read_indices = _subset_indices( - relevant_read_indices, subset_parameters=subset_parameters - ) - read_tuples_raw = _load_read_tuples_for_indices( - h5=h5, - readwise_datasets=readwise_datasets, - compressed_binary_datasets=compressed_binary_datasets, - binarized=binarized, - relevant_read_indices=relevant_read_indices, - region_start=-1, - region_end=-1, - region_strand=".", + if subset_parameters is not None: + relevant_read_indices = np.sort( + utils.random_sample(relevant_read_indices, **subset_parameters) + ) + read_tuples_raw = list( + zip( + *( + retrieve_h5_data( + h5=h5, + dataset=dataset, + indices=relevant_read_indices, + compressed=dataset in compressed_binary_datasets, + dtype=np.uint8, + decompressor=gzip.decompress, + binarized=binarized, + ) + for dataset in readwise_datasets + ), + [-1 for _ in relevant_read_indices], + [-1 for _ in relevant_read_indices], + ["." for _ in relevant_read_indices], + ) ) # We add region information (start, end, and strand; chromosome is already present!) # so that it is possible to sort by and process based on these @@ -1051,40 +1153,46 @@ def read_vectors_from_hdf5( convert_bytes_to_strings(tup) for tup in read_tuples_raw ] else: - mod_vector_index = readwise_datasets.index("mod_vector") - val_vector_index = readwise_datasets.index("val_vector") read_tuples_processed = [ adjust_mod_probs_in_tuples( convert_bytes_to_strings(tup), - mod_vector_index, - val_vector_index, + readwise_datasets.index("mod_vector"), + readwise_datasets.index("val_vector"), ) for tup in read_tuples_raw ] read_start_idx = readwise_datasets.index("read_start") read_end_idx = readwise_datasets.index("read_end") + read_name_idx = readwise_datasets.index("read_name") + motif_idx = readwise_datasets.index("motif") + mod_vector_idx = readwise_datasets.index("mod_vector") + val_vector_idx = readwise_datasets.index("val_vector") if calculate_mod_fractions: # Add the MOTIF_mod_fraction entries to the readwise_datasets list for future reference in sorting readwise_datasets += [f"{motif}_mod_fraction" for motif in motifs] - # dict[read_name][motif]=modified fraction of motif in read, float - mod_fractions_by_read_name_by_motif: defaultdict[ - str, defaultdict[str, float] - ] = defaultdict(lambda: defaultdict(lambda: 0.0)) - motif_index = readwise_datasets.index("motif") - mod_vector_index = readwise_datasets.index("mod_vector") - val_vector_index = readwise_datasets.index("val_vector") - read_name_index = readwise_datasets.index("read_name") - for motif in motifs: - for read_tuple in read_tuples_processed: - if read_tuple[motif_index] == motif: - mod_sum = np.sum(read_tuple[mod_vector_index]) - val_sum = np.sum(read_tuple[val_vector_index]) - mod_fraction = mod_sum / val_sum if val_sum > 0 else 0 - mod_fractions_by_read_name_by_motif[read_tuple[read_name_index]][ - motif - ] = mod_fraction + # dict[read_name][motif_index]=modified fraction of motif in read, float + motif_idx_by_name = {motif: i for i, motif in enumerate(motifs)} + mod_fractions_by_read_name: dict[str, list[float]] = {} + for read_tuple in read_tuples_processed: + motif = read_tuple[motif_idx] + motif_fraction_idx = motif_idx_by_name.get(motif) + if motif_fraction_idx is None: + continue + mod_sum = np.sum(read_tuple[mod_vector_idx]) + val_sum = np.sum(read_tuple[val_vector_idx]) + mod_fraction = mod_sum / val_sum if val_sum > 0 else 0 + read_name = read_tuple[read_name_idx] + if read_name not in mod_fractions_by_read_name: + mod_fractions_by_read_name[read_name] = [0.0] * len(motifs) + mod_fractions_by_read_name[read_name][motif_fraction_idx] = mod_fraction + + empty_mod_fractions = tuple(0.0 for _ in motifs) + mod_fractions_by_read_name_tup = { + read_name: tuple(mod_fractions) + for read_name, mod_fractions in mod_fractions_by_read_name.items() + } read_tuples_all = [] for read_tuple in read_tuples_processed: @@ -1092,11 +1200,8 @@ def read_vectors_from_hdf5( read_tuples_all.append( tuple(val for val in read_tuple) + (read_length,) - + tuple( - mod_frac - for mod_frac in mod_fractions_by_read_name_by_motif[ - read_tuple[read_name_index] - ].values() + + mod_fractions_by_read_name_tup.get( + read_tuple[read_name_idx], empty_mod_fractions ) ) else: @@ -1112,7 +1217,23 @@ def read_vectors_from_hdf5( # - "field" or ["field1", "field2"] -> [("field1", "asc"), ("field2", "asc")] # - [("field1", "desc"), "field2"] -> [("field1", "desc"), ("field2", "asc")] - sort_by_normalized = _normalize_sort_by(sort_by) + # Enforce that sort_by is a list + if not isinstance(sort_by, list): + sort_by = [sort_by] + + # Parse into (field, order) tuples + sort_by_normalized = [] + for item in sort_by: + if isinstance(item, tuple): + field, order = item + if order not in ["asc", "desc"]: + raise ValueError( + f"Sort order must be 'asc' or 'desc', got '{order}' for field '{field}'" + ) + sort_by_normalized.append((field, order)) + else: + # Default to ascending order + sort_by_normalized.append((item, "asc")) # If 'shuffle' appears anywhere in sort_by, we first shuffle the list if any(field == "shuffle" for field, _ in sort_by_normalized): @@ -1150,15 +1271,11 @@ def readwise_binary_modification_arrays( window_size: int | None = None, regions_5to3prime: bool = False, single_strand: bool = False, - sort_by: str | tuple[str, str] | list[str | tuple[str, str]] = [ - "chromosome", - "region_start", - "read_start", - ], + sort_by: str | list[str] = ["chromosome", "region_start", "read_start"], thresh: float | None = None, relative: bool = True, - quiet: bool = True, - cores: int | None = None, + quiet: bool = True, # currently unused; change to default False when pbars are implemented + cores: int | None = None, # currently unused subset_parameters: dict | None = None, ) -> tuple[list[np.ndarray], np.ndarray[int], np.ndarray[str], dict | None]: """ @@ -1175,6 +1292,8 @@ def readwise_binary_modification_arrays( coordinates. If positions are relative, regions_5to3prime can be used to show all regions as upstream-to-downstream along their respective strands. + TODO: Implement progress bars and parallelization as with pileup loaders + Args: file: Path to an hdf5 (.h5) file containing modification data for single reads, stored in datasets read_name, chromosome, read_start, @@ -1203,9 +1322,8 @@ def readwise_binary_modification_arrays( in the genomes, centered at the center of the region. If False, absolute coordinates are provided. There is not currently a check for all reads being on the same chromosome if relative=False, but this could create unexpected behaviour for a the standard visualizations. - quiet: silences progress bars - cores: cores across which per-read modification position extraction is - parallelized + quiet: silences progress bars (currently unused) + cores: cores across which to parallelize processes (currently unused) subset_parameters: Parameters to pass to the utils.random_sample() method, to subset the reads to be returned. If not None, at least one of n or frac must be provided. The array parameter should not be provided here. @@ -1231,8 +1349,6 @@ def readwise_binary_modification_arrays( window_size=window_size, single_strand=single_strand, sort_by=sort_by, - quiet=quiet, - subset_parameters=subset_parameters, ) read_name_index = datasets.index("read_name") mod_vector_index = datasets.index("mod_vector") @@ -1242,14 +1358,6 @@ def readwise_binary_modification_arrays( read_start_index = datasets.index("read_start") region_strand_index = datasets.index("region_strand") - if len(sorted_read_data_converted) == 0: - return ( - np.array([], dtype=int), - np.array([], dtype=int), - np.array([], dtype=str), - regions_dict, - ) - # Check this .h5 file was created with a threshold, i.e. that the mod calls are binarized if thresh is None: if not (sorted_read_data_converted[0][mod_vector_index].dtype == np.bool_): @@ -1259,77 +1367,60 @@ def readwise_binary_modification_arrays( else: thresh = utils.adjust_threshold(thresh) - read_ints = _assign_region_scoped_read_ints( - read_data=sorted_read_data_converted, - read_name_index=read_name_index, - region_start_index=region_start_index, - region_end_index=region_end_index, - region_strand_index=region_strand_index, - ) - - read_ids_by_mod_pos: list[int] = [] + read_ints_list = [] mod_coords_list = [] motifs_list = [] - n_reads = len(sorted_read_data_converted) - cores_to_run = 1 if cores is None else max(1, min(cores, n_reads)) - - read_payloads = ( - { - "read_int": read_int, - "read_data": read_data, - "mod_vector_index": mod_vector_index, - "motif_index": motif_index, - "region_start_index": region_start_index, - "region_end_index": region_end_index, - "read_start_index": read_start_index, - "region_strand_index": region_strand_index, - "thresh": thresh, - "relative": relative, - "regions_5to3prime": regions_5to3prime, - } - for read_int, read_data in zip(read_ints, sorted_read_data_converted) + read_names = np.array( + [read_data[read_name_index] for read_data in sorted_read_data_converted] ) + # TODO: handle the case where a read shows up in more than one different region + _, unique_first_indices = np.unique(read_names, return_index=True) + unique_in_order = read_names[np.sort(unique_first_indices)] + string_to_int = { + read_name: index for index, read_name in enumerate(unique_in_order) + } + read_ints = np.array([string_to_int[read_name] for read_name in read_names]) + + for read_int, read_data in zip(read_ints, sorted_read_data_converted): + if thresh is None: + mod_pos_in_read = np.flatnonzero(read_data[mod_vector_index]) + else: + mod_pos_in_read = np.flatnonzero(read_data[mod_vector_index] > thresh) + + if relative: + if regions_5to3prime and read_data[region_strand_index] == "-": + # Here we want to show the regions each along their 5 prime to 3 prime direction + # This means that negative strand regions need to be flipped + mod_pos_record = -( + mod_pos_in_read + + read_data[read_start_index] + - (read_data[region_start_index] + read_data[region_end_index]) + // 2 + ) + else: + # This is the default case: just make the coordinates relative using + # the reference genome coordinate system. Normal, easy, chill, nice. + mod_pos_record = ( + mod_pos_in_read + + read_data[read_start_index] + - (read_data[region_start_index] + read_data[region_end_index]) + // 2 + ) + else: + # If we aren't using relative coordinates, then I think the 5prime to 3prime argument + # can just be ignored, and I think it's nicer if that's silent - less clutter in the output + # Basically if you are keeping different regions separate using other metadata (such as + # just keeping their actual real genomic coordinates) it is superfluous to do the 5to3 flip. + mod_pos_record = mod_pos_in_read + read_data[read_start_index] - if cores_to_run > 1: - with concurrent.futures.ThreadPoolExecutor( - max_workers=cores_to_run - ) as executor: - read_iterator = executor.map( - _readwise_mod_positions_from_payload, - read_payloads, - ) - read_iterator = tqdm( - read_iterator, - total=n_reads, - disable=quiet, - desc="Extracting readwise modifications", - leave=False, - ) - for mod_pos_record, read_ids, motif_labels in read_iterator: - mod_coords_list += mod_pos_record - read_ids_by_mod_pos += read_ids - motifs_list += motif_labels - else: - read_iterator = map( - _readwise_mod_positions_from_payload, - read_payloads, - ) - read_iterator = tqdm( - read_iterator, - total=n_reads, - disable=quiet, - desc="Extracting readwise modifications", - leave=False, - ) - for mod_pos_record, read_ids, motif_labels in read_iterator: - mod_coords_list += mod_pos_record - read_ids_by_mod_pos += read_ids - motifs_list += motif_labels + mod_coords_list += list(mod_pos_record) + read_ints_list += [read_int] * len(mod_pos_record) + motifs_list += [read_data[motif_index]] * len(mod_pos_record) return ( np.array(mod_coords_list), - np.array(read_ids_by_mod_pos), + np.array(read_ints_list), np.array(motifs_list), regions_dict, ) @@ -1351,25 +1442,25 @@ def reads_from_fake( """ Helper function to support testing. + TODO: What does the bed file represent in this method? This one is breaking my brain a bit. + TODO: Variable names in this method stink. + TODO: Currently assumes mod calling (thresholding probabilities) was already performed elsewhere + Args: file: Path to file containing modification data for single reads - regions: Placeholder for a regions input, kept for signature compatibility with - non-stub loaders. It is intentionally unused by this synthetic data helper. - motifs: types of modification to extract data for + bed_file: Path to bed file specifying regions (WHAT DO THESE REPRESENT???) + mod_names: types of modification to extract data for Returns: - Returns three parallel arrays, of length (N_READS * len(motifs)), containing the following for each index: + Returns three parallel arrays, of length (N_READS * len(mod_names)), containing the following for each index: * array of positions at which the specified modification was found in a read * unique integer ID for the read * modification represented by the positions - For example, if called on a dataset with a single read and two modification - types, each array would have two entries. The unique IDs would be the same, - as both entries would represent the same single read. The mods and positions - would be different, as they would extract different mods. + For example, if called on a dataset with a single read and two modification types, each array would have two entries. The unique IDs would be the same, as both entries would represent the same single read. The mods and positions would be different, as they would extact different mods. """ - read_positions = [] - read_ids_by_mod = [] - motif_labels = [] + reads = [] + read_names = [] + mods = [] for mod_name in motifs: match mod_name: case "A,0": @@ -1386,13 +1477,13 @@ def reads_from_fake( ] case _: raise ValueError(f"No stub settings for requested mod {mod_name}") - read_positions += mod_reads - read_ids_by_mod.append(np.arange(len(mod_reads))) - motif_labels.append([mod_name] * len(mod_reads)) + reads += mod_reads + read_names.append(np.arange(len(mod_reads))) + mods.append([mod_name] * len(mod_reads)) - read_ids_by_mod = np.concatenate(read_ids_by_mod) - motif_labels = np.concatenate(motif_labels) - return read_positions, read_ids_by_mod, motif_labels, {} + read_names = np.concatenate(read_names) + mods = np.concatenate(mods) + return reads, read_names, mods, {} # def convert_bytes(item): diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index 5dd391b..f79a288 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -1,8 +1,8 @@ -import csv import gzip -import itertools -import multiprocessing +import json +import os import subprocess +import time from collections import defaultdict from pathlib import Path @@ -24,63 +24,29 @@ # Specifies how many reads to check for the base modifications of interest. NUM_READS_TO_CHECK = 100 - - -def _threads_command_list(cores: int | None, quiet: bool) -> list[str]: - cores_avail = multiprocessing.cpu_count() - if cores is None: - if not quiet: - print( - f"No specified number of cores requested. {cores_avail} available on machine, allocating all." - ) - return ["--threads", str(cores_avail)] - if cores > cores_avail: - if not quiet: - print( - f"Warning: {cores} cores request, {cores_avail} available. Allocating {cores_avail}" - ) - return ["--threads", str(cores_avail)] - if not quiet: - print(f"Allocating requested {cores} cores.") - return ["--threads", str(cores)] - - -def _compress_uint8_vector( - vector: np.ndarray, - compress_level: int, -) -> np.ndarray: - return np.frombuffer( - gzip.compress(vector.tobytes(), compresslevel=compress_level), - dtype=np.uint8, - ) - - -def _unlink_existing(*paths: Path) -> None: - for path in paths: - path.unlink(missing_ok=True) - - -def _reference_oriented_read_offset( - *, - pos_in_read: int, - read_length: int, - ref_strand: str, -) -> int: - """ - Convert modkit's read-oriented position into a left-to-right reference offset. - """ - if read_length <= 0: - raise ValueError(f"read length must be positive; got {read_length}.") - if pos_in_read < 0 or pos_in_read >= read_length: - raise ValueError( - f"pos_in_read {pos_in_read} is out of bounds for read length {read_length}." - ) - if ref_strand == "+": - return pos_in_read - if ref_strand == "-": - return read_length - pos_in_read - 1 - raise ValueError(f"Unexpected strand '{ref_strand}' in modkit extract row.") - +VERIFY_CACHE_FILENAME = ".dimelo.verify_cache.json" +VERIFY_CACHE_VERSION = 1 +VERIFY_CACHE_MAX_ENTRIES = 64 +DEFAULT_MODKIT_MEMORY_PER_THREAD_BYTES = 2 * 1024 * 1024 * 1024 +DEFAULT_MODKIT_MEMORY_FRACTION = 0.8 +IUPAC_BASES = { + "A": {"A"}, + "C": {"C"}, + "G": {"G"}, + "T": {"T"}, + "U": {"T"}, + "R": {"A", "G"}, + "Y": {"C", "T"}, + "S": {"G", "C"}, + "W": {"A", "T"}, + "K": {"G", "T"}, + "M": {"A", "C"}, + "B": {"C", "G", "T"}, + "D": {"A", "G", "T"}, + "H": {"A", "C", "T"}, + "V": {"A", "C", "G"}, + "N": {"A", "C", "G", "T"}, +} """ User-facing parse operations: pileup and extract @@ -101,6 +67,7 @@ def pileup( cleanup: bool = True, quiet: bool = False, override_checks: bool = False, + verification_cache: bool = True, ) -> tuple[Path, Path]: """ Takes a bam file containing long read sequencing data aligned @@ -138,11 +105,7 @@ def pileup( output_directory: optional str or Path pointing to an output directory. If left as None, outputs will be stored in a new folder within the input directory. - regions: optional region selector passed through to modkit via an include-bed - file. This may be a BED file path, a single region file, or a list of - region files/paths that define the loci to process. When paired with - ``window_size``, the provided regions are expanded around their centers - before being passed to modkit. + regions: TODO motifs: a list of strings specifying which base modifications to look for. The basemods are each specified as {sequence_motif},{position_of_modification}. For example, a methylated adenine is specified as 'A,0' and CpG methylation @@ -169,6 +132,16 @@ def pileup( Path object pointing to 'regions.processed.bed', the `--include-bed` file used for `modkit pileup` """ + """ + TODO: There are a lot of issues that are all related here: + dimelo/parse_bam.py:150: error: Incompatible types in assignment (expression has type "Path | None", variable has type "str | Path") [assignment] + dimelo/parse_bam.py:169: error: Argument "input_file" to "prep_outputs" has incompatible type "str | Path"; expected "Path" [arg-type] + dimelo/parse_bam.py:256: error: Argument "input_file" to "run_with_progress_bars" has incompatible type "str | Path"; expected "Path" [arg-type] + dimelo/parse_bam.py:257: error: Argument "ref_genome" to "run_with_progress_bars" has incompatible type "str | Path"; expected "Path" [arg-type] + + I'm not sure of the most elegant way to fix it. Come back and address. + """ + ## Verify and prepare inputs and outputs run_modkit.ensure_modkit_available(quiet=quiet) @@ -176,12 +149,15 @@ def pileup( input_file, ref_genome, output_directory = utils.sanitize_path_args( input_file, ref_genome, output_directory ) - input_file = Path(input_file) - ref_genome = Path(ref_genome) - output_directory = None if output_directory is None else Path(output_directory) try: - verify_inputs(input_file, motifs, ref_genome) + verify_inputs( + input_file, + motifs, + ref_genome, + quiet=quiet, + cache=verification_cache, + ) except Exception as e: if override_checks: if not quiet: @@ -195,7 +171,7 @@ def pileup( prep_output_directory( output_directory=output_directory, output_name=output_name, - default_directory=input_file.parent, + input_file=input_file, output_file_names=[ "pileup.bed", "pileup.sorted.bed", @@ -207,6 +183,7 @@ def pileup( ## Build up the command list to be sent to modkit, then run modkit + # TODO: This is mildly confusing. I get what it's doing, but it's hard to follow / names are bad. Also, why is it used in cleanup here, but not in extract? region_command_list, processed_regions_path = create_region_command_list( output_path, regions, @@ -215,21 +192,20 @@ def pileup( motif_command_list = [] if len(motifs) > 0: + seen_motifs: set[tuple[str, int]] = set() for motif in motifs: parsed_motif = utils.ParsedMotif(motif) - motif_command_present = False - for a, b in zip(motif_command_list, motif_command_list[1:]): - if a == parsed_motif.motif_seq and b == str(parsed_motif.modified_pos): - # This motif is already going to be processed; we want to skip adding it a second - # time because modkit does not like duplicate motifs. - # It's actually ok if it's a different mod code in the two cases because the pileup - # operation, under the hood, keeps all mod codes. Filtering is only done when loading. - motif_command_present = True - break - if not motif_command_present: - motif_command_list.append("--motif") - motif_command_list.append(parsed_motif.motif_seq) - motif_command_list.append(str(parsed_motif.modified_pos)) + motif_key = (parsed_motif.motif_seq, parsed_motif.modified_pos) + # This motif is already going to be processed; we want to skip adding it a second + # time because modkit does not like duplicate motifs. + # It's actually ok if it's a different mod code in the two cases because the pileup + # operation, under the hood, keeps all mod codes. Filtering is only done when loading. + if motif_key in seen_motifs: + continue + seen_motifs.add(motif_key) + motif_command_list.extend( + ["--motif", parsed_motif.motif_seq, str(parsed_motif.modified_pos)] + ) else: raise ValueError("Error: no motifs specified. Nothing to process.") @@ -240,8 +216,9 @@ def pileup( else: log_command_list = [] - cores_command_list = _threads_command_list(cores=cores, quiet=quiet) + cores_command_list = _resolve_modkit_threads_command(cores=cores, quiet=quiet) + # TODO: This is SO SO SO similar to extract; just the ValueError vs. printing. I think this can be resolved mod_thresh_command_list: list[str] = [] if thresh is None: if not quiet: @@ -257,10 +234,9 @@ def pileup( for motif in motifs: parsed_motif = utils.ParsedMotif(motif) for mod_code in parsed_motif.mod_codes: - mod_thresh_command_list = mod_thresh_command_list + [ - "--mod-thresholds", - f"{mod_code}:{adjusted_threshold}", - ] + mod_thresh_command_list.extend( + ["--mod-thresholds", f"{mod_code}:{adjusted_threshold}"] + ) ref_genome_command_list = ["--ref", ref_genome] filter_command_list = ["--filter-threshold", "0"] @@ -276,7 +252,8 @@ def pileup( + log_command_list ) - run_modkit.run_with_progress_bars( + # TODO: Do we need to store and use the output from this method? Previously was being printed immediately afterward. + _ = run_modkit.run_with_progress_bars( command_list=pileup_command_list, input_file=input_file, ref_genome=ref_genome, @@ -292,18 +269,25 @@ def pileup( expect_done=True, quiet=quiet, ) + # print(done_string) ## Sort, compress, and index the output bedmethyl file - with open(output_bedmethyl_sorted, "w") as sorted_file: - subprocess.run( - ["sort", "-k1,1", "-k2,2n", output_bedmethyl], stdout=sorted_file - ) + _sort_bedmethyl_output( + input_bedmethyl=output_bedmethyl, + output_bedmethyl_sorted=output_bedmethyl_sorted, + requested_cores=cores, + quiet=quiet, + ) pysam.tabix_compress(output_bedmethyl_sorted, output_pileup_path, force=True) pysam.tabix_index(str(output_pileup_path), preset="bed", force=True) + # TODO: Can cleanup be consolidated? if cleanup: - _unlink_existing(output_bedmethyl, output_bedmethyl_sorted) + if output_bedmethyl.exists(): + output_bedmethyl.unlink() + if output_bedmethyl_sorted.exists(): + output_bedmethyl_sorted.unlink() return output_pileup_path, processed_regions_path @@ -322,6 +306,7 @@ def extract( cleanup: bool = True, quiet: bool = False, override_checks: bool = False, + verification_cache: bool = True, ) -> tuple[Path, Path]: """ Takes a bam file containing long read sequencing data aligned @@ -357,11 +342,7 @@ def extract( output_directory: optional str or Path pointing to an output directory. If left as None, outputs will be stored in a new folder within the input directory. - regions: optional region selector passed through to modkit via an include-bed - file. This may be a BED file path, a single region file, or a list of - region files/paths that define the loci to process. When paired with - ``window_size``, the provided regions are expanded around their centers - before being passed to modkit. + regions: TODO motifs: a list of strings specifying which base modifications to look for. The basemods are each specified as {sequence_motif},{position_of_modification}. For example, a methylated adenine is specified as 'A,0' and CpG methylation @@ -388,17 +369,30 @@ def extract( Path object pointing to 'regions.processed.bed', the `--include-bed` file used for `modkit extract` """ + """ + TODO: There are a lot of issues that are all related here: + dimelo/parse_bam.py:374: error: Incompatible types in assignment (expression has type "Path | None", variable has type "str | Path") [assignment] + dimelo/parse_bam.py:393: error: Argument "input_file" to "prep_outputs" has incompatible type "str | Path"; expected "Path" [arg-type] + dimelo/parse_bam.py:480: error: Argument "input_file" to "run_with_progress_bars" has incompatible type "str | Path"; expected "Path" [arg-type] + dimelo/parse_bam.py:481: error: Argument "ref_genome" to "run_with_progress_bars" has incompatible type "str | Path"; expected "Path" [arg-type] + + I'm not sure of the most elegant way to fix it. Come back and address. + """ + ## Verify and prepare inputs and outputs input_file, ref_genome, output_directory = utils.sanitize_path_args( input_file, ref_genome, output_directory ) - input_file = Path(input_file) - ref_genome = Path(ref_genome) - output_directory = None if output_directory is None else Path(output_directory) try: - verify_inputs(input_file, motifs, ref_genome) + verify_inputs( + input_file, + motifs, + ref_genome, + quiet=quiet, + cache=verification_cache, + ) except Exception as e: if override_checks: if not quiet: @@ -408,10 +402,11 @@ def extract( f'{e}\nIf you are confident that your inputs are ok, pass "override_checks=True" to convert to warning and proceed with processing.' ) from e + # TODO: Add intermediate mod-specific .txt files? output_path, (output_reads_path,) = prep_output_directory( output_directory=output_directory, output_name=output_name, - default_directory=input_file.parent, + input_file=input_file, output_file_names=["reads.combined_basemods.h5"], ) @@ -423,12 +418,12 @@ def extract( window_size, ) - cores_command_list = _threads_command_list(cores=cores, quiet=quiet) + cores_command_list = _resolve_modkit_threads_command(cores=cores, quiet=quiet) if thresh is None: if not quiet: print( - "No valid base modification threshold provided. Raw probabilities will be saved." + "No valid base modification threshold provided. Raw probs will be saved." ) adjusted_threshold = None else: @@ -437,10 +432,6 @@ def extract( print( f"WARNING: thresh {thresh} is very low and may lead to unexpected behavior. Typical thresholds are at least 0.5 or 128." ) - if not quiet: - print( - "Threshold provided. The extract text will stay probability-valued and read_by_base_txt_to_hdf5 will binarize at write time." - ) if log: if not quiet: @@ -452,62 +443,48 @@ def extract( ref_genome_command_list = ["--ref", ref_genome] filter_command_list = ["--filter-threshold", "0"] - # Run modkit once for each motif, because the output .txt can be ambiguous otherwise - # There is no column currently to specify the motif (e.g. CG,0 vs GCH,1), only canonical - # base (e.g. C) and mod code (e.g. m) - # There is a 5mer context so we could technically manually motif check if we want to. - # Our current design paradigm is to leave all such operations to modkit, hence the loop below. - for motif in motifs: - # Here we prepare the motif-specific commands and delete any old .txt file because - # modkit will crash otherwise - motif_command_list = [] - parsed_motif = utils.ParsedMotif(motif) - motif_command_list.append("--motif") - motif_command_list.append(parsed_motif.motif_seq) - motif_command_list.append(str(parsed_motif.modified_pos)) - - output_txt = Path(output_path) / (f"reads.{motif}.txt") - - output_txt.unlink(missing_ok=True) + motif_command_list = _build_extract_motif_command_list(motifs) + output_txt = Path(output_path) / "reads.combined_motifs.txt" + output_txt.unlink(missing_ok=True) - extract_command_list = ( - ["modkit", "extract", input_file, output_txt] - + region_command_list - + motif_command_list - + cores_command_list - + log_command_list - + ref_genome_command_list - + filter_command_list - ) + extract_command_list = ( + ["modkit", "extract", input_file, output_txt] + + region_command_list + + motif_command_list + + cores_command_list + + log_command_list + + ref_genome_command_list + + filter_command_list + ) - run_modkit.run_with_progress_bars( - command_list=extract_command_list, - input_file=input_file, - ref_genome=ref_genome, - motifs=[motif], - load_fasta_regex=r"\s+\[.*?\]\s+(\d+)\s+parsing FASTA", - find_motifs_regex=r"\s+(\d+)/(\d+)\s+([\w]+)\s+searched", - contigs_progress_regex=r"\s+(\d+)/(\d+)\s+contigs\s+[^s]", - single_contig_regex=r"\s+(\d+)/(\d+)\s+processing\s+([\w]+)[^\w]", - buffer_size=100, - progress_granularity=50, - done_str="Done", - err_str="Error", - expect_done=False, - quiet=quiet, - ) + _ = run_modkit.run_with_progress_bars( + command_list=extract_command_list, + input_file=input_file, + ref_genome=ref_genome, + motifs=motifs, + load_fasta_regex=r"\s+\[.*?\]\s+(\d+)\s+parsing FASTA", + find_motifs_regex=r"\s+(\d+)/(\d+)\s+([\w]+)\s+searched", + contigs_progress_regex=r"\s+(\d+)/(\d+)\s+contigs\s+[^s]", + single_contig_regex=r"\s+(\d+)/(\d+)\s+processing\s+([\w]+)[^\w]", + buffer_size=100, + progress_granularity=50, + done_str="Done", + err_str="Error", + expect_done=False, + quiet=quiet, + ) - # Create the compressed and indexed output + for motif in motifs: read_by_base_txt_to_hdf5( output_txt, output_reads_path, motif, adjusted_threshold, quiet=quiet, + require_motif_context=True, ) - # Delete intermediate file - if cleanup: - output_txt.unlink() + if cleanup: + output_txt.unlink(missing_ok=True) return output_reads_path, processed_regions_path @@ -517,16 +494,144 @@ def extract( """ +def _file_fingerprint(path: Path) -> dict[str, int | str]: + stat = path.stat() + return {"path": str(path.resolve()), "size": stat.st_size, "mtime_ns": stat.st_mtime_ns} + + +def _verification_cache_key( + *, + input_file: Path, + ref_genome: Path, + motifs: list[str], +) -> str: + sorted_motifs = sorted(str(motif) for motif in motifs) + return "|".join([str(input_file.resolve()), str(ref_genome.resolve()), ",".join(sorted_motifs)]) + + +def _verification_cache_path(input_file: Path) -> Path: + return input_file.parent / VERIFY_CACHE_FILENAME + + +def _load_verification_cache(cache_path: Path) -> dict: + if not cache_path.exists(): + return {"version": VERIFY_CACHE_VERSION, "entries": {}} + try: + data = json.loads(cache_path.read_text(encoding="utf-8")) + except Exception: + return {"version": VERIFY_CACHE_VERSION, "entries": {}} + if not isinstance(data, dict): + return {"version": VERIFY_CACHE_VERSION, "entries": {}} + if data.get("version") != VERIFY_CACHE_VERSION: + return {"version": VERIFY_CACHE_VERSION, "entries": {}} + entries = data.get("entries") + if not isinstance(entries, dict): + return {"version": VERIFY_CACHE_VERSION, "entries": {}} + return {"version": VERIFY_CACHE_VERSION, "entries": entries} + + +def _save_verification_cache(cache_path: Path, cache_data: dict) -> None: + temp_path = cache_path.with_suffix(cache_path.suffix + ".tmp") + temp_path.write_text(json.dumps(cache_data), encoding="utf-8") + temp_path.replace(cache_path) + + +def _load_cached_verification_result( + *, + input_file: Path, + ref_genome: Path, + motifs: list[str], +) -> tuple[int, int] | None: + if os.environ.get("DIMELO_DISABLE_VERIFY_CACHE", "").lower() in {"1", "true", "yes"}: + return None + + cache_path = _verification_cache_path(input_file) + cache_data = _load_verification_cache(cache_path) + key = _verification_cache_key(input_file=input_file, ref_genome=ref_genome, motifs=motifs) + entry = cache_data["entries"].get(key) + if not isinstance(entry, dict): + return None + + try: + if entry["input"] != _file_fingerprint(input_file): + return None + if entry["ref"] != _file_fingerprint(ref_genome): + return None + total_bases = int(entry["total_bases"]) + correct_bases = int(entry["correct_bases"]) + except Exception: + return None + + if total_bases <= 0: + return None + if correct_bases / total_bases < 0.35: + return None + return correct_bases, total_bases + + +def _store_cached_verification_result( + *, + input_file: Path, + ref_genome: Path, + motifs: list[str], + correct_bases: int, + total_bases: int, +) -> None: + if os.environ.get("DIMELO_DISABLE_VERIFY_CACHE", "").lower() in {"1", "true", "yes"}: + return + + cache_path = _verification_cache_path(input_file) + cache_data = _load_verification_cache(cache_path) + entries: dict[str, dict] = cache_data["entries"] + key = _verification_cache_key(input_file=input_file, ref_genome=ref_genome, motifs=motifs) + entries[key] = { + "input": _file_fingerprint(input_file), + "ref": _file_fingerprint(ref_genome), + "motifs": sorted(str(motif) for motif in motifs), + "correct_bases": int(correct_bases), + "total_bases": int(total_bases), + "timestamp_ns": time.time_ns(), + } + + if len(entries) > VERIFY_CACHE_MAX_ENTRIES: + sorted_keys = sorted( + entries, + key=lambda entry_key: int(entries[entry_key].get("timestamp_ns", 0)), + ) + for stale_key in sorted_keys[: len(entries) - VERIFY_CACHE_MAX_ENTRIES]: + entries.pop(stale_key, None) + + try: + _save_verification_cache(cache_path, cache_data) + except Exception: + # Best effort cache only. + return + + def verify_inputs( - input_file, - motifs, - ref_genome, + input_file: Path, + motifs: list[str], + ref_genome: Path, + *, + quiet: bool = False, + cache: bool = True, ): """ Checks .bam format and alignment quality (to verify that you are using the right reference genome) The correct-bases-called fraction, if under 35%, means the user almost definitely passed the wrong reference genome. """ + if cache: + cached = _load_cached_verification_result( + input_file=input_file, + ref_genome=ref_genome, + motifs=motifs, + ) + if cached is not None: + if not quiet: + print("Using cached parse_bam input verification results.") + return + check_bam_format(input_file, motifs) correct_bases, total_bases = get_alignment_quality(input_file, ref_genome) if total_bases == 0: @@ -537,6 +642,14 @@ def verify_inputs( raise ValueError( f"First {NUM_READS_TO_CHECK} reads have anomalously low alignment quality: only {100 * correct_bases / total_bases}% of bases align.\nPlease verify that {input_file.name} is actually aligned to {ref_genome.name}." ) + if cache: + _store_cached_verification_result( + input_file=input_file, + ref_genome=ref_genome, + motifs=motifs, + correct_bases=correct_bases, + total_bases=total_bases, + ) return @@ -570,71 +683,51 @@ def check_bam_format( input_bam = pysam.AlignmentFile(bam_file) try: - reads_checked = 0 - for counter, read in enumerate( - itertools.islice(input_bam.fetch(), NUM_READS_TO_CHECK) - ): - reads_checked = counter + 1 - read_dict = read.to_dict() - for tag_string in read_dict["tags"]: - tag = tag_string.split(",")[0].split(":")[0] - if tag == "Mm" or tag == "Ml": - raise ValueError( - f'Base modification tags are out of spec (Mm and Ml instead of MM and ML). \n\nConsider using "modkit update-tags {str(bam_file)} new_file.bam" in the command line with your conda environment active and then trying with the new file. For megalodon basecalling/modcalling, you may also need to pass "--mode ambiguous.\nBe sure to index the resulting .bam file."' - ) - elif tag == "MM": - for tag_substring in tag_string.split(";"): - tag_fields = tag_substring.split(",")[0].split(":") - if len(tag_fields) >= 3: - tag_value = tag_fields[2] - else: - tag_value = tag_fields[0] - if ( - len(tag_value) > 0 - and tag_value[-1] != "?" - and tag_value[-1] != "." - ): - raise ValueError( - f'Base modification tags are out of spec. Need ? or . in TAG:TYPE:VALUE for MM tag, else modified probability is considered to be implicit. \n\nConsider using "modkit update-tags {str(bam_file)} new_file.bam --mode ambiguous" in the command line with your conda environment active and then trying with the new file.' - ) + for counter, read in enumerate(input_bam.fetch()): + if read.has_tag("Mm") or read.has_tag("Ml"): + raise ValueError( + f'Base modification tags are out of spec (Mm and Ml instead of MM and ML). \n\nConsider using "modkit update-tags {str(bam_file)} new_file.bam" in the command line with your conda environment active and then trying with the new file. For megalodon basecalling/modcalling, you may also need to pass "--mode ambiguous.\nBe sure to index the resulting .bam file."' + ) + + if read.has_tag("MM"): + mm_tag = read.get_tag("MM") + for tag_substring in mm_tag.split(";"): + if not tag_substring: + continue + tag_value = tag_substring.split(",", 1)[0] + if ( + len(tag_value) > 0 + and tag_value[-1] != "?" + and tag_value[-1] != "." + ): + raise ValueError( + f'Base modification tags are out of spec. Need ? or . in TAG:TYPE:VALUE for MM tag, else modified probability is considered to be implicit. \n\nConsider using "modkit update-tags {str(bam_file)} new_file.bam --mode ambiguous" in the command line with your conda environment active and then trying with the new file.' + ) + if len(tag_value) > 2 and tag_value[0] in basemods_found_dict: + correct_mod_codes = mod_codes_dict[tag_value[0]] + if tag_value[2] in correct_mod_codes: + basemods_found_dict[tag_value[0]] = True else: - if ( - len(tag_value) > 0 - and tag_value[0] in basemods_found_dict - ): - correct_mod_codes = mod_codes_dict[tag_value[0]] - # valid_mod_codes = mod_codes_dict[tag_value[0]].union( - # utils.BASEMOD_NAMES_DICT[tag_value[0]] - # ) - if tag_value[2] in correct_mod_codes: - basemods_found_dict[tag_value[0]] = True - else: - mod_codes_found_dict[tag_value[0]].add(tag_value[2]) - # With the mode-code-aware motifs, it no longer makes sense to throw this error - # This is because the warning the user gets if their mod code isn't found, or (if none is specified) - # the default mod codes aren't found, can tell them what mod codes *were* found and they can add them - # to their motif or use adjust_mods according to what makes sense. Thus, unexpected codes are not a - # problem (in part this is because parse_bam will now set thresholds for the motif-specified OR default mod codes) - # elif tag_value[2] not in valid_mod_codes: - # raise ValueError( - # f'Base modification name unexpected: {tag_value[2]} to modify {tag_value[0]}, should be in set {valid_mod_codes}. \n\nIf you know what your mod names correspond to in terms of the latest .bam standard, consider using "modkit adjust-mods {str(bam_file)} new_file.bam --convert 5mC_name m --convert N6mA_name a --convert other_basemod_name correct_label" and then trying with the new file. Note: currently supported mod names are {utils.BASEMOD_NAMES_DICT}' - # ) - if reads_checked == NUM_READS_TO_CHECK: - missing_bases = [] - for base, found in basemods_found_dict.items(): - if not found: - missing_bases.append(base) - print( - f""" -WARNING: no modified appropriately-coded values found for {missing_bases} in the first {reads_checked} reads. + mod_codes_found_dict[tag_value[0]].add(tag_value[2]) + + if all(basemods_found_dict.values()): + return + if counter >= NUM_READS_TO_CHECK: + missing_bases = [] + for base, found in basemods_found_dict.items(): + if not found: + missing_bases.append(base) + print( + f""" +WARNING: no modified appropriately-coded values found for {missing_bases} in the first {counter} reads. Do you expect this file to contain these modifications? parse_bam is looking for {motifs} but for {missing_bases} found only found {[f"{base}+{mod_codes}" for base, mod_codes in mod_codes_found_dict.items()]}. Consider passing only the motifs and mod codes (e.g. m,h,a) that you expect to be present in your file. You can use modkit adjust-mods --convert [OPTIONS] to update or consolidate mod codes. See https://github.com/nanoporetech/modkit/blob/master/book/src/advanced_usage.md """ - ) - return + ) + return except ValueError as e: if "fetch called on bamfile without index" in str(e): raise ValueError( @@ -681,55 +774,286 @@ def get_alignment_quality( # checking stage.) if read_sequence is not None: - for pos_in_read, pos_in_ref in read.get_aligned_pairs(): - if pos_in_read is not None and pos_in_ref is not None: - total_bases += 1 - if read_sequence[pos_in_read] == str( - genome_fasta.fetch( - read.reference_name, pos_in_ref, pos_in_ref + 1 - ) - ): - correct_bases += 1 + aligned_pairs = read.get_aligned_pairs(matches_only=True) + if len(aligned_pairs) == 0: + continue + reference_positions = [pos_in_ref for _, pos_in_ref in aligned_pairs] + ref_start = min(reference_positions) + ref_end = max(reference_positions) + 1 + ref_window = genome_fasta.fetch(read.reference_name, ref_start, ref_end) + + total_bases += len(aligned_pairs) + correct_bases += sum( + 1 + for pos_in_read, pos_in_ref in aligned_pairs + if read_sequence[pos_in_read] == ref_window[pos_in_ref - ref_start] + ) return correct_bases, total_bases def create_region_command_list( - output_path: Path, - regions: str | Path | list[str | Path] | None, - window_size: int | None, -) -> tuple[list[str], Path | None]: + output_path, + regions, + window_size, +): """ - Create modkit `--include-bed` arguments and the processed BED path, if regions are provided. + Creates commands to pass to modkit for specifying genomic regions. + + TODO: Split into two function? Convert to bed, then construct commands """ - bed_filepath_processed = _regions_to_processed_bed( - output_path=output_path, - regions=regions, - window_size=window_size, - ) - if bed_filepath_processed is None: - return [], None - return ["--include-bed", str(bed_filepath_processed)], bed_filepath_processed + if regions is not None: + bed_filepath_processed = output_path / "regions.processed.bed" + regions_dict = utils.regions_dict_from_input( + regions, + window_size, + ) + utils.bed_from_regions_dict(regions_dict, bed_filepath_processed) + region_specifier = ["--include-bed", str(bed_filepath_processed)] + else: + bed_filepath_processed = None + region_specifier = [] -def _regions_to_processed_bed( - output_path: Path, - regions: str | Path | list[str | Path] | None, - window_size: int | None, -) -> Path | None: - """ - Build a normalized BED file from region inputs for downstream modkit calls. - """ - if regions is None: + return region_specifier, bed_filepath_processed + + +def _build_extract_motif_command_list(motifs: list[str]) -> list[str]: + seen_motif_specs: set[tuple[str, int]] = set() + motif_command_list: list[str] = [] + for motif in motifs: + parsed_motif = utils.ParsedMotif(motif) + motif_spec = (parsed_motif.motif_seq, parsed_motif.modified_pos) + if motif_spec in seen_motif_specs: + continue + seen_motif_specs.add(motif_spec) + motif_command_list.extend( + ["--motif", parsed_motif.motif_seq, str(parsed_motif.modified_pos)] + ) + if not motif_command_list: + raise ValueError("Error: no motifs specified. Nothing to process.") + return motif_command_list + + +def _parse_positive_int(value: str | None) -> int | None: + if value is None: return None - bed_filepath_processed = output_path / "regions.processed.bed" - regions_dict = utils.regions_dict_from_input( - regions, - window_size, + text = str(value).strip() + if not text: + return None + digits = [] + for char in text: + if char.isdigit(): + digits.append(char) + else: + break + if not digits: + return None + parsed = int("".join(digits)) + return parsed if parsed > 0 else None + + +def _slurm_memory_limit_bytes() -> int | None: + mem_per_node_mb = _parse_positive_int(os.environ.get("SLURM_MEM_PER_NODE")) + mem_per_cpu_mb = _parse_positive_int(os.environ.get("SLURM_MEM_PER_CPU")) + cpus_per_task = _parse_positive_int(os.environ.get("SLURM_CPUS_PER_TASK")) + cpus_on_node = _parse_positive_int(os.environ.get("SLURM_CPUS_ON_NODE")) + + candidates: list[int] = [] + if mem_per_node_mb is not None: + candidates.append(mem_per_node_mb * 1024 * 1024) + if mem_per_cpu_mb is not None: + cpus = cpus_per_task or cpus_on_node or utils.cores_to_run(None) + candidates.append(mem_per_cpu_mb * cpus * 1024 * 1024) + if not candidates: + return None + return min(candidates) + + +def _available_memory_bytes_for_modkit() -> int | None: + override = _parse_positive_int(os.environ.get("DIMELO_AVAILABLE_MEMORY_BYTES")) + if override is not None: + return override + + candidates: list[int] = [] + slurm_limit = _slurm_memory_limit_bytes() + if slurm_limit is not None: + candidates.append(slurm_limit) + + try: + import psutil # type: ignore + + candidates.append(int(psutil.virtual_memory().available)) + except Exception: + pass + + if not candidates: + return None + return min(candidates) + + +def _memory_limited_modkit_threads(cpu_limited_threads: int) -> int: + available = _available_memory_bytes_for_modkit() + if available is None: + return cpu_limited_threads + + per_thread = _parse_positive_int(os.environ.get("DIMELO_MODKIT_MEMORY_PER_THREAD_BYTES")) + if per_thread is None: + per_thread = DEFAULT_MODKIT_MEMORY_PER_THREAD_BYTES + + fraction = DEFAULT_MODKIT_MEMORY_FRACTION + fraction_env = os.environ.get("DIMELO_MODKIT_MEMORY_FRACTION") + if fraction_env: + try: + parsed_fraction = float(fraction_env) + if 0 < parsed_fraction <= 1: + fraction = parsed_fraction + except ValueError: + pass + + budget = int(available * fraction) + if budget <= 0: + return 1 + memory_cap = max(1, budget // max(1, per_thread)) + return max(1, min(cpu_limited_threads, memory_cap)) + + +def _sort_bedmethyl_output( + *, + input_bedmethyl: Path, + output_bedmethyl_sorted: Path, + requested_cores: int | None, + quiet: bool, +) -> None: + sort_threads = utils.cores_to_run(requested_cores) + sort_tmpdir = os.environ.get("SLURM_TMPDIR") + basic_command = ["sort", "-k1,1", "-k2,2n", str(input_bedmethyl)] + attempts: list[list[str]] = [] + if sort_threads > 1: + parallel_command = [ + "sort", + "--parallel", + str(sort_threads), + "-k1,1", + "-k2,2n", + str(input_bedmethyl), + ] + if sort_tmpdir: + attempts.append(parallel_command[:-1] + ["-T", sort_tmpdir, parallel_command[-1]]) + attempts.append(parallel_command) + if sort_tmpdir: + attempts.append(["sort", "-k1,1", "-k2,2n", "-T", sort_tmpdir, str(input_bedmethyl)]) + attempts.append(basic_command) + + last_error: subprocess.CalledProcessError | None = None + for attempt_index, command in enumerate(attempts): + with output_bedmethyl_sorted.open("w") as sorted_file: + try: + subprocess.run(command, stdout=sorted_file, stderr=subprocess.PIPE, text=True, check=True) + return + except subprocess.CalledProcessError as err: + last_error = err + if not quiet and attempt_index == 0: + print("Falling back to compatible sort options after --parallel sort failure.") + if last_error is not None: + raise last_error + + +def _resolve_modkit_threads_command(*, cores: int | None, quiet: bool) -> list[str]: + available_cores = utils.cores_to_run(None) + if cores is None: + resolved_cores = _memory_limited_modkit_threads(available_cores) + if not quiet: + if resolved_cores < available_cores: + print( + f"No specified number of cores requested. CPU allows {available_cores}, memory-aware cap allocates {resolved_cores}." + ) + else: + print( + f"No specified number of cores requested. {available_cores} available in this runtime, allocating all." + ) + return ["--threads", str(resolved_cores)] + + requested_cores = int(cores) + resolved_cores = utils.cores_to_run(requested_cores) + if requested_cores != resolved_cores and not quiet: + print( + f"Warning: requested {requested_cores} cores, allocating {resolved_cores} based on available CPU/cluster constraints." + ) + elif not quiet: + print(f"Allocating requested {resolved_cores} cores.") + return ["--threads", str(resolved_cores)] + + +def _build_compressed_read_vectors( + *, + valid_coordinates: list[int], + mod_values: list[float], + read_len: int, + thresh: float | None, + compress_level: int, +) -> tuple[np.ndarray, np.ndarray]: + if len(valid_coordinates) > 0: + read_len_along_ref = max(valid_coordinates) + 1 + else: + read_len_along_ref = read_len + + coordinate_array = np.asarray(valid_coordinates, dtype=np.intp) + + mod_vector = np.zeros(read_len_along_ref, dtype=np.uint8) + if coordinate_array.size > 0: + if thresh is None: + # We subtract 0.25 because in modkit they add 0.5, but our elements are zero when the + # base motif isn't present, so to get things to round to the right integers to match the + # original .bam file, subtracting 0.25 is good. Anything from 0.001 to 0.4999 would work. + mod_values_uint8 = np.rint(np.asarray(mod_values) * 256 - 0.25).astype(np.uint8) + else: + mod_values_uint8 = np.asarray(mod_values, dtype=np.uint8) + mod_vector[coordinate_array] = mod_values_uint8 + + valid_vector = np.zeros(read_len_along_ref, dtype=np.uint8) + if coordinate_array.size > 0: + valid_vector[coordinate_array] = 1 + + mod_vector_compressed = np.frombuffer( + gzip.compress(mod_vector.tobytes(), compresslevel=compress_level), + dtype=np.uint8, ) - utils.bed_from_regions_dict(regions_dict, bed_filepath_processed) - return bed_filepath_processed + valid_vector_compressed = np.frombuffer( + gzip.compress(valid_vector.tobytes(), compresslevel=compress_level), + dtype=np.uint8, + ) + return mod_vector_compressed, valid_vector_compressed + + +def _iupac_bases_for_char(base_char: str) -> set[str]: + return IUPAC_BASES.get(base_char.upper(), {base_char.upper()}) + + +def _kmer_matches_parsed_motif(kmer_context: str, parsed_motif: utils.ParsedMotif) -> bool: + kmer = kmer_context.strip().upper() + motif_seq = parsed_motif.motif_seq.upper() + if len(kmer) == 0 or len(kmer) < len(motif_seq): + return False + + kmer_center = len(kmer) // 2 + for start_index in range(0, len(kmer) - len(motif_seq) + 1): + if start_index + parsed_motif.modified_pos != kmer_center: + continue + matches = True + for kmer_char, motif_char in zip( + kmer[start_index : start_index + len(motif_seq)], + motif_seq, + ): + if _iupac_bases_for_char(kmer_char).isdisjoint( + _iupac_bases_for_char(motif_char) + ): + matches = False + break + if matches: + return True + return False def read_by_base_txt_to_hdf5( @@ -740,24 +1064,24 @@ def read_by_base_txt_to_hdf5( quiet: bool = False, compress_level: int = 1, chunk_size: int = 1000, + require_motif_context: bool = False, ) -> None: """ - Takes in a txt file generated by modkit extract and appends all the data from a - specified motif into an hdf5 file. If a thresh is specified, the mod calls are - binarized at write time and the threshold is stored alongside the vectors. - - If the h5 file does not exist it will be created with top-level datasets named - ``read_name``, ``chromosome``, ``read_start``, ``read_end``, ``strand``, ``motif``, - ``mod_vector``, and ``val_vector``. Each dataset stores one value per read, so the arrays - are parallel and have length ``num_reads``. The optional ``threshold`` dataset stores the - scalar threshold used for binarization and is not part of the per-read arrays. - - Each read's position data is stored in genomic reference coordinates on the positive strand - convention. ``read_start`` and ``read_end`` are reconstructed from the aligned modkit extract - coordinates, not copied from the original BAM CIGAR string or any raw alignment tag. In this - representation, ``read_start`` is the leftmost aligned reference position for the read and - ``read_end`` is the rightmost aligned reference position observed while iterating through the - read. The modification vectors are ordered left to right along genomic coordinates. + Takes in a txt file generated by modkit extract and appends + all the data from a specified motif into an hdf5 file. If a thresh is specified, it + also binarizes the mod calls. + + If the h5 file does not exist it will be created and datasets will be added for read_name, + chromosome, read_start, read_end, strand, motif, mod_vector, and val_vector. + + All the datasets (exception threshold) are parallel arrays of length num_reads + + Each read's position data is defined in genomic reference coordinates on the positive strand + (i.e. the read_start is the leftmost aligned position, read_end is the rightmost, vectors + are left to right along genomic coordinates) + + TODO: Make a nice key:value map of the h5 file structure, make sure start and end are documented + as reconstructions NOT original cigarstring alignment info. mention pysam Args: input_txt: a string or Path pointing to a modkit extracted base-by-base modifications @@ -770,37 +1094,30 @@ def read_by_base_txt_to_hdf5( a methylated adenine is specified as 'A,0' or 'A,0,a' and CpG methylation is specified as 'CG,0' or 'CG,0,m'. thresh: a floating point threshold for base modification calling, between zero and one. - If specified as None, raw probabilities will be saved in the .h5 output. If set, - the stored mod_vector values are binary 0/1 values at motif-valid coordinates. + If specified as None, raw probabilities will be saved in the .h5 output. quiet: if True, this suppresses outputs compress_level: gzip compression level for datasets, specifically for vectors for now chunk_size: size of write chunks in reads + require_motif_context: if True, additionally filter rows to motif sequence using the kmer + context column from modkit extract output (used when one extract pass includes many motifs) Returns: None + """ + """ + TODO: There are some issues that are all related here: + dimelo/parse_bam.py:718: error: Incompatible types in assignment (expression has type "Path | None", variable has type "str | Path") [assignment] + dimelo/parse_bam.py:725: error: Item "str" of "str | Path" has no attribute "open" [union-attr] + dimelo/parse_bam.py:890: error: Item "str" of "str | Path" has no attribute "name" [union-attr] + + I'm not sure of the most elegant way to fix it. Come back and address. """ input_txt, output_h5 = utils.sanitize_path_args(input_txt, output_h5) - input_txt = Path(input_txt) - output_h5 = Path(output_h5) parsed_motif = utils.ParsedMotif(motif) - read_name = "" - num_reads = 0 - with input_txt.open(newline="") as txt: - reader = csv.reader(txt, delimiter="\t") - # Check file length - line_index = -1 - for line_index, fields in enumerate(reader): - if line_index > 0 and read_name != fields[0]: - read_name = fields[0] - num_reads += 1 - if line_index < 0: - raise ValueError(f"modkit extract output is empty: {input_txt}") - num_lines = line_index - txt.seek(0) - + with input_txt.open() as txt: with h5py.File(output_h5, "a") as h5: ## Define hdf5 dataset types for later dt_str = h5py.string_dtype(encoding="utf-8") @@ -808,9 +1125,9 @@ def read_by_base_txt_to_hdf5( # h5py does not appear to otherwise support vlen binary dt_vlen = h5py.vlen_dtype(np.dtype("uint8")) - ## Format threshold value and create dataset to store whether this data is thresholded (binary) or raw. - # Option 1: thresholded outputs are written as binary 0/1 vectors and the threshold dataset - # records the cutoff used. Raw-probability outputs are preserved only when thresh is None. + ## Format threshold value and create dataset to store whether this data is thresholded (binary) or raw (float16) + # TODO: should this method thresholding without binarization + # None becomes NaN threshold_to_store = np.nan if thresh is None else thresh if "threshold" in h5: threshold_from_existing = h5["threshold"][()] @@ -823,244 +1140,317 @@ def read_by_base_txt_to_hdf5( else: h5.create_dataset("threshold", data=threshold_to_store) - ## Create read metadata datasets if "read_name" in h5: old_size = h5["read_name"].shape[0] - h5["read_name"].resize((old_size + num_reads,)) else: old_size = 0 h5.create_dataset( "read_name", - (num_reads,), + (old_size,), maxshape=(None,), dtype=dt_str, compression="gzip", compression_opts=9, ) - def ensure_dataset_capacity( - *, - name: str, - dtype, - mismatch_message: str, - compression: str | None = None, - compression_opts: int | None = None, - ) -> None: - if name in h5: - if old_size != h5[name].shape[0]: - print(mismatch_message) - else: - h5[name].resize((old_size + num_reads,)) - return - - create_kwargs: dict[str, object] = { - "maxshape": (None,), - "dtype": dtype, - } - if compression is not None: - create_kwargs["compression"] = compression - if compression_opts is not None: - create_kwargs["compression_opts"] = compression_opts + ## Create read metadata datasets + # TODO: loop through dict instead? + if "chromosome" in h5: + if old_size != h5["chromosome"].shape[0]: + print("size mismatch: read_name:chromosome") + else: h5.create_dataset( - name, - (num_reads,), - **create_kwargs, + "chromosome", + (old_size,), + maxshape=(None,), + dtype=dt_str, + compression="gzip", + compression_opts=9, ) - - for dataset_name, dataset_dtype, mismatch_message in [ - ("chromosome", dt_str, "size mismatch: read_name:chromosome"), - ("read_start", "i", "size mismatch read_name:read_start"), - ("read_end", "i", "size mismatch read_name:read_end"), - ("strand", dt_str, "size mismatch read_name:strand"), - ("motif", dt_str, "size mismatch read_name:motif"), - ]: - ensure_dataset_capacity( - name=dataset_name, - dtype=dataset_dtype, - mismatch_message=mismatch_message, + if "read_start" in h5: + if old_size != h5["read_start"].shape[0]: + print("size mismatch", "read_name", "read_start") + else: + h5.create_dataset( + "read_start", + (old_size,), + maxshape=(None,), + dtype="i", + compression="gzip", + compression_opts=9, + ) + if "read_end" in h5: + if old_size != h5["read_end"].shape[0]: + print("size mismatch", "read_name", "read_end") + else: + h5.create_dataset( + "read_end", + (old_size,), + maxshape=(None,), + dtype="i", + compression="gzip", + compression_opts=9, + ) + if "strand" in h5: + if old_size != h5["strand"].shape[0]: + print("size mismatch", "read_name", "strand") + else: + h5.create_dataset( + "strand", + (old_size,), + maxshape=(None,), + dtype=dt_str, + compression="gzip", + compression_opts=9, + ) + if "motif" in h5: + if old_size != h5["motif"].shape[0]: + print("size mismatch", "read_name", "motif") + else: + h5.create_dataset( + "motif", + (old_size,), + maxshape=(None,), + dtype=dt_str, compression="gzip", compression_opts=9, ) ## Create the vector datasets. These will contain raw bytes formatted into a uint8 array - for dataset_name in ["mod_vector", "val_vector"]: - ensure_dataset_capacity( - name=dataset_name, + # TODO: loop through dict instead + if "mod_vector" in h5: + if old_size != h5["mod_vector"].shape[0]: + print("size mismatch read_name:mod_vector") + else: + h5.create_dataset( + "mod_vector", + (old_size,), + maxshape=(None,), + dtype=dt_vlen, + # compression='gzip', # we are handling compression ourselves because hdf5 is bad at it + # compression_opts=9, + ) + if "val_vector" in h5: + if old_size != h5["val_vector"].shape[0]: + print("size mismatch read_name:val_vector") + else: + h5.create_dataset( + "val_vector", + (old_size,), + maxshape=(None,), dtype=dt_vlen, - mismatch_message=f"size mismatch read_name:{dataset_name}", + # compression='gzip', # we are handling compression ourselves because hdf5 is bad at it + # compression_opts=9, ) + read_name_dataset = h5["read_name"] + chromosome_dataset = h5["chromosome"] + read_start_dataset = h5["read_start"] + read_end_dataset = h5["read_end"] + strand_dataset = h5["strand"] + motif_dataset = h5["motif"] + mod_vector_dataset = h5["mod_vector"] + val_vector_dataset = h5["val_vector"] + ## Add data to datasets from txt file # Initialize loop vars - these will go into datasets - read_name: str | None = None + # TODO: initialize read name to actual first read so we can get rid of the logic in the loop + read_name = "" read_chrom = "" + read_len = 0 ref_strand = "" + reverse_read = False read_start = 0 read_end = 0 - valid_genomic_positions_list: list[int] = [] + valid_coordinates_list: list[int] = [] mod_values_list: list[float] = [] # Count reads for batched write - read_counter = 0 - # Keys (strings): dataset names, values: lists of dataset values by read; string or ints or arrays - # Contents reset at the end of each chunk, after writing to h5 - chunk_rows: defaultdict[str, list[str | int | np.ndarray]] = ( - defaultdict(list) - ) - chunk_row_count = 0 - - def flush_pending_chunk_to_h5() -> None: - nonlocal chunk_row_count, chunk_rows - if chunk_row_count <= 0: + write_index = old_size + safe_chunk_size = max(1, int(chunk_size)) + reads_in_chunk = 0 + + chunk_read_names: list[str] = [] + chunk_chromosomes: list[str] = [] + chunk_read_starts: list[int] = [] + chunk_read_ends: list[int] = [] + chunk_strands: list[str] = [] + chunk_motifs: list[str] = [] + chunk_mod_vectors: list[np.ndarray] = [] + chunk_val_vectors: list[np.ndarray] = [] + + motif_base = parsed_motif.modified_base + motif_mod_codes = parsed_motif.mod_codes + raw_probabilities = thresh is None + + def _write_chunk() -> None: + nonlocal reads_in_chunk, write_index + if reads_in_chunk == 0: return - start_index = old_size + read_counter - chunk_row_count - end_index = old_size + read_counter - for dataset, entry in chunk_rows.items(): - h5[dataset][start_index:end_index] = entry - chunk_rows = defaultdict(list) - chunk_row_count = 0 - - def flush_current_read() -> None: - nonlocal read_counter, chunk_row_count, chunk_rows - - if read_name is None: - return - - read_len_along_ref = max(read_end - read_start, 1) - - # Populate mod vector array appropriately based on thresh settings. - # Option 1: when thresh is provided, write binary 0/1 values; otherwise preserve raw probs. - mod_vector = np.zeros(read_len_along_ref, dtype=np.uint8) - valid_vector = np.zeros(read_len_along_ref, dtype=np.uint8) - - if len(valid_genomic_positions_list) > 0: - valid_coordinates = ( - np.asarray(valid_genomic_positions_list, dtype=int) - read_start + start_index = write_index + end_index = write_index + reads_in_chunk + read_name_dataset.resize((end_index,)) + chromosome_dataset.resize((end_index,)) + read_start_dataset.resize((end_index,)) + read_end_dataset.resize((end_index,)) + strand_dataset.resize((end_index,)) + motif_dataset.resize((end_index,)) + mod_vector_dataset.resize((end_index,)) + val_vector_dataset.resize((end_index,)) + read_name_dataset[start_index:end_index] = chunk_read_names + chromosome_dataset[start_index:end_index] = chunk_chromosomes + read_start_dataset[start_index:end_index] = chunk_read_starts + read_end_dataset[start_index:end_index] = chunk_read_ends + strand_dataset[start_index:end_index] = chunk_strands + motif_dataset[start_index:end_index] = chunk_motifs + mod_vector_dataset[start_index:end_index] = chunk_mod_vectors + val_vector_dataset[start_index:end_index] = chunk_val_vectors + write_index = end_index + chunk_read_names.clear() + chunk_chromosomes.clear() + chunk_read_starts.clear() + chunk_read_ends.clear() + chunk_strands.clear() + chunk_motifs.clear() + chunk_mod_vectors.clear() + chunk_val_vectors.clear() + reads_in_chunk = 0 + + def _append_current_read() -> None: + nonlocal reads_in_chunk + mod_vector_compressed, valid_vector_compressed = ( + _build_compressed_read_vectors( + valid_coordinates=valid_coordinates_list, + mod_values=mod_values_list, + read_len=read_len, + thresh=thresh, + compress_level=compress_level, ) - mod_values = np.asarray(mod_values_list, dtype=float) - in_bounds = (valid_coordinates >= 0) & ( - valid_coordinates < read_len_along_ref - ) - valid_coordinates = valid_coordinates[in_bounds] - mod_values = mod_values[in_bounds] - - if thresh is None: - # We subtract 0.25 because in modkit they add 0.5, but our elements are zero when the - # base motif isn't present, so to get things to round to the right integers to match the - # original .bam file, subtracting 0.25 is good. Anything from 0.001 to 0.4999 would work I think - mod_vector[valid_coordinates] = np.rint( - mod_values * 256 - 0.25 - ).astype(np.uint8) - else: - mod_vector[valid_coordinates] = mod_values.astype(np.uint8) - valid_vector[valid_coordinates] = 1 - - mod_vector_compressed = _compress_uint8_vector( - mod_vector, compress_level=compress_level - ) - valid_vector_compressed = _compress_uint8_vector( - valid_vector, compress_level=compress_level ) - - chunk_rows["read_name"].append(read_name) - chunk_rows["chromosome"].append(read_chrom) - chunk_rows["read_start"].append(read_start) - chunk_rows["read_end"].append(read_end) - chunk_rows["strand"].append(ref_strand) - chunk_rows["motif"].append(motif) - chunk_rows["mod_vector"].append(mod_vector_compressed) - chunk_rows["val_vector"].append(valid_vector_compressed) - - read_counter += 1 - chunk_row_count += 1 - if chunk_row_count >= chunk_size: - flush_pending_chunk_to_h5() + chunk_read_names.append(read_name) + chunk_chromosomes.append(read_chrom) + chunk_read_starts.append(read_start) + chunk_read_ends.append(read_end) + chunk_strands.append(ref_strand) + chunk_motifs.append(motif) + chunk_mod_vectors.append(mod_vector_compressed) + chunk_val_vectors.append(valid_vector_compressed) + reads_in_chunk += 1 + if reads_in_chunk >= safe_chunk_size: + _write_chunk() # Setting up progress bars if not in quiet mode # Skip header - reader = csv.reader(txt, delimiter="\t") - next(reader) - iterator = reader + iterator = txt + header_line = next(iterator, None) + if require_motif_context: + if header_line is None: + raise ValueError( + "Cannot require motif context: extract output is empty (missing header)." + ) + header_fields = header_line.rstrip("\n").split("\t") + if len(header_fields) <= 14: + raise ValueError( + "Cannot require motif context: extract output is missing the kmer context column." + ) if not quiet: iterator = tqdm( iterator, - total=num_lines, - desc=f"Transferring {num_reads} from {input_txt.name} into {output_h5.name}, new size {old_size + num_reads}", - bar_format="{bar}| {desc} {percentage:3.0f}% | {elapsed}<{remaining}", + desc=f"Transferring reads from {input_txt.name} into {output_h5.name}", ) # Loop through txt file - for fields in iterator: - pos_in_genome = int(fields[2]) - canonical_base = fields[15] - prob = float(fields[10]) - mod_code = fields[11] + for line in iterator: + # TODO: use csv module + fields = line.rstrip("\n").split("\t") + read_id = fields[0] pos_in_read = int(fields[1]) - line_read_len = int(fields[9]) - line_ref_strand = fields[5] - pos_in_read_ref = _reference_oriented_read_offset( - pos_in_read=pos_in_read, - read_length=line_read_len, - ref_strand=line_ref_strand, - ) - start_candidate = pos_in_genome - pos_in_read_ref - end_candidate = start_candidate + line_read_len + pos_in_genome = int(fields[2]) - if read_name != fields[0]: - flush_current_read() + if read_name != read_id: + if len(read_name) > 0: + _append_current_read() ## Set up for next read # Metadata - read_name = fields[0] + read_name = read_id read_chrom = fields[3] - ref_strand = line_ref_strand - read_start = start_candidate - read_end = end_candidate + read_len = int(fields[9]) + ref_strand = fields[5] + reverse_read = ref_strand == "-" + if reverse_read: + pos_in_read_ref = read_len - pos_in_read - 1 + else: + pos_in_read_ref = pos_in_read + # Calculate read start (leftmost position on ref genome) + # TODO: logic can be replaced when we switch to true read start/end from modkit + read_start = pos_in_genome - pos_in_read_ref + read_end = 0 # Instantiate lists mod_values_list = [] - valid_genomic_positions_list = [] - - # keep read extents in reference coordinates by using inferred starts/ends from - # each line, which is robust even when rows are not ordered by genomic position - read_start = min(read_start, start_candidate) - read_end = max(read_end, end_candidate) - + valid_coordinates_list = [] + + # TODO: verify that read position is in the right (ref) coordinate system + if reverse_read: + pos_in_read_ref = read_len - pos_in_read - 1 + else: + pos_in_read_ref = pos_in_read + + # Adjust the read_end (rightmost position on ref genome) each time there's a new mod + # This will lead to the most accurate end positions for gapped reads + # TODO: logic can be replaced when we switch to true read start/end from modkit + read_end = pos_in_genome + (read_len - pos_in_read_ref) # Regardless of whether its a new read or not, # add modification to vector if motif type is correct # for the motif in question + canonical_base = fields[15] + mod_code = fields[11] if ( - canonical_base == parsed_motif.modified_base - and mod_code in parsed_motif.mod_codes + canonical_base == motif_base + and mod_code in motif_mod_codes ): - valid_genomic_positions_list.append(pos_in_genome) - if thresh is None: + if require_motif_context: + if len(fields) <= 14: + raise ValueError( + "Cannot require motif context: encountered extract row without kmer context column." + ) + if not _kmer_matches_parsed_motif(fields[14], parsed_motif): + continue + valid_coordinates_list.append(pos_in_genome - read_start) + prob = float(fields[10]) + if raw_probabilities: mod_values_list.append(prob) elif prob >= thresh: mod_values_list.append(1) else: mod_values_list.append(0) - flush_current_read() - flush_pending_chunk_to_h5() + # Save the last read + # TODO: try to consolidate + if len(read_name) > 0: + _append_current_read() + _write_chunk() return def prep_output_directory( output_directory: Path | None, output_name: str, - default_directory: Path, + input_file: Path, output_file_names: list[str], ) -> tuple[Path, list[Path]]: """ As a side effect, if files exist that match the requested outputs, they are deleted. + TODO: Is it kind of silly that this takes in input_file? Maybe should take in some generic default parameter, or this default should be set outside this method? + Args: output_directory: Path pointing to an output directory. If left as None, outputs will be stored in a new folder within the input directory. output_name: a string that will be used to create an output folder containing the intermediate and final outputs, along with any logs. - default_directory: default output directory when output_directory is None + input_file: Path to input file; used to define default output directory output_file_names: list of names of desired output files Returns: @@ -1068,7 +1458,7 @@ def prep_output_directory( * List of Paths to requested output files """ if output_directory is None: - output_directory = default_directory + output_directory = input_file.parent print(f"No output directory provided, using input directory {output_directory}") output_path = output_directory / output_name diff --git a/dimelo/plot_read_browser.py b/dimelo/plot_read_browser.py index febccac..95b330f 100644 --- a/dimelo/plot_read_browser.py +++ b/dimelo/plot_read_browser.py @@ -154,15 +154,19 @@ def format_browser_data( read_tuples, columns=entry_labels, exclude=to_exclude ) - # For each row, pull out just the positions of valid bases and the probabilities at those positions - # TODO: I don't like using iterrows, but it seems silly to have two calls to apply that do basically the same thing redundantly; just looping once instead + # For each row, pull out just the positions of valid bases and the probabilities at those positions. + # Iterate over NumPy-backed column arrays to avoid iterrows() per-row Series overhead. + mod_vectors = read_df["mod_vector"].to_numpy(copy=False) + val_vectors = read_df["val_vector"].to_numpy(copy=False) + read_starts = read_df["read_start"].to_numpy(copy=False) prob_vectors = [] pos_vectors = [] - for _, row in read_df.iterrows(): - selector = row.val_vector == 1 - all_positions = np.arange(len(row.mod_vector)) + row.read_start - prob_vectors.append(row.mod_vector[selector]) - pos_vectors.append(all_positions[selector]) + for mod_vector, val_vector, read_start in zip( + mod_vectors, val_vectors, read_starts, strict=False + ): + selected_indices = np.flatnonzero(val_vector == 1) + prob_vectors.append(mod_vector[selected_indices]) + pos_vectors.append(selected_indices + read_start) read_df["prob_vector"] = prob_vectors read_df["pos_vector"] = pos_vectors @@ -237,32 +241,56 @@ def collapse_rows( TODO: This could be improved by checking for overlaps on both ends of the seed read for each row. This might allow other types of pre-sorting to work more effectively. """ + read_count = len(read_extent_df) # Sentinel value for un-indexed reads is -1 - collapsed_indices = -np.ones(len(read_extent_df), dtype=int) + collapsed_indices = -np.ones(read_count, dtype=int) + if read_count == 0: + return pd.Series(collapsed_indices, index=read_extent_df["y_index"]) + + starts = read_extent_df["read_start"].to_numpy(copy=False) + ends = read_extent_df["read_end"].to_numpy(copy=False) + + # parent[i] points to the next unassigned index at or after i; parent[n] is a sentinel. + parent = np.arange(read_count + 1, dtype=int) + + def _find_next_unassigned(index: int) -> int: + while parent[index] != index: + parent[index] = parent[parent[index]] + index = parent[index] + return index + + def _mark_assigned(index: int) -> None: + parent[index] = _find_next_unassigned(index + 1) - # Collapse reads curr_y_idx = 0 - for seed_read_idx in range(len(read_extent_df)): - # If seed read has been indexed already, move on - if collapsed_indices[seed_read_idx] != -1: - continue + seed_search_start = 0 + while True: + seed_read_idx = _find_next_unassigned(seed_search_start) + if seed_read_idx >= read_count: + break + collapsed_indices[seed_read_idx] = curr_y_idx + _mark_assigned(seed_read_idx) + + curr_row_end = int(ends[seed_read_idx]) + scan_cursor = seed_read_idx + while True: + # Preserve the original one-pass scan semantics while skipping impossible ranges. + start_threshold = int( + np.searchsorted(starts, curr_row_end + minimum_gap, side="right") + ) + candidate_start = max(scan_cursor + 1, start_threshold) + candidate_idx = _find_next_unassigned(candidate_start) + if candidate_idx >= read_count: + break - # Add any other non-indexed reads that fit onto the current row - curr_row_end = read_extent_df.iloc[seed_read_idx]["read_end"] - for other_read_idx in range(seed_read_idx + 1, len(read_extent_df)): - # If other read has been indexed already, move on - if collapsed_indices[other_read_idx] != -1: - continue - # If other read fits onto the current row, index it - if ( - read_extent_df.iloc[other_read_idx]["read_start"] - > curr_row_end + minimum_gap - ): - collapsed_indices[other_read_idx] = curr_y_idx - curr_row_end = read_extent_df.iloc[other_read_idx]["read_end"] + collapsed_indices[candidate_idx] = curr_y_idx + _mark_assigned(candidate_idx) + curr_row_end = int(ends[candidate_idx]) + scan_cursor = candidate_idx curr_y_idx += 1 + seed_search_start = seed_read_idx # Series mapping original indices to collapsed indices idx_map_orig2collapse = pd.Series( @@ -274,14 +302,18 @@ def collapse_rows( match meta_sort: case "full_extent": # sort by full extent of the covered reads in the row (max end - min start) - idx_map_meta2collapse = ( - read_extent_df.groupby(collapsed_indices) - .apply( - lambda row_group: row_group.read_end.max() - - row_group.read_start.min() + grouped = ( + read_extent_df.assign(_collapsed=collapsed_indices) + .groupby("_collapsed", sort=False) + .agg( + start_min=("read_start", "min"), + end_max=("read_end", "max"), ) + ) + idx_map_meta2collapse = ( + (grouped["end_max"] - grouped["start_min"]) .sort_values(ascending=False) - .reset_index()["index"] + .index ) case "covered_bases": # sort by number of bases covered by reads in the row @@ -290,14 +322,15 @@ def collapse_rows( read_lengths.groupby(collapsed_indices) .sum() .sort_values(ascending=False) - .reset_index()["index"] + .index ) case _: raise ValueError(f"Invalid meta sorting option: {meta_sort}") # Series mapping collapsed indices to meta indices idx_map_collapse2meta = pd.Series( - idx_map_meta2collapse.index.values, index=idx_map_meta2collapse + np.arange(len(idx_map_meta2collapse), dtype=int), + index=idx_map_meta2collapse, ) # Return Series mapping original indices to meta indices @@ -365,21 +398,43 @@ def make_browser_figure( plot_bgcolor="rgba(0,0,0,0)", xaxis=dict(range=[region_start, region_end]), ) - # TODO: I feel like there has to be a cleaner way to do this, maybe using plotly express, but I dont know and I'm just trying to get this done first. Lots of iterrows. Sad. fig = plotly.graph_objects.Figure(layout=layout) - for _, row in read_extent_df.iterrows(): - # TODO: How can I get the hover information for the reads to match the ones for the mod events? Not sure how to get customdata and hovertemplate working here. + if not read_extent_df.empty: + starts = read_extent_df["read_start"].to_numpy(copy=False) + ends = read_extent_df["read_end"].to_numpy(copy=False) + y_values = read_extent_df["y_index"].to_numpy(copy=False) + read_names = read_extent_df["read_name"].astype(str).to_numpy(copy=False) + + n_reads = len(read_extent_df) + x_coords = np.empty(n_reads * 3, dtype=object) + y_coords = np.empty(n_reads * 3, dtype=float) + hover_text = np.empty(n_reads * 3, dtype=object) + + x_coords[0::3] = starts + x_coords[1::3] = ends + x_coords[2::3] = None + + y_coords[0::3] = y_values + y_coords[1::3] = y_values + y_coords[2::3] = np.nan + + hover_text[0::3] = read_names + hover_text[1::3] = read_names + hover_text[2::3] = "" + fig.add_trace( plotly.graph_objects.Scatter( - x=[row.read_start, row.read_end], - y=[row.y_index, row.y_index], + x=x_coords, + y=y_coords, mode="lines", line=dict(width=width, color="lightgrey"), showlegend=False, hoverinfo="text", - hovertext=row.read_name, + hovertext=hover_text, + connectgaps=False, ) ) + for motif_idx, (motif, motif_df) in enumerate(mod_event_df.groupby("motif")): min_overall = motif_df["prob"].min() max_overall = motif_df["prob"].max() diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 69ba170..2945d9d 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -3,6 +3,7 @@ from collections import Counter from dataclasses import dataclass +import numpy as np import pandas as pd from dimelo.distribution import _require_columns @@ -1114,23 +1115,39 @@ def prepare_region_discovery_hit_context_data( f"{', '.join(missing_selected_hit_ids)}." ) + windows_by_contig: dict[str, pd.DataFrame] = {} + window_position_by_contig: dict[str, dict[str, int]] = {} + for contig, contig_windows in windows.groupby("contig", sort=False): + contig_table = contig_windows.reset_index(drop=True) + windows_by_contig[contig] = contig_table + window_position_by_contig[contig] = dict( + zip(contig_table["window_id"], contig_table.index, strict=False) + ) + context_frames: list[pd.DataFrame] = [] padding = int(padding_windows or 0) + has_rank = "rank" in selected_hits.columns - for _, hit in selected_hits.iterrows(): - same_contig = windows.loc[windows["contig"] == hit["contig"]].reset_index(drop=True) - hit_positions = same_contig.index[same_contig["window_id"] == hit["window_id"]].tolist() - if not hit_positions: + for hit in selected_hits.itertuples(index=False): + hit_contig = hit.contig + hit_window_id = hit.window_id + contig_windows = windows_by_contig.get(hit_contig) + if contig_windows is None: + continue + + hit_position = window_position_by_contig[hit_contig].get(hit_window_id) + if hit_position is None: continue - hit_position = hit_positions[0] start_index = max(0, hit_position - padding) - end_index = min(len(same_contig), hit_position + padding + 1) - context = same_contig.iloc[start_index:end_index].copy() - context["selected_hit_id"] = hit["window_id"] - context["selected_hit_rank"] = hit.get("rank") - context["relative_window_offset"] = list(range(start_index - hit_position, end_index - hit_position)) - context["is_selected_hit"] = context["window_id"] == hit["window_id"] + end_index = min(len(contig_windows), hit_position + padding + 1) + context = contig_windows.iloc[start_index:end_index].copy() + context["selected_hit_id"] = hit_window_id + context["selected_hit_rank"] = getattr(hit, "rank") if has_rank else np.nan + context["relative_window_offset"] = np.arange( + start_index - hit_position, end_index - hit_position + ) + context["is_selected_hit"] = context["window_id"] == hit_window_id context_frames.append(context) if context_frames: diff --git a/dimelo/region_analysis.py b/dimelo/region_analysis.py index e5e9248..9b67e01 100644 --- a/dimelo/region_analysis.py +++ b/dimelo/region_analysis.py @@ -1,20 +1,73 @@ from __future__ import annotations +import concurrent.futures from pathlib import Path from typing import Sequence import numpy as np -from . import cluster +from . import cluster, utils from .models import SampleSpec +def _build_sample_region_features( + *, + sample: SampleSpec, + motif: str, + matched_regions: str | Path | list[str | Path] | None, + pileup_paths: dict[str, str | Path] | None, + cores: int | None, + regions_executor: concurrent.futures.Executor | None = None, +) -> tuple[np.ndarray, list[dict[str, object]]]: + pileup_path = None + if pileup_paths is not None: + pileup_path = pileup_paths.get(sample.sample_id) + if pileup_path is None: + if not sample.metadata or "pileup_path" not in sample.metadata: + raise ValueError( + f"Sample {sample.sample_id!r} is missing a pileup_path for region_anchored mode." + ) + pileup_path = sample.metadata["pileup_path"] + + regions = matched_regions or sample.regions_bed + if regions is None: + raise ValueError( + f"Sample {sample.sample_id!r} requires matched_regions or regions_bed." + ) + + matrix, region_metadata = cluster.region_feature_matrix_from_pileup( + bedmethyl_file=pileup_path, + motif=motif, + regions=regions, + cores=cores, + quiet=True, + regions_executor=regions_executor, + ) + + matrix_float32 = np.asarray(matrix, dtype=np.float32) + metadata_rows = [ + { + "sample_id": sample.sample_id, + "condition": sample.condition, + "replicate": sample.replicate, + "region_id": f"{chrom}:{start}-{end}:{strand}", + "chromosome": chrom, + "start": start, + "end": end, + "strand": strand, + } + for chrom, start, end, strand in region_metadata + ] + return matrix_float32, metadata_rows + + def build_region_feature_table( *, samples: Sequence[SampleSpec], motifs: Sequence[str], matched_regions: str | Path | list[str | Path] | None, pileup_paths: dict[str, str | Path] | None = None, + cores: int | None = None, ) -> tuple[np.ndarray, list[dict[str, object]]]: """ Build one region-level feature row per sample and matched region. @@ -28,45 +81,67 @@ def build_region_feature_table( "region_anchored mode." ) - matrices: list[np.ndarray] = [] - metadata_rows: list[dict[str, object]] = [] - - for sample in samples: - pileup_path = None - if pileup_paths is not None: - pileup_path = pileup_paths.get(sample.sample_id) - if pileup_path is None: - if not sample.metadata or "pileup_path" not in sample.metadata: - raise ValueError( - f"Sample {sample.sample_id!r} is missing a pileup_path for region_anchored mode." - ) - pileup_path = sample.metadata["pileup_path"] + sample_list = list(samples) + if not sample_list: + raise ValueError("No region feature rows were generated.") - regions = matched_regions or sample.regions_bed - if regions is None: - raise ValueError( - f"Sample {sample.sample_id!r} requires matched_regions or regions_bed." - ) + if cores is None: + sample_workers = 1 + per_sample_cores: int | None = None + else: + cores_to_run = max(1, utils.cores_to_run(cores)) + sample_workers = min(len(sample_list), cores_to_run) + per_sample_cores = max(1, cores_to_run // sample_workers) - matrix, region_metadata = cluster.region_feature_matrix_from_pileup( - bedmethyl_file=pileup_path, - motif=motifs[0], - regions=regions, - ) - matrices.append(np.asarray(matrix, dtype=np.float32)) - for chrom, start, end, strand in region_metadata: - metadata_rows.append( - { - "sample_id": sample.sample_id, - "condition": sample.condition, - "replicate": sample.replicate, - "region_id": f"{chrom}:{start}-{end}:{strand}", - "chromosome": chrom, - "start": start, - "end": end, - "strand": strand, - } - ) + if sample_workers > 1: + ordered_results: list[tuple[np.ndarray, list[dict[str, object]]] | None] = [ + None + ] * len(sample_list) + with concurrent.futures.ThreadPoolExecutor(max_workers=sample_workers) as executor: + future_by_index = { + index: executor.submit( + _build_sample_region_features, + sample=sample, + motif=motifs[0], + matched_regions=matched_regions, + pileup_paths=pileup_paths, + cores=per_sample_cores, + regions_executor=None, + ) + for index, sample in enumerate(sample_list) + } + for index, future in future_by_index.items(): + ordered_results[index] = future.result() + results = [result for result in ordered_results if result is not None] + else: + shared_regions_executor = None + if len(sample_list) > 1 and (cores is None or cores > 1): + try: + shared_regions_executor = concurrent.futures.ProcessPoolExecutor( + max_workers=max(1, utils.cores_to_run(cores)), + ) + except Exception: + # Some environments (for example restricted CI sandboxes) cannot + # create process pools; fall back to the legacy per-sample path. + shared_regions_executor = None + try: + results = [ + _build_sample_region_features( + sample=sample, + motif=motifs[0], + matched_regions=matched_regions, + pileup_paths=pileup_paths, + cores=per_sample_cores, + regions_executor=shared_regions_executor, + ) + for sample in sample_list + ] + finally: + if shared_regions_executor is not None: + shared_regions_executor.shutdown(wait=True, cancel_futures=False) + + matrices = [matrix for matrix, _ in results] + metadata_rows = [row for _, rows in results for row in rows] if not matrices: raise ValueError("No region feature rows were generated.") diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py index 7b17152..74bbba7 100644 --- a/dimelo/region_discovery.py +++ b/dimelo/region_discovery.py @@ -654,6 +654,16 @@ def _build_merged_hit(group: pd.DataFrame) -> dict[str, object]: return merged +def _build_window_id_series(frame: pd.DataFrame) -> pd.Series: + return ( + frame["chromosome"].astype(str) + + ":" + + frame["start"].astype("int64").astype(str) + + "-" + + frame["end"].astype("int64").astype(str) + ) + + def merge_adjacent_hits(hits: pd.DataFrame, merge_distance: int) -> pd.DataFrame: if hits.empty: merged = hits.copy() @@ -670,41 +680,34 @@ def merge_adjacent_hits(hits: pd.DataFrame, merge_distance: int) -> pd.DataFrame else 1 ) if {"chromosome", "start", "end"}.issubset(merged.columns): - merged["window_id"] = merged.apply( - lambda row: f"{row['chromosome']}:{int(row['start'])}-{int(row['end'])}", - axis=1, - ) + merged["window_id"] = _build_window_id_series(merged) if {"modified_count", "valid_count"}.issubset(merged.columns): merged["window_fraction"] = _safe_fraction( merged["modified_count"], merged["valid_count"] ) return merged - merged_rows: list[dict[str, object]] = [] - current_group: list[pd.Series] = [ordered.iloc[0]] + same_chromosome = pd.Series(True, index=ordered.index) + if "chromosome" in ordered.columns: + same_chromosome = ordered["chromosome"].eq(ordered["chromosome"].shift()) - def _can_merge(previous: pd.Series, row: pd.Series) -> bool: - same_chromosome = row.get("chromosome") == previous.get("chromosome") - same_strand = row.get("strand") == previous.get("strand") - within_distance = int(row["start"]) <= int(previous["end"]) + merge_distance - return same_chromosome and same_strand and within_distance + same_strand = pd.Series(True, index=ordered.index) + if "strand" in ordered.columns: + same_strand = ordered["strand"].eq(ordered["strand"].shift()) - for _, row in ordered.iloc[1:].iterrows(): - if _can_merge(current_group[-1], row): - current_group.append(row) - continue - merged_rows.append(_build_merged_hit(pd.DataFrame(current_group))) - current_group = [row] + within_distance = ordered["start"].le(ordered["end"].shift().add(merge_distance)) + merge_with_previous = (same_chromosome & same_strand & within_distance).fillna(False) + merge_group = (~merge_with_previous).cumsum() - merged_rows.append(_build_merged_hit(pd.DataFrame(current_group))) - merged = pd.DataFrame(merged_rows) + merged_rows = [ + _build_merged_hit(group) + for _, group in ordered.groupby(merge_group, sort=False, group_keys=False) + ] + merged = pd.DataFrame.from_records(merged_rows) merged = _sort_hits_for_output(merged) if "window_id" not in merged.columns and {"chromosome", "start", "end"}.issubset(merged.columns): - merged["window_id"] = merged.apply( - lambda row: f"{row['chromosome']}:{int(row['start'])}-{int(row['end'])}", - axis=1, - ) + merged["window_id"] = _build_window_id_series(merged) if "merged_window_count" not in merged.columns: merged["merged_window_count"] = 1 diff --git a/dimelo/shared_cluster_tests.py b/dimelo/shared_cluster_tests.py index 4102df6..66012d1 100644 --- a/dimelo/shared_cluster_tests.py +++ b/dimelo/shared_cluster_tests.py @@ -508,6 +508,20 @@ def _build_pooled_omnibus_p_value( return float(omnibus_p_value) +def _mean_by_group_codes( + values: np.ndarray, + group_codes: np.ndarray, + *, + n_groups: int, +) -> np.ndarray: + sums = np.zeros((n_groups, values.shape[1]), dtype=float) + np.add.at(sums, group_codes, values) + counts = np.bincount(group_codes, minlength=n_groups).astype(float, copy=False) + means = np.zeros_like(sums) + np.divide(sums, counts[:, None], out=means, where=counts[:, None] > 0) + return means + + def _score_time_course( *, result: SharedClusterResult, @@ -528,20 +542,21 @@ def _score_time_course( filtered["condition"] = pd.Categorical(filtered["condition"], categories=time_order, ordered=True) filtered = filtered.sort_values(["condition", "sample_id"], kind="stable").reset_index(drop=True) - grouped = ( - filtered.groupby("condition", sort=False, observed=False)[cluster_order] - .mean() - .reindex(time_order) - ) - counts = ( - filtered.groupby("condition", sort=False, observed=False)["sample_id"] - .nunique() - .reindex(time_order) + n_timepoints = len(time_order) + condition_codes = filtered["condition"].cat.codes.to_numpy(dtype=np.int64, copy=False) + if (condition_codes < 0).any(): + raise ValueError("Shared cluster time_course found rows with conditions outside time_order.") + value_matrix = filtered.loc[:, cluster_order].to_numpy(dtype=float) + observed_matrix = _mean_by_group_codes( + value_matrix, + condition_codes, + n_groups=n_timepoints, ) - time_course_table = grouped.reset_index(names="timepoint") - time_course_table["n_samples"] = counts.to_numpy(dtype=int) + counts = np.bincount(condition_codes, minlength=n_timepoints).astype(int, copy=False) + time_course_table = pd.DataFrame(observed_matrix, columns=cluster_order) + time_course_table.insert(0, "timepoint", time_order) + time_course_table["n_samples"] = counts - observed_matrix = grouped.to_numpy(dtype=float) observed_first = observed_matrix[0] observed_last = observed_matrix[-1] observed_delta = observed_last - observed_first @@ -552,19 +567,14 @@ def _score_time_course( permuted_cluster_stats = np.zeros((n_permutations, len(cluster_order)), dtype=float) permuted_omnibus_stats = np.zeros(n_permutations, dtype=float) permuted_trend_stats = np.zeros(n_permutations, dtype=float) - condition_values = filtered["condition"].to_numpy() - value_matrix = filtered.loc[:, cluster_order].to_numpy(dtype=float) for permutation_index in range(n_permutations): - permuted_conditions = rng.permutation(condition_values) - permuted = pd.DataFrame(value_matrix, columns=cluster_order) - permuted["condition"] = permuted_conditions - permuted_grouped = ( - permuted.groupby("condition", sort=False, observed=False)[cluster_order] - .mean() - .reindex(time_order) + permuted_codes = rng.permutation(condition_codes) + permuted_matrix = _mean_by_group_codes( + value_matrix, + permuted_codes, + n_groups=n_timepoints, ) - permuted_matrix = permuted_grouped.to_numpy(dtype=float) permuted_delta = permuted_matrix[-1] - permuted_matrix[0] permuted_cluster_stats[permutation_index] = np.abs(permuted_delta) permuted_omnibus_stats[permutation_index] = _composition_effect_size_from_vectors( diff --git a/dimelo/utils.py b/dimelo/utils.py index c13be1c..63668a2 100644 --- a/dimelo/utils.py +++ b/dimelo/utils.py @@ -1,4 +1,5 @@ import multiprocessing +import os from collections import defaultdict from collections.abc import Sequence from pathlib import Path @@ -43,12 +44,53 @@ rng = np.random.default_rng() +def _parse_positive_int(value: str | None) -> int | None: + if value is None: + return None + text = str(value).strip() + if not text: + return None + digits = [] + for char in text: + if char.isdigit(): + digits.append(char) + else: + break + if not digits: + return None + parsed = int("".join(digits)) + return parsed if parsed > 0 else None + + +def _effective_cpu_count() -> int: + candidates: list[int] = [] + + try: + candidates.append(int(multiprocessing.cpu_count())) + except Exception: + pass + + try: + affinity = os.sched_getaffinity(0) + if affinity: + candidates.append(len(affinity)) + except Exception: + pass + + slurm_cpus_per_task = _parse_positive_int(os.environ.get("SLURM_CPUS_PER_TASK")) + if slurm_cpus_per_task is not None: + candidates.append(slurm_cpus_per_task) + + if not candidates: + return 1 + return max(1, min(candidates)) + + def cores_to_run(cores): - cores_avail = multiprocessing.cpu_count() - if cores is None or cores > cores_avail: + cores_avail = _effective_cpu_count() + if cores is None: return cores_avail - else: - return cores + return max(1, min(int(cores), cores_avail)) class ParsedMotif: diff --git a/dimelo/workflows.py b/dimelo/workflows.py index f65bbea..24766e7 100644 --- a/dimelo/workflows.py +++ b/dimelo/workflows.py @@ -258,14 +258,31 @@ def _cluster_label_strings(labels: np.ndarray) -> list[str]: def _cluster_profiles( - feature_frame: pd.DataFrame, - assignments: pd.DataFrame, + feature_matrix: np.ndarray, + feature_names: list[str], + cluster_labels: np.ndarray, ) -> pd.DataFrame: - profiles = feature_frame.copy() - profiles["cluster"] = assignments["cluster"].to_numpy() - aggregated = profiles.groupby("cluster", sort=True).mean(numeric_only=True).reset_index() - counts = assignments.groupby("cluster", sort=True).size().reset_index(name="count") - return counts.merge(aggregated, on="cluster", how="left") + if feature_matrix.shape[0] == 0: + return pd.DataFrame(columns=["cluster", "count", *feature_names]) + + labels = np.asarray(cluster_labels, dtype=str) + unique_labels = np.unique(labels) + codes = pd.Categorical(labels, categories=unique_labels, ordered=True).codes + counts = np.bincount(codes, minlength=len(unique_labels)).astype(np.int64, copy=False) + + sums = np.zeros((len(unique_labels), feature_matrix.shape[1]), dtype=np.float64) + np.add.at(sums, codes, np.asarray(feature_matrix, dtype=np.float64)) + means = np.divide( + sums, + counts[:, None], + out=np.zeros_like(sums), + where=counts[:, None] > 0, + ) + + profiles = pd.DataFrame(means, columns=feature_names) + profiles.insert(0, "count", counts) + profiles.insert(0, "cluster", unique_labels) + return profiles def _sample_training_rows( @@ -662,10 +679,13 @@ def _build_shared_cluster_result( assignments = pd.DataFrame(metadata_rows) assignments["cluster"] = _cluster_label_strings(predicted_ordered) - feature_frame = pd.DataFrame(full_matrix, columns=feature_names) cluster_distribution = distribution.build_cluster_distribution(assignments) condition_distribution = distribution.build_condition_distribution(cluster_distribution) - cluster_profiles = _cluster_profiles(feature_frame, assignments) + cluster_profiles = _cluster_profiles( + full_matrix, + feature_names, + assignments["cluster"].to_numpy(), + ) plot_data = { "cluster_distribution_bar": plotting.prepare_cluster_distribution_bar_data( cluster_distribution @@ -742,6 +762,7 @@ def shared_cluster_distribution( artifact_policy: str = "prefer_cached", random_state: int = 42, make_plots: bool = True, + cores: int | None = None, ) -> SharedClusterResult: """ Fit one shared clustering model on pooled read windows and assign all reads back @@ -802,27 +823,38 @@ def shared_cluster_distribution( motifs=motif_list, matched_regions=matched_regions, pileup_paths=pileup_paths, + cores=cores, ) sample_by_id = {sample.sample_id: sample for sample in sample_list} for row in metadata_rows: sample = sample_by_id[row["sample_id"]] _merge_sample_metadata(row, sample.metadata) - sample_ids = [row["sample_id"] for row in metadata_rows] + sample_row_positions: dict[str, list[int]] = { + sample.sample_id: [] for sample in sample_list + } + for index, row in enumerate(metadata_rows): + sample_id = row["sample_id"] + if sample_id in sample_row_positions: + sample_row_positions[sample_id].append(index) + sample_row_indices = { + sample_id: np.asarray(indices, dtype=int) + for sample_id, indices in sample_row_positions.items() + } sample_dataset_sizes = { - sample_id: int(sum(1 for row_sample in sample_ids if row_sample == sample_id)) - for sample_id in {sample.sample_id for sample in sample_list} + sample.sample_id: int(sample_row_indices[sample.sample_id].size) + for sample in sample_list } sample_normalization = { sample.sample_id: {"global_offset": None} for sample in sample_list } region_matrix = np.asarray(feature_matrix, dtype=float) if signal_normalization in {"per_sample_global", "control_regions"}: - for sample_id in sample_dataset_sizes: - mask = np.array([row["sample_id"] == sample_id for row in metadata_rows], dtype=bool) + for sample in sample_list: + sample_id = sample.sample_id + sample_indices = sample_row_indices[sample_id] + if sample_indices.size == 0: + continue if signal_normalization == "control_regions": - sample = next( - sample_item for sample_item in sample_list if sample_item.sample_id == sample_id - ) control_regions = sample.regions_bed if control_regions is None or control_regions == matched_regions: raise ValueError( @@ -852,11 +884,12 @@ def shared_cluster_distribution( motifs=motif_list, matched_regions=control_regions, pileup_paths={sample.sample_id: control_path}, + cores=cores, ) offset = float(np.asarray(control_matrix, dtype=float).mean()) else: - offset = float(region_matrix[mask].mean()) - region_matrix[mask] = region_matrix[mask] - offset + offset = float(region_matrix[sample_indices].mean()) + region_matrix[sample_indices] = region_matrix[sample_indices] - offset sample_normalization[sample_id] = {"global_offset": offset} if cluster_basis == "shape_only": @@ -872,11 +905,7 @@ def shared_cluster_distribution( training_blocks: list[np.ndarray] = [] sample_training_rows: dict[str, int] = {} for sample in sample_list: - mask = np.array( - [row["sample_id"] == sample.sample_id for row in metadata_rows], - dtype=bool, - ) - sample_matrix = region_matrix[mask] + sample_matrix = region_matrix[sample_row_indices[sample.sample_id]] feature_blocks.append(sample_matrix) training_matrix, _ = _sample_training_rows( sample_matrix, diff --git a/tests/test_cluster.py b/tests/test_cluster.py index 7332993..5a83a78 100644 --- a/tests/test_cluster.py +++ b/tests/test_cluster.py @@ -17,8 +17,8 @@ def test_region_feature_matrix_from_pileup(monkeypatch): cluster.load_processed, "regions_to_list", lambda **kwargs: [ - (np.array([1, 1, 0], dtype=float), np.array([2, 2, 1], dtype=float)), - (np.array([0, 2, 2], dtype=float), np.array([1, 4, 4], dtype=float)), + np.array([0.5, 0.5, 0.0], dtype=float), + np.array([0.0, 0.5, 0.5], dtype=float), ], ) @@ -41,6 +41,24 @@ def test_region_feature_matrix_from_pileup(monkeypatch): assert metadata == [("chr1", 0, 3, "+"), ("chr2", 5, 8, "-")] +def test_pileup_fraction_vector_from_bedmethyl(monkeypatch): + monkeypatch.setattr( + cluster.load_processed, + "pileup_vectors_from_bedmethyl", + lambda **kwargs: ( + np.array([1, 1, 0], dtype=float), + np.array([2, 2, 1], dtype=float), + ), + ) + fraction = cluster._pileup_fraction_vector_from_bedmethyl( + bedmethyl_file="pileup.bed.gz", + motif="A,0", + regions="chr1:0-3,+", + pseudo_count=0.0, + ) + np.testing.assert_allclose(fraction, np.array([0.5, 0.5, 0.0], dtype=float)) + + def test_read_mod_fraction_table(monkeypatch): datasets = [ "read_name", diff --git a/tests/test_global_analysis.py b/tests/test_global_analysis.py index f431497..107b000 100644 --- a/tests/test_global_analysis.py +++ b/tests/test_global_analysis.py @@ -29,13 +29,25 @@ def test_summarize_global_samples_from_pileup(monkeypatch): ("s2.bed.gz", "CG,0"): (0, 0), } - def fake_global_counts_from_bedmethyl(bedmethyl_file, motif, quiet=True): - return counts[(bedmethyl_file, motif)] + observed_calls = [] + + def fake_global_counts_for_motifs_from_bedmethyl( + bedmethyl_file, motifs, quiet=True + ): + observed_calls.append((bedmethyl_file, tuple(motifs), quiet)) + return {motif: counts[(bedmethyl_file, motif)] for motif in motifs} + monkeypatch.setattr( + global_analysis, + "_global_counts_for_motifs_from_bedmethyl", + fake_global_counts_for_motifs_from_bedmethyl, + ) monkeypatch.setattr( global_analysis, "_global_counts_from_bedmethyl", - fake_global_counts_from_bedmethyl, + lambda *args, **kwargs: (_ for _ in ()).throw( + AssertionError("legacy single-motif counter should not be used here") + ), ) result = global_analysis.summarize_global_samples( @@ -85,6 +97,85 @@ def fake_global_counts_from_bedmethyl(bedmethyl_file, motif, quiet=True): ) pd.testing.assert_frame_equal(result, expected) + assert observed_calls == [ + ("s1.bed.gz", ("A,0", "CG,0"), True), + ("s2.bed.gz", ("A,0", "CG,0"), True), + ] + + +def test_global_counts_for_motifs_from_bedmethyl_single_pass(monkeypatch): + rows_by_contig = { + "chr1": ["row-1", "row-2"], + "chr2": ["row-3"], + } + + class FakeTabixFile: + opened_paths = [] + fetch_calls = [] + + def __init__(self, path): + self.opened_paths.append(path) + self.contigs = tuple(rows_by_contig) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc, tb): + return False + + def fetch(self, contig): + self.fetch_calls.append(contig) + return iter(rows_by_contig[contig]) + + parsed_motifs = [] + + def fake_parsed_motif(motif): + parsed_motifs.append(motif) + return {"motif": motif} + + processed_rows = [] + process_results = { + ("row-1", "A,0"): (True, 10, 3, 8), + ("row-1", "CG,0"): (False, 10, 99, 99), + ("row-2", "A,0"): (False, 11, 99, 99), + ("row-2", "CG,0"): (True, 11, 4, 9), + ("row-3", "A,0"): (True, 12, 5, 10), + ("row-3", "CG,0"): (True, 12, 6, 12), + } + + def fake_process_pileup_row(row, parsed_motif, region_strand, single_strand=False): + motif = parsed_motif["motif"] + processed_rows.append((row, motif, region_strand, single_strand)) + return process_results[(row, motif)] + + monkeypatch.setattr(global_analysis.pysam, "TabixFile", FakeTabixFile) + monkeypatch.setattr(global_analysis.utils, "ParsedMotif", fake_parsed_motif) + monkeypatch.setattr( + global_analysis.load_processed, + "process_pileup_row", + fake_process_pileup_row, + ) + + counts_by_motif = global_analysis._global_counts_for_motifs_from_bedmethyl( + bedmethyl_file="pileup.bed.gz", + motifs=["A,0", "CG,0"], + ) + + assert counts_by_motif == { + "A,0": (8, 18), + "CG,0": (10, 21), + } + assert parsed_motifs == ["A,0", "CG,0"] + assert FakeTabixFile.opened_paths == ["pileup.bed.gz"] + assert FakeTabixFile.fetch_calls == ["chr1", "chr2"] + assert processed_rows == [ + ("row-1", "A,0", ".", False), + ("row-1", "CG,0", ".", False), + ("row-2", "A,0", ".", False), + ("row-2", "CG,0", ".", False), + ("row-3", "A,0", ".", False), + ("row-3", "CG,0", ".", False), + ] def test_global_counts_from_bedmethyl_sums_only_matching_rows(monkeypatch): diff --git a/tests/test_load_processed.py b/tests/test_load_processed.py new file mode 100644 index 0000000..02695da --- /dev/null +++ b/tests/test_load_processed.py @@ -0,0 +1,405 @@ +import numpy as np +import h5py + +from dimelo import load_processed +from dimelo import utils as dimelo_utils + + +def _single_region_chunks(): + return [ + { + "chromosome": "chr1", + "region_start": 100, + "region_end": 104, + "subregion_start": 100, + "subregion_end": 104, + "strand": "+", + } + ] + + +class _FakeTabix: + def __init__(self, *_args, **_kwargs): + self.contigs = {"chr1"} + + def fetch(self, _chromosome, _start, _end): + return ["row_a", "row_b"] + + +def test_resolve_cores_for_task_count_auto_small_batch_is_single_core(monkeypatch): + monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: 8) + resolved = load_processed._resolve_cores_for_task_count( + requested_cores=None, + task_count=20, + ) + assert resolved == 1 + + +def test_resolve_cores_for_task_count_explicit_cores_are_preserved(monkeypatch): + monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: int(_cores)) + resolved = load_processed._resolve_cores_for_task_count( + requested_cores=4, + task_count=2, + ) + assert resolved == 4 + + +def test_memory_limited_cores_caps_auto_parallelism(monkeypatch): + monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: 8) + monkeypatch.setattr(load_processed, "_available_memory_bytes", lambda: 1024 * 1024 * 1024) + monkeypatch.setattr(load_processed, "AUTO_PARALLEL_MEMORY_FRACTION", 0.5) + monkeypatch.setattr(load_processed, "AUTO_PARALLEL_PROCESS_OVERHEAD_BYTES", 64 * 1024 * 1024) + + resolved = load_processed._memory_limited_cores( + requested_cores=None, + task_count=1024, + bytes_per_task=128 * 1024 * 1024, + extra_shared_bytes=0, + ) + assert resolved == 2 + + +def test_memory_limited_cores_keeps_explicit_override(monkeypatch): + monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: int(_cores)) + monkeypatch.setattr(load_processed, "_available_memory_bytes", lambda: 128 * 1024 * 1024) + + resolved = load_processed._memory_limited_cores( + requested_cores=6, + task_count=1, + bytes_per_task=1024 * 1024 * 1024, + extra_shared_bytes=0, + ) + assert resolved == 6 + + +def test_memory_limited_cores_falls_back_when_memory_unknown(monkeypatch): + monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: 8) + monkeypatch.setattr(load_processed, "_available_memory_bytes", lambda: None) + + resolved = load_processed._memory_limited_cores( + requested_cores=None, + task_count=160, + bytes_per_task=256 * 1024 * 1024, + extra_shared_bytes=0, + ) + assert resolved == 8 + + +def test_slurm_memory_limit_bytes_uses_mem_per_cpu(monkeypatch): + monkeypatch.setenv("SLURM_MEM_PER_CPU", "2048") + monkeypatch.setenv("SLURM_CPUS_PER_TASK", "4") + monkeypatch.delenv("SLURM_MEM_PER_NODE", raising=False) + assert load_processed._slurm_memory_limit_bytes() == 2048 * 4 * 1024 * 1024 + + +def test_slurm_memory_limit_bytes_uses_mem_per_node(monkeypatch): + monkeypatch.setenv("SLURM_MEM_PER_NODE", "8192") + monkeypatch.delenv("SLURM_MEM_PER_CPU", raising=False) + monkeypatch.delenv("SLURM_CPUS_PER_TASK", raising=False) + assert load_processed._slurm_memory_limit_bytes() == 8192 * 1024 * 1024 + + +def test_available_memory_bytes_respects_override(monkeypatch): + monkeypatch.setenv("DIMELO_AVAILABLE_MEMORY_BYTES", "12345") + monkeypatch.setattr(load_processed, "_cgroup_memory_limit_bytes", lambda: 999) + monkeypatch.setattr(load_processed, "_slurm_memory_limit_bytes", lambda: 999) + assert load_processed._available_memory_bytes() == 12345 + + +def test_cores_to_run_respects_slurm_and_affinity(monkeypatch): + monkeypatch.setattr(dimelo_utils.multiprocessing, "cpu_count", lambda: 64) + monkeypatch.setattr( + dimelo_utils.os, + "sched_getaffinity", + lambda _pid: set(range(8)), + raising=False, + ) + monkeypatch.setenv("SLURM_CPUS_PER_TASK", "4") + assert dimelo_utils.cores_to_run(None) == 4 + assert dimelo_utils.cores_to_run(12) == 4 + + +def test_get_tabix_file_caches_by_path(monkeypatch): + class _FakeTabixFile: + calls = 0 + + def __init__(self, _path): + _FakeTabixFile.calls += 1 + self.contigs = set() + + load_processed._clear_tabix_cache() + monkeypatch.setattr(load_processed.pysam, "TabixFile", _FakeTabixFile) + + first = load_processed._get_tabix_file("same.bed.gz") + second = load_processed._get_tabix_file("same.bed.gz") + third = load_processed._get_tabix_file("other.bed.gz") + + assert first is second + assert first is not third + assert _FakeTabixFile.calls == 2 + + +def test_pileup_vectors_from_bedmethyl_single_core_bypasses_process_pool(monkeypatch): + def _raise_if_called(*_args, **_kwargs): + raise AssertionError("ProcessPoolExecutor should not be created for single-core execution.") + + def fake_process_pileup_row(row, **_kwargs): + if row == "row_a": + return True, 100, 2, 5 + if row == "row_b": + return True, 102, 1, 3 + raise AssertionError(f"Unexpected row payload: {row}") + + monkeypatch.setattr(load_processed.utils, "regions_dict_from_input", lambda *_args, **_kwargs: {"chr1": [(100, 104, "+")]}) + monkeypatch.setattr(load_processed.utils, "process_chunks_from_regions_dict", lambda *_args, **_kwargs: _single_region_chunks()) + monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: 1) + monkeypatch.setattr(load_processed.concurrent.futures, "ProcessPoolExecutor", _raise_if_called) + monkeypatch.setattr(load_processed.pysam, "TabixFile", _FakeTabix) + monkeypatch.setattr(load_processed, "process_pileup_row", fake_process_pileup_row) + + modified, valid = load_processed.pileup_vectors_from_bedmethyl( + bedmethyl_file="fake.bed.gz", + motif="A,0", + regions="chr1:100-104,+", + quiet=True, + ) + + np.testing.assert_array_equal(modified, np.array([2, 0, 1, 0], dtype=np.int32)) + np.testing.assert_array_equal(valid, np.array([5, 0, 3, 0], dtype=np.int32)) + + +def test_regions_to_list_single_core_bypasses_process_pool(monkeypatch): + def _raise_if_called(*_args, **_kwargs): + raise AssertionError("ProcessPoolExecutor should not be created for single-core execution.") + + monkeypatch.setattr( + load_processed.utils, + "regions_dict_from_input", + lambda *_args, **_kwargs: {"chr1": [(100, 110, "+"), (120, 130, "-")]}, + ) + monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: 1) + monkeypatch.setattr(load_processed.concurrent.futures, "ProcessPoolExecutor", _raise_if_called) + + result = load_processed.regions_to_list( + function_handle=lambda regions, **_kwargs: f"ok:{regions}", + regions="ignored", + quiet=True, + ) + + assert result == ["ok:chr1:100-110,+", "ok:chr1:120-130,-"] + + +def test_regions_to_list_auto_cores_prefers_single_core_for_small_batches(monkeypatch): + def _raise_if_called(*_args, **_kwargs): + raise AssertionError("ProcessPoolExecutor should not be created for small auto-core batches.") + + monkeypatch.setattr( + load_processed.utils, + "regions_dict_from_input", + lambda *_args, **_kwargs: {"chr1": [(100, 110, "+"), (120, 130, "-")]}, + ) + monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: 8) + monkeypatch.setattr(load_processed.concurrent.futures, "ProcessPoolExecutor", _raise_if_called) + + result = load_processed.regions_to_list( + function_handle=lambda regions, **_kwargs: f"ok:{regions}", + regions="ignored", + quiet=True, + cores=None, + ) + + assert result == ["ok:chr1:100-110,+", "ok:chr1:120-130,-"] + + +def test_regions_to_list_explicit_cores_still_uses_process_pool(monkeypatch): + class _FakeExecutor: + last_max_workers = None + + def __init__(self, *, max_workers): + _FakeExecutor.last_max_workers = max_workers + + def __enter__(self): + return self + + def __exit__(self, *_args): + return False + + def map(self, fn, iterable): + return map(fn, iterable) + + monkeypatch.setattr( + load_processed.utils, + "regions_dict_from_input", + lambda *_args, **_kwargs: {"chr1": [(100, 110, "+"), (120, 130, "-")]}, + ) + monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: int(_cores)) + monkeypatch.setattr(load_processed.concurrent.futures, "ProcessPoolExecutor", _FakeExecutor) + + result = load_processed.regions_to_list( + function_handle=lambda regions, **_kwargs: f"ok:{regions}", + regions="ignored", + quiet=True, + cores=2, + ) + + assert result == ["ok:chr1:100-110,+", "ok:chr1:120-130,-"] + assert _FakeExecutor.last_max_workers == 2 + + +def test_regions_to_list_parallel_batches_preserve_order(monkeypatch): + class _FakeExecutor: + observed_batch_count = None + + def __init__(self, *, max_workers): + self.max_workers = max_workers + + def __enter__(self): + return self + + def __exit__(self, *_args): + return False + + def map(self, fn, iterable): + batches = list(iterable) + _FakeExecutor.observed_batch_count = len(batches) + return map(fn, batches) + + regions = [(idx * 10, idx * 10 + 5, "+") for idx in range(100)] + monkeypatch.setattr( + load_processed.utils, + "regions_dict_from_input", + lambda *_args, **_kwargs: {"chr1": regions}, + ) + monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: int(_cores)) + monkeypatch.setattr(load_processed.concurrent.futures, "ProcessPoolExecutor", _FakeExecutor) + + result = load_processed.regions_to_list( + function_handle=lambda regions, **_kwargs: f"ok:{regions}", + regions="ignored", + quiet=True, + cores=2, + ) + + expected = [f"ok:chr1:{start}-{end},+" for start, end, _strand in regions] + assert result == expected + assert _FakeExecutor.observed_batch_count is not None + assert _FakeExecutor.observed_batch_count < len(regions) + + +def test_regions_to_list_uses_external_executor_when_provided(monkeypatch): + class _ExternalExecutor: + called = False + + def map(self, fn, iterable): + _ExternalExecutor.called = True + return map(fn, iterable) + + def _raise_if_called(*_args, **_kwargs): + raise AssertionError("ProcessPoolExecutor should not be created when external executor is provided.") + + monkeypatch.setattr( + load_processed.utils, + "regions_dict_from_input", + lambda *_args, **_kwargs: {"chr1": [(100, 110, "+"), (120, 130, "-")]}, + ) + monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: int(_cores)) + monkeypatch.setattr(load_processed.concurrent.futures, "ProcessPoolExecutor", _raise_if_called) + + executor = _ExternalExecutor() + result = load_processed.regions_to_list( + function_handle=lambda regions, **_kwargs: f"ok:{regions}", + regions="ignored", + quiet=True, + cores=4, + executor=executor, + ) + + assert result == ["ok:chr1:100-110,+", "ok:chr1:120-130,-"] + assert _ExternalExecutor.called + + +def test_pileup_counts_from_bedmethyl_single_core_bypasses_process_pool(monkeypatch): + def _raise_if_called(*_args, **_kwargs): + raise AssertionError("ProcessPoolExecutor should not be created for single-core execution.") + + def fake_process_pileup_row(row, **_kwargs): + if row == "row_a": + return True, 0, 2, 5 + if row == "row_b": + return True, 0, 1, 3 + raise AssertionError(f"Unexpected row payload: {row}") + + monkeypatch.setattr(load_processed.utils, "regions_dict_from_input", lambda *_args, **_kwargs: {"chr1": [(100, 104, "+")]}) + monkeypatch.setattr(load_processed.utils, "process_chunks_from_regions_dict", lambda *_args, **_kwargs: _single_region_chunks()) + monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: 1) + monkeypatch.setattr(load_processed.concurrent.futures, "ProcessPoolExecutor", _raise_if_called) + monkeypatch.setattr(load_processed.pysam, "TabixFile", _FakeTabix) + monkeypatch.setattr(load_processed, "process_pileup_row", fake_process_pileup_row) + + modified, valid = load_processed.pileup_counts_from_bedmethyl( + bedmethyl_file="fake.bed.gz", + motif="A,0", + regions="chr1:100-104,+", + quiet=True, + ) + + assert modified == 3 + assert valid == 8 + + +def test_read_vectors_from_hdf5_mod_fraction_order_and_missing_defaults(tmp_path): + h5_path = tmp_path / "reads.h5" + with h5py.File(h5_path, "w") as h5: + h5.create_dataset("read_name", data=np.array(["r1", "r1", "r2"], dtype="S2")) + h5.create_dataset("chromosome", data=np.array(["chr1", "chr1", "chr1"], dtype="S4")) + h5.create_dataset("read_start", data=np.array([0, 0, 10], dtype=np.int32)) + h5.create_dataset("read_end", data=np.array([4, 4, 14], dtype=np.int32)) + h5.create_dataset("motif", data=np.array(["A,0", "CG,0", "A,0"], dtype="S4")) + h5.create_dataset("strand", data=np.array(["+", "+", "+"], dtype="S1")) + h5.create_dataset( + "mod_vector", + data=np.array( + [ + [1, 0], + [1, 1], + [0, 1], + ], + dtype=np.uint8, + ), + ) + h5.create_dataset( + "val_vector", + data=np.array( + [ + [1, 1], + [1, 1], + [1, 1], + ], + dtype=np.uint8, + ), + ) + + reads, datasets, _regions_dict = load_processed.read_vectors_from_hdf5( + file=h5_path, + motifs=["CG,0", "A,0"], + regions=None, + sort_by=["read_name", "motif"], + calculate_mod_fractions=True, + ) + + assert datasets[-2:] == ["CG,0_mod_fraction", "A,0_mod_fraction"] + + dataset_idx = {name: i for i, name in enumerate(datasets)} + r1_rows = [row for row in reads if row[dataset_idx["read_name"]] == "r1"] + r2_rows = [row for row in reads if row[dataset_idx["read_name"]] == "r2"] + + assert len(r1_rows) == 2 + assert len(r2_rows) == 1 + + for row in r1_rows: + assert row[dataset_idx["CG,0_mod_fraction"]] == 1.0 + assert row[dataset_idx["A,0_mod_fraction"]] == 0.5 + + r2_row = r2_rows[0] + assert r2_row[dataset_idx["CG,0_mod_fraction"]] == 0.0 + assert r2_row[dataset_idx["A,0_mod_fraction"]] == 0.5 diff --git a/tests/test_parse_bam.py b/tests/test_parse_bam.py index f8423e4..7caaf2a 100644 --- a/tests/test_parse_bam.py +++ b/tests/test_parse_bam.py @@ -1,111 +1,425 @@ -import pytest +from __future__ import annotations + +import gzip from pathlib import Path +import h5py +import numpy as np +import pytest + from dimelo import parse_bam class _FakeRead: - def __init__(self, tags=None): - self._tags = tags or [] + def __init__( + self, + *, + tags: dict[str, object] | None = None, + query_sequence: str | None = None, + aligned_pairs: list[tuple[int, int]] | None = None, + reference_name: str = "chr1", + ) -> None: + self._tags = tags or {} + self.query_sequence = query_sequence + self._aligned_pairs = aligned_pairs or [] + self.reference_name = reference_name + + def has_tag(self, tag: str) -> bool: + return tag in self._tags + + def get_tag(self, tag: str): + return self._tags[tag] + + def get_aligned_pairs(self, matches_only: bool = False): + assert matches_only is True + return list(self._aligned_pairs) + + +class _FakeBam: + def __init__(self, reads: list[_FakeRead]) -> None: + self._reads = reads - def to_dict(self): - return {"tags": self._tags} + def fetch(self): + return iter(self._reads) -class _FakeAlignmentFile: - def __init__(self, read_count): - self.read_count = read_count - self.reads_yielded = 0 +class _FakeFasta: + def __init__(self, mapping: dict[tuple[str, int, int], str]) -> None: + self.mapping = mapping + self.calls: list[tuple[str, int, int]] = [] - def fetch(self): - for _ in range(self.read_count): - self.reads_yielded += 1 - yield _FakeRead() + def fetch(self, chrom: str, start: int, end: int) -> str: + key = (chrom, start, end) + self.calls.append(key) + return self.mapping[key] -class _TagSequenceAlignmentFile: - def __init__(self, reads): - self._reads = reads +def test_check_bam_format_rejects_lowercase_mm_ml(monkeypatch): + fake_bam = _FakeBam(reads=[_FakeRead(tags={"Mm": "x"})]) + monkeypatch.setattr(parse_bam.pysam, "AlignmentFile", lambda *_args, **_kwargs: fake_bam) - def fetch(self): - for read in self._reads: - yield read + with pytest.raises(ValueError, match="Mm and Ml"): + parse_bam.check_bam_format("ignored.bam", motifs=["A,0,a"]) + + +def test_check_bam_format_rejects_implicit_mm_probability(monkeypatch): + fake_bam = _FakeBam(reads=[_FakeRead(tags={"MM": "A+a,0;"})]) + monkeypatch.setattr(parse_bam.pysam, "AlignmentFile", lambda *_args, **_kwargs: fake_bam) + + with pytest.raises(ValueError, match="Need \\? or \\."): + parse_bam.check_bam_format("ignored.bam", motifs=["A,0,a"]) + + +def test_check_bam_format_accepts_expected_mod_code(monkeypatch): + fake_bam = _FakeBam(reads=[_FakeRead(tags={"MM": "A+a?,0;"})]) + monkeypatch.setattr(parse_bam.pysam, "AlignmentFile", lambda *_args, **_kwargs: fake_bam) + + # Should return without raising because the expected mod code is present. + parse_bam.check_bam_format("ignored.bam", motifs=["A,0,a"]) -def test_check_bam_format_consumes_at_most_the_first_100_reads(monkeypatch): - fake_alignment_file = _FakeAlignmentFile(parse_bam.NUM_READS_TO_CHECK + 1) +def test_resolve_modkit_threads_command_auto(monkeypatch): + monkeypatch.setattr(parse_bam, "_memory_limited_modkit_threads", lambda cores: cores) + monkeypatch.setattr( + parse_bam.utils, + "cores_to_run", + lambda cores: 6 if cores is None else min(int(cores), 6), + ) + assert parse_bam._resolve_modkit_threads_command(cores=None, quiet=True) == [ + "--threads", + "6", + ] + +def test_resolve_modkit_threads_command_caps_requested_cores(monkeypatch): + monkeypatch.setattr(parse_bam, "_memory_limited_modkit_threads", lambda cores: cores) monkeypatch.setattr( - parse_bam.pysam, - "AlignmentFile", - lambda *args, **kwargs: fake_alignment_file, + parse_bam.utils, + "cores_to_run", + lambda cores: 5 if cores is None else min(int(cores), 5), + ) + assert parse_bam._resolve_modkit_threads_command(cores=12, quiet=True) == [ + "--threads", + "5", + ] + + +def test_get_alignment_quality_fetches_reference_window_per_read(tmp_path: Path, monkeypatch): + ref = tmp_path / "ref.fa" + ref.write_text(">chr1\nACGT\n", encoding="utf-8") + (tmp_path / "ref.fa.fai").write_text("fake-index\n", encoding="utf-8") + + fake_reads = [ + _FakeRead( + query_sequence="ACG", + aligned_pairs=[(0, 100), (1, 101), (2, 102)], + reference_name="chr1", + ), + _FakeRead( + query_sequence="TT", + aligned_pairs=[(0, 200), (1, 201)], + reference_name="chr1", + ), + ] + fake_bam = _FakeBam(fake_reads) + fake_fasta = _FakeFasta( + mapping={ + ("chr1", 100, 103): "ACG", + ("chr1", 200, 202): "TA", + } ) - parse_bam.check_bam_format("dummy.bam", motifs=["A,0", "CG,0"]) + monkeypatch.setattr( + parse_bam.pysam, "AlignmentFile", lambda *_args, **_kwargs: fake_bam + ) + monkeypatch.setattr( + parse_bam.pysam, "FastaFile", lambda *_args, **_kwargs: fake_fasta + ) - assert fake_alignment_file.reads_yielded == parse_bam.NUM_READS_TO_CHECK + correct, total = parse_bam.get_alignment_quality("ignored.bam", ref) + assert total == 5 + assert correct == 4 + assert fake_fasta.calls == [("chr1", 100, 103), ("chr1", 200, 202)] -def test_check_bam_format_raises_on_malformed_tags_after_motifs_are_found(monkeypatch): - fake_alignment_file = _TagSequenceAlignmentFile( - [ - _FakeRead(["MM:Z:A+a?;C+m?"]), - _FakeRead(["Mm:Z:A+a?"]), - ] + +def test_build_compressed_read_vectors_raw_probabilities(): + mod_compressed, valid_compressed = parse_bam._build_compressed_read_vectors( + valid_coordinates=[0, 2], + mod_values=[0.5, 1.0], + read_len=4, + thresh=None, + compress_level=1, ) - monkeypatch.setattr( - parse_bam.pysam, - "AlignmentFile", - lambda *args, **kwargs: fake_alignment_file, + mod_vector = np.frombuffer(gzip.decompress(mod_compressed.tobytes()), dtype=np.uint8) + valid_vector = np.frombuffer(gzip.decompress(valid_compressed.tobytes()), dtype=np.uint8) + + assert mod_vector.tolist() == [128, 0, 0] + assert valid_vector.tolist() == [1, 0, 1] + + +def test_build_compressed_read_vectors_thresholded_binary(): + mod_compressed, valid_compressed = parse_bam._build_compressed_read_vectors( + valid_coordinates=[1, 3], + mod_values=[1, 0], + read_len=5, + thresh=0.8, + compress_level=1, ) - with pytest.raises(ValueError, match="Mm and Ml instead of MM and ML"): - parse_bam.check_bam_format("dummy.bam", motifs=["A,0", "CG,0"]) + mod_vector = np.frombuffer(gzip.decompress(mod_compressed.tobytes()), dtype=np.uint8) + valid_vector = np.frombuffer(gzip.decompress(valid_compressed.tobytes()), dtype=np.uint8) + + assert mod_vector.tolist() == [0, 1, 0, 0] + assert valid_vector.tolist() == [0, 1, 0, 1] + + +def test_read_by_base_txt_to_hdf5_round_trip_thresholded(tmp_path: Path): + input_txt = tmp_path / "reads.A,0,a.txt" + output_h5 = tmp_path / "reads.h5" + input_txt.write_text( + "\n".join( + [ + "read_id\tread_pos\tref_pos\tchrom\tref_kmer\tref_strand\tref_mod_strand\tfw_soft_clipped_start\tfw_soft_clipped_end\tread_length\tcall_prob\tcall_code\tbase_qual\tref_position\tref_kmer_5mer\tcanonical_base\textra_col", + "read1\t0\t100\tchr1\tNNNNN\t+\t+\t0\t0\t4\t0.9\ta\t0\t100\tAAAAA\tA\tX", + "read1\t1\t101\tchr1\tNNNNN\t+\t+\t0\t0\t4\t0.1\ta\t0\t101\tAAAAA\tA\tX", + "read1\t2\t102\tchr1\tNNNNN\t+\t+\t0\t0\t4\t0.8\tm\t0\t102\tCCCCC\tC\tX", + "read2\t0\t200\tchr2\tNNNNN\t+\t+\t0\t0\t3\t0.7\ta\t0\t200\tAAAAA\tA\tX", + "", + ] + ), + encoding="utf-8", + ) + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0,a", + thresh=0.5, + quiet=True, + chunk_size=1, + ) -def test_threads_command_list_defaults_to_all_available_cores(monkeypatch): - monkeypatch.setattr(parse_bam.multiprocessing, "cpu_count", lambda: 12) + with h5py.File(output_h5, "r") as h5: + assert h5["read_name"].shape[0] == 2 + assert h5["read_name"][0].decode("utf-8") == "read1" + assert h5["read_name"][1].decode("utf-8") == "read2" + assert h5["chromosome"][0].decode("utf-8") == "chr1" + assert h5["chromosome"][1].decode("utf-8") == "chr2" + assert h5["read_start"][0] == 100 + assert h5["read_end"][0] == 104 + assert h5["read_start"][1] == 200 + assert h5["read_end"][1] == 203 + + read1_mod = np.frombuffer( + gzip.decompress(h5["mod_vector"][0].tobytes()), dtype=np.uint8 + ) + read1_val = np.frombuffer( + gzip.decompress(h5["val_vector"][0].tobytes()), dtype=np.uint8 + ) + read2_mod = np.frombuffer( + gzip.decompress(h5["mod_vector"][1].tobytes()), dtype=np.uint8 + ) + read2_val = np.frombuffer( + gzip.decompress(h5["val_vector"][1].tobytes()), dtype=np.uint8 + ) + + assert read1_mod.tolist() == [1, 0] + assert read1_val.tolist() == [1, 1] + assert read2_mod.tolist() == [1] + assert read2_val.tolist() == [1] + + +def test_read_by_base_txt_to_hdf5_appends_across_calls(tmp_path: Path): + first_txt = tmp_path / "reads_first.A,0,a.txt" + second_txt = tmp_path / "reads_second.A,0,a.txt" + output_h5 = tmp_path / "reads.h5" + + header = ( + "read_id\tread_pos\tref_pos\tchrom\tref_kmer\tref_strand\tref_mod_strand\t" + "fw_soft_clipped_start\tfw_soft_clipped_end\tread_length\tcall_prob\tcall_code\t" + "base_qual\tref_position\tref_kmer_5mer\tcanonical_base\textra_col" + ) + first_txt.write_text( + "\n".join( + [ + header, + "read1\t0\t100\tchr1\tNNNNN\t+\t+\t0\t0\t3\t0.9\ta\t0\t100\tAAAAA\tA\tX", + "", + ] + ), + encoding="utf-8", + ) + second_txt.write_text( + "\n".join( + [ + header, + "read2\t0\t200\tchr2\tNNNNN\t+\t+\t0\t0\t3\t0.7\ta\t0\t200\tAAAAA\tA\tX", + "read3\t0\t300\tchr3\tNNNNN\t+\t+\t0\t0\t3\t0.6\ta\t0\t300\tAAAAA\tA\tX", + "", + ] + ), + encoding="utf-8", + ) - command = parse_bam._threads_command_list(cores=None, quiet=True) + parse_bam.read_by_base_txt_to_hdf5( + input_txt=first_txt, + output_h5=output_h5, + motif="A,0,a", + thresh=0.5, + quiet=True, + ) + parse_bam.read_by_base_txt_to_hdf5( + input_txt=second_txt, + output_h5=output_h5, + motif="A,0,a", + thresh=0.5, + quiet=True, + ) - assert command == ["--threads", "12"] + with h5py.File(output_h5, "r") as h5: + assert h5["read_name"].shape[0] == 3 + assert [value.decode("utf-8") for value in h5["read_name"][:]] == [ + "read1", + "read2", + "read3", + ] -def test_threads_command_list_caps_requested_cores_to_available(monkeypatch): - monkeypatch.setattr(parse_bam.multiprocessing, "cpu_count", lambda: 8) +def test_read_by_base_txt_to_hdf5_require_motif_context_missing_column_raises( + tmp_path: Path, +): + input_txt = tmp_path / "reads_missing_context.txt" + output_h5 = tmp_path / "reads_missing_context.h5" + input_txt.write_text( + "\n".join( + [ + "read_id\tread_pos\tref_pos\tchrom\tref_kmer\tref_strand\tref_mod_strand\tfw_soft_clipped_start\tfw_soft_clipped_end\tread_length\tcall_prob\tcall_code\tbase_qual\tref_position", + "read1\t0\t100\tchr1\tNNNNN\t+\t+\t0\t0\t4\t0.9\ta\t0\t100", + "", + ] + ), + encoding="utf-8", + ) - command = parse_bam._threads_command_list(cores=32, quiet=True) + with pytest.raises(ValueError, match="missing the kmer context column"): + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0,a", + thresh=0.5, + quiet=True, + require_motif_context=True, + ) - assert command == ["--threads", "8"] +def test_kmer_matches_parsed_motif_with_iupac(): + parsed = parse_bam.utils.ParsedMotif("GCH,1,m") + assert parse_bam._kmer_matches_parsed_motif("AGCAT", parsed) is True + assert parse_bam._kmer_matches_parsed_motif("AGCGT", parsed) is False -def test_threads_command_list_uses_requested_cores_when_available(monkeypatch): - monkeypatch.setattr(parse_bam.multiprocessing, "cpu_count", lambda: 16) - command = parse_bam._threads_command_list(cores=6, quiet=True) +def test_verify_inputs_uses_cache(tmp_path: Path, monkeypatch): + bam = tmp_path / "input.bam" + ref = tmp_path / "ref.fa" + bam.write_text("bam", encoding="utf-8") + ref.write_text(">chr1\nA\n", encoding="utf-8") - assert command == ["--threads", "6"] + called = {"format": 0, "align": 0} + def _fake_check(_bam, _motifs): + called["format"] += 1 -def test_create_region_command_list_returns_empty_without_regions(tmp_path): - command, bed_path = parse_bam.create_region_command_list( - output_path=tmp_path, - regions=None, - window_size=None, + def _fake_align(_bam, _ref): + called["align"] += 1 + return 90, 100 + + monkeypatch.setattr(parse_bam, "check_bam_format", _fake_check) + monkeypatch.setattr(parse_bam, "get_alignment_quality", _fake_align) + + parse_bam.verify_inputs(bam, ["A,0,a"], ref, quiet=True, cache=True) + parse_bam.verify_inputs(bam, ["A,0,a"], ref, quiet=True, cache=True) + + assert called["format"] == 1 + assert called["align"] == 1 + + +def test_resolve_modkit_threads_command_memory_caps_auto(monkeypatch): + monkeypatch.setattr( + parse_bam.utils, + "cores_to_run", + lambda cores: 8 if cores is None else min(int(cores), 8), ) + monkeypatch.setattr(parse_bam, "_available_memory_bytes_for_modkit", lambda: 4 * 1024 * 1024 * 1024) + monkeypatch.setenv("DIMELO_MODKIT_MEMORY_PER_THREAD_BYTES", str(2 * 1024 * 1024 * 1024)) + monkeypatch.setenv("DIMELO_MODKIT_MEMORY_FRACTION", "1.0") + + assert parse_bam._resolve_modkit_threads_command(cores=None, quiet=True) == [ + "--threads", + "2", + ] + + +def test_extract_runs_modkit_once_and_routes_per_motif(tmp_path: Path, monkeypatch): + bam = tmp_path / "input.bam" + ref = tmp_path / "ref.fa" + bam.write_text("bam", encoding="utf-8") + ref.write_text(">chr1\nA\n", encoding="utf-8") + output_path = tmp_path / "out" + output_path.mkdir(parents=True, exist_ok=True) + output_reads = output_path / "reads.combined_basemods.h5" + + monkeypatch.setattr( + parse_bam.utils, + "sanitize_path_args", + lambda *_args: (bam, ref, tmp_path), + ) + monkeypatch.setattr(parse_bam, "verify_inputs", lambda *_args, **_kwargs: None) + monkeypatch.setattr( + parse_bam, + "prep_output_directory", + lambda **_kwargs: (output_path, [output_reads]), + ) + monkeypatch.setattr( + parse_bam, + "create_region_command_list", + lambda *_args, **_kwargs: ([], None), + ) + monkeypatch.setattr( + parse_bam, + "_resolve_modkit_threads_command", + lambda **_kwargs: ["--threads", "2"], + ) + + modkit_commands: list[list[str]] = [] + + def _fake_run_with_progress_bars(**kwargs): + modkit_commands.append(list(kwargs["command_list"])) + return "" + + routed_reads: list[tuple[str, bool, Path]] = [] - assert command == [] - assert bed_path is None + def _fake_read_to_h5(input_txt, _output_h5, motif, _thresh, **kwargs): + routed_reads.append((motif, kwargs.get("require_motif_context", False), Path(input_txt))) + return None + monkeypatch.setattr(parse_bam.run_modkit, "run_with_progress_bars", _fake_run_with_progress_bars) + monkeypatch.setattr(parse_bam, "read_by_base_txt_to_hdf5", _fake_read_to_h5) -def test_create_region_command_list_writes_processed_bed(tmp_path): - command, bed_path = parse_bam.create_region_command_list( - output_path=tmp_path, - regions="chr1:10-20", - window_size=None, + parse_bam.extract( + input_file=bam, + output_name="out", + ref_genome=ref, + output_directory=tmp_path, + motifs=["A,0,a", "A,0,Y", "CG,0,m"], + quiet=True, + cleanup=False, ) - assert bed_path == Path(tmp_path) / "regions.processed.bed" - assert command == ["--include-bed", str(bed_path)] - assert bed_path.exists() + assert len(modkit_commands) == 1 + command = modkit_commands[0] + assert command.count("--motif") == 2 + assert len(routed_reads) == 3 + assert all(require_context for _motif, require_context, _input_txt in routed_reads) + assert len({input_txt for _motif, _require_context, input_txt in routed_reads}) == 1 diff --git a/tests/test_plot_read_browser.py b/tests/test_plot_read_browser.py new file mode 100644 index 0000000..df9363b --- /dev/null +++ b/tests/test_plot_read_browser.py @@ -0,0 +1,132 @@ +import numpy as np +import pandas as pd + +from dimelo import plot_read_browser + + +def test_collapse_rows_preserves_expected_assignment(): + read_extent_df = pd.DataFrame( + { + "read_start": [0, 10, 30, 60], + "read_end": [50, 20, 40, 70], + "y_index": [0, 1, 2, 3], + "read_name": ["r0", "r1", "r2", "r3"], + } + ) + + collapsed = plot_read_browser.collapse_rows( + read_extent_df, + minimum_gap=0, + meta_sort=None, + ) + + assert collapsed.to_dict() == {0: 0, 1: 1, 2: 1, 3: 0} + + +def test_make_browser_figure_batches_read_extents_into_single_trace(): + read_extent_df = pd.DataFrame( + { + "read_start": [100, 150, 200], + "read_end": [130, 185, 240], + "y_index": [0, 1, 2], + "read_name": ["readA", "readB", "readC"], + } + ) + mod_event_df = pd.DataFrame( + { + "y_index": [0, 1, 2], + "read_name": ["readA", "readB", "readC"], + "motif": ["A,0", "A,0", "A,0"], + "pos": [105, 160, 225], + "prob": [0.4, 0.8, 0.6], + } + ) + + fig = plot_read_browser.make_browser_figure( + read_extent_df=read_extent_df, + mod_event_df=mod_event_df, + collapse=False, + chrom="chr1", + region_start=90, + region_end=260, + colorscales={"A,0": "Viridis"}, + ) + + assert len(fig.data) == 2 + line_trace = fig.data[0] + assert line_trace.mode == "lines" + assert np.count_nonzero(np.array(line_trace.x, dtype=object) == None) == 3 # noqa: E711 + + +def test_format_browser_data_preserves_event_vectors_and_duplicate_extent_handling(): + entry_labels = [ + "chromosome", + "strand", + "region_start", + "region_end", + "read_start", + "read_end", + "read_name", + "motif", + "mod_vector", + "val_vector", + ] + read_tuples = [ + ( + "chr1", + "+", + 90, + 120, + 100, + 110, + "read1", + "A,0", + np.array([0.1, 0.8, 0.2]), + np.array([0, 1, 1]), + ), + ( + "chr1", + "+", + 90, + 120, + 102, + 109, + "read1", + "C,0", + np.array([0.3, 0.4]), + np.array([1, 0]), + ), + ( + "chr1", + "-", + 180, + 210, + 200, + 204, + "read2", + "A,0", + np.array([0.9, 0.7]), + np.array([1, 0]), + ), + ] + + read_extent_df, mod_event_df = plot_read_browser.format_browser_data( + read_tuples=read_tuples, + entry_labels=entry_labels, + ) + + assert read_extent_df.reset_index(drop=True).to_dict("records") == [ + {"read_start": 100, "read_end": 110, "y_index": 0, "read_name": "read1"}, + {"read_start": 200, "read_end": 204, "y_index": 1, "read_name": "read2"}, + ] + + assert list( + mod_event_df[["y_index", "read_name", "motif", "pos", "prob"]].itertuples( + index=False, name=None + ) + ) == [ + (0, "read1", "A,0", 101, 0.8), + (0, "read1", "A,0", 102, 0.2), + (0, "read1", "C,0", 102, 0.3), + (1, "read2", "A,0", 200, 0.9), + ] diff --git a/tests/test_region_analysis.py b/tests/test_region_analysis.py new file mode 100644 index 0000000..698bb76 --- /dev/null +++ b/tests/test_region_analysis.py @@ -0,0 +1,107 @@ +import threading +import time +from pathlib import Path + +import numpy as np + +from dimelo import region_analysis +from dimelo.models import SampleSpec + + +def _samples() -> list[SampleSpec]: + return [ + SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5", metadata={"pileup_path": "s1.bed.gz"}), + SampleSpec(sample_id="s2", condition="TR", extract_h5="s2.h5", metadata={"pileup_path": "s2.bed.gz"}), + ] + + +def test_build_region_feature_table_parallelizes_across_samples(monkeypatch): + started = 0 + started_lock = threading.Lock() + second_started = threading.Event() + + def fake_region_feature_matrix_from_pileup(*, bedmethyl_file, motif, regions, cores, **kwargs): + nonlocal started + with started_lock: + started += 1 + local_started = started + if started >= 2: + second_started.set() + + if local_started == 1: + # If sample processing is serial, this wait will timeout and inflate wall time. + second_started.wait(timeout=1.0) + time.sleep(0.05) + + if str(bedmethyl_file).endswith("s1.bed.gz"): + return np.array([[1.0, 2.0]], dtype=float), [("chr1", 0, 10, "+")] + return np.array([[3.0, 4.0]], dtype=float), [("chr1", 10, 20, "-")] + + monkeypatch.setattr( + region_analysis.cluster, + "region_feature_matrix_from_pileup", + fake_region_feature_matrix_from_pileup, + ) + + start = time.perf_counter() + matrix, metadata_rows = region_analysis.build_region_feature_table( + samples=_samples(), + motifs=["A,0"], + matched_regions=Path("regions.bed"), + cores=2, + ) + elapsed = time.perf_counter() - start + + assert elapsed < 0.5 + assert matrix.shape == (2, 2) + assert matrix.tolist() == [[1.0, 2.0], [3.0, 4.0]] + assert metadata_rows[0]["sample_id"] == "s1" + assert metadata_rows[1]["sample_id"] == "s2" + + +def test_build_region_feature_table_reuses_regions_executor_in_serial_sample_mode(monkeypatch): + class _FakeProcessPoolExecutor: + instances = [] + + def __init__(self, *, max_workers): + self.max_workers = max_workers + self.shutdown_called = False + _FakeProcessPoolExecutor.instances.append(self) + + def shutdown(self, wait=True, cancel_futures=False): + self.shutdown_called = True + + observed_executor_ids = [] + + def fake_region_feature_matrix_from_pileup( + *, bedmethyl_file, motif, regions, cores, regions_executor=None, **kwargs + ): + observed_executor_ids.append(id(regions_executor)) + if str(bedmethyl_file).endswith("s1.bed.gz"): + return np.array([[1.0, 2.0]], dtype=float), [("chr1", 0, 10, "+")] + return np.array([[3.0, 4.0]], dtype=float), [("chr1", 10, 20, "-")] + + monkeypatch.setattr( + region_analysis.concurrent.futures, + "ProcessPoolExecutor", + _FakeProcessPoolExecutor, + ) + monkeypatch.setattr(region_analysis.utils, "cores_to_run", lambda _cores: 8) + monkeypatch.setattr( + region_analysis.cluster, + "region_feature_matrix_from_pileup", + fake_region_feature_matrix_from_pileup, + ) + + matrix, metadata_rows = region_analysis.build_region_feature_table( + samples=_samples(), + motifs=["A,0"], + matched_regions=Path("regions.bed"), + cores=None, + ) + + assert matrix.shape == (2, 2) + assert len(metadata_rows) == 2 + assert len(_FakeProcessPoolExecutor.instances) == 1 + assert _FakeProcessPoolExecutor.instances[0].shutdown_called + assert len(set(observed_executor_ids)) == 1 diff --git a/tests/test_shared_cluster_tests.py b/tests/test_shared_cluster_tests.py index 4e7f3bf..eb91857 100644 --- a/tests/test_shared_cluster_tests.py +++ b/tests/test_shared_cluster_tests.py @@ -216,3 +216,30 @@ def test_shared_cluster_tests_time_course_optional_pairwise_follow_up(): ) assert result.pairwise is not None + + +def test_shared_cluster_tests_time_course_permutations_do_not_build_dataframe_per_iteration( + monkeypatch, +): + from dimelo import shared_cluster_tests + + result = _make_shared_cluster_time_course_result() + n_permutations = 20 + dataframe_calls = 0 + original_dataframe = shared_cluster_tests.pd.DataFrame + + def _counting_dataframe(*args, **kwargs): + nonlocal dataframe_calls + dataframe_calls += 1 + return original_dataframe(*args, **kwargs) + + monkeypatch.setattr(shared_cluster_tests.pd, "DataFrame", _counting_dataframe) + shared_cluster_tests.shared_cluster_tests( + result=result, + contrast=ContrastSpec(mode="time_course", time_order=["t0", "t1", "t2"]), + test="permutation", + n_permutations=n_permutations, + random_state=7, + ) + + assert dataframe_calls < n_permutations From fea1de5bbffcaae12e683654399bea4656ece006 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 14 Apr 2026 15:31:15 -0700 Subject: [PATCH 266/272] docs: unify superpowers plan status and remaining backlog --- docs/superpowers/README.md | 10 +- ...4-02-docs-coherence-and-discoverability.md | 6 + ...anup-and-shared-cluster-tests-execution.md | 344 ++++++++++++++++++ .../2026-04-14-unified-remaining-work-plan.md | 118 ++++++ 4 files changed, 477 insertions(+), 1 deletion(-) create mode 100644 docs/superpowers/plans/2026-04-13-legacy-cleanup-and-shared-cluster-tests-execution.md create mode 100644 docs/superpowers/plans/2026-04-14-unified-remaining-work-plan.md diff --git a/docs/superpowers/README.md b/docs/superpowers/README.md index 3f60afb..d03be88 100644 --- a/docs/superpowers/README.md +++ b/docs/superpowers/README.md @@ -5,6 +5,8 @@ This directory tracks internal design and implementation work for the current br - `specs/` contains design documents. - `plans/` contains executable implementation breakdowns. - Status is tracked here centrally so historical docs can remain stable snapshots. +- Historical plan checkboxes may remain unchecked; treat this index and the + unified remaining-work plan as the canonical execution status. ## Status Labels @@ -45,7 +47,7 @@ This directory tracks internal design and implementation work for the current br ### Shared Clustering - [2026-03-31-shared-clustering-foundations.md](plans/2026-03-31-shared-clustering-foundations.md) - shared clustering models, artifacts, plotting payloads, and workflows. Status: `implemented` -- [2026-04-12-shared-cluster-tests.md](plans/2026-04-12-shared-cluster-tests.md) - shared-cluster global composition inference with permutation paths plus pooled screening options. Status: `partially implemented` +- [2026-04-12-shared-cluster-tests.md](plans/2026-04-12-shared-cluster-tests.md) - shared-cluster global composition inference with permutation paths plus pooled screening options. Status: `implemented` ### Region Analysis @@ -67,12 +69,17 @@ This directory tracks internal design and implementation work for the current br - [2026-04-01-region-contrasts-plotting.md](plans/2026-04-01-region-contrasts-plotting.md) - region contrast plotting prep for profiles and heatmaps. Status: `implemented` - [2026-04-02-region-discovery-plotting.md](plans/2026-04-02-region-discovery-plotting.md) - region discovery plotting prep for per-contig scans and local hit-context views. Status: `implemented` - [2026-04-02-global-analysis-plotting.md](plans/2026-04-02-global-analysis-plotting.md) - global analysis plotting prep for summary and broad-window payloads. Status: `implemented` +- [2026-04-02-shared-clustering-plotting.md](plans/2026-04-02-shared-clustering-plotting.md) - shared clustering plotting prep for distribution, profile, and occupancy payloads. Status: `implemented` +- [2026-04-08-matplotlib-renderers.md](plans/2026-04-08-matplotlib-renderers.md) - Matplotlib renderers and export helpers for region contrasts, discovery, and global analysis payloads. Status: `implemented` +- [2026-04-10-shared-clustering-matplotlib-renderers.md](plans/2026-04-10-shared-clustering-matplotlib-renderers.md) - Matplotlib renderers for shared-clustering payloads. Status: `implemented` ### Cleanup And Docs - [2026-04-02-superpowers-docs-cleanup.md](plans/2026-04-02-superpowers-docs-cleanup.md) - central docs index and tracked-plan cleanup. Status: `implemented` - [2026-04-02-docs-and-integration-cleanup.md](plans/2026-04-02-docs-and-integration-cleanup.md) - historical path normalization plus narrow discoverability cleanup around completed analysis and plotting work. Status: `implemented` - [2026-04-02-docs-coherence-and-discoverability.md](plans/2026-04-02-docs-coherence-and-discoverability.md) - coherence pass across internal and user-facing docs plus narrow package-surface cleanup if needed. Status: `partially implemented` +- [2026-04-13-legacy-cleanup-and-shared-cluster-tests-execution.md](plans/2026-04-13-legacy-cleanup-and-shared-cluster-tests-execution.md) - sprintized completion pass for shared-cluster follow-up and legacy cleanup tracks. Status: `partially implemented` +- [2026-04-14-unified-remaining-work-plan.md](plans/2026-04-14-unified-remaining-work-plan.md) - consolidated, current backlog across all historical plan docs. Status: `partially implemented` ## Current Themes @@ -83,3 +90,4 @@ This directory tracks internal design and implementation work for the current br - Global analysis: use the region analysis architecture spec first, then the global analysis foundations plan. - Plotting: start with the plotting-axis spec, then the plotting-axis implementation plan, then the region-contrasts, region-discovery, and global-analysis plotting plans for helper-level coverage. - Docs cleanup: use the docs cleanup design and plan for the central status map and tracked historical plans, then the docs-and-integration and docs-coherence follow-on docs passes for portability and discoverability cleanup. +- Legacy cleanup: use the legacy cleanup execution plan for debt-lane context, then treat the unified remaining-work plan as the canonical active backlog. diff --git a/docs/superpowers/plans/2026-04-02-docs-coherence-and-discoverability.md b/docs/superpowers/plans/2026-04-02-docs-coherence-and-discoverability.md index ff8e829..4a8e027 100644 --- a/docs/superpowers/plans/2026-04-02-docs-coherence-and-discoverability.md +++ b/docs/superpowers/plans/2026-04-02-docs-coherence-and-discoverability.md @@ -10,6 +10,12 @@ --- +## Status Note (2026-04-14) + +This document remains the detailed execution playbook for docs coherence work. +The active cross-plan backlog now lives in +`docs/superpowers/plans/2026-04-14-unified-remaining-work-plan.md`. + ## File Map - Modify: `docs/superpowers/README.md` diff --git a/docs/superpowers/plans/2026-04-13-legacy-cleanup-and-shared-cluster-tests-execution.md b/docs/superpowers/plans/2026-04-13-legacy-cleanup-and-shared-cluster-tests-execution.md new file mode 100644 index 0000000..d1e8996 --- /dev/null +++ b/docs/superpowers/plans/2026-04-13-legacy-cleanup-and-shared-cluster-tests-execution.md @@ -0,0 +1,344 @@ +# Shared Cluster Tests Completion And Legacy Cleanup Execution Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Finish the active shared-cluster inference slice, then execute a prioritized legacy TODO cleanup program without derailing current delivery. + +**Architecture:** Treat shared-cluster inference completion as Sprint 0 (feature lane), then run legacy cleanup in Sprints 1-5 (debt lane). Keep commits narrow and test-gated. Prefer no cross-sprint mixed commits. + +**Tech Stack:** Python 3.11, pytest, pandas, numpy, scipy, dimelo workflows/models/plotting stack + +--- + +## Status Note (2026-04-14) + +This document is retained as the historical sprint breakdown. The canonical +"what remains" backlog is now tracked in +`docs/superpowers/plans/2026-04-14-unified-remaining-work-plan.md`. + +## How Current Track Fits + +- Sprint 0 is the current active branch work: + - `dimelo/shared_cluster_tests.py` + - `tests/test_shared_cluster_tests.py` + - `README.md` + - `docs/shared-clustering.md` + - `docs/superpowers/README.md` +- Sprints 1-5 are legacy debt cleanup outside the new analysis track. +- Recommended flow: complete Sprint 0 first, then run Sprints 1-5 in order. + +## File Map + +- Modify: `dimelo/shared_cluster_tests.py` +- Modify: `tests/test_shared_cluster_tests.py` +- Modify: `docs/shared-clustering.md` +- Modify: `README.md` +- Modify: `docs/superpowers/README.md` +- Modify: `dimelo/parse_bam.py` +- Modify: `dimelo/run_modkit.py` +- Modify: `dimelo/load_processed.py` +- Modify: `dimelo/plot_read_browser.py` +- Modify: `dimelo/plot_reads.py` +- Modify: `dimelo/plot_enrichment.py` +- Modify: `dimelo/plot_enrichment_profile.py` +- Modify: `dimelo/plot_depth_profile.py` +- Modify: `dimelo/plot_depth_histogram.py` +- Modify: `dimelo/utils.py` +- Modify: `dimelo/test_data.py` +- Modify: `dimelo/test/__init__.py` +- Modify: `dimelo/test/dimelo_test.py` + +## Sprint 0: Complete Shared Cluster Tests (Current Track) + +**Files:** +- Modify: `tests/test_shared_cluster_tests.py` +- Modify: `dimelo/shared_cluster_tests.py` +- Modify: `docs/shared-clustering.md` +- Modify: `README.md` +- Modify: `docs/superpowers/README.md` + +- [ ] **Step 1: Add failing tests for missing scope (time-course + pooled tests + include_pairwise)** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_shared_cluster_tests.py -k "time_course or chi_squared or g_test or include_pairwise" -q +``` + +Expected: FAIL on currently missing behavior. + +- [ ] **Step 2: Implement pooled screening paths (`chi_squared`, `g_test`)** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_shared_cluster_tests.py -k "chi_squared or g_test" -q +``` + +Expected: PASS for pooled tests. + +- [ ] **Step 3: Implement `time_course` and `include_pairwise` follow-up** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_shared_cluster_tests.py -k "time_course or include_pairwise" -q +``` + +Expected: PASS for time-course behavior. + +- [ ] **Step 4: Update docs and status map** + +Update: +- `docs/shared-clustering.md` (global shared-cluster tests usage and boundaries) +- `README.md` (analysis guide note for `shared_cluster_tests`) +- `docs/superpowers/README.md` (status line updates) + +- [ ] **Step 5: Run shared-cluster regression subset** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_shared_cluster_tests.py tests/test_models.py tests/test_workflows.py -k "shared_cluster" -q +``` + +Expected: PASS. + +- [ ] **Step 6: Commit Sprint 0** + +```bash +git add dimelo/shared_cluster_tests.py tests/test_shared_cluster_tests.py docs/shared-clustering.md README.md docs/superpowers/README.md +git commit -m "feat: complete shared cluster inference v1 scope" +``` + +## Sprint 1: Parser Correctness And Duplication + +**Files:** +- Modify: `dimelo/parse_bam.py` +- Modify: `dimelo/run_modkit.py` +- Test: `tests/test_distribution.py` +- Test: `tests/test_cluster.py` + +- [ ] **Step 1: Identify parser TODO targets and lock scope** + +Run: + +```bash +rg -n "TODO|FIXME|TBD" dimelo/parse_bam.py dimelo/run_modkit.py +``` + +Expected: Enumerated TODO set for this sprint only. + +- [ ] **Step 2: Refactor duplicate pileup/extract setup paths** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_distribution.py -q +``` + +Expected: PASS with no behavior regression. + +- [ ] **Step 3: Harden coordinate/chunk/compression paths** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_cluster.py tests/test_distribution.py -q +``` + +Expected: PASS. + +- [ ] **Step 4: Clean `run_modkit.py` typing TODO and run focused regression** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_distribution.py tests/test_cluster.py -q +``` + +Expected: PASS. + +- [ ] **Step 5: Commit Sprint 1** + +```bash +git add dimelo/parse_bam.py dimelo/run_modkit.py tests/test_distribution.py tests/test_cluster.py +git commit -m "refactor: harden parse_bam core paths and reduce duplication" +``` + +## Sprint 2: Processed Loader Reliability + +**Files:** +- Modify: `dimelo/load_processed.py` +- Test: `tests/test_distribution.py` +- Test: `tests/test_workflows.py` + +- [ ] **Step 1: Triage loader TODOs and group by behavior** + +Run: + +```bash +rg -n "TODO|FIXME|TBD" dimelo/load_processed.py +``` + +Expected: TODO set grouped into naming, progress/parallelization, subsetting semantics. + +- [ ] **Step 2: Clean naming/API clarity and keep compatibility** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_distribution.py -q +``` + +Expected: PASS. + +- [ ] **Step 3: Add progress/parallel behavior parity and subsetting fixes** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_distribution.py tests/test_workflows.py -k "load or processed" -q +``` + +Expected: PASS. + +- [ ] **Step 4: Commit Sprint 2** + +```bash +git add dimelo/load_processed.py tests/test_distribution.py tests/test_workflows.py +git commit -m "fix: improve load_processed reliability and API clarity" +``` + +## Sprint 3: Read Browser Behavior And Performance + +**Files:** +- Modify: `dimelo/plot_read_browser.py` +- Test: `tests/test_plotting.py` + +- [ ] **Step 1: Resolve collapse/sort semantics TODOs** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "read_browser" -q +``` + +Expected: PASS. + +- [ ] **Step 2: Stabilize duplicate-read handling and hover contract** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "read_browser or plot_reads" -q +``` + +Expected: PASS. + +- [ ] **Step 3: Reduce hot-path iteration overhead where safe** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -q +``` + +Expected: PASS. + +- [ ] **Step 4: Commit Sprint 3** + +```bash +git add dimelo/plot_read_browser.py tests/test_plotting.py +git commit -m "fix: harden read browser behavior and clean plotting debt" +``` + +## Sprint 4: Legacy Plotting API Normalization + +**Files:** +- Modify: `dimelo/plot_reads.py` +- Modify: `dimelo/plot_enrichment.py` +- Modify: `dimelo/plot_enrichment_profile.py` +- Modify: `dimelo/plot_depth_profile.py` +- Modify: `dimelo/plot_depth_histogram.py` +- Test: `tests/test_plotting.py` + +- [ ] **Step 1: Normalize dispatch/API patterns across legacy plotting modules** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -k "plot_reads or enrichment or depth" -q +``` + +Expected: PASS. + +- [ ] **Step 2: Remove redefinition/mypy TODO clusters without changing output behavior** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -q +``` + +Expected: PASS. + +- [ ] **Step 3: Commit Sprint 4** + +```bash +git add dimelo/plot_reads.py dimelo/plot_enrichment.py dimelo/plot_enrichment_profile.py dimelo/plot_depth_profile.py dimelo/plot_depth_histogram.py tests/test_plotting.py +git commit -m "refactor: normalize legacy plotting APIs and remove type-debt hotspots" +``` + +## Sprint 5: Utils And Fixture Hygiene + +**Files:** +- Modify: `dimelo/utils.py` +- Modify: `dimelo/test_data.py` +- Modify: `dimelo/test/__init__.py` +- Modify: `dimelo/test/dimelo_test.py` + +- [ ] **Step 1: Resolve utility reproducibility/type TODOs** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_distribution.py tests/test_cluster.py -q +``` + +Expected: PASS. + +- [ ] **Step 2: Improve fixture realism and remove internal test TODOs** + +Run: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest -q +``` + +Expected: PASS. + +- [ ] **Step 3: Commit Sprint 5** + +```bash +git add dimelo/utils.py dimelo/test_data.py dimelo/test/__init__.py dimelo/test/dimelo_test.py +git commit -m "chore: improve utility typing/reproducibility and test fixtures" +``` + +## Cross-Sprint Gates + +- [ ] `git status --short` is clean before each sprint commit. +- [ ] No mixed-sprint commits (one sprint theme per commit). +- [ ] No new `TODO/FIXME/TBD` markers introduced. +- [ ] Full regression at sprint boundaries: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest -q +``` + +## Success Metrics + +- Baseline markers: `96` TODO/FIXME/TBD in `dimelo/*.py`. +- Post Sprint 0 target: current feature lane complete and documented. +- Post Sprint 3 target: TODO count < `35`. +- Post Sprint 5 target: TODO count < `10`, with any remainder explicitly deferred in docs. diff --git a/docs/superpowers/plans/2026-04-14-unified-remaining-work-plan.md b/docs/superpowers/plans/2026-04-14-unified-remaining-work-plan.md new file mode 100644 index 0000000..4da2a24 --- /dev/null +++ b/docs/superpowers/plans/2026-04-14-unified-remaining-work-plan.md @@ -0,0 +1,118 @@ +# Unified Remaining Work Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans. This plan consolidates outstanding work across historical `docs/superpowers/plans/*.md`. + +**Goal:** Maintain one canonical backlog of what is still open after auditing all historical plan docs, and execute remaining work in a clean, commit-friendly sequence. + +**Audit Date:** 2026-04-14 + +## Audited Plan Inventory + +The table below captures what remains from every tracked plan document. + +| Plan | Status | Remaining Work | +|---|---|---| +| `2026-03-31-global-analysis-foundations.md` | implemented | none | +| `2026-03-31-region-contrasts-foundations.md` | implemented | none | +| `2026-03-31-region-discovery-foundations.md` | implemented | none | +| `2026-03-31-shared-clustering-foundations.md` | implemented | none | +| `2026-04-01-cluster-occupancy-region-contrasts.md` | implemented | none | +| `2026-04-01-discovery-cluster-contrast-workflow.md` | implemented | none | +| `2026-04-01-paired-region-discovery.md` | implemented | none | +| `2026-04-01-plotting-axis-architecture.md` | implemented | none | +| `2026-04-01-region-contrasts-plotting.md` | implemented | none | +| `2026-04-01-region-discovery-cluster-workflow.md` | implemented | none | +| `2026-04-02-docs-and-integration-cleanup.md` | implemented | none | +| `2026-04-02-docs-coherence-and-discoverability.md` | partially implemented | keep status index synchronized with newly added plans and run periodic coherence checks | +| `2026-04-02-global-analysis-plotting.md` | implemented | none | +| `2026-04-02-region-discovery-plotting.md` | implemented | none | +| `2026-04-02-shared-clustering-plotting.md` | implemented | none | +| `2026-04-02-superpowers-docs-cleanup.md` | implemented | none | +| `2026-04-03-single-read-region-contrasts.md` | implemented | none | +| `2026-04-08-matplotlib-renderers.md` | implemented | none | +| `2026-04-10-shared-clustering-matplotlib-renderers.md` | implemented | none | +| `2026-04-12-shared-cluster-tests.md` | implemented | none | +| `2026-04-13-legacy-cleanup-and-shared-cluster-tests-execution.md` | partially implemented | finish legacy cleanup sprints and close commit-hygiene gates | + +## Canonical Remaining Backlog + +Only two workstreams remain active after the full audit: + +1. Legacy cleanup execution (from `2026-04-13-*`) +2. Ongoing docs coherence/index maintenance (from `2026-04-02-docs-coherence-*`) + +## Workstream A: Legacy Cleanup Completion + +**Scope Source:** `2026-04-13-legacy-cleanup-and-shared-cluster-tests-execution.md` + +### A1. Finish Sprint 1 leftovers (parser/runtime debt) + +- [ ] `run_modkit.py`: resolve remaining typing and API clarity debt. +- [ ] `parse_bam.py`: close remaining high-value TODO clusters that are still behavior-adjacent, not cosmetic. +- [ ] Verification: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_distribution.py tests/test_cluster.py -q +``` + +### A2. Finish Sprint 4 (legacy plotting normalization) + +- [ ] Normalize dispatch/API patterns in: + - `dimelo/plot_reads.py` + - `dimelo/plot_enrichment.py` + - `dimelo/plot_enrichment_profile.py` + - `dimelo/plot_depth_profile.py` + - `dimelo/plot_depth_histogram.py` +- [ ] Remove redefinition/mypy-TODO hotspots without output behavior drift. +- [ ] Verification: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_plotting.py -q +``` + +### A3. Finish Sprint 5 (utils + legacy fixture hygiene) + +- [ ] `utils.py`: close reproducibility/type TODOs that affect public behavior or determinism. +- [ ] `dimelo/test_data.py`, `dimelo/test/__init__.py`, `dimelo/test/dimelo_test.py`: + - reduce external fragility (network/download assumptions), + - improve restricted-environment compatibility (process/semaphore constraints), + - keep legacy integration coverage meaningful. +- [ ] Verification: + +```bash +PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3.11 -m pytest tests/test_distribution.py tests/test_cluster.py -q +``` + +## Workstream B: Docs Coherence Maintenance + +**Scope Source:** `2026-04-02-docs-coherence-and-discoverability.md` + +- [ ] Keep `docs/superpowers/README.md` in sync with all files in `docs/superpowers/plans/`. +- [ ] Keep status labels aligned with branch reality for the active cycle. +- [ ] Run link-existence verification after index edits: + +```bash +for f in $(rg -o "\\((specs|plans)/[^)]+" docs/superpowers/README.md | tr -d "("); do + test -f "docs/superpowers/$f" || echo "MISSING $f" +done +``` + +## Execution Order Going Forward + +1. Finish Workstream A1, commit. +2. Finish Workstream A2, commit. +3. Finish Workstream A3, commit. +4. Apply Workstream B coherence pass, commit. +5. Run final verification suite for the branch: + +```bash +pytest tests +``` + +## Commit Hygiene Rules (Canonical) + +- [ ] Keep one sprint/theme per commit. +- [ ] Keep `git status --short` clean between sprint commits. +- [ ] Do not introduce new `TODO/FIXME/TBD` markers in touched files. +- [ ] Record verification command output in PR notes before merge. + From 87186168c2ac4f8c12f91385e2ca42688ac6c5c7 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 14 Apr 2026 15:40:35 -0700 Subject: [PATCH 267/272] fix: restore parse/load compatibility after rebase --- dimelo/load_processed.py | 129 +++- dimelo/parse_bam.py | 1294 +++++++++++++------------------------- tests/test_parse_bam.py | 444 ++----------- 3 files changed, 626 insertions(+), 1241 deletions(-) diff --git a/dimelo/load_processed.py b/dimelo/load_processed.py index 176e819..4e20023 100644 --- a/dimelo/load_processed.py +++ b/dimelo/load_processed.py @@ -690,6 +690,58 @@ def pileup_vectors_from_bedmethyl( return modified_base_counts, valid_base_counts +def counts_from_pileup( + bedmethyl_file: str | Path, + motif: str, + regions: str | Path | list[str | Path], + window_size: int | None = None, + single_strand: bool = False, + quiet: bool = False, + cores: int | None = None, + chunk_size: int = DEFAULT_CHUNK_SIZE, +) -> tuple[int, int]: + """ + Preferred alias for `pileup_counts_from_bedmethyl`. + """ + return pileup_counts_from_bedmethyl( + bedmethyl_file=bedmethyl_file, + motif=motif, + regions=regions, + window_size=window_size, + single_strand=single_strand, + quiet=quiet, + cores=cores, + chunk_size=chunk_size, + ) + + +def vectors_from_pileup( + bedmethyl_file: str | Path, + motif: str, + regions: str | Path | list[str | Path], + window_size: int | None = None, + single_strand: bool = False, + regions_5to3prime: bool = False, + quiet: bool = False, + cores: int | None = None, + chunk_size: int = DEFAULT_CHUNK_SIZE, +) -> tuple[np.ndarray, np.ndarray]: + """ + Preferred alias for `pileup_vectors_from_bedmethyl`. + """ + return pileup_vectors_from_bedmethyl( + bedmethyl_file=bedmethyl_file, + motif=motif, + regions=regions, + window_size=window_size, + single_strand=single_strand, + regions_5to3prime=regions_5to3prime, + quiet=quiet, + cores=cores, + chunk_size=chunk_size, + ) + + def counts_from_fake(*args, **kwargs) -> tuple[int, int]: """ Test helper function. @@ -967,6 +1019,28 @@ def process_pileup_row( ################################################################################################################ +def _validate_subset_parameters(subset_parameters: dict | None) -> None: + if subset_parameters is None: + return + if not isinstance(subset_parameters, dict): + raise ValueError("subset_parameters must be provided as a dictionary.") + if "array" in subset_parameters: + raise ValueError( + "subset_parameters cannot include 'array'; this is set internally." + ) + if "n" not in subset_parameters and "frac" not in subset_parameters: + raise ValueError("subset_parameters must include at least one of n or frac.") + + +def _subset_indices( + relevant_read_indices: np.ndarray, + subset_parameters: dict | None, +) -> np.ndarray: + if subset_parameters is None or relevant_read_indices.size == 0: + return relevant_read_indices + return np.sort(utils.random_sample(relevant_read_indices, **subset_parameters)) + + def read_vectors_from_hdf5( file: str | Path, motifs: list[str], @@ -1040,6 +1114,8 @@ def read_vectors_from_hdf5( TODO: The way the subsetting is implemented is confusing, in that you need to pass all but one of the available parameters. """ + _validate_subset_parameters(subset_parameters) + with h5py.File(file, "r") as h5: datasets: list[str] = [ name for name, obj in h5.items() if isinstance(obj, h5py.Dataset) @@ -1092,12 +1168,9 @@ def read_vectors_from_hdf5( | (ref_strands == region_strand) ) ) - if subset_parameters is not None: - relevant_read_indices = np.sort( - utils.random_sample( - relevant_read_indices, **subset_parameters - ) - ) + relevant_read_indices = _subset_indices( + relevant_read_indices, subset_parameters=subset_parameters + ) read_tuples_raw += list( zip( *( @@ -1120,10 +1193,9 @@ def read_vectors_from_hdf5( else: regions_dict = None relevant_read_indices = np.flatnonzero(np.isin(read_motifs, motifs)) - if subset_parameters is not None: - relevant_read_indices = np.sort( - utils.random_sample(relevant_read_indices, **subset_parameters) - ) + relevant_read_indices = _subset_indices( + relevant_read_indices, subset_parameters=subset_parameters + ) read_tuples_raw = list( zip( *( @@ -1349,6 +1421,9 @@ def readwise_binary_modification_arrays( window_size=window_size, single_strand=single_strand, sort_by=sort_by, + quiet=quiet, + cores=cores, + subset_parameters=subset_parameters, ) read_name_index = datasets.index("read_name") mod_vector_index = datasets.index("mod_vector") @@ -1358,6 +1433,14 @@ def readwise_binary_modification_arrays( read_start_index = datasets.index("read_start") region_strand_index = datasets.index("region_strand") + if len(sorted_read_data_converted) == 0: + return ( + np.array([], dtype=int), + np.array([], dtype=int), + np.array([], dtype=str), + regions_dict, + ) + # Check this .h5 file was created with a threshold, i.e. that the mod calls are binarized if thresh is None: if not (sorted_read_data_converted[0][mod_vector_index].dtype == np.bool_): @@ -1371,16 +1454,22 @@ def readwise_binary_modification_arrays( mod_coords_list = [] motifs_list = [] - read_names = np.array( - [read_data[read_name_index] for read_data in sorted_read_data_converted] - ) - # TODO: handle the case where a read shows up in more than one different region - _, unique_first_indices = np.unique(read_names, return_index=True) - unique_in_order = read_names[np.sort(unique_first_indices)] - string_to_int = { - read_name: index for index, read_name in enumerate(unique_in_order) - } - read_ints = np.array([string_to_int[read_name] for read_name in read_names]) + read_ids_by_region_key: dict[tuple[str, int, int, str], int] = {} + read_ints = np.empty(len(sorted_read_data_converted), dtype=int) + next_read_int = 0 + for idx, read_data in enumerate(sorted_read_data_converted): + read_key = ( + read_data[read_name_index], + read_data[region_start_index], + read_data[region_end_index], + read_data[region_strand_index], + ) + read_int = read_ids_by_region_key.get(read_key) + if read_int is None: + read_int = next_read_int + read_ids_by_region_key[read_key] = read_int + next_read_int += 1 + read_ints[idx] = read_int for read_int, read_data in zip(read_ints, sorted_read_data_converted): if thresh is None: diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index f79a288..5dd391b 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -1,8 +1,8 @@ +import csv import gzip -import json -import os +import itertools +import multiprocessing import subprocess -import time from collections import defaultdict from pathlib import Path @@ -24,29 +24,63 @@ # Specifies how many reads to check for the base modifications of interest. NUM_READS_TO_CHECK = 100 -VERIFY_CACHE_FILENAME = ".dimelo.verify_cache.json" -VERIFY_CACHE_VERSION = 1 -VERIFY_CACHE_MAX_ENTRIES = 64 -DEFAULT_MODKIT_MEMORY_PER_THREAD_BYTES = 2 * 1024 * 1024 * 1024 -DEFAULT_MODKIT_MEMORY_FRACTION = 0.8 -IUPAC_BASES = { - "A": {"A"}, - "C": {"C"}, - "G": {"G"}, - "T": {"T"}, - "U": {"T"}, - "R": {"A", "G"}, - "Y": {"C", "T"}, - "S": {"G", "C"}, - "W": {"A", "T"}, - "K": {"G", "T"}, - "M": {"A", "C"}, - "B": {"C", "G", "T"}, - "D": {"A", "G", "T"}, - "H": {"A", "C", "T"}, - "V": {"A", "C", "G"}, - "N": {"A", "C", "G", "T"}, -} + + +def _threads_command_list(cores: int | None, quiet: bool) -> list[str]: + cores_avail = multiprocessing.cpu_count() + if cores is None: + if not quiet: + print( + f"No specified number of cores requested. {cores_avail} available on machine, allocating all." + ) + return ["--threads", str(cores_avail)] + if cores > cores_avail: + if not quiet: + print( + f"Warning: {cores} cores request, {cores_avail} available. Allocating {cores_avail}" + ) + return ["--threads", str(cores_avail)] + if not quiet: + print(f"Allocating requested {cores} cores.") + return ["--threads", str(cores)] + + +def _compress_uint8_vector( + vector: np.ndarray, + compress_level: int, +) -> np.ndarray: + return np.frombuffer( + gzip.compress(vector.tobytes(), compresslevel=compress_level), + dtype=np.uint8, + ) + + +def _unlink_existing(*paths: Path) -> None: + for path in paths: + path.unlink(missing_ok=True) + + +def _reference_oriented_read_offset( + *, + pos_in_read: int, + read_length: int, + ref_strand: str, +) -> int: + """ + Convert modkit's read-oriented position into a left-to-right reference offset. + """ + if read_length <= 0: + raise ValueError(f"read length must be positive; got {read_length}.") + if pos_in_read < 0 or pos_in_read >= read_length: + raise ValueError( + f"pos_in_read {pos_in_read} is out of bounds for read length {read_length}." + ) + if ref_strand == "+": + return pos_in_read + if ref_strand == "-": + return read_length - pos_in_read - 1 + raise ValueError(f"Unexpected strand '{ref_strand}' in modkit extract row.") + """ User-facing parse operations: pileup and extract @@ -67,7 +101,6 @@ def pileup( cleanup: bool = True, quiet: bool = False, override_checks: bool = False, - verification_cache: bool = True, ) -> tuple[Path, Path]: """ Takes a bam file containing long read sequencing data aligned @@ -105,7 +138,11 @@ def pileup( output_directory: optional str or Path pointing to an output directory. If left as None, outputs will be stored in a new folder within the input directory. - regions: TODO + regions: optional region selector passed through to modkit via an include-bed + file. This may be a BED file path, a single region file, or a list of + region files/paths that define the loci to process. When paired with + ``window_size``, the provided regions are expanded around their centers + before being passed to modkit. motifs: a list of strings specifying which base modifications to look for. The basemods are each specified as {sequence_motif},{position_of_modification}. For example, a methylated adenine is specified as 'A,0' and CpG methylation @@ -132,16 +169,6 @@ def pileup( Path object pointing to 'regions.processed.bed', the `--include-bed` file used for `modkit pileup` """ - """ - TODO: There are a lot of issues that are all related here: - dimelo/parse_bam.py:150: error: Incompatible types in assignment (expression has type "Path | None", variable has type "str | Path") [assignment] - dimelo/parse_bam.py:169: error: Argument "input_file" to "prep_outputs" has incompatible type "str | Path"; expected "Path" [arg-type] - dimelo/parse_bam.py:256: error: Argument "input_file" to "run_with_progress_bars" has incompatible type "str | Path"; expected "Path" [arg-type] - dimelo/parse_bam.py:257: error: Argument "ref_genome" to "run_with_progress_bars" has incompatible type "str | Path"; expected "Path" [arg-type] - - I'm not sure of the most elegant way to fix it. Come back and address. - """ - ## Verify and prepare inputs and outputs run_modkit.ensure_modkit_available(quiet=quiet) @@ -149,15 +176,12 @@ def pileup( input_file, ref_genome, output_directory = utils.sanitize_path_args( input_file, ref_genome, output_directory ) + input_file = Path(input_file) + ref_genome = Path(ref_genome) + output_directory = None if output_directory is None else Path(output_directory) try: - verify_inputs( - input_file, - motifs, - ref_genome, - quiet=quiet, - cache=verification_cache, - ) + verify_inputs(input_file, motifs, ref_genome) except Exception as e: if override_checks: if not quiet: @@ -171,7 +195,7 @@ def pileup( prep_output_directory( output_directory=output_directory, output_name=output_name, - input_file=input_file, + default_directory=input_file.parent, output_file_names=[ "pileup.bed", "pileup.sorted.bed", @@ -183,7 +207,6 @@ def pileup( ## Build up the command list to be sent to modkit, then run modkit - # TODO: This is mildly confusing. I get what it's doing, but it's hard to follow / names are bad. Also, why is it used in cleanup here, but not in extract? region_command_list, processed_regions_path = create_region_command_list( output_path, regions, @@ -192,20 +215,21 @@ def pileup( motif_command_list = [] if len(motifs) > 0: - seen_motifs: set[tuple[str, int]] = set() for motif in motifs: parsed_motif = utils.ParsedMotif(motif) - motif_key = (parsed_motif.motif_seq, parsed_motif.modified_pos) - # This motif is already going to be processed; we want to skip adding it a second - # time because modkit does not like duplicate motifs. - # It's actually ok if it's a different mod code in the two cases because the pileup - # operation, under the hood, keeps all mod codes. Filtering is only done when loading. - if motif_key in seen_motifs: - continue - seen_motifs.add(motif_key) - motif_command_list.extend( - ["--motif", parsed_motif.motif_seq, str(parsed_motif.modified_pos)] - ) + motif_command_present = False + for a, b in zip(motif_command_list, motif_command_list[1:]): + if a == parsed_motif.motif_seq and b == str(parsed_motif.modified_pos): + # This motif is already going to be processed; we want to skip adding it a second + # time because modkit does not like duplicate motifs. + # It's actually ok if it's a different mod code in the two cases because the pileup + # operation, under the hood, keeps all mod codes. Filtering is only done when loading. + motif_command_present = True + break + if not motif_command_present: + motif_command_list.append("--motif") + motif_command_list.append(parsed_motif.motif_seq) + motif_command_list.append(str(parsed_motif.modified_pos)) else: raise ValueError("Error: no motifs specified. Nothing to process.") @@ -216,9 +240,8 @@ def pileup( else: log_command_list = [] - cores_command_list = _resolve_modkit_threads_command(cores=cores, quiet=quiet) + cores_command_list = _threads_command_list(cores=cores, quiet=quiet) - # TODO: This is SO SO SO similar to extract; just the ValueError vs. printing. I think this can be resolved mod_thresh_command_list: list[str] = [] if thresh is None: if not quiet: @@ -234,9 +257,10 @@ def pileup( for motif in motifs: parsed_motif = utils.ParsedMotif(motif) for mod_code in parsed_motif.mod_codes: - mod_thresh_command_list.extend( - ["--mod-thresholds", f"{mod_code}:{adjusted_threshold}"] - ) + mod_thresh_command_list = mod_thresh_command_list + [ + "--mod-thresholds", + f"{mod_code}:{adjusted_threshold}", + ] ref_genome_command_list = ["--ref", ref_genome] filter_command_list = ["--filter-threshold", "0"] @@ -252,8 +276,7 @@ def pileup( + log_command_list ) - # TODO: Do we need to store and use the output from this method? Previously was being printed immediately afterward. - _ = run_modkit.run_with_progress_bars( + run_modkit.run_with_progress_bars( command_list=pileup_command_list, input_file=input_file, ref_genome=ref_genome, @@ -269,25 +292,18 @@ def pileup( expect_done=True, quiet=quiet, ) - # print(done_string) ## Sort, compress, and index the output bedmethyl file - _sort_bedmethyl_output( - input_bedmethyl=output_bedmethyl, - output_bedmethyl_sorted=output_bedmethyl_sorted, - requested_cores=cores, - quiet=quiet, - ) + with open(output_bedmethyl_sorted, "w") as sorted_file: + subprocess.run( + ["sort", "-k1,1", "-k2,2n", output_bedmethyl], stdout=sorted_file + ) pysam.tabix_compress(output_bedmethyl_sorted, output_pileup_path, force=True) pysam.tabix_index(str(output_pileup_path), preset="bed", force=True) - # TODO: Can cleanup be consolidated? if cleanup: - if output_bedmethyl.exists(): - output_bedmethyl.unlink() - if output_bedmethyl_sorted.exists(): - output_bedmethyl_sorted.unlink() + _unlink_existing(output_bedmethyl, output_bedmethyl_sorted) return output_pileup_path, processed_regions_path @@ -306,7 +322,6 @@ def extract( cleanup: bool = True, quiet: bool = False, override_checks: bool = False, - verification_cache: bool = True, ) -> tuple[Path, Path]: """ Takes a bam file containing long read sequencing data aligned @@ -342,7 +357,11 @@ def extract( output_directory: optional str or Path pointing to an output directory. If left as None, outputs will be stored in a new folder within the input directory. - regions: TODO + regions: optional region selector passed through to modkit via an include-bed + file. This may be a BED file path, a single region file, or a list of + region files/paths that define the loci to process. When paired with + ``window_size``, the provided regions are expanded around their centers + before being passed to modkit. motifs: a list of strings specifying which base modifications to look for. The basemods are each specified as {sequence_motif},{position_of_modification}. For example, a methylated adenine is specified as 'A,0' and CpG methylation @@ -369,30 +388,17 @@ def extract( Path object pointing to 'regions.processed.bed', the `--include-bed` file used for `modkit extract` """ - """ - TODO: There are a lot of issues that are all related here: - dimelo/parse_bam.py:374: error: Incompatible types in assignment (expression has type "Path | None", variable has type "str | Path") [assignment] - dimelo/parse_bam.py:393: error: Argument "input_file" to "prep_outputs" has incompatible type "str | Path"; expected "Path" [arg-type] - dimelo/parse_bam.py:480: error: Argument "input_file" to "run_with_progress_bars" has incompatible type "str | Path"; expected "Path" [arg-type] - dimelo/parse_bam.py:481: error: Argument "ref_genome" to "run_with_progress_bars" has incompatible type "str | Path"; expected "Path" [arg-type] - - I'm not sure of the most elegant way to fix it. Come back and address. - """ - ## Verify and prepare inputs and outputs input_file, ref_genome, output_directory = utils.sanitize_path_args( input_file, ref_genome, output_directory ) + input_file = Path(input_file) + ref_genome = Path(ref_genome) + output_directory = None if output_directory is None else Path(output_directory) try: - verify_inputs( - input_file, - motifs, - ref_genome, - quiet=quiet, - cache=verification_cache, - ) + verify_inputs(input_file, motifs, ref_genome) except Exception as e: if override_checks: if not quiet: @@ -402,11 +408,10 @@ def extract( f'{e}\nIf you are confident that your inputs are ok, pass "override_checks=True" to convert to warning and proceed with processing.' ) from e - # TODO: Add intermediate mod-specific .txt files? output_path, (output_reads_path,) = prep_output_directory( output_directory=output_directory, output_name=output_name, - input_file=input_file, + default_directory=input_file.parent, output_file_names=["reads.combined_basemods.h5"], ) @@ -418,12 +423,12 @@ def extract( window_size, ) - cores_command_list = _resolve_modkit_threads_command(cores=cores, quiet=quiet) + cores_command_list = _threads_command_list(cores=cores, quiet=quiet) if thresh is None: if not quiet: print( - "No valid base modification threshold provided. Raw probs will be saved." + "No valid base modification threshold provided. Raw probabilities will be saved." ) adjusted_threshold = None else: @@ -432,6 +437,10 @@ def extract( print( f"WARNING: thresh {thresh} is very low and may lead to unexpected behavior. Typical thresholds are at least 0.5 or 128." ) + if not quiet: + print( + "Threshold provided. The extract text will stay probability-valued and read_by_base_txt_to_hdf5 will binarize at write time." + ) if log: if not quiet: @@ -443,48 +452,62 @@ def extract( ref_genome_command_list = ["--ref", ref_genome] filter_command_list = ["--filter-threshold", "0"] - motif_command_list = _build_extract_motif_command_list(motifs) - output_txt = Path(output_path) / "reads.combined_motifs.txt" - output_txt.unlink(missing_ok=True) + # Run modkit once for each motif, because the output .txt can be ambiguous otherwise + # There is no column currently to specify the motif (e.g. CG,0 vs GCH,1), only canonical + # base (e.g. C) and mod code (e.g. m) + # There is a 5mer context so we could technically manually motif check if we want to. + # Our current design paradigm is to leave all such operations to modkit, hence the loop below. + for motif in motifs: + # Here we prepare the motif-specific commands and delete any old .txt file because + # modkit will crash otherwise + motif_command_list = [] + parsed_motif = utils.ParsedMotif(motif) + motif_command_list.append("--motif") + motif_command_list.append(parsed_motif.motif_seq) + motif_command_list.append(str(parsed_motif.modified_pos)) - extract_command_list = ( - ["modkit", "extract", input_file, output_txt] - + region_command_list - + motif_command_list - + cores_command_list - + log_command_list - + ref_genome_command_list - + filter_command_list - ) + output_txt = Path(output_path) / (f"reads.{motif}.txt") - _ = run_modkit.run_with_progress_bars( - command_list=extract_command_list, - input_file=input_file, - ref_genome=ref_genome, - motifs=motifs, - load_fasta_regex=r"\s+\[.*?\]\s+(\d+)\s+parsing FASTA", - find_motifs_regex=r"\s+(\d+)/(\d+)\s+([\w]+)\s+searched", - contigs_progress_regex=r"\s+(\d+)/(\d+)\s+contigs\s+[^s]", - single_contig_regex=r"\s+(\d+)/(\d+)\s+processing\s+([\w]+)[^\w]", - buffer_size=100, - progress_granularity=50, - done_str="Done", - err_str="Error", - expect_done=False, - quiet=quiet, - ) + output_txt.unlink(missing_ok=True) - for motif in motifs: + extract_command_list = ( + ["modkit", "extract", input_file, output_txt] + + region_command_list + + motif_command_list + + cores_command_list + + log_command_list + + ref_genome_command_list + + filter_command_list + ) + + run_modkit.run_with_progress_bars( + command_list=extract_command_list, + input_file=input_file, + ref_genome=ref_genome, + motifs=[motif], + load_fasta_regex=r"\s+\[.*?\]\s+(\d+)\s+parsing FASTA", + find_motifs_regex=r"\s+(\d+)/(\d+)\s+([\w]+)\s+searched", + contigs_progress_regex=r"\s+(\d+)/(\d+)\s+contigs\s+[^s]", + single_contig_regex=r"\s+(\d+)/(\d+)\s+processing\s+([\w]+)[^\w]", + buffer_size=100, + progress_granularity=50, + done_str="Done", + err_str="Error", + expect_done=False, + quiet=quiet, + ) + + # Create the compressed and indexed output read_by_base_txt_to_hdf5( output_txt, output_reads_path, motif, adjusted_threshold, quiet=quiet, - require_motif_context=True, ) - if cleanup: - output_txt.unlink(missing_ok=True) + # Delete intermediate file + if cleanup: + output_txt.unlink() return output_reads_path, processed_regions_path @@ -494,144 +517,16 @@ def extract( """ -def _file_fingerprint(path: Path) -> dict[str, int | str]: - stat = path.stat() - return {"path": str(path.resolve()), "size": stat.st_size, "mtime_ns": stat.st_mtime_ns} - - -def _verification_cache_key( - *, - input_file: Path, - ref_genome: Path, - motifs: list[str], -) -> str: - sorted_motifs = sorted(str(motif) for motif in motifs) - return "|".join([str(input_file.resolve()), str(ref_genome.resolve()), ",".join(sorted_motifs)]) - - -def _verification_cache_path(input_file: Path) -> Path: - return input_file.parent / VERIFY_CACHE_FILENAME - - -def _load_verification_cache(cache_path: Path) -> dict: - if not cache_path.exists(): - return {"version": VERIFY_CACHE_VERSION, "entries": {}} - try: - data = json.loads(cache_path.read_text(encoding="utf-8")) - except Exception: - return {"version": VERIFY_CACHE_VERSION, "entries": {}} - if not isinstance(data, dict): - return {"version": VERIFY_CACHE_VERSION, "entries": {}} - if data.get("version") != VERIFY_CACHE_VERSION: - return {"version": VERIFY_CACHE_VERSION, "entries": {}} - entries = data.get("entries") - if not isinstance(entries, dict): - return {"version": VERIFY_CACHE_VERSION, "entries": {}} - return {"version": VERIFY_CACHE_VERSION, "entries": entries} - - -def _save_verification_cache(cache_path: Path, cache_data: dict) -> None: - temp_path = cache_path.with_suffix(cache_path.suffix + ".tmp") - temp_path.write_text(json.dumps(cache_data), encoding="utf-8") - temp_path.replace(cache_path) - - -def _load_cached_verification_result( - *, - input_file: Path, - ref_genome: Path, - motifs: list[str], -) -> tuple[int, int] | None: - if os.environ.get("DIMELO_DISABLE_VERIFY_CACHE", "").lower() in {"1", "true", "yes"}: - return None - - cache_path = _verification_cache_path(input_file) - cache_data = _load_verification_cache(cache_path) - key = _verification_cache_key(input_file=input_file, ref_genome=ref_genome, motifs=motifs) - entry = cache_data["entries"].get(key) - if not isinstance(entry, dict): - return None - - try: - if entry["input"] != _file_fingerprint(input_file): - return None - if entry["ref"] != _file_fingerprint(ref_genome): - return None - total_bases = int(entry["total_bases"]) - correct_bases = int(entry["correct_bases"]) - except Exception: - return None - - if total_bases <= 0: - return None - if correct_bases / total_bases < 0.35: - return None - return correct_bases, total_bases - - -def _store_cached_verification_result( - *, - input_file: Path, - ref_genome: Path, - motifs: list[str], - correct_bases: int, - total_bases: int, -) -> None: - if os.environ.get("DIMELO_DISABLE_VERIFY_CACHE", "").lower() in {"1", "true", "yes"}: - return - - cache_path = _verification_cache_path(input_file) - cache_data = _load_verification_cache(cache_path) - entries: dict[str, dict] = cache_data["entries"] - key = _verification_cache_key(input_file=input_file, ref_genome=ref_genome, motifs=motifs) - entries[key] = { - "input": _file_fingerprint(input_file), - "ref": _file_fingerprint(ref_genome), - "motifs": sorted(str(motif) for motif in motifs), - "correct_bases": int(correct_bases), - "total_bases": int(total_bases), - "timestamp_ns": time.time_ns(), - } - - if len(entries) > VERIFY_CACHE_MAX_ENTRIES: - sorted_keys = sorted( - entries, - key=lambda entry_key: int(entries[entry_key].get("timestamp_ns", 0)), - ) - for stale_key in sorted_keys[: len(entries) - VERIFY_CACHE_MAX_ENTRIES]: - entries.pop(stale_key, None) - - try: - _save_verification_cache(cache_path, cache_data) - except Exception: - # Best effort cache only. - return - - def verify_inputs( - input_file: Path, - motifs: list[str], - ref_genome: Path, - *, - quiet: bool = False, - cache: bool = True, + input_file, + motifs, + ref_genome, ): """ Checks .bam format and alignment quality (to verify that you are using the right reference genome) The correct-bases-called fraction, if under 35%, means the user almost definitely passed the wrong reference genome. """ - if cache: - cached = _load_cached_verification_result( - input_file=input_file, - ref_genome=ref_genome, - motifs=motifs, - ) - if cached is not None: - if not quiet: - print("Using cached parse_bam input verification results.") - return - check_bam_format(input_file, motifs) correct_bases, total_bases = get_alignment_quality(input_file, ref_genome) if total_bases == 0: @@ -642,14 +537,6 @@ def verify_inputs( raise ValueError( f"First {NUM_READS_TO_CHECK} reads have anomalously low alignment quality: only {100 * correct_bases / total_bases}% of bases align.\nPlease verify that {input_file.name} is actually aligned to {ref_genome.name}." ) - if cache: - _store_cached_verification_result( - input_file=input_file, - ref_genome=ref_genome, - motifs=motifs, - correct_bases=correct_bases, - total_bases=total_bases, - ) return @@ -683,51 +570,71 @@ def check_bam_format( input_bam = pysam.AlignmentFile(bam_file) try: - for counter, read in enumerate(input_bam.fetch()): - if read.has_tag("Mm") or read.has_tag("Ml"): - raise ValueError( - f'Base modification tags are out of spec (Mm and Ml instead of MM and ML). \n\nConsider using "modkit update-tags {str(bam_file)} new_file.bam" in the command line with your conda environment active and then trying with the new file. For megalodon basecalling/modcalling, you may also need to pass "--mode ambiguous.\nBe sure to index the resulting .bam file."' - ) - - if read.has_tag("MM"): - mm_tag = read.get_tag("MM") - for tag_substring in mm_tag.split(";"): - if not tag_substring: - continue - tag_value = tag_substring.split(",", 1)[0] - if ( - len(tag_value) > 0 - and tag_value[-1] != "?" - and tag_value[-1] != "." - ): - raise ValueError( - f'Base modification tags are out of spec. Need ? or . in TAG:TYPE:VALUE for MM tag, else modified probability is considered to be implicit. \n\nConsider using "modkit update-tags {str(bam_file)} new_file.bam --mode ambiguous" in the command line with your conda environment active and then trying with the new file.' - ) - if len(tag_value) > 2 and tag_value[0] in basemods_found_dict: - correct_mod_codes = mod_codes_dict[tag_value[0]] - if tag_value[2] in correct_mod_codes: - basemods_found_dict[tag_value[0]] = True + reads_checked = 0 + for counter, read in enumerate( + itertools.islice(input_bam.fetch(), NUM_READS_TO_CHECK) + ): + reads_checked = counter + 1 + read_dict = read.to_dict() + for tag_string in read_dict["tags"]: + tag = tag_string.split(",")[0].split(":")[0] + if tag == "Mm" or tag == "Ml": + raise ValueError( + f'Base modification tags are out of spec (Mm and Ml instead of MM and ML). \n\nConsider using "modkit update-tags {str(bam_file)} new_file.bam" in the command line with your conda environment active and then trying with the new file. For megalodon basecalling/modcalling, you may also need to pass "--mode ambiguous.\nBe sure to index the resulting .bam file."' + ) + elif tag == "MM": + for tag_substring in tag_string.split(";"): + tag_fields = tag_substring.split(",")[0].split(":") + if len(tag_fields) >= 3: + tag_value = tag_fields[2] + else: + tag_value = tag_fields[0] + if ( + len(tag_value) > 0 + and tag_value[-1] != "?" + and tag_value[-1] != "." + ): + raise ValueError( + f'Base modification tags are out of spec. Need ? or . in TAG:TYPE:VALUE for MM tag, else modified probability is considered to be implicit. \n\nConsider using "modkit update-tags {str(bam_file)} new_file.bam --mode ambiguous" in the command line with your conda environment active and then trying with the new file.' + ) else: - mod_codes_found_dict[tag_value[0]].add(tag_value[2]) - - if all(basemods_found_dict.values()): - return - if counter >= NUM_READS_TO_CHECK: - missing_bases = [] - for base, found in basemods_found_dict.items(): - if not found: - missing_bases.append(base) - print( - f""" -WARNING: no modified appropriately-coded values found for {missing_bases} in the first {counter} reads. + if ( + len(tag_value) > 0 + and tag_value[0] in basemods_found_dict + ): + correct_mod_codes = mod_codes_dict[tag_value[0]] + # valid_mod_codes = mod_codes_dict[tag_value[0]].union( + # utils.BASEMOD_NAMES_DICT[tag_value[0]] + # ) + if tag_value[2] in correct_mod_codes: + basemods_found_dict[tag_value[0]] = True + else: + mod_codes_found_dict[tag_value[0]].add(tag_value[2]) + # With the mode-code-aware motifs, it no longer makes sense to throw this error + # This is because the warning the user gets if their mod code isn't found, or (if none is specified) + # the default mod codes aren't found, can tell them what mod codes *were* found and they can add them + # to their motif or use adjust_mods according to what makes sense. Thus, unexpected codes are not a + # problem (in part this is because parse_bam will now set thresholds for the motif-specified OR default mod codes) + # elif tag_value[2] not in valid_mod_codes: + # raise ValueError( + # f'Base modification name unexpected: {tag_value[2]} to modify {tag_value[0]}, should be in set {valid_mod_codes}. \n\nIf you know what your mod names correspond to in terms of the latest .bam standard, consider using "modkit adjust-mods {str(bam_file)} new_file.bam --convert 5mC_name m --convert N6mA_name a --convert other_basemod_name correct_label" and then trying with the new file. Note: currently supported mod names are {utils.BASEMOD_NAMES_DICT}' + # ) + if reads_checked == NUM_READS_TO_CHECK: + missing_bases = [] + for base, found in basemods_found_dict.items(): + if not found: + missing_bases.append(base) + print( + f""" +WARNING: no modified appropriately-coded values found for {missing_bases} in the first {reads_checked} reads. Do you expect this file to contain these modifications? parse_bam is looking for {motifs} but for {missing_bases} found only found {[f"{base}+{mod_codes}" for base, mod_codes in mod_codes_found_dict.items()]}. Consider passing only the motifs and mod codes (e.g. m,h,a) that you expect to be present in your file. You can use modkit adjust-mods --convert [OPTIONS] to update or consolidate mod codes. See https://github.com/nanoporetech/modkit/blob/master/book/src/advanced_usage.md """ - ) - return + ) + return except ValueError as e: if "fetch called on bamfile without index" in str(e): raise ValueError( @@ -774,286 +681,55 @@ def get_alignment_quality( # checking stage.) if read_sequence is not None: - aligned_pairs = read.get_aligned_pairs(matches_only=True) - if len(aligned_pairs) == 0: - continue - reference_positions = [pos_in_ref for _, pos_in_ref in aligned_pairs] - ref_start = min(reference_positions) - ref_end = max(reference_positions) + 1 - ref_window = genome_fasta.fetch(read.reference_name, ref_start, ref_end) - - total_bases += len(aligned_pairs) - correct_bases += sum( - 1 - for pos_in_read, pos_in_ref in aligned_pairs - if read_sequence[pos_in_read] == ref_window[pos_in_ref - ref_start] - ) + for pos_in_read, pos_in_ref in read.get_aligned_pairs(): + if pos_in_read is not None and pos_in_ref is not None: + total_bases += 1 + if read_sequence[pos_in_read] == str( + genome_fasta.fetch( + read.reference_name, pos_in_ref, pos_in_ref + 1 + ) + ): + correct_bases += 1 return correct_bases, total_bases def create_region_command_list( - output_path, - regions, - window_size, -): + output_path: Path, + regions: str | Path | list[str | Path] | None, + window_size: int | None, +) -> tuple[list[str], Path | None]: """ - Creates commands to pass to modkit for specifying genomic regions. - - TODO: Split into two function? Convert to bed, then construct commands + Create modkit `--include-bed` arguments and the processed BED path, if regions are provided. """ - if regions is not None: - bed_filepath_processed = output_path / "regions.processed.bed" - regions_dict = utils.regions_dict_from_input( - regions, - window_size, - ) - utils.bed_from_regions_dict(regions_dict, bed_filepath_processed) - region_specifier = ["--include-bed", str(bed_filepath_processed)] - - else: - bed_filepath_processed = None - region_specifier = [] - - return region_specifier, bed_filepath_processed - - -def _build_extract_motif_command_list(motifs: list[str]) -> list[str]: - seen_motif_specs: set[tuple[str, int]] = set() - motif_command_list: list[str] = [] - for motif in motifs: - parsed_motif = utils.ParsedMotif(motif) - motif_spec = (parsed_motif.motif_seq, parsed_motif.modified_pos) - if motif_spec in seen_motif_specs: - continue - seen_motif_specs.add(motif_spec) - motif_command_list.extend( - ["--motif", parsed_motif.motif_seq, str(parsed_motif.modified_pos)] - ) - if not motif_command_list: - raise ValueError("Error: no motifs specified. Nothing to process.") - return motif_command_list - - -def _parse_positive_int(value: str | None) -> int | None: - if value is None: - return None - text = str(value).strip() - if not text: - return None - digits = [] - for char in text: - if char.isdigit(): - digits.append(char) - else: - break - if not digits: - return None - parsed = int("".join(digits)) - return parsed if parsed > 0 else None - - -def _slurm_memory_limit_bytes() -> int | None: - mem_per_node_mb = _parse_positive_int(os.environ.get("SLURM_MEM_PER_NODE")) - mem_per_cpu_mb = _parse_positive_int(os.environ.get("SLURM_MEM_PER_CPU")) - cpus_per_task = _parse_positive_int(os.environ.get("SLURM_CPUS_PER_TASK")) - cpus_on_node = _parse_positive_int(os.environ.get("SLURM_CPUS_ON_NODE")) - - candidates: list[int] = [] - if mem_per_node_mb is not None: - candidates.append(mem_per_node_mb * 1024 * 1024) - if mem_per_cpu_mb is not None: - cpus = cpus_per_task or cpus_on_node or utils.cores_to_run(None) - candidates.append(mem_per_cpu_mb * cpus * 1024 * 1024) - if not candidates: - return None - return min(candidates) - - -def _available_memory_bytes_for_modkit() -> int | None: - override = _parse_positive_int(os.environ.get("DIMELO_AVAILABLE_MEMORY_BYTES")) - if override is not None: - return override - - candidates: list[int] = [] - slurm_limit = _slurm_memory_limit_bytes() - if slurm_limit is not None: - candidates.append(slurm_limit) - - try: - import psutil # type: ignore + bed_filepath_processed = _regions_to_processed_bed( + output_path=output_path, + regions=regions, + window_size=window_size, + ) + if bed_filepath_processed is None: + return [], None + return ["--include-bed", str(bed_filepath_processed)], bed_filepath_processed - candidates.append(int(psutil.virtual_memory().available)) - except Exception: - pass - if not candidates: +def _regions_to_processed_bed( + output_path: Path, + regions: str | Path | list[str | Path] | None, + window_size: int | None, +) -> Path | None: + """ + Build a normalized BED file from region inputs for downstream modkit calls. + """ + if regions is None: return None - return min(candidates) - - -def _memory_limited_modkit_threads(cpu_limited_threads: int) -> int: - available = _available_memory_bytes_for_modkit() - if available is None: - return cpu_limited_threads - - per_thread = _parse_positive_int(os.environ.get("DIMELO_MODKIT_MEMORY_PER_THREAD_BYTES")) - if per_thread is None: - per_thread = DEFAULT_MODKIT_MEMORY_PER_THREAD_BYTES - - fraction = DEFAULT_MODKIT_MEMORY_FRACTION - fraction_env = os.environ.get("DIMELO_MODKIT_MEMORY_FRACTION") - if fraction_env: - try: - parsed_fraction = float(fraction_env) - if 0 < parsed_fraction <= 1: - fraction = parsed_fraction - except ValueError: - pass - - budget = int(available * fraction) - if budget <= 0: - return 1 - memory_cap = max(1, budget // max(1, per_thread)) - return max(1, min(cpu_limited_threads, memory_cap)) - - -def _sort_bedmethyl_output( - *, - input_bedmethyl: Path, - output_bedmethyl_sorted: Path, - requested_cores: int | None, - quiet: bool, -) -> None: - sort_threads = utils.cores_to_run(requested_cores) - sort_tmpdir = os.environ.get("SLURM_TMPDIR") - basic_command = ["sort", "-k1,1", "-k2,2n", str(input_bedmethyl)] - attempts: list[list[str]] = [] - if sort_threads > 1: - parallel_command = [ - "sort", - "--parallel", - str(sort_threads), - "-k1,1", - "-k2,2n", - str(input_bedmethyl), - ] - if sort_tmpdir: - attempts.append(parallel_command[:-1] + ["-T", sort_tmpdir, parallel_command[-1]]) - attempts.append(parallel_command) - if sort_tmpdir: - attempts.append(["sort", "-k1,1", "-k2,2n", "-T", sort_tmpdir, str(input_bedmethyl)]) - attempts.append(basic_command) - - last_error: subprocess.CalledProcessError | None = None - for attempt_index, command in enumerate(attempts): - with output_bedmethyl_sorted.open("w") as sorted_file: - try: - subprocess.run(command, stdout=sorted_file, stderr=subprocess.PIPE, text=True, check=True) - return - except subprocess.CalledProcessError as err: - last_error = err - if not quiet and attempt_index == 0: - print("Falling back to compatible sort options after --parallel sort failure.") - if last_error is not None: - raise last_error - - -def _resolve_modkit_threads_command(*, cores: int | None, quiet: bool) -> list[str]: - available_cores = utils.cores_to_run(None) - if cores is None: - resolved_cores = _memory_limited_modkit_threads(available_cores) - if not quiet: - if resolved_cores < available_cores: - print( - f"No specified number of cores requested. CPU allows {available_cores}, memory-aware cap allocates {resolved_cores}." - ) - else: - print( - f"No specified number of cores requested. {available_cores} available in this runtime, allocating all." - ) - return ["--threads", str(resolved_cores)] - - requested_cores = int(cores) - resolved_cores = utils.cores_to_run(requested_cores) - if requested_cores != resolved_cores and not quiet: - print( - f"Warning: requested {requested_cores} cores, allocating {resolved_cores} based on available CPU/cluster constraints." - ) - elif not quiet: - print(f"Allocating requested {resolved_cores} cores.") - return ["--threads", str(resolved_cores)] - - -def _build_compressed_read_vectors( - *, - valid_coordinates: list[int], - mod_values: list[float], - read_len: int, - thresh: float | None, - compress_level: int, -) -> tuple[np.ndarray, np.ndarray]: - if len(valid_coordinates) > 0: - read_len_along_ref = max(valid_coordinates) + 1 - else: - read_len_along_ref = read_len - - coordinate_array = np.asarray(valid_coordinates, dtype=np.intp) - - mod_vector = np.zeros(read_len_along_ref, dtype=np.uint8) - if coordinate_array.size > 0: - if thresh is None: - # We subtract 0.25 because in modkit they add 0.5, but our elements are zero when the - # base motif isn't present, so to get things to round to the right integers to match the - # original .bam file, subtracting 0.25 is good. Anything from 0.001 to 0.4999 would work. - mod_values_uint8 = np.rint(np.asarray(mod_values) * 256 - 0.25).astype(np.uint8) - else: - mod_values_uint8 = np.asarray(mod_values, dtype=np.uint8) - mod_vector[coordinate_array] = mod_values_uint8 - - valid_vector = np.zeros(read_len_along_ref, dtype=np.uint8) - if coordinate_array.size > 0: - valid_vector[coordinate_array] = 1 - - mod_vector_compressed = np.frombuffer( - gzip.compress(mod_vector.tobytes(), compresslevel=compress_level), - dtype=np.uint8, - ) - valid_vector_compressed = np.frombuffer( - gzip.compress(valid_vector.tobytes(), compresslevel=compress_level), - dtype=np.uint8, + bed_filepath_processed = output_path / "regions.processed.bed" + regions_dict = utils.regions_dict_from_input( + regions, + window_size, ) - return mod_vector_compressed, valid_vector_compressed - - -def _iupac_bases_for_char(base_char: str) -> set[str]: - return IUPAC_BASES.get(base_char.upper(), {base_char.upper()}) - - -def _kmer_matches_parsed_motif(kmer_context: str, parsed_motif: utils.ParsedMotif) -> bool: - kmer = kmer_context.strip().upper() - motif_seq = parsed_motif.motif_seq.upper() - if len(kmer) == 0 or len(kmer) < len(motif_seq): - return False - - kmer_center = len(kmer) // 2 - for start_index in range(0, len(kmer) - len(motif_seq) + 1): - if start_index + parsed_motif.modified_pos != kmer_center: - continue - matches = True - for kmer_char, motif_char in zip( - kmer[start_index : start_index + len(motif_seq)], - motif_seq, - ): - if _iupac_bases_for_char(kmer_char).isdisjoint( - _iupac_bases_for_char(motif_char) - ): - matches = False - break - if matches: - return True - return False + utils.bed_from_regions_dict(regions_dict, bed_filepath_processed) + return bed_filepath_processed def read_by_base_txt_to_hdf5( @@ -1064,24 +740,24 @@ def read_by_base_txt_to_hdf5( quiet: bool = False, compress_level: int = 1, chunk_size: int = 1000, - require_motif_context: bool = False, ) -> None: """ - Takes in a txt file generated by modkit extract and appends - all the data from a specified motif into an hdf5 file. If a thresh is specified, it - also binarizes the mod calls. - - If the h5 file does not exist it will be created and datasets will be added for read_name, - chromosome, read_start, read_end, strand, motif, mod_vector, and val_vector. - - All the datasets (exception threshold) are parallel arrays of length num_reads - - Each read's position data is defined in genomic reference coordinates on the positive strand - (i.e. the read_start is the leftmost aligned position, read_end is the rightmost, vectors - are left to right along genomic coordinates) - - TODO: Make a nice key:value map of the h5 file structure, make sure start and end are documented - as reconstructions NOT original cigarstring alignment info. mention pysam + Takes in a txt file generated by modkit extract and appends all the data from a + specified motif into an hdf5 file. If a thresh is specified, the mod calls are + binarized at write time and the threshold is stored alongside the vectors. + + If the h5 file does not exist it will be created with top-level datasets named + ``read_name``, ``chromosome``, ``read_start``, ``read_end``, ``strand``, ``motif``, + ``mod_vector``, and ``val_vector``. Each dataset stores one value per read, so the arrays + are parallel and have length ``num_reads``. The optional ``threshold`` dataset stores the + scalar threshold used for binarization and is not part of the per-read arrays. + + Each read's position data is stored in genomic reference coordinates on the positive strand + convention. ``read_start`` and ``read_end`` are reconstructed from the aligned modkit extract + coordinates, not copied from the original BAM CIGAR string or any raw alignment tag. In this + representation, ``read_start`` is the leftmost aligned reference position for the read and + ``read_end`` is the rightmost aligned reference position observed while iterating through the + read. The modification vectors are ordered left to right along genomic coordinates. Args: input_txt: a string or Path pointing to a modkit extracted base-by-base modifications @@ -1094,30 +770,37 @@ def read_by_base_txt_to_hdf5( a methylated adenine is specified as 'A,0' or 'A,0,a' and CpG methylation is specified as 'CG,0' or 'CG,0,m'. thresh: a floating point threshold for base modification calling, between zero and one. - If specified as None, raw probabilities will be saved in the .h5 output. + If specified as None, raw probabilities will be saved in the .h5 output. If set, + the stored mod_vector values are binary 0/1 values at motif-valid coordinates. quiet: if True, this suppresses outputs compress_level: gzip compression level for datasets, specifically for vectors for now chunk_size: size of write chunks in reads - require_motif_context: if True, additionally filter rows to motif sequence using the kmer - context column from modkit extract output (used when one extract pass includes many motifs) Returns: None - """ - """ - TODO: There are some issues that are all related here: - dimelo/parse_bam.py:718: error: Incompatible types in assignment (expression has type "Path | None", variable has type "str | Path") [assignment] - dimelo/parse_bam.py:725: error: Item "str" of "str | Path" has no attribute "open" [union-attr] - dimelo/parse_bam.py:890: error: Item "str" of "str | Path" has no attribute "name" [union-attr] - - I'm not sure of the most elegant way to fix it. Come back and address. """ input_txt, output_h5 = utils.sanitize_path_args(input_txt, output_h5) + input_txt = Path(input_txt) + output_h5 = Path(output_h5) parsed_motif = utils.ParsedMotif(motif) - with input_txt.open() as txt: + read_name = "" + num_reads = 0 + with input_txt.open(newline="") as txt: + reader = csv.reader(txt, delimiter="\t") + # Check file length + line_index = -1 + for line_index, fields in enumerate(reader): + if line_index > 0 and read_name != fields[0]: + read_name = fields[0] + num_reads += 1 + if line_index < 0: + raise ValueError(f"modkit extract output is empty: {input_txt}") + num_lines = line_index + txt.seek(0) + with h5py.File(output_h5, "a") as h5: ## Define hdf5 dataset types for later dt_str = h5py.string_dtype(encoding="utf-8") @@ -1125,9 +808,9 @@ def read_by_base_txt_to_hdf5( # h5py does not appear to otherwise support vlen binary dt_vlen = h5py.vlen_dtype(np.dtype("uint8")) - ## Format threshold value and create dataset to store whether this data is thresholded (binary) or raw (float16) - # TODO: should this method thresholding without binarization - # None becomes NaN + ## Format threshold value and create dataset to store whether this data is thresholded (binary) or raw. + # Option 1: thresholded outputs are written as binary 0/1 vectors and the threshold dataset + # records the cutoff used. Raw-probability outputs are preserved only when thresh is None. threshold_to_store = np.nan if thresh is None else thresh if "threshold" in h5: threshold_from_existing = h5["threshold"][()] @@ -1140,317 +823,244 @@ def read_by_base_txt_to_hdf5( else: h5.create_dataset("threshold", data=threshold_to_store) + ## Create read metadata datasets if "read_name" in h5: old_size = h5["read_name"].shape[0] + h5["read_name"].resize((old_size + num_reads,)) else: old_size = 0 h5.create_dataset( "read_name", - (old_size,), + (num_reads,), maxshape=(None,), dtype=dt_str, compression="gzip", compression_opts=9, ) + def ensure_dataset_capacity( + *, + name: str, + dtype, + mismatch_message: str, + compression: str | None = None, + compression_opts: int | None = None, + ) -> None: + if name in h5: + if old_size != h5[name].shape[0]: + print(mismatch_message) + else: + h5[name].resize((old_size + num_reads,)) + return + + create_kwargs: dict[str, object] = { + "maxshape": (None,), + "dtype": dtype, + } + if compression is not None: + create_kwargs["compression"] = compression + if compression_opts is not None: + create_kwargs["compression_opts"] = compression_opts - ## Create read metadata datasets - # TODO: loop through dict instead? - if "chromosome" in h5: - if old_size != h5["chromosome"].shape[0]: - print("size mismatch: read_name:chromosome") - else: - h5.create_dataset( - "chromosome", - (old_size,), - maxshape=(None,), - dtype=dt_str, - compression="gzip", - compression_opts=9, - ) - if "read_start" in h5: - if old_size != h5["read_start"].shape[0]: - print("size mismatch", "read_name", "read_start") - else: - h5.create_dataset( - "read_start", - (old_size,), - maxshape=(None,), - dtype="i", - compression="gzip", - compression_opts=9, - ) - if "read_end" in h5: - if old_size != h5["read_end"].shape[0]: - print("size mismatch", "read_name", "read_end") - else: - h5.create_dataset( - "read_end", - (old_size,), - maxshape=(None,), - dtype="i", - compression="gzip", - compression_opts=9, - ) - if "strand" in h5: - if old_size != h5["strand"].shape[0]: - print("size mismatch", "read_name", "strand") - else: h5.create_dataset( - "strand", - (old_size,), - maxshape=(None,), - dtype=dt_str, - compression="gzip", - compression_opts=9, + name, + (num_reads,), + **create_kwargs, ) - if "motif" in h5: - if old_size != h5["motif"].shape[0]: - print("size mismatch", "read_name", "motif") - else: - h5.create_dataset( - "motif", - (old_size,), - maxshape=(None,), - dtype=dt_str, + + for dataset_name, dataset_dtype, mismatch_message in [ + ("chromosome", dt_str, "size mismatch: read_name:chromosome"), + ("read_start", "i", "size mismatch read_name:read_start"), + ("read_end", "i", "size mismatch read_name:read_end"), + ("strand", dt_str, "size mismatch read_name:strand"), + ("motif", dt_str, "size mismatch read_name:motif"), + ]: + ensure_dataset_capacity( + name=dataset_name, + dtype=dataset_dtype, + mismatch_message=mismatch_message, compression="gzip", compression_opts=9, ) ## Create the vector datasets. These will contain raw bytes formatted into a uint8 array - # TODO: loop through dict instead - if "mod_vector" in h5: - if old_size != h5["mod_vector"].shape[0]: - print("size mismatch read_name:mod_vector") - else: - h5.create_dataset( - "mod_vector", - (old_size,), - maxshape=(None,), - dtype=dt_vlen, - # compression='gzip', # we are handling compression ourselves because hdf5 is bad at it - # compression_opts=9, - ) - if "val_vector" in h5: - if old_size != h5["val_vector"].shape[0]: - print("size mismatch read_name:val_vector") - else: - h5.create_dataset( - "val_vector", - (old_size,), - maxshape=(None,), + for dataset_name in ["mod_vector", "val_vector"]: + ensure_dataset_capacity( + name=dataset_name, dtype=dt_vlen, - # compression='gzip', # we are handling compression ourselves because hdf5 is bad at it - # compression_opts=9, + mismatch_message=f"size mismatch read_name:{dataset_name}", ) - read_name_dataset = h5["read_name"] - chromosome_dataset = h5["chromosome"] - read_start_dataset = h5["read_start"] - read_end_dataset = h5["read_end"] - strand_dataset = h5["strand"] - motif_dataset = h5["motif"] - mod_vector_dataset = h5["mod_vector"] - val_vector_dataset = h5["val_vector"] - ## Add data to datasets from txt file # Initialize loop vars - these will go into datasets - # TODO: initialize read name to actual first read so we can get rid of the logic in the loop - read_name = "" + read_name: str | None = None read_chrom = "" - read_len = 0 ref_strand = "" - reverse_read = False read_start = 0 read_end = 0 - valid_coordinates_list: list[int] = [] + valid_genomic_positions_list: list[int] = [] mod_values_list: list[float] = [] # Count reads for batched write - write_index = old_size - safe_chunk_size = max(1, int(chunk_size)) - reads_in_chunk = 0 - - chunk_read_names: list[str] = [] - chunk_chromosomes: list[str] = [] - chunk_read_starts: list[int] = [] - chunk_read_ends: list[int] = [] - chunk_strands: list[str] = [] - chunk_motifs: list[str] = [] - chunk_mod_vectors: list[np.ndarray] = [] - chunk_val_vectors: list[np.ndarray] = [] - - motif_base = parsed_motif.modified_base - motif_mod_codes = parsed_motif.mod_codes - raw_probabilities = thresh is None - - def _write_chunk() -> None: - nonlocal reads_in_chunk, write_index - if reads_in_chunk == 0: + read_counter = 0 + # Keys (strings): dataset names, values: lists of dataset values by read; string or ints or arrays + # Contents reset at the end of each chunk, after writing to h5 + chunk_rows: defaultdict[str, list[str | int | np.ndarray]] = ( + defaultdict(list) + ) + chunk_row_count = 0 + + def flush_pending_chunk_to_h5() -> None: + nonlocal chunk_row_count, chunk_rows + if chunk_row_count <= 0: return - start_index = write_index - end_index = write_index + reads_in_chunk - read_name_dataset.resize((end_index,)) - chromosome_dataset.resize((end_index,)) - read_start_dataset.resize((end_index,)) - read_end_dataset.resize((end_index,)) - strand_dataset.resize((end_index,)) - motif_dataset.resize((end_index,)) - mod_vector_dataset.resize((end_index,)) - val_vector_dataset.resize((end_index,)) - read_name_dataset[start_index:end_index] = chunk_read_names - chromosome_dataset[start_index:end_index] = chunk_chromosomes - read_start_dataset[start_index:end_index] = chunk_read_starts - read_end_dataset[start_index:end_index] = chunk_read_ends - strand_dataset[start_index:end_index] = chunk_strands - motif_dataset[start_index:end_index] = chunk_motifs - mod_vector_dataset[start_index:end_index] = chunk_mod_vectors - val_vector_dataset[start_index:end_index] = chunk_val_vectors - write_index = end_index - chunk_read_names.clear() - chunk_chromosomes.clear() - chunk_read_starts.clear() - chunk_read_ends.clear() - chunk_strands.clear() - chunk_motifs.clear() - chunk_mod_vectors.clear() - chunk_val_vectors.clear() - reads_in_chunk = 0 - - def _append_current_read() -> None: - nonlocal reads_in_chunk - mod_vector_compressed, valid_vector_compressed = ( - _build_compressed_read_vectors( - valid_coordinates=valid_coordinates_list, - mod_values=mod_values_list, - read_len=read_len, - thresh=thresh, - compress_level=compress_level, + start_index = old_size + read_counter - chunk_row_count + end_index = old_size + read_counter + for dataset, entry in chunk_rows.items(): + h5[dataset][start_index:end_index] = entry + chunk_rows = defaultdict(list) + chunk_row_count = 0 + + def flush_current_read() -> None: + nonlocal read_counter, chunk_row_count, chunk_rows + + if read_name is None: + return + + read_len_along_ref = max(read_end - read_start, 1) + + # Populate mod vector array appropriately based on thresh settings. + # Option 1: when thresh is provided, write binary 0/1 values; otherwise preserve raw probs. + mod_vector = np.zeros(read_len_along_ref, dtype=np.uint8) + valid_vector = np.zeros(read_len_along_ref, dtype=np.uint8) + + if len(valid_genomic_positions_list) > 0: + valid_coordinates = ( + np.asarray(valid_genomic_positions_list, dtype=int) - read_start ) + mod_values = np.asarray(mod_values_list, dtype=float) + in_bounds = (valid_coordinates >= 0) & ( + valid_coordinates < read_len_along_ref + ) + valid_coordinates = valid_coordinates[in_bounds] + mod_values = mod_values[in_bounds] + + if thresh is None: + # We subtract 0.25 because in modkit they add 0.5, but our elements are zero when the + # base motif isn't present, so to get things to round to the right integers to match the + # original .bam file, subtracting 0.25 is good. Anything from 0.001 to 0.4999 would work I think + mod_vector[valid_coordinates] = np.rint( + mod_values * 256 - 0.25 + ).astype(np.uint8) + else: + mod_vector[valid_coordinates] = mod_values.astype(np.uint8) + valid_vector[valid_coordinates] = 1 + + mod_vector_compressed = _compress_uint8_vector( + mod_vector, compress_level=compress_level + ) + valid_vector_compressed = _compress_uint8_vector( + valid_vector, compress_level=compress_level ) - chunk_read_names.append(read_name) - chunk_chromosomes.append(read_chrom) - chunk_read_starts.append(read_start) - chunk_read_ends.append(read_end) - chunk_strands.append(ref_strand) - chunk_motifs.append(motif) - chunk_mod_vectors.append(mod_vector_compressed) - chunk_val_vectors.append(valid_vector_compressed) - reads_in_chunk += 1 - if reads_in_chunk >= safe_chunk_size: - _write_chunk() + + chunk_rows["read_name"].append(read_name) + chunk_rows["chromosome"].append(read_chrom) + chunk_rows["read_start"].append(read_start) + chunk_rows["read_end"].append(read_end) + chunk_rows["strand"].append(ref_strand) + chunk_rows["motif"].append(motif) + chunk_rows["mod_vector"].append(mod_vector_compressed) + chunk_rows["val_vector"].append(valid_vector_compressed) + + read_counter += 1 + chunk_row_count += 1 + if chunk_row_count >= chunk_size: + flush_pending_chunk_to_h5() # Setting up progress bars if not in quiet mode # Skip header - iterator = txt - header_line = next(iterator, None) - if require_motif_context: - if header_line is None: - raise ValueError( - "Cannot require motif context: extract output is empty (missing header)." - ) - header_fields = header_line.rstrip("\n").split("\t") - if len(header_fields) <= 14: - raise ValueError( - "Cannot require motif context: extract output is missing the kmer context column." - ) + reader = csv.reader(txt, delimiter="\t") + next(reader) + iterator = reader if not quiet: iterator = tqdm( iterator, - desc=f"Transferring reads from {input_txt.name} into {output_h5.name}", + total=num_lines, + desc=f"Transferring {num_reads} from {input_txt.name} into {output_h5.name}, new size {old_size + num_reads}", + bar_format="{bar}| {desc} {percentage:3.0f}% | {elapsed}<{remaining}", ) # Loop through txt file - for line in iterator: - # TODO: use csv module - fields = line.rstrip("\n").split("\t") - read_id = fields[0] - pos_in_read = int(fields[1]) + for fields in iterator: pos_in_genome = int(fields[2]) + canonical_base = fields[15] + prob = float(fields[10]) + mod_code = fields[11] + pos_in_read = int(fields[1]) + line_read_len = int(fields[9]) + line_ref_strand = fields[5] + pos_in_read_ref = _reference_oriented_read_offset( + pos_in_read=pos_in_read, + read_length=line_read_len, + ref_strand=line_ref_strand, + ) + start_candidate = pos_in_genome - pos_in_read_ref + end_candidate = start_candidate + line_read_len - if read_name != read_id: - if len(read_name) > 0: - _append_current_read() + if read_name != fields[0]: + flush_current_read() ## Set up for next read # Metadata - read_name = read_id + read_name = fields[0] read_chrom = fields[3] - read_len = int(fields[9]) - ref_strand = fields[5] - reverse_read = ref_strand == "-" - if reverse_read: - pos_in_read_ref = read_len - pos_in_read - 1 - else: - pos_in_read_ref = pos_in_read - # Calculate read start (leftmost position on ref genome) - # TODO: logic can be replaced when we switch to true read start/end from modkit - read_start = pos_in_genome - pos_in_read_ref - read_end = 0 + ref_strand = line_ref_strand + read_start = start_candidate + read_end = end_candidate # Instantiate lists mod_values_list = [] - valid_coordinates_list = [] - - # TODO: verify that read position is in the right (ref) coordinate system - if reverse_read: - pos_in_read_ref = read_len - pos_in_read - 1 - else: - pos_in_read_ref = pos_in_read - - # Adjust the read_end (rightmost position on ref genome) each time there's a new mod - # This will lead to the most accurate end positions for gapped reads - # TODO: logic can be replaced when we switch to true read start/end from modkit - read_end = pos_in_genome + (read_len - pos_in_read_ref) + valid_genomic_positions_list = [] + + # keep read extents in reference coordinates by using inferred starts/ends from + # each line, which is robust even when rows are not ordered by genomic position + read_start = min(read_start, start_candidate) + read_end = max(read_end, end_candidate) + # Regardless of whether its a new read or not, # add modification to vector if motif type is correct # for the motif in question - canonical_base = fields[15] - mod_code = fields[11] if ( - canonical_base == motif_base - and mod_code in motif_mod_codes + canonical_base == parsed_motif.modified_base + and mod_code in parsed_motif.mod_codes ): - if require_motif_context: - if len(fields) <= 14: - raise ValueError( - "Cannot require motif context: encountered extract row without kmer context column." - ) - if not _kmer_matches_parsed_motif(fields[14], parsed_motif): - continue - valid_coordinates_list.append(pos_in_genome - read_start) - prob = float(fields[10]) - if raw_probabilities: + valid_genomic_positions_list.append(pos_in_genome) + if thresh is None: mod_values_list.append(prob) elif prob >= thresh: mod_values_list.append(1) else: mod_values_list.append(0) - # Save the last read - # TODO: try to consolidate - if len(read_name) > 0: - _append_current_read() - _write_chunk() + flush_current_read() + flush_pending_chunk_to_h5() return def prep_output_directory( output_directory: Path | None, output_name: str, - input_file: Path, + default_directory: Path, output_file_names: list[str], ) -> tuple[Path, list[Path]]: """ As a side effect, if files exist that match the requested outputs, they are deleted. - TODO: Is it kind of silly that this takes in input_file? Maybe should take in some generic default parameter, or this default should be set outside this method? - Args: output_directory: Path pointing to an output directory. If left as None, outputs will be stored in a new folder within the input directory. output_name: a string that will be used to create an output folder containing the intermediate and final outputs, along with any logs. - input_file: Path to input file; used to define default output directory + default_directory: default output directory when output_directory is None output_file_names: list of names of desired output files Returns: @@ -1458,7 +1068,7 @@ def prep_output_directory( * List of Paths to requested output files """ if output_directory is None: - output_directory = input_file.parent + output_directory = default_directory print(f"No output directory provided, using input directory {output_directory}") output_path = output_directory / output_name diff --git a/tests/test_parse_bam.py b/tests/test_parse_bam.py index 7caaf2a..f8423e4 100644 --- a/tests/test_parse_bam.py +++ b/tests/test_parse_bam.py @@ -1,425 +1,111 @@ -from __future__ import annotations - -import gzip -from pathlib import Path - -import h5py -import numpy as np import pytest +from pathlib import Path from dimelo import parse_bam class _FakeRead: - def __init__( - self, - *, - tags: dict[str, object] | None = None, - query_sequence: str | None = None, - aligned_pairs: list[tuple[int, int]] | None = None, - reference_name: str = "chr1", - ) -> None: - self._tags = tags or {} - self.query_sequence = query_sequence - self._aligned_pairs = aligned_pairs or [] - self.reference_name = reference_name - - def has_tag(self, tag: str) -> bool: - return tag in self._tags - - def get_tag(self, tag: str): - return self._tags[tag] - - def get_aligned_pairs(self, matches_only: bool = False): - assert matches_only is True - return list(self._aligned_pairs) - - -class _FakeBam: - def __init__(self, reads: list[_FakeRead]) -> None: - self._reads = reads - - def fetch(self): - return iter(self._reads) - + def __init__(self, tags=None): + self._tags = tags or [] -class _FakeFasta: - def __init__(self, mapping: dict[tuple[str, int, int], str]) -> None: - self.mapping = mapping - self.calls: list[tuple[str, int, int]] = [] + def to_dict(self): + return {"tags": self._tags} - def fetch(self, chrom: str, start: int, end: int) -> str: - key = (chrom, start, end) - self.calls.append(key) - return self.mapping[key] +class _FakeAlignmentFile: + def __init__(self, read_count): + self.read_count = read_count + self.reads_yielded = 0 -def test_check_bam_format_rejects_lowercase_mm_ml(monkeypatch): - fake_bam = _FakeBam(reads=[_FakeRead(tags={"Mm": "x"})]) - monkeypatch.setattr(parse_bam.pysam, "AlignmentFile", lambda *_args, **_kwargs: fake_bam) - - with pytest.raises(ValueError, match="Mm and Ml"): - parse_bam.check_bam_format("ignored.bam", motifs=["A,0,a"]) - - -def test_check_bam_format_rejects_implicit_mm_probability(monkeypatch): - fake_bam = _FakeBam(reads=[_FakeRead(tags={"MM": "A+a,0;"})]) - monkeypatch.setattr(parse_bam.pysam, "AlignmentFile", lambda *_args, **_kwargs: fake_bam) - - with pytest.raises(ValueError, match="Need \\? or \\."): - parse_bam.check_bam_format("ignored.bam", motifs=["A,0,a"]) - - -def test_check_bam_format_accepts_expected_mod_code(monkeypatch): - fake_bam = _FakeBam(reads=[_FakeRead(tags={"MM": "A+a?,0;"})]) - monkeypatch.setattr(parse_bam.pysam, "AlignmentFile", lambda *_args, **_kwargs: fake_bam) + def fetch(self): + for _ in range(self.read_count): + self.reads_yielded += 1 + yield _FakeRead() - # Should return without raising because the expected mod code is present. - parse_bam.check_bam_format("ignored.bam", motifs=["A,0,a"]) +class _TagSequenceAlignmentFile: + def __init__(self, reads): + self._reads = reads -def test_resolve_modkit_threads_command_auto(monkeypatch): - monkeypatch.setattr(parse_bam, "_memory_limited_modkit_threads", lambda cores: cores) - monkeypatch.setattr( - parse_bam.utils, - "cores_to_run", - lambda cores: 6 if cores is None else min(int(cores), 6), - ) - assert parse_bam._resolve_modkit_threads_command(cores=None, quiet=True) == [ - "--threads", - "6", - ] + def fetch(self): + for read in self._reads: + yield read -def test_resolve_modkit_threads_command_caps_requested_cores(monkeypatch): - monkeypatch.setattr(parse_bam, "_memory_limited_modkit_threads", lambda cores: cores) - monkeypatch.setattr( - parse_bam.utils, - "cores_to_run", - lambda cores: 5 if cores is None else min(int(cores), 5), - ) - assert parse_bam._resolve_modkit_threads_command(cores=12, quiet=True) == [ - "--threads", - "5", - ] - - -def test_get_alignment_quality_fetches_reference_window_per_read(tmp_path: Path, monkeypatch): - ref = tmp_path / "ref.fa" - ref.write_text(">chr1\nACGT\n", encoding="utf-8") - (tmp_path / "ref.fa.fai").write_text("fake-index\n", encoding="utf-8") - - fake_reads = [ - _FakeRead( - query_sequence="ACG", - aligned_pairs=[(0, 100), (1, 101), (2, 102)], - reference_name="chr1", - ), - _FakeRead( - query_sequence="TT", - aligned_pairs=[(0, 200), (1, 201)], - reference_name="chr1", - ), - ] - fake_bam = _FakeBam(fake_reads) - fake_fasta = _FakeFasta( - mapping={ - ("chr1", 100, 103): "ACG", - ("chr1", 200, 202): "TA", - } - ) +def test_check_bam_format_consumes_at_most_the_first_100_reads(monkeypatch): + fake_alignment_file = _FakeAlignmentFile(parse_bam.NUM_READS_TO_CHECK + 1) monkeypatch.setattr( - parse_bam.pysam, "AlignmentFile", lambda *_args, **_kwargs: fake_bam + parse_bam.pysam, + "AlignmentFile", + lambda *args, **kwargs: fake_alignment_file, ) - monkeypatch.setattr( - parse_bam.pysam, "FastaFile", lambda *_args, **_kwargs: fake_fasta - ) - - correct, total = parse_bam.get_alignment_quality("ignored.bam", ref) - assert total == 5 - assert correct == 4 - assert fake_fasta.calls == [("chr1", 100, 103), ("chr1", 200, 202)] + parse_bam.check_bam_format("dummy.bam", motifs=["A,0", "CG,0"]) + assert fake_alignment_file.reads_yielded == parse_bam.NUM_READS_TO_CHECK -def test_build_compressed_read_vectors_raw_probabilities(): - mod_compressed, valid_compressed = parse_bam._build_compressed_read_vectors( - valid_coordinates=[0, 2], - mod_values=[0.5, 1.0], - read_len=4, - thresh=None, - compress_level=1, - ) - - mod_vector = np.frombuffer(gzip.decompress(mod_compressed.tobytes()), dtype=np.uint8) - valid_vector = np.frombuffer(gzip.decompress(valid_compressed.tobytes()), dtype=np.uint8) - assert mod_vector.tolist() == [128, 0, 0] - assert valid_vector.tolist() == [1, 0, 1] - - -def test_build_compressed_read_vectors_thresholded_binary(): - mod_compressed, valid_compressed = parse_bam._build_compressed_read_vectors( - valid_coordinates=[1, 3], - mod_values=[1, 0], - read_len=5, - thresh=0.8, - compress_level=1, - ) - - mod_vector = np.frombuffer(gzip.decompress(mod_compressed.tobytes()), dtype=np.uint8) - valid_vector = np.frombuffer(gzip.decompress(valid_compressed.tobytes()), dtype=np.uint8) - - assert mod_vector.tolist() == [0, 1, 0, 0] - assert valid_vector.tolist() == [0, 1, 0, 1] - - -def test_read_by_base_txt_to_hdf5_round_trip_thresholded(tmp_path: Path): - input_txt = tmp_path / "reads.A,0,a.txt" - output_h5 = tmp_path / "reads.h5" - input_txt.write_text( - "\n".join( - [ - "read_id\tread_pos\tref_pos\tchrom\tref_kmer\tref_strand\tref_mod_strand\tfw_soft_clipped_start\tfw_soft_clipped_end\tread_length\tcall_prob\tcall_code\tbase_qual\tref_position\tref_kmer_5mer\tcanonical_base\textra_col", - "read1\t0\t100\tchr1\tNNNNN\t+\t+\t0\t0\t4\t0.9\ta\t0\t100\tAAAAA\tA\tX", - "read1\t1\t101\tchr1\tNNNNN\t+\t+\t0\t0\t4\t0.1\ta\t0\t101\tAAAAA\tA\tX", - "read1\t2\t102\tchr1\tNNNNN\t+\t+\t0\t0\t4\t0.8\tm\t0\t102\tCCCCC\tC\tX", - "read2\t0\t200\tchr2\tNNNNN\t+\t+\t0\t0\t3\t0.7\ta\t0\t200\tAAAAA\tA\tX", - "", - ] - ), - encoding="utf-8", - ) - - parse_bam.read_by_base_txt_to_hdf5( - input_txt=input_txt, - output_h5=output_h5, - motif="A,0,a", - thresh=0.5, - quiet=True, - chunk_size=1, - ) - - with h5py.File(output_h5, "r") as h5: - assert h5["read_name"].shape[0] == 2 - assert h5["read_name"][0].decode("utf-8") == "read1" - assert h5["read_name"][1].decode("utf-8") == "read2" - assert h5["chromosome"][0].decode("utf-8") == "chr1" - assert h5["chromosome"][1].decode("utf-8") == "chr2" - assert h5["read_start"][0] == 100 - assert h5["read_end"][0] == 104 - assert h5["read_start"][1] == 200 - assert h5["read_end"][1] == 203 - - read1_mod = np.frombuffer( - gzip.decompress(h5["mod_vector"][0].tobytes()), dtype=np.uint8 - ) - read1_val = np.frombuffer( - gzip.decompress(h5["val_vector"][0].tobytes()), dtype=np.uint8 - ) - read2_mod = np.frombuffer( - gzip.decompress(h5["mod_vector"][1].tobytes()), dtype=np.uint8 - ) - read2_val = np.frombuffer( - gzip.decompress(h5["val_vector"][1].tobytes()), dtype=np.uint8 - ) - - assert read1_mod.tolist() == [1, 0] - assert read1_val.tolist() == [1, 1] - assert read2_mod.tolist() == [1] - assert read2_val.tolist() == [1] - - -def test_read_by_base_txt_to_hdf5_appends_across_calls(tmp_path: Path): - first_txt = tmp_path / "reads_first.A,0,a.txt" - second_txt = tmp_path / "reads_second.A,0,a.txt" - output_h5 = tmp_path / "reads.h5" - - header = ( - "read_id\tread_pos\tref_pos\tchrom\tref_kmer\tref_strand\tref_mod_strand\t" - "fw_soft_clipped_start\tfw_soft_clipped_end\tread_length\tcall_prob\tcall_code\t" - "base_qual\tref_position\tref_kmer_5mer\tcanonical_base\textra_col" - ) - first_txt.write_text( - "\n".join( - [ - header, - "read1\t0\t100\tchr1\tNNNNN\t+\t+\t0\t0\t3\t0.9\ta\t0\t100\tAAAAA\tA\tX", - "", - ] - ), - encoding="utf-8", - ) - second_txt.write_text( - "\n".join( - [ - header, - "read2\t0\t200\tchr2\tNNNNN\t+\t+\t0\t0\t3\t0.7\ta\t0\t200\tAAAAA\tA\tX", - "read3\t0\t300\tchr3\tNNNNN\t+\t+\t0\t0\t3\t0.6\ta\t0\t300\tAAAAA\tA\tX", - "", - ] - ), - encoding="utf-8", - ) - - parse_bam.read_by_base_txt_to_hdf5( - input_txt=first_txt, - output_h5=output_h5, - motif="A,0,a", - thresh=0.5, - quiet=True, - ) - parse_bam.read_by_base_txt_to_hdf5( - input_txt=second_txt, - output_h5=output_h5, - motif="A,0,a", - thresh=0.5, - quiet=True, - ) - - with h5py.File(output_h5, "r") as h5: - assert h5["read_name"].shape[0] == 3 - assert [value.decode("utf-8") for value in h5["read_name"][:]] == [ - "read1", - "read2", - "read3", +def test_check_bam_format_raises_on_malformed_tags_after_motifs_are_found(monkeypatch): + fake_alignment_file = _TagSequenceAlignmentFile( + [ + _FakeRead(["MM:Z:A+a?;C+m?"]), + _FakeRead(["Mm:Z:A+a?"]), ] - - -def test_read_by_base_txt_to_hdf5_require_motif_context_missing_column_raises( - tmp_path: Path, -): - input_txt = tmp_path / "reads_missing_context.txt" - output_h5 = tmp_path / "reads_missing_context.h5" - input_txt.write_text( - "\n".join( - [ - "read_id\tread_pos\tref_pos\tchrom\tref_kmer\tref_strand\tref_mod_strand\tfw_soft_clipped_start\tfw_soft_clipped_end\tread_length\tcall_prob\tcall_code\tbase_qual\tref_position", - "read1\t0\t100\tchr1\tNNNNN\t+\t+\t0\t0\t4\t0.9\ta\t0\t100", - "", - ] - ), - encoding="utf-8", ) - with pytest.raises(ValueError, match="missing the kmer context column"): - parse_bam.read_by_base_txt_to_hdf5( - input_txt=input_txt, - output_h5=output_h5, - motif="A,0,a", - thresh=0.5, - quiet=True, - require_motif_context=True, - ) - + monkeypatch.setattr( + parse_bam.pysam, + "AlignmentFile", + lambda *args, **kwargs: fake_alignment_file, + ) -def test_kmer_matches_parsed_motif_with_iupac(): - parsed = parse_bam.utils.ParsedMotif("GCH,1,m") - assert parse_bam._kmer_matches_parsed_motif("AGCAT", parsed) is True - assert parse_bam._kmer_matches_parsed_motif("AGCGT", parsed) is False + with pytest.raises(ValueError, match="Mm and Ml instead of MM and ML"): + parse_bam.check_bam_format("dummy.bam", motifs=["A,0", "CG,0"]) -def test_verify_inputs_uses_cache(tmp_path: Path, monkeypatch): - bam = tmp_path / "input.bam" - ref = tmp_path / "ref.fa" - bam.write_text("bam", encoding="utf-8") - ref.write_text(">chr1\nA\n", encoding="utf-8") +def test_threads_command_list_defaults_to_all_available_cores(monkeypatch): + monkeypatch.setattr(parse_bam.multiprocessing, "cpu_count", lambda: 12) - called = {"format": 0, "align": 0} + command = parse_bam._threads_command_list(cores=None, quiet=True) - def _fake_check(_bam, _motifs): - called["format"] += 1 + assert command == ["--threads", "12"] - def _fake_align(_bam, _ref): - called["align"] += 1 - return 90, 100 - monkeypatch.setattr(parse_bam, "check_bam_format", _fake_check) - monkeypatch.setattr(parse_bam, "get_alignment_quality", _fake_align) +def test_threads_command_list_caps_requested_cores_to_available(monkeypatch): + monkeypatch.setattr(parse_bam.multiprocessing, "cpu_count", lambda: 8) - parse_bam.verify_inputs(bam, ["A,0,a"], ref, quiet=True, cache=True) - parse_bam.verify_inputs(bam, ["A,0,a"], ref, quiet=True, cache=True) + command = parse_bam._threads_command_list(cores=32, quiet=True) - assert called["format"] == 1 - assert called["align"] == 1 + assert command == ["--threads", "8"] -def test_resolve_modkit_threads_command_memory_caps_auto(monkeypatch): - monkeypatch.setattr( - parse_bam.utils, - "cores_to_run", - lambda cores: 8 if cores is None else min(int(cores), 8), - ) - monkeypatch.setattr(parse_bam, "_available_memory_bytes_for_modkit", lambda: 4 * 1024 * 1024 * 1024) - monkeypatch.setenv("DIMELO_MODKIT_MEMORY_PER_THREAD_BYTES", str(2 * 1024 * 1024 * 1024)) - monkeypatch.setenv("DIMELO_MODKIT_MEMORY_FRACTION", "1.0") +def test_threads_command_list_uses_requested_cores_when_available(monkeypatch): + monkeypatch.setattr(parse_bam.multiprocessing, "cpu_count", lambda: 16) - assert parse_bam._resolve_modkit_threads_command(cores=None, quiet=True) == [ - "--threads", - "2", - ] + command = parse_bam._threads_command_list(cores=6, quiet=True) + assert command == ["--threads", "6"] -def test_extract_runs_modkit_once_and_routes_per_motif(tmp_path: Path, monkeypatch): - bam = tmp_path / "input.bam" - ref = tmp_path / "ref.fa" - bam.write_text("bam", encoding="utf-8") - ref.write_text(">chr1\nA\n", encoding="utf-8") - output_path = tmp_path / "out" - output_path.mkdir(parents=True, exist_ok=True) - output_reads = output_path / "reads.combined_basemods.h5" - monkeypatch.setattr( - parse_bam.utils, - "sanitize_path_args", - lambda *_args: (bam, ref, tmp_path), - ) - monkeypatch.setattr(parse_bam, "verify_inputs", lambda *_args, **_kwargs: None) - monkeypatch.setattr( - parse_bam, - "prep_output_directory", - lambda **_kwargs: (output_path, [output_reads]), +def test_create_region_command_list_returns_empty_without_regions(tmp_path): + command, bed_path = parse_bam.create_region_command_list( + output_path=tmp_path, + regions=None, + window_size=None, ) - monkeypatch.setattr( - parse_bam, - "create_region_command_list", - lambda *_args, **_kwargs: ([], None), - ) - monkeypatch.setattr( - parse_bam, - "_resolve_modkit_threads_command", - lambda **_kwargs: ["--threads", "2"], - ) - - modkit_commands: list[list[str]] = [] - - def _fake_run_with_progress_bars(**kwargs): - modkit_commands.append(list(kwargs["command_list"])) - return "" - - routed_reads: list[tuple[str, bool, Path]] = [] - def _fake_read_to_h5(input_txt, _output_h5, motif, _thresh, **kwargs): - routed_reads.append((motif, kwargs.get("require_motif_context", False), Path(input_txt))) - return None + assert command == [] + assert bed_path is None - monkeypatch.setattr(parse_bam.run_modkit, "run_with_progress_bars", _fake_run_with_progress_bars) - monkeypatch.setattr(parse_bam, "read_by_base_txt_to_hdf5", _fake_read_to_h5) - parse_bam.extract( - input_file=bam, - output_name="out", - ref_genome=ref, - output_directory=tmp_path, - motifs=["A,0,a", "A,0,Y", "CG,0,m"], - quiet=True, - cleanup=False, +def test_create_region_command_list_writes_processed_bed(tmp_path): + command, bed_path = parse_bam.create_region_command_list( + output_path=tmp_path, + regions="chr1:10-20", + window_size=None, ) - assert len(modkit_commands) == 1 - command = modkit_commands[0] - assert command.count("--motif") == 2 - assert len(routed_reads) == 3 - assert all(require_context for _motif, require_context, _input_txt in routed_reads) - assert len({input_txt for _motif, _require_context, input_txt in routed_reads}) == 1 + assert bed_path == Path(tmp_path) / "regions.processed.bed" + assert command == ["--include-bed", str(bed_path)] + assert bed_path.exists() From f470a59dfe1e1a4186fdbb429d2a489da236d7e9 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Thu, 16 Apr 2026 23:28:05 -0700 Subject: [PATCH 268/272] feat: integrate DMR workflows and refresh clustering/tutorial tooling --- .gitignore | 13 + README.md | 137 +- dimelo/__init__.py | 14 + dimelo/chip_atlas.py | 1259 +++++ dimelo/cluster.py | 2095 +++++-- dimelo/dmr.py | 375 ++ dimelo/global_analysis.py | 5 +- dimelo/load_processed.py | 77 +- dimelo/models.py | 97 + dimelo/parse_bam.py | 458 +- dimelo/plot_depth_histogram.py | 19 +- dimelo/plot_depth_profile.py | 33 +- dimelo/plot_enrichment.py | 16 +- dimelo/plot_enrichment_profile.py | 28 +- dimelo/plot_reads.py | 31 +- dimelo/plotting.py | 374 ++ dimelo/plotting_matplotlib.py | 196 +- dimelo/region_analysis.py | 10 +- dimelo/regulatory_enrichment.py | 1170 ++++ dimelo/run_modkit.py | 231 +- dimelo/utils.py | 11 +- dimelo/workflows.py | 690 ++- dimelo_test.ipynb | 4795 +++++++++++++++++ dmr_multi_sample.ipynb | 122 + .../hdf5_openzl_compression_benchmark.py | 334 ++ docs/modkit-dmr.md | 58 + docs/region-discovery.md | 5 +- docs/roadmap-2026-04-wrapup.md | 85 + docs/shared-clustering.md | 15 +- environment.yml | 7 +- modkit_update_tests.ipynb | 436 ++ scripts/bootstrap_dimelo_env.sh | 63 + scripts/ensure_dimelo_kernel.py | 365 ++ scripts/run_tutorial_offline.py | 95 + scripts/update_modkit_version.sh | 32 + tests/test_chip_atlas.py | 267 + tests/test_cluster.py | 704 ++- tests/test_dmr.py | 127 + tests/test_load_processed_aliases.py | 81 - tests/test_models.py | 51 + tests/test_parse_bam.py | 197 +- tests/test_parse_bam_vectors.py | 68 + tests/test_plotting.py | 465 +- tests/test_regulatory_enrichment.py | 400 ++ tests/test_run_modkit.py | 125 + tests/test_workflows.py | 447 ++ tutorial.ipynb | 285 +- tutorial_offline.ipynb | 314 ++ 48 files changed, 16579 insertions(+), 703 deletions(-) create mode 100644 dimelo/chip_atlas.py create mode 100644 dimelo/dmr.py create mode 100644 dimelo/regulatory_enrichment.py create mode 100644 dimelo_test.ipynb create mode 100644 dmr_multi_sample.ipynb create mode 100644 docs/benchmarks/hdf5_openzl_compression_benchmark.py create mode 100644 docs/modkit-dmr.md create mode 100644 docs/roadmap-2026-04-wrapup.md create mode 100644 modkit_update_tests.ipynb create mode 100755 scripts/bootstrap_dimelo_env.sh create mode 100644 scripts/ensure_dimelo_kernel.py create mode 100644 scripts/run_tutorial_offline.py create mode 100755 scripts/update_modkit_version.sh create mode 100644 tests/test_chip_atlas.py create mode 100644 tests/test_dmr.py delete mode 100644 tests/test_load_processed_aliases.py create mode 100644 tests/test_regulatory_enrichment.py create mode 100644 tests/test_run_modkit.py create mode 100644 tutorial_offline.ipynb diff --git a/.gitignore b/.gitignore index f8245de..2566728 100644 --- a/.gitignore +++ b/.gitignore @@ -61,6 +61,19 @@ dimelo/test/output # Checkpoint files .ipynb_checkpoints/ +*.executed.ipynb # Local worktrees .worktrees/ + +# Local analysis artifacts and caches +artifacts/ +cache/ +docs/benchmarks/tmp_bench/ + +# Local benchmark/output files +modkit_test_results.json +pileup_0.2.4.bed.gz +pileup_0.2.4_test.bed +pileup_0.2.4_test.bed.gz +pileup_0.6.1.bed.gz diff --git a/README.md b/README.md index 313a916..36ff0bd 100644 --- a/README.md +++ b/README.md @@ -83,6 +83,32 @@ conda env create -f environment.yml *If you want to handle environment creation yourself, see [the alternative installation instructions](#alternative-installations).* +### Recommended one-command bootstrap (dev + notebook) + +For local development and notebook work, prefer the bootstrap helper. It creates/updates the conda env, installs the package in editable mode with clustering extras, registers a Jupyter kernel, and runs a full environment health check. + +``` +bash scripts/bootstrap_dimelo_env.sh +``` + +Defaults: +- conda env: `dimelo-toolkit` +- kernel name: `dimelo-test` + +Notes: +- The bootstrap uses **flexible** conda channel priority for environment solve stability with `nanoporetech::modkit`. +- Python scientific/user packages are installed via `pip` inside the conda env (`-e .[clustering]`) to avoid channel pin conflicts. + +Optional overrides: + +``` +bash scripts/bootstrap_dimelo_env.sh "" +``` + +Examples: +- Keep default tested pin (`0.2.4`): `bash scripts/bootstrap_dimelo_env.sh` +- Install a specific version (for example `0.6.1`): `bash scripts/bootstrap_dimelo_env.sh dimelo-toolkit dimelo-test "Python (dimelo-test)" 0.6.1` + ### Install pip dependencies and core dimelo-toolkit package Activate your conda environment, which should now contain python 3.11 and a modkit executable on the path and executable on your system. @@ -97,6 +123,12 @@ Ensure that you are still in the top-level dimelo-toolkit directory. Install the pip install . ``` +To verify the active environment at any time: + +``` +python scripts/ensure_dimelo_kernel.py --expected-env dimelo-toolkit +``` + ## Google Colab Installation Run the following code in the first cell of your notebook to grab `modkit v0.2.4` from conda and install the `dimelo-toolkit main` branch. This will have to be run whenever you make a new Colab instance, unless you have a better way of managing this, in which case please reach out. The tutorial notebook runs equivalent code blocks to set up your environment, so if you are trying to run the tutorial you can skip to [Basic Use](#basic-use). @@ -113,15 +145,27 @@ condacolab.install() import dimelo ``` +`dimelo-toolkit` parsing paths support both `modkit 0.2.4` and `modkit 0.6.x`. The default environment pin remains conservative (`0.2.4`) for reproducibility, but you can install `0.6.x` when preferred. + +To switch versions in an existing env: + +``` +bash scripts/update_modkit_version.sh dimelo-toolkit 0.6.1 +``` + ## Alternative Installations -Alternatively, you can install modkit into any conda environment you like. If you want to, you can install modkit some other way, and then add it to the path of your notebook or script. *NOTE: if you are creating the environment yourself, be sure to use python 3.10 or greater. Some dimelo-toolkit features require relatively new python releases.* +Alternatively, you can install modkit into any conda environment you like. If you want to, you can install modkit some other way, and then add it to the path of your notebook or script. Supported series are `0.2.4` and `0.6.x`. *NOTE: if you are creating the environment yourself, be sure to use python 3.10 or greater. Some dimelo-toolkit features require relatively new python releases.* ``` conda install nanoporetech::modkit==0.2.4 ``` OR ``` +conda install nanoporetech::modkit=0.6 +``` +OR +``` # install modkit some other way # add to path in python before importing dimelo import sys @@ -160,6 +204,12 @@ pytest See the [tutorial](tutorial.ipynb) as a starting point. +For deterministic local verification (no external network dependency), run [tutorial_offline.ipynb](tutorial_offline.ipynb) and use: + +``` +python scripts/run_tutorial_offline.py +``` + For local operation on Mac or Linux, you will already have cloned the repo to disk in the installation step. Activate your conda environment, make sure you have jupyter installed, and then launch a jupyter notebook server and navigate to `tutorial.ipynb`. You can also use other tools to open the jupyter notebook or you can simply reference it as an example. ``` @@ -193,13 +243,14 @@ def pileup( output_directory: str | Path = None, regions: str | Path | list[str | Path] = None, motifs: list = ['A,0','CG,0'], - thresh: float = None, + thresh: float | dict[str, float] | None = None, window_size: int = None, cores: int = None, log: bool = False, cleanup: bool = True, quiet: bool = False, - override_checks: bool = False,) -> Path, Path: + override_checks: bool = False, + modkit_executable: str | Path | None = None,) -> Path, Path: ``` `parse_bam.extract` creates an hdf5 file with datasets for different aspects of single read data, which can then be passed to plot single reads. @@ -211,13 +262,14 @@ def extract( output_directory: str | Path = None, regions: str | Path | list[str | Path] = None, motifs: list = ['A,0','CG,0','GCH,1'], - thresh: float = None, + thresh: float | dict[str, float] | None = None, window_size: int = None, cores: int = None, log: bool = False, cleanup: bool = True, quiet: bool = False, - override_checks: bool = False,) -> Path, Path: + override_checks: bool = False, + modkit_executable: str | Path | None = None,) -> Path, Path: ``` ## Analysis Guides @@ -226,15 +278,37 @@ Three higher-level analysis guides now sit on top of the existing parsing layer: - [docs/global-analysis.md](docs/global-analysis.md) for pileup-backed global summaries and normalization factors - [docs/region-discovery.md](docs/region-discovery.md) for de novo and paired locus discovery from tiled pileup scans -- [docs/shared-clustering.md](docs/shared-clustering.md) for shared-boundary clustering workflows +- [docs/shared-clustering.md](docs/shared-clustering.md) for shared-boundary clustering workflows, with read-window clustering as the default path and region-anchored analysis as an exploratory option - [docs/region-contrasts.md](docs/region-contrasts.md) for known-region motif-abundance and cluster-occupancy contrasts +- [docs/modkit-dmr.md](docs/modkit-dmr.md) for native `modkit dmr` pair/multi workflows and HMM segmentation +- native `modkit dmr` wrappers in `dimelo.dmr` and `dimelo.workflows` for pairwise beta-binomial DMR testing and optional HMM segmentation (`modkit_dmr_pair_workflow`) plus multi-sample regional DMR (`modkit_dmr_multi_workflow`) -Use `parse_bam.pileup()` when you want defined-region abundance testing, and use `parse_bam.extract()` when you want read-level clustering or single-read follow-up. When you want occupancy-backed region contrasts, run clustering first and pass `SharedClusterResult.region_summaries` into `region_contrasts.score_regions(..., analysis_unit="cluster_occupancy")`. +Use `parse_bam.extract()` when you want read-level clustering or single-read follow-up. The recommended path is to cluster read windows first, then summarize those read-cluster labels at the region level with `SharedClusterResult.region_summaries` and `region_contrasts.score_regions(..., analysis_unit="cluster_occupancy")`. Use `parse_bam.pileup()` when you want defined-region abundance testing, or when you intentionally want optional region-anchored/profile clustering for exploratory shape-based analysis. For an end-to-end discovery-to-clustering run, use `workflows.discovery_cluster_workflow()`. It keeps discovery output in BED-style `selected_regions`, then derives the serializable region spec that `shared_cluster_distribution(..., matched_regions=...)` consumes. For discovery-to-clustering-to-contrast follow-up, use `workflows.discovery_cluster_contrast_workflow()`. It keeps discovery output in BED-style `selected_regions`, passes the derived serializable region spec into clustering, normalizes clustering-side `region_id` values to the same `chr:start-end,strand` key used by contrasts, scores the same selected loci by default, honors an explicit `contrasts["regions"]` override when provided, and stores the full discovery scan in `metadata["full_scan_windows"]`. +For production region discovery and DMR calling across samples, prefer the native `modkit dmr` wrappers: +- `workflows.modkit_dmr_pair_workflow(...)` for pairwise site-level DMR with optional HMM segmentation (`segment_path=...`) +- `workflows.modkit_dmr_multi_workflow(...)` or `workflows.modkit_dmr_multi_from_samples_workflow(...)` for all-vs-all multi-sample regional DMR + +`dimelo_test.ipynb` stays single-sample focused. See `dmr_multi_sample.ipynb` for a multi-sample DMR template notebook. + +For external regulatory-context enrichment, use `dimelo.chip_atlas.run_enrichment(...)` directly on BED-like region inputs, or use `workflows.chip_atlas_cluster_enrichment_workflow(...)` to query ChIP-Atlas from read-cluster region associations (`SharedClusterResult.region_summaries`) either per cluster or as a combined region set. + +If your regions are in a different assembly than the requested ChIP-Atlas genome (for example CHM13 regions against `hg38`/`hg19` catalogs), pass `regions_genome=...` and the ChIP-Atlas interface can convert coordinates inline using CrossMap before submission. The helper `dimelo.chip_atlas.cache_chain_files(source_genome="chm13", target_genomes=("hg38","hg19"))` pre-fetches and caches chain files under `cache/chains/` so repeated queries reuse local chain assets. + +The ChIP-Atlas API currently requires class/threshold fields to be populated. `dimelo.chip_atlas` now defaults to `antigen_class="TFs and others"`, `cell_type_class="No description"`, and `threshold="100"`; override them when you want narrower biological context. + +For mixed-provider regulatory follow-up (e.g. SCREEN + UniBind), use `workflows.resolve_regulatory_enrichment_spec(...)` to normalize species/provider configuration before running provider-specific queries. The spec defaults to human (`homo_sapiens`) and `target_genome="hg38"`, supports explicit `reference_genome` / `target_genome` / CrossMap chain settings for arbitrary assemblies, validates species against the UniBind-supported species set, and automatically filters out `screen` requests when species is not human or mouse. + +For dataset-level ChIP-Atlas BED retrieval (antigen-first), use `chip_atlas.search_peak_datasets(...)` / `workflows.chip_atlas_search_peak_datasets_workflow(...)` with required `antigen` plus optional `genome`, `cell_type`, `antigen_class`, and `cell_type_class` filters. Then pass the returned table to `chip_atlas.download_peak_datasets(...)` / `workflows.chip_atlas_download_peak_datasets_workflow(...)` to generate complete sorted BEDs, top/bottom subsets (default top/bottom 3,000), optional quantile splits (`quartiles`, `quintiles`, `deciles`, or integer bin count), and optional CrossMap-converted BED6 outputs to a target assembly. + +For UniBind track inputs, `workflows.resolve_unibind_track_paths(...)` supports either explicit local track paths (`track_paths=[...]`) or Track Hub discovery/download to cache (`trackhub_url` or named `collection="robust"|"permissive"`), with optional `search_terms`, `max_tracks`, and `convert_bigbed_to_bed=True` (requires `bigBedToBed` on PATH). + +For UniBind web-tool workflows (TFBS extraction and enrichment), use `dimelo.regulatory_enrichment.run_unibind_tfbs_extraction(...)` and `run_unibind_enrichment(...)` or the workflow wrappers `workflows.unibind_tfbs_extraction_workflow(...)` / `workflows.unibind_enrichment_workflow(...)`. These functions submit CSRF-protected UniBind forms programmatically, poll job status (`Queued`/`Running`/`Completed`), expose downloadable result URLs, and can optionally cache downloads under `cache/unibind_jobs/`. + `region_discovery` also exposes renderer-neutral plotting prep helpers that consume `RegionDiscoveryResult`: `prepare_region_discovery_scan_data(...)` prepares per-contig scan and hit tables by default, and `prepare_region_discovery_hit_context_data(...)` prepares local hit-context tables for small-multiple follow-up views. `global_analysis` now exposes renderer-neutral plotting prep helpers that consume `GlobalAnalysisResult`: `prepare_global_analysis_summary_data(...)` prepares sample-level summaries, optional condition-level views, and normalization tables, while `prepare_global_analysis_window_data(...)` prepares broad-window payloads that stay per-contig by default. @@ -273,7 +347,7 @@ There should not be such issues for command line operation. See below an example ``` (dimelo-toolkit) % python dimelo_cmd.py -modkit found with expected version 0.2.4 +modkit detected and command capabilities loaded No specified number of cores requested. 8 available on machine, allocating all. Modification threshold of 0.9 will be treated as coming from range 0-1. ████████████████████| Preprocessing complete for motifs ['A,0'] in chm13.draft_v1.1.fasta: 100% | 00:30 @@ -293,6 +367,8 @@ Legacy plotting entry points remain supported, but they now share a common plott - Single-read plots remain coordinate-preserving. They can use fixed-window coordinates and 5'->3' orientation, but they do not stretch variable-length regions onto a synthetic continuous axis. - Built-in Matplotlib plotting is still available, while plot-ready tables remain the stable contract for users who prefer seaborn, Plotly, Altair, or custom renderers. +For legacy API compatibility, `by_regions(...)` helpers now also accept `regions=` as an alias to `regions_list=` across enrichment/depth/profile plotting modules. + Newer region-contrast plotting helpers accept a `RegionContrastResult` plus an explicit `position_table` from the parsing/loading layer. This keeps region scoring and positional extraction separate while still using the shared plotting-axis system. The current helper contract expects `region_id`, `position`, `anchor`, `value`, `region_strand`, and either `condition` or `sample_id` in that positional table. `plot_enrichment_profile` module for pileup line plot profiles across one or more region @@ -910,13 +986,13 @@ def regions_to_list( ## Clustering scaffolding -`dimelo.cluster` wraps the loading utilities above so you can quickly build matrices for downstream clustering or dimensionality reduction. +`dimelo.cluster` wraps the loading utilities above so you can quickly build matrices for read-window clustering, dimensionality reduction, or optional region-anchored exploratory analysis. For the higher-level shared-boundary workflows added on top of these loaders, see [docs/shared-clustering.md](docs/shared-clustering.md). The short version is: -- run `parse_bam.extract()` for `mode="read_global"` -- run `parse_bam.pileup()` for `mode="region_anchored"` -- run both when you want region-level summaries plus read-level follow-up +- recommended: run `parse_bam.extract()` and cluster read windows first, then feed the resulting read-cluster labels into region-level occupancy follow-up +- optional: run `parse_bam.pileup()` and `mode="region_anchored"` when you want region-aligned exploratory clustering on shape-like summaries +- run both when you want region-level summaries plus read-level follow-up in the same analysis ```python from dimelo import workflows @@ -933,10 +1009,23 @@ result = workflows.shared_cluster_distribution( ) ``` -``` +```python from dimelo import cluster -# Region-level features: rows are regions, columns are aligned positions. +# Recommended read-window clustering pipeline using extract outputs. +read_windows = cluster.extract_read_windows( + hdf5_file="output/extract.h5", + motifs=["A,0", "CG,0"], + regions="regions.bed", + config=cluster.ReadWindowExtractionConfig(window_bp=2000, orientation_aware=True), +) +feature_matrix, feature_names = cluster.read_window_feature_matrix(read_windows) +read_clusters = cluster.cluster_read_windows(feature_matrix, method="kmeans", n_clusters=8) + +# Use the resulting read-cluster labels as the bridge into region-level occupancy or contrasts. +# For example, pass SharedClusterResult.region_summaries into region_contrasts.score_regions(..., analysis_unit="cluster_occupancy"). + +# Optional region-anchored exploratory analysis from pileup-derived region vectors. pileup_matrix, region_info = cluster.region_feature_matrix_from_pileup( bedmethyl_file="output/pileup.sorted.bed.gz", motif="A,0", @@ -946,16 +1035,6 @@ pileup_matrix, region_info = cluster.region_feature_matrix_from_pileup( ) labels, model = cluster.cluster_features(pileup_matrix, n_clusters=4) -# Read-level feature pipeline using extract outputs. -read_windows = cluster.extract_read_windows( - hdf5_file="output/extract.h5", - motifs=["A,0", "CG,0"], - regions="regions.bed", - config=cluster.ReadWindowExtractionConfig(window_size=2000, orientation_aware=True), -) -feature_matrix, feature_names = cluster.read_window_feature_matrix(read_windows) -read_clusters = cluster.cluster_read_windows(feature_matrix, method="kmeans", n_clusters=8) - # Optional visualization/export cluster.plot_region_cluster_profiles(pileup_matrix, labels, window_bp=1000) cluster.export_region_clusters_to_bed(region_info, labels, "region_clusters.bed") @@ -989,7 +1068,7 @@ sampled_features, sampled_labels, idx = cluster.sample_rows(feature_matrix, labe cluster.cluster_read_windows(sampled_features, method="kmeans", n_clusters=4) ``` -`region_feature_matrix_from_pileup` delegates to `load_processed.regions_to_list`, so you inherit the same controls for multi-core execution and windowing. For read-level work you can either keep using `read_mod_fraction_table` (motif-wide fractions) or run the new window-based pipeline above: `extract_read_windows` builds a matrix of per-base modification calls (optionally enforcing strand orientation and dropping reads spanning multiple regions), `read_window_feature_matrix` augments that matrix with PCA, autocorrelation, density, and summary statistics, and `cluster_read_windows` exposes the same clustering options demonstrated in the exploratory notebook (k-means, GMM, spectral, OPTICS/HDBSCAN, etc.). +`region_feature_matrix_from_pileup` delegates to `load_processed.regions_to_list`, so you inherit the same controls for multi-core execution and windowing. Treat it as an optional exploratory path for region-anchored/profile clustering rather than the default workflow. For read-level work you can either keep using `read_mod_fraction_table` (motif-wide fractions) or run the read-window pipeline above: `extract_read_windows` builds a matrix of per-base modification calls (optionally enforcing strand orientation and dropping reads spanning multiple regions), `read_window_feature_matrix` augments that matrix with PCA, autocorrelation, density, and summary statistics, and `cluster_read_windows` exposes the same clustering options demonstrated in the exploratory notebook (k-means, GMM, spectral, OPTICS/HDBSCAN, etc.). `cluster_features` currently offers a lightweight k-means wrapper powered by `scikit-learn`, while `cluster_read_windows` can switch between `kmeans`, `minibatch_kmeans`, `gmm`, `agglomerative`, `spectral`, `birch`, `dbscan`, `optics`, `hdbscan`, or `umap_kmeans`. These dependencies (`scikit-learn`, `scipy`, `hdbscan`, `umap-learn`) live in the `clustering` extra (`pip install dimelo[clustering]`), or feed the matrices above into your own estimator. @@ -1019,9 +1098,13 @@ Many of the parsing, loading, and plotting functions share parameters. The commo `motif` and `motifs` are used to specify what base modifications you are interested in and what their sequence context is for parse, load, and plot functions. A single `motif` is a string containing several canonical bases (using the [IUPAC nucleic acid notation](https://en.wikipedia.org/wiki/Nucleic_acid_notation), e.g. **H** refers to "not a G"), followed by a comma, and then an integer specifying which coordinate in the string is your modified base. For example, 6mA is denoted "A,0" and CpG is denoted "CG,0" whereas GpC *excluding CpGs* is denoted "GCH,1". `motifs` is a list of such strings for functions that can work on multiple base modifications at once. -`thresh` for parsing and some loading/plotting functions refers to a base modification probability threshold, used to transform the the output of most basecalling pipelines into a binary call for any given read position. For parsing pileup calls, this defaults to `None` which allows `modkit` to pick its own threshold based on the data. For other calls, the parameter is mandatory. The normal use is specifying between 0 and 1, but 1-255 is also supported to make the inputs more backwards compatible with old `dimelo` package versions and with examination of the raw .bam file contents. A value between and 255 will simply be converted into a 0-1 probability before being handed down to subsequent processing. +`thresh` for parsing and some loading/plotting functions refers to a base modification probability threshold, used to transform the output of most basecalling pipelines into a binary call for any given read position. For parse functions, it accepts `None`, a single numeric threshold, or a per-motif dictionary (e.g. `{"A,0": 0.70, "CG,0": 0.80, "default": 0.75}`). `None` keeps adaptive/inferred thresholding behavior where applicable. Numeric values can be in [0,1] or [1,255] (the latter is converted to probability scale for backward compatibility). + +`modkit_executable` on `parse_bam.pileup()` / `parse_bam.extract()` allows pinning parsing to a specific modkit binary path/name (for example a side-by-side `modkit-0.2.4` and `modkit-0.6.1` install). You can also set `DIMELO_MODKIT_EXECUTABLE` globally. + +`window_size` for parsing and most loading and plotting functions is a *modification to your regions* that will redefine them to be all the same size, i.e. `2 x window_size`, centered around the centers of your original regions. This is important for parsing/loading/plotting operations that aggregate many loci at once, but should be left blank if you do not want your regions modified. The default is `None` for functions where the parameter is optional. -`window_size` for parsing and most loading and plotting functions is a *modification to your regions* that will redefine them to be all the same size, i.e. 2 x window_size, centered around the centers of your original regions. This is important for the parsing and plotting applications that show many genomic regions at once, but should be left blank if you don't want your regions modified. The default is `None` for functions where the parameter is optional. +For **clustering read-window extraction APIs** (`cluster.extract_read_windows`, `cluster.build_multimotif_read_windows`, and `cluster.ReadWindowExtractionConfig`) the preferred parameter is `window_bp`, which is the **full extracted span in bp**. `window_size` is still accepted there only as a backward-compatible alias. `relative` is a boolean input that specifies whether loading and plotting operations adjust coordinates to be relative to some center point or simple plot in absolute genomic coordinates. In the newer shared plotting layer, `relative=True` maps to fixed-window plotting around a common anchor. Aggregate plots may grow into richer segment-based normalization later, but single-read plotting still preserves coordinate geometry rather than stretching variable-length features. diff --git a/dimelo/__init__.py b/dimelo/__init__.py index 14d88b4..5d4dba6 100644 --- a/dimelo/__init__.py +++ b/dimelo/__init__.py @@ -1,5 +1,7 @@ from . import ( + chip_atlas, cluster, + dmr, distribution, export, global_analysis, @@ -14,6 +16,7 @@ plot_enrichment_profile, plot_read_browser, plot_reads, + regulatory_enrichment, region_discovery, region_analysis, region_contrasts, @@ -21,13 +24,19 @@ workflows, ) from .models import ( + ChipAtlasEnrichmentResult, + ModkitDMRMultiResult, + ModkitDMRPairResult, RegionDiscoveryClusterContrastResult, RegionDiscoveryClusterResult, SharedClusterContrastResult, + UniBindJobResult, ) __all__ = [ + "chip_atlas", "cluster", + "dmr", "distribution", "export", "global_analysis", @@ -42,12 +51,17 @@ "plot_enrichment_profile", "plot_read_browser", "plot_reads", + "regulatory_enrichment", "region_discovery", "region_analysis", "region_contrasts", "shared_cluster_tests", + "ChipAtlasEnrichmentResult", + "ModkitDMRMultiResult", + "ModkitDMRPairResult", "RegionDiscoveryClusterContrastResult", "RegionDiscoveryClusterResult", "SharedClusterContrastResult", + "UniBindJobResult", "workflows", ] diff --git a/dimelo/chip_atlas.py b/dimelo/chip_atlas.py new file mode 100644 index 0000000..f451f36 --- /dev/null +++ b/dimelo/chip_atlas.py @@ -0,0 +1,1259 @@ +from __future__ import annotations + +import csv +import io +import json +import re +import shutil +import subprocess +import tempfile +import time +import zipfile +from pathlib import Path +from typing import Any, Iterable, Mapping +from urllib import error, parse, request + +import numpy as np +import pandas as pd + +from .models import ChipAtlasEnrichmentResult + +DEFAULT_SUBMIT_URL = "https://dtn1.ddbj.nig.ac.jp/wabi/chipatlas/" +DEFAULT_STATUS_URL = DEFAULT_SUBMIT_URL +DEFAULT_RESULT_URL = DEFAULT_SUBMIT_URL +DEFAULT_CHAIN_CACHE_DIR = Path("cache/chains") +DEFAULT_METADATA_CACHE_DIR = Path("cache/chip_atlas") +DEFAULT_EXPERIMENT_LIST_URL = ( + "https://dbarchive.biosciencedbc.jp/data/chip-atlas/LATEST/chip_atlas_experiment_list.zip" +) + +_SUCCESS_STATUSES = {"finished"} +_TERMINAL_STATUSES = {"finished", "error", "cancelled", "unknown"} +_STATUS_ALIASES = { + "finished": "finished", + "complete": "finished", + "completed": "finished", + "done": "finished", + "success": "finished", + "ok": "finished", + "error": "error", + "failed": "error", + "failure": "error", + "cancelled": "cancelled", + "canceled": "cancelled", + "running": "running", + "preparing": "running", + "queued": "queued", + "pending": "queued", + "submitted": "queued", +} + +_GENOME_ALIASES = { + "chm13": "hs1", + "t2t-chm13v2.0": "hs1", + "t2t_chm13v2.0": "hs1", + "t2t_chm13v2": "hs1", + "hs1": "hs1", + "hg38": "hg38", + "grch38": "hg38", + "hg19": "hg19", + "grch37": "hg19", + "mm10": "mm10", + "mm39": "mm39", +} + +_CHAIN_URL_OVERRIDES = { + ("hs1", "hg38"): "https://hgdownload.soe.ucsc.edu/goldenPath/hs1/liftOver/hs1ToHg38.over.chain.gz", + ("hs1", "hg19"): "https://hgdownload.soe.ucsc.edu/goldenPath/hs1/liftOver/hs1ToHg19.over.chain.gz", +} + +_BED_THRESHOLD_COLUMN_MAP = { + "05": "Peak-call (BED) (q < 1E-05)", + "5": "Peak-call (BED) (q < 1E-05)", + "q05": "Peak-call (BED) (q < 1E-05)", + "1e-05": "Peak-call (BED) (q < 1E-05)", + "10": "Peak-call (BED) (q < 1E-10)", + "q10": "Peak-call (BED) (q < 1E-10)", + "1e-10": "Peak-call (BED) (q < 1E-10)", + "20": "Peak-call (BED) (q < 1E-20)", + "q20": "Peak-call (BED) (q < 1E-20)", + "1e-20": "Peak-call (BED) (q < 1E-20)", +} + +_STRATIFY_TO_BIN_COUNT = { + "quartile": 4, + "quartiles": 4, + "quintile": 5, + "quintiles": 5, + "decile": 10, + "deciles": 10, +} + + +def _http_request( + *, + url: str, + method: str = "GET", + data: bytes | None = None, + timeout_seconds: float = 60.0, + headers: Mapping[str, str] | None = None, +) -> tuple[int, str, str]: + request_headers = {"Accept": "application/json,text/plain,text/html,*/*"} + if headers: + request_headers.update(dict(headers)) + if method.upper() == "POST": + request_headers.setdefault("Content-Type", "application/x-www-form-urlencoded") + + req = request.Request( + url=url, + data=data, + method=method.upper(), + headers=request_headers, + ) + try: + with request.urlopen(req, timeout=timeout_seconds) as response: + status_code = int(response.getcode()) + content_type = response.headers.get("Content-Type", "") + body = response.read().decode("utf-8", errors="replace") + return status_code, content_type, body + except error.HTTPError as exc: + detail = exc.read().decode("utf-8", errors="replace") + hint = "" + lowered = detail.lower() + if exc.code == 404 and ("chip-atlas: 404" in lowered or "" in lowered): + hint = ( + " The endpoint may be outdated. The current API base URL is " + "'https://dtn1.ddbj.nig.ac.jp/wabi/chipatlas/'." + ) + raise RuntimeError( + f"ChIP-Atlas API request failed with HTTP {exc.code}: {detail[:400]}{hint}" + ) from exc + except error.URLError as exc: + raise RuntimeError(f"ChIP-Atlas API request failed: {exc.reason}") from exc + + +def _normalize_genome_name(genome: str) -> str: + token = str(genome).strip() + if not token: + raise ValueError("Genome name cannot be empty.") + lowered = token.lower() + return _GENOME_ALIASES.get(lowered, lowered) + + +def _chain_url_for_pair(source_genome: str, target_genome: str) -> str: + source = _normalize_genome_name(source_genome) + target = _normalize_genome_name(target_genome) + override = _CHAIN_URL_OVERRIDES.get((source, target)) + if override: + return override + target_token = target[0].upper() + target[1:] if target else target + return ( + f"https://hgdownload.soe.ucsc.edu/goldenPath/{source}/liftOver/" + f"{source}To{target_token}.over.chain.gz" + ) + + +def _resolve_chain_file( + *, + source_genome: str, + target_genome: str, + chain_file: str | Path | None = None, + chain_url: str | None = None, + chain_cache_dir: str | Path | None = None, + timeout_seconds: float = 120.0, +) -> Path: + if chain_file is not None: + resolved = Path(chain_file).expanduser().resolve() + if not resolved.exists(): + raise FileNotFoundError(f"CrossMap chain file not found: {resolved}") + return resolved + + source = _normalize_genome_name(source_genome) + target = _normalize_genome_name(target_genome) + cache_root = Path(chain_cache_dir) if chain_cache_dir is not None else DEFAULT_CHAIN_CACHE_DIR + cache_root.mkdir(parents=True, exist_ok=True) + cached_path = cache_root / f"{source}_to_{target}.over.chain.gz" + if cached_path.exists() and cached_path.stat().st_size > 0: + return cached_path + + url = chain_url if chain_url is not None else _chain_url_for_pair(source, target) + request_obj = request.Request(url, headers={"User-Agent": "dimelo-toolkit/1.0"}) + try: + with request.urlopen(request_obj, timeout=timeout_seconds) as response: + with cached_path.open("wb") as handle: + shutil.copyfileobj(response, handle) + except Exception as exc: + raise RuntimeError( + "Failed to download CrossMap chain file for " + f"{source_genome!r} -> {target_genome!r} from {url!r}. " + "Provide an explicit chain_file path to continue." + ) from exc + return cached_path + + +def cache_chain_files( + *, + source_genome: str = "chm13", + target_genomes: Iterable[str] = ("hg38", "hg19"), + chain_cache_dir: str | Path | None = None, + timeout_seconds: float = 120.0, +) -> dict[str, Path]: + cached: dict[str, Path] = {} + for target in target_genomes: + cached[str(target)] = _resolve_chain_file( + source_genome=source_genome, + target_genome=str(target), + chain_cache_dir=chain_cache_dir, + timeout_seconds=timeout_seconds, + ) + return cached + + +def _resolve_crossmap_executable(preferred: str | None = None) -> str: + candidates = [] + if preferred: + candidates.append(str(preferred)) + for fallback in ("CrossMap.py", "CrossMap"): + if fallback not in candidates: + candidates.append(fallback) + for candidate in candidates: + if shutil.which(candidate): + return candidate + raise RuntimeError( + "CrossMap executable was not found on PATH. Install CrossMap and ensure " + "either 'CrossMap.py' or 'CrossMap' is available." + ) + + +def _normalize_text_token(value: str | None) -> str: + if value is None: + return "" + return str(value).strip().lower() + + +def _normalize_bed_threshold(threshold: str = "05") -> str: + token = _normalize_text_token(threshold) + if token not in _BED_THRESHOLD_COLUMN_MAP: + supported = ", ".join(sorted(_BED_THRESHOLD_COLUMN_MAP)) + raise ValueError( + f"Unsupported bed threshold {threshold!r}. Supported aliases: {supported}." + ) + return token + + +def _resolve_stratification_bins(stratify: str | int | None) -> int | None: + if stratify is None: + return None + if isinstance(stratify, int): + if stratify < 2: + raise ValueError("stratify must be >= 2 when provided as an integer.") + return int(stratify) + token = _normalize_text_token(stratify) + if token in _STRATIFY_TO_BIN_COUNT: + return _STRATIFY_TO_BIN_COUNT[token] + if token.isdigit(): + parsed = int(token) + if parsed < 2: + raise ValueError("stratify must be >= 2.") + return parsed + allowed = ", ".join(sorted(_STRATIFY_TO_BIN_COUNT)) + raise ValueError( + "Unsupported stratify value " + f"{stratify!r}. Use an integer >=2 or one of: {allowed}." + ) + + +def _download_bytes( + *, + url: str, + timeout_seconds: float = 120.0, + headers: Mapping[str, str] | None = None, +) -> bytes: + req_headers = {"User-Agent": "dimelo-toolkit/1.0"} + if headers: + req_headers.update(dict(headers)) + req = request.Request(url, headers=req_headers) + try: + with request.urlopen(req, timeout=timeout_seconds) as response: + return response.read() + except error.HTTPError as exc: + detail = exc.read().decode("utf-8", errors="replace") + raise RuntimeError( + f"ChIP-Atlas download failed with HTTP {exc.code}: {url}\n{detail[:300]}" + ) from exc + except error.URLError as exc: + raise RuntimeError(f"ChIP-Atlas download failed for {url}: {exc.reason}") from exc + + +def _ensure_experiment_list_zip( + *, + experiment_list_url: str, + cache_dir: str | Path, + allow_cached: bool = True, + timeout_seconds: float = 120.0, +) -> Path: + cache_root = Path(cache_dir).expanduser().resolve() + cache_root.mkdir(parents=True, exist_ok=True) + output_path = cache_root / "chip_atlas_experiment_list.zip" + if allow_cached and output_path.exists() and output_path.stat().st_size > 0: + return output_path + payload = _download_bytes(url=experiment_list_url, timeout_seconds=timeout_seconds) + tmp_path = output_path.with_suffix(output_path.suffix + ".tmp") + tmp_path.write_bytes(payload) + tmp_path.replace(output_path) + return output_path + + +def _iter_experiment_rows(experiment_list_zip: Path) -> Iterable[dict[str, str]]: + with zipfile.ZipFile(experiment_list_zip) as archive: + member = next((name for name in archive.namelist() if name.lower().endswith(".csv")), None) + if member is None: + raise RuntimeError( + "ChIP-Atlas experiment-list archive did not contain a CSV file." + ) + with archive.open(member, "r") as handle: + reader = csv.DictReader(io.TextIOWrapper(handle, encoding="utf-8", errors="replace")) + for row in reader: + yield {str(k): ("" if v is None else str(v)) for k, v in row.items()} + + +def _score_series_for_bed(table: pd.DataFrame) -> pd.Series: + if table.shape[1] > 4: + return pd.to_numeric(table.iloc[:, 4], errors="coerce") + return pd.Series(np.zeros(table.shape[0]), index=table.index, dtype=float) + + +def _sorted_bed_by_score(table: pd.DataFrame) -> pd.DataFrame: + scores = _score_series_for_bed(table).fillna(float("-inf")) + order = scores.sort_values(ascending=False, kind="stable").index + return table.loc[order].reset_index(drop=True) + + +def _coerce_bed6(table: pd.DataFrame) -> pd.DataFrame: + if table.shape[1] < 3: + raise ValueError("BED table requires at least 3 columns.") + out = pd.DataFrame( + { + "chrom": table.iloc[:, 0].astype(str), + "start": pd.to_numeric(table.iloc[:, 1], errors="coerce").fillna(-1).astype(int), + "end": pd.to_numeric(table.iloc[:, 2], errors="coerce").fillna(-1).astype(int), + "name": table.iloc[:, 3].astype(str) if table.shape[1] > 3 else ".", + "score": table.iloc[:, 4] if table.shape[1] > 4 else 0, + "strand": table.iloc[:, 5].astype(str) if table.shape[1] > 5 else ".", + } + ) + out = out.loc[out["end"] > out["start"]].reset_index(drop=True) + return out + + +def _extract_request_id(body: str) -> str: + stripped = body.strip() + if not stripped: + raise ValueError("ChIP-Atlas submit response was empty; no request id found.") + + try: + parsed = json.loads(stripped) + except json.JSONDecodeError: + parsed = None + + if isinstance(parsed, dict): + for key in ("id", "requestId", "request_id"): + value = parsed.get(key) + if value: + return str(value) + + if "?" in stripped and "id=" in stripped: + parsed_url = parse.urlparse(stripped) + query = parse.parse_qs(parsed_url.query) + request_ids = query.get("id") + if request_ids: + return str(request_ids[0]) + + id_match = re.search(r"\b(?:id|requestId|request_id)\s*[:=]\s*['\"]?([A-Za-z0-9._-]+)", stripped) + if id_match: + return id_match.group(1) + + if re.fullmatch(r"[A-Za-z0-9._-]+", stripped): + return stripped + + raise ValueError( + "Could not parse ChIP-Atlas request id from submit response. " + f"Response snippet: {stripped[:160]}" + ) + + +def _normalize_status(status: str | None) -> str: + if status is None: + return "unknown" + normalized = str(status).strip().lower() + if not normalized: + return "unknown" + return _STATUS_ALIASES.get(normalized, normalized) + + +def _extract_status_value(body: str, parsed_body: Any) -> str | None: + if isinstance(parsed_body, dict): + for key in ("status", "state", "job_status", "phase"): + value = parsed_body.get(key) + if value is not None: + return str(value) + + if isinstance(parsed_body, str) and parsed_body.strip(): + return parsed_body.strip().splitlines()[0].strip() + + lowered = body.lower() + for token in sorted(_STATUS_ALIASES, key=len, reverse=True): + if re.search(rf"\b{re.escape(token)}\b", lowered): + return token + return None + + +def _parse_region_id(region_id: str) -> tuple[str, int, int, str]: + raw = region_id.strip() + if not raw: + raise ValueError("Empty region id is not allowed.") + if ":" not in raw or "-" not in raw: + raise ValueError( + "Region ids must look like 'chr:start-end' or 'chr:start-end,strand'. " + f"Received: {region_id!r}" + ) + + chrom, remainder = raw.split(":", 1) + strand = "." + if "," in remainder: + core, strand_token = remainder.rsplit(",", 1) + if strand_token in {"+", "-", "."}: + strand = strand_token + remainder = core + elif remainder.count(":") >= 1: + core, suffix = remainder.rsplit(":", 1) + if suffix in {"+", "-", "."}: + strand = suffix + remainder = core + + start_text, end_text = remainder.split("-", 1) + start = int(start_text) + end = int(end_text) + if start < 0 or end < 0 or end <= start: + raise ValueError(f"Invalid region coordinates in {region_id!r}") + return chrom, start, end, strand + + +def region_ids_to_bed_dataframe(region_ids: Iterable[str]) -> pd.DataFrame: + rows = [] + for index, region_id in enumerate(region_ids): + chrom, start, end, strand = _parse_region_id(str(region_id)) + rows.append( + { + "chrom": chrom, + "start": start, + "end": end, + "name": f"region_{index}", + "score": 0, + "strand": strand, + } + ) + return pd.DataFrame(rows, columns=["chrom", "start", "end", "name", "score", "strand"]) + + +def _regions_dataframe_from_input( + regions: pd.DataFrame | str | Path | Iterable[str], +) -> pd.DataFrame: + if isinstance(regions, pd.DataFrame): + source = regions.copy() + elif isinstance(regions, Path): + source = pd.read_csv(regions, sep="\t", header=None, comment="#") + elif isinstance(regions, str): + candidate = Path(regions) + if "\n" not in regions and "\t" not in regions and candidate.exists(): + source = pd.read_csv(candidate, sep="\t", header=None, comment="#") + else: + lines = [line.strip() for line in regions.splitlines() if line.strip()] + return _regions_dataframe_from_lines(lines) + else: + lines = [str(line).strip() for line in regions if str(line).strip()] + return _regions_dataframe_from_lines(lines) + + if not isinstance(source, pd.DataFrame): + raise TypeError("Could not coerce ChIP-Atlas regions to a DataFrame.") + if source.empty: + return pd.DataFrame(columns=["chrom", "start", "end", "name", "score", "strand"]) + + if source.columns.dtype == object and {"start", "end"}.issubset(source.columns): + chrom_column = "chrom" if "chrom" in source.columns else "chromosome" + if chrom_column not in source.columns: + raise ValueError( + "Region DataFrame must include 'start', 'end', and 'chrom' or 'chromosome'." + ) + normalized = pd.DataFrame( + { + "chrom": source[chrom_column].astype(str), + "start": source["start"].astype(int), + "end": source["end"].astype(int), + "name": source.get("name", pd.Series(".", index=source.index)).astype(str), + "score": source.get("score", pd.Series(0, index=source.index)), + "strand": source.get("strand", pd.Series(".", index=source.index)).astype(str), + } + ) + return normalized + + if len(source.columns) < 3: + raise ValueError("BED-like input requires at least 3 columns.") + normalized = pd.DataFrame( + { + "chrom": source.iloc[:, 0].astype(str), + "start": source.iloc[:, 1].astype(int), + "end": source.iloc[:, 2].astype(int), + "name": source.iloc[:, 3].astype(str) if len(source.columns) > 3 else ".", + "score": source.iloc[:, 4] if len(source.columns) > 4 else 0, + "strand": source.iloc[:, 5].astype(str) if len(source.columns) > 5 else ".", + } + ) + return normalized + + +def _regions_dataframe_from_lines(lines: Iterable[str]) -> pd.DataFrame: + rows = [] + for index, line in enumerate(lines): + if "\t" in line: + tokens = line.split("\t") + chrom = tokens[0] + start = int(tokens[1]) + end = int(tokens[2]) + name = tokens[3] if len(tokens) > 3 else f"region_{index}" + score = tokens[4] if len(tokens) > 4 else 0 + strand = tokens[5] if len(tokens) > 5 else "." + else: + chrom, start, end, strand = _parse_region_id(line) + name = f"region_{index}" + score = 0 + rows.append( + { + "chrom": chrom, + "start": start, + "end": end, + "name": name, + "score": score, + "strand": strand if strand in {"+", "-", "."} else ".", + } + ) + return pd.DataFrame(rows, columns=["chrom", "start", "end", "name", "score", "strand"]) + + +def _regions_to_bed_text(regions: pd.DataFrame | str | Path | Iterable[str]) -> str: + region_frame = _regions_dataframe_from_input(regions) + if region_frame.empty: + raise ValueError("ChIP-Atlas enrichment requires at least one region.") + lines = [] + for row in region_frame.itertuples(index=False): + lines.append( + "\t".join( + [ + str(row.chrom), + str(int(row.start)), + str(int(row.end)), + str(row.name), + str(row.score), + str(row.strand if row.strand in {"+", "-", "."} else "."), + ] + ) + ) + return "\n".join(lines) + + +def convert_regions_with_crossmap( + *, + regions: pd.DataFrame | str | Path | Iterable[str], + source_genome: str, + target_genome: str, + chain_file: str | Path | None = None, + chain_url: str | None = None, + chain_cache_dir: str | Path | None = None, + crossmap_executable: str | None = "CrossMap.py", + timeout_seconds: float = 300.0, +) -> pd.DataFrame: + source = _normalize_genome_name(source_genome) + target = _normalize_genome_name(target_genome) + region_frame = _regions_dataframe_from_input(regions) + if source == target: + return region_frame + if region_frame.empty: + return region_frame + + resolved_chain = _resolve_chain_file( + source_genome=source, + target_genome=target, + chain_file=chain_file, + chain_url=chain_url, + chain_cache_dir=chain_cache_dir, + timeout_seconds=min(timeout_seconds, 120.0), + ) + with tempfile.TemporaryDirectory(prefix="dimelo-crossmap-") as tmpdir: + tmp_path = Path(tmpdir) + input_bed = tmp_path / "input.bed" + output_bed = tmp_path / "mapped.bed" + region_frame.to_csv( + input_bed, + sep="\t", + index=False, + header=False, + columns=["chrom", "start", "end", "name", "score", "strand"], + ) + resolved_executable = _resolve_crossmap_executable(crossmap_executable) + cmd = [ + resolved_executable, + "bed", + str(resolved_chain), + str(input_bed), + str(output_bed), + ] + try: + proc = subprocess.run( + cmd, + capture_output=True, + text=True, + timeout=timeout_seconds, + check=False, + ) + except FileNotFoundError as exc: + raise RuntimeError( + f"CrossMap executable {resolved_executable!r} was not found. " + "Install CrossMap and ensure it is available on PATH." + ) from exc + except subprocess.TimeoutExpired as exc: + raise RuntimeError( + "CrossMap conversion timed out while converting regions from " + f"{source_genome!r} to {target_genome!r}." + ) from exc + if proc.returncode != 0: + raise RuntimeError( + "CrossMap conversion failed with exit code " + f"{proc.returncode}. stderr: {proc.stderr.strip()[:500]}" + ) + if not output_bed.exists() or output_bed.stat().st_size == 0: + raise RuntimeError( + "CrossMap conversion produced no mapped regions. " + f"source_genome={source_genome!r}, target_genome={target_genome!r}" + ) + + mapped = pd.read_csv(output_bed, sep="\t", header=None, comment="#") + if mapped.empty: + raise RuntimeError( + "CrossMap conversion returned an empty mapped region table." + ) + normalized = pd.DataFrame( + { + "chrom": mapped.iloc[:, 0].astype(str), + "start": mapped.iloc[:, 1].astype(int), + "end": mapped.iloc[:, 2].astype(int), + "name": mapped.iloc[:, 3].astype(str) if len(mapped.columns) > 3 else ".", + "score": mapped.iloc[:, 4] if len(mapped.columns) > 4 else 0, + "strand": mapped.iloc[:, 5].astype(str) if len(mapped.columns) > 5 else ".", + } + ) + normalized = normalized[normalized["end"] > normalized["start"]].reset_index(drop=True) + if normalized.empty: + raise RuntimeError( + "CrossMap conversion filtered all regions after coordinate validation." + ) + return normalized + + +def _build_url(base_url: str, params_dict: Mapping[str, Any]) -> str: + query = parse.urlencode({key: value for key, value in params_dict.items() if value is not None}) + return f"{base_url}?{query}" if query else base_url + + +def _request_url_with_request_id(base_url: str, request_id: str) -> str: + base = str(base_url).strip() + if not base: + raise ValueError("ChIP-Atlas URL cannot be empty.") + rid = parse.quote(str(request_id).strip(), safe="") + if not rid: + raise ValueError("request_id cannot be empty.") + if "{request_id}" in base: + return base.format(request_id=rid) + if base.rstrip("/").endswith(str(request_id).strip()): + return base + return f"{base.rstrip('/')}/{rid}" + + +def submit_enrichment( + *, + regions: pd.DataFrame | str | Path | Iterable[str], + genome: str = "hg38", + regions_genome: str | None = None, + antigen_class: str | None = "TFs and others", + antigen: str | None = None, + cell_type_class: str | None = "No description", + cell_type: str | None = None, + distance: int | None = None, + threshold: str | None = "100", + crossmap_chain_file: str | Path | None = None, + crossmap_chain_url: str | None = None, + crossmap_chain_cache_dir: str | Path | None = None, + crossmap_executable: str | None = "CrossMap.py", + params: Mapping[str, Any] | None = None, + submit_url: str = DEFAULT_SUBMIT_URL, + timeout_seconds: float = 60.0, +) -> dict[str, Any]: + region_payload: pd.DataFrame | str | Path | Iterable[str] = regions + conversion_metadata: dict[str, Any] = {"applied": False} + if regions_genome is not None: + input_build = _normalize_genome_name(regions_genome) + atlas_build = _normalize_genome_name(genome) + if input_build != atlas_build: + resolved_chain = _resolve_chain_file( + source_genome=input_build, + target_genome=atlas_build, + chain_file=crossmap_chain_file, + chain_url=crossmap_chain_url, + chain_cache_dir=crossmap_chain_cache_dir, + timeout_seconds=max(timeout_seconds, 120.0), + ) + region_payload = convert_regions_with_crossmap( + regions=regions, + source_genome=input_build, + target_genome=atlas_build, + chain_file=resolved_chain, + chain_url=crossmap_chain_url, + chain_cache_dir=crossmap_chain_cache_dir, + crossmap_executable=crossmap_executable, + timeout_seconds=max(timeout_seconds, 120.0), + ) + conversion_metadata = { + "applied": True, + "source_genome": input_build, + "target_genome": atlas_build, + "chain_file": str(resolved_chain), + } + else: + conversion_metadata = { + "applied": False, + "source_genome": input_build, + "target_genome": atlas_build, + } + + bed_text = _regions_to_bed_text(region_payload) + payload: dict[str, Any] = { + "format": "text", + "result": "www", + "genome": genome, + "typeA": "bed", + "bedAFile": bed_text, + "typeB": "rnd", + "bedBFile": "empty", + "permTime": 10, + "descriptionA": "query_regions", + "descriptionB": "random_permutation_background", + "title": "dimelo_toolkit_enrichment", + } + if antigen_class is not None: + payload["antigenClass"] = antigen_class + if antigen is not None: + payload["antigen"] = antigen + if cell_type_class is not None: + payload["cellClass"] = cell_type_class + payload["celltypeClass"] = cell_type_class + if cell_type is not None: + payload["cellType"] = cell_type + payload["celltype"] = cell_type + if distance is not None: + payload["distanceUp"] = int(distance) + payload["distanceDown"] = int(distance) + if threshold is not None: + payload["threshold"] = threshold + if params: + payload.update(dict(params)) + encoded = parse.urlencode( + { + key: ",".join(map(str, value)) if isinstance(value, (list, tuple, set)) else str(value) + for key, value in payload.items() + if value is not None + } + ).encode("utf-8") + + status_code, content_type, body = _http_request( + url=submit_url, + method="POST", + data=encoded, + timeout_seconds=timeout_seconds, + ) + request_id = _extract_request_id(body) + return { + "request_id": request_id, + "status_code": status_code, + "content_type": content_type, + "response": body, + "submit_url": submit_url, + "query": { + "genome": genome, + "regions_genome": regions_genome, + "antigen_class": antigen_class, + "antigen": antigen, + "cell_type_class": cell_type_class, + "cell_type": cell_type, + "distance": distance, + "threshold": threshold, + "crossmap": conversion_metadata, + "params": dict(params or {}), + }, + } + + +def get_status( + request_id: str, + *, + status_url: str = DEFAULT_STATUS_URL, + params: Mapping[str, Any] | None = None, + timeout_seconds: float = 30.0, +) -> dict[str, Any]: + url = _request_url_with_request_id(status_url, request_id) + query_params: dict[str, Any] = {} + if params: + query_params.update(dict(params)) + if query_params: + url = _build_url(url, query_params) + status_code, content_type, body = _http_request( + url=url, + method="GET", + timeout_seconds=timeout_seconds, + ) + try: + parsed_body = json.loads(body) + except json.JSONDecodeError: + parsed_body = None + + raw_status = _extract_status_value(body, parsed_body) + status = _normalize_status(raw_status) + return { + "request_id": request_id, + "status": status, + "raw_status": raw_status, + "status_code": status_code, + "content_type": content_type, + "response": parsed_body if parsed_body is not None else body, + "status_url": url, + } + + +def poll_request( + request_id: str, + *, + status_url: str = DEFAULT_STATUS_URL, + poll_interval_seconds: float = 5.0, + timeout_seconds: float = 600.0, + params: Mapping[str, Any] | None = None, +) -> dict[str, Any]: + history: list[dict[str, Any]] = [] + deadline = time.monotonic() + timeout_seconds + while True: + snapshot = get_status( + request_id, + status_url=status_url, + params=params, + timeout_seconds=min(30.0, max(poll_interval_seconds, 1.0)), + ) + history.append( + { + "time_epoch_s": time.time(), + "status": snapshot["status"], + "raw_status": snapshot.get("raw_status"), + "status_code": snapshot.get("status_code"), + } + ) + if snapshot["status"] in _TERMINAL_STATUSES: + return { + "request_id": request_id, + "status": snapshot["status"], + "history": history, + "last_snapshot": snapshot, + } + if time.monotonic() >= deadline: + raise TimeoutError( + f"Timed out waiting for ChIP-Atlas request {request_id!r} after {timeout_seconds} seconds." + ) + time.sleep(max(poll_interval_seconds, 0.0)) + + +def fetch_result( + request_id: str, + *, + result_url: str = DEFAULT_RESULT_URL, + params: Mapping[str, Any] | None = None, + timeout_seconds: float = 120.0, + as_dataframe: bool = True, + sep: str = "\t", +) -> pd.DataFrame | str: + url = _request_url_with_request_id(result_url, request_id) + query_params: dict[str, Any] = {"info": "result", "format": "tsv"} + if params: + query_params.update(dict(params)) + url = _build_url(url, query_params) + _, _, body = _http_request( + url=url, + method="GET", + timeout_seconds=timeout_seconds, + ) + if not as_dataframe: + return body + return pd.read_csv(io.StringIO(body), sep=sep) + + +def run_enrichment( + *, + regions: pd.DataFrame | str | Path | Iterable[str], + genome: str = "hg38", + regions_genome: str | None = None, + antigen_class: str | None = "TFs and others", + antigen: str | None = None, + cell_type_class: str | None = "No description", + cell_type: str | None = None, + distance: int | None = None, + threshold: str | None = "100", + crossmap_chain_file: str | Path | None = None, + crossmap_chain_url: str | None = None, + crossmap_chain_cache_dir: str | Path | None = None, + crossmap_executable: str | None = "CrossMap.py", + params: Mapping[str, Any] | None = None, + wait: bool = True, + fetch_results: bool = True, + raise_on_failure: bool = True, + submit_url: str = DEFAULT_SUBMIT_URL, + status_url: str = DEFAULT_STATUS_URL, + result_url: str = DEFAULT_RESULT_URL, + poll_interval_seconds: float = 5.0, + timeout_seconds: float = 600.0, +) -> ChipAtlasEnrichmentResult: + submission = submit_enrichment( + regions=regions, + genome=genome, + regions_genome=regions_genome, + antigen_class=antigen_class, + antigen=antigen, + cell_type_class=cell_type_class, + cell_type=cell_type, + distance=distance, + threshold=threshold, + crossmap_chain_file=crossmap_chain_file, + crossmap_chain_url=crossmap_chain_url, + crossmap_chain_cache_dir=crossmap_chain_cache_dir, + crossmap_executable=crossmap_executable, + params=params, + submit_url=submit_url, + ) + request_id = str(submission["request_id"]) + history: list[dict[str, Any]] = [] + final_status = "queued" + + if wait: + poll = poll_request( + request_id, + status_url=status_url, + poll_interval_seconds=poll_interval_seconds, + timeout_seconds=timeout_seconds, + ) + final_status = poll["status"] + history = poll["history"] + + if raise_on_failure and wait and final_status not in _SUCCESS_STATUSES: + raise RuntimeError( + f"ChIP-Atlas request {request_id!r} finished with status {final_status!r}." + ) + + result_table: pd.DataFrame | None = None + if fetch_results and wait and final_status in _SUCCESS_STATUSES: + fetched = fetch_result( + request_id, + result_url=result_url, + timeout_seconds=timeout_seconds, + as_dataframe=True, + ) + result_table = fetched if isinstance(fetched, pd.DataFrame) else None + + return ChipAtlasEnrichmentResult( + request_id=request_id, + status=final_status, + results=result_table, + query=submission["query"], + status_history=history, + submit_url=submit_url, + status_url=status_url, + result_url=result_url, + metadata={"submission": {k: v for k, v in submission.items() if k != "response"}}, + ) + + +def search_peak_datasets( + *, + antigen: str, + genome: str = "hg38", + cell_type: str | None = None, + antigen_class: str | None = None, + cell_type_class: str | None = None, + threshold: str = "05", + match_mode: str = "contains", + max_results: int | None = None, + experiment_list_url: str = DEFAULT_EXPERIMENT_LIST_URL, + cache_dir: str | Path = DEFAULT_METADATA_CACHE_DIR, + allow_cached_metadata: bool = True, + timeout_seconds: float = 120.0, +) -> pd.DataFrame: + """ + Search ChIP-Atlas experiment-level peak datasets by antigen and optional metadata filters. + + This reads the published ChIP-Atlas experiment metadata table and returns candidate datasets + with direct BED URLs for the requested peak threshold. + """ + + antigen_query = str(antigen).strip() + if not antigen_query: + raise ValueError("antigen is required.") + if match_mode not in {"contains", "exact"}: + raise ValueError("match_mode must be 'contains' or 'exact'.") + if max_results is not None and int(max_results) <= 0: + raise ValueError("max_results must be positive when provided.") + + threshold_key = _normalize_bed_threshold(threshold) + bed_column = _BED_THRESHOLD_COLUMN_MAP[threshold_key] + experiment_zip = _ensure_experiment_list_zip( + experiment_list_url=experiment_list_url, + cache_dir=cache_dir, + allow_cached=allow_cached_metadata, + timeout_seconds=timeout_seconds, + ) + + genome_query = _normalize_text_token(genome) + antigen_class_query = _normalize_text_token(antigen_class) + cell_type_class_query = _normalize_text_token(cell_type_class) + cell_type_query = _normalize_text_token(cell_type) + antigen_norm = _normalize_text_token(antigen_query) + + def _matches(value: str, query: str) -> bool: + value_norm = _normalize_text_token(value) + if not query: + return True + if match_mode == "exact": + return value_norm == query + return query in value_norm + + rows: list[dict[str, Any]] = [] + for raw in _iter_experiment_rows(experiment_zip): + row_genome = _normalize_text_token(raw.get("Genome assembly", "")) + if genome_query and row_genome != genome_query: + continue + if not _matches(raw.get("Antigen", ""), antigen_norm): + continue + if antigen_class_query and not _matches(raw.get("Antigen class", ""), antigen_class_query): + continue + if cell_type_class_query and not _matches(raw.get("Cell type class", ""), cell_type_class_query): + continue + if cell_type_query and not _matches(raw.get("Cell type", ""), cell_type_query): + continue + + bed_url = str(raw.get(bed_column, "")).strip() + if not bed_url: + continue + rows.append( + { + "dataset_id": str(raw.get("Experimental ID", "")).strip(), + "genome_assembly": str(raw.get("Genome assembly", "")).strip(), + "antigen_class": str(raw.get("Antigen class", "")).strip(), + "antigen": str(raw.get("Antigen", "")).strip(), + "cell_type_class": str(raw.get("Cell type class", "")).strip(), + "cell_type": str(raw.get("Cell type", "")).strip(), + "cell_type_description": str(raw.get("Cell type description", "")).strip(), + "processing_logs": str(raw.get("Processing logs", "")).strip(), + "title": str(raw.get("Title", "")).strip(), + "metadata": str(raw.get("Meta data", "")).strip(), + "bigwig_url": str(raw.get("BigWig", "")).strip(), + "bed_url": bed_url, + "bigbed_url": str( + raw.get( + bed_column.replace("Peak-call (BED)", "Peak-call (BigBed)"), + "", + ) + ).strip(), + "threshold_key": threshold_key, + "threshold_column": bed_column, + } + ) + if max_results is not None and len(rows) >= int(max_results): + break + + return pd.DataFrame(rows) + + +def download_peak_datasets( + *, + datasets: pd.DataFrame, + dataset_ids: Iterable[str] | None = None, + output_dir: str | Path = "cache/chip_atlas/peak_sets", + include_complete_sorted: bool = True, + include_top_n: int | None = 3000, + include_bottom_n: int | None = 3000, + stratify: str | int | None = None, + allow_cached: bool = True, + timeout_seconds: float = 180.0, + crossmap_target_genome: str | None = None, + crossmap_chain_file: str | Path | None = None, + crossmap_chain_url: str | None = None, + crossmap_chain_cache_dir: str | Path | None = None, + crossmap_executable: str | None = "CrossMap.py", +) -> pd.DataFrame: + """ + Download selected ChIP-Atlas BED datasets and optionally generate sorted/stratified subsets. + + Outputs are written as BED files under ``output_dir//`` and returned in a manifest. + """ + + if not isinstance(datasets, pd.DataFrame): + raise TypeError("datasets must be a pandas DataFrame.") + required = {"dataset_id", "bed_url", "genome_assembly"} + missing = required - set(datasets.columns) + if missing: + raise ValueError( + "datasets is missing required columns: " + f"{', '.join(sorted(missing))}" + ) + if include_top_n is not None and int(include_top_n) < 0: + raise ValueError("include_top_n must be non-negative.") + if include_bottom_n is not None and int(include_bottom_n) < 0: + raise ValueError("include_bottom_n must be non-negative.") + + stratify_bins = _resolve_stratification_bins(stratify) + selected = datasets.copy() + if dataset_ids is not None: + wanted = {str(dataset_id).strip() for dataset_id in dataset_ids if str(dataset_id).strip()} + selected = selected.loc[selected["dataset_id"].astype(str).isin(wanted)].copy() + if selected.empty: + return pd.DataFrame( + columns=[ + "dataset_id", + "variant", + "path", + "n_rows", + "source_genome", + "target_genome", + "crossmapped", + "bed_url", + ] + ) + + output_root = Path(output_dir).expanduser().resolve() + output_root.mkdir(parents=True, exist_ok=True) + manifest_rows: list[dict[str, Any]] = [] + + def _write_variant(path: Path, frame: pd.DataFrame) -> Path: + path.parent.mkdir(parents=True, exist_ok=True) + frame.to_csv(path, sep="\t", index=False, header=False) + return path + + for row in selected.itertuples(index=False): + dataset_id = str(getattr(row, "dataset_id")) + bed_url = str(getattr(row, "bed_url")) + source_genome = str(getattr(row, "genome_assembly")) + dataset_dir = output_root / dataset_id + raw_path = dataset_dir / "raw.bed" + + if not (allow_cached and raw_path.exists() and raw_path.stat().st_size > 0): + payload = _download_bytes(url=bed_url, timeout_seconds=timeout_seconds) + raw_path.parent.mkdir(parents=True, exist_ok=True) + tmp_path = raw_path.with_suffix(".bed.tmp") + tmp_path.write_bytes(payload) + tmp_path.replace(raw_path) + + bed_table = pd.read_csv(raw_path, sep="\t", header=None, comment="#") + if bed_table.empty: + continue + sorted_table = _sorted_bed_by_score(bed_table) + variants: list[tuple[str, pd.DataFrame]] = [] + if include_complete_sorted: + variants.append(("full_sorted", sorted_table)) + if include_top_n is not None and int(include_top_n) > 0: + variants.append((f"top_{int(include_top_n)}", sorted_table.head(int(include_top_n)).copy())) + if include_bottom_n is not None and int(include_bottom_n) > 0: + variants.append((f"bottom_{int(include_bottom_n)}", sorted_table.tail(int(include_bottom_n)).copy())) + if stratify_bins is not None and len(sorted_table) > 0: + chunks = np.array_split(np.arange(len(sorted_table)), stratify_bins) + for i, idx in enumerate(chunks, start=1): + if len(idx) == 0: + continue + variants.append( + ( + f"quantile_{i}_of_{stratify_bins}", + sorted_table.iloc[idx].copy(), + ) + ) + + target_genome = source_genome + if crossmap_target_genome is not None: + target_genome = str(crossmap_target_genome) + + for variant_name, variant_table in variants: + variant_path = dataset_dir / f"{variant_name}.bed" + _write_variant(variant_path, variant_table) + manifest_rows.append( + { + "dataset_id": dataset_id, + "variant": variant_name, + "path": str(variant_path), + "n_rows": int(len(variant_table)), + "source_genome": source_genome, + "target_genome": source_genome, + "crossmapped": False, + "bed_url": bed_url, + } + ) + if crossmap_target_genome is None: + continue + if _normalize_genome_name(source_genome) == _normalize_genome_name(target_genome): + continue + bed6 = _coerce_bed6(variant_table) + if bed6.empty: + continue + mapped = convert_regions_with_crossmap( + regions=bed6, + source_genome=source_genome, + target_genome=target_genome, + chain_file=crossmap_chain_file, + chain_url=crossmap_chain_url, + chain_cache_dir=crossmap_chain_cache_dir, + crossmap_executable=crossmap_executable, + ) + mapped_path = dataset_dir / f"{variant_name}.{target_genome}.bed" + mapped.to_csv(mapped_path, sep="\t", index=False, header=False) + manifest_rows.append( + { + "dataset_id": dataset_id, + "variant": f"{variant_name}_crossmapped", + "path": str(mapped_path), + "n_rows": int(len(mapped)), + "source_genome": source_genome, + "target_genome": target_genome, + "crossmapped": True, + "bed_url": bed_url, + } + ) + + return pd.DataFrame(manifest_rows) + + +__all__ = [ + "DEFAULT_EXPERIMENT_LIST_URL", + "DEFAULT_CHAIN_CACHE_DIR", + "DEFAULT_METADATA_CACHE_DIR", + "DEFAULT_RESULT_URL", + "DEFAULT_STATUS_URL", + "DEFAULT_SUBMIT_URL", + "cache_chain_files", + "convert_regions_with_crossmap", + "download_peak_datasets", + "fetch_result", + "get_status", + "poll_request", + "region_ids_to_bed_dataframe", + "run_enrichment", + "search_peak_datasets", + "submit_enrichment", +] diff --git a/dimelo/cluster.py b/dimelo/cluster.py index e3fe01f..2246031 100644 --- a/dimelo/cluster.py +++ b/dimelo/cluster.py @@ -3,11 +3,13 @@ from collections import Counter, defaultdict from dataclasses import dataclass from functools import partial +import math from pathlib import Path from typing import Any, Sequence import numpy as np import pandas as pd +from tqdm.auto import tqdm from . import load_processed, utils @@ -55,8 +57,8 @@ @dataclass class ReadWindowExtractionConfig: - # Controls how windows are cut from per-read vectors - window_size: int = 2000 + # Legacy-style half-window around region center (full span = 2 * window_size) + window_size: int | None = None orientation_aware: bool = True filter_multi_region_reads: bool = False @@ -159,7 +161,7 @@ def region_feature_matrix_from_pileup( feature_vectors = [] expected_length: int | None = None - for vector in per_region_vectors: + for vector in tqdm(per_region_vectors, desc="Processing regions", disable=quiet): # Backward-compatible path if upstream loaders still return (modified, valid). if isinstance(vector, tuple) and len(vector) == 2: modified = np.asarray(vector[0], dtype=np.float32) @@ -416,10 +418,271 @@ def _identify_multi_region_reads( return {name for name, keys in regions_by_name.items() if len(keys) > 1} +def _infer_window_span_from_records( + records: Sequence[tuple], + idx: dict[str, int], +) -> int: + if "region_start" not in idx or "region_end" not in idx: + raise ValueError( + "Could not infer window span from records. Pass window_size explicitly." + ) + lengths = [] + for rec in records: + try: + start = int(rec[idx["region_start"]]) + end = int(rec[idx["region_end"]]) + except Exception: + continue + length = end - start + if length > 0: + lengths.append(length) + if not lengths: + raise ValueError( + "Could not infer a default window span from region metadata. " + "Pass window_size explicitly." + ) + return int(min(lengths)) + + +def _infer_window_span_from_metadata( + metadata: Sequence[dict[str, Any]] | None, +) -> int | None: + if metadata is None: + return None + lengths = [] + for row in metadata: + try: + start = int(row.get("region_start")) + end = int(row.get("region_end")) + except Exception: + continue + width = end - start + if width > 0: + lengths.append(width) + if not lengths: + return None + return int(min(lengths)) + + +def _resolve_window_size(window_size: int | None = None) -> int | None: + if window_size is None: + return None + resolved = int(window_size) + if resolved <= 0: + raise ValueError("window_size must be a positive integer when provided.") + return resolved + + +def _window_span_from_size(window_size: int) -> int: + return int(window_size) * 2 + + +def _centered_x_axis(length: int, span_bp: int | None) -> np.ndarray: + if length <= 0: + return np.array([], dtype=float) + if length == 1: + return np.array([0.0], dtype=float) + span = float(span_bp if span_bp is not None else length) + step = span / float(length) + return (np.arange(length, dtype=float) * step) - (span / 2.0) + + +def _smooth_profile_vector( + values: np.ndarray, + *, + smoothing: str | None = None, + smooth_win: int = 21, + smooth_sigma: float = 6.0, +) -> np.ndarray: + arr = np.asarray(values, dtype=float) + if smoothing is None or arr.size < 3: + return arr + mode = smoothing.lower() + if mode not in {"gaussian", "boxcar"}: + raise ValueError("smoothing must be None, 'gaussian', or 'boxcar'.") + + win = int(max(3, smooth_win)) + if win % 2 == 0: + win += 1 + if win >= arr.size: + win = arr.size - 1 if arr.size % 2 == 0 else arr.size + if win < 3: + return arr + + if mode == "gaussian": + radius = win // 2 + x = np.arange(-radius, radius + 1, dtype=float) + sigma = max(float(smooth_sigma), 1e-6) + kernel = np.exp(-0.5 * (x / sigma) ** 2) + else: + kernel = np.ones(win, dtype=float) + kernel = kernel / kernel.sum() + + pad = len(kernel) // 2 + padded = np.pad(arr, (pad, pad), mode="edge") + return np.convolve(padded, kernel, mode="valid") + + +def _infer_shared_window_size( + regions: Sequence[str | Path | Sequence[str | Path]], +) -> int: + """ + Infer one half-window size that is safe across multiple region selectors. + Returns half of the shortest positive region width across all inputs. + """ + widths: list[int] = [] + for region_input in regions: + regions_dict = utils.regions_dict_from_input(region_input, window_size=None) + for region_list in regions_dict.values(): + for start, end, _ in region_list: + width = int(end) - int(start) + if width > 0: + widths.append(width) + if not widths: + raise ValueError("Could not infer shared window size from provided regions.") + shortest_width = int(min(widths)) + if shortest_width < 2: + raise ValueError( + "Could not infer a usable shared window_size because the shortest region " + f"width is {shortest_width} bp." + ) + return shortest_width // 2 + + +def _center_crop_matrix(matrix: np.ndarray, target_width: int) -> np.ndarray: + arr = np.asarray(matrix) + if arr.ndim != 2: + raise ValueError("Expected a 2D matrix for center-cropping.") + width = arr.shape[1] + if width == target_width: + return arr + if width < target_width: + raise ValueError( + f"Cannot center-crop from width {width} to larger target_width {target_width}." + ) + start = (width - target_width) // 2 + end = start + target_width + return arr[:, start:end] + + +def merge_read_window_results( + results: Sequence[ReadWindowExtractionResult], + *, + source_labels: Sequence[str] | None = None, + align: str = "error", +) -> ReadWindowExtractionResult: + """ + Merge multiple ReadWindowExtractionResult objects safely. + + Args: + results: extraction results to concatenate + source_labels: optional labels to append to metadata as ``source_label`` + align: one of: + - 'error': require identical window widths (strict) + - 'center_crop': center-crop all matrices to the smallest width before merging + + Returns: + A merged ReadWindowExtractionResult. + """ + if len(results) == 0: + raise ValueError("results must contain at least one ReadWindowExtractionResult.") + if source_labels is not None and len(source_labels) != len(results): + raise ValueError("source_labels length must match results length.") + if align not in {"error", "center_crop"}: + raise ValueError("align must be one of {'error', 'center_crop'}.") + + widths = [int(r.data_matrix.shape[1]) for r in results] + unique_widths = sorted(set(widths)) + target_width = min(widths) + if len(unique_widths) > 1 and align == "error": + raise ValueError( + "Read-window widths do not match across results: " + f"{unique_widths}. Use a shared window_size upstream " + "or call merge_read_window_results(..., align='center_crop')." + ) + + data_blocks: list[np.ndarray] = [] + val_blocks: list[np.ndarray] = [] + all_have_val = all(r.val_matrix is not None for r in results) + metadata_merged: list[dict[str, Any]] = [] + datasets_merged: list[str] = [] + + for i, res in enumerate(results): + data = np.asarray(res.data_matrix) + if align == "center_crop": + data = _center_crop_matrix(data, target_width) + data_blocks.append(data) + + if all_have_val and res.val_matrix is not None: + val = np.asarray(res.val_matrix) + if align == "center_crop": + val = _center_crop_matrix(val, target_width) + val_blocks.append(val) + + label = source_labels[i] if source_labels is not None else None + for row in res.metadata: + if label is None: + metadata_merged.append(dict(row)) + else: + metadata_merged.append(dict(row, source_label=label)) + + if not datasets_merged and res.datasets: + datasets_merged = list(res.datasets) + + merged_data = np.vstack(data_blocks) + merged_val = np.vstack(val_blocks) if all_have_val and len(val_blocks) > 0 else None + + return ReadWindowExtractionResult( + data_matrix=merged_data, + val_matrix=merged_val, + metadata=metadata_merged, + datasets=datasets_merged, + regions_dict=None, + ) + + +def _prepare_group_labels(labels: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]: + labels_arr = np.asarray(labels) + codes, uniques = pd.factorize(labels_arr, sort=True) + # Handle NaN/None labels from factorize (-1 code): convert to explicit category name + if np.any(codes < 0): + labels_arr = labels_arr.astype(object) + labels_arr[codes < 0] = "NA" + codes, uniques = pd.factorize(labels_arr, sort=True) + unique_codes = np.unique(codes) + return labels_arr, codes, unique_codes + + +def _resolve_motif_slices( + width: int, + *, + motif_count: int | None = None, + motif_labels: Sequence[str] | None = None, + window_size: int | None = None, + view_window_size: int | None = None, +) -> tuple[int, int]: + window_span = _window_span_from_size(window_size) if window_size else None + view_span = _window_span_from_size(view_window_size) if view_window_size else None + inferred_count: int | None = None + if motif_count is not None: + inferred_count = int(max(1, motif_count)) + elif motif_labels is not None and len(motif_labels) > 0: + inferred_count = int(len(motif_labels)) + elif window_span and window_span > 0 and width % window_span == 0: + inferred_count = width // window_span + elif view_span and view_span > 0 and width % view_span == 0: + inferred_count = width // view_span + n_motifs = inferred_count or 1 + slice_width = width // n_motifs if n_motifs > 0 else width + if slice_width <= 0: + return 1, width + return n_motifs, slice_width + + def _extract_window_from_record( record: tuple, idx: dict[str, int], - window_size: int, + window_span: int, orientation_aware: bool, ) -> tuple[np.ndarray, np.ndarray | None] | None: required = ["read_start", "read_end", "region_start", "region_end", "mod_vector"] @@ -440,16 +703,16 @@ def _extract_window_from_record( return None center = (region_start + region_end) // 2 - half = window_size // 2 + half = window_span // 2 # Grab a symmetric window around the region center window_start = center - half - window_end = window_start + window_size + window_end = window_start + window_span # Skip reads that do not fully span the requested window if window_start < read_start or window_end > read_end: return None slice_start = window_start - read_start - slice_end = slice_start + window_size + slice_end = slice_start + window_span if slice_start < 0 or slice_end > len(mod_vector): return None @@ -481,7 +744,7 @@ def build_multimotif_read_windows( motifs: Sequence[str], regions: str | Path | list[str | Path] | None = None, *, - window_size: int, + window_size: int | None = None, orientation_aware: bool = True, single_strand: bool = False, subset_parameters: dict | None = None, @@ -491,14 +754,17 @@ def build_multimotif_read_windows( """ Group per-motif rows by read and return a combined window per read, concatenating motifs. - Each requested motif contributes a window of length `window_size`; missing motifs are filled with zeros. + Each requested motif contributes a centered window of length `2 * window_size` + (or inferred full span when window_size is None); missing motifs are filled with zeros. Windows are concatenated in the order provided by `motifs`. Args: hdf5_file: path to extract .h5 file motifs: motifs to include (order matters for concatenation) regions: optional region filter - window_size: fixed window length around region center to extract per motif + window_size: half-window in bp around region center to extract per motif. + Full extracted span is ``2 * window_size``. + If None, full span is inferred from the shortest selected region length. orientation_aware: flip windows if read strand != region strand single_strand: passed to loader subset_parameters: passed to loader for subsetting @@ -506,7 +772,8 @@ def build_multimotif_read_windows( require_all_motifs: if True, drop reads that are missing any requested motif Returns: - ReadWindowExtractionResult with data_matrix of shape (n_reads, len(motifs) * window_size) + ReadWindowExtractionResult with data_matrix shape + ``(n_reads, len(motifs) * full_window_span_bp)``. and val_matrix if available, metadata per combined read, and datasets info. """ @@ -540,6 +807,18 @@ def build_multimotif_read_windows( metadata: list[dict[str, Any]] = [] has_val = "val_vector" in idx + requested_window_size = _resolve_window_size(window_size=window_size) + requested_window_span = ( + _window_span_from_size(requested_window_size) + if requested_window_size is not None + else None + ) + effective_window_span = ( + requested_window_span + if requested_window_span is not None + else _infer_window_span_from_records(read_tuples, idx) + ) + for key, motif_map in groups.items(): motif_windows = [] motif_val_windows = [] @@ -547,13 +826,13 @@ def build_multimotif_read_windows( for motif in motifs: if motif in motif_map: extracted = _extract_window_from_record( - motif_map[motif], idx, window_size, orientation_aware + motif_map[motif], idx, effective_window_span, orientation_aware ) if extracted is None: # If window cannot be extracted, treat as missing - motif_windows.append(np.zeros(window_size, dtype=float)) + motif_windows.append(np.zeros(effective_window_span, dtype=float)) motif_val_windows.append( - np.zeros(window_size, dtype=float) if has_val else None + np.zeros(effective_window_span, dtype=float) if has_val else None ) else: mw, vw = extracted @@ -563,8 +842,10 @@ def build_multimotif_read_windows( ) motifs_present.append(motif) else: - motif_windows.append(np.zeros(window_size, dtype=float)) - motif_val_windows.append(np.zeros(window_size, dtype=float) if has_val else None) + motif_windows.append(np.zeros(effective_window_span, dtype=float)) + motif_val_windows.append( + np.zeros(effective_window_span, dtype=float) if has_val else None + ) if require_all_motifs and len(motifs_present) < len(motifs): continue @@ -573,7 +854,7 @@ def build_multimotif_read_windows( if has_val: combined_vals.append( np.concatenate( - [vw if vw is not None else np.zeros(window_size, dtype=float) for vw in motif_val_windows], + [vw if vw is not None else np.zeros(effective_window_span, dtype=float) for vw in motif_val_windows], axis=0, ) ) @@ -623,27 +904,40 @@ def extract_read_windows( hdf5_file: path to the extract .h5 file motifs: motifs to pull from the file regions: optional region specifier - config: controls window size and orientation handling - window_size: overrides config.window_size when provided + config: controls windowing and orientation handling + window_size: half-window override in bp (full span = 2 * window_size); + when omitted, falls back to config.window_size. + When omitted in both places, full span is inferred from the shortest selected region length. Returns: ReadWindowExtractionResult containing raw mod/val matrices and metadata """ cfg = config or ReadWindowExtractionConfig() - effective_window = window_size or cfg.window_size + requested_window_size = _resolve_window_size( + window_size=window_size if window_size is not None else cfg.window_size, + ) + requested_window_span = ( + _window_span_from_size(requested_window_size) + if requested_window_size is not None + else None + ) + effective_window_span = requested_window_span # Load all requested reads/vectors from extract output read_tuples, dataset_names, regions_dict = load_processed.read_vectors_from_hdf5( file=hdf5_file, motifs=list(motifs), regions=regions, - window_size=window_size, + window_size=None, single_strand=single_strand, subset_parameters=subset_parameters, span_full_window=span_full_window, ) idx = _build_dataset_index(dataset_names) + if effective_window_span is None: + effective_window_span = _infer_window_span_from_records(read_tuples, idx) + effective_window_span = int(effective_window_span) drop_names: set[str] = set() if cfg.filter_multi_region_reads: @@ -660,7 +954,7 @@ def extract_read_windows( continue extracted = _extract_window_from_record( - rec, idx, effective_window, cfg.orientation_aware + rec, idx, effective_window_span, cfg.orientation_aware ) if extracted is None: continue @@ -1165,27 +1459,42 @@ def plot_cluster_profiles( *, val_matrix: np.ndarray | None = None, include_clusters: Sequence[int] | None = None, - view_bp: int | None = None, - window_bp: int | None = None, + view_window_size: int | None = None, + window_size: int | None = None, motif_index: int = 0, motif_count: int | None = None, + metadata: Sequence[dict[str, Any]] | None = None, + motif_labels: Sequence[str] | None = None, + motif_colors: Sequence[str] | None = None, + plot_all_motifs: bool = False, + motif_profile_mode: str = "single_axis", + color_points_by: str = "cluster", + show_valid_profile: bool = False, + signal_label: str = "Modification signal", + valid_label: str = "Valid-site fraction", + smoothing: str | None = None, + smooth_win: int = 21, + smooth_sigma: float = 6.0, + show_unsmoothed_overlay: bool = False, cmap_name: str = "viridis", invert_y: bool = True, point_size: float = 1.0, point_alpha: float = 0.01, ): """ - Scatter plot of per-read modification calls with per-cluster average profiles. - Useful for quick QC after clustering. - Set motif_count when data_matrix contains concatenated motifs to select motif_index safely. + Scatter plot of per-read modification calls with side profile summaries per label. + Supports concatenated multi-motif windows and optional overlays per motif. """ import matplotlib.pyplot as plt from matplotlib import gridspec + from matplotlib.lines import Line2D from matplotlib.colors import Normalize X_full = np.asarray(data_matrix) labs = np.asarray(labels) + if X_full.shape[0] != labs.shape[0]: + raise ValueError("data_matrix and labels must have the same number of rows.") if include_clusters is not None: mask = np.isin(labs, list(include_clusters)) if not np.any(mask): @@ -1194,80 +1503,242 @@ def plot_cluster_profiles( labs = labs[mask] if val_matrix is not None: val_matrix = np.asarray(val_matrix)[mask] + if metadata is not None: + metadata = [row for row, keep in zip(metadata, mask) if keep] - # If concatenated motifs are present, select the requested motif slice - if motif_index is not None and X_full.ndim == 2: - window_len = X_full.shape[1] - # Prefer explicit motif_count; otherwise infer from window_bp/view_bp if they evenly tile the window - inferred_count = None - if motif_count is not None: - inferred_count = int(max(1, motif_count)) - elif window_bp and window_bp > 0 and window_len % window_bp == 0: - inferred_count = window_len // window_bp - elif view_bp and view_bp > 0 and window_len % view_bp == 0: - inferred_count = window_len // view_bp - n_motifs = inferred_count or 1 - slice_width = window_len // n_motifs if n_motifs > 0 else window_len - if slice_width == 0: - slice_width = window_len - n_motifs = 1 - start = motif_index * slice_width - end = min(window_len, start + slice_width) - if start >= window_len: - raise ValueError( - f"motif_index {motif_index} exceeds concatenated width {window_len}; " - "pass motif_count/window_bp to disambiguate." + V_full = np.asarray(val_matrix) if val_matrix is not None else None + if V_full is not None and V_full.shape != X_full.shape: + raise ValueError("val_matrix must match data_matrix shape.") + + if color_points_by not in {"cluster", "motif"}: + raise ValueError("color_points_by must be 'cluster' or 'motif'.") + if motif_profile_mode not in {"single_axis", "separate_axes"}: + raise ValueError("motif_profile_mode must be 'single_axis' or 'separate_axes'.") + + window_len = X_full.shape[1] + n_motifs, slice_width = _resolve_motif_slices( + window_len, + motif_count=motif_count, + motif_labels=motif_labels, + window_size=window_size, + view_window_size=view_window_size, + ) + if motif_index < 0 or motif_index >= n_motifs: + raise ValueError(f"motif_index {motif_index} out of range for {n_motifs} motif slices.") + motif_ids = list(range(n_motifs)) if plot_all_motifs and n_motifs > 1 else [motif_index] + + if motif_labels is None: + motif_labels = [f"motif_{i}" for i in range(n_motifs)] + else: + motif_labels = list(motif_labels) + if len(motif_labels) < n_motifs: + motif_labels.extend( + [f"motif_{i}" for i in range(len(motif_labels), n_motifs)] ) - X = X_full[:, start:end] - V = val_matrix[:, start:end] if val_matrix is not None else None + if motif_colors is None: + motif_cmap = plt.get_cmap("tab10") + motif_colors = [motif_cmap(i % 10) for i in range(n_motifs)] else: - X = X_full - V = val_matrix - - n_reads, window = X.shape - window_bp = window_bp or window - half = window_bp // 2 - if view_bp is not None: - half = view_bp // 2 - x_axis = np.arange(-half, -half + X.shape[1]) - - mod_fraction = X.mean(axis=1) - order = np.lexsort((-mod_fraction, labs)) - X = X[order] - labs = labs[order] - V = V[order] if V is not None else None - - unique_clusters = np.unique(labs) - cmap = plt.get_cmap(cmap_name) - norm = Normalize(vmin=int(unique_clusters.min()), vmax=int(unique_clusters.max())) + motif_colors = list(motif_colors) + if len(motif_colors) < n_motifs: + motif_cmap = plt.get_cmap("tab10") + motif_colors.extend( + motif_cmap(i % 10) for i in range(len(motif_colors), n_motifs) + ) - rows, cols = np.nonzero(X) - colors = cmap(norm(labs[rows])) + selected_start = motif_index * slice_width + selected_end = min(window_len, selected_start + slice_width) + primary_matrix = X_full[:, selected_start:selected_end] + inferred_window_span = ( + _window_span_from_size(window_size) + if window_size is not None + else primary_matrix.shape[1] + ) + view_span = _window_span_from_size(view_window_size) if view_window_size is not None else None + x_axis = _centered_x_axis(primary_matrix.shape[1], view_span or inferred_window_span) + + mod_fraction = primary_matrix.mean(axis=1) + labs_arr, lab_codes, unique_codes = _prepare_group_labels(labs) + order = np.lexsort((-mod_fraction, lab_codes)) + X_full = X_full[order] + labs_arr = labs_arr[order] + lab_codes = lab_codes[order] + V_full = V_full[order] if V_full is not None else None + + unique_labels = np.array([np.unique(labs_arr[lab_codes == code])[0] for code in unique_codes]) + cmap = plt.get_cmap(cmap_name) + norm = Normalize(vmin=int(unique_codes.min()), vmax=int(unique_codes.max() or 1)) - fig = plt.figure(figsize=(12, max(4, len(unique_clusters)))) - gs = gridspec.GridSpec(nrows=len(unique_clusters), ncols=2, width_ratios=[3, 1]) + fig = plt.figure(figsize=(12, max(4, len(unique_codes)))) + gs = gridspec.GridSpec(nrows=len(unique_codes), ncols=2, width_ratios=[3, 1]) ax_left = fig.add_subplot(gs[:, 0]) - ax_left.scatter(x_axis[cols], rows, s=point_size, alpha=point_alpha, c=colors) + if color_points_by == "cluster": + rows, cols = np.nonzero(primary_matrix[order]) + colors = cmap(norm(lab_codes[rows])) + ax_left.scatter( + x_axis[cols], + rows, + s=point_size, + alpha=point_alpha, + c=colors, + rasterized=True, + ) + else: + for motif_id in motif_ids: + s = motif_id * slice_width + e = min(window_len, s + slice_width) + motif_matrix = X_full[:, s:e] + rows, cols = np.nonzero(motif_matrix) + ax_left.scatter( + x_axis[cols], + rows, + s=point_size, + alpha=point_alpha, + c=motif_colors[motif_id], + label=str(motif_labels[motif_id]), + rasterized=True, + ) ax_left.set_xlabel("Distance from region center (bp)") ax_left.set_ylabel("Sorted read index") if invert_y: ax_left.invert_yaxis() - change_points = np.flatnonzero(np.diff(labs)) + 1 + change_points = np.flatnonzero(np.diff(lab_codes)) + 1 for cp in change_points: ax_left.axhline(cp, color="0.2", linestyle="--", linewidth=0.3) - for i, cluster_id in enumerate(unique_clusters): + for i, code in enumerate(unique_codes): ax = fig.add_subplot(gs[i, 1]) - mask = labs == cluster_id - mean_profile = X[mask].mean(axis=0) - ax.plot(x_axis, mean_profile, color=cmap(norm(cluster_id))) - if V is not None: - mean_val = V[mask].mean(axis=0) - ax.plot(x_axis, mean_val, color="0.35", linestyle="--", linewidth=1.0) - ax.set_title(f"Cluster {cluster_id} (n={mask.sum()})") + row_mask = lab_codes == code + panel_max = 0.0 + if motif_profile_mode == "separate_axes" and len(motif_ids) > 1: + axes_for_motifs = [ax] + motif_maxima = [0.0 for _ in motif_ids] + for motif_pos in range(1, len(motif_ids)): + twin = ax.twinx() + twin.spines["right"].set_position(("outward", 35 * motif_pos)) + axes_for_motifs.append(twin) + for motif_pos, motif_id in enumerate(motif_ids): + s = motif_id * slice_width + e = min(window_len, s + slice_width) + motif_matrix = X_full[:, s:e] + mean_profile_raw = motif_matrix[row_mask].mean(axis=0) + mean_profile = _smooth_profile_vector( + mean_profile_raw, + smoothing=smoothing, + smooth_win=smooth_win, + smooth_sigma=smooth_sigma, + ) + motif_maxima[motif_pos] = max( + motif_maxima[motif_pos], float(np.nanmax(mean_profile_raw)) + ) + panel_max = max(panel_max, motif_maxima[motif_pos]) + motif_ax = axes_for_motifs[motif_pos] + if show_unsmoothed_overlay and smoothing is not None: + motif_ax.plot( + x_axis, + mean_profile_raw, + color=motif_colors[motif_id], + linewidth=1.0, + alpha=0.25, + ) + motif_ax.plot( + x_axis, + mean_profile, + color=motif_colors[motif_id], + linewidth=1.5, + ) + motif_ax.set_ylabel(str(motif_labels[motif_id]), color=motif_colors[motif_id]) + motif_ax.tick_params(axis="y", colors=motif_colors[motif_id], labelsize=8) + if show_valid_profile and V_full is not None: + mean_val_raw = V_full[row_mask, s:e].mean(axis=0) + mean_val = _smooth_profile_vector( + mean_val_raw, + smoothing=smoothing, + smooth_win=smooth_win, + smooth_sigma=smooth_sigma, + ) + motif_ax.plot( + x_axis, + mean_val, + color=motif_colors[motif_id], + linestyle="--", + linewidth=1.0, + alpha=0.85, + ) + for motif_pos, motif_ax in enumerate(axes_for_motifs): + motif_ax.set_ylim(0, max(motif_maxima[motif_pos], 0.05) * 1.05) + else: + for motif_id in motif_ids: + s = motif_id * slice_width + e = min(window_len, s + slice_width) + motif_matrix = X_full[:, s:e] + mean_profile_raw = motif_matrix[row_mask].mean(axis=0) + mean_profile = _smooth_profile_vector( + mean_profile_raw, + smoothing=smoothing, + smooth_win=smooth_win, + smooth_sigma=smooth_sigma, + ) + panel_max = max(panel_max, float(np.nanmax(mean_profile_raw))) + if show_unsmoothed_overlay and smoothing is not None: + ax.plot( + x_axis, + mean_profile_raw, + color=motif_colors[motif_id] if len(motif_ids) > 1 else cmap(norm(code)), + linewidth=1.0, + alpha=0.25, + ) + ax.plot( + x_axis, + mean_profile, + color=motif_colors[motif_id] if len(motif_ids) > 1 else cmap(norm(code)), + linewidth=1.5, + ) + if show_valid_profile and V_full is not None: + mean_val_raw = V_full[row_mask, s:e].mean(axis=0) + mean_val = _smooth_profile_vector( + mean_val_raw, + smoothing=smoothing, + smooth_win=smooth_win, + smooth_sigma=smooth_sigma, + ) + ax.plot( + x_axis, + mean_val, + color=motif_colors[motif_id] if len(motif_ids) > 1 else "0.35", + linestyle="--", + linewidth=1.0, + alpha=0.85, + ) + ax.set_title(f"{unique_labels[i]} (n={row_mask.sum()})") ax.set_xlim(x_axis[0], x_axis[-1]) - ax.set_ylim(0, min(1.0, max(0.05, mean_profile.max() + 0.05))) + y_max = max(panel_max, 0.05) + ax.set_ylim(0, y_max * 1.05) + + legend_handles: list[Line2D] = [] + if len(motif_ids) > 1 or color_points_by == "motif": + legend_handles.extend( + [ + Line2D([0], [0], color=motif_colors[m], linewidth=2, label=str(motif_labels[m])) + for m in motif_ids + ] + ) + if show_valid_profile and V_full is not None: + legend_handles.extend( + [ + Line2D([0], [0], color="black", linewidth=2, linestyle="-", label=signal_label), + Line2D([0], [0], color="black", linewidth=1, linestyle="--", label=valid_label), + ] + ) + if legend_handles: + fig.legend( + handles=legend_handles, + loc="upper center", + ncol=min(4, len(legend_handles)), + frameon=False, + bbox_to_anchor=(0.5, 1.01), + ) fig.tight_layout() return fig @@ -1314,6 +1785,7 @@ def classify_read_features_binary( y_raw = np.asarray(sample_labels) if X.shape[0] != y_raw.shape[0]: raise ValueError("feature_matrix and sample_labels must have matching length.") + row_index = np.arange(X.shape[0], dtype=int) le = LabelEncoder() y = le.fit_transform(y_raw) @@ -1321,8 +1793,16 @@ def classify_read_features_binary( if len(classes) != 2: raise ValueError("Binary classification requires exactly two sample labels.") - X_train, X_test, y_train, y_test, lbl_train, lbl_test = train_test_split( - X, y, y_raw, test_size=test_size, random_state=random_state, stratify=y + X_train, X_test, y_train, y_test, lbl_train, lbl_test, idx_train, idx_test = ( + train_test_split( + X, + y, + y_raw, + row_index, + test_size=test_size, + random_state=random_state, + stratify=y, + ) ) clf_name = classifier.lower() @@ -1415,6 +1895,7 @@ def classify_read_features_binary( "proba": proba, "split": "test", "sample_label": lbl_test, + "row_index": idx_test, } ) @@ -1426,6 +1907,7 @@ def classify_read_features_binary( "proba": proba_train, "split": "train", "sample_label": lbl_train, + "row_index": idx_train, } ) @@ -1470,99 +1952,243 @@ def plot_confusion_matrices(predictions: pd.DataFrame, *, cmap: str = "Blues"): return fig +def _resolve_prediction_row_selection( + matrix: np.ndarray, + preds: pd.DataFrame, + *, + owner: str, +) -> tuple[np.ndarray, np.ndarray | None]: + """ + Align a feature/signal matrix to a predictions split. + + Supports two calling conventions: + 1) matrix is the full dataset and ``preds.row_index`` maps split rows. + 2) matrix is already split-aligned and has the same row count as ``preds``. + """ + matrix_full = np.asarray(matrix) + if "row_index" not in preds.columns: + if len(preds) != matrix_full.shape[0]: + raise ValueError( + f"{owner}: predictions and matrix must have matching rows for the chosen split " + "or predictions must include a row_index column." + ) + return matrix_full, None + + row_idx = preds["row_index"].to_numpy(dtype=int) + if row_idx.size == 0: + return matrix_full[:0], row_idx + + in_bounds = (row_idx >= 0) & (row_idx < matrix_full.shape[0]) + if in_bounds.all(): + return matrix_full[row_idx], row_idx + + # If matrix is already split-aligned, keep it as-is and ignore out-of-range + # row indices (which refer to original global row IDs). + if len(preds) == matrix_full.shape[0]: + return matrix_full, None + + raise ValueError( + f"{owner}: row_index contains out-of-bounds values for the provided matrix " + f"(max row_index={int(row_idx.max())}, matrix_rows={matrix_full.shape[0]})." + ) + + def plot_classification_profiles( data_matrix: np.ndarray, predictions: pd.DataFrame, *, val_matrix: np.ndarray | None = None, split: str = "test", + group_by: str = "pred_label", + positive_label: str | None = None, motif_index: int = 0, - view_bp: int | None = None, + motif_count: int | None = None, + metadata: Sequence[dict[str, Any]] | None = None, + motif_labels: Sequence[str] | None = None, + motif_colors: Sequence[str] | None = None, + plot_all_motifs: bool = False, + motif_profile_mode: str = "single_axis", + color_points_by: str = "cluster", + view_window_size: int | None = None, + window_size: int | None = None, + show_valid_profile: bool = False, + smoothing: str | None = None, + smooth_win: int = 21, + smooth_sigma: float = 6.0, + show_unsmoothed_overlay: bool = False, cmap_name: str = "viridis", invert_y: bool = True, point_size: float = 1.0, point_alpha: float = 0.01, ): """ - Visualize per-read modification calls colored by predicted label, with mean profiles per predicted class. + Visualize per-read modification calls colored by prediction-derived groups. + For binary models, ``group_by='confusion'`` renders TP/TN/FP/FN groups. Args: data_matrix: per-read windows (n_reads, window_len) - predictions: DataFrame from classify_read_features_binary (must align row-wise with data_matrix) + predictions: DataFrame from classify_read_features_binary val_matrix: optional valid-site matrix to overlay split: which split to visualize ('train' or 'test') """ - import matplotlib.pyplot as plt - from matplotlib import gridspec - from matplotlib.colors import Normalize - preds = predictions[predictions["split"] == split].reset_index(drop=True) - if len(preds) != data_matrix.shape[0]: - raise ValueError("predictions and data_matrix must have matching rows for the chosen split.") - - labels = preds["pred_label"].to_numpy() X_full = np.asarray(data_matrix) - V = np.asarray(val_matrix) if val_matrix is not None else None - - # Slice motif window if concatenated - window_len = X_full.shape[1] - motif_width = window_len // max(1, (window_len // (view_bp or window_len))) if window_len else window_len - if motif_index is not None and X_full.ndim == 2: - n_motifs = max(1, window_len // (view_bp or window_len)) - slice_width = window_len // n_motifs - start = motif_index * slice_width - end = start + slice_width - X = X_full[:, start:end] - V = V[:, start:end] if V is not None else None + X, row_idx = _resolve_prediction_row_selection( + X_full, + preds, + owner="plot_classification_profiles", + ) + V_full = np.asarray(val_matrix) if val_matrix is not None else None + M_full = list(metadata) if metadata is not None else None + + if V_full is not None: + row_idx_max = int(row_idx.max()) if row_idx is not None and row_idx.size > 0 else -1 + if row_idx is not None and row_idx.size > 0 and row_idx_max < V_full.shape[0]: + V = V_full[row_idx] + elif V_full.shape[0] == len(preds): + V = V_full + else: + raise ValueError( + "plot_classification_profiles: val_matrix could not be aligned to predictions. " + "Pass either full val_matrix (with row_index) or split-aligned val_matrix." + ) else: - X = X_full - - n_reads, window = X.shape - half = window // 2 - if view_bp is not None: - half = view_bp // 2 - x_axis = np.arange(-half, -half + X.shape[1]) + V = None + + if M_full is not None: + row_idx_max = int(row_idx.max()) if row_idx is not None and row_idx.size > 0 else -1 + if row_idx is not None and row_idx.size > 0 and row_idx_max < len(M_full): + M = [M_full[i] for i in row_idx] + elif len(M_full) == len(preds): + M = M_full + else: + raise ValueError( + "plot_classification_profiles: metadata could not be aligned to predictions. " + "Pass either full metadata (with row_index) or split-aligned metadata." + ) + else: + M = None + + if group_by not in {"pred_label", "true_label", "confusion"}: + raise ValueError("group_by must be one of {'pred_label', 'true_label', 'confusion'}.") + + if group_by == "confusion": + class_values = sorted(pd.unique(preds["true_label"])) + if len(class_values) != 2: + raise ValueError("group_by='confusion' requires exactly two classes.") + positive = positive_label if positive_label is not None else class_values[-1] + true_vals = preds["true_label"].to_numpy() + pred_vals = preds["pred_label"].to_numpy() + confusion_labels = np.empty(len(preds), dtype=object) + confusion_labels[(true_vals != positive) & (pred_vals != positive)] = "TN" + confusion_labels[(true_vals != positive) & (pred_vals == positive)] = "FP" + confusion_labels[(true_vals == positive) & (pred_vals != positive)] = "FN" + confusion_labels[(true_vals == positive) & (pred_vals == positive)] = "TP" + labels = confusion_labels + else: + labels = preds[group_by].to_numpy() - mod_fraction = X.mean(axis=1) - order = np.lexsort((-mod_fraction, labels)) - X = X[order] - labels = labels[order] - V = V[order] if V is not None else None + return plot_cluster_profiles( + X, + labels, + val_matrix=V, + view_window_size=view_window_size, + window_size=window_size, + motif_index=motif_index, + motif_count=motif_count, + metadata=M, + motif_labels=motif_labels, + motif_colors=motif_colors, + plot_all_motifs=plot_all_motifs, + motif_profile_mode=motif_profile_mode, + color_points_by=color_points_by, + show_valid_profile=show_valid_profile, + smoothing=smoothing, + smooth_win=smooth_win, + smooth_sigma=smooth_sigma, + show_unsmoothed_overlay=show_unsmoothed_overlay, + cmap_name=cmap_name, + invert_y=invert_y, + point_size=point_size, + point_alpha=point_alpha, + ) - unique_labels = np.unique(labels) - cmap = plt.get_cmap(cmap_name) - norm = Normalize(vmin=0, vmax=max(len(unique_labels) - 1, 1)) - rows, cols = np.nonzero(X) - colors = cmap(norm(pd.factorize(labels)[0][rows])) +def plot_region_classification_profiles( + pileup_matrix: np.ndarray, + predictions: pd.DataFrame, + *, + split: str = "test", + group_by: str = "pred_label", + positive_label: str | None = None, + window_size: int | None = None, + motif_index: int | None = 0, + motif_count: int | None = None, + plot_all_motifs: bool = False, + motif_labels: Sequence[str] | None = None, + motif_colors: Sequence[str] | None = None, + motif_profile_mode: str = "single_axis", + color_points_by: str = "cluster", + point_size: float = 1.0, + point_alpha: float = 0.01, + smoothing: str | None = None, + smooth_win: int = 21, + smooth_sigma: float = 6.0, + show_unsmoothed_overlay: bool = False, + cmap_name: str = "viridis", +): + """ + Region-level counterpart to plot_classification_profiles. + Uses classifier predictions to group regions by predicted label, true label, + or confusion-class (TP/TN/FP/FN for binary tasks) and renders cluster-style profiles. + """ - fig = plt.figure(figsize=(12, max(4, len(unique_labels)))) - gs = gridspec.GridSpec(nrows=len(unique_labels), ncols=2, width_ratios=[3, 1]) - ax_left = fig.add_subplot(gs[:, 0]) - ax_left.scatter(x_axis[cols], rows, s=point_size, alpha=point_alpha, c=colors) - ax_left.set_xlabel("Distance from region center (bp)") - ax_left.set_ylabel("Sorted read index") - if invert_y: - ax_left.invert_yaxis() + preds = predictions[predictions["split"] == split].reset_index(drop=True) + X_full = np.asarray(pileup_matrix) + X, _ = _resolve_prediction_row_selection( + X_full, + preds, + owner="plot_region_classification_profiles", + ) - change_points = np.flatnonzero(np.diff(pd.factorize(labels)[0])) + 1 - for cp in change_points: - ax_left.axhline(cp, color="0.2", linestyle="--", linewidth=0.3) + if group_by not in {"pred_label", "true_label", "confusion"}: + raise ValueError("group_by must be one of {'pred_label', 'true_label', 'confusion'}.") + + if group_by == "confusion": + class_values = sorted(pd.unique(preds["true_label"])) + if len(class_values) != 2: + raise ValueError("group_by='confusion' requires exactly two classes.") + positive = positive_label if positive_label is not None else class_values[-1] + true_vals = preds["true_label"].to_numpy() + pred_vals = preds["pred_label"].to_numpy() + labels = np.empty(len(preds), dtype=object) + labels[(true_vals != positive) & (pred_vals != positive)] = "TN" + labels[(true_vals != positive) & (pred_vals == positive)] = "FP" + labels[(true_vals == positive) & (pred_vals != positive)] = "FN" + labels[(true_vals == positive) & (pred_vals == positive)] = "TP" + else: + labels = preds[group_by].to_numpy() - for i, lbl in enumerate(unique_labels): - ax = fig.add_subplot(gs[i, 1]) - mask = labels == lbl - mean_profile = X[mask].mean(axis=0) - ax.plot(x_axis, mean_profile, color=cmap(norm(i)), label=str(lbl)) - if V is not None: - mean_val = V[mask].mean(axis=0) - ax.plot(x_axis, mean_val, color="0.35", linestyle="--", linewidth=1.0) - ax.set_title(f"{lbl} (n={mask.sum()})") - ax.set_xlim(x_axis[0], x_axis[-1]) - ax.set_ylim(0, min(1.0, max(0.05, mean_profile.max() + 0.05))) - fig.tight_layout() - return fig + return plot_region_cluster_profiles( + X, + labels, + window_size=window_size, + motif_index=motif_index, + motif_count=motif_count, + plot_all_motifs=plot_all_motifs, + motif_labels=motif_labels, + motif_colors=motif_colors, + motif_profile_mode=motif_profile_mode, + color_points_by=color_points_by, + point_size=point_size, + point_alpha=point_alpha, + smoothing=smoothing, + smooth_win=smooth_win, + smooth_sigma=smooth_sigma, + show_unsmoothed_overlay=show_unsmoothed_overlay, + cmap_name=cmap_name, + ) def plot_multisite_read_raster( @@ -1571,8 +2197,14 @@ def plot_multisite_read_raster( n_windows: int = 2, min_separation_bp: int = 5000, distance_mode: str = "center", # or "bounds" - window_bp: int | None = None, + window_size: int | None = None, motif_index: int = 0, + motif_count: int | None = None, + plot_all_motifs: bool = False, + motif_labels: Sequence[str] | None = None, + window_center_offsets: Sequence[int] | None = None, + center_tolerance_bp: int | None = None, + min_read_length_bp: int | None = None, smoothing: str | None = "gaussian", # None, "boxcar", "gaussian" smooth_win: int = 21, smooth_sigma_bp: float = 6.0, @@ -1580,27 +2212,44 @@ def plot_multisite_read_raster( cmap: str = "viridis", vmin: float | None = None, vmax: float | None = None, + render_mode: str = "scatter", # "scatter" | "heatmap" + scatter_size: float = 4.0, + scatter_alpha: float = 0.7, + x_axis_mode: str = "relative_to_primary", # "relative_to_primary" | "centered" sort_by: str = "mod_fraction", # or "cluster" sort_labels: Sequence[int] | None = None, beds: Sequence[str | Path] | None = None, rotate: bool = True, ): """ - Plot n windows per read (e.g., paired sites) as stacked rasters, sorted by cluster or mod fraction. + Plot multi-window read rasters, optionally across multiple motifs. Args: read_windows: ReadWindowExtractionResult from extract_read_windows / build_multimotif_read_windows - n_windows: number of windows per read to plot (e.g., 2 for pairs) + n_windows: number of windows per read to plot when ``window_center_offsets`` is not provided min_separation_bp: minimum separation between site centers (distance_mode="center") or read starts (bounds) distance_mode: "center" uses region_start/end center; "bounds" uses read_start/read_end - window_bp: overrides default window length inferred from data_matrix slice - motif_index: which motif slice to use if data_matrix concatenates motifs + window_size: half-window in bp; if provided, per-motif slice width is ``2 * window_size``. + motif_index: reference motif slice index for single-motif plotting and ordering + motif_count: total motif slices concatenated in data_matrix; inferred when possible + plot_all_motifs: when True, render all motif slices in a motif x window panel grid + motif_labels: optional motif names aligned to motif slices + window_center_offsets: explicit desired window centers in primary-region coordinates + (for example ``[-2500, 0, 2500]``). When provided, this replaces ``n_windows``. + center_tolerance_bp: matching tolerance for ``window_center_offsets``. Defaults to half window span. + min_read_length_bp: optional minimum read length filter. Must be at least the required + span implied by requested centers/separation plus plotted window width. smoothing: None, "boxcar", or "gaussian" smooth_win: smoothing window length smooth_sigma_bp: sigma for gaussian smoothing max_rows: cap rows; downsample by averaging if exceeded cmap: matplotlib colormap vmin/vmax: color scale limits; None auto-scales + render_mode: "scatter" or "heatmap" + scatter_size: marker size for scatter mode + scatter_alpha: marker alpha for scatter mode + x_axis_mode: "relative_to_primary" offsets window axes by each read-pair + center distance from window 1; "centered" centers each window at 0 sort_by: "mod_fraction" or "cluster" sort_labels: cluster labels to sort by when sort_by="cluster" beds: optional list of BED/GTF/GFF paths; only reads intersecting all beds are retained @@ -1610,6 +2259,19 @@ def plot_multisite_read_raster( import matplotlib.pyplot as plt import math + if render_mode not in {"scatter", "heatmap"}: + raise ValueError("render_mode must be 'scatter' or 'heatmap'.") + if x_axis_mode not in {"relative_to_primary", "centered"}: + raise ValueError("x_axis_mode must be 'relative_to_primary' or 'centered'.") + if distance_mode not in {"center", "bounds"}: + raise ValueError("distance_mode must be 'center' or 'bounds'.") + if n_windows < 1: + raise ValueError("n_windows must be >= 1.") + if min_separation_bp < 0: + raise ValueError("min_separation_bp must be >= 0.") + if center_tolerance_bp is not None and center_tolerance_bp < 0: + raise ValueError("center_tolerance_bp must be >= 0 when provided.") + def _kernel(kind: str, win: int, sigma: float): if win % 2 == 0: win += 1 @@ -1646,15 +2308,74 @@ def _smooth(M: np.ndarray) -> np.ndarray: for bed in beds: bed_filters.append(pr.read_bed(bed)) - meta = read_windows.metadata - X_full = read_windows.data_matrix - # motif slicing - window_len = X_full.shape[1] - slice_width = window_bp or (window_len // max(1, window_len // (window_bp or window_len))) - n_motifs = max(1, window_len // slice_width) - start = motif_index * slice_width - end = start + slice_width - X = X_full[:, start:end] + meta = list(read_windows.metadata) + filtered_original_indices = np.arange(len(meta), dtype=int) + X_full = np.asarray(read_windows.data_matrix) + if X_full.ndim != 2: + raise ValueError("read_windows.data_matrix must be a 2D array.") + width = X_full.shape[1] + n_motifs, slice_width = _resolve_motif_slices( + width, + motif_count=motif_count, + motif_labels=motif_labels, + window_size=window_size, + ) + if n_motifs <= 0: + n_motifs = 1 + if slice_width <= 0: + raise ValueError("Unable to infer motif slice width from read_windows.data_matrix.") + if width % slice_width != 0: + raise ValueError( + "read_windows.data_matrix width is not divisible into consistent motif slices. " + "Pass an explicit motif_count or compatible window_size." + ) + if motif_index < 0 or motif_index >= n_motifs: + raise ValueError(f"motif_index {motif_index} out of range for {n_motifs} motif slices.") + motif_ids = list(range(n_motifs)) if plot_all_motifs and n_motifs > 1 else [motif_index] + if motif_labels is None: + motif_labels_resolved = [f"motif_{i}" for i in range(n_motifs)] + else: + motif_labels_resolved = list(motif_labels) + if len(motif_labels_resolved) < n_motifs: + motif_labels_resolved.extend( + [f"motif_{i}" for i in range(len(motif_labels_resolved), n_motifs)] + ) + X_by_motif = [X_full[:, m * slice_width : (m + 1) * slice_width] for m in motif_ids] + + if window_center_offsets is None: + n_windows_effective = int(n_windows) + target_offsets = None + else: + offsets = [int(offset) for offset in window_center_offsets] + if len(offsets) == 0: + raise ValueError("window_center_offsets must contain at least one center when provided.") + n_windows_effective = len(offsets) + target_offsets = np.asarray(offsets, dtype=float) + + if target_offsets is None: + required_read_length_bp = int(max(slice_width, ((n_windows_effective - 1) * min_separation_bp) + slice_width)) + else: + required_read_length_bp = int( + max( + slice_width, + np.ceil(float(target_offsets.max() - target_offsets.min()) + float(slice_width)), + ) + ) + + if min_read_length_bp is not None and min_read_length_bp < required_read_length_bp: + raise ValueError( + "min_read_length_bp must be >= required span implied by requested windows " + f"({required_read_length_bp} bp)." + ) + effective_min_read_length = ( + required_read_length_bp if target_offsets is not None and min_read_length_bp is None else min_read_length_bp + ) + + def _apply_index_filter(index_vector: np.ndarray) -> None: + nonlocal X_by_motif, meta, filtered_original_indices + X_by_motif = [matrix[index_vector] for matrix in X_by_motif] + meta = [meta[i] for i in index_vector] + filtered_original_indices = filtered_original_indices[index_vector] # Filter by beds if provided keep_idx = np.arange(len(meta)) @@ -1697,9 +2418,26 @@ def _smooth(M: np.ndarray) -> np.ndarray: keep_idx = np.sort(candidate_indices) else: keep_idx = np.array([], dtype=int) + _apply_index_filter(keep_idx) - X = X[keep_idx] - meta = [meta[i] for i in keep_idx] + if effective_min_read_length is not None: + keep_by_length: list[int] = [] + for idx, m in enumerate(meta): + read_length_val = m.get("read_length") + parsed_length: int | None = None + try: + if read_length_val is not None: + parsed_length = int(read_length_val) + except Exception: + parsed_length = None + if (parsed_length is None or parsed_length <= 0) and {"read_start", "read_end"}.issubset(m.keys()): + try: + parsed_length = int(m["read_end"]) - int(m["read_start"]) + except Exception: + parsed_length = None + if parsed_length is not None and parsed_length >= int(effective_min_read_length): + keep_by_length.append(idx) + _apply_index_filter(np.asarray(keep_by_length, dtype=int)) # Group by read key groups = defaultdict(list) @@ -1713,41 +2451,116 @@ def _smooth(M: np.ndarray) -> np.ndarray: center = (int(m.get("region_start", 0)) + int(m.get("region_end", 0))) // 2 else: center = int(m.get("read_start", 0)) - groups[key].append((i, m.get("chromosome"), center)) + groups[key].append((i, center)) - panels = [[] for _ in range(n_windows)] + pair_indices_per_window = [[] for _ in range(n_windows_effective)] + panel_centers = [[] for _ in range(n_windows_effective)] for _, items in groups.items(): - if len(items) < n_windows: + if len(items) < n_windows_effective: + continue + items = sorted(items, key=lambda x: x[1]) + centers_arr = np.asarray([entry[1] for entry in items], dtype=float) + idx_arr = np.asarray([entry[0] for entry in items], dtype=int) + + if target_offsets is None: + # sliding window of n_windows with minimum separation + for j in range(len(items) - n_windows_effective + 1): + centers = [items[j + k][1] for k in range(n_windows_effective)] + if any( + (centers[k + 1] - centers[k]) < min_separation_bp + for k in range(n_windows_effective - 1) + ): + continue + idxs = [items[j + k][0] for k in range(n_windows_effective)] + for k, idx in enumerate(idxs): + pair_indices_per_window[k].append(int(idx)) + panel_centers[k].append(float(centers[k])) continue - items = sorted(items, key=lambda x: (x[1], x[2])) - # sliding window of n_windows with separation constraint - for j in range(len(items) - n_windows + 1): - centers = [items[j + k][2] for k in range(n_windows)] - if any((centers[k + 1] - centers[k]) < min_separation_bp for k in range(n_windows - 1)): + + tolerance = float(center_tolerance_bp if center_tolerance_bp is not None else max(1, slice_width // 2)) + best_candidate: tuple[float, list[int]] | None = None + for anchor_pos in range(len(items)): + anchor_center = centers_arr[anchor_pos] + targets = anchor_center + target_offsets + used_positions: set[int] = set() + selected_positions: list[int] = [] + total_error = 0.0 + for target in targets: + distances = np.abs(centers_arr - target) + order = np.argsort(distances) + chosen = None + for candidate_pos in order: + pos = int(candidate_pos) + if pos in used_positions: + continue + if float(distances[pos]) <= tolerance: + chosen = pos + break + if chosen is None: + selected_positions = [] + break + used_positions.add(chosen) + selected_positions.append(chosen) + total_error += float(distances[chosen]) + + if not selected_positions: continue - idxs = [items[j + k][0] for k in range(n_windows)] - for k, idx in enumerate(idxs): - panels[k].append(X[idx]) + if best_candidate is None or total_error < best_candidate[0]: + best_candidate = (total_error, selected_positions) - if not all(len(p) > 0 for p in panels): + if best_candidate is None: + continue + _, selected_positions = best_candidate + for k, pos in enumerate(selected_positions): + pair_indices_per_window[k].append(int(idx_arr[pos])) + panel_centers[k].append(float(centers_arr[pos])) + + if not all(len(p) > 0 for p in pair_indices_per_window): raise ValueError("No read sets found meeting separation criteria.") - panels = [np.vstack(p) for p in panels] - # Smooth - panels_smooth = [_smooth(p) for p in panels] + window_indices = [np.asarray(values, dtype=int) for values in pair_indices_per_window] + panel_centers = [np.asarray(center_values, dtype=float) for center_values in panel_centers] + panels_by_motif = [] + panels_smooth_by_motif = [] + for motif_matrix in X_by_motif: + motif_panels = [motif_matrix[idx] for idx in window_indices] + panels_by_motif.append(motif_panels) + panels_smooth_by_motif.append([_smooth(panel) for panel in motif_panels]) + + # Sorting uses the reference motif to keep all motif panels aligned. + try: + ref_motif_pos = motif_ids.index(motif_index) + except ValueError: + ref_motif_pos = 0 + reference_panels = panels_smooth_by_motif[ref_motif_pos] # Sorting if sort_by == "mod_fraction": - means = [p.mean(axis=1) for p in panels_smooth] + means = [p.mean(axis=1) for p in reference_panels] order = np.lexsort(tuple(-m for m in reversed(means))) elif sort_by == "cluster" and sort_labels is not None: - sort_labels = np.asarray(sort_labels)[keep_idx] - # repeat labels to match panels length - order = np.argsort(sort_labels) + labels_array = np.asarray(sort_labels) + if labels_array.shape[0] == len(read_windows.metadata): + labels_filtered = labels_array[filtered_original_indices] + elif labels_array.shape[0] == len(meta): + labels_filtered = labels_array + else: + raise ValueError( + "sort_labels must match either the original metadata length " + "or the filtered metadata length." + ) + pair_labels = labels_filtered[window_indices[0]] + order = np.argsort(pair_labels) else: - order = np.arange(panels_smooth[0].shape[0]) + order = np.arange(reference_panels[0].shape[0]) - panels_sorted = [p[order] for p in panels_smooth] + panels_sorted_by_motif = [ + [panel[order] for panel in motif_panels] + for motif_panels in panels_smooth_by_motif + ] + centers_sorted = [c[order] for c in panel_centers] + primary_centers = centers_sorted[0] + center_offsets = [c - primary_centers for c in centers_sorted] # Downsample rows if too tall def bin_rows(M, k): @@ -1758,181 +2571,431 @@ def bin_rows(M, k): out[i] = M[s:e].mean(axis=0) return out - P = panels_sorted[0].shape[0] + def bin_vector(vector: np.ndarray, k: int) -> np.ndarray: + n_bins = math.ceil(vector.shape[0] / k) + out = np.zeros(n_bins, dtype=float) + for i in range(n_bins): + s, e = i * k, min((i + 1) * k, vector.shape[0]) + out[i] = vector[s:e].mean() + return out + + P = panels_sorted_by_motif[0][0].shape[0] downsampled = False if P > max_rows: step = math.ceil(P / max_rows) - panels_sorted = [bin_rows(p, step) for p in panels_sorted] - P = panels_sorted[0].shape[0] + panels_sorted_by_motif = [ + [bin_rows(panel, step) for panel in motif_panels] + for motif_panels in panels_sorted_by_motif + ] + center_offsets = [bin_vector(v, step) for v in center_offsets] + P = panels_sorted_by_motif[0][0].shape[0] downsampled = True if vmin is None or vmax is None: - vmax_auto = max(p.max() for p in panels_sorted) + vmax_auto = max(panel.max() for motif_panels in panels_sorted_by_motif for panel in motif_panels) vmin = 0.0 if vmin is None else vmin vmax = vmax_auto if vmax is None else vmax - # Plot - import matplotlib.pyplot as plt - - if rotate: - fig, axes = plt.subplots( - n_windows, 1, figsize=(max(6, P * 0.06), 3 + n_windows * 1.5), sharex=True - ) - axes = np.atleast_1d(axes) - for i, ax in enumerate(axes): - im = ax.imshow( - panels_sorted[i].T, - aspect="auto", - origin="lower", - vmin=vmin, - vmax=vmax, - cmap=cmap, + x_positions = np.arange(slice_width, dtype=float) - (slice_width // 2) + + share_x_axes = True + if ( + rotate + and render_mode == "scatter" + and x_axis_mode == "relative_to_primary" + and n_windows_effective > 1 + ): + share_x_axes = False + + n_plot_motifs = len(motif_ids) + if n_plot_motifs == 1: + if rotate: + fig, axes = plt.subplots( + n_windows_effective, + 1, + figsize=(max(6, slice_width * 0.01), 2.7 + n_windows_effective * 1.5), + sharex=share_x_axes, ) - ax.axhline(slice_width // 2, linestyle="--", linewidth=1, color="0.7") - ax.set_ylabel(f"Window {i+1} (bp)") - axes[-1].set_xlabel("Reads (sorted)") + axes = np.atleast_1d(axes).reshape(n_windows_effective, 1) + else: + fig, axes = plt.subplots( + 1, + n_windows_effective, + figsize=(10, max(3, P * 0.06)), + sharey=True, + ) + axes = np.atleast_1d(axes).reshape(1, n_windows_effective) else: - fig, axes = plt.subplots( - 1, n_windows, figsize=(10, max(3, P * 0.06)), sharey=True - ) - axes = np.atleast_1d(axes) - for i, ax in enumerate(axes): - im = ax.imshow( - panels_sorted[i], - aspect="auto", - origin="upper", - vmin=vmin, - vmax=vmax, - cmap=cmap, + if rotate: + n_rows, n_cols = n_windows_effective, n_plot_motifs + fig, axes = plt.subplots( + n_rows, + n_cols, + figsize=(max(8, 4.2 * n_cols), max(3.5, 2.3 * n_rows)), + sharex=share_x_axes, + sharey=True, + ) + else: + n_rows, n_cols = n_plot_motifs, n_windows_effective + fig, axes = plt.subplots( + n_rows, + n_cols, + figsize=(max(8, 3.8 * n_cols), max(3.5, 2.2 * n_rows)), + sharey=True, ) - ax.axvline(slice_width // 2 - 0.5, linestyle="--", linewidth=1, color="0.7") - ax.set_xlabel("Position (bp)") - axes[0].set_ylabel("Reads (sorted)") + axes = np.atleast_2d(axes) + + def _axis_for(motif_pos: int, window_pos: int): + if len(motif_ids) == 1: + return axes[window_pos, 0] if rotate else axes[0, window_pos] + if rotate: + return axes[window_pos, motif_pos] + return axes[motif_pos, window_pos] + + first_mappable = None + for motif_pos, motif_id in enumerate(motif_ids): + motif_panels = panels_sorted_by_motif[motif_pos] + motif_label = str(motif_labels_resolved[motif_id]) + for window_pos in range(n_windows_effective): + ax = _axis_for(motif_pos, window_pos) + panel = motif_panels[window_pos] + row_offsets = ( + center_offsets[window_pos] + if x_axis_mode == "relative_to_primary" + else np.zeros(panel.shape[0], dtype=float) + ) + axis_center = float(np.nanmedian(row_offsets)) if row_offsets.size else 0.0 + + if render_mode == "scatter": + rows, cols = np.nonzero(panel > 0) + values = panel[rows, cols] + if rows.size > 0: + x_scatter = x_positions[cols] + row_offsets[rows] + first_mappable = ax.scatter( + x_scatter, + rows, + c=values, + s=scatter_size, + alpha=scatter_alpha, + cmap=cmap, + vmin=vmin, + vmax=vmax, + linewidths=0, + rasterized=True, + ) + x_min = float(np.nanmin(x_scatter)) + x_max = float(np.nanmax(x_scatter)) + else: + x_min = float(x_positions[0] + axis_center) + x_max = float(x_positions[-1] + axis_center) + x_pad = max(1.0, 0.02 * (x_max - x_min + 1.0)) + ax.axvline(axis_center, linestyle="--", linewidth=1, color="0.7") + ax.set_ylim(-1, panel.shape[0] + 1) + ax.set_xlim(x_min - x_pad, x_max + x_pad) + else: + if rotate: + first_mappable = ax.imshow( + panel.T, + aspect="auto", + origin="lower", + vmin=vmin, + vmax=vmax, + cmap=cmap, + ) + ax.axhline(slice_width // 2, linestyle="--", linewidth=1, color="0.7") + else: + first_mappable = ax.imshow( + panel, + aspect="auto", + origin="upper", + vmin=vmin, + vmax=vmax, + cmap=cmap, + ) + ax.axvline(slice_width // 2 - 0.5, linestyle="--", linewidth=1, color="0.7") + + if render_mode == "heatmap" and x_axis_mode == "centered": + heatmap_title = ( + f"{motif_label} | Window {window_pos + 1}" + if len(motif_ids) > 1 + else f"Window {window_pos + 1}" + ) + ax.set_title(heatmap_title, fontsize=9) + elif len(motif_ids) > 1: + if rotate and window_pos == 0: + ax.set_title(motif_label) + if not rotate and motif_pos == 0: + ax.set_title(f"Window {window_pos + 1}") + + if rotate and motif_pos == 0: + ax.set_ylabel(f"Window {window_pos + 1}\nReads") + if (not rotate) and len(motif_ids) > 1 and window_pos == 0: + ax.set_ylabel(f"{motif_label}\nReads") - cbar = fig.colorbar(im, ax=np.ravel(axes).tolist(), shrink=0.6, pad=0.02) + if rotate: + bottom_axes = [_axis_for(motif_pos, n_windows_effective - 1) for motif_pos in range(len(motif_ids))] + xlabel = ( + "Position relative to primary window center (bp)" + if render_mode == "scatter" and x_axis_mode == "relative_to_primary" + else "Position from window center (bp)" + if render_mode == "scatter" + else "Reads (sorted)" + ) + for ax in bottom_axes: + ax.set_xlabel(xlabel) + else: + for motif_pos in range(len(motif_ids)): + _axis_for(motif_pos, 0).set_ylabel("Reads (sorted)" if len(motif_ids) == 1 else _axis_for(motif_pos, 0).get_ylabel()) + for window_pos in range(n_windows_effective): + _axis_for(motif_pos, window_pos).set_xlabel("Position (bp)") + + if first_mappable is None: + first_axis = _axis_for(0, 0) + first_mappable = first_axis.scatter([], [], c=[], cmap=cmap, vmin=vmin, vmax=vmax) + cbar = fig.colorbar(first_mappable, ax=np.ravel(axes).tolist(), shrink=0.6, pad=0.02) sigma_txt = f", σ={smooth_sigma_bp}" if smoothing == "gaussian" else "" + scale_label = "fraction modified signal" + if render_mode == "heatmap": + scale_label = "window signal (row-aggregated heatmap)" cbar.set_label( - f"Modification density (smoothed={smoothing}, win={smooth_win}{sigma_txt})\\n" + f"{scale_label} (smoothed={smoothing}, win={smooth_win}{sigma_txt})\\n" f"{'downsampled' if downsampled else 'full'}" ) - return fig, {"pairs": panels_sorted[0].shape[0], "downsampled": downsampled, "vmin": vmin, "vmax": vmax} + return fig, { + "pairs": panels_sorted_by_motif[0][0].shape[0], + "downsampled": downsampled, + "vmin": vmin, + "vmax": vmax, + "render_mode": render_mode, + "x_axis_mode": x_axis_mode, + "motifs_plotted": [motif_labels_resolved[m] for m in motif_ids], + "n_windows": n_windows_effective, + "window_center_offsets": target_offsets.tolist() if target_offsets is not None else None, + "required_read_length_bp": required_read_length_bp, + "min_read_length_bp": effective_min_read_length, + "center_tolerance_bp": center_tolerance_bp, + } def plot_region_cluster_profiles( pileup_matrix: np.ndarray, labels: np.ndarray, *, - window_bp: int | None = None, + window_size: int | None = None, motif_index: int | None = None, motif_count: int | None = None, - show_all_motifs: bool = False, + plot_all_motifs: bool = False, + motif_labels: Sequence[str] | None = None, + motif_colors: Sequence[str] | None = None, + motif_profile_mode: str = "single_axis", + color_points_by: str = "cluster", + point_size: float = 1.0, + point_alpha: float = 0.01, + smoothing: str | None = None, + smooth_win: int = 21, + smooth_sigma: float = 6.0, + show_unsmoothed_overlay: bool = False, + invert_y: bool = True, cmap_name: str = "viridis", ): """ - Visualize region-level clustering by overlaying per-cluster mean profiles and a heatmap. + Visualize region-level clustering with a sorted matrix view and side profiles. + Supports concatenated multi-motif matrices with shared or separate profile axes. Args: pileup_matrix: 2D array (n_regions, region_length) of modification fractions labels: cluster assignments per region - window_bp: optional x-axis width in bp (assumes symmetric window); defaults to range(len(profile)) + window_size: optional half-window in bp for axis scaling and motif-slice inference + (full span = ``2 * window_size``). motif_index: if pileup_matrix is a concatenation of multiple motifs, select which motif slice to plot motif_count: total number of motifs concatenated; if None, inferred when possible - show_all_motifs: if True and motifs are concatenated, plot mean profiles for each motif slice per cluster + plot_all_motifs: if True and motifs are concatenated, plot all motif slices per cluster cmap_name: matplotlib colormap name for clusters """ import matplotlib.pyplot as plt from matplotlib import gridspec + from matplotlib.lines import Line2D from matplotlib.colors import Normalize X_full = np.asarray(pileup_matrix) labs = np.asarray(labels) if X_full.shape[0] != labs.shape[0]: raise ValueError("pileup_matrix rows and labels must have the same length.") + if motif_profile_mode not in {"single_axis", "separate_axes"}: + raise ValueError("motif_profile_mode must be 'single_axis' or 'separate_axes'.") + if color_points_by not in {"cluster", "motif"}: + raise ValueError("color_points_by must be 'cluster' or 'motif'.") - # Motif slicing region_len = X_full.shape[1] motif_idx = motif_index if motif_index is not None else 0 - if motif_count is None and window_bp and window_bp > 0 and region_len % window_bp == 0: - motif_count = region_len // window_bp - motif_count = max(1, int(motif_count or 1)) - slice_width = region_len // motif_count if motif_count > 0 else region_len - if slice_width == 0: - slice_width = region_len - motif_count = 1 - - start = motif_idx * slice_width - end = min(region_len, start + slice_width) - if start >= region_len: + n_motifs, slice_width = _resolve_motif_slices( + region_len, + motif_count=motif_count, + motif_labels=motif_labels, + window_size=window_size, + ) + if motif_idx < 0 or motif_idx >= n_motifs: raise ValueError( - f"motif_index {motif_idx} is out of range for concatenated length {region_len}; " - "pass motif_count to disambiguate." + f"motif_index {motif_idx} out of range for {n_motifs} motif slices." ) - X = X_full[:, start:end] + motif_ids = list(range(n_motifs)) if plot_all_motifs and n_motifs > 1 else [motif_idx] - n_regions, region_len = X.shape - if window_bp is None: - x_axis = np.arange(region_len) + if motif_labels is None: + motif_labels = [f"motif_{i}" for i in range(n_motifs)] + else: + motif_labels = list(motif_labels) + if len(motif_labels) < n_motifs: + motif_labels.extend( + [f"motif_{i}" for i in range(len(motif_labels), n_motifs)] + ) + if motif_colors is None: + motif_cmap = plt.get_cmap("tab10") + motif_colors = [motif_cmap(i % 10) for i in range(n_motifs)] else: - half = window_bp // 2 - x_axis = np.linspace(-half, half, region_len) + motif_colors = list(motif_colors) + if len(motif_colors) < n_motifs: + motif_cmap = plt.get_cmap("tab10") + motif_colors.extend( + motif_cmap(i % 10) for i in range(len(motif_colors), n_motifs) + ) - # Sort regions by cluster for heatmap readability - order = np.lexsort((np.arange(n_regions), labs)) - X_sorted = X[order] - labs_sorted = labs[order] + primary_start = motif_idx * slice_width + primary_end = min(region_len, primary_start + slice_width) + primary_matrix = X_full[:, primary_start:primary_end] + x_axis = _centered_x_axis( + primary_matrix.shape[1], + _window_span_from_size(window_size) if window_size is not None else primary_matrix.shape[1], + ) - unique_clusters = np.unique(labs_sorted) + labs_arr, lab_codes, unique_codes = _prepare_group_labels(labs) + order = np.lexsort((-primary_matrix.mean(axis=1), lab_codes)) + X_sorted_full = X_full[order] + lab_codes_sorted = lab_codes[order] + + unique_labels = np.array([np.unique(labs_arr[lab_codes == code])[0] for code in unique_codes]) cmap = plt.get_cmap(cmap_name) - norm = Normalize(vmin=int(unique_clusters.min()), vmax=int(unique_clusters.max())) - - fig = plt.figure(figsize=(10, 6 if not show_all_motifs else 8)) - rows = 2 if not show_all_motifs else (2 + max(0, motif_count - 1)) - gs = gridspec.GridSpec(rows, 1, height_ratios=[1] * (rows - 1) + [2], hspace=0.3) - - # Mean profiles (optionally per motif) - ax0 = fig.add_subplot(gs[0]) - for cl in unique_clusters: - mask = labs == cl - mean_profile = X[mask].mean(axis=0) - ax0.plot(x_axis, mean_profile, color=cmap(norm(int(cl))), label=f"C{cl} (n={mask.sum()})") - ax0.set_ylabel("Modified fraction") - ax0.legend(loc="upper right", ncol=min(len(unique_clusters), 4), fontsize="small") - - if show_all_motifs and motif_count and motif_count > 1: - for mi in range(1, motif_count): - ax_m = fig.add_subplot(gs[mi]) - start_m = mi * slice_width - end_m = start_m + slice_width - Xm = X_full[:, start_m:end_m] - for cl in unique_clusters: - mask = labs == cl - ax_m.plot( + norm = Normalize(vmin=int(unique_codes.min()), vmax=int(unique_codes.max() or 1)) + + fig = plt.figure(figsize=(12, max(4, len(unique_codes)))) + gs = gridspec.GridSpec(nrows=len(unique_codes), ncols=2, width_ratios=[3, 1]) + ax_left = fig.add_subplot(gs[:, 0]) + + # Left panel: scatter only (parallel to read-clustering style) + for motif_id in motif_ids: + s = motif_id * slice_width + e = min(region_len, s + slice_width) + matrix_view = X_sorted_full[:, s:e] + rows, cols = np.nonzero(matrix_view) + if color_points_by == "cluster": + colors = cmap(norm(lab_codes_sorted[rows])) + else: + colors = motif_colors[motif_id] + ax_left.scatter( + x_axis[cols], + rows, + s=point_size, + alpha=point_alpha, + c=colors, + rasterized=True, + ) + + ax_left.set_xlabel("Distance from region center (bp)") + ax_left.set_ylabel("Region (sorted)") + if invert_y: + ax_left.invert_yaxis() + change_points = np.flatnonzero(np.diff(lab_codes_sorted)) + 1 + for cp in change_points: + ax_left.axhline(cp, color="0.2", linestyle="--", linewidth=0.35) + + for i, code in enumerate(unique_codes): + ax = fig.add_subplot(gs[i, 1]) + row_mask = lab_codes_sorted == code + panel_max = 0.0 + if motif_profile_mode == "separate_axes" and len(motif_ids) > 1: + axes_for_motifs = [ax] + motif_maxima = [0.0 for _ in motif_ids] + for motif_pos in range(1, len(motif_ids)): + twin = ax.twinx() + twin.spines["right"].set_position(("outward", 35 * motif_pos)) + axes_for_motifs.append(twin) + for motif_pos, motif_id in enumerate(motif_ids): + s = motif_id * slice_width + e = min(region_len, s + slice_width) + mean_profile_raw = X_sorted_full[row_mask, s:e].mean(axis=0) + mean_profile = _smooth_profile_vector( + mean_profile_raw, + smoothing=smoothing, + smooth_win=smooth_win, + smooth_sigma=smooth_sigma, + ) + motif_maxima[motif_pos] = max( + motif_maxima[motif_pos], float(np.nanmax(mean_profile_raw)) + ) + panel_max = max(panel_max, motif_maxima[motif_pos]) + motif_ax = axes_for_motifs[motif_pos] + if show_unsmoothed_overlay and smoothing is not None: + motif_ax.plot( + x_axis, + mean_profile_raw, + color=motif_colors[motif_id], + linewidth=1.0, + alpha=0.25, + ) + motif_ax.plot( x_axis, - Xm[mask].mean(axis=0), - color=cmap(norm(int(cl))), - label=f"C{cl}", + mean_profile, + color=motif_colors[motif_id], + linewidth=1.5, ) - ax_m.set_ylabel(f"Motif {mi}") - - # Heatmap sorted by cluster (using selected motif slice) - ax1 = fig.add_subplot(gs[-1]) - im = ax1.imshow( - X_sorted, - aspect="auto", - interpolation="none", - extent=[x_axis[0], x_axis[-1], n_regions, 0], - cmap="viridis", - ) - ax1.set_xlabel("Position (bp)" if window_bp is not None else "Index") - ax1.set_ylabel("Region (sorted by cluster)") - fig.colorbar(im, ax=ax1, label="Modified fraction") + motif_ax.set_ylabel(str(motif_labels[motif_id]), color=motif_colors[motif_id]) + motif_ax.tick_params(axis="y", colors=motif_colors[motif_id], labelsize=8) + for motif_pos, motif_ax in enumerate(axes_for_motifs): + motif_ax.set_ylim(0, max(motif_maxima[motif_pos], 0.05) * 1.05) + else: + for motif_id in motif_ids: + s = motif_id * slice_width + e = min(region_len, s + slice_width) + mean_profile_raw = X_sorted_full[row_mask, s:e].mean(axis=0) + mean_profile = _smooth_profile_vector( + mean_profile_raw, + smoothing=smoothing, + smooth_win=smooth_win, + smooth_sigma=smooth_sigma, + ) + panel_max = max(panel_max, float(np.nanmax(mean_profile_raw))) + if show_unsmoothed_overlay and smoothing is not None: + ax.plot( + x_axis, + mean_profile_raw, + color=motif_colors[motif_id] if len(motif_ids) > 1 else cmap(norm(code)), + linewidth=1.0, + alpha=0.25, + ) + ax.plot( + x_axis, + mean_profile, + color=motif_colors[motif_id] if len(motif_ids) > 1 else cmap(norm(code)), + linewidth=1.5, + ) + ax.set_title(f"{unique_labels[i]} (n={row_mask.sum()})") + ax.set_xlim(x_axis[0], x_axis[-1]) + y_max = max(panel_max, 0.05) + ax.set_ylim(0, y_max * 1.05) - # Cluster boundaries - change_points = np.flatnonzero(np.diff(labs_sorted)) + 1 - for cp in change_points: - ax1.axhline(cp, color="0.8", linestyle="--", linewidth=0.5) + if len(motif_ids) > 1 or color_points_by == "motif": + handles = [ + Line2D([0], [0], color=motif_colors[m], linewidth=2, label=str(motif_labels[m])) + for m in motif_ids + ] + fig.legend( + handles=handles, + loc="upper center", + ncol=min(4, len(handles)), + frameon=False, + bbox_to_anchor=(0.5, 1.01), + ) fig.tight_layout() return fig @@ -1980,9 +3043,14 @@ def plot_cluster_karyotype( region_bed: str | Path, chrom_sizes: str | Path, *, - cmap_name: str = "viridis", - linewidth: float = 6.0, - figsize_per_chrom: float = 0.4, + cmap_name: str = "tab10", + linewidth: float = 4.0, + figsize_per_chrom: float = 0.7, + min_visible_bp: int = 50_000, + min_visible_fraction: float = 0.002, + chromosome_order: str | Sequence[str] = "length_desc", + invert_position_axis: bool = True, + detect_haplotype_backbone_shading: bool = True, ): """ Plot cluster-labeled regions along chromosomes (ideogram-style), colored by cluster. @@ -1993,8 +3061,16 @@ def plot_cluster_karyotype( cmap_name: matplotlib colormap to map cluster ids to colors linewidth: thickness of region segments figsize_per_chrom: vertical size per chromosome for sizing the figure + min_visible_bp: minimum displayed region length in bp for visibility + min_visible_fraction: minimum displayed region length as a fraction of chromosome length + chromosome_order: "length_desc", "length_asc", "natural", or explicit ordered chromosome list + invert_position_axis: if True, chromosome position increases downward + detect_haplotype_backbone_shading: if True, apply subtle maternal/paternal-like + backbone shading when paired haplotype naming is detected """ import matplotlib.pyplot as plt + from matplotlib.colors import Normalize + import re clusters_df = pd.read_csv( region_bed, @@ -2004,6 +3080,8 @@ def plot_cluster_karyotype( usecols=[0, 1, 2, 3], names=["Chromosome", "Start", "End", "Name"], ) + if clusters_df.empty: + raise ValueError(f"No records found in region_bed: {region_bed}") chrom_df = pd.read_csv( chrom_sizes, sep="\t", @@ -2011,41 +3089,182 @@ def plot_cluster_karyotype( usecols=[0, 1], names=["Chromosome", "Length"], ) + if chrom_df.empty: + raise ValueError(f"No chromosome sizes found in: {chrom_sizes}") df = clusters_df.merge(chrom_df, on="Chromosome", how="inner") if df.empty: raise ValueError("No overlapping chromosomes between BED and chrom_sizes.") - df["start_frac"] = df["Start"] / df["Length"] - df["end_frac"] = df["End"] / df["Length"] - df["cluster_id"] = ( - df["Name"].astype(str).str.extract(r"(\d+)$", expand=False).astype(int) + df["Start"] = pd.to_numeric(df["Start"], errors="coerce") + df["End"] = pd.to_numeric(df["End"], errors="coerce") + df["Length"] = pd.to_numeric(df["Length"], errors="coerce") + df = df.dropna(subset=["Start", "End", "Length"]).copy() + if df.empty: + raise ValueError("No valid numeric coordinates after parsing BED/chrom sizes.") + + def _natural_chrom_key(chrom: str): + text = str(chrom) + match = re.match(r"^chr(\d+)$", text, flags=re.IGNORECASE) + if match: + return (0, int(match.group(1)), text) + if text.lower() in {"chrx", "x"}: + return (1, 23, text) + if text.lower() in {"chry", "y"}: + return (1, 24, text) + if text.lower() in {"chrm", "mt", "m"}: + return (1, 25, text) + return (2, text.lower(), text) + + def _split_haplotype(chrom: str) -> tuple[str, str | None]: + name = str(chrom) + patterns = ( + r"^(?P.+?)[._-](?Pmat|pat|maternal|paternal)$", + r"^(?P.+?)[._-](?Phap1|hap2)$", + ) + for pattern in patterns: + m = re.match(pattern, name, flags=re.IGNORECASE) + if m: + return (m.group("base"), m.group("hap").lower()) + return (name, None) + + parsed_cluster = pd.to_numeric( + df["Name"].astype(str).str.extract(r"(\d+)$", expand=False), + errors="coerce", ) + if parsed_cluster.isna().all(): + df["cluster_id"] = pd.factorize(df["Name"].astype(str))[0] + else: + fallback = pd.factorize(df["Name"].astype(str))[0] + df["cluster_id"] = parsed_cluster.fillna(pd.Series(fallback, index=df.index)).astype(int) + + chrom_sizes_series = df.groupby("Chromosome")["Length"].max() + if isinstance(chromosome_order, (list, tuple, pd.Index, np.ndarray)): + requested = [str(chrom) for chrom in chromosome_order] + observed = chrom_sizes_series.index.astype(str).tolist() + chrom_order = [chrom for chrom in requested if chrom in observed] + chrom_order.extend([chrom for chrom in observed if chrom not in chrom_order]) + else: + order_mode = str(chromosome_order).lower() + if order_mode == "length_asc": + chrom_order = chrom_sizes_series.sort_values(ascending=True).index.astype(str).tolist() + elif order_mode == "natural": + chrom_order = sorted(chrom_sizes_series.index.astype(str).tolist(), key=_natural_chrom_key) + else: + chrom_order = chrom_sizes_series.sort_values(ascending=False).index.astype(str).tolist() + + haplotype_pairs: dict[str, set[str]] = {} + if detect_haplotype_backbone_shading: + for chrom in chrom_order: + base, hap = _split_haplotype(chrom) + if hap is None: + continue + haplotype_pairs.setdefault(base, set()).add(hap) + + def _backbone_color(chrom: str) -> str: + if not detect_haplotype_backbone_shading: + return "0.75" + base, hap = _split_haplotype(chrom) + if hap is None: + return "0.75" + pair = haplotype_pairs.get(base, set()) + # Only apply shading when we detect at least a pair for the same base. + if len(pair) < 2: + return "0.75" + if hap in {"maternal", "mat", "hap1"}: + return "0.66" + if hap in {"paternal", "pat", "hap2"}: + return "0.84" + return "0.75" - chrom_order = ( - df.groupby("Chromosome")["Length"].max().sort_values(ascending=False).index - ) cmap = plt.get_cmap(cmap_name) - fig_height = max(3.0, figsize_per_chrom * len(chrom_order)) - fig, ax = plt.subplots(figsize=(10, fig_height)) + unique_clusters = np.sort(df["cluster_id"].unique()) + if hasattr(cmap, "colors") and len(getattr(cmap, "colors")) > 0: + color_cycle = list(getattr(cmap, "colors")) + cluster_to_color = { + int(cid): color_cycle[i % len(color_cycle)] + for i, cid in enumerate(unique_clusters) + } + else: + norm = Normalize(vmin=0, vmax=max(1, len(unique_clusters) - 1)) + cluster_to_color = { + int(cid): cmap(norm(i)) + for i, cid in enumerate(unique_clusters) + } - for i, chrom in enumerate(chrom_order): - ax.plot([0, 1], [i, i], color="0.9", lw=linewidth) # chromosome backbone + fig_height = max(3.0, figsize_per_chrom * len(chrom_order)) + fig, ax = plt.subplots(figsize=(max(8, len(chrom_order) * 0.7), fig_height + 1.5)) + max_length = float(df["Length"].max()) + x_positions = np.arange(len(chrom_order), dtype=float) + + for xi, chrom in zip(x_positions, chrom_order): + chrom_len = float(df.loc[df["Chromosome"] == chrom, "Length"].max()) + # Backbone for full chromosome (proportional in bp units) + ax.plot( + [xi, xi], + [0, chrom_len], + color=_backbone_color(chrom), + lw=linewidth + 1.5, + alpha=0.7, + solid_capstyle="butt", + zorder=1, + ) + # Cluster-assigned regions sub = df[df["Chromosome"] == chrom] for _, row in sub.iterrows(): + start_bp = float(row["Start"]) + end_bp = float(row["End"]) + region_len = max(0.0, end_bp - start_bp) + min_len = max(float(min_visible_bp), chrom_len * float(min_visible_fraction)) + if region_len < min_len: + center = 0.5 * (start_bp + end_bp) + start_bp = max(0.0, center - (0.5 * min_len)) + end_bp = min(chrom_len, center + (0.5 * min_len)) ax.plot( - [row.start_frac, row.end_frac], - [i, i], - color=cmap(row.cluster_id % cmap.N), - lw=linewidth, + [xi, xi], + [start_bp, end_bp], + color=cluster_to_color[int(row.cluster_id)], + lw=linewidth + 2.0, + alpha=0.95, solid_capstyle="butt", + zorder=2, ) - ax.text(-0.02, i, chrom, ha="right", va="center", fontsize=8) + # Per-chromosome coordinate summary below each chromosome. + label_y = -0.055 * max_length if invert_position_axis else 1.055 * max_length + label_va = "top" if invert_position_axis else "bottom" + ax.text( + xi, + label_y, + f"0 .. {int(chrom_len):,} bp", + ha="center", + va=label_va, + fontsize=7, + color="0.35", + ) - ax.set_xlim(0, 1) - ax.set_ylim(-1, len(chrom_order)) - ax.set_yticks([]) - ax.set_xlabel("Relative position along chromosome") - ax.set_title("Clustered regions by chromosome") + ax.set_xlim(-0.7, len(chrom_order) - 0.3) + if invert_position_axis: + ax.set_ylim(1.08 * max_length, -0.1 * max_length) + else: + ax.set_ylim(-0.1 * max_length, 1.08 * max_length) + ax.set_xticks(x_positions) + ax.set_xticklabels(chrom_order, rotation=45, ha="right") + ax.set_ylabel("Position (bp)") + ax.set_title("Clustered Regions by Chromosome (Vertical, Proportional Length)") + ax.spines["top"].set_visible(False) + ax.spines["right"].set_visible(False) + from matplotlib.lines import Line2D + + legend_handles = [ + Line2D([0], [0], color=cluster_to_color[int(cid)], linewidth=3, label=f"C{int(cid)}") + for cid in unique_clusters + ] + ax.legend( + handles=legend_handles, + title="Cluster", + loc="upper right", + frameon=False, + ncol=min(4, len(legend_handles)), + ) plt.tight_layout() return fig @@ -2141,6 +3360,184 @@ def summarize_region_cluster_annotations( return merged +def _adjust_p_values_bh(p_values: pd.Series) -> pd.Series: + if p_values.empty: + return pd.Series(dtype=float, index=p_values.index) + + numeric = pd.to_numeric(p_values, errors="coerce") + valid_mask = numeric.notna() + if not valid_mask.any(): + return pd.Series(np.nan, index=p_values.index, dtype=float) + + valid_values = numeric[valid_mask].to_numpy(dtype=float) + order = np.argsort(valid_values, kind="mergesort") + ranked = valid_values[order] + adjusted = np.empty_like(ranked) + running_min = 1.0 + total = len(ranked) + + for index in range(total - 1, -1, -1): + rank = index + 1 + candidate = min(1.0, ranked[index] * total / rank) + running_min = min(running_min, candidate) + adjusted[index] = running_min + + restored = np.full(len(p_values), np.nan, dtype=float) + restored_indices = np.flatnonzero(valid_mask.to_numpy()) + restored[restored_indices[order]] = adjusted + return pd.Series(restored, index=p_values.index, dtype=float) + + +def _binomial_greater_tail(k: int, n: int, p: float) -> float: + if n <= 0: + return 1.0 + if k <= 0: + return 1.0 + if p <= 0.0: + return 0.0 if k > 0 else 1.0 + if p >= 1.0: + return 1.0 + if k > n: + raise ValueError("k cannot exceed n for a binomial tail probability.") + + log_p = math.log(p) + log_q = math.log1p(-p) + tail = 0.0 + for i in range(k, n + 1): + log_prob = ( + math.lgamma(n + 1) + - math.lgamma(i + 1) + - math.lgamma(n - i + 1) + + i * log_p + + (n - i) * log_q + ) + tail += math.exp(log_prob) + return float(min(max(tail, 0.0), 1.0)) + + +def summarize_read_cluster_region_associations( + metadata: Sequence[dict[str, Any]], + labels: Sequence[int | str], + *, + include_strand: bool = True, + min_reads_per_region: int = 1, + prior_count: float = 0.5, +) -> pd.DataFrame: + """ + Summarize read-cluster associations per region with enrichment statistics. + + Returns a long-form DataFrame with one row per (region, cluster). + """ + + if len(metadata) != len(labels): + raise ValueError("metadata and labels must have the same length.") + if min_reads_per_region < 1: + raise ValueError("min_reads_per_region must be at least 1.") + if prior_count < 0: + raise ValueError("prior_count must be non-negative.") + + rows: list[dict[str, Any]] = [] + for meta, cluster_label in zip(metadata, labels): + chrom = meta.get("chromosome", meta.get("chrom")) + start = meta.get("region_start", meta.get("start")) + end = meta.get("region_end", meta.get("end")) + strand_value = meta.get("region_strand", meta.get("strand")) if include_strand else "." + strand = strand_value if strand_value in {"+", "-"} else "." + rows.append( + { + "chrom": chrom, + "start": start, + "end": end, + "strand": strand, + "cluster": cluster_label, + } + ) + + columns = [ + "chrom", + "start", + "end", + "strand", + "cluster", + "count", + "total_reads", + "fraction", + "global_count", + "global_total", + "global_fraction", + "log2_enrichment", + "p_value", + "q_value", + ] + df = pd.DataFrame(rows, columns=["chrom", "start", "end", "strand", "cluster"]) + if df.empty: + return pd.DataFrame(columns=columns) + + region_cols = ["chrom", "start", "end", "strand"] + cluster_order = list(pd.unique(df["cluster"])) + region_totals = df.groupby(region_cols, sort=True).size().reset_index(name="total_reads") + kept_regions = region_totals.loc[region_totals["total_reads"] >= min_reads_per_region, region_cols] + if kept_regions.empty: + return pd.DataFrame(columns=columns) + + region_grid = kept_regions.assign(_key=1).merge( + pd.DataFrame({"cluster": cluster_order, "_key": 1}), + on="_key", + how="outer", + ).drop(columns="_key") + + observed_counts = ( + df.groupby(region_cols + ["cluster"], sort=True) + .size() + .reset_index(name="count") + ) + global_counts = ( + df.groupby("cluster", sort=True) + .size() + .reindex(cluster_order, fill_value=0) + .reset_index(name="global_count") + ) + global_total = int(len(df)) + global_counts["global_total"] = global_total + global_counts["global_fraction"] = ( + global_counts["global_count"] / global_total if global_total > 0 else 0.0 + ) + + summary = region_grid.merge(observed_counts, on=region_cols + ["cluster"], how="left") + summary["count"] = summary["count"].fillna(0).astype(int) + summary = summary.merge(region_totals, on=region_cols, how="left") + summary = summary.merge(global_counts, on="cluster", how="left") + summary["fraction"] = summary["count"] / summary["total_reads"] + + cluster_count = max(len(cluster_order), 1) + if prior_count == 0: + with np.errstate(divide="ignore", invalid="ignore"): + summary["log2_enrichment"] = np.log2( + (summary["count"] / summary["total_reads"]) + / (summary["global_count"] / summary["global_total"]) + ) + else: + region_shrunk = (summary["count"] + prior_count) / ( + summary["total_reads"] + (prior_count * cluster_count) + ) + global_shrunk = (summary["global_count"] + prior_count) / ( + summary["global_total"] + (prior_count * cluster_count) + ) + summary["log2_enrichment"] = np.log2(region_shrunk / global_shrunk) + + summary["p_value"] = [ + _binomial_greater_tail(int(count), int(total), float(prob)) + for count, total, prob in zip( + summary["count"], + summary["total_reads"], + summary["global_fraction"].fillna(0.0), + ) + ] + summary["q_value"] = _adjust_p_values_bh(summary["p_value"]) + summary = summary.sort_values(region_cols + ["cluster"]).reset_index(drop=True) + return summary[columns] + + def summarize_read_clusters_by_region( metadata: Sequence[dict[str, Any]], labels: Sequence[int], @@ -2166,32 +3563,31 @@ def summarize_read_clusters_by_region( if len(metadata) != len(labels): raise ValueError("metadata and labels must have the same length.") - - def region_key(meta: dict[str, Any]) -> tuple[Any, Any, Any, Any]: - strand = meta.get("region_strand") if include_strand else None - return ( - meta.get("chromosome"), - meta.get("region_start"), - meta.get("region_end"), - strand if strand in {"+", "-"} else ".", + summary = summarize_read_cluster_region_associations( + metadata, + labels, + include_strand=include_strand, + ) + if summary.empty: + return pd.DataFrame( + columns=[ + "chrom", + "start", + "end", + "strand", + "total_reads", + "dominant_cluster", + "dominant_fraction", + "entropy", + ] ) - rows = [] - for meta, label in zip(metadata, labels): - key = region_key(meta) - rows.append((*key, label)) - - df = pd.DataFrame(rows, columns=["chrom", "start", "end", "strand", "cluster"]) - if df.empty: - return df - - counts = df.groupby(["chrom", "start", "end", "strand", "cluster"]).size() - counts = counts.reset_index(name="count") - pivot = counts.pivot_table( + pivot = summary.pivot_table( index=["chrom", "start", "end", "strand"], columns="cluster", values="count", fill_value=0, + aggfunc="sum", ) pivot["total_reads"] = pivot.sum(axis=1) @@ -2219,6 +3615,7 @@ def _dominance_and_entropy(row: pd.Series) -> tuple[int, float, float]: __all__ = [ "cluster_features", "read_mod_fraction_table", + "merge_read_window_results", "extract_read_windows", "build_multimotif_read_windows", "read_window_feature_matrix", @@ -2229,9 +3626,11 @@ def _dominance_and_entropy(row: pd.Series) -> tuple[int, float, float]: "plot_region_cluster_profiles", "export_region_clusters_to_bed", "summarize_region_cluster_annotations", + "summarize_read_cluster_region_associations", "summarize_read_clusters_by_region", "plot_cluster_karyotype", "plot_classification_profiles", + "plot_region_classification_profiles", "plot_confusion_matrices", "sample_rows", "cluster_label_mapping", diff --git a/dimelo/dmr.py b/dimelo/dmr.py new file mode 100644 index 0000000..9de4bd7 --- /dev/null +++ b/dimelo/dmr.py @@ -0,0 +1,375 @@ +from __future__ import annotations + +import subprocess +from pathlib import Path +from typing import Any, Iterable, Sequence + +import pandas as pd + +from . import run_modkit, utils +from .models import ModkitDMRMultiResult, ModkitDMRPairResult + + +def _coerce_path(value: str | Path) -> Path: + return Path(value).expanduser().resolve() + + +def _coerce_sample_items( + samples: dict[str, str | Path] | Iterable[tuple[str, str | Path]], +) -> list[tuple[str, Path]]: + if isinstance(samples, dict): + items = [(str(name), _coerce_path(path)) for name, path in samples.items()] + else: + items = [(str(name), _coerce_path(path)) for name, path in samples] + if len(items) < 2: + raise ValueError("modkit dmr multi requires at least two samples.") + seen_names: set[str] = set() + for name, path in items: + if len(name) == 0: + raise ValueError("Sample names for modkit dmr multi cannot be empty.") + if name in seen_names: + # modkit supports duplicate names (combining), but keep workflow strict by default. + raise ValueError(f"Duplicate sample name for modkit dmr multi: {name!r}") + seen_names.add(name) + if not path.exists(): + raise FileNotFoundError(f"Sample bedMethyl file does not exist: {path}") + return items + + +def _bed_table_from_path(path: Path) -> pd.DataFrame: + if not path.exists(): + raise FileNotFoundError(f"Expected modkit output file not found: {path}") + if path.stat().st_size == 0: + return pd.DataFrame() + + with path.open("r", encoding="utf-8", errors="replace") as handle: + first_line = handle.readline().strip() + + if first_line.startswith("#"): + columns = first_line.lstrip("#").split("\t") + return pd.read_csv(path, sep="\t", comment="#", header=None, names=columns) + return pd.read_csv(path, sep="\t", header=None) + + +def _select_high_confidence_sites( + sites_table: pd.DataFrame, + *, + pvalue_max: float = 0.01, + abs_effect_size_min: float = 0.1, + min_total_coverage: int | None = None, +) -> pd.DataFrame: + if sites_table.empty: + return sites_table.copy() + + out = sites_table.copy() + mask = pd.Series(True, index=out.index) + + pvalue_col = "map_pvalue" if "map_pvalue" in out.columns else None + if pvalue_col is not None: + pvals = pd.to_numeric(out[pvalue_col], errors="coerce") + mask &= pvals <= float(pvalue_max) + + effect_col = "effect_size" if "effect_size" in out.columns else None + if effect_col is not None: + effects = pd.to_numeric(out[effect_col], errors="coerce") + mask &= effects.abs() >= float(abs_effect_size_min) + elif "score" in out.columns: + scores = pd.to_numeric(out["score"], errors="coerce") + mask &= scores.abs() >= float(abs_effect_size_min) + + if min_total_coverage is not None: + coverage_col = None + for candidate in ("a_total", "b_total", "num_sites"): + if candidate in out.columns: + coverage_col = candidate + break + if coverage_col is not None: + coverage = pd.to_numeric(out[coverage_col], errors="coerce") + mask &= coverage >= int(min_total_coverage) + + return out.loc[mask].reset_index(drop=True) + + +def _append_if_value(command: list[str], flag: str, value: Any) -> None: + if value is None: + return + command.extend([flag, str(value)]) + + +def run_dmr_pair( + *, + control_bed_methyl: str | Path, + experiment_bed_methyl: str | Path, + ref_genome: str | Path, + out_path: str | Path, + regions_bed: str | Path | None = None, + segment_path: str | Path | None = None, + bases: Sequence[str] = ("A",), + assign_codes: Sequence[str] | None = None, + min_valid_coverage: int = 0, + dmr_prior: float | None = None, + diff_stay: float | None = None, + significance_factor: float | None = None, + decay_distance: int | None = None, + max_gap_size: int | None = None, + log_transition_decay: bool = False, + fine_grained: bool = False, + prior_alpha: float | None = None, + prior_beta: float | None = None, + delta: float | None = None, + n_sample_records: int | None = None, + max_coverages: tuple[int, int] | None = None, + cap_coverages: bool = False, + missing: str | None = None, + threads: int | None = None, + io_threads: int | None = None, + batch_size: int | None = None, + interval_size: int | None = None, + header: bool = True, + force: bool = True, + suppress_progress: bool = True, + log_filepath: str | Path | None = None, + modkit_executable: str | Path | None = None, + pvalue_max: float = 0.01, + abs_effect_size_min: float = 0.1, + min_total_coverage: int | None = None, +) -> ModkitDMRPairResult: + """ + Run modkit's native pairwise DMR pipeline (including optional HMM segmentation). + + Notes: + - `regions_bed` and `segment_path` are mutually exclusive in modkit. + - When `segment_path` is set, the output includes single-site statistics plus + segmented regions from the HMM model. + """ + if regions_bed is not None and segment_path is not None: + raise ValueError( + "modkit dmr pair does not allow --regions-bed with --segment in one command. " + "Run region-level and segmented analyses as separate runs." + ) + if len(bases) == 0: + raise ValueError("run_dmr_pair requires at least one primary base in `bases`.") + + capabilities = run_modkit._ensure_modkit_available( + quiet=True, + executable=modkit_executable, + ) + executable = capabilities.executable + control_path = _coerce_path(control_bed_methyl) + experiment_path = _coerce_path(experiment_bed_methyl) + reference_path = _coerce_path(ref_genome) + output_path = _coerce_path(out_path) + region_path = None if regions_bed is None else _coerce_path(regions_bed) + segment_output_path = None if segment_path is None else _coerce_path(segment_path) + if not control_path.exists(): + raise FileNotFoundError(f"Control bedMethyl file does not exist: {control_path}") + if not experiment_path.exists(): + raise FileNotFoundError(f"Experiment bedMethyl file does not exist: {experiment_path}") + if not reference_path.exists(): + raise FileNotFoundError(f"Reference FASTA does not exist: {reference_path}") + if region_path is not None and not region_path.exists(): + raise FileNotFoundError(f"regions_bed does not exist: {region_path}") + + output_path.parent.mkdir(parents=True, exist_ok=True) + if segment_output_path is not None: + segment_output_path.parent.mkdir(parents=True, exist_ok=True) + + command: list[str] = [ + executable, + "dmr", + "pair", + "-a", + str(control_path), + "-b", + str(experiment_path), + "--ref", + str(reference_path), + "--out-path", + str(output_path), + ] + if region_path is not None: + command.extend(["--regions-bed", str(region_path)]) + if segment_output_path is not None: + command.extend(["--segment", str(segment_output_path)]) + + for base in bases: + command.extend(["--base", str(base)]) + for code in assign_codes or (): + command.extend(["--assign-code", str(code)]) + + _append_if_value(command, "--min-valid-coverage", min_valid_coverage) + _append_if_value(command, "--dmr-prior", dmr_prior) + _append_if_value(command, "--diff-stay", diff_stay) + _append_if_value(command, "--significance-factor", significance_factor) + _append_if_value(command, "--decay-distance", decay_distance) + _append_if_value(command, "--max-gap-size", max_gap_size) + _append_if_value(command, "--delta", delta) + _append_if_value(command, "--n-sample-records", n_sample_records) + _append_if_value(command, "--missing", missing) + _append_if_value(command, "--batch-size", batch_size) + _append_if_value(command, "--interval-size", interval_size) + if prior_alpha is not None or prior_beta is not None: + if prior_alpha is None or prior_beta is None: + raise ValueError("prior_alpha and prior_beta must both be provided together.") + command.extend(["--prior", str(prior_alpha), str(prior_beta)]) + if max_coverages is not None: + if len(max_coverages) != 2: + raise ValueError("max_coverages must be a 2-tuple: (control_max, experiment_max).") + command.extend(["--max-coverages", str(max_coverages[0]), str(max_coverages[1])]) + + resolved_threads = utils.cores_to_run(threads) + command.extend(["--threads", str(resolved_threads)]) + if io_threads is not None: + command.extend(["--io-threads", str(utils.cores_to_run(io_threads))]) + if log_transition_decay: + command.append("--log-transition-decay") + if fine_grained: + command.append("--fine-grained") + if cap_coverages: + command.append("--cap-coverages") + if header: + command.append("--header") + if force: + command.append("--force") + if suppress_progress: + command.append("--suppress-progress") + if log_filepath is not None: + command.extend(["--log-filepath", str(_coerce_path(log_filepath))]) + + subprocess.run(command, check=True) + + sites_table = _bed_table_from_path(output_path) + segments_table = ( + _bed_table_from_path(segment_output_path) + if segment_output_path is not None + else None + ) + high_confidence_sites = _select_high_confidence_sites( + sites_table, + pvalue_max=pvalue_max, + abs_effect_size_min=abs_effect_size_min, + min_total_coverage=min_total_coverage, + ) + + return ModkitDMRPairResult( + output_path=output_path, + segment_path=segment_output_path, + command=command, + sites=sites_table, + segments=segments_table, + high_confidence_sites=high_confidence_sites, + metadata={ + "bases": list(bases), + "regions_bed": None if region_path is None else str(region_path), + "pvalue_max": float(pvalue_max), + "abs_effect_size_min": float(abs_effect_size_min), + "min_total_coverage": min_total_coverage, + "resolved_threads": resolved_threads, + "modkit_version": capabilities.version, + "modkit_executable": executable, + }, + ) + + +def run_dmr_multi( + *, + samples: dict[str, str | Path] | Iterable[tuple[str, str | Path]], + regions_bed: str | Path, + ref_genome: str | Path, + out_dir: str | Path, + bases: Sequence[str] = ("A",), + assign_codes: Sequence[str] | None = None, + min_valid_coverage: int = 0, + missing: str | None = None, + threads: int | None = None, + io_threads: int | None = None, + prefix: str | None = None, + header: bool = True, + force: bool = True, + suppress_progress: bool = True, + log_filepath: str | Path | None = None, + modkit_executable: str | Path | None = None, +) -> ModkitDMRMultiResult: + """ + Run modkit's native multi-sample DMR workflow. + """ + if len(bases) == 0: + raise ValueError("run_dmr_multi requires at least one primary base in `bases`.") + sample_items = _coerce_sample_items(samples) + + capabilities = run_modkit._ensure_modkit_available( + quiet=True, + executable=modkit_executable, + ) + executable = capabilities.executable + region_path = _coerce_path(regions_bed) + reference_path = _coerce_path(ref_genome) + output_dir = _coerce_path(out_dir) + if not region_path.exists(): + raise FileNotFoundError(f"regions_bed does not exist: {region_path}") + if not reference_path.exists(): + raise FileNotFoundError(f"Reference FASTA does not exist: {reference_path}") + output_dir.mkdir(parents=True, exist_ok=True) + + command: list[str] = [ + executable, + "dmr", + "multi", + "--regions-bed", + str(region_path), + "--ref", + str(reference_path), + "--out-dir", + str(output_dir), + ] + for name, path in sample_items: + command.extend(["--sample", str(path), str(name)]) + for base in bases: + command.extend(["--base", str(base)]) + for code in assign_codes or (): + command.extend(["--assign-code", str(code)]) + + _append_if_value(command, "--min-valid-coverage", min_valid_coverage) + _append_if_value(command, "--missing", missing) + if prefix is not None: + command.extend(["--prefix", str(prefix)]) + + resolved_threads = utils.cores_to_run(threads) + command.extend(["--threads", str(resolved_threads)]) + if io_threads is not None: + command.extend(["--io-threads", str(utils.cores_to_run(io_threads))]) + if header: + command.append("--header") + if force: + command.append("--force") + if suppress_progress: + command.append("--suppress-progress") + if log_filepath is not None: + command.extend(["--log-filepath", str(_coerce_path(log_filepath))]) + + subprocess.run(command, check=True) + + pair_paths = sorted(output_dir.glob("*.bed")) + pair_rows: list[dict[str, Any]] = [] + for bed_path in pair_paths: + pair_rows.append( + { + "pair_file": bed_path, + "pair_name": bed_path.stem, + } + ) + pair_files = pd.DataFrame(pair_rows) + + return ModkitDMRMultiResult( + out_dir=output_dir, + command=command, + pair_files=pair_files, + metadata={ + "bases": list(bases), + "regions_bed": str(region_path), + "resolved_threads": resolved_threads, + "n_samples": len(sample_items), + "modkit_version": capabilities.version, + "modkit_executable": executable, + }, + ) diff --git a/dimelo/global_analysis.py b/dimelo/global_analysis.py index ad0c12f..2784b90 100644 --- a/dimelo/global_analysis.py +++ b/dimelo/global_analysis.py @@ -6,6 +6,7 @@ import pandas as pd import pysam +from tqdm.auto import tqdm from . import load_processed, utils from .models import GlobalAnalysisResult, SampleSpec @@ -80,7 +81,7 @@ def summarize_global_samples( rows: list[dict[str, object]] = [] - for sample in samples: + for sample in tqdm(samples, desc="Summarizing global samples", disable=quiet): if not sample.metadata or "pileup_path" not in sample.metadata: raise ValueError( f"Sample {sample.sample_id!r} is missing metadata['pileup_path'] for global_analysis mode." @@ -200,7 +201,7 @@ def build_window_summary( ] rows: list[dict[str, object]] = [] - for sample in samples: + for sample in tqdm(samples, desc="Processing tiled windows", disable=quiet): metadata = sample.metadata or {} if "pileup_path" not in metadata: raise ValueError( diff --git a/dimelo/load_processed.py b/dimelo/load_processed.py index 4e20023..5b4e83e 100644 --- a/dimelo/load_processed.py +++ b/dimelo/load_processed.py @@ -41,7 +41,6 @@ def regions_to_list( quiet: bool = True, cores: int | None = None, split_large_regions: bool = False, - executor: concurrent.futures.Executor | None = None, **kwargs, ): """ @@ -67,6 +66,7 @@ def regions_to_list( Returns: List(function_handle return objects per region) """ + executor = kwargs.pop("executor", None) regions_dict = utils.regions_dict_from_input( regions, window_size, @@ -109,7 +109,7 @@ def regions_to_list( ) process_partial = partial( - apply_loader_function_to_region_batch, + _apply_loader_function_to_region_batch, function_handle=function_handle, quiet=quiet or not split_large_regions, cores=cores_to_run @@ -163,7 +163,7 @@ def apply_loader_function_to_region(region_string, function_handle, **kwargs): return function_handle(regions=region_string, **kwargs) -def apply_loader_function_to_region_batch(region_batch, function_handle, **kwargs): +def _apply_loader_function_to_region_batch(region_batch, function_handle, **kwargs): return [function_handle(regions=region_string, **kwargs) for region_string in region_batch] @@ -464,8 +464,6 @@ def pileup_counts_from_bedmethyl( If no regions are specified, returns the sum total for the motif of interest across the entire bedmethyl file. - TODO: Consider renaming this method, e.g. counts_from_pileup - Args: bedmethyl_file: Path to bedmethyl file regions: Path to bed file specifying regions @@ -513,7 +511,7 @@ def pileup_counts_from_bedmethyl( with concurrent.futures.ProcessPoolExecutor(max_workers=cores_to_run) as executor: futures = [ executor.submit( - pileup_counts_process_chunk_batch_local, + _pileup_counts_process_chunk_batch_local, bedmethyl_file, parsed_motif, chunk_batch, @@ -571,8 +569,6 @@ def pileup_vectors_from_bedmethyl( A region must be provided because otherwise there is no way to know what vector to return. However, a region can be a whole chromosome if desired. - TODO: Consider renaming this method, e.g. vectors_from_pileup - Args: bedmethyl_file: Path to bedmethyl file regions: Path to bed file specifying centered equal-length regions @@ -647,7 +643,7 @@ def pileup_vectors_from_bedmethyl( with concurrent.futures.ProcessPoolExecutor(max_workers=cores_to_run) as executor: futures = [ executor.submit( - pileup_vectors_process_chunk_batch, + _pileup_vectors_process_chunk_batch, bedmethyl_file, parsed_motif, chunk_batch, @@ -690,58 +686,6 @@ def pileup_vectors_from_bedmethyl( return modified_base_counts, valid_base_counts -def counts_from_pileup( - bedmethyl_file: str | Path, - motif: str, - regions: str | Path | list[str | Path], - window_size: int | None = None, - single_strand: bool = False, - quiet: bool = False, - cores: int | None = None, - chunk_size: int = DEFAULT_CHUNK_SIZE, -) -> tuple[int, int]: - """ - Preferred alias for `pileup_counts_from_bedmethyl`. - """ - return pileup_counts_from_bedmethyl( - bedmethyl_file=bedmethyl_file, - motif=motif, - regions=regions, - window_size=window_size, - single_strand=single_strand, - quiet=quiet, - cores=cores, - chunk_size=chunk_size, - ) - - -def vectors_from_pileup( - bedmethyl_file: str | Path, - motif: str, - regions: str | Path | list[str | Path], - window_size: int | None = None, - single_strand: bool = False, - regions_5to3prime: bool = False, - quiet: bool = False, - cores: int | None = None, - chunk_size: int = DEFAULT_CHUNK_SIZE, -) -> tuple[np.ndarray, np.ndarray]: - """ - Preferred alias for `pileup_vectors_from_bedmethyl`. - """ - return pileup_vectors_from_bedmethyl( - bedmethyl_file=bedmethyl_file, - motif=motif, - regions=regions, - window_size=window_size, - single_strand=single_strand, - regions_5to3prime=regions_5to3prime, - quiet=quiet, - cores=cores, - chunk_size=chunk_size, - ) - - def counts_from_fake(*args, **kwargs) -> tuple[int, int]: """ Test helper function. @@ -783,7 +727,7 @@ def pileup_vectors_process_chunk( single_strand, regions_5to3prime, ) -> None: - pileup_vectors_process_chunk_batch( + _pileup_vectors_process_chunk_batch( bedmethyl_file=bedmethyl_file, parsed_motif=parsed_motif, chunk_batch=[chunk], @@ -850,7 +794,7 @@ def _pileup_vectors_local_contribution( return subregion_offset, valid_base_subregion, modified_base_subregion -def pileup_vectors_process_chunk_batch( +def _pileup_vectors_process_chunk_batch( bedmethyl_file, parsed_motif, chunk_batch, @@ -907,7 +851,7 @@ def pileup_counts_process_chunk( lock, single_strand, ) -> None: - modified_subregion_counts, valid_subregion_counts = pileup_counts_process_chunk_batch_local( + modified_subregion_counts, valid_subregion_counts = _pileup_counts_process_chunk_batch_local( bedmethyl_file=bedmethyl_file, parsed_motif=parsed_motif, chunk_batch=[chunk], @@ -924,7 +868,7 @@ def pileup_counts_process_chunk( existing_modified.close() -def pileup_counts_process_chunk_batch_local( +def _pileup_counts_process_chunk_batch_local( bedmethyl_file, parsed_motif, chunk_batch, @@ -1123,8 +1067,9 @@ def read_vectors_from_hdf5( if "threshold" in h5: # we are looking at an .h5 file with the new, much better compressed format that does # not know the data type intrinsically for mod and val vectors, so we must check + metadata_datasets = {"threshold", "threshold_by_motif_json"} readwise_datasets = [ - dataset for dataset in datasets if dataset not in ["threshold"] + dataset for dataset in datasets if dataset not in metadata_datasets ] compressed_binary_datasets = ["mod_vector", "val_vector"] threshold_applied_to_h5 = h5["threshold"][()] diff --git a/dimelo/models.py b/dimelo/models.py index 971abb7..ccb0347 100644 --- a/dimelo/models.py +++ b/dimelo/models.py @@ -324,6 +324,62 @@ def __post_init__(self) -> None: ) +@dataclass +class ChipAtlasEnrichmentResult: + request_id: str + status: str + results: pd.DataFrame | None + query: dict[str, Any] = field(default_factory=dict) + status_history: list[dict[str, Any]] = field(default_factory=list) + submit_url: str | None = None + status_url: str | None = None + result_url: str | None = None + metadata: dict[str, Any] = field(default_factory=dict) + + def __post_init__(self) -> None: + if not self.request_id: + raise ValueError("ChipAtlasEnrichmentResult.request_id cannot be empty.") + if not self.status: + raise ValueError("ChipAtlasEnrichmentResult.status cannot be empty.") + if self.query is None: + raise ValueError("ChipAtlasEnrichmentResult.query cannot be None.") + if self.status_history is None: + raise ValueError("ChipAtlasEnrichmentResult.status_history cannot be None.") + if self.metadata is None: + raise ValueError("ChipAtlasEnrichmentResult.metadata cannot be None.") + + +@dataclass +class UniBindJobResult: + job_id: str + status: str + job_url: str + endpoint_url: str + results_url: str | None = None + download_urls: list[str] = field(default_factory=list) + query: dict[str, Any] = field(default_factory=dict) + status_history: list[dict[str, Any]] = field(default_factory=list) + metadata: dict[str, Any] = field(default_factory=dict) + + def __post_init__(self) -> None: + if not self.job_id: + raise ValueError("UniBindJobResult.job_id cannot be empty.") + if not self.status: + raise ValueError("UniBindJobResult.status cannot be empty.") + if not self.job_url: + raise ValueError("UniBindJobResult.job_url cannot be empty.") + if not self.endpoint_url: + raise ValueError("UniBindJobResult.endpoint_url cannot be empty.") + if self.download_urls is None: + raise ValueError("UniBindJobResult.download_urls cannot be None.") + if self.query is None: + raise ValueError("UniBindJobResult.query cannot be None.") + if self.status_history is None: + raise ValueError("UniBindJobResult.status_history cannot be None.") + if self.metadata is None: + raise ValueError("UniBindJobResult.metadata cannot be None.") + + @dataclass class CohortSpec: cohort_id: str @@ -340,3 +396,44 @@ class BatchJob: cohorts: list[CohortSpec] artifact_policy: str = "prefer_cached" metadata: dict[str, Any] | None = None + + +@dataclass +class ModkitDMRPairResult: + output_path: Path + segment_path: Path | None + command: list[str] + sites: pd.DataFrame + segments: pd.DataFrame | None + high_confidence_sites: pd.DataFrame + metadata: dict[str, Any] = field(default_factory=dict) + + def __post_init__(self) -> None: + if self.output_path is None: + raise ValueError("ModkitDMRPairResult.output_path cannot be None.") + if self.command is None: + raise ValueError("ModkitDMRPairResult.command cannot be None.") + if self.sites is None: + raise ValueError("ModkitDMRPairResult.sites cannot be None.") + if self.high_confidence_sites is None: + raise ValueError("ModkitDMRPairResult.high_confidence_sites cannot be None.") + if self.metadata is None: + raise ValueError("ModkitDMRPairResult.metadata cannot be None.") + + +@dataclass +class ModkitDMRMultiResult: + out_dir: Path + command: list[str] + pair_files: pd.DataFrame + metadata: dict[str, Any] = field(default_factory=dict) + + def __post_init__(self) -> None: + if self.out_dir is None: + raise ValueError("ModkitDMRMultiResult.out_dir cannot be None.") + if self.command is None: + raise ValueError("ModkitDMRMultiResult.command cannot be None.") + if self.pair_files is None: + raise ValueError("ModkitDMRMultiResult.pair_files cannot be None.") + if self.metadata is None: + raise ValueError("ModkitDMRMultiResult.metadata cannot be None.") diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index 5dd391b..c3a8b73 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -1,6 +1,7 @@ import csv import gzip import itertools +import json import multiprocessing import subprocess from collections import defaultdict @@ -24,6 +25,194 @@ # Specifies how many reads to check for the base modifications of interest. NUM_READS_TO_CHECK = 100 +ThresholdInput = int | float | dict[str, int | float] | None + + +def _unique_preserve_order(items: list[str]) -> list[str]: + seen: set[str] = set() + ordered: list[str] = [] + for item in items: + if item in seen: + continue + seen.add(item) + ordered.append(item) + return ordered + + +def _build_pileup_targeting_command_list( + motifs: list[str], + capabilities: run_modkit.ModkitCapabilities, +) -> list[str]: + # modkit 0.6.x requires --modified-bases. In some environments capability + # detection can be stale during in-session binary upgrades, so treat version + # 0.6+ as requiring modified-bases even if the help-derived flag is false. + requires_modified_bases = capabilities.supports_modified_bases or ( + capabilities.version_tuple is not None + and len(capabilities.version_tuple) >= 2 + and (capabilities.version_tuple[0], capabilities.version_tuple[1]) >= (0, 6) + ) + + motif_command_list: list[str] = [] + modified_bases: list[str] = [] + include_cpg = False + motif_pairs_seen: set[tuple[str, int]] = set() + + for motif in motifs: + parsed_motif = utils.ParsedMotif(motif) + if requires_modified_bases: + modified_bases.extend( + f"{parsed_motif.modified_base}:{mod_code}" + for mod_code in parsed_motif.mod_codes + ) + + if parsed_motif.motif_seq == "CG" and parsed_motif.modified_pos == 0: + include_cpg = True + continue + + if ( + requires_modified_bases + and len(parsed_motif.motif_seq) == 1 + and parsed_motif.modified_pos == 0 + ): + continue + + key = (parsed_motif.motif_seq, parsed_motif.modified_pos) + if key in motif_pairs_seen: + continue + motif_pairs_seen.add(key) + motif_command_list.extend( + ["--motif", parsed_motif.motif_seq, str(parsed_motif.modified_pos)] + ) + + modified_bases_command_list: list[str] = [] + if requires_modified_bases: + for modified_base in _unique_preserve_order(modified_bases): + modified_bases_command_list.extend(["--modified-bases", modified_base]) + if len(modified_bases_command_list) == 0: + raise ValueError( + "No mod codes were resolved from motifs; cannot build required " + "--modified-bases arguments for modkit pileup. Pass motifs with " + "explicit mod codes (for example 'A,0,a' or 'CG,0,m')." + ) + + cpg_command_list = ["--cpg"] if include_cpg else [] + return modified_bases_command_list + cpg_command_list + motif_command_list + + +def _build_extract_targeting_command_list( + parsed_motif: utils.ParsedMotif, +) -> list[str]: + if parsed_motif.motif_seq == "CG" and parsed_motif.modified_pos == 0: + return ["--cpg"] + return ["--motif", parsed_motif.motif_seq, str(parsed_motif.modified_pos)] + + +def _build_mod_threshold_command_list( + motifs: list[str], + motif_thresholds: dict[str, float], + capabilities: run_modkit.ModkitCapabilities, +) -> list[str]: + if capabilities.supports_mod_threshold: + threshold_flag = "--mod-threshold" + elif capabilities.supports_mod_thresholds: + threshold_flag = "--mod-thresholds" + else: + threshold_flag = "--mod-threshold" + + mod_code_thresholds: dict[str, float] = {} + for motif in motifs: + parsed_motif = utils.ParsedMotif(motif) + threshold_for_motif = motif_thresholds[motif] + for mod_code in parsed_motif.mod_codes: + existing_threshold = mod_code_thresholds.get(mod_code) + if ( + existing_threshold is not None + and abs(existing_threshold - threshold_for_motif) > 1e-12 + ): + raise ValueError( + "Cannot apply different thresholds to motifs that share mod code " + f"{mod_code!r}. Received both {existing_threshold} and {threshold_for_motif}." + ) + mod_code_thresholds[mod_code] = threshold_for_motif + + command: list[str] = [] + for mod_code in _unique_preserve_order(list(mod_code_thresholds.keys())): + command.extend([threshold_flag, f"{mod_code}:{mod_code_thresholds[mod_code]}"]) + return command + + +def _build_extract_command_prefix( + input_file: Path, + output_txt: Path, + capabilities: run_modkit.ModkitCapabilities, +) -> list[str | Path]: + if capabilities.supports_extract_subcommands: + return [capabilities.executable, "extract", "full", input_file, output_txt] + return [capabilities.executable, "extract", input_file, output_txt] + + +def _build_extract_reference_command_list( + ref_genome: Path, + capabilities: run_modkit.ModkitCapabilities, +) -> list[str | Path]: + if capabilities.supports_extract_subcommands: + if capabilities.extract_supports_reference_long: + return ["--reference", ref_genome] + if capabilities.extract_supports_reference_short: + return ["--ref", ref_genome] + return [] + if capabilities.extract_supports_reference_short: + return ["--ref", ref_genome] + if capabilities.extract_supports_reference_long: + return ["--reference", ref_genome] + return ["--ref", ref_genome] + + +def _build_implicit_tag_command_list( + capabilities: run_modkit.ModkitCapabilities, +) -> list[str]: + if capabilities.supports_force_allow_implicit: + return ["--force-allow-implicit"] + return [] + + +def _canonical_motif_key(motif: str) -> str: + parsed = utils.ParsedMotif(motif) + return f"{parsed.motif_seq},{parsed.modified_pos}" + + +def _resolve_motif_thresholds( + motifs: list[str], + thresh: ThresholdInput, + quiet: bool, +) -> dict[str, float] | None: + if thresh is None: + return None + + if isinstance(thresh, (int, float)): + adjusted = utils.adjust_threshold(float(thresh), quiet=quiet) + return {motif: adjusted for motif in motifs} + + if not isinstance(thresh, dict): + raise TypeError( + "thresh must be None, a number, or a dict mapping motif keys to thresholds." + ) + + resolved: dict[str, float] = {} + for motif in motifs: + canonical_key = _canonical_motif_key(motif) + threshold_value = None + for key in (motif, canonical_key, "default", "*"): + if key in thresh: + threshold_value = thresh[key] + break + if threshold_value is None: + raise ValueError( + f"Missing threshold for motif {motif!r}. Provide an exact key, canonical key " + f"{canonical_key!r}, or a default key ('default' or '*')." + ) + resolved[motif] = utils.adjust_threshold(float(threshold_value), quiet=quiet) + return resolved def _threads_command_list(cores: int | None, quiet: bool) -> list[str]: @@ -94,13 +283,14 @@ def pileup( output_directory: str | Path | None = None, regions: str | Path | list[str | Path] | None = None, motifs: list = ["A,0", "CG,0"], - thresh: float | None = None, + thresh: ThresholdInput = None, window_size: int | None = None, cores: int | None = None, log: bool = False, cleanup: bool = True, quiet: bool = False, override_checks: bool = False, + modkit_executable: str | Path | None = None, ) -> tuple[Path, Path]: """ Takes a bam file containing long read sequencing data aligned @@ -147,9 +337,12 @@ def pileup( The basemods are each specified as {sequence_motif},{position_of_modification}. For example, a methylated adenine is specified as 'A,0' and CpG methylation is specified as 'CG,0'. - thresh: float point number specifying the base modification probability threshold - used to delineate modificaton calls as True or False. When set to None, modkit - will select its own threshold automatically based on the data. + thresh: base modification threshold specification. Accepted forms are: + * None: modkit infers thresholds from data + * float/int: one threshold for all motifs + * dict: motif-specific thresholds keyed by exact motif string + (e.g. ``{"A,0": 0.7, "CG,0": 0.8}``), canonical motif key, or + ``default``/``*`` fallback. window_size: an integer specifying a window around the center of each bed_file region. If set to None, the bed_file is used unmodified. If set to a non-zero positive integer, the bed_file regions are replaced by new regions with that @@ -162,6 +355,9 @@ def pileup( outputs. The final processed files are not human-readable, whereas the intermediate outputs are. However, intermediate outputs can also be quite large. override_checks: convert errors from input checking into warnings if True + modkit_executable: optional executable name or path to a specific modkit + binary. If None, dimelo resolves modkit from PATH (or + DIMELO_MODKIT_EXECUTABLE when set). Returns: Path object pointing to the compressed and indexed .bed.gz bedmethyl file, ready @@ -171,7 +367,10 @@ def pileup( """ ## Verify and prepare inputs and outputs - run_modkit.ensure_modkit_available(quiet=quiet) + capabilities = run_modkit._ensure_modkit_available( + quiet=quiet, + executable=modkit_executable, + ) input_file, ref_genome, output_directory = utils.sanitize_path_args( input_file, ref_genome, output_directory @@ -195,7 +394,7 @@ def pileup( prep_output_directory( output_directory=output_directory, output_name=output_name, - default_directory=input_file.parent, + input_file=input_file.parent, output_file_names=[ "pileup.bed", "pileup.sorted.bed", @@ -213,25 +412,12 @@ def pileup( window_size, ) - motif_command_list = [] - if len(motifs) > 0: - for motif in motifs: - parsed_motif = utils.ParsedMotif(motif) - motif_command_present = False - for a, b in zip(motif_command_list, motif_command_list[1:]): - if a == parsed_motif.motif_seq and b == str(parsed_motif.modified_pos): - # This motif is already going to be processed; we want to skip adding it a second - # time because modkit does not like duplicate motifs. - # It's actually ok if it's a different mod code in the two cases because the pileup - # operation, under the hood, keeps all mod codes. Filtering is only done when loading. - motif_command_present = True - break - if not motif_command_present: - motif_command_list.append("--motif") - motif_command_list.append(parsed_motif.motif_seq) - motif_command_list.append(str(parsed_motif.modified_pos)) - else: + if len(motifs) == 0: raise ValueError("Error: no motifs specified. Nothing to process.") + motif_command_list = _build_pileup_targeting_command_list( + motifs=motifs, + capabilities=capabilities, + ) if log: if not quiet: @@ -243,34 +429,38 @@ def pileup( cores_command_list = _threads_command_list(cores=cores, quiet=quiet) mod_thresh_command_list: list[str] = [] - if thresh is None: + motif_thresholds = _resolve_motif_thresholds( + motifs=motifs, + thresh=thresh, + quiet=quiet, + ) + if motif_thresholds is None: if not quiet: print( "No base modification threshold provided. Using adaptive threshold selection via modkit." ) else: - adjusted_threshold = utils.adjust_threshold(thresh, quiet=quiet) - if adjusted_threshold < 0.5 and not quiet: + if any(value < 0.5 for value in motif_thresholds.values()) and not quiet: print( f"WARNING: thresh {thresh} is very low and may lead to unexpected behavior. Typical thresholds are at least 0.5 or 128." ) - for motif in motifs: - parsed_motif = utils.ParsedMotif(motif) - for mod_code in parsed_motif.mod_codes: - mod_thresh_command_list = mod_thresh_command_list + [ - "--mod-thresholds", - f"{mod_code}:{adjusted_threshold}", - ] + mod_thresh_command_list = _build_mod_threshold_command_list( + motifs=motifs, + motif_thresholds=motif_thresholds, + capabilities=capabilities, + ) ref_genome_command_list = ["--ref", ref_genome] filter_command_list = ["--filter-threshold", "0"] + implicit_tag_command_list = _build_implicit_tag_command_list(capabilities) pileup_command_list = ( - ["modkit", "pileup", input_file, output_bedmethyl] + [capabilities.executable, "pileup", input_file, output_bedmethyl] + region_command_list + motif_command_list + ref_genome_command_list + filter_command_list + + implicit_tag_command_list + mod_thresh_command_list + cores_command_list + log_command_list @@ -315,13 +505,14 @@ def extract( output_directory: str | Path | None = None, regions: str | Path | list[str | Path] | None = None, motifs: list = ["A,0", "CG,0", "GCH,1"], - thresh: float | None = None, + thresh: ThresholdInput = None, window_size: int | None = None, cores: int | None = None, log: bool = False, cleanup: bool = True, quiet: bool = False, override_checks: bool = False, + modkit_executable: str | Path | None = None, ) -> tuple[Path, Path]: """ Takes a bam file containing long read sequencing data aligned @@ -366,9 +557,12 @@ def extract( The basemods are each specified as {sequence_motif},{position_of_modification}. For example, a methylated adenine is specified as 'A,0' and CpG methylation is specified as 'CG,0'. - thresh: float point number specifying the base modification probability threshold - used to delineate modificaton calls as True or False. When set to None, modkit - will select its own threshold automatically based on the data. + thresh: base modification threshold specification. Accepted forms are: + * None: keep raw probabilities in output vectors + * float/int: one threshold for all motifs + * dict: motif-specific thresholds keyed by exact motif string + (e.g. ``{"A,0": 0.7, "CG,0": 0.8}``), canonical motif key, or + ``default``/``*`` fallback. window_size: an integer specifying a window around the center of each bed_file region. If set to None, the bed_file is used unmodified. If set to a non-zero positive integer, the bed_file regions are replaced by new regions with that @@ -381,6 +575,9 @@ def extract( outputs. The final processed files are not human-readable, whereas the intermediate outputs are. However, intermediate outputs can also be quite large. override_checks: convert errors from input checking into warnings if True + modkit_executable: optional executable name or path to a specific modkit + binary. If None, dimelo resolves modkit from PATH (or + DIMELO_MODKIT_EXECUTABLE when set). Returns: Path object pointing to the compressed and indexed output .h5 file, ready for @@ -389,6 +586,10 @@ def extract( """ ## Verify and prepare inputs and outputs + capabilities = run_modkit._ensure_modkit_available( + quiet=quiet, + executable=modkit_executable, + ) input_file, ref_genome, output_directory = utils.sanitize_path_args( input_file, ref_genome, output_directory @@ -411,7 +612,7 @@ def extract( output_path, (output_reads_path,) = prep_output_directory( output_directory=output_directory, output_name=output_name, - default_directory=input_file.parent, + input_file=input_file.parent, output_file_names=["reads.combined_basemods.h5"], ) @@ -425,15 +626,18 @@ def extract( cores_command_list = _threads_command_list(cores=cores, quiet=quiet) - if thresh is None: + motif_thresholds = _resolve_motif_thresholds( + motifs=motifs, + thresh=thresh, + quiet=quiet, + ) + if motif_thresholds is None: if not quiet: print( "No valid base modification threshold provided. Raw probabilities will be saved." ) - adjusted_threshold = None else: - adjusted_threshold = utils.adjust_threshold(thresh, quiet=quiet) - if adjusted_threshold < 0.5 and not quiet: + if any(value < 0.5 for value in motif_thresholds.values()) and not quiet: print( f"WARNING: thresh {thresh} is very low and may lead to unexpected behavior. Typical thresholds are at least 0.5 or 128." ) @@ -449,8 +653,14 @@ def extract( else: log_command_list = [] - ref_genome_command_list = ["--ref", ref_genome] - filter_command_list = ["--filter-threshold", "0"] + ref_genome_command_list = _build_extract_reference_command_list( + ref_genome=ref_genome, + capabilities=capabilities, + ) + filter_command_list = ( + [] if capabilities.supports_extract_subcommands else ["--filter-threshold", "0"] + ) + implicit_tag_command_list = _build_implicit_tag_command_list(capabilities) # Run modkit once for each motif, because the output .txt can be ambiguous otherwise # There is no column currently to specify the motif (e.g. CG,0 vs GCH,1), only canonical @@ -460,24 +670,26 @@ def extract( for motif in motifs: # Here we prepare the motif-specific commands and delete any old .txt file because # modkit will crash otherwise - motif_command_list = [] parsed_motif = utils.ParsedMotif(motif) - motif_command_list.append("--motif") - motif_command_list.append(parsed_motif.motif_seq) - motif_command_list.append(str(parsed_motif.modified_pos)) + motif_command_list = _build_extract_targeting_command_list(parsed_motif) output_txt = Path(output_path) / (f"reads.{motif}.txt") output_txt.unlink(missing_ok=True) extract_command_list = ( - ["modkit", "extract", input_file, output_txt] + _build_extract_command_prefix( + input_file=input_file, + output_txt=output_txt, + capabilities=capabilities, + ) + region_command_list + motif_command_list + cores_command_list + log_command_list + ref_genome_command_list + filter_command_list + + implicit_tag_command_list ) run_modkit.run_with_progress_bars( @@ -502,7 +714,7 @@ def extract( output_txt, output_reads_path, motif, - adjusted_threshold, + None if motif_thresholds is None else motif_thresholds[motif], quiet=quiet, ) # Delete intermediate file @@ -761,8 +973,8 @@ def read_by_base_txt_to_hdf5( Args: input_txt: a string or Path pointing to a modkit extracted base-by-base modifications - file. This file is assumed to have been created by modkit v0.2.4, other versions may - have a different format and may not function normally. + file. This parser supports both legacy and current extract table schemas used by + modkit 0.2.4 and 0.6.x. output_h5: a string or Path pointing to a valid place to save an .h5 file. If this file already exists, it will not be cleared and will simply be appended to. motif: a string specifying a single base modification. Basemods are specified as @@ -790,14 +1002,26 @@ def read_by_base_txt_to_hdf5( num_reads = 0 with input_txt.open(newline="") as txt: reader = csv.reader(txt, delimiter="\t") + header_fields = next(reader, None) + if header_fields is None: + raise ValueError(f"modkit extract output is empty: {input_txt}") + + if "read_id" in header_fields: + first_pass_read_name_idx = header_fields.index("read_id") + elif "read_name" in header_fields: + first_pass_read_name_idx = header_fields.index("read_name") + else: + first_pass_read_name_idx = 0 + # Check file length - line_index = -1 - for line_index, fields in enumerate(reader): - if line_index > 0 and read_name != fields[0]: - read_name = fields[0] + line_index = 0 + for line_index, fields in enumerate(reader, start=1): + read_id_value = fields[first_pass_read_name_idx] + if read_name != read_id_value: + read_name = read_id_value num_reads += 1 - if line_index < 0: - raise ValueError(f"modkit extract output is empty: {input_txt}") + if line_index == 0: + raise ValueError(f"modkit extract output has no data rows: {input_txt}") num_lines = line_index txt.seek(0) @@ -808,20 +1032,59 @@ def read_by_base_txt_to_hdf5( # h5py does not appear to otherwise support vlen binary dt_vlen = h5py.vlen_dtype(np.dtype("uint8")) - ## Format threshold value and create dataset to store whether this data is thresholded (binary) or raw. - # Option 1: thresholded outputs are written as binary 0/1 vectors and the threshold dataset - # records the cutoff used. Raw-probability outputs are preserved only when thresh is None. - threshold_to_store = np.nan if thresh is None else thresh - if "threshold" in h5: - threshold_from_existing = h5["threshold"][()] - if threshold_from_existing != threshold_to_store and not ( - np.isnan(threshold_from_existing) and np.isnan(threshold_to_store) - ): - raise ValueError( - "existing threshold in output_h5 does not match provided threshold for read_by_base_txt_to_hdf5." - ) + # Threshold metadata: + # - `threshold` remains for backwards compatibility and for fast binarized/raw checks. + # - `threshold_by_motif_json` stores per-motif thresholds so different motifs can use + # different binarization cutoffs in one output file. + threshold_for_motif = None if thresh is None else float(thresh) + threshold_by_motif: dict[str, float | None] = {} + if "threshold_by_motif_json" in h5: + raw_threshold_map = h5["threshold_by_motif_json"][()] + if isinstance(raw_threshold_map, bytes): + raw_threshold_map = raw_threshold_map.decode("utf-8") + threshold_by_motif = json.loads(str(raw_threshold_map)) + elif "threshold" in h5 and "motif" in h5 and h5["motif"].shape[0] > 0: + legacy_threshold = h5["threshold"][()] + legacy_threshold_value = ( + None if np.isnan(legacy_threshold) else float(legacy_threshold) + ) + existing_motifs = np.unique(np.array(h5["motif"], dtype=str)) + threshold_by_motif = { + existing_motif: legacy_threshold_value + for existing_motif in existing_motifs + } + + threshold_by_motif[motif] = threshold_for_motif + + has_raw = any(value is None for value in threshold_by_motif.values()) + has_binary = any(value is not None for value in threshold_by_motif.values()) + if has_raw and has_binary: + raise ValueError( + "Cannot mix raw-probability and thresholded motifs in one output_h5 file." + ) + + if has_binary: + unique_thresholds = sorted( + {float(value) for value in threshold_by_motif.values() if value is not None} + ) + if len(unique_thresholds) == 1: + threshold_to_store = unique_thresholds[0] + else: + # Keep legacy `threshold` dataset non-NaN to indicate binarized vectors. + threshold_to_store = 0.0 else: - h5.create_dataset("threshold", data=threshold_to_store) + threshold_to_store = np.nan + + if "threshold" in h5: + del h5["threshold"] + h5.create_dataset("threshold", data=threshold_to_store) + + if "threshold_by_motif_json" in h5: + del h5["threshold_by_motif_json"] + h5.create_dataset( + "threshold_by_motif_json", + data=json.dumps(threshold_by_motif), + ) ## Create read metadata datasets if "read_name" in h5: @@ -979,7 +1242,28 @@ def flush_current_read() -> None: # Setting up progress bars if not in quiet mode # Skip header reader = csv.reader(txt, delimiter="\t") - next(reader) + header = next(reader) + + def _column_index(*candidates: str, fallback: int) -> int: + for candidate in candidates: + if candidate in header: + return header.index(candidate) + return fallback + + read_name_idx = _column_index("read_id", "read_name", fallback=0) + pos_in_read_idx = _column_index( + "forward_read_position", "read_position", fallback=1 + ) + pos_in_genome_idx = _column_index( + "ref_position", "reference_position", fallback=2 + ) + read_chrom_idx = _column_index("chrom", "chromosome", fallback=3) + ref_strand_idx = _column_index("ref_strand", fallback=5) + line_read_len_idx = _column_index("read_length", fallback=9) + prob_idx = _column_index("mod_qual", fallback=10) + mod_code_idx = _column_index("mod_code", fallback=11) + canonical_base_idx = _column_index("canonical_base", fallback=15) + iterator = reader if not quiet: iterator = tqdm( @@ -991,13 +1275,13 @@ def flush_current_read() -> None: # Loop through txt file for fields in iterator: - pos_in_genome = int(fields[2]) - canonical_base = fields[15] - prob = float(fields[10]) - mod_code = fields[11] - pos_in_read = int(fields[1]) - line_read_len = int(fields[9]) - line_ref_strand = fields[5] + pos_in_genome = int(fields[pos_in_genome_idx]) + canonical_base = fields[canonical_base_idx] + prob = float(fields[prob_idx]) + mod_code = fields[mod_code_idx] + pos_in_read = int(fields[pos_in_read_idx]) + line_read_len = int(fields[line_read_len_idx]) + line_ref_strand = fields[ref_strand_idx] pos_in_read_ref = _reference_oriented_read_offset( pos_in_read=pos_in_read, read_length=line_read_len, @@ -1006,13 +1290,13 @@ def flush_current_read() -> None: start_candidate = pos_in_genome - pos_in_read_ref end_candidate = start_candidate + line_read_len - if read_name != fields[0]: + if read_name != fields[read_name_idx]: flush_current_read() ## Set up for next read # Metadata - read_name = fields[0] - read_chrom = fields[3] + read_name = fields[read_name_idx] + read_chrom = fields[read_chrom_idx] ref_strand = line_ref_strand read_start = start_candidate read_end = end_candidate @@ -1048,7 +1332,7 @@ def flush_current_read() -> None: def prep_output_directory( output_directory: Path | None, output_name: str, - default_directory: Path, + input_file: Path, output_file_names: list[str], ) -> tuple[Path, list[Path]]: """ @@ -1060,7 +1344,7 @@ def prep_output_directory( directory. output_name: a string that will be used to create an output folder containing the intermediate and final outputs, along with any logs. - default_directory: default output directory when output_directory is None + input_file: default output directory when output_directory is None output_file_names: list of names of desired output files Returns: @@ -1068,7 +1352,7 @@ def prep_output_directory( * List of Paths to requested output files """ if output_directory is None: - output_directory = default_directory + output_directory = input_file print(f"No output directory provided, using input directory {output_directory}") output_path = output_directory / output_name diff --git a/dimelo/plot_depth_histogram.py b/dimelo/plot_depth_histogram.py index 9bc4b7a..27a179e 100644 --- a/dimelo/plot_depth_histogram.py +++ b/dimelo/plot_depth_histogram.py @@ -61,6 +61,7 @@ def plot_depth_histogram( one_depth_per_region=one_depth_per_region, quiet=quiet, cores=cores, + split_large_regions=split_large_regions, ) axes = make_depth_histogram_plot( @@ -96,8 +97,9 @@ def by_modification( def by_regions( mod_file_name: str | Path, - regions_list: list[str | Path | list[str | Path]], - motif: str, + regions_list: list[str | Path | list[str | Path]] | None = None, + motif: str | None = None, + regions: list[str | Path | list[str | Path]] | None = None, sample_names: list[str] | None = None, **kwargs, ) -> Axes: @@ -108,6 +110,17 @@ def by_regions( See plot_depth_histogram for details. """ + if regions is not None: + if regions_list is not None and regions_list != regions: + raise ValueError( + "Pass either regions_list or regions to by_regions, not both with different values." + ) + regions_list = regions + if regions_list is None: + raise ValueError("by_regions requires regions_list (or alias regions).") + if motif is None: + raise ValueError("by_regions requires motif.") + sample_names_for_plot = ( sample_names if sample_names is not None else [str(region) for region in regions_list] ) @@ -159,6 +172,7 @@ def get_depth_counts( one_depth_per_region: bool = False, quiet: bool = False, cores: int | None = 1, + split_large_regions: bool = False, ) -> list[np.ndarray]: """ Get the depth counts, ready for plotting. @@ -198,6 +212,7 @@ def get_depth_counts( single_strand=single_strand, quiet=quiet, cores=cores, + split_large_regions=split_large_regions, ) # places where read depth is zero are assumed to not have the motif present - this may not always be true, # but with the available information in a pileup file it's the best we can do diff --git a/dimelo/plot_depth_profile.py b/dimelo/plot_depth_profile.py index 35570be..31744bc 100644 --- a/dimelo/plot_depth_profile.py +++ b/dimelo/plot_depth_profile.py @@ -89,8 +89,9 @@ def by_modification( def by_regions( mod_file_name: str | Path, - regions_list: list[str | Path | list[str | Path]], - motif: str, + regions_list: list[str | Path | list[str | Path]] | None = None, + motif: str | None = None, + regions: list[str | Path | list[str | Path]] | None = None, sample_names: list[str] | None = None, **kwargs, ) -> Axes: @@ -101,6 +102,17 @@ def by_regions( See plot_depth_profile for details. """ + if regions is not None: + if regions_list is not None and regions_list != regions: + raise ValueError( + "Pass either regions_list or regions to by_regions, not both with different values." + ) + regions_list = regions + if regions_list is None: + raise ValueError("by_regions requires regions_list (or alias regions).") + if motif is None: + raise ValueError("by_regions requires motif.") + sample_names_for_plot = ( sample_names if sample_names is not None else [str(region) for region in regions_list] ) @@ -231,15 +243,22 @@ def make_depth_profile_plot( """ if not utils.check_len_equal(trace_vectors, sample_names): raise ValueError("Unequal number of inputs") + x_axis_label = kwargs.pop("x_label", "Position (bp)") + legend_title = kwargs.pop("legend_title", "Mod, index") + vector_len = len(trace_vectors[0]) + half = vector_len // 2 + if vector_len % 2 == 0: + indep_vector = np.arange(-half, half) + else: + indep_vector = np.arange(-half, half + 1) axes = utils.line_plot( - indep_vector=np.arange( - -len(trace_vectors[0]) // 2, - len(trace_vectors[0]) // 2 + len(trace_vectors[0]) % 2, - ), - indep_name="pos", + indep_vector=indep_vector, + indep_name="position_bp", dep_vectors=trace_vectors, dep_names=sample_names, y_label="per strand reads\nwith motif and mod info", + legend_title=legend_title, **kwargs, ) + axes.set_xlabel(x_axis_label) return axes diff --git a/dimelo/plot_enrichment.py b/dimelo/plot_enrichment.py index 4f114e2..de97973 100644 --- a/dimelo/plot_enrichment.py +++ b/dimelo/plot_enrichment.py @@ -83,8 +83,9 @@ def by_modification( def by_regions( mod_file_name: str | Path, - regions_list: list[str | Path | list[str | Path]], - motif: str, + regions_list: list[str | Path | list[str | Path]] | None = None, + motif: str | None = None, + regions: list[str | Path | list[str | Path]] | None = None, sample_names: list[str] | None = None, **kwargs, ) -> Axes: @@ -95,6 +96,17 @@ def by_regions( See plot_enrichment for details. """ + if regions is not None: + if regions_list is not None and regions_list != regions: + raise ValueError( + "Pass either regions_list or regions to by_regions, not both with different values." + ) + regions_list = regions + if regions_list is None: + raise ValueError("by_regions requires regions_list (or alias regions).") + if motif is None: + raise ValueError("by_regions requires motif.") + sample_names_for_plot = ( sample_names if sample_names is not None else [str(region) for region in regions_list] ) diff --git a/dimelo/plot_enrichment_profile.py b/dimelo/plot_enrichment_profile.py index 3c6c70c..3af421f 100644 --- a/dimelo/plot_enrichment_profile.py +++ b/dimelo/plot_enrichment_profile.py @@ -7,6 +7,13 @@ from . import load_processed, plotting, utils +def _looks_like_motif_spec(label: str) -> bool: + parts = str(label).split(",") + if len(parts) < 2: + return False + return bool(parts[0]) and parts[1].strip().isdigit() + + def _legacy_aggregate_axis_spec( *, window_size: int, @@ -204,8 +211,9 @@ def by_modification( def by_regions( mod_file_name: str | Path, - regions_list: list[str | Path | list[str | Path]], - motif: str, + regions_list: list[str | Path | list[str | Path]] | None = None, + motif: str | None = None, + regions: list[str | Path | list[str | Path]] | None = None, sample_names: list[str] | None = None, **kwargs, ) -> Axes: @@ -216,6 +224,17 @@ def by_regions( See plot_enrichment_profile for details. """ + if regions is not None: + if regions_list is not None and regions_list != regions: + raise ValueError( + "Pass either regions_list or regions to by_regions, not both with different values." + ) + regions_list = regions + if regions_list is None: + raise ValueError("by_regions requires regions_list (or alias regions).") + if motif is None: + raise ValueError("by_regions requires motif.") + sample_names_for_plot = ( sample_names if sample_names is not None else [str(region) for region in regions_list] ) @@ -358,6 +377,10 @@ def make_enrichment_profile_plot( """ if not utils.check_len_equal(trace_vectors, sample_names): raise ValueError("Unequal number of inputs") + legend_title = kwargs.pop("legend_title", None) + if legend_title is None and sample_names and all(_looks_like_motif_spec(name) for name in sample_names): + legend_title = "Modifications (motif, mod_index)" + resolved_legend_title = "variable" if legend_title is None else str(legend_title) axes = utils.line_plot( indep_vector=np.arange( offset_center - len(trace_vectors[0]) // 2, @@ -367,6 +390,7 @@ def make_enrichment_profile_plot( dep_vectors=trace_vectors, dep_names=sample_names, y_label="fraction modified bases", + legend_title=resolved_legend_title, **kwargs, ) return axes diff --git a/dimelo/plot_reads.py b/dimelo/plot_reads.py index 194303c..832fc89 100644 --- a/dimelo/plot_reads.py +++ b/dimelo/plot_reads.py @@ -57,9 +57,14 @@ def _legacy_single_read_plot_table( relative: bool, regions_5to3prime: bool, ) -> pd.DataFrame: - plot_table = pd.DataFrame({"read_name": read_names, "mod": mods, "pos": reads}).explode( - "pos" - ) + plot_table = pd.DataFrame( + { + "read_name": read_names, + "read_index": list(range(len(read_names))), + "mod": mods, + "pos": reads, + } + ).explode("pos") plot_table = plot_table.reset_index(drop=True) plot_table["anchor"] = 0.0 if relative and regions_5to3prime: @@ -100,6 +105,13 @@ def plot_reads( mod_file_name = Path(mod_file_name) # bed_file_name = Path(bed_file_name) size = kwargs.pop("s", 0.5) + legend_title = kwargs.pop("legend_title", "Mod, index") + x_axis_label = kwargs.pop("x_label", "Position (bp)") + y_axis_mode = kwargs.pop("y_axis", "read_index") + y_axis_label = kwargs.pop( + "y_label", + "Read index" if y_axis_mode == "read_index" else "Read name", + ) palette = kwargs.pop("palette", {}) @@ -135,6 +147,8 @@ def plot_reads( relative=relative, regions_5to3prime=regions_5to3prime, ) + if y_axis_mode not in plot_table.columns: + raise ValueError(f"Unsupported y_axis {y_axis_mode!r}. Use one of: {sorted(plot_table.columns)}") axis = _legacy_single_read_axis_spec( relative=relative, regions_5to3prime=regions_5to3prime, @@ -158,7 +172,7 @@ def plot_reads( axes = sns.scatterplot( data=prepared["plot_table"], x="plot_x", - y="read_name", + y=y_axis_mode, hue="mod", # palette=colors, s=size, @@ -175,7 +189,7 @@ def plot_reads( # Update legend properties. if legend is not None: - legend.set_title("Mod") + legend.set_title(legend_title) # Update marker size for all handles for handle in handles: @@ -183,7 +197,12 @@ def plot_reads( handle.set_markersize(10) # Set a larger marker size for legend # Re-apply the legend with updated marker size. - axes.legend(handles, labels, title="Mod") + axes.legend(handles, labels, title=legend_title) + + if hasattr(axes, "set_xlabel"): + axes.set_xlabel(x_axis_label) + if hasattr(axes, "set_ylabel"): + axes.set_ylabel(y_axis_label) # regions_dict may be absent for some loader paths, so guard before reading bounds. if relative and regions_dict is not None and len(regions_dict) > 0: diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 2945d9d..7fc2392 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -1459,3 +1459,377 @@ def prepare_shared_cluster_region_data( "has_condition_aggregation": aggregate_conditions, }, } + + +_READ_CLUSTER_ASSOCIATION_VALUE_MODES = {"fraction", "log2_enrichment"} +_READ_CLUSTER_ASSOCIATION_REGION_COLUMNS = ("region_id", "chrom", "chromosome", "start", "end", "strand") +_READ_CLUSTER_ASSOCIATION_LEGACY_EXCLUDE_COLUMNS = { + "count", + "fraction", + "log2_enrichment", + "total_reads", + "dominant_cluster", + "dominant_fraction", + "entropy", + "value", + "value_mode", +} + + +def _format_region_coordinate(value) -> str: + if pd.isna(value): + raise ValueError("region coordinates must not be missing.") + if isinstance(value, (np.integer, int)): + return str(int(value)) + if isinstance(value, float) and value.is_integer(): + return str(int(value)) + return str(value) + + +def _synthesize_read_cluster_region_id(table: pd.DataFrame, *, owner: str) -> pd.Series: + if "chrom" not in table.columns and "chromosome" not in table.columns: + raise ValueError( + f"{owner} requires region_id or chrom/chromosome, start, end, and strand columns." + ) + _require_columns(table, ("start", "end", "strand"), owner) + + chrom_column = "chrom" if "chrom" in table.columns else "chromosome" + if table[[chrom_column, "start", "end", "strand"]].isna().any().any(): + raise ValueError( + f"{owner} requires region_id or chrom/chromosome, start, end, and strand columns." + ) + + return table.loc[:, [chrom_column, "start", "end", "strand"]].apply( + lambda row: ( + f"{_format_region_coordinate(row.iloc[0])}:" + f"{_format_region_coordinate(row.iloc[1])}-" + f"{_format_region_coordinate(row.iloc[2])}:" + f"{_format_region_coordinate(row.iloc[3])}" + ), + axis=1, + ) + + +def _ensure_read_cluster_region_ids(table: pd.DataFrame, *, owner: str) -> pd.DataFrame: + normalized = table.copy() + if "region_id" not in normalized.columns: + normalized["region_id"] = _synthesize_read_cluster_region_id(normalized, owner=owner) + return normalized + + missing_region_ids = normalized["region_id"].isna() + if missing_region_ids.any(): + replacement_ids = _synthesize_read_cluster_region_id(normalized.loc[missing_region_ids], owner=owner) + normalized.loc[missing_region_ids, "region_id"] = replacement_ids + normalized["region_id"] = normalized["region_id"].astype(str) + return normalized + + +def _normalize_long_form_read_cluster_region_association( + table: pd.DataFrame, + *, + value_mode: str, +) -> pd.DataFrame: + _require_columns(table, ("cluster",), "association_table") + if value_mode not in _READ_CLUSTER_ASSOCIATION_VALUE_MODES: + raise ValueError("Unsupported read-cluster association value_mode.") + if value_mode not in table.columns: + raise ValueError( + f"association_table does not include the requested {value_mode} column." + ) + + normalized = _ensure_read_cluster_region_ids(table, owner="association_table") + if normalized["region_id"].isna().any(): + raise ValueError( + "association_table requires region_id or chrom/chromosome, start, end, and strand columns." + ) + + normalized = normalized.copy() + normalized["value"] = normalized[value_mode] + normalized["value_mode"] = value_mode + normalized["source_format"] = "long_form" + return normalized + + +def _infer_read_cluster_columns(table: pd.DataFrame) -> list[object]: + excluded_columns = { + column + for column in _READ_CLUSTER_ASSOCIATION_REGION_COLUMNS + if column in table.columns + } + excluded_columns.update(col for col in _READ_CLUSTER_ASSOCIATION_LEGACY_EXCLUDE_COLUMNS if col in table.columns) + cluster_columns = [column for column in table.columns if column not in excluded_columns] + if "region_id" in cluster_columns: + cluster_columns.remove("region_id") + return cluster_columns + + +def _normalize_legacy_read_cluster_region_association( + table: pd.DataFrame, + *, + value_mode: str, +) -> pd.DataFrame: + if value_mode != "fraction": + raise ValueError( + "Legacy read-cluster association tables only support value_mode='fraction'." + ) + + cluster_columns = _infer_read_cluster_columns(table) + if not cluster_columns: + raise ValueError("Could not infer cluster columns from the legacy association table.") + + normalized = _ensure_read_cluster_region_ids(table, owner="association_table") + if normalized["region_id"].isna().any(): + raise ValueError( + "association_table requires region_id or chrom/chromosome, start, end, and strand columns." + ) + + if "total_reads" not in normalized.columns: + normalized["total_reads"] = normalized.loc[:, cluster_columns].sum(axis=1) + if (normalized["total_reads"] <= 0).any(): + raise ValueError("Legacy association rows must have positive total_reads or cluster counts.") + + id_vars = [column for column in normalized.columns if column not in cluster_columns] + melted = normalized.melt( + id_vars=id_vars, + value_vars=cluster_columns, + var_name="cluster", + value_name="count", + ) + melted["fraction"] = melted["count"] / melted["total_reads"] + melted["value"] = melted["fraction"] + melted["value_mode"] = "fraction" + melted["source_format"] = "legacy_wide" + return melted + + +def _read_cluster_region_association_cluster_order(table: pd.DataFrame) -> list[object]: + return table.loc[:, "cluster"].drop_duplicates().tolist() + + +def _parse_region_id_components(region_id: object) -> tuple[str, int, int, str]: + text = str(region_id) + strand = "." + core = text + if "," in text: + candidate_core, candidate_strand = text.rsplit(",", 1) + if candidate_strand in {"+", "-", "."}: + core = candidate_core + strand = candidate_strand + if ":" not in core or "-" not in core: + return text, -1, -1, strand + chrom, coords = core.split(":", 1) + start_s, end_s = coords.split("-", 1) + try: + start = int(start_s) + end = int(end_s) + except ValueError: + start = -1 + end = -1 + return chrom, start, end, strand + + +def _region_coordinate_table_for_association(table: pd.DataFrame) -> pd.DataFrame: + regions = table.loc[:, ["region_id"]].drop_duplicates().copy() + has_chrom = "chrom" in table.columns or "chromosome" in table.columns + has_start_end = "start" in table.columns and "end" in table.columns + if has_chrom and has_start_end: + chrom_col = "chrom" if "chrom" in table.columns else "chromosome" + coords = ( + table.loc[:, ["region_id", chrom_col, "start", "end"] + (["strand"] if "strand" in table.columns else [])] + .drop_duplicates(subset=["region_id"]) + .copy() + ) + coords = coords.rename(columns={chrom_col: "chrom"}) + if "strand" not in coords.columns: + coords["strand"] = "." + coords["start"] = pd.to_numeric(coords["start"], errors="coerce").fillna(-1).astype(int) + coords["end"] = pd.to_numeric(coords["end"], errors="coerce").fillna(-1).astype(int) + return coords.loc[:, ["region_id", "chrom", "start", "end", "strand"]] + + parsed = regions["region_id"].map(_parse_region_id_components) + regions["chrom"] = parsed.map(lambda x: x[0]) + regions["start"] = parsed.map(lambda x: x[1]) + regions["end"] = parsed.map(lambda x: x[2]) + regions["strand"] = parsed.map(lambda x: x[3]) + return regions + + +def _chromosome_sort_key(chrom: object) -> tuple[int, object]: + text = str(chrom) + if text.lower().startswith("chr"): + suffix = text[3:] + if suffix.isdigit(): + return (0, int(suffix)) + if suffix in {"X", "x"}: + return (1, 23) + if suffix in {"Y", "y"}: + return (1, 24) + if suffix in {"M", "MT", "m", "mt"}: + return (1, 25) + return (2, suffix) + return (3, text) + + +def _read_cluster_region_association_region_order( + table: pd.DataFrame, + *, + region_sort: str, + strength_aggregate: str, +) -> list[object]: + if region_sort == "input": + return table.loc[:, "region_id"].drop_duplicates().tolist() + + coords = _region_coordinate_table_for_association(table) + coords = coords.copy() + coords["chrom_sort"] = coords["chrom"].map(_chromosome_sort_key) + coords = coords.sort_values(["chrom_sort", "start", "end", "region_id"], kind="stable") + + if region_sort == "genomic": + return coords["region_id"].tolist() + + if region_sort == "association_strength": + grouped = table.groupby("region_id", sort=False)["value"] + if strength_aggregate == "mean": + strength = grouped.mean() + else: + strength = grouped.max() + coords = coords.merge( + strength.rename("association_strength"), + left_on="region_id", + right_index=True, + how="left", + ) + coords = coords.sort_values( + ["association_strength", "chrom_sort", "start", "end", "region_id"], + ascending=[False, True, True, True, True], + kind="stable", + ) + return coords["region_id"].tolist() + + raise ValueError("region_sort must be 'input', 'genomic', or 'association_strength'.") + + +def prepare_read_cluster_region_association_data( + association_table: pd.DataFrame, + *, + value_mode: str = "fraction", + top_n_regions_per_cluster: int | None = 5, + region_sort: str = "input", + association_strength_aggregate: str = "max", +) -> dict[str, pd.DataFrame | dict[str, object]]: + if not isinstance(association_table, pd.DataFrame): + raise TypeError("association_table must be a pandas DataFrame.") + if value_mode not in _READ_CLUSTER_ASSOCIATION_VALUE_MODES: + raise ValueError("value_mode must be 'fraction' or 'log2_enrichment'.") + if top_n_regions_per_cluster is not None and top_n_regions_per_cluster < 0: + raise ValueError("top_n_regions_per_cluster must be non-negative.") + if region_sort not in {"input", "genomic", "association_strength"}: + raise ValueError("region_sort must be 'input', 'genomic', or 'association_strength'.") + if association_strength_aggregate not in {"max", "mean"}: + raise ValueError("association_strength_aggregate must be 'max' or 'mean'.") + + if "cluster" in association_table.columns: + normalized = _normalize_long_form_read_cluster_region_association( + association_table, + value_mode=value_mode, + ) + else: + normalized = _normalize_legacy_read_cluster_region_association( + association_table, + value_mode=value_mode, + ) + + normalized = normalized.copy() + if normalized.duplicated(["region_id", "cluster"]).any(): + raise ValueError("association_table contains duplicate region and cluster rows.") + + region_order = _read_cluster_region_association_region_order( + normalized, + region_sort=region_sort, + strength_aggregate=association_strength_aggregate, + ) + cluster_order = _read_cluster_region_association_cluster_order(normalized) + normalized["region_id"] = pd.Categorical(normalized["region_id"], categories=region_order, ordered=True) + normalized["cluster"] = pd.Categorical(normalized["cluster"], categories=cluster_order, ordered=True) + normalized = normalized.sort_values(["region_id", "cluster"], kind="stable").reset_index(drop=True) + normalized["region_id"] = normalized["region_id"].astype(str) + normalized["cluster"] = normalized["cluster"].astype(object) + + matrix_table = ( + normalized.loc[:, ["region_id", "cluster", "value"]] + .pivot(index="region_id", columns="cluster", values="value") + .reindex(index=region_order, columns=cluster_order) + .reset_index() + ) + matrix_table.columns.name = None + region_axis_table = _region_coordinate_table_for_association(normalized).copy() + region_axis_table = ( + region_axis_table.set_index("region_id") + .reindex(region_order) + .reset_index() + ) + region_axis_table["axis_index"] = np.arange(len(region_axis_table)) + chromosome_blocks: list[dict[str, object]] = [] + if not region_axis_table.empty: + grouped = region_axis_table.groupby("chrom", sort=False)["axis_index"] + for chrom, values in grouped: + chromosome_blocks.append( + { + "chrom": str(chrom), + "start_index": int(values.min()), + "end_index": int(values.max()), + "n_regions": int(values.max() - values.min() + 1), + } + ) + + top_columns = [ + column + for column in [ + "region_id", + "chrom", + "chromosome", + "start", + "end", + "strand", + "cluster", + "count", + "fraction", + "log2_enrichment", + "total_reads", + "value", + ] + if column in normalized.columns + ] + if top_n_regions_per_cluster is None or top_n_regions_per_cluster == 0: + top_regions_table = normalized.loc[:, top_columns].head(0).copy() + top_regions_table["rank"] = pd.Series(dtype="int64") + else: + top_regions_table = ( + normalized.loc[:, top_columns] + .sort_values(["cluster", "value", "region_id"], ascending=[True, False, True], kind="stable") + .groupby("cluster", as_index=False, sort=False, group_keys=False) + .head(top_n_regions_per_cluster) + .copy() + ) + top_regions_table["rank"] = top_regions_table.groupby("cluster", sort=False).cumcount() + 1 + top_regions_table = top_regions_table.sort_values(["cluster", "rank"], kind="stable").reset_index(drop=True) + + metadata = { + "plot_family": "read_cluster_region_association_heatmap", + "value_mode": value_mode, + "source_format": normalized["source_format"].iloc[0] if not normalized.empty else "long_form", + "region_order": [str(value) for value in region_order], + "cluster_order": cluster_order, + "top_n_regions_per_cluster": top_n_regions_per_cluster, + "has_top_regions_table": not top_regions_table.empty, + "region_sort": region_sort, + "association_strength_aggregate": association_strength_aggregate, + "chromosome_blocks": chromosome_blocks, + } + return { + "association_table": normalized.reset_index(drop=True), + "matrix_table": matrix_table, + "region_axis_table": region_axis_table, + "top_regions_table": top_regions_table, + "metadata": metadata, + } diff --git a/dimelo/plotting_matplotlib.py b/dimelo/plotting_matplotlib.py index 15514c5..ad9643a 100644 --- a/dimelo/plotting_matplotlib.py +++ b/dimelo/plotting_matplotlib.py @@ -1,8 +1,9 @@ from __future__ import annotations -from collections.abc import Mapping +from collections.abc import Mapping, Sequence from pathlib import Path +import numpy as np import pandas as pd @@ -635,6 +636,199 @@ def plot_shared_cluster_region_matplotlib( return fig, ax +def plot_read_cluster_region_association_heatmap_matplotlib( + payload: Mapping[str, object], + *, + ax=None, + title: str | None = None, + region_label_mode: str = "auto", + max_region_labels: int = 50, + row_annotation_column: str | None = None, + row_annotation_title: str | None = None, + row_annotation_palette: Mapping[str, str] | None = None, + group_region_labels: bool | None = None, + group_label_columns: Sequence[str] | None = None, +): + _require_payload_keys( + payload, + ("matrix_table", "metadata"), + owner="plot_read_cluster_region_association_heatmap_matplotlib", + ) + matrix_table = _require_payload_table(payload, "matrix_table") + metadata = payload.get("metadata") + if not isinstance(metadata, Mapping): + raise TypeError("plot payload key 'metadata' must be a mapping.") + + if matrix_table.empty: + fig, ax = _make_axis(ax=ax, figsize=(8, 4)) + ax.set_title(title or "Read-cluster association heatmap") + ax.set_xlabel("Cluster") + ax.set_ylabel("Region") + return fig, ax + + region_column = "region_id" if "region_id" in matrix_table.columns else matrix_table.columns[0] + cluster_columns = [column for column in matrix_table.columns if column != region_column] + fig_width = max(8.0, 4.5 + (0.75 * len(cluster_columns))) + fig_height = max(4.5, min(16.0, 2.0 + (0.10 * len(matrix_table)))) + fig, ax = _make_axis(ax=ax, figsize=(fig_width, fig_height)) + value_mode = str(metadata.get("value_mode") or "fraction") + region_axis_table = payload.get("region_axis_table") + if region_axis_table is not None and not isinstance(region_axis_table, pd.DataFrame): + raise TypeError("plot payload key 'region_axis_table' must be a pandas DataFrame when provided.") + if region_label_mode not in {"auto", "region_id", "genomic", "chromosome"}: + raise ValueError( + "region_label_mode must be 'auto', 'region_id', 'genomic', or 'chromosome'." + ) + max_region_labels = max(1, int(max_region_labels)) + + heatmap = matrix_table.loc[:, cluster_columns].copy() + image = ax.imshow( + heatmap.to_numpy(), + aspect="auto", + origin="upper", + interpolation="nearest", + ) + ax.figure.colorbar(image, ax=ax, label=value_mode.replace("_", " ").title()) + ax.set_xticks(range(len(cluster_columns))) + ax.set_xticklabels([str(value) for value in cluster_columns], rotation=45, ha="right") + + n_regions = len(matrix_table) + default_ticks = np.arange(n_regions) + default_labels = matrix_table[region_column].astype(str).tolist() + ticks = default_ticks + labels = default_labels + step = max(1, int(np.ceil(n_regions / max_region_labels))) + if step > 1: + ticks = default_ticks[::step] + labels = [default_labels[idx] for idx in ticks] + annotation_values: list[str] | None = None + + axis_table = None + if isinstance(region_axis_table, pd.DataFrame) and not region_axis_table.empty: + axis_table = region_axis_table.copy() + if {"chrom", "start", "end"}.issubset(axis_table.columns): + genomic_labels = [ + f"{chrom}:{int(start):,}-{int(end):,}" + for chrom, start, end in axis_table[["chrom", "start", "end"]].itertuples(index=False) + ] + chrom_labels = axis_table["chrom"].astype(str).tolist() + effective_mode = region_label_mode + if effective_mode == "auto": + default_region_sort = str(metadata.get("region_sort") or "input") + if default_region_sort == "genomic": + effective_mode = "chromosome" if n_regions > max_region_labels else "genomic" + else: + effective_mode = "region_id" + if effective_mode == "genomic": + labels = [genomic_labels[idx] for idx in ticks] + elif effective_mode == "chromosome": + labels = [chrom_labels[idx] for idx in ticks] + # Mark chromosome boundaries to visually group regions. + chrom_codes = pd.Categorical(axis_table["chrom"].astype(str)).codes + boundaries = np.flatnonzero(np.diff(chrom_codes)) + 1 + for boundary in boundaries: + ax.axhline(boundary - 0.5, color="white", linewidth=0.6, alpha=0.6) + elif effective_mode == "region_id": + labels = [default_labels[idx] for idx in ticks] + if row_annotation_column is not None and row_annotation_column in axis_table.columns: + annotation_values = axis_table[row_annotation_column].astype(str).tolist() + + if group_region_labels is None: + group_region_labels = ( + axis_table is not None + and region_label_mode in {"genomic", "chromosome", "auto"} + and n_regions > max_region_labels + and ( + ("chrom" in axis_table.columns) + or (row_annotation_column is not None and row_annotation_column in axis_table.columns) + ) + ) + + if axis_table is not None and group_region_labels: + requested_group_cols = list(group_label_columns or []) + if not requested_group_cols: + if row_annotation_column is not None and row_annotation_column in axis_table.columns: + requested_group_cols = [row_annotation_column, "chrom"] + elif "chrom" in axis_table.columns: + requested_group_cols = ["chrom"] + requested_group_cols = [col for col in requested_group_cols if col in axis_table.columns] + if requested_group_cols: + group_parts = axis_table.loc[:, requested_group_cols].astype(str) + group_key = group_parts.agg(" | ".join, axis=1).tolist() + boundaries = np.flatnonzero(np.array(group_key[1:]) != np.array(group_key[:-1])) + 1 + group_starts = np.concatenate(([0], boundaries)) + group_ends = np.concatenate((boundaries, [len(group_key)])) + centers = ((group_starts + group_ends - 1) / 2.0).astype(float) + group_labels = [group_key[int(start)] for start in group_starts] + # Downsample grouped labels when there are still too many. + if len(group_labels) > max_region_labels: + gstep = max(1, int(np.ceil(len(group_labels) / max_region_labels))) + centers = centers[::gstep] + group_labels = group_labels[::gstep] + ticks = centers + labels = group_labels + for boundary in boundaries: + ax.axhline(boundary - 0.5, color="white", linewidth=0.6, alpha=0.6) + + ax.set_yticks(np.asarray(ticks).tolist()) + if annotation_values is not None and not group_region_labels: + labels = [f"{labels[pos]} | {annotation_values[idx]}" for pos, idx in enumerate(ticks)] + ytick_fontsize = 8 if len(labels) <= 30 else 7 + ax.set_yticklabels(labels, fontsize=ytick_fontsize) + ax.set_xlabel("Cluster") + ax.set_ylabel("Region") + ax.set_title(title or "Read-cluster association heatmap") + + if annotation_values is not None and n_regions > 0: + from matplotlib.colors import ListedColormap + from matplotlib.patches import Patch + + ordered_annotations = _ordered_unique_values( + pd.DataFrame({"annotation": annotation_values}), + "annotation", + ) + if row_annotation_palette is None: + plt = _import_pyplot() + cmap = plt.get_cmap("tab10") + row_annotation_palette = { + value: cmap(i % 10) for i, value in enumerate(ordered_annotations) + } + annotation_colors = [row_annotation_palette.get(value, "0.6") for value in ordered_annotations] + color_lookup = {value: i for i, value in enumerate(ordered_annotations)} + color_codes = np.array([color_lookup.get(value, 0) for value in annotation_values], dtype=int) + strip_ax = ax.inset_axes([-0.07, 0.0, 0.022, 1.0], transform=ax.transAxes) + strip_ax.imshow( + color_codes.reshape(-1, 1), + aspect="auto", + origin="upper", + interpolation="nearest", + cmap=ListedColormap(annotation_colors), + vmin=0, + vmax=max(1, len(annotation_colors) - 1), + ) + strip_ax.set_xticks([]) + strip_ax.set_yticks([]) + strip_ax.set_title( + row_annotation_title or row_annotation_column, + fontsize=8, + pad=2, + ) + + legend_handles = [ + Patch(facecolor=row_annotation_palette.get(value, "0.6"), edgecolor="none", label=str(value)) + for value in ordered_annotations + ] + if legend_handles: + ax.legend( + handles=legend_handles, + title=row_annotation_title or row_annotation_column, + loc="upper left", + bbox_to_anchor=(1.01, 1.0), + frameon=False, + ) + return fig, ax + + def plot_global_analysis_summary_matplotlib( payload: Mapping[str, object], *, diff --git a/dimelo/region_analysis.py b/dimelo/region_analysis.py index 9b67e01..3290876 100644 --- a/dimelo/region_analysis.py +++ b/dimelo/region_analysis.py @@ -5,6 +5,7 @@ from typing import Sequence import numpy as np +from tqdm.auto import tqdm from . import cluster, utils from .models import SampleSpec @@ -68,6 +69,7 @@ def build_region_feature_table( matched_regions: str | Path | list[str | Path] | None, pileup_paths: dict[str, str | Path] | None = None, cores: int | None = None, + quiet: bool = True, ) -> tuple[np.ndarray, list[dict[str, object]]]: """ Build one region-level feature row per sample and matched region. @@ -125,8 +127,9 @@ def build_region_feature_table( # create process pools; fall back to the legacy per-sample path. shared_regions_executor = None try: - results = [ - _build_sample_region_features( + results = [] + for sample in tqdm(sample_list, desc="Building region features", disable=quiet): + result = _build_sample_region_features( sample=sample, motif=motifs[0], matched_regions=matched_regions, @@ -134,8 +137,7 @@ def build_region_feature_table( cores=per_sample_cores, regions_executor=shared_regions_executor, ) - for sample in sample_list - ] + results.append(result) finally: if shared_regions_executor is not None: shared_regions_executor.shutdown(wait=True, cancel_futures=False) diff --git a/dimelo/regulatory_enrichment.py b/dimelo/regulatory_enrichment.py new file mode 100644 index 0000000..7dd7969 --- /dev/null +++ b/dimelo/regulatory_enrichment.py @@ -0,0 +1,1170 @@ +from __future__ import annotations + +from dataclasses import dataclass, field +import html +import http.cookiejar +from pathlib import Path +import re +import shutil +import subprocess +import time +from typing import Any, Iterable +from urllib import error, parse, request + +from .models import UniBindJobResult + +_UNIBIND_SUPPORTED_SPECIES = ( + "arabidopsis_thaliana", + "caenorhabditis_elegans", + "danio_rerio", + "drosophila_melanogaster", + "homo_sapiens", + "mus_musculus", + "rattus_norvegicus", + "saccharomyces_cerevisiae", + "schizosaccharomyces_pombe", +) + +_SCREEN_SUPPORTED_SPECIES = { + "homo_sapiens", + "mus_musculus", +} + +_DEFAULT_SPECIES = "homo_sapiens" +_DEFAULT_TARGET_GENOME_BY_SPECIES = { + "homo_sapiens": "hg38", + "mus_musculus": "mm10", +} + +_PROVIDER_ALIASES = { + "screen": "screen", + "screen2": "screen", + "screen_2": "screen", + "screen2_0": "screen", + "screen_2_0": "screen", + "unibind": "unibind", + "unibind_2021": "unibind", + "unibind2021": "unibind", +} + +_SPECIES_ALIASES = { + "arabidopsis_thaliana": "arabidopsis_thaliana", + "arabidopsis": "arabidopsis_thaliana", + "3702": "arabidopsis_thaliana", + "caenorhabditis_elegans": "caenorhabditis_elegans", + "c_elegans": "caenorhabditis_elegans", + "celegans": "caenorhabditis_elegans", + "worm": "caenorhabditis_elegans", + "6239": "caenorhabditis_elegans", + "danio_rerio": "danio_rerio", + "zebrafish": "danio_rerio", + "7955": "danio_rerio", + "drosophila_melanogaster": "drosophila_melanogaster", + "d_melanogaster": "drosophila_melanogaster", + "fly": "drosophila_melanogaster", + "fruit_fly": "drosophila_melanogaster", + "7227": "drosophila_melanogaster", + "homo_sapiens": "homo_sapiens", + "human": "homo_sapiens", + "9606": "homo_sapiens", + "mus_musculus": "mus_musculus", + "mouse": "mus_musculus", + "10090": "mus_musculus", + "rattus_norvegicus": "rattus_norvegicus", + "rat": "rattus_norvegicus", + "10116": "rattus_norvegicus", + "saccharomyces_cerevisiae": "saccharomyces_cerevisiae", + "s_cerevisiae": "saccharomyces_cerevisiae", + "yeast": "saccharomyces_cerevisiae", + "4932": "saccharomyces_cerevisiae", + "schizosaccharomyces_pombe": "schizosaccharomyces_pombe", + "s_pombe": "schizosaccharomyces_pombe", + "4896": "schizosaccharomyces_pombe", +} + +_GENOME_SPECIES_HINTS = { + "hg38": "homo_sapiens", + "grch38": "homo_sapiens", + "hg19": "homo_sapiens", + "grch37": "homo_sapiens", + "hs1": "homo_sapiens", + "chm13": "homo_sapiens", + "t2t_chm13v2_0": "homo_sapiens", + "t2t_chm13v2": "homo_sapiens", + "mm10": "mus_musculus", + "grcm38": "mus_musculus", + "mm39": "mus_musculus", + "grcm39": "mus_musculus", +} + +_UNIBIND_TRACKHUB_URLS = { + "robust": "https://unibind.uio.no/static/data/latest/UniBind_hubs_Robust/UCSC/hub.txt", + "permissive": "https://unibind.uio.no/static/data/latest/UniBind_hubs_Permissive/UCSC/hub.txt", +} + +DEFAULT_UNIBIND_TFBS_EXTRACTION_URL = "https://unibind.uio.no/TFBS_extraction/" +DEFAULT_UNIBIND_ENRICHMENT_URL = "https://unibind.uio.no/enrichment/" + +_UNIBIND_FORM_SPECIES_CODES = { + "arabidopsis_thaliana": "3702", + "caenorhabditis_elegans": "6239", + "danio_rerio": "7955", + "drosophila_melanogaster": "7227", + "homo_sapiens": "9606", + "mus_musculus": "10090", + "rattus_norvegicus": "10116", + "saccharomyces_cerevisiae": "4932", + "schizosaccharomyces_pombe": "4896", +} +_UNIBIND_FORM_SPECIES_BY_CODE = {v: k for k, v in _UNIBIND_FORM_SPECIES_CODES.items()} +_UNIBIND_COLLECTION_ALIASES = { + "robust": "Robust", + "permissive": "Permissive", +} +_UNIBIND_ENRICHMENT_ANALYSIS_ALIASES = { + "onesetbg": "oneSetBg", + "one_set_bg": "oneSetBg", + "with_background": "oneSetBg", + "twosets": "twoSets", + "two_sets": "twoSets", + "differential": "twoSets", +} +_UNIBIND_STATUS_ALIASES = { + "queued": "queued", + "pending": "queued", + "running": "running", + "submitted": "queued", + "processing": "running", + "completed": "completed", + "finished": "completed", + "done": "completed", + "success": "completed", + "failed": "error", + "failure": "error", + "error": "error", + "cancelled": "cancelled", + "canceled": "cancelled", +} +_UNIBIND_TERMINAL_STATUSES = {"completed", "error", "cancelled"} +_UNIBIND_SUCCESS_STATUSES = {"completed"} + + +class RegulatoryEnrichmentSpecError(ValueError): + """Invalid regulatory enrichment provider configuration.""" + + +def _normalize_token(value: str) -> str: + return re.sub(r"[^a-z0-9]+", "_", value.strip().lower()).strip("_") + + +def _normalize_assembly_token(value: str) -> str: + return re.sub(r"[^a-z0-9]+", "", value.strip().lower()) + + +def normalize_species_name(species: str) -> str: + token = _normalize_token(species) + if not token: + raise RegulatoryEnrichmentSpecError("Species cannot be empty.") + canonical = _SPECIES_ALIASES.get(token, token) + if canonical not in _UNIBIND_SUPPORTED_SPECIES: + supported = ", ".join(_UNIBIND_SUPPORTED_SPECIES) + raise RegulatoryEnrichmentSpecError( + "Unsupported species for UniBind-backed workflows: " + f"{species!r}. Supported species: {supported}." + ) + return canonical + + +def _infer_species_from_genomes(*, reference_genome: str | None, target_genome: str | None) -> str | None: + for genome in (target_genome, reference_genome): + if genome is None: + continue + token = _normalize_token(str(genome)) + if token in _GENOME_SPECIES_HINTS: + return _GENOME_SPECIES_HINTS[token] + return None + + +def _normalize_provider(provider: str) -> str: + token = _normalize_token(provider) + if token not in _PROVIDER_ALIASES: + supported = ", ".join(sorted(set(_PROVIDER_ALIASES.values()))) + raise RegulatoryEnrichmentSpecError( + f"Unsupported provider {provider!r}. Supported providers: {supported}." + ) + return _PROVIDER_ALIASES[token] + + +def _unique_preserve_order(values: Iterable[str]) -> list[str]: + seen: set[str] = set() + out: list[str] = [] + for value in values: + if value in seen: + continue + seen.add(value) + out.append(value) + return out + + +def _normalize_unibind_species_code(species: str) -> str: + raw = str(species).strip() + if not raw: + raise ValueError("UniBind species cannot be empty.") + if raw in _UNIBIND_FORM_SPECIES_BY_CODE: + return raw + token = _normalize_token(raw) + if token in _UNIBIND_FORM_SPECIES_BY_CODE: + return token + canonical = normalize_species_name(raw) + return _UNIBIND_FORM_SPECIES_CODES[canonical] + + +def _normalize_unibind_collection(collection: str) -> str: + token = _normalize_token(collection) + if token not in _UNIBIND_COLLECTION_ALIASES: + allowed = ", ".join(sorted(_UNIBIND_COLLECTION_ALIASES.values())) + raise ValueError( + f"Unsupported UniBind collection {collection!r}. Supported: {allowed}." + ) + return _UNIBIND_COLLECTION_ALIASES[token] + + +def _normalize_unibind_enrichment_analysis_type(analysis_type: str) -> str: + token = _normalize_token(analysis_type) + if token not in _UNIBIND_ENRICHMENT_ANALYSIS_ALIASES: + allowed = ", ".join(sorted(set(_UNIBIND_ENRICHMENT_ANALYSIS_ALIASES.values()))) + raise ValueError( + "Unsupported UniBind enrichment analysis_type " + f"{analysis_type!r}. Supported: {allowed}." + ) + return _UNIBIND_ENRICHMENT_ANALYSIS_ALIASES[token] + + +def _normalize_unibind_status(status: str | None) -> str: + if status is None: + return "unknown" + token = _normalize_token(str(status)) + if not token: + return "unknown" + return _UNIBIND_STATUS_ALIASES.get(token, token) + + +def _regions_to_bed_bytes(regions: Any) -> bytes: + from . import chip_atlas + + text = chip_atlas._regions_to_bed_text(regions) + return text.encode("utf-8") + + +def _coerce_optional_text_file_payload( + value: str | Path | Iterable[str] | None, + *, + default_filename: str, +) -> tuple[str, bytes, str] | None: + if value is None: + return None + + filename = default_filename + if isinstance(value, Path): + payload = value.read_bytes() + filename = value.name + elif isinstance(value, str): + candidate = Path(value).expanduser() + if "\n" not in value and "\t" not in value and candidate.exists(): + payload = candidate.read_bytes() + filename = candidate.name + else: + payload = value.encode("utf-8") + else: + lines = [str(item).strip() for item in value if str(item).strip()] + payload = ("\n".join(lines) + ("\n" if lines else "")).encode("utf-8") + + if not payload: + return None + return filename, payload, "text/plain" + + +def _build_multipart_form( + *, + fields: dict[str, str], + files: dict[str, tuple[str, bytes, str]], +) -> tuple[bytes, str]: + boundary = f"----dimelo-{int(time.time() * 1000)}" + chunks: list[bytes] = [] + for key, value in fields.items(): + chunks.append(f"--{boundary}\r\n".encode("utf-8")) + chunks.append( + f'Content-Disposition: form-data; name="{key}"\r\n\r\n'.encode("utf-8") + ) + chunks.append(str(value).encode("utf-8")) + chunks.append(b"\r\n") + for key, (filename, payload, content_type) in files.items(): + chunks.append(f"--{boundary}\r\n".encode("utf-8")) + chunks.append( + ( + f'Content-Disposition: form-data; name="{key}"; ' + f'filename="{filename}"\r\n' + ).encode("utf-8") + ) + chunks.append(f"Content-Type: {content_type}\r\n\r\n".encode("utf-8")) + chunks.append(payload) + chunks.append(b"\r\n") + chunks.append(f"--{boundary}--\r\n".encode("utf-8")) + return b"".join(chunks), boundary + + +def _extract_csrf_token(page_html: str) -> str: + match = re.search( + r'name="csrfmiddlewaretoken"\s+value="([^"]+)"', + page_html, + flags=re.IGNORECASE, + ) + if match is None: + raise RuntimeError("UniBind form did not include a CSRF token.") + return html.unescape(match.group(1)) + + +def _extract_unibind_results_url(job_html: str, *, base_url: str) -> str | None: + match = re.search( + r"\s*Results URL:\s*\s*\s* str: + match = re.search( + r"\s*Job status:\s*\s*\s*([^<]+)\s*", + job_html, + flags=re.IGNORECASE, + ) + if match is None: + return "unknown" + raw = html.unescape(match.group(1)).strip() + return _normalize_unibind_status(raw) + + +def _looks_like_unibind_output_url(url: str) -> bool: + parsed = parse.urlparse(url) + path = parsed.path.lower() + if "/temp/" in path: + return True + return path.endswith( + ( + ".bed", + ".bed.gz", + ".tsv", + ".csv", + ".txt", + ".zip", + ".pdf", + ) + ) + + +def _extract_unibind_output_urls(job_html: str, *, base_url: str) -> list[str]: + links: list[str] = [] + for href in re.findall(r'href="([^"]+)"', job_html, flags=re.IGNORECASE): + resolved = parse.urljoin(base_url, html.unescape(href).strip()) + if not _looks_like_unibind_output_url(resolved): + continue + links.append(resolved) + return _unique_preserve_order(links) + + +def _extract_unibind_job_id(job_url: str) -> str: + parts = [segment for segment in parse.urlparse(job_url).path.split("/") if segment] + if not parts: + raise ValueError(f"Could not determine UniBind job id from URL: {job_url}") + return parts[-1] + + +def _submit_unibind_form( + *, + endpoint_url: str, + fields: dict[str, str], + files: dict[str, tuple[str, bytes, str]], + timeout_seconds: float, + query: dict[str, Any], +) -> UniBindJobResult: + cookie_jar = http.cookiejar.CookieJar() + opener = request.build_opener(request.HTTPCookieProcessor(cookie_jar)) + + get_req = request.Request( + endpoint_url, + method="GET", + headers={"User-Agent": "dimelo-toolkit/1.0"}, + ) + with opener.open(get_req, timeout=timeout_seconds) as response: + landing_html = response.read().decode("utf-8", errors="replace") + + csrf_token = _extract_csrf_token(landing_html) + fields_with_csrf = dict(fields) + fields_with_csrf["csrfmiddlewaretoken"] = csrf_token + body, boundary = _build_multipart_form(fields=fields_with_csrf, files=files) + + post_req = request.Request( + endpoint_url, + data=body, + method="POST", + headers={ + "User-Agent": "dimelo-toolkit/1.0", + "Content-Type": f"multipart/form-data; boundary={boundary}", + "Referer": endpoint_url, + }, + ) + with opener.open(post_req, timeout=timeout_seconds) as response: + final_url = str(response.geturl()) + job_html = response.read().decode("utf-8", errors="replace") + + results_url = _extract_unibind_results_url(job_html, base_url=final_url) + job_url = results_url or final_url + status = _extract_unibind_job_status(job_html) + output_urls = _extract_unibind_output_urls(job_html, base_url=job_url) + job_id = _extract_unibind_job_id(job_url) + + return UniBindJobResult( + job_id=job_id, + status=status, + job_url=job_url, + endpoint_url=endpoint_url, + results_url=results_url, + download_urls=output_urls, + query=query, + status_history=[ + { + "status": status, + "timestamp": time.time(), + "stage": "submitted", + "url": job_url, + } + ], + metadata={}, + ) + + +def _fetch_bytes(url: str, *, timeout_seconds: float = 60.0) -> bytes: + req = request.Request(url, headers={"User-Agent": "dimelo-toolkit/1.0"}) + try: + with request.urlopen(req, timeout=timeout_seconds) as response: + return response.read() + except error.HTTPError as exc: + raise RuntimeError( + f"Track hub request failed with HTTP {exc.code}: {url}" + ) from exc + except error.URLError as exc: + raise RuntimeError(f"Track hub request failed for {url}: {exc.reason}") from exc + + +def _fetch_text(url: str, *, timeout_seconds: float = 60.0) -> str: + return _fetch_bytes(url, timeout_seconds=timeout_seconds).decode("utf-8", errors="replace") + + +def _parse_kv_blocks(text: str) -> list[dict[str, str]]: + blocks: list[dict[str, str]] = [] + current: dict[str, str] = {} + for raw in text.splitlines(): + line = raw.strip() + if not line or line.startswith("#"): + if current: + blocks.append(current) + current = {} + continue + parts = line.split(None, 1) + key = parts[0] + value = parts[1].strip() if len(parts) > 1 else "" + current[key] = value + if current: + blocks.append(current) + return blocks + + +def _load_trackdb_stanzas( + url: str, + *, + timeout_seconds: float = 60.0, + _visited: set[str] | None = None, +) -> list[dict[str, str]]: + visited = _visited if _visited is not None else set() + if url in visited: + return [] + visited.add(url) + + stanzas: list[dict[str, str]] = [] + current: dict[str, str] = {} + text = _fetch_text(url, timeout_seconds=timeout_seconds) + + def flush_current() -> None: + nonlocal current + if current: + stanzas.append(current) + current = {} + + for raw in text.splitlines(): + line = raw.strip() + if not line or line.startswith("#"): + flush_current() + continue + + if line.lower().startswith("include "): + flush_current() + include_ref = line.split(None, 1)[1].strip().split()[0] + include_url = parse.urljoin(url, include_ref) + stanzas.extend( + _load_trackdb_stanzas( + include_url, + timeout_seconds=timeout_seconds, + _visited=visited, + ) + ) + continue + + parts = line.split(None, 1) + key = parts[0] + value = parts[1].strip() if len(parts) > 1 else "" + current[key] = value + + flush_current() + return stanzas + + +def _select_trackdb_url( + *, + hub_url: str, + assembly: str | None, + timeout_seconds: float, +) -> tuple[str, str]: + hub_text = _fetch_text(hub_url, timeout_seconds=timeout_seconds) + hub_meta = _parse_kv_blocks(hub_text) + if not hub_meta: + raise RuntimeError(f"Track hub descriptor is empty: {hub_url}") + + genomes_file = hub_meta[0].get("genomesFile") + if not genomes_file: + raise RuntimeError( + "Track hub descriptor did not include 'genomesFile'. " + "Only multi-file hubs are currently supported." + ) + + genomes_url = parse.urljoin(hub_url, genomes_file) + genome_blocks = _parse_kv_blocks(_fetch_text(genomes_url, timeout_seconds=timeout_seconds)) + candidates: list[tuple[str, str]] = [] + for block in genome_blocks: + genome = block.get("genome") + trackdb = block.get("trackDb") + if genome and trackdb: + candidates.append((genome, parse.urljoin(genomes_url, trackdb))) + if not candidates: + raise RuntimeError(f"No genome/trackDb entries found in {genomes_url}") + + if assembly is None: + genome, trackdb_url = candidates[0] + return genome, trackdb_url + + requested = _normalize_assembly_token(assembly) + for genome, trackdb_url in candidates: + if _normalize_assembly_token(genome) == requested: + return genome, trackdb_url + + available = ", ".join(genome for genome, _ in candidates) + raise ValueError( + f"Assembly {assembly!r} was not found in track hub. Available assemblies: {available}" + ) + + +def _is_bigbed_path(path: Path) -> bool: + lower_name = path.name.lower() + return lower_name.endswith(".bb") or lower_name.endswith(".bigbed") + + +def _download_track_file( + *, + url: str, + cache_dir: Path, + allow_cached: bool, + timeout_seconds: float, +) -> Path: + filename = Path(parse.urlparse(url).path).name + if not filename: + filename = "track_file" + output = cache_dir / filename + + if allow_cached and output.exists() and output.stat().st_size > 0: + return output + + payload = _fetch_bytes(url, timeout_seconds=timeout_seconds) + output.parent.mkdir(parents=True, exist_ok=True) + tmp_output = output.with_suffix(output.suffix + ".tmp") + tmp_output.write_bytes(payload) + tmp_output.replace(output) + return output + + +def _convert_bigbed_to_bed(path: Path) -> Path: + converter = shutil.which("bigBedToBed") + if converter is None: + raise RuntimeError( + "Requested bigBed conversion but 'bigBedToBed' was not found on PATH." + ) + + converted = path.with_suffix(".bed") + proc = subprocess.run( + [converter, str(path), str(converted)], + capture_output=True, + text=True, + check=False, + ) + if proc.returncode != 0: + raise RuntimeError( + f"bigBedToBed failed for {path}: {proc.stderr.strip()[:400]}" + ) + return converted + + +def unibind_trackhub_url(collection: str = "robust") -> str: + key = _normalize_token(collection) + if key not in _UNIBIND_TRACKHUB_URLS: + available = ", ".join(sorted(_UNIBIND_TRACKHUB_URLS)) + raise ValueError( + f"Unsupported UniBind track hub collection {collection!r}. Available: {available}." + ) + return _UNIBIND_TRACKHUB_URLS[key] + + +def search_unibind_trackhub_tracks( + *, + trackhub_url: str | None = None, + collection: str = "robust", + assembly: str | None = None, + search_terms: Iterable[str] | None = None, + timeout_seconds: float = 60.0, +) -> list[dict[str, str]]: + resolved_hub_url = trackhub_url if trackhub_url is not None else unibind_trackhub_url(collection) + resolved_assembly, trackdb_url = _select_trackdb_url( + hub_url=resolved_hub_url, + assembly=assembly, + timeout_seconds=timeout_seconds, + ) + stanzas = _load_trackdb_stanzas(trackdb_url, timeout_seconds=timeout_seconds) + + terms = [str(term).strip().lower() for term in (search_terms or []) if str(term).strip()] + + rows: list[dict[str, str]] = [] + for stanza in stanzas: + big_data = stanza.get("bigDataUrl") + if not big_data: + continue + + track_name = stanza.get("track", "") + short_label = stanza.get("shortLabel", "") + long_label = stanza.get("longLabel", "") + track_type = stanza.get("type", "") + big_data_url = parse.urljoin(trackdb_url, big_data) + + if terms: + haystack = " ".join( + [track_name, short_label, long_label, big_data_url] + ).lower() + if not any(term in haystack for term in terms): + continue + + rows.append( + { + "assembly": resolved_assembly, + "track": track_name, + "short_label": short_label, + "long_label": long_label, + "type": track_type, + "url": big_data_url, + } + ) + + return rows + + +def resolve_unibind_track_paths( + *, + track_paths: Iterable[str | Path] | None = None, + trackhub_url: str | None = None, + collection: str = "robust", + assembly: str | None = None, + search_terms: Iterable[str] | None = None, + cache_dir: str | Path = "cache/unibind_tracks", + max_tracks: int | None = None, + allow_cached: bool = True, + timeout_seconds: float = 60.0, + convert_bigbed_to_bed: bool = False, +) -> list[Path]: + if track_paths is not None: + resolved_paths: list[Path] = [] + for raw in track_paths: + candidate = Path(raw).expanduser().resolve() + if not candidate.exists(): + raise FileNotFoundError(f"UniBind track path does not exist: {candidate}") + resolved_paths.append(candidate) + if not resolved_paths: + raise ValueError("track_paths was provided but empty.") + return resolved_paths + + discovered = search_unibind_trackhub_tracks( + trackhub_url=trackhub_url, + collection=collection, + assembly=assembly, + search_terms=search_terms, + timeout_seconds=timeout_seconds, + ) + if not discovered: + raise ValueError( + "No UniBind tracks matched the requested track hub search criteria." + ) + + if max_tracks is not None: + discovered = discovered[: int(max_tracks)] + + cache_root = Path(cache_dir) + cache_root.mkdir(parents=True, exist_ok=True) + + outputs: list[Path] = [] + for row in discovered: + downloaded = _download_track_file( + url=row["url"], + cache_dir=cache_root, + allow_cached=allow_cached, + timeout_seconds=timeout_seconds, + ) + if convert_bigbed_to_bed and _is_bigbed_path(downloaded): + downloaded = _convert_bigbed_to_bed(downloaded) + outputs.append(downloaded) + + return outputs + + +def submit_unibind_tfbs_extraction( + *, + regions: Any, + species: str = _DEFAULT_SPECIES, + collection: str = "robust", + tf_list: str | Path | Iterable[str] | None = None, + experiment_ids: str | Path | Iterable[str] | None = None, + name: str | None = None, + email: str | None = None, + endpoint_url: str = DEFAULT_UNIBIND_TFBS_EXTRACTION_URL, + timeout_seconds: float = 120.0, +) -> UniBindJobResult: + species_code = _normalize_unibind_species_code(species) + resolved_collection = _normalize_unibind_collection(collection) + bed_payload = _regions_to_bed_bytes(regions) + + files: dict[str, tuple[str, bytes, str]] = { + "bed_file": ("regions.bed", bed_payload, "text/plain"), + } + tf_payload = _coerce_optional_text_file_payload( + tf_list, + default_filename="tf_list.txt", + ) + if tf_payload is not None: + files["TFs_file"] = tf_payload + experiment_payload = _coerce_optional_text_file_payload( + experiment_ids, + default_filename="experiment_ids.txt", + ) + if experiment_payload is not None: + files["experiments_file"] = experiment_payload + + fields = { + "name": (name or "").strip(), + "email": (email or "").strip(), + "species": species_code, + "collection": resolved_collection, + "performTFBSextraction": "1", + } + return _submit_unibind_form( + endpoint_url=endpoint_url, + fields=fields, + files=files, + timeout_seconds=timeout_seconds, + query={ + "species": _UNIBIND_FORM_SPECIES_BY_CODE.get(species_code, species_code), + "species_code": species_code, + "collection": resolved_collection, + "name": fields["name"], + "email": fields["email"], + "has_tf_filter": tf_payload is not None, + "has_experiment_filter": experiment_payload is not None, + }, + ) + + +def submit_unibind_enrichment( + *, + regions: Any, + analysis_type: str = "oneSetBg", + background_regions: Any | None = None, + comparison_regions: Any | None = None, + species: str = _DEFAULT_SPECIES, + collection: str = "robust", + name: str | None = None, + email: str | None = None, + endpoint_url: str = DEFAULT_UNIBIND_ENRICHMENT_URL, + timeout_seconds: float = 120.0, +) -> UniBindJobResult: + resolved_analysis_type = _normalize_unibind_enrichment_analysis_type(analysis_type) + species_code = _normalize_unibind_species_code(species) + resolved_collection = _normalize_unibind_collection(collection) + bed_payload = _regions_to_bed_bytes(regions) + + files: dict[str, tuple[str, bytes, str]] = { + "bed_file_1": ("regions_1.bed", bed_payload, "text/plain"), + } + if resolved_analysis_type == "oneSetBg": + if background_regions is None: + raise ValueError( + "UniBind enrichment with analysis_type='oneSetBg' requires " + "background_regions." + ) + files["bed_file_background"] = ( + "background_regions.bed", + _regions_to_bed_bytes(background_regions), + "text/plain", + ) + elif resolved_analysis_type == "twoSets": + if comparison_regions is None: + raise ValueError( + "UniBind enrichment with analysis_type='twoSets' requires " + "comparison_regions." + ) + files["bed_file_2"] = ( + "regions_2.bed", + _regions_to_bed_bytes(comparison_regions), + "text/plain", + ) + + fields = { + "analysis_type": resolved_analysis_type, + "name": (name or "").strip(), + "email": (email or "").strip(), + "species": species_code, + "collection": resolved_collection, + "performEnrichment": "1", + } + return _submit_unibind_form( + endpoint_url=endpoint_url, + fields=fields, + files=files, + timeout_seconds=timeout_seconds, + query={ + "analysis_type": resolved_analysis_type, + "species": _UNIBIND_FORM_SPECIES_BY_CODE.get(species_code, species_code), + "species_code": species_code, + "collection": resolved_collection, + "name": fields["name"], + "email": fields["email"], + "has_background": background_regions is not None, + "has_comparison": comparison_regions is not None, + }, + ) + + +def poll_unibind_job( + job: UniBindJobResult | str, + *, + poll_interval_seconds: float = 5.0, + timeout_seconds: float = 1200.0, + request_timeout_seconds: float = 60.0, +) -> UniBindJobResult: + if isinstance(job, UniBindJobResult): + current = job + else: + parsed = str(job).strip() + if not parsed: + raise ValueError("job URL cannot be empty.") + current = UniBindJobResult( + job_id=_extract_unibind_job_id(parsed), + status="unknown", + job_url=parsed, + endpoint_url=parse.urljoin(parsed, "."), + query={}, + status_history=[], + metadata={}, + ) + + history = list(current.status_history) + started = time.monotonic() + status = current.status + results_url = current.results_url + output_urls = list(current.download_urls) + + while True: + page_html = _fetch_text(current.job_url, timeout_seconds=request_timeout_seconds) + status = _extract_unibind_job_status(page_html) + extracted_results_url = _extract_unibind_results_url(page_html, base_url=current.job_url) + results_url = extracted_results_url or results_url or current.job_url + output_urls = _extract_unibind_output_urls(page_html, base_url=current.job_url) + + history.append( + { + "status": status, + "timestamp": time.time(), + "stage": "poll", + "url": current.job_url, + } + ) + if status in _UNIBIND_TERMINAL_STATUSES: + break + + elapsed = time.monotonic() - started + if elapsed > timeout_seconds: + raise TimeoutError( + "Timed out waiting for UniBind job completion: " + f"{current.job_url} (last status={status!r})." + ) + time.sleep(max(0.1, float(poll_interval_seconds))) + + return UniBindJobResult( + job_id=current.job_id, + status=status, + job_url=current.job_url, + endpoint_url=current.endpoint_url, + results_url=results_url, + download_urls=output_urls, + query=dict(current.query), + status_history=history, + metadata=dict(current.metadata), + ) + + +def download_unibind_job_outputs( + *, + job: UniBindJobResult, + output_dir: str | Path = "cache/unibind_jobs", + allow_cached: bool = True, + timeout_seconds: float = 120.0, +) -> list[Path]: + if not job.download_urls: + return [] + + root = Path(output_dir).expanduser().resolve() / job.job_id + root.mkdir(parents=True, exist_ok=True) + downloaded: list[Path] = [] + + for index, url in enumerate(job.download_urls): + name = Path(parse.urlparse(url).path).name or f"output_{index}" + destination = root / name + if destination.exists() and destination.stat().st_size > 0 and allow_cached: + downloaded.append(destination) + continue + + payload = _fetch_bytes(url, timeout_seconds=timeout_seconds) + tmp_path = destination.with_suffix(destination.suffix + ".tmp") + tmp_path.write_bytes(payload) + tmp_path.replace(destination) + downloaded.append(destination) + return downloaded + + +def run_unibind_tfbs_extraction( + *, + regions: Any, + species: str = _DEFAULT_SPECIES, + collection: str = "robust", + tf_list: str | Path | Iterable[str] | None = None, + experiment_ids: str | Path | Iterable[str] | None = None, + name: str | None = None, + email: str | None = None, + endpoint_url: str = DEFAULT_UNIBIND_TFBS_EXTRACTION_URL, + submit_timeout_seconds: float = 120.0, + wait: bool = True, + poll_interval_seconds: float = 5.0, + timeout_seconds: float = 1200.0, + download_outputs: bool = False, + output_dir: str | Path = "cache/unibind_jobs", + allow_cached_downloads: bool = True, + download_timeout_seconds: float = 120.0, +) -> UniBindJobResult: + result = submit_unibind_tfbs_extraction( + regions=regions, + species=species, + collection=collection, + tf_list=tf_list, + experiment_ids=experiment_ids, + name=name, + email=email, + endpoint_url=endpoint_url, + timeout_seconds=submit_timeout_seconds, + ) + if wait: + result = poll_unibind_job( + result, + poll_interval_seconds=poll_interval_seconds, + timeout_seconds=timeout_seconds, + ) + if download_outputs: + if not wait: + raise ValueError("download_outputs=True requires wait=True.") + downloaded = download_unibind_job_outputs( + job=result, + output_dir=output_dir, + allow_cached=allow_cached_downloads, + timeout_seconds=download_timeout_seconds, + ) + result.metadata["downloaded_outputs"] = [str(path) for path in downloaded] + return result + + +def run_unibind_enrichment( + *, + regions: Any, + analysis_type: str = "oneSetBg", + background_regions: Any | None = None, + comparison_regions: Any | None = None, + species: str = _DEFAULT_SPECIES, + collection: str = "robust", + name: str | None = None, + email: str | None = None, + endpoint_url: str = DEFAULT_UNIBIND_ENRICHMENT_URL, + submit_timeout_seconds: float = 120.0, + wait: bool = True, + poll_interval_seconds: float = 5.0, + timeout_seconds: float = 1200.0, + download_outputs: bool = False, + output_dir: str | Path = "cache/unibind_jobs", + allow_cached_downloads: bool = True, + download_timeout_seconds: float = 120.0, +) -> UniBindJobResult: + result = submit_unibind_enrichment( + regions=regions, + analysis_type=analysis_type, + background_regions=background_regions, + comparison_regions=comparison_regions, + species=species, + collection=collection, + name=name, + email=email, + endpoint_url=endpoint_url, + timeout_seconds=submit_timeout_seconds, + ) + if wait: + result = poll_unibind_job( + result, + poll_interval_seconds=poll_interval_seconds, + timeout_seconds=timeout_seconds, + ) + if download_outputs: + if not wait: + raise ValueError("download_outputs=True requires wait=True.") + downloaded = download_unibind_job_outputs( + job=result, + output_dir=output_dir, + allow_cached=allow_cached_downloads, + timeout_seconds=download_timeout_seconds, + ) + result.metadata["downloaded_outputs"] = [str(path) for path in downloaded] + return result + + +def unibind_supported_species() -> tuple[str, ...]: + return _UNIBIND_SUPPORTED_SPECIES + + +def screen_supported_species() -> tuple[str, ...]: + return tuple(sorted(_SCREEN_SUPPORTED_SPECIES)) + + +@dataclass +class RegulatoryEnrichmentSpec: + providers: tuple[str, ...] = ("screen", "unibind") + species: str | None = None + reference_genome: str | None = None + target_genome: str | None = None + crossmap_chain_file: str | Path | None = None + crossmap_chain_url: str | None = None + crossmap_chain_cache_dir: str | Path | None = None + crossmap_executable: str | None = "CrossMap.py" + strict_provider_support: bool = False + enabled_providers: tuple[str, ...] = field(init=False) + provider_notes: dict[str, str] = field(init=False, default_factory=dict) + + def __post_init__(self) -> None: + requested = self.providers if self.providers else ("screen", "unibind") + normalized_providers = _unique_preserve_order(_normalize_provider(p) for p in requested) + + inferred = _infer_species_from_genomes( + reference_genome=self.reference_genome, + target_genome=self.target_genome, + ) + resolved_species = self.species if self.species is not None else (inferred or _DEFAULT_SPECIES) + canonical_species = normalize_species_name(str(resolved_species)) + + enabled: list[str] = [] + notes: dict[str, str] = {} + for provider in normalized_providers: + if provider == "screen" and canonical_species not in _SCREEN_SUPPORTED_SPECIES: + message = ( + "SCREEN disabled for species " + f"{canonical_species!r}; SCREEN supports only " + "homo_sapiens and mus_musculus." + ) + if self.strict_provider_support: + raise RegulatoryEnrichmentSpecError(message) + notes[provider] = message + continue + enabled.append(provider) + + if not enabled: + raise RegulatoryEnrichmentSpecError( + "No providers remain after species-based filtering. " + f"Requested providers={normalized_providers}, species={canonical_species!r}." + ) + + if self.target_genome is None and canonical_species in _DEFAULT_TARGET_GENOME_BY_SPECIES: + self.target_genome = _DEFAULT_TARGET_GENOME_BY_SPECIES[canonical_species] + + self.providers = tuple(normalized_providers) + self.species = canonical_species + self.enabled_providers = tuple(enabled) + self.provider_notes = notes + + def as_dict(self) -> dict[str, Any]: + return { + "providers": list(self.providers), + "enabled_providers": list(self.enabled_providers), + "species": self.species, + "reference_genome": self.reference_genome, + "target_genome": self.target_genome, + "crossmap_chain_file": ( + str(self.crossmap_chain_file) + if isinstance(self.crossmap_chain_file, Path) + else self.crossmap_chain_file + ), + "crossmap_chain_url": self.crossmap_chain_url, + "crossmap_chain_cache_dir": ( + str(self.crossmap_chain_cache_dir) + if isinstance(self.crossmap_chain_cache_dir, Path) + else self.crossmap_chain_cache_dir + ), + "crossmap_executable": self.crossmap_executable, + "provider_notes": dict(self.provider_notes), + } + + +__all__ = [ + "DEFAULT_UNIBIND_ENRICHMENT_URL", + "DEFAULT_UNIBIND_TFBS_EXTRACTION_URL", + "RegulatoryEnrichmentSpec", + "RegulatoryEnrichmentSpecError", + "download_unibind_job_outputs", + "normalize_species_name", + "poll_unibind_job", + "resolve_unibind_track_paths", + "run_unibind_enrichment", + "run_unibind_tfbs_extraction", + "screen_supported_species", + "search_unibind_trackhub_tracks", + "submit_unibind_enrichment", + "submit_unibind_tfbs_extraction", + "unibind_supported_species", + "unibind_trackhub_url", +] diff --git a/dimelo/run_modkit.py b/dimelo/run_modkit.py index 933a984..ffbaefb 100644 --- a/dimelo/run_modkit.py +++ b/dimelo/run_modkit.py @@ -1,4 +1,6 @@ import os +from dataclasses import dataclass +from functools import lru_cache # I believe that pty does not currently work on Windows, although this may change in future releases: https://bugs.python.org/issue41663 # However, it may be that pywinpty, which is installable from pip, would work fine. That just needs to be tested with a Windows machine @@ -6,6 +8,7 @@ import pty import re import select +import shutil import subprocess import sys from pathlib import Path @@ -13,16 +16,38 @@ from tqdm.auto import tqdm -# This should be updated in tandem with the environment.yml nanoporetech::modkit version -EXPECTED_MODKIT_VERSION = "0.2.4" +SUPPORTED_MODKIT_SERIES = ("0.2.x", "0.6.x") +SUPPORTED_MODKIT_MINOR_VERSIONS = {(0, 2), (0, 6)} +MODKIT_EXECUTABLE_ENV = "DIMELO_MODKIT_EXECUTABLE" FindingProgressDict: TypeAlias = dict[str, tuple[int, int]] +_NOISY_RUNTIME_LINES: tuple[str, ...] = ( + "MallocStackLogging: can't turn off malloc stack logging because it was not enabled.", +) -def ensure_modkit_available(quiet: bool = False) -> None: - """ - Lazily check that modkit is on PATH and matches expected version. - Called by parse functions to avoid import-time failures during analysis-only workflows. - """ +@dataclass(frozen=True) +class ModkitCapabilities: + executable: str + version_raw: str + version: str | None + version_tuple: tuple[int, ...] | None + supports_mod_threshold: bool + supports_mod_thresholds: bool + supports_modified_bases: bool + supports_force_allow_implicit: bool + supports_extract_subcommands: bool + extract_supports_reference_long: bool + extract_supports_reference_short: bool + + +def _strip_runtime_noise(text: str) -> str: + cleaned = text + for line in _NOISY_RUNTIME_LINES: + cleaned = cleaned.replace(line, "") + return cleaned + + +def _prepare_modkit_path(quiet: bool = False) -> None: # Add conda env bin folder to path if it is not already present current_interpreter = sys.executable env_bin_path = os.path.dirname(current_interpreter) @@ -33,23 +58,189 @@ def ensure_modkit_available(quiet: bool = False) -> None: ) os.environ["PATH"] = f"{env_bin_path}:{os.environ['PATH']}" + +def _parse_modkit_semver(version_text: str) -> tuple[int, ...] | None: + match = re.search(r"(\d+)\.(\d+)\.(\d+)", version_text) + if match is None: + return None + return (int(match.group(1)), int(match.group(2)), int(match.group(3))) + + +def _help_supports_flag(help_text: str, flag: str) -> bool: + return re.search(rf"(?m)^\s+{re.escape(flag)}(?:\s|$)", help_text) is not None + + +def _resolve_modkit_executable( + executable: str | None, +) -> str: + requested = executable or os.environ.get(MODKIT_EXECUTABLE_ENV) or "modkit" + looks_like_path = any(sep in requested for sep in ("/", "\\")) + + if looks_like_path: + expanded = str(Path(requested).expanduser()) + if not Path(expanded).exists(): + raise FileNotFoundError( + f"Requested modkit executable does not exist: {expanded}. " + f"Set {MODKIT_EXECUTABLE_ENV} or pass a valid executable path/name." + ) + return expanded + + discovered = shutil.which(requested) + if discovered is None: + raise FileNotFoundError( + f"Executable not found for modkit candidate '{requested}'. " + 'Install dimelo using "conda env create -f environment.yml" ' + 'or install modkit manually using "conda install nanoporetech::modkit==0.2.4". ' + "Without modkit you cannot run parse_bam functions." + ) + return discovered + + +def _modkit_cache_fingerprint(executable_path: str) -> str: + """ + Build a cache fingerprint for a resolved executable path. + Includes file metadata so replacing/upgrading modkit in-place invalidates + cached capabilities. + """ + path = Path(executable_path) + try: + stat = path.stat() + return f"{path.resolve()}:{stat.st_mtime_ns}:{stat.st_size}" + except OSError: + # Fall back to the resolved path string when stat is unavailable. + return str(path.resolve()) + + +@lru_cache(maxsize=16) +def _get_modkit_capabilities_cached( + executable_path: str, + executable_fingerprint: str, + quiet: bool = False, +) -> ModkitCapabilities: + # executable_fingerprint is included to invalidate cache entries when the + # binary file is replaced in-place (e.g., conda install modkit==new_version). + # It is intentionally unused beyond participating in the cache key. + _ = executable_fingerprint + executable = executable_path + try: - result = subprocess.run( - ["modkit", "--version"], stdout=subprocess.PIPE, text=True, check=True + version_result = subprocess.run( + [executable, "--version"], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True, + check=True, ) - modkit_version = result.stdout.split() - if len(modkit_version) > 1 and modkit_version[1] != EXPECTED_MODKIT_VERSION: - if not quiet: - print( - f"modkit found with unexpected version {modkit_version[1]}. " - f"Expected {EXPECTED_MODKIT_VERSION}." - ) - except Exception: + except Exception as exc: # pragma: no cover - direct subprocess failures are environment-specific raise FileNotFoundError( 'Executable not found for modkit. Install dimelo using "conda env create -f environment.yml" ' 'or install modkit manually using "conda install nanoporetech::modkit==0.2.4". ' "Without modkit you cannot run parse_bam functions." + ) from exc + + version_raw = (version_result.stdout or version_result.stderr).strip() + version_tuple = _parse_modkit_semver(version_raw) + version = ".".join(str(value) for value in version_tuple) if version_tuple else None + + pileup_help = subprocess.run( + [executable, "pileup", "--help"], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True, + check=True, + ) + pileup_help_text = (pileup_help.stdout or "") + "\n" + (pileup_help.stderr or "") + + extract_help = subprocess.run( + [executable, "extract", "--help"], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True, + check=True, + ) + extract_help_text = (extract_help.stdout or "") + "\n" + (extract_help.stderr or "") + supports_extract_subcommands = "extract " in extract_help_text + extract_command_help_text = extract_help_text + if supports_extract_subcommands: + extract_full_help = subprocess.run( + [executable, "extract", "full", "--help"], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True, + check=True, ) + extract_command_help_text = (extract_full_help.stdout or "") + "\n" + ( + extract_full_help.stderr or "" + ) + + minor_version = ( + (version_tuple[0], version_tuple[1]) if version_tuple and len(version_tuple) >= 2 else None + ) + if minor_version is not None and minor_version not in SUPPORTED_MODKIT_MINOR_VERSIONS: + if not quiet: + print( + "modkit found with version " + f"{version or version_raw}. Officially tested series are {', '.join(SUPPORTED_MODKIT_SERIES)}." + ) + + return ModkitCapabilities( + executable=executable, + version_raw=version_raw, + version=version, + version_tuple=version_tuple, + supports_mod_threshold=_help_supports_flag(pileup_help_text, "--mod-threshold"), + supports_mod_thresholds=_help_supports_flag(pileup_help_text, "--mod-thresholds"), + supports_modified_bases=_help_supports_flag(pileup_help_text, "--modified-bases"), + supports_force_allow_implicit=_help_supports_flag( + pileup_help_text, "--force-allow-implicit" + ), + supports_extract_subcommands=supports_extract_subcommands, + extract_supports_reference_long=_help_supports_flag( + extract_command_help_text, "--reference" + ), + extract_supports_reference_short=_help_supports_flag( + extract_command_help_text, "--ref" + ), + ) + + +def get_modkit_capabilities( + quiet: bool = False, + executable: str | None = None, +) -> ModkitCapabilities: + _prepare_modkit_path(quiet=quiet) + executable_key = executable or os.environ.get(MODKIT_EXECUTABLE_ENV) or "modkit" + resolved_executable = _resolve_modkit_executable(executable_key) + executable_fingerprint = _modkit_cache_fingerprint(resolved_executable) + return _get_modkit_capabilities_cached( + executable_path=resolved_executable, + executable_fingerprint=executable_fingerprint, + quiet=quiet, + ) + + +def configure_modkit_executable(executable: str | Path | None) -> None: + """ + Configure which modkit binary should be used by parse operations. + Pass None to clear explicit override and fall back to PATH resolution. + """ + if executable is None: + os.environ.pop(MODKIT_EXECUTABLE_ENV, None) + else: + os.environ[MODKIT_EXECUTABLE_ENV] = str(executable) + _get_modkit_capabilities_cached.cache_clear() + + +def _ensure_modkit_available( + quiet: bool = False, + executable: str | Path | None = None, +) -> ModkitCapabilities: + """ + Lazily check that modkit is on PATH and return parsed capabilities. + Called by parse functions to avoid import-time failures during analysis-only workflows. + """ + executable_override = None if executable is None else str(executable) + return get_modkit_capabilities(quiet=quiet, executable=executable_override) def run_with_progress_bars( @@ -200,10 +391,12 @@ def run_with_progress_bars( # If we have hit an error or modkit is done, just accumulate the rest of the output and then deal with it: # no need to check the progress tracking stuff in that case if err_flag or done_flag: - tail_buffer += text + tail_buffer = _strip_runtime_noise(tail_buffer + text) # If we haven't hit an error or a done state, first check for that else: - tail_buffer = (tail_buffer + text)[-buffer_size:] + tail_buffer = _strip_runtime_noise( + (tail_buffer + text)[-buffer_size:] + ) if err_str in tail_buffer: index = tail_buffer.find(err_str) tail_buffer = tail_buffer[index:] diff --git a/dimelo/utils.py b/dimelo/utils.py index 63668a2..9f87fbb 100644 --- a/dimelo/utils.py +++ b/dimelo/utils.py @@ -368,6 +368,7 @@ def line_plot( dep_vectors: list[np.ndarray], dep_names: list[str], y_label: str, + legend_title: str = "variable", **kwargs, ) -> Axes: """ @@ -376,14 +377,13 @@ def line_plot( Takes in one independent vector and arbitrarily many dependent vectors. Plots all dependent vectors on the same axes against the same dependent vector. All vectors must be of equal length. - TODO: Right now, this always generates a legend with the title "variable". I could add a parameter to specify this (by passing the var_name argument to pd.DataFrame.melt), but then that percolates upwards to other methods. How to do this cleanly? - Args: indep_vector: parallel with each entry in dep_vectors; independent variable values shared across each overlayed line indep_name: name of independent variable; set as x axis label dep_vectors: outer list parallel with dep_names; each inner vector parallel with indep_vector; dependent variable values for each overlayed line dep_names: parallel with dep_vectors; names of each overlayed line; set as legend entries y_label: y-axis label + legend_title: legend heading shown for the overlaid traces kwargs: other keyword parameters passed through to seaborn.lineplot Returns: @@ -394,10 +394,13 @@ def line_plot( """ # construct dict of {vector_name: vector}, including the x vector using dict union operations data_dict = {indep_name: indep_vector} | dict(zip(dep_names, dep_vectors)) + hue_column = legend_title if legend_title else "variable" # construct long-form data table for plotting try: data_table = pd.DataFrame(data_dict).melt( - id_vars=indep_name, value_name=y_label + id_vars=indep_name, + value_name=y_label, + var_name=hue_column, ) except ValueError as e: raise ValueError( @@ -405,7 +408,7 @@ def line_plot( ) from e # plot lines return sns.lineplot( - data=data_table, x=indep_name, y=y_label, hue="variable", **kwargs + data=data_table, x=indep_name, y=y_label, hue=hue_column, **kwargs ) diff --git a/dimelo/workflows.py b/dimelo/workflows.py index 24766e7..a6c711d 100644 --- a/dimelo/workflows.py +++ b/dimelo/workflows.py @@ -5,23 +5,31 @@ import numpy as np import pandas as pd +from tqdm.auto import tqdm from .artifacts import resolve_artifact from . import ( + chip_atlas, cluster, + dmr, distribution, plotting, + regulatory_enrichment, region_analysis, region_contrasts, region_discovery, ) from .models import ( + ChipAtlasEnrichmentResult, + ModkitDMRMultiResult, + ModkitDMRPairResult, DatasetArtifact, RegionDiscoveryClusterContrastResult, RegionDiscoveryClusterResult, SampleSpec, SharedClusterModel, SharedClusterResult, + UniBindJobResult, ) _SUPPORTED_SIGNAL_NORMALIZATION = {"none", "per_sample_global", "control_regions"} @@ -326,6 +334,71 @@ def _build_region_summary(assignments: pd.DataFrame) -> pd.DataFrame: return summary +def _assignments_have_region_coordinates(assignments: pd.DataFrame) -> bool: + required = ("chromosome", "region_start", "region_end") + if not set(required).issubset(assignments.columns): + return False + return assignments.loc[:, list(required)].notna().all().all() + + +def _region_id_from_coordinates(row: pd.Series) -> str: + chrom = row.get("chromosome", row.get("chrom")) + start = row.get("region_start", row.get("start")) + end = row.get("region_end", row.get("end")) + region_id = f"{chrom}:{int(start)}-{int(end)}" + strand = row.get("region_strand", row.get("strand")) + if pd.notna(strand): + strand_value = str(strand) + if strand_value in {"+", "-", "."}: + return f"{region_id},{strand_value}" + return region_id + + +def _build_read_global_region_summary(assignments: pd.DataFrame) -> pd.DataFrame | None: + if not _assignments_have_region_coordinates(assignments): + return None + + summarizer = getattr(cluster, "summarize_read_cluster_region_associations", None) + if callable(summarizer): + association_frames: list[pd.DataFrame] = [] + include_strand = "region_strand" in assignments.columns + grouping_columns = ["sample_id", "condition"] + grouped = assignments.groupby(grouping_columns, sort=False, dropna=False) + for (sample_id, condition), sample_assignments in grouped: + try: + sample_summary = summarizer( + metadata=sample_assignments.to_dict("records"), + labels=sample_assignments["cluster"].to_numpy(), + include_strand=include_strand, + ) + except Exception: + association_frames = [] + break + if not isinstance(sample_summary, pd.DataFrame) or sample_summary.empty: + continue + normalized_summary = sample_summary.copy() + if "region_id" not in normalized_summary.columns: + coordinate_columns = {"chrom", "start", "end"} + if coordinate_columns.issubset(normalized_summary.columns): + normalized_summary["region_id"] = normalized_summary.apply( + _region_id_from_coordinates, + axis=1, + ) + normalized_summary["sample_id"] = sample_id + normalized_summary["condition"] = condition + association_frames.append(normalized_summary) + + if association_frames: + region_summaries = pd.concat(association_frames, ignore_index=True) + required_columns = {"region_id", "sample_id", "condition", "cluster", "count", "fraction"} + if required_columns.issubset(region_summaries.columns): + return region_summaries + + summary_source = assignments.copy() + summary_source["region_id"] = summary_source.apply(_region_id_from_coordinates, axis=1) + return _build_region_summary(summary_source) + + def _select_discovery_hits( hits: pd.DataFrame, *, @@ -494,6 +567,610 @@ def _normalize_cluster_region_ids( ) +def _require_region_summary_table_for_chip_atlas( + cluster_result: SharedClusterResult, +) -> pd.DataFrame: + if cluster_result.region_summaries is not None: + region_summaries = cluster_result.region_summaries.copy() + else: + assignments = cluster_result.assignments.copy() + if "region_id" not in assignments.columns: + if _assignments_have_region_coordinates(assignments): + assignments["region_id"] = assignments.apply(_region_id_from_coordinates, axis=1) + else: + raise ValueError( + "SharedClusterResult does not include region_summaries, and assignments " + "do not contain region coordinates to derive region ids." + ) + region_summaries = _build_region_summary(assignments) + + required_columns = {"cluster", "region_id"} + if not required_columns.issubset(region_summaries.columns): + missing = required_columns - set(region_summaries.columns) + raise ValueError( + "Cluster region summary table is missing required columns for ChIP-Atlas " + f"workflow: {sorted(missing)}" + ) + return region_summaries + + +def _rank_cluster_regions_for_chip_atlas( + *, + region_summaries: pd.DataFrame, + cluster_label: str, + min_fraction: float | None, + top_n_regions: int | None, +) -> list[str]: + cluster_rows = region_summaries.loc[region_summaries["cluster"] == cluster_label].copy() + if cluster_rows.empty: + return [] + + if "fraction" in cluster_rows.columns: + ranked = ( + cluster_rows.groupby("region_id", dropna=False)["fraction"] + .mean() + .sort_values(ascending=False) + .reset_index(name="score") + ) + if min_fraction is not None: + ranked = ranked.loc[ranked["score"] >= float(min_fraction)] + elif "count" in cluster_rows.columns: + ranked = ( + cluster_rows.groupby("region_id", dropna=False)["count"] + .sum() + .sort_values(ascending=False) + .reset_index(name="score") + ) + else: + ranked = ( + cluster_rows.groupby("region_id", dropna=False) + .size() + .sort_values(ascending=False) + .reset_index(name="score") + ) + + if top_n_regions is not None: + ranked = ranked.head(int(top_n_regions)) + return [str(region_id) for region_id in ranked["region_id"].tolist() if pd.notna(region_id)] + + +def resolve_regulatory_enrichment_spec( + *, + providers: Iterable[str] = ("screen", "unibind"), + species: str | None = None, + reference_genome: str | None = None, + target_genome: str | None = None, + crossmap_chain_file: str | Path | None = None, + crossmap_chain_url: str | None = None, + crossmap_chain_cache_dir: str | Path | None = None, + crossmap_executable: str | None = "CrossMap.py", + strict_provider_support: bool = False, + ) -> regulatory_enrichment.RegulatoryEnrichmentSpec: + return regulatory_enrichment.RegulatoryEnrichmentSpec( + providers=tuple(providers), + species=species, + reference_genome=reference_genome, + target_genome=target_genome, + crossmap_chain_file=crossmap_chain_file, + crossmap_chain_url=crossmap_chain_url, + crossmap_chain_cache_dir=crossmap_chain_cache_dir, + crossmap_executable=crossmap_executable, + strict_provider_support=strict_provider_support, + ) + + +def resolve_unibind_track_paths( + *, + track_paths: Iterable[str | Path] | None = None, + trackhub_url: str | None = None, + collection: str = "robust", + assembly: str | None = None, + search_terms: Iterable[str] | None = None, + cache_dir: str | Path = "cache/unibind_tracks", + max_tracks: int | None = None, + allow_cached: bool = True, + timeout_seconds: float = 60.0, + convert_bigbed_to_bed: bool = False, + regulatory_spec: regulatory_enrichment.RegulatoryEnrichmentSpec | None = None, +) -> list[Path]: + resolved_assembly = assembly + if resolved_assembly is None and regulatory_spec is not None: + resolved_assembly = regulatory_spec.target_genome + return regulatory_enrichment.resolve_unibind_track_paths( + track_paths=track_paths, + trackhub_url=trackhub_url, + collection=collection, + assembly=resolved_assembly, + search_terms=search_terms, + cache_dir=cache_dir, + max_tracks=max_tracks, + allow_cached=allow_cached, + timeout_seconds=timeout_seconds, + convert_bigbed_to_bed=convert_bigbed_to_bed, + ) + + +def unibind_tfbs_extraction_workflow( + *, + regions: Any, + species: str | None = None, + collection: str = "robust", + tf_list: str | Path | Iterable[str] | None = None, + experiment_ids: str | Path | Iterable[str] | None = None, + name: str | None = None, + email: str | None = None, + endpoint_url: str = regulatory_enrichment.DEFAULT_UNIBIND_TFBS_EXTRACTION_URL, + submit_timeout_seconds: float = 120.0, + wait: bool = True, + poll_interval_seconds: float = 5.0, + timeout_seconds: float = 1200.0, + download_outputs: bool = False, + output_dir: str | Path = "cache/unibind_jobs", + allow_cached_downloads: bool = True, + download_timeout_seconds: float = 120.0, + regulatory_spec: regulatory_enrichment.RegulatoryEnrichmentSpec | None = None, +) -> UniBindJobResult: + resolved_species = species + if resolved_species is None and regulatory_spec is not None: + resolved_species = regulatory_spec.species + return regulatory_enrichment.run_unibind_tfbs_extraction( + regions=regions, + species=resolved_species or "homo_sapiens", + collection=collection, + tf_list=tf_list, + experiment_ids=experiment_ids, + name=name, + email=email, + endpoint_url=endpoint_url, + submit_timeout_seconds=submit_timeout_seconds, + wait=wait, + poll_interval_seconds=poll_interval_seconds, + timeout_seconds=timeout_seconds, + download_outputs=download_outputs, + output_dir=output_dir, + allow_cached_downloads=allow_cached_downloads, + download_timeout_seconds=download_timeout_seconds, + ) + + +def unibind_enrichment_workflow( + *, + regions: Any, + analysis_type: str = "oneSetBg", + background_regions: Any | None = None, + comparison_regions: Any | None = None, + species: str | None = None, + collection: str = "robust", + name: str | None = None, + email: str | None = None, + endpoint_url: str = regulatory_enrichment.DEFAULT_UNIBIND_ENRICHMENT_URL, + submit_timeout_seconds: float = 120.0, + wait: bool = True, + poll_interval_seconds: float = 5.0, + timeout_seconds: float = 1200.0, + download_outputs: bool = False, + output_dir: str | Path = "cache/unibind_jobs", + allow_cached_downloads: bool = True, + download_timeout_seconds: float = 120.0, + regulatory_spec: regulatory_enrichment.RegulatoryEnrichmentSpec | None = None, +) -> UniBindJobResult: + resolved_species = species + if resolved_species is None and regulatory_spec is not None: + resolved_species = regulatory_spec.species + return regulatory_enrichment.run_unibind_enrichment( + regions=regions, + analysis_type=analysis_type, + background_regions=background_regions, + comparison_regions=comparison_regions, + species=resolved_species or "homo_sapiens", + collection=collection, + name=name, + email=email, + endpoint_url=endpoint_url, + submit_timeout_seconds=submit_timeout_seconds, + wait=wait, + poll_interval_seconds=poll_interval_seconds, + timeout_seconds=timeout_seconds, + download_outputs=download_outputs, + output_dir=output_dir, + allow_cached_downloads=allow_cached_downloads, + download_timeout_seconds=download_timeout_seconds, + ) + + +def chip_atlas_search_peak_datasets_workflow( + *, + antigen: str, + genome: str = "hg38", + cell_type: str | None = None, + antigen_class: str | None = None, + cell_type_class: str | None = None, + threshold: str = "05", + match_mode: str = "contains", + max_results: int | None = None, + experiment_list_url: str = chip_atlas.DEFAULT_EXPERIMENT_LIST_URL, + cache_dir: str | Path = chip_atlas.DEFAULT_METADATA_CACHE_DIR, + allow_cached_metadata: bool = True, + timeout_seconds: float = 120.0, +) -> pd.DataFrame: + return chip_atlas.search_peak_datasets( + antigen=antigen, + genome=genome, + cell_type=cell_type, + antigen_class=antigen_class, + cell_type_class=cell_type_class, + threshold=threshold, + match_mode=match_mode, + max_results=max_results, + experiment_list_url=experiment_list_url, + cache_dir=cache_dir, + allow_cached_metadata=allow_cached_metadata, + timeout_seconds=timeout_seconds, + ) + + +def chip_atlas_download_peak_datasets_workflow( + *, + datasets: pd.DataFrame, + dataset_ids: Iterable[str] | None = None, + output_dir: str | Path = "cache/chip_atlas/peak_sets", + include_complete_sorted: bool = True, + include_top_n: int | None = 3000, + include_bottom_n: int | None = 3000, + stratify: str | int | None = None, + allow_cached: bool = True, + timeout_seconds: float = 180.0, + crossmap_target_genome: str | None = None, + crossmap_chain_file: str | Path | None = None, + crossmap_chain_url: str | None = None, + crossmap_chain_cache_dir: str | Path | None = None, + crossmap_executable: str | None = "CrossMap.py", +) -> pd.DataFrame: + return chip_atlas.download_peak_datasets( + datasets=datasets, + dataset_ids=dataset_ids, + output_dir=output_dir, + include_complete_sorted=include_complete_sorted, + include_top_n=include_top_n, + include_bottom_n=include_bottom_n, + stratify=stratify, + allow_cached=allow_cached, + timeout_seconds=timeout_seconds, + crossmap_target_genome=crossmap_target_genome, + crossmap_chain_file=crossmap_chain_file, + crossmap_chain_url=crossmap_chain_url, + crossmap_chain_cache_dir=crossmap_chain_cache_dir, + crossmap_executable=crossmap_executable, + ) + + +def chip_atlas_enrichment_workflow( + *, + regions: pd.DataFrame | str | Path | list[str], + genome: str = "hg38", + regions_genome: str | None = None, + antigen_class: str | None = "TFs and others", + antigen: str | None = None, + cell_type_class: str | None = "No description", + cell_type: str | None = None, + distance: int | None = None, + threshold: str | None = "100", + crossmap_chain_file: str | Path | None = None, + crossmap_chain_url: str | None = None, + crossmap_chain_cache_dir: str | Path | None = None, + crossmap_executable: str | None = "CrossMap.py", + params: dict[str, Any] | None = None, + wait: bool = True, + fetch_results: bool = True, + raise_on_failure: bool = True, + submit_url: str = chip_atlas.DEFAULT_SUBMIT_URL, + status_url: str = chip_atlas.DEFAULT_STATUS_URL, + result_url: str = chip_atlas.DEFAULT_RESULT_URL, + poll_interval_seconds: float = 5.0, + timeout_seconds: float = 600.0, +) -> ChipAtlasEnrichmentResult: + return chip_atlas.run_enrichment( + regions=regions, + genome=genome, + regions_genome=regions_genome, + antigen_class=antigen_class, + antigen=antigen, + cell_type_class=cell_type_class, + cell_type=cell_type, + distance=distance, + threshold=threshold, + crossmap_chain_file=crossmap_chain_file, + crossmap_chain_url=crossmap_chain_url, + crossmap_chain_cache_dir=crossmap_chain_cache_dir, + crossmap_executable=crossmap_executable, + params=params, + wait=wait, + fetch_results=fetch_results, + raise_on_failure=raise_on_failure, + submit_url=submit_url, + status_url=status_url, + result_url=result_url, + poll_interval_seconds=poll_interval_seconds, + timeout_seconds=timeout_seconds, + ) + + +def chip_atlas_cluster_enrichment_workflow( + *, + cluster_result: SharedClusterResult, + genome: str = "hg38", + regions_genome: str | None = None, + clusters: Iterable[str] | None = None, + min_fraction: float | None = None, + top_n_regions: int | None = None, + mode: str = "per_cluster", + antigen_class: str | None = "TFs and others", + antigen: str | None = None, + cell_type_class: str | None = "No description", + cell_type: str | None = None, + distance: int | None = None, + threshold: str | None = "100", + crossmap_chain_file: str | Path | None = None, + crossmap_chain_url: str | None = None, + crossmap_chain_cache_dir: str | Path | None = None, + crossmap_executable: str | None = "CrossMap.py", + params: dict[str, Any] | None = None, + wait: bool = True, + fetch_results: bool = True, + raise_on_failure: bool = True, + submit_url: str = chip_atlas.DEFAULT_SUBMIT_URL, + status_url: str = chip_atlas.DEFAULT_STATUS_URL, + result_url: str = chip_atlas.DEFAULT_RESULT_URL, + poll_interval_seconds: float = 5.0, + timeout_seconds: float = 600.0, +) -> dict[str, ChipAtlasEnrichmentResult]: + if mode not in {"per_cluster", "combined"}: + raise ValueError("mode must be 'per_cluster' or 'combined'.") + + region_summaries = _require_region_summary_table_for_chip_atlas(cluster_result) + available_clusters = [str(value) for value in pd.unique(region_summaries["cluster"])] + selected_clusters = ( + [str(cluster_label) for cluster_label in clusters] + if clusters is not None + else available_clusters + ) + unknown = sorted(set(selected_clusters) - set(available_clusters)) + if unknown: + raise ValueError( + "Requested clusters were not present in cluster_result.region_summaries: " + f"{unknown}" + ) + + per_cluster_region_ids: dict[str, list[str]] = {} + for cluster_label in selected_clusters: + region_ids = _rank_cluster_regions_for_chip_atlas( + region_summaries=region_summaries, + cluster_label=cluster_label, + min_fraction=min_fraction, + top_n_regions=top_n_regions, + ) + if region_ids: + per_cluster_region_ids[cluster_label] = region_ids + + if not per_cluster_region_ids: + raise ValueError("No regions met the requested filters for ChIP-Atlas enrichment.") + + queries: dict[str, list[str]] + if mode == "combined": + union_region_ids = sorted({region_id for ids in per_cluster_region_ids.values() for region_id in ids}) + queries = {"combined": union_region_ids} + else: + queries = per_cluster_region_ids + + results: dict[str, ChipAtlasEnrichmentResult] = {} + for query_key, region_ids in queries.items(): + bed_frame = chip_atlas.region_ids_to_bed_dataframe(region_ids) + enrichment = chip_atlas_enrichment_workflow( + regions=bed_frame, + genome=genome, + regions_genome=regions_genome, + antigen_class=antigen_class, + antigen=antigen, + cell_type_class=cell_type_class, + cell_type=cell_type, + distance=distance, + threshold=threshold, + crossmap_chain_file=crossmap_chain_file, + crossmap_chain_url=crossmap_chain_url, + crossmap_chain_cache_dir=crossmap_chain_cache_dir, + crossmap_executable=crossmap_executable, + params=params, + wait=wait, + fetch_results=fetch_results, + raise_on_failure=raise_on_failure, + submit_url=submit_url, + status_url=status_url, + result_url=result_url, + poll_interval_seconds=poll_interval_seconds, + timeout_seconds=timeout_seconds, + ) + enrichment.metadata["workflow"] = { + "query_key": query_key, + "cluster_mode": mode, + "source_clusters": selected_clusters, + "region_count": len(region_ids), + "min_fraction": min_fraction, + "top_n_regions": top_n_regions, + } + results[query_key] = enrichment + return results + + +def modkit_dmr_pair_workflow( + *, + control_bed_methyl: str | Path, + experiment_bed_methyl: str | Path, + ref_genome: str | Path, + out_path: str | Path, + regions_bed: str | Path | None = None, + segment_path: str | Path | None = None, + bases: Iterable[str] = ("A",), + assign_codes: Iterable[str] | None = None, + min_valid_coverage: int = 0, + dmr_prior: float | None = None, + diff_stay: float | None = None, + significance_factor: float | None = None, + decay_distance: int | None = None, + max_gap_size: int | None = None, + log_transition_decay: bool = False, + fine_grained: bool = False, + prior_alpha: float | None = None, + prior_beta: float | None = None, + delta: float | None = None, + n_sample_records: int | None = None, + max_coverages: tuple[int, int] | None = None, + cap_coverages: bool = False, + missing: str | None = None, + threads: int | None = None, + io_threads: int | None = None, + batch_size: int | None = None, + interval_size: int | None = None, + header: bool = True, + force: bool = True, + suppress_progress: bool = True, + log_filepath: str | Path | None = None, + modkit_executable: str | Path | None = None, + pvalue_max: float = 0.01, + abs_effect_size_min: float = 0.1, + min_total_coverage: int | None = None, +) -> ModkitDMRPairResult: + return dmr.run_dmr_pair( + control_bed_methyl=control_bed_methyl, + experiment_bed_methyl=experiment_bed_methyl, + ref_genome=ref_genome, + out_path=out_path, + regions_bed=regions_bed, + segment_path=segment_path, + bases=list(bases), + assign_codes=None if assign_codes is None else list(assign_codes), + min_valid_coverage=min_valid_coverage, + dmr_prior=dmr_prior, + diff_stay=diff_stay, + significance_factor=significance_factor, + decay_distance=decay_distance, + max_gap_size=max_gap_size, + log_transition_decay=log_transition_decay, + fine_grained=fine_grained, + prior_alpha=prior_alpha, + prior_beta=prior_beta, + delta=delta, + n_sample_records=n_sample_records, + max_coverages=max_coverages, + cap_coverages=cap_coverages, + missing=missing, + threads=threads, + io_threads=io_threads, + batch_size=batch_size, + interval_size=interval_size, + header=header, + force=force, + suppress_progress=suppress_progress, + log_filepath=log_filepath, + modkit_executable=modkit_executable, + pvalue_max=pvalue_max, + abs_effect_size_min=abs_effect_size_min, + min_total_coverage=min_total_coverage, + ) + + +def modkit_dmr_multi_workflow( + *, + samples: dict[str, str | Path] | Iterable[tuple[str, str | Path]], + regions_bed: str | Path, + ref_genome: str | Path, + out_dir: str | Path, + bases: Iterable[str] = ("A",), + assign_codes: Iterable[str] | None = None, + min_valid_coverage: int = 0, + missing: str | None = None, + threads: int | None = None, + io_threads: int | None = None, + prefix: str | None = None, + header: bool = True, + force: bool = True, + suppress_progress: bool = True, + log_filepath: str | Path | None = None, + modkit_executable: str | Path | None = None, +) -> ModkitDMRMultiResult: + return dmr.run_dmr_multi( + samples=samples, + regions_bed=regions_bed, + ref_genome=ref_genome, + out_dir=out_dir, + bases=list(bases), + assign_codes=None if assign_codes is None else list(assign_codes), + min_valid_coverage=min_valid_coverage, + missing=missing, + threads=threads, + io_threads=io_threads, + prefix=prefix, + header=header, + force=force, + suppress_progress=suppress_progress, + log_filepath=log_filepath, + modkit_executable=modkit_executable, + ) + + +def modkit_dmr_multi_from_samples_workflow( + *, + samples: Iterable[SampleSpec], + regions_bed: str | Path, + ref_genome: str | Path, + out_dir: str | Path, + bases: Iterable[str] = ("A",), + assign_codes: Iterable[str] | None = None, + min_valid_coverage: int = 0, + missing: str | None = None, + threads: int | None = None, + io_threads: int | None = None, + prefix: str | None = None, + header: bool = True, + force: bool = True, + suppress_progress: bool = True, + log_filepath: str | Path | None = None, + modkit_executable: str | Path | None = None, +) -> ModkitDMRMultiResult: + sample_list = list(samples) + if len(sample_list) < 2: + raise ValueError("modkit_dmr_multi_from_samples_workflow requires at least two samples.") + + dmr_samples: dict[str, str | Path] = {} + for sample in sample_list: + metadata = sample.metadata or {} + pileup_path = metadata.get("pileup_path") + if pileup_path is None: + raise ValueError( + f"Sample {sample.sample_id!r} is missing metadata['pileup_path'] " + "required for modkit DMR multi workflow." + ) + dmr_samples[sample.sample_id] = pileup_path + + return modkit_dmr_multi_workflow( + samples=dmr_samples, + regions_bed=regions_bed, + ref_genome=ref_genome, + out_dir=out_dir, + bases=list(bases), + assign_codes=None if assign_codes is None else list(assign_codes), + min_valid_coverage=min_valid_coverage, + missing=missing, + threads=threads, + io_threads=io_threads, + prefix=prefix, + header=header, + force=force, + suppress_progress=suppress_progress, + log_filepath=log_filepath, + modkit_executable=modkit_executable, + ) + + def discovery_cluster_workflow( *, samples: Iterable[SampleSpec], @@ -502,6 +1179,7 @@ def discovery_cluster_workflow( discovery: dict[str, Any], clustering: dict[str, Any], selection: dict[str, Any] | None = None, + quiet: bool = True, ) -> RegionDiscoveryClusterResult: sample_list = list(samples) motif_list = list(motifs) @@ -541,6 +1219,7 @@ def discovery_cluster_workflow( samples=sample_list, motifs=motif_list, matched_regions=matched_regions, + quiet=quiet, **clustering, ) return RegionDiscoveryClusterResult( @@ -646,6 +1325,7 @@ def _build_shared_cluster_result( cache_hits: dict[str, str], cache_misses: list[str], sample_rebuild_decisions: dict[str, str], + quiet: bool, region_summaries: pd.DataFrame | None = None, ) -> SharedClusterResult: full_matrix = np.vstack(feature_blocks) @@ -696,6 +1376,8 @@ def _build_shared_cluster_result( } if region_summaries is None and mode == "region_anchored": region_summaries = _build_region_summary(assignments) + if region_summaries is None and mode == "read_global": + region_summaries = _build_read_global_region_summary(assignments) model = SharedClusterModel( mode=mode, @@ -743,6 +1425,7 @@ def _build_shared_cluster_result( "sample_dataset_sizes": sample_dataset_sizes, "rows_after_filtering": sample_dataset_sizes, "sample_normalization": sample_normalization, + "quiet": quiet, }, ) @@ -763,6 +1446,7 @@ def shared_cluster_distribution( random_state: int = 42, make_plots: bool = True, cores: int | None = None, + quiet: bool = True, ) -> SharedClusterResult: """ Fit one shared clustering model on pooled read windows and assign all reads back @@ -795,7 +1479,7 @@ def shared_cluster_distribution( cache_misses: list[str] = [] sample_rebuild_decisions: dict[str, str] = {} - for sample in sample_list: + for sample in tqdm(sample_list, desc="Processing samples", disable=quiet): requested_artifact = _requested_pileup_artifact( sample, motifs=motif_list, @@ -824,6 +1508,7 @@ def shared_cluster_distribution( matched_regions=matched_regions, pileup_paths=pileup_paths, cores=cores, + quiet=quiet, ) sample_by_id = {sample.sample_id: sample for sample in sample_list} for row in metadata_rows: @@ -885,6 +1570,7 @@ def shared_cluster_distribution( matched_regions=control_regions, pileup_paths={sample.sample_id: control_path}, cores=cores, + quiet=quiet, ) offset = float(np.asarray(control_matrix, dtype=float).mean()) else: @@ -938,6 +1624,7 @@ def shared_cluster_distribution( cache_hits=cache_hits, cache_misses=cache_misses, sample_rebuild_decisions=sample_rebuild_decisions, + quiet=quiet, ) feature_blocks: list[np.ndarray] = [] @@ -1073,4 +1760,5 @@ def shared_cluster_distribution( cache_hits=cache_hits, cache_misses=cache_misses, sample_rebuild_decisions=sample_rebuild_decisions, + quiet=quiet, ) diff --git a/dimelo_test.ipynb b/dimelo_test.ipynb new file mode 100644 index 0000000..03735a4 --- /dev/null +++ b/dimelo_test.ipynb @@ -0,0 +1,4795 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mac and Linux setup\n", + "\n", + "Make sure to have enabled the environment set up for running `dimelo` analysis. See the readme for details. If you are running your jupyter notebook some way other than by the `jupyter notebook` command in the command line from within your activated `conda` environment, you may need to use `ipykernel` to connect this notebook appropriately to the environment with `dimelo` and `modkit` installed." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Colab setup\n", + "\n", + "If you are running in Google Colab, run the cells below. **It is expected that Colab will make you restart your runtime to enable new package versions.** " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "You don't seem to be running on Google Colab so this cell is not going to be useful for you.\n", + "Make sure you are running you notebook in a conda environment set up as per README.md.\n", + "Once you have this notebook running in a correctly configured environment, proceed to the rest of the cells.\n", + " \n" + ] + } + ], + "source": [ + "# Lets Colab access your Google drive\n", + "try:\n", + " from google.colab import drive\n", + "except:\n", + " print(\"\"\"\n", + "You don't seem to be running on Google Colab so this cell is not going to be useful for you.\n", + "Make sure you are running you notebook in a conda environment set up as per README.md.\n", + "Once you have this notebook running in a correctly configured environment, proceed to the rest of the cells.\n", + " \"\"\")\n", + "else:\n", + " drive.mount('/content/drive')\n", + " # Install condacolab to let us get the modkit dependency\n", + " !pip install -q condacolab\n", + " import condacolab\n", + " condacolab.install()\n", + " # Install modkit\n", + " !conda install nanoporetech::modkit==0.2.4\n", + " # Clone the repo, change the active path to be inside the repo, and install the package\n", + " !rm -r dimelo\n", + " !git clone https://github.com/streetslab/dimelo\n", + " import os\n", + " os.chdir('dimelo')\n", + " !pip install ipywidgets==7.7.1 .\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After runtime restart in previous cell, run this cell to make sure your notebook is set up." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "try:\n", + " from google.colab import drive\n", + " drive.mount('/content/drive')\n", + " import os\n", + " os.chdir('dimelo') \n", + "except:\n", + " pass" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# System and Versions Information" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conda Environment" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run this cell to list the packages present in your conda environment" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "CondaError: Run 'conda init' before 'conda activate'\n", + "\n" + ] + } + ], + "source": [ + "!conda activate dimelo-toolkit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## System Information" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run this cell to list system information about your machine" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "System: Darwin\n", + "Release: 25.5.0\n", + "Version: Darwin Kernel Version 25.5.0: Fri Mar 20 18:56:10 PDT 2026; root:xnu-12377.120.72.0.4~13/RELEASE_ARM64_T6020\n", + "Processor: arm\n" + ] + } + ], + "source": [ + "import platform\n", + "print('System:',platform.system())\n", + "print('Release:',platform.release())\n", + "print('Version:',platform.version())\n", + "print('Processor:',platform.processor())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Git Repo Version" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run this cell to capture the exact repo version you're running, in case we need to debug anything" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "87186168c2ac4f8c12f91385e2ca42688ac6c5c7\n" + ] + } + ], + "source": [ + "!git -C . log -1 --format=%H" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Modkit Version Selection (Demo)\n", + "\n", + "Use this cell to pin a preferred `modkit` version for reproducible runs.\n", + "It detects your installed version and records a `MODKIT_VERSION_SELECTED` value for downstream cells.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "modkit selected: 0.6.1\n", + "modkit active : 0.6.1\n" + ] + } + ], + "source": [ + "import re\n", + "import shutil\n", + "import subprocess\n", + "\n", + "# Target modkit version for this notebook run.\n", + "# Auto-install is enabled so Run All upgrades PATH to this version when needed.\n", + "MODKIT_VERSION_SELECTED = \"0.6.1\"\n", + "AUTO_INSTALL_SELECTED_MODKIT = True\n", + "\n", + "\n", + "def _installed_modkit_version(binary: str = \"modkit\") -> str | None:\n", + " try:\n", + " proc = subprocess.run([binary, \"--version\"], capture_output=True, text=True, check=True)\n", + " except Exception:\n", + " return None\n", + " text = (proc.stdout or proc.stderr or \"\").strip()\n", + " m = re.search(r\"(\\d+\\.\\d+\\.\\d+)\", text)\n", + " return m.group(1) if m else text\n", + "\n", + "\n", + "def ensure_selected_modkit(\n", + " selected: str = MODKIT_VERSION_SELECTED,\n", + " binary: str = \"modkit\",\n", + " auto_install: bool = AUTO_INSTALL_SELECTED_MODKIT,\n", + ") -> str:\n", + " installed = _installed_modkit_version(binary)\n", + " if installed != selected and auto_install:\n", + " installer = shutil.which(\"mamba\") or shutil.which(\"conda\")\n", + " if installer is None:\n", + " raise RuntimeError(\n", + " \"modkit version mismatch and no conda/mamba installer found on PATH. \"\n", + " \"Install modkit manually or set a matching environment.\"\n", + " )\n", + " subprocess.run(\n", + " [installer, \"install\", \"-y\", f\"nanoporetech::modkit=={selected}\"],\n", + " check=True,\n", + " )\n", + " installed = _installed_modkit_version(binary)\n", + "\n", + "\n", + " # Clear cached capability detection so command flags match the active binary version.\n", + " try:\n", + " from dimelo import run_modkit\n", + " run_modkit._get_modkit_capabilities_cached.cache_clear()\n", + " except Exception:\n", + " pass\n", + "\n", + " if installed != selected:\n", + " raise RuntimeError(\n", + " f\"Notebook requires modkit {selected}, but PATH resolves to {installed!r}. \"\n", + " \"Activate the intended environment or enable AUTO_INSTALL_SELECTED_MODKIT.\"\n", + " )\n", + "\n", + " print(f\"modkit selected: {selected}\")\n", + " print(f\"modkit active : {installed}\")\n", + " return binary\n", + "\n", + "\n", + "MODKIT_BINARY = ensure_selected_modkit()\n", + "\n", + "\n", + "def run_modkit_checked(args: list[str]) -> None:\n", + " ensure_selected_modkit(binary=MODKIT_BINARY)\n", + " cmd = [MODKIT_BINARY, *[str(a) for a in args]]\n", + " print(\"$\", \" \".join(cmd))\n", + " subprocess.run(cmd, check=True)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Modkit Version Comparison (Cached Results)\n", + "\n", + "This cell summarizes the cached benchmark at `modkit_test_results.json` and compares runtime/output behavior across tested versions.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
versionruntime_mean_sruntime_std_sruntime_min_sruntime_max_s
00.6.12.0819530.2763181.7662932.280039
10.2.45.2468480.3708825.0062305.673964
\n", + "
" + ], + "text/plain": [ + " version runtime_mean_s runtime_std_s runtime_min_s runtime_max_s\n", + "0 0.6.1 2.081953 0.276318 1.766293 2.280039\n", + "1 0.2.4 5.246848 0.370882 5.006230 5.673964" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compatibility flags\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
versionsupports_force_allow_implicitsupports_modified_basessupports_reference_long_optsupports_reference_short_opt
00.2.4TrueFalseFalseTrue
10.6.1FalseTrueTrueTrue
\n", + "
" + ], + "text/plain": [ + " version supports_force_allow_implicit supports_modified_bases \\\n", + "0 0.2.4 True False \n", + "1 0.6.1 False True \n", + "\n", + " supports_reference_long_opt supports_reference_short_opt \n", + "0 False True \n", + "1 True True " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pileup comparison summary\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
row_deltarow_delta_pct_vs_024outputs_identical_sha256
016030.312757False
\n", + "
" + ], + "text/plain": [ + " row_delta row_delta_pct_vs_024 outputs_identical_sha256\n", + "0 1603 0.312757 False" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Recommendations\n", + "- Prefer modkit 0.6.1 for pileup runtime in this workflow (~60.3% faster on average).\n", + "- Backend-aware command building is required: use --force-allow-implicit for 0.2.4 only.\n", + "\n", + "Re-checking selected modkit binary after comparison...\n", + "modkit selected: 0.6.1\n", + "modkit active : 0.6.1\n" + ] + } + ], + "source": [ + "import json\n", + "from pathlib import Path\n", + "\n", + "import pandas as pd\n", + "from matplotlib import pyplot as plt\n", + "\n", + "results_path = Path(\"modkit_test_results.json\")\n", + "if not results_path.exists():\n", + " print(f\"No benchmark file found at {results_path}.\")\n", + "else:\n", + " results = json.loads(results_path.read_text())\n", + "\n", + " runtime_summary = pd.DataFrame(results.get(\"runtime_summary\", []))\n", + " if not runtime_summary.empty:\n", + " runtime_summary = runtime_summary.sort_values(\"runtime_mean_s\").reset_index(drop=True)\n", + " display(runtime_summary)\n", + "\n", + " fig, ax = plt.subplots(figsize=(6, 3.5))\n", + " ax.bar(runtime_summary[\"version\"], runtime_summary[\"runtime_mean_s\"], color=[\"#4C78A8\", \"#F58518\", \"#54A24B\"])\n", + " ax.set_ylabel(\"Mean runtime (s)\")\n", + " ax.set_xlabel(\"modkit version\")\n", + " ax.set_title(\"Cached modkit runtime comparison\")\n", + " plt.show()\n", + "\n", + " edge_flags = pd.DataFrame(results.get(\"edge_case_flags\", []))\n", + " if not edge_flags.empty:\n", + " print(\"Compatibility flags\")\n", + " display(edge_flags)\n", + "\n", + " pileup_cmp = results.get(\"pileup_comparison\", {})\n", + " if pileup_cmp:\n", + " print(\"Pileup comparison summary\")\n", + " display(pd.DataFrame([pileup_cmp]))\n", + "\n", + " print(\"Recommendations\")\n", + " for rec in results.get(\"recommendations\", []):\n", + " print(f\"- {rec}\")\n", + "\n", + "print(\"\\nRe-checking selected modkit binary after comparison...\")\n", + "MODKIT_BINARY = ensure_selected_modkit(binary=MODKIT_BINARY)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Initialization" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "from matplotlib import pyplot as plt \n", + "import urllib, gzip" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dimelo module path: /Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/__init__.py\n", + "dimelo version: unknown\n" + ] + } + ], + "source": [ + "# Ensure this notebook imports the local repo version of dimelo\n", + "import importlib\n", + "from pathlib import Path\n", + "import dimelo\n", + "\n", + "importlib.reload(dimelo)\n", + "print('dimelo module path:', Path(dimelo.__file__).resolve())\n", + "print('dimelo version:', getattr(dimelo, '__version__', 'unknown'))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Base input and output directories\n", + "test_data_dir = Path('./dimelo/test/data')\n", + "output_dir = Path('./dimelo/test/output')\n", + "\n", + "output_dir.mkdir(exist_ok=True)\n", + "\n", + "# Input files\n", + "ctcf_bam_file = test_data_dir / 'ctcf_demo.sorted.bam'\n", + "ctcf_guppy_bam_file = test_data_dir / 'winnowmap_guppy_merge_subset.updated.bam'\n", + "ctcf_target_regions = test_data_dir / 'ctcf_demo_peak.bed'\n", + "ctcf_off_target_regions = test_data_dir / 'ctcf_demo_not_peak.bed'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The cell below only needs to run once; if you try to run it with the reference genome already downloaded it will likely just not complete." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reference genome already present. Set force_redownload=True to if you want to download it again.\n" + ] + } + ], + "source": [ + "ref_genome_url = 'https://s3-us-west-2.amazonaws.com/human-pangenomics/T2T/CHM13/assemblies/chm13.draft_v1.0.fasta.gz'\n", + "ref_genome_gz = output_dir / 'chm13.draft_v1.0.fasta.gz'\n", + "ref_genome_file = output_dir / 'chm13.draft_v1.0.fasta'\n", + "force_redownload = False\n", + "if ref_genome_file.exists() and not force_redownload:\n", + " print('Reference genome already present. Set force_redownload=True to if you want to download it again.')\n", + "else:\n", + " urllib.request.urlretrieve(ref_genome_url,ref_genome_gz)\n", + "\n", + " with gzip.open(ref_genome_gz,'rb') as gzip_file:\n", + " with open(ref_genome_file,'wb') as output_file:\n", + " for chunk in gzip_file:\n", + " output_file.write(chunk)\n", + "\n", + " ref_genome_gz.unlink()\n", + " print(\"Reference genome downloaded and decompressed.\")\n", + "# !curl https://s3-us-west-2.amazonaws.com/human-pangenomics/T2T/CHM13/assemblies/chm13.draft_v1.0.fasta.gz -o ./test/output/chm13.draft_v1.0.fasta.gz\n", + "# !gunzip ./test/output/chm13.draft_v1.0.fasta.gz" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Basic Use Overview" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For details on parameters and functionality breakdown, please read the README sections on **Basic Use**, especially **Parameters and what they mean**." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Parsing" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import importlib\n", + "from dimelo import parse_bam, run_modkit\n", + "\n", + "# Ensure notebook uses latest local backend code and capability logic.\n", + "importlib.reload(run_modkit)\n", + "importlib.reload(parse_bam)\n", + "\n", + "# Reset cached capability detection after reloads/version changes.\n", + "run_modkit._get_modkit_capabilities_cached.cache_clear()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Pileup and Update Tags" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Attempting to parse a malformed BAM file will raise an error, thanks to input BAM format checking. Passing a bam file that doesn't meet the specifications directly to `modkit` will typically result in an empty ouput file; `modkit` will find no valid base modifications and return all-zero data.\n", + "\n", + "Megalodon and Guppy bam files are considered malformed because they do not meet the latest .bam spec. Some newer basecallers output correctly formatted files without requiring additional processing.\n", + "\n", + "However, `modkit` comes with two tools that can update bam files to meet spec." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "try:\n", + " pileup_file, pileup_regions = parse_bam.pileup(\n", + " input_file=ctcf_bam_file,\n", + " output_name='ctcf_demo_pileup_on_target',\n", + " ref_genome=ref_genome_file,\n", + " output_directory=output_dir,\n", + " regions=[ctcf_target_regions,ctcf_off_target_regions],\n", + " motifs=['A,0','CG,0'],\n", + " # parsing can optionally specify mod codes. \n", + " # The default is Y or a for adenine and m or Z for cytosine, corresponding to methylation\n", + " # motifs = ['A,0,Y','CG,0,Z'], \n", + " thresh=190,\n", + " window_size=1000,\n", + " # cores = 1, # uncomment this line if your process appears to be terminating early (reduces memory usage)\n", + " # quiet = True,\n", + " # cleanup = False,\n", + " # log=True,\n", + " modkit_executable=MODKIT_BINARY,\n", + " )\n", + " print('The code executed successfully.')\n", + "except Exception as e:\n", + " print('This is expected to fail. Read the error message below:\\n\\n')\n", + " print(e)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To fix this, follow the suggestion from the error and run `modkit update-tags`..." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "modkit selected: 0.6.1\n", + "modkit active : 0.6.1\n", + "$ modkit update-tags dimelo/test/data/ctcf_demo.sorted.bam dimelo/test/output/ctcf_demo.updated.bam --mode ambiguous\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[0;32m>\u001b[0m done, 1024 records processed\n" + ] + } + ], + "source": [ + "run_modkit_checked([\n", + " \"update-tags\",\n", + " \"dimelo/test/data/ctcf_demo.sorted.bam\",\n", + " \"dimelo/test/output/ctcf_demo.updated.bam\",\n", + " \"--mode\",\n", + " \"ambiguous\",\n", + "])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "ctcf_bam_file_updated = output_dir / 'ctcf_demo.updated.bam'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "...and reindex the resulting file." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "''" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pysam\n", + "\n", + "pysam.index(str(ctcf_bam_file_updated))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, the updated .bam file can be parsed, both for pileup and read extraction:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pileup_file, pileup_regions = parse_bam.pileup(\n", + " input_file=ctcf_bam_file_updated,\n", + " output_name='ctcf_demo_pileup_on_target',\n", + " ref_genome=ref_genome_file,\n", + " output_directory=output_dir,\n", + " regions=[ctcf_target_regions,ctcf_off_target_regions],\n", + " motifs=['A,0','CG,0'],\n", + " # parsing can optionally specify mod codes. \n", + " # The default is Y or a for adenine and m or Z for cytosine, corresponding to methylation\n", + " # motifs = ['A,0,Y','CG,0,Z'], \n", + " thresh=190,\n", + " window_size=1000,\n", + " # cores = 1, # uncomment this line if your process appears to be terminating early (reduces memory usage)\n", + " # quiet = True,\n", + " # cleanup = False,\n", + " # log=True,\n", + " modkit_executable=MODKIT_BINARY,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extract" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "extract_file, extract_regions = parse_bam.extract(\n", + " input_file=ctcf_bam_file_updated,\n", + " output_name='ctcf_demo_extract',\n", + " ref_genome=ref_genome_file,\n", + " output_directory=output_dir,\n", + " regions=[ctcf_target_regions,ctcf_off_target_regions],\n", + " motifs=['A,0','CG,0'],\n", + " # parsing can optionally specify mod codes. \n", + " # The default is Y or a for adenine and m or Z for cytosine, corresponding to methylation\n", + " # motifs = ['A,0,Y','CG,0,Z'], \n", + " thresh=190,\n", + " window_size=2000,\n", + " # cores = 1, # uncomment this line if your process appears to be terminating early (reduces memory usage)\n", + " # quiet = True,\n", + " # cleanup = False,\n", + " # log=True,\n", + " modkit_executable=MODKIT_BINARY,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plotting" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot Enrichment Profile" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from dimelo import plot_enrichment_profile" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "de000ce1b7a546d08095c12712c22e00", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading data: 0%| | 0/50 [00:00" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(4, 2)) # If you want a different sized plot, you can us matplotlib commands\n", + "plot_enrichment_profile.by_modification(\n", + " mod_file_name=pileup_file,\n", + " regions=ctcf_target_regions,\n", + " window_size=1000,\n", + " motifs=['A,0','CG,0'],\n", + " single_strand=False, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", + " regions_5to3prime=False, # if set to True, regions on the reverse (-) strand will be flipped so everything is 5 prime to 3 prime\n", + " smooth_window=50,\n", + " palette = { # you can pass down kwargs to sns barplot if you want to\n", + " 'A,0':'blue',\n", + " 'CG,0':'orange'\n", + " }\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1e0881ac48214764b5773570c1d0c32b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading data: 0%| | 0/50 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_enrichment_profile.by_regions(\n", + " mod_file_name=pileup_file,\n", + " regions_list=[ctcf_target_regions,ctcf_off_target_regions],\n", + " window_size=1000,\n", + " motif='A,0',\n", + " single_strand=False, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", + " regions_5to3prime=False, # if set to True, regions on the reverse (-) strand will be flipped so everything is 5 prime to 3 prime\n", + " smooth_window=50,\n", + ")\n", + "plt.xlabel('position relative to center of feature')\n", + "plt.ylabel('mA/A') # You can also use matplotlib commands to rename axes and more" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot Enrichment" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from dimelo import plot_enrichment" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f4a7d074a57c436c9a51880e55111215", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading data: 0%| | 0/50 [00:00" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGdCAYAAAD60sxaAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAM3BJREFUeJzt3Q9Y1GW+//83oICaYOoR/ENixWoGYqIimOGeSD25x8y21LWDaxw71aaUSomZZuYhM10sLS5bbf2T6XplrpmXm5KVpWmiVp7NP1kp+Q/RkrQUhfld7/v7m2lGBmRcxhnm83xc1yfnc889H+6ha+DF/bn/BNlsNpsAAABYSLCvGwAAAHC1EYAAAIDlEIAAAIDlEIAAAIDlEIAAAIDlEIAAAIDlEIAAAIDlEIAAAIDl1PN1A/xRRUWFHDlyRBo3bixBQUG+bg4AAKgBXdv5p59+klatWklwcPV9PAQgNzT8xMTE1OR7DQAA/ExRUZG0adOm2joEIDe058f+DYyIiPDO/x0AAFCrSktLTQeG/fd4dQhAbthve2n4IQABAFC31GT4CoOgAQCA5RCAAACA5RCAAACA5RCAAACA5RCAAACA5RCAAACA5RCAAACA5RCAAACA5RCAAACA5RCAAACA5RCAAACA5RCAAACA5RCAAACA5RCAAACA5dTzdQOsLCl7ka+bAPidwhkZvm4CAAugBwgAAFgOAQgAAFgOAQgAAFiOzwPQ3LlzJTY2VsLDwyU5OVm2bdtWbf0VK1ZIhw4dTP2EhARZu3aty/NnzpyRRx99VNq0aSMNGjSQjh07Sn5+vpffBQAAqEt8GoCWL18uY8aMkcmTJ8uOHTskMTFR+vbtK8XFxW7rb968WYYOHSqZmZmyc+dOGThwoDl2797tqKPXW7dunSxZskS++uoreeyxx0wgWr169VV8ZwAAwJ/5NADNmjVLRo4cKSNGjHD01DRs2FAWLFjgtv7s2bOlX79+kp2dLTfddJNMnTpVunTpInPmzHEJScOHD5fevXubnqUHH3zQBKvL9SwBAADr8FkAKisrk8LCQklPT/+1McHB5nzLli1uX6PlzvWV9hg5109NTTW9PYcPHxabzSYbN26Uffv2SZ8+fapsy/nz56W0tNTlAAAAgctnAaikpETKy8slKirKpVzPjx075vY1Wn65+i+//LLpTdIxQKGhoabHSMcZ3XbbbVW2JTc3VyIjIx1HTEzMv/z+AACA//L5IOjapgHo008/Nb1A2sM0c+ZM+dOf/iQbNmyo8jU5OTly+vRpx1FUVHRV2wwAACyyEnTz5s0lJCREjh8/7lKu59HR0W5fo+XV1f/ll19kwoQJ8vbbb0v//v1NWadOnWTXrl3y4osvVrp9ZhcWFmYOAABgDT7rAdLbU0lJSVJQUOAoq6ioMOcpKSluX6PlzvXV+vXrHfUvXLhgDh1L5EyDll4bAADA53uB6ZR1nbHVtWtX6d69u+Tl5cnZs2fNrDCVkZEhrVu3NmN0VFZWlqSlpZnbWtrDs2zZMtm+fbvMmzfPPB8REWGe11liugZQ27Zt5cMPP5RFixaZGWcAAAA+D0CDBw+WEydOyKRJk8xA5s6dO5s1fOwDnQ8dOuTSm6MzvJYuXSoTJ040t7ri4uJk1apVEh8f76ijoUjH9AwbNkxOnTplQtC0adPkoYce8sl7BAAA/ifIpnPF4UKnwetsMB0Qrb1K3sJu8EBl7AYP4Gr8/g64WWAAAACXQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACW4xcBaO7cuRIbGyvh4eGSnJws27Ztq7b+ihUrpEOHDqZ+QkKCrF271uX5oKAgt8eMGTO8/E4AAEBd4PMAtHz5chkzZoxMnjxZduzYIYmJidK3b18pLi52W3/z5s0ydOhQyczMlJ07d8rAgQPNsXv3bkedo0ePuhwLFiwwAeiee+65iu8MAAD4qyCbzWbzZQO0x6dbt24yZ84cc15RUSExMTEyatQoGT9+fKX6gwcPlrNnz8qaNWscZT169JDOnTtLfn6+26+hAemnn36SgoKCGrWptLRUIiMj5fTp0xIRESHekpS9yGvXBuqqwhkZvm4CgDrKk9/fPu0BKisrk8LCQklPT/+1QcHB5nzLli1uX6PlzvWV9hhVVf/48ePy7rvvmh6jqpw/f95805wPAAAQuHwagEpKSqS8vFyioqJcyvX82LFjbl+j5Z7UX7hwoTRu3FgGDRpUZTtyc3NNYrQf2gMFAAACl8/HAHmbjv8ZNmyYGTBdlZycHNNdZj+KioquahsBAMDVVU98qHnz5hISEmJuUznT8+joaLev0fKa1t+0aZPs3bvXDLSuTlhYmDkAAIA1+LQHKDQ0VJKSklwGJ+sgaD1PSUlx+xotv3Qw8/r1693Wnz9/vrm+ziwDAADwix4gpVPghw8fLl27dpXu3btLXl6emeU1YsQI83xGRoa0bt3ajNNRWVlZkpaWJjNnzpT+/fvLsmXLZPv27TJv3jyX6+pAZl0vSOsBAAD4VQDSae0nTpyQSZMmmYHMOp193bp1joHOhw4dMjPD7FJTU2Xp0qUyceJEmTBhgsTFxcmqVaskPj7e5boajHSGv64ZBAAA4FfrAPkj1gECfId1gAAE/DpAAAAAvkAAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAluNxAFq4cKG8++67jvMnnnhCmjRpIqmpqXLw4MHabh8AAIDvA9D//u//SoMGDczjLVu2yNy5c+WFF16Q5s2by+OPP177LQQAAPB1ACoqKpIbb7zRPF61apXcc8898uCDD0pubq5s2rTJ4wZogIqNjZXw8HBJTk6Wbdu2VVt/xYoV0qFDB1M/ISFB1q5dW6nOV199JQMGDJDIyEhp1KiRdOvWTQ4dOuRx2wAAQGDyOABdc801cvLkSfP4vffekzvuuMM81kDyyy+/eHSt5cuXy5gxY2Ty5MmyY8cOSUxMlL59+0pxcbHb+ps3b5ahQ4dKZmam7Ny5UwYOHGiO3bt3O+ocOHBAbr31VhOSPvjgA/niiy/k6aefNu0DAABQQTabzebJt2LYsGGyZ88eueWWW+TNN980PSvNmjWT1atXy4QJE1zCyOVoj4/2zsyZM8ecV1RUSExMjIwaNUrGjx9fqf7gwYPl7NmzsmbNGkdZjx49pHPnzpKfn2/OhwwZIvXr15fFixdf8f/h0tJS03t0+vRpiYiIEG9Jyl7ktWsDdVXhjAxfNwFAHeXJ7+/gK7lllZKSIidOnJC33nrLhB9VWFhoemdqqqyszLwmPT3918YEB5tzHVvkjpY711faY2SvrwFKB2j/5je/MeUtWrQwIUtv1VXn/Pnz5pvmfAAAgMBVz9MX6Iwve4+NsylTpnh0nZKSEikvL5eoqCiXcj3XHiZ3jh075ra+liu9dXbmzBl5/vnn5bnnnpPp06fLunXrZNCgQbJx40ZJS0tze10dv+Rp+wEAgMXWAdLBzvfff7+Z+n748GFTprecPv74Y/El7QFSd911l5mRprfG9Fba7373O8ctMndycnJMd5n90IHeAAAgcHkcgPS2l95e0qnwOnBZbx8pDQ46Rb6mdNp8SEiIHD9+3KVcz6Ojo92+Rsurq6/XrFevnnTs2NGlzk033VTtLLCwsDBzr9D5AAAAgcvjAKS3lrQ35bXXXjODje169uxpAlFNhYaGSlJSkhQUFLj04Oi5jjFyR8ud66v169c76us1dVD13r17Xers27dP2rZtW+O2AQCAwObxGCANF7fddlulch11/eOPP3p0LZ0CP3z4cOnatat0795d8vLyzCyvESNGmOczMjKkdevWZoyOysrKMuN4Zs6cKf3795dly5bJ9u3bZd68eY5rZmdnm9li2sbf/va3ZgzQO++8Y6bEAwAAXFEA0ttNX3/9tVm80JmO/7n++us9upYGFZ1NNmnSJDOQWcfsaGCxD3TW21Y6M8xOxxwtXbpUJk6caKbcx8XFmRle8fHxjjp333236aHS0DR69Ghp3769uW2nawMBAABc0TpAGiyWLFkiCxYsMIsg6krMugeYDjrWBQd1DZ+6jnWAAN9hHSAAV+P3t8c9QDqrSsfq3H777fLzzz+bW006iHjcuHEBEX4AAEDg8zgABQUFyVNPPWXG2uitMF13R2dd6RYZAAAAAbsOkH3GlQYf3XNrw4YNZgNSAACAgAxA9913n2MlaN38VKeda1mnTp3MYGMAAICAC0AfffSR9OrVyzx+++23zXggnf7+0ksvmTWCAAAAAi4A6cjqpk2bmsc6Zf2ee+6Rhg0bmnV59u/f7402AgAA+DYAxcTEmN3XdcFCDUB9+vQx5T/88IOEh4fXbusAAAD8YRbYY489JsOGDTOzvnR7id69eztujSUkJHijjQAAAL4NQI888ogkJyebVZp1IUT7Ss26CjRjgAAAQEAGIKWbmOrhTMcAAQAABGwA+v7772X16tWmF6isrMzluVmzZtVW2wAAAPwjABUUFMiAAQPMLa89e/aYjUi/++470S3FunTp4p1WAgAA+HIWWE5Ojtn368svvzSzvnTxw6KiIklLS5N77723NtsGAADgHwFIt7zIyMgwj+vVq2dWg9YZYc8++6xMnz7dG20EAADwbQBq1KiRY9xPy5Yt5cCBA47nSkpKard1AAAA/jAGqEePHvLxxx/LTTfdJHfeeaeMHTvW3A5buXKleQ4AACDgApDO8jpz5ox5PGXKFPN4+fLlEhcXxwwwAAAQmAFIZ3853w7Lz8+v7TYBAAD43zpAavv27WZAtOrYsWOlhREBAAACJgDpIohDhw6VTz75RJo0aWLKfvzxR0lNTZVly5ZJmzZtvNFOAAAA380C++///m+5cOGC6f05deqUOfRxRUWFeQ4AACDgeoA+/PBD2bx5s7Rv395Rpo9ffvll6dWrV223DwAAwPc9QDExMaYH6FLl5eXSqlWr2moXAACA/wSgGTNmyKhRo8wgaDt9nJWVJS+++GJttw8AAMA3t8CuvfZaCQoKcpyfPXtWkpOTzVYY6uLFi+bxAw88IAMHDqz9VgIAAFztAJSXl1ebXxMAAMD/A9Dw4cO93xIAAAB/HQMEAABQ1xGAAACA5RCAAACA5RCAAACA5RCAAACA5dRoFtigQYNqfMGVK1d63Ii5c+eaBRaPHTsmiYmJZluN7t27V1l/xYoV8vTTT8t3330ncXFxMn36dLnzzjsdz//xj3+UhQsXurymb9++sm7dOo/bBgAALNoDFBkZ6TgiIiKkoKDAZSXowsJCU6bPe2r58uUyZswYmTx5suzYscMEIA0rxcXFbuvrPmS6G31mZqbs3LnTLLyox+7du13q9evXT44ePeo43nzzTY/bBgAAAlOQzWazefKCJ5980uwAn5+fLyEhIY59wB555BETjrQnxxO6onS3bt1kzpw55lx3ldf9xnS7jfHjx1eqP3jwYLMS9Zo1axxlPXr0kM6dO5s22XuAfvzxR1m1apVcidLSUhPmTp8+bd6TtyRlL/LatYG6qnBGhq+bAKCO8uT3t8djgBYsWCDjxo1zhB+lj7UXR5/zRFlZmek9Sk9P/7VBwcHmfMuWLW5fo+XO9ZX2GF1a/4MPPpAWLVqYneoffvhhOXnyZJXtOH/+vPmmOR8AACBweRyAdN+vPXv2VCrXMu298URJSYnpPYqKinIp13MdD+SOll+uvt7+WrRokbktp+ODPvzwQ/mP//gP87Xcyc3NdbnNpz1QAADA4oOgnY0YMcKMvzlw4IBjoPLWrVvl+eefN8/5gyFDhjgeJyQkSKdOneSGG24wvUK33357pfo5OTmmB8tOe4AIQQAABC6PA9CLL74o0dHRMnPmTDO4WLVs2VKys7Nl7NixHl2refPm5vbZ8ePHXcr1XL+GO1ruSX11/fXXm6/19ddfuw1AYWFh5gAAANbg8S0wHaPzxBNPyOHDh81AYz30sZY5jwuqidDQUElKSjK3quz0Npqep6SkuH2NljvXV+vXr6+yvvr+++/NGCANagAAAFe0EKKOA9qwYYOZWh4UFGTKjhw5ImfOnPH4Wnrr6bXXXjPr9nz11VdmwLLO8rLfTsvIyDC3qOyysrLMej7aA6Xjjp555hkzJf/RRx81z2sbtDfq008/NesEaVi666675MYbbzSDpQEAADy+BXbw4EEzyPjQoUNm9tQdd9whjRs3NoON9dw+Fb2mdFr7iRMnZNKkSWYgs05n14BjH+isX0d7nexSU1Nl6dKlMnHiRJkwYYJZCFGnu8fHx5vntRfqiy++MIFKe6datWolffr0kalTp3KbCwAAXNk6QLrooAae+fPnS7NmzeTzzz83Y2x0gPHIkSNl//79UtexDhDgO6wDBOBq/P72uAdo06ZNZjVmHb/jLDY21owFAgAACLgxQDpI2d16OjrQWHuGAAAAAi4A6XiavLw8x7kOgtaBx7qXl/OGpAAAAP7K41tgOvtKZ1N17NhRzp07J3/4wx/MuB9dZ4cNRwEAQEAGoDZt2piBz8uWLTOzrbT3R1eGHjZsmDRo0MA7rQQAAPBlADIvqldP7r///tpsBwAAgH8FoNWrV5vNROvXr28eV2fAgAG11TYAAADfBSBd+0cXKWzRooV5XBUdEF3VjusAAAB1KgDp1Hd3jwEAAAJ2GnzTpk2lpKTEPH7ggQfkp59+8na7AAAAfBuAysrKzPLSSvfY0unvAAAAAX0LLCUlxYz9SUpKEt06bPTo0VVOeV+wYEFttxEAAODqB6AlS5bIn//8Zzlw4IAZ6KybjNELBAAAAjoARUVFyfPPP28et2vXThYvXmx2ggcAALDEQojffvutd1oCAADgTwHopZdekgcffFDCw8PN4+ro+CAAAIA6H4B0/I/u9aUBSB9XRccHEYAAAEBABCDn217cAgMAAJZYBwgAAMByPUBjxoyp8QVnzZr1r7QHAADAPwLQzp07Xc537NghFy9elPbt25vzffv2SUhIiFkoEQAAICAC0MaNG116eBo3bmy2xLj22mtN2Q8//CAjRoyQXr16ea+lAAAAvhoDNHPmTMnNzXWEH6WPn3vuOfMcAABAwAUg3RT1xIkTlcq1jF3iAQBAQAagu+++29zuWrlypXz//ffmeOuttyQzM1MGDRrknVYCAAD4ciuM/Px8GTdunPzhD3+QCxcu/L+L1KtnAtCMGTNqs20AAAD+EYAaNmwor7zyigk7uju8uuGGG6RRo0beaB8AAIDvA5CdBp6mTZs6HgMAAATsGKCKigp59tlnJTIyUtq2bWuOJk2ayNSpU81zAAAAAdcD9NRTT8n8+fPl+eefl549e5qyjz/+WJ555hk5d+6cTJs2zRvtBAAA8F0A0gUQ//KXv8iAAQMcZZ06dZLWrVvLI488QgACAACBdwvs1KlT0qFDh0rlWqbPAQAABFwASkxMlDlz5lQq1zJ97krMnTtXYmNjJTw8XJKTk2Xbtm3V1l+xYoUJXFo/ISFB1q5dW2Xdhx56SIKCgiQvL++K2gYAAAKPx7fAXnjhBenfv79s2LBBUlJSTNmWLVukqKio2iBSleXLl5vd5nV9IQ0/GlT69u0re/fulRYtWlSqv3nzZhk6dKjZjuN3v/udLF26VAYOHGg2aI2Pj3ep+/bbb8unn34qrVq18rhdAAAgcHncA5SWlmZ2f9cVoX/88Udz6ArQGliuZDNU3Vx15MiRZnXpjh07miCkaw0tWLDAbf3Zs2dLv379JDs7W2666SYz+6xLly6VeqUOHz4so0aNkjfeeEPq16/vcbsAAEDguqJ1gLRHpTZme5WVlUlhYaHk5OQ4yoKDgyU9Pd30Krmj5dpj5Ex7jFatWuU41+n4//Vf/2VC0s0333zZdpw/f94czvudAQCAwHVFAUinu3/xxRdSXFxcae0f59lhl1NSUiLl5eUSFRXlUq7ne/bscfuaY8eOua2v5XbTp08323OMHj26Ru3Q22lTpkypcbsBAIDFAtC6deskIyPDhJdL6WBjDTS+pD1KeptMxwRpe2pCe6Cce5W0BygmJsaLrQQAAHVqDJCOq7n33nvl6NGjpvfH+fA0/DRv3lxCQkLk+PHjLuV6Hh0d7fY1Wl5d/U2bNpmeqeuuu870Aulx8OBBGTt2rJlp5k5YWJhERES4HAAAIHB5HIA0bGhvyaW3oa5EaGioJCUlSUFBgaNMg5Se22eYXUrLneur9evXO+rr2B+9Pbdr1y7HoWOWdDzQP/7xj3+5zQAAwIK3wH7/+9/LBx98YHaArw0apoYPHy5du3aV7t27m2nwZ8+eNbPClN5u01WmdZyOysrKMjPRZs6caabjL1u2TLZv3y7z5s0zzzdr1swcznQWmPYQtW/fvlbaDAAALBaAdLq53gLTW026COGlU8xrOvDYbvDgwXLixAmZNGmSGcjcuXNnM87I3sN06NAhMzPMLjU11az9M3HiRJkwYYLExcWZGWCXrgEEAABQlSCbzWYTD+hGqLq6sq7CrD0tzgON9fE333wjdZ0Ogtbd7k+fPu3V8UBJ2Yu8dm2griqckeHrJgCwwO/vK9oNXqeMjx8/3qVnBgAAoK4IvpLFC/W2FeEHAABYJgDpgGXdvwsAAKCu8vgWmK71oxui6pTyTp06VRoErXt7AQAABFQA+vLLL+WWW24xj3fv3u3yXE1XXgYAAKhTAWjjxo3eaQkAAMBVwjQuAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOR7PAlP79+83s8GKi4uloqLC5Tnd1BQAACCgAtBrr70mDz/8sDRv3lyio6MrbYZKAAIAAAEXgJ577jmZNm2aPPnkk95pEQAAgL+NAfrhhx/k3nvv9U5rAAAA/DEAafh57733vNMaAAAAf7wFduONN8rTTz8tn376qSQkJFTaDHX06NG12T4AAADfB6B58+bJNddcIx9++KE5nOkgaAIQAAAIuAD07bffeqclAAAAdWEhRJvNZg4AAICAD0CLFi0y438aNGhgjk6dOsnixYtrv3UAAAD+cAts1qxZZhD0o48+Kj179jRlH3/8sTz00ENSUlIijz/+uDfaCQAA4LsA9PLLL8urr74qGRkZjrIBAwbIzTffLM888wwBCAAABN4tsKNHj0pqamqlci3T5wAAAAIuAOk6QH/7298qlS9fvlzi4uJqq10AAAD+cwtsypQpMnjwYPnoo48cY4A++eQTKSgocBuMAAAA6nwP0D333CNbt241u8GvWrXKHPp427Ztcvfdd3unlQAAAL7sAVJJSUmyZMmS2mwHAACAfwWg0tJSiYiIcDyujr0eAABAnQ5A1157rZnh1aJFC2nSpInZ8+tSuiK0lpeXl3ujnQAAAFc3AL3//vvStGlT83jjxo2199UBAAD8NQClpaU5Hrdr105iYmIq9QJpD1BRUVHttxAAAMDXs8A0AJ04caJS+alTp8xzV2Lu3LkSGxsr4eHhkpycbGaUVWfFihXSoUMHU1/3JFu7dq3L87oitT7fqFEjc/suPT3dzFwDAAC4ogBkH+tzqTNnzphA4ildQHHMmDEyefJk2bFjhyQmJkrfvn2luLjYbf3NmzfL0KFDJTMzU3bu3CkDBw40x+7dux11fvOb38icOXPkyy+/NPuUabjq06eP2+AGAACsJ8imiaYGNKSo2bNny8iRI6Vhw4aO53Tgs/awhISEmEURPaE9Pt26dTOBRVVUVJhbbKNGjZLx48dXqq+LMJ49e1bWrFnjKOvRo4d07txZ8vPz3X4NnbkWGRkpGzZskNtvv/2ybbLXP336tFdntSVlL/LatYG6qnDGr/sMAoAnPPn9XeN1gLS3RWle0p6V0NBQx3P6WHtuxo0b51FDy8rKpLCwUHJychxlwcHB5pbVli1b3L5Gy+1hzE57jHRBxqq+xrx588w3RNvozvnz581hd7mp/gAAoG6rcQCyz/4aMWKE6QWqjZ6RkpIS03sUFRXlUq7ne/bscfuaY8eOua2v5c60h2jIkCHy888/S8uWLWX9+vVmxWp3cnNzzRYfAADAGjweA5SXlycXL150Owjan3pOfvvb38quXbvMmKF+/frJfffdV+W4Iu2B0u4y+8FsNgAAApvHAUh7VZYtW1apXDdC1ec8oT0yOm7o+PHjLuV6Hh0d7fY1Wl6T+joDTHeu1/FB8+fPl3r16pl/3QkLCzM9Ws4HAAAIXB4HIB3srL0rl+rdu7fHU8117JDuK6Y7ydvpIGg9T0lJcfsaLXeur/T2VlX1na/rPM4HAABYl8eboWqIcHcL7MKFC/LLL7943AAd0Dx8+HDp2rWrdO/e3dxi01leOtZIZWRkSOvWrc04HZWVlWUWZpw5c6b079/f9EZt377dDHRW+tpp06bJgAEDzNgfHWek6wwdPnxY7r33Xo/bBwAAAo/HAUhDioaNl19+2aVcp6Brb46ndFq7rs8zadIkM5BZp7OvW7fOMdD50KFDZmaYXWpqqixdulQmTpwoEyZMkLi4ODMDLD4+3jyvt9R0APXChQtN+GnWrJmZZr9p0ya5+eabPW4fAACw8DpAdrrOj05T11BhX1NHb0l99tln8t5770mvXr2krmMdIMB3WAcIwNX4/e3xGKCePXuatXh0sUId+PzOO++YwcZffPFFQIQfAAAQ+Dy+Bab0NtUbb7xR+60BAADw1wBkd+7cObPSsjOmkAMAAH/n8S0wXVn50UcflRYtWjh2W3c+AAAAAi4AZWdny/vvvy+vvvqqWUDwL3/5i9lGolWrVrJoEZt7AgCAALwFpoOeNejowoe6Vo8OfNZB0G3btjXjgoYNG+adlgIAAPiqB0j3/Lr++usd4330XN16663y0Ucf1Va7AAAA/CcAafj59ttvzeMOHTqYqfD2nqEmTZrUfgsBAAB8HYD0ttfnn39uHo8fP95sMxEeHi6PP/64GR8EAAAQcGOANOjY6YrQuu1EYWGhGQfUqVOn2m4fAACAb3uAdMNT3f5i//79jjId/Dxo0CDCDwAACMwAVL9+fbPlBQAAgKXGAN1///0yf/5877QGAADgKvB4DNDFixdlwYIFsmHDBklKSjKrQTubNWtWbbYPAADA9wFo9+7d0qVLF/N43759Ls8FBQXVXssAAAB8GYB03E98fLwEBwfLxo0bvdUWAAAA/xkDdMstt0hJSYljIcSTJ096u10AAAC+DUC6wrN99efvvvtOKioqvNciAAAAf7gFds8990haWpq0bNnSjPPp2rWrhISEuK37zTff1HYbAQAArn4Amjdvnlns8Ouvv5bRo0fLyJEjpXHjxrXbEgAAAH+bBdavXz/zr257kZWVRQACAADWmQb/+uuve6clAAAA/roSNAAAQF1HAAIAAJZDAAIAAJZDAAIAAJZDAAIAAJZDAAIAAJZDAAIAAJZDAAIAAJZDAAIAAJZDAAIAAJbjFwFo7ty5EhsbK+Hh4ZKcnCzbtm2rtv6KFSukQ4cOpn5CQoKsXbvW8dyFCxfkySefNOWNGjWSVq1aSUZGhhw5cuQqvBMAAFAX+DwALV++XMaMGSOTJ0+WHTt2SGJiovTt21eKi4vd1t+8ebMMHTpUMjMzZefOnTJw4EBz7N692zz/888/m+s8/fTT5t+VK1fK3r17ZcCAAVf5nQEAAH8VZLPZbL5sgPb4dOvWTebMmWPOKyoqJCYmRkaNGiXjx4+vVH/w4MFy9uxZWbNmjaOsR48e0rlzZ8nPz3f7NT777DPp3r27HDx4UK677rrLtqm0tFQiIyPl9OnTEhERId6SlL3Ia9cG6qrCGRm+bgKAOsqT398+7QEqKyuTwsJCSU9P/7VBwcHmfMuWLW5fo+XO9ZX2GFVVX+k3IigoSJo0aeL2+fPnz5tvmvMBAAACl08DUElJiZSXl0tUVJRLuZ4fO3bM7Wu03JP6586dM2OC9LZZVWkwNzfXJEb7oT1QAAAgcPl8DJA36YDo++67T/Qu36uvvlplvZycHNNLZD+KioquajsBAMDVVU98qHnz5hISEiLHjx93Kdfz6Ohot6/R8prUt4cfHffz/vvvV3svMCwszBwAAMAafNoDFBoaKklJSVJQUOAo00HQep6SkuL2NVruXF+tX7/epb49/Ozfv182bNggzZo18+K7AAAAdY1Pe4CUToEfPny4dO3a1czUysvLM7O8RowYYZ7XNXxat25txumorKwsSUtLk5kzZ0r//v1l2bJlsn37dpk3b54j/Pz+9783U+B1ppiOMbKPD2ratKkJXQAAwNp8HoB0WvuJEydk0qRJJqjodPZ169Y5BjofOnTIzAyzS01NlaVLl8rEiRNlwoQJEhcXJ6tWrZL4+Hjz/OHDh2X16tXmsV7L2caNG6V3795X9f0BAAD/4/N1gPwR6wABvsM6QAACfh0gAAAAXyAAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAy/F5AJo7d67ExsZKeHi4JCcny7Zt26qtv2LFCunQoYOpn5CQIGvXrnV5fuXKldKnTx9p1qyZBAUFya5du7z8DgAAQF3j0wC0fPlyGTNmjEyePFl27NghiYmJ0rdvXykuLnZbf/PmzTJ06FDJzMyUnTt3ysCBA82xe/duR52zZ8/KrbfeKtOnT7+K7wQAANQlQTabzearL649Pt26dZM5c+aY84qKComJiZFRo0bJ+PHjK9UfPHiwCThr1qxxlPXo0UM6d+4s+fn5LnW/++47adeunQlK+rwnSktLJTIyUk6fPi0RERHiLUnZi7x2baCuKpyR4esmAKijPPn97bMeoLKyMiksLJT09PRfGxMcbM63bNni9jVa7lxfaY9RVfVr6vz58+ab5nwAAIDA5bMAVFJSIuXl5RIVFeVSrufHjh1z+xot96R+TeXm5prEaD+0FwoAAAQunw+C9gc5OTmmu8x+FBUV+bpJAADAi+qJjzRv3lxCQkLk+PHjLuV6Hh0d7fY1Wu5J/ZoKCwszBwAAsAaf9QCFhoZKUlKSFBQUOMp0ELSep6SkuH2NljvXV+vXr6+yPgAAgF/1ACmdAj98+HDp2rWrdO/eXfLy8swsrxEjRpjnMzIypHXr1maMjsrKypK0tDSZOXOm9O/fX5YtWybbt2+XefPmOa556tQpOXTokBw5csSc79271/yrvUT/ak8RAAAIDD4NQDqt/cSJEzJp0iQzkFmnq69bt84x0FmDjM4Ms0tNTZWlS5fKxIkTZcKECRIXFyerVq2S+Ph4R53Vq1c7ApQaMmSI+VfXGnrmmWeu6vsDAAD+yafrAPkr1gECfCdQ1gE69GyCr5sA+J3rJn3p1evXiXWAAAAAfIUABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALIcABAAALMcvAtDcuXMlNjZWwsPDJTk5WbZt21Zt/RUrVkiHDh1M/YSEBFm7dq3L8zabTSZNmiQtW7aUBg0aSHp6uuzfv9/L7wIAANQVPg9Ay5cvlzFjxsjkyZNlx44dkpiYKH379pXi4mK39Tdv3ixDhw6VzMxM2blzpwwcONAcu3fvdtR54YUX5KWXXpL8/HzZunWrNGrUyFzz3LlzV/GdAQAAf+XzADRr1iwZOXKkjBgxQjp27GhCS8OGDWXBggVu68+ePVv69esn2dnZctNNN8nUqVOlS5cuMmfOHEfvT15enkycOFHuuusu6dSpkyxatEiOHDkiq1atusrvDgAA+KN6vvziZWVlUlhYKDk5OY6y4OBgc8tqy5Ytbl+j5dpj5Ex7d+zh5ttvv5Vjx46Za9hFRkaaW2v62iFDhlS65vnz581hd/r0afNvaWmpeFP5+V+8en2gLvL25+5q+elcua+bAFju8136/19fO0P8OgCVlJRIeXm5REVFuZTr+Z49e9y+RsONu/pabn/eXlZVnUvl5ubKlClTKpXHxMR4+I4A/KsiX36IbyIQqHIjr8qX+emnn0znh98GIH+hPVDOvUoVFRVy6tQpadasmQQFBfm0bfA+/YtBw25RUZFERETwLQcCCJ9va7HZbCb8tGrV6rJ1fRqAmjdvLiEhIXL8+HGXcj2Pjo52+xotr66+/V8t01lgznU6d+7s9pphYWHmcNakSZMrfFeoqzT8EICAwMTn2zoiL9Pz4xeDoENDQyUpKUkKCgpcel/0PCUlxe1rtNy5vlq/fr2jfrt27UwIcq6jfwHobLCqrgkAAKzF57fA9NbT8OHDpWvXrtK9e3czg+vs2bNmVpjKyMiQ1q1bm3E6KisrS9LS0mTmzJnSv39/WbZsmWzfvl3mzZtnntdbVo899pg899xzEhcXZwLR008/bbrDdLo8AACAzwPQ4MGD5cSJE2bhQh2krLep1q1b5xjEfOjQITMzzC41NVWWLl1qprlPmDDBhBydARYfH++o88QTT5gQ9eCDD8qPP/4ot956q7mmLpwIXEpvf+o6VJfeBgVQ9/H5RlWCbDWZKwYAABBAfL4QIgAAwNVGAAIAAJZDAAIAAJZDAAIA+Nwnn3wiCQkJUr9+fceMXXdlQG0hACGgfffdd2ZphF27dom/8Mc2Af6wJIrOAtb9HP/6179WWXap2NhYs3yKP/HHNqEyAhBQQxcuXOB7BXjJgQMH5N///d+lTZs2jpX43ZV5c3NuWIxOgwf8wblz52yjRo2y/du//ZstLCzM1rNnT9u2bdscz2/cuFGXbLBt2LDBlpSUZGvQoIEtJSXFtmfPniqvqfWdj7S0NFOu101PT7c1a9bMFhERYbvttttshYWFlV77yiuv2P7zP//T1rBhQ9vkyZNN+dSpU00br7nmGltmZqbtySeftCUmJrq89rXXXrN16NDBvI/27dvb5s6de9k2AVb8bH/77beVPhOvv/6627JL6Wfn0nqqpKTENmTIEFurVq3Mz4n4+Hjb0qVLK732T3/6ky0rK8v8HOjdu7cp//vf/2678cYbTTu17K9//au57g8//OB47aZNm2y33nqrLTw83NamTRvz3s6cOVNtm+B/+D8DvzF69GjzA2vt2rW2//u//7MNHz7cdu2119pOnjzpEoCSk5NtH3zwganTq1cvW2pqapXX1B+y9tB09OhRx7UKCgpsixcvtn311Ve2f/7znybIREVF2UpLSx2v1de1aNHCtmDBAtuBAwdsBw8etC1ZssT80NOyvXv32qZMmWIClHMA0jotW7a0vfXWW7ZvvvnG/Nu0aVPzg7S6NgFW/GxfvHjRfA70c5SXl2cea5i4tOznn3+udF19vQaQZ5991tTRQ33//fe2GTNm2Hbu3Gk+uy+99JItJCTEtnXrVsdrNajoHzHZ2dnmjyg99PNav35927hx48z5m2++aWvdurVLAPr6669tjRo1sv35z3+27du3z/bJJ5/YbrnlFtsf//jHatsE/0MAgl/QH3j6g+eNN95wlJWVlZkfmi+88EKlHiC7d99915T98ssvbq9r/+tSfxBWp7y83Na4cWPbO++84yjT1z322GMu9TR86V+NzvSvWecAdMMNN1T6a1N7jbS3ypM2AVb5bKvIyMhKvTzuyi7Vtm1bE0Yup3///raxY8e6BCANLs60N1d7i5w99dRTLgFI/1h68MEHXepoj1BwcLDj51BN2wTfYgwQ/ILe69cxNj179nSU6cwP3R/uq6++cqnbqVMnx+OWLVuaf4uLiz36esePH5eRI0earVR052DdKfrMmTNm6xVnukeds71795o2OXM+1y1Y9L1kZmbKNddc4zh0bzotB6zGk892bSkvL5epU6eaGWRNmzY1n8F//OMflT7fuhn3pZ/vbt26uZRd+nn//PPPzYBs58933759zUbeOlgbdYfP9wIDPKU/PO10NpXSHz6e0A14T548KbNnz5a2bdua/YJSUlIqDYRs1KiRR9fVEKVee+01SU5OdnkuJCTEo2sBuDIzZswwn22diaUhSD/Hukn2v/r5tn/G/+d//kdGjx5d6bnrrruO/2V1CD1A8As33HCDhIaGmnU/7PSvxs8++0w6dux4xdfVa9r/InSmX0d/gN15551y8803mwBUUlJy2eu1b9/etMmZ87lu4tuqVSv55ptv5MYbb3Q52rVrV22bgEDkrc+2nV7b3ef7rrvukvvvv18SExPl+uuvl3379tXo8719+3aXsks/7126dJF//vOflT7fetg/2+7aBP9DAIJf0L/EHn74YcnOzpZ169aZHzB6i+rnn382t5OuVIsWLaRBgwbmmnrb6/Tp06Zcb30tXrzYdMFv3bpVhg0bZupdzqhRo2T+/PmycOFC2b9/v7m19cUXXzh6otSUKVMkNzdXXnrpJfND98svv5TXX39dZs2aVW2bgEDkrc+285o7H330kRw+fNjxR4x+vtevXy+bN282n3HtsdHP2uVovT179siTTz5pPrt/+9vfHOsP2T/j+pxe99FHHzVreenPgb///e/mvLo2wQ/5eAwS4KADCHU6afPmzaudBu88HVUHEmuZDiyuik5Jj4mJMYMU7VPOd+zYYevatauZ0RUXF2dbsWJFpYGLet2333670vV0doe2UWeQPPDAA2aGS48ePVzq6IDPzp0720JDQ81sF51mv3LlymrbBFj1s/2vDILesmWLrVOnTua69l9pOhPrrrvuMp9Rnck5ceJEW0ZGhimz08+dToG/1KXT4F999dVKEy207XfccYe5vs4I068/bdq0atsE/xOk//F1CAPqsjvuuEOio6NNjxKAwDJt2jTJz8+XoqIiXzcFtYxB0IAHtNtefxjqrA8d1Pzmm2/Khg0bTHc7gLrvlVdeMTPBmjVrZsYS6YBq59tbCBwEIMADOg5g7dq15q/Cc+fOmUGTb731lqSnp/N9BAKAfWzfqVOnzKyusWPHSk5Ojq+bBS/gFhgAALAcZoEBAADLIQABAADLIQABAADLIQABAADLIQABAADLIQABAADLIQABAADLIQABAADLIQABAACxmv8PG4BKYZiltJcAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_enrichment.by_regions(\n", + " mod_file_name=pileup_file,\n", + " regions_list=[ctcf_target_regions, ctcf_off_target_regions],\n", + " motif='A,0',\n", + " single_strand=False, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", + " sample_names=['on target', 'off target'],\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "08c132c9a990451cb5d892639d55b4c3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading data: 0%| | 0/50 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_enrichment.by_modification(\n", + " mod_file_name=pileup_file,\n", + " regions=ctcf_target_regions,\n", + " motifs=['A,0','CG,0'],\n", + " single_strand=False, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", + " )\n", + "plt.title(ctcf_target_regions)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e1ee52758d5a49cf8e7698b298f634fe", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading data: 0%| | 0/100 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_enrichment.by_modification(\n", + " mod_file_name=pileup_file,\n", + " regions=ctcf_off_target_regions,\n", + " motifs=['A,0','CG,0'],\n", + " single_strand=False, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", + " )\n", + "plt.title(ctcf_off_target_regions)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot Reads" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from dimelo import plot_reads" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, \"CTCF target data, 100 known binding locations\\nsort_by=['shuffle'] i.e. default\")" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_reads.plot_reads(\n", + " mod_file_name=extract_file,\n", + " regions=ctcf_target_regions,\n", + " motifs=['A,0', 'CG,0'],\n", + " window_size=1000,\n", + " single_strand=False, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", + " regions_5to3prime=False, # if set to True, regions on the reverse (-) strand will be flipped so everything is 5 prime to 3 prime\n", + ")\n", + "plt.title(\"CTCF target data, 100 known binding locations\\nsort_by=['shuffle'] i.e. default\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot Browser" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The read browser plot lets you see modification locations and probabilities in the same visualization. While the `pileup` operation and downstream plots by definition requires a threshold, but plot browser requires raw probabilities. Read extraction can be run with *either* binary modification calls *or* raw probabilities. Run the cell below to re-extract the single reads but with raw base modification probabilities for plot browser." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from dimelo import plot_read_browser" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This is expected to fail. Read the error message below:\n", + "\n", + "\n", + "A threshold has been applied to this .h5 single read data. plot_read_browser must be used with an .h5 file extracted using thresh=None.\n" + ] + } + ], + "source": [ + "try:\n", + " plot_read_browser.plot_read_browser(\n", + " mod_file_name=extract_file,\n", + " region='chr1:114357437-114359753', # you can only browser a single region, not a bed file or list of regions.\n", + " # The only cap on region size is your computer's memory and your patience\n", + " motifs=['CG,0','A,0'],\n", + " thresh=0.5,\n", + " single_strand=False,\n", + " sort_by=\"collapse\",#you can sort by anything that the loading function accepts, but the special \"collapse\" option doesn't allow other sorting\n", + " hover=False, #turning off hover will remove the hoverover read names and other info \n", + " )\n", + "except Exception as e:\n", + " print('This is expected to fail. Read the error message below:\\n\\n')\n", + " print(e)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "extract_file_no_thresh, _ = parse_bam.extract(\n", + " input_file=ctcf_bam_file_updated,\n", + " output_name='ctcf_demo_extract_no_thresh',\n", + " ref_genome=ref_genome_file,\n", + " output_directory=output_dir,\n", + " regions=[ctcf_target_regions,ctcf_off_target_regions],\n", + " motifs=['A,0','CG,0'],\n", + " # parsing can optionally specify mod codes. \n", + " # The default is Y or a for adenine and m or Z for cytosine, corresponding to methylation\n", + " # motifs = ['A,0,Y','CG,0,Z'], \n", + " # thresh=190,\n", + " window_size=1000,\n", + " # cores = 1, # uncomment this line if your process appears to be terminating early (reduces memory usage)\n", + " # quiet = True,\n", + " # cleanup = False,\n", + " # log=True,\n", + " modkit_executable=MODKIT_BINARY,\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Resorting to unclean kill browser.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import Image, display\n", + "from plotly.io import to_image\n", + "fig = plot_read_browser.plot_read_browser(\n", + " mod_file_name=extract_file_no_thresh,\n", + " region='chr1:114357437-114359753', # you can only browser a single region, not a bed file or list of regions.\n", + " # The only cap on region size is your computer's memory and your patience\n", + " motifs=['CG,0','A,0'],\n", + " thresh=0.5,\n", + " single_strand=False,\n", + " sort_by=\"collapse\",#you can sort by anything that the loading function accepts, but the special \"collapse\" option doesn't allow other sorting\n", + " hover=False, #turning off hover will remove the hoverover read names and other info\n", + ")\n", + "# plot browser is made using plotly, so you can use the returned \"fig\" object to make updates using plotly commands\n", + "fig.update_layout(\n", + " width=1000,# these values are in pixels\n", + " height=300, \n", + " title={\n", + " 'text': 'DiMeLo-seq CTCF and CpG methylation',\n", + " 'x': 0.5,\n", + " 'xanchor': 'center',\n", + " 'y': 0.75, # Adjust the vertical position of the title\n", + " 'yanchor': 'top',\n", + " 'pad': {'b': 10} \n", + " },\n", + " xaxis_title='chr1 coordinate, t2t v1.0',\n", + " yaxis_title='reads'\n", + ")\n", + "# Comment out these lines to display an interactive plot with e.g. zoom and pan\n", + "png_bytes = to_image(fig, format=\"png\", width=1000, height=300)\n", + "display(Image(png_bytes))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When using the read browser, one can optionally request plotting of a random subset of the reads using the `subset_parameters` argument:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+gAAAEsCAYAAABQRZlvAAAQAElEQVR4AeydB2AUxdvGn730BEgIhN6rNOkWLKAoKmIBsQv2Loj8sYuNDxRFFBREsYCKoKCAoIgKgiiigPQu0nsLhATSv3nnssfd5ZLcJXeXu8tzyezstHfe+c3c7r4zu3uWXH5IgARIgARIgARIgARIgARIgARIgARKnYAFPv1QOAmQAAmQAAmQAAmQAAmQAAmQAAmQgDsEgttAd6eFzEMCJEACJEACJEACJEACJEACJEACQUCABnohncQkEiABEiABEiABEiABEiABEiABEvAXARro/iKdvx7GkAAJkAAJkAAJkAAJkAAJkAAJkICNAA10G4pQ22F7SIAESIAESIAESIAESIAESIAEgokADfRg6q1A0pW6kAAJkAAJkAAJkAAJkAAJkAAJeJUADXSv4qQwbxGgHBIgARIgARIgARIgARIgARIoawRooJe1Hmd7hQAdCZAACZAACZAACZAACZAACQQcARroAdclVCj4CbAFJEACJEACJEACJEACJEACJOA5ARronjNjCRIoXQKsnQRIgARIgARIgARIgARIICQJ0EAPyW5lo0ig+ARYkgRIgARIgARIgARIgARIoHQI0EAvHe6slQTKKgG2mwRIgARIgARIgARIgARIoAACNNALAMNoEiCBYCRAnUmABEiABEiABEiABEggeAnQQA/evqPmJEAC/ibA+kiABEiABEiABEiABEjAhwRooPsQLkWTAAmQgCcEmJcESIAESIAESIAESKBsE6CBXrb7n60nARIoOwTYUhIgARIgARIgARIggQAnQAM9wDuI6pEACZBAcBCgliRAAiRAAiRAAiRAAiUlQAO9pARZngRIgARIwPcEWAMJkAAJkAAJkAAJlAECNNDLQCeziSRAAiRAAoUTYCoJkAAJkAAJkAAJBAIBGuiB0AvUgQRIgARIIJQJsG0kQAIkQAIkQAIk4BYBGuhuYWImEiABEiABEghUAtSLBEiABEiABEggVAjQQA+VnmQ7SIAESIAESMAXBCiTBEiABEiABEjAbwRooPsNNSsiARIgARIgARJwJsAwCZAACZAACZDAGQI00M+w4B4JkAAJkAAJkEBoEWBrSIAESIAESCCoCNBAD6ruorIkQAIkQAIkQAKBQ4CakAAJkAAJkIB3CdBA9y5PSiMBEiABEiABEiAB7xCgFBIgARIggTJHgAZ6metyNpgESIAESIAESIAEADIgARIgARIIPAI00AOvT6gRCZAACZAACZAACQQ7AepPAiRAAiRQDAI00IsBjUVIgARIgARIgARIgARKkwDrJgESIIHQJEADPTT7la0iARIgARIgARIgARIoLgGWIwESIIFSIkADvZTAs1oSIAESIAESIAESIIGySYCtJgESIIGCCNBAL4gM40mABEiABEiABEiABEgg+AhQYxIggSAmQAM9iDuPqpMACZAACZAACZAACZCAfwmwNhIgAV8SoIHuS7qUTQIkQAIkQAIkQAIkQAIk4D4B5iSBMk6ABnoZHwBsPgmQAAmQAAmQAAmQAAmUFQJsJwkEOoEyZ6DP+mkxJn37i1f7JTc3F5mZWRDfq4IpjARIgARIgARIgARIgARIIFgIUE8SKDGBMmegf/HNz3hn/LQSg7MXsODPlWhz+X34bclq+2jukwAJkAAJkAAJkAAJkAAJkICXCFBMWSBQ5gx0b3VqdnYOflq4DOM++w5PDfnAW2IphwRIgARIgARIgARIgARIgAT8T4A1BgQBGujF7IbMrCw88dJ7ePeTb5F26nQxpbAYCZAACZAACZAACZAACZAACYQ+AbbQPQIhZ6CfTD2Ft8Z9jd73v4SOVz2kfbmlff+how5Etu7Yi4Evj9V5JN/gNz5Bysk0W57T6Rl4+Jm3MX7SbBxPScWnU+ao/GPw0ohPdZ6oyAh8N3GYdvfe2l3HcUMCJEACJEACJEACJEACJEACJOB3AiFTYUgZ6EeOncC1dz2HT6b8gIyMTJzXrhkOKMNcjOw58/6ydZqseF9753OYu+BvNKhTXcd/+8NveGPsFL0vm6ysbPy2ZBUmz5iHHn2ewYhxX6n8SzH/938kGYZhoGHdGtpVTaqo47ghARIgARIgARIgARIgARIgARIINQL+a09IGeijP/5GGeTH8Ph9N+iV7XeHPo6F347G/z19LyonxjtQfajvtVj244f46oOX8OOXbyA2JhpipMuz5fYZDxw6hratGmPiqGexaMa7+OK9F+yTuU8CJEACJEACJEACJEACJEACJEACxSdgVzJkDPSs7GxMm70Qtaon4R67W84tFgM9r7oI13TrZGu2GOP97umFmOhIHVepYgVcdG4rvX80+YT2zY3Ejx7SHx1aN0ViQnnUrVXVTKJPAiRAAiRAAiRAAiRAAiRAAiRAAl4jYPGapDOCSmVPVrql4tbNGyI8LEx2PXLxFcrp/JmZWdo3N7ExMeYufRIgARIgARIgARIgARIgARIgARLwGYEgNNBdszh9Ol0nREVZV8V1wIONxTA8yM2sJEACJEACJEACJEACJEACJEACJOBdAiFjoNeolqTJbNu5T/vF3rAgCZAACZAACZAACZAACZAACZAACZQCgZAx0OV58iYNamHF2i3a2bOUt7uvXr/VPqrU9lkxCZAACZAACZAACZAACZAACZAACbgiEDIGujTuuf53iIc7HhuKMZ9Ox6yfFuufR7vytqewfPVmneatjbyU7svp8yBuyfL1Wuz8P/7R4e/nLdHhUtiwShIgARIgARIgARIgARIgARIggSAlEFIGesc2Z+HDNwfpN62PnTgTzwz7EJ9OmaN/67xNy0aFdpG87V0yGBYrEsMo/Jn07OwcDB31uXbz/1ghRfVb5CXug8++0+HQ27BFJEACJEACJEACJEACJEACJEACviJgtUZ9Jb0U5F7QsSV++GI4Fs8ag9mfvYY/Z4/Vv3XetmVjrY387vnSOeP0vv3m+cf7YN2CCaheJVFHx8VG6/DIlx/RYedNVGSETpcyzu67icOcszPsDgHmIQESIAESIAESIAESIAESIIEyTCDkDHSzL+PLx6F+neqoUC7WjKJfxgmw+SRAAiRAAiRAAiRAAiRAAiQQyARC1kAPZOjULSQJsFEkQAIkQAIkQAIkQAIkQAIkUCICNNBLhI+FScBfBFgPCZAACZAACZAACZAACZBAqBOggR7qPcz2kYA7BJiHBEiABEiABEiABEiABEig1AnQQC/1LqACJBD6BNhCEiABEiABEiABEiABEiCBognQQC+aEXOQAAkENgFqRwIkQAIkQAIkQAIkQAIhQYAGekh0IxtBAiTgOwKUTAIkQAIkQAIkQAIkQAL+IUAD3T+cWQsJkAAJuCbAWBIgARIgARIgARIgARLII0ADPQ8EPRIgARIIRQJsEwmQAAmQAAmQAAmQQPAQoIEePH1FTUmABEgg0AhQHxIgARIgARIgARIgAS8SoIHuRZgURQIkQAIk4E0ClEUCJEACJEACJEACZYsADfSy1d9sLQmQAAmQgEmAPgmQAAmQAAmQAAkEGAEa6AHWIVSHBEiABEggNAiwFSRAAiRAAiRAAiTgKQEa6J4SY34SIAESIAESKH0C1IAESIAESIAESCAECdBAD8FOZZNIgARIgARIoGQEWJoESIAESIAESKA0CNBALw3qrJMESIAESIAEyjIBtp0ESIAESIAESMAlARroLrEwkgRIgARIgARIIFgJUG8SIAESIAESCFYCNNCDteeoNwmQAAmQAAmQQGkQYJ0kQAIkQAIk4DMCNNB9hpaCSYAESIAESIAESMBTAsxPAiRAAiRQlgnQQC/Lvc+2kwAJkAAJkAAJlC0CbC0JkAAJkEBAE6CBHtDdQ+VIgARIgARIgARIIHgIUFMSIAESIIGSEaCBXjJ+LE0CJEACJEACJEACJOAfAqyFBEiABEKeAA30kO9iNpAESIAESIAESIAESKBoAsxBAiRAAqVPgAZ66fcBNSABEiABEiABEiABEgh1AmwfCZAACbhBgAa6G5CYhQRIgARIgARIgARIgAQCmQB1IwESCA0CNNBDox/ZChIgARIgARIgARIgARLwFQHKJQES8BMBGuh+As1qSIAESIAESIAESIAESIAEXBFgHAmQgEmABrpJgj4JkAAJkAAJkAAJkAAJkEDoEWCLSCCICNBAD6LOoqokQAIkQAIkQAIkQAIkQAKBRYDakIA3CdBA9yZNyiIBEiABEiABEiABEiABEiAB7xGgpDJGgAZ6GetwNpcESIAESIAESIAESIAESIAErAS4DTQCNNADrUeoDwmQAAmQAAmQAAmQAAmQAAmEAgG2wWMCNNA9RsYCJEACJEACJEACJEACJEACJEACpU0gFOungR6Kvco2kQAJkAAJkAAJkAAJkAAJkAAJlIRAqZSlgV4q2FkpCZAACZAACZAACZAACZAACZBA2SXguuU00F1zYSwJkAAJkAAJkAAJkAAJkAAJkAAJ+JWA1wx0v2rNykiABEiABEiABEiABEiABEiABEggxAgEi4EeYtjZHBIgARIgARIgARIgARIgARIgARJwJEADXfPghgRIgARIgARIgARIgARIgARIgARKlwANdH/wZx0kQAIkQAIkQAIkQAIkQAIkQAIkUAQBGuhFAAqGZOpIAiRAAiRAAiRAAiRAAiRAAiQQ/ARooAd/H/q6BZRPAiRAAiRAAiRAAiRAAiRAAiTgBwI00P0AmVUURoBpJEACJEACJEACJEACJEACJEACQoAGulCgC10CbBkJkAAJkAAJkAAJkAAJkAAJBAkBGuhB0lFUMzAJUCsSIAESIAESIAESIAESIAES8BYBGujeIkk5JOB9ApRIAiRAAiRAAiRAAiRAAiRQhgjQQC9Dnc2mkoAjAYZIgARIgARIgARIgARIgAQCiQAN9EDqDepCAqFEgG0hARIgARIgARIgARIgARLwiAANdI9wMTMJkECgEKAeJEACJEACJEACJEACJBBqBGigh1qPsj0kQALeIEAZJEACJEACJEACJEACJOB3AjTQ/Y6cFZIACZAACZAACZAACZAACZAACZBAfgI00PMzYQwJkAAJBDcBak8CJEACJEACJEACJBCUBGigB2W3UWkSIAESKD0CrJkESIAESIAESIAEQo3AhK9+xILFK5GVnV2qTaOBXqr4WTkJkAAJkIATAQZJgARIgARIgARIwO8Eduw5gEefewfdbhmEiVPn4viJVL/rIBXSQBcKdCRAAiRAAmWEAJtJAiRAAiRAAv4l4MmKbEZGJg4cOobc3Fz/Ksna8NLAOzHl/RdxfvsWeGPMZHS69lG8MnIiNm3d5Vc6NND9ipuVkQAJkAAJhDQBNo4ESIAESIAE7Ajs3HMQrbvei737D9vF5t8Vg3zsxJlo2+1+XHrjE7i4Z3+sWr81f8YQjfF0YiI17TQOHk52OZGRk5OL/YeO4tTpDI9ptWrWAEOfuQ+LZryLQQ/deTMwdAAAEABJREFUjIV/rkSvewfjrgGvY96if/xy+zsNdI+7jQVIgARIgAR8TeDECeDAAeDIEcD+UbDDh4GbbgLq1AHuvx/IyDv3/vAD0Lcv8PjjwKpVrrVbvRro0QO4/HKgTx9g1CjgiSeATz4BsrJclylO7LJlwKJFVj02bSqOhILLlHbK5s3A9OnAnDnAwYOlrY3v6580CWjf3upkzCQn+77Ogmo4ehSYPRsQnX76CUhPLyhn2YxfvBiYOhVYuDC02EyYAAwYAAwfDkycCGRmBn//pqYCycnAyZNQxlXwt6ewFtz6yBBcdftThWWxpa1c9y/GfDodn7/7HFb+/BGuv/IiPPHSexBj05YpBHc8nZgQQ/7poR/gnO4P4ZLeA9D1poFYs3GbjcwfS9eic6/+6HrjQHS48gEMHfV5sRiGWSwIDw+D+Vm3aTv6Dx6NS24YgEnf/mJG+8SngV5CrAfVFQrdQXWhRsdxwDHAMeCdMXDgwBHIBVxODrQBfvhwmu0Y8/nnKRBjXIyVyZOBmTOTsXfvQXz2WQ7EeN+yRQyYDJ3/0KFD2jf7ZfTodG2Ih6nz7alTwLp10PUsWQIsWZLskNcs46l/4MBB7NuXiypVgOho6MmFAwcOe0W2p7oUI3+heu7ffxD//JOLtDRA+K9cmV5ofm/X72950pfDhuVoA0LuNJXxMn16Sqm1eePGHD1hJZNJ+/YBa9aUni7+7oui6tu48Ri2qetzmbDbvVu+26HBZo9aeZ06NRd16wKRkdbv3YoVx0ttDBbVD+6kHzqUrI/r8p2SyQZxJbwUD+jio17th8ljB7ul4/zfV+D8Di3QrlUTRESEo0/vbvpW901bd7pVPlgzeTox8fOi5VisjPBp41/Byl8+Rufz22DQK2ORnpGJw0eP44EnR+CGqztj6ZxxmP7J/+HL6fMwc+7vbuNZu2kbBr/xib69/fX3vkSLJvXw0Ygn8df370PqvOjcs/Hx5O/dllecjDTQi0ONZUiABEiABAKGgFzoGUbAqOOgSKDq5aCk3wLBVxH7L/j6LJQ0lmNbKLUn0NqyatUqNbn7WbHdggULcODAAQfn3MYqlRNQNSnROdpleN/BI6hfu5otTcpKQG7jFr8w98ywDzFi3FfYuedAYdmKlVZSTlK+sIo9nZiYrAzunlddhGaN6yJCrXD3v7cXdu87hH+37cHqvEcC7r7lKsTGRKNJg1roe+MV+EUZ9YXpYKbJ8+Y3P/gKfvz1b9x/ew/8NGUE3h36uJ44sVgMXeewZ+/Xhr9Zxhc+DfQSUq2ilknoqqjVIjqOA44BjgHvjIGqVSshLg6wqDOUrBpVrhxrO8b06VMe3bsDiep659ZbgeuvT0DNmlXQp48FlSsDjRsDt98eqfMnJSVp3+yXRx+NQni4dVU7JgZo0QK6nvPOA84/P8Ehr1nGU79q1SqoXt1QK1zA6dPQbahatbJXZHuqi7fzV6tWBe3aGYiNhebfpk1UYLXLy+dj6ctnn7VAjHRxMl569ixfam0+6ywLKlWCHsPVqwOtWpWeLt4eWyWVd9ZZFVG/vnWVuVYt+W6HBptatargxhsN7NgBveosx722beNLbQyWtJ+kfFJSgr4bQL5TERGAuBJeihe7uBiOo0evwquvAq+8Ao/80aNX45133sHAgQMdXLGVUQVPpKQiOipK7Z35FyPzZNqpMxEF7LVu3hBfzfwVV93+tH4Ludzm7a1b44XTqp9HA2sVqDUKlAf+alVOyhegto72dGIiMzNLnVstuqxsKsaXFw8iJyJvQFlkgOlYoHaNKti152BeqHBPJkVef+4BLJoxGgPu742a1dSFhYsi8eXjXMR6L+pM67wnk5JIgARIgARIoEQEKlQAqlaFNkjklnRTmBjhX38N7NwJjB8P28WdGO2ffQb9XHnr1mZuR79tW+hneH/+Gfj8c+vz6m+/DdxzD2Bfh2Mpz0MdOgAXXQSIHk2bel4+kEs0aQL07AlcdRWUkRDImnpHt9tvB5YvtzoZMwkJ3pFbHClinPXoIRNQQLdugNN1fHFEhlSZTp2gjFmgc+fQYnPXXYCyA/H008Cdd5455gVz58kEbEICUK4c9AQYSvFz/HhrNQHSV51T+nrkS7levXph0qRJDg4l+FRQRl+6PKdhJyPt1GmUi42xi3G9e+v1XfHb9NGQ1d0Dh47p27x79H0GU2bOx8nUU64LeRDbuvpx9G27A33b7bT67fN8M+zs56VLuWXLluH99993cPZVezoxcVXXczF+0mxM+OpHzF3wN94cO8Um7uzmDZCYUB6PD35Xp309awGmzvrVll7UTnz5cmpcxqiJkkiHrDt2H9C3vRfnpXMOgtwMWNzMx2wkQAIkQAIkQAIkQAK+IUCpJEACpUBAFlplglbu2PLEl3LeVrd6lUrYvmu/Tax5a7us6toiC9mJiY7EdVdcoJ+TlufeExMqYMjbn+Hcqx/G8DGTsW3nvkJKF5VkAJYwwFCmo/jI882ws29LNxCnZmSqqhl3ewe7j6cTE3feeAUGP9EXi5etxTff/4a009Y3Zgo/Wdn+4r0XUEOtfH/xzS/4Z81mZGfnoHbNKnY1Frz7p5K58V+1AuCUJTYmCt/+8Bt27XVvJd6puMdBRdfjMiFbICs7u8C3/KWcTMOx4ykh23Y2jARIgARIgARIIFQJsF0kQAKuCBgG4KlxLvmlnCt5znGZWdnIyHsTnuyLM/NM+PpH9Ok3zAzi0gvbQm5N/2fNFki+z6bNRdWkimjasI4tT1E72coYFRmywrxi7Rad/You52Da7IXo0fdZDHr1fR3n8UY32AIYykgX49tdHwaaNWsGudvA3sHuI4a1JxMThmHglusuxYdvDtKuepVE/bx5g7o1tNS6tari/56+V78N/0VlyG/dsRfntWuu04qzyVL24Z/L1+misjqvd3y8UaR9XEOQiD91OgO97hmMH+YtcdBYbi3p9/wonNfjEVx4XT/IzyXIGwIdMjFAAiRAAiRAAiRAAmWVANtNAkFKQNl68GTlXIxzyS/l3Glyp2sexZW3WX9mrfsdT+PS3gNsxQ4dTob9am2bFo3wUN9rldE+FG0uu1c/U/7WS4+oCQTDVqagneTjJzFx6lxIHfIW883/7cZz/W/H4lljMPLlR/Qz1WK0pqadLkhEEfFKB0MZ54YyHT3yVbkiJF9axMSE80SGPFt/6EgyTqdnYNFfqzF+0vfof28vyB0EUtWRYyf0BMf+Q0cxdNQX+pb3G66+WJIKdBdd3w8tutyF+X+swHufTNf7EhbXuuu9eHbYeFzRpSMqJ8YXKMObCYqyN8UFpyx566H8Tp7MsDi3QF7NL4P812nvYMnssQizWDDqo2+cszFMAiRAAiRAAiRAAiTgAwIUSQK+IqAu6yFOjG5PfMnrjk7yU1/rFkyA6RbNeNdW7MlHboGkmxGGYaDfPb2wfO6H+HnKCP2zXm1bNjaTC/UHv/Ex3hgzGY3q19SrynMmvYHbe10OueVbCkZHRULefP7+609I0HNnKJNROw+NdFltL6K2oiYmnCcyTqeno8sNA9D+igfw3GvjIRzlJ+nMaj6f9pOe4Oh640AcOXYc08a/qlfYzXRX/sAHb8Lzj/dBQ7UKf0HHlnpfwuJeHnQXvps4TE10POqqqE/iFG2fyA0qoffdejXmTR2pbyNxVlxes9+7R2fI8x/ly8WiT+/L9TMIufl++yIHSF4DHFgAZJ10FuNeWMrt+R44/CeQm+VeGVe5Mo8D2z4H9s0FcjJd5SjFuNxSrNvPVedmA0eWAntmA5knXFcufS5jRsYO1BhynSt/bE4GcHS51cl+vhyK84kNwN4fgIyj+VLzRWSnAQcXAsdWqvGbCpw+AGSbs6xK1vF1wP6fARlb+QrnRaQfAlK3qTFnfRYoLzbPU20TeYWN6xxVTlxeCXokQAKBREAdByAukHSiLiTgFQIUUoYJKJsYnhrnkl/K+QqbGNPyDLXFUvTqs6lD1wvbY9pHr2LMsAEQA9MsK6vMe/YfRn67xSzprq90MeyMczG83QqrckVUYRiFT0yIAW4/kSFvthe7TV6KJxMeN13TxaGGB+64Bj9++QZW/vIxxg3/n0v7zqGACsjkxW09u2Los/fj2X63Q/ZNd2OPLtpwV9n89k8DXaFOiC+HakmJiJDf34HjR97aV6dmVVukvKpfAidOKoNGdkwnhvWGN4H/PgHWvGrGeub/8z9g/XBgxdPAvx95VtY+92+9gGX9gN9vBtYOtU8p3X0xWHOVoSZ+6Wrin9q3fab68klgwwhg6aOu65SxImNGxs6uGa7zuIr971M11vLc9i/y5zi4SNWtxtGWccDfDytju4g3eK5T4+7f8cC2CcDxtcrQ3g4kr1LllJG+/xc1joYAWz9WMp+Cy8kjMcwP/Q5t4O+fp/RR/ay21n91UZ+eDGQpwz9DTR65mlCQCQybU3msBbklARIICALqO6yP3ep7XVaO3wHBnUqEBgG2IpAJKNsQFmUNidHtiS/lAqld835fjgWLV+RTaffeQ+h2yyDsP+jGYg0K+UiDDQXKNMrlRXHuhGEUItQxyZOJCbHbKlWs4CggLyQvdBN7LSJcTSjkxRXmyTPm8kizTGK0Oqs+6tepXlh2v6Qp0n6pJygrkY6SDpMBYzYgKjJC76blPcOxbt06iDu9W62c6xS1Ob0fW1fP1/GS5o7bsupX4Lha8VTF5T9j9zyPypt1bFmhVs1lZVWEKJex/dtiyTHlecs/fMjxrYcHDuwPCL281T5XcjJ2/qh6IO8/bRe2rHTs0y2r1Yq1Git5OZCx9ze3mGxYtwK5yWvNYsg6uiFfueNb1Tgwc2Sfwu5V0/PlMXXeuOYv4ORWa+7yTax+3vbArg04uUONzbywrKDvWPV9PlknD202cwBqFXzHpmW2PLt3blNp6gJfbeX/+NGDtjRTh6yMMxNeudnp2LBhfb48Zt5g99evD922BXvfUP91Lr93J1McX5C6Y8d2l/nIzzU/b3HZsGGDHELpSMCRAEMlIiB2p6fGueSXciWq2E+F42KjdU35FhZ1rCcbZWiLcW6unLvtq3KeVFMKeX//aw06XvUQdu45iIEvj3F4/lyeQbd3x1PUYpMfdKSBXghkwzD0MwvpGWduEzf3Y/MGvLyZUFxUzc5nJEVXQ/2WXfRbCyXNHdewlSof38wmI6LmpR6VN+to2PpyILH9GTl1exZLjinPW35ipco2nWQnKalKgXo1b94coeAi61wpTbW62Npo1PpSh3Y1anUxoMaKNQMQWeNih/SCGJzVvA2MhJZmMYQnNstXrkKDbrZ0hMWg5tnX58tjym/a8hygXENr/pT/rH7etkqtsxBXx+7WoYh41Dn76nyy4irbPSNliUKdJh1seWrWrgfYzaBWqJhkSzN1CI+MhfkxwqJw1ln522TmDXZfvlPB3gbqHxrHKHf7MU5+rNj8giq/Tp26+b7D7spivuYFnmYCiCsAABAASURBVPvk2FCYO+ussxR9/pOAfwmEem2yai5OjG5PfMkbCGy+mjkfn06ZA3mP1vLVm/W+hMV9+MUsDHjxPf2StEb1apZMXVktF6PcEqbkWAB3fUPlVSUC+b9Orap4sM81+nn9a7p1wjOP3Vags1+09WWbAp+aL1vvhmx5Vf/OPQdsOc3fv6tQLlbHWdQ3VJxRqwfQ7EmgwT1AqxchcZ46tHsLaP400HY4jMb3F0uG1ImLvwU6vAtc+BWMVi8UW47I8qaDzLwZasgpvzC5hmHAMILfoX5f1ZdvqnExCOg4xmWboMaKHjMydmpf7zKPYeRngQZ3q7GW5+rdkb9c1YtV3cOBxg8B57wPIzw2fx47uWihxl2j+4H6dwDxyviPU0Z1QmtVLgZG9cuBloOBhvcqmW/AsITnl1WuAZB0IVCxDVCtq0q3KGfqbQGiEoDwOCAyHoYywA3DTLP6iKiAM07lcUo3DGs+w6BvGGRgGGRgGP5kYAH0sVv8MLvvtj91CJ26LHnXDZ76hmGAHxIIMQKl3hz5Wtkb57IvTn1N4cqXOHFSrtSVVwp8ooxzedm1PJL757J1kH3TydvNxY5588WHVVvU8VvlL/6/Ov5YwlRx5bSv5Ln0ndNVOVUqkP8b1KmO/vfegIT4crikU1v06d2tQGfeSe3r9ii6vq4i8OXLsweZmdaXsmVmZcHcF83llfpTZy3AwcPJOJl6Cp9P+xm9ul+sL1Ak/YxTKBNaAVXVamN4uTPRnuxJuZpXA5XPh7KMUOyPWuVE/T5A9SsAi/WW/GLL8npBw+sSA1agoQ5SlToCNdXkjRigrhSVPpcxI2NHZiZd5XEVZ4mEvlNC7paQ/Xx5FOcKzYAa3YHIxHyp+SLCYoEqna0GthjS0VWBsOi8bAYQ3wKopgx1GVt5sfm8qCQgrj6gVtDzpUnbRJ4Rnj/JjJFy4swwfRIggQAiYChdxCmP/yRAAiQQFASKVtKiLt/FidHtyg9Xly2u4gPFQJ87+U39hvg7b7wC8rbxdQvOvDFeXqz2xuCHcF675kWDKDKHHP8FVpjKqXy5xpVrO7VoA/FtYad0mdxVJQL5XxZi123aDndcdnaOX5qiCPulnoCu5KkhH6DN5fdh975DeGH4x3p/2859Wufbel6GBnVr4JLeA3Du1Q9r411+AkEnckMCJEACJEACJEACJEACJBC0BMQ4N50Y3ua++AWFxWhHALX4qUdvhbxt3GcqiaGtV8wNQHwxyMWHgcLDPtPIa4LfHDsFNz34slvuZFoRL132klY00BXIkS8/omef1tnNOtWvUx3ykZcryG8GLp41Bgu/HYWvPnhJ/+SapNGRAAmQAAmQAAmQAAmQAAkEJwExtMWJMS5+QSvmzuliuPu6xUXJ37pjL94ZPw3Hjqdg/h8r8NnUuQU68x1aRcksON1QScps1HdCiu+8Um6Gw/PymWGVV8UE8v+Tj9yKqR++7JYrFxvjl6YEPjW/YCi6kvjycaicGF90RuYgARIgARIgARIgARIgARIIeAJiaIvxbfpipEvY9GVfnHO6hEu7cfITauMnzcaJlDTM/vlPDB8zuUAnv4fupK9nQWmwrJobynSUlXPxdVgZ4jpsADrslC4r7AjsT52aVdC8ST23XFiYap8fmuOfWvzQEFZBAiRAAiRAAiRAAiRAAiRAAu4SMA3xwlbOxUB3Tpdy7tbhq3wXntMKS+d8ADEwXd0NbH9nsCw0lkwPZTKaRrn5zLktHAb97ixbWPJKnPjKIbA//r0TwT0WgU/NvXaEQK5cIG0XcHw9kLoDyM32XZukngMLgcN/AhlHfVePveSDqr6fLwJmNQX+/cA+xeV+Sgpw8CBw7BiQ7UUUK1cC48cDX34J7FK4XVYeRJHCZsgQ4LbbgD59gDvuAGbODKIGmKpuHgss6AEsH2D9Hpjx9EOewIkTwB9/AD/9BGzebP2+y3dT9vfudd38V18F6tUDLr8cWLPGdR5fxv73HzB4MPDww8B337muSb6by5cDI0YAou9CdQh0nfNM7KxZVnnS9p07gSzru0vPZOAeCbgikJEMbFHH0BVPAzu+cpXDGnd8LbBplNUlq5PhfxOBlc8B4uekW/OUxvbEJuv1yPF16trnzM/aloYqQVFnhrow2jwGWPGk6u/JQaFyICtpqIVfMbbFiSHuypc4cfbpUq602yWrubExUTAM1QifK6PqkBXyfMa5MiXFMDfjTV/idH5Vzhe6eVGmX+9EcFNvRdXNnMzmksCRI0fgDXfiqLoSlZOsGOaZJ5CavNcrcvPrdhi5J7YAOacBVU/msU0+qseRS+aa4cCxFcCpPchd9SKOHNpXYL2HDx9DWhqQq+YsMjKAo0dPFZg3f/sc67VPP3ToCBYtysXJk8CBA8DixZlekWtfh7/3//rrBJYtAyIioCcycnKAb7+V9hXMwd86FlXfsT3KwtqhZkwyk1VnL8Opf6cGfb8U1WamnxmfGzeeVt9xIF3ZB2KY7tqVqr+jYuAePw7s33/cYTxs2HAUr78OPYEnhv3o0acd0v3BdubMdGxRh9Fj6jr5K2UP7dlzNJ8OR49mYulSq55yzPn5Z2Dfvvz5TH23bz+Kv/4CWrcGoqKsx7+DB71z7DProH9m3IUSi7RdC6yT+9mpwKFFSN67Nt94lPZm71GzYOlH1JftCHJ2zYY+J2erk+2xFUjZtcRlGSnnS3fiyC6lj5qNz1WzUWrBIPXIjlLRw5dt9LZsa3+ryYws1d8HC+5vb9cbbPJcXrS7iBTb1jS+xQAX505YyrkQ59eoDz6fhUefe8ctl3ZKXfeXRDtpsBjcljDANL7twzpepWnfovKofUk3At9Ad3UnwroFZ96Gb79f8jsR4NZHEXQrHzMVQCBdXVV6w2VmZjrUIGFvyHUlI1cs37zacpRF5yqPt+OknrwqtZeenqEuyNNdugyxynUu6yZbXal7Q5/Tp5UFYBWpt6JTSeSKnqXtslwssUn3pqVlorR1c7f+zEw1C6N7xLqR/na3LPNlBE0/F9RX8j209rx1K/1v3bNu5WcvHcs6HiulvGO675lInVbtrFtX9dsfZ625UGhfZTqdA6SMsHAlm3G+7+NgYizjRMaL6WQsudLffkzKecLML76cS1yV8XWc6Cr1m6609PB1O70p393+9madwSjLHFNF+WI/mrevi2Euzp2wlCtKtq/TRQeL2rjjSq6LMrTFMNcr5OaL4MSMVM724ji1ny9dlSt55T6VEBZmgas7EY6fSNUv4PNB5UWKFJJFZmKGggnUqFED3nCVqtYFIhMAmW2KqICEpLpekZtft5qwxDcBLNGAqieqUjMf1ePIJar1s0DFtkBMTRitX0WNWoW1rypiYxUKQyGJBJKSynlFx9q1a+CiiwyUKwdUrQpceGFUieRWr14dpe06dUpEhw6AXNubs7433ADUr1+t1HVzl02Veu2Burep8ZgAJHZAuaa3BI3u7raR+Qr+rjRvHovEROhV4ybq0FS3bgX9HZXxHB8P1K5dyWE8tG5dFc88A1SpAlxwATBgQKxDuj9Y9+wZg8aNgYoVgZtvhsvvW6VKkejY0aqnHHPkdvy6dQv+XjZuXBXnngusWqUWFNVcomFAtauccgWz80dbWUfg8y9frysQ3xwIiwOSLkJS3bYux014rSvUF62SdmF1eqgBrM7JYbHar1j/QpdlfN3/lao1UPqoL7Nc4EcmIr5qw1LRw9ft9KZ8a3+3AMJVf1cpuL+9WWcwyoKbHzHIxck5x3Rm2Nm3T5c0N6vwWbYH7rgG7w593C0XGxNdMj20cR4GWJQzLFZfjHEJ23yVJmH7dNkvWc1+LS2/cz7m0+noeNVD6HTto7jwun56f/TH3yDtlDo5+0kbRbgENbGoFwkYQGxt60k2ri4ghjp89JF6qnYGKp8PqBOij2pxFFtF1Xf5IuCaTUCjBx3TXITKl4e+AJcLYDkgushSrKg2bYD777c+s11b4S6WkAAqJLO88iysPFP/+efAF18A110XQAq6q0qTR4Aus4H271i/B+6WY76gJ1ChArSh3a0bIAa6jGn5bsq+mv902b4XXwS2bwfktvFWrVxm8WlkA2VTyLsf3n8fuPZa11XJcat9e2DQIED07dzZdT772GuuscqTttepAwgL+3Tuk4BLApEJQGN1DG07HKirZoxcZlKR8S2Bpo9bXYI6GTa4E2gzDBDfEqUylNJ/habW65F4ZXQaEaWkRBBVG1kRaPIo0PZN1d+3BpHigamqoS6/5XgtBrezL8dgV/GST8qVdouysrOV0Xga9nfH+E4nBUqMbzHGtY1iASzhqjrxwxx9h3RDpQXP/9ezfsXYiTPR/uzGeOKBG/HMY7ehQ+umkMcJXhj+kd8aoqj6rS6PK2IBEiABEiABEiABEiABEiABEvAFATG0LcoaEqPbE1/K+UIfT2T+/tcavbq7c89BDHx5DFp0uatAdzwl1RPR+fPqBitQpvHt7Dsb72Y6gstAl5+ta9a4Lt5/fSDuu+1q9OndTe0/gf89dBPmLliK3fsO5WfjgxhF2gdSg0MktSQBEiABEiABEiABEiABEiijBMTu9NQ4l/xSrrSR1alVFQ/2uQbx5eNwTbdOerVXVnxdueioyBKqqwxtMcLllnVXvqysu4oPBFAetDwpMQHy0jjDUO21K9fjsk46dPBwsvZ9vaGB7jPCFEwCJEACJEACJEACJEACJBCoBGTVXJwY3Z74kre029SgTnX0v/cGJMSXwyWd2urVXlnxdeWiIkv4+IgY5mKEmyvj7vpSprRBeVD/5Z074KeFSyGPD9gXO5F3B0KdmlXso322TwPdZ2h9LJjiSYAESIAESIAESIAESIAEik1AFko9Nc4lv5QrdqU+KihvHf9q5ny8OXYKho+ZDNk/cuyEl2pTK8pilIuh7pGvynlJA1+Jkdva+w8eDXHLVm3Ejt0HcPeA4TosceKeHPK+rr7EL9vTUore0EAvmlGp5Dh9GpBfG9u7F9i3D9i92z01srPz5zt4EDh2DFi/Hvj+e+g3fksu+ZkV+T1w8SVs77y1L7LT0s7U6S25lEMCQiA9HXA15iUtVFxODrBhQ2h8h/bvBzZv9k7PbN8OnDrlKEuON44xJQ8lJ7vmn5oKbN/uWr78qoK084S6Lvr1V2DHDtf5XMUKIznmO4/rXbsASRPZrsoxjgRIgAQKIiDXk3IMKSi9LMeLoS2r4WJ0e+JLuUDitnPPAf3W8Vff/gwTvv4Rn02dC9m/uGd/LPprTclVlQZ7bJyLmRn4BrqslmdmZiv7KBuGauPF57VGubgYHTbjq1WpBIkHckvO0g0JQs6NbMziLwJygfnff8Dq1cDs2cCyZcBzz0H/rNDzz6thUcC4kJ/DFiNcLgjFmfpOmwZMnQpcdhnQqRNw663Wt6P//TcwfDjw7rtW/+RJs4T3fJG5ZQsgfnIycPgwIMYGAO9VQkllloCMLfl+/PWvrFX1AAAQAElEQVQXIBNNoQhCvtOPPw689hrw4IPAxo3B28rx44FJk6AnCd95B3oCsritufNOoHt36Le///abVYpMaooTo12Oo9bYkm2nTwdGjwa+/traBzJRIhJnzQLk7fEXXmj9VQiJM92mTcDrr0MfX/v2tR7/xFifM6foNku5ceOAzz4D3n77zMSsvAl+5Ejgq68AeXO8yDPro08CJEAChRGQ68kFC4CdO4GFCwE5ThaWv6ylid3pqXEu+aVcILEaNvoLrc6XYwdj5c8fYdW8jzFl3Evo2OYs/QK5U6czdHrxN8rQtl85l1vX3QqrcsWv1C8lH+57nX4R3PuvP1GkzxV0v3RJySvZpK7GvOl27z4MWZkRI1t+O1eJVzM4Vj1lFebnn3fBVX2HDp2wZlJbWXnZunUH/vlnmy4rF/X2xrGkjxt3WhvOKrv2f/31gEu5rupyN27nzpOIjATMg5hcNO/addDr9eTXZxPrUAMnlLls3LgFh/JepCnjavv20yHZ5z/9dALHj0N/ZBLuu+9Sg7Kdq1f/q/tLViekMdJnxT3mzJu3DUuXihTrheYXX6Rg1669EJnWWJmwOVJiTitWbINMlppyxZ8375SW+/HHqbYJBjG85837T8fLd+6XX05pNbZuBc45B4iO1kHIz/UsW3bIlk/y2rvfftuuV9pjYqz55Tj9xx/J+Ouvf3V769a1xoseS5emFijHXib3eS7gGOAY+OefU4iLsx4/5Di0fPnRMnH8sLa46K2cl8SJ0e2JL3mLlu6/HJv/243benZF6+YNERERjnDVoFZn1cfDd16nf4pty3+7SqaMWlmGdmHQvvlCONNILygshjz48ZQAV9A9JeaUv0GDBvCmS0pKgPpO6Ys6uX23ShXHCtu1q+ayvgoV8o6+ednr1KmBpk1r6dt/ExMBueiTC7u8ZJUWae5q/6yzKrmUW5K2VawYm2/FPCkp0ev1lETHYpX1cp9TB8+/Qw0b1kNUlB66epOQEBmS46pp0zjbBJc0tHHj6KBsZ5MmdfVxTdpgumbNinfMad++FmJjTSlAy5ZxqFo1CfafxMSEEnNq3ryWPm7ay61XL0rL7dAhxhYtF77nn19bx1u/y9Zja0IC9KSELaPaadKkol0+x3Hftm1Nfby2v8uoXr3yaNu2rh7r9re216kTU6Acqw6OshlHHhwDZXcMVKpkd7IEUK9ehTJx/FBNdevfMKDPT2Jwy/W3u76Uc6sCP2Vq06IRUlKtE8T2VTZtUFsHo7zxFncjTMmyAB75BoLpk5GRiXfGT8PND76C7nc8nc+lnEzzS3MUZb/UE7KVREREqJkq77no6HDUqgV1wQk941m5MnDuuUCLFoDc6lq5suu6YmPD9MWkUgey8i56xcVFoGNHa9kePYAmTYCkJOC224BHHrHg2muh5YrfqFG4V9sh9VepYtE6mbecyiRBbGy41+uRukLJsS0Rbo0RczzXrAnUq2dxq0ywsW3VKgy9ekFdTFkfU7niirCgbGd0dATkGCSrN4YBfXt4nTrFOxYkJETo27+vugp4+GGgTx8LIiMjlAPk4kqOgZGRYSXmFBUVoW+jr1YNesK0cWPg0kut4+z++y147DHg+uuBTz6BmjA4M2Y7dw5D06ZAhw7Qz4wvWQL9CEbFikDlyuEF6lW+fAQefRT6uC/HcFl9b9MmTLUrAsOGWW+Vh/o0bw60a2cpUE6EAkB3pj/IgizK+hi45BKLvlNS7saSO3pq1Cj4OBRKrODmR85J7hrl9vmknJtV+Czbrr0HsWHLDu0u6NgKs35ajD+WrtVhM/77eUsgt2XXr61OZiXRRDdYmY2yUi6r4u76ulxJKvZv2Y+n/AB5aVz1qpX0y+LObdccl17YDoeOHNccw+VCxg8qKdJ+qIVVeESgQgXAejEIXH010K8f8Oyz0MZ2QYJk/MuBVy7s1PWZLZtcKN50EzBiBLB8OSC3XY4bB5QvD337pTyTLheCUt5WyEs7crFcvTpQpw4gdwKIbl4STTHFJxAyJWUMi5Ferx70CmPINMyuIfIduu464OWXAXme2X7l2C5bUOzKJKMcywYMsE42lETpiy4C3nrLemwUw1dkCSt5pMab58569QB59v/pp60Tmyb/qlWh3wvy3nvQz8FL/aaTPHLMfeEFYPJkYPBg4I47ADHYzTwF+a1bA/37Qxvql1xyZlxL2VdegZ6kvfxyqxFfkAzGkwAJkIA9Abn2uuIK6AnH9u3hcFcW+IG90S3nEeewxIlzjvfFdbOn3fHGmMnoff9L2r34ppotVgIeeHKEDpvx8mx62qnTOJXuhWfQXRrlYYDLeGVimvFKr2D5X/DHStx7a3cMe/Z+rfLdN1+JQQ/djKcevQUHDh1Vk+OqvTrFtxtFz7cVUDoJkEBZIsC2kgAJkAAJkAAJkEBwEBBD2974lkle+7CzcW6mS57SbuGgh2/BlPdfdMvFxea9EKXYSovJqJwlXElQviGGqvJNI9wWdkoXwKpEsPwfOpqMOjWrqtXyKK3y3gNHtH9u22Y4mpyCLf+5+bNaulTxN4ps8QuzJAmQAAn4lQArIwESIAESIAESIAEvERD7UYxw07kblnxeUqHYYurWqopWzRq45eSlccWuSApKg7UxbkCvmItB7m5YygeJS0yogINHkrW253dogZ8XLtP7e/Yd1r7FTzMzNNA1bm5IgARIACADEiABEiABEiCBskNA7C1xYqCLb66QFxWWvIFG6fDR41j01xrMXbA0n8vMyi6humIyKmc4r5AXFVZlSlizP4s3qFNdMVytq7yu2wWYMnM+rr3zOdw36E00aVALTRvW1mm+3gQXNV/ToHwSIAES8B0BSiYBEiABEiABEgggArIwbBrj9n5B8WKYS74AaoJWZfX6rejc63E89PRbGPjymHxOnkPXGYu7ESCyam4o01FWzu3DZrzp26fDKG6NpVLuxYF34r2hj+u6r+nWCa8+eQ/kToVH7+6JccP/p+P9sVGU/VEN63CLQK6a3crJBMR3q0ABmVK3AYcXAymbVYYc5Zz+T24Ftn4C7JwGpFtv2XDK4f1gbhZw+hBwah+Qnf9nILxfYahJVP14YiNw6Hfg5H9FNy4zWY2BJVYn+0WXKFmOY/8Afz8A/POEGnebPJd1QpU58re1bVkpnpdnCQCEQAIFEMg8DuyYAmx4Czi2ooBMxYjOVcel7DQgK7Xk561iVM8iHhLIOAYcVOcQcbLvYXGPs++aDiy5B9j0LiDjpCABqdvVuSrvmqWk1z8F1RFs8fvmqvPpk8B/E/KzE0apO4Hkteq66mCwtSzg9BU70zS6TV8McOeVdImzT5f9QGrMR5O/R7PGdfHl2MFaremf/B8WzxqDrhe1w6UXtEV8+TgdX/yNMrTFOBcjHGGArKSbYWffIV2VQ/B8ysXFoFLFCjA/N1x9Md5VBvsjd16HqkkVzWif+zTQS4j4xIkT8IY7eVIZJWLEQl3wKD8t7WSx5KYeUwftI8uAtD3AsVVIO7o9n5ycf5VxfkQZb/t/QuZ/X+VL90Z7nGVkpuwFMo4CmSeQk7rHL3U66+Dt8PHjx+Evl3r4P9Wf6sI6bRdw5C+cPLK90LqzD/ypDOUt2sm+r/XM/usR64XE5jHI+qt/obrl0+XYIeuFRrn6QER5dTFyWo2PZM9k+LEv8ulfVupmO4N2TKZvnaoM9K+BQ38A69/E8eQj8MY4zko/ob6v6UBOhvpP8YpMb+hFGa7PTdn7fwNObNBO9n3JKWXfajVp+yCwZzawdghObZnicnykHFPXBkeWnrlmOfKvy3y+1DXQZJ84rBZZVj4LHJinJjdG49S/3zgwOXVMpctCS7o6dx5fhxPJhx3SA609paWPu5f3YqCbxrdplIvxLc6MN337dCnnbh3+yPfvtj3o1f1itGhaT1eXnZ2tjfK7b74K8/9YgYOH1cKNTinmRhosRrn8xJoY5NpXhrrpS5zL9OAy0IXOkuXrMfDlseh5zwv69nbZl5+vkzR/OYu/KgrVepKTk5HsBZeTnemISM2QFkdudooy0O0k5Z7c4aBf6qGNsGSog3penrDUfx3Si1OnO2XCck/n1Qj1Vc5GWspRv9Trjm7FzePPkw5Sd9j4yU7OyZ2FnpDDMtVkiGRULizzMFKSDxaavyRtST2wCmHJagVd1SX/YcnLPKor64i6kCvfSIraXFZ6qkcySqJ/cct6e8KnrMtj+0+oiSnfuLBjy2zfLWSfRsbB5V6pK8zItcm1qP201JNekcux4KNxoM4FZofJecGXnHN2zTCr0r6xe6bLsZGrrlF0BnOjFhd8qVdhsot7LvB2uexd35s0tG8cXOBwPjTSj+h4c5Odutch3dv6BKs8k09Rvhji4kwj3N6XfXGu0iWuKNn+TM/OVgt8qkJ5GVyt6knYnPe28cQE62rw7n0HVWpJ/pXJKEa4vn1d7WtfGejaV2FZWXeVLnElqdbPZcU4v/d/b2Dugr+RVClB394u+/LzdeMnzfabNoqo3+oKyYrq1KkDb7gK8YkOfGLjKhRLboXa5wFhMVZZlkjE1ejoIKd6w3OAyp2s6erLZKnbyyHdG21xJcMSW9Vap2wj4lGtZj2/1OtKl2CMi6t5LqD6U/AhLBYV6nRCYe1AQkudVW8Szkatuo0LzV+YrKLSajS5GGjST1cFdSA2Wg32qK5KjboCKWq1Xx7vECm5OUhMqumRjKJ09EV67dq1QRc0DMp0X4U36nvm+BHfAklNunmFhxGed66R721YFKrXqOkVufxe+eZ7hYptpKesTu37knN8h2eAcg2sdYWXR3THoS7HRoVaHWF/zRJb4xyX+XypqynbF+eJ4sis2PpBILZOHrtyiG7ztMP5MDqpBaCu3yAfdb1XsWYrh/Ti1BmKZQSPO84wAPuVcTG83QlLOXfk+ytPzWqVsX7zdl1dp44tMXbCDMz//R988Pl3Oq5Jg9raL/5GgVLXeFDLbPr2du1blDjl8q2cmy+OU2lB9gz68DFfIjGhPJbP/RAfvjlI396+8pePcWOPLnhn/DQcO56i2uz7fyHn+1pYg3sELFFq3Ecqp/ziDmj5ktTsAVTvBtS6Fggvl7/uBncBrV8D2o0Eki7Kn+6LGGWUo0JjoHwDIKaaL2oIbZnSj7V7ATWuUv16HawHRxT8qdgaqNPb6mS/4JzeSWn3FnDtf0DPvUDTAZ7LFF0tEYCMk+iqnpdnCRIoVQIBXnmSmpTtNBHo+B7Qeoj3lA2LBiITlIuHTBx6TzAl+YRAYnug/h1WJ/s+qSRPqEwoX7EEuHwhcO1GIN5u0jgvi/bcuWbRGcvQRs6FnWcAF34NXDYfKN/EsfFyPVBFXbtVkgWX81SaoRz/i0tADG0xyl2tlEucOFfpUq64dfqiXO8eXVCjaiUt+uG+10FeCtfvhdGYOfcPDHroZpSLi9Fpxd7oBlsASxhg5PnyrLlDOC/ePt0wEEyf9IxM/ahAdFSk5bInQgAAEABJREFUTe2I8DDcccPlOrxt5z7t+3qjSPq6Csr3jICXBrIYOoUZ+VHqS6xmXj3TraS51XAzlBFWUjFltrwaGxEJ7rde+lec+yVKljO2FhDpeCeIRwKjkmC7S8CjgsxMAiFOwBvNkwngmBrekOQkw1BhdWxXW/4HAQE5J4jzl6oVmgHunPeLumZBGfzIo18ygeGy6ep7Fx7nMoWRnhEQ+9E0wsPDAVfGuKt0KedZTb7N3b3ruXjkrut1JVUqJ+DXb97B1A9fxpLZY3H3LWpxR6eUZGMAFgVIr5yHKUEWFc7z9R0dEnaVbqi8wfN/QceWWJd3J4K91nF5ExyVE9WEtH2Cj/YVTR9JplgSIAESIAESIIGAJ0AFSYAESKCsErAoS0icaYS760uZQGS2Zdtu/Lp4BRYuXoWIiPCSr5ybjTQsak85mzHuZJyb8aYvK+tizGunigbw/4LFKzHp21+0i42Jxp/L1mH0x9/osBn/3iffQtKqJZVgIcoDBoq0B7mZlQRIgARIgARIgATcJ8CcJEACJBCwBGQl3F2j3D6flAukRp1MPYU7HhuK6+9+AY89Nwr9B4/W+336DcPOPQe8oKpaCRejWwx18cXwFt8MO/u2dFXOC7X7UsSMH3/HsNFfaPfRl9aXNH7w+SwdNuMljzw2cCo9w5eq2GTTQLeh4A4JkAAJkAAJkEBwEaC2JEACJFB8AmJoy2q4vfHtTljKFb9W75cc9dE0rFi7Bf976CZ88d7z+vb2Jx+5BXsPHNYGe1Z2dskq1Q1WZqO5Qu6uX9jjtiXTyGul33n1MaxbMMEtF1/eP4+WKNJeax8FlZhALiC/bZlbwi+R6JHr9LNtEmfvTh8EstPsY3y/n5UCpO32fT3BVkOu9acxgk1t6ksCJEACIU+ADSQBEghpAmJ3emqcS34pF0hgfvz1b1x+cQfcc0t3tG3ZGM2b1MNdN12JgQ/chK079uK/HftKqK5aCRejXFbKPfJVuRLWXFrFjxw7gb37D6PEkxvFaAAN9GJA80kRMZZ/uwH4805gQQ/g1J5iVqOM/FN7Vfn9QJqSkZuVX86m94C/HwIWq7r2/5w/3RcxO74C5rQHfrkYWPGUL2oIQpmqrzJPAlmpgPhQ4SBsBVUmARIgARIoHgGWIgESKF0CslouToxuT3zJW7qaO9betFEdVKuS6BipQhee00ptgdOn07Vf7I02zJXZ6JFxrvLLre7FrrR0Ck6fswgXXd8PF/fsj8tvGYTWXe/FKyMn4niKul73k0pCzk9VhWY1W7duhTfcgbXTgXS1qi2Y1ErzkXVTiyX34N7tgG0FPgdHDuxykPPflnXAwYVSi86XsW2mQ7o32uJKRvrmiaq+vMmC3TPx3+bVfqnXlS6BEnfogMxmmkZ5Lg4f3FfmmQRK31AP7xzXyJEcOQZKdQzwnOKlazSO4+Abx9YL3aK3shLuqXEu+aVc0dL9l+PGHl3wzfe/5TMiZfVctGhYr6Z4JXBqJdzeOBfD262wKleCWv1ddPbPf+KF4R9DeA24vzdeffIeXN31PHz93a94ZuiHyM01r9t9qxkN9BLyrV69Orzh4muc7aBJuaotiiW3QkIlRzkVEh3kVKtZH7lRVWx5wsrXcUj3RltcyQhLaGKrMzemOqrVauiXel3pEihx5Ss4/lRD+QoJZZ5JoPQN9ajOseilYzvHEsdS6I4B9i37NnDHgO2is4gdMbRlNVyMbk98KVeEaJ8nD3x5LFp0uUu7gS+PgbzErNM1j+qwGd+3/zCtR3ZOCR+nlAbrVfQwQHzzBXGmkV5QOAieQYfdZ8rM+foRgQnvPIP7b++BG66+GG8MfggvD7oLvy1ZhX0Hjtjl9t0uDfQSso2NjYU3XHRSK6DFs0CVzkCTfoiq1aVYcqNjKwCRiYD8zmlkAqJi4/PJMc7qb62n1nUIa3RnvvRYL7XJXk54yyeBhvcDtXrCaD9S1RmnnHfY2dcTTPvRMXGqn6IB+Z3TsGhERZdtHsHUd9SVY5VjgGOAY8DHY8AH1yLss7LTZ3DzYxiAp8a55Jdyblbhs2yysvvkw7fAHRcVGVFCPQzACAPMlXO3fUOVCZ7/Hbv349IL2+ZT+MJzrAupe/Yfzpfmiwga6L6gWlyZNa4GWg8F6t4MGCX4IoXHAVGVgfDycPmp0BQ463GgwZ1AdFWXWbweGVPTOgHR7i2gYjuviw9agRbVz+ExgPhB2wgqTgIkQAIkQALBRYDakoAQsFjUJZhyYnTLvru+5JXypem6XtQOd918pVuuxAa6rJqLUS4r5Z74ulxpUvKs7hZN62HGnN+Rk+N4K/usn/7QgurWqqZ9X28svq6A8kmABEiABEiABEiABEigDBFgU4OEgGEA9ka57IsTA9yVL3HipFygNTE9IxPygrPX3/sSL434FOMnzcauvXnvtyqxsgagjfOwPF+ZkDrs7DunGyWu2Z8C7r/9Gv3W+869+uOZYR9ixLiv0POeFzDqo2/Qq/vFqFI5wS/qKKp+qSdoK5m36B+HZzla5D3rIV+CoG0UFScBEiABEiABEiABEghSAlTbWwTEEBcnRrcrPzwccBUvcd7SwRtyDh89jmvvfE6/4OzzaT/hh3l/4Z3x03DlbU9h7oKlXqjCUDKU2Wga5YYyxPVKugIkvi2cF2+GDVVGlQyW//ZnN8Hn7z4HeSu+2ICfTpmD7OwcPPPYbXjxib5+a0ZwUfMbljMV5SIXsTHR+OGL4Q4uMkIG5Jl83CMBEiABEiABEiABEiCBoCdQxhogxrnpZGXc3Be/oLDEBxImWeE9mpyCiaOexT8/jcfSOeMw67PX0KVTG8gL5E6dziiZumJoa+NcGeriiwEuvrwETvzCwiWr2a+l/1y2DoeOJOOjEU9qhmt//RTfTRyGPr27IcKPth8NdDe6PToqAnVrVXVwhqEGqBtlmYUESIAESIAESIAESIAESMBKIJC2shIuToxx8QtaMXdOl7yB1I4/lq7Brddfig6tm8J83rxBnerod08vrebWHXu0X/yN2D3KbJQXG9uvmIth7hCWBUzJZ66kS7ni1+rvklNnL8A33/9mq9YwSkd/RdCmA3cKICAzUs+9Nh6vjJyI7+ctQVZ2dv6cmcnAzqnAlveBExvyp7sTc2wlsPJZYMMI4NRed0q4zuMtOa6lM9ZdAhlqTOyaDmz9CEjZ5LrUoT+ApQ8D64apPt/nOo8Zm3kCSN1mzZebZca69rPTgN3fAZvfA44uc53HPlbG297vgYO/Akf+Bvao/eQ1KkcukH7Eqt+Su4F9P6k4D/6TVwNbxgG7ZwBZKR4UZFYSIAESIAESIAES8JiARwXE/hLj2/TF8Jaw6cu+OOd0CXtUkY8zx5ePw4kUde3nVI+rOKcs7gWlwWKMmyvp4uuwMsT1CroyZHVYmZY6rHwJi/HuXg0BkatR/VrYsftAqeui6JW6DgGtQNWkRNx9y1Wor2ahRNGnhozD8Pe+lF3t0tLSIC5rhzJA9swCDv+J3E1jkJZ6QsdLmnsuFbkrngFExn8TkLV+lIflrXqkpXlLjimPvnv9l59T1k41JvbNgRi8uVs+VP2Zqpx9PtVXfz0AiBG/aTSy1r7hlO6YFyeVcS5G/+n9yEzZU0jeNGTsVbN/u6bpuqFknzqxv9D8uWKQH1+v8v8DGcM4+S9wYD5OJ+9A5uaPgfVvWPVcfDvSThwoVJaNV8pRYNO7kPbLZEHmnnnulcv7TtnkBGg4NTUVdGTAMcAxwDEQGmMg0M851M/+mqjofX2R7sbGNMQLWzkXA/1MOiBlxF51Q7zfslx07tmQ1V9xYmAeT0nF/D9W4K1xXyExoTyaNqxTQl2UyWiIUwa5GN1ifNvCKk5W1m3hvHw6bJSwXv8Wv+maLjianIJFf6kFJv9W7VCbIugQZsCJQKuz6mPQQzfj/tt74KWBd2LIU/fgy+nzbKvo+/fvhzgcXW4raWSdwPGdf+p4SXPHHdu2EMap3WdkqJVVd8o55/GWHGe5DFv72RMOSF57pj/V6nHyrr8dxkTylh9gZKjVaTPXgV8d0u3rOnFExkaOmRNQhrp9uvN+zsHFZ/KqvdRdvxUo++jejTDkDhCVD3IwFT/PnT60Drk7lKGfF0ZOJk5u+bZAWfZ6nNz9B5B75m6T3EN/uVXOXkYg7x84cAB0ocXg4MGDoCu7DPh9Dq3vs6f9GcjnG+pWjGsw87qlCN9Q9qMY3OLEEHflS5w4+3QpV4To4iUXs9TDd16PCzq2xMsjJqD7HU+j0zWPot/zo7D3wGGMGtIfEeHKiC6mbGsxBUqM8nzGuTIl9bWj+FJHni9xOr8qZxUQFFt5A37aqdN46OmRLl8SLhMf/miIouiPakKnjqRKFXVjsrKshkeDBg0gLrzhHYDMHkF9EjugerMrdLykueNqtugO1LpeFVb/Sk5YiwEelTfr8JYcUx59a/8Wh0N4g1tgGxMV26JG00sc+rRG6xuBGqrfoT6WSIS3ecUh3b7OarWbAuHlVEb5NxARX7/AvFIuuokaj5YoyQzE1UXlFjcWmL9Wo3ZAfEtr3lw1CaB00YGwWCQ0uASRHYYCYTE6CkkXokr7hwuUJXWbrkqza4AKSm8pqWRGNrrNrXJmefrFH3tkVzx29evXB13ZZcDvTfG+N+RGboE4BuTSwx0nhrZpfIsBLs6dsORxR76/8sRER+LDNwfhi/ee1wuKTz58izLM+2Hu5DfRrlVjmxrF3hFQYnDb375uH9bxYYD2LYCkaaf2ETyfqy45F8KuIBcdFemXxgQXNb8gcaxEVsuXr94Mefvh/kNH8eEXs3Bu22bI10GVzgXOGQu0HQE07e8oxN1Q6/8DLp0LdFsE1O7tbqn8+bwlJ79kxnhCQE3UoP3bQGtl4DZ+2HXJ8z4BrlgC9NgA1LrOdR4ztrw6wMY3ByqeDURUMGNd++WbWMdjm2HA2UNUHkO5Qv5rXAU0ekCN3ceAxg8B9ZSB3+g+QBnpqHY5cN1W4MplQJfZhQhxkdT8aUB06DAaSGjlIgOjSIAESIAESIAESKB0CBgGEB4OiMFtOnfCUq50NHZd6wvDP8YDT45A25aNcdO1l+Cum6/EZRe1179E5bqEp7EGYFgAvYKugGk/X9hFuqHigue/60XtNDvh58qZL+DzdYssvq4g2OXvP3gEffsPQ4crH0DXGwciNzcXrz51j+tmWaKB6Cqu09yNjakJhJd3N3fB+bwlp+AamOIOAVnFjkoqPGdcPdXncYXnMVNFnhwUzXBhvhEBxNQqLIdjWkQ8oOUbQFQllaZ8tdX/YqiXb6R3Pd5EVwPUCrrH5ViABEiABEiABEiABHxIwDTKZeXcdBIn+86+xImTeMPwoVLFEG0YBjIyi3iBcDHk2opo4zwMMFfIxZfrUQffRbrSyyajxDv+EXDseAqmzJyPN8ZM1u7rWQvgr1vbzRZazB36rgkMfPAmLJ/7IX788g38MfM9fetIrU6mjhAAABAASURBVOpFGFyuRTGWBEiABEiABEiABEiABEggQAiI/Wga3c6+uZLuHC9hKRcgTdBqXHJBWyxdudGHhqQBbZyLUS63rotvCVd1K1PSwUhXYYd0Q+UJkn+lprxg78Lr+mHI259h4tS52r3y1gRcdtP/8M+azSqHf/4VRf9UFMy1yO3stWtUQUK8+QxwMLeGupMACZAACZAACZAACZAACYihLSviYnR74kveQKJnUQ2JjYnGc6+Nx6Rvf8nnMjIyS6aukg8xyk3j29k3jXTneClTspr9WnroqM91ffIs/8qfP8KqeR/rxdm6tari8cHvIjs7R6cXZ+NJGRrontBiXhIgARIgARIgARIgARIggZAgIHanp8a55JdygQRgxo+/Q94+vmDxSgwb/UU+dyo9o4TqGtAr6IYyHcUYd/bFEHcVH2igiqDw7/Y9uK1nV/0sf0REOMJVZ8tz/Q/2uUb//NrOPQeKkOCdZEXZU0HM71sCud4Rf2ovkJXiHVnelpK2G8g57W2pgSkvR81YZiYXrlvGMcWjGAfO7FOAuMKlu596+qCSl+Y6f7aKT9niOs05VvLmungOKuuEylnYzKOkiVPZgvw/RX31/vwT2LQJyHKBorDmpaYWlhrYaaftvtZr1gD//ptf3xzVxVvUUDp5Mn+afYxwWLwYWLfOPta6n6sOk4cOWfczMwFx1lDR22Pq61ZU3UVLAdLUV8K+Xmm79Ls7ZbOzgY0bPdPbHbnM4xsCe/YAq1erw7Qau9J3y5cDO3c61pWeDnhjXDlK9TAkP9Waq74QHhbzXXYFLMvNA5r+SU6V33fKULITgQPKzpg/3zFSjq271SXaf/8BGcW4LHGUFhwhWQkXp+wweOIHmt35zquPYd2CCQW6+PJuvuuooG4zxGRUznmFvKgwjIIkBmR8mxaNkZKqrq+dtGvWuK6OCQtTDPSebzf+qcWTNpTlvDnqaJitrnDF6NInq2LCWPMSsKA78MslwK5viynER8X+GQQsuQf47UbgyN8+qiRAxKZsBra8D2z9FNgzy7VSu6apPGPV1fpI4MR613lcxR5bBexUZcXJvqs8nsRteg/4+yFg8Z3A/p8dS+77CZihDkxz2gK/XuWY5hw6tlKVnwfs/RFItbuCPaCuAvar+D2z1Vn/iHMpZcUqa00mM+TqoCRjP79kv8d8/TVwzTUK2QzgfdX9Tz0Fl4aqs2Jy4b9kCbBsGfDHH4AYfM55AjUsF3Jr10JPSIhB3bUr8PzzgLT9ITWspFtF9337gGeeUcPoV+DLL63tlHhnN3cu0K4d0KcPcN11wGWXAaYMMbDfeQf46CPgW3V4++cfQJxcVDrLsQ/LRMmcOYBMnCxapA5DirV9uif7Up/o+P33wPbtwNKlwHvqKzRuHOB8wess96CaB7viCqBXL6BTJ2hD3TkPw4FD4Omngb59reO2e3egRQvg2mutfde/v1VPmYhbrw7fW7daDXn5PlhT/LVVM1arBwMrnwP+fgSQc09BVcvx1XQF5fFGfKaamD7wG3BYfdEOF3Guz1B5ZVEhTc2EZKlzgTfqp4xCCchxuE4dQMZ01arQxvgJNYc+cCDw8ceAnI9kYkpcoYJCIFEMbU+Nc8kv5QKx+fIy6+TjJyHOu/opQ1uMcTHUPfJVOe8q4lNpV15yDmb9tBh/LF2LDVt22NyPv/6t34h/UhnvEv/vNnW88qEmZc5A9zbLnWoa3Rtu165d6gpULavkKZhxOk3N0O/02O3appZl9qirRpGjVjEztk7xWIY32uNKxr4tvwPJahlCdMtJR9rWmQGjmyt9SxqXvl9dlMiFkLQ35V/s3r7Job0SxolNkqr7Pn3vYof0guvfjpzjqp+tJZF9fLOb5VyPp13b1UTCwYVWaUrfzO3fOchLWz9ena3zZhMPLcK+DXMd0k09d+3cBsjdEVpSLjKTrXod2KmWQDOP61go+ScPrM9XPidLLT8Z8rIRa7aUE8fz5THrCXT/iy9y0KwZICtq0hpZMZ4z53SR7dm48YitjBiTmzcnF1kmUFhs356sL+ikvTLBICuJ8nIdCYtBumjRft2W6dOPo1o1QC5sxG3YkKsM3Pzj8uuvs/UEheSB+mzfDnz33QEtY8mSZJ2mopGYKFur27cvW6cXxGTt2sNaR1OmGPr//ru30DKuZG3btkuVsdYpkwabNmVi+fIs2wTCqlW52LYtf5tMWb/9loO9e63l5S6ByZNPKHkF5zfL0fc/ow0bduGHH3IRFWXtLxkz0mfmGJo5E1i/fjcOH86FrLxJLhkT27cn+7VP9/+rZvRSd0j1gDq3ntw212X9J1OUBWbNpbf791u/l74YWycP/Qs53uuKslKwf5fj+c+sc9euncjNTNHZZJN56phL3c389L3zPZgwIUcfh4X5cXV6/vTTQ2py8Sj2KJvjwgsB8/gtE8U7d+4Kyj6Rtrnj5Pss318xuj3xJa878v2VR56NfveTb3FO94dxwXWPadfxqofwweezkF7S58+lEQLKsAAeGecqv9z6juD5zPpJHU+VuvKTdb3vfwmme/vDqZBHCG584GUd98BTI1Qu3/0LOd9JLwOSExISkHDGFXs/Pj4eOTlqFjyPmaG++cWRG1+pOnKiquVJAYzyDYqtU4IX2mUvI65yI6XQGSMsLKFJwOhmr6e39o2oM9ZDriUGFRKrO7RXwrny82Wwfozoyg7pBeuRiNywM7cq5YZXcLNcgst88YnVkBOZZFVCtrE1HfKFVVIr5xIvThnRcVVbOqQnJCTocHxCJeTITw1KPnHh5XR8bLzjTw+Gx+Zvp93Ql5KIiIzUZRPyZAeTX6tWLo4cge3iB+pTs6alyPYkJkarnGf+ExODh0F8fKRN8dq11TxNmi2oOdSvHwfpw4YNIx1uA46NzVVGdoJOS7Dr69q1zxwLTUlnnx2r81WvfqYuuXg006OjAXsZzvtVq0bbjGgpY6hJ/aQk6xh1zltYuFKleMTE5IgI7cqVAypV0rt6Ex+fq8IJBeoi40NnzNs0bRpRYN4EOybcT/A7p5o141Gu3JmxKIa6jJu8rkOVKrmoVasCLJYzeSStfHn/fnfjEusBctEM6ye8fB2XrMIjIqwZ8rZxcdbvZYIPxll4VIW8WsQzEFch/3Ff6o2PT0AuLJLJ6gx+H4SLr129eo5jtkOHGDRsGAUZ43Knk7Uz1ByLmnFKSIh3OZ4SfDBuvCnTbENRvqHOBWFhUN9jwBNfyhUl25/pU2bOw7jPvkPblo3wxAM34qlHb9X7oz/+Bq+NnuQFVQzAUKAM9X0VX7634hcZVuUQPJ9BD9+CKe+/WKQb+9oTPm2UouxT+SEvvEKFCvCWs0REwzr4wxERFetCrjt1xcPSdihQ42qgfl9ENO9fTDnu1OVhnorVgLNfBqp0Burdgaj61weObl7sR3M8RNa4GKjUEahwFoxaPVy21ajdC4hvAVTuhMhaXV3mMeXZ+2FVLwDKN9YuvOq5bpezl2G/b2n2uLVfal2HiCZ3O8iLavYA0PwZoPYNwIVfoUJiTYf0CnbsLJXaA7G1gHINEVH5bJ2vfHyS4nAuEFMTqNAc0YmNdLx9ufDoeLVKfxrIyYJ8oqNj8uWxzx/I+88+G4bq1aUVQHw8cN55wJVXRhbZnurV49C0qRoKlaEulICaNWOLLBMoHKpUiUWNGtDtbdMGePll6Au9yqotjz0G1K5dXrelS5cYNG9uNeDLlwe6dbPoeOd2PPRQOG66CahYEahbF3jzTaB+fauMVq1iIbfQCyvhXKWKGrrKNWoU5lKWKbt69XK67pgYQOqWW+jj4ysUWsYs6+x37GhRbQIaq69g27YRuOyycH1LfqtWwNVXu26TKaNduzC89BLQWR0GBwwAevaMKZYOpjz6xetDd7mNHWtBkjqExccDt94KyHhu2BDo0AF4/31D912LFhbIhb04GfPVqsXqeHfrKGm+8om1gCbqi1bpHKB2b0TXudxl/XJchVxMw4D45dUXoaR1F1Q+OrEB5DyAaPXlrNgK5eMrudRJyltiFODwOEBN6kbEVS4wn+Sl8854Hz8+TD9iU7cu8MorQPv25dCyZRzuuQeQRzXksR25Y6RmTSNo+wNufiwWQJx8fz3xDcPNCvyU7ePJP6Bl0/r48M1BuO+2q3HnjVfo/Xtv7Y6psxeU/OfXDAVKuzBAfEueb+T5BYXleIPg+cjb2ls1a4Ci3FmN6vi0UYq2T+VTuEcEVHdYIgFLhCplKFfM/4TWQGtlpJ81EIip4b4Qf+SUC4iWzwMN+gIR6orHH3WWVh3qYgNJFwI1rgLEaHWlR1xdoNb1QNVLgPDyrnK4jousCFRWlp+4iATXeTyJrdAUOEsZ6Q3uBKKrOpaMqgy0fAE4fyJQ/QrHNOeQ6FVRrbjHKyvM7u4APQ6l76UetULiXAxqZR5ygRYWBcjBHsH7qV0bGDUKePtt64XPLbcAsbHutUdu/5ZnXGvVAowSHALg54/oKkZMvXpQK+LADWouZ/Jk4MMPgUvU0DbVkdWZ3r2Bx9VQEy5izJhp9r5wEKNcLhLnzRMj9kyqXESdo+wQeYa7tTrU1a8PZbxDrWqfyVPQnhhWXboAcgunGPYF5SsqPjER2kBr2dLatxXV11EmDa68Un2Vnb4+zrIi1SH+5pvFuAMeUHNfMmHgnIfhwCHQVh3OJqpDn4znhx+Gfq/CwoXAjBnWMSCaqjlKZdyow6QaDzXVPKR8HyTery6xPSBGeq1rAftjbz4lDEAurqF8+PAjx/Ry9YAENWsVpQzwwqqS655I9aWS84eUKywv07xCQCYT5X0Z8v4Eec+CCDXUkJDjtUwgygSpTGKWheOTtFvOKxYL4Ikv5YRboLikxASc36FFPnWuu+ICHbf/4FHtF39jAIYyxs2Vc7d9VQ78eEpADUdPizA/CRSPAEuRAAmQAAmQAAmQAAmQQKAQMJT96KlxLvnFBUobRI8rLumInxYuRZa84U8i8tzJtNN6r3rVStov9kZAiVEuK+We+HpCsNi1ltmCNNDLbNeHXMPZIBIgARIgARIgARIgARJwm4AY2oWtnEuaOOd82l51uxbfZzx1Kh07dh/A3QOGo//g0TY3ePjHuvIXhn+k414eMUGHPd/ITEbeCrqDka7iHMLKtHQIq3KeV1bmSyiKZZ4BAZCAGwSYhQRIgARIgARIgARIIJQIiKFtb3zLG+ztw87GuZku5QKJgyXMgovPa41ycTHIzMy2uZrVk3S8LU5+JqZYiovJqJwlXJVWvnm7u2mM28JO6VxBV7w8/1eEPS/EEiRAAl4mQHEkQAIkQAIkQAIkQAJ+JSCGdphaBDadu2Ex4v2qaBGVPdz3Orz/+hNFuqHP3FeEpAKSBYw2xtWKuPhikIsv77MQv8BwAfIYXSgBGuiF4mEiCYQGAbaCBPxJYPNm4KuvrG7LFs9rljI9ewJt2gDduwPff39GRkYGMG4c9NuG5cVdZordenyuAAAQAElEQVSUGTsW+PRTa72Stm2bmQrs3w+sWAEsXgzIS77WrQNyHX9p6Exm7pEACZAACZQJAmJoixMDXXxzhbyosNirZQKQrZFiMiqnX+QovprVkGfRiwyrvDYZgbuTnZ2DP5etw+A3PsFdA15H9zue1q5Pv2EY+cHX2LBlh1+VDw5qfkXiWWUZ6mqRLgNkUKYZsP95HLCNgePHMyBvXj96FBAn+8nJnn0/+vXLxd9/A9HRVhlDhgD79lll/PhjFl58EZg92/o2+BUrMnXd77+fi99/hy4nb39fvhz47DMgPT0DycmZWLMGOHwYSEkBTp8Gdu8Wo91a1jx+paenq/x0ZZWDOQ7oW79r5EAOwTwG3L2aF0PbNMbt/YLixYiXfJLubh0hkU8aLKvkcsu6XjFXK+lm2Nm3T5cV9iAAMOqjabhv0JtYsHgFYqKj0LxJPZzVqK7aj8TkGfPR+/6XMHHqXL+1hAZ6CVFv374d2+nIgGPAh2NgO2UH0fhavvyYw8q0rFL/888xj/pQjHP56TL7w/OMGVYZX355yj5aGeEpWLJkn1ohVxcLKkWMeuXpfzHG//57P7ZsOa7DzpstWzId9NqxYwfoyi6D7UH0PaOu2x2+u9vZd+ThNAacj/cFhcXuNI1u0xcD3HklXeLs02W/IJmhGa/OsWKcizEOtXouK+dm2Nl3SA98U3PV+q34ePIP+L+n78Vv00frxwRGvPgwRr78CD58cxD+nD0G997aHW+MmYyTqY7XIL7qa4uvBJcVuU2aNAEdGXAMBPEY4HfYq8ewSy+tioSEM7ePx8cDEufJd+Tllw1lcAPmr8XUrAk89FBVredrr5XX8uUcU6MGMGRIIi6+uC46d4b+pKYCcsEF9enYEbjoojro0KEyYmOh4800ubjq0CFWy/REN+ZtQmY8ZnAMcAwE/BiAmx85J5jGt2mUy/lBnBlv+vbpUs7NKkIjmzRYjHJ9W7uYj8ppYz3P10Z6uGqrhJXT+ZQhD2XYq9hA/t/83y4kJpRHz6sugmHk1zdcDYC7b7lKN2Hrjr3a9/VGCPq6DsonARIggTJLoCw2/LbbgBtvBHr3BmTfUwb9+wPyHPvQocCECcA330CdNKE/9esDGzYACxZYnykvV05H48EHgVGjgHfeEaMdeO454OabrWlyvr3gAuC884CuXYF27YDLLoM22q05uCUBEiABEiiLBMQQF6dsMDj7EifOOV7Ccl4pW7yUyWgop29fN31lgJthMdZdpQcBqGpJiTianILDR13fbSf9vH3XfvEgt7/rHR9vFGEf10DxJEACJEACviIQsHKTkgBxxVUwMRHo1g0466z8EuSCqXlz2Ix25H2kPlkpl9vcpXxetM0TY17KSr4guGaw6c0dEiABEiAB3xCQc4H9yrgY3+6EpZxvNCqe1D37D2PZqk34+bdl2v29YiOOn0gtnjCXpdTKshjgemXceaW8sLAq51Je4ESe3byhXkG/6cGX8cmUH7Dor9X4Z80W5TZj4Z+rMHbiTDzw5Fu49IK2aFy/pl8Up4HuF8yshARIgASCkQB1JgESIAESIIHQJSCGthjlMnnr7EucOOd4CYsLBCqbtu7CHY8NRbdbBuHOx1/DgBff0+7uJ15Hp2sfRf/Bo7Hv4NGSqyqgxDg3V8zFl2fNxRfDXXxX6ZJW8tp9KiG+fBwmjn4ObVo0xlvjvsZDT49En35DlRuGR559G2M+nY5unTvg/565Ty0M+GfCgQa6T7ucwkmABEiABAokwAQSIAESIAESKEUCYneaRri5cm6GnX37dClXimrrqk+cTEP/F0bjREoqhjx1D6a8/yK+mzAUMz79P3zx3vN4rv/tWKFWgh98cgRyckr6u6LKMLWYK+Vhqn5lQppGudzero1zV+mqnMod6P8N6lTXL4X76/v3MfXDl/HxyKfwmTLaZ332GpbOGYehyjgXQ95f7VB0/VUV6yEBEiABEiAB/xFgTSRAAiRAAiRQGAFZCRfnbIwXFQ4EA/33v9Zg975D+GLMC+jV/WK0atYADevVROP6tdC2ZWPc3utyfPDG/yAvNtu192BhGIpO0yvhymy0GeN5RroZdvZN4x3BYaCbAMrFxeifWDuvXXO0P7sJxHCPjYk2k/3mK9J+q4sVkQAJkAAJkECoEGA7SIAESIAEgpyAGNpFGeOu0qVcaTc9PSMDYjxWKBdboCpVKlfUaUeTT2i/+BtlaIvRLYa6+HrFXBnpZtjZt6WrcsWvNCBKZmVn46kh47Bi7Ra/6UMD3W+oy3hFx9cDqwYDy/oD+38u4zCK0fzcbCBlM3B0OXByqxKQq1wA/R9bCWx4C/jvU2Dn18DB34Cc9ABSkKqQQLARCAJ9jy4Dlj8O/P0gcGCe5wqfPgDsnQPsmm49vnkugSU8IXB8HbD5XatLXg3snAqsH271czI8keTdvKf3W89rp/YCcq7zrvSSS1v/GjC7GbDwGuDEppLLK6kE+d4s6wf8cgmwblhJpZX58mJoF2cFXcqUNrxmjesi7dRpTPj6R2RmZuVTJ+1Uun7BmRjx9WtXz5fuUYSAEqPbeaW8qLCU8aiiwMucm5OL7+ct0c/6977/Jcz6aTHSMzJ9qigN9BLi3bt3L+iKZpD+3zQgdRuQcRS526Zg756d5ObB2Ek++J9id0xdvKgDcPphHNm/LYD47UH2HjXpkqMOVmHRSkc1mXBqD5L3rAkgHYseo/wek1GZGgMeHH8K4pL57yR1XN8BKIMh59+J6vu+Rzn3x1H6wX/Uce0okJ2G3CP/qLK7lXO/fEF6Md41w6w9PwHpR7TL3vMjIAZ79intH9v5V6mwP3xgF5CZos4bOUBWKpIPB9YY2L9jNfTkc/oh4PCfSF07tlQ42Y/pExunAIf+UNyOq8mVaTi09fdS18lev0DZd/fyXuxOVyvkYoAXFi/l3K3DV/nOalQH99zSHW+OnYI2l9+Hmx98BfcNehP3PDEcYkh2vOpBfDVzPl577n4kxOf9JmmxlVEr4WKMy0q5R74qV+w6A6NgREQ4pn/yf3iu/x2omlQRzwz7UL9Mzpfa0UAvId3o6GjQFc3AIkc6O9bR0THk5sHYiYiIsKMHREZGBhQ/Qw7YDhoConO0B21k3qK/R2RERoE0BgzjzIWX7Nrr5s5+/vMC+9cdbsXNY8/b+ZhdWsdrOZfZnzpKS4+CmEapc629fmHKYisor7/iw+VNZXZKCUN/1R1M9dghKnRXLk/Fqa6FJ74c8woV7KfE/z10E2Z+OhSP3nU9qlROwOnT1rth5Nnpx+7piTmThuOyi9qXXBvDAmgX5pmPM+cJBPGnSYNauL3XZRgzbABW/vwR7rvtap+2RtH2qfyQF56YmAi6ohlE1OsFxNUHIhNh1L8FiZWSQG5FczMZxVWsrdhVBIxwIKoyyifWDCB+lWCp0RWwRADZp5WOYUBMTcRVOSuAdHSftcmcPplxDBQ+BsIb3gbE1QWiq8JoeKf6vldSrvAy9kwjKreBnBMQFgujUjtVtrJybpVnvmJce1iqXwZEVdLOUqMbEN8CCIvRfrnqwt//7CtUrApElFfnDQsQHoe4+KoB1bcVq58FNPufYpYEVD4f0c0eLHX9Yhv1BpIuACLigTq9EV/7nFLXyf57HSj7cPNjGICnxrnkl3JuVuHzbI3q18QjykB/d+jjkLe3f/L203hj8EN4uO91qFNTfce8ooEBGGHKWZRTPvJ802gvMKzKIbQ+ERHhejLEl61SdH0pnrJJII9AfHOg9RCgw2ig2uV5kfTcJiAHxfJNgEQ1C1quoSoWYAe8iupCWy5iGtwN1LkJqHIxYIlSevKfBEggZAkkdgDajwLO+QCoqibpPG2oMuxR4yqgdk9Ajm+elvdZ/hAVLAZ5k36AuISz1bH6RqD501bfEll6jY6uBsh5LaYGtAGAAPs0fxbosQHoPAuo0LT0lZPvTYd3gct+BVo8V/r6BLkGhgFYlDUkRrcnvuQN9KbLT6v9t3Ofd9QUUIYCJdej4luUkS5+UWEx3L2jgU+ljJ80Wz8ecPjocV2PvPX+rgGvw97NXbBUp/ljo0j7oxrWQQIkQAIkQAIkQAIkACIgARIIGAJid3pqnEt+KRcwjShAkezsbFzT91lteC78cxWys3MKyOlOtAGIMS4Gt0e+KofA/sgL3z78Yrb+SbXKifFaWXnB3tKVG/V+THQUDh4+hs+n/aTD/tjQQPcHZdZBAiRAAiRAAiRAAn4gwCpIgATcJyAr4eLE6PbENwLf7oRhMXBFl45YtW4rHnn2bXS/42n8uniF+3DscxpiMionK+dipLvrG4EPau3Gbfpt+Ldcn/9OsCFP3YP3X38Cgwf01T+zdjL1lD0Vn+0r0j6TTcEkQAIkQAIkQAIkQAKhQ4AtIYGQIiD2o71xLvviCjLWJU2clAt0EOFK0ZEvP4o/Z4/BVx+8hJuvuwRHj6UUU21laGujPAzQvjIhXfrO6UYx6/NfsX0HjujK5MV6esfFpmG9mjpWbn3XOz7eKLo+roHiSYAESIAESIAESIAESKBIAsxAAv4lIIa4OGXLwpUvL813FS9x/tW0+LWFWSxo2bS+/km2G66+uJiCxNBWZqNplJu3uVvClTwVbwsrA11W2M2wodJUjkD+NywGYmOiHVSsWrkinn+8DyrGl9fx8riA7OTm5orncxf41HyOgBWQAAmQgP8IZGUB+/YBx475r05v1ZSiJt6XLgV27gQKO0cdPQp8/TUwfTpw3Pq+FZsKmzYBU6cCK1YAwsKWYLeTng58/jlw++3A//0fcPCgXaIfd1NTrfrnlOSxvWLou3cvMHo08OqrwHPPAd9/D2RYfzmnGNLcLyLtFPbiS6nsbGDHDqtLSwP++guYMweYPBn44w/g8GHJFbxO2rlgAfD448A33wCZmfnbcuqUlf+33wLSL7t3A999ByxaBAir/CWs343kZEC+B1KHqzzBFiff1WnTgH79gGHDgOXLAfl+CItffoFfxqdXmBUgRI5nf/4JfPCBtZ8LyOZ2tHxf588HPv0U2LLF7WKFZpSxJMxPny40W4kTpa///hv46Sfgv/8KPk6XuKJCBMi55tAh/9UtxrnpZGXc3Be/oLDEF9KEgEjatnMfxk6Yga43DcTxFHVCK4lWhjIZtXGuDHXxxQAXX35GTfzCwiWp1w9l69Wqpm9x339IXbzk1ZcQXw639eyKcnExOmbDv+rCR+3VqlFFbX3/r2j7vpJQriFHHTHpckAGZMAx4N4Y+OcfYPNmYPVqMXxyg+a7k5mZg3fftRorn3wCrFzpWvfU1Bw8+yywbBkgF7zDh0MZPlY2y5fn4IsvoNpsZfDrr7JvTbMfP088kYunngLEmJ8xA7j+eiAlJX8++zLe3j94MBdijO3fb52Q8Lb8guSdPJmDgQOBNWuA334Dfv8dEIajRrnmXZAcT+OzsnL0ZIoY4jKpIv3955+5WLwY2o0caZ1UmTABeR6zXgAAEABJREFUiFYLDerUhw0bhI1v9fK0HZ7knzYtF7fcYp0Muv9+YPDg/G156SXrOJSJCpk0EgNOJpfE+JLvgav6du3KxbZt8v0Gtm6FGu/+HbuudCpp3JAhuXj+eUB+FvzECeskm0ygPfMM0L8/MHRofnYlrdOf5adOzUXXrsATTwBt2gCnTxevz0yd338fGDPGeryU4+HGjSWTJ3IPHLBO+ojhevy473h/9lku5NgsBqiMXzlnSf3+cnLslXOkTASvW1f874+7todaXIY4McbFL2jF3Dld8rpbhz/zHU1OwZSZ83Hzg6+gR99nMWbCDDSoWwORERElVEMZ5nplPFzJUeajGOQ6HOYUdk6XciqLG/8ZGZk4cOgYvLVKnZOT69aL8YRPYkJ5vDFmisu6006dxoj3p6BZ47qoUC7WjZaUPIsiXHIhZVnCxo0bQUcGHAMcA+6MgbVrt0NW5Mxj5q5d6UFz/Fi0aLfDKtmSJakudf/++72wvw6Q1Zh58/bovN9+exx16pitt15srl37r06z5zd7dg7KlTuTT1ajvv56b7589mW8vX/s2JnlVFkp3bjxP7/UP23aPsgFoqySSb0mhYULs31a/969jsvh+/cfxb59agldKSAry1ajHYiKAipXVpF5/7t3B88Ydh4jU6acclgFnzbNkfHff2/Rd7qIoSLNlf6wvyiXOztWrsw/fo8ezZLs2p08CdVv+fM46xLo4XnzclGjBmzfbRmfMoGmG6k2CxZkqXYG73ng009VR6l2yL/02ccfW49ZxemXFSu2KBaAOW6gPj/+eFTFFZ/Pli075I4jJcn6f+zY6RLJK6xdCxdmolEjaz2yle/++vX+G8N79pySarWT88e6dTuL1VYtwI2N9JMY36Yv33EJm77si3NOl7Ab4nUWbxueWqjd5nR6Bn7+bRn6PT8KF13fD0Pe/gxrN23D/bf3wIJv3sFHI55ETHSkXYli7EqDxSg3LIBeMVe+DoflhQ1Ah1W8fboY8Sj8Iwb52Ikz0bbb/bj0xidwcc/+WLVezW4WUEwmIVp0uQvObsk/620lROYrIyfg1bcn2uIK2hE2Lwzog7kL/kaffsP0i/Tk5+k2qO/d9DmL9ETHjt0H8PzjdxQkwuvxiqLXZZYpgc2bNwcdGXAMcAy4MwbOPrsBYqx3S+njZJ060UFz/OjcuQ5k9Uwrrjbnn1/Ope7XXFNLrZirDHn/Ymxefnltnffaayvq2+PzklCpEnD22U10mj2/a64Jg1wkm/mk3ltuqZUvn30Zb+8nJkaa1WujtHnzRn6p/6abamp+skot7TaV6NIl3Kf116rleNtejRqVlUEmKyHQRll8vNUXI9X+1vbataN9qpe3+9Ve3q23xuq+NRnfeKMj4/POa4qKFaFWVKw5ZHJC7hywhoCqVYF27fKP30qVzqxUyURT8+b589jrEQz7l11mURM2cjeMtfUyPpva/ST4JZdEBO04EP733GN9zlRaJ332wAPWY5akeerat2+Kxo3PjBuR2b175RLxadq0vp64E1niEhNjSiTPdZus5/EuXSLx779Si9XJd79lS/+N4Vq1Yq0Vq62cP1q1qlestqribv2bhrjUZe47+2KgO6cbRtHixUj0tuFpX+vho8fxysiJyijvjwEvvofN/+3Go3f3xBfvPa+zXXJBWyRVStD7Jd9YAENcGCBGt2mMiw8VZ6jzhct0Q+Uv/H/lun8x5tPp+Pzd57Dy549w/ZUX4YmX3oOsgLsqKVwlftzw/+GHL4bbXGt1npb4ucrQFiN/2uyFEnTLXdHlHLw5+GFs2roLjz03Sv88Xe/7X8ILwz/W5T98cxDatlRfbB3y/UaR9n0lrIEESIAESMBKoF07oEkTKMMUDqvJ1tTA3coFijx/evXVwD33AK1bu9ZVJiBeew3o0AE4/3zg6acBKSu5zz0XuOMOQC5+hEGXLhKb38nt1G+8AYgBcP31wIwZQFxc/ny+jElKAmrVAqpV828/xapr07ffBlq1Ajp3Bi680MpQbiP2ZXulT+RCXOoXX/rsvPOATp2sTm67b9sWuOsuuf3X2ofNmgG1a/tSK9/KvuEGYMoUoE8fYPx46Gf+nWt85RXrOKxb15rvwQcB4XDppcDddzvntoZl3NSvD0iZhg2tccG+feEF6PdByN0sFSoAN94ITJoEvP669X0J8q6EYG5j797AvHmAfPdWroSelCpJex57DHj0UUCOl3I8lONdSeRJWZkQSkwE5NgkfSBxvnDyfbjkEusEg4xfOWd5pR43hUj7hJfcbdWihZuFSpDNMKDPSXIMlOOeK1/ixNmnS7miqvW24elc3849B/H1d7+iepVEbZT/+OUbeOTO6/Qt7c55Sx42AEMZ4vmMc4uKV86MN31Dxen8qhwK/8z/fQXO79AC7Vo1Ud+9cPTp3U3f6r5pq/W574JK16peGXVrVbU5WQmXvBed2xpTx7+CHperixCJcNN173ou5I6DL8cOxrBn79cG+zQlZ86kN3BBx5ZuSvFONkXPO4IohQRIgARIoGgCMgtfvTr0ylzRuQMrR3m1yNSxI/TEglHIOVcuIm+6CejZE4iPd2yDGN1ycS9GjrBwTLWGZKVSLhLFABDDoEoVa7y/tzIpIPrLhZk/65ZbicUgf/FF6BdyyUW+/Wq6r3SRdgp78aUOuRgVI1OcGO4ywXLVVcCttwIXXACHW90lf7A5aWeXLsCoUYAY6/aPZphtkQkn4d+rFyD9Isb3tdcCF10Eh9V3M7/48t1ISADkeyB1SFywO/muihEr76EQY7x9e+ukmbC47DI43F0TjG2VPpMJRZmAkX4uaRvk+2pO4shqeknlSXkZS3JMkrsXJOwrJ319zjlAt25AgwZwWLn3VZ3OcuVcI4a66OKcVlC4uPHS98JWjnemcycseYqq09uGp3N9FePLoWpSRWzdsRf/e2Us3lOr0P9u2+OczTthASUGt/3t6/ZhHR8GaN8CSJp2ah+Ff/YdPIL6tavZMlWprA6gKnTwcLLaFvw/8oOv9Qr3Z1PnOrwELzYmCtWSEhEXG1NwYacUuaV+1k+LkZWdjdbNG+K6Ky6AGOzy3PnBw8cgafLSPadiPgsWTc1nVQeX4JSTaTh2PCW4lKa2JEACJEACJEACJEACJEACLgkYBvQkhBjcppOJAXNf/PBwQHzTSbqUcynQLtLbhqedaL1bv051/PLVSHz+7vPo0qktPpv6E667+3nc+vCrOv1ESpr2vbNRoAyLEqWc3M6uV8rVvvbD8+JdhQ0sXLgQr776qoNTBWz/J1JSES2zw7YY6J89O5l25n0EdkmIiozQb1g/WxnSiQnlMX7SbNz1+GuQZ/3t87m7L7fSPzVkHCYqQz8uNjpfsQrl4vDq259hxLiv8qX5KkJI+kp2SMiVN/f1e34UzuvxCC68rh9ufWQI5JmPkGgcG0ECJEACJEACJEACJEACZZTA2rWrMWnS5/jyyzPOnfCaNavwzTff4NZbb3Vw9hjdNzytpYpjeFosBtq1aowXn+iL32e+i1FD+qFR/Zpa4ENPv4W7BryOb3/4Ta8M68hiblavWYvPP/8Sn09S7otJVt8Mf+4UtktftXoN6tWrhy5dujg42H0qlI9Dujw/Yxcn9le5AlbA5afPnn+8D+QleAMfvAmfjX5OP3+/Me+n0OzEuLW7bvN27N53CM/2ux3hchuFU6n4CnEY9NBNWLB4JU6mnnJK9U2QBnoRXL+cPk93+q/T3sGS2WMRZrFg1EffFFGKySRAAiRAAiRAAiRAAiRAAoFKoHXr1jj77LOVerkeOyk3cOBAjB492sEpQbZ/fxueYuBfdlF7jB7SXxvrYrSfOpWOwW98gtS00za9PN0xOWlKapNrOiVI7zv7dunC6dprr8XFF1/s4FQR23/1KpWwfdd+W9i8td281d2WUMBOlcoVdcqp9Azte7rZteegLtLqrPrad7WR1XqJ37XXmlf2felooBdB98df/0bvHp1RpXICypeLRZ/el+uZKPMNgkUUZzIJkAAJkAAJkAAJkAAJkECAERDDs2/fviiu69y5M5KSkhycfRNL0/CsGF8eN193Kb764CX9lnNXt27b61rYflGciuIn5QuTf+mFbfHH0rX4Z80WZGZl47Npc/Wz9U0b1tHFJnz9o/75Mx1Qm4V/rtI/iXY8JRWy0i4Lp7Ex0TirkTV/dnYOMjOzkJ2djSwlT/blNnZV1OW/5JPykZERLtMlUiZbxPeX/UcDXWgX4uR37+rUrGrLUbtGFb1/4qQ3n+vQIrkhARIgARIgARIgARIgARIIAQLeNjyLi0TedO7q1u3iyvN2uTYtGuGhvtcqI3wo2lx2L76a+SveeukRWCyGVIVDh5Nhf/t6RmYmXhj+CTpd8yg6XvUQ5sxfgnf/rz/iy8fp/N98vxBtLr8P8jNrM378Xe/P+HGRTnO1qV+3ujb0C3sJ3Kp1W3VR0w7UAR9uaKAXAldmSWRmJjoq0pZLbh+RQFrerSIHDx4EHRlwDHAMcAxwDHAMcAxwDHAMcAwExhiQa/XSdt42PEu7Pb6q3zAM9LunF5bP/RA/TxmBv75/3+E3x5985BYsnTPOVv3lF3fAn7PHYP7Ut7X7bfponNe+uS39pmsvwboFExxcr+4X29Idd4DG9WvpFfvBb3zi8DZ4M9/OPQfw2rtfQH4GTu6mNuN96dNAL4SuYRj6LYLpGZm2XOZ+rIu3/NkycYcESIAESIAESIAESIAESKDMEjAM7xqeoQ5SFkRrVKtsWzkvrL1yR0DVpIrasDYM60p7YfkLS5PF16FP34cVa7fgspv+hzfHTsHU2Qsg7yF7acSnuOr2p3E0OQUvDuwLjz/FLEADvQhwcluIzJyY2cyXA1QoF6ujqlSpAjoy4BjgGOAY4BjgGOAY4BjgGOAYCIwxoC/SA2RTWoZngDQ/KNQ4v0MLfPvxEMiL4uSZ95dHTMDQUZ/r2+S7XtQOcye/qVfa/dUYdw10f+kTcPVc0aUjps5aAHmjoLxa//NpP0NukzCMks3WBFxDqRAJkAAJkAAJkAAJkAAJkAAJlEECTRvWxidvP41V8z7GnEnD8ctXb2HN/E/1W/FrVU/yK5EAMdD92maPKrut52VoULcGLuk9AOde/bB+K6A8J+GREGYmARIgARIgARIgARIgARIgARIIaAJy+7y8ILx61Upu3W7vi8aUDQO9BOTkZwnef/0JLJ41Bgu/HaV/rkB+cq0EIlmUBEiABEiABEiABEiABEiABEiABPIRoIGeD4nrCHl1f+XEeJeJjCQBEiABEiABEiABEiABEiABEiCBkhKggV5Sgr4vzxpIgARIgARIgARIgARIgARIgATKAAEa6GWgkwtvIlNJgARIgARIgARIgARIgARIgAQCgQAN9EDohVDWgW0jARIgARIgARIgARIgARIgARJwiwANdBeYcnNzkZWd7SLFGpWTk4vs7BxroARbqQ5JBHEAABAASURBVOdocgp27jmI9IzMEkgqu0XLSsuz1HiUceeqvTKOJN1VmqdxMg537zsEGZeelpX8aadO4/iJVNmlC3IChY0pb445+fnKXXsPIjXtdLGIHT56HKfTM4pVloWCh4Ac/7ILOe9mqWOkN1ojcg4cOoZ9B44U6zwv41h+llW+I97QhzJKj4CMBRl3BWkg6QWleRJf0vPukWMnkHz8pCdVMi8JkECAE6CB7qKDZv/8J7rdMshFCiAn3VdGTsCrb090mS6RC/9chRZd7oL4KOCzev1WXNyzPy66vh+uuv0pXHhdP0yfs8iWe96if7QMkWPv5EAu+ezjzP2BL4/V5cW4MuPs/SX/rNfpl974hJZ97HiKDstGLnA7XvWQji/shCR5y5ALiKaeOp2BXvcMxg/zlrjUp7DxKgUy1ORPn37D0Pv+lyRYoHth+Mdo1+1+XHHrk3pcShnzpF/UmJIL2n7Pj0LnXgNw2c3/g5TdsGWHrksMfhmHNz/4ig6bG0mX+PsGvWlG0Q8QAjJp2Lrrvdi7/7BLjYoac3tUOTmejPzga5flJVImc3re84L++corb3sK53R/CENHfW4ziooac38sXYtbHxkCkXHR9f3Rf/BoiLEvssVde+dz+ngmY8x0YyfMkCQMfuMTnbborzU6bG5kDEvef9ZsMaPoBwCBos67RY1XacLbH07VfX7iZJoEXbqvZs6HjHs5R8px7PJb/oe1m7bZ8hY2puQ4+/TQD/Q4lp9l7XrTQKzZeKasyGyhrgt43rXhDOidos67RY05GQ9yHizJeVcAFTbm5Dgr51W5lrzgusdwzxPDIca6lBM3fMxkPeZl3JnujseGShJm/bRYp70zfpoOm5tJ3/6s48dPmm1G0ScBEigFAjTQ7aDv3HNAGyfPDPvQLvbM7twFf2ujetrshWcinfY2bd2FQa++7xSbP5iroh6/rzcWzXgXK3/5GH1v7AYxkMQAV0nIVX+xMdH44YvhDi4yIhyXX9zBIU7ynN28ISpVLC9F9SSC7Iwb/j+HfK2bN5Jom5s8Y75t//tflkAumG0R3PEDgaKrGDHuK3S48gFs3bE3X+aixqsUsF7YTsQ/azZLsFBXu0YVTP3wZT0e50waju279uHrWb/qMiJHdgoaU28pPWXsLv7uPfw5ewzq1a6GUR85nvjlQvfvFRtFjHYTvv5R+9wEFgExemXS0JVW7oy5FGUAPfz0yCKPJzIR2PXC9vjxyzewet4nGDd8IL6cPg+r1v+rqy5szMnK1QNPjsDF552N36aPxsJv38G/2/bYxqsWoDb9773B4Rh4W8/LVOyZ/w+/mGUL/LdzH+b/scIW5k5gEJhbxHm3sPFqtkAmtT/68nszWKAv51wZh0vnfKCOY2PRqF5NjBznOMlU0Jj6edFyLFaTRtPGv6KPoZ3Pb4NBr4yFHBftK+R5155GYO4Xdt4VjYsac3LsemVkyc+7Upe4gsbc+C9mo2JCOcyf+jb+mPmevgtJzsVSRpzo0aVTG4dj4IiXHpYkmxND/HhKqg5nZmXj48k/6H1uSIAESpcADXQ7/jWqVcbE0c/i+cf72MWe2b3o3NaYqk6+PS4//0yk3d6hI8l4+JmReHnQXZATvV1Svt3WyqDu3aMzEhPKIyI8DFWTEvW+xXKmS6KjIlC3VlUHZxgGysXFOMQdP3ESsiLfp/cVDvXUql7ZIV9MdKQt/fZel+HTKXP0AT07OwdyoXp7r8tt6dwJDAL33Xo15k0diapJFfMpVNR4hSohF6XrN2/HwAdvUqHC/x/scw2aN6mnx2P1KpV05oQK5bRvbgoaU3sPHEFSpQREqAmk8LAwtGvVGJv/220W0/7tasx99KV1Vl5m/mUV9sYeXXQaN4FDYNSr/TB57GCXChU15rKys/HkkPdV/zfBFV3OcSnDjJTj2GP39IRMDIWFWVCjaiWdVKFcnPbNjasxl5GRpZOrqeOmYRj6eNumRSNs27lfx5ubpErxDsfAhPgz47nnVRfpiasVa62r5Z9P+wm38xiIQPsUdd4tbLxKW5au3IhhoydhxIuOhomkObtrunXCReeercZTFCqUi0WF8nFIiC8P+09BY2qymlySMdWscV3IOb3/vb0gdw/JxJFZ/nZ1DOR516QRuH5h513Ruqgx95GaDPLmedfVmJM7QabOXoBbr79MXx8kqGObnMNnzv3DtkgjupZX49j+OlKOmRIvTsZqu1ZNMHXWAgni54XLkJSYgLYtG+swNyRAAqVH4Iw1WHo6BEzNYljIwauiOtC5Uio2JgqSHhcbky9Zbod67LlR6HXVxbi663n50guKWL56M14a8SnGfTYTz/S7XZ/YzbxHk1Pw3GvjITOx389bUuBz8SM/nIpbrrsUdWpWMYtqX24vlVX5z6bOhTlDqhPUplOHlvrC9ZvvF2LhklWIiozAJZ3aqBT+BxIBOenKmIsID8+nVlHj9Sd1spW+f1+tTJZXkzr5BLiIkNvyxn32Hfo+/hraKiO7u9NYth9T9mPqnluuwowff9e3Gf+6eAVkVv6RO693qOHW67tCbktet2k7Jn3zM/r07oYqlRMc8jBQ+gSkT2TC0JUmRY25N8ZMgRjPzz9+h6viLuPEiJFx1e+F0Xi473VoVL+mQz5Jcz6OybH43lu767uOZLVLjo+L/lqN23p2dSg7dfZCnWfshBmQ1X/7xIrK8BIZcjEtk6tff/cr7rjhMvss3A8AAtLXcgx0dd4V9Qobrzt2H8Ajz76Dd159DI3r15LsbrnvfvoDA158D2JkPXBHD4cyBY2pzMwsWOwm2GV8ScF9B4+Ipx3PuxpDwG8KO++K8oWNOV+cd12NOYuamBRd7MecTKBKnFw7ii/u7xUb9HXkm2OnQK43Jc7e3Xfb1fjg81lIO5WuztuzcL/TeLfPy30SIAH/EaCB7gXWcqvm869/hJrVk/DIXY5GSVHi5UU08kIZObkn2z0TLhfIdyujp36d6lrEU0PGYfh7X+p9+82iv9ZAVggeuOMaW7QY23KhKre9J6oVejGW7lIGlxhfZibDMCBlJG2sunh9sO+1MCyGmUw/yAms2bgNMibHvj5QTyq525zsnFy98i13ZZxISUNK6ildtKgx1bRRHT3hYzEseGrIB5DbnGVFUxfO2yRWrKBWKC+D3II3UU0a3XFDoXds5JWiFywEJs+Yh4V/rsTbrzwGuZPCXb1lrMjznOLvP3QUciyUskWNuU4dW+q7jrbt3KfG3DjIapB5gSrlr+jSUd8CL3Fy6/oN972Uz0i/Ta1oLli8Ei+++Snkbg457kpZuuAncPxEKuQxiCceuBEXqLHiSYv+27FPP8ubnZ0DOQ6aZQsbU1d1PVcZOLMx4asfMXfB3xCDyCxn+obB867JIhR9b593hVFBY07uQLr4vNZqgecT/f4iuSNt7MQZUsTmWjSpB7mrQx4527XvIPr2H6bHpi2D2pE7RqpXScT/XhmrjfRLOrVVsfwnARIobQKW0lYgFOqXtwjLCbl8uRiMeH8K3hgzWR3oTkOe3527YGmhTZTb5d9//Qk1w99P34YnbzOWAq3Oqo9BD92M+2/vgZcG3okhT92jn8/Mys6WZO2y1cXDyA++gqwC2d8CLQfu5x/vo8vKrc2fjX5OG10b/92py5mbSy9sC7kV/2jyCXTr3NGMph8CBGbMWQS5LW7OvCV6PP4w/y/IapKMTTGECmpiTHQkRr78CL7//HWEh4dhzKfTddaixtTAl8agx+WdICtV86eORMc2zfQLvLLsxqsIuuOGbvhLzejLraS11ISWxJWOY63eJiCGidxK+cHn3+kxt27TNixetk4bLYXV1axxXT1uZqsxJ8fLOb/+pbMXNubk7o17B76BES89gjHDBmDOpOHYf/AoXnlroi4rm0fv7qlX5B+58zp9y74cn+Xlm5JmOlmZ7dX9Yvy2ZBXuvMnxESEzD/3gJLDkn3X6FnM5p8px76PJ3+uGyEux5AWVOlDAZsD9vfH5u89Bxsb/Xhljy1XYmLrzxisw+Im+asyvxTff/4a00+m6XPW8x4V0QG143lUQQvTf2+ddwVTYmHvjhQdxjTrvym3tc9WkkLkIIwszUlbOs/3u6aUXY0YP6Q8Jy/sYJM10FrUwI9eZcgyUW+TlcSMzjT4JkEDpEaCB7gX25eKi8fh9N6BmtcqQW6PEidhycTHKAI6S3SKdXNhKJjH2xXd2SZUq6qisrGzty+ZHdUCW53xlpV3CBbkqla1lTzn9FJHcrvqiMv5fGXQ3IpQxVlB5xgcfAXkxzPVXXggZi+LiYqMRHRWhw+6cgA3DQIM61SErmq5abz+m5GeF5AVwZzWsrbPKM28yaZR26jRkdVNH5m3kMQy5iH3Q7o6PvKTQ8spga+Qxhw6tm+oxJmNOxll0VCTkWV53cMSXj9OTSvKLAK7y24+51ev/01maNrCOuTo1q6J3j85Y9NdqHe+8iYgIhzxb6XwMlHz33361fu+IebeSxNEFPwF5wZuclyvGl9Nj0hyHCRXiIC9bdaeFMiaOJqe4fLzMeUwZhqEfNfvwzUEQV12tSsoEeIO6NRyq4nnXAUdIBXx93nUec3KulTtEJrzzDN4d+rh+vOjSC9rCMAyXXGVCMjXNOnFkn+HKS86BGOdXX3a+fTT3SYAESpEADXQ7+PLGS7m90jSC9b7dCmC2WrGWuGwVJ3lkX25vl5Ow3C5u7ySu+6Xn6RfOSBVLV27UP3Mlq5gSllnM+b//o58NlxXNsRNnKmM+GnJRIenyNmN5XujU6QxtJMlL3M5t20wZWdYXvclMqdwqLLOrFePLSxGbW/jnKn0bk6wyiZE06qNvtOyzGtWx5TF3LujY0qajGUc/cAhkqbEm40w0yszKst3+K+HCxqvctmY/Hjuf1xpy+67EydiUMSc//zJHrayLLPl5KnnWVwzqTDUJtGr9Vkyf8zs6tj5LklHYmBLjX1bD5Y4RGXOir/wknEw6yQWuFmC3kfcluIq3y8LdIgj4Mln6PyMzU1ch++J0QG0KG3M3X3epXqmRMSburEZ1IS8LlHhVVD/2YD/m5OVscpyTR3zkeCbHRDk+ykuLJH9hY65BXeujP/KTQDLe5IVJ8uynTBBIWXneXH4lQCaYRH+5/VMmkeQYKun2Tox7eSTIPo77gUMgu4Dzrqmh9K+r8dqwXk2H8XjTNZfoInfdfBUkTQIDXx4LeYeB7IuTx73k2HdaTWbLiyw//WoOZMyIUV3UmJJrAXmXgZSViaLxk76HvCguJjpSRDs4nncdcARcIKuQ864oW9CYK+q8K2Xtx1xR592ixpyUT007ra8j5Vgod6c90OdaqUY7+WnBrdv3QPSV49+kb3/Bhee00mn2GzH8+997g34XkX0890mABEqPAA10O/Zbt+9Fm8vvg/zMmqziyL68nMjMIi9Ukzj5mTV5IZbsz/hxkZlcqH8y7RTktjo5eUtGOWDKS5E6XfMozutBbX/uAAALr0lEQVTxCBYsXoF3/68/ZEZU0vcfPKKfF5Kf2Op640D9Vs5Xn7pHkrT7ds4idcF7Cn1cPMcrFysvDP8EIlt+i3jO/CVatqxQ6cLcBA0BeZ5bxpm8SEvGouyLES0NKGq8Sp6CnFxMynhMPnFSZzEMA3I7co++z6LNZffitkeGoFvnDrjr5it1elFjSm5tj4yM0GOu07WPQX6yavjzD0IubLUAtTEM17P6Kon/AUSg0zWP4srbntIadb/jaVzae4Del403x5yMjY++nI1LlPy23e7XL3N7+tFb0f7sJlIVChtzcreSPIrx5/L1kPEmx0iZEHrpf3fqsrKRFyRKfBs1np8e+gHsZUs6h6NQCHxX1HlXznMFjdeiWrdt517s3X/Ylk2Mcjn2tb/iAXS7ZRDCLBbYn3cLG1On09PR5YYBkLLyctcnH7lFvwjTJpw7QUOgsPOuNMJbY84wCj/vSl2FjTmZTDqn+0P6vPvVzF/xxXvPQx6PlHLilqjj47V3Pa/P6Tc/+Io+p9/JR3kEDR0JBDwBGuh2XSRvD163YALs3evPPWDLcdO1lzikST55Rs2WwW5n6Zxx6Hx+a1vMJZ3a6rJN824DvumaLlg172P9+5XyM1q/fDUS57Vvbssvz44vn/uh/o1g+X1LOfDKKqWZQVYhpQ7ToDfjxb/84g6Q36KeP/VtLf+36aMdZEu8vW5SRtx57ZprHS0WGlLCIxCcGCEyzuydufpc1Hi111/Grvw+rxkXXyFO97W8WV3iZBVc0v/+YZx+nnfpnA8w9Jn7bDPqRY0peY5YnnGT8r989RbkvQqtmjUQ0ZBxK/qbt5jqyLyNvFTxoxFP5oXoBQKBpXPG6bEhfSZu0Yx3bWp5MuZk7MpxzCx8Zsx11VEyPuZ9PRK/z3xXH+dW/vIx+t545jnwosbcFV3O0RekP3zxupYxVI1XuYVThMuquMiWY9+PX76hj7X2suWdHva6SRlx8mI6abOs/EuYrvQJyLFL+sTe2Z93Cxuv9tqbY9f+ODT9k//DyJcftWWTMbTip/GYO/lNOJ93ixpTcmeSnMtlzMl3Rs7xNsFqh+ddBSFI/ke+/IjDMVDGnnnehfq4O+Zk7Mp5VRWx/duPuaLOu0WNuXPbNdPHTtHnu4nD4PzzaF998BKWzB6rz+nLfvxQn9PlsSNRRp5Hd9ZN4sXJ9aY8ly77dCRAAqVDgAZ66XDXtcoKkrzcTS4qXRnFciCV3wiW5zl1AQ82pmyRbxg0uD1AV6azygWDXBTITxs5g3BnTEl5McScyzJMAq4IGIYBeURHjnOu3oPhzphLqpRgm0jSdeRtDMNApYoVILJFDvghATcIyJ1AMqno6rxrGIWPKTmXy5hzoxpmIQEbATlvFnTeNYyCx5wc1+T4JpNDNmFOO7KII7JdPWrhlJVBEiCBACJAAz2AOoOqkAAJkAAJBDYBakcCJEACJEACJEACviRAA92XdCmbBEiABEiABNwnwJwkQAIkQAIkQAJlnAAN9DI+ANh8EiABEiCBskKA7SQBEiABEiABEgh0AjTQA72HqB8JkAAJkAAJBAMB6kgCJEACJEACJFBiAjTQS4yQAkiABEiABEiABHxNgPJJgARIgARIoCwQoIFeFnqZbSQBEiABEiABEiiMANNIgARIgARIICAI0EAPiG6gEiRAAiRAAiRAAqFLgC0jARIgARIgAfcI0EB3jxNzkQAJkAAJkAAJkEBgEqBWJEACJEACIUOABnrIdCUbQgIkQAIkQAIkQALeJ0CJJEACJEAC/iNAA91/rFkTCZAACZAACZAACZCAIwGGSIAESIAE7AjQQLeDwV0SIAESIAESIAESIIFQIsC2kAAJkEBwEaCBHlz9RW1JgARIgARIgARIgAQChQD1IAESIAEvE6CB7mWgFEcCJEACJEACJEACJEAC3iBAGSRAAmWPAA30stfnbDEJkAAJkAAJkAAJkAAJkAAJkEAAEqCBHoCdQpVIgARIgARIgARIgARIILgJUHsSIIHiEKCBXhxqLEMCJEACJEACJEACJEACJFB6BFgzCYQoARroIdqxbBYJkAAJkAAJkAAJkAAJkEDxCLAUCZQWARropUWe9ZIACZAACZAACZAACZAACZRFAmwzCRRIgAZ6gWiYQAIkQAIkQAIkQAIkQAIkQALBRoD6BjMBGujB3HvUnQRIgARIgARIgARIgARIgAT8SYB1+ZQADXSf4qVwEiABEiABEiABEiABEiABEiABdwmU9Xw00Mv6CGD7SYAESIAESIAESIAESIAESKBsEAj4VtJAD/guooIkQAIkQAIkQAIkQAIkQAIkQAKBT6DkGtJALzlDSiABEiABEiABEiABEiABEiABEiCBEhMo1EAvsXQKIAESIAESIAESIAESIAESIAESIAEScItAaRrobinITCRAAiRAAiRAAiRAAiRAAiRAAiRQFgiEsIFeFrqPbSQBEiABEiABEiABEiABEiABEggVAjTQi9uTLEcCJEACJEACJEACJEACJEACJEACXiRAA92LML0pirJIgARIgARIgARIgARIgARIgATKFgEa6GWrv83W0icBEiABEiABEiABEiABEiABEggwAjTQA6xDQkMdtoIESIAESIAESIAESIAESIAESMBTAjTQPSXG/KVPgBqQAAmQAAmQAAmQAAmQAAmQQAgSoIEegp3KJpWMAEuTAAmQAAmQAAmQAAmQAAmQQGkQoIFeGtRZZ1kmwLaTAAmQAAmQAAmQAAmQAAmQgEsCNNBdYmEkCQQrAepNAiRAAiRAAiRAAiRAAiQQrARooAdrz1FvEigNAqyTBEiABEiABEiABEiABEjAZwRooPsMLQWTAAl4SoD5SYAESIAESIAESIAESKAsE6CBXpZ7n20ngbJFgK0lARIgARIgARIgARIggYAmQAM9oLuHypEACQQPAWpKAiRAAiRAAiRAAiRAAiUjQAO9ZPxYmgRIgAT8Q4C1kAAJkAAJkAAJkAAJhDwBGugh38VsIAmQAAkUTYA5SIAESIAESIAESIAESp8ADfTS7wNqQAIkQAKhToDtIwESIAESIAESIAEScIMADXQ3IDELCZAACZBAIBOgbiRAAiRAAiRAAiQQGgRooIdGP7IVJEACJEACviJAuSRAAiRAAiRAAiTgJwI00P0EmtWQAAmQAAmQgCsCjCMBEiABEiABEiABkwANdJMEfRIgARIgARIIPQJsEQmQAAmQAAmQQBARoIEeRJ1FVUmABEiABEggsAhQGxIgARIgARIgAW8SoIHuTZqURQIkQAIkQAIk4D0ClEQCJEACJEACZYwADfQy1uFsLgmQAAmQAAmQgJUAtyRAAiRAAiQQaARooAdaj1AfEiABEiABEiCBUCDANpAACZAACZCAxwRooHuMjAVIgARIgARIgARIoLQJsH4SIAESIIFQJEADPRR7lW0iARIgARIgARIggZIQYFkSIAESIIFSIUADvVSws1ISIAESIAESIAESKLsE2HISIAESIAHXBGigu+bCWBIgARIgARIgARIggeAkQK1JgARIIGgJ0EAP2q6j4iRAAiRAAiRAAiRAAv4nwBpJgARIwHcEaKD7ji0lkwAJkAAJkAAJkAAJkIBnBJibBEigTBOggV6mu5+NJwESIAESIAESIAESKEsE2FYSIIHAJkADPbD7h9qRAAmQAAmQAAmQAAmQQLAQoJ4kQAIlJEADvYQAWZwESIAESIAESIAESIAESMAfBFgHCYQ+ARrood/HbCEJkAAJkAAJkAAJkAAJkEBRBJhOAgFAgAZ6AHQCVSABEiABEiABEiABEiABEghtAmwdCbhDgAa6O5SYhwRIgARIgARIgARIgARIgAQClwA1CxECNNBDpCPZDBIgARIgARIgARIgARIgARLwDQFK9RcBGuj+Is16SIAESIAESIAESIAESIAESIAE8hNgjI0ADXQbCu6QAAmQAAmQAAmQAAmQAAmQAAmEGoFgas//AwAA///+wUOnAAAABklEQVQDAOEzudvaighXAAAAAElFTkSuQmCC", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = plot_read_browser.plot_read_browser(\n", + " mod_file_name=extract_file_no_thresh,\n", + " region='chr1:114357437-114359753',\n", + " motifs=['CG,0','A,0'],\n", + " thresh=0.5,\n", + " single_strand=False,\n", + " sort_by=\"collapse\",\n", + " hover=False,\n", + " subset_parameters={\"frac\": 0.25}\n", + ")\n", + "# Comment out these lines to display an interactive plot with e.g. zoom and pan\n", + "png_bytes = to_image(fig, format=\"png\", width=1000, height=300)\n", + "display(Image(png_bytes))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot read depth profile" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The depth profile plotters allow you to visualize the depth of your data, both at a single locus and across many loci. This is always showing the read depth that is *usable for DiMeLo-seq*, that is to say read depth for the motifs in question where there is mod tag information available for the putatively modified nucleotide. Because not all motifs are reverse-complement-symmetrical, the depth is expressed on a per strand basis. You can use the same single_strand command as in enrichment plotters to only pull data from the strand specified for a region. Otherwise, data will be pulled from both strands, but the populated read depth will for each position only come from one strand, so you will still only get effectively (full read depth) / 2. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from dimelo import plot_depth_profile" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4c8bb6352d604b3d80565a23de728287", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading data: 0%| | 0/1 [00:00" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAADvCAYAAAAgqammAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAS+VJREFUeJztnQncTNX7wE8oOxUKJZF9yVIpOyUSWlRUtiQtKCmSf8nSppSSkFRotRTqJ5EsWUNCWQplb0FJyJLc/+d73s64M+/MvHNnnzvP9/O57ztz567n3nue+yzneU6zLMtSgiAIghADssVio4IgCIIgQkYQBEGIKaLJCIIgCDFDhIwgCIIQM0TICIIgCDFDhIwgCIIQM0TICIIgCDFDhIwgCIIQM0TICIIgCDFDhIyQcixYsECddtpp+r/badSokZ6SnTvuuENdeOGFKhXg3hk4cGBK3nsDBw7U+9+3b59KFUTIpDDjx4/XN5y/6dFHH0304aUE77//vnr55ZcTfRiC4MUzzzyjpk+frtxAjkQfgBA5gwcPVqVKlfKaV6VKFWnaEIXMunXr1IMPPijtJSSVkLn55pvVDTfcoFIdETIuoHnz5urSSy+N+nYPHz6s8ubNq+INOVuPHj2qcufOrZIJjumMM85Q2bKJAcDt11qIHvK0pAHz5s1T9evX1wLjzDPPVNdff73auHGjX1vvhg0b1O23367OOussVa9ePfXJJ5/o+d9++61n2Y8++kjPa926tdc2KlasqNq2bev5Pm7cOHXllVeqc845R+XMmVNVqlRJjR49OtPxYctv2bKlmj17thaWdDhjxozRv+3atUu/zXHsbKdXr17q2LFjIZ33wYMHtYbC9tk/61999dXqm2++0b/j6/j000/V9u3bPWZG41cwtveJEyeqxx9/XJ133nkqT5486q+//lJ//PGH6t27t6patarKly+fKlCggBb0a9eu9dq/2cbkyZPV008/rc4//3yVK1cuddVVV6ktW7ZkOt7XX39dXXTRRfr8a9WqpRYtWqRChf306NFDTZkyRbcz26hdu7b67rvv9O+0Z5kyZfT+Oe9t27Zl2gbrXnLJJXrdwoULq/bt26vdu3dnWg4zDpoy2+L/tGnTQj7OYNf6zz//1NerRIkS+npxvM8995w6efKk1zZeeOEFVadOHVWoUCG9Psf84YcfZtoX9wn3S5EiRVT+/PnVddddp++nUHFy7y1fvlxdc801qmDBgvo+adiwoVqyZInfZ+z7779Xbdq00fcN59CzZ08taA0swwvehAkTPPclPi87tBXzeJ7ZZ+fOndXff/+tkhHRZFzAgQMHMjkC6STgiy++0B1g6dKl9U1+5MgRNWLECFW3bl3d2fo6a2+55RZVtmxZra7zlomg4SZfuHChuvjii/UydH68zS9evNiz3t69e/XDQ0dnQKBUrlxZP9w5cuRQ//vf/1S3bt10p9G9e3ev/f7www/qtttuU/fcc4/q2rWrKl++vD5WOuQdO3aoBx54QBUvXly98847WmiGwr333qs7H46Jjvf333/Xx4yArVmzpnrsscd029GZvPTSS3odhIadJ598UmsvCBU6GD4jiOloaSvMlL/99pvuKOlY+I3jtDNkyBDdXmyD/T3//POqXbt2umMyvPnmm/rc6TzpaH/66SfdbmeffbbudEOB68JLgWnbZ599VnfojzzyiBo1apRu+/379+v933nnnV7tiH+Pjuqyyy7T63FOw4cP1x3l6tWrdWcGn3/+ubrpppt0e7Icbcp6CNBQ8Xet6SBpP4Qa8y+44AK1dOlS1a9fP/XLL794+c04LtqGNjx+/Lh+EeBazJgxQ7Vo0cKz3F133aXeffdd/dJEu3K+9t+D4eTeYx7PGMJuwIAB+lqbF6xFixbpFwY7CBieO9rvq6++Uq+88oq+Lm+//bb+nf1w7Kx3991363m8fPhug3uPbfAcv/HGG1oQIpSTDurJCKnJuHHjqAXkdzJUr17dOuecc6zff//dM2/t2rVWtmzZrI4dO3rmDRgwQK932223ZdpP5cqVrTZt2ni+16xZ07rlllv08hs3btTzpk6dqr+zbcPff/+daVvNmjWzSpcu7TWvZMmSet1Zs2Z5zX/55Zf1/MmTJ3vmHT582CpTpoyeP3/+/KDtU7BgQat79+5Bl2nRooXevy9sm31wrL7ncfToUevff//1mrd161YrZ86c1uDBgzNto2LFitaxY8c884cPH67nf/fdd/r78ePH9TXiWtmXe/311/VyDRs2tLKC5dg/x2EYM2aMnl+0aFHrr7/+8szv16+fnm+WNfuvUqWKdeTIEc9yM2bM0Ms98cQTnnkcY7Fixaw///zTM+/zzz/Xy/lrR18CXesnn3zSyps3r7Vp0yav+Y8++qiVPXt2a8eOHZ55vteD4+fYr7zySs+8NWvW6P1069bNa9nbb79dz+d+D0ao997JkyetsmXL6vuaz/ZjLFWqlHX11Vdnesauu+46r31xjL7PDm3RqVOnTMdltnHnnXd6zb/xxhutQoUKWcmImMtcwMiRI9WcOXO8JuANcM2aNVqt5o3YgEaC2WjmzJl+3/59wdRmTDeYoDAL8YaFtmTm85+3XXvAgd3ObrQt3lZ5S+e7Hd7KmjVr5jWP4ytWrJh2gBowRZi3u6zgeNAWfv75ZxUunTp1yuQvwJRj/DL//vuvfptHA+KN3Jji7PCmjwZkb0+gHeDrr79We/bs0W1vX47rhikkVHjztmuml19+uf6P5oG5yHe+7/7RdDCBGXjrr1ChgjYp2u8n2sR+XNxLaDah4u9aY6qjXTDTcp+YqUmTJrqN0aQN9uuBBsC9xLr2tjf3NlqInVADPEK992iPzZs3a22J+8AcN+YursfChQszmft8tfj777/f65hDwfc55fzZP+bcZEPMZS4Atdqf4x9fA9D5+YL/BLu4r3PfN0rN3MCvvfaa9iP8+OOP2nyGvd8IH0we/McEZ3eKY2rBfLBs2bJM9mI6BntH5W+/HD92efZnx9/5+AOzEB0i5iZMGddee63q2LGjNh2Gir/jotPAZIMJauvWrboTNGBj9wXTjx06UtNB2q8TZko7p59+uqNj9d2PaV9fc5uZ77t/f+2KkDFm0UDHadb1J2BDbVM6avx++E/8gRA0YBZ76qmndAdv95HY7xOOlXvR18wU6r0T6r3HcQP3WSAOHDjgueb+2o9j5Fj9+ckCEeyewteTTIiQEbzwF+WDXwZ4K+PtF38Gggkhgz350KFD2m6Pc9uAMOJNjk5q2LBhuqPjLZ23Nfwfvm93sYguwm7NMeKYxpcwdOhQbbOeOnWqtqGHgr/jwl/Vv39/7dfAZ4OWSCfBW7LveUH27Nn9bjvalc8D7Sde+w8Vf21Ku6ER4T/yR7ly5fR/XmbwxzRo0EALebQNhDE+EMLR44253txb1atX97tMPh8/ny++giwUku2aBkOEjIspWbKkx9HqC056zF2hhCjz1sTEA46QMeYeHvSHHnpImzp4m+e7ASc/b5k4ou1vXfPnz3d0/Ixh4cGxP4j+zicQdEKYgZh4G0ZAIgyNkAnnASeYoHHjxtpZ7xvxYwIuwrlOvBXjLDb8888/WlOqVq2a422Gs3/a1b5/M8/8bj9OX5xcE3/wNs/LCuaxYBDZiEkPLRyzpQEhY4djRQDwsmPXPkI9zlDvPaMpoT1kdewG2s+uzWEh4Fjtps5w7stkRXwyLoYOlrcrQiHpAA08PLzZYz4KFQQLUTQrVqzwCBm2ja2f6CkTSur7pmV/s8Js4NsZBIPjw59iD0/F7Eaob1Yg9Hz9PkTfECVkN7EgZH2XywrOzfeNEUHrL9w3FDB1YibCJEm0lD3iy37dYgX7p23Yv71tPvvsMx2JZyKy7PeTvc3wARJVF6nWiVkV4eELbXDixAlP29MB202UmJl8R8eblwg0bTuhZncI9d7jnkfQEFaNkPRl7969fn2odoj2tB+zuS/jce3jgWgyLgc1npsXH0qXLl08IczY5Z3kb0KwvPfee/oBN+YzHnhCQ+kYGHthd1o3bdpUf2/VqpUOSeUBHDt2rO7McCCHAr6eV199VftRVq1apTs5wjtxwGYFAQqE1eK4RRPAZEE498qVK9WLL77o1UlMmjRJa2SE77IcxxwMwoLJsoBDn/NnLApt48R/YgdzDz4G2glNgrFGaDAI5HC36XT/mBE5HwIzCC82Icy8XTM+xEDILEKHewBzIWOGuJ8IVffXyYZKnz59tNZL2xLwwHXBX0jb0tEjSNAS2TfmV8ak4GxHO6XTxn9iH8uFMOQ8MKkhELlOc+fO9Ts+KZJ7DzMp4cM8Y7QBbciYKl440NoLFCigtXo7XFtMfpwDgtWEWds1Vs6f+5Vz5cUIzccEbKQciQ5vEyIPYV65cmXQ5b744gurbt26Vu7cua0CBQpYrVq1sjZs2OA3NHLv3r1+t7F+/XpPOK6dp556Ss/v379/pnU++eQT6+KLL7Zy5cplXXjhhdZzzz1nvfXWW17hsyaslVBif2zfvl2HfObJk8cqXLiw1bNnTx3+mlUIM6HAffr0sapVq2blz59fh4TyedSoUV7LHTp0SIe1nnnmmV5huCb8eMqUKZm2TQjzww8/rEN5aVPadtmyZTrU2B5uHGgbnDvzuX52ODbCXglFvvTSS62FCxdm2mYg2J5vuLbZz9ChQ73mBzquSZMmWTVq1ND7P/vss6127dpZu3btyrSvjz76SN8HLFepUiUdvk64baghzIGu9cGDB3V4NWHCZ5xxhr7ederUsV544QUdpmx48803ddgw+69QoYJuR3P/2iEc+4EHHtChvVx/7vudO3eGFMLs9N5bvXq11bp1a70vjovzJOx/7ty5nmXMMfLs3Xzzzfq+POuss6wePXp4hY7D999/bzVo0EDfX6xjwpkDPaemL7A/V8nCafxJtKATBEFwOwMHDlSDBg3SJrRwfHepivhkBEEQhJghQkYQBEGIGSJkBEEQhJiREJ8MseuEEppMwKSkIBOp7+hcQRAEIbWJuyZDuCtChfEW5NBiIr8U4X8m55YgCILgDuKuydSoUUMnx2MAnx3KBTNAMNT8R4IgCELyE3chQ0oIBlj5JonbtGmT1mrsxXtSFVJEMFqY0fBuSg8hCEL6YlmWHuTM4FAn1WHjPuKf9BlkT/UVMsxjNLgbQMCEWmhKEAQhldi5c6ejInVxFzKka6AmA4kWSfVgUsKT1oLUHm7A1O7gYiRb2m1BEIRwoFYNL8/22kRJaS5jd0SWkT/KFJNC/SJ3EQWG3GBe4mKQG4ycSSJkBEFwA+H2a3GJLiPxHWnLASFCwj3qqnOwpsY6IcxOBQz1TUhmiJBiXd9MrKRxoJ4JGU0p6kMqbntd9UCQcI/EgPiPSEpHJJwgCILgnLgImRtvvNGTtprMvabKHWqXU9XLDllayVzqmzrbXuiITKoEGlDdD8FBdmB/6bcNJiMvFR2JdGP7RMPZK/MJgiAISWQuK1q0qE7zjtZBVAJpxAOVWQ0XNBkqIN5www1Zqnuk0KZqoz/QXEj5jnAykWLYIanDTZh1LNVKorcDVWClMCAZ8g8eVDGB4n2NGilFpV1Kd5QpQzBGxm81ayqFn2/BAs5NuRYq2FJ3jVI41OWiRApPh59ilyFTrJhSV1zB/ZnxnWu4bJlyNZQV+q++maLq9rx5StnK5DiC7PdmjDalbubOVSrWAainn64Utduo50eNMs6hRo1Tx/DllxnzcuXKONelSylTTVAT1pXI7pd4Urt2xv0ZczdAPFI9k576tNNOs7Jly5blFC6cyrRp04KmfiflecGCBQOms2eZ7NmzZ9pOx44ddcrvQJD6/cCBA57JpBPnsxPuvpvzSNx04YX+5xcubFmvvprYY4vX9O67pP+3LG7FaG1z4cJT15hKCYk+x1hPRYpY1okTGedL9YFItlWgACn7M7bVr1/8zqFLF8v6889T3zdvzjiG3r0Dr1OrVuLbXjmYPv7YUfek+7Nw+rW4RJfhG7n11lt1wSCK9VCM6cwzz4zHrtWMGTP0vqlqR+EhsgoESrO9b98+XXHv3HPP9ZrPd8oVB4JCTqTwjhTe2OrWzTyfN1/zdnTeeUrZqrRGBbQnijoG0qL27ct4o4PixZWyVY51DdSy+u23jDb44w/vt1GuS9Gizre5bh3VQJXatevUvJ07T2mHfkrdpzQUq/zqK6pBZrzxU99rx47w2pBuEA0BzZlaaGgNpu24/3kOYgH3APcCzwOfDZwH2v0LLwRe12j+VaooVbBgbI4vmpx9dpx2ZMWZgQMHWocPH476dgNpMhSl2rx5sy4qdeedd+riWb/99pvfbezevVtvZ+nSpV7zKX5Vi9eUGGsygcif/9Tbx//9nxV1+vbN+q2na9eM/yzrRrp1yzg/aq/9+KP3uY8dG942mzTJWP+9907Ny5s3Yx77cBtoHKbNzK3fvHnGd5/6bFly8uSpbe3ZkzHv9tszvg8bZsWMCRMy9tGsmWV9++2pY5g9O+P3YM9IjhwZ/7/80nIlB8LUZOKeuwyHeijlc6MFkWWUZr3iiivUm2++qXLkyKH/+wMNh8AEfEZ2+I5fKRA5c+bUNkr7FE3sg2vxF0SbUAbvGju4rcKyq8iZM+M/b+D/BUJ6CDeq3rSrXSsynx0MmE4Z8GUY8OsZ7QZyRMFmol8l49h23AsG33vCH+baumAURlSJ+61Oh92hQwcddkyHT6dun2INjvxj9rvHBjXpqa1NLXD78nyvjZcsQdhv2lg0USgPhduFjDkvHNS+TmoRMqFh7/yNkDH/nQoZe5sb4RKPTtxsm33auwlzHsEQIZMkI/7vuOMOtWPHDtW/f3/tI4lk8OWhQ4e0n8ewdetWnZ7m7LPPVoUKFVJPP/209gGxH/wthDrv3r1b3XLLLZ51iDIjxLpHjx76O+HLnTp1UpdeeqmqVauWHjhKqHTnzp1VMjy80XgjDLb9rISMeeN3G7HQZOwdlsF8duPbLufE/UmHHKmQSQZNxh7FFoomY3DjtU0pIcN4lUWLFqnq1atHvK2vv/5aNW7c2PPdpKVBSLz22mvaWT9hwgQtYBA6hCazb8oK2Gvb8Luhbdu2ehzNE088oX799Vd9nLNmzcoUDBBPksFcduSIuzUZMZdFByNkTKccDSHjq8nEUsgE0mREyKSQkGHMSbSG5jRq1CjotqZOnZrlNrb5CalCqzGaTTKQDOaydBEymMpEkwkfI0xiqcnES1Nwai4ziCaTYJ8M5icGNfrr3IXk1WTSxScjjv/kETK+5kbRZFKTuGsymKMYs0KpZaLMTreHpCjGKPwR70NKepJBk3G7kBGfTGyFTDTu23hrMuKTSVEhgyYjOEM0mfgKmVhFl9ktu24MYQbzzhiNEGba3YxCSbQmI+ayFBIyOOWF1NVk3BpdZg9hjpVPxi5k3Gq3j6VPJt4hwuL4TyEhQ2I1M0CRz8GQ+ivJpcnwGw93ujj+Y+mTsQ/KdKsmE0ufTDxCmCW6LEWFDLVcfvnlF11emZxl/sbGECXGfHKHCcmjyRghIz6Z8NvVn7lMNJnU0mTEXJbkQmbevHl6gCTMnz8/Hrt0FYnUZNgfD1i6CJlomstMu/r6FOy/uQ2jsURjnEyiNRlx/EcHx5f+yJEjWusw+ce2b9+u67hUqlRJFwTzR8OGDf1+FlJDk7F3kG4VMvEIYU4Hx79bfTKiyYSP41v9+uuvV2+//bb+TLVLiny9+OKLev7o0aMjOBQhGdPK+Ao1tzr+YxFdFmicRyTbTKcQ5kRrMuL4jw6OLxclievXr68/f/jhhzrdCtoMgueVV16J0mEJyabJGNyqycTSXCaO/9TXZCStTByFDAMp8+fPrz9//vnnqnXr1rqkMqn0ETaC+3wy6SBkYmEuS8cQ5miPk0kWn4yYy8LH8eWiNsv06dPVzp071ezZsz1+mD179kj4sUtDmNNByEgIc+r4ZJK1nozbXyDCxfHlIjtx79691YUXXqj9MabOClpNjRo1wj4QITnNZemiycQjrUw6aDLxyF2WiHoyImTCx/Glv/nmm1W9evX0uJdq1aplqsviD4RPqHVj8PkIyWsuc7vjn07Rt6ad+GTCEzJ01NEQMoZ4mstAosuiQ1hKLKWIfcsRU+ArEDfccIPn89GjR9WoUaN0yLPRgr766iu1fv161a1bt3AOx/WI4z/22DW0w4cDt78T0nkwJm/+9mi6aNaTiUfbyTiZ6BHSpce5Hyr+argMGDDA8/muu+5SDzzwgHryySczLYOfR0huTcbt5jI4dMj7NxmMGZ4mY3eWp7omI+ay8AnpchUsWNAzkVuMmvdUpTSsWrVKz+P3rJgyZYrq2LFjpvnt27dXH330kdPjTwuSSZPxqczgGuzCM9pCJh01GV8hE8l9myhNRsxl0SGk94tx48Z5Pvft21e1adNGlzfO/t+dQ74xTF2hJLfMnTu3WrJkiSpbtqzXfOblypXL+RmkAcmiySBg3No50gamdHC0zWWJ6CTdpMnIYMzUxvGlf+utt9TixYs9Agb4/NBDD6k6deqooUOHBl3/wQcfVPfdd5928Bs/zvLly/V2+/fvH845uJ5k0WTc6vS3nx8dY6w1GbemlPEdJ2PPdZvqgzFlnEz4OL70J06cUN9//70qX76813zmnbR7+gJA6eXSpUur4cOHq3fffVfPq1ixotaW0JCE5E0r41Z/jF3IoMX4CplwhYJoMpG1YaomyHTzS0Q4OO6yOnfurLp06aJ+/PFHL01kyJAh+rdQQJiIQEm9cTLpIGRANJnomsuYFw3tQ9LKpImQeeGFF3T4MkkxGSsDxYoVU3369FEPP/xwyNshWGDjxo36c+XKlWUgZwr4ZNwuZMz5RUvIpLMmw5t/pKP9A7WflF9OLRxffvKUPfLII3oyVS6dVLMk/cytt96qFixYoAuYmWzOjRs3VhMnTlRFihRxekiuJ1l8Mm4XMrHWZOKdFiWZNJloYISNJMhMLSK63REuTssl33///ergwYN68OUff/yhp3Xr1mmBxfgZIXlzl4mQiY5PIR00mWgImURrMlK0LDqEdblI8Y9PhczLNWvW9JqyYtasWXrEP85+A6P/R44cqT777DNHx7Fw4ULVqlUrVbx4cZ22hsSdhn/++UeHW1etWlXlzZtXL8P4nJ9//jnoNgcOHKi3ZZ8qVKigEkmyCBm3R5cZIepbAVw0mciETLTu2XhG5/nWFJLosvBxfLmoGYODnzoyq1ev1s7/QoUKqZ9++kk1b948y/WJQDvdz4g+5oUSnWbn8OHDOn8aAspfSQLCpAmL5j+ZCH744Qd13XXXZbldfET4m8xEyHY6msuYn46ajC8SwhxeCHOsNJl4JMj0zV8nI/7Dx/HlRwt5/fXX1W233abGjx+vfTOEJJOdGdNXVlx55ZWqZ8+e6oMPPtDaBezevVv16tVLJ9l0AkItkGAj+8CcOXO85r366qtaKO7YsUNdcMEFAbebI0eOTLnZEkmyaDIiZJyRzo5/+ziZaPtk4qHJ2E1lIEImfBxfLjpoBl2a0fv4V6BDhw5acGQFHT3+F0oFXHTRRXoqVaqUnjdixAgVSw4cOKDNXybgIBCbN2/WAhDh2a5dO33OwTh27Jg+fvsUTUSTiQ+iyaSGTyYemoyvkBFzWfg4vvy84aOxlCxZUmsDZFDGZLV161Zl2ZMzBaBEiRLafPXFF1/oAZyAf6ZJkyYqlpD9GR8NGliwYAVq5KChMdgUU9mgQYN0uWmCE0xFUF+effZZvVysEE0mPgTS1CSEObmiy0STSS0cX37MXZ988oke14JvBjMXgQAkzAw1WzPaxNVXX62neEAQAIEKCMHRo0cHXdZufrv44ou10EGgTp48WQ9C9Ue/fv10Wh0DmgzC1G2ajNsd/6LJpMY4GfHJpBaOLz/+GOOg7969u3b6L126VDvU77nnnpC2sXLlSjV//nw9ZsbX2T9s2DAVCwGzfft2NW/ePMch15jWypUrp7Zs2RJwmZw5c+opVsRayIhPJjZCJt19MtHWZOI5zkjMZQkejMlkYGAlU6g888wz6vHHH9fmKCLU7BUzQ62e6VTA4GNBqCEQnXLo0CGdQgefU6KwWyFjkbtMostiYy5LxwSZsfTJxGOckdm2rw9GHP/hE9blX7RokRozZozufDGVnXfeeeqdd97RDnxKMweDxJhkXL7jjjtUpCAA7BoGfqE1a9aos88+W6e6oVQ0/p8ZM2bocgS//vqrXo7fz/ivRzFlo3v06KG/9+7dW4+9wUTGmBqKqZFlGl9OorAre6LJxA7RZJJ7nEwiMibkzq3UkSPi+I8Ex5eLwmLNmjXTkWWMkyGyykRuoaVkucNs2VTdunVVNMAPhG+ICfCL8JlwasKi8R3t2rVLVa9eXQsdM2HeMyAo9+3b5/nO8ggUNC20ILQfghsSme7GrsnIOJnYIT6Z5B4nE09NxpAvX8Z/0WTCx/Hlf+qpp3TBMkbPk2vMgODgt6wgUIDBky+//LKKlEaNGgWNaAsl2m3btm1e3+3nlCwkSpMRx/+pdggHs55v7rJ08clEOk7Gt53imVbGQEDp3r0Z5xNCd+J3G+mO48vPqPkGDRr4HfxIosuswBzVokULPT6GdDK+o/8ZmS8khyaTboMxY+WTiWc9FDc6/hOZ+y1v3lOffdMNBUKEjDfZwhkn4y/SitQrDF7MCpJg4oQnYgtTFMLJPgnJq8m4XcjE2lyWTlmYoxnCnEhNxpjLnJjMRMh44/jyd+3aVaeFwXlPNBjO8WXLlmkNJZTyyRMmTNB+HbQZwbkmE4sHTIqWZSCO/8hxmyYjQiZyHF9+yicztoWoLJJQYjpjjAhChjT+WUFkF6YyITxNJhYPmGgyGUgIc3KGMCeLJhNqahnRZLxxdLkIAyZ8mUGYpg4MkVd79+5VTz75ZEjbIJU+YcEIKCE0QnU4houk+s9ANJnkDGGOZz0ZX/LkOfVZzGXh4egdg/EiTZs21WWTGQmP4z6cUgGEDTMQkySZvo5/xrUI3jisgOAYGYyZgYQwJ7cmk4gQZu4JuigEjAiZ8HB8+atUqaJrxzDwMhxuuOGGsNZLZ2ItZCStTAaiySTXOJlk0GRy5TolZHzNZZhXfYubgZjLojBOBv8L5rFLLrlEV520k1VuMExlQnKZy0STyUB8Msk9TiZRmow9Ys4OwkeETNY4vvzXXnut/k9CTHuuMQY+8h2/jRBdRJNJbU0mXQdjukGTMeYy8NVk/BT4df31DQfHl58xLkJ8EU0mtX0y6TgYMxbjZJJNkwl0XiJkvHF8+Rs2bOh0FcElmozb68nE2lyWToMx3ajJ+DOX+UOEjDcuvt3dg2gy7nD8J2IwYbxxW3SZcfz7M5eJJhMaImRSgGTRZNIprYz9LVU0mfQdJyPmssiJQQmszNhLE2dFtCtjugHRZOIvZHiDNeYR0WQSm+rfEM/yy6GYy0STSSIhQ90Z3wGXJ06c0DVbYNOmTXqgJyHRQmZEk4kPdk2NzuXgwciEfLr7ZCINYTYkMnAiWHSZCJkkEjL2iDQ0lfz58+tEmWeddZaet3//ftW5c2dVv379eBxOypEsmozbHf/287N/Drf9fX0yEsIcXvslUpNBow0UXRbIDOhmn1vMhAzVJu1jYoKRVVqYF198UX3++eceAQN8ZpAnKWsefvjhkPaTTogmEx/sgsWu1URLk0mnEOZYZmFOluiyYIllhVPkcJoK5ujRo2rUqFE6b1nt2rX1PJJkrl+/XnXr1i3Lbf311186oaYvzDto7BNCUiTITLd6Mvbzs5+3aDKJHScTT8d/MJ+Mr7ksmAVAOEVIl9+eCuauu+7Shcd8sy6zzM6dO7Pc1o033qhNY2g0tWrV0vOWL1+u+vTpo1q3bh3K4aQdiUqQCekkZKJtDkxnTYZzNSlXItVkzPYS0YkHiy4LdB3dfH3DwfHlnzJlivr6668zzW/fvr269NJLdTGzYLz22ms699ntt9+u/vnvquXIkUN16dJFDR061OnhpAWJMpfxMNsfaLcLGfv52c9bHP+hYxcoR49mnheuJhPrwn2++zSIuSxyHF/+3LlzqyVLlqiyZct6zWdeLrxkWZAnTx5tbkOgkPIfKGLmm2hTSLzjH+yp6Nzu+Lc7cu1tEq6QT+fBmHYhE42S4YnSZIINxoxFKXQ34ljIPPjgg+q+++7TDn67uQsNJpTyywaEysUXX+x092lJIjUZ+4Pldk3Gjmgy4WEfxBpNTcb+DMRbk3FiLnPzC0Rcyy+XLl1aDR8+XL377rt6XsWKFdW4ceNUmzZtslz/8OHDasiQIWru3Llqz549upSzHWrVCMkTwmwXMoFyNbmRaAiZdNdkjh3LPM8JgbTJRA3G9NVkRMiERliXH2ESikDxB4EDX375perQoYMqVqxYyKHR6UwiQ5jtb2/pZB6wCxbxyYR3L0WqydjbP14+GV9Ek4mcsC//8ePH/WoiF1xwQdD1PvvsM/Xpp5+qunXrqkhZuHCh9u2sWrVK/fLLL2ratGmecGuCCh5//HE1c+ZMrR0VLFhQNWnSRGtRxYsXD7rdkSNH6u3++uuvqlq1amrEiBEe02A6azLpRDSETDpqMpwbQoX75siR1Ndk7D4ZMZeFh+N3gs2bN+uR+QQAlCxZUpdhZrrwwgtDKsnMwMuzzz5bRQNMbwgBhIIvf//9t/Yb4Sfi/9SpU9UPP/ygi60FY9KkSTrXGiHZrMf2mzVrpgVqOmoyImREk3GKESpu0WTEXBYZji//HXfcoUOOZ8yYEZa5i/E1TzzxhE4rQ6RZJDRv3lxP/kBzmTNnjte8V199VWskO3bsCKhxkfama9eueiyPCblG8yKwAX9UIhBNJrU1GcYeT52q1IoV3vPdSrSETDJoMnZz2dq13r+JTyY0HF/+NWvWaPNUhQoVVDgwCJPQ5XPPPVdrP6f7eJOzSksTCQcOHNBC8cwzzwxoAuTc+vXr55mXLVs2bWZbtmxZwO0eO3ZMT/asBtGkZk2lZs9WKkoKYCYCRY3xcBUpotKS0qWV+i/CXoUbXW/adeNGpW66KX0CKGKhyfz2W3x8g/Zj5TNT7twZ3ydO9F42f/7M67v92oaD48tPOpl9+/apcLGnqIknpMPp27evuu2221SBAgX8LsN5/fvvv1oA2uH7999/H3Dbzz77rBo0aJCKFS+9pBRy74EHYrN9XFS9eilVooRSW7cqNWKEUrjM2rdXqmlTpXbtIlODSgvQOMaOVeqZZ5RasECpHTuUqlYtvG01aqRU27YZ7WfvhHr2VGklZMIVCmY9xmr9+Wd8xmuRCL5TJ6W2bKGvytBsMGrwonD4cIZGxfvmmDFKVami1KFDGX4b/E+8Z9pfJoT/sBwyd+5cq3bt2tb8+fOtffv2WQcOHPCaEgWnMm3aNL+/HT9+3GrVqpVVo0aNoMe4e/duvZ2lS5d6ze/Tp49Vq1atgOsdPXrUqw127typt5PI9hCERFGsWIYXJW/ejP9Tp4a3nQoVMtb/8kvLWrEi43OJEtE+WiFU6M/C6dccazKYjuCqq67ymk8/jykKTSCZIMqMcOvt27erefPmBdRioHDhwrquzW923Vyhqv+mihYtGnC9nDlz6kkQhFOaTKTjZIwmQ/BJOkTmuZUckdSGCQeE0EsvvaQmT56sHfD4Qez88ccfKtoChog4jrtQoUJBlz/jjDN04TQGihqzHiHafO/Ro0fUjksQ3Iw93b/9e7jb4b1VhEzq4vjyN2zYMKId4rt44403dN0YxrE89thjatu2bWr69Ok66swJhw4dUlswnv7H1q1bdWACIdJEvt188806kIBIOIQb416A3xEoRiMjM7QRIoQvd+rUSSf7JBLt5Zdf1qHSJtpMEITg+AqVSIWMaDKpTdhxH4xD8aeJZJWP7L333lNjx45VLVq0UAMHDtSOeBJksh51aSgjECpkg27cuLHnOwICEBJs+5NPPtHfq1ev7rUeWk0jvLKKCKIfvQIZ2rZtq2vbIPAQSqw7a9asTMEAgiDEVsiIucwdOL78dMC81TNy3x9Z+WTouKtWrao/58uXT4cVQ8uWLR0l2AQERYbP3z/BfjOgRfmCViPmMUFIDk1GzGWpTbZwsjD/+eefOvMyo/55y2dgJan/jeYQjPPPP1+ngAE0GEoxw8qVK8V5LgguwFeoRBrCLOay1MbxOwYRWh9//LH2WTBQkdQyV199tY7aYrwIZrBg4P/AkX755Zer+++/Xxc7e/PNN7XprReDNQRBSGl8BySKJpPeOBYyOMHPOeccTx4yzGflypXTJrBQRuuToNLu/0BILV26VGtCrVq1cno4giAkGeL4FyISMuXLl9eJJkkJQ/LIMWPG6M/k+CKiyylXXHGFngRBcAfi+Be87genzdGzZ0+PT4VMxddcc42OGCMkePz48dK6gpDmiONfiEjI4EMxMHCRkfTk9SKrMSPmBUFIb0STEcKOLmMEPRFhG8kW9x+k669Zs6YIGEEQNKLJCGELGdLyk83YKa+88opnPaLIQhm/IghCaiKOfyGicTLdu3dXzz33nDrhoGQiI/FNjRWqZxKRJgiCO5FxMkJEPhkGTTLOhUGUhC3n9anoRJljX4oXL64++ugjde2112otZteuXQE1okAVKwVBSA1iOU4mnqWXhejg+PJTVfImh5V5SITJwEtStVAO4LLLLsu0TLKWChAEwRliLhMiEjLjxo1zuoq6++67dSJMItFIhPnFF19kmXZfEITURKLLhIiEzJVXXqlNYmg0dvC5UIOFtDP+yJ8/v6pSpYoWUnXr1pU8ZYLgUiS6TIhIyCxYsCBTen/Ax7Jo0aIs1ycNvyAI7kU0GSEsIfPtt996Pm/YsMFTAAzwo5CN+bzzzvO7LkXCNm3apMfSkO8M30sgolkZUxCE+COajBCWkKF4F8KBCZOZL6T9HzFihN91KbeMucx8DiZkBEFwl5AJNyJMKmOmmZChtDERYKVLl1YrVqxQRYoU8fxG3jIyM2cPUDjCbiK74447Ij1m14AGSBYFIbVhkHKgez/dhQzNEu47pdSTSTMhQ0p+OHnyZEQ75GEkwaYpF2D4/fff9bx0CGFGWGNupPib4A4IhClatKho6T7jZMIdI2NfVypjpjaObwGqYOJbMcXJHnnkEfX666+rSpUqqQ8++MAjjAIRKKXMsWPHtEaUDhgBg1Al95uYD1MX7ue///5b7dmzR38Pp9yF27ALlkiEjF2TMe+2YmlPPRzfAs8884waPXq0/rxs2TL16quvqpdfflnNmDFDV7b0N+Lf5C8DOtQ33nhD5cuXz/Mb2svChQtVhQoVlNvhXI2AkbFC7gB/JCBogpmN04VoCRnRZNyB41tg586dqkyZMvrz9OnT1c0336wHWzL2pVGjRgHXw+Fv3vwocGZ/ENFgTOEzt2N8MGgwgnsw15PrK0ImukIGTcYYQESTST0c3wJoIPhPyDFG/jKSX0KuXLnUkSNHggYOQOPGjbW2QyhzOiMmMnch1zO25jIRMqmL41vg6quvVnfddZeqUaOGHvtC0ktYv3691kayYv78+Zn8M/KACoJ7EHOZYMdxBPvIkSNV7dq1dbp+Misbv8KqVat0frJQePvtt3UGZ2zZTOQze+edd5weipAAyPjAS4GTyDjC1kk5FCnsFxOtkF5CRjSZ1CZbOKGaOPs//vhjdc0113jmDxo0SD322GNZrj9s2DB13333aQ1o8uTJemI79957r8dvEyoEC7Rq1UqXEvDXAWGWa9q0qRaE/L5mzZostzl+/HjPoFMzYQpMBejMOV7a0l8dIH5LxDil4cOH63YV0nOcTLiYdSWEObWJe3UGsgIQnUbhs+uuu05Pzz//vBo1apQnAi1UDh8+rKpVq6a1q0C/16tXT+/LCQUKFNBjecxE9uhUoUSJEmrixIle/jHyyr3//vsJq9VTsGDBTAlVBfcS7XEyosmkNnEXMnTaderUyTSfefzmhObNm6unnnpK3XjjjX5/79Chg3riiSdUkyZNHG2XN34G1pnp3HPPValCzZo1taCxh5LzGQGDH813bNIDDzygw27R1hDIFKWzM3PmTFWuXDlt1iRoY9u2bY6PyddcRhQi+2WMFXntaOOBAwd6rbN582bVoEEDfVyMwZozZ47fSMc2bdpoAcZ2rr/+es/xff/99zriC+FqQGvmPMi9J8QOcfwLCRUyhD/zsPsyadIkVbZsWZUMHDp0SA8qpbOm4yKoIRh01pQ6sE+J5M477/Sq+/PWW2+pzp07Z1qOTh6/GgNsv/nmG31tmjVr5klSSifeunVrbZLE1EjAx6OPPhqVY2SfVFVdvny51mQHDx7sESRklWC/hLbzO6Htffv29VqfUGGOlZx4ZP9esmSJjnzE9EqWcMZcvfDCC6pbt25qx44duhorZkS0WoSWEDvE8S94YTng5MmT1vbt260jR45Y4fLhhx9a2bNnt5o1a2YNHjxYT3zOkSOHNXXq1LC3y6lMmzbN729bt27Vv69evTrL7SxdutSaMGGCXnbBggVWy5YtrQIFClg7d+4MuM6AAQP09n2nAwcOZFqWttuwYUNEbRiITp06Wddff721Z88eK2fOnNa2bdv0lCtXLmvv3r36N5aBQ4cOWaeffrr13nvvedY/fvy4Vbx4cev555/X3/v162dVqlTJax99+/bV57Z//37Hx2Vo2LChVa9ePa9lLrvsMr1tmD17tr4fdu/e7fn9s88+87rG77zzjlW+fHl9TxqOHTtm5c6dW69vaNGihVW/fn3rqquuspo2beq1fDSJ5XVNNbilMoKOLatmzfC38847Gdto2tSyPvgg43OjRtE8UsEJ9GeB+rVgOLKY0pfztsubfbhaB6WbeTvFyW8c9RUrVtRJN33NOYmAyDkmuxmP4xszZox68skn/a7Tr18/z3ghQJNBC0oUJC8l7Q/Odq4Zn0kFZOfHH3/U2gCDaO2JHmvVqqU2btyov/P/8ssv91rP3jaRQEShHdKxmNQs7Jf2I6Aj0H7Xrl2rtmzZ4snubfc/cW52LQ5zX7Zs2fR9K+HysUfMZYIdR0KGBxXhwmDMSExbl1xyiXr33XdVKkDHi/CjQwtEzpw5k67SJyazHj166M+BAiMS3a526PydJF/FpMl99N5772X6zZ4hHGFEAAj3Lj4/yS0We8RcJkTkkxkyZIjq06ePWrdunYoE3lrZBsXQ7FMy5hr77rvvUq5zMr4J47vw5aKLLtI+D3wZBpbF8W98FkbDtPPVV1/F/NjZL/4geyCI734JcCA4gKAFtGv7RDQb4Fsi6IDQev63a9cuaFYKITqIJiPYcRxg2LFjR511ltBhOimTHDDUypYM2qS+DCYR34zMvM06SfXP26xdwyB1DQ5qIo2IpuJYcPr+/PPP+vcffvhB/zdRY+Z8qOj57LPP6u84oK+44grdWTHgcOjQoTqEGad3KkH+LGP28pdLC6c745V4YTDthQOea9ulSxe9DI7yF198US/D+XPt4jHehWhATFzcJ7Q/5kffMVgIDH4jMINrdv755+vrRCQdAQ185/gxuz3++OM6OAONtHfv3kmp2bkJu5IayTgZSZCZpkKGjMuRmnHoQN58800dGhyJjfzrr7/WYbUG4xehc6Iz/OSTT7yiqm699Vb9f8CAAZ6QWYQQphTD/v37VdeuXXU6fvKrYZJZunRpSkYkMd4nK60UExWh3gcPHlSXXnqpmj17tievHIKH6DOyazO+CX8NWbi5hna4hkSzRWugJ9dj2rRpWtixT9IVMYbKPviX8GQG4xJ1RiQax8/LwlVXXaXPm6wShF+vXr1a5ciRQ0+YaAnTbtmypQ5/F1JvxH+4VTaFxHEa3v947hBHLQ++yeTsRnjzxmRz4MCBTB09jmk0rlKlSqVMJoFgcC68NDD2JFlC0BOB265rJJCe0FRoR5bPnBnedmbPxuxL6XelevXi5VEpLL+zZkX1cIUo9GvBCOu9gOgdTBDkKjMRQZ999lmW40mAN02csYI7QFug1EM6CxjBG3H8C3YcK7NffvmlNjUQ+oq54umnn9bOVwQHJrAPP/ww6PoULMOchdO/SpUqmaKMSDMjpA7kRBMEO+L4FyISMoz4JpUL/g/7GIUrr7xSJ87MCqppEtGE5uOLU8e/IAjJh2gyQkTmMsJ5/eUKQ5vZt29fluvff//9qn379jo8FaezfRIBIwipj6T6FyJO9e8vkSXOfKJ7soKBnEQrpVLSSUEQEpfqX7Iwp5mQIQyYsFFCfM0obcxfjD9gzElWEG5qr44pCIK7iHaqf6knk9o4vgUYJ4Gzl0FumLcYP8L/22+/XUecZQXhruT6Wrx4sa6O6ev4JwW8IAipi5jLhIiEDKP8x44dq/r3768jxBh1z0jqUENYiS4jJTtRakx20IxEyAhCahPt6DLRZFKbsG8BRoObTMNORu0zYE0QBPcimowQ8WBMxsMwxoWRzUx8RkMRhFhCRc0HH3wwLo3Mi5MpRSE4Q8bJCBEJGcoZ9+zZU1dLnDJlip74TMQYvwnuh7FOJN2kTk0okLmIe4NM1iRUJQEmGZSTAXLYVSdviRA1ZJyMEJGQGT16tPbJkLWY0flMfH799dfVqFGjnG5OSEHQZBnvRMYHk+E6GGR3JsElZZQpWEcGaMoPkO9LcB9iLhMiEjLUHCFbry9kKz5BQLvgGFKUHj6cmMlpelQCPSZNmqTLBJjqm8HPzdKZu4k8JC0/FTHJkIxwCmaOotAYIfEEiaABUXLAF9L3EzrP+CwEF1U8FyxY4PmdY2NcF/shMAXTLsKNWjXm90GDBumUSJjHmOznw+BiBh6T8Zn1yeotxH+cjDj+00zIkBYebcYXNBlqfAjO+ftvpfLlS8zEvp0wefJkVaFCBVW+fHmduYHyxsESeRPowZgqTGQGMrkiEDC7BYIaNkQffvzxx+rzzz/XwuObb77xWobKn2xj4sSJuuDdLbfcossB2E1x1Mchvx6CjfFc1AgyJR/atm2rHn74YVW5cmU9wJiJeQYEUJs2bfS2r732Wn1/Z1UvSYj+OBkKppqiqRFUBhESRI5wzSU8+BT3Akwg1GXhzdNe637YsGF+1+dBp+IiGZx9S+6GMqBTSBxce4QL0KGT9hthgFPeHwgY8M3wwHfzmz9tif1Q/4Ws3TBhwgRdiMzA/UYNG/4XL15cz0OrmTVrlp7PeC6jeZNTD6FmtmMqflKrBk2JWjOmiJ0d6uOQaRzYHiY/1rPXtRFi7/gHYyQRIZN6OL4FGBtD6VuT8h8KFy6sJ3tJ5kBhzf/73//0GyEdCTUJ7MvxOR2FTJ48dKyJ23eoUFmUTpaCYkDnzJs/AiGQkAkH7itKRxvBAFTvRHuy59BjEDCDe31NaIUKFfJ85xgvu+wyz3e0MExoVA1FyAQD054Bcxz3qyltIQTGXlgsGpoM/PNPxn8RMqmH41sg0pQwmCeorMibIbZuIePByZs3+VsCYYLfzWgOgKksZ86cWlvADOaL0RB+++037Vsx8D2SqC5eUohwoyS0b3lptJNo4JuNwqRRErK+nxEQaB/REjLHj5/atpBaxL2Y6e7du/WofhEwqQXCBb8GDvg1a9Z4JpzmCJ0PPvjA73pUikTQzJ0716vCHibW2rVr+13noosu0h08y9jLYm/atMnznSwTaDJoFlRZtU920xfHTZluuzaGuRaTmclgIdm/o48REGIuEyJ4zwgPont46EuXLi2tn0LMmDFDd/RdunTJpLHcdNNNWsu59957M63H2z8DKKlBRIQWQoeURAimG264we++0ETYD85/TF+UkXjsscdUNpsdBjMZZlfMqwg+hM7evXu1MMPMZcbwIKwIt8afgumMYAF8icZUduGFF+rgBAQmPh9qJKGZCYkXMmIucwdxETL20E8efjoPasL7S5AplTGTE4QIEWL+TGIIGcbCEIVFB0/HjdOcgY7wyCOP6JBkyjSjRdSrV0876AkpDsTQoUO1SYyBvnT8mFkJMrCDgx/hxW9oyPgFESAtW7b0LIPGTNZwEriyTP369fW52I996tSpqnHjxvrY2CbHLiReyPBOgXmM4EVx/KcwVhw47bTTQpqyZctmuYEDBw4Q06v/+3LkyBFrw4YN+r8bOXz4sJUrVy5r/vz5iT4Ua9y4cVbBggXjsi+3X1enFCmCaLCs11+PbDs5cmRsp1evjP/t20frCIVo9mvBiIsmI87S9IHAEEpxRzPaTEhPTcasjxZjosvskWtCahD3S4bzmDBTXwhZ5TchtcEc+umnnyb6MASXCBl7dUyQ6LLUI+5CpnPnzpls63Dw4EH9myBEC3wr+FmE1NZkQMbJpC5xFzKMq/A3UHPXrl1+ncrBIEEjjmEilfylZseh27RpUx2hxO9EEIUCmaUZtIdjmuCEmTNnOjouQUh3oi1kRJNJXeIWwkyIqUlCSKoQwkkNjFMgjNRpug4ilqpVq6YHd7Zu3drv70QykX+qa9euIW1z6dKlOpUImaWJUnr//fd1qC15s6ibEy2C5fsSUg+5nrE1l4kmk7rETciYMRFoE4yVsY/KZkAcYa+EkzqhefPmegqWzBO2bdsW8jaHDx+uhR1h1vDkk0+qOXPm6BHtpKqPFBOyTeJGaqsI7oDrCb4h+elKtDUZ8wiLTyb1iJuQGTBggP6PMCHfVbAxEomErL72JJ+AUAyWlp5ABnswAyPaA0EKFHJnmRxYjONwUr5aSD4NBgHD9eS6+qa4SVfM4x3puFaz/tKlGf9FhqcecR/x36lTJ5XMkBnYScZgwLRGWvhQMWlPJNmie0DA+MvknK707asU72X160e2HYrtMnYW6zKpDrt0idYRCvEiLkKGDLrknWJE9llnnRX0zT0V63X069fPS/tBkylRokTA5Tl/kkWSLoVU9EJqg4lMNBhvsHw7tH77heQLkoAhtYmLkHnppZd0ahDzOZnNQ7yNkiHYDt+DvaWS6yqcfFd0TNI5CYLgZnLE20SW7HmhyAxMkkWSOhpw/AfKGCwIgiAkkU+GrLkkI2zQoIFO6R4JJFDcsmWL57vJpot57oILLtCmNyonUk/epHkHtBKjmXA81IjHrwI9e/ZUDRs21Jl9Gb1OaV+yRlNeWhAEQXCIFWe6dOlilS1bVifEPP/886127dpZY8eOtTZt2uR4WyRh5BR8p06dOnkSJPr7fcCAAZ5tNGzY0LO8YfLkyVa5cuWsM844w6pcubL16aefxiWRnCAIQrISbr92Gn9UAiDtOiP2qQ/PRGAAznBG/qc6pM0h2mjnzp26ZK8gCEKqYwKaSNXkJDtL3M1lBqLMSPfCfzpkMgAUKVJEuQHysEGwCDNBEIRU7d+cCJm4azL/93//pxYsWKBWr16tS+Di/yAtPD4aBI4boLQBfiAi6pxE0pk3BdGApG3knokceZ6i2y6ICgQMuSLtVWqTTshwcGgsvXr10vnGKKMrnLr4vCFgbhMzmzfSNv6RdgmMtE1ytEvczWVoMPhg0GaI4CJvmdFmmEToCIIguIe4CxmyJjM98MAD+vvatWv1AM3u3btrMxMZmQVBEAR3EHchg3UObQZNhmnx4sVafbv44ou1RpPOkDWARKLhZA9wO9I20i5yz6TmsxR3nwzOfQZRos0YM1n9+vV1hJkgCILgLuIuZKj/jlARx7YgCIL7SdhgTEEQBMH9hB7sLAiCIAgOESEjCIIgxAwRMnHg6aefVnXq1NGllgMFOJAtmqzPLEMxsz59+qgTJ054LUM0Xs2aNXVUSJkyZdT48eMzbWfkyJG6xDXlrS+//HK1YsUKlUpw7GRJsE9DhgzxWubbb7/Vfj3OkZHLzz//fKbtTJkyRVWoUEEvU7VqVTVz5kzlRlL9ejtl4MCBme4PrrPh6NGjejgEKavy5cunbrrppkz1oUJ51pKdhQsXqlatWunR97SBb3l4vCBPPPGEzgeZO3du1aRJE7V582avZchS365dO+0fp1/q0qWLDspy+qxlSQySdQo+PPHEE9awYcOshx56yCpYsGCm9jlx4oRVpUoVq0mTJtbq1autmTNnWoULF7b69evnWeann36y8uTJo7exYcMGa8SIEVb27NmtWbNmeZaZOHGizhz91ltvWevXr7e6du1qnXnmmdZvv/2WMtekZMmS1uDBg61ffvnFMx06dMjzOxlgzz33XJ29e926ddYHH3xg5c6d2xozZoxnmSVLlui2ef7553VbPf7449bpp59ufffdd5abcMP1dgoZ1MmMbr8/9u7d6/n93nvvtUqUKGHNnTvX+vrrr60rrrjCqlOnjqNnLRWYOXOm9dhjj1lTp07VmZGnTZvm9fuQIUN0XzN9+nRr7dq11nXXXWeVKlXKOnLkiGeZa665xqpWrZr11VdfWYsWLbLKlClj3XbbbY6etVAQIRNHKD3gT8hww2TLls369ddfPfNGjx5tFShQwDp27Jj+/sgjj+iHy07btm2tZs2aeb7XqlXL6t69u+f7v//+axUvXtx69tlnrVQSMi+99FLA30eNGmWdddZZnnaBvn37WuXLl/d8b9OmjdWiRQuv9S6//HLrnnvusdyEG653OEKGjtEff/75p36ZmDJlimfexo0bdSe8bNmykJ+1VEP5CJmTJ09aRYsWtYYOHerVNjlz5tSCAnj5Yr2VK1d6lvnss890CZbdu3eH/KyFgpjLkoBly5Zpk865557rmdesWTM9SHX9+vWeZVB57bAM8+H48eNq1apVXsuQJ47vZplUAfMY5o4aNWqooUOHepkyOBeSqZKOyN4OFKTbv39/SG3lBtx0vZ2C2QczUenSpbW5B/MX0B7//POPV5tgSqOAoWmTUJ61VGfr1q3q119/9WoHcpVhTrW3AyaySy+91LMMy3MPLV++PORnLalT/Qun4Iaw3/RgvvNbsGV4OI4cOaIvOil5/C3z/fffp0xzk24IvxPVTZcuXar69eunfvnlFzVs2DBPO5QqVSpgWzHYN1BbmbZ0A/v27XPF9XYKHSW+yPLly+v7YtCgQdpnsG7dOn196RB9/Z72ax/Ks5bq/PrfeQR7BviPP8oO5VZ47uzLZPWshYIImTB59NFH1XPPPRd0mY0bN3o5JdMVJ2310EMPeeaRaohO45577tHlsSXdjtC8eXOv+wOhU7JkSTV58mTt4BaSDxEyYfLwww+rO+64I+gyqPOhULRo0UxRQSYiht/Mf98oGb4TGcLDlT17dj35W8ZsIxXbik4Ec9m2bdv022ugdgilrRLdDtGkcOHCSXu94wlaC5nbt2zZoq6++mptRqRyo12bsbdJKM9aqlP0v/PgvIguM/C9evXqnmX27NnjtR7PGRFnWT1H9n2EgvhkwoSaOLx5B5vstsxg1K5dW3333XdeF33OnDlagFSqVMmzzNy5c73WYxnmA/u65JJLvJYhqzXfzTKp2FZr1qzRdmKj2nMuhG9ie7e3AwLIqO9ZtZUbSObrHU8Iuf3xxx91Z0p7nH766V5tgv8An41pk1CetVSnVKlSWgjY2wGzOr4WezsgjPFjGebNm6fvIV7sQn3WQiKisAYhJLZv367DJQcNGmTly5dPf2Y6ePCgV1hl06ZNrTVr1uiw5CJFivgNYe7Tp4+OmBk5cqTfEGYiSMaPH6+jR+6++24d0mqPpElmli5dqiPLaIMff/zRevfdd3U7dOzY0StKhrDKDh066LBKzpl28Q1hzpEjh/XCCy/otiIiya0hzKl8vcPh4YcfthYsWGBt3bpVX2dCkQlB3rNnjyeE+YILLrDmzZunQ5hr166tJ0Moz1oqcPDgQU8/QjfOEAk+09eYEGbuhY8//tj69ttvreuvv95vCHONGjWs5cuXW4sXL7bKli3rFcIcyrMWCiJk4kCnTp30jeA7zZ8/37PMtm3brObNm+s4dB4aHqZ//vnHazssX716dT02onTp0jok2hfGz/CQsQwhrsTApwqrVq3SocaEeefKlcuqWLGi9cwzz1hHjx71Wo64/3r16ukO9rzzztMPlC+TJ0+2ypUrp9uB0O9PP/3UciOpfL3DgbD9YsWK6fPl2vN9y5Ytnt/pRLt166ZDb+kQb7zxRj2Wxk4oz1qyM3/+fL99Cn2NCWPu37+/FhI8J1dddZX1ww8/eG3j999/10KFF19CuDt37ux58XXyrGWFJMgUBEEQYob4ZARBEISYIUJGEARBiBkiZARBEISYIUJGEARBiBkiZARBEISYIUJGEARBiBkiZARBEISYIUJGEARBiBkiZAQhAVBKm7K55I8KBqWVX3755bgcU4cOHdQzzzwT1X1TkoC8c7t27YrCEQqpiAgZQQgAmaNNHXkSUpYpU0YNHjw4KvXg69Spo+uhUEwKqJHiWwcFVq5cqe6+++6YX6O1a9eqmTNn6no+0c4W3bFjRzVgwICobldIHUTICEIQrrnmGi0MqMZIyYKBAwfqap2RgtAiUy4CLKsM1nny5In5NRoxYoS65ZZbVL58+aK+7c6dO6v33ntPp5EX0g8RMoIQBAqlIQwojHXffffpErWffPKJ/o1qpLylk/YcQUBBLYSRYfv27apVq1b697x586rKlStrbcHXXMZnOuIDBw54NCeEmT+TFWnrr7/+ei0MSE/fpk0br5ofrEfNkHfeeUevi6Z06623qoMHDwY8Rypsfvjhh/pYfWG92267TR//eeedp0aOHOn1O8c6evRofe7UNaIuENuyw3lTLnnatGlyr6UhImQEwQF0pBTGMua0r7/+Wgsd6qGT1fzaa6/11N/o3r27OnbsmK7JQQ0TqoP60xQwnSFIEBpoTUy9e/fOtBy1PhAwaARffvmlru3x008/qbZt23otR32V6dOnqxkzZuiJZYcMGRLwnL799lst4Oz13g1obdWqVVOrV6/WFU579uyp92unf//+6qabbtImt3bt2mmhRqVTO7Vq1VKLFi3Ksn0FFxJhxmlBcC2kTacOh0mdPmfOHJ3yvHfv3tamTZt0anVqmhj27dun08dTZgCqVq1qDRw4MGiq9v379+vvlG2gxIEvJUuW1DV24PPPP9c1hHbs2OH5ff369Xo7K1as0N+pnUOK+7/++suzDDWIKKEQiGnTpuntco6++6bmiB1S65Mm38C+qeFih33dd999XvN69eplNWrUKOAxCO5FNBlBCAKaANpHrly5tEkIrQGTFG/qOXLk8FQRhEKFCumqgeYtHif6U089perWrasd32gMkcB2S5QooScD1RwJGLBrDpjJ8ufP7/lO1UjfUrt2jhw5os2C/vxDvlU2+e6rpYSyDBrg33//HdJ5Cu5ChIwgBKFx48a6BDS+FjrjCRMmaP9EKNx1113anEVoMOYyzFE42GMNJYjtIDwwtQWLAEMAGDNgLMDERxCDkH6IkBGEICBQCF2+4IILtOZiqFixog5lpm664ffff9c15e214tE67r33XjV16lQdnTZ27NiA0WY44IPBPnfu3Kknw4YNG3TwQCT16QkUMNvy5auvvsr0neNwusy6detUjRo1wj5GIXURISMIYVC2bFnthO/atatavHixdnq3b99eR2AxHx588EE1e/ZstXXrVvXNN9+o+fPnZ+p87SauQ4cOqblz5+oBjP5MS0S2Va1aVTvX2d6KFSt0dFvDhg39Ou1DBQ2jZs2a+jx8WbJkiXr++efVpk2bdGTZlClTtPPfDvPeeustvQxmQY6rR48ent85l1WrVqmmTZuGfYxC6iJCRhDCZNy4ceqSSy5RLVu21H4I/OCEKBtzFZoJEWYIFsbblCtXTo0aNcrvtogwQ+PB50OnT8fuC2avjz/+WIdEN2jQQAsdQoYnTZoU8TXEtMdYFl/QvoigQwvBvzRs2DDVrFkzr2UGDRqkJk6cqC6++GL19ttvqw8++MBLs+KY0QTr168f8XEKqcdpeP8TfRCCICQW/E0ELSCwfB35wUDwMf7lhhtuCLjMFVdcoYMgbr/99igdrZBKiCYjCIKO/kILwVQXTdhe69at9YBOIT0RTUYQhPA7kBA0GSG9ORUuIwiC4BCxtgtZIeYyQRAEIWaIkBEEQRBihggZQRAEIWaIkBEEQRBihggZQRAEIWaIkBEEQRBihggZQRAEIWaIkBEEQRBUrPh/0x5fvbea7kYAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(4, 2)) # If you want a different sized plot, you can us matplotlib commands\n", + "plt.title(\"Forward strand mod read depth\")\n", + "plot_depth_profile.by_modification(\n", + " mod_file_name=pileup_file,\n", + " regions='chr1:114357437-114359753,+',\n", + " window_size=1000,\n", + " motifs=['A,0'],\n", + " single_strand=True, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", + " regions_5to3prime=False, # if set to True, regions on the reverse (-) strand will be flipped so everything is 5 prime to 3 prime\n", + " smooth_window=None,\n", + " palette = { # you can pass down kwargs to sns barplot if you want to\n", + " 'A,0 depth':'blue',\n", + " }\n", + ")\n", + "plt.figure(figsize=(4, 2)) # If you want a different sized plot, you can us matplotlib commands\n", + "plt.title(\"Reverse strand mod read depth\")\n", + "plot_depth_profile.by_modification(\n", + " mod_file_name=pileup_file,\n", + " regions='chr1:114357437-114359753,-',\n", + " window_size=1000,\n", + " motifs=['A,0'],\n", + " single_strand=True, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", + " regions_5to3prime=False, # if set to True, regions on the reverse (-) strand will be flipped so everything is 5 prime to 3 prime\n", + " smooth_window=None,\n", + " palette = { # you can pass down kwargs to sns barplot if you want to\n", + " 'A,0 depth':'red',\n", + " }\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can superimpose plots of mod fraction enrichment and read depth to get a better picture of what is going on, and how meaningful results are. For example, in the below plot, we see that adenines are somewhat depleted at CTCF sites, while CpG motifs are enriched. The adenine modification signal has much higher read depth because `A,0` motifs are much more prevalent than `CG,0` motifs. With this set of loci and read depth, the CpG signal flanking the CTCF sites is quite low depth - explaining the noisy trace." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3b7e7ffd4a884a54a596532568730024", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading data: 0%| | 0/50 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax1 = plt.subplots(figsize=(8, 4)) # Create figure and primary axis\n", + "ax2 = ax1.twinx() # Create secondary y-axis sharing the same x-axis\n", + "plt.title(\"Motif read depth across peaks\")\n", + "plot_depth_profile.by_modification(\n", + " mod_file_name=pileup_file,\n", + " regions=ctcf_target_regions,\n", + " window_size=1000,\n", + " motifs=['A,0','CG,0'],\n", + " single_strand=False, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", + " regions_5to3prime=False, # if set to True, regions on the reverse (-) strand will be flipped so everything is 5 prime to 3 prime\n", + " smooth_window=10,\n", + " palette = { # you can pass down kwargs to sns barplot if you want to\n", + " 'A,0 depth':'blue',\n", + " 'CG,0 depth':'orange',\n", + " },\n", + " alpha=0.4,\n", + " ax=ax1,\n", + ")\n", + "plot_enrichment_profile.by_modification(\n", + " mod_file_name=pileup_file,\n", + " regions=ctcf_target_regions,\n", + " window_size=1000,\n", + " motifs=['A,0','CG,0'],\n", + " single_strand=False, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", + " regions_5to3prime=False, # if set to True, regions on the reverse (-) strand will be flipped so everything is 5 prime to 3 prime\n", + " smooth_window=50,\n", + " palette = { # you can pass down kwargs to sns barplot if you want to\n", + " 'A,0':'blue',\n", + " 'CG,0':'orange'\n", + " },\n", + " ax=ax2,\n", + ")\n", + "# Combine legends\n", + "lines1, labels1 = ax1.get_legend_handles_labels()\n", + "lines2, labels2 = ax2.get_legend_handles_labels()\n", + "ax1.legend(lines1 + lines2, labels1 + labels2, loc=\"upper left\")\n", + "ax1.set_ylabel(\"Read Depth\")\n", + "ax2.set_ylabel(\"Enrichment\")\n", + "ax1.set_xlabel(\"Relative Genomic Position\")\n", + "ax2.get_legend().remove()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot depth histogram" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Depth histograms show the distribution of read depths across sites, either averaging each locus into a single value or providing readouts across all genomic coordinates." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from dimelo import plot_depth_histogram" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1c07a0a5a1ee45798283d09e70f7106c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading data: 0%| | 0/50 [00:00" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_depth_histogram.by_modification(\n", + " mod_file_name=pileup_file,\n", + " regions=ctcf_target_regions,\n", + " window_size=1000,\n", + " motifs=['A,0'],#,'CG,0'],\n", + " one_depth_per_region=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ee33e9942d7a48e6bef1781e7c0c2917", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading data: 0%| | 0/50 [00:00" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_depth_histogram.by_modification(\n", + " mod_file_name=pileup_file,\n", + " regions=ctcf_target_regions,\n", + " window_size=1000,\n", + " motifs=['A,0'],#,'CG,0'],\n", + " one_depth_per_region=False,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Advanced Use Cases" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Clustering and Classification\n", + "\n", + "This section shows how to work with processed files (`pileup.sorted.bed.gz` and `extract.h5`) to discover structure in your data.\n", + "\n", + "- **Read clustering**: build fixed-length windows per read, compute features (PCA, autocorrelation, density, stats), and cluster molecules. Supports single motifs or combined multi-motif windows.\n", + "- **Read classification**: train a binary classifier on read features to quantify separability between two samples; includes train/test metrics, confusion matrices, and per-read profile plots.\n", + "- **Region clustering**: cluster loci on their pileup profiles (single motif or concatenated multi-motif features), and visualize mean profiles plus genome distribution.\n", + "- **Region classification**: treat each locus feature vector as a sample for downstream classifiers.\n", + "\n", + "Optional clustering deps: `scikit-learn`, `scipy`, `hdbscan`, `umap-learn`, `pyranges`, `xgboost` (install via `pip install dimelo[clustering]`).\n", + "Make sure earlier parsing steps have produced the processed files before running these examples." + ] + }, + { + "cell_type": "markdown", + "id": "6f031f5a", + "metadata": {}, + "source": [ + "### Read analysis tips\n", + "- Use `span_full_window=True` and `orientation_aware=True` when extracting to keep windows consistent.\n", + "- For multi-motif windows, set `require_all_motifs=True` to drop reads missing motifs instead of zero-filling.\n", + "- Drop low-information reads by setting `require_nonzero_valid=True` and `min_valid_fraction` in `read_window_feature_matrix`.\n", + "- Inspect cluster/classifier QC: profile plots for clusters, confusion matrices and per-read profile plots for classifiers.\n", + "- Check locus homogeneity with `summarize_read_clusters_by_region` (dominant_fraction/entropy) to see if clusters are locus-driven.\n", + "- Beware class imbalance in classifiers; look at both accuracy and ROC-AUC, and at confusion matrices to spot overfitting." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Read Clustering" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Single motif (merged on-target vs off-target reads)\n", + "\n", + "This example uses the notebook test data directly: extract read windows separately from `ctcf_target_regions`\n", + "and `ctcf_off_target_regions`, merge them, and run unsupervised clustering to see whether clusters enrich for one group.\n" + ] + }, + { + "cell_type": "markdown", + "id": "efbdf960", + "metadata": {}, + "source": [ + "*Motif semantics*: extract output stores one row per motif per read. For multi-motif analyses, use\n", + "`build_multimotif_read_windows` and either:\n", + "- `motif_profile_mode=\"single_axis\"` to overlay motif profiles on a shared y-axis, or\n", + "- `motif_profile_mode=\"separate_axes\"` to keep each motif on its own y-scale.\n" + ] + }, + { + "cell_type": "markdown", + "id": "d5ae7b69", + "metadata": {}, + "source": [ + "**Sampling for speed**: Use `cluster.sample_rows` to downsample reads or loci before clustering/classification. Example:\n", + "\n", + "```python\n", + "sampled_feat, sampled_labels, idx = cluster.sample_rows(feature_matrix, labels, frac=0.2, stratify=True)\n", + "```\n", + "\n", + "Run heavy algorithms (e.g., spectral/DBSCAN/UMAP) on the sample, then apply insights back to the full set." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reads used: on_target=2173, off_target=4030, total=6203\n", + "Cluster purity vs on/off labels: 0.802\n", + "Counts by cluster and region set:\n", + "region_set off_target on_target\n", + "cluster \n", + "0 3939 1140\n", + "1 91 1033\n", + "Within-cluster fractions:\n", + "region_set off_target on_target\n", + "cluster \n", + "0 0.776 0.224\n", + "1 0.081 0.919\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAGGCAYAAACqvTJ0AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsvQvsrmt61nV/5/P/tNY+zJ6ZthxGFKs0tmlFUNBUWltMqrEhVZGgqSIpUosHihaCShpFoB7ACoqn2FDU1ERICpVIqFAEWzVRU5Viazsz+7TW+h++89H8ruu5v+9ba/YcmMOevWeee7Jm7fX/f4f3fd7nfd7nvu7ruu7G4XA4RI0aNWrUqFGjRo0aNWrUqFGjRo0a72I0380vq1GjRo0aNWrUqFGjRo0aNWrUqFGDqKBUjRo1atSoUaNGjRo1atSoUaNGjXc9KihVo0aNGjVq1KhRo0aNGjVq1KhR412PCkrVqFGjRo0aNWrUqFGjRo0aNWrUeNejglI1atSoUaNGjRo1atSoUaNGjRo13vWooFSNGjVq1KhRo0aNGjVq1KhRo0aNdz0qKFWjRo0aNWrUqFGjRo0aNWrUqFHjXY8KStWoUaNGjRo1atSoUaNGjRo1atR416OCUjVq1KhRo0aNGjVq1KhRo0aNGjXe9aigVI0aNWrUqFGjRo0aNWrUqPElGN/yLd8S3/md3/nFPoz3XGw2m/jwhz8cf+SP/JEv9qF82UcFpWrUqFGjRo0aNWrUqFGjRo33WKxWq/iX/+V/OV577bUYDAbxDd/wDfFjP/Zjn/H7/+Jf/IvxZ//sn9VnvJvxa3/tr41Go/EJf775m7/5szrHn/3Zn33Hz8s/L4JuP/mTP6nvuri4iMlkEr/u1/26+F//1//1udd0Op34nu/5nvh9v+/3xXK5/AKNRI3PJBqHw+HwGb2yRo0aNWrUqFGjRo0aNWrUqPGuxHd8x3fEf/1f/9fx3d/93fGRj3wk/tP/9D+Nv/pX/2r8D//D/xC/+lf/6k/7/m/7tm+LxWIRf+bP/Jl4t0Gpn/mZn4nv//7vf+7nAE9/39/39/0Nn+NsNosf+ZEf+YTv+dEf/dH4L//L/zL+5J/8k/Ht3/7t+tlP/dRPxa/6Vb9KLKh/5p/5Z2K/34sN9fTp0/grf+WvxC/7Zb/s+P7b29t45ZVX4j/4D/6D+Cf/yX/yCzQaNT5dVFCqRo0aNWrUqFGjRo0aNWrUeA8FAAqsod//+39//Av/wr+gn8Ho+eqv/up4+eWX4y/9pb/0Kd//5ptvxgc/+MH4wR/8wfin/ql/Kt5tUOrtt9+O//1//9+/oOf4jd/4jQKw3njjjej3+/rZt37rt8ZP/MRPxP/z//w/8ejRI/3s4x//ePxNf9PfJMbUf/Pf/DfPfcY/+A/+g3F3dxd/4S/8hc/xrGt8tlHlezVq1KhRo0aNGjVq1KhRo8Z7KGAPtVqt+Kf/6X/6+DOAFwAmQJef//mf/5Tv/9N/+k/HdrsVcHMeMJGQvCHtQ7720ksvxWg0in/oH/qH4q233vq8ngPfP51OvyDnCNAEm+of/of/4SMgRfz4j/+4zjkBKeIDH/hA/Jpf82viT/2pP/UJx/P3//1/f/yP/+P/KCZVjS9OVFCqRo0aNWrUqFGjRo0aNWrUeA/F//K//C9i9+CLdB5f//Vfr79f9Eh6MWAZAcx85Vd+5Tv+/rf9tt8W/9v/9r/F7/k9vyf+2X/2n43/7r/77+K7vuu7nnsNAA6Mp0/3B6bRi/F//9//t8AuPJ1effXV+L7v+z6Zi3++zvFP/Ik/IWneP/aP/WOf4FGFN9WLMRwOY71efwJ762u/9msDR6NPx8qq8YWL9hfws2vUqFGjRo0aNWrUqFGjRo0af4MBEwiGz4uRP/vYxz72Kd//0z/90/FVX/VVn/T3AFaYoMOaIgB4/t1/998VwHR5eamfAVL9Z//Zf/ZpjxUW0p//83/++O9f8kt+Sfy9f+/fG3/b3/a3yQ8KRtS/8W/8GwKqfviHf/jzco54SfG6Fz2q8Iz6y3/5L8dutxMLiwCM+p/+p/9J//3Rj370udf/4l/8i/X3//l//p/x63/9r/+051rj8x8VlKpRo0aNGjVq1KhRo0aNGjXeQ4FBea/X+4Sfp1SN33+qePLkiTylPlkgmUtAivi7/+6/O/7QH/pD8XM/93Pxt//tf7t+9i/9S/9S/OP/+D/+aY/1+vr6uX//x//xf/zcv3/jb/yN+r4/9sf+WPzz//w/H3/n3/l3fk7nCLhFhz0+q9l8Xvz1W3/rbxXzCwkgxw/YBiAGAPZOn5nHDuOrxhcnKihVo0aNGjVq1KhRo0aNGjVqvIcCCRpStBcDI/D8/acLZGmfLL7iK77iHcGZZ8+eHX/2y3/5L9efz0f8jt/xOwRK/ff//X9/BKU+23OEJUW8KN0jfstv+S3yosI8PVleX/d1XyeA6vf9vt8X4/H4HcfoHKCr8e5GBaVq1KhRo0aNGjVq1KhRo0aN91AgTXtRakYk4+e11177lO9HnncOML0YKW37VEAWUr5Px8giut1u3NzcfMrXfPjDH9bf54bin+05/tAP/ZBkevhBvVMAPtHN7//4P/4PSRGREf6u3/W79Ds8rM4jx+jx48ef5ixrfKGiGp3XqFGjRo0aNWrUqFGjRo0a76H4mq/5GsnU7u/vn/t5eiPx+08Vf/Pf/DfH//v//r+f0zH89t/+2wUcfbo/dMD7dPHX//pf1990+/tczpHf/bW/9tfekSX1IvPrV//qXy1AioCh9aEPfUjjch45Rn/L3/K3fNpzqPGFicqUqlGjRo0aNWrUqFGjRo0aNd5D8Y/8I/9I/Nv/9r8df/SP/lGxfgikbv/Jf/KfxDd8wzccmUefLH7lr/yV8R/9R/+RwKA08/4bjc/GUwqACZ+oc68o2Ff4OhHf9E3f9DmdIywp4h/9R//Rz/g8MFf/q3/1r+q7XvSgwpsK6R7jVeOLExWUqlGjRo0aNWrUqFGjRo0aNd5DASjz7d/+7fG93/u98eabb8Yv/aW/VB5JP/uzP/sJRuLvFN/6rd8a7XZbDCFMxj+b+Gw8pX7qp34qvuM7vkN/OGbkfz/yIz8Sf/Ev/kUdx9/xd/wdn/U50lEPgAlPKjr8vVP8hb/wF+Jf+9f+tfh1v+7XScJIJz5Arm/+5m8W8+vF+LEf+7H4Vb/qV+m1Nb44UUGpGjVq1KhRo0aNGjVq1KhR4z0W//l//p/H933f98V/8V/8F/I+oiven/pTfyr+nr/n7/m0733llVfiW77lW+JP/sk/+VmDUp9NfOVXfqU6+QFEvf7662ImIY37wR/8wXc8jr+RcwRge+ONN+Jf+Vf+lU/6/XQcxC8Lo/OHh4f4Rb/oF4ml9T3f8z0C6c4Dz6w/+2f/bPyRP/JHPk9nX+OzicbhU1ny16hRo0aNGjVq1KhRo0aNGjXed/HjP/7j8Wt/7a+Nn/7pn46PfOQjX+zDec/FD/zAD8S/9W/9W/EzP/Mzn1E3wxpfmKigVI0aNWrUqFGjRo0aNWrUqPElGP/AP/APyOD7j/2xP/bFPpT3VGw2G0kAf+fv/J3xW3/rb/1iH86XdVRQqkaNGjVq1KhRo0aNGjVq1KhRo8a7Hs9bz9eoUaNGjRo1atSoUaNGjRo1atSo8S5EBaVq1KhRo0aNGjVq1KhRo0aNGjVqvOtRQakaNWrUqFGjRo0aNWrUqFGjRo0a73pUUKpGjRo1atSoUaNGjRo1atSoUaPGux7td/8r33+x3+/jYx/7WEwmk2g0Gl/sw6lRo0aNGjVq1KhRo8b7KA6HQzw8PMRrr70WzeaXFi+g5ko1atT4XNa9Ckp9BgEg9eEPf/gzeWmNGjVq1KhRo0aNGjVqvGP8/M//fHzoQx/6khqdmivVqFHjc1n3Kij1GQQMqRzMi4uLz+QtNWrUqFGjRo0aNWrUqKG4v79XkTvzii+lqLlSjRo1Ppd1r4JSn0GkZA9AqoJSNWrUqFGjRo0aNWrU+GziS9EKpOZKNWrU+FzWvS8tQXONGjVq1KhRo0aNGjVq1KhRo0aN90VUUKpGjRo1atSoUaNGjRo1atSoUaPGux4VlKpRo0aNGjVq1KhRo0aNGjVq1KjxrkcFpWrUqFGjRo0aNWrUqFGjRo0aNWq861FBqRo1atSoUaNGjRo1atSoUaNGjRrvelRQqkaNGjVq1KhRo0aNGjVq1KhRo8a7HhWUqlGjRo0aNWrUqFGjRo0aNWrUqPGux5cVKPWH//Afjq/6qq+Kfr8f3/AN3xB/5a/8lS/2IdWoUaNGjRo1atSoUaNGjRo1anxZxpcNKPXDP/zD8T3f8z3xe37P74mf+qmfil/xK35FfNM3fVO8+eabX+xDq1GjRo0aNWrUqFGjRo0aNWrU+LKLLxtQ6g/+wT8Y3/md3xm/+Tf/5vjlv/yXxw/+4A/GcDiMP/7H/3h8ucXhcHjHf/P3+Z9P9pp3+rzz97zTv/Pv/X7/Cd+TP/9kn8/v8n3nP3un136y4/pUr/10n/O5xqcau0/3nnd6//mYfabXidfudrtP+V35eZ9sbF+8fi9+/qe7Jvma/PM3GufzpMb7Iz7dvfflGl/oMflM75P36/30fphXX+hjzPXwk13D9/r4fCHi8/GM+FTP1893vBc+/9OdJ7/bbref9bG+037vkx3nZ3r9XtwffTnO9Ro1atT4Uot2fBnEer2On/zJn4zv/d7vPf6s2WzGN37jN8ZP/MRPfMLrV6uV/mTc39/HezF4EC8Xq9jvdtEf9qPVan3a9/DAX6/W0Ww1o9PpGKzY7mJ/OMRitojVchWH3SGG42EMJ4PYbnb6WbvdikPjEKsF49KM4bAfnW4nGs1G3D97iN1uH/1BN3qDvl6/3Wyj3W7rNa1WMzbbrT5/vVxFHBrR7Xej2+/EYraMh9uHaHdacfnoMpqNJhcn2q2WziuajVg8zGN/iBiNB9HpdWL6MI/NYh2DST8Gg0G0O+1oNBo6P/5mXABgFvNFzGeL2K620Rv2YjgcRLffi2azEavlOg77fbQ6rdiut9HpdaPTaWs8Zg9zfUan68/t6T3N5zZOzI/NZhf9fi+63Y43bptt8Ao+53wDtlltotFqRavZ0OdxvPw8jzk3YvybP3yOrsu+/DxCY8j15bod9ofY8JrdTp/Vavu6816u5Xa703vaOv5mbDeb4zmNLkY6Zl7LZ282m2hEQ5+32241LvvtPvqjfowvRvrO3JTutsyVra41x8O1Z2z4TsZ5vz9Er9+N/qD33Lnx3s16q+PgNRw/7x9ORppXeezn78m5ys84tgjGdx+7zSYG44GOS9d2u49OtxW8tdXifEPHd5wLe8Y5osl80uZb36Dj4PdcK33tIXQ+m/Um1ptdNMt1arebem2O//l9x73AHOF1wbzlc3ccc0S319WcOZ8vmnP6743ujdHI95Cvw05jwfdw/H4v37PW9xwOuzjsG9FsN/27w0Fzgfuec3h4mOrzuRZ8xtXNpe5vxn45X5Y55nnDe3q9ru/pMg/5TO4ZzStutmAcd7pXPEZch43mE/M9x+IEdvIZvoZOKvjv0Hj4Xuocr+9pTNY6V8aY8cg5cP66z2ZN/Fze/+Jn6f5d+15j7eE483c5P/M6v9P7X3wNP1uvNvo81kB+/vk63vPP5z5lrcv7652C68naxPrBfUxwLXMMff5eez7ZOeZ78hwNknjcmA/n58dzmPu11+vo37yW3/PH8451paVjzuPg3/ycNY17IfY7buzYbz1+PKf4/MV86WdLk+OO6PV9rdbLtcaD4H7Rf/OCRkS7043RuK97NY9Rz8e153mHZwPr4s5rajQO5esPMRp7bcwx53W+h5ua68vFMpbzVRzioGfZYDzUfXQ+9hwE53ocswIwsc6yruQ9w8+0Lh/ntu/l9WIZW90/rWh1Ovr8btffwTrGOsMxDoa+tnktct3P4+f8GKuc2zkOep7sdvrvbrf73PXmZ/n6vP6sPcT5cbP+8L35XS/O9VxL59O5rg+/Z30ZjAZHcCLfyzGzFjLWfAfzm+/09x40H3abnc+n245er/cp5yxzjqnAuOl5Vs6Xecb45bVkfrzTsefx5zzO+yZfx2exxmkPUT7jPHLvxfPj/P26PqtNNNstjUV+lu5HnlvN548j770Xn5+cH3u93d5j1B/0j89+7TO2u3h4mMVO+592dHvscyIWi1XM7qbaFwwmIw5U61VvyL3itT/3Bcsl991a+yfOkXHTc3m9jdHlOPr9ru65+Xwe84dZNJtea0aT0XGfcH/3ENPbh9ge9hG7g46FY+V1/K37ozzTuRasIzyvWbd4P883389cx1ZZT7y2sR/9VGtgjRo1atR478SXBSj19ttv66H+yiuvPPdz/v3TP/3Tn/D67//+74/f+3t/b7xXIx/S+8M+FtOFwJ5m+0GbtEx0SKp3JOFsGFtcZifWvHf6bBb77TYmNxfRaDVjy6ZhNo+7p/cxf1jodRfXk1hvJrGZk0hsYzgZapP75KNvaaPz6AOP4+aVK22cprezuH92J5BpdHUR2wXJJkDQIPrjgQCSxXQeb3z0rZg+W0Rv2IlHr15rU/PWL7wdt2/eR6fXi0cfvox2o6VN4tXjS22015tV3L5+G5vVNoZX/bh6+XG8+bMfjzd+4Wk8evUqPviLPxDjy9FpU1cSYzbxb3/sSTz5+Nsxe1jFow9fx0uvPIpJAY1W86WArsNiH5vFJrrDfowng7i7vY+3P/q2NjkAOCQfCUyxsWOTScJx+9ZtHLaHuHntUVzdXOi6kMywEeK9bJ7b3Y42x/s1m+RW7AuopCRnQ9IIENbxBnllQIt9JeANyTobbK7H/rCLdq8T/V5Xx3nYkVRslThxzgBObDCdhDZi/rA8biJbLTZtq1jPVrFj00dy0mhoQ8dmkQ1ls8VG+BDz+7k2lUoomSvjYZAPKMFZAmzNNI80zgdAL46dpKGhY92uN9FRQrl3grXbx3y+jNsnd9E8hM6XubXebAQ+8v7tpqn3dQdOoPkuBgIQiYxhvd3E4mEhzIexAtDk80lkbt+6i+VsIb7nIRoxHg+iNxrEdrkhbdO8b3KgbNrZ7LNZPwA8AYyScLSjN+jqOPg9xwUAyri0mq3oj/vRarejBUDVa0ez7/FmDgCkLmdLJS2Di4GAXOYH15Drw3GQDHK+bPLf+uhbMbufCiBlnnAtR49GcXF9pcSDMWh3OgJJV7NltLodgW3Mszd/4W3uegGrx+T2wDVs6t7knv7oX/t4PHn7Tkn75GIcH/rIa3H90k1M7x7i/u37aPc7mhO75TbmzPWrcQxHPSU5BIAL14tjXHP/bvdKIgBTx1eTaDQ8H9vtTnQGXZ0bCYPuCRLF3S4Gw77uQ4Bs7gFACeY5/2C+nYPmjCFjwtolgLrXi8GoJ5AhAZJPFefV8UyyBEYDsO9J6g0U5+8MLBgo/2Tg/TmIROS9wDmsV1sd83A0OAKJjIfWm87Zd/CzkiBpnd7udS9pXLZb3W/MXeYFGWAD0KIkU58JyJUAwDkoyOuXKibstd5M76exWixjxDUeDnw/N5rH4zh+nkDvQzTLWHJ+T994ov+eXE2i2eT+iWiUZ8onexYJGACoOLB2bQ32l7XO18eAyGy60LNhOeopEV4vN9Efcd37ApXu3r4TEH7x6CJm93OBTCS2HOPyYRHr1Urrwna3jW1Zs1sdwIeuQI27t291by0fVtEdd+Pq0WU0Gq3Yq1jgucD9zTq3WG/i8mas5xggLckzc4PjmN3PBOqxfjRir7m9fFjGRqD4Wmv5o9deVmGGa8fay/dzTjwPWXeXD3Pde+Aqw3Hf13pEgux5wXNC4Eq/p2IF95sT6bXHuswhgcEk+vczgeXMFwMKWz3DtttDtDrN6LRa0R30YzDuR6PZEmA1f5gbmFv1NEaMHfOOucJzhXWH+QuAwPMFQIt1gOu/mC71O+ZIPv9zLlFIYo0cTQY6FvYDDZ6/OX/LPOMZzDzkXLhVWV9YI7jfz8FdXje/ncWePUqnFf3BQOO4K884QAo+l+fP/ZN7PYta3ZaKGp12W9/B2ja8GOmcODfe37g2gH7Oosn7lGcm15l1SZ/Tafl+OJzAvv3OoAfPG+8Bni80MC6sX+zBOoAoep4YaNEzfb2Nt37hrTg09nHx6Cq6HQONBm99L3OOBNea68x9w76Na9fqGixTgW221PXOCgrXRs8LnnE8G/lc9nIbij8U85oxn85icT+P+9t7PXcuX7qMx68+FrDDs+Pu2X28/fG3o8Xa0G5rr3hoRszuZvHwdK3XvPzhS63/6/lGx8AYdEvxkXi4ncf02b2uB9d0SnFkutJhPv7Qy7GbDOPhyUP8ws98zHNu2I1Hr1xHfNBjTbBePfno07i7m2nMePZevTyO0eUwOu2Ox7fX0Z6wPxpqbHZbA04qWt7N/Czud1Sw4vxYYxt7bSUMxDVPa2aNGjVq1HhvxpcFKPU3GjCq8J86Z0p9+MMfjvdKsKFR5YjNfrupSth6xmZ8IZCJ4CGeGw1teJdrJeCdYU+Vph1AwHwZneFAla27t25jtd44sQRIYfNJIsD7hr1odhrR3rq6tmAT+TBT0jNgkx37mC/WcX87j9ndMtr9RnR7/ejDrJottPFSwrZyRbPTb2sTu54uY0MS2WCDt4n1bB2zzSG63aYS/eZmp03O0ycPStQn63H0+sNo9jvRH3U1DoADbGoBFQBzljreviqtbPA5LsC0+7dm0ev0tDEnoebnhz3sB6rkbJg38eTNRdy+fReLhc+ZmE3nsafSOHEyyAaJTT1AHmAIYEnS31UZXSy1sWKzCrOMJJuEsB+92LcPcVizoWwq8Yc1ML4w0MG4AuSxewcIYWO1b+/F9po9m0U8NGJD8rSmIr+JzWYdnXY39pej2C03RzZbswdzrBULwDMAG+YIG/txLwYkv00nv5v5Jh7uHnSOHCMADQDisDXURh0ACFDhJKvcFxAEoInqKiDEIDr9rsG9ZgiIIbkhEhxYLZcxezaN3X4bj157KfrDXhyWgHauRiupXRuQWwKw3c+i2WjF8LIv4IVxvH3zmb7n+tUbb97ZeK83+kzmEtd/u9zFbthzJbewfvj5hiRebIyGrvV2vVbiyfXtDoa+/mxs58t49voTXbvh5TBavcLWYPxKJTvBzumzh3jy9jPdg0pUuo1oRUvfA4A4vZsqqeb+4HZk/jF/Yx8CgplTJHCzZ/NoHFpx8Zjkmc93Us8xNLh3mX+zecyn3Ke9GPW6Su5ImMbXE7FF5nczJTEc0wZmRgHXBLDBHpmvlZCLldZtx3pOwsA95g06x6b5W4Ai/i3mU5Oi9T4296tY7zZKakkAed1mttH9qsSo3RYLEmAKgIBEvVVADiVYYlV8ohSVpJ85xXXhQwX8LFvR6ZkFkaybd2JOJfjEPSPgqSR1YrqJQVikpIWxA7i9gdm42iqhYo3LzxEDBrZE1+xFgCaBKQ1AKVgeDY0pxwtLZslcKkk3ayTgw4lledB6yQeSFPP9vL/X7h3Bm83arDIBoSTuc7MKAGW5kQQEtHx+TAiBV4XlYnBs7Z+3275OjBHA58NcnwvIA0Ayu53HPpoCxFnzmKedpu/NPHeBFB3fH3z2gsIEAHK0zTTpmxlB8YPvSnbE+fUQs2N3AllYH9arpYAHmCqer6xrITBBRZKNj5dixsXhQtebxPT2rXuzfmHoCnRZR7u/jjb3RrMhgIpxY9zv32btOmgdIJZLijOwosxI5Jie7fdKqCfXl9FOgIy1kXXhYRHTh0X0x1Pdm6vRQMUNAz77WE4Xek4C8LT7bd0P4CgshzxPp7d3sSmFB4AinhkqNHQA0yPm84VZKKV4ZILmIUYTM7u4hpxjrAD9egLRWTfm04XWn86AOcP8gRHS1rxtdXc6LzEimU8A722e9W01bzHYwzrUiOh1YrsHdPa8Wx1WYt6KScr5zZgvA63HVBh4rs222+iPDAitZ8totM3W5DroOUAhotPSuHAcYnQCmsDO7DS0DrCWc2zMLX7OfJ1NAfkKu1YMXs/DZCHyDB3ejA2QF4bdcmGwZyfW9qAw4lp6Duh+pGBz/6B1DfCmuTMowr6nA5i899omsHAPWw1QCfYNa6gZ34A3WbhRUYZnttjTZrEylsvlJtb3jNUhlvP2kZnKZ+vc7uexhAHUXcQEAJVrvQ+zg2azuH1yG+1WR0WTXqcb/ckwJheci+8f1p+mnmVew9u9rr5DxQ3m+e2DmdZ69qy0fjDHGUhY4lx79nkCxwNW9tZ7IeYJYN3hINbz6rAUSynZ6uwr3n79NrbzdYxfZh/XUgGJveR8ton9gcIRoBesNRi93dgUBjzjo2IWz9RuKwYXw5jdP8THfu7NmN0totNuxuR6rHmyeXstsJi50hv34vKlsUDnw6ER0yf30ewAXreiO+7FMLYxuzcDSgDh9hB3d/dxfzuLoQoyA63l7CdhR+3W+9jsNvEAU3/tZzHfM5oYBFXlrICmfObnm5Vao0aNGjU+v/FlAUo9fvxYG+o33njjuZ/z71dfffUTXs9m+lNRv7/YoUSJP1DWRXXvxwGZ1nqrJJWHsajW3Va02n1tQmCHrKFpD0jCD9EGoOK/w2ADmz02d7Cd2LyQjbPRIcmh+tdqd2PX2sfj1x7HI5gI/U4c9luBUxzDq689EtuKYCNJEstmutnuRKO1ESDCxprNHGwDNgkzEoVOI25ensRug7RsoO+GnQEoA+Nlu9xGH2p5dxIXV66iv/yhx/HaV7wixhIV3YdbWFo9bd5un8zi0ctsiiZx+fhKyfwMVstiI0p6p+NxYgMIfRzJYXsyVOUNNhfA0NVLk7i6udLG++F2Gg/PpmI8wF5RkrHfx/BqJOALaQZVVwAWsZvYZLab0R0PYsPGacuYm3HDRkoJ4qCnjT+bvOmRKcHGWHXwYxJpsI2ErCXzN64X7IBYAKKsYr9aqTI+4lj2Q4NSbFZHVBAj7t66VxIwvB5Gvz9QJVwbPja7Tx/i2eu3SrjaHa4xQF5bSWHKKMR6EEjW0meSkLz1+pN4+uZ97BbruPlAaM6Q1AHcDS+G2gSn5ItrOByPot2/jYe357H+udfjA1/xsiWXYy89JAaJWbDZpLIbrUZ0B07aJf3odnUt1otNNLoHJeGMNZ/DnGIDvlkt4+LqMkbj4UnWqgS6F1tJKJq6BrOHaczvABJgCbiaT5WcZGrxsFTlFdYOyTiJc6ttkEuJd0mAJbloNGOxWsW0sNIevXITwxHn7zlzD8i7WsYlMrpeJ25evYkG59XrxHgxisUDEmGDnzAlACm5b9vdrhhasIWYC4PhMB69AlNhpM8hUYMRAzOCVPcOsKvdiscfehSDKUwCV8fv3noW/W43enzWeBDjC+ZAL+L6BMY8e/tZzBiLflvzdDm1BAqQYHwzUbLzxs++Hnevz6KD3Bd21+Uw1nOA567m5uhiXNhSML2Wkvlw7x/lq/sTI2e7WR/lldwz0WhZ4jEciAkmYHKxKlLgnuYu11/yyDNWULKexMgT+y2UTIkdxev42Q7gvgB8sBD32yLtKLKiDUAayf1BDAbYggLASO6OYCwgUQtUxRKbthNf1g8xCcVEhTmyilXTLIZkUHEPk4Izj1VAUELfjk5/H62d72+BdYXBl+yiTEb5DrOPvD4wHmaf+XuZ0wbNmtHuccyAAx4T5snwEokr4Edxjmye3qv7DoCsfAbf7fMJXQ9JefoDzQXGiGBsATAkdSoJHpFyZJ0H1296p2cQr3n0gUe675izJMvbLfI7rhXJpI9TbEnkvYuNQNblcluA04jVehXNh2bcvPxITJ1klDE+zDHLpQ/x7M3beOvnn4gldXkDCDWJ+XwayzvP5ZuXb7yONg4xRnb3oRAAxX0NkCPuyd5sFOFFh73WWdZbwHcNYQ8WjI93vTBji+cNY2gWoO9V1rwEY+7efNA9BBix7lJI2Crxh9UBmCZZHLKustZSVIINAzDEPQPTRVJE1n2Os7B2knUEEMVYwli8gomTDD4AxAJOcT+B+jBOq1JQ4b0cl2Sbg4GeY0/fuI3pPTL5Q1y/fB3bLaxUs6tjxDrcUgGI9VpssMJsdfLfMEsYNu39NOLuIVpNWEGwfgxqCWyb9GMvJmC5T8Qs3ETjwPOiI5YtYnVY3M/efCaGT6HBFmCqH/1hV3P36Vu3AoMAR65fvins0YPuz/Hl2NI1FRCmGlvmT6fjdckgPM8R5q73Ghw/c10M8qvxEUSlmMczARB+fst+Yx6Xjy8FDuk50OtEbz8QuMI4AGyxlgN6MXcklR72fe1AtQ8UnwzG677R89LPM4AsWHndXtvM3Cas55WA68nNJEa9sZhN89lSrFKviRS6AAJhXQEOtqLRbWuOcRLsD5Byn0vdpnczgWnsPzowCq8vtY6zj2C+XFzzeVt9Hs9G2LHDEfcpYJoBc+0R4xCT4dhSy902Br15NC4iJteDuLi6UFFkejtnmY/XfsmrsmfAgkEAIHutJlfhEM1ourjTaui+ZH/I8475jJRy9OzeTGmYfJ1WtC5HAtoYb64zjE72t3o+XQxVLOO5DiZl9tdprapRo0aNGu/d+LIApUiUvvZrvzb+3J/7c/Ft3/Zt+hkbE/79Xd/1XfF+i2PSjTyEytyheayoksy2uwZl7B8QsWDDVDw1SHoBcvabdezGOyXx8vHoduPZm09i/mwe/atRjEb4L9kHQZsQ6OsDy4fYQGzWa1Wo2CAOJkNtNsQkmi3sD9FsKsFh077fhJgAbKTMlGioiqeqIFlr+R2bevlcHQB+GrFozWLEpvuqHxeTsTcqSNjweVCFGqr5PFYLmAZ9AVZU8S4fXUSfxGw4iIubcTwbdOLu6V0cNvtodpxYjK/HSuR4PUn+bkuibh+ni+uLGE9G5Tj2cfv2rSqLbUln7D+UHgqcC6DEConcaiWQgapim9fAkhj0tVGSzwFJjDx9egIJSEAEcjWQ9/m4GgKBzJ5iU23/oaYkDSQeAoxgvuyQhlFVRSZmGdX0fqZjkyStTUXRfjHdbi/a8iGyPwdgiFgmRQak5FWys11hcG01vmI9qXiNV1Qv5ptlLO7mYmY1Beq0NC6r+0XMF6tYTFcxGM51rdngch6AfjcvXWvOze7XcfvWs9hdefM86cL28Rjz2marF62+vVGcMBjIBDhDfpDsLaql/A5gY3o71WaWXavkc4yb5uY0VqtFNFttJZxiDywPYuuR8ONJ9vDkzgn25ViA2s2HXtIYkHAieYTFx3cRbLDZQAuguxxFe9CL3cffjLvpLHr4mGzNcum2DKYBrDFmsMeQyWWCs4TNsSSRbcTN5aU20Mv5Iu6f3StBgTVFRR+Qj1vj6tEkHn/gkeaAPN8k78FbCtnDQvOx0+OYxro3p3fLmCOX+OtvSNrx0odeiQEAyM6+POmdwnc+e+OZ7tVHrz6KRp9xbYrFYt+qltaGi2szGOazVaznUzOcYP6J3WS2gIDUdlOJGknbYY+MzyCPfYWKLxCgHlMNqR0kH5giSI9IfDowfJaxni5i37O/1rkXyDbZWDAzYX/uzmVxO8m5LJ3z/dgF6OoApuMZR/JoJkkm9FtAK8YDP6tuS5/Nz2EIHTYh4IH53WjuNVb87mJ0IbaYPdI2mhsAiHwW9zJsLHm+iYVkAJLjtYQxlKB2qfQ30oPJUj3GUAm+1kX7pNlnpiG5JQe9KZ5muSZzrtxDzFWxY8QI2IhtBTgKGMy1Th8awDPWHtbj9IlK/pruDcCtiLi4mmht03csVgL+5ZM2GcXhcAIbz0P3kJhIh9iNx7GarY7XBTkx4w8LSyyq5TrG231MHl1EB6AAoFRstlaMb0ZaG0XKaTQls7t7MtW8Hr18c5RoMpfwpYL9lJ498qAZdGNycynwvfvQjmebO12nh7u7aOwA72DJDuLq+ioubwxmJmtJCfSzB3m/qRAywVNvHIeh5wLrz4bnRSm0CMwAONZ9ZfCetZ6EmoSYz9Q1EZBtVjMg98PdvaRQJNk8P3YUJ5D0LpEc9mJ4PY7x5UTFortni5g/PBQvnyK/a5tRCdjAh/Jc41kKs4h1kyR+encvZpJYLcjTVCzYC0juB/MEKbfvVa4T15t7n30DgBhAnlh9q43mMNeEa8n9cvfkVs83vLjEDJWXlosJkovNV9or8J5mc6CCDL5ErLub+S728qVrHD24lsXvq3VoCqjk+bmFdSr0+hDdYefo5XaUth4aMQAwXG4EnDBhOHfuI663gFLuXeTFmvs77Q+YY/aMWsVm6XsBNjjnyxzs9zux27e9J+DZL/AF375ezOeNuH/C2la8kvh+AVERjYuhAfX5MlYzmEoGO/ddSzcF2ogJvdfPmRMUQXi+Sh4LwxM29+1Ux8i5SmInIBzpONfDxY67N6c6fgC85rXfL0+nIr3kuzUOC/YaG9kP8Nw8+m7q1oXh1I3hxVj3LTYL7OnkHbXexbbXiM2MsUGWfRDDqRFjFU0AzVh7lrMHzS2Bu1qDuvHqV72q4iZjo+v78U3ELgRGIqXlfpJ8H58rAcrefyCNhnkOeN0d9mJyMRGwyNizd5eEVHPZoHR/cJJk8hf3/lIFRdZzP3/lpQmb17UFFTo/n36DNWrUqFHj8x9fFqAUgRzvN/2m3xRf93VfF1//9V8fP/ADPxCz2Uzd+N5PcfQ4QbJEsqMEjyoZEpONkqHh5YU27LxGtagiM5IGv3GIKZt5UfJdhc8Nyz0JX2OjDR+gFhsA6Oe8lt9DT0+j7UzgOv2WvJi0eSBhIVmXQTLsEpIRquS7YxVf39mjQhja0FJNREpAsta5tCn6fnPQ5pXNVLdNwkhl0RVNqvpsfI2WGGRpdxrRBZAbDNRRUTIGbeBbMZsulbCOB6PYDYtpL4lotGK/OggoEFMDdhl+CZ2uKugGGLpOMubrWM7n9r4Z9MtGiI0eVXFLz2ChsblijGV0LsYYNHg2zDZ+JSltkrjip0QiOerbDFeSCle3cwPOWDK+mM3vNjZbZTvFZs5yuEMMrvHi8aaNDTHSNzGCui1dc5IBAURjV97ZUOLrwhiymSSxEksOs26S4sLUaK6BvVyZzOQkjas5nt4F/lsws0i49zFjA7i31ImKMedMQgngBDBzcXMpdhMAIpvxh6cPMlGVB1a3FbP7pczrNeZIMeSJQgUdw+JeDAeDiIEZJZZAYTKPKftK7B4kc6Px2PfFmmu1knEqEjbAU8DZHoyt/UHnDXtFHisAdrAi+1yfZtw8vlQyArgHwEAyAVOQCjuJAJKo6dM7yfKQ4fW6/RhOiuSlEWIJkKgxrrAqYJHlGFKx5/h7Q8stDDQapNh0YWM0JD3FO4Zjm94vBUrBDFC6Lyka98xeiTgJLomVfDRgc8k4fhivfMVj+2ZhCjynYr+IZhNWAEDbUtdbbA6Ss7UBCu5HgFh595CwIX+RB107Hr32OF75ylfjrY89ibd+/k2Bkf1+W5VwfOAAUQGV+jcTJRmAIvJJATBRwusEAj8e5rmMg0kCxQozGM44E/0h6xHgJImHpV8li/L4381UIU/PKbGRBOwwepaYch1J5NI02993MipOYIxjbnJt9buD2AOMj6TKAj8a0Rs66dzjF4YskHtUDDaDQhwgIIe9YfBCA1imQcNByXyO87oYM58bR9sI3KB4pzDXYLIgVeVsbj5wI6Axmy+kfK/N//BR6qdBttdU+b4t8F5r2rcH0FjMLdZqG1Db540MjXHuRpcGFB18e2y4rfW5mF5LRgiLgfsRQ33kf4WJA8Da7sCiMGCb5sxe43rx0odeUuLJWAP2QapgXDfInFh7+36+ACzBTgEcZ21FPgwQyvfIaLpLI4xFzB4e4ubx1dGcGSCCe15JaLMVk+tRDC9HWqeyMUG71xOgCpj6sb/+hu6b8eUwXv3KVzRvwbG5R2QKD5ipxg2hZB5AXJ7LyCphTF36HmYywCzjeTUA+LsYxHpvyTbzAY8f1hsmCNfg6uWJwBhANXzpnnzs7Th0mmZPiqkEUIaf3FosM+4DnjdKqHcAm4VJJ39B2Hl8P4zAbvHhwv+xFcvZKvrDdXR77AnwCbRXIGszz2dkfjxn+c7xDYWinpiNgPXyVWqtdF3GgOSjvq4d64vAsH7XnoRLxiV87Ei9hwODxrpJ7a8ESDu6ADTeS6bGZ7HGUYCBoUzhhufRaQ9j3x/Oy5Jxz+1urxnbxxdiKAFact3ccAU5pVm4ABw8a2G3MUasDwL2o2G2DGsr60NjUFhLm9gBnDI/tgU0ho0pYJv5bwPv9IFjTgLSmZ3j5/Hkaqj7KyV8t/N73feAiAPWBdZPTL53ezG7+DdreRaNGCruJRjl8pXbrqPXM+OH6wa3krWHY+MZInk7PmYwCLfIU/GZasWgBdO8LdB4C0YHcISJOV5tW3s1eR01KG8Wpe9t/hvfNmSkFAE43kNpYsJaxHoHAHv/+kPM5quY7IexnDKfbmN5v4jNdiM2vdaVDezhrT6PdY95ybrNfc99efn42p+JNHwOk6kn4A/g9+F2pmf1zSvXMYYhj3flxmvI4dwnEEgXf7fSuEW2BoWNyvqkpi7sOxsHyUSZ15sJIBry6iyEUCDw/rSCUjVq1Kjx3o0vG1DqN/yG3xBvvfVW/O7f/bvj9ddfj6/5mq+JH/3RH/0E8/P3euTDWoycfWFlUD0uUhk2iD1o88WAmE0BGxz8h7L7D8wmKqNpypkmnkiQJpdscJH+OTGQjKQkcvJx2e2PvgRUWElCBE6UarEYDPgfLAoLiKS134xWsxOzh3tVUwfjUUyuRtGbsBmReY3OwRuGhjeQqiqaPWRPDhtnC2iDPYW/kgybobu7mkpCvC8bPM45jT8BOfA9YCPzxs99XEkivlKAWJi1s3lWAlskIfy3gJhu2Qip02BbngZU40ka0z+Gjd5hS4IG0LbTplGJeBzi/skmVjtLmtikSv6iamZhJskzxB41SuQPz3d4Y9MPYysN3HV8VG/x/NJ5Fb8dFZXtaQVrRslihw0wyatBLhIwpJYkMIBVl9cYXcPSwUfCJru8jg30UtXXwjwpEjqOGDBgIpmIDVvFFmmTrBn8AmRiXAFgYJfI+JxObYe2zLdJulZUqD/2duz12cgUMC7exZPX3y7AI3JUSxGZAzDFOAc+Z3E/k+cNDL3bp/MYjrvxGNnc5Umyl94teJK1Vs1ozPHoAShyJyUhPICIdG+8GOm8SLokxThu4EkgGvJ4oYLLdQfUUZINU2m+VCV3eIGxsL0udExv3ckPR6bn673kp3jTAPooxRdwBxDSUlWa74GhNB4PY/fKTSwepjG4mNiz4xmS03Usl+3odpZKgAXK7XZx++Re58lY9Sb2STOI0IjLi0l0PtKVfCPlPJsFfkiW2W43locyaQByF7AHC2uHsUCGAYOMtaQ37gp4o+IM6Mb9KJZNGKjgRWsSXxhsLYNdBifMxrL3k0358ZYDpEs/J96zbm2KD5wNiQWcFzNh5pZBtFbse7A+Sjc2dYpzgpHNDfK/vUAWAE8SkaXmAmCdz90ADGBkoQtZCi3fo50lMLttdCTDMqgDA4qE/bC3h5SYOgVYUmfDZYhxgWTZPn4ktoCj7mIok2SNq99jGc8hGqyXZb1mXNXhr4BV+B4x4MzHbZ5b6SCZ58trScgFVIkJ6+vKe8SWLYWGUzfEkzmzpdnFsBnGGOsW6x/Jd2GnCTwDzCpSOT5TDDsYkfdzGecDIB3XL+4ZpJDMyX43bmH/LPBGgwnX1b20W+7lDYMhNKAzzxbuETEA58zxYTQBjwEHWsj7kHIDxBtMZ90BROJ6AUAAvI+uJiqKNGl+AMsObLAZLnJcX8R2i0R1H8v1VoxGg1qbeMDPcLPWuZBAX7x8KXN3rVesg6N+SXxpkhDRgPElYHIbnZafN4DCgO+wDbWWtzDdXmisxjcXej4xvwG+BRh2m9E82NOQ63P39n3EA8UOJLwtrbl+DnCJ7BvGmFBU0TVkHS5eaRozJLMwt8a+njxzAfd5Bl1eXARWXoDcz958GvP7dVxeD/XsB4CetWFhzdy59OB7gmedCjkY5a820ZcBeCcWh6WOCykwALw7zhroFXN00I/mY563HHNHewOKNQYkDtp7XD2+1rXLbnKcW39o2Zq7lbowwD3P8545lU0FOEcAKYoZjCdNGpCCyXtOklt/jjwIp3M9q5MBznyH8cjzhuuHJ2VvwNy6jLU6xxnE61505SMoFpMM5X2Myavh+K4eXxUJqbu7IQNf3s9dYEE6jDk9xQ5YZYDWul9hecLsO4EiFL3EioZQSxGHvU63Fy991SuyXIDhTYiFPLuL26d39r6LRjz+4E1Mri/kZcdzq1t831jHkE8mqzkw+YeEjh8UDDr8BVc8jzl+dynk3mU+ALbzbOM5dv3SVdw/m8XyZhmjR8O4fHSj4+T+5Tj4rJHkc0N5eomVfGs7B3V7ld8lTFD808yWZh3muljmiuEToC/PHfazfm6wF80umABmuZ4z1rCNJSUs5vi552HN1P1SfDPbLWweKFJS9LEs+OSD94Xdl9eoUaNGjc89vmxAKQKp3vtRrnceubFxAs1GzmyhNHFMiQZAg4xnoYlfjY9SGLVLRtLU6WHucUxYDDCQuNMhzaAWm2Oq12ygJEXB5HRlM1PTp5HAuBOaGSwwU2zaqY5BbJBbLVVXYdjggwV7iPb2fB6b48N1xOoRjA2zuYjVshkNtbq2FI/NF4CMzaq9EZXcLWUrA0QJZm9lpyk27qZzF5PY4gHD+wBG2Dwi7aPimwn0aDQ8a6nuJJixmlzApCJxdttstQ2XbMQyvvYYllEj9g90pXNlW0llD2mgGT4wMQCq2LjpmI6AUmlPLibFqfWz2BeMKSyLIkXMTkdiww1GSm6yHTa+RP3hUNVdvk8JbsNgFgwcNuB05VNyKN8KX1M2lfh9TIMN6kAMKBJqEjw22ROqoBrnYsqaUqrlSsAOzCi+m2uHVAHZ3MP91BJLQCoq+lSPS9KKOTAss864H5vlIrbLhjyKSDoGA1hLPW162egzj6Hlb9cdbZ7NBpvG/H4pT53eo1FcvXyt6uyT15/F9OlD7C+29scoXdwAdJTgAEruqGQ7EcG1mu9NbwyAgu1iWYC1vkC+7Z0TlvS3uLiZSF4gALJIhix97cQ0ppZyGKtRV0J932IRV6MrdT6yTxBtAWBmkMggyTEQeXFlVowYPLAG+nhlmVEwv32m8b966VIAHGPPd5FET64uJJFiI76cr8VuunlpGO3X3JWJexA2GfcAyZtYUJj34+PSIwm1XAXQR+bos6X8xgALh1dDyQQZAwCAR689ctdGrjtdzbR2uNse3w8ApaYBkh6WDo7FSwqzayRUMsBveG0iYcanRvfi9UTsB3VgPCCPMxNGncCLrxQJsYCa0jhBUczAs/OdABr5sAn1dcIJw7F0p2ocJXOsVQWkKh52dKGSuTPnxVwVAyo7b1lm5q800MOcVefJIpVqyjQZzzoz0ADXLZFFzlOYS4Uhit85ySrfxfzhNZzjCFkxlX0YdqVLJ0HSFkXNmL5aBuPc7UxG3IFUl8YDXtMBUCW9K6Cjk8K2k1BkVE2AX8aSlWmt75QJNJK3J/dq1S5wWMkdY8f3Gthq7HwdBBpmBz7JyQ0cWk7UjmYHZgq+RzCgtu5o2YQFshWofOA8Z/t4QHrMunY1On4OLJLRCK+p0hUSYEwG3w0l/QKSJf1kG1NM6WWMTVc2FyUAaAAQWkiLYe4MezI6f/rG2wINYGtxrRgjnn0wLPjMZO9xr8lYvICKKtjI3wlg7MGsud0ewVlsNm5mwDzEpwxWnaR8h30MR6N4+UOMPew6d8hjbCXd7HHfOyEneVcDBe7XRitajVasg0YOeBv5GQSQRNc9rqOM+4unD9fr/q17AQQvf/CluLgcSgY4u4OZSsGGObtSgYQCikzQN/YR45hsor6RAT3rBueFv5a6mNIMYroQICUmcZF+q8NeYVbBerx8xLMYZilzYiugJBrunsb9lfcQ8yO7CM7UWREwaOMOwFO6vHXi8vFF9DowEfeS2eEHSLSX3WjPFgI41SWvzENAMzVxKQ0BZLZOs5TpgxiCrY4LPLAbeR2NATXz10jWLTkmBBSpUON5r+JWkZmr2CLWWmGBXgxVtJI8G+kiz30V6rjfDSBrL9FND0W6OgLEtF34AhsHWGQfh1wvC1YHAN5uXL1yE0Cj9ximA7R2upLiMybp9Tgc9SWR1XNBdhUA02MXHgrQY7+8snaUvSFfxbomL83SQZNn0GDUjde+6lVdT7EZadSxwL9yIKbd1aNrnSdeV7OnD7HpdOIShrg8N71HkBef2KouYHG/2v/Pc/vRB240pgLzCgs4maUG4LyvlecdzxXmrzpBWvrsPWvpYgy7vNOOi5sLPfez8yljpD0pQLZ8Dc04rVGjRo0a7834sgKlvhQiH8hp1MuGm41itkNOn5Im7CKxhixnYtOh31MR7bAx8cZG1fztVkwP/ENAIkjgzaJqCpSQ5KPI5diwI5VIfwcTrM0EEJNKgNU+mmwyYBnhrwRTC8o9lPbNlcCFZDS40xaGnnOBF9r0y0MhfWNcxZW/QNm0pKWJNlEl2SQxbPa9WWZDyiZ3fTeVCbF8OHBFmIyi90t7pYNMS6a3DKekDmxaiw8Mxys/KemlDI7lmDsR8r8FjpVqMIlWT+wEHxvJkQCdkuhh3Gomk7tSNZtDvQ4/kUaT82CTyufPJT/CJ4yOgHgxyV+mJMZcK4zFYTyp4iqPkaYSh+HEwBudFDF1hyGyvxqLjs9mmk2sKP6Y6spPBLPfkqjq+tkfRIa76030G65YJkMCcAumgKUUm9jhoTXqxUKGqGYz8dkwHUiMmG9q0V7kH1xLtynvRP8Sc/mdwC825eOLro736uZCwBAMpV2Rb3A9qOQChFzcXMWQLkfbrSrXSBMxl12uFtEiQeMaIyHlOABdOsxfG1IDyLHB5XswrQfx6HSdbCNZ3K1d+bcJtTEAyY1kxrzT50rqiC+QEjozYrZ7J+Jsiqnis9keIKcZ2K9ss6bLogG3h7upfUrU0cgMALGUdC3LPO92BOSOJlux+u72T4s0cackATkMCdfoYiTGo4ABSRjc4YgEMyvEzKkD+UmzaUkjXTeRL4ld1ZQ8lpsRYBKggmvbGbTlSwRIhD8Ic5fNPYAJnkPutMZ9uC+tyVNGahNms3mcAKVUjGt+3k5dEivYUQDKSlbdwEH3b5FDqYMdIMjaPmwcC3MQjzetcQWgkgxOgEtT87ZdpLKAWPYSL53OeOCVe5nXq0ue5neIlbHp7WL+MI2Hp3MlN/gKAWrIMymlJELJyjmoI11brNXeAaagQfUBzBXWNw9GWSuLNGi3dbt6sdUwNnZnv+WMeWSQBRYRRsT5PtseFT+ds5AXUPGDe/Y2DMJ7rTH4t0guV2TTTkot0yQhh9XI9Vwj3WkabJa/V8PMHlhJkkgLfN/bWLmAvD2AJhU5iuF5YaOa5cVcd9LI/d/f9Q18NHcyyAf0xpybzwPsgEnhIsAqZvLi62itEpjeMYtDDQkAOmHcLWwq3h92IgBnabBQkmnWSLGK1FLekjDup24bSdlYpvN81m4PCA4za61mH+OX8enzc0pFhiJXVBdHkmN1GGvHdm5PGwAdJeQLQDwMyHVriR3E2qOCEM9mWCkdgxIq6iBL63c0fwV2tBvqoCkmGlIzZHzq8EjRpiGAX4CG5I6sq8ioAcg2Nhrv96OJmX2RUKb5PDLq9cMmZrCgej73q5dZi5ABN+0tpjWgG/NYlKTfYMQWuK+xKsxrjzfFlItHE4Ho+7WLMQD46+VW58MNxrOW51FXHfkwy14LwOK+ZzwwuB9NxhpHFUzU7bJVQK2VvSnXsIzLvmaJxJ2bzAg/YDsACHJCChDMl+nT+9iukMXtNe/V+fMCg2yuj+WWjCfr2pOPPXW31lduxFhifj48oyEEXfPa0T2E9h7HfQRND1QU2cRBEnfuSTONBFbB3h314wrDc9afYpTPM6XNfVb2BN5bmXWVDMfszpnXLBsr8CLGVrJKrASYW3RVHPbUJAOwlmNnzknyry6QpQDZd8EQWV92X5SMvxTiWPMXi6VYfRR8eD7glyjQBm8nljQaCyCBfHqvzwCAokjkZg5mKbEGjMdjSXl5n6TvQ7oAA5YZZNWzqMV9AzveXoOsadl1UsBfoxHji4n3XvhfbTYyuIdNy7ojNhYSTBr4lG6IZuG5qKH1kv3IfFXY510dI9+dgJTAYK/UxUbrE7u41qhRo0aN91ZUUOp9GNq8Y7B6N3dCUKj0hE12m9FpdaPTc9UJ34D91jK4xuZk+MgDH7BisViJGr+LnZIGV9gtxSAR1KZbnYZoK42sjuTEm2E238lgUpJLMgTLYbVWUsEmUUabJDFsKMYwf6gMp+n5acNGFd7ndzJmxpPDRpokdaUV/KYwE0gi8DeQ58YummKaFHo9SdfKJsFiJsGWKNKS2XQu89pFo2mZhqQfdANrxmHijV1S4SVpkDm0ky828e5G6G47C3xSSlJMlzM2rzAs2rDCOKf1VpVqABE21WJFIAcyKucOb3jyDK+0MXc3nmJy3AQgs8k8kd2aAGWyFbrYKPhBML507BN4tBKY0Wdc8V0oG0+uES3S1cGJTkBIh4a96A7d6S+riSQ2oIpmRznpxysFZhEyFpgwnQ5Jnz05WgA4AvS60X7pSokXSZgq7Wzy1dGuLdNbdTXCZ0abXExwB0qEke/Q8SulVTCw6DZkFlsx7W21YtyeCIgT/b90z1MnNwxVh8iMDCoCfOIXxpwgeRKjDPCo+HTBpss5wobW3i27aAl0KEzEYWmPTses5fJotGppU8SidMciqcUDDSCAjoBs2AMj6lY7drGNxWwmCRwgokACoFz81pa7uEfC04y4vL7QfS2JYbmu/U4vBg1LaZEIzZ496N6hq6SBHDoSrmO2XMf9k3sBKI9fe6QEy75ATc0/gGZAB5hyXFfkH+rK2HSyLh+eHc0IuD4YZb+sajbJh8y1ZSK9isYB4Kwt9qDkdXT2UoeuYtrdPjegLXJcmQVbipSgm+Yx85lOTABpzOnRUACpmzdYKox/ibxwSMZgHe7tVUbC20HuwT3CenDYRU+sn40r6ZJpIruy/4wSM7Fd9u6YWUzU1VnseF953qzmpfsoRtR9/KUKkKaW8Bh/09HN80ByObFIafyw9RolGRFIGB2lYA7A3DRAp453y41YcPxuA7sJeQ8mx7N7Jbt92GKdlOn5m8XEatqXKsdXADnd9wprR4kaYH9ggE8H1oaYKQJ08TS7m8Z+14jJ1Va+atxz/Gy93QloQYIFmDJ/QHZL44h2HFqADmYscB66J0pXzZQiOpxYS9bZ8P0OEMu9zlrNXG0DEjXtNwQQ2urAOOyU7pcArXSX7HqN1Dja2yoK+0xySBVRDEIJiMeHbbGSnw3/TUKKwx8gB4CkGEGAhKxxA4ycI+bI/uKg7pIUKWAaJoBoFqxBm9ntVMwXzMftkyNn/pjquDymmpcwYPaAnb53KTjwLJnf2bSaew9vK56bYpzM6Wi4il4H6e0wesOuWV1lvsLUEkBR5qu6cdKNbdKKh/t2LO4eYreCldeIfbPtNZm5VkC9wcjAGCDRvL+SIfnlzVX0+oOjGTtzXZ3THl2YXdjzM1RNMXqwWzEod7IvELPXdmdCpJSM/3wXrQmgWVvm5CoqIFccIeujQ+jSRuPNgwos3TYSY/un0VlRBYe+Gafyjxv2Y91a6zqOLiYxup4IhADIdOGlLYZod4DUjCLHQvuC3sigLM9C/gDSc7wJenPPYeLNz7mmfA/zZ78HFDZgkh0lDXDvVEQAXJJ5+2IR/eYgmkjSWFdwGlBBh+fBqhihe+6zDjDuXK80806fMZ73fJ7Mvcta0DlKj8PXkA5/kuS6qUKMAWOGusfpZqlixaitNTkls3ibsWbM7pbqXKyOpcWDTGCtCkgGcKYwDQFiYV3Dfm8jlVzJE43rbVCUe4udyYmNlJ1DBUgPzIZOH1LWFpiPzHcAqNKIUfNeUmHGknWBNZ8CCQWc4nHKuLAn4ztn9wsVLyTH3u/VvIR/JxDP+LHezOcwdF3Iw3Df89nNfMxkc5GzLNjHfSXXl2NPa4QaNWrUqPHejApKvQ8jNfJ4vmwf2Dzhe9KIGA+Lz5FZPvP7qeUA+4Mqpmyy6P5FQqIH+qgvw2J1fEO73+3Ji4edkzb+KTErkpGlWDorVzXVlWuvarXYTDzw2bxQ4escYop0RQmZ5UkpOcSLx1V1+wX45wAFw7N211vZTG3TF4tOZrQA1smz8bEPCljCZgY7i+4zHRm0qzqISfHA/jRUCbNtuejgACBLd1PqDXxebI6QsVi+sIoZ50nb+24nhk3L1/hiWBiSfBUZEEk/bLTNdhu9jjee92/eR7PbUnc/Ql113riLh+kiXqY70xhJBXuugza66TnBWErieCgGsoUVx0ZayQnsnNINCNNfWouzuRMLQqwXEqNWtEYDtUBfTVbHMZBpcAPAzh2ryHrMYFpbAggYtWUDt4/FZhGzW4Mt7dZc84lkifkkAEqd5aiO83M2kSFQSy3rxc43u0yyMTyBoO/DvLkYu/15kRYiwwGEUKVdwFVp99wqrb2LUb29c+w9pPbaxdsmfXU4Dg4CFggJF0avy51lDJ6/9hcS4CJWjCVPJPruxLSUp5kMrovBvEEUkkN/zxrpmSRhzWImDxMEM/1ObLY0E8A/pLxeFXJLFUh8Glu6LtLm3rJLTJ45B7Pn7uLuzVsxkFZDzJtt6E3I16Tpjm0yFh70YqEk1cBqyuWaVMqp4DeQEBX2Ixt0GGEYDCPTLNXpeHyQPA0GnxhC6acEiJaAHaByka0k+wLgVsBz8Xfx4BqwlClySaSY2y+yeVZbMzVJgtqwLuXFZNNd2Hy3b94pCYX5IQNrtV4zC0nVfMBmMVfwICmm3bSUL13luC/SL4xks902ayb9tJoJaNCJSV2nzGbkvZyf5ITq/uiuV/K6g5VVPFLS54kKvgBpgZ5uZGDjcHs7wbrbFHCBtcPeZG1LAou8ZF98o0henTw1BNZIyrqdaG2WEb3AQLObsoPb0UuKJJHETACXGZ+S+w36cfPKo2Li7ns9JUaAtsxffPlsMr1R0SHN4wEJeh+EPWfT51YH1uAu5k/mMoYGMDxfk5ItooSv+Nlw/x4TWcn5nMwmm8sdwMzi8OcUKXmR35FcMn+QDxvMQubENbEUu9Pdaa7t9/6ebs9ghsYJkK6AVnz+ubk7yTZrasqC9mLcdsQ+suwdUGOr3y32fjbKM5BnDwbQD77GZmDYZwsQWEm5WLstRrUUZlg/hCiLPcNaxhzRWrlp6T5VZ1buI64NDSkYSzyHWrBSPCfFJlJ3yL1YJ7ut563mNExiPJxY26w71DVwoaATj165KqxKZI/Iw/o2vpeHkcce9pCAsSG/83pk0N4sIQA9PNZYTxlfXi+/KwFxHYFBXFf5iz0g8wbUdYMAxpHn2Bp2GcxLiifZ5ZD5Xu5LX/+9QHHALAoUadzfF5PYoKPnEde/C/Kq8ZdX4qirLm2ST27xVesULyIDhviFyeeu045HH3ik8xAoASp0iJhcjiR7072MxxsAVt9FL603SK1Xu1g1VgISWfcpULF/wDuQZ5V8HnnmAsTh/3c7i97FQEwnrr+YegB6ev/U4OvV2EzcYjWQgPlmaf9P7gOtuQCpWA3sfR5q4FC6jQJMAYaKOYoHV5nrR1mbGGJmowvobGBiP4qDQDs8pjo6J+6tTq/vzys+fYB08nkqjRnE+sLzqwBeuWdLELfddMHLj30z5VlvmWow/pjjfAYMP9YZ5Lx+RnjPKYk2xSDOHRkkzz89s2Gv2TdLf2YLHcPVzaWA0btnD3omJOOVM8dIPYMikNdrGMowdWuqU6NGjRrv9agr9fswtOlnI73BT2EvnxxVikuVKBM/P/jZ6NjfY7elOofpJCavvPegjnr9MVVIVzNVLRYTxO2LM8mUbG8EaEIlDpmZmSsyGOd72LSXDnJqN46MSeCX/aoSFMrqV8rC3JkLY3NLXbY7byag6HMG2tS23FZdGyWSILxpRD3fxQ7/ls0hDnQqUoc5KO02gJWcpjBz1g13g1rMMbdFCmBzTculAM7GSh6QBs3vF26hvbbhNUPA55FUKOFo0yUHQAo2DEwlwDMkN/exWK6i3yJpYDMGI6DtBHK/dVe84r+ypxXyBp+QYs4cp3FJ027YaQBuovmziZeXjr0SMLVtHkggTXXPltkAIWy4bRS+U0K6oQV5m9dasiVAiA2lKpo2anbmAPtnVTw9DNSREIl1NRjE4JKE0Z3+Mqllrg2bg9g0aetseaOYeWJduXPfvsFG2Ak9SafAEH4nhpSlpUqQ6GKHlHNejqcwRaiMSzpRTG2zGxLfoThYdsm/V4BG6vY1jNGlpZpi0hWpw+JhGfPuXNVz0h4Z7wqYxJNpJdkpoIyZSCRie1f9++5MqHuLzXAPIHUUw8ZQ4wNDTu246Qg4W+kajejGFY0Y7DELR9bqeYR0h401QC4MACQVdJDEXwnpJd4ol7AFDk2xXmTyOujI+8Xt1EnQuf8MnsHQu5ZHVUeyC5JZd5Rqq6NlspZgJNH5CDNk5llKkahokyQzZwDpALLlRzLAi8NJk7vHwSDYnDrBkbDw/hUMQkzgN2JQpocJ84/kUGy7BqwhJ/hOTmBgwdKzRw3ziWMwk8pMTUndACepqgv8iBiLHdmWvO3u7TsBrzevPjJ7pzBpJEct95kNoQ0i5Hrm15389M5DbKAC/ANQK2ktMl6BK/K2c5cs1rNsH888SXN0fPgYN1gTAvyL953UjCRHYv55jTIIZ/kgn601rMi/9uiKWjsxww4YxMPuo3snTE7WSIFfTkbVYl7eVAB2jWhIykLDhrX81/CkA9iXH1LpFkrzBxLogNhH4wpM9gsYvMJjDsneAJ+gS0nET/JLMyjw4uHD8FbLhFiM1yXPgWZ0YD6WuaKmFeV8AfFgXjK2NDXQmC6W7vZX1j97f/mawORNIE/M3fKcyu/Mbq8EbBOAXxU06NZW5NwcL8l4/xGSwYj726lA/ckVbepbsZgv48nrb8mU+/KlC8mSmWdiEMKG0vMKxuJMa6ebWfj5RVLP2iHpofzISpI94NlooE9AGmAj4GxJkJlf+FKJyXiBlBh5fUOFHQ2sihcea3kItZA9jcRUTi/JYQsZ+EFFADzazFhuR4ciVQHmDd567GezRdw+vdX9peYWAOtje6fpGU/zkMuRWHQP5XU8NzWf5BUG88deTevZUgDsBnbLk2msr1faT+QeYCMipZkyPA8FlJZnsqS+rBO61mbCPHvrWRz2DTWP4BwEFmvczdTT/bM3SJ7MMJ4vgyGMs77WHplbI/vjfCUNRR6NvB32ko3q1UgD776u55r86eSz2D3+TOycoEi18Dq2WMuqgDrK5c04Gp1ODCdj2SQYSNzHstOwvPJ2prUNn8CUt0r2DxhZ9kECmWEva07z+avYHjZqCALYmhYBrZGbf9hbznNZcn6BUwauBLYW/yQVUdg7wOxlj4IHGabyI/YE3nNlZ1JAYPaFeiYVFpF8SfGUBLQs6yXX7ejhV56BfFf68fEcYS8lpiIFyzLf7S1nBn3EWvsPeRtqr+N7h2dSTAC97PvHoMi8feAOzas5RUQXxihciOEWLnSy/xFreYtxvdmnWXjkGc1zmONgvlTpXo0aNWq896OCUu/DENgwm0tqIZnD0JtdNjmSyLBplBwK5tPY7adhh+wxRx4pSbt7dq+NIhugycQeUYT0/SQEfSeKbJy1ESVZUTebXUxvVwI7MFpW5yh1W3FVLTfgRxkd9PH52qbT/Z4qhiT8ArNI/AAKpnjIbJScq6MTLJW1afkwYLRZFHPAiaD9YTAs7ca+T+c/+zY4wWPjZskZ4aTWngSSmcAokfQuq3QlCUo2EIbh475kX4splPdFrDjWAQmPP1fdoWTmbCYGX37/9E4UeZKZ61euYjTBfHYfBxgF8r7iGrljnXw82AxLVgcFvWuvJs6vtIJ+9vZTdWdic3Xz8pXGjmQTZsOzt54a9LgcxXgC8wyj7r3AJ0swaN/ejuYuKfiwbvDFMaOk3dnHruvkSJVhwMHirYO/yMX1KC5fuYkRFXMxMvDlOrEKAMEAdajGy0S3EHHErul4E8rYqM16ZMchV6gl40B2h6ws7BfBhpZ5mObBgKwkfLpkzYZ8mDDfHg+nsf/QYyXJJLVpoJ5SSjan9gmyGb79ypoyUYaVg2eP5lR7qGutzkQ7b7hhnZB4HKjSt9hwJ5sD359NDHp46nQFPpCMqVucuuoVUEfMFKUtZosBVKjzmgEz+V7I9BbwDlYU1x1mziOzv/DU6CzdmGDNuHRUyb97+hDTp1MBgsMhCSjzm6oz7dHTGN/j2yrXuDv0ecvUthj2u6Js6QNSv0wuBaji44FEiWsNGCyz5pVB5X0jVitAyp4GpA2YrVbbeKEV6R+fz/qC/KsYaMMQ4PPWc7fzhg0h35oGcsK2EjSOIbtuSUIj9pYZZ/vhPrqH0twA9iXzuUh5ON9NdxuHoZMaeWSJOWL2hZLAYlZus1+8xfg+ElVUWAbLc44wDtmmXowaAB/uzQLMq8MoXmKluUKaXiu5E4u0JQMyS4YgzclRuIBVmNo76Rbjxq3cNF8EMOJ9VxJnvmMnKL4wEgB0WCuOsmV8n7z+HDrQF9yJDWBbry/PgNXDPA7bbjSRExf/r+yUirzMQO0hJmM3BGA9UmMCQPPSMQ4ZFB06Be4XIE5rSWG5cHOyNpFsyiS+NMfQiOfcI7ktDBwGvn1RvH7UBGNpkANPJElsGNsivVHY10fgs2TcBvEMeBjky8h/K1GW9tPjzlrJ2Ls5A9/BtbG5+N0bz46yt/HYhZUDhMG2GRcwbNrIdymwCJPEDwgfP0uXAFU1DGJbMd9hsAGa2zdKMrC254vNsg3q5PNbBuHF90bszTJ+rEPb1V6ecwBwCaoxD2ByMpfz1BOcEGAAK6aAlZBNtR84HGQiDstSnoWbbTx9/e14/ReeiMGCf1+jsZZMluPVc/DxZUwuJwbe8IRqbCWNpTOd5KwCEyw9H1yOooUR9nwROzW26BbplkEnjgGAS+CG7oGibC1ySf6Wx2W7Fc+e3MXifimPPECpA9MGBmvfoHAD0AiQF+l32F9Rc67luW15v9clrVN0asQIe7uyafsGmbClazL6XiCrn4nlJjuB4nmXhTI1P+h2JZvuDgbRvhlovec5xd6H9RfmFucPeKt9T6sV90/uVLSRXFSfRROTlqwMstCzWgFI0SAGgMldC/sAxKwfkvafTLkTANI68kJBz3PHAI+ad7BulGch84f7ietI4W6zhhllkFjjqYYOeA66Cyb7C63Pm626u26WSxVB+DlrvIqAWDKMBrq/OUee0cxHg62ei8lEze6h/GN6/xDL6UpgfRqbE/KTopChBie2oMBnbnLpc7TX1EFFGr4DJryekwB/pSsz/oEw59RUpoB2apRQAGrJ+6cLMcSyMc6XUvzhP/yH4/f//t+vjuK/4lf8ivj3/r1/L77+67/+k77+v/qv/qv4vu/7vvjZn/3Z+MhHPhL/5r/5b8a3fMu3vONrf8tv+S3xH/6H/2H8oT/0h+K7v/u7v4BnUaNGjRqOCkq9D0MghLpyAfA0ZNi6VMM3TMrHlhjcPgh8kvTm6sKMHwCBhrvhsbnAZJqnt3w9iiG3qOzJdNjYt8hJhunWZkA4aWZj9XC/ELUd74YJHhBl4+3jdILIZlRd4BZLsUHwnpm0hrHbAHrBMHrQpouNWwJaazaxSHZkUt6U+W/KIR7oZFco/TBv2LxQfVdHPHx8SPx39r1hU5iJ53w2L35GTVVob/HzoRsM0q2SwPOZowtvkABjqDriY7NdAlLhX9KO9ZCOQk35ZiF54vvkdfOwlicGwMCiyCQ3C8zKC+tJyWDxJwkq9+585sooQIo3mZZU2TeFajvVc17b7lC17kdv7jbObPL4o+q4NmGHaGbb92K4yvlk6+yUw8G+MVDlbmDyF1K3qYM+j7EYU0VFIrY2C4bEh41vdgkj0dEmr3g3SJpTWjWTSOB1JMAJaUjpjOaqtBPG3JgCyJHU8bN1+nQgJdUmEunVJtozn9+uZY+vlN8hd+K/5TeCqTrsoc7wyLqRZxDfKT+0XUweX6jzn021zXbBf6i1J5GiQk8CwfW0rwygD0keXjxmT4WSGpn3d+2/kl0JgaPUbUwSkR7Zlr3JxEJT7yCzufCoKv5d8qCSPM9sJrpR8j2MlViIRZJCFzckNWYLMf54aTWVPMDQwiNKpucyrT+xSFLyJTYiTKbCbCNhIQmgsrxccI7uLrbDBJhkbIj5b0eSTjb+yLladAc7yiEx8qc6T7YOIwfDcjMgJB9WAuS1Qqy1Hj42TrDz2GBQMbZcewPGKbe02XSrNTqyPMTuKxV+B50tO9GRXLcwkLh5WAPl+2KWnpgllwArZkexTjBe/ryIjbo5OYnVseo6mSXRbXYK8FY6jem47XVl3yt3gtofDNqT1HO/c4+ZFef1bjVdSp4Jw0WgVZHUZRItMFcMopQuMtbM3dI4AA8yQA3faEcz306vGYdhV8k2r9lLtgfqYuN07j3uyd2+G23kTUrIkgXSijZ+ZCsYch0VLdSpdYNky4A2B5bgVXb6g72Vnfj4mwGHxZLXJuVz8tDZhrz7uN/lwQdjVP42SwMBRWqNdFhXtM3zyWuJfBDnGE9TNMHbyB5hajig47S/VrI7dF3V5c2NCWDfcS5TAPODvYmuAFBKF0fOZ3IzMXulJKoyyr4aq5gAGOyupgadfA+lnNaMEAGKkmN67SOZ1jgBwCKZVgOLhjt5ygOLOW8ftvQdk6wKL60C0NrTx3P8nNFykph59uexJZvGUlSYlDBxi4dZ6ZIJAJgy1tYeRmgv+owdc6zTPBqQZ5MSzgdpONcGCTrHqGut560lgDzLAFZH/U5sB71Ycm+3G+pe6y68lqnC+PIzwB5kPPs1pwrQaPkg3lQuVMjc+mIoBg+SQdhrMJ95SAl8AXAHPCnP8+Oa0TxJpnkuMP+YO81mKRaoW+MmOhcjPy87HUnqxPICgMUIv2/PtwTHIZqxHwF83OEHeDBQAkMZMAs2MMbqk+ZE66okn0iNuUhY0iHj5Xm2KYBho2kG9n6v5hyAQndPb/V5k+tJXFxfSjKbz0aBMrttPP34Uz07kFKyF2GvcPXSdeku53nFfAIkEoPwYGBXLKpSCHlY7FSwkr3CoKfjdVdI32sC+ySXDHVgpdDEZ6a/I96KSOmQajI/mbNit8l2wDJ12RvIR6tIYe+9R+O5xXfJ1zKJzWUOq6slzzqKZIWdb1bbyc+KcVeDhlFPzx2v14do8XyjKycyRdUFsaHw+gHQBfOMDs4AkuqCen0hVuSXEij1wz/8w/E93/M98YM/+IPxDd/wDfEDP/AD8U3f9E3xf/1f/1e8/PLLn/D6v/SX/lJ8x3d8R3z/939//Ppf/+vjh37oh+Lbvu3b4qd+6qfiq7/6q5977Y/8yI/EX/7Lfzlee+21d/GMatSo8eUeFZR6HwYJOOATlHbMnNm8iCEif46mEhQ28Osl8hV31CMJcGXalV53yyJJciIoD5sCOiUjicQvO0jJy0GdtopRdPGRYnMCTTxbjieDwF25TAvn30oG8IdKIGbQj33vIG8eZG2wNVzdLedYzKn59/xh5tbzovMbRIMtwCYI0IKkGrkibAkmNIkvG2zkDGymSEzZHN09sYcPm9DxJUwmsyZoSZ/eJEoQOu24fzZVhyZX/knOS3c+EmaYFQBuqky6K83F40uxpKCd38PKWdPxyCarVJmRRKnSjIyujUE8le9GXFxcHjsCWXa5lXeVzOQHA43PaHSSVjauGrFcUf2dWQYh75GdKokkmiQVy/uZNvVU/NnMqeuimG7NWGASS6KC/AbJwHoXA6RsE9PjAQk4N8aA4Dqy0aeLIckXm+Ms1XNtbTRq83MBfsWryMmMEwWNlaq9Hi+SFJI7tpJiX5WEGMYRGdXFowsZLxOAKVRCkdTgs4ERvyRSdNi7JFFsHgE1cnpVast9oqpwK+StxHyia122rZb8hI15JtScs8Am5qw9vlJ+QCLJuW2Xm+gOkuFjDx426U4qDeoyN5HydLoHdQNsNPtiafH+TWcd/bE9i+THoY5FToJyPEeTicCNZAaRtGl+FAaiZEBdKu4Ht9neOdHgZwk4nFfREyRRArC3Z0gfBgiApOYAIEHp7NYwS0dyWHmYkGiRkGPMvo1dw/IwgL21iW/2DWJeIMMoBu0CUpgHmKYDbhbGmgGHrRJCujwBbI2uJrqWXGfWqvTLslzw5B3G8SPpZS6kST+G1rvVPnYv79Qp0JV6AFjWspa7PxWWkq8LZvWYHPueUcdJmF8CojBwL+uYOoAWn7SS9ItJ0rQfj1iaR/8sr3ONrpmdXPtkajRXDcnjJKkTQL8Rq4OkOM+LtbDTO/ka2TPHg+vEcS/2YgMZDmtnMeNuALrRXKHXip3WXcbE55sSStaYlRJJujZ23ZWUzmblWgg4luk4kheA44UAS3catH8V552gBQzG7OLZPDN693OEbognBgfHD6ClrnelgxkALYn5ervVz7RW7fAr4rqCJrLKGyg388NMIt1vpcscnwkownNhMDRgJPaiDM9tWE3hpdVvxeKuqc6c+PggX8yABdZ61aCGJEfqoNaUdM3XPLseFnmgGIQwmyxZ7RdQKtlZi1kxsC6ga6sk+fxbbI/S5YzijUyr2001K8A02kwrjxvNIxaSnFkKa4891qAiFyyMrVxfzxNsXttEiqcGGGZnypuPeSxPHa81r37oFT2TuA8ZU9axlJ0+3E/Fak75uxuSNOWZdCxUFesA/RsguqwzdDlMAE9rcGH0JHNaU4I5LbN3WHJ4CA2Onytz9e7JUwnQB7N4yXzxxetZOqz9hgoOlmkhM2Td4FnHeDYB0PV8duFOQDF+g52RQCSeK5KN9dsxfozRO91iYVACktAowIB9t9WN/fCgvRXgkianG3jq/uSZwjjysEnTbSR7owJ8iFGW8nI1HNATKjYrSwoP21Y8PHmIJ2+YIdbp9sxaPANvKBri4XnAML7Vjrsn9zG/WwjQYi3A24p1g6KMJHF0VS5SdXtTch3KdSvPAPYxsLABwPAmk68WTFKt2+zxWgIGuWLjq4vjnhGGF8yz7BZIsZN13J3t/JxG9q8uhCk97JjBr+dd8cDKpimyesBjsWOQ13Jtg1IZev6KGZgdpzfHBgAC1hYrXWPWLHeT9b5VBYqmvS7tIWbG65cSIEX8wT/4B+M7v/M74zf/5t+sfwNO/ek//afjj//xPx6/83f+zk94/b/z7/w78c3f/M3xL/6L/6L+/a//6/96/NiP/Vj8+//+v6/3Znz0ox+N3/bbflv8mT/zZ+Jbv/Vb38UzqlGjxpd7VFDqfRg8uC8ux5JXsYlhY2aJhjsa0YL7gpbyF2OzEYqEik2TjSvdec8dp1w5TnZJthAG4OCz0hsmGVQkTVT3RFooVPzeZHCkX9++fafNA13eqNZlVZmNnQ1rSTidWFEdxQSbzYla+jZbkhJwLiTlVJ9haqgSiE8RFS+AkL43vSQi+AZQYYcVRsI2uh45CSCJXWD2CuBgSY26I41GxcSaClxLxqSSjnHw+NuQ9BbmD5vc0PdhTOvNMW2/SV5UCR4UQ+tox+XNRWyWg5jTzfB+KikInZAEKF0MY8qmGqN0jnnB3+tY3i0kkWjdXOp6IEez3wrVVaCCUJVvQ2J1PYnhqDA+5uu4e3Mai+Ey4hWSlJFYCYwbMqns0KXXHmUvmGgv9flsqumEB+DF8QAyJjgCCHIeMiC+GMXhbmr/CxhMZ11sshOVu91tlOBiWt9sOVlMM2ixxmBi9OngA+sHKdzuZJZMorFzBySxvrQ5N8PH3fvc2e74vZ12XFzRVtqbboGTKyrWAC8GrlLuQGe7865l9qzBE4yNOEyCUCWdZGvcGVvukhvrAkxRkUWOZeNmGGIGWMRSKKbgbum9UucuNsqAYAAEG7XQ9lxEhuRkz+AwkfJRvmc04d483TdH2WxhiIgBUyRBJEUkGYxlSiFybDPUtYhuYLOlDY8Zd7zYimF2snU6vZakoKqeF+8yJwiwzQorqlHAOjoDAgpKxuYkmTBg1omDTNhPrI88jmz3ri6HsBkAs+QxU/zJCkvOhvEnRogAtGKevVrMRYdCPrNbbmM+n0f73g0HAB70uSVpO/ccShZKSox1ZMyRTlMdIlV9Z10oP7d5N+wJZ6LqjrUzcAQAwFxIk/HsKmg5rueI/FHockVSnX5MAvcsk1L3wmKIrm5YZV1uNjnWfTxMYfmE5EGSOZGM8xqBPQZjOyU5J+EVS0FgM10dMfNpRG/Y0c/ns5lAJo+1k3b5yeHXBnMMqfRqJ7NpvkzdIzV0lhOZsebroeuScrHWOXBohoIBK8CI0OfZy8wm2AIqAdcblrxZttaM/sTSJTHIOm2B7pvdJqiu9NL7K6VNzcKWWO5PnjcAwpP0r7IcibWdZ0HraIL/fMJ7fo9wzH15DBoQlU+gWGAnIFijwTxiHgNycE272aJ+JY9GFhLWX8AF+9iZSaL1D9ARBhEdTwG/i3TxPFHmvAD+AGxhYgIeuwNkAZdpBJAFCDr7nR0//nM5r1LGBdjiRP0s0W+14uJy4gYgRU6dMjE1peiYEcYxCuAT+HhiSMszq3REyzVLxanCrJNBPev12f2Xa4MAWV4Dw7h0vksGJd0l6WgH0AFbTXItWLuArMjbkU+ukDfO9L5tywxedZws6Hh6K83XNujn57CU6Voq4HU0kCzYvmbr2C7dCZi3r2cGy3qDpb3Uhj2BLG/93Js6Z4pOmsNi1FqGBosVaRgsaeb+o9dedsGwNJxhjYDFntdZnl5Tdw+VpxwNQK760eyZ0etnYDEBpynM1YTmpUVKvVPzlxaMdXUpNSD6cDuLh+lMhusU31QYWWzi6iXA177A1jT7J5hbzz5+pz3AzaArkLFNs4b5qjQJ8DWmeELTC0vRbSTuQgb7P/tDURDjecfzio7DjEOThpk8I1W8Y14BDloWvtMe0QzrzSGi37UcFOAYViNzaXx5EY3yHBCoNnSHVT1nYd0h2QREbjVjOIFl3BWIrWdimaMUbABc2bskA/FLDI+Sn99P/uRPxvd+7/cef8Z9/I3f+I3xEz/xE+/4Hn4Os+o8YFb9t//tf3v8N9f/N/7G3yjg6m/9W//WT3sceFTyJ+P+/v6zPKMaNWrUqKDU+zaOHeVK+2wqnJh1pqkmvhokjoBXKXvJimz6GslMVhIn5yCZwD48nUan34mrR5dHvxCqddlBJxNVmamz2RdTygkcmzNYPGLElI1/tg/n7drsKsnexBoT1fR30cb4oA5VMFKo/FHFs5dRSxtBSV2K7wx/1OVKFi32sWDDTtJHy2ZaTw8uBzG+ehz9PolGOy4f0f2sL58oTIL7o2HpGmfvmfToYGNHouhW6JbVwDJRe+c08WRM2CgDNohl485LQ9j7bMjBuDCQLxR6tVwvxsvqdDhEkmbpVm6oDRQAMsD/hxES8fDk3sDfaBC7vhN75CmdvjdhdD+UvJFEtEg8SIrEYNBm0j4LZpPZeFxMgAbGrh35irzo0ZKR140xMjjiZGS5XMb6fqfOYSRNZlSQNDoB92vp3ueJpaoz/jrTVez2nndHFo8SebPbGk2DVIBXMjaHSTFfiH1CYru+tKcFm3zeR9dJkmySFLWbxpS8a+kDkdK1c6+QpPdLEtWks547LsqzBVbCEoNXM9NI3Ni0G3hAukE1eGFDVQAQkgOx0/ZKCtP4FcYczDwuBj9TMwG6HBZpi32Tiil08QpJgIq5wJwCpFG3wbN7SEBR+yTJIwmRHKzTjtkDhujIVg/RlCmuk1XGaXZnwJJEliSK5DoZEvjCAWrbj8vd/uQfsqbrk5lwud4YkDLjIoE0JDbcx2auGIQQACgkpRG7pf1qAEAtN6HLlT2e5ItVunClETQVda1nC0C2pSR5vclI3fAkEUQuiW9OpxNXH3gUg+VI9wCJp27jYswudmQBWFM2J6loWcN0L6wtuxEILkDL8zcBLWSuD8/ulaACAApkYD4xruut5CwtMaoscePYkZ4Y4DWY76YSW3U5Pa/641n15I2nTnBLpz+v5fvYPEzFFBIIuVoZIC3aLbF6ZJYN4ATgvD8eK6Aw37FAbrzmXrhWZ0N7pm0M7MKEEqPF11sNAOb2lRN7D8aE5I/2eco1nykLSN9ZM09hjubzpAB2gM4UDXg6lPbvMicuhRCxKgFIHl0cmZZHOU/p/iqAG+ByxlrmjqtIvAhk3iSraqKx28fDw1z3PpIcGXmz4JSuimpVP0CGZ3P/lC2+U/DM4p6mGQWFEEtHT+wlPTfp4gbTgnVLz4kTGCfm1HAgsMVArt8rELFVDNuLeTzXZr+/sN8eY0Z3P4DSwmKSX+N0JqatALp+LybMWbHMPLYCUGDapJzuDDjj805d3bwn4NrzHM2upfazQr5lE2itpQU8RqJ47u+TcswjmMfcbwBIG7w7Z3gSXH+thQ0XKjRzEugowIHkmMWbLRnCeu9qq66vKo61DbhfPrrwGryx9FZjiidYMdk+dlUtjViSVc3+Qcb0YkRGrLfrGPVLx9HsEAnAjD0Bz6dyzx9g/Z4BM5wWz2nmOh5RGGszxpYj48HWjU1/r2cSrGibhrspie9ly/bOCyTynyv7rcvry7h6dHWUkeZ5cO/lPQErdcF+bUvBwc1AeI2eg71XI37h9Xjz559p/uOFCeOc49QaxL2iogksJdsC8Fztjntmmi8plBxi17dcXMfIdW00YzWbx0yMI4Pu6kYIU4oP6ftcaNih7pP4XuHHeOAZM5BcHmkdvRWbHfsoirFUOMzp4acmGshsn03jycefSmYrtnZhBuccZO5b9myPwYOAels9qCkMMk/mnsz13alXXnjySTRQquvQPQHM7/d4++23dS+/8sorz/2cf//0T//0O74H36l3ej0/z8BjirH75/65f+4zOg6kgL/39/7ez+ocatSoUePFqEyp92lk1zp1aVLl3OacfuCHzFbViYxNpBK63nFzqM110e27zTbVW3cvI7GHEdBrskHzpvOo95f5biO6aiuMTKQ89JPR0GjF6Gok2Z86exVK+DmAlsmsqnzP7lXJpLqMLIoM1KaV9hpKtgjyA1XpVEEzY4mwebvbVluegmkmDBxvQvDomeB/0Gi4QjlfaFOl/Y6MiwGdXNGWlKpsrHMTqU3mAXaCkwv5ypTE8GiOzGYIMGpMEjR0p7FSec6NKKGqHRvZft/t6WXabDmcDOHD0h6SxkzixFjr8f2MX6skE/ysEx/4qlfFtlKVGu8GgKhiGpsMFTEEAA9XZgk4iQklIWz0Q10ON9HrnzZrxy5W260MXel8hW8X0jl1tFqslACTkHO+nVdKgqJEvEjm1HmvdCUqxyI2j9gCeButn2vRrJbW+IoAdrRJaO1BJekScxKPCIFOgC3NaIyRJtFmG080CY3ECmBeyJA7u4AV/59MoAwaWXIlyc9yqU50AGrusGY2yPQB+eNcG3xJPXTt+vbRKJ5Ybl0NuGeGgAy2uQ/oRjZCLoh3GF4aa0lVs8MR75vjdRMXBnxKu3R5dq3XOifuC5rKr6+Rm9DZCFmlJSBH1pCM4otcUYAOjArGHjaS56eqzchtZaLLvd+I6ds2pm8/ZkzwdGkL0LQPjK9bJhGWbhkseXEzn93t0lxY6qvszAVzDk8PAAsSo7LOCMgNA+c2a7c3W8pd5N+ySQ+zg+YLbwaY2cKmlLzVTA5JQAe0M+/EE8nc3CVtPbc0BLmV71WuCSByYXHh17YtiS4+K8xXJHMD1r1D9EsSbh80zztAZqQrSB2d5DnpFuOLLpIwIPFN2XLPH4o5cEvX8u7tW3VpRJbJXNHcOdAdy+wHJf5n6wT3PDUEy00YAxJBGIawBXxvwTyQbBcjdkyeka0xjtx/rCnMvc1U46VW8Ltx3D+7d2fSNfc7TDM6kbHeApacpNd8/5bnCUlkx75H8ugrQCfsJ80TmfhbTge7p9C5jveIuqay7uu5AdBwYv1lpKm82JTcxWVuS6LV8foI6HlKeg9iYfKsSJZesndsbm9Wh8akrM8qlrCelOt6BAXXsBrXan4wezIVW4M1fHs1OoLByW6xB4+bPQBA5WfzGQK4OU8SZViekpfjqWYJqoAnsZiRoHWLjG8es7v7wgK2VB3gX/5+8oRqykAfw/oF7NRRX2uTrnMXgKqAWeVZmpHMpZS9c3+lpDqBZMYTEI7GGnSHpJFBq9wjnBf3SDIztfYePD8FIkiSdQLsUoKa/9bzunRVk+SfecJ+gvtYXdwMRNFRjvdMp3PNIYoojDmybcBwHtCsv6whkv8z1wp7mbnNuqRnHHsRjLy5H1TYwCNrGMsO9yPn3YrOqBUvD1+KVmnUgIRNsldkggCFxaONpilHv8Pi98W1vnnpRt8PQMo9P2j1xbJUJ2D8DIe9aHzgkfYtmH4nkGtW+dl8K/s0DOaR+Nlr0IbwBniKIX5ZB2xu7v1Yk06vxz2PfQ77w4iLi0lsX97EZso6RlFgaO+rbicubybHrnkCMCly6Zk4iMarjzRPMXuHYQowDtinOSWpLixF+wMyxntJjLm2Zu5ZIt+IZs+yy5T92VPR3UUpavI8F3Nsso/FonxWuVeze6tA3ckgRqux7AokXabPjYpn7E33sTv48xn/o7VAE8+6RfEltBugGiIAshc2NA1OuKkY8/MOoTXeOWBeIfHDY+ozHSuYWufsK5hSH/7wh+sQ16hR47OKCkq9T0Ob5flafjVsrrK7C5uabo/2x6uY3i7FTGk2x67ik4yr49zumPiRkGkDXdg9kgVd4vNy5nOkRBHJjVkFByRVXftB2NdoL8mIumzJl4Mk2pvTbNcNaMB3AgIQBrgi+uOuNuVu1U513i3V2fDxWneGciKjKqqYFWZ3aRPJ8SBHA8hBEoIn0bXlcCnRkMHsfBnLh6U8J9jApseSQRMSdvsxaMNUOpqRSKlr3tlm0cbtZsYo8ScJB9yBWVJYVkilJIsAAGpsn+teRQeZzdpjoy420N+h+cNAKXKcrNRzThO66xW5Dp4XyO2o6tMJ6PLRlTzE2LzyXbCjEvBjQylWjr3HtTHTdcaTRqbFVD7XR9Ntd4gyiJGgGiyP2zefytC989pLR0CGa5zJL+9js2hJmcGL3d5A5HmYOdCMGXIhiq0CNttegSQjc8WTc6TqDDgn0+ARvlxDXRt3N7O8SODObC6ZyG6LvNIsh6MX1hkz6rgRLkwLNsyS3Wxa9peRt1NK8LZxjwS1mBFndRt2T7c3cOIOi4Uk47A4+ek0kYxSefbGedMwc5B/u/ukO1CRFCELAZxkQ881SoaJkt+5zXDZdPO69XwTw4utJYjF3yg9M8QMwBC6dDtU0jlbyLxajJiSLMqYtoHxts332fjb98MMQRh9KW3j/gaMZJw5vhzL89CYFkaG2INaP8xUSUN1/rbJsLtHcZ4GmjuqortLF0y+w/HY5m/fCsxALgoLgQSWZF4sBvl1bSTLdfJtTzySR+53yTmKiTFMNZmPH6WFBnUTELGZdzeWvK5ITAxKAjJvjwAibKtk6thjjDngtWA4Kp3VSPaLybLGtiR3HDPXIF66inbPHawM1loGyfsmjy50H+RxuZmADYjpktpsIN+xlx8sJ68/3Fsef8lWdM8imXXDA7F9sgtqWa/k9/Iwl9SZJNssDL8HSRCMteUKf54HmxeXLlgwxNIM2fde6fyFvKiw/QzYAKh3VDyQ55VYY5hJL2P11q2S8PQBOo8jW3JNR0sbm3PduI7MTeYErK9Dw+CoOriq2yJFFs9vdQzjngNURTqmbnnZqMBrrq59Ad3yfkVC9fSNp2JCwg6RvGu3ibun9wKj1f1OHoBF0k4TBZlol+cGUqz7hQC5Tr8tLyx1jdVTNuSXKAZmYRPDjAN4EviKfyFgy9oG6gD/XHeYHZcvX8f40ZXnVAHoWIpk1i8JoQG8Tkrm8GiT5HtzXJfd/e4gdjOgEmxTd+X1ekCB4XDg3nKHuMZxveSTzSgTy4b/wWbW2mlPIs4fECm7Ler5ib9+OZ5kMAnYZF0XCAwA0Tl+F79fLBfx9ONPzDz7ipbAd+TYkj9LEjfTdw8vR5LTATLxb7Gthz3tDbQGl2czzzd5j7GXaK21HlHQ4XnH+su6uOb8LidiuvK9YieyFpZnl73FyvNluSoMzpAUjTGVN2OR6eLntyvMOdYgAbPB9TVTSmCpOnye7kE1KkDfVtatHB+e4TR/EeBcvOJYizcb76mwswKkZTrTgRcT73VvpeOBgRm/6HhHaR8ByETBMJ+7lpgWya2klR2BUftO6YoJ6CRfJzdwwKDeTQPasVos3B1029L9dSwKyt/M+6AEI9sbvEGXsaeQiM9iaWoh+FrS67V9DAHwV+623G+1YnJBF9BBWdsM3MukH587GX8eYj/yc0KdR49M1Vms1/u4uKbBDo0pzKaTB9b2EPNbirKHaLH+fIl13nv8+LHm7BtvvPHcz/n3q6+++o7v4eef6vU//uM/Hm+++WZ8xVd8xfH3PJN+x+/4HTJRp2Pfi8E8y7lWo0aNGp9rVFDqfRp6QGMeOeGBbN+A7EizLGwWgBLMROVvwgMmfVlI7pCuYAgrI9OUAVpKkJu06f302J1IOv6mPT8EXokR4USfDRh+At6UIs+hs5UrrDLZpQMb0jVANMyJMVwmMez3Y3zpDjywmPi92l/L06ShjZ6MLccDbaQxBufzleSu7Hti8182Sq50amO9L4BR2ZCp60yyrUiyVvZsEgAkavrexseFvcOGSOCC/JP2saELTGF8ZKfCBOwEthRwTiwPuiLez5U4yDQ5Qb4CGKZnjjbnh33M7+ba/LNBsyH5CQBLBglEIja3JGI6H6qO/gSDMZ2TPEDXgDeXyra8u4rEQqCDTCq2MRh0YitPFKqKZtGcb9r4LOQAo/VEzA9tzstn8O+Jzt9AgUyGO22BRykbOJcsECQmgDnyYxYTpVQ4S9czkEK8ygBaARd7yKXSO2J0cTSBJ7mAJUVnxk7x6cHPpdHYaE7B9Mh24+nnYkZb6drVp+Odzd/VNauYfCeIetjNYgs7oYdnSBrx+pocJRbtdqzV7W8jZpI6hynp20e3zDuxkeiSNzeIou5QJADdthh88kXRPUFF39eS8+Ve7AP0qfPZTtK4UZEyqJMg9/DGQIHGYmaWk2Rvh13sVlv5j0nWJNNkb+6ZszDeSNYMWroLmJNkmykTzF8lyJIw+nq/09ojOUWjE50jw+5kCp3dE1M+stvRMMBMQ3tR7aPDuXTMhIIhJRAV6e8UI+22DdI7J3CNsZ5uZkUqC+PJbAkl2wCYBfBJBk/JrfVZnn9maNk0GybNIcbj0/mlp5WM/cu48P18N+Ms1QoSTOQkgJt4V2l92RwbRwDM6P5K2Sjd/64mpVMcDSjcoVHeQrAuRn0liEqGC+AjFo4A9dKivYAOAAsCIUCRYCLA9FR3LMacZJJkjy6fy+I/ZUN+sV9JoDf7mC3mOj5YFNePb/T9fP49650YUm77DhiDubVbxPt6qgOj1hp7EKZCM+VdNu4vHVwLS1Nsl9kqGh1YFICMJ6lXrjFac3TcsCIihhODJu5Qx3khA3Pbd41XMeVOiaWLLEVCK9N2HwMsO3Uz5di6lkTJRL6YuO+YP1r3wHdBBoq5+x7pMF1V7ZkjqTTM39Pst3yO/8k/rBR0CsB2lIfperC2+vh3JOvbndZIm/8jySyMzt0hFhRMKKhcOIE2Cwx2WulAyRxWMckm/zKuBvzeADgutHbKE3A8iF0Dz6R5bJYGWTgPJLo9+Wb1xCZKNqA61qb3GutKg0KGQW7fv1nE8nNNYAom2BdjM67LcyPlkQKkxKzz++yHxTPBYEP6YzWQOVIIaJ46hR73NfhNjc3UFhtyAIiGryRrVnZwNcCIx5iaFIgJlgC6QVfu81wMfG3YJ7hZgLpIqlByAqtVNMCnCkYy0vCt/TJVFCtNJNKfi2vDWsWazXkupyux0wcj7h8k+wayxebq+FkDAOX70SCV/AFZFwDcZ4vYFWA3x8Iy1F4sjs0OuvJU4ngkfy7Px8nVRdkNeD7lfi/Xc4AiQKjcX5gN5WYfSPIWnXksxfjFp60jBh3jpONc4fW1jgb3y4pmJAf5JPJsUMdGuueVec93AbCqGHYYRWNoiFYef7yn+NOZeV+67+1ctHOBy+u3xqVLs41Q0w0Ynkjn1WSG1+VzmD3fHi+sch37zP+hmZWSfVoqT3HlRUD8/R4Ubb72a782/tyf+3PqoEdw3vz7u77ru97xPb/yV/5K/f67v/u7jz/D6JyfE3hJ4Un1oucUP08z9Ro1atT4QkYFpd6nIdCgGDLLq6VsSIj0yKE6CS2djQAbqFMCyqbGCbc6ZZXNPV4+PNjYvJCk0e1FvjM3F5ZXxD6G/b40/a5GQ/HfCSzaUc7beQMiyUJ2XisGCmI+0PHmZnJse24ZjwENfq9/l418t98WZZ7qseQwpTOWO3g5KbcHDAkmXh3FVLuwaY7mtCVBFDOn11NyR+JuDwiSTvsluAMblTlaHDdjQ6cuEuji5bPd2OsIlgfpixJlkqliLNs+IE3i1PZKZCRdJFnS5m8TmyKXlHeS/stABl0RvRE3k+1FYCjvUFHwAeAAuIauoieQSLcpy9Iclhq6O5beW16bvkDa0ON3ooT2EPuGE5CsfGZ79wH+Ih9wYi7pGbLD0godpg6begNtTujE+lE3Ix/PuVeVE5KQnIg5RZJ82OP9UFp7U10dD+QxwUaXpEqyRZLjIhXDWwrpC8nx4KIXvfFABvhpwuouWe5yRVKNBwfnaqNr+610Bj1LA9i8F++UbI8ttofmHCwug0vJuhCjosyrZJbh97Ej4UYyA6DEPTlCJmAWE6+X6e0KVqIlKGIZlGthieIp2SHh3AG4bfdKqA7Fi5nxTIkswMEC1svSPhokFvgLcb7NfSM6RcbIdyZTLo2oLbXdH7sJdvs2i2YuborBOe+TGbWYRT7/lEqloTchpkS4sp3rB+fshNOsOIJ1R2uEWFTICt0pFMaHfb3cpYxrgaeI1jISL4yOzzowAkTyiawT+FMJbFTi3LHBLfMGYEWeekiGCnAkJt8hVhiiKzm0pEV+MjpekuKSzJbrBjgGaJCgtjqYAspu6aKJZ8sh4nqs68R4cQ+TqDGmAK8ef3dra6r7XpPVUSA76yNzQSDMshG73uY5JiVdGwDM0nBJjEAkphxrq7AgYe20W5I7Med223XMpjMlxkjb2s2WQJX+cCzQmPOkQxeJ/n6ThtSwFrx2jib9WC8XsaH74WigxI7EN9lfjAFJI+bhee0z8IBpNW1wbnmYO2LBRgNEMnPwEFtYNmfSyPQY0ucVLy+xYfTcKMAgXjij4dEnBtN2Ec0ARQuIYACB62VgNVnAus4CWlaxotsXY9Zry9+NJhTMF+aYiirMD0Ad+Y4BQiGJ7AqoE/uKtWQ0sA/Zch0zOpGyLpHAiz2XDUE8JxNkIeFvtt15jDmUDEMxY+TBaBZxt9uM5qXBbxdJkPxhwp3AYvEy23NPeh0QG0csLAygm9Fr+nkmILFIv1j/WVMBGPBdm99yLyKHt5Qp10vxJXkYHNgfwNgpBu0Ng31iMHctA+az06MrgdRzBnF2zjSLMae0nyliVauI0xbD9aVXHwssQa7IsWgdhIELe5XuejBfSvFHjKqjiX5Tz6b9weALv+O5w/0ollEpGknOjORz5EYsKRfTM1OgmOXu56FnW5HP8rc7R/o92fyg2YLBBvPb6586cbY7sZji62ZAj/cA8AIeuYNiJ/bH5wxMTTdrAZwR+9P8OoGM5q963W8jdYRhTPFqe1BjGMnwJUFnv2JAOwGpLJblPSrgjmshEF0GnDJLpxkFazznIP8xOv3R1bhzGQP5Wu3lUyjzd4GZA93Lp+IF4N1Slg1ps8DcU/OUNSwz9nHd43UQazT94yjqLJHlwuz1XlVzih0mBabiXYlfldcGM7Mk+U8z/0ao4YxktuX577Uc2WRD/lHNAmCdNzj4Ugpkc7/pN/2m+Lqv+7r4+q//erGZZrPZEUD6J/6JfyI++MEPyveJ+O2//bfHr/k1vyb+wB/4A+qq9yf+xJ+I//l//p/jj/7RP6rfP3r0SH/Og8IMTKpf9st+2RfhDGvUqPHlFhWUep9HtsQGGGjuqbrZw2dwMVbVi4e2fExKq3Kq/dmuGrmUE1aYAkgBH/QapBtp7qpOeWycFnSngU7uhFNeI2In0OHG5uiAIyThMJ/EElkuVcXlM2nLLbPbvtsQk5RRoV/TPa/ZksSI6uuy42ooG5FMFnkwpkeTjhfZUPFHOnYAgwpfKuZURM8ZHQlMiY2x3Shh0+a1bGIA98RIoIsO1cGtmVhNfEYGVC7d0luyNjZ0kpvZjBuWkLtTuRPNcjbX+F1cjcVUI2lCGiNQUJKgkRKwBIqguBN5nLmpzNCGE8PwwnpyJ0Qb0ibYwHgcio/CkaVUtrnJXsjPtVSJMXJyrmoi7HrJB0tVvnViOakbFp5DtOMWS8CbZm3eA5kRIFlfAMvD7YNATjam7mjojbPleSFmHECOgUDAvENsYGoVKZJamDcbktbsDu5iRdXcgCleOzbr5vh7XUu0YDSdOuqxId0/l+Bwbmz68aRRW3WqqAKobFjNvwG20hOHaiyyTRvsFmkdiV/pTpgAL3MbzxESHsnWCjNGUsvCnAt1GYNZYDAwWXJUpGU0fSiMQbxmSPYEdoY8NlTNLiwVjgXmB8mv57eNrvnDfYLc6dhOW8kqBttzJVXDq0n0BlTGkfEsfd5IPEYGafl+AmmF/Yxcaef38nNR1dnMngZsP9h1xfw/WWgExwc4xJpxZGaW13G+Nv+1dEPJqpLpluS0AvxgXnV7MRwCaPi73UnKkg+zQOjq6O5UYhsVSZkS7CasFUy38F5bmlnQ6pTOjsg2h0f2kACz/gk4tAwJlpTng+6fs46CljXCLmMu7KKJRA6Aezf3WpQAsBoa2t+L74BhhZQl70FJ8Zi73C8CDnyfuwOq5wNyajFMdi15BnH8sF/ECu0a+GqKTegkUKAbxr4UIMbF26gk8MmSYoyuH10JRGGd555iDnF8yGNhowAE2I/LrFDWRhtXe+1MNlJel1yP1UUy2bQcu6Q3+C/BmMXnrCVGEmCcDda9Dqurl54vJx845jPsKK/7BYhnrS4s1QRbuHzq2tZqCExaTtfReTQWGw8Aj/EYjP38O2yRO63FsuntWVPMFObeQnbSbm1j10FuOHIHwAJewHhslPG151VZi/mf2LbMU47djUB8P5y8F1l78L/iuSFpV/Gm82stVWYcWIO46WVUPUgZ51bAMcibG2E4JD0+69i5awPgwUBBdgwL1QwR3St0feUZjkTvEHp2A8rBGkug2QCBi0MsR5w7ewMxkZFkAzKwRjYt8eI65ecb2PVnMDcBMFgjuHdZtxPw57ORs9tjjLnOGkYXx/SKdKOWPCf/RykEAdpJkulnEfeBJZC5B3HDAtYCeaFxbDuYtZhguzeAvNbC3TbTC1LXtIDFn1DoG1pqy/4iJaraPxRwg+vC+i8ghvHt9sQslNSMe63BvYiPmZ8x9kWC8RjqUOf+Dz44PmPFMwb2NQ1D8DRUB02a1PSPwJ+9vNxV1J3kXHRSYahRik3lHpUPY/lvFwVdJMv3nPtdMrc6XT87ud97m50KObIVmC80Z/gc9mxX1xeey8is50uZk3OOl48nR1BW84iiyXSpohPALs9H3bti/rrjq5rAADYDwJW9Dl1A1UkZyX7ZzzGeairSMticjD11D4bpDHOqyEPdZbLch+VehEZ3Xqz7Uovf8Bt+Q7z11lvxu3/375ZZ+dd8zdfEj/7ojx7NzP+//+//ew6Q+7v+rr8rfuiHfij+1X/1X43f9bt+V3zkIx9R572v/uqv/iKeRY0aNWqcooJS79NIMMbdYyxNSwo1Rc9OARi0UcAIWptRV98EXJGQCRAhMaZK7YSEIHlqH9zeWr8TEAGIYllSVki1+W42VOHusXkuraJJpLRp5HcLd+SRCSWbcAwxi0eDAQZ7K+XGCEAr2Sl46vAZHAfJqbxN6W4lwMQgFElIyowkYSxAQG6+1LXIRWCbC5dK736/tLFroaI3S+JBqOMgVP+UMKna6M0pbaTxDsJYnHFPrxJ9JgBGMSBWd7jZKma3D2aOcEyDYgir6myRDJxtGsxMcMU5JT36jjPPGTNESgc2Gcl6k+qu2KVrFpu10q5e7dszoZLJ+4mNRUINIMD5Ak7kRl+JfsevmT5M49mbt96wj3oCJdW6XEkV7aAPAhwFnqzwZLlT4gHI2E75JAwPPFWU8F2q651a188WTr4OSAva2jyryxGePsVXg2OmS9kbH31DCeD142t1P0rvHyWnTQOsSNlgDAHqQNlXsoBsEHPnFl2l3IUqDZaTjXJoNGN6dy9/Nlp/A+RKmkGSo65ZpVX8saqubgHP34eFJZQbY0lbSmXdVfFiil5kjKQLzHVtrgVKbEsHyYjW0E0ENrFW4sOcZcOechiSk8uLC4Fm3JDMM8CSwWhow/8D78OId6cE3iw8J5B4XwnwPUpXnGAS6qpVgFoYSYSSGeZFYeDp2kuiQbcyrpFBQYyTG0W6mcHnA9ypks26APuERLOMI4zO2VPak5tJwBrSffla4/lwO1UnSpJKEvHhiO5ZJ6DoYefGBer4yPhlK3rMpTfNmCPHE7PKjAD7ufhczs8rzbLVUU1MTLMyBIjBzKFToTyoMDvHF6hfOnM2YyNGoEEUjhGWXLu31XUVgxJpkz7L14B5pMS4iaTXZscC1yVDtQENDDlL11KKU9gGRSI3HA5icwFLgSYHMKfMbgNQULfUYq6tTlsYcQPQTAaSbvKz9HmBMcf9y/0tIK3XictXH8Vhi4df1wbDMPkkkynrea4bhbmof5cdRB6jOqaqY5dlUmkKr+SzgOPpO5VzRfNNXV4BKwxYJhsm5wrnaYman3fpF0jB4jBQzz+DyOq8Zg8x7nWeX3iMTR+QYAKCW/4m/6VOU88ngyWA8nyXu8SeG/wn6C12JfcFzxaxwQwyZXiN9bGKXSQmrn+WbBnu9WTXqkkFxYIigT/I3P7UmTTngIotBexKQIjrau8zXxfYoQK5R8xPN1rQ+0shQ3K2ngHYN19/S7I7/PTU5U9+Tzz3fC9P7+Zi/UhKPLR0nj1DY2+ANaVfrDsAkOwXkPqzf7h+yeunxqisvRRq3ITF+437Z1MBhXiqXT/ieXDqSmmmpTv8ev1sFK/IYvT+Qsc/pOtiUHuw7NW15zlp0EmsIj5Pz0yPpxg3n0TNxbFnx1PthVSYMACe64X2HcuZzdsBW3nOws7jGmtN5zp6XrsYdIjZs5mAcnUQFTDm4xb4JaZRgq67aHWHLhyyf1qtNdZiEu1gaxfGL8wrACO6W6apfyvn31p7LYFkWZwpjT8Ek+nZ6TXdzE7k0if/QPy6+Dmy6l4pQMpTbLGOFSb5rMtaj7ymn7PS5RHI32WvkfNzV/Z5KhJtDCDi+cW8wMMwO3jC8mTdxyPKXnBt7x0LAMrPsvBGsA5uVvhrmW2aFgP5GjcE4ny/tDylMpDqfTK53p//83/+E3727d/+7frzmcY7+UjVqFGjxhcqKij1Pgwbr9pUWYBUYbZk5fow6qvytMGsk82D/Kbo/uMOQJLPsFGW3MU+KiSN16/caEPAJmo9dwchdS5abdWeekRL8OKzouqUkolOXL90Je8UJABiUqXHyNjm0wSvZVPDd+f7mi3arJPUW6ZCxfrYPa3jKi7nOr2bxfTZg45LAAhMLDZ2fCaJORvMAgyce+AkQ4oQ4CUKOVXqdTRKB5/0fuCYAD22qn52on2DabDPdVMYV2YCtGXSCasojeVPLAH7ylDdE/ggKZS70mSr7c4Lx3fevejoy1H+djc0NsO+5vpZ2EAXkC1lcskIy05e+YfIznCSLpQNatEPCrBDyrgvFdTzBCuZVZL6kdCTtDG3MN1tdGJ44STLlWiPO228SQhIeNgMNwB0xFZwJV4JheSQlswhQ8IwVp37iuxDXagKOwe5JB45T994Fk8/ei+Pq6tH1zJgTmP27LKHbIj53lxT7bWPmiUqe81fdc4qclcxQUgIixyUfbAMqtfplVN8uSIT4BPzh/kPO2xQuizqXmAOlmRHYFrjNOeJTEbVPRC/MzbbZTxPHhsnDzIxdg6njolszJ0crWUKTTVbm+8W3ckWBlrTKBvZ3gp/Le6v/hFIkywIeV5hXMEAPM1DTwnG4Nzo/rimyD9rHbdP7iX74nswU+/1x/osHWuLZMyeZRyDgaAiJZaBMCBBQ/KwDHX5k+Gv5YJt2HWNECCFCTXABRK14eRRYf6YaQWQurifxsPdTIwwjNENkrejUzoj3r11V+YnFC3kuLARDC4CeFPxJ9FO1ieAHGvh/bO76HTcfIHvggECmwjTc4QiuV6sxQAksYcZ5rGUHGq5iWVzadPxIs3NEONnBzPM/mEAn90+4B6sxb1AMEA0sQwLiMzPaHPPFcInTIDd3VRyGwZ4sVjE7G4hHzHGE0AMPyoSv6dvPovldBmTm7ETa3xs+p24vJyok+P0fq2ufM1oxuWjCzVOyHCnQANu+NZJRlXYFySCAFqa89lYQKwSgKSu1oFkZ7oTqOXc8+2igDNeDxNgyPXOUkt3TuRanYMDnJuAMJm+n+SO8mdCOolPIu9j/VWzDSfrHnfA17bmCuA1jDl1N4RZuQF8s2SrPfCan4BbrsspTWQ9YjwATw9Fbn3eZZXjB/Ri3gIG2di/Ff0R6779fAwAmwnMOqbnS2Ef8Xzwc6iwgUoineBdrnfMG+SAZjLDDLSPnkzhkUDtD+5+W+7dZOJx/e+f3MWT158J6Ln5wFU8fvWxi00AN/Kgw99rpa6+rHqt9kagr64vy7fAH+PyltHuYrvYRbfdiUbP6yWvaRRQUzJwPH3UaEUPaq1XG9TZBRA+fyaeN/ooqJy+7lw6nCzNBOkEfjOfEswD4JF4s7wWH02kdGU+ZPOVfKbmdbYXVmFTFTDRssPCtAZE7nQkM2au0YF2vbAnEs8mAVKlmJJzL9k97Be27LkovghAMbOn0Wu6QybPsQ2dOX3vaU/Cfadjs4+c5IbyxDKjU5Ll9u4Txka+X7yvAObqTKex3sTyge6uDyoA4WMJM3NfClj84Xkyu8MgvBGXNxdHJj3zjWtFYYrrnsUMMSrFYnaRjHufgp2YgWeNZvI5qPPcH2J+fx/NtbutYonQZi6PO9EqHmhNPXJtbL7X2uKGFZqrZc2gqDV/WOqZ1Lp8Hhw+eqZRbC2AbwLZNWrUqFHjvRkVlHofRhpgk2zR1SdgglBpLpvYfPiuGmwGXHU3Y9yVKjYtBIAVzAk8OWSu28eDql+8HNgIsMU9qMOXKo+8d+SNH4kvIQ8OZDFFYpcbev5bMqfFUjIGfm/DUne5UptfvoMPPZBw0BLcSU96LJEI8nkzpEj4bbRoSU7l1km5zEL5Yenelp2DsrV5Mo0IVYrVnQd/BBhYZkm5A44H6GhYW1pXPwcqHHyrwJTIbnNHvwZMXIu8BZ8DxgfQhYQ1hjYu3S5d2W70T0lqdi9CnmemEW3Pnby2+mWTJdNeU/q1WVXHREs21b5bhvP+nHOjXT5LVX9IGDpOdxgk+ei0DLLIPP44RmZpvWi0LilG8Tbh2GS4fDjEoNuLGEPNT8lbK5oXDVeCMwEXDR9z5tK9UYbJxSifMVYXKMadreiJaWQvH8xd15ojVy9fBzx9kmMkXAmuZWLhbmJNgZVK1Epb7kw6zguk6YWWYInYDKWlO8k8LA98mzC83S3MVBKjC/nPsBuXN1c6XwAcxjjHJq8DiQ1Jx3MSmXMZXDHbTkCTUCLUailJSO8mgUwNyxCbBWxljnUHjJtBWcLAlpkEjBUSSt3LGDTvD7HBLLrlcZDPkbpEMY9PoABjx7gJ7CneN+rQV9gdvI75PIW9BBtjwpzwGHBMJ9nEQcwJdcSkcxvyzNXaXQlhpBzoBGjpDeOkDneY4yuJcwLGd3N+E+Qiy5W7zhXwNkFSAXHF54ik4+6J2VaSHY6RhTD3kYrs3QVsV6SL3EtiXa4EfNF1DlYNc5w5AmiOL9MiVnHx+ELXj6SHc2dNlceVKv32vusDSME0wThZvmVcY6Rg7lLF53pBclIrMCUr/Oq0aEk19ySJIH9gUNFhCw89J17zmN8t5OckEJVzUVdSs/ho2gCrAUAC0GGBFG/Ui81qp5+JRbKPeHhypzV7wnmN3c1TIKRYG0jhzMywYbTX0WS02h/OSTrgL55mAKRIGDdrG2znM6MRY0l28md8J+B0u9vQfzP26SvD9BMTRGxDA6PMQefgJwkzIRPl6UIJr4zIC4B+XO/o1rXdxOSa73d3uPOwn6LlWIy55nh4vdqog6plurlGqONgMrtK4wHuHYo3Yqd0zABLFpI6+tHhdbaQhC2fdc/eeBbL1TouH13qZ9wP7gLKvWVfQj6bzzSA52dKskQBIOHuwXzmNQmSWYLJ2rGPdfHDGl2PfU8yD1dbNWrwulEMxmEp49Wmjrd9GZ4LVCySePsWUnAY2yeNuVTYXowB99qcxgxiZ3d0P3Tp/Hgx0nFz/3N+kh0XxjRFifRrs3S3qXv74uby6AV0vjaLWZs+Y8VPKyWMRxl6YY7ls15m2y0bWuea22gUYFH7BEvk9qXjaHprirUJGFgYb+xXWBc6xXssO+TxzMIxEgYmII4YUt1utG8MygFU8UzQWl4ah1ApSxCd+0b3dSlq5HPa5wJg1dY6tN2uTk0xyliI6cV8HaRZuwFQvic7CGfx7cg2073sIqTk2L2OfREpGNAUB9npwOxoS5gL00rPU5vq4+nJ50vCx72IvLNLZ79hMVVHhruJt5891fexZmt/hdwYZl25f3l2UlTk/FgX3ABhpnsFj7IujSxYW9U1kfVsI+byOdPJoNvJUiD9SvUcHewElL1oZp7WBnmv5/PjS9VfqkaNGjW+FKKCUu/DkGl0qcy6/boruN1w23nCXknF14FNsGtQx00fYVPSdsQMr5kiW+PB3g1VFt2lzi3J7duwLu3jnXyn1EfHVCRA6cUCkDK7nyqZJ9nDLB35FptfSeqKkafZWwN93znFOg1r7UPQ0EaRpCdbi8u4uiRMlghgyOlEm4SPJJRNizbeJWkkDMI4YchqH5XmbBueHeuyCnge6TOU7IDceMmPaupEme5K6UPizTgMMbPa+JmNdT2mKfFSVz/MfOkoSJUZZhtGrGw+iwm78kQAPJgCpeV9SkvymspMWxfB0kaBkTBM2CQ3ipdIYcbpD53tJmwmbfhraSNjbXPWZMlkFzUq6BiNk6TDBsOE2JvxU7v14kRc2lC7vbzAGhg8KSUribi7Ep3mUF53MzIMNnGtACdhua3nSwFi2VXv1LGsbWChsCjyPA9Ns9kajcnReDfNm+U9gxxrTOLWim7pEMU4rKbzuH/7Ng5492tOW26oyjTtsZtc05U9eYZO7jhuNt8cN0kXcwtjdr4L2ZauFYl7SSSeY9AUn5NMVFLGeWTQ7fH1wDDZ1yUZFTKaLT5YlvEZBKabF0y65sDzpVEMiwEChxeY/vY+YcwB4ugkZ5BAd0HEzgAUyQTHTHt2JDQG3cwgSA+tBMrl0yUfJYO2Zk5E7Bd0LDNAKIkQwMZqFaOL8ZFplGsVwN3kchidly8FqHDvcG5Kjrut6B4ABdrR6nqM5UsHcFyMzfuDYcS1wWQB20j7SEZhshQ/I3W9UuKPbPeg9YNzG9GIAfAPCRu+QBeD0tAB5sLp2jA58rwTzAUEINlTl0/mPt1NMewtYIcTXN9XMArMUIHxSSLZFtvUXd/2MZ3OfO6wueSfQsLlcwAEYK2TfGdoeVo2UIB1KOD6sBfI6TXRTCfud2SerI3MJcB9vIfs9+IEEiBCn1PAadZSdewammVKKAEGNNDzxd/Fus55SAZ5Jg82+GMpWzJyOVcVA/YUREh6i9l/kX9z/tmkIb+PtV9gbPfEcDkyQvFRQ/eqn50aLGTHziObZmiwTMlpkVW5e2s7doXdYt84pNgGMsQclA/jSY6bvloADgJpi+ScBB72jO7TtmVJ8hXTs+AEoOU52afMjFEDgdkC4/S8oeOdJJg8d8s4cXyT60m5PjCmbKYuDz9kwHuKRZ2Tl08BLFjf1FnxlUcyrhYoUSTukrBTKBj0yvNjJ484ijNHIH+1jvUC/72TnEvdLMWWpBOfOwnSVADwi7UYCR9zHvCMNZfrS7c4ju+c0avzVXMAj/mgyPhkgs3YF1aa7uHCzOl3PHf13FL3XT9bs/ufmc7eO1B04Pm1xfReAAtdZM1CzXkCyw2Ar9GwKfdR3pudBJHcwd7eAVr6mmZRIgF1usVtlu74ywsExGlO2VxfXTzPCj+59qc8MGRAfvIRy4WD/QEwf+49xETPY+ca0024eIt5b+a5nH9zLbatbYxplKLmMd4rsn5utvaZ07OF6806j9k551k8JzlvFa8KYAvYr/cik4b5iBcX7NiyHp4DaFobCtDtvSPAvc3L6RC5Q26JhJB92bl0snRyTba3/E2LNF77o/LMPJfNiy1eGNCe141oM6dr1KhRo8Z7Pioo9T6LrIoJNCkMA23Ci3wrN+xp9pzgi6VXz8vDspsMVP9zRkdW8dmYkgBpkyfmkVlJGOLKc2Dkz0/fCwM/JXGDxYS3ESwBvBBoNU7ClnU2vJeKcbS+W74qp2OTFEbJoDfr8kYun58VSBlhwrbh36UCb1DC7wcg2ZYEnuRHvj8YSMuk2wBVmhzLyBSQaumNsVhPZ9W3BFYE/BRpxVE6Vww12Xidm46KRYInVq+tTRcbNhJCgVL4XZRuSWKXBebtBTgqHavk91HaN4t5wAYcD4j+8zKTrKoTbCTtu0DFHO8n5F2WJQDsZFIGswDvEL6TqrDGAi+XhkGfc88NySwKcwAJCwwWAYNFNpYAY1YlPQZOcpWwk2iSxwdMnIXBPgFeRU54FmlUTnLj+e3NuyrMo+KxVSreec55LfKaak7SXbAApNr0878C1PEZACzMYYFrYjVYIqQW6dwTFxMdL95OsIJSRufEuRVrgAeNhxNLqskysub7SZ6KTwjZiMGlAvoWsOZozl6u33kF9/yaKrkGmKDLX/OUyNFtDYCQOXJ1c1kSj47kcbCduOa73j56sED2mNBPlexM1P3QG/+sIJNccH+YveSunrT2hvWxLh0XSW6urie6//F6I9kMvq9lQ+VMQA7dBAz9vZnoAInDuiDMunqQNI66vL3dfJ8K/JPvlNc2Yg3rEpaKGBo9J5swu3a76PcBIumyhA+XTZ0ZW5ute+0bDMZqPqD26JgK0+FrQJcomDuAjIwFvmcbAReAqZIUNfCJonuZvVjkm0NnJ1hpdN+U/HmjudkOX0P80pTEpbfN2qA6ElYzRcwYYCzcqMFgLmAUUjI+D+CIL9nTnbLfE/NAUt3SeCDnevocIaVstUmYO7FdI71aRaNNMk4yBrvKvlgwEPbb7MyGmXIBW6IZyw3rUknq5NN/kMQRhlXKhQAzxYLY8TwoTBQBzBhi23crzfgZZ94DGCBmY5Fl7UoirW6aS5hpS3vJlY6RAKFiz0i66HVGJswF7KNpxLO37mRIjezJEh2KCmZ2JNPLoO0q5ndzrRcXYhEVKR5qPRmqFyZGMmTLuPp5yfx1N7TG2kAZ5wfAnEw/szfKs1XNNwA/PI9h3VBUYf7Y08sS0/wO1hmZNgME8XPNNz+DxTgDTOH7YH4CLIrJh1zMn0nxA/QJ8DSLScdnRwEPuX+ZWwOYjayb6gbrNVDzqQBzYsc0ATX8OR5zr1nHZ7GM1GGndK3eg7FHB7XiDea576Yhy/L9+XyQf1Y5H823xgmg8LifzPMZE7F2t22xaWa3U3VDRbKcTB6eXerOKO8w2M9mwSVALNZe8bSUBBqWNuuFWEwwcwGlYIJZBq4mEDQAaDXj8vGV19EioRRYhWyaNWlf5IHJvpWkzxLkLt3eSoGErrJHRpvAMs6J40sg/ySNtmF8kdizLqmbcPHaLPNzPp2LRbkedOPq8Ulim/sMs2tzbFYuGg3dUOYory3sc3sz+ZrwP3fQ9bHrp3pWpWdoK9ZiNttLLQth6rIYGPkPdH5qvNLn+rgbMJc3jcfVVXUyOD53bYZu7ynuF4DK2bO51qhemctaH1gXObci/+M96oCaz0kR/Dzfk60ogLPUUzRH2QufWxxUllSNGjVqvKejglLvs3CS6sql/CfOPHjEjhDQkpXX56uzuUE5lxap69eZb4W63qjSZY+g9BFio5EMDXlxSCJHErtRxf3c4FisGQEV7bi46KhCyEba0oLtsUrmTlgGwjJyMyYPoGH/JM9qXhyTCld/XVF216yGPAnS8J2kU3TuwjTR+MjXiCQdrwU2KMlYYXdT5CFbM7iUXJcELTfM/E8gkej/J/+m3PAwVmxcSYaTOi7PHFg43X606ChUgB2xhwBrykYxGT9pmq4K/NGM2UmCr40TAG/sTxvkc2+W7EQo0EiMHps1x8GgJAbmeD4pES5djXLD5m5ep7mQyWN6StEquvkKcoixjXThmJTP4tzTO8tdvywviI0ZZ62+5152q9L1KJvqnKEJLomZUc5FrBNdBxI6e5Hp3JBQYURdpImSYOLjUmQEOddVVaeqXQCqTEJHAFwkEMnyOwC2kPStJW+4eXxpkPJM4qHP475DUoKxfgEMSQLE8Nluo3dh0IcxZQ52C1CVYCCyQV7POEvlgRQSieRZl6289smGmj0s/Hl4aSnptg8U0p/Zw1RjdHF1oe+9hEFBw4MiX5Xkcoa/nFmHW4yo26UrXrIQ2MuLHUhy6msCexAPKQEinW5cP7o4q9K3YrM/SUs0NwGBUaEcmZqnxE2AmQCQiPv7ueRn8ufqdsWkvD3cuYsjUuAu8iF7rIglqATHlX6ABAHvyHwDZhhdnjAG7ojBxn+T+ArEUMc8IaHHpEVgK6An71YlH1bSQRJo5siMJP7wxJLRx1eS6poxRTK/LWDcTgwkvhMZW7LXAOAW07XYfErWig8XLEndn0gJkbDKHLhjKeFyFfvtIXaxFzPvjY8+Vde3q1cu4+qlK0nKWHcZf5Ek0/S7SKdTBtftG8x1l9CdOqEyr/sjg+IY4AMobObzaHRb0enYU03XqjScQBYtb7/CTqWIwPFxP+C1xOd2uvam8/w2O8xdRE+MRTNPzY4VuFHmdXovpacXf7h+gA4DOhLiPVfWG7FXJGvj+yiaWP7Nir8AAIaFq7XQ7LHVHHklzyvuI997t0/v4vbJrf774mpSCiuFdcr6VNhYOuZSBIBZmeupj3MrHyDNOZJf1iNJ50rn1sHJv8/P4q6ZT8tNGauOQE7kyfakctMNM3iYf07EAQEYs+WMMS7PrrLmY1CvcRYoCtOIxhQ2nk8JW8qvvN6VIotAReRgEb1dX50EJfe+LDJxYaWnwsC5L5HnlAGCHAue9UjxuMlhqbBGSJqJj2QymPkMdUnjs7JQ4CYWnI+6hJZngzr/iupc/CUL81vd1gRG+7mi9XlvI/gE9eRlxfyg63BzdwK0xaTC08n3xTkgA5iIyNAFpWzy4DHebgA/S/dVdXs7Y+npGPysFVsL/yN5JXb1DFvOAbYXusfUAEGeVgY406rgwCTq8Gyy+XweE3NS4KUKTQajkkV7vm/TNeh11aEvzdrzfMUqLNJUWTcAYFLAKAzn831VPn+Tkf5iMcffWUDhwtij2QCXSYWu8po0WZcVAoWy0nDD7G+DnTmXkqWVz/D9zuwtql7M/c6jbvF3zKYThe3GZ6rpjjv+8Z4Be6ss6Kh7q68x8yA7qarfYOkSmpJ0Ci5Z+Dkf1xo1atSo8d6KCkq9D8OVLSfr5z9LGrP9ONggeBOXANT5ZkayPwCDklwfk0mSGTY//YOqhXrPkM2MTdLzwS5J2N7SovQjIPiu3CSyQWfj0Lv0+0QFL5tUVQm1+SjSjTQGLVI0bbLEkKFT016SwqNvD8ahyO3klYB0DrNLs14SKCI5zY0u7By6E7lrkGUtoponSNF1oiQj9naztKr2OeZY8bc26nTHSsp8oZKbHeNuM1m909YHwAZwq7lRctYdFOkaDAl+Lu+I/XOmqjrmdv6bDZbZK7m5+1SbK4NLz/9M5tO7dtmYneRyqhKXMVDyQrer0joamaYSnXKe+Z1morXNeCs+Q/IbEyDVjbYUX06OmUls0rkmsF4ACvmOrAKnGbDm6ln3ngQBiXa7mL8rdzH75lhFFShquYWuH+NJklQ6sPE6ydkw6Ue2UiRoOU58Bl4vJN85nvJ7AQiQx5K9wnJuJjNG8i+ADyQL6uRnSYlNs82kev56FA+MlucFc0wsQiVipbKbrdCP3fy8qSZ5nN7PYkUXymLAfzhsdU/Ikwpw6AHPjrkSWVhdKe9zNzhYP3Tga8XwauzE6+D27XjO8DvACPlqtTfRwEx6ZyPl5f3c3jSSxxh0y/VAny/mmOelkne6KZ15ZeX8TAkrf/G9t2/eCpDFmJu1ITtOrZbLoz8TjCfGYbFGShNi/HjemgkodqXuPRzqbQKcDE+YAKj3EvCGLcO84J6WlV4zxDaUf3HKyrbINGG+RNy9XTzTRvhBCa0rTCxYK53YLt2NTu3It76XJN3iupbunotZI8ZK+Hi8Agq7UUS/46YUuudoq34/jU67Y8ke6yLgbdeNKThf/JNY62BqNGAKFiknMiMADrPQAD7cIVVdUkvXVE7UyX5LjAkKFgBUXYG2TvolpSzyNs1/JNqLpb3DeA4M+zF+dKHvAIRO0NwJr+enwIUZr+2pUYW7t80M4Pe67tQI4wmgQ55+yMM8BgJxWB+KZE4S3dLAIwpow7jyOzXwOIQ8+yTTAZgryXJ7YjCg37fsinOCRfj0o89ieDWKl157WeCjQU430Fgv8VYDjLGxOPcvjNfnohQjBGizZosVWaSq5TmTAEayhVln1bBhNBEYxXwU+3JjQCPlu5JH7X3d1WkWaZsAE7OWlZzvMNTfROsAqIP3GVLhwRFAWm5ZS4rEUExXZK6wl+yV52ebQQh15S2+iQkS5PHnent+3hSU8h7WHoBkv4C+bmRiz6d8fiVTBQBcjQ66h+g2WAvMycnnx3YLaGe/Q3lT4ofGc1dsG68rboLBmgPY4eIOazPPjLzHOVfmHpNgNB5ZDlvsADDuzkLA8TlYGlwcvZzEgvMa6CIa52eg3kAc3n9d+depcQSdTQFOi9+Z5iDHQdGjsJ1YI7UeFIYPc0YgpmStth/ge9KwPj0pQZxbHfudcd7poZXsKe5D7hXWY5nyH04NKXiuJDNOlg1FAne+Pzj3+tQ6SmEqQS32LWdycrFTdYueOvcKKHyhy2SObe5JEmQz8+r59Z/XHL3X+pYynhclWV84t3N/MY0jrFqtH17rBKRJIkhxaBPNg9ciQMjje858yQRK8kwzhl+jRo0aNd7jUUGp92GcV2lz43DuzaOqXqmgpbaeJ3lvUDq+FNo+CUg0CnBw5nHABh2ZgNkMbhNNwiLjTTYYApcMnmQlnNdgSM5r1JIaqU4TY1xT/AVoqfuUO/9po0lynuyYwiQRc6bsTVJueA7EHVrlewtYYCNeV2g5Box43fHv5EGR48JmFs8dJGvbdQebJVUxtUni2NgUkfQWTRoeT3y+PBRgZJCYcloJwBUWkX1/nLxk1VBykzbAW6GdAyoUfw77V7ARt8+EGTlU1u2jkR5hGFTrWMpG8tzM1FV3V6nP6f7PgVWlk5wwIr6rVJsBW9iQ83PJSAp4SBLFcdChCSAJI1KiW6ryTghO5ycGEt/fNQiYhsBKdpDdpZdJMZY9N2VVn8a2N8mna+w5IC+xAtBJwlckS+nnI/CwtKUm2aCC3AA4EVDh19knBIbDJhodjPEBlUh2AC97msMwXWAowGYYXw5VYW40bRpMYrwnmSjMJFduYUqYtcD/AQQlM435DqCTgGv6W2TysaHzEcAF4wPQSsKlOeFkP1mLAEIyS+8jizB4t93DwGsJ8GsCdBbxBS3dSYBIaOR70nbikeCx50SIRdjT+Df0OhAKeZjoHnK3TIG4AoJ9bZiLw0sb0+oYs/J/ZHF5/FOamGCrhqZc41MXrdP1Fdgy7MUFXTQlg4KV5bF93mg6AV8n0scp3Xb3SYPEbTUTAGxNjy8AHOaGuqsJGAco2snXSMCdGH4AziSqxdh3SWLWissiURG7Y9jx/C7MMJhegHx8nk26YWQiRSNBLh08Ma/GrwWQVAmu5WesmQbJPd/leTdblAQz5BF3+fgyRhcDfQbXQ0yANtfJ1yo9vMxusgxLLeYLc3B/KABrNGI0mUR/5E5grOW6Hru9EvfzDlTMt4L5HpNcfiYjb5gl8uM7AQ75DDB4COBi+RoG4+pMJ9DYRsla7zqtWC7c5ABFojppFcmWWDEYrD9Cepqggddzlkyv8f1oIMuW1NtrOffj9c2FmDsy9IetV6RC53MHmfboCrACY2azKpprt7EXmI13EQn4fnDsBNofFHZs+vBgPj7fyy/QfoP2cARYpDhxADApXd58X9gImvEDBPX9Yhl6rn+81z6JbkzAmiS5LeuCpMn2BWKcGDd1FCyePYyxwH6BjniteQ3XfVK8lgSiijXcE8uOcVxvbDh/lICesaIsIzRbOgEG+1ad2C7qA8L7JL/z3zYbt2F+3g/nazafJWl6YW2JQcc9yn4ASSENQToteSXRWZd7F3bi+Gqk565krADIKzoMu6AhRtli6WKXAFJude8nTtfg5MtHESG9urKzaR6j2YBm7CUAyPrI9yCB267tHbVYbGJ5PxVwZJaRNgtHoMfeXQAjLuKkj1cTIFEFEsbTYH4+DxIgOu7VyjoKw07d6MprxWxlPTor/OHXl9RiA/7MA4NLue4m2HMex+fu2R7i3DD+KN8rTKh8hrJXOAd7cj+lZ9WsMHhLR1UKfww3zStyr5PFR+bZumGje65ffo7M8ddGjcQILWsN8w+2roqYPdb5kw+i7QQ47gJ0vVAISmlfArHZ6bOypGrUqFHjvR0VlHofRsq6LA9ZqfqLZwqbzfRpSJAqKe3n3Yxs9o2+H3lIEeCffbZYJHOo/4doTFwBUyV+uYpeAbtMjzadWpvasondHiwfiLBsD+CLjY+7hJEyFZZD6YyjP+etwdnIpJStVHP12kMBG4psLhMHNuz4hcgvBmNpWll33JmPY8aLQpIyVchNLedr2Ow3YHqwr9t7I00lGvApuxOmd4wSJAEUJ/DnZCDPJtSbJ9HJi5eT2CaLRXTocjRGPlNYJ6VV+8OzqZgBj169ORmeF6mI2z8Dxpxagh9lfQlKrdgUzmO33skfSTKrIllII3pVJ9utmLDR32Lqe+r6k9X6Vmfgrjf440hS5yTkcPBGMrsvad5gjPqwjA0b9V5XY4tRcnrGiOFzKHJM5gGV3XLtaUF/rEpbtSEw4UWfB5nGz9caQ15DQu8OjydzeXn10MK9G7EX9mX2Dowg5lYaOcPoUoKmLmIHtUJfTueSRmGwzWYaRgHXQUmUOkxSiYUpwNgYaMvNO+fPe7JjmJPkU9v5DDFnSitqmcNicrsGGNgdpR/z+9mx695+5yRAINreyRvSJbr94aci41sK6tnquhjlA6bZ8BqwjuOxYfECjx11z/PY4pUinLVUxUm2eZ+lk5ZeZkU+33N/31BCKH+RIqk8JidnlXcq9ZLxKSk9yCco15q0bk4AGUDo0cvXRw+ebGUPWwXWAfeHjW29hgj87gD2OfnQvN8gK7wVIwPJ33CCKKfIS9qtWD7MYv5gU/TL64viDWO2X0pfbJir2XTsdNYANGk3JJci5BNG90N1iewf5x9z0omcQThMxDm0Zrcf7SI5AdxUQglEBODStTwqu1Emiw1zdmxm1JkTxsDEQB1JMSDyluRrxblzH/eOYGgmjZLHdcyCvIeBtsM/yJ3fBPCIhbOL+2f3Gstr+eU87ydmqTfovCVPSA81nwuozJrKGPj+Pq19KRU+lPuXtcXNIlivxgaLi0wR2Ru/MzhXurSyRmGeDcjDPdHdxAGvHwG2Bgl0XWEllnXC7LiTpJk1PhtexAHJXGFsrNYxHPRi8ks/eGQLuyhjMIfn0mA0ih7AXa8jZhfAPMQ7btZkKlpOuJc8EICr1wf85fwAIlxssP/gQWsNxZ1O9+Ioj8ox1jrBPBJQZT8mSc453lKQ2Q77Alhs6F1gZ9ZIsTI7khvevn0XexhyH3wpxnTIA0Tq2jfNDS/sewUwZiY189wMJ/n4dE4+UXqeABQAgBXD95TK5/7iuN7q/rP3UD4bDSbYV0tsbIjTgISDXgwKeJjNSuYrut3a20wScfzf2H8gH469ihrDxkBMRDW4oEGFuqw2Y9OjUYR9/yzD6xxNxnlOIu/K53IeL58LQxIwkRfqfpC3nkFgZLnZ5EUG5Lu25fSYeVNcAEQthTDm0tO3buUXKAniyN3n+FyxM6dLrYcwTuUbpS59OzF0kjGeDPa8byx39+/FZGbvIklldjJl3hR7JM6nMID7A3sxai9xMJCD35QYg8yRMw9OmOXPPVvPGjKkV99Runcm83tuj3lmD5ANSPL1YvHRvEJea2b9Mv+OPmRFhpefkcw0bTcB3EuhZwdAT3dTAWknKwGNQWH485zLsfS+zHPuvGFIdn/N4gl7AOanJIZnnW5r1KhRo8Z7Nyoo9T4NNntsvB6ePRy7emGgqzbHxdickB8OHgxlU3D3bKokChCLh/05O+Gcwu2NCgmjkws2PVDtxaqQL1Dz6HnDfpANP5X1wejUdlebz8JOkEm0qvxmFKWH0oubBXeq8e/Pf2fmi9lQHCbnkslDVtmpDKekTr44AtaQlgwERslwWe3JYUGU7lmF6ZEJo9puiz2QJtCuYpMAyA9KTCEnIwKZSjc9mY2WjablEptYzdh0r6IxGWp8zeTYFImA22obcHHinRvWXdusqfPuf/q92FhFgoTXAp3HlstoqZLoDlBuV79SAsNm7+rRRVze0A3O3aKYK94MYxZd5AzRiDvkRM+mMboax/Ur1+5ENFvEEp8meetYmjUcj2K2fRAj5XAAxPBxJsOJsUhmk8a6eD2kvORYgS3tts/D1VgkCiSbvMbChHMmjkAu5iJyy7mr/Js2xq74EdnIVX4mam/veS+z2Nk85nOYfMjzPKc5H3mo6bgtySC5Voc0qutHBh8n4c14Gukmu+md2kw7MXKL+QPysAJmINmzn0xToASJSQIMYjwUNo+6gan7HnO7Fc2BfWcy+ZRytrCyBEoUtpvYbLOlmBf8HKab/G9Kk4M0KAak4vhhHK2X+EoVMLqAU8y12bOHePr6E3Xpunn1St8lbyXJWQENYV/YHwlQASkaZrzcJ/aC83WQhGm7fU561zocJOUDPEIW0x92onFwAi2DduZJ6eKYEtpjd6U914HzdiWe9uLtdieGk6FM3FlfYMAx/gAeMEY4ngTz1DIBNkcL4MlsG1g1hzBDwcmP56w8qkhoSgKaIFCa6KdnToK9i4PBFPysGt00q8dDyCAczI9M9kiUYRuaAHUoHnnFuB8QlzV3t42VOlAaSJKpdJHxHlmXAP9i37Wi3W+qgx9Asj3XzAQRWNswizC9nXLuCrgSoNGIThlzMWkKqym7ipJ0c1+wbq43BtnUjfN2LsYCYAEeOzyPWNPwcVInMFgQnDvMhu6JacdYTlezuHv71qBgHGIsCZbZOgfYPci0ZXifnnoGBM9ZD5rzyDFZ12SYbiNuxpA1UQCYCg0uShCwyBJoPDFL/JzkzTlGYszJkN7AhkAKpEGinp7AGe7VrYAWwMDnF7UETFIKLVCuvFfspPLdeS39mb5fYBR6feB5s9IYYf6+WCy1TljudGLHuvslfj9mplEUkDpMTL/SyKMAC1o3kfCWZxvf9U5sknN2SnolJZvl2P2seO+l1PsEwPieX80Xfk4PepKSHhuqLJFmbWN0OYkeoMp+rwYIAGiDl/B0g3FWzPhpVgJQrG5+7rQJK/rZ67f6/aNXbtw5siiiZaSv4kQrmuO+CkT41zFerBdikxZ/N7GqKFKVQll7eGKd90ddsTrZ96jIRqME5k34eZqsn5w3zA0YbQCcMCL5PjHMy7pvL04z19SQoTDIW/uIDQNW9kgChYPnGIjvGahV9nF8bnb9ZTxYgwUa8r4CnKcJeILxrP3bcu8l+PNOYM2LwGTOg+fM4wE/L4aFPcU87sbFDZ/rpiTpCaXP4/2tdnQLex15MmPIM02NT1hXGmaLt1p5f7topeIn/n003QC80h4E0PV5761z1heFv4fbB7HyvKbgR1qZUjVq1KjxXo8KSr0Pwx1bSNyKZwHtmEvSnhuH80h5GTR5EkeSBjxTXLl9B9lXUPl1V62UdQicKhuJ8wpVsh4SeEiPCmn+G/gznXxm8vXnx6VvO+uiYojk+eNnE8ZmlaASy3es6MxzN5MU6uJ6UtqbD44VYG34Bzb7ZDPL/ioNZM/9q1RhVUJOW3To6q7EiemgTailFGzc7THizTbJs+SPYhXACEBSY3kRpt7XbKpHS3lzyIwToIVNe7sdj157fNy82cD3xLRJEOW4yU1zbV7fd8c9bc5LNz0q6TaIdsVVPkAkgmzOxTpiY3x/PCeMlfeTIgNKaQbzBule8V0ZUEkGnCidkLgaKROFkZV+ZkgJzGJpSrrJBplE24yb5+UDYm7BcBJLyhvnF+UEmeCQIKnbkaSGAEQAepbaATS0oPmrO1SpQiPDkjyExNtgqMzQ5SG2PbZWb0U7Blc9g7Q6bhhIRVZBVVcdsMySSQYNyfaRPnZ+P2E0XozWU6pyvHsks2pJcsk4JlDaPpgpyDlmx8tMVPS+AhbhZaL25ZIfIt07dVHKeaGufyv7cYl9UDw4JF8sHib6eUrsMFbnPku/tpJ0YJKdJtBiCer1EaNLsw9lHC52i+9pHZ8YMWauyPB4s4353Szu37qTh4/OnaTp4MYBXAMMrbkul4+uYr5ZiCnIXO2PiwS1a9mICBDbQ0xlALzSnOfc8txZ9GClwD4CBLl/8073gRhvw77WApIeedXgdwbrUAComSkcgxLWxVpgHhSPpjrSuWsUiZCkRYNWNIbuyCdwpPjUaL6esXUS3EGGNbtfyNgY1hNsjF7vdA+k55W6ThWz7wROsgMX8xQgR549AJAH2E6MMX51Ljakr5Pu9dJFk2swvr6UHFEJczEMpvMmx9obwYyDzWZwA6AgQQExLfYHXW/7s3BOXpOQpyHRAUCEKTK+HMeWzqvrtQAgxhmwi2Sd9Y3EEZN1QB/YoaKR0u2MYgCgrLp/mcHJHEEWOrm5UFKre7I0nDBA5HU+7zetEaUXwLn0SfcQzxoS3QLwAGzl80aSQ4DCXBOKryHfmZ8LUEJkYwMOPIGQ7CaYnogyri73meXDLcmrkC6eP0PzGe3CDt97AuQ4NPlbFVZzrlOSbhYGiFknRaKP1Je192Kkaze/W0Sn07WkCZBFEjEzx0jEfR35WVsMX0ALnlULGISAZ4V1xBh0mqVA8UkAigQjDGpjEL/V39n19xjtiPb++S6iKgzQ/CL6kvtnl8A8LzFAByFAimPa3E+91AoEzvX/JMWj4QPMJc6B814hx2aNoBMtXRjlPWTAhIIPnmysUwIOYT8VRq0kesgZ1d3VPpV5ngmAZlzdXMVoMvY1LdJ1FS2QrY3dfU5MyFYBnsVGNaiO1FAy9SLbzWd7SrtX2XlTLPL0pgTA8TPi3FhcrPfSXZmZpE6VdMWTt6ALftznuUZpLizcqIDvp/umnkUY5t9NNV/YDx29pc7N0wujVg0cynM/ZZn5fOP6D/ouztmSwfP83AYi2e0q0GBP0GtHV9ffex/NafZkK17n/euxY66KqWUdKp04l3Nf+xcLQbYD8DHb7NzdVDVHC+M+AdMq4atRo0aN925UUOp9Gjxshx0kNxhgQov3xiVNL4nnPGCaDRt8q7uNPUHeaRPqBNntm883qpadPN8hjEhTzneqsGa3nJQzkcSSPL6T30Em5illOw825cc28YVBREJJp6gGbdwlvzp1AuO0SerohMaGFMZUYEJdZBV5fAlO+bx3MjplA5ObdnlRFMaYGVDeeBIwc/DqcJt6KOK9I0DjsYUVY9DPtHLLl9gkp+fPO0Vu2FP2YWP3jSUu2vi6Aq4NV7cTg2LArspoMQCHHcI5LMZDJxLqBkVCjiTlBFydfxcsuxgbMPI8YsgYIwN7uSFul0QacAhD5NWMzW1XCQMMGgCMF89NptWqdLIxtHSUpEK+LkXmc55oanzLNeAPXdEebmfaTPPRgxFjgHn5KCbXsMBcRRcQegZpCjyTPtMV8NElwKX9zhJY1UbbeowCUlruujucmGuZlB1lsc0zc+uSRKdk53SvmC12rNCScO838lAhOZLxdjGHVdVcbCKfr3ycujB0nFCnVDATAyVgMIEk5wQoHJjxB+sDdsHAHiY5VzOByWQ1IwFlvHDouoe8xn4tTc0HmEcC7IrkKWW4Yg2KGWfmnQr8vU5cvHxZWHWWjsGUIsviPlUjgm7fHjeLNBg24JlyzmRAGnBbao7BHJg+LKK9Wgss5ZpynelEBuikOSQPObMdYGwJlJXpvrKcklxtY9gcaFxlWk1SiBH+cnX0VYLdYwP9zbGLpny9ZC4Om8lMtOwMalkz52JAbzGdWR65NltHnQFLm3dYG3iuaL1sNsRybLZ8zXmxvHKQ8ABbtfYCFzC/Xj4sojdyAq21UwylrT2p5FHj4oRA0gZSGpiX9pIS2wmwo/j+AHJynFwLWCMk9bPbWfT7g+j2V7GAUbPHL+hQzMZhjgKeGriRETnJ9cPJz+365vIIVmoOwoiQMbrXS44xAVuzXbz+AOJgWs6fvJ/EPFmZ8ZTPp3NvowQBE5zWfdLvlutmJlSywPLeklE6oDudz8qzhnEm0kMp74kEB9P8XWBN93kzcB1PAc/zflQZpYDsKUvMjp6aDzCLy/kkCH30vioggs7R3TF0Iwjwp6O9GMJmZzYbMJ6KlFfFJ+TnJ3DN3mPgrPvoASr0DMwDcE8fZu7eCICAXK/fiXZZJ7xWvvPzKMEe7nV8vJBuA0Ze3UxsmH7md3TuI0QAwk7vHlQ4GtGJVPfpaV8CqHYYGKgyE7HtDn0qjrhIdWThymeLhgE867Za+2BBXbz8KAZFOkkBCTqipemdGA7NrpbBfLsVF5rDA90skroVz73zfdKLcQ4+786uoZ5RPGf7p851ORa9Jv5ffi64Y6h3ZXkfqJthxxLwfFaY8Vo8pRrP76vOJWomejbVgZJCEsb3AH5md54k1ppfSxhZa/vLiXVkDzOAWtbFfF2y3ACe+Xz2GTqfho37xRgs7Pj0O0v2pkFyS68l1U7W+nP7LPaSfnZwPzKX5L12ZKUmc+t0r58ztbS+wG4e+DjEFi4MR93nhTWf9yefe3Ez1loqFusZm7BGjRo1arx3o4JS78M4rzYS25Y9ZtJzqRlNGbCyyVc3slKhpHrPn+Mm+IVIM1KZ75JUnCWwL0bSs1PSxIZVPjfFVDKTd/kfwACA5k5yJPaGPRVyg5dSvgSyXgz5PV1N/A9MmgGOeh3J0tLsVhuTo3+RK4dZSc/kICnt8pdCTtA9sQpSUpYMojR7be9bpttLAuLqG8GYwgaQtGN4quoTyZxw5dPm3NoslQ34cz4IxV8kk1/9d+n4pOo8Rrl0YGrso9dEtuPE1MeSTA0nkdo0UvVlM9/txARQjkS6tXLlEePerPaW40hvGg7/vIU2yaxAhTNQEwbLUZ6n1tc6C/2OzT6SClgs54nJ8f3anBrUIWFQB6Oz7pG6tMlakubklITKE6lIaAaTgZgjYidwYZUI2n9C161I2jQ3S6KUcin5lXhf/9zmN8FGd1UyWCmz/DJv9NpyeTPxkDGuJBbZyawwkeTnVRK1M0NaNxBgLixton70rTl12mL+qblAGAjEn0sgLWdaEif5tChJNNPCiag7VOmVZd4kiCjJq8x8+fylTOGR3rGhTx8ZQD3ADPb1MA+ye2SrDaugYYPks+tJkisGYfH34twuLielo6XZcym/EOMMo2bMs0sCL8YCVfriY5TuUySaMKokR+OajYZxwGOL8135WnKcbkKwiXazFb3ri7i4meh85JED4LXfCTSihbiM4knqMcdn/HuevyS0TD8khHwWvmywCXTPlrHT9ZZ8cBfLqYEMg5nuOIgX0XI2lzcUgwcLEWbTcrqK+QEJIfehPe/Sy0vdo9LfLluvF2abPZlhOexO44AXE9JcALD5KqYpu1GTCTPkdsVDJc7mUDIqmjBVBj2tYTBlWJf4hfxgGgfJHgEoYI7dvXkXjW5LBu4UAG5evorrly5itzfwy7iw1vYfXxcmhVkoJJkMF5K4EZ47Z+ukQcfT8ybZCr53yj1Vxpt5gcdS+ridGysDRCkZTUPlXcTwYuQuf3xXy35jkkaXznDZhID/M1vWz6Xs4up7+LRWHZNzrXHPM0gSkD5fI3ON2TaYY2aB2gttJ2BBfkvphVe8EHMsLHEuTMcmAISfEwB2AI0cC10LVwt7MHJeXMfh4ysDFudrU9kTcP+pgMO1Ls9mABn8DdfzpaTZkj4VtgrHrAKOur0+v2bneiy5cvGd4tmh/UGT474wYFU66YlRecZEyfcy5xgDOiNKOnhumF0Yh/ncz2vDGpRA63GNFgBTuuaqk2fpitfrCITgOPh3g3W+sBXbk6H2Jdy/veDedkGL5wAsQRz1N0UCud2so7WzPFeNZAoLOBuYpKQzxzuBwgQb03Mp52u3rK/M28VyGZuwb5Lfu4vtDvbWVt0Rj8b63Xasy3MI8McNQnxtOA/GhfNCoud1nvMxu/S0NlvGzfFSOINFTBHBt4E7TSJ9tj/Y8x36KDKxfkxuJtFLFmLxVjt6kRXgVoWeY8MXS7pd4PFYeRJkR91mNAq7zEwsyxAz8jw57uw++OI+kNcMYL43W1qvNS8kqXThRvdCYZNxHL2+pZzPAcoVmKpRo0aN93RUUOp9GscNARsnNiGHYv4twMKbE2/+ThITKpf3T+8FOCHFyE3SUSJ3P1WiJTlMoU6/U2SFzdI3V7LwcVH7aTrvdJtnXVK8+bfEwGCRNrPqoHYCdM7la/kd534WuXFO92SZjiIRgfUAUwGMTC21XJE834g0R6dueVn5pXLobmPFuFgMFW9KzxOO9WZtM1s28HjTjEqFXGwJs3leNLlm7NPXR4kCyU+jVP7PN4Lpg1B8ZbLrHH4laj/d9gZ1I3YBHkJb+2K94PWAX0r59qA7MiCEmvYVU2FkSJlUnV/z43GcVbszRPUvHk0cVyYMR6YY1chHV5bBIQUYIlEpRr5n8yPlBAQyEhIr0+2Lfxcd0mj/jb9G8Q9ZUY0vSYAlNN24fumy0PKdHHGpuwV8TN8MSTeKZO08EnTLROm8Afp5MgHDYP4w0/dhJJyJSRrEImUi8VGVFl8TSYYMLuS8tZePq8Z0X6JrmFkRlqOQoGUb9aMUjDknVhwsoX3s9shzLL9rlU5P/lzYgWuBHvIjE9uK6jVzdKV5pg5zxcxa0jrNqZ2kHJrDtw9KIPCbQuqWbEYSMRIfWDSAIny+jO/lKWavnjxmdzxC8ofcj+touSdj4mtpsCnZYwCpsLlgA5EgMy59uu+VZDPvORnhyt9tXySLBg+W+6W7XpV7C3Dn4tFFkYC51bqB31b0J313veohPybZZOx8Pzj5dFWde2N8iafeLqZ3cxmmc4wCOJJhtlxL3obJtDy8SIDliWNWnbxbRIkyi7PHOqMulzv5vLW5toWRoHHqdwVmAZ6kHNDgHyAo94bn/P3dNOZTX0u6x8lTRa3pASJJuOkOOBDbjnOBhdghOe25mEDnVJlI0yFQnmawe5pa/zHYb3Vb0et2xVYQM5F7braMNbKhIm+Ur5WuYTtaAE+wjvDoaza07ua1ZSzUJGG1spSprL3JJORe7Y9hzxVmRWlsYXnh6shuAOxg2FlTvcybmQbQhx/cw7OZwNR2rxeb+TJ6GLrTebGAX/I6W25idk9iHWpkoOuFb9x+J3kx85lCAuwkzk+d+wqjynPfkkhkRgLkX2Cp5HrG9WPNODI8ub953havHd6vtauAcswjd/jDz6+jLogCBfKZ3fTagkQ5ZXe+by315NoBJqtpwwvr/3kAOMh/qsi2siCVMnYKFdmVknNl/AECzXAqLMgiLRXjRwAGDD0KI/sYdW0OXuhFRxalJN4vsJt9j7VjiJy2GFMnKOFnNl353GE2vdqS7WwJqZ9B+RzmWM6vxWDoYoVASRqbgJXpucy19dzUvS62ogGvZEapqyHP1OaJDSuAbr/W58ESldyuFEhsyG/QBSYX38MYcz9pPAYp6T5/spyKEZaYlzWugMOwkljnsvCT5ymj9eJTydbAazhrLR6Wu2gNfe+2LrKocipSHhlSZW3SujvqC5jk3ylJ9YbD1yC7HzMv8M9TN9ezoiefkWu+PPeYP4U5DBitZ8IRWLIP3RZZuZ4rvgNYYz0GsKr7sR/YWD/PGZk7oPmzN59qzl89utQac2RbwY5FIn4/1/o7KAWOLGzJF7B0BM1xyCLVJyt01qhRo0aN915UUOp9Gkm7Tj39sU9wqZapZW4x01anos0m7p7dxsPTmTap2oScdehjg7G4n6sK1bwYH2UG54ysjJQJ8r9sed4v0i4Z4MqEeqlkJztvpexO1WiBSE70zzdyVPGRx6gbUPHJ4E963mS5Tm3s5RdgaQ9VYBg0Mik+6+QnxodYI8WIXHJH/Ge8+coWzmIvyAD1E9sLk3hwbnz/uTxkWVpTk5CnYfh5pDeIJA4de27xGhIsv88mtny3qu1bex5k2+jzjnckOWoH/ykkf9k1LTfC5xv6F6v7L8Y7fW76iLnVdDmns8/0OTZiMbM8Js1HJYcqHd+0mU1WAl5YuoZu4y2VivzBSMiWmi/DCWBIT3NQksVSSdemuYAiSjQwMj8z8895kpvnT3ae2qAC/mx8PNrsqgNUMSxG1rgkObWEk/M3e8Hsuoe7aSyQO02G0b22HELV2bPqvxl4JXktEjvmCrIXqsVq7y4PFFMB1DVSLcjtOSbmEEAd3lpFlmpfDjo6zmOG8fRqGzcfuJanSQKtkhIKMPMxJVPxaMdEgsN9xeb9YHab7m+ShobBOgyJYUAB4gDo0JXtnKUlWR1AVNBly/eaq+iuci82S0uDSrJOEkXbegHSJCzS6TVVwXdXvOKZU6ROrEewH2Gayfx2D+OqdzTxT1YOJvEkjplQWv7IuYSAGoEJOml3heOPZUGFKVk8SSaXF9Ht9gRAMs7uIvn8mnQ0uwZwUPdOOl6tYrNZix3FeAIAAHQAlikxg7XWaodGarsVC6m9QXJrKXBKc4/3eAGr82/MnfeTkYGq0nWKyn+3J1i2zLE0Ti73krr8dext02Wt47M4n1OXN0BIMeQwKcaPTiAi3lYtgTWXj69sgD/He6isvcXnT6wuzXU/atxZjQ6ZmGvzDDDbJ8FZezP5yZS+Y6xxGs9i/M48kzy2406yGvUGDMOG/JUE2psUqWdZZ4Bx+SEabQAMP78kbS3rgtkyPFcsZXMTjI79aKZLrb3433CuR8me/MXwq1mVJLsRG9YWvAAZt8LuEtAD4Mp8A0xrGKwFyGT83IHSXfbOzdJV+NiRdK/j/umd5pvWs1IcyM6qAGoJfKTkEwaoJG+wrhonT6ZPFvyOeyUbPhDM6VFrWDrleX3K7+VAWQvn27lkz/ueO+3N7uZ+ul8xF/nOdqzm85jDLirP3wR226XbqppcNE/d1qYPczVfQF7mez3nemF3F4aLLvmZjxDxTjYB52t6gjfaI5T1XmthGa8saHnf4bUuDc2Pn9EyaMPzRs1hJG03IHMcz/JMmQoUvbNMv7ApBdYV+V2eAw0Fzo+T9VLAn9jEJ3BaDMe9gaDsXHt8PgHYhrt+mmVOEWVv5meZN0emEms0z62D2Z9mWptFCfi83EeMbyYn2d3ScyK/i+uSjTt8n+PZ2RULXctnAo/l7xwTjkHApXwbt7YTUIdEs6TpDHj+TBZztlzj8+Yt59dV80EFGcune0W6mcfB82/GnMJLc9gvAGxZX3hmFab+ScLI+7zek+VUYKpGjRo13vtRQan3aST76bjRKpIisSGKpMeSGyeVbFJh2yBbUfvi0pLXJtylEkhleUwHPSeBMpU+696ViVRKiAzkWNJxzsDZ77xJ4PNyY/E8E6qwQ0p76eP7JHVzBbV9toE0hmEZQ1Zo0yfgfHPL75elE6E2aLBpMKpNKUipHJsMAbCEPIIOPR1JVlaYuB5C3jXnbCkSj8PgxNzalkSTTTcgwrmfFVVKxhKJU0oBUybFZuvu6UNMnz6I0fH41Uf+7NIK/LnKagESF8hskLCl5O0Fk89k8tiz66Aq/Lm/Uc4ReT4U/4o8r+fH3kmUNtL4dZRjENPiTHbyXEVW0g7LgdIYX34qJERF/pnAnpkeeP0gaSryAbx/BGAcnmvpzKY9q9T4WjBuNrAl8fNG/LyN9blc6Px8zplaCa4epYglIZP3B95ZDbOu+mOzDc5lpTrfndlRK6QoMnOHVeM5fe5p4aS/+BEdSgJb7rUG147xO0u6AF4wDxaAm12JuDZpPKukwA0NBpOhO9NhWluAVH1fGORa001KsiPfu7A/ZCorKadbjXM9V8teLOdzM2w6HXXN9HiRrDWisaf7n+8XZHbcM2rtPltKVgbAwXtI0Nqdvu4tm74bBOLY1IygeP+QcKv9Ol06xfawrE7gDsbFpXMox+bOcjbQpbuiQDyS2pJYrSXHs0eWEtIybs3i5SNGWvHk6WKIX+6jNK6XX88m39/UWge4kF3FUgZMUijgWEbXRR5Z2FybxdIgcjFoFlurebpXNkXWeGQO0KlSvmAGxHu90tmxsEdyHdM6WaSmkhYX9p+ApwBsAWzODl6wJg2MktyKrQBjbA0L1ICKZaVFlia2YyuuH1/aKLo0vxA4LyPkU/c1AGWYO0/eeCLTfa61rsMAU3NLi/D1gSnHtUQCaDPv0hWM8eXY1cmSQsQ27h/mWhc5NkBJWGA8h2CU4m8FqKj7prBDOvLjsdeWwIZkfSB7Kt3MWIMB/TSOMkdH2ky3rdYRPMh1zQbXEeNLg31aO0tRx0yRTnR6HvNkWnANcy0BYJVpOqyq5UpAGs0EuTY9ngGFCZbrohcm/8X8HYx4ZpoJmD5GlrJ7fcKHLQCh8R3kuFl3ADNkrG2Z5jvF+TqXoAbHUg7neEyN3un96ZsFE01PVrF4bVRt+S2/MyN1STMDmeIvLe8K5F0eQx170/sOMbu2OwHGkgaqsODn6blUOotgOf9znRUrszBQP5mUMD/jORZ1+W8br9sQPVnK3B8yAj9/Xmp/RNGBda3sW1AEp/Sa/cdZV1U+bzldqCAxPlyYNZwdiQtYef/sQXOF+ZzekwLhdwdJbgF8sFQA1La30/P2CxmMMfd1q4CZFDNgnY4mffsGHllAKW3tuoEI8nXZLpiB5AIVDEAz+tw5EM8o1rznmUP5nNKeStfqeda31s4zGV4WXo6MR8ZT+7ETuH5eGGIdVwMNNfjILpplj4pkVRJGN5eIV25iMZ8Xk/jVcwx31pLx9bgUlEqzhMI0zW6YOpYmwJ9/ruMue+EaNWrUqPHejwpKvQ8jH+rJNFLLa202aAlM+282JFDzSWrtNcRGjI3N5Griij2qsWLenBtHkg+3mm7Kc8Gmx2WDUZ7r59V94p1YKUpAL8faACXt+7wry7YAKLRh3+9abrFO4oDs6MLn4WSstE9eUnkjgRy4Ilt8mHjdCAaEmBddJ6X4z4ixsY/BuB+tNka6JDh0cHE3sATQbMC9isNsGb1BJ+b3C22erl+5dveoszjfBNufJ6LdtzfN+SbPXeCWsVqZ9eIW8wU82+50nDP5cFlOmR5f6S91DvyQxM2eTb3hJTEsAEl2RFS782Olf6mkNKUKNhe1zIhEGgaaAA8Bkqf26OlnZE+rXdy+fRfTJw8xuhrFxaNLJciW2BlYSO8eGaU3i/yyyHxIXvC3QV6UhvZ5LpynDJTZTKpltZM3zgOAR0bFGFKT2AxsSswgix10N5PcTCbf8n3xJvfcIP04/gXcSvr+HgPvkmDkuG0PBs5gUCBJAhIkmYIV0B/iY4QXE8n3wmNFgoNBe68t9hLAB/cHJs0JXNFp6PxYEoxjbDh/jj9lgjBhnIi5u2MUPx7ArtzsHz2NSqUacCCTTiUa8ovZiX3Fe8aTUWxL9Zj5DvPMG36Ss15E31280gwfcEHJWf9k+N/uMlcwwGfNcEcpvVcT3wAJLMs9bCz5UPka8zmAppKSlLmgz6O7ZN/yT2ctLXUD4x8wR2jbjYRpcDEIOIu53uR1PffyMaBafLXUrSyr/qfuVnl/mjhKck1CYsCdOdPtA677/YAQmUBlQsp94nHP5gSFqdeEjeVOi6wjSPWYK1z/BH8AXBkTy7HUdk5JL+cuQAOWzZqGFDQo8DzM+aJiQsqWC56Ra6DBI0AlZKbr2CMBlG8M58n6BniRxsiCppz8KSHjfvQ6w/2vBL110JqyKT5aOuaSaLpzaXqF7QXEImflKPFv0jEDnpBO7mBwAsT5nmRs0meqqLsKE9Ed4SQLSh+swrDTHEM2Kr8dAEPLqwCPVAyR91Ujdms3UIDJyDOiCYgIowvglWeJpJG+nhwDa0+CGwYhDlo/+/teDEfD0t3O4EMWXZrJvCtG6owXa7QZtmbmcPy6/67MCs75c77+2/x+rfXh5OFj1iJrhzte+j5nTk4X0+NaxzrI2M7ny1jcz8QW28BqS1ZtmavPPYvK+e2aXhPeiUl1LjFPefnd23d4guuZyvPQa6PXeTXkKAwtGopkV8rhZBz7/VZ/572ptQMQisIIRQcA67EBR8vbYU3Nit+kuxxyzbJpBkUHQJuHJ/cCFsdX47JUpAeRpft5vZJNLNCoeED6OehnsoBrgKD2RuCqzr9TCnPM0+K3pgYSvDcN9cseJ4t62YXU0nAYkchdT3LzZPCaxbM5+kQhsR+OAZG4N5vRphENstfiofWiTD6DZ9GTN57GeraKAZJdmiNMl7onDiqUeF5mw5dOz1L1NSw7mLh4MRW2Jz5T3K8AtinNtJzPa6skxGskfmszzmA5qXGD/QWPBS2BXx4rxrLZOc2vfGYM2cswxwvQfb5XyjgHhY7sq/1BnnkbJJC7nfzCRrA3aVpSCnE513l9l2cJLDF8w4JxPz3rLeF04dTPSBidzHkzHT8Zc7pGjRo1ary3ooJS77M4f6jbNLewOrJLDAmUKNmAIFTKDMqIDSCpWKHb83Avm6STefY5g8ZsAxgauRE8moCrEn3qjkakuW5KBM6ZUS9S75W45LeUyqkSbVgCpasLnzefUkWnUr49egzwP6p+yeShdXvGhmS6SOJyE2sz0sJUmpEc7U4sIJgOSIOUILEJRa7kDWlWoM8ZYpZZOJmGso43C+NIZVoypNJaGlP2njoiugObWFmYzsdB4MejD4Ro/Wz4YKvIJLy8NsG/BJxkbVK8uAAeleTChjhKpOyXIykAXhMtS+jWq5k8IgawKJQgNlWllzF2MVTn2OWXJRAHuWfjaNKrpF6AFuOV/mX7aADIzOmMtrax8Xhgc1o6ot1NlTz3Li3lO9+kcrwX11wHb+JTalB6gGs+JbUgkx2BP8hqSlei4/ynU+L+DAgsm9ME4dIjTGDseTW4zM/0aGq2OB7OZSFJIYlxyiBhtwAYSZqojX4BPfYHsYUWRX6nroUvMM/ODXI1L6lSF9ZSJlsG65xIpVznXLZyDvoemYBlky6ZQgGL30la6xbgPZvRZ0dLgFHjLQIXSUJIlGxQ3z7OI4Fo3Iv4wVw4gScAE5hjZlV5rPMeT8lRJs05zu00nC5gq/yGJDczcKQOg7C4LkdOUgDoAKFK6/bsAJrnnlIogBDuVTV3EIvoJH3ReCg5BXhcaS1AtoWpcKM1FrALYyjB4pwb3Idpkss12q5XGj/mNefruaE+V9GZtOzPc2ZcLCBrl0nUSYor0HUAwGeJWbIoSEIXczyGWtFQod/XTZ5IpZGCJKulYQMef/stc3fnTpMbd6nbL+3/IxP18h3JBtQ8Cs6XpM0yIH4uDz75zjXkWZXXURI4GAoApwPLwLjPOWd+h+xUzxzGunyHOokVua3BoLY61iX4MbubSvI5uU7PLj9/xIRgTsDO3fdssI/Spu3j4F6AddcfD9z4ofgOaS3Lzq7Mr0FPfkew6lgr+N4JMsXSjTZfy/dCSBTbljld7pMX/fkIA+9uY5/zQ3MZRh6ArzzcYG82ojV4gXG6A8BkHM0g1bPkDEiXCrKwRhgDfHJAPwCkdxiyC0BcCBBDegYYwnOi2TJomgbRycYUKBMGDgTEnzGkzoEod4Yt92cprHAkAFBuAsG420CadZ1rC3iUbGrW+cvrybGRwvnarjnNesQcYq3muTPE2HynZyWebS4QWYaeXeeOz+212cWcy6JrVqHXW68TyNc9l2bqIJyeeexeeS8MTsaVDpGMo+dG8YtMP75i8J8NALw3cPMD7mWxi4u0zgbsZoQzrxm3Vz74stY+xo17FM+6cTHaRyJn7yQz1VOSTEGFawlIJH/B3LdlQah4P+k5jiH7xmuZm1B0Yt1aizn0cDczW1O+ZzutBdlhVfYCA5iDp4YRKoIUyTPBXNXzSICTze8Bevc0cVluYjCyr2d2R1Snx1z3tbYbLD5nJ+dzV35fvdNeL6/tqSGMwdznJIo8l5v45e9jf7YGp3fYOeCrZ6neWOTJnZPMOn0WGy9YFCT7roJRNWrUqPH+igpKvc8iH+p0G1LFmTJm2WCffi/ycmzWgC1u4dvpuCsNG6OUV6iTWqkUphTpxDYw7Tsldi924stk8Zytk2bVtHo+T/7P2Q4JUqXhKqHKHTIezIKLB1aGpFX4cAhA88bILCA2jcXksiQ6bNokwSqSODZcliGxSWmoNTWbyDx2NreZJBFiBWlDakljJpU5rvYtoQJefFUk5eD7CnOlnBsbwmOSUDbCdETCZ6bTa8RgCGhTPFNK171zhoy8JDBDbrdlwGwzUyez27AHEWNx9NSA6cO5lUQFZsLs2YMAMKSIg6G9vnQexZye962j+DZpDFyFHo37ks1w7c3uIpHuCghQ57SSuMtjpwBjx7GGmVPAtRdlFicfKvuc5FxQQisJnYGZ83nOO0lmYLHBFMrxMtPG10edxYqEsFkAORJDWAmaywWwIikhYSDpQPbDvBqPR0pi7iVLMcst51hKvfiDvK6zLz4bhQEDEHE0JC5j8pwsCOCmbTmjgFWuZ0k2MmnhmMVMPJPFnieSWdEvF+TYFfCc4fP/s/cn0LZtVXUwPHddnOoWr6IUTbAIKiZggRpjWowY9TdYxBhNRDQa/dAmkqZEg9o0icYaLGnGX01sEqPti0XUkBCxQCUqYE2NFFK8xyvuvafYdfG13sfoc421ztrnnPsAefe55+Ny79ln77XXmmvOueboo/c+YnAYPb/4R2a/BJTB0ND48GDPwTYGfEcnVvGJoIMq0BWAT2b7+VjNAUPFx0seVwpeJfvIQY2vWzjOYH8nDb3Qgaqv4Xyi5BLHgo8WgdFGI01OELyuCVJzTWvK78rMqgFk4N4cXTtiMNteoVT8Io1Umv6OKyY1WyzT6OjY7gnkoisDl0zaafAogKOT6ycMXLt3XiVTTtcdx7eYWmDJwPeEjEgARgRI16k3BMDm1Uz9c5BCwbB+vttLQ2eQQKpDfyp6FFlyYTk2o2bKfLvrdHJ8kq696xoLMLDYAyqMAQjwioMGkNlaBh8mepbBJHm5ADxlUtvdPpBuAmEWEFsQymvCa5TKtkGkSMsuxg7YOhbsi70iM2kZV2fL68AE4StkQprHnXzUZHTGcUmfLpwH1pRFGlPuaj5lAAHoWQWZOOV59hzQOEMz78F1mkMC7CXbxDDTnCAQ4WvZYmHMHrDA+DeTOqGqmsvBzXAdEnhLFMiQnNLt47HJ3bsGuqJbtfbTtxAADCu7mkcewagWWLoYL8aYgVRrAdYR2GrMPCSuEWTggt24A0nrDtcamqSj+hoSEpijYGA5e4rzEzIzL2yi+ShAAlI2VhN0JouZmXfSwW37xlYS84VrEMapMYoxDilRbXcISOn5rUQIzgNzRx5s9CnbNSCE7Bo3MpeUkmu79yeANsnwMe4AJjXuumJrF8cUnjVgUPk+hCCis7sB0A09gdRMNLA/vO867xf8qwzM7JT2JvS4JNgK+ZzNQQJoAArXAGuRqDFgDUBw3AehG+EbSUltB35OVnAAkwv9gIuE8bj2RwJqOE5G8J1cpPauVavVfkVJAq3vSrbtX90LlWKtEiWvGaxQMjTByLW5Qaa5ntl7O/xugtWTWVo6w1PjQfs3seHMp9IYVJhbZBsGSTyfx87ow/iLz7TMXiLbdkmWu0zkyYo8AbsrZVCb8yqYqpdYezgGEqWtYm8ZAS2tEXj+WQLLvCq1fzDQcJFli3mPs2VGbdu2bdu23ZLtfQpK/dZv/Vb6ru/6rvSKV7wivfOd70w///M/n572tKfl3+NB983f/M3pP/2n/5SuX7+ePu7jPi79yI/8SHr84x+f3/PAAw+kr/qqr0r/43/8Dz4AP/uzPzs9//nPT7u7u/k9f/Inf5Ke+cxnpj/4gz9It99+O9//dV/3delWbVGbLx+eyNQAA6HXRxbeNkvF5tUq/tDc05lJObDwYFbBMEGCgUuTavyHckl7+RFww2oeObHVsTnicfQ5uqYQiCl8JmBOnGhQ7BXSaJxuJZTzpsuBNsvaW7ZT3ymPEAUpZGb4v0vNs++SF1jZYgf/dJ4r+wz6DplkfP9khMLbBgAqc1/IjvzaEURxY2u+OAauITtrXivYsFclF9rYLrHhaxQbSWxcEQhwAxlAIb1f3w3vlcUMZegRbIlJ515gYlI0vEJcx7KuCvaidwe9QeAL4ubVtiHFJtQ8t/SdOC4C9nb3kn2fSxyytK3Gw0LBK01zl2V/qAi0oMQ8Dban8zTJbD1sgBc0HbZqdHYf4DlxcmNMYKo3GjOQZ1aW8qqpee6ApYHqXV5dkkGTVyk0phjYAvCNsqDv8NphGsFMfx+VuwY8xsHVg3y+Yprp2sTaInzlTAbc48agm2U7cfxJBiLwNso3s+eNy08hdaAJOXxjKJkoj5vIKlIAWsyzojy2TKujDIiSoxFMxGHmiwp2LQeminku8BhjkCbJHnzafCykNARJQEtRqXgvYS+WAKuXAVTAvZjOCA6T4YY/uHaXV1lxhqN07Z4HUm+3nw6uHNCEG3IfBIViZVIG6Ww6lnsfAUw6Tr29YdrZw/dZUI/7bvenkQ6vHxJwAtPm0m0HDJqx9ozhYTQbpy69cZpkIyEowhSlF4/mD1P3RTU5rLUA2sC+QL9gfhMQpccQJHSjNJ9OGDxDQoY+5v3vdtJ0PidjBgwRfC9N1/H6aJJGRyNWlqIUuNtJJ4cnaXw8KTx9wKAAiACQumcM2GikDgbYjbsfcPliNzVg/rtcpeP7DtN8NuS10esGwSfBmiUluGtnuM0JvgA9tbHLZ46b+mOpMPDCCgGoSiXmCGXBswWlqgDo6BMDiXHLqpaaMXrW+aVOr5Vay6axWQHkI5B1cBN3G35sNo5daqgqYc6WQ5/tNfdK/nFxPTGp9oSsEbDDTBYJEJSRbn724VowjlgIRKbSIdDlegHZrgPEAr0kRTa2b49jOgJ0lJc7QAxQ/OjaIYH/S3dcZkDN78E1DeDd1XdGo3kyHs9O0uF9N1IHjBaAMf5cEmiSVgjMjYGF/wdQMz4e0Ri+ifGB8eDgrzGiIOsCIwXS27LfHteLxZgMHzB0IdHE51HetpBEWuEP3r5VAdLi+ckCCi45JmCyv0Mpn9YQgR/y4aP/D6RlXnFPoDvXPhRLadvPPTzLL8PLypiMSqahe8FWpby9Y+t4yWKgnVILHmVgK4Eh6oAPPYlaAJXwbDWwlqzLsKQSmEGhCbBEHawyINhAOtwbGYBrncxG8mSnw0MOnn1W6Zi+e+tyEkH7A/nbxWQeqsse3GHPGlWVzfutCsuPxwRu4yxnPYu478FY9OIbPJYzwwAsC2gyw3Nj87JacJgT2h+eYuVir4X56cxgSZ8BGObKeGsA6SPOKUgKWcTBf8eKx5Ccu2cbsMTqXpPyWhY5sbVC+7fM0uLaYucbKyejqUom2V5nFAjYtm3btm3btodGe5+CUicnJ+mJT3xi+uIv/uL0WZ/1Wad+/53f+Z3p+7//+9N//s//Ob3/+79/+sZv/Mb01Kc+Nb3qVa9K/b5t6r/gC76AgNaLX/xiPoSe8YxnpC/7si9LL3zhC/n7w8PD9Mmf/Mnpkz7pk9ILXvCC9Kd/+qf8vkuXLvF9t2rLwZ9voGOGTw9j+mv4Jg9NARR/dqVQZDPJe0EytGjgXfXMwMaUwZOb6oIazkBkDiPiZep2nULdKfsMKFimNOtkzA0mg3YaDWX1mmXCvVpNBFy0sYUXhTZ12jwpc6vv4qbRs6V14JqaAploNqwNjgIJBdQZEGNgXFDy1b9qpb7GJnUoSYtlbS0wKO4Zs344T2fpGOPHgBKCHMsmy8sDxDEWULHxrAId2Pi1bys2xywFj8o1kCs0AJCZaSrZRW68G5kClGz4RtyANmR+bZyYhMmqkIGJka/VKxDKt0Nja70w81qdn5Uin/A+W2l586TJ99z7Xx5Q7LMZMveQYnXSsN+1a0YwhQ01S3wvUrvVMU+gtVXWQxBOhgCr/aHUPDK3FhgsplYJ7gRZXVNOGUiDgA3mtDOwC1ZpuON+St7EEklhPFEm4ptzVjHyewj5GM4Tc0SBUJS3sX+Q9XaDe46VXLK7XMpaxQgm9PIyVpndSPfScCAR76d0F54nZJ71MitFc5ey3qXNd1l90BR4gGABXkEWrPd2es5gKZhuYIZg4chSPbyfoICZZRvLzKu2OavQzLYl17VrxxzAWMTfNFZ2Jga/P3rmrNZpfHSSjq+dMICmsbdLXQCe4PsIXgEYzD5ztuZBetjfHZq8FNX3wEhrWCn3GbxyxlNWIyQziwA2xg8C+gkZTDg3GkYP4M9iRvD4DL4HQTY+F+ecsvZka7khf6uFv73vT6ZpdGNERhaOu3ewy+8cH48JjkHmxnL0B3vGnEH2HxJDrBXTRTq+cUSQtTfcSXc89vbUHfTT/v5OWixdCud+c5ISmseVe5Oh+hgkVfuDtLO/SxNzVOyCF83qYCclGF070MEx54A0WHP0J0QVRZczmwedSXwJDGB9gJwWEixn5DWbhUE35h8CarKxIOOBB1oIeOkhB8CGz5UFg0wyQsDyAiMFn3fjZsp4KbECyFmwJywgtmeCriHeGzGBWUCB6xjmKJ5Ddp907UxkuIQpv+ZAk+6x1iexQEp94j5aAhYyyONBONYcfV/2C2PQPubnrXoiAJuC4VLMvXZqNcGKMbm0ycvM74q+ar7mAECChHp2AjCxl/oE4CCx8mqDONeR+Ru2O+bTV33Gk4ns4PHyxjxNXPa1e7Cbq/vl6n1uOC3WD55RVo1vkbpeRVcVPM0XydYmSmjdhFz9IPmr1knK7jXPYXA9X/I5MG1NTcaHang9YzBhHcZzBd8NMAggkPpQ5yspsq/m9MwzZiTWb7vnZuztiQBfp+NzvXgmFvsSrvtTYwnHZzqASVajdUCVa3W7MKUXiKXzjMwm7XcIdntSDs9bPesF+MTEghIOWrcjczYyesnqlpUCwUDb23AvCAayj92ioI3ZA8R5Ffc32jMA8KXx/6DcDxgXfB7j+ez3RftTSAbJskcSq9El8wrfK8asyQPL+zar/GnyYz3z8KxRclZ9wfWCEsniGbtt27Zt27ZtD932PgWl/tE/+kf8U9fwUHne856Xnvvc56Z//I//MV/7L//lv6Q777wz/cIv/EL6vM/7vPTqV786vehFLyID6slPfjLf8wM/8APpUz/1U9N3f/d3p0c+8pHpp3/6pynd+fEf/3EGA094whPSH/3RH6Xv/d7vvWVBKW1SmD0iMFN+2DJ7DpNKACnIaEJhEDT3sVUf1lmqE/wOtDkwSvqUVWEkixo6C0ebFDAfACKgVY1XBRAVm3VsqjyAQfY7eXUyBldeLa6N9Jl9HhlmfDfeQyYLAkn3xuL5YTPftQo3aplSjhLwwT+ldL0undJGKZZrB3CAP9jAxv4zNpVnmZ1lVG0RiOFmM2+OTL4o+Z28qrDhZnWuAbLqJvlbNLC5ss0qMqmDdp/XR1nT4QnvEwAFShHDPdaGVKAjpSswt4b8rG9ZbDFtIvMOLBSMnSY2sEFKBaADwX9CxpoZZZOcnJadmZwH54jN5hLnTiZDIdc0yY+DmKji5SyDqi+TQCqyjYYoB28eXNg4I4AbIGPt3iMIYCFkRNANMAJHQoYVxqlkRDgbikbOa5g4N9Phvdd4HEho0IcYJ5B0TY4mqQMT+0fclvYv7zNQBgiuDbiyywIqyFIY9Iypg7mnjTg2zmQTGKOh0bSNNP7HQAbZ4a7JL6ryWN1DyU/McB0sCQT1BvIAYKPprpva2/tN3pkZkirnTbmpSVxZ/RIAgcskMtNh2LP55D51JUNoD6AaXWfthUqGVWPyRsMDEgegGdgggIKc0cESML0g1+WYSha8aj6gMYBLKe1fvcRz3znYJ8OouWcVsegFI+N/gNFruxezKYDAdtp55G0cG/j9bqedhsOBlx03JhDuN2S+mFMKzAkWXdoh+MaAD+O2b2biqJ5FEG1VBOLLqZdgb1rFOXiqrWartGLhBquapwqgHXwfg0IDZXiNDm7AA6k7tMQCjbx57w3Q2b+0S2+a9drAOJgB7+wa68Xm04LBOQCP48OTtKZ0EGuEBeL8Dl8vWOGQ5vstnpe9ZmCtgmNWZgXDzZkg630FyU1eH0APjCf+HhUYGawKiHGDdgct5V/HNQbfOUMvBumSM64IWkwh7TLwmCCFrSY27iDvcm8mrh+52petDeaTpYpefEfCJBTzg96BBGgNuICsbtWwyogdSsPLYAUYTJzHqHTJALcoKKLnhEkc4fNVAHYAxMHyw3OMwT0MssVm9WeLEh4AWPE6q7fdd53y5yG8CAfwlkNQD5mdJVUI5FHabCAe+lwBN5hKTJLQ+NskqLicndsO0u6eybc1x2UwDrCRiQb3uquyTDBeUaUQVeUA0jSbBt7Z+m73BH0GyS/WOUiQcX9YiTW1+V30TERfrXu856x2ynOw+d9qm9QuPw9c1clnD0FEmM/7HHKpPPoaRU+WzQV9lVg9j56JVtgC+wPJ9WkCzj5a8JmqqrNWebBIeMnM28BIyIMtIQF5N6oS4m8VyND1EwRFQqGjRJl7NQYgkX3p66G8zuIzUHscsT3FPgegSMAyVrp1qV72v8NzdTbnXBH4Q1AXfQMvS1YMNdakPC2NCTtlf2HNM3/RAozVWhklero3snCo2ztKdo2CCpHZK7abrZUGcKOvMd4JcLlPpXl8GeCG+4Hnu84Tnl1VIIkS6UMbd7x2svPB5LOEEXxU5YOmKr4Y9wT5nV26bdu2bdu2bQ/N9pD1lHrTm96U7r77bjKc1A4ODtJHf/RHp5e97GUEpfA3GE8CpNDwfjx4fu/3fi995md+Jt/zCZ/wCblkMxrYVt/xHd+Rrl27li5fvpxupYaHPjLdk/E8DXd73HTGDZPR0o1iTuZCpXRytWUaeXgfg2Zn9DDTSXmKSwA9Q75OlmUsvDTgWdBKsykkHdNcLrzXL2cas7So3coyCrEOtKEBQEMz0X4vb+Rsw+YVrHqW2Udgf3j9iGAADc5brTRIBtqEC3TPBFD4IQm071STMTZ9ZBxg0++LTGEjLVru6+AMHpwzGEsmKSz7SWy6b2RBBZ+GyP4igOdMLPsOgIBmbLzCJquHQMUCynBx+Z6oie2lTD/6CJu+nUu7qY+Kc5N5zpaa9GnhgYcFKQz23S+GDDqXCZC14Z8xDyncaBYUZ8hhAIdlwgkwteHjc8JgJDWs8hyYEx2XdCggYmly95rBd9Hc2dld2Jx24NvS61LKSe+jw5EFQn4P0HZ2d9KyB0AN/iANSh47LovTppzBwcmYXkOz0SS1PaAByJM30A5arFsma8TGnWynELiy2lkYpwjcCCAgyHQ/IslfjY1hG2Nsto0t0uK1YPNvclX32gnyWco8uFlfU65Dph8lK8YEpM8V2JCYe2AaIbjx4JfZ+kE/e8ggeII3UmNqQCjGUYPyioLhcHT9mONiuNfPfmwI8ijHZanwouofA522BeTysVFGP7K8KHPB/EBpc4KBM5rrItDrDb0EOMYrpbBFhjs2vL4H+Q+DL8uwmwl2md2B70K2PK2tGpvJfREEmvFuigwulJ5HNTZIsBqYZ+VABQwL89IrGDRoAKX7A7sO4K65CihAjA7WIjMhbqAkOb2DMLc9gGVVrk5qHxizjmCGsxKw5sDzDT58MoyOsi/0OStXAkhVYcE1AHozCtc9huGzzSOb+1rHVLqewRnkl5Dx9dpp79Kug7VlaUsEh02SZWxBytqcgQj0Q4G4vdUMs6N82c7d+lryVlbFCoAuA+CGV8DDeawBroAdNzIgeq/HfsvPJvfZEsjPtSlUT4uyYP6biRmbW+hbMu0AIMLA3J9bYLIoCUF5N64N73HWLxMSADYQ0GI8kBUpibr78PhQjGMGyRmw28DaQV/LgytW/SN4ArZjv8v3AzDD4Gqiel27VyRVjsbp5L5DstYal33s5iRAKhJF7hcGkBtrbZkZpGcvqn+a/BbHBrtKPoCWeDKmK+cLwEzMNzD4AED2jKXK50TDvpfAD8Zcwtqw8AqD6H8w8YxNTNDBBy/AiV4f65OBV5LziV0J4AmG7wKCNDWtSi3AaTD7ABriWWbVa8mIhpekA/ACoGyc2XWq4qyNJatwiOsDMy16wxHIFYjqe6NqIkvrVGaoEmS3/Yf2AGT44PnigCn6XZ5SHJ94Vo6QUGhmIFbFRVhogkVsnPnkwCsa/CIBnAEBtuIgxdjj+oh7OkGCL1F6i/cAhMKZFkVRkMQqEhK4j+gTgVwam1wHBuXqjdWG9RAVjAEE23pjAKcqigp46/eLNVsgLtYSPnedeSw5Z7xvddI7zXF5ZKEPDbgrChMQBPQCNMfYM7j/1rZt27Zt27Y9dNtDdpUGIIUGZlRs+Fm/w9933HFH6ffYoFy5cqX0Hkj/qsfQ7+pAKZaKn+JBm7IE8KHSSIEfT1nWu7HepVRLzXwzrIoUSz33wFaZMBhRVr5uc2GsFDfg9J8BTMB7hd/pvk2s9IKNCzK1M2w2yllEsk52rP+wuVaWPDZs9sGOQLCBIEGBcQR0WLp+UZiA43VWwXLja5hTUzrnZqoI0DqQgezu8N/0GECmFKafYCeI3eMNx2qE6mwKLLQRIyUfPkYzZw1tAJpYWcwrzsTNlbLjatzkrQO7JPxOG1sEdbEiGDP2ZAyY9Aam5dwwZmNaA/WUuRbdngwzyhEMVEIFQx7fZQ4GKBqLgMaoToMHS0YAA4ELSRfnAlggn7LzY/U9UPU9qCAzCgGfe72YsbDLBfg6GDe4ewYoCEyaTsYuIzEJlUm9CgNY9uvE6PdgeVjFxHbqARB0I2KyLby65HoMA+kTG8dgUeG2efwIIIUGwjD7ztUWTYKCzXGv7x5maZ12GubvgUD/+o0bZJ6gQlyWvHlmGN8PA2srFQ/2CbLf8zQ9mdDHCH5FYuIhkILEozFfpXm3a8EUAl0BYs4MxDHhYwXwDX4bB1f2nI1ikh3dZwVMqkbEueUyXMwPBcCUujkrpo3scvaiglwNwPPMyokT6JHnWZAQejl2sVrws1hA/qYcBJQlU9ZXGFsI2BScIcqEn43mFGS+xRpk9zIGD/icXb+BpqpqWF3HcE0IyBe41uk0LRjEmV8RgrwOxxUkYAa8ohz8fAGD8BWcikvsSF27pDmap5RENmzc8T0IMskotUAKjDqsmww+wbBcQYYCfyirkgoWjdZLAqzwWlku0u7eLvuREh8YkDsYwb9hKk1mB2mbadkxgBLzCVIXSxJYNUIL1iwoBGvC2HDOcMPxRygdj/UBgeogy9F073LlSvfKsvvoa3unQTZXY4b10JhsNhbNr6zaf/ysB9NZfj0oQHhJkyN4ZmCTeV+ZYXlZlsxzlRybEupVSh64irHJ9ch99MCmgcRNRzBpJ4B9W6Ow/t144JDjH3MfrEiBT6gyiuTKbAHJcjvt7ptnUpvn3y6NxTrprfkrYlyXJWn6Qx+02cR8pa7up53dIX20jHVWXK/NwRaZdiCsdAHi4md/ExkwE4BSU7L0UBSiu7fjBU2MBSWWo0AMFrlwKTATOoEFZWzChWmawQZyOawqTUquDrk+/eHAlroOxpkVTZCszMYSoJeJ+Sv6Mw7PEBQjAHud9xFVNJ11RkDC/dB0PnwmOfgI43uxuI9vnNADTxV4jelY+ARyzMLPTr5JDoZSCo21BhUSR6gg282AKoH0XXum6jlUlYJWZXEccy4dNtDWAEyBy5QRhvUMLE32oz83AXra/syYqbZ3MAklEzVhTDHBxETEmkkIgHIoDKCqkHiG4PAAbuGTZf1miSQAmZgJkOxOJxNLmKDIxWyWbtx/aHs5VhQtA7yyQIAxPwBt3D/1M68H14xkC56tYPe556X1CRhrnbRsBtmgg/FcN7ziKFYhsJRx3nh2AdgUCKdnQuwHPuvdXJ9tkdJ4bHsJgMCsNO1rhxi/6Jhq0mPbtm3btm3bHlrtIQtKvS/bt3/7t6dv+ZZvSQ/FhocsAmb65Oy6N5A3C4AhNbGHsWnvYfA7JZiTH+KhaePHYI2sH9vESNKBY2DzrlLcOVDolDNoCghYXpmZMgcbQpW+oxvH6fD+G+7LMkyNq/t5M4XzNJkF6OUDSnus9K+xG2BmjY0cNleSPWCXDnkLAApJChBggMbfQFU3lysM4d/iQZRVFjJPIwa7CMQhj6jIDBHUAXzBBpjZbEoqDGwy6ZVn6z14BYVdEo1qqwJRamQpUX7oWVXfCFsA3KRnUHMFwAa2LwDKbDOnaxGgh+ypMUUsW0hpYMOCqxzgO6ACYIY+PotlLj9OYA4Ah7NwdK70/WL23jwlDLQx8IObfd/wM4B03xZJyLApBvhA6RIkXF7RR8dWgIhrY0VEv39iOSBwgbnydGp9NGWlOGNNFfKgAvRUf5h0AWbMKDfNutP5e+HJg03yaDROk+OJAY4I1lhi2xiH9FYCq2Q+T9fvu54mR2NjBO4NGaSJnaTs/nB/wGs3jy0LRue8r2DBIJhbE1ykF0sf5tFmLG1sNDsvBhIEB9clHxtID+kXA6AhMOTsvhvzQOAawGfcK9xvzB80KyHvrAz35clGUrnfUtq7tGfG02C/uNSvNHcbyHib1JCmuT7WEbC0u8Z6jPNc/k6U0zL48qDcge0qg0PrUGwEWIOsU+bdYNYImIs+XWhctyBLaVi1Rqxb8FwiKwAl7gFWMXAD1alJJsEUgeFQkrfCV05IBq7l5GTEe7ALM2UVjcA8wVoDxtTEGZWZKVNUtOp0upmlq7EPoAkSHKzLCNtng2UCPE5zeAfHEXCizynT4jjFPTEZHsYmwEwD4CHrHZCJAACEUshOK83BuHHAR2wFMOgazWmWsgKQxPFYHa1nlUfBRMX1Ys7iuHFdBFtsuhgzOUBpmYPgkiZrbMY5HpvmLNlWvsblRASuy4sjyPC5+nmB9WLvsgiDmzLz9wF8kCwqQVLngKLuQbEOeZKAktpCcpSBIIBj80K+roZrGB2Ps6SaVUnDuoC5Q0auM0sFwgvQkIwYTFL8vHtpl2srvptr+VQVFE1aCUCcrEMHbAn4uKcir4191ktpiGeam2V78ZFq/6sfJS0FA5agsYqD0CvLQapel8xJAAW6fvqUgd2GqnlgfCIpdDLOADLlwjD6b3fSup0ogwbwhPer0APuM9kri3ka7EIua/1DNiWACSRguu6PN5kZgxbAEfy2wKylPxPWtMJPEusn1j8azXshEj0TYF4udh5AGMwReOaRFeym38b8K0CoLLnf4FFWrJ+WAOIzIiTSAJRgTwPAEAdHXwH80t7IpIVeMGAxTeseEib2vIz7BQGFxsxEkszmO9oJCnBMpmnu9weSPiazMOZQwbNjALUx2xo0k5+crNPhA0ccqxi7WKfwB5VJCfiSOWVsU94veost0v1vv5dj/tKdl9PVOy7nMU27AYCL7qelpKbY8KulA0OBRTlfm28XwC2TFmNveMK1btbwJIB8qxyYimx+Jb+iVyie43xuViwjuO55pcGt2fm2bdu2bdtDuz1kQam77rqLf99zzz3pEY94RH4dP3/ER3xEfs+73vWu0uewaUFFPn0ef+Mzselnvafavv7rvz49+9nPLjGlHvOYx6SHSoNcCX/Qqoao2LxGo05t4BF41DF+isyfbaixIc2bOW8Mul2qp2ozp6qqeUAA8ESSvAhC8DwJiphEAiwSVXaDFMmALhuOzFgOC08kBHFWcUsbQgskcBx6wwz62deI53lim9POwY5v/MzI1ExxDaizLL69X+NG5ysZlPXFmj44K7JPuuGcjJVi/dBIXfdkqMvu1zWZdUK2gQBvvS68R7IJ6E43vxd+MdMTeE61aThrxtCo5DQlO4gZ5nYjs1AYYHQ6aXdfBubI/E/IdGF1tZ4BG7g2AVHyx6nKECjn8KqBqsTXdb8aGfwKaOAG2Es4R8YOfXICGGHyhk5aIZvtG04FDpKDEcDozAguoHJXY6cABWJfq7+xqRfjwlhDBbhSeNi0zGcFbCBU92NlqLKBK88FMi2Y+Q+67G+y6rKHGAIh82cCAEwvCzcqprTGmTBkFjo7AX00lPG0suzOgOGxASS4nOvS1YO0f3nP55WxQ+BrUxpXXnnLWDkpjZBpholwACxzIO5AFwGPcA+smpaxM+Qpov6PEi7KEn1cRrBKQUA8LwULAOZUspwAIwzvAyAlqbHGvCq3UTqM+T43QBRB2vUHbqQb912n7POOR93B99539/08191Le15G3gIqsB9S08ALBGz4eTnoUgIlsA8G5BaQtjn/xqMxGVMGygAkhlTP1in4Cs3G8zSfAphqpP1w/VbN0rz3NG4YjDftnjRa1rdxDcScpzeTS3S4Dq1WnN8IzFDZ8eDqHoNPOxfSKXj/8TMqfh7fGJm0E5ynQY9rKgAsAEoYUAhIVanqOphAk2m6dPslgrLj8TK9641vJ1iAsYrqebNZLzUvO5g2naWjBw4J6onBkgEeen0VICAa2TZk0q3ZZ2Bv1QFKcXy4rrwkrY3jNfZvFeSy77fKf7zO8H5WdQNQNoUs1iqBCWSqrsnypQITMXpgIWkB1g885BjQLgww1xqlNc5AH0N1+f2ZmKfEAh5nbUoAcc/l/aPrwflhrpqMUOCDm/YDdIkJJGJ+JskUw4kJJveQwlfv7u+WmbS+NrMaYwdAZSExJ2AKRiUN+8uAMvu4788ySdgqBTzWKxmlt5kUghx0OXcvQU9KpT0DB1WxL0osDQg0Vl9eb+XZ5fJBsNGM9WZQvSWuzLzagPfCtkBMawJtzuCMFRE1zuCBNR7NeM3wK9LarPcu5rZemfzQpKKtlQ2VLuoAAQAASURBVI3lOkN43c+msz31XbEICaTiXGvxzHRpOv3KsMbB4gAAWsf8/TROs6F+KIxhZuHGUjQM1ZiLlI1jjzJfmTWAewnqe7jt8rWN5w8kEq5nvl/COe1dNk9DnIN9H1h8BlgTaMLzAXJ3Mtv8BLx183fZfDNJb1F1V6BhLDgDIKuJe+NAMPobBv5zMrRRhMISNDa9nLHmz7/M+myZxFxjHaBfdZ7rWUtwbFWMvW3btm3btm17aLaHLCgFyR1Ao1/7tV/LIBTAIXhFfcVXfAV/fspTnpKuX7+eXvGKV6QnPelJfO0lL3kJH0bwntJ7/u2//bcMdOQ1hEp9H/RBH7TRTwpZY/x5qLdoHK5NU3zo4gEOwAbtrIcxGQ9tmVqWj5GzXA5KoB9Vxj42BZRxA1s9F/hcgZqtDb4ygG0yG/CnCPh0fcgoogQ6GCZiSWETA6mMztU26u4/4PI5MxPvka6OzV+zgcAC52OZVAsMbNME0GMZmCCkiLsROY2xuTmz7zOgzyUewQT+ok0bI2MYod/snHPgpSpYoX+NSg/p4zwtRovU6HTSDog7zliwanzGZsI1xcpguh/c2Ll/kVX+A2CCDSfKqGPMGygGcA5/cAwaybr/lYKKKB1T/0fGmDbmJgUrKuHoTx63vilWsISGAAvgBwJuboTpA2NSzTnMXVEZiRv1YpPNoCwAXpmBxQBuTlNUMB5koG9aEgOjCEIwu12wz3QM3P+dy3vmwaFgLyjGEMAUc8RYbMY0MGBKzLc6toj6oDzfGpQLMRDu7vJ+iMVYnUuYg0c3jugHA5Ns/MrYCiYJEeDDimOBYVW7afeqV/OVS1o1NyVH9cyzCXtPX4fGJwAkBqo+h1VVMYOCDTNY1tw3PxuwIPCzFWagGTLNcR2IhgkzsvvjcXrgHTfS8dEJjbjB6jo5Pkmr2Zpl3lswraY0ENcEoA+VtcBig2/SYTq5MQY3MO3fdkCvNtSPxDHotUUgBqAT/iAwnacdgL4uW1TVuH7LJYQ+NzQfBOQDIDF/KjMk76Ma6Qp/TKollocVkMBa6bJXBKv9LkEpeCnBhwlAKLRfZmKPOQomHs5zkcbHo3Tt7mtpvlqn2+48SAdIQiBgp1eRmX/PJmYwjOPf/877WQGzt7PDcfzA3dfTO950T9q/NEiDD3xMaiAQXa7JgkCfUS4JpqrfX4BWWDd6fS8t7yxL+V+RNcny8ghoTYZj/jRgJZ7eXkiKhXMjOOLFEVD1cL00loxdh5n5A+SKck6BucaQssSBgk+MG4B20xNIZ1H4oUV2LsC8S7ddTvuX9oox66xEkyVbmfrjw2MCWo3dflr3jAFqc7g8b6zIgq81Yd0QqwUsN84ZyJbBSDsacYzRYNqDapO697PfEOdMt536eyYfk7Q9rptKCtBPDr5IMOWeAYjuUOor8F3vNzB/mta+nsFLCqABjbfdVB7jktV6nfGKJh+fQrpl61IE5vQdeA8KEFjVx6K4SZa41phjYxwBfBVYJVY31lf49wnAM/kpWC7+fawa6mb6/h2xYi7uudbc/JwV0whS5cnc/ASd8RvPKQPqDUvA0GjcX4v3oQ7gjGOzJKP2SpKsSMfqnpDO2rMd82PVWwY5tTUy08ECJ+Bszx3JASlXFdg1MUYRCh+QSZlQbdGe17k6MKZZeD6jQSqM8Q5ADq+xoqePHd1XjJVivhrwdPsjb8ugZZXpakyzYn8Q+0L9SyDOi+fY88TkhXlMeMIiFk3BOIhJnNjPLLxZSSbFJjm47tcWjNq2bdu2bXvot/cpKHV8fJze8IY3lMzNURkPnlCPfexj07Oe9az07//9v0+Pf/zjCVJ94zd+IyvqPe1pT+P7P+RDPiR9yqd8SvrSL/3S9IIXvIAbj6/8yq+kCTreh/b5n//5lOJ9yZd8SXrOc56T/uzP/iw9//nPT9/3fd+XbvWmTSokLQhg0KrGnJGBwgf13AJH0a/RSNmeTBnYiW0SN5/yzUCARjZHvwzESM7D82kWJr3VVjIg900HK98h0KtI6CIlnwauwx43nWJmVK9R52uBtQfSZIa0WEnOqoeb0Ss2e8pMg2evjW5144LrUDY1+7tM4dWCIO3mQctY4U+BGfxNqmyAOiCD0jkEppB3wOuEG1vbTNLHIZgjb+p7HMekmAFQIX2m8KyAZA3ndvn2gqJfPZcIzmQGUsgmx/tcMPG8D8EOg6wKwFi/R4NnBSWssORBPMYpQDN6o5E14IEZQDX3lMF1IGjm5hbABjwvAAg5sEgT1sNRSsdjZsZZqYmZ3EJGg1LUJi8r0/5xDfuXzJslBg2537IPivUbGQ7zAoQ5Tyqg/ipLD+285b0Rq4eprzEG77/3gfTAO66Z/AasDjLIulZhcbZMozUAIsg5E33HqvMu3ptYCYrzrIkA3QI5m9PN1G0VlR31/vh5GdoyW88qegWbTfeWRvdxnvqaYixGzFXLogOIwv1hINZsUfp25Y4raTqD4boZbWMOD903Z2dn4AxOq0wIMAmdBokk5v5qOUwTBHCwjhoOU78LT5kFGVKH9x2lk+NjsmIAbqFqWmfQN/lQv5NmE2Og9QeoRrZLANPM91cM3LSuYgKB9YEONGBrQcYO2FlcE68eeMU0G2u7B8M0Gk3T+PAke8ug2pkpHc2nCeMJ3mKQeOJ3ACsGAIIgQ4Rh/LqVDm67RBm0VcCCIbrJqSjpIauhQfBt1gJrbZ5uXD9OjdY63f7oq+ng9oO0i+IBFXNySYwAGIE1BOZFZMNRnopqFmmVBqig5uBp9njieDB2Rl3T+qExQdBmPEnX77mWwdnmbpNVHrmGezIkru8EpNcmlT05GnFMGNgIdtzCSJAAKNcNskvpr9VF4QyrwibQFMUrwEhD4RAabM+NNSpgNhrGV+du9HKM8wLAA9Y3fA/GDBqeGazGN0A/FXOP5u5eBdWSJDaG1J9xbWCAnZp8f3PWSjOajKNwAK4b3n+LNIfE29lyfF4DaAWQv26kFYonzOG3002NdiMtZ7b24T5hrNE/CEBYSC7w3PEMBmAIydvAjOflkZgZagTSy8kkAQIx4RLXnfhswXcfXT9KJzdGabA/ZN9ybLg0E0xL65NCAhjvhb4TzFZ5s3HsdApQikUFUiPtXdkPz5TifEwWXgAq8DbjmhcSHkoQbGJN5fvle48o3aQFAQDb9Zpm7XFfUf18ZuQ5QK/xir0KmJm2Ryjeh+SZXXPx3Nn0/FGyTWzeKG3VPiRLtGEFgAq2NfuAuvPmvQzV+0p7RHg3utQXHmD5vWS1FjYS5oFaVBaM9hBmAWA+VfE783d4Mib7HVb2H1tgatu2bdu27aHd3qeg1Mtf/vL09//+388/SzL39Kc/Pf3kT/5k+rqv+7p0cnKSvuzLvoyMqI//+I9PL3rRixhEqP30T/80gah/8A/+AR+Cn/3Zn52+//u/v1Sx73//7/+dnvnMZ5JNddttt6Vv+qZv4jFv9caHfsc2SzS+lVl4yyut+MYAmzKAO3yoY0OdioytZYhP0uF9N7gBPwAYETZdkpPhe1TNr2479mBNJM2Kp7zx1+aCJuXIgLL8s21Qain07uNBn5Es3WqkTtPkU2uUTF+tyJpB1Dbc3+HflMdgEzYAEHea1VK9NvQzTEmxJep4XyszXWUL1R/HgzFK4GxjvmpuNlLPfeSZRG50fTMqeYdkhzHTWee1xH7yKoqSoUk2xfLmbr5ql2qSNB3vvAwxP+FZz2q/xe+X75iAF0kn+V7PpCpjH3+n34sNp0012VTwZmKgvigAQ5dJIIABqLCicT7ADvi/2Lkq+F8Edk+1cfNbj+eUwMMFjVwRrJ0hWyJwY/426F8FRbwHzr6RkS+PyUCqzF4CSHV44zgd3XdEgOHS7QdkSPSdIQcmgFXVMoYEUA6ABjK+1z2n/MOz2sbwMhmWAFO+H9JHFkYwUAkMGDNWdzN7l/Lp3PA9nR4ChmKOChCfwFD6/usM1C/ddskN941ZQ18ilabvGqNAn9f8bzZ76dHv105H12BKbddIwIDrFzL7MOl3sBfA63iSRgy0LbBF5bBup5P6Pa9uRx0v2CELBueT1STtD/bNVH6AgLWQGbbHtrbgnFfLaZqzip2BFzCjB0OtyYqGDYKSzPQDFGfJdYDA01xRCqApAyRINoGaOJCDewVPuoOru8ZamyzS8bXjNBsv02Bo4xvyYAB4AF8IBBE4XFrBi44FrQpUl1gzyVxaU6raZbVM+MRMUrfTTZevXiZIi3soEErzAfcDQC8qg2Eo9y4ZizXfE3jR4XxXZsasioxMhsBXhgzBopJkBC7pt4MECEy5vfIfQZJGSsPL+zRflvchqztiTKLaqo8zeZWZpNjmDe41+iw1u6nXhVx5mKuY4j61Byb/HJ2MCGQdXN3n+iDZNVgpVn3UpEwAXigB9qqgVZn6WU3eNmDVioWL71o7QasKblfBYgFhXAt9zuGeiynD8Y055UbOZNKgbwjq2jHoDwR2CwAkVhjteNEQA4wN5MA5OvOJxQsAamBtNh++CDqb3Mp8+uL6f16fnLcfqDJgeF/J8vWiDYsFmYFm4i3D6hqgRafkPmCxkieLfjQsAYQECKsIkzFWMIFiq8oUo4RZ53sesCFwMUqhc8KpVT5e3TOVgOewnyWFYNjJ54tm4NM5mdHwLNOxbN6u0sIBpk3FIIrzawfD8VCcpVMwnzXHWACnUWYcaU9w1n6pev8L+WbBEubr64KRSq+2k3E6fuCIyaXWI01qz7kwmlD2zGqCw35m8+lYkp/TqH9hthWxMue2bdu2bdu2PfTb+xSU+sRP/MQzNy94mHzrt34r/2xqYFW98IUvPPN7PvzDPzy99KUvTQ+3VtrUsCIS3MdRiWSSDq8BZOqknd0+g9WTG0fMfMMQFTIaZNYlkeLmE9TvQTdXcskbw9k8SA7woHfJmweHrDKEjYso3cFgVVTsszYFkgYK4OEmSxlCz1RjJ4MATEFC7ebUq6IZWFAOjLWRsiDKSt1jg9omeGEAyaZzjFlfHtu9Q8QMs/OyCnH4VfTcifIr2yx6WXd4NkwKCZqkAtUKVuoP/RvfSxP4UB4aQRXlJP66mcVaxSJmv6PHhDLwMn6FGXJgSgDAa915OYNGqkBp/l3lqmi6v2gKauULpHspI9dYyQuBR7eJcWqshbhhp4kus7O2oVSG1lhzqAplx+v2+kWg4t5jNHL38uICv3D8vT2TltBHK/SvsQwtu1zHhLpI08aa5tr0tCgHLQZAWtaelRCPRvQ16fb7ZL9gruEe4neU/GX/KRMXQaJDfy55rmA+gtG4XqVLV3fT5asHVt3Jxz08bPAZgFmo/gd/I2TW2y3rNwInlMkZkwVgESSDCFzJKlqtWd4b4wCgmebl1N9HkKptzCSbnygvBoNilFxPqTc4PTdpqD2aptH1EwbKu5eWRabbxxbOh+vJeJpal/cyi6DMXEPFxYGPMZwr2GAmZ2H/uOTTpDeNXPkM34WKZFwbuV7ZmgeGXvuRt6fBLgyXF2Re7e7tZJYXwDoEgSzbTtkegrd26vQQBCWvYjVjENVZIDNgLA0wsrqDXUqz4GMCDzgUECDI5ZIuAtm4Jqy9ZKDafYUfXwcyYciYhqhC1SOzQ74tmNvGCjKG3mplbKsuWKRYy9rOInAvNUjt8DdYU7bOYZ4b+zMC6JGVM3U2Qm+3RwAckqA4psXcE+PIvKu8vBo6Bj5cANYgQwRQ6eNTlf3AIAOQh7G20xymFkvWD+w8AfaxG419ODoak70ELzH0E0GptQe2DkoBUFkuZ+xjqx5m30f2IuSPlG23+QwEMIV5t+7KG07+gZa8UHVaAUJgZUIuKlYmA2cApW6OXdcEEEdAY7CBFaMmAAWdaEARQHYU5ACgiSIaDmRMYdqPYiCFxE3gMk3xKcOzZyTYRhE4kBSeldIg0URg7+CEPXPhG+eSxiD/ZrDfB8CCay6q06pF+ZzOJf5c91wV41jPJrS9gz0bB4GVQ1+hms8rEWTV7owZpuev3o9rRSKOQJSD6x2wjZGM8qqEWlfVj3XfE4FJSEn5nTCiz5USTz8X6xjE9Nfyoh/qt017mVK1RvdoMhsFA4FNthrlcXYuLGCCdYgm9kXVSzWxEwU2Mhnjnlnmi6gkQNnfjdYBYBF6kQHKZ31voabzEYtORRoMCLUkEwDBLC/1mht4PuHYYKBibwn2N4BVeoDCzP0EBTzGBLInRyMrMIA10U3hUQhlMZ16IZZhPrb86FQYY9u2bdu2bdse+u0h6ym1bec3UsJBdx47DdvNuRH8jo8mqdNfcpOMoBklpZdLQh9mIuyU/N2DPT7QD8BwwDbQvUwaCoIgpwmlvPHMx4aZ3htu8ErDZ5dPUH4x7OXsFzYudVI3bSoV+MpLAYwBmni7gbaAJgIAjWbqBNNUbXC0Ycw+T6o0ViOBU/beylFb0HaRxu+h7M6kZBlQwvV79RkF/vEz2vRH8BX9TkYQbHAoPVsx8I1SFXkilDKrZLCYQawAJlZ+4ubcfEGwGadx7jKRLaENGYJsBiSqDkbAycCn6Ecmf5XRMTaAE5azHxLwKmdFo/eFsSMKCSeMX6O0NMr91BfVfaL5OKE0t/nvsKoggBDKNyBxwRhBsGGyFbCKIO0qgqdWSn1jkLCiITbeqIK1Z/KmqixSQSkkKzEIu0jLxrq+wTcmzelxRNkOQAQCvUTeKFWDb1CWIwJEYlXFZdG3lBJ55TwPGAicNuEBMmQmHVI/Gri69xMluYjvCJrC02doRrYIPNrWny385+bQqIrEIBxghSREHvjjXCGrQuVBgJbY/ENWIxYA/ZFaxtAjexBMmQ1yEQZj3VbahYTN5T+nAGmcn19z/Fw1+BFbxIDORpp1UL3LGAMAvhbtBQEMSj/6YiDaOQNAGp+MyfTC79Fopn9bmwGRsVwKhgXGHny7OJZ2B94vxlrBuCfDEMH/7jC1ZeYLs3uUvWelMPR9K43AWqPnHS7KgXJ3xcY4gN8TTb/bxvJsd3CMbrp09ZJ73JkZvfy/APy0O+YJIxYpuXfEhbyCGjyGOtZfk1Yj9R2spVSawbCBL5qjmh+chwCkWPXN+rw67ynnASjm8qS1V8TMEm78B3f+SiNzA9UmW420e3mPYwZVBFc3jimXZJUvMKPA2HHJOK59hWcXWbJY20OSAcH02jydrOS7RblaP80TDZXKeulRf/ORxjhpA5w0FpVdGzwXe24c3WQwXFSq9GqaqkRH9u6K/SfwcxNTpCp3qvPFiY0G/ZAh49nllWRxTf1d8wuCZBvgNUBYgGqolilQjKCvF4IA4Cfz8PxcdB/I8XiW2i5bBqim9xwdjijfg98jzO/t883yuXklyUYAM9UnmTWzdvDLnwExOVNtKoqiSnW5sEfXxpEYswREyRCyIgUYDyyO4j5+ZGyuAU4CTPFCFARUrAolkz2U7fsYjHsGmuUXRvh1+wCdp6pXaowThMd61GllEDQ+PwRImel3KoGcrf2dUyzgTU3FYgx8Q+IC8/50wRpjThu7M0s9VZgkjAMyUuGdifW+gedFO89Zk3oueHx9b7FlkWE65lRZXig2r3w61ccAhMn4w/0FU49jAmucMcCsAI9VLJQX4HJiVQIt8QSGHzz0rICHrbV97muMxR2S2ax+bEk6S9rYOU+bM/NSQ9XRLTC1bdu2bdv2kG9bUOoWbRE4WMH/oN2FEzaNdRH4Dvb6ZCaYfxSCl2467pyQbYIgkZs6bpyWrIzFABAbMPm5eKBjjBr7TgJN0zm3AwtsuNYw6kSQWUiRtHkXgFXdvCJIlzkwN+vAmtz7QV4qzWGDjAKYuOI9ZJAQ/DG/GZltC7QBIFWARAaM0fg4BLTVrLFAouqGstr4GVpL2HssSCxkaSbXgAEwAj8LFMwzyTauZGTJE8MrIoGNggAMATUygzoP9h8ACJU493NkAOw+F821BfJWOcdkHbYRxAbRpBu8XwTxChYT+o6bW95n+BXNmW2Uh5NYc2q8XnOY9WsoLxUG/hn7K8t1/D7kfuuUAzHbqINVZ/dIzKocILNak2XvMa7BAukMe2nvwCpL4YsOrx+lKTaqszmNiyXrzJWKBIy578Ym2QdZBe7XsSlI0Dipep3pOpRZ3jh2AOA4IwtzcrgLVoiXIvegDWyZNABDpgDYZAatkvJi8gHsEIhLORkC0pUBg5SEuU9Zn35jBZuMrJLpIi1bViFNY5flwulDZV5eCHoskGoQqDm+fswqXXuXwdYxj6YszVhH3zVUaivGbJQgypcEgUHdGFLfQk5m0qIi4JXniQVY5idm/dqg4f1wp2CsYI0AKGRS5sJ0Htl3nQuZOMmMns2bCuDFPB1dO6IvF+YimEQIggFydbo9ykcAbCKIYnECrjEtskrwzf39XQanoxsnthYv12nCIMgM5LHerpeomonkgIEovH9YC8kOWhhjCp5gS6xvhak8/v/w2hGTDDgHMEkkL0O/waQY4wBsLXnvSVKpPsSctus2qaQkdCuuryZRUwU5MSh0bxTIar0p5lVh6o0W5d7yNgQrBMcyMAVehVbNr4ES8ej32TId3n/D2bdtJgwkWyJgAU85B2gE7sfgmuBZG9JDk0zakFybybgH1VYJzsBujHNWE2P1V2d1cF4VLE+Cv57AsGsq2Hrm3eeJB/kLtc+WsWmNsDWykeVR+h3uG9YhgP4AFcTkU/9b8gEy2k4CjIr7pvMqzyGby3ifgFMlciCBhOwJ3lrD/b4DWmCvLPn9hw9c5zgAow9szSj9Lpi+WOsBAi2RR8nXrfESn62SH571TBVzSPPSiE7o7AI4skptOJYZ/LMMqXsKEpRyeRZAXRjkr1tgexbApIGndm/z3mJmhQzi6/ojdi3HRfAUQxXR4/uP2a+YgwT11sYqFYCtMWuswoLVrPuisavPtFpFhdTY6vYiMbGlcVj9Pe8R+rxt40v7DFUfxP1SkQUD4cTctuelqqtSzkcWoFhiBRMaQN9sah5wXMMahXWBJIQAo1Xtj2tKx9deVroEoGvrISv/tXvuW4gklDEqkezE75HwNElqg8UBWK0PfmnYe67XZESpkIh9DsUabE+DdQXPTQBo48mYa3lvMCFz0J6JFy9Ks23btm3btm1/tW0LSt2CTRsObCKQkUJme7hndHxltLKHEYxP4bviPhTYnKZhj0EgMn6QocxmYA0h89dO3TbYKp4txWZjjkwXNl5W0QwBGLOYKh0PPyhm+S3gQwMgxMyd09MVECorinchCKmWAKfpMb6XG+s2L4AyBmxGPNtvweq8ZKSKTCneC5DGgv1GWocst2jr+F6ZgcYAOTIF6lrB7jGZijK8Bnjgc7YxREAGSdTJA0fsE1bFc3DOTFo73FjBiwaB03KB/ndmV6NJWQvvgXt/gAUHMKNPnx0cypgOFgQA3Cvkl/idKBMnh8dpMp4ZQEmPEGSizVQX/8bmsimWBUrPu5TAxoxdm5Wah4+O9W1deXZV6clspQAAatMds+qSs/U6ZmSL7CkDARgfezaYvutucAxD6jS1YAiZUlwbzd3JbMC4whiYp2WruH8FSGdsppJcT95gZHmZyS+usy6AwnvJ3PO5U61iF8ftpoYs+sq9cOh7UcMekF9MZCfIz6QuQEFshsCg2bAANUv+UM4eFQq9OmQPkrxYsYhMmXJRAt0v3mMcEww1FkOwudbf3yFIDAnVlAG9navmTAPyNHppFfImXrdLi9TfuQJfKAteBQrFwqJkGIwV+QgFD7LEAgViT7qO1vsLzDmZw9u4cDlzZmt1aPpuPiQeHNJfCqCZMWgojaFvUystISGFUfze0CtAmkSa19dHoGkgGD27WLbegmNUvjt+4DA1m/u8Ho5Xso/MXFljs9eCrxEqn6n6Y4tzW4GkgWkAb2Civ0izzjTtUF7Yruk7SX/Lhr5RmkRDbKzxoXIggXyatBfjLB47s1hSMwGOyEUaAlAU10aA8QDHKI/caZN5cfjADc7zVvsgdZpWaAD3mKbvTZhrez/MbI3H/Mc9JHDrrDrOQ/hfecVVMTDxLFKig+slGL6pkfo7xrJSwQsxwpAAkaRKCQxdryp26nd1YLP5dtkYjszXuhYZPzIejw1r0LV7HiAT5Oqjbk+Xr+6X3sPrchYKnpXN5g77U/KqeBwkDcAQ1ByzRIPNA0vgQFIKfylbK3AcAlZj+IytmRxBfxEE9qRIBI6U/GDQj8RQWKuq11UthLGpb2yt8T1E2/o8+yOSAWzMP4JtvXYugNDsdAPAakDEGJUje8vMIMuAWah0agk1VHvE3qJgD58cjzNj2lhlVmBD0nJjrK7SYmXApY33osok/MPAUBtdO6J/GWSIrHoa1no+KwcmXROjVgArmpjRcX5pbkX5n5JxEdASeCaZmvpE+yNWW0QFYpc9YzCgGAP6Vs8OMpOwP+S6XDzbYoES+ktxfbJxqYI4yQsZ4n6wUqkn6lhshHYC89TmmgpZMnzQXGK/sOMZcxd3xSTamKOWIEAFWzx3rb9wDeZzZ3MzPh/xOVZNxHrLSsSNNB6NKfXD2EBCZrVja/UWlNq2bdu2bXvoti0odYs1BZXcGIPSPkAACvNOgFIyfrQAi9m/YLCpz0NOgqw7TYa9Wg+8TGwTUFQ8sqxrsTlFM0CnkZYOEIkCvlqa94ACpOjTJEBAZY3hlYE3k4EQzF6RQez1zNQbr0uOYtImyfIsSEGTYa2VGo6+J5ZBqzXRdlDNgpPoN7XBqyqwLMynJXGjoyyeqtOYaThkkaN0cjxKfXgMgbo/X5N1ARXbfN5JqwWYH2B7NHkseCUwGMf9cmkCAlQECDA7Rp907jhIA5c2LBYN39BBPpnMH8U9qQQyUF4DttZslm7AV6UFE+0Bz5WgQAv3y8YR3suA2kEcBIS4Vtx3HG88g7fOzCRcXtI89nO1ZbmHS+qUkaWpNoJNHw/c8BI7bZR8IHBvuhgDPQAuJrPCJhd9O0UA0W0z+MA1g3FBZsx6mVYNz3QbaYjAKAJxbJp1/7OUgUEiB+rGSkoAQ8FQaToDAebheM1Mgi2zSzAnBBWaH7Fp8xyrVcUmDw68B6wJ+G8wqKkJimNmutznxjCiDG6OcwpSUZ+7EXwj2BfYgx2Uivd5OUPw0jDvMvhxTQGWgBVEI2sLBsQA4dxpF3JT+buoChsDyjNkPHVN8wjnhnPW9RqLzuY0g7NV0ecFg8eAHLxuY8/73tmK+KN7ouNCvsViCOHemTwNYKgFSwVjxEvPdxG0GmPSgr4px+LOpX1bEyktWqfOAF5FPoaD2X/2miEwDWBgyfLmrOjY6BQ+b/CQ2xumZqdjwATYKu5RpnGHtVqVqnStujZeA7wDW7EiacHUocFxTbXPOHZl9J9ZJQ4iK2jFvQYbwcYV7jv8CU0CV6zbBjBKgtdr9dJqf50GewOak9v8RmVXSIv8fQRmHfDK1fY8YPZriU0SLLFANB6q4JGuozqHDIgqtkN1FbuK5MZmQCpKyg0YcdBAJszoEyxTBFjM2xGJgur54PPweGT/Ud5uXkFid+p8AI5Q9gk2lc9xMqAxNrnWN9P+5b38OTO8X3EdxXwAmKWElfYMKoTAcww+fPDl4lhNzdTteLEB+q15oQIHY85iSUn2rSqwOOdBd0DWNxIpGKfch/D8bB42/Q8a9gbwzITfGPqNADwYg2SE+5h05q/8wTLI2cN1GqiB+3T4wFE6vn5kSQc82+mPuUzTk7EXP/GiIF2Y6OPabM6jSiB8jnq7xv48PjxO1951PXV3eqnX7aZW8MbK8srxhJ8vpHEVv0mSkm1+AQDWGkFWOkAmVTAFQxqsw1DtkMdrFuukxrfG8HyKdQp7IvNdo+ekmN5+b1k9MeyZdNw4H9DH8j7T9+g6AQqxEI4DfHlfhbmMfmzYdTA5B2b5ClYCNv6xVqJCJH+3hzFv+0qBc8bWt3nSajvjsmK6H03ayZTrdrkHw/e2UShnQ/Jp27Zt27Zt2x46bQtK3WJNmTFk5+bwicCGCVk4GMh6Vk/Vh2LJefzBZoYeKanJjDY2BSg1ztLhbjqKTQCCLFCokVmK5sv4DDYQyFiLDZGP7xKbOq+NmIXWhgXABzanAA4UgLO0cQDF5DlDUMgZQmgMOOE10jVfHWxmJLOiTMPZGNowSdYknytsErH57O2ABVH4KdW1SPG3AEkBQbnCjAx9U9qximge7GIzalLFlPpDGE+jutYU+key2HpD82hpAlyBFIobWvMPAoMNLDVtZO3asTGEDA/ZTj9HN1DXRhwBLH4JNhAZCG5orv5EUAVvCAuMvQy5qPwMSCQ9gfTI/lTL0MUsb2yqzAbGTpSjGOOlYDLZeZv/jJkwm9yG7CbJ1RDQ+8aWQbSPHVD7zd/LDWglBVmjGhfNezi2O50iAJ+gzwFCsCR2Yd5cF5ArYDCQFSgXytbPGAgRy7piFbx0/ZF9pM2+ADb5fNSynsL7Mb5RMhyAI+ZXdR4Za8XANPNK8Tk0mbGPiiyw9aX6BeAmgjLrZ68k58EHf08AsZCi0JNrtUydxTIUPbCqeJjzWh/A6sP9iWsMTXBRTc5ZaK09k0fVBQ+xH+LPZDeieijm8bGxy8TKkcE27s3x0QnLyNt9BiNpkHb3d40hpUAJJcbn8MczcIDXRvmyVdODHJbVuVrGApk7SwTgsJhtBAPAAuXaVsh/dT04Bo6NOZ/I9rHPAVTVmieWQxwHBKd8jmguyAjYGKKQ2wAc7qRLVyCrWjOIJhi+B7N5mzttXn+HwKL6E/cHYMV4Aj+WSRru7Kb9y7up2TdwA+upAkZjsIJJZmtMdawScPTguQo4EJAgYI/jYQ3E88QYsAK99q/s+Rrvc5eSX5fpMsg04MDGIYDVroHNeJ6N4D1jAHC+NlSVTPBMM4Acf/qD0x47uk8qtkAj9WRgZwR2NrV4r/V8kMcQTfUBfgL8aToQ52tWrFYb2bgCI63apc2V4e4O1zIZ+1evISZsrDhHg2Nm7Wb0AhVw//BMgf+cFS2wghwCOvO5k6HkRUsAkLQs+aH9Ao/nz4Msrce1t4okFZIq8EJb5YIC1scEpF0uXm1xjheJKjxfnPWNdcfN69nnS2cvahzh2QePNMzTubO7J5PUbHfSoGPPO8m0M+MoNQnUmCQezxQDVXRfKbvD+IOXJhl3tndpOPMaDGJeGwAtMHjRjz2TVHZ6eBb3eP+wLu5d2uX7UHAAz2/tmfg97uVI76TwCI3MJ3r9uaVBZB5q3UPfUgKHMaC1ZFk8VwT0kZHpDCa8lgtKALgOFfWwvgs03pSIqzbMXxnj657EtUBzsTqG9cyAVBTVj1kkwKtr4hzw/FqiKEfX5MgRcNfYwhg9ORpZNUYAcjVzt0iM2FhC64DdB3ZW36TBF73Wbdu2bdu2bXvftC0odQs2spW4ScAmxB7w8lJRZhlGltWHN3T1YpfQEBSZKc9Inwqa8X+eMc1ShGi4G1qkyte1HIz4xojG2CoRTPAjBSDJAh2cQCEvMo8RsTWMnVRUz5FZLyUALt+hF4cHp8qCi87OzXfPGC/IFm8CpQpKPWjnRRDQvLSbzU4jK0Ebwp1gzk7PI2dhMTimKTQ2l+Y31etjswTGiQMt3o/4e//Aq/QEphuamDRlSZoFm2Yi2jGfkg6yopaRRIZZ9wHBqaRtyqhm6YCfh23mIfvoeqWmQjZSzfJGRhzZbMbIz0boYPJ1GRwZmyMGKPHfAqV4/1aomGeZarJmel1eA4M7bKbd7D0GQco449zhkSIjdAYckj3UbJ6r5bmNddFi5S1VTOK1ecCGTXWsyhgrTWkzTYkp7oWDOafAu1CdSeXpzTvD7nfdeCRYCGCKrDKvsuRyR2adA/BhlbgkxwQYu8zVqXQ+5sWDIAf92KLkigGuV9PL1+O+KaVzd1BEQC/XHIAWuA4azsOr5DTAIZmfZEcsveAm4wBTYFSLv3EeABAbjT6vBYEJ2KDg5IyPR+no8Dhdv+dGmi9X6fLl3XTpdgPW4YFlZuBt3oPDa4eJtnmUyk7Zt3tXD4yJ6ZXk8Br6AC66PF8H8PE3WJHoj8EuqiP2KSMBCIO5jnEtuRGBXciPvOABxUfBWwvfvYbX38CCscPrx7xf9Ika9n0dXJCNgnUcYxhBHPoX8ip4I51cP2ElPfg00fy3kdLe1f20f2AeQbgGSIJPDsdpdHicjg9HBKcm+2Bp2BzH/QFoiIAcLC4cB0zO5WpJNgHOR4wbArM2sUuSt3g/KSGFByD6MiQccL/wOzHFSkAkjJVn5lXFQH9dSKoxx/FZBtn0cTJgFJ9nZdEF1gdbe+WxRjl5RdamccpnA9AVB+/jtKqymvL5hXW1kFMWoL4dy/hSkMDxXNz/iuyidHr+EhBm0QH3K2o2yF6VNLju+2N/a81Csgj3TN5iYK8ioJ9NjDkbwQJdgxUJsb/RZznJQikq2LMwprYkVLdla1tmxYV1GuAPZKsFsAoformBUZ7cqYLMAkD1bEM/YIzhu2zO2T2CzNX8KU22F6X9mGcCQjiuWmBHUeVPkEjPeUkWVYFTCTywD+NzSv25sztglUw97/C8NKaV9lGttCILGrJyK8YAhhJktOs9MLrtmvf2d9mvSvJU+597Fr/PEXQpr+2V56KD93w2oQ/c3F3eerhfGpMAOrm2eSISv9PzHX0jcEpMaO6nGksmAOsSJnVNUl7K6y/4mTj28cyZda2apEkxnSnaZkUW9z497TnIMeUyZsr4Q79WmxjRWpdQ5RZgYKd9doXlbdu2bdu2bXtotC0odYs2mJIqoOLDFnL8XNGuXpIh4CQaZ9ZtnlkS3lkSOThhdruVGi7rupkm6UIssQxTZTSxm7iJchlT/Bwld401wRFtNqoSMgXM/D0YS84+qGYCtcFl5ZeK51HteSu7TMPbMuND7K7qBilmytWYlc4lz9ep02rT+0DsJHDMq35MaGKBRVAqAijVIBHBSpZkIWAZtNKKflSng8lqv4jdI8YZutDYagW4WfWRieerLCWAAPMeWRqQSCaDbdirTSyYKkjFoAD91LaqfmBRCDATW2/VtdLYMfut+4tAHME9AhZs5CG9QzRK82Xvy1w9z6s46Xx0bQC08EcNwXV/4IwHyVwU8C0LYErNKoKVgby6QEQMPsrTOC7rZXoC1DKQ4+xAAcccjwQULaCCVw36EMAaAgJ4kCHbDsvZGQ3x7bwYiDqQYGwXq/im/lRwKPaLpHmSd+I+jyBPdQkwEGaCg41ENpWBFQXTBe+nDAgyEK96xrE/b6QJPEDG+AwqhAGAbpPhdv8770vj8TxdveMgdXt9D8AbBIr6aZ0GYON0nf2JOQNAuAXT6znNx8FIRDGI0dE0DQbdNO1P0nQ9MZlfp5t2DnbSfDZlsAdTd6ytaARB/F4jcAe4N5vCiHeWvWGMeWPmvQvIHOlX4/M63zzzr5nPxmm96NFHCQEugSX4QAE0bTUpD33g7mtpPp2kS3deJdDBSqpkpXUoQ2mtTIa4XEKqaesyJT6Yd2DBIgjvt1OvsUMGSLODio0DAgCcn7NlOrpxIyV40F3BnMC4aabJ4TiPGRk0y8cPfWrgpctEw1yuMiTEpAMDYgBvp2CCrTlD5ifky/47+9mOI08k9EurU1RENFkZAE+rJpnZnLi3ANBdUpuZMP68oQ+YJz9o0CzmUKjuCABALMEsRw+MzTxXo6SpZd8/4+vnG1SLIVWqPslkQXlNJCjv51L1PjQ2kK0rZq1W9F/qhjUhnK8qrsmXUYw/gsIO/hAQBeDi9yCvWS4Ji98f7z09KcFcgxzdX59TJtvhdUa2mVXJK1i/qhCZQasgt6xj3ETvL1ZmXNscih6CBFzwmoPF+X5tyJdhTVdio7Tv8OcSE0IAvYY9Y1KCEeiJpuo+haOA63YxvuK5y8uy9BlPkglwqz7b1eeU1sVxBcBtGSV0JukrP4NO72tsX1AwODcBNXXVIsUw1Lw4y+6grmHu7UFG6mNQbMXI0qs2JXwIHDYvs//h90WvVN/bqQ+U2MDzzOSF5g/YpTdVMR4ebu2HfuiH0nd913elu+++Oz3xiU9MP/ADP5A+6qM+auP7f+7nfi594zd+Y3rzm9+cHv/4x6fv+I7vSJ/6qZ/K3yH589znPjf96q/+avqLv/iLdHBwkD7pkz4p/cf/+B/TIx/5yL/Cq9q2bdu2v65tC0rdoo3MEq/soowwA0uWR7bX0cTYiUGh/IfO8hKJv5OXU/SXqDbJvUwOU2zMsifAakWvJWTJQKWGgXD+LDKuoMyv59k4GZ+H9xVMwbFvGu7tZACBwZFnQbGZpgxQ5a4ZRMMDyGQlYAVVQY+LetxEv594nao6RaPuRZWdYuwVfY+ANZMLrOnZQ2bUutyvkt0geCHg6H48EZyQXAvnRR8csk4Q7Nj9lDdQNCjVZjJuWOUBQiq9v1cSAFZhg3dUnafKojCMl5xE9xcAAHw2VD4bgALNSjeYi+ag0fs5VrlCcCQpIb4N1w0ASpXnZORf3U+LhYMxA9YJ5YKtVhodjgzMdCBwsbJAiH4h7l5dZP/LhrPVxsqK0zlBUprsI9hEv7jBvipb0RvMr10VyWIwI0aDBSVeTZIeMWMr/707JNstn5f3PbLuOi9e78oqSlkFtUKmQ/UNGYcmSWO/IjiFGfXxkv2KMSZwGEAPjoF+FgtP5wzfMkm1yIwIzDOev/zZIJt0ttSSmW0L/AszfuvzFjLXBBwtoMd3SoIIrxsCZe7ncnTj2NgPkKq12/TQa1Pa0zSpJua9WDSrlFqsuIbA16rEYZ2BPxHO7eAOSDqseh4N0U/GlKbOxmNnIFi1yRgcg82y2oHnjAGavR5khBjbBWOE7DvMV/QNTsID/UJu3KZ/HvqegGLDzmtGkNQZbqzqhrkOEByBaDvtHVxKEwBmU5MIch55oIZzkfyZ6w8KQ7AqKkDSlHYG/bS/t0P/NXwfgnlW3lzO0nKKcWQFMbqdQWpfAmgJmTSqqQZmZwDurVIWOrh5JtBqcxrVvPBdRR+IGch/U/LGWVfqI64jkIYej/k9BkJDlsSFwMYjpFEdlzBlRpoxY1WwIUt6faHCeVT9kTTn85qIymMLe1+0jKp75umZqzWI7ML5nCB2sUZKLmfnOAHg11izkmiVEaJm/kcGfsiP79Qz30EtsDBVxVPBe5b2VRg59serVjrYgrFAoISeeVYEQ0Cr7i3Z1/QxsoD/tCy/nRZkWtlzjzJMeC+2F6mxa88kMPD4bDuZmjR50C15E8YCG2AAEkiveBdW+4ASdppk21ql1yWBI8DrlTsjUFk9Tt0zLv4cf88CDJA6eh8J2Dfze+sfAdh65uo71nMHdJqFbJTzCv9eSjJtoDI962qYtaXzDvJsgTxgn+lek+VZ42+IZgz76p6t2BPxHk6R0DFGrUAfgaWsOJsM2Kp+1t4jv7yaseueXLRicNCffmi4j/36OaHnhvZDaEgysX+6BowiiQUTf/QYzpHPaE+yYC9VZZo/XNp/+2//LT372c9OL3jBC9JHf/RHp+c973npqU99anrta1+b7rjjjlPv/93f/d30z/7ZP0vf/u3fnj790z89vfCFL0xPe9rT0itf+cr0oR/6oWk0GvHfAK0AcF27di199Vd/dfqMz/iM9PKXv/x9co3btm3b9terbUGpW7DJ/wUPZmza8VCmyTGCQGT/QTefuV+Nl2gGwAPWAQIvAAXcxMCw3AMF825SZayy9wlalQmipo0Jtf8IusiMkWyqoFMbw0MbfgNT9D18Lyvc2Eaq07bNC6UakAYxAzu1kteeFZ3CrJM0fWxE7N/m4RM3madp3jGDvclPKAIBunZtRJlxpj9P4cVkwN8yXb/vBgPKg1BJCb8fH42wC7UNs1cstOC3yBAyIJnMrPIY5ZmnZYUKWsxfx4NQr9BEI9JOJ61oYl7IUkyGZ8FRvCesUEavneJ1BBSozojvgVQjepqw3yj5cGnL2jbqGHOsFEZGmW9k3c8BG8UY6MRjiXkh+VbMZoPpYnwgu375T1h23cZGHVPMXodMppUa8MxyaSorubnJdb73XrGI0g2XDNJvS74xzdNjBoEnQBJIL8FaWSCAHmFctlOLwWA7rXuQLU4Y5HYHAPcwR1GpSaBp+xSrTkwUHFcSRAUdGVB1s2d6Ca0s8MxBj7nkWoU175Od3X5aLS2okAS11TIWDNYLMPYoK5sYCxDMpg6YKe7nJuBV4LXuv+YVzeRhNNwxE33Mb7Er6ZHlkmLETDQCd7NxGl0jgCitD7xCsroEamu8w6QZQASlR2B8qfw45gAAJweqbUzBsBdA24A/A5DZPdj1CmjGPBRLBOvP5dsPctBN2aezaTDH5X8GGbSYGDxXVCX0PrEAznzbOK8hCWQhzUaaAlx44IbJ8yjtwTi0+6NAGaCtmHesaDUYpDsf2+M4k0/ecDhMq36RYLAAGQUqzG+qYI66CT2MrwGugSAClkELkisDePsDlHIHewDSL5PKaf1pXzkIHmiFiby8sDRPMnOpRr6ruQU/rdQYmkdgYP2JPQb2icYRmTLOUGLgD0YZgMymgfD4PZgSBKXd7w5jjc+A8ZR9wH4U60lV9YK8maxN9wCMgE1kp0q2nJm37sNEo/jggybgW5XoKH1crJg0We9YpVD1DccRmS7GBgbogomjKpB1/l3Wj0V1100tSgw15xrhu3U8MVHEftR50eAefeXG/nXHlw8WmFmSLcaGtQzs0enY1gIA9QDsTRq4TjceOOQ9AqORayNButOsXTTsTyC1RZIAMr6zmC1Z3hjPNVT1JGuXPmfOoAlMo9g2AT+570L1PktgGNg6ncCzbWpG8ShE4PcJUk7MXYHqusdaP+WLqXkn1pueO2KhUqu3QVpePXcAywI/1S8xaWEMOcjZT/dpfv4EwJFrKUHV4meBrATA8czkWEAVP1gDuHG55sXUKuqdJZfDq9yD+N4k3lOBWvQv8/7gscHKI3BsySasqfgHC3TgOzm+UHRhyrmGRBQN03tt+mmdN59uxfa93/u96Uu/9EvTM57xDP4McOpXfuVX0o//+I+nf/Nv/s2p9z//+c9Pn/Ipn5K+9mu/lj//u3/379KLX/zi9IM/+IP8LJhR+Dk2/A7Mq7e+9a3psY997F/RlW3btm3bX9e2BaVuwYaHLjKPAEJUSa6xNtkKyzdz019UV0G2EpvD0Y3j1Gpbufi1jgPpDbPDCF7dMJleLg5UuHcSjxs2O/IbMZ8O83CIG3u0nGl3hgsCRKPwg7lQ+E8o26ugR59FgLl7adcCEmdUMKOP84aka4Xy3ya1YTlyMgdUIdDemxkavoGX3wnOiR5QYUMuCRolRR7UYJPEDDQlUSMvVw9pl5nGWmBj75uDbQLpznovH1MZepwYwAtE6axiVsneMUiFQTn7b70R/GOJeTd1JXWfXlEF1T6DEIB1WuVy0QJX6AvRsXOKMoGGjxWCYzBf9+/RcQ34KMpnpwU2l8hUgonVZKUwBvxTZx2ETGcEIaxjLNNeBw5moAWb4mSZ3yp7b1ND0EN2iJun29gtvKyiBI2SyvmCptmQQmF8ElipbKjFfqAvkwN8zNazUqD5YQj/VDCDqnRW6aksd419UVQVc6koWQJWY7t6vWKuqIqkTO0l8cwgXQigaTB7PE7TyYRyKILRu0OCP5gDqHaF+7ReG0BMlqKPK50r5pQkIgLLWC1tsU7LORiLzsxzSQa9k1z2iQCdpdPdYH658GtgX4L1Z+bMqJ7VdmZMnncud0L/7e2dnqP0TuuZaX0eM25UHhmROhaDylBxKs772DCPKTt0XxpcMwGilclI6aVFz7IOpXUIRGeUNy9YyhzXjeqG8KIiaI2ZSEPfeRpdP2GQ1L5ioJatrVaylMbKi4WZJJNZMuH3wL8mBpNav6xKZZkFwrEHhqJXymKAjnWJrBHzPcLxqkC3VfUy8IQALVimSDKMJxzWkL/EwDj7f83ADoL0DlI/WyMJkgGskJzLZWP0U3JgS4kKmW4X97Xw8ANgr4CVnn59Bb4Aws0wHNdlJu0GzkUQN66HmIuY39ngvIJ3RAaSeSY6+KWEieSDFXYVKpphzYQEEuBzHnNggrmZOZ9H9N2yRJL5fi2N+eXm3XntcikrKtFNJ7ZOQ2ImQE/gga43Xme+/zWyqgjW2XroSR9nkNU1rfNai5Xc0Pwqjol5b5YBeq7rvKzCK9bBdmZG1wEsfJ2/cwDH77vuhwCFTaBjZiati/kNNqWKvlw0yRefd9W+MAahreXm3VeW/1ufuCQcyQHfD0XpM6r6Yb/Vgceis5TF7NO9iPsC8yY8PddjUi1KNq0gjAo5SIIIYNfA9FOVYStMbe2/CGBpHZVHGtbCNvraWKiS2aZGATrHNTj2bTxfJYToQ4hncPBcZJIE+1HKh8HMBTvWnjfwClwu5844NFYw1zjsO3YMZIffHxJAtg5iLIJRuLI9W0Xqf6s3JEhf8YpXpK//+q/Pr+HaILd72cteVvsZvA5mVWxgVv3CL/zCxu+5ceMG+/PSpUvvwbPftm3btm2rb1tQ6hZspc0CynNTRoRgYpYa/U6aLWwTNxz2UhubuRY2Nb202l2ZoWivy7LAzGfSWwcBupVQ1+YcGb/JBBK4KZlLYuZogy7Ty7xJRIA8PD2cYiadFf4EaPgmShlOVYyxzKzL0ZBtrGEMmScFygmb+SdkE5AfzUaTbLZrZuxBrkDKuAWWNOD2TXNzr9isYUM3HU3M92Knb+wxSBOmDrw5CAUTbWwoEUCSQUO6OwyU92myLDNOBdUoux0zmLHFjTY2qpBCkTmB6mee4dWmW/0igMJYCWYOruNw09WpeKCQ1LX2DO849zHZQzARd+ZKF/cG5+oBfLVpQxf9OrBhFKMBsRg2kWvPlIriLymDfuaG1FlVBHQqfRF9YcjywsZ0A6stSml03nkMhPlS+hyNuu11nMv4aEIAiSyXuqy0g0cKjFkWHd4ifVS+NJAwshZarX7puwE05SpKzqiSZEuArAK9KnuidB6qckkQ1ECbOrZFlFzYsZGRR3+iop5VsbP3GbPDvrd1CrhE43h0pg3vNwIOVcf0yl+SfYItAUASn+nvIIjrMijivWv2zT+LEpdFGh1NOG+wHs2PjlmNEqDs7r6BJurPujEo8Ns89YJ3zBl9Vgd+1r/fZJf4B/qLVbUGBn4hmGy4qTvBESxAKEPfWKf1rJ1WcwTG87QEEwVzgBXOjCHK9RFl5btFNUHKLuHjBZ+7PlhWRdCmAgylcasxRm8xM3OP78H1YYzqutHM8LebgUCYp9Nkex8ysnIpeqwTmJ/X7r+eprg3eBagCijkqljzOlaOHTcS43gCOTZKrw+7DLZRGKEzQJDZS22XG9KAP8nn0MevvI0ciNT6hUaGiQfbBM0rDDdVV+U8Jyh52ouvev/NoNyqSJ41t9SHWD/zGuTeX7PguQbp9LAzTF3IoBcwODdpkkBvAyccsJZHVaNJhpT8ljatsQZArVlZd8I+c0ZVuMd1a1ROFGn+ZmDIWbMOYOt1gmwuZRboExMQeqZrbVc1SgGLURJuVSNtDFEyT+lXJx1c3UuLxYDP5zj39HmBbAaGtPh+3PEsUXRQGwAvZalgPx7sZKA2J5EchFD/2bO2yUp6EciJ9zn2nzHeAFwYe7HEUM3P5i7lYuwfNxSvrr2svDfscS/GYhFIqPhay+tcm2RtPp+lSQu+mn1+HxnO7lsX+0nXbwkRJPOQNDLw2iT8tkcxLzmTAc+QFKBHlbP+lBirMaFH0z2UPNeqGlv/675Hz6fYL51uuQKxKvTFRhDaWciINjTOKH1HZcOQnOR4oOn8khUCLWHSSm0mBlAYYCc11jZeJJvkcXD/3Nzd9n4A8wf2jHc25s36oD7U23333cfxceedd5Zex8+vec1raj8D36m69+P1ujaZTNJznvMcSv729/dr3zOdTvlH7fDw8EFczbZt27Ztm7WH10r916SRNj8Eg8MCcm5GJibjayzbaXzjyDY4d13OATq8Y4ag0aOCDTbY8zklO+bVYxVvEIy1/SF/dOMkTU8mVjkGmyb6ZpheHwEONp2QaHETGDKbaqpApuBdDAwBUdkfKGxqqpttbYgFWsUNETb3uGZsyAgOILidmKE1mnkHIaNpsqvxCL4+AIwaudqVmZNaMMaNu/eHNrhW0dAybfh++GG0BlatR/I6Y9GsYSOTdsEUciZQXda+2ur8i5gVDObAul5cF1hMq7kFdMvGkps9nDRCFm3wFUzUNWXHcV9wTWTN7MTzWVF+gc05cYToK5bLj684Bhi8I1B3kBHnAklRq9XNJc5NkmD9kc/NS8Azix6C0To5kMCguiY/DAAi+O5O34JDBYbqt2rfx9d0PpCbmr9WEeCWQaZgxBpYPJHNpO8lOFfxX8nyN42NtEgzeuU0yfTTBntTk3QQMgVsuBGg4B7u7g/TcHdo8tVgKB4DAYA+AFEFPiioNAP6wmVZoCnv72hKqR4AN3g8td1IXcFsQ+CBWBSrZRodT1l9DpWqMIdQ+QgACeYMzf2Z1cbaAqZXmxltABiUQU7telikwJlJCiI0FnRPxBRRv57X4hzTPY2gV5U1ZJJDrA0IImGU7XMPsmhKZF02C98v917D2jhDgEVZLwIl88UiYOLgC9ePvkka89jiXHBja+BbZHxaFS2MixLbJwRuHQd2opl6lipVglqxl5qtFfsc7C6ABqgkKJZdrL5qYNOYY61/e4cyXgSPANhw/pojkFit1i5DI9gB5hSYZCv6Grb2BgFcWHHsY0zhNV6/E9UE6uMJZJUqC5A9Myt83YmyY44rm0y5Ql4MPPGMk8ebHcdAm/F4YsyrUMgjtrh+GmvK5bz8A2lT4QnE92GI+HHsvA0gpcTWTeAFyve6VjGP3+lLdBzX+n74jxHQDOC+xtGmMc6aB7m6pbHjLIGiQhenP0ePQ7DoVpjrXVZCVAIkGoiT9ernoWcen6/uT0kGUcPug1XTs3UC195DMgx7Ad4Pe25KEiaWFj0lUZFTMjkvyKJrwzmOTpAsMiAnJnIIqOA8Fks3uS78yyS7A1MN35Q9DB0UifsJPvMqTL7id2WAuPqMjX5pXIPXSOaZxDg2ANRYE+mfCVYpZGestmrn02oZA4usKbPbs58JzuC5baAsgCczfDcJJtae9Rp7FPdd9OcP7y32gYFJq4bjEMxy76iCtVtn0WB7IL03ArYs8uCAZewXPfdtihrjFteD6xe4ifU+y3C9ojKeV5jj2Pv1UX1XbHwV4IE3HsZZYANPRvBJHNHUHMkQ/Aw2ex8FIdx7bJOZ+rbVN+w3PvdzP5dz7Ud+5Ec2dhP8qb7lW75l243btm3b9h5pW1DqFm222faNOo0gO6ndbNnGbAdZIiv/rM1IfCAbzb7wC8EDH5skVVwzrx8LJHs7qN5lVHiCUpQNOq0aZZ19gxpBphyEc2NiEhg1mWGqCgxaBAAkP9JmnabmNVI3C/is+hgZAtgsgZEgWn1XgJEF8TBeBuMG/hbYWNkXFxt9bT4HgZllTKdWarBin7EyTCpXbN7kd6QNWbyWeG11m72qf5GYT+tAMy+y3ji+yWQYGLjchWXAfVN5VtNG36REM25IEYiIWREN81fYnIZrLJ0zQJngY2WstXZKQ/NC0WkwoEFwrwyoB24KEuXlU2X2oLcE+NX5rugcaHgPEzJIPloYc26sC2YDpQH2vVU/GGV+9RrHzeUCPBTjgMegRED3vbjfkd2UPdc8+BRQUN0Acxx4JUX6OnVMakHfmWR9BWkP5VCqQuZeHvj7xKViLZdYWZ9ZcAEfDY6PvZDRdlYKruP4xglfA1MDwQEYOgAl+l4eXteGwJEV2uZmHovvBmtFfcCs6NgMfgHIaAwjY4+xie8auleKKh5FZiX+TTbgCozNAcevGJGScchPKvaf7omND/Oao9ywxsRYhrwIzMFWMjmeSQgx3vH9ZGU6OCSpiTGfLAAGSEYPMMhgUHJ9BkNeM4YG6y0yPE1CaYwIXSuuXeeFDP5siiDSAiNVpswyoEaTrDEmEcBGcmYS7idYFAZSG9ilIhAm4TPfKVyXeVqZlxruBd5r42LiAKTLuMEguLRLhhx94GoSAeibgzuvOKvOvk9AYJQ8Yi1BYoCecDg+XkPxBbFuYPgf/ArxPEI/cozsDg2ooBzS/uY8bzVYwp33H9fWsvNBn7LqJtcnA03B+MIYNGmh9YMa/InAruEzZqdYewS4EgjcGZBJHNcC3D8Aa7z3LTP2J1gGudXA2GYE2PwayQ7y6yvGqHnumNl0/ZpRWkvdZ0jMm6YH3zR/Ds8irV0EdwJQEgGRgslk44cFMGqYxlqv1h2T3mku8Nrc5y8CwEW1tkKOliV9zkqS7A7gguTIk6n5LqEB2FT10/jMtX/YswNgi/peIDlAUcoYAdK2ANgN8tzi3+2iwqCqB+p6bT3GOmn+a9aPBRCoa8xm5Q5+nsXUrGuS0Ql8lKysmhwi2IzKns7CjPOPAB7GjMshNQewTooxbmznGccwnt9Ys6wKMwna7HOubwHQZ0LPGXux8TmPcdwIrOfwrFW1S8liF1N73kRpt+S0lA0CuHbvMj0LNa4JHELSr9ckMezaM4MsfwLLDgS6ZFjfnX1JcyVDKzBSVM3F2mfHA7MqrcAMs3G5Xt1clcBbpd122228rnvuuaf0On6+6667aj+D1y/yfgFSb3nLW9JLXvKSjSwpNMgHoyQQTKnHPOYxD/Kqtm3btu2ve9uCUrdwE4hDpo1X4sOGZHdv59zPwfyz6VlfbjS8ktqS2TgLGqOPlDyNkDHFBggBnwAHeRbFDTY3Wc6YiVlgZfjEvGCAh6yqVxUrs6GK8sV1m+rmoDguvrfICvsmHHRxeKW4CTc2rWY6bJ4GkTkSs3zaCGFTxizioFzxppo1FXtAQILOJ2eVQwW00jVQVlIGDGMAkc/DN6iSqvA9BB3cOPkmqOkmTWylFYGEol9xfQjycEwAEZGGz2ANrDc3ToKnA4KNeF+VwSyVk/ZDRIAOwTK2nQqW9HlVKQI4iiuuMmViU5CKMQ8GYEka4h4XlJZWgLVcGatlY1T3TNn5aiBSF8zF10r+OJIcBa+O0jmD1YiNu7NNMDcaTfPVUMUjeJI19gepNWhVDGYNrCSgRYmnVS+yTbib0TKbbucfmV1Hh6N0/d7rxnhkdcY12TJmam3yTQGa8h7ivAOYjMAFoJiDYIuZGQiLxSNAGteL4Ah/qi33l5+ngDyau8MvZWbgT68Haa8BblWpiMYOPgdwDhJbsEnMxNykHBoXJ0cnVqGy0UwTjAEwQyH5ItNswqC5P4CJvwPIS/Ojw7WzsIKvcxjfq/UyHR9DnjCjlxgNtV0+g78xhgUOwdQfoIt5mthcpfQL1TF5MSZfBOjFKmNuyk4JK+TUK8gZZ2kG6dYEPn9YVzF3WpREgukDNmgb1SSPYZxvkif6H9G8fpZaM7qskwUU+wzfNRuh2AI8+Ibs6zrQVGvZ/v4OExCQRMPDBewFVceL60UM9gA0xWOh5edBy6t1YYyuDEi1ZAEqPlrwTqk02DLzFcdDk+CjJU0AFB0fnpj0rd9Oy5N1mh6PeY8FwjXi97Lyo4FHHKM0+DfJFead+fR4Zbngf0O51DEqMQL8sEqdNIl2oBgmemCSzhAM9yUXLld1Xa3AFrJ13wp7FIF5Xat73ebzkl5lMqjWs4DMYe+v+LyM6y4CeqwXWtPMcP20rJlMuR0rClA8ayCXLtaPKvtOr+nv6vNQVdKy9No9JZlEWFnAi7VKlUk1lvhsa9jzB+M3JwE6nbS7555L7iVUPRf5lUVAW/si7GWMMWesRAOiHLDyBEVcL/XZOI433btSywk9qzZax9DFXFdCbFkDBsoHcd0svnexNhalFaowsJfejyyMYPLVbiP4odFLtCgQUucxxnvve6t4P6vPNfudXQvkxRoLAiQNOEdiw9hMANMWc9+vISEysaqM+B6sXQLXwS4ssV4BIKq6LJh0TWPR5b1cSCzl68Ta6AAnrkXea9xLegVZFe3YJO29lRvkpE960pPSr/3ar7GCnvoFP3/lV35l7Wee8pSn8PfPetaz8mswNsfrVUDq9a9/ffr1X//1dPXq1TPPA0xI/Nm2bdu2bXtPtC0odQs2ZU21Ea4GCCVg4Iymz6jSlh3b5TMVECVXkln4RjKwWSR/qwOOqg3HkFfSeRKtug1xbGdR6uP1D4attIAMKQSvqs5j5s3WjxGo0KbVAp6y5GtTy0FDxVw1ysGq5y9WTDUAj++JUha16j3X5846P2MXLbmJR0BcbWTbwe+oUqnG+mvOQFWSmLpAi8CSVSpnq2OxmBl8Sk2wFComv9yQnmG+q2vMZt80+gd7zFgrPB8CgX7fuvXeUPH4VRahALLI/LNqaKdBxfjZOkZibMjyAxhaB2kRWFoCLGm+3jOD8HiuCjw1NhGgjycIGJpp1V6lFhlwFpQAXAH4GgNZsHjA0OoOhwRkxSTKIJwXSvB/kgHJDLUVN8pSwFmamZzPfy9Augqq1t0v/H66mtPMu7lcptGNUZovTM4zd4AHpQchQ5EHC85fhsySaoJZBjkG2U8TMAWuk2F26eolsr5wn04OR6wyCpBkDkYB/Ffc72cxBcsATKhV2jkA46JBc9wxzHNRqQmBmjOqCAbNF+nk8ChNTmapNwR41EkrB50APmBOEGCkifsijVmNceIMo7YFWmBUMfBK9F2aTRCsOxjSABA8cLZYO53cOCaABpDJCk+svKImznOaZqMZCxSQIbcE+xOMqxbBOYwvAI5gm4AtakGdLegw4W6CNTZDILxIy1YR/KJf0G8m0TOjYgAzlAq76fd4ZAxGm6PGENLzoW690Wsx6CWTDKC3wBuwAmkerTXAKrCuOQcKaTTXTponmzcWQGiY7LNvcE9oaIx5b1XlyDJBda4BZKvm3bRcOxidTKYm0CR68aEZ683AN1tfnY3rwZrmaqMCHmj8c17IM8srym5ay3IixK8/9iPn1dK8dSQvz8/6Cohi88Mr1TZNOlywOB0oELO1xuw6MrF0PVVfoLoWGaK6HlxzFRDJQIczlsfTJQFv9aHOgcwwZ4tVm9ZAJrDcCzC+jww+J/FFICk+I20c+f0G47hSmTeOg+rfF2l6LmnsnDUv0DgHGmYWjjWN/Yd7i/9i1T/q16zIiPZD7X1LOla/o+75dJbX3lm/qz7XIktSrGrJDvNrDhzGc6F8rtXls45j3gHkuDYAyFx6ok3fmZlclTUmJuqU6NvkayUz9rXvEx5u8j0wlJ7+9KenJz/5yayQ97znPS+dnJzkanxf+IVfmB71qEdRYof21V/91env/b2/l77ne74nfdqnfVr6mZ/5mfTyl788/eiP/mhe4z7ncz4nvfKVr0y//Mu/zDkuv6krV66Yr9q2bdu2bdt7sW1BqVusifLPMuvuC6MAVJuY7GXAPXWRKYqbjQhs6WdjyVgwumljGunbp0Ah36AoY7gpaDGzWvgQFBuw6sYjnjMCcWwusLEpMV+Cb0G8NgT98RrEhpHPBTf33aKaGIPLwDbiRqeFzas8Tc7fnOp8mdFk+fIiMKtWc6v2hTxv8r1YhfLlNUGLrj1ugOv8qarnBw+RQvpVnwWu26yaSXOHDAZVpjqjI2wz6FlKyAwAHHS6JusAuwkZ07r+iJnYTeNHLDGCO/RYcgnlWhJKB1Uqfh66DvXvMtlYyCBUDcCJ8wDIQKPnvnll1QJYNb5HmwA/Sq8gw2s3jS3lnx06YwE/Z4ZHDLBctgVQhZXUYCjtVdEkcQKzBT5q6ONm04OkVUqXLu9TfqSgT/2gSnfNNdg4M0rVBGhpXJp3Ec4LPnIAqws21HmbfAUQ8EkanYzoNdPqGAiiLLnWMzBmGvDLWkPK1UqNLuYG5BdijIHoA6bPgEwOVCg7uX6SgRsENnqfgC2sDqgwiEpwO7tgKnVZQRPFG5aLbmoCnFhYX4NFhv6Evwlew7QDIwosn24fptVdymbQP/DmazQG9LQD2AOPOl4vJDmrlAY7QwvKWTzCmFToU4BSR9dvEBwcHuylfmCEUJo1N+YcmFxgXaEfAIy0d3B/5mk0Gqd+t0fpZWvWSqPJiLIYWl8BTGnAt8l81vDdYGRBbjlwltcKSih4/lSAbxLGghfeXPJEVuC0eQPA06SMAL5mqTPosaJiZGLomaK5FtcRXCfYDHpfmzGuV1ADyEXmbZmNpb+7yb5Hck18L1iHAG1xnpJmzRYzGw+Q/njAqrlEJiJATzDy+H4cKzz7/Fkj9l0c2xivMsLWnK1lOCmIbum49eu+WDIxERIbQTx6axXFB+TD2OuUWQl6Pq2chSe2CQEy/OfePSY7r5+vxl51MOwCQAzB36MxvwuSYEpyMfeAGLHyb3Ed6hdj4VkxFRr/V/YXm84tjlPJtVAFbtN7s/F52IsUz2aTGOr3eGaIrZ0Bx+BJuGn/Er8vA5pu2K/7telz0S9NBRvIsuKcKSfh7Dxp+OmsLy+uIIBKZubhmPq8+dQVr8VnVPX6rICAWTLouRerLBqj0fZT9n22CRDLHM9hrhOQ7OIeLXEsMHORdLHrKmTt9clDsKGqiTuda+yT+JquSdLuKiuMx+PcsSIj5yU5b7X2T//pP0333ntv+qZv+iaCRx/xER+RXvSiF2Uz87e+9a2l6/3Yj/3Y9MIXvjA997nPTd/wDd+QHv/4x7Py3od+6Ify929/+9vTL/3SL/HfOFZsYE194id+4l/p9W3btm3bX7+2BaVusaaNgmWl6jJ19uCPr9GXScwGp0LLlFkmlVG/nzZsrLSZOwuYijKpaslrfYYeT/BD8o0yfsbrkgvGTQaOCU8YejDsW2l5NFZcYfl52xBSDtax67Iy5Ku0NjsK35xAVVGYmltFLN/w1VQwu5lqLbnCnAcTOUsoLx33SahK+FQ9yPdOLvMpZBGxT2Mzc9AZP0QZBP1PUFHPqPJVcERMCFw15D/sv7B5Py8QMcASfl1GiQfIQHNS9+eJ/Rb/KBiE/KnbXZgMiOCB3ydn6MksPRtSu4kzgo/IYlAzdorebyAVN8qQNLl8ZRM4xP7D5+CCs8FsWH2MoP7k8Ni8cyryAVWflJk/Tbpd7oPNeCmo9cpdHBteWc3MoY3dhMEZDWRp3upVlCALU9Us87hqp07DDKEjcFyAzQXYpDklT5sMRlHqW0j97N7ZvMpBzcx8Qrowlx2YdCQGNgBIRsdjBjJ7B3unQGwGiIsF5XbH163wAqVzOztpZ3dYVHFDwAOwT9XWnGGCPsdYm3uVQpPxNlKvaZIVy7g3OYbk/wMmULsLNo2VbwcLaf/SLkE6yR9lwi/fJ/jMGWsQlarWBDoQXDdxrlgD8J0o8jCyypWtjvlKyS/IPI1sTIFJBUCiYKVYxTcFZlZ1zph8mocMEBcAwPAaPp84TwbrHmV9kBlS+ngZQCS8jfqUN00h3wE4s17bmshzsHVg1VinDuaBg0AMgLE2ecl2lavX+m3yQ6ush/PZu7THColWodOAaFsvsO6u0/HRSVpeP0oHV/fTHlhavn5m8KRRZhmKWRWTBAKMVMJdYHqVTaJzjJUWee88mLb6fM64ILPO1pO4bnAtwjmsA2Djn8c6VjVwLoBSk98JHBAIwGIfzjhFv0piK+NoeTSi78gCqbCKtFby/OWBeI7hOp8v6/pqm2Il4ZytEqaxwpiAgey75lmm4N6el0ZvxfUI9Oc99/OO9059M8YYWNhn2N8Vo2zJ0sz7x9lr7nFpVgCnq/DVnaPAeRl4W6EON3EPhR0y20ughT8HsT6DHUiZLNZA97hS3+kzet6KGYp5RQBlg/ytmgTKUrRzwPrsO1izN6ptmPt4joJJyL1cUbVV4JKBnF58xhMUGKOQmuK5BMA99hWrD6Pgiyc06Qk1mac11q9eo/S8KgzNweRNRcIneEohoYH5gR4Ee3PlTHuMmQzA4rVWvWxYe1QmrTwRp/0AGJvxHhi4VVgXxHtZxxyj/ULDmMkPxwap3ia53m/8xm+ceu2f/JN/wj917XGPe1wto3/btm3btu2vqm1BqVuwYWNAA9BSUBmMxgOFP/oTxAc3/jaDymVJRiZPhE1AhcAGVRmrMxvmJj34+cSgXxlTSuYEoIhmraymb3DFljF2TQG2KZhgmeSKgawFOybPQ+DP4I+by9NZSL1fMqSbbRmcc8Ny+L6A3VB9j/kvlGnm+hykQHZuRllXkKIsbpU1pgYwBgwJbPaz/4NfYzVzKCYEf/ZNOSuLXbDR+BvSMM/sYsxIggTgIWYgI5hH49NB18aDqkN52XCUGyb7oNVMl247KLwqxIzB/abP0dyDNwvwwahBZt6qGBmjg5XbcJ+DpKiWWaaA3P3QdH+i71euQDeZ0Ux5vUypu98jmCGTfgKeuOcNPz8E7Lk6n4OyDa8A6GbjDPB9o64ADwzAHESi2p37nekPLIcR0LWcEcU+hvcOsr6VIJ6BrwObCvo5v3Qvgs8VrxlzH345XvVIIEEeo4xLbW7KG06fBSh57zvvS9ffeS3tXdkjgAQfuxKL0SulmSk5xkGffYjgSAAAjhUBhOzR5Z4gFsyr4EAR0PDa222W/VbZdTE9aV7t8iwEo/CekgQGn9/hz05NcG8OjLfxaJxQcaALQMvZCwyUwErrmhcMAC8wbRjIYX3hOSNIt76np5abPNPEG5JDNwBOXVuz1+kKQUn8AdiOc8Hr8GyB6TdAqAwmeJCL8wOTrkHfJmMuwE+pjWeAM41s3XCPHXgnsThDNw13+h60W6DIW6uqoRVPHQJPCFb7AGFtvAtEINuBweiC49Q8gwBWmVl7lnQGpgbAg5MbJ5wjg70hASwmRDwo13hiFbEafyICJgiQyaRqZxCZa1p3nRpLjP8iQYKxRbCgwqQgcNMpVzfNgASfO2UGsIADARO4D2CaFckcq4TJNdQ/j8CfxwP+AsYfmGXwZ2L1NFufKTnORuEI4GHybBLMCBpXG5/Pfv6lOYbx5UCY1g57HlgRiPVqnrrNwsOIySCaW6OwwtoKg5CJYwBSO8umbN4DlEc/ALyAHDY/j1aJ6zqBDQea6hg5ZmxvoBT6vdMljduM7b3yo+bheUypyOphNcCG7VO0ZmjcYyzJn8jmItY0MzivsoV03mJV5etreZbIn+tay0uMnUqRkk3XUE0ucZ6i589JBBVAmz/2MJbAdHX5tO4R93FMIMwLubMbvHMsLAFU2njO94rVIQ2Q1JxodbAW2BzXOrDimNR9LZh0ZCovC0CbwLyD8HzOh6SoQCtWgnX/t2r/2D3EMxRXCQDbi324HPA02FRmrwtErQN2lXCN92Dbtm3btm3bHpptC0rdgk3yMlUJy+V4XeKDqktW9tuYKdGoPB7DwB4DPWZeJQobOAYoXmZ+kxRsU1PwnwNr0rvN68Oqs1glu9iQbbUA1oI7bRIpuVguyIxAwBcz2Wgss+7ZPvOcQUbM5HPmCbVMc5aoNsAhZmoXTjHHdcLLhgat7UISyM2ZB5RxU1MFM9iXFW+dXMnOgQ6x0KobMtH383FDV1dZZzKC173DteiYCsSwkYybYB2DwSj8gIK0T5vaizQDAexcWU4dAZj3ASRJAMgETlY3fvD6kbQqVxCaTtP4aMRAqAPWSZBTWOBmHkPasDJTuzDZGjfJHJd2LyGpwu8BPqBy2SbphNhXqDYkZksdUMu+YSVKkxS1Bm0yUbTZN/Nv88rgdcMAlpvoQoqjoD/PCb+meFrGkrNxguA9l69HAQJIlIa9DGaxWhvGJqRw41maoO92YNZdBLIsq+7VwpqBOUBfGfQfzMS9zDrvEzfy7uOzNsbRBCbPyaReuM+wkBDrKvYpAQDMpx1j88A4HYwRMIhi8IXPolrWYHdo3lYIdOQTVPEGiawFBf8yXmZ1tcjiQtBEo3Cb+2rDXftuSFHA5LCA3cEYr4qmuSh/NJkwz0ZgjS7SsDkkuAEGl80lq+iJ8ZX2C+BtgaDYJXrW96iqJ/83C/xw3vw3x5iZwYuhhbXKiDjO8qMhOIJir1bp14zxxsp/CEa9cqHGgV3rIsvOIOXO95cBN3s3V6rielRh65zXxKhEv2Gc4plx6fYDFrvg6wHQ1/vg0wUWncOaJfeeqocg7qEYWqqihvuF9UTzjdcUQFUDq8C2tcQDQBLYP0kmxDFUqboJySHXEQTRGWT1+RtA9Rh0W/Bu/nVgBKpvwV7E7zJD1eebjmvJHQNRWVUOIIyvobwvRDJcB722hIwSF3X3JM6T6usaGwXrrZ1mkzHHhwAFPYdZsS2Me4JCTUiKDYTgdzhgj2Pj2cpKb7M5mZsAlfE780yDj5kBS1ESpucrwQjK6GFyPeCabcbT/jzx/ojJpmqze2HeWgKQsH+gd1ZIPuQ5if3Q1ObFmgwxVLJdE/8s+Vs5G4qSOQfH4jNAa0QGZX3Nip5X8hZjAmNqUvB4nPw9zhzUs0EenHEcYyzkseHPcxZroDl/K02miaynPV9/rDDGzAEmA3JsTBZzBGtBs9XP1fHUxCTWd2N/RWn6sB+Y8njOF/5gYh4XoGxR+a4kwaasvJCk53kLafZZaw2L0LS55kKC3ulBkmvJkqrfphKZkY0OtiXmgVUTLn//Fojatm3btm27ddoWlLoFmwJkbHaxseo3zLNGATw3Fh5Myi9Bn9PGiiwkp/6jAYCxilwKzMsyjEizjyamZ1HVLchYpOnUTIGt1LUxJ+K10PvCN9ml4MD9MhgAVEzX5VegjRLAEXyfAXEAqdq+8bSgTmbmOHds2M0XxWRZ+CxBG2zulR31azYpIyQABagWA2ida1X6gU08gh5sDlVxp9rqsoCF5MWqiuH8cS7JgSfJs2IAI8njaDRhkEa2CHx5AhtM5vIGVADoMumLDEstq2lVqyCDQVNlMTEFiv53WSCqZS1naTqxIFkyMY6flWWyJbuJUhTKhSBDGkBqNcjAR3FsA0kpQSAoZ3IKApoAYpzJxyAMBvasvtTifJAUxwICk/cp8EHAlT1ExJryqlwReGHFRvjldADyLijbIrtH5cxxbJ6vSb8gM8R5KqDm/Gqs6HuE75IxfBXMNZAEfj2Qw03SYHdQkgYKZG6wgpgFcayqlYbZT0p9yvdzbhe+ZDbG8mgryWV4X0IgKS8wVFbkOqHMd2WM4t/IeF+967a0f3k/zSDlORyl8Wia2SR6n3yA1LcMXLx0PGhGUWpjAXUo5+4m22JAlOZNRSoU1wV9N2SHqLxHgMMZFLhGyWVNltUsmEXDblqvcJ86uWKavHh0brFFiaiAbKvgB2Zbz9lgdIgqsUR1HFYVO9jN94oSZl8DYUze7juoAQiUt8fmJ6+NUjvM+UVKU/cAPItpU8POqHrV6X7F16Khse6hgD29T2BEnD+SVpPRi0qwuzAY75fYVFpDJRmzsbBOS3pFFdXB2qmoEpaDa5d4mteOsW51n/CamISlZxMAEZSJB+PI2aViFSsY12ewjiDoB4vQmHzFYSiJhWzZQTr4imFssXIpxrgfVxUQKV1zuZHGOe6jqr+aDM3lb5XxHP3/eK7uUZWLFaAf8czyz+F8TNJuhu68bP9OrEHwRoPEVJJEjDeY/8dqeDoHPePxOax/rGhIVqXNF40BnIcBl+b/Bsnf9GRCRhY+D4afqunF5xXniyrgOthKcAx7GfcIE4uaz1T4uzlbUs/gqh/R6GScRjdO6HcmgLC0/oBZSzDFxpr1L/rSxo8YOnk+hHFftw6yz/GMQlKr180JstgiK6/uWQ9gNTLJsSNHf7JgAeRvq3Ya3Ti2ggle5RQ+eaiKif0K1nzeXzwDMXY9AQiQiuePGgteeTGeex2rSHsDY5UWnlx6f9zbYI4hWVjMv3JiR82Sfa1TQJKqtvJZ50kbeaOJqUi4DveoGarlegEasV2jr2hk+lfXpG3btm3btm176LctKHWLNgYwCO58MyfZFjOQOz0DraampbdY2IP+4DfDn728NNkZrSKoVBU0ZQoLo8pycFVtUVJk8kCTX3S6lvWLmwQrzW2bE/7BJsvBLmXoxNhSi/IubGYQtNn5O9uG1Vyw8U5pgfNnMO/yKQWENOyGH1PXpFde9t7MZP1cjNhhGylt1sLmUhtItLoNnijvWdZ1wU0S+uv4EGDGPO3u7xhoyM0gss8AElNqgMnSLeRWAg5ZZQmgJLxOeqgeZt4QkkhJDmNgpl1/u2ESCLDFGOT6/TB/EgBNAIFOmxZbPxpjSoCgfoeNPv0gEqQpZSko/g0gSuWxde4xG63glwGd4zgdeATB3ygEJGTAeQUgjPvpzKQ0mRXggT7mCAAGsI8UfE8hu5vM+Hq1VLo2z7wXN44YdOB9AGHIdHH/I7IN0VfrBdlC6AP47DT7FhwArMGsae+36TXEClQEOM0/wzb1DTIbWeGOjCnbqAOEs3labPYpP4OEa7c8H8w3ZVnymWIG2dk0OHf2pyQnDZj42xyWrxnG+mBvkNk9+h36qTCnFRvDgB5aFoPRswv5UnFflMnXvcmAtrNqclAUQbWaqk/WzyZzVGCt+3OWVMZkejvuTVUAmIX3W+Enh75D2z3YMaahA3lV9kxs7HN6gdl1K1jG+pYBUHnahPdV50EMnnitEzDwpsbQbLXNt8hBiwhoUgIJ2SE8x3oGVNX5BuVjU9dX/FwtklAd99XiEBk0rFTa0rOkatoNlgMASgTNOFexCKPBsvogmqQbA6fwk5F3jsaUwNp8DAdTEdJmFt0MAb09V4Y7YZxgbaFxvAEt5qdoJsgYJ2IP2pwzj69Gv2DNQMqG9aATGIcEogFIEFTBGj2jhxreB7kbmYN4HvUFzNu6cIwqi85YwnxWOfvqGEPwj+cTgCSZ95NpikqMYF/R72vN5JLAMKugiYIFXQOfvMP0PC2NYYx9ArjmRYTzETMOQI+SOLZ9MNCg1g+IgF4hzzbmaycNdmwc1D0fxUSOYAWeX0iqLCcoRIDiGAay27PJAH8ktuSfBQDMnvftCphtc0WAhZ4x6DMykFAYgabe7ms2BpCzIOCD+3ZqnlaSFnG+CPiht2FFWimGdgT74jOba5zviZr6vXy4iNtbkhCJLTwPIsMcCTXaLAiEd/ANz8zlEvfFAD5LPpkUWXOWfe2eaR3KkQsWoK2X1m8YHzx2KMhg7zPwl9eJ6qbu14UxiOeFqjer/+JnI+PY/NcMMGciyKvRil3mSHMGx7WGU05Mc9ACTM+m77jOpvaIRf9v27Zt27Zt20O/bUGpW7BZlgibeJhOYuNSlrfgQb6cWcYUoi75h2CbYxsEPNzNT4rBOv1HOvSKIZ0c2XBnU3CTzoN7kFg5D2UfyahxM81IcUfGDlk+ZVfjBkUbMGVvq/IFZUoX8EcIm0ujmLsvFr47mcltNwR6MjZlZpqf80p4Ln0TuDHPm551YIhYQG51goyBwmo2nl2NG15V86HRcGanNAiAKLA1aaGZyUbDXjVJK+UJAlCHm+CQXecm142/FTxZdTWgTgYQ0T/HM9QGUhkouKD8cRCyiXb8TqcA4/Be4AtgHtEkF/IsN4zetKljoNMzD56CNYb3Fv4idQGJsXSM3QVGUWTkaNPKewg2CsZ3p5/ZVuWNv/xEsLlvZymOPGIIgiLQ4rUV18D7gnsPs32XmdWBhQACp5NFmo4maXc/VhAqmGfWp76RJivFrgVzc3Cww/ci2MHhCTxNZgTMGAAcmL8UJG44NqVMnvlvkD3jTLVgnr+pZWaB3wczr51Z9a2OyXj5nophubLSMmsGw205N9nadAyj91E2bEYjq2jg59m1DD1YCTFbzkz/ZJ5a7VXquVdaZqnkPoOEBoGlsT7ggWJAZeGjpAAcjLNGE6wLAB1yp3d2kIKshRmzN3zcRCCnWkI8ngOZJatVGu6bbK98/4uqXNXPaQ61PVgi2IVCAgF4r76vDuxXUMV1q28VBnHWKtbQ3HMZUqVaah6HzsLMrDOXBo5Oph4c4o8FjGIX4Z5ird+/vOfgnfWTACAWMkDFxOMJgQIwugDaaW0V07DEIgmABQGU/R0Ck1bMwOahAXSFwXK1r7PvHYAJmE174YK8NoL1IeCzuWS1Q4IzlKLa+OF5uFQszg1cmyrY6Z6KMaXngr6L5wdzfGefQI4Ifzn0xc7+bur2DNAjyBNA2pPpLF2773qajaZpfac9l8XqlYRO92jNZ8I6jZtTPiPRZ9X5zPURjBSusQV4x2cf1y2fyy5r5jrqctW4jm5aL+TtKLZyBIjiWoI1flNCJRZPsKIjJj3ma+d4U2K9FlDC56rvMcgEOhql3rBHYAp9YAyYAhSlJ+EYBTS6qblr14y1Y+/yfp6D2STdATbsdex+N4pxxucHpKAGRsY5rjmm862yB22s9FLHGcylvYtLMtWvAmCj0TmP74CqQFuBgkjicT2EjO0yimgUhV/APFuR1VlmQ3PuIZHnMm6tLZkZ7dJR7Q04FmvAcjFZC69FW0P07CbQ2jEAUc9OAWIwzV+0GmnprGT51cXj65w0fuDZhcQD2FmS7hb3oWEMQICJACOxp5nDuF7sMD3LimRCfL5V2cnbtm3btm3b9tBtW1DqFmwFgGGbcZkex2pi2vBZJSBz9qCpqfu6IAuGTTb+mCIJXiDu9bMyiQICEWy6sNnAsx2xaqsVJD8ppfExNodTSo+0AdHGDY0bX5XsxvehhLdTusngcMYCNjMIQyi/oFGrl6mGDI0SvMLfCdXclFlbLWA0jU2xTL1tEzJixb559rlh1rCm1DODFb8+ycL0niVKrGPjtrb+nS/MkwMbTctEFubkyGSiPDvOH33Hykxumk3W0ciqPFWrLUXfCWyesfkDiAGggywlv69kTHg/5nMEGERzdTsejZZDwznhfC17DiNU81yQUSp8gBgggR7vm3S8joAY7wGQdR6zy+6xLSMm/0Mp+WJjWf28Mp1mBm3yDWZinemWYrVExCnYqLZCdUjPjmtzGwOpeB4RBF33C1AznzMBK/PZ2nSN7IMdM+ju70BuWParUMP93ruy72CVs0U6nbR/UMiceE3oElP/cS5mlkET7AubE8Xx8TtIYzxrzPi3YBlRNgNGjZtai0lCkNfBGoJHnrXO5udVs3+CIIW8bjZb0kPJss9gXNgcxT2NHmSlcVgBzBRkZQkVl6rTLAseAyzF5dp8r9oIVAoABo0MFBjrN8zIl+sXAiX3c2ms7LwhMQIohfEd2Qkxy57LpENqpHKX5sBv7LVka0wE+OqCGspqfarJbLkKGKEJkND7VIkqVr+rHpfjnt8LxgfGr1exm0HOav4+uEYwOnQfcFyCJlgjIV2Gp9bxmD4tO3sG6GIsca1qNdPoZMT3kyXjbMU8RtXnC6wDJu0SsJavy/10MvAc/Jt0TjI9JvuFZtKbWaK8Pt7DCf3q6G/jXmL6jIL6KHVqM5dhDFG9Dvllf6jy9AZaWfVF8yIig7JhMmUyjFuNNNwF4Fau7qlikvouSn/x/OkVIH0sWiDm2c7OTur2IB8rPBDjPMlrXcdkcdVETexDrD3LfuFnpdeVVInyMjWA5UxEMBFka3pd0/qJ/wQ+CKwzgBfSbGMdYd3T/Y9VNiNLhXPWAb6LVHQlwAEQ2O8h7ouYL91uKyUA0NgfYOnrwXPIvAlNogYDdZNq2TixY+J4EViG72ZOGvk6HddY7pOwz8GzfWYeRlozImMsgy4sgDHlforAt9hrAqCCB2fuE0+cWGXeoghM9nR0RrbGR36mkWXqVgsLY5vHNYYG+r7e0+fR2UwCjwSSKXnFSqoy4wfm1G5yvwLJI8aK/MIwDymV5POzLKfG6/RhC1Uli7XPEmh4riHRMDoyT7nBzpD7mLiW5mt3dh32nXg/WGE7+zt5zOYkFNZEMqDsOzpNMCrtuaZ9mt6fnysYOAVpbtu2bdu2bdtugbYFpW7BpsyvJAi1bJSw4eNvPVDgRgmbh27bsvHcALUp28Ix+3vDtKRheOHlwc2K+5ksABq590N/Z8BNfbuLDVQRBHJDy42uZXCtKg5kSmMGSwh0IYUi+8IDZgRSBMsmczI8DHhqpYGqaQHwwGYGWx1VRhqgH7DRsoBbzarzjdN8gg0bNldgK5lvAbP4IYjSRk7ZRDNtip4PBoJkPyEPZiV7RONGGcEXzEGxsW0Vm8ECIED22H0QnBGgDV8VKDA5SPma9D35vDy4rfrtqBWePG7AqsplNdInSAEFImHDT6mDm29r4x2PG81ZJUVTcByBk2opdHwWgSc+D9kAWQvIemMcLsEIKGQqxmTw/vFxi80rPFwQ8NGfjJtX91dzmZmCIvVlBE9iq/pcVfvEpFGddOnqPn8uNvvWNzyGg3jEjFROPUjY4rXrPks+xO9AULG2qkORaZTv8dKAAZOZmAeYfLvQ75iHNhZdRuKMF52vxrWBhcYci/fTZFhmqstqWDz/tQXfDOQtiI7jLo7DU+OtDpCSWT9AlnbxWQX6AG8t4LN+1BjS/Bi6xAYMoh7AWlzPeJ7WDIZXaTWDd9eYf3CsGdadkVW1E+BimflVOrp2aLKuXbCiDPCB1Ays0cUC68sytVcWCIpJoQZzfguYDWSKcrkoXYtgFhhLEbggi2kxZ6W//mBgFfUqxRP0R+ee2aEI9I4nxn5roN/mheRnvUrXH7iRJifTtH8V2k7rs07H/KcI5q8MiOaYvu1yarWsgqUq/cXzEHDS67UZYALsjsG+AKL4c7URgIHUCp5vKgTg/VD/fpu7OXkxg2eNgeXV9QdzHWMd54l1YO6+Nt6JBB3xM5jAxpJscLyojwG8Yh0B4DbY6TnYuhm8wb2lbLZimK3jCSxAf16561Jxr93bqm7dwfgRY0zrSvU6ba2o79s6KVjxWfMq4prS2QwO6TNiKnEdXaAioLF6jS+ZCFSALYqfwMbV2I/gsdZpyo6ZCDFAyOaFMXOQhIrgX+FJZX58Gu/d4YAJkXj8ON4ITHRwzT2rJEim9un7FxN1se+0huN7MYYkXYx7grrngVWSM7lvR1SnDZ5tvJauyeDxPXi+zaZeqMOr35nU0bcFofIsXgQQqTEdJa0EtiUxxbqFBBIl6MXzrDo3yS6aoOgDEnzG6GUCDkD3eGrsUq438t8vvBYNoDPQEj5XfALsmg+kqjDLHwqMPgDKfD7m50GDkr45vsdl4AKysHfrZp86B+RYRMT2NhrXuD5VC8TvxabKjPxNa9HaGcMhiXmRJNu2bdu2bdu2vW/aFpS6hVu16ltskqQJWNBraMrOAgAQewA/Y4OPzbcM061qlMtLcmbPaf7ukQH5h4L6mBEG+0bgjYINSgQbE5OoBNaFMshLL2FPTxYG+TAU7pWCdgaKffdg4eYKAfnpgGmA7HcXrIIONyXTEejfds3VlivpOCNAQSCDCpeDiMWQ318JJvm3B+NoqoyIi1BgWlQUOx30xLapWp8a5U408S6X4VaLWe8evIvcsDeyDDY1STax+QZjrd05XXmN3lXKwnIDaX46CubFltO1ljf5+H7bWLJPCXhC0mbmqgpuxK6IARiYbwBqdB06rmQqBmwUpqgXaWKvRN+s+FpV0sXrh9SIshOY+9p41TzMHjiVaxeTKUrBGMg2i5LqpXuH7Leb7wNYZcLYQadCmojPghlmAWh1XOo77O+CIZgDewbos3R07YhBys6BlX2XHBjtItXaxEgh8wBBHn2ECsBPzAtJZ42NYXKy2GdiA1mFRwNl0ADeaGzOZm5+u8T3AgyepePDEwLanV4rndw4TOMbo7R7eS/d/qjbcoUyWHPB+wzzBqCU1kAwiNAXAHywPuzs7Vq1xYUBZfLZuX7vDZ73wW0HJnnygFtBroJKzBsEYfAXWi1Rjaqb9g52c7+fHI7T9XuvpWbrRtq9BFncLgNwk/pBwmbzBtcqLxete5AzmblxI42PRwwoEQRC5jYh2Ivv3LGiCLhmBrmMoJ3F6mye3QFBVNzzOqaOgJNVljvdnCeL+kOMirpWZa3aOMCYbuYqXFx3Q1n62GJCgB6BlbVcUrJmq2BDWuDcMeYXmRom6YpFCDYBbEoUsBriqmDUmQy1SBD0eiZdo5cimJB4bp7Vx6pm1ij8z+LauYlJpcSE5GnxPcZwMTP8i7TqmmHrL8ZcAT7Vteq1K1FGBiiqFnIOrQqvKvdai89NScdZ7bNnbNF4XtWiKGhYX3BPchU477NNCYj42eK7y7+vk5idvmdWedH+XQB53N94IqoKLnJty9VYi2IBa2dAkn01naVucum52zHE7z+dcJvCUDR1UG3OqxJveqZzzYV8XBVXnTWO76CXWRPPuMKsnIxpJRLDswOfR3JQ/ZOTLJk5Z2sl95WhwjL3CWC28WRaxriFsbzfBHsmttPepb1SEoMFXvR8IChnMtrZFIyvzbLQ0v1EUtaf1SRfd7fG59u2bdu2bQ/ltgWlbuF2FriQvQsCSIKHc8yeIgA8un7MBzyCo7iRaAT/E2bCsAnxDTyCgBhIx82gwKfoC6CGjDsCLVWQi03SPx4nVKvTJi/KJJjBW1vlGwBFyMhXN7MwxcYffaYHORxMiWs2+bqWEmOBfhDYIJqELoJHdZ+XTwKCSnvRMCwrUW3SAAIoTfNegOwIx40yLAVwZ22uDdxwwK9m4yzQxDaHuAcFIKnKNVXj8uq1yDeiDvAyBgTuT7kyorK6ddnm2K9gpoABIbNgOya8Q8ybqnoMNZw7MqsIIuFxEjfsEYR6T2ZCCQJVukn3OoJv8XqrgUS+dpmMh2ioGnShMUgDUJzwu0ZqMbg0lp4ARQVgAFgpZQGbytlN1euPptRi/hAwhTTLTeFxD1crsC6XqdMGELJ5XdkUvJvEzKSieIvAX2MZGqtJjAACvvj+5SpLg2K/VW9hNCsnsQDZf/QlCymAhZVSF2yeXjdNJvOE6QHQCxUBkaFfLtapO2g78G1AswXOq3R0dJJmKCkO0+VlM01bY5MFqbopGJadVprN5wnL5mQyS0sWb1ilwd4wDQaQ2hprDcbLYINSigIAnOsYTLLHzooA6A4UE6/BEHtJUK3X7/OYlOKgYt2wTwB2NPLqnR0UfFhQsog1GODtZDojcxASPXwHq69iXaG8CcHbLPXWABnLwDn706uMbfIJiveUley8oEB8ve7+K4iUh2F1ndHvq/IoNSZBeL+7ZAWSeeNebZEV0eubHxzuseZhBJIFNnItC0CPniPwhML9k/8SQESa4m+YQxrvBEKWi1IlPAIJLTdtDp/La8QZ8uB47E3fed5n6j4bWaAXbZx3fi+yBCocF7Kqqnyv7tqztHPVSquWjLXdU6niMZWTTFjr3J9oU9NzLX+Hgx9oYuxseq5FibzuL0DvOoas3l9XCRBNZvF4zSodeuEUf0YJAI7NQNXTFerwPhjo0zML96xnoE3dc1fvb/QMcMVcZ0XLM/pMjfsK96iMBuSRIa1WTehoXGguleTyBCJPf1/sL92nmEBrNBZpBVY5+sl9QxtMvHj/NBsE76ejcRrs7RBEz89XJ6uLSbip6dkqlnuUAm/btm3btm3bQ7NtQamHaVN2W8FsYUxbNYK0KmfVYJkBAap0YYOBv50NEk0+0UxCeDbQEY8bN7U6hzoQIn4m/q1sNZkfToM/b68BEAN/NjUyOVA1JphscuPLKnyFh4+q6dQFZGiUSyWv+MONEIxqTQqh96GvwWpAZpUsBxo9uwHvBb04bIN7dgWyeD+ZWQ3lwc9r5o202dw8sofOAreqG1ydezWDb6DWuaeVfa82yRofTFPGu+ofFD2u0CLLTMGQNt9xPunfpzb3Z7Aaq43gDozP6VtSgKL83dyqJ+I4VuFMvk/1Y0dgmIz8NbfxGQuohgy0IKtNa1TAtCqZ9v7CvytX9BtNMosrBlf8mWxDN08PAR8DIfVfHIPuaVUtQ98Icw7sJowZeMPZOYAltaT5eWq0Un8HTKShyXRbjbS7N2AQQ/kJvgumy2tUmeoQ+MHn7nvnA2SFgs0xujail93OpWFqtjv0Wjo5uTd1u8ZKAtMITAKwEvD3EuATq1o20mw8d9aGnStkkPiDcx/u7abhbp/rClg/DJoZhKW0f+USQRMAK/j94T030vhkltr9drrjMVcxeNLx/dcpmervD+kXQ/YUvIoIyCaa4xNk53zARzppPgdgZuyo4f4Off5m82mazmYEtAhc+fo9976gNG1vZ+O6AKBtMZ7w+vjdziitzsNcodWXhiqogXGLazXT7kIuqPWc8hqaLoupZ2ClEiPVBom5zoPBcgB9q8wRzRmTpMJXz/6w8iQAWlbrW6XGwAy9Nz3LBKLEwLxunUPT/Ky2KqNHwE5ctzVPNoETajfDCL1IO+s5XH1un7XGGyiW8yEbP6/XN/yqtpn0zrwLxQCWf9BZn6kCqXUJATVjbxkbmAb97r/JsVtJRhBwU0JmXfhPVcdI3Z5BCSCsjWT1XeDZgPdUvSPFOEPbtD/B3MM5Y53W8+u8VifXvsj+IZ6PJNtiihsL2OY495huMxCPq8QFAHEmANbGBrOx5hU3axJGF9mvbNu2bdu2bdtDt930ruY1r3lN+uAP/uDa3/2v//W/0lOf+tT3xHlt2wUbzSdDZTk1bcxt473IJaiXK+h9zMiSUprbjOHDrB0zfzLnXBg7qg0Gj5keY6OBDLwFtl5RiWWDUxq2LWisa9VKNiXfFUjcmIHsbSypHF/nJp4bndOZx5ttWXYjVhk22TVBDX156CVxugLh0tkR+Dz8NuImHZ4uUa4gQABSIhif43gIxFSd6aKA0Vk+ITzvdlGZDgEZQDDcr539YakaznlMifd0i1nXm2m8R2sLps+SNJJFd0bFp7qxKD8z9JUqv9E/zf2fFGSI/SHJVum7XSJg3hj1369Apgr+Vse7gnMzb76YJOUsrwyTj+C7ijHNfuzHcdkrZJhuritWQrxf8Poxc+YOQZ4Y1OHfkINkBkyNhDAGOZDBANzJmtjQT2q4D5PRmIyALJsEs3CxSIfXjijha7Uup0u3HZDRRMZUz/zGIgim85wgnjlOaXR0wuMMD4apu2uAz3C4w+pfx/fdSCfXxql1uZUu33GHgXNeLl6eKOuB9zfXikapuhu/202q6T/lgSqkd/RUH1tfof9w7Ov3X0/HDxyT4bULs3uwDzCF3dcJY5JsN3i3DRpkKYKFJtmgKgSCaTibttN4PSZghXVzOh6lw/uOMcrT3pWDNNx1BkPX1gcG96t16g9R2aweWKHU2gPETmdl5sE+TmNj0sKvlRKdytpi5uuQGFo1vyhzJbgEf7HKOYgdUQV0KKdDv4A96cCxCmboc3EdNrDq9NzIFe1YcdQCelwnZcC98ndXkydmMH0aSJD03RhflWqzztiJADjWZfN8W2UWDqWuFQ+c6rr116VF1lauKjuekiWIfhrsDm2fEuZ5tWkdv+hzh6wtB39ZRAGAPfYorKIaGOH+vIheTjJDBwiKNQ73tPq98iSkPyAB0OK48brrGGub+qiu0EJsSIIBrBYLV5UbzcPPKzeGdRr7Bnl1Zbb8GX1cd04A6OEtpiqP9BWjl5oBzvSzqvGtxDqwuz9I/SFAR1vrcoGUtE4Tl3hjxxmlvfEZqvVxy47atm3btm17GINSf+fv/J30Xd/1XemZz3xmyQT2X//rf51+7Md+jKV6t+2vpsnDhKavLMte/j0NSscTyhNQphrSA7ThzjAdXN3nwx8PfUglsInCRg/BCmQ8CPJaHfM4QAUVBDrYR9MwvKGKLsYCaEGSBR+ZQT11Xkwdmu76xo0lv9erdHJ0AqiH1P6Sgar7O0kmUWZb1cve7Jot0LLN3tkbKJ0HK+Yx0Cw8d+oyhFWmiwKLZWCHxFaXjWV1PTc4ll9C3Xme5f903kaLfe5mz6iy04LsrVOUdbZztmBwU6a/7nyiz8lFmzaGZ3m2nNdQIQhjCBt8+AFVj4FrgdE1NsF7B6h+ZYFA9X11sqHiXhfSATtfe68FQhac1DE2LKsr+Qh8ejZLmzDHaEDtoEKs9CbD2G6rYPWd3DghU2hIY1kzzCe4ZXb/9NjAZySXrb1egnW4viLIEetPQTPGHwBVAWs6tzLoYesEQau2mThrnpUCtRrZbux7SYtMQgcwuCzPjfP4xgOHaXQ0SpfAUHJGISYr/OKu3gn5Lqp+giXVStP5zEy54QeVJb9lELMPyejVg9Tu9YxVtW8MoWww3Ejp0u0HqQNvvf0hAyNW6qNfShGQVUFdAXgAnvqNfs784/dmpFwAmZj7CiAxny5dvURAaffaDbKr9i8dcByZ95atR2DOqUJWXOs0d82PygAaGouDqUUJ4MK8mVZrq84VmHOUL/n1n7VO9oc9SmZpgE9poHmRtStbh5L8OrAI8QwyqVziudlYMBYepYHOmFCAXJeIUPEMViR13z4B/LGqpIygdT5VYDYyDuN5t4atMmhUAY+1VkLuCTkhj+nMjyrrhCwbJGpUdCF4q6Fh7mHc8/AsmjGjd1+zhnWp6mY6ru533TPBKsgWa+x5SY4HC3Kd9ma6eOB/syBBVXancyXr0bTHaXIChmdKvR1I2TYfa9N11j2X6MPUE8PcGKvmF1YATGfNGxrNc20r3xNdkwrUWGVUzYkCVNLacFEGOtdp937rVAEwlxpbgYyOGX8j+ehVJLG2EJAKSQaMUTxPcf5INEgzx6TNBdlJvCaauy/SGoVwvOJvPmdfhzbR3AHoe02JDHAhIYLrXM2WfAaBRQU2oioHqgqiWhw727Zt27Zt2/bQbze9Wv/kT/5k+oqv+Ir0K7/yK+knfuIn0jvf+c70+Z//+XyAvvSlL33vnOW21TZumvDwXWGD79XHIhsJGx0Gkq3UHPbSbAGTSQu+SpskACoYDN02fVOwUaA0DiDUzCqXWMCJwFjGvmZ+icDCKq2cXXs3bkjQsGlfwlNlumDWrk4+qH/XNWz6wABCie5WywyaSe2fwGNnnvooKe0gmRhZDGpcDmXslqLSlzZkMlvG6wg4tKGhRCps9GUWjR+R0RNNPGY4LVg0FlrcWILpIP+kTZvls5g55zUDyKyKmgXFJqHaJCGoPYZXu0HDxjlmY+P1nXkNwdxbIGOd/O7Ma3HAAPcLsrJN580qR2DWUD5lmd86aUkEq8xnzcuYB7NkZHLRfwhAZS6uQE+MJ2WYMzvKDcKr58VsMd4rqYLPhdgF1rdFaXN/lQE9zs3AolWCMhRBxOTINueQb8GUW+dXHMvuHeaHQASMA1wXiw04SEyD4uDVxqqWqoynrD98mVgmHH49TQI2WFcQEKzQJzDfvkD23Pq9MAW31+y+sWplYCcqCBldH5mHE+4TGTVgc6U06PXS7t6wNEZOUOEJlaj8WNGsPZ4DPKDwJwaLPH/H0np39dIVBzrwHgB/VqULbMbKGhakOlpHxDKLx68CDVhjcEy8HybuAMsuXzkw6WTFI4bAcr+Z+mf5zPk4ZUJhZn2FABoArlX9tPPQ/BU4IwP56nXktcsDXQBa/B4APhinZ9zj2Phs8fHHypp9Y4eJTQIjbLymoFLXgS/QeDC51ozrOteRlpnbY3wwoUC/oyHvD4LpWo8gBKpnPJ5KDCxW+jqdDOC98ypkNPT2aq2Y96VKjDRPL8B/spQxVyi/hI+RGfXjPZIidbrmo2YSXFt/MHz4LIOzv69n0dC9em54L4sHwJ/JGXYqWlG9N1VwftO4qvusmF6xItxFGDR6FsT3GphiQPV5oFFc85lII4jpbL8AJL47oFe1xT1AFeST9DN7RYYxhPHM/vFEBMEiTxrkZISPMZsLM5MLOmvIPB2NeWim/Nbf2UDfkwTqM5zHbDyzSqYBOMO6DdAOP6NSslWITWnO+9d2Np8XF6n0P2wHeH3dVer1wJYyf7Sb2ZeSkeUVMvHsQIvrPBKpOJ+qX52SIWhF3xvbl0o8l2y2miYLr0rk8RK8urBWAVDctm3btm3btocpKPW5n/u56WM/9mPTM57xjPSEJzwhnZycpC/6oi9K3/M935OGwyJQ2Lb3XrOsqFGXyRqagREFSrgBR3HzQ1nCWjRxbOjnOXjmZmY6Syc3jvle27gUvi70kKFkpcgKWoljY5Agi47gCsdQVrfO70cbg0hzZ5Zubj5OzETKKBwgQTDZjsye0jHAAKLEpVyuPko4qplEmhm7r0Ihnyhns1W1UB8Xm0oVdtgHlBCZXxS+h1WxQv9wg4pSyPCYOZmm/k7vFMPnZo1ob6ZhI9ffKZhYAtAss4+x4Bu9MwISM8O26oHNYfOUz4mYUwrSav2tKn5GEXi8mWayFvssxq98vhRI4LvBJsLY38TUQdNn8jU3ypt8jTdV/LKNsANZAfBFcGUlti2IsPefLnU+nYBJ6ABnRaZZZXIJNFQgDoYOfYNY7rsw+l42TeoEWQSCDJs7BbBkpc5tDFqQmvh+/b4qIeS9ZkbbgjvKzELGHmN+MTaPq04PErUVZXLoa3g2Gdhc9p6q63cGUW44q3WC1ZwcgKi+H/d8/45LaW+1TLv7uw4ytcwUGABZkOTgejCnEWAhs9+qmGnXjYkYXG/yKDMQCQG/AXMCH6wEu1UKExilAF1gE03JqzJPZyCAvcTiUKhuh7Ejc+gNpsvV6pCl++ZghApQLAddgiUa5xpPvB6sa4HtVwUqCEK5d0shWbXgWYmITt+M8M8ClsXQQ+NYdSYXKgKiTReQN8ErDB5xg3wsMp+SnQf+q64r9KKjwfSc8ktWgvUqqev1zMCkbgEcx7mLAL+uySBd180+rizNWivFShN7DeDubHrEtR3rqsDcgnGCNXRBYBffbmzgVlr4mK8WzoiBONY73ZNOz57lZyUo7FqD56DfMyU34vdchLUa13fNkQgQldguF3iUZc+vxpqVefHdWHPMZ6yTpYvVfo99VFQNhdQRxU1sna4yNm+mRSZv3efrGFGSnsFfr9PvEXTBONTzkXseFqGYu1xunRqLolIs1ghej/ulYb6aV54xh8z03cYaATekFp3BK0Ytv8d9H1X9VXO7uD9mSYCEiMBuVUYtzTmfn1ZBr1l4BALk93F3M7I9nCP6B+eO5CDWZdxnPlsHxTMbbMk4JtFftqZNXS7cJoMXUQrWdT2jM9vek4oaG7qHXK8BYnuyaNu2bdu2bdtujfagea3IVgpEeMQjHpH6/dOmntv2nm9R6gPKtVVAsaBR2VxltLg5QEZ6Cd8QmEVa5TIFbNiITMbjNJstU8dNuFerVpbMcaNEeVvw5yBrfs19qG0QsIlBltuAnzqD7LihEbiEJhYXvBfwXTDeRcYQDVllGnoCOMDmlZ5Y2CwVnirY4McNPTfQ2HANbSOVv8dZXiUpGSppjadWGnmIwMg2yVbVxsqIa/MTN3wZ4EEg0y48eBRoc5O5EJuAgplTfiZnSfNynyEQgPH0g9hU2aa4LDNkH7qXhWR8dZtwm9NuHg//WJhBjya8Eva7ZzzjJlAAJsdF8HiI5t7rUMK9rsVAKQKQAlcR0KHPjXVUgCxqCFIk22NAvCE+qQKDYnHp3CJgVPVMyscAw8hZC3XZY7KUxtM0PhrRpwh9JhNmC2ptzsT7hZVY40J9CwZNFTQxBsQl853xvpEnmhiNAmIwr8QakvRS2X+T9BW+RJh3BvSYf4ey86yS6FXzMCgYOKOop5//8eExwVmsL2cZZufgwQMJy+5PCVrUAUMInm6743LpteayeA8AX0pKXBIMKV5sYiRJSiegJUpszwNJyTBw8+uFs3PWq2VqTGZpZw/+bEUFNoClJpk1wE4MpRJIOZ1Z8gAg6LCfBsPBTQXTmhdab2gE7CA+wX2CZYWMU2sV7j0CQ/XxpuA7vs73ksk2Nz83+ZH5vTrrnMlyOxpxnuC+YLwxKOV5YszZ8QkiU5pZjDe8jmCfa4mvU/i725MMD4AlkhEGQtqwtHEJFl2J5RWAprPO2cBHMDqD11ONV5QSQfS4aS3pDbgE6DSe1LKY8EzB9RLo5ZocAHEfepE1FO8P13DMdQBRzqA7q8+NiWbrn65B64iNeRyzuBbJC6ssuer4qDKY43OJ51lhh8YxGo+tZwGapNA8P++MTazb+DOOjTnG6+0C4N9soH6RpvGx6VlY7YP4ngx2OPsRFwIgGi1XekQyAGPEwUkwQtcgvIIdBpDIWUJYO9tdS2JoLV81bX5jLoFJLvadvNRiEQ70ARKESr6ZcboBuLRo8M9mVhbZqRhTtm4AJMfey45v0mEA7yY1xb6qk5/v543D+Dyx+V4k/PS8IajrxQd0/Zb8wxppFhJmE2H7VwPcLZmmxv0uQc4iEUhvVa94CcsCY8UX7NwHs5fatm3btm3btr+6dtNP9J/5mZ+hfO/v/t2/m173utelP/qjPyJrCibnP/VTP5U+4AM+4L1zptt2Su6DhgetfEr4O5c/YGNvWUV4ORn7CSwKmnayEhM2Kk0rAb+rsu3I2AdQAZtqAD8hA4dNNs3SfUO1e7CT5rMiyN3UtDnGeTFT2GxYWXheh0kN6auRxMIpWEsqt95qrNOqi0CkyLYVMizzwxGDIp4LN1tumKksI4N0yBORZUffNb0KG34fPG7qvFLI6goeWbEcuWVK7b0InhB0VUthX8Qv4ryN8s00BhPdZpov0Ce2Od10r+g5MZmTdg9gEBtHgAfGuir8LwwENcaa5FZk2sDbLGdw66v2aCxUWVf2RpOt4B8AIPF7ZF0lZbNgpLgXAH+wcTWZEaqDNRkAY1PbG5gHTczGcqO9tM01/iADK4nleZvtCMQZsFMPaoihhnOB7MHGmQUiK5Sqx/k7wyoCKAhYJFGMgFc1YNT3x/OKYFQdcACmhzbmej2CqTQuJ8BayKhk7K3Kd/peXgvABBjEz8GKsbHAMb3BH42SNQcVcY4YZ/DLghcMpGmb+jvOZZVEx5qAbLg8RBRw5fcEpqj597gkhD50JgHkvfDXIpCzCZhatltpvoDxOmSdBoCXmEbuHwNWQtUnReDQfAIJKuQ9fQKGeBvu/VmBtZg+5qtkxSqK6o9mci9mq9hJthbHCm/OmqxIlMRurWNO6m/Jj2A2j5ewfitI3MzawbEXaTnBvbbqfghyuzVssMjIEdhBmRvBS3uPjJI1xskYYlAdA/OiKp6AkU2ssNi4fvt4R/8JFLBkTxHMI3AXy1bFEWBcnyjXq+8LA5a6BNRiE0AaGXlibEbwVMAR7icATZMvlQtV4Lln4GthRI1xTdAWnmCVamuYg5Q4o092cDywvqw6ZGRiWSIAMrPGqfW6uhbF8WTSYFu71bfxWScAUtdPabkXCTiTdeuVg/FcEtB+XqsCanXtPKCiygjWNYPZpeeQ+SGUAVHdZ/Sv1inuDeDtSI+5IumRC2q4tDNWp8VXIBlXqiRXIX5G9hDXIZfIWjVh82CL65CBQY2UMKchd2PiDOu4jSGO7Wbivms8s8qbrVab+6LkEvCzGp578PqTVQKaqrVmQD2zMA3UY/922/RLxNG5n3ObhvUaYNWcbDTsuSj3ZfLPQDYmzMCUda/CZsVjUQnLB2OFsG3btm3btm0PYVDqS77kS9J3f/d3E5hC+4f/8B+mP/3TP03/6l/9q/QRH/ER6fDw8L1xntvmzUCRNstIx81hDgZbBWhAvX4HvkImj0MlK8hHECSjZPhwF+bk2LAagwGt2GhZBi4G6zItRzBpG3Erx60AfdMDX0a19DhAFpx+OJ49dgNuKxHcSoNdl3u5OSc359jUYBO1LioaKWsr1pg8hMTCkB9K3DhLmiFwAX5Uyvbi3Gn+69nAmB0tBfcCJLplKUP8fdzYY4adlaGPgIL6SoyvTS0yPuoYADHzTeYRpYZLbnCx861mxuPnwPigtKbbSp2myUh4r0Hz999n2ZL79/B4koWdA6QxcIH0LRUsl9I515iJ454g0wyQj5v2tm2KsVmGdwSy59zog3nnjDhKItwvxKQzNlaQEZ6N56kzRLDYIbuklIF1IDT6s+l1yU1MZmTnNNxBhSVjJMWGsTwkc8jBXIK+CqzLDKssg1Eg7UOKnm7uk1Pnj6W/qzKgTeXsSyBKBHzaBQOGzVlbaNz0N4p5Jxmwjbtl2tkbkElDY+4NgBRAQzBnCICgKELXvo+Su4qHUjw/sT5LEi7+24ITgS/0gUMlJ3qn9DPIZEB0IfFAv3KdW2ONWKUJ1sJGI+1d2jFG2BnngGx+Z4ny7RjvK657OWD19zOb76bmYgxIdmPzBayZQWarUuKC7+gaIF9ljOn4AvPIkHA2jGRCnN9eARRJB2P/GTvCKqwW4Gl1vmMss9pcP5kRep0JuAdyGLsIEBGocoiEohSZpZor4Rn7dbyYWBEIB75K3z2fF/cXf7zIhD1HwHzC4C+vjZEFhHVgheRIzdg+jxlVbWIbFuD16XUd9xzBOxjiYg6ibwfBL6iuSWYkWRT7pwaYo2/bbEEgHc9jGlADVHAm2dG1Y7JAVMhB7BAWAHCZqh3M+nY2gvE/xv6ahU3iOo1g3hi8xTOM5txuCxBBf7S6eVjX7FlqXkp1VRkNGLZ+7LTbLlkzAEI+d5EBVOdHxSqYNQkbzoGx+wg5UIs+pHy6BWDZ1oVNTc/dOG5iIqL6zDRAzY4npm0cn/q37RfM22vTs1rH01xVPxP4apVBrbpxJlBH6wer+1muryRXFxNKjDqdO8cyZM/Yy5FVZcARnvt4LDWbWOtWad0w9tVZTQy/6pyPCS1jmgM0M/YcQDJ6s3XbqS/5epYVrtNsPKE3Fhj/GKCSelqVaAPhsN5sMjR/TyX3tm3btm3btu0hBkq98pWvTB/0QR9Ueu3y5cvpZ3/2Z8mUupn27d/+7em///f/nl7zmtekwWBAr6rv+I7vKB0f1fxQ2Q8MLVB7n/rUp6Yf/uEfTnfeeWd+z1vf+laCZL/+67+ednd309Of/nQeOz4Uf+M3fiM9+9nPTn/+53+eHvOYx6TnPve59MK6FZuyqWdm93fAAHGKMzeJLXpf0NScbAVlmz24cJrz5ixlCK64+SkHxnXnIo8MysAQnCxso9LownRZG7BCmlC3540Mneo5id6OjU2/bZvVvPH2SkySaFWZSsh8z1gNrEkwozmQH0gRaKmvN/Wz3iO/D73vvGovkkCQATSbs9Q0AtWYlVXWFYGKlYYvNpI8f5c5yqekJHMIZdZzMEJWkwUCR9ePsjwybp65QeYeuQBGcpYdXg30ibDgWmMQ58/KX7j+roEWZzV6kI0n3AD3IqiqgDYw9YosK4IMvF42W0WQjHNFlhTXApYRPkMjYso9wYwzFg9ZP+h3ALpplkaHJ2nSaKb+7iDtX9rN3ymmBBgQ1blgQReC8wX7cDUnr+8UoGFSAoCbNfKQmrhInkICG6L85qJB1Hkb7xiAAsDAfUNQxXN3CYSZeRfXTTDpeMLfD+kN0s5VJi3rLNbKZqNjC+zYeznoEYtJbJsIyIpZIbAY/VKsIwaeC+QTMGSgiTEFdN8jC8GC/nmauHy1S5+1NcE06TyjhEznIrYKJTgO2g92yhl/Ve3jOUDaGjzwZmRGgY1nvjOsXuUGxAr88e85vFfQ9zS1L+RPJbYY1meAFeiLhskbqwAWBdEuGYtSMILNfu2433nddiZOTETEhnsLr7Z8j9ZzA5IdqFKxCKztEYjA2iHpaJQNqmHswUAeoAGOt+N+e1r/wAqi/x/Xn7YBGT7mUEGMci+vxojxIHmvZEtVyRcTEGew0SKIRcZJ5zQYpsSLZJO4rtiXm8Y+kzEo5tE1lt8mYIcgOMe7sXmrTDktyGbkLJDEfSU7xmLL5+vJGJrBL4xNla+v3UoDygnFli6zK+P36m+uuQ6un3W9EViR96Q89/A5zEF4/fA6u/YcwUXwWe0V6VaVwgn0vDw64VgBYxOy2TpAanQySYcP3GAl3/2re2ngFXrHJ8bMXh6s0t7Bbq0/FI8hk30UmPP35LXIma+bpIXVfhMrVYDPWeyv6j4jP+Ph58n9garj1fte5e9xby/dz7hni+8Dm0isNfM8My8rvM4ETQabm+zr/tAAVYK2lICeD/DYHqxg1+m1aoVIMs4BumOcOCguewDNxVYLz9JuZqDKukHyXJql49lyBnNOa/oWnNq2bdu2bXuYgVIAjPCwB8jzxje+kZX39vb20jve8Y70mZ/5mTd1rN/8zd9Mz3zmM9NHfuRH8pjf8A3fkD75kz85vepVr0o7O+YR8jVf8zWs9PdzP/dz6eDgIH3lV35l+qzP+qz0O7/zO/w9HnSf9mmflu666670u7/7u6wG+IVf+IXctH/bt30b3/OmN72J7/nyL//y9NM//dPp137t19K//Jf/kl5YALluxXbWA1ZsqlarYNQI5OgikPPyxhFAqAtsFeShKYDExhCsAbTz5Hr6wwC013aj5MLcEptU0Nn1/pvdNBi7CxulVrYQEtsGm1NseOskVrkMuce6m2RYF20XAQWq7+f3JjNSpm+DZ111LAU0Cmw73aJ/VoGhgVdWNawemoC635dMpi04hQQJ/TbjBk/jQhtVmnG3LNsZWXJ8H8+xLDth8AhgwJkZ54IjSeOhHFTHf1cDB8zlbPzqjAYLssDwsO+tlmbPIJMkmR6UAVzptFtpDK81ByVLn1NVxMrrDFz7FnTRtJmb7iWNWKvXnBlINdXX6vpHG/DcRw60RDPv2HBNAJZYZY3+ZzL/r6+wmOWlNIq2Cn6oeikAhTJfD4RZArz0WTAbjJHRcgaVjHpjwLmpGTAB8G+YuigNXiOTjICZpLhW6dMNo5fGCrE54WAFmIqQeroXFsATFlxYLMkG5fgNlbEgWz45PCHLrnN1n2DHwIF7qyIK/5RlSjPMPXgoGVDIkupkHSA4AgDazcE8gaO2nbvkMzLrxUiXTFnAEr7r+GiMhYvAEb5utZinBDbAdEZwxgJ1q4SKucW+YMAGr6VjrzjaM289zlEEjMZQtEp2fQ84FwR+FGTi+s0w2WSuaGJ81jF3NAYjmJMrg/makSWTDCQL/xiMpQEAuFD5r3psDDdjxIYy8QpcCRhypBNUAZAhwBJ9IiBNPk+ZneMMJjFrcAiy0ZarNNi1Ih5xDml8Vq+5uv6ITajW7mxmrcSmMSKQcNM6IJlfp2MMEevrwAhOrbR/5cBYqy4Ft2dYcf5VphiN+DsdPlsi4Iem53dk/WwGy5yN5+zjujWmes1aN+i7GBhFAikje1AAznptFQer66Axa8F4GtPXDOtd9EvUHgX3n6C6V5zVmgpjftaCq3nGa0xl0Ldxen2249yct2O8zw92b6N5YbLVCpO1en5ezETftel98VmOxrUGz0/3Q8M3aq3SC2TVgWCO+47/LnAd2dQ+9DnuEdY4sih75TUECTImSTdIYPWcieOUUn54pJ7hkxevfdu2bdu2bdse+q2xvsmI/C1veUv6lE/5FLKTwFyCrxR8pL76q7+aP7/gBS940Cdz7733pjvuuINg1Sd8wiekGzdupNtvvz298IUvTJ/zOZ/D94BV9SEf8iHpZS97WfqYj/mY9D//5/9Mn/7pn05QTOwpnMNznvMcHq/b7fLfALb+7M/+LH/X533e56Xr16+nF73oReeeFySJAMRwPvv7++lWbZAejI6sRPDO/s65rBaCIlOvkFcBES7Sqqan1Qwhjq8st3kpnF9aunp8baLEiChXMLK2KUupzF1dIKKseGYshOo68T03u+mJcj35G1WZTjkjj6DUZYyx7LhM6g18K1cQVL/gs2JwxYbvRLUqbvY6Fy/rraBGPkN6jdWFEERv2DRXG2UnzuK62QqEdZ+N90hBF6n/nqXetJlHY+YeFYbcI2fTfSxkWgzrCYbcrMFuNl+u9HOUheCPqudVgbZsWsxqYyZDxImAuSO5Wh1AxGIHNLs2JhSCQmTgec86yDgD6HHzbfj+uPSFTBiMFVaQMh8o6yNjEIjtdJGxf9Y9F1DKinF+/GgoTfnf1KU9rTalw6ulsQcB+kyOJ6m300sHV/YzO4TeS240bCy0JpkUkOthKAz3h+yrycikiQDa0T+QlZ4cHaf5eJ6GlyBvHqSTGydkcbQhD6HHnkvjAA44E4/nBnn0ZJZuvOuaeTDtDvBwzdURsVLgOlHpFHOa3QbT42QV9KYns7R7MEwHt11K7RYkNh33Ult61cZE1gdkLGvdq26XHjvwWjEzczNYx/eDXYLP2/laJTBQ1uT1onL2PLcgB7YxaP5JUV57Ec+vizSxtnBdYBnGca5AlUbHvo6LGUTgwWafAe5u7o1rFVCjtZyAiK/txgq0KmB9yJYEQknC7Ww787EzwEbngVYF+1Ux7WbWLs1xrk8+wM9bbwXOnSebq0on43MqAm0xwXSz3jq5/y/oy6PnAit2Br+tB9N/ZAzRnBvV2Ix1WGXCQV7IZdmPq+sV61jjNLKNdT6SPm4C1yOLuMo+uki/bQKJ4vmjbdp/yKeveozq+FQ/cD74mEarSwDUnb8+z2dcYIJqjyYW7UVanRRSz5LI+pYElQDTGdLKmx1/D/X2cIkn/rpd27Zt27a999eGm2ZKAXx68pOfnP74j/84Xb16Nb8OltSXfumXPvgzTokni3blyhX+/YpXvIKB4yd90ifl93zwB39weuxjH5tBKfz9YR/2YSU5H9hPkPNBqve3//bf5nviMfSeZz3rWbXngSBIgRDaw8UnCw/+/lCbmfM3VrZZq6+OdZF2lok3qyJ5UCvqPDKV55WXLjwezOdD/lPygkLADlYAMqY7uwMzUXWvDLzfKp/ZZimyb2bLefZ1iZlllq9m2ebTQUqdySs+J/ZKFYjLch8PDMxgeLPpOL0weqf9ing/Kn5ZsTEjHSs9hYbvrHooVa9lU79TurVYp1XL5XoyXq0c66yxIqnagxlPsZpffi0wHWKWN3tDnWWIizEBg2M3Ic/Z+zqJhB9PXm1nsQuqoKkA07oxXjUCVnXLaq5A/hlgyYFGon4EMBHHggIhnfdyhbmFYMUBSgSwCFi9UAF+JxkngEwAOpLyaaxkI2rv+zp2xlkt+sqcugVxXjDoKAcnAJkAxnC9GCI4aqf53CSUKncugBsm+GJIWYlzD8ISKhmKGeo+TXNj0CBLz/UgtdOqi3uUCOiwet4uPMrsfGB2TgBHxRfIgoIBtpvsD3pWkGGxSh2Y/wM4YWBn40uSzp2DHd7jxdzBs3UrzSe2dpBB4CwZY5W0nS05c4NzAwblwQKpC97fQBUtAGUwkl6teP7GSigKOuD6BVKTLXk8JosEku6S7NH99DjMACRuWMMzA9HlNjfTslzOQQTdfwE1xtAq2B/YA1CyiPGI8vJgy7lnjdahGIQboGmG+Li/jSY87CSb1Fwprx0GDpg/l+RBbO3KGoP5v7Z5gOPhOGcF1Gom45tzTQfoyLmw4VkXJVl1HnvxHtg4N5N4eQ9VGU6q1qYExc2uvWLjnPfZuP7XGXLnBAhYzO7tuOmYGhP43h0vtFDX+NlOmZ2ar9+N+zcBNBrvWqerbLbo71gkFcxTr3q8ums5jyErBis/UxkLSrTF+SeQiv5fZMAZCw9rB/7Arw8efyYdLrOSqudU7Ws9W1RQQACQnos3M2bq3puLKYTnlI57kQTPlu20bdu2bdv28G83DUq99KUvpUwOwVBsj3vc49Lb3/72B30ieDACJPq4j/u49KEf+qF87e677+b3XLp0qfReAFD4nd4TASn9Xr876z0Am8bjMf2sYoMf1bd8y7ekh1vDgx3yjuomKWYBS5r/sCl5b5xLppFfEKjI8h7fQDFAdDlRGwHN3tBkM/Agmc4oVeTnYJQ9t+pmlEVUDLYFDCT3eqqVY7nkLwZQMVhBgAKmBb4ELACUh4ZkREwEkyUVpssmCzLJCT09wvnQuJkG043U6KOazGlvo/Po6hfJRGfgrQYEidcl03n6OoAZpeo+Xk2J5t+k96dzs5l153ZRxllValOVwMQNNH+3Lrw2Tl23MvZgi1VkfgIyp/CCkT8PAzOn8URZHAP3eqYdwZIp/DKMrcJKltWx5YCNmnm9WR8paOG8VEWshp8rL89KgDdD5TneD/e8gXwGc4NeTu5nxAp0zpbDUcFShBRMgQFYVOzP4MVW9bCrrh2RQRe9mTaBULE6lUmXOmkdKjWV7jn7wqSaPEeYsrdg/m3nhyAM/nDm8wMDcpjszsy7Bl5zOwOvlgn5InyZUpqnWZp7BT0DmWwsAIjbv7LPQA8m9fRYcWkYARPJCWH27ZfGa3STbpRlb95ZPKsgqyOIh3mzdJN4N9VeQjKzY1JKfF+3Dznh0D2+Cm86VYfk2ECgDzCFPkNmDEwmHKppgc0AY2L8PJ5hQpAdBBmzfJfEUGg2rXoifZiyjxruWVG1MPd3TWPQ6zJFY2zVswzr5kcEOHLQXrP+aI0D0wljkp8bIkjvUkYbmRhiX1GeTpBRiQWwawCsSjJmku5CYlYAwvDAQhl7rhcVv8Q6AESBP7GlGiZLXVupwiBAxDNYyuqj81g2rFzrcnUCJw2v2FdZJ2Nlw02tOo+rBTgi26qOvXURJhbHnq+n+dmz4XmRTayDZHFjX52R/Ip/b7pmPWshzZbUENdyfHjCKpJgz8k3EM9sMCzRxCQ0RvnMElL9ojqd2EEmhy+ztC7Sqs9FJs+cxWhjwysaj6c0tjcAc5Cfb7z3G5JTp77HDe5xnhdJLl303GOrAnZxDggAPDXfNqwZ27Zt27Zt2/bwazcNSsmvptre9ra30VvqwTZ4S0Fe99u//dvpfd2+/uu/nqboagCvYI7+cGlVhg8COuxKomyBnlTnAFIx6IifrfONOauynAAB1gA+57zNDHhFKQoDKEnYmlZdDRKfnf1BajRbqYcNGU06Ebi307phAUg1o0rj3pAl1OvRfFSfkRRJ7xGIhAAFxsmtTifNJ9O0wCZ3aBtZnC+CK2wawahQWWZ0V69v2f5qu0lV7U03gSbVDHFspO9js02QAYbqZm6ta+e1OfABYKRqXH2RJh8ejD9J6DaBbsoUw+Ac97QqL4r/FkOqjmkgeaPYapmVEFhW8OOBpAryKFT9s42xASfaPNNIeLYg46QWUAkeKud5tkSZqI1oBWbGhJCvBqu2QaI2sXNDgDKfw2y7kVLXJLrzKYK9NhlRAB8WlClOyRoxo1uxn6xSZQKI0bdgsruClMmrwjmIWp3PMWjJkhxnj4itoeA2M8QC8KCAVz9X5Yy8b/59ZIL5ccVoi0xBII6LOaSuFihyPnqVxA6lPjaW4hwjG4Zm9qlg0Ph7wK6E71hm8AC08HGv61GFPY0vFnFws/9OZ5jltc2esTHVT/F+U37onmAAl/YP9oz95MbuApLI2KoWm2C1VAO0afAOUB0MLfoItSk1XC8XqdMxFhjAC63RKv5g32vz1XxbCsmOAa/F/RGImFmkztQAsEn/K2f5VRvWBRunbY7NyJTQNQkQRPW9OqBDzCUzOa8UDQjvAxDHa/M5GscV1pfFZMbxD/mX1j7eo1zJ0I5Lj5umzfc6oCzKhtWn5613Gn96bx3IUh33VTl3HUBFtpcnS6qf0bHyOujXVpVVxe8AiGLvg1egSa2imXsuArHpu85hUEpSLdDvzMSKyzax/oFNfLNS73enFXJLPLfNkH+1j2c1mIyNNMF6yaq0NtYsgWGVLyO4YvPEipKgT1lNr+KdeNazTgmJzOJlYQn0AxIpmDNmKglDcjA6WTXY2cGqsHcRYInrKxmBYY2X/L3C1No0ftAk2dS/0W98bvmeq7qf1L+ZSHFAWP5YJi+3PUd877Zt27Zt27Y9fNtNg1IwIn/e856XfvRHfzQ/LI6Pj9M3f/M3p0/91E99UCcB8/Jf/uVfTr/1W7+VHv3oR+fXYV6OIAveT5Etdc899/B3es/v//7vl46H3+t3+luvxfdA11hlSaH1YCTbO10i/OHWFATDvwPB681+lobJkJ0404KyCvio9E5XoIuZ0WoGUxugOpZStXHj1/IS6u5Rs+yW2T6d7qAc6AaWQ3Vza0GCeytVqp3VbeiqRtiF9APjxuRDR6j0dTJJoy42VQYc8DrXKR3dOElTyJG6LSszz01bu3Q+Mia/6Kby3WkRfKv/nZmbS7IQGV3yMumAzeXVnB7cGJR0xgLiCA7hdVXwkgk2WG8ryqeaDHYl1eLG1/tN7AXdn+hrYsy4NQ20c0W/IOexYAASSBjM4/dgtxT+aBlchXRpbZK7KAGM9xH3HAEeryNIBHXtubKcd10MhMUgJCPCK8BNRpM0Hk0JyqLyEFlACNra1j8AJ1AGHtcFXyKc7/HhcZqOTQLV3d2hFw8CJHhNjY9Gab5c8mcBBABhcIbwrcL5wHNJzNjowwJ5DPu45cUFQhDM++WG02SZ+T2MLJAq2BEDsaonHO6V7lvVFBfA9Nqlj/gsWC/4zshALA86m4w0QIYMyxlxkbGRgQswBQFaONOsysxAv8jvRL/XmhLHQ3Uem2k3/Foi0Kv5br5Ozbndl+r8LAWpjSYZmZQvg9kK0/cBzqmYrzpdC/7cmyWcm8DO6vqsdVnXpvXZguNOYRK9YY3CmARTA0wySaHjfR2PxgZoO+sL5yAQL0uQYG69V/imKeDlefu6yQqGACVzdcaiv2zdWKSTw1Fq92a5aqSNj8I8WWuZ/p2ZQ2Es6nUD6wHaGMuvjjmo+6Q5w7WpJ2lkMVaq3xXZI/n7/D4I6CW46KymTWu3nkn4HWWiLWNVqcIcXif4GTynlGASe7DZKAD4KJ+u+77qnI3XsOlnjbu643GO9WwMvrea1mgxQSOohtd3L+2kdrfJBMbJ9aM0brfS3uU9rhVoeP9kMk2HDxxySRlcGZQKAdizsZPW0wWBY0r1KqznOiBWrcocqsr5SrYMYFTKU7HGI7Pa6tareA4x0ZBfFygZKhTGzxC8c99EMjhHU46l1o6xt85qnHduNK/xvWou0/ommPoXZVxv27Zt27Zt20Oz3XQU+T3f8z30Y/pbf+tvpclkwup7r3/969Ntt92W/ut//a83dSw8RL7qq74q/fzP/zyr+b3/+79/6fdPetKT+MBFtbzP/uzP5muvfe1rabL+lKc8hT/j7//wH/5Dete73kWTdLQXv/jFBJxwjnrPr/7qr5aOjffoGA+Hdp5spq4piESQGr2U0KLJZl221jZekNEs0npqm3zLeEMUZLIiBAhVPws0ZMXEpqCBZsjminnEwNdLTOv6BDSoUo7OhecYAq+6LG5mbQT5VXyfvDeQMYwbtOp1K4hRo5SPAAB8NCxAYLAkRo9vTnvDvsnyRuZD0t8ZZkZG3X25GSPt6L9Rn8FUAGz3IW9Ez8lC4nX1f7VFL6QeGDs1krrzzFrzdwx6tqmF0aofE2Wq6RvE4xRG5My6thpp3kQQZ/InAwVMupWCDGyhQIDGLyYTEisKFeWOr4/JbIOhNc+azBMLSnEvdT/tODYeOx0L5mRajrnDzTqCuFpQ1c3JwQZTRTN4Bc3NQJwMG9yXhgeXftvLYwwZaB+7zCC3Urs74L2x++jzEXIxH+dkzyzNyJr97IbQkpagodrXyo2x8Tp8SazKngU1AKVgxN/t92uz5RoH0bg4zg8zrLZKc41Wm8dndSwvWW5sFTMplsy1OoZ0zMLr6HSQWhhe2zlkydaGcW2VzZxqAkAA3++AThyXkdV01ppalZZU5Y7VpmNbkFkA5uo3nJ/GTV2rrkGSFun7uJ7zeuqqWZncsI61IHAErAt8lr5Uvt6KZUWgiOCN988GQEpjFeeClj2avIE9Mj4BC3PJ+UefHBR2aC1L1V0JEHQKs2xWFRxN7fuHDjr7syJX/6skPsAa6QwW5vVFyXeD5vDReL/KZuK1ziBRXLF/AURItuyqOfqGyThJUkAxA3mP1wbGAWDEnJU0KhYKkKxb15sBAUgXR2P2d7vfT70u1kRbo+RxWAUN1PQd6guAKrw+nycCTcjW9eqTnF9YF4HPe5W7Kounyt6KY+7UvfcWJX0E/YKMsArGVY+VvcdqmN1c0s8oTnHRtomphNf6fSQnAd7P0vH1IxTN5LqKZIAtH16VcLZMrV7BCIpeUQCtwa4S6HlWqxqvx/FYx9qr/hz3UZuaMeJsbxbndrFm+z7ItPhk5fK9vk4VDNVU80xopAbuY6uRGivQUNd8vgrs3XRe1b2Bni9133XWdRHoZ78bqLgFp7Zt27Zt2x7moBSYTDA5/5mf+Zn0J3/yJ2RJfcmXfEn6gi/4glrW0XmSPVTW+8Vf/EVK/+QBBYd2HAt/49iQ0sH8HEATQCyASTA5F3ML4NO/+Bf/In3nd34nj/Hc5z6Xxxbb6cu//MvTD/7gD6av+7qvS1/8xV+cXvKSl6Sf/dmfZUW+W7EJuDGKsxm/ImhmAMrNhL3vIgBVNfsWgw8cDBt3bMQkLRGbQNRubDrgY7J0D5PMaMFrodqOjs3gA0E6srcezMZAWYEpq/7Ri8Sz5uMZN4OQX0QQqrShc/BFQEd1o6MNcg5a3MTWZIgKDE5nvbkhDIa3sRGIQ3AQ+hE+NwjsVFWPgVHXWTwoNQ9QygGFm21i/qjinYERp6salQMDA/nkSxSZOtrwvjsbOPVtNbhA341OwIZY8H4M3bBWVagwZnHelBqQCuSMJ/wOpcnoQWIMGARMkbEQpWE2GOx3symkWAtKK4yhBoaBb24RcK0BbHXScoog2IIHVkgLDB+BCvgdWBhW7avst6Y+iwBBLbMO98SBMvWwGE9TeJPA92jYyxXIYnAggDUf36U6vQaCdgTI6IdGCcyg8e0E7CFjeKH1hwMG9jLtVgN4I2aZHd/laR2r9rhzsEfZn8CNor8NqIkZ9VqfMLEIGwATpmS3QeaZKzV6JT95eVVlfFWWAL6LAVXwu4kslGpDH8dqT8U9MYBBEpxNAYwCad3zTW1TUHtWU9BZ1xjM+nhA/0H6y/vu4JOa/Nx0jWpiR1V9WqL5c7XIAe+XAnT3pDEW0yoNugN/LlhF0JazdgDaYEStVqcZaXFs8JnRPR1gmiwWxTf6RaAcGJnw09N5x76JSQONG1aHrbDd1DD2d/cN+MpeTa4VF+uqGhjzer3KJa55d39oa9u6YeAWmIkub5WkFmAZfkZFTJ0HvMzqGoFuoltewbDiUYhznc2WXCOsgmLfx6z3B2L+AJZGr0Otw8Z2MuYdQZzAquLzAPikm+Wz6lrTQBYbfx2+B/sAMn7CHDG55DT7mlUlXnWsL/VpNWlxHoPmFADCMTgnwzGCv2fNNwJZC0tqnVdxeBM41bwCxhk81NoE1dWwH2nceYXVMesM7/nsD3PzvO8SMKkKrNqPCWTUtVb3dmLUWTU7A7vr+sTAyCmPL5YYjxnWBTQmcjwhYt+N6zidWIp7JB2Lcll4KTqYXAXR0Vh52Ku6VgEr9kOFUXZW05jTGpI8waG5qb1m3Gdu27Zt2823w/uP0r1vuz/9jSc+7j3WfZiro8MRi8AYIWGZBjtFInTb/nq1m9fbOG3+n//zf/5uf/mP/MiP8O9P/MRPLL3+Ez/xE+mLvuiL+O/v+77v40MLTClUxANL64d/+Ifze7HRgPQP1fYAVu3s7KSnP/3p6Vu/9Vvze8DAAgD1NV/zNen5z38+gbUf+7Ef47FuxSZzS2R7kf2kFCWYiGbjbjdh3ZTNpAeAV62rk7UxmAR7hZWkVqkZHurMYGOjyo0sNhaFFxDBEd/Ar5yFodcNwLHsWZRqxePS4BcAl2++6HtjZ725TzxgArNDAVldZjcGaQJTshwpMAvE8rkI7TxmGusq3KlRWjN897wxsEHFAo7G0vaQu1QypGaUPs0AgwEjBUim9xgbrQBWNgXJdS1mvRXc1vWVQDOYz+t9zMSiChpZSwXLCwABWg5MXb5WrULFTbkDKIsVfMRMKoWfESzZ1xSmzSWvqWyO3En9vWFaLObmvRTeVwQHYBzNGLRBopqZcAGsKGX9HUSKwZtVClvTyyn2L+Wu7QUDrNWiw7moABufQzAMPxM8nHf2dkrAl/lwIWCcEuwrDKxNNkHXId5X+TJ10pKynEJqKlYlGoIIsB6b8qCice+cDLjO7rCGQRSuu3W6wqHAEpoU52x/ohSjCuJBJhllUfJsE6vvtOzNAHgxLBWoV+9HDuR4v8qeNNkXEcBuKFlf1y4K1pa8ZM7wXbloy2Mo+4qdBuqsvwzIWXfLpevRquXuY/Ae2Rw2To1JGQs6VK+fAf0QDBobP5gPYK5hjENGW51nkonV9QPGJKVia8hEx2ayzAqJZeldbAq8BZKoYcwiAQImkcZD/IzYNWDtYW4ASACogzXy5GjE74MvD8ZUCQwGUMV1vJDOxfWTY5xyUgXf9swkE01m4UjWwABf0lWtW3j2zqY8d47liqmz3RsD5cGI5OdQCTb0pRibeD/vARiezWI8a92MbFcVQuDYQA0IrGUOEGu82X2x+Ujfrcr8Fji9WgHYOM0KjD/XJUHiGDmPrRvPW35JTa8iKhYP2brB+6p6rgDW4DmGNbzZPF3N9iINjKdKbZ+Nz/S45zov4RP3GOxzmZQ7K68KpNQ9Y+NeRYzvBtiSm1jY6D/I08N+oA645jrmawHW6dr5GLzyinUdY67DOVlX/VbPRYC+aFWwvbo/NS/LzYzMrBIAWxaFS9ZFPyExgfvPtWWD1HXbtm3bzm6Qv2Ot/8vXvsMKvbwH27veel+6+03vSh/yMY9Pb/ijN6f5ZJ6e+IlP2N6Sv6btQlHoL/3SL134gJ/xGZ9x4feeF/Cj9fv99EM/9EP8s6m93/u93yl5XrUB+PrDP/zD9HBoKhkvT4nsyaSNAfZsC/djcMPIalYYG4Px8ZjZv/6OsVjyRtKNcJWlW60kSysDXKKnIyCJDZ9frBdcXCjdwnmRKeQsHt9obApYquwtY0eZVGTjJo90/nbqeIE0BnMNy47qXDXa44ZxCU4+Kpoh8MBn8PuOexp41rHwerEWg2iT751d2Si2qhzwvFathENQIJRL1+/KWXYzD0cw2xs2Ug+AFIL8AJTpfQQwmE0/Ddydxw7JDAv5jQT2iszLbZOIjGzhpyQPojV62wHMyA5BWyR535T9Ps7qJ2al+13e/02ZYvU/ft+lp0wx5vN4z9UV0dcYp2UPnmrf2PUCvGpk89ssX5PvTuV86NPU71o1JQT2/HtdYvjVnX+WV6ytNDiCy9hvYrQwSFUAzrlvDANdF89pXcifmDkHwN00Dxrz92mmTqsMRNdJ1U7dC79ujFOTytWb19s6Y+eeK/eFylFokaGhAAmgLFiTg91+Ws5x31PqrO08GQSRzOVypZq5SWYNA3Wr7HfRFmVWGueahwA9jInprC8Cqvbd0WRcLL+LBkcMSglmnB7PnBuDssm01q3MDqR3kwVmGJtY57MsMbMwVFXNwF2tv9X7Zut9sVagrxVcVitQCoA5q6lyGVm1ATw7q/9lKN3ypIOtwQ5W1YCjYnGQ5QVmBipyBok6fbf9Y3gdJtYAtgEGmzG1zd0IWOfjO6iH18z7C6b7kAvHeVoAs/G62+1Vmq+sqqcSSZJ46fmMk+M5VKTnGej34MCYpC6TXpXvQbVxnE5maU3mCBIaxtytk1drvlfPn2MaEtwVKtdNCfZh7YCvUWSa6vmIs8Y9lky4ynwTsFBN7uie8F45UAMGKJ5lrEQ3m2XDehWtqDb2m/ubxTl0nmn3u/vc5twK91TXWsfwkZciACl6T5ExaPsOJQ3rkndqxZzH8wdm7GdXHGTRkm79mhxfi/NeQH7xbFt6AsgrXoZzVMJAoOmiIqfTXlLM+7qG454cjvn53YOd7HkY71kBwmEt8uqvZOkX7FvKi/H3Tazz2/aeb3/8G3+eHvX4u9Jtj7q67d73UnvV/30dffAe+8GP2viei6gi6t7zhle+iX8rcVxtWA+u3X09vf31d5fuc13CQk2vmyonpaNrJ4wZ0e57+/3p8l2XHlSBC4y1x3zwI9OVuy7f9HXWMcPgC7hlbj3EQKmnPe1ppZ9jMBpfQ6urzLdt77kmWQy8Dhj0oXy9/JCQJW5J0uCeJD7nsCEH8wJBU2/QZ4aRVbzgG4IS6DuDkixGG6izvI3oJ+XZWPkGReCJdHIYPTPjJRBFtcXqA9q666WMiiBHSstQ3h4tbugVPORghB4ZxUZe15SlJW54y9+bKqnE9gLTi6qvCiClijo0112nNNwd3qTsssiuX+T9OF9kE8WkgQeLgtvYol8JzY+XlmnFZvyUpMXN1CMAUgSpRcWr81rJI8XN8s1LyAHQDoAJqwKm71DQ0mpizFpQcvrifQx58FllIemco9QO1Q83lSNHgxTP2CPmm2LHtOBsU3l6yPrqSqCruhA+RlNXZGN73eyhw/NzRgjmad3DFa/1B85UAYgYwBiwowBQyfiZ5ybTY0oZ4WVl54pKgTw+FZAmSYPhOUU5uhaAWAz8INmxc0TAw8AAGw1hOXidUap7iNQEqqeAzUowaQa/xv44L+irVk9s9BAIF0FF9btbNNDygAfXj0AlXEvB4vCqkhsCNEltFGyetzkR0IpjW9VHADJYAxBsIwBdZTml+nY181LzZBcZ2Ee5KBho7qtVNXuvNgKtG2QnZ//OxrjWkNHhSWqzEAMYH35fOpKhwqS/f8pXi5Upa0q153uB93ZTWrmpe2ybxka1keWy0zcmBrzi5pBflwGEfDyBvO4zV5yHeQ/OXRLXDubhKkAAALpVAb4AouhngSM8Jw9guZZsKDiBY0J2GIE7spmCxC5W9DzVd+0WxxPuiwE2xlAUuIO+5zrvCRzJncjC9fOKzFIyCJ2hKGlo3foNcGZBcMg88zj+vEBA9f6pb2vvPRjSK/jrQTLvbL2KSb4Ba8XzVs/a2meIM/5iP+fP+TVmH0n6XjXSoDPg2D4LAMX7CcxX5PwEQyXdPse/UUxCPbcvGihpbRFjEbttgdkcJ3ncQHI9s+qHBEFxf7HxOD3+I0Cq/Rf2djg/Vk91Sd7GftZ60yoM2auAaN11xKIGpaQe1r3Oae877VU2reNVBpjYTmL3G6PPqhwiZ5Zlgm7UH4F92UAQPMOegvPY5qEVIkBXnpHQ3La/knbf2x+4ECiF+3T3m9+V7njsbaXxeM9b7k1XHnFpK8Pc0ADoABiKoNToaMyiSwBo3vLqt6Xr99w4k4WE97/+FX+RPvDJH8AY4iL3CuvSu/7yvvSut9x36j7/yW++Kg33B+kDPvz9uL7gZ7X3e8Kj06XbD7Iv5dte+478O4Bbk9EsPfrxj8ivCVs4a/3VM/z+d1yrBaXw+7e//p08F5wnCBmP/zsfsPF4b/rTt/Lvm2Vu5WJIf4VVY98bTZ6xF0nGyGf33V1jLwRKRVbG//k//yc95znPSd/2bd+WjcJf9rKX0ccJr23be7dF1oUCGW0IV6Gss6Q8q7llgzFMsHGlESQ/7yBBwsZynq7df82yXt1uGsCD5hz9vXynKAlaWbYKJbcHLlXAxsiqQlkFNctembkss4AXzFxlarqy877JM2zOQBcFovKZUsDF86wJ+uTBtF4BeFoXfRi+s85kVf2vxsptzvRRn/C7NixElBJMZ2l0NKJsYri3w2AJYIR5fhSmuWbGvaa8BMDh/pUDbq5VaU5eW2Q4ODMjBpAALWPWs2qEb9nK+swyvkP+KwKgzwowNfb03ZT5DLolaVY126vxq89U5ZYCBWPQAoZVdcOta1k1zq7SpI27+qvRsGAMgFGJxYBzcpZhrjZVCQ6iJMQq96FfTFJUBWfOW6TVpwgwKRRy9pMF0mUKosbpco2MtZX9xthAYAgQCqAbMu0I8o1xVdx/gncuf8FnbQ4AlCvMz9k/i1Va0s8NY/h8oKYumOS1+2s3+4ASkBVZIfF3kIWkK3vGhms20sK6P2fdNZboXn4OE1cBo/rnvHPlXAgS4hy0kzlioKDWI7Q5j1eVLNWDeu+pxjm7MiYNVxAPNgcHOyXDcJ1/DBCr53EeQK01JBt8VypnUi7XPO1XU21izSr5wM+4ZC1+l93/AuzU6zZn12k+niWkLijj8XktcEasywie8dp9zeWzkuB/l2NMQe+mtTwGxZuu7SzDe+t7q8gKQMLAbEKomQ0iWZNkmgSVMaecsSKGpO6xhnsEyqoNx43eUptaXJ/r1nytjXieQw6I51jp3vszjUmJZqfkj1d9TuYkkIPKehbE+QGGFMCoU4UV+qeTGpmlFtYhJe4ojVwu09GNY4KBu5f2UmNQsGXrGOXHhydpfDxiVc+dvTIws0nOFiXlMdEh7yM9E4uqwM00HYNx1rY1TgkSzi0DOON1YrwKkDOGoxUWOO+e1jHRaNGgft4g+TPWUZk1Sel4v9grlcYHASJnCZ5TKELrMJ6pkPwpwQLTM+sfT5aB1Q7mf8PmFSwsBDwRfOezHd5XZisRgfNNAPG2vfdbbdLxjHb0wDEBDtz7g9v2uM/BvIHEC6DJYz/kUekvX/OOdNf730Fp9M00+P6Bnf2219nn3xc+YziHi553fO+1d93gPK0DW2IhkfgZAExou5d3CUihya+urp3cMGuQycm0FpTSFIKcD88AADwn10dkNVUbvKfQRofj9Ge//RoCirG95c/flm7cebT52k8mTNxofv/ZS19zLkCksYY1ra6BZQ/Aqvh5nC7ajq4dp/HxJN3xmNv4M32PvShQtb3m917Pqs441xv3HXJf82BZglNUuD/HgxjMMsjT96/s2b/73bR/de/dHoe4b/u37aVH/c27SoVhNr0X7d2VXt60p9SznvWs9IIXvCB9/Md/fH4N3kzD4TB92Zd9WXr1q1/9bp3Qtp3fqkbf3MC1ECjP00QZM5cxKWjk5gCZqxnApDnpiIO9oW0qp3M+CDBI9y7tpm6vx2zzucE0fS4QAGI1MNZJ3KgjCNBm3/yuzFj5ZjwduIlGdrLiTQFwB9JDSiFqSjoLTMmyByjFFMyQRWCeOyjmlaVbkuyp9HnYZOu4oskPhv2S5CAavJ4VjLPPVinNRjMGRAg0Rkcn3HhZ33cL1psH3DBH13nQyNMfDlZW3ipPYUOGG076vhvWKijjZ/2YcUNf25DZduBS7LezAsx8rc5OUV9GgA0SK55PzWfRNEZipjaCgurzCA7dTABogYEYXUUpeATttVUBVUGrfVpSJA8y3J7uAFlpZNqtr6og36bAsHpuylTnjDTuUdXJv9LIgvNrXkM6iHmC4A/gjDMoY2OQNCyXeI8bdWW2CaR5dbZN0rYIGCk4rZ7bptLh1c9vanW/U4A6HPbzfLOqYQaixqwOfbRqKnHKz4QgcKXAQgRe8TM8DCVNAkBoVfEKOYvmliRQMeizuWCAFV6H1EigPL6X8unRJAdVaFjTxBSIa0iUlNYaygdzbMqAAkgEkBHjAevVJlD53Q3W6u53HBtai+u+x9hmYKwYSwtgfXyOXNQcHteJZ4w9XzZUFz0naSmgqNW62LboIs+xjc+BZpMMW/phLWyszMFu3HCPcA/nLrUlgNArxqnWTluzsRRvDgLjfYlsuQwiVX3BLnDtp5IbngQjmOm/i/MimnZnNqU/G2hWjfWw5bI3Zxfx+ezzQFUHY5KJIA+qmspPkazFVkqYWyyG64wrlBfMe6YCDNV34PPH14/5bEAiiBI6ssnk07e5T6qMosxwbRZgVQ7Q5bGpCsIdH/tkDDrj29czgXYA5vQ85HxyeRq8IvEMOu+exTlRfg3PeADup704N31ObK+6hESpT+h3WiQMN50Xi3Lg/qOa7toKlVA+3uswmToCkwxrsTPV1h60+uqXLRtoRF8pbFFXGGfb/moaAuo3/9lf2l1amxzqra9+W/qAJz4uDffOZuJgLLzm995A8EiABmIVSMkAmuD3j/gbd6ad/SFBEhzvrGcZvhvMl0f+zbvSA++8zrH7qL9ZMHHeWw3z+M1//pfpMR/8KI7R1/7+G3gOtz/6KufxG//ozZS8RRAIgMd8Mktv+EP7HQCNt77qbfxdHSj12pe/sfj377+BYIm8KNEA6EWw6BHvf2fp8zyPP35z3uMoQQCQKoKKAFqinE8NDC01FvBJKb3jDVa4TA19jmO98sV/QlDw7/zDDz91DjfuPUzvfNO70vhonD7kYz6QgBdAjne8sXys2GBDA0AmMpVRGEvtXW+9l31xfP0kXXnE2ZK+s9pf/PFb+LdAqVe/7HVkgYFppfuIGPr9P+yxuZ8AtGv8P1hQ6jW/94Z09VFXSqyxagOzDA19Ff9dbZon6Atczwc88f24xrKit6/xYNRdun0/Hdy2z58P7zvin70ru2n38g7H8F2Pu6N0XIDFpe+5cULPY83H+97xQHrtH77+vQNKvfGNb0yXLp1GRVEp781vfvPNHm7b3kPNHuyWucTfxuBB4G0yLTQEqthgSabRH3RYBQ4LIIP1fsc2yheo2sfAz4OpyHSJn8uAkH/3eRs6Havuu9AEeqARLGmd7fOgbK/o9whcCEiInRKqtLC1N5kJuxE6gtEARMXN+KaAr1ZKcNV8f7rMMgOQMXmVFcBy1hbKKbdbafdg1wxPKyyHWGUP50XDbAcZeD+8qlN+v/twaONfDUDydTD7jc162VNCPlDV+5Mz6jU0/brg9GZa/P7z2Bbx/XWvy3/NWB+bS1TrfFndagOoZJ4fGP8mr0O7GZpuZANUm1iEFz0egSMZLTtjslrFrgrY5vMNXyFTefweksLq+eqzEUST30y1MdhKm9kEOSh1E3vJBqvAc/RTExBdyOdUfn1FnyHIaU0ajN/jvhTHiubS3OxhvaMss2AzACDCBpqSyU4rTUfTNILcebU2+d0BmFfWBwSrwFbBeEpgJVmwVF37CCRhIwep9GhqQdMK9wpeSrN0dO2Q14PkAM5nejJJi+WK2avdvZ0MtFLCi7WrYl4c7wU9XujhZ0A91wQw7igb8g1bAN6q5xp/VvBv98gAyrNa3f2OQbkxW228RCmqAQ2rNJ9M+czCGtfrX2zcx7FBadsM1b7a2QuR53XGelH1BzsL1L5oqwXCzni24WdUCIb8Cc+BBuaCKqhVfJf0bEIgZn5DzVq24mwy4TjdVGmuCjBoTluF3bMTKhdt2m/UsaHjczJ+T7HWN+h3FZku+RnszKy68Vv84VFSq4PxZMy4KtCGP0gA6bkqKb/6AjJQypgxrzs9VoXqwQNQVVTPeM5UGUXx2iyB5AUoCoUZG85juFOwtPm5Zk1RguRgvCpOnrHnqPpRag3U9+X+6HoFYhQDcEDwIuOgylCvtggQVz9XZV4TON9B1WLzSKVHHaXrjUL+GPoSwCz2q1ZZEue6RmmT98j43bZ3v73mD96QPvwpTyBAogagQHIoMHhi0IzgHckiAExqegaBnXLNWT7jI0vkoAEwKYEjjZSe+PeecIrd8pZXvY1jO4JT8fh6DQADwBsARmjH107INsEx4F+JdROgA8YvkvoCjrA+nNXe/oa7eawH3nmNnk8CbABK4ZpxHfe85b70uCc8hvMPzBowwdRw/bH98W/+OQEbADcADnDu8mJSi4CUQKMH7r6edg4GBH7ARIM8cudgmIEGAEDx/W999dszc/+Xfvh/pXf+xT3pU//lP0jv/2Hvl9+HNe13fvH3CTgBPMSxn/zUJxKEw5ryf3/5FQQQP/4zP4pr8c99z/9Ir/jff8zP/vYv/H76lGf8/fT3/9nHEyD55R99cUnCh/75f57/DAIc973tgY39+7qX/wUBE0gEca/yNdxzndf2zr94Vy2jTI33dLXKoODMAfDzQFMxrcRkFsvsnW+8J//+/ndeK303QCGwmS7qETb3+6pjv/YP3sD+/LBP+JDatb/6fQCL9i7v5uvEfMG6qeMKaAND92895YP4bzDq8AeAb2wgruAPGkApHA/zGAb1EYD8y9e+neMBQPJjPsikpG9/3TvTi//Lb753QKmP/MiPTM9+9rPTT/3UT6U777STvueee9LXfu3Xpo/6qI+62cNt27vRomTCQCJ4hjijhtRvpI+Mnt3pGLsH8oS4GZCvjQCmm3mox81OXYub/bM2T5IC1hmh6vhmqmkBKTabzIa5b0c04Kw7R35+Mk+z0TSlvT49O+I5Vq9n8yZ6szSiLpu46XzA9NB10YfIsxOqPBUBg2qZ6bhJj2XiVTFJ11sNJrUZF9uq1h/Cs+Wq1hQ3gszCI2BqnAZTzspExuD0IpX8NrV3d6Mpb6Y60KZ6/LMAIdxjC2hvHmRTozzSN/+xkp/OJ/ZD9fyiAXUE7DA3AF6I8aS1Qd4uAgQ2eRjhPZhjAHfAMkKAoCBNQYHOM4LNda06HopgyORuCkjWblANZgeKIYjFlw2Axfbz+aFKhpAJF8wyq9Znhtkmb6LE0QObXsvGMoHpifnIEAOmP9EirXM1wzk3fyYDHBrriD5k89SYAsjt8xwFAPH4KHzqVU6rjf5HYoiCeYZg2u8B5h/LpnugyXMBmdPLteMc5j4HLYDDMu4eeJVGQGaJfjDDcPQRDN4ZQAM09OBOa4ao+wLRqiwsjZlijKe0CuxKSobFOPS16az5H5lcpXN2lhsDa5wHZVLHvLf9SjUuGcrHipF5cwk7NK51xoCVPPestVjXyHUygN3viWC2LgCP86cW1Nd640zWTYkZrRVxfagyn+A1B7TjLJZjdY15dxIHN7vmn/ecFEgSG/3ZCPBukJES5LHzxrMUYyGeQ52sPj5X47liXhxc3Se4pYp+myrv3cy1KTEioC57Wobfx4IVkZ0sCbhkkQigzvJOPJVM8zHOIhFHXrl3b3iqD/A8wtyUfLwKtMd2VqIogmGbfl+VfbPvWIzF1iC9puNUQWPuBZ1BLz/BuFeLz6ibYeZv23um4Vl7z5sLMACJICbMN9yLV//e6wnS7lwaZgBJATaADvxR0ig23GMASfgcgn2YXANUgkSvN+zShyoCUmgAiND0jIcsTiwkNYzNe//S5GdqVx95OUu/AKi9+v++jueM1x/9gY8sAQlgywDQun7vDYJRYAZhfwHWUz6P6yc8P10j1qnXveIvSiwf67tFesMfBvBtbSyd2P7kt16VXvLCl5IJ9JT/35PT3/iIx+W+Rt//9L//f9Of/c5rCLw9/Vv+afobT3wcq96h3f6Yq+m2RxcsHsrN4G/oTHKACb/7i3/Af//QV/9EOrh9P12+4yDd8X63UYKna1D77Z//vfRl3/kv0kv+629nSRdAif2ruwSkMIUv3XmJwNf//P+/JP2vn/j1fC/Q77c9+gpBETC6Xvgf/l/GfOg/MLk+5tOedOr+owEsec3vvz5df9eN9KrffV06uMNYPtUGFheuD0nC2x9zG9cMAacf+nc/mICS7jF+jmwsNYyx2DD+btxXyBAFIKHF9U998eF/72+RLQj7jw980t8oHev6vTd4vZJdqk0cmAQghfanv/Vq9j8Yb+YVbS2CeviOw/uP+X0Ya2/5c2NsYXziet7xxnsIhLJ673RBcDMmkiK4VtcAkGEs3v3me9Mr/8+fpN/4b7+T7njs7enT/9U/5FgHkxXgFMY8ZJ6/9XO/m94roNSP//iPp8/8zM9Mj33sY9NjHvMYvvaXf/mX6fGPf3z6hV/4hZs93LY9iCYAAaW08W94EEQDTpmMz2kwjlcMpGozM3h6M1PaGIfvOA9MMvaC+fRwQxEqj8VjR+CDGeFKJb/s8QQPy8rmL58HAybLuKuKlf0eF3iaGaLv1fuwUW33sGE1CUiVkRGlYpL9ZF+RcK7VjZbKFhtz6uY44joOsuUPSi7DTZi9pn6PxqVzv654/puyuRaobZYf1n3npj4/r1UzpRf93Lvb6qRcAj6qAaOup8qewL8pvwpZtps/j4INoGPG41fPDy0yMKoBpZ2ngTgADQmcuRQ1thL7yCWq8ThgIo1Ppmk9WGW2URWAuijQfAp0xkYLLKwhmEgVhqEzpU6BcS6z1X3gmuG0ckrdFMwNeiQdzNKUsSlkUI5RGEtHslVKmBspAcBamvG9BUIe7COYbZtZcNpNNMHExmEBBhI88zoGzBLwxbnh2rw/I4szM5jCGDcps1X6pNcN2Rp7JfYTNiO9/sTYHWBxYh0nG8HZTzWABtae6ck4teG1BHkbZKUerDFAB8jnBuHV8YCGcwKYpfOIAAVVzw76/X/svQmcbFV1Nb6reu7Xb54HZmQQREQcg6IRUdQoARMwDqhoPo0axQFnjTNiNKLgFGPU/DUqfkY/ETGI4oQBmUQIoCDjm+f3eu6uqv9vrbP3rVO3762hh/f6vbcXv+Z1V926de6555y79zpr713UeYr+xA4tqq8V+xor+mxuxaQzdnFhBOH8obJqmwzsRt6eYbaHybyjPH2WD8hI5Xh9sv5F0nEjgBrBrnFP5JnJIuWyYOG19ZCprEwRQLahkAcbB7GCqBFR1KhSnfV5o1CuyYLKIi04kf7eZH3C/ltS1a02WXo6XLD+dxWlPSL1p2N8WML2WAGb7stYuRfW6bBm2WdsQ4nXylyWEzfu0orYvPESipNmV1ok6axK4Bhxnq28jTm71jhPXyP1dNr+svcntM0240jCo2pwCAdjBVnc43L1GWnq0lCBNhT2adU2c0wNn3vTv8tzX/5MhpWBcAIBAaKoZ24PnVWoWs658EwqdWJArYP5+odf38mwp5WHL5cTnvpI+eZH/6/c+T9/kmMefyQVP3guQ6EBYgVqDxBeL3vf38hxf3FMjWqjZ243HfCffPVakg/IjwNHHCqhE59+vCxZvSghpBg+tmVXMh6hBIEzveLQpVRDxbmIQASA2PjTzfdRRYWxhuctyJGH7lpLYgLXhnN95xP/T278ya20J458zGFUr5x8+qP5fWjr7666hUm9V39vBZU3eP1RpxxLIgHfCeURns9/vu0BHg9VEPoE8wd9gdf+44OX83n28B/XM5k4iCNcG9rYv2OQZA2A83/pbV+Xv/7H58rjzjiR8wrkG9XhQyNy1b/9jKQSCLVT/+bJ8uc/PJCQKbhOPKONJIQayl4/9PiD+V1oI4iTz7zuyxNIM8N5HzxXjv+LY+SGH98i37vkR0H9WyzIE//qZDn9vKdRTYZE95e89kvs3/e94KJE+YXQP4ScgXyDLXnrz26X//3t3SHHaHtRvn3xDxJS6FFPOZZjZHA38kAtpvIJYxFkGfrq0OMPkqe+8EkcY1BlYXxY2B3wPz+8iX2BvscYQt/imtFXq45YIQcdvYohaui/O667W677wQ3MrYWxfeNVt5JUe+rfPEmectYTeT4bV3h9x6ZdNQQXiFSM6a1rt6lyC/dyHVV+uM+P+ctHTSD/oHZD2x66c6388v/+j2x5eCvnWP/OQTnpGY+Sox93JI8D2WQhhMC2Ddvls6/7Mqsd4tqPe/LRJFFtoxBjZd2fN/L67vjNXfKHX90pBx+7Rk57yVOTyIJfXv5bhuTh+27/9Z3y9X/6Dp9ZuF+/+f4N/B4osp78Vyezj//rs1c2SvGaoFBpZC1lAB+5+uqr5a67wmA99thj5bTTTttvZbO7du1ieOLOnTtl3rxsBnZPwvKRDOwKuYggO+yd012zm01SChWqUN6dCYhKNEYgOzVjIet+VRUI9SuyJO0YGKIjERyqkIQ2DzAosHCZcxo7cSFB+8SqS2Z42m6hVRsLhmaQwnf39vBzVuUvBPGYEY+QCJBhY0yMyQTsvd3JrqTJ1mn8sSISKhIip0FbslOah9AWxLaPkZCzCnnx+1lhjVNFSHCOBaQ2hNC+k30D51eTozbaVY3bCmTd79iwThv9Vvq50e6qfY9VPspTxs0kYuM9UZypugYIIWFByULSAmobdZzT50kTSEZUZTl4WdUDG6HGoULesJHR3D62fjUHM65IGTsoecn4g5pwVEaGh6W9s5NqvuqudG0YSAzurGs4CZcZ5PaJko7bd1oC63S+j3rXnkVq83xaVQ1/kVTS/h4eBKkxrsRpIQn/AGwOhOscCdWqQH6gWlV7G69jsH+YCiOrqgaMkHQPyTbxeVbbU2fKSGxMNhikoc+DcWS/GzGEdQVrBT4LJ8muJU46bUommxdJFVE9pykpYwwPj1ABCrKNKhmqJAtVdZbmzOH9i8I7bS3lXEQocSo0MC8RPObE8MAQCwQYoZTO1RU+hzDxicn/46IDeM+cxdD/Q1zH0f/xsyxW99kcyguJywpPjMcq8zepImOyyPuOeI20/jNnmv2f6gc+kwaGg+JVHed67Z8OZOXvqwdbCxk2y9wTE583RvziGbgn13K7FuZWyiHFbOOsWomtcUhabPvkXU8rGzGWJ8tye6ZBlaoWjbFKsAxhixLL2vo8ODDE9zH3TN3O4ie6WcfnQ0dH7hyxDb28ioOmSozJTvyNtZXqMVaErV/9qlFF0Qn3UFVjcRGWdJtM3bh9yw7aiajuGlSgVXWVrfH2XEebg63ZnVuldG9gtvkTM3FtT5MXSHuhfp9D6YFwO6iAQAZ1z+mWhcvnU+0RK0+aBUKQnv3Kv5S++XM41xYsn08Vy0//4xeZ5zvqsYfL//nkefLb/3cjSQU46xvv3yxrjl4lT3reY+XKf7smCWlDKBLCmxavXMhwfiiOvv/ZKxNyYcGyeSRabvn57fwMnPWTn3Uir8tInTQWLJtPwqDRBie+E4QWwgANIfRvLPl+AOqoeYv6SLyYosYA1djL3v+3cv2Pbk4IIoS2gRw77aWnyu9/frt8/7KrJoQBGk456wly5uvPIDGCZOFQl0Fpg7Y/9YVPZBU9AITKF9/yNXlIFTt/966zSK4h/A8AsYF7ZADZA2INYYgW2gjg/v3p5j/Ltz7+/Zp8VcDjz3gMCazO7g75r89cyVxOMeYunENiytRXzQD397gnH8P8U7g2hJ0hWXmsesoCyE3kCrOQxCwg1BJjC4TTyc8+kYTjrT+/neQUSEKQek875y9YNfG7/3JFUOClgPuPe3D37+6lDfmsVzydua1AshrpmcbRjz+SKnwQoSDxEDqLvrnp6tuSJPQxMKYwju+59f4kN1eMQx65hm3EGDe1YQwkQ4e6MT32EnSJ/HT4uw3XvUmRUgcaZttDhGTI4LCMquGPvFBZDi8cIRoIcMw0dwtDxfSOp5M4m8MWJ8muR2iY8onx/U2QC2ZYcfeqAeGTZ0QjvAjOS7mkZEKxjQ8zTFTmbaExGRK+4n9mKMMwxAIIA7a3rxrCB0clSIuDQsIqtMXOf7pyXU37xuGkDTOJPEi5mFSLCa9mQvvSMCcnnZw8lubD6CpFjmyaKDEYCdRKOWvr+3Sp+Pj8IeF8IENCKGK+4Z/sdGoZ8nrhmnG785KzmwEcv1+vAqI5KFDXoa1mwJrjbuMMDzM43ti5ANmKUIdGTmx8T9JKIJARCMtiaFKU86YZWPusOhHIAAvBzSKmjHDLc9rroRl1ZLptJLIGg2NNZxwECnL7NCCo7fOtOLFGnMbtzAtBjQk122nH2oH3g0ozUg0mBNRoGMfqwKQJN6qmxsakm/llOiY4p0aKGdFlhKCdf/euQa5JvX2humkWsWmvpUnE0J7we6x25QYErxHfVaugsrXIHFFrS9zn6dxK6bbY+dJEtH3GgDUA4zOUsS/I+Mgo5wHW5ry5mDV+7fuaeb0VmLoOGw5w9psZn1mIiSTkXzRi0v5llVAB2QdnuyQ9fQiTyq5yiucYxkyhrShz+npCmKWS15N5XjTK2xO/bs9uqurqPBOMlAphnyAiq4Rts0qqmUIWcT0Z5U4azYw3I1MaVSSqt6ETvx+IP+SNw9oeNpTi4xl61z8oQ4NYo4SbkHg2BSIb89sKPwRSPWvMTRa024ZCLh3L59cKzH7Kun4bX8ODQ1ybsWnaO6eaIDe2Q/CsGdjZT5tuzvw+2rSW1zBdJZQk+Rg2v0J0QDPVVQ9Uf2Imru0tz3yv3HbNnSReQGYcctxBzPEDJRHGAciGLMfWAMIEpBEIBxBKuHUgM/A7NrSR+BlEytzFc+Vp5zxZfvTFq+WuKH9VGlANwZEHQQKFyU1X/54Fn0Ae4bmeh3TC8DSghuJaHlVxs1yZyd8Fkb+98EwSUFAYYfz+6ru/TZQjIC1WHbE8UeHgGQXFUbptIN0Q7oUwttjxR38+5i+Pl7Pe9FySxngWg7ygorkDypddVM7gXmBe/OI718m1374uk3BBP6Gfb7jyZpJgx/3F0fxOhCuCfInDwwwHHbOqJgcW/CmQfCDvjn3CI/gayCx8N8LNcG+hVsNOAnKFIbQPgHLJFD1QOEEZh/Vh84Nb2acgUr763m9N+H70GZRhIMSOOulwOfuC58mWtdvkuv/3O4aPgUDc/NCWpHLeY57xKBJ4P/2PX5I8Q5hpHoEFogbthmIN/Yz+gOofOa7i/E0A1GsQM0AdeOgjD2KbLOxxMpi3uI/5u6CAignJPIB8gg2GsWekYB6gtjv/o39HZROSyIMIi8cUSDD8jb47+uQj5Pbr7q4hLOFvL1y+gL4Nxj6Ithe/92yO73t//4A84jGHMWE9CGGovTDmn//GZ8o/XHz+zJBS11xzDX82bcLNLE8I79vfMBsfIs3ueKYdzazdbwOM9oHdgzQOjLiZzp1P202H4Z1l3ARDIpS7NxIg3X4mKx4O1cYsd4TtRlteKsrQx0s0+GGkUQVAaTp2AUuhwo0aMFQdjQYSKpZ/p40iklI5BiicXail8PSx5KqmuAmqJTWaVbnSrFFnpBYW5LhSWKzKCdc9VtfRmgw5ZoQTHsis5pixy2xECRPGIo9NAxUMjEoo6xCKScVeBskX77SyiqBev43V2MDnsVH/NHJAwo7viEr6a9VPcTJmU4QgdAnjp5kS6rETyM+PgvzCzndH2OFGSfGuDumb15e5i91o590IPZCweCDUIxnziIZ6bbdKkmnys3ptGj6XIoAwlzGnQ8hZCG8Lu9cTFRXx9cFhgPESxlZnTX/EZHc8pmyu2rpXz8mMkwPjOPQdJPe4z7j3IAeroTLVnXgjFfE3xioezDAGQUSBfMMx/LzmhYtB0ksVn1y/MF71PsEAQ2gkQqnxeaxBQFudORA7cRhPINXRTQiBAJmQrE0N1JBBWalOdKrfLD+WhT1Zf+D7bf5jblv1vjwlj31HCLcMa5+RhjFRH6tiTcWWJrwsFLJZJ7IeKRIT16bgCmqSbKIoHqNJ7rPo+YNNm/6dA+yTOXODQ2KJpy3vHkipkLsnqJjzVBqcA5r8OhSymFg1dbKInx04V6yCRf/37xqk8zNnbjfHY71KapiLWL8Qwgq7oFm142xAq8qdRudK1gqtdBnbXzYXAa6lLXxfvQ0BuwaMlzDXq2MFZBE+g/FobZoMcWRpC5K1K/X9LDIRKT9bQSMCD5sB/dv7OcZ6582R+Yvm1dh/zC9I8j38jjbY8z7OQZgmc9PPgP3Rn7jsssvkE5/4hGzYsEEe/ehHy2c/+9m6uX0vv/xyee9738uiVEi58vGPf1ye85znJO+jv9///vfLv/7rv8qOHTvkL/7iL+Tzn/88j23l2n59xf+wGjDGZdaYBkmBXEKwHx/55KMZRgSSCuXsESoHkgWfxfi++ad/YHjTIceuyf5ShOwPj8kvv/tbElMgKfDcCom9e+Wxp50gT3r+yTyfAbmfvvKubyZ//8WZjycpsnjVIvnWRf9FUgO5mZ73mmfS5oDzjjw/CL0DGYGQuROffpyc9cbn8ry//eGNDLc6/IRD5aTTHsVQsBuuuoWJ2x//nJP4GgiSOB8P2opwxKNOPiLzeYp+Q+JufC9s/BOeeiz7Bq/h8whHQ+U3OPz4/GEnHCz33RYSyWchTnCNeQEi4geXXZUkkf/LF50iZ7zqGblrFogphjeCPJ7bw9BG3DMoy9bfu0HmLJhDNQ3yHRkQzhYrnbr7uklyxIA6CcnIcf54/QSJieP/+LtqZUGQPD/7z1+xP0CGIOzsJe97IfMAThYYY3f85m754033yvJDlpK8A5GCsM3HPfsxXF9wD1YctlwWragWeQPB+eN/u4bKs8efcZK84HXP4jPSgGvBuACxipA+kFQgaRByCiISycqh6oMiDEQhbJODjl4lf3vhC5iziwV2tCLp9y/7MUMVjzzxMD7ToS5k9VHd3D/3HWfKSc+oVjPEWITiCffqlmv+QPsRycnxnEf+tWe8+KnMNWWEIAhTELUI6Xvcs06U5Ycu5XiFchHPsbX3rJdff+962uwnnHoc246IJBtLqx+xkn1n4YgrD1/Ge4o+wDzsW9ArY+UxOeV5T5x+UuoDH/iAfPCDH5STTz5ZVq5cOWEA/9d//Zfsb5iNpFS9fDhpRRUQGyp5O4EYuGA+MejhtNWTeAN5eQ3STou9xgpRWr0C7Ynz5NTbyc5zFgyxw2N/BwIshInFiq+0oWLONYy8PKeumZwaNeFScMwQWmjEiapwjPyiU9rkjm3Wbnfcp4Gs0OvJUfPUO0+97zZDkJVwcpRSZsjW6z8DVTVDIWdOHKKTPmecGNiUYiF0KjhxoTJPtcIYiABL3mzGOxynePyas2shjXFSWbteYDqcLZt36Dvca/QRdoI7Ojvp3MdjIsk1oteaZUCnQ0qMjMsiGRuF02SNZapckKMJ1cAwL7UqJfvWkl5bkQF1sFslOtMkOsbC6NCItKmDYduGRhRDRYIE2CCDbFzb2GA/aOU8PrQ1zwiOixVz+A4LdcG/JI+xHkSqQrsOhrtaxTxWVuwkAQESkyQ5rzu0Ee/Vc8xiMiMml6yfrQ+NfAhKzuC4JWtSqm/temKnMxCnyMEUiCa7n5bnzuat9VtMSln74AjCGGJi2O6umjw9Q4MjMj4CZVg31V3J9WQkHm7kjNp4M0VVhQR+eD0mnPH8wXfgnlk/NVoH620axOSMbVbYOMtyBCwMubrJEcKDbKMBDjTyX2EuQ62SbLJgvYnmAe4BCYSMkMt6aLQOGXk8MSSy+n323LOk/xgHYb2p5mFkpUYqU7qSCnRQYWY9Q+IwfagUrLjGgQSzT+B04NaQcNX+snQJVXVhKOgwXeqceCMx3vBiVc5SCKuMi1DEdhNQT1FrsHlpStz4HKbkAsFuz4A8pWMWsYZ1Cmtn3lzgOjQ4zPB0HIMNq6xiJHZ+blpoSKbZUmmyPH7GNquQ29f8iW9/+9vyspe9TL7whS/IE57wBPn0pz9N0unuu++WZctqS7YD1113nTz1qU+Vj33sY/K85z1PvvnNb5KUuvnmm+X444/nMfgb73/ta1+Tww47jATWH/7wB/nf//1f6e7ubvraHrj3Qdn+4K6EqLfE38B9f3iACZgN2PRZdshSPtusnH0WoYHqbgjHg0oKigzY01DdwOEHiRTnkjJ09nRqPkuR4085hp9DYmYoYH74uZ8wFOmYxx3J0Ci2pbsjqZSLcYPwLJAPCBWLQ+Vs/FsFQRxjYWQgH/A98XUg7AlzdteW3VSYYIMMZAtIFzj+2PzCtR77pKO4GXfX9fmqL/SX5T4y5x9AW0BY4VkOlRFCseI2g3SraB+j7wDYN7/78S2yYOk8Oen0R08I3wOpB0UVQiHTpCBII1ToQyLrJauridIx50DqgGDBHIyvJa642CxAYOK+IxwtruZoRVuOfMyhcs8t90+ovgiiBeSM9RWuH6+FdDMdVDuBfMFrVtUxPebysPqolQmhY8B9h82NMD2E1eFeN8IxTziS/bNr226qCFcevpz9hv40ggd9lk6ubmQaxhzG8uqjViUJ8kEYxcRgHuxe4DzoI4RlxpUKTSWIRPjppP+YF3he2PhCUnizNZGTatGKhXwdYx4V/zB3BwYHZPUhq6aflAIRdfHFF8tLX/pSOVAwG0kpC4OKjfo0KHnWqnWNcgE0kvxbWAwdqIzdeToxQ6M0XJB43ZxL7u4xCSW+u7rrzCpcWgEJRkvIAdNGByLtOIVrQPLlKtGQdtTzZPGxks927mMDJkuVkIWssLBYkRKHEoQkxxWGZeBBi8ShzFujVUAmGzpSD60YiXsLjdRAsSFpoWAWmmeEJv5FEm68Doc5CW9SQgVjHQ98jDcoGUz9YSSRVW+caYSd5TBHwjwc1XxCgSBhXiTsADP0so2GhoU01svtY0RMPZKxbrhpxq41c70xPCPkXUmIJ51fRp4htCQmiBqFhMYqBctxZsezT+BY6L22MUFVE/OBjEixrZCESMXnTIeZgayxZN2m4iARqFVJkAg9756nlTQYOyAZQJrC+bY1hDnGQChpCOZk5hTJtt3IdVCWrt5QYt4IKYYWk4QLDlm9sFU7F/PzMV9EbW6nrP6wfkv3H0mp0XH2EeZPkihc84NBudrZ1S5dXZ01hD7alk7enNVGI5Xt3gNB6RrGLp8FOk5xPMgPfKY7J+9fFgFaL9F2/EwjgZmjEo6fqWEMIjn/CJ302OnHvB4fLVGmz7mtitVGufSmA3iWkjjQxO4xCWn5JTF+SJBEcxPXgMkdSAwlnzoCuc3dTp4nJAvPu5/Wj3syRK/eJlf8e97709nOOMQO/Yd/AYxRKwKC572p/9IbaGmSp94GUbwmxfPazmtKQ7u8rHti63OeIn5c1werwGcVkLnpgb+RwgA2W6WamDzYgFhDkMMqFHnA9aI6oc0trOlQMmG9yAprj4n/rFA+oJESy55X+HzeBl+sIgU5m6XK3tf9CRBRqIZ+6aWXJn2N4lNveMMb5B3veMeE48855xwZGBiQK664InntiU98opx44okkttBXq1atkre85S3y1re+le+jjaiy/tWvflXOPffcabk2RjEMDMuubf3Mv4SwoxhwwOHgI8Trnlvv4zFpMgPXCrLEyt2j7SAXQF6AWECYlmFg50B4rqb8n9jRh+ONdqGKHogdOOfIzwSSIMYDdz7MynAgM6AMiccUwqDwNz6D8QmkqwU2C1wP2oGKgiBlMDeRsBxKJCikBnaFvFWYU1AaQTlkFQBjmF2Hz+NcAJ4DCIMEEWWkEcgtq0aH90FcgZRAbiUQbkgYn56XOA4KoiNPOjzJb5cFEC6m4JoMKYW+QBtwr++7/UGSm71zu0lEYm6vecRKvo9Qs2btMtiXyLF01MmHT7guI00R4ofbi7ET/FCNxMGmpRYUWX/fRo5P9B8IxvS5oKwDSQPicWDXEO0YjFGQOggnBKFqQMLw0niZCqYJG2bjpSQ3GfJfxao7ABULQbJZHxuRB9ILfg+IfiQmNyINx68+cmXDsWd/41xWrRHAeTG2cT9AvjVzX5td91ompRYvXiw33HCDHHFErQRvf8ZsI6VixUBevp9mE1s2A3NGzDixMJd0iXgYxpgAWDQRntK/a4CGXCj9HRwwU7TwvAgRGR2jc4VjIHVNt9NCroK6qmpEZe0eZiFRYFGlVKxJRp6ogZCcuY7iIyssrF6omDnxMNoGd4c+QaUtS8hpC04eOdMqLA+WKTy4gIKwwa4/QkPwwFCHo96i3UpukLwwnvx7gB2YoFCyz5iTY6qEkJzeqgMW6VhZ+ElsZJp0Hw8JVrCjT4XKS9VzIewO6g5zxI2Ust1tPFgmS9bVI31iIsb628ZZlrIRxBR+B2lSj7QzZ8YQt72VMWREQXrOmFInVmqlHw1Zbar33Vl5ttLOozlfds3myGXlUssCxwWrs4V8KjFpZtWXmk2mn6fUAaCawhjGdUyWVA7OVCArQSpYW6lQZW6hNumJCKZGbc27vkQhGiUSr3eeODm3KWxMXQPE49XmfVIRr866aePHci3ZsTFBBsTqhniOx9/Zak68zOtMVfyMYcoTfDeeEbYRk6xH6nRzjqrqA22xeVkv/C0PWeRD7nHc4BkPRTU0b1BMSu3e0c/7MXfhXLaZ1ds0ZNzmehwez02h6L6wj/SZhbMiL5ytScBUnlN5yuo04txnpiwkedIZiHK7hyBR0SojOADbbLBnDZprz8JGSuKs/sZ8xL2hKjHjc/07+9kO5Bu00Ll0mHc6hDJRNmvIZt5mYvy59JgP9tIwX4vJaGt3PGdsvKbDLS33HYjodGgpVUsDwzKMEujFaiEJC1eGrUaFJs4/MsaNg775faosHSXZgP7As9dg98hsR1vb443HeptVWQjEXP15k9hoavvMlhC+6fAnRkdHpbe3V7773e/KmWeembx+3nnnMezuBz/4wYTPoGL6m9/8ZnnTm96UvIZQPVRN//3vfy9//vOf6dfdcsstJKoMp556Kv++5JJLJpxzZGSEPwZcE74HFdkne22w97FJl2xeDY3SqZ5uIPn0js27qEyJn/X1gLVl3T3rWY1stmz27gsIz9aw6TnbEQrzjFMVvCfRaKz/4Vd3Uom14rCl8vDd6+WQ49YwSTqILySJRzglVFNIGZAHkFVdczplwZKQmL4VPPTHdUy6D/9+Mn2FdQ+kOdYnrH95aHmVftWrXkXZJ2Sdjr0DM9rMKEs7yLFCJjdBNHalUkRFrIhKVz8Ksathx9vIKTPUg7IFYWmBUYbRPDw0SsOF+YbaglE5Pg7So0rGlAq609YTwlGy2hp2w2BcBgOp5r2oYlo9mFMBqTudm86qA0aDWUvPN+pv+z3vtfj7+B4Jh6JIOeTHKRbDgsxcLVCedMKJbp9SolBz5GAodhSCrB6OtRF5TL6OsA0N3cjrK6uIhZApLHyNiE5TTFg4Wb17wGTwQ8M8txEHcahMonpDX3aG3CzhnqUc54gw4fu91cTNcViLObTxvQKrb9W3oICAs2HjoBWnqoZ0Qjlqddrs+mN1njkzJGVwnysTHbTOqA15uTHsHBgDICIwliyPQLwDHcp2B4IrD1ZePD1mGbLXVksyTXCwQGZFTpKpW7JILrvGuA/SiMmq9OfSSs3Y2YoJKyP0JCIu7T2M/WYQkxX4DNWXqfGPMVUzVtsmHlMPRmCDWE9fnyUEj9frRqSvtTWLKDUnvpn1I26LHYe8V5LjxNmxIXw2X+0xYVx0VCtbpvOTGfLIS47XjskT+HF+PKy56XlvoZFwqKEg4sZJR20C8Nhpjp+1Ni/N8Y7vWT0yxkKfURm2UMkmyuLvtgSmuK9pkqE6BzC/a5/58dzhmOmqJbNRtTGpbCsVbtBUxlXd1t6WFLGw+9iM0se+NyYwifZqX5gNEleCtKqaVI52GklfPTaoS0GkhfyNaHcgHWhUqEqpEJR4hSoJYikBTMXUiPC2/H1QxFFlpohDbfEF0JmVyiVpK2WrcNhfWFOVdE/bLfXmNu6l5VACjADF2s/Q3I6J63OcEy+xefDMGBtLKvIBII2SBOFKBNp9CJ9voxKQz+MaJWMZjePnCwgXLVdzCoZxGcKwqaqKVOz2PUl+TaQ10Gedhcq2mvspK2dh3B/2nAj5POvbd/sitmzZwj6FiikG/raq6Gkg71TW8Xjd3rfX8o5JA6F+SOmSBpxPh8PhSGP37t3TS0oNDw/Ll770JfnpT38qJ5xwQqJcMXzqU59q9ZSOFhGrlIyQQNU526mLK4llJkJmEtsQOxwIiGrpalOnmFFDJwWEUKq8+MQ2hbA0np/Gdkk64Wxp6IwlwA2bt2rgw9gqwgCtVq3LCjlLDLJoh90qC9JZ1PezrtMqvNGIjHJRxcfH5eKzCJYs55mJfUEsab9kAdcEVrlSCflTDBZeUaljgMWqpdjpSbfN1EZx2JW1uaMTRGFQdVQKwTjOghm7gXms7xylv3t8GI5sbWjXxA8qGaI79BP7qY0lnqlM0DEHZwkwsoohnOOoZtWTOGXx2I5/z3KWSFZhraoEFYmF12WF3cTEh7WB41UdYyMnkuP0vdgQjpM7J22EY1cxZ6G1ynMA5xB/kDg7nMOqvMChHBmsyovrnTvv/sZzI+14IpxpbHiUORdqnF7k6NI8XXH/ZZHinDNM1q73YhK58xgOXKpNMJy0xdrdwMmPYWErQF6es5hgoYOMalcFDOqmLiFZV0zZauSZOfoJaZlqkykfG11HvDlhBEPN+7p+2HiOidWYYDFnOE+ph915loXPmH8T2hSNCyO+8JyiIozVXXoS8jQmbxqNzWYRX2NCQHB5mzgvwjjH+EIOponjKhnPqWqKBssjyLVqLIxNwFSCICaS56mOA3Pasc41SuoeE89Z+XH4vuY8yyL68mBjplI0VZX2T1fIoWWV3bAZlSjpotDAemtMrN6Nc1nauhJCyKpJq61fw1gJvxsRnHy+CBsH/YX2BLUr7BLsLtvaG0hZhExHfR5t2oXiDGUpQgaUM3zxfVgLSl24VyCoap/zmKsIDS/PCYm2s8pnG0jklKptSRPSccjaxHWzJPg4z69txevMuWT59JSE5/3UxN8xQYNqoRWm1KkWS7HzJ7mibINM7UfMb4YQg/ArBEKe/Y/NkPYw1vGsx/zl9+umFv7umRN20bkBNFaWgrVJ14KkIqjOg5qxGl0H+q3SZD6ouEiJEd+mkAoFOGZP6N7+hne+851UXxmggjjkkEPkwQcfrOt47u8wVchUFGP7A7wfvA9qwgJ372aIcD20TErddtttibTz9ttvr3nPF/49h8SRgHGohEKjcJoYMMDNmcEnzFiKd/YSZ0qNXRoHOmISlRCTepvTMSaD/cjjEhQ6HW2hvDGNxWIbMkolbcd5KQNXhQ+sLsulkibU0o6pGW+2ixqHfSTXDxtbKyEEJzjk9ol3uI0kSELINGdEo+o14ftKlK8XZOKOelDLBAMM+RbSsJ3KLILGzmF5qbj7XUeVYGqUOFSM5JCGHZgypqEDXQjkXF5IQexI2e4nX4NRSwcUjmX2lzCxOXI/RA5zrH7AD8II4hw0/M5E3aXkUAlqIBjQ+eM8hDUFwhXXHpOJ/B7NdYEYfCbHjoxjc2pwPea4JCqCKPcYSaUMktDGY55C0c4DVUYWkRfvVmf2I+5ld3WX3ZRfHPeJUz31nC9xWI9dHxxTJk5PXZc55DWOloZ2xYo7tHFocJhSYzhA8xbOravitKTMRmKHsRYULXinpz2HXGAfNv8sqjrKwZmx9sdh0WmCxYibZhETmVRaaGLuOLwtXnsScrOJEMnqdYc5nqlI0yqWMl5V+9kaagmyTaWQt+7B6ezfORg2LRbNnZDsOh3mlR4XnJfMdVUKSotUQuI8wmWyiAkQPHvs+vIULbgeI0fiNti9YShXiviPP88xWqz2q81jro2VEt9LqvPlqK5qVJiRCjhet7KuMzwbsX43F6aahrUlkKNVJ75UwTywzYS26lqs9zbdjvSGj72WnA859FD9NiH3atuBvrUcfMmYjMjaeC2378C9xbODSd113YUqNial7N9ApIaNsUZzKlRDRMGFkPS42NYtHdFnakhkCTZLeq6GaqFB1dXeEciZvLxPZlMYQWQhubFC0PoS/wWCTZ+XlUghhHFoZKCplPQZYeRvnIrBCFmSZ1IlykHGoY4kbLsa0poNAc8WCCOMOailWLm5f1h653RJN3I+mv1oZJTaWnaecjGo5u1vXGeyVlDdNhZUVykSLwt2baZc5toJ8Vzb9DwPZyOWLFnC8bRx48aa1/H3ihUrMj+D1+sdb//iNeQOjo+Jw/lidHV18ScNEFIHMhljQB94P3g/+FgIaIaobpmU+vnPf97qRxwziNhxsodvrMgIMvSqkWKS6c52VTVFOV2yDL+0oTUhfAxGB3YfiwUaEiMDQzwGO2YwFsNOWtitjM8dVB7BWEIloGJhPIRU1UmCbQqTROrdU83rkT6OP9EOb1bb0wRAMG6CUZNV/cWODQaoJovOyIEFVQ8IFCR8z1Li5IUqxsY4K/cVqoZ1nrOYVnGZA9PWXnWwR8dDAtMsp4zkoO5qN5LO23iI+8RixGvCMqIEq/ZeXt/HYywdWhaPY+wOd3RVS9fXayPCNBOVWYZTz3ZFIbBWmYpjj3MhKI8SxWCH7rBHDmN8n5KQJk10m6W8ihV4CaGaQeQ1MsDjc8ckVtqBmwp4TlVlxU5alrppwnqgDgIcpvbU44VRNkqgGfmU3AMN5QEwFkdHxgVfbzldzKmFAwRlxNjoqMydPzdJqGvtzlPr5eVLY5/1VMejJQkHkrUFfnhUQW4yeY1qlJ9MJly7ZlE5aRUIUaUqCk2tkkeBFMhqQ71QJITO9u/ql67ubpmnxE8IqQlEEQgnC/sar4wnawHaESdYZs42U+qlvsMc3XjOZ6l5QFSmya+YFJkuxKFAzZy30X1tlhiM14Nk3bBiDHGoaI7qqrqpEfq9EVEX8uYEtWoeGR6f274vCduK1tN0RcX09eSt5UaOGHkVq5zS840KwUp4FtnzKP0MRjhYPRLQlISWl4jnicLxQhvDsfZss7DWevc5HW6J+VYar27cZT1LbBMEPyA24/vFTRGqCrPXyZgAzSSTM8bHBFtMu8fsPz5T4nDN7lD9Fe+bqir+7pCsP9iAtiSBhA0KKlS6DWGP2NSz8RGS/Y9LobM9JHovFliRcmj3iBQLZdp9psKT9tpwVr7eFtT3WPPGKujbQs1GJfodGywJ2R6vMVo0wXLm2cZeTD6W+P44bdw4R910Ed6zAdjsfOxjHyvXXHNNklMKfYS/X//612d+5klPehLfj3NKXX311XwdQLU9EFM4xkgoKF2uv/56ee1rX7tHrsvhcBzYmB2Z/xxTAo2stgyjthLK8SJPBMXgSGTKnWqQCRo2YooXNVITxVSURDSdd8p+aATASFBFEncok7w1GqIEoyHJ91AF1UtQDOH7SQRN3CGOjzUDNil9rY5NQmrAQG2rTdCM9lu5eHzWwk6yyBMLgUt/NxArhEwlQ+UXSK+MHWOGFrJqVW2y3kaOlyUBDblBqvc0C1nkT/o1U5AxmfYkcyqEcaG5SiKHP913cbvsWhupPNIKuCwHxe6l7VwzGW9EYKRBh6irPWlznjLCcjmZOiauBsY2KZFq6hNTCNhciBPXIvmsOfVZTmaN6q0tVPOyduQhUUDUyX0yWYKkEdI79JP5PPL2TCADEUrb3Sk9SJpLh68k5baQsBtOJvrFQuiohkNp9UgxiXNCXYYkw8NDIXddSFrfRGLwaG5ZKBnVakwGXp0/zDmkzi4QKzfz+iOed41CRbg+wFFWBYU5e+1dQdFghHhMMPIzII80306iPGwirAUhd1A4ofJLsVg9Z6IeQQWfRFUiLFYB0g9JlBmipM8AfCeKNdhn09fUaK4HB3mi2id+Bk23omE6nFBrN8aLzfe882YScSAgI8c5i7SDwhjMp6mUqPhIhcTmIZwT6s5AIuf1Y3qtjRPVp8+XPr4ZwpCkR7kaipZJnGJjpFw7Butdlz2/4jXQ5gLWDK7BndVUBhPaZArLSH2bh6zCJVgHeuaEpPdx7qt44yuem9kbUBNDiWMSL1lnSAwVEzW5EWn1QqrjPh6vhL43Eq9GXQUFur7PtrRFG0JqJ9qzjzYWVLL8imoYJ4h6bhomirTq8SGksIfrNYhvU0JxLdWE+rxGKOWgBNPiJIGMD/OJnxkvy+CuAfaAJU9P7o+qp0jmo+16TwuFWuI5pKAYp03KHKZqu9kzaX8CwuaQ2Pzkk0+Wxz/+8fLpT3+a1fVe8YpX8P2Xvexlsnr1auZ9At74xjcyafknP/lJee5znyvf+ta35MYbb2Q6FutDEFYf/vCH5RGPeARJKuQORrhNnEzd4XA49iopddZZZ7EkKGSI+L0evve9701X2xwNYA97I6FQ8Q7ybSS1NgOGyoEJxEG1KpYZqAitsWpDdBKoLAhKmHRoDnbeoSxhEm39PAAjYs6cnpDnCqFtDCkKjmNsXNnvcSU9+6HjlSPZZklrdQrs/di4jg0xM/zgAA7tHqSUu7CgLwk7ySJPGu0y27nxXWOlcRkfCmREXAmJSqXubhGoeugsgBgLMv7wHnbvQrhF2oilkVVprrx1VvuzXuN3qBE5wTDWEEPuImaQKkZMhl3YSJVXJ7F5TDA1iziMyWBOkeXJCWMyhAPkkXXp3BLNIFYbxQoBXmNKZRcTs0bcwjlCGGc611LcH7Hqzb6zXl8YURbnR4oJwj3i5rZLAAEAAElEQVRR3nqy57f7D8T3IChlApGXKFh0rMd9b2M2rxoO1px5i+aR+E1Xu6rbrmhuJeo4VVyasxLWy4nFBxo55XFoDEJr6oHrwUhQVmCnv5prJeQ8svPVrAvss5AXD2t7M1dcJXQL0t0LZ1JkjlajrDlvivxK1DGpZMz1+qBR2GkzmOnxbPPKkqy3SlihdXFocUufzcmVWJvTrCDFqJoawv3qrbMGG782puNcZVnXz362kNjovfi5Ea9zzYCEQluZREASGpaTuwvzuh4BaSSg5RVC0Q6MRdoamgeJmwKdQfnUsH/wWS2kkrXhEY9bCxmO2wKbhtU9tY+CigtEWdjEsmsKZHHteoQ5DsURyBkjWEIfV9WyBvTb2DBsJpGyqV9VJRzaFjYUuY6lNgxicsnun/WTXZ+tyWnVbhxWbOcMCrXqpgvugZH6YcMghFnauCGZ39EhnYsCaRUqMmkIvbQlv1ufmmq+0h7G5GD/YKLuGkIl5jaoYselHOVI5djFusTnKY4Ntm34PlQ0RN8VKW/Dv+1dsGvapaRJ1fOIy30Z55xzjmzevFne9773MRE51E1XXXVVkqgceZ3i+fHkJz+ZRare8573yLve9S4ST6i8d/zxxyfHXHjhhSS2/v7v/575oU455RSesxs2bRNAKB8q+mWF9B1I8H7wfvCxMDkUKk1YHmDeP/OZz8jcuXMTFj4P//7v/y77G6ajhOt0w5z2UMoaaphxOmmWGDeEnVhYT5VMCIZECBcxZx8OHkqeM7mkVlhhFbaOkPCzJi/MwBCNiEJbu/TN7aEBgBAQ/GtlIU1+DyuJoWpRBZa8Sl2NSn9zt05VCxYaYEZTVjUdM5hgUKKqEt7v7eut6YvEkWyi7HzaQQjl3Uf4WkxKxeoevBdCkUKIDBxAqMNQ/Y3Krd6gdshTxCQqJ833lH4/rjiX91qW4iauRsVKU1SHTAzJsetIV3eMz8v+yyBJ6t3L9HE2Xi3Uwogcvq6kFEOoMgikdH+l85FlOR+NEFcGzLon5rzjPagc4CxYCfWpIjgySHKNORPmiTljSBKN/mD58yZLGO9JxBXgmunrmEy1UL56TmZcRS4d/lLvM0CsLkjCRHQticdGliKBydWVDMwLCY2rWNn35F0rnDwbQ1ZVEnMw/lzaUcxrWz3EJK99vp6C0D4TE/95pPhMjouatuiGw2RVT7HjjOcSnnuTmT954Z/NtiHOm5W+p3iOAKZEabY96XFrSp+s5yueIwxNBaGiuZUs9I0qFDxfdSwG1WdYc+07mmlXnLR7OvoVayHWPFb27e6sqTIaci/lk1LW56woaxsv0TORG1w6tvAew+4Hw33Ac7lGmTUySmIFz25Mh1CRMGzCxSrl9DVg3cDnbPyyMAuTiFfXEDveiBw8R0x9nbZn6ilnY0VzvFGXTplgYyRL1ZUFK6QD+64rpfy2ZzX/xhjCMxOkGdoAGxAEOvKsocKk5tIMa1341wipwd2DzF7VCSJMxx82MLp7gl0VbzZljUWspyD620ikhbZh83EmVMT7qz/hcDgcswFNeVEx0bQ/kk77Imqd81ARikRHT9j9NiM1KJ6qO2bhJyhfbEeNDrgmCIUlGvyQiQmbA9EFo6JT2jqCcRHOV6skCWW1q6FutuseJwzOcuzqhQ3ZOdqLteRMniNryideF/IepMIuGimjsvo6Rpz3Ja0+SKufaLx2hl3GoBhBv9UmHc6rGBbyPWQb3lntb6YiWXLtUY6aek4U8unEJFM6lDPe0Y3PwXvdoEpZ3q68hcgBVmmx0lGpW40sTlxfY1QjvA551JqoZFZzDTmqrLitebmWpgILHeEYi3NIIccPyJucBPlZSEpxN5GfJo1WQqoSkpJLRHNzK1bh4FrZVks2TnK1GiZiqj3+aDL/rGuJCRBzPvEv86xFhBHynpiDazv3th7CUULoB8IMoRrA2oocKkJnVZPgp8hWhiBH1Rhj8iEdOsWQLlWqMBRpZEy653bLnDm9PIbkLPIAtoc1Nm53TCzHxJw5pbFCNh1Wa3M6a87nraeTIaPicVOjtmxyXEwIuUytE7ZBwbWpAdHFjZBx5NmpJuk2gjcvz95MhAImBH+GCg6bGq0AY9aUyBjXtq4baZP9PMQzqyhjI1gPQkL9rp4qyRofB5sBvY4wr7i6aKN+amZzJ94Iygptrjlfu9kk1ec/26L/GaGb9T3x7/GjJd40svQCyTzihlW2XRLGWntS8U/lZnU3O/BcsOu0KnesAJwxZmmr9NbPaVYv52NNjjZThaZUfc2SizWf0Up76YTh8bn4PZhfmoahA5s5PaGaLh7/eG7XFF1JKdGo2O5ANT88n6sJ3xnqp3Pcjs8C7weeCZ3YYAURGHJhzVZSyuFwOBzZ8JxS+yjMwUl+lPCIiQ0anFFC3ZrPRs5NcHDU+EqFc8RGdDAikCcAJmFwGqi0STnladIoeV2ryOG70uWi47ZloZGKYqadiiw0Y/Rk5YZK51Yxo2uCoQqjvNg1pfbH0v1mQ6RqCUwNCzQHkWMsP0zLwNc0f08zsB3UOPmttddKSjdyivIchNgRabYteU5YFvE1nYhVgPH3h7mH+9VRVyGYmetldJzrANUFyOPWxLhtpGqccLwRHg1ULVmqQ0uMDkcbDgpIWCg6oNaEU2rhSePmqECFQCKpNpFyTIBggYJzg7DkkLOuLF093TWJ0FkEYDiEBIPoQtUoKEoGdg3K6HBQTeA7KpgDXEcrtTnm0gQwvofrZXCiY7VFogSrFJNKewj5rEhQaIxhU0GK0je3l981CkXDWNXpjUM4QaiMjsLxCs4yxoUl/0X7ucD2dtOhs/LopjYcGw0kdyNFGjAZpy4dQmvrRBZZ0khtmeQXtE0NJRlBUoOwLBRrw7bTqFY303xNqjjEOXiNbNv057JKo9Fa2SqMAC0WJj47cwl7KyJRLJIIjfubGzfd2SHjgZ6aHsT3O2mThjZnbkQpaTHh9dS4iJEmgPH8jInbWEFka5XdE3sup8mX9LOylYISdm7kyKtQ7TzzeY3SBUOaJbamci47rlIJm4aBGNdxmqMutHPMjVRs4blWO07qEY+2oWH3BISrdOI55ISUw+Fw7GtwUmofhj3o8UAu9tYmCKchplLuYISDfAoV4WKjijJs3cEbG6kmrsxzGPhdVta8iQS36fYy6SaMQ1XSNEjB0hRiOT4rPO1D+QPqKbZaUXNN5vwx0mF/ZnAmjp1Vl4p2X2P1QpbR2mrb8xy2PKImRl6YUex8NFJUxKRu3rEJSZeR8LheuFEz86RRSFr8eSNg8hR2BjpgUPuwTHbzcy5WNTY8NlVBsd49shDcWJkUqlUGoodkg6pauNaoE0d1DPOGYFc+lCwvjYcKZzHZak4uiAjs2odqVFZJK1SZSysZqTIdLUgJY14rNaF9WCsTRaFUlVZxLp6EsMd5ixZqMrEv0QhTPHIMgYIqFmXO3D6+NzYyGhQqmhuG5dAzxhHX85ExzR8kJO7g7CbETVKEQJM8W/iy5WVjmfravGRxKFg1x5FQeWBOezNrvI2DLNVjo+Oz1JbpjQg7b6i2FsLSGxGg2D6JCUJTvViY0GTnKRAflyiOM9qUrupmr6VDvmI1Vb1+C9VDs5UvWaSvwRSCcZJqQ701Z7pIOyOKLPQLpDHCVqGSadRfzW5QpcO102rGuG/T55hJcnK6KqPWQ42KcBrtoGb7JWuDsZ4NgPBGVFkF8c+KfUgrgBBT2KNcv6pq0EQhCMUqiChd79LzLeQja00R7HA4HI7ZASel9lGYI2EP91iubOonI4BCBT7sEmJ3v+o4GpkTElFWpI0JRGG01qpL0oZ6HFo1GUOunhJlMghKBCQCVUXALCOlwv0IScVneld+MqiptBTdF1MVoO1WJSyNPPLSStibAxTn9pnsmGmm/WnFRTPkWN715x0LEoUhYdhZV/+bzlZGuFGzCdjTZdUbwZRojZxGqg1UaRSvGY3AtjY5XptVgsTk0UQnsiid3UElF0qJVxWg1h4LJYWDR6c+Qz1nykQLPe0SJPcG0YQwp9q+Spz7KBwFr/XNn1OTwy1dETQrd1gN4aBjILluqtkCoUtFIHPThOqBVGIsmh9y30SEKBM7W7n7mhDONumZO0fGx0Y5v9AWGzOmPBm3ECcjkvWH9xT3SkOr43Fn545B1VkpO7Qq7/7mqaLsXkMlhkmT5PjRroyVYJaHJ533huHkGAeF5pzOeI7EyAvtideBrLXOQiRJdKYcYjjLWBd4f+aEXDiW89FCmY3szKq0GhO2CVlVZy2y6qAxOR6HaKJf8/qolc2C9PfH6wh+sM5j7uYRIPHxvH/63bjHUHCWS6HiZlauosnYCPWS7pvKdarP4Fbzi5l9ApKlHsk7HTnUmPQ7qVg4O+0NA+7/6NCwVCpdXMdso8UKEgwPjjBFgiXHN4KdpFRnCIO29cYq8tq9R9VRKPip9mtAcjocDodjdsBX6X0QMAQZwjEyKgP9g7Jjy04ZQLJIdfBgHKOs99DQCB/s3MFFdRRNRG6GH5OGd3RIT28XQ0Dakfsoci4tNDAvPKuZh3zWznmWc9oMkhwwGTvxrHDT09WyPN0IvMkiTgieewwcEHU4JnP+qbSvGeQphHhdSizVK7ud7gOrUoSE7uYk0dhErogZvpbJIL7+RohzlKSvPV25rHp8c6ojO67ZNqdzdEzmeJtTRhrGx7dCIDa7HhjZZc6H5bJDkYR0BTru+kehZHBemXtK89DUyydkxAKS53Z2dobcJBnOOM6H85pjHNa94CDFRGocVmoJojMdXyaor/2u9GssSKGEi4UuItzESECELKE9dozBxhrD9to7mCsvzjll121h0nZ9PX09gRBpD31o4dYW2hcc5mqibJCt+DGVoVV1a0Y1FxMPE8jckVGGRcIZpXIvY9wEZe+4jIyMsXJq+junY8xPRu2VFBaJiKOa68a8h4OsxEK8NsDBTncd7k+a9I2/txHZ3Eo48nQibP4EIpNFPIZGk6q4WbCqcQlZpvcQxCyrcU7IaZVfyKJZ1AsXi9+b7LOo2WeZvW/V4UzhmHfv4jD5rOdqI4S1qY12UFYic1trWh07eeHvUx2DSPqOtb9DSXKOCyj5mZNUqzarKt9yA+J9jJ1QBToUkAHRDTsX9jDQv2uANvHgwBCvN9jDQY3rmDw+8pGPsIJfb2+vLFiwIPMYVPx77nOfy2OWLVsmb3vb22hfxLj22mvlpJNOYoW6I488kpXd07jsssvk0EMPZdW/JzzhCXLDDTfM2luHdsbrFn4uuuiimmNuu+02ecpTnsLrOeigg+Tiiy+ecJ7LL79cjjnmGB7zqEc9Sq688krZl7Ev3cNW8U//9E8T7jnunWF4eFhe97rXyeLFi6Wvr0/OPvts2bhxY8tz5UCEk1L7IMxICDvcITQkhqmgaCCrQgqkUxd2pwvhIW/GD4wXOoU93aycEhsaWeETecZJ3uvm0MQGnDlDmIBBxj9eY4SFioLB0I1fZz4RJAbOcFbgfFlVm/h7sgyRqjMWjOV6hmI9mMHDqmgZn8f7qFYI5ypLdYLPoHIMKh/mfd4MqjTpE/fnVI3D2NGOQWe8M98BT45JJRwOBmYgZ2BU1ig24l39Jg3krGNtXKQJ1Mk4M42IhhiBRDFjOoQV2r21vojnjJEEUKfUc47jftyTwFzC+KrnWE4WWY5V4hBa7qdIuWIhg+FetidqkGbOW69PGxHVE8KwxkD61zoyzZDDMZEVny8mdOwYaz8cqqH+YZI1cR6VGiWTfi+JgFEkuUZOpewqa8k4ShFVeEykFVxUmiHfEsmnQAiy//V+WOVUI8/S/R3PwUbgOo9cWphrICRyxjnvF5RkuFaoaZQo2xPIWsvi94JaLxRMSM9zEn66Lth6YMUVoHrDmhHPbSMq43B7vI/nMZPy11kHbL1K3/9krYlenwy5EaOac9LC3pRM03+DSi+fvI7X/vgYrJ0kSFkxrVbZ2kwC+0bIelbEr0Fdbht7rYKJxJX0zetXOz9U6gxFxrjWMPSs8M4kHUIUgsuqfyD+tCpteq6l7RsLQQeZnfUdRt60MqesbWkbyey2vPnfDJGFOYOKyKiUZ44diSkS7sEuNZuOba4I8/5hnoHlRYU/hmhnJbaP1rt4I8kxeUB99jd/8zfy2te+NvN9jD842Tjuuuuuk6997WsknN73vvclx9x333085ulPf7rceuut8qY3vUle9apXyU9+8pPkmG9/+9vy5je/Wd7//vfLzTffLI9+9KPlWc96lmzatGnW3r4PfvCDsn79+uTnDW94Q021xdNPP10OOeQQuemmm+QTn/gESY0vfelLyTHorxe96EVy/vnnyy233CJnnnkmf26//XbZF7Ev3sNWcdxxx9Xc81//+tfJexdccIH88Ic/JNH4i1/8QtatWydnnXVWS3PlQEWh0oS18pnPfKbpE/7jP/6j7G+YbSVczbExRzgdvldVFEEmP0oDCqQTYMmRQ2LzKJG1Suzjc6TDMNKleW3oxNW90ju/6RwyPF7JoHjHkrvJWqLdShp30viwKjkIjwpkUuxomjFjpJW1wxw+fIVVKLI22XEWcpUV9tUM0MdwXHFuOiMpQ3BocEiGB0a4szdnbqisFcOSFoNU7OzuCCE3UeLqrPPHigZrv92TPNKj2aTYM4nYgUUbjBi1pLM2VrLayPEyFqrO2X03gzgO8ZqO9qV30pGA2kqk45h4F5+k6uj4PpfHLAYrvWm4R1p10wjWH3l/2zyPw32zQnrSr8dJb9PH2HmBmRjLpogBUVwsBgIyzqGXV8EwrDejPA7rjSVGtnEOUtLCqW0sY+ziezCGEKqHjYP4muJQJnyvzWOb781e/1T7u6rQmliivtHaY2PCxhmuO66CGSuD7LvCPcC1lqjYSveJPZdmc2hSHizhPRB2RUMS9pm6Flsn03OwGcTPb7vH6TGSvn97AnGFzbwwuDgMM2sdGsHm1vAolTcgRQzxszXvmmxTKyYX08g7fxZsjRAQXUZeM8RxlPnzWDQS34P8W5F9Fts7cdttjYrnt9lDYSOyPVmf7B7bNadD8dNrkNla9dbDvDDYrBD1OBQ0y07gdZk6vlJtF9ZNfAfWB4SPlsulRAFqx+Nv6yeGA09zldz9xZ9oFXCeQSbt2LGj5vUf//jH8rznPY8O+PLly/naF77wBXn7298umzdvpmIZv//oRz+qIVvOPfdcnuuqq67i31DVPO5xj5NLL72Uf2M8QF0Eoucd73iHzDZADYT+wE8WPv/5z8u73/1u2bBhA/sAwHV8//vfl7vuuot/n3POOTIwMCBXXHFF8rknPvGJcuKJJ7IP9zXsa/ewVYBUxP0DsZoG5vXSpUvlm9/8przwhS/ka7jPxx57rPz2t7/lfW1mrhyoaMpK+Zd/+Zeav9Fpg4ODiYQTC4pJ0PZHUmq2gQ/7KHFm5gCOkuXC8DWnIsvBM4Mt3p21fBggg+KEsIlKS8v/xsYEdvRC22orL6WrlcWx/zQ2Sli0NPeGtrkSK75oWGBHM+RDoYPGxO1VY3l4aJjyeEjC2zuCbYfddiT4Te/Exvlv4p3qVsF70JOfcDbI0cOuelaYBvP9sOJP6Auo2ooQL7Zlnz822Ej0FcIYaBQaZqo65IfJauueQEI6WQhFqmx1QpxlJO7mWIl2p2tenyZniKEoI6Eqle3cMmxgeExK7WFulFJOdVABljhWZ3v+jjwwt4+GaMX3pxFigrqq2qwqI7g+6FjNum9ZhEo8zvOOAeqRMVMlLbgmdFZDMOP1oZnxNkFhE5Wyt39NaWKhehZqk3XuGiVNnTLnWcRR3KZmXs87d6N8bpUxHQemakuu1ZK8h3HGUC1tp63tsRMc/x0UNLUhSDERNp05CVvFZMcYnGUofU1lVBrVa2FY6syQ2ul1tqXPRmOW6x0VzOOBRNP+39P3ICZm8/JD2fPVxljcTiNpOL4071L6c+lzpzfokiIQnBvZxV6gqCsUg9KnEZI1ApuFOl9I+EAtyu9ENdEoxDUKK866T2YLWOhkpS2QR2jTiCovY7IqWafLhQnXn5U/NG1DWXtNwU77LaNPYjslbJzimYPxVFXGpdekOHcgSDm7fuYg7Aq2n5H8sY1hNhf/1v8cMws43Ag7MycbgDoGyqo77rhDHvOYx/CY0047reZzOMYIHShHoCZ65zvfmbyPe4zP4LOzFQjX+9CHPiQHH3yw/N3f/R2VMuajod1PfepTa/w0XPPHP/5x2b59uyxcuJDHQFkUA8eA+NjXsK/ew1bxpz/9SVatWsXwxCc96UnysY99jPcf1w6hSDzOEdqH94yUamauHKhoipSC5NIA9u9zn/uc/Nu//ZscffTRfO3uu++WV7/61fJ//s//mbmWOppGbJwgdA+Jfhsen2G0BvXSOPZyE9LKCKZEqaXOOOXhQ0i+W5FCdycdu7gtacQGlZFDVk44OLvBwarA6IMhMoZy50FR0FYsJ8Y2gLYM9g8xbwNsDwsdg0Ipqd6FEvP6PdOpsKhbVUf7BzkTYsS7z8HYh8ErSQLiOCwtPn8gCqsJU80ApJOTEWZpfc/7VSyRYLEKhei5qYZINLNrXe2KahvN8IydOl5PWyVx1mNkJf01o3gmnSKG03Sh3xG+UKYRjaAyc1DYhkL98JW9DXM6wpjKVmWw74saNjtWks7OxvlskvOOIQQsrBUslgBFIwgpU73lKIvyYCpJUxa1eq1xoufJfD5dxTNRkEbjLb27b6+DYKp0TiwKYQoTcwRjxaidxxKAx6rOrDxvja57T5HOSZ8omW6kZOLgYp6g2TpXgtJhYr6m2EmtKhMLJNzT1x0Tg80QQ1mO8VQxHcQYiOy2wGhIexvu1wyuYal1tlWYihWwkP+xaE7UUxM1ei7EJGQ9FZedC+uJbUbFGz1ptVa86ZX8dFRVP6YyRAGI9OfTJHL6eW0hrVj0MGfRtqy21yOQ06hJk6AfiRXpCbmEdbWAMLzRZL1JVHe6ScBKymiTrl+2mWN9TRtNQ/Ltu21tiwvgpNewrDZPVO+HdBFUN2aoJ+NE8xYmHdsqWch6P6xx1XtrNpAdX9NO21xoghx0TA1QAsVONmB/4716x0A9NjQ0RJIGcyrrGFMVzTZAiIEcWYsWLWIoFsgYhHN96lOfSq75sMMOy+0XkFJ5/WL9ti9hy5Yt+9w9nIwSDIpBcCC41x/4wAeYMwwKQFPEpfOuxfezmblyoKLl6nvvfe975bvf/W5CSAH4HWoqSNVe/OIXT3cbHTkA0QIHMKs0thmT8e5WXtgLduOyjAx8NCasYgcpVl2Z0VaAgQ0nPdr1bSTvN6MjnQPFnJTwXlGku0OKpXZK2S3Ey4xt9AN2PsPxwUFu7yiyPfj8EHI7jIxKV08383vMBIEwYTfVnBf0TU6ojcngR4fHGCbU3h52UhqFCqXJHIM5hPbdtssZjDgYnME5DGoFLWM/xbwdjXatDbZ7mX6t3vt5x8Z/ZylEJlNtx5I6x31rjkWpFMIa2ju6NZQvfBcIwz1Q6XvSsPFF0nZgiEq5uQv7JigrzcGEs1MujYFOoMOThWQNgbIFaT5w/wtB2WLnYv9h/UiRpc0gJptbRdoRbRXmWJkirlQIa1usFsgLSaw37uIQGCMy4hAXOtvqnIPUis/TzHVM5ZqngkAuG4Gm61Gl+kwICocq+Z2ufpYm+0DWlBBqk7NGJ46vEgHsp5zKgLhPUCWlwwWn45rr9XecYydNQlpSf4Yx2ibPHiIQp+PzpjAK/GITylwlkvLIGXvGZxEhWefiQqNrfRz+lRUqlu7XRsSYkUDp50jW59hebNiRIJvY9jgkdrKIx1dMvGBjBHmhQmXbtmTzzwh1/IRQv5BXKiZOmQagF4RR1a5IK8nSucjqXUds21VJSlDr1XsW35P0NTH9gI4lK3qRSWp2KKmmOTZZyZh586grr/mO+Hc8zxjGl5FjyxGAUCoodurhzjvvrEnifCCglX6JFU4nnHAC7SsINKCcQTJ3x/6HM844o+aeg6RCzrDvfOc70tPTs1fbtq+jZZcKrGBWhng8MNLZ5R0zB/T37p0DMtw/KH0L50rvnB4+xONk0rGhRqMFOQWqpcNYLQglwiFFisulJzvuyGdQJ3dJvGMd8oUgUWtt7ijI/a0EeKbzkNqFjD/HctMSyqMjHwBSAqSJNiMHmDCzpzuUd48cgWpoUW0S96nurCeKAEtInMqdZaQe80BoaErSr3DkNE9EcFZDm9PXlUacVDt9XGxcZ5FN3DXtDWFpjYjCZpG3s2ztmY7vqAcY6MjdgbHb1V0N/bJ+iEk9M2oZAprRP43CxbIIgj1xjdMBOgMClUEw9POOYXLxQgjZzSJbYxLSqiOVcvqu1fw106nsmCzM6Q7jJju5dx7MOY7PlSZdJziaEVmB/Hn2VWkCqxmkNyH2FPiMSW1C2HUa+ZIOgYxRE9bdXhRBEvScexjIvbGQZ7AdYzK/fywv1UygfvuCbWTPRMwp5ApLwtmjzZys9aQueaLrF5ONN3Cy7fhAXjRXGbNRW2JiNqv9BiMc4k2aLMQqnWbOVa9vmhn3aZLGSM60ei8rrcGEFARIes+Q1NoxyEqm3MCoVuu066jew6oqqRnEc4iEDItApKpSoj1lLdZBhfXEfs0q5hGqXWrOpYi8Sdtl6WedVcSLP4cE6+NjBSZnp+2jVUyzrtPuRVDG1iYij4lI2KtUmaKd42HDAAd34DUWZwi2ZbKRqbkz8Zn+nQM8fu7ieUyQ7piIt7zlLfLyl7+8btccfvjhTXXdihUrJlRYM58Q79m/aT8RfyO3Fpx5I5yzjrFzzPZ+AUGBdeD++++nYCPvmpvplz15zdOFJUuWzIp7uCcBVdRRRx0l99xzjzzzmc9kCCPSGsVqqfj6m5krBypatuCf8YxnkAX+8pe/TMkigBhKxEKmY4UdM4vw4A75kxhqF5XZNkwwfNV5osOgBjNKlMfqJBpBGWFhefkdYDhYSJgZ4/yuyNijM5zh81sFmVhejWNhTIQKfSVp65iY1yB9DiQLRntth9CA33vmdCfGkamp0sRE3o5r3nXHaiZzyGNjlwk9o2pscWJuGltJOFX4fKwuy3MwzcjNcpRjp5ftYWRN7ednIjF0ngIsnTA1CzjOqh+1qmawewCitQiFXluBxKX1QchpFEJX8TdDFzSfiyC0oUXyIt02U2LgfHEYRSuYDhKhHjEWj2Uqf8ayQ00MIH/rhcPF4WTJzwzk9tmb5J+Fy9pOPQi6uM/i0KA0YuKOIYiqhMkKP60qC6rEul0rQnQm44A32z8z1Z/pRMbNVLOMETYe8pMRxzn4spzuGEl5+RlMIp6GEY1xGGVWaJ49h+LCDnBisJZZBb4J6w3Jg3E+v9EHMdmeVujy3FT84X5oMugW5qkRMnigY1xOCMNq4jnS7Ho41XPFauBGSM9bCxXmxlsdWyePTE2vl/ZMCsR92OgLYc0aPoZqu4PDJI1YeXASBDrG85y5PRP6LhDqYe7Uu4708wvsURhDteo3EEtoe8gPWLWNzE6xcZelmsN1M6hblfZ5sPPZJlpM2PF7C+jPsPGEcc9Nz66gaG7Xa4/J/4SUgqIO1xXlpNobhP2+ACRkxs90AHl1PvKRj7DCGvILA1dffTUJp0c+8pHJMVdeeWXN53AMXgegMnrsYx8r11xzDavPid5D/P36179e9oV+QfJrjEvrA1wbEp0jz5A933DNIKwQumfH4BrjZOlxv+xLmC33cE+iv79f7r33XnnpS1/Ka8d9xvWeffbZSYqjBx98MLmfzcyVAxUtPxW/8pWvyHnnnScnn3xyTbULJOkCUeXYM8CDe+6COdI7t1c6taxyWWPts4D3kWNJYIcgrA0PbSWxzDlKqsBoSIQpBeo5SDSUKwj3CeWOY1LKQqLyDCVzerlbGdl3TDbd2yXlQTXGYazrDnOWERuMQavOFioPGjkTwtWquYqsbVm77LZz2qhKXbhGGGkihU4N9YqcpExCKRWWFJwWtCEYfc0a8ZYsl0ZxT1X5ZASE/W4OIkg9fE890icmI6fDcIvDMupfS0mGBoYTlU4ryX7D/YVj0EFia3DXoHT1dktPb3cICyBhGq6dTgWcDp4/jIWpwoiHgoYrtYqsSkStwkI2MEcwt7Pym9k9wFqN9+PcRpNBvRDMmUA6vGZPhWGYg8k1M4Ws8DyqKqBIKRQZYoLFISaa80jDdEh1TCRmEaEx2TUZ2PqcJsWmA+b8mY86nffK1uZmcgImhDFJ0z0XXxs77UCcvDmN2IFmzrGSKrtw/3OeHyDeK1okws6RpWipzhdsLlXzPrZyH0MS6pKUO8uTJt2n8uwA6t1nbkShvyrlCZs6dh4A1w1nMKlwqcRN7TMZpF7t50kodrb+PExIaE3qj2cQyZ1yyD0IYiXL9ohtrXp9beMp2fSJ1OXcJGsinpxVfxEGh9xmHW0JyVlVY+lmI8m1jsw+jcmktIKM2QVV6VTPfoxD72OlaawoZLVAhOriHhWwcdKVe41si4YQ4rN983qlXKnax46pAU71tm3b+C/GkFUeO/LII6Wvr09OP/10OtRwzC+++GLmxnnPe94jr3vd65Iwtte85jWsyHbhhRfKK1/5SvnZz37GkCdU5DMgHM58zMc//vHy6U9/mpXpXvGKV8y6W4iE1ddff708/elPl7lz5/JvJDl/yUtekhBOSHyOnEPnn38+q6sh79All1xSU0DsjW98o5x66qnyyU9+Up773OfKt771LbnxxhvlS1/6kuyL2Jfu4WTw1re+Vf7qr/6KIXuooPf+97+fa9aLXvQiVtbEvUYfIM8YiCZUHQQRhSTnQDNz5YBFZZK4++67Kz/4wQ/4g9/3Z+zcuZPPWfw7W1EulysjIyOVocHhytjYOP9OY3R0tNK/q78ysHugMjoyWhkewrFjlVKpxB/8jtftdxw32D+Yea7qd+p5Rsf4N37Gx8f5Y8D58Hf6PPh7eGiE34M2p2Ft2Ll9V2Xbpu1sO86V1Y7BweHK4MBQZWhwqLJ7Zz9/t7aMDI3wurLalv4+9J8dm9d2/I1jstoctyn9GWt7/B7+Rd9Z/7Edo9X7kD4nrm/Hlh2V/l0D4T7lHIvXce92bttZ6d/Zn3vNdiz6CP9OF2xM1QPatGvH7srunbsbHpsH9MlA/0Blx9YdlcGB6ljFueM+tWPzxvJkvhfzqd4YqAe0D+3dvWug5t7gvOiLZtrJcd8/WNm9Y3dlZHikqe9s9T5PZ59Nup9HRnl9jcZIM2OuWaCPhgaGmuqruF/x/cODw1wTG/UbjsV1xetNozbh+Ly5bGMn77vsB9/X7He2glbGbqtIr+P1gHUcz4BdO3ZVhoby+6ve2MFneP/Hxqd1XBnsWWTn5X0ZHa3b1qy5mF7/4+fJVNqG5zqeMXjeTPe1T3VOhOfgcGXn1p18fqTXBhvj1gc4dvum7XzOpM9pz9C4v9LP41bbHz+D0I/oQ7ueeB7GdkXeMzjLbkqv4zgXnwM7+4P9V6fto6NjtAm2bd7OvhvNuG6cD+fB/ceYTPppLDxTMb/qjVPr06y2x9eA+4E2ow02boNdFdpgcwSvwZ4L7RnLH7PDI1x39+R43V/9iSycd955oZpJ6ufnP/95csz9999fOeOMMyo9PT2VJUuWVN7ylrfwfsbA8SeeeGKls7Ozcvjhh1f+/d//fcJ3ffazn60cfPDBPObxj3985X/+538qsxE33XRT5QlPeEJl/vz5le7u7sqxxx5b+ehHP1oZHh6uOe73v/995ZRTTql0dXVVVq9eXbnooosmnOs73/lO5aijjuI1H3fccZUf/ehHlX0Z+8o9nAzOOeecysqVK3ltuJ/4+5577kneHxoaqvzDP/xDZeHChZXe3t7KX//1X1fWr19fc45m5sqBiAL+t7eJsdkOVIYA+7lz506ynrMRI8MjMtg/yHC+7jnd0t3TNWHHDTuG2EHGTrwlMradc/xYzgGGm42Pc8e/qFLzejtNNoSyFA12fiatzKiolQ4/yDo32j3UP0Q1TW9fT82xtrOa5CBAkk2E/LW3hWpYUQhhox32OOzMVEd5ScdbkYNjV3J0eISqi27kvUqFDZpywRQS9p1ZiVdDSGO4V5DJxmGB6WMZwkHZfQiPC4lCR4MSLUomPB2qncmCoZtTVGjxPmlp6cmcx+57nI8NyKqyFn8mnSS21e/EuBgfGWOYEcYFkHc/88B7h7nVRN4YmydpJeBMhTY0ChOrhsjVb3ujxPWmokGVRJtHU1ESJT9NtM0+E6vPbO4hX18z1cfY/xrq1SixcN6Yy1LNxO/F65hhNif/TY9Ju75GKtY4/AjPRClVOL+gsKj3Xel1HiFDY1CkdmBNDDnGWg1HbGbsptcYm6PNjDtrO+/5NK/bsdq1mXYwD+TIWBLOPNn1JOs+h/U9hC+iMiPC1BhiCLUy1NGp8Z7OB8Xn3vAo18i06qve83cq60jSDrQxNXaybKKs+z48PCIjg8PS0dVJBXBNmFp0b/gsGRwOdpR+Pvk3bQOOjjFROtqEtAY1fRxdN++Dtt3U7kyrgPWKyrJqaoK8+4jqhBY+mr4/I8NjMrh7gNcAtT/sVVOyY+4CVN+r+g/nwns4V1bYI8/JBPCVcEykiJtt2Bf8CYfD4dgbmNQT9+GHH5bPfe5zrFAAiVr80wo+//nPM3M9Fmb8QN724x//OHl/eHiYcrbFixdTHor4zHTyNEhJIXfs7e1lbObb3va2CYnYr732Wua/giwOUlOUctyfYAY8Q6A623OrjSCEp2dOT2I05oWUAHDwER7GfBQNDMzYWEpznDScKFvPJh6akauDfOmdO4dGVPpYhv+hXDJInI426erqJIlmhFRa5t7oOoyYs78tafqEcIqWwiGUIGJCz3T+hWDcxc6rSeMZ0qHhPfGxIDCsghoTnEZ5reJjYbzB2INDZoYdyDGWvY+qRFn+l2Ydm6z7PFm0kvC1Xnumcp44XKEmPASV66Lk1TFwP0Nlu8klU2Y4LeYqw14nhsQ1ey3MndOk85SMtZSDYKT0dMNy18VjLYY5OZZ3ZcLntW2N1gicH84bCPf0uAyEVchbV2/Mwum1SoUWxhyqXQUSOO8a4nATu29cLyzEM+dzTIiMilM21zW/TT3YuQPpVXtNVVKjSk5lfbaa66iY2S9x+NTeQkK+R2PS1uZm1yjMCRDveB7GifvzEPcPgNA3fLa9A47x5Ehzu44kL1sT79s6lDcn0uDzL3W/bXxMZY2OQ6iagYXQIwRxqt+bvs9GmIyCxNd0AbBl8JzH8z49JpLnmT5TYcuA1MkKQzTiKg61tL8nkxw+fS1m98TjJ1knonGVRfIE+0WTe6fOy3QNah/gd9hqZvcw0bduSKXbhOvqndvDzb10xWNuSkX9wDBRrUBq6yELtzRRjCK0PayjWesayMXu3i5WHcb8qjdmaANiQ6+3KzcPF+2d7g7pAAHWQhoAh8PhcMwetJxwAcm7nv/857PywF133SXHH388qwzgoWKJz5vFmjVr5KKLLpJHPOIR/PzXvvY1ecELXiC33HKLHHfccYzNRazx5Zdfzp0FJEk766yz5De/+Q0/jwcyCClkq7/uuutYGfBlL3sZDZaPfvSjPOa+++7jMYhl/sY3vsH2v+pVr5KVK1cyD9a+CjNGzDggEaW7Y+md+xiWg8h+twSZ6WoxQCu7r3FOo8zEqDmnajafkSWsTe8845pthzCdcDxJclnITrLeDFrJc5QH7hTqjmjWPalRWMRl4tH+VNvTn2+WwGCS4K6OXEVGs07XTOakmQxitclkd7Z5DQVhwv5mVUP8CPt+kg1X4tfyPIXqlcExmS7lUrPqkplQStkaU8/ZCPr//PebKStvoIOnzmg8n8zpt77NS8wP4tjWEVsjmRx/ZIw5kjq72jPVNllKT5u/WYUiTNU3OjzGsWN54ez4RrBcRCDRgsNdTcRuY8dyucTtSY+rmLC3JNg2t8PJpk9JleTxa0H9Y23NG5vNjO1GidPzckFZe9M5+1pF4tw3SPYcw2JiWvm6LEUZC4tobsg9AVZa62m8yTQZ2Dgv9AVlT7MEfL2/Y2Rt6LSKrHxvcWGINJoptAHCLeRQy678SmUV9pXbJha3ifMzAWllVRbSJBXWBV5bap41u8EHu4c1MlI2lN1D2J1JYR2rRKokPdCKMp02cDTX07n6HA6HwzH70XL4HpKWnXHGGUzchsRuv//976lQevGLXyzPfvazWYVvKkBisE984hPywhe+kNUPvvnNb/J3ACTYsccey2RySBgGVdXznvc8Jhpbvnw5j/nCF77AZHKbN2+mmgS/g9hCcjnDueeey3KNV1111T4pt8WDHGoXI6Pih7VJxuHsGdEUP9zT0nZDXjgIMJPkg6kSskL7DOkkmM2GN7UagtAs8sKgsoyhOAlyMwl67d4kZNs0JR+fLsT3YjLhLNN9T2JSaioJoDGf0iGm9cL37Lun497YHDDiZLoQh4/khTOkQ8KMmJiOUM5Gobn1Qk+T39XRa9TPWU5IXA3L+rZeGFW6rSSlRsdYNSsOeW409tLVquK2W0VRhksjjHYSxEdQc9n11o6Z+Dqa6TOOeS1QERNadj2Nws8aIQ5VQqZihDSmySkLv0Rzm517eaFRU0U6nGs6VJxA3nni68wKI5zM+ZsNi81qS9bYaWVMHQjIso3w/ED4YntXR00y9ZlsQ73naLyeJJsealdM5fk9XWjFvqw3L7LWCbve9LlnS7jybPMnHA6HY7ag5VX6zjvvpBrJdseGhoYYWvfBD35QPv7xj0+6ITCkUHEAGfoRxnfTTTcxl9Bpp52WHHPMMcfIwQcfTFIKwL+PetSjEkIKgPoJi/4dd9yRHBOfw46xc2RhZGSE54h/ZhNslyxUR6lkqj5CZbMh5lKIQ8DsGAtTQeWyrBAbM3qmM1QrC6YQaGSUxEZWbITUC1NoNQShWSC0wlQcta+XJ4RTJI5ek+EYhYiQqveZEI43yjmyJ5EOd7C25N0DVsIaHU36g33EMI/ssLhWYY7/VPN/WIhpfI5GTth0GfQkgECGTXPYAZ0QvVexcW8GflbYEu/XyKgqhKY27xsRj1n3LVY3tUIMsAJXhuIBnwfxkxfSHB9rCgNzdPDZ3jk9SVgMYOvmVPoGSkWGHikh1epYwnUiNA3hn+kxE5QVzW0iWJiTjYs0eWeOY1Y4YLNIwqE62pKQxqwQSwtftPcazT1ep86Z6XSss9a3qaCRUiq+TguhQrhhs9+ddX67r62sh2Hej3FtTt9rhoKlXmfOyZGJ4bKG9DNhNoSFNkIrYY+xfWTPbSodZ9heata2MRvP+jxrndkT7WylDxuN8Syy1ELE08rQeD1HblQ802b7+HM4HI4DHS17cXPmzKGTCSAE7t57703e27JlS8sN+MMf/kBSC/meEGL3X//1XyyViBKJUDotWLCg5ngQUHgPwL8xIWXv23v1jgHRBEItCx/72Me4k2E/Bx10kMwmJIZ+huEc5yYAecKwFJAoqR3gJLkmXofjkYr7j3MdzdQOU+KANNjRTUo+q9Fu14eEmEjwOR0OdCvthToBDpHJzNPGUGw8mfOUPjYNM7AsjKiaW6RcVy2HMKA06TjTiOX25tBm5a+wZN4DuwZpFJqjQkM059yTcfqbDWGsB3PkJnOeZgzrep9rhUiYTNhLfK9szue318bw1Ps0hn1vun15+dqm4542CqFJw+Zdmgyu6b9oXuYRoll54gx2vIUjT8e1TRXxfUj3Vfq1rPvYjJrD1nCuhRmhw/XyDu7JDQcgPu9knyuTXRO4Du3hsGi0FfnY8APmMP3dCGuOrwe/I1n20O7BzE2RdK6smAyfzcRAFvnWyP5Kws7aQjjabAhpB0JRkxH+AFyjkLsO4XKaO2pvKofqbSYF5WTId2fgs7lY3TRInyv9d1y0Z2+Tbw6Hw+FoDi3HiiBs7te//jXD6J7znOfIW97yFhJL3/ve9/heqzj66KPl1ltvpZT1u9/9rpx33nnyi1/8QvYm3vnOd9YkbQeBNZuIqSQsJseRxYPYdtLN4bBklUBCNkHKzZCxcrLDF59vKkZLcF5CVbB6oQtJhRf9rrxjw64XwkCqVXJA4MCK3hN5jkDc4fvMmKsX2hQ7V0nuB1U/5eXPilUliUNUyA99Msc3nSemWec7DtmaChop6XB2hOzgt5odz5wKW63kEZpse5vJYdYs4pDLVkLvJvu5ySImUYC8cYX5Kl31VUVTCdVolKuI90VzHO1psF0d9dcgkstRDpd6x+a9Phuc1iwnLut1Gy/4Pd7YaOYepasB1lN1tDIHpitsthEmW5U0Dpearrkd55CcifUcSzjshSySgOt3StEVXsJx+aHNMaZyvxqFQE4XaIdIc88Fs6UqxUjB3YTie6ZTIth3gEgMf1fnC98b01QCHW1NhVzXC92M1W+TeZ7mrQdJvrgsdZT2e7L5p3mvctdbrR44E5s+DofD4ZhetGwxfepTn5L+/n7+jrxS+P3b3/42k5XjvVYBNRQq4gGPfexj5Xe/+51ccsklcs4551CRhdxPsVoK1feQ2BzAvzfccEPN+aw6X3xMumIf/kYsd09PT2aboNrCz2yGSZNhdWQpjWI1C/+25JH6b7wDXpBADOU9tGPjo1nj3BQFcZ6QrGsggaM7YJbLxELX4uuKDXJrJ/Np6WdhtPOaKzOU9yIjgXBerikg3mm3ZOulsoaotNWWZrdrmlCuvThRbh/nULCqeolUv0kHKslzNQ1OU3yOLKKN1R67uwLZkXL8s463+z9Tu7hGhGbdg8lithu7eXlycnM+VQKhgD6aLmLQnKJm+mpPEQ5pJ9/UN6YGyhqDM0WU5pEK002itoq0aqqVeclnSqUw6bxjWf1iZG4zOQWnikbrfT1Mt8owKYCRQQZOdT3ns6QnhKdm3QfaDKnnL0JPpQfzpdjUMyEmN1tBvfxszcLuoY2ndGU/a1e9gizp8yXjVu2NeIOtHmGb/tx0I853iUTj/E5U5Cxr2zIKKsQ5yEwFas8Js8uyrikm2ZrdSLD21VPHZ9l6NfZPNObqbniibTOQeN/hcDgcM4OWLRhU3YtD+ZBYfDrB8t4jIySoUE0D1fLOPvtsvnf33XfLgw8+yJxTAP79yEc+Ips2bWKydeDqq68m4YQQQDvmyiuvrPkOHGPn2BdhdjKex2aAhNfznb40SZVHhpjCKa7QlrdzVe/78nYdY1LF2sTzl6vhXww3BLnDY7Lbaa/hv2KhyMTurSZ2bQWmLKtneMUkmyEmYdhflfpVtuIQB8tvYt9JckFLYqfDg5pxoMwgRF+x77QdthvaqtNZc4054H1LJdQ3xz9r/OwJAzKv0llM+jXbjsmGENnO7Z4iGtLfleyoqwOSDvGjk1tuvtpSo++erFM6E6jn5Fu/2BxrdG/zEoHXI1saKYomvJdDZO9ptHofmykdX+/a65EtDLGc4cJaXPMnQR7wnre3PtYtXCmrz+op85pZR+olP08ImQYh6/YdFl7d1p7fN1nf0QzySIsQ0gVytrVnVDyf03n04vdaCWdLFJNxFWCcry0ofOupJBspVacKtqM9rDt2jUmS8LaghJtgk1nIcirvVLxxCWQp6Vu9HtusjD+TRbxnVS5N7M86549VYWG8F6QtZ9PM4XA4HLMLk7JyoV5CqB3ySb3tbW9jxbybb76ZuZpWr17dUpgcKvkhefnu3btZae/aa6+Vn/zkJ8zldP755zOMDucH0fSGN7yBZJKFCZ5++ukkn1760pfKxRdfzPxR73nPe+R1r3tdonRCnqpLL71ULrzwQnnlK18pP/vZz+Q73/kOK/LtiwgPW4TbCXeMzEirGorB2Z1shTMzGkpqiBoRQ2MgMrgaKXOydh1jZzB2MsxYgwMQcmGVpdgeSiE3ghmH5Sh31kwYfFlOvb2etEWNQLajUDWy4v6p5+BXcy7BsMoOgbCQS15n5DDxvpfr32+7t5bXJSG7TNWGsdQ586RQHN6yp3Nw1HOUm93tTiNrB7mZcJo9tYNbL8why/mdCfKjmb6cDCk42bY0IlLtp5GKKY/AyiL86pFZeWPF1Eb1iOypopkwnKzNimYw1bkdk+d7OryzWdI4i5hs+bkbV5hNXZ/dk3oEUKM+icOiJ9OuOFx8qiqy+t+nG1LxRlq7vo7+abDxlBUSHj+rs57jzVxHXKkyi8RrNsRwKutaM99hdhCU2XZsI+KICikJhF+hUEt+2rMgti/j87S6YREr9o2AZKgh2qzEex4Rnxdena7WynbhmvVYV0o5HA7HvoGWvY/bbruN1exAGt1///3y6le/mqQRckpBxfT1r3+96XNB4YRKfuvXr+f5TjjhBBJSz3zmM/n+v/zLv/CBAqUU1FOomve5z32u5oF4xRVXyGtf+1qSVVBuIScVKgEaDjvsMBJQF1xwAcMC16xZI1/+8pd5rn0RZmSkd+EtOSSNMpAjpkjKMVbzdvKrld8ioiJnpzoxflqwS0Ibw+8xIWHGYkJ2Ndhhjx1YtM0URnsiqWW9kAJTeU3GiTTSyYjAtAFNI72zKG2qYEnffyOXbJd5AuGQCt2MX7eQJfT/TIfFWBvif/ck6u1km9JtKu2azvDI6UIWGZWnekG7ERqbtcbY/JoJQ3+ypGCrsDXD7lN6HYr7pVHur0bKySzYOW19TueGi4/bE6Xb0RYUIuB97+rIdLgThcMk1ah55F68GdEMgbwn1YXTnS+tHhqpThpdc6P3pxIWne5/WyNnYg0AMSIkPlJqYylLJUfhCoRnV8iNGW+UGalVPU/tdTWj9ElyHdYJu4s3dmYCzaq6YrIwDuWrmwMTG4HYiBwvZSuptG/LZYTDTW3tjxX7ZuuVK5qfq6RKs4iIj+3ULDLQNrjijTw7Bv/uCXvQ4XA4HNODQqXFVRuE1EknnURl0ty5c+X3v/89Q/quu+46+bu/+zsSVfsbkOgcpBmSsUOxNVtgD3UzrGA4VCLDKK1IimEkTl5ujnoJLieb68TKTpdLJWlvb6cDlDZwUGqajqJWQ6t3LnNgk8TnTahTWgmraWZXOzbirM/iHdU9hRrjLKry1SysP6264Uyj2Z3lvaWsSe+Mt2LkpxWBWeeaKqZjHLf6faj2iDEWVzaa7LmyEv4mYcIzlOQ+DVwP70tHfn6ihGDMUYTmjeN64ztPMZr+fBJ2M4W+bgTrc1QyhTI1/V1JVVAda5MJkY6rseF+MxfgHlob88IrW3nW1VONkbhshizIGdszsTbE5wamMpf29DrTqC15tgir+6F/9Zk8mWdYvTlbL7Qy/WxoxSaaTF7ARuPM+slIfnRKvRxstrZjTHembLKkb8fGeR7YbdNFksfPb1PCmf1h19DITrV5lRRgwOe1fyZbqOBA9SccDodjb6PlJzcSkX/xi1+c8DrC9hA+59hzSNRKujtEA7kQCCeE94H0mSwaGfFAqw96OmHtbVJWwzwz7Ik7Xo3DVbJyODRjKNXLYTKZnCH2nXu6mlraSLbvNfl+qzu2Jo3fU85HK0ZtnuOWVtZkjcssp6oRIZZXBdBeR660eurAOJwm71xTdajjcWxho3tCRWLXNG3hYpHyoB5JM9nvsfNmgarQOhUumwmNavR6Xt60ZpRgabVk1vXkOerNInFyc8imZE3G2J0icZKEfu2h6nmNVExGRiU5dTqae6bFqjHL7ddMWBVJi0qVtGhGgRO3s1HbYiefjr6eO03a0z5oogKcERJZqt29gXpzzWyLPNKvEZmaR5QbGvV9ov4Zn5kNiCSkscF1xPeJCqg2fLaqzMxT4fEH2SZzUga0q6uQfv42Oy6yjo2VT4VCUDpl2XKNzh9UXGVp72yXjriQxwyFmDocDodjZtCyB4BcTWD60/jjH/8oS5cuna52OSaRfNse8mMjY4EgUeIla8c0L2SkkTNcL49KIzTjjJnh0ui80+3Atop0+/ak8RM7M3F/Js5Osfmd7ZjMaKT+adYAnU4FUz1SJw4lyUvGn87tEztaeY6DvZcms/JyWmQhnpNp8qOZCkTxzrjd4/hz8XcYOTedKrf02mDzzUiwqThccX6aRuOjkbPY6HO2TiX9B4dR18xG1bamqhLJy8MCWHuAPEcxvpc4D0LssMx0dXcmKoJGCp0spB31evM6HvOTved2v+3+7UnVTUzoMY+dXnM8PpKQoQYKmCQkLKOSbSNYP2atDfXOUdPOBn0Xr4HW1+n7ZmO6EREWHzuZSpb10OyzpBXy0jZk0iRus7m04mudCmk6U4TrZDYdjKhTWrbuZ+uNQ4z7OBTO1q4stXgWGm3YpUP0YmTZqTYn7Rk9PjbGTdhisfb5MNlCBQ6Hw+HYO2jZg3n+85/PnE1IFg5gwUcuqbe//e1JlTzHnkGWkYK/mRcE4VtQJcUJVDNKoDfjDMeIDZNWH/aNDDYzpvPaNh2ol8MkbmcrbbCqePi3t6932tpqbbFd9dgIJNGhqrK4HUmumihJcx7ZhHAH5A5r5NTGicmbIT0sUel0VEPMInXy8lPY8XnjOnY8LP9a3rXnEQWTUdelyY+sCkRZ32XvJeRT9LnYWKdTWCffSrPAeCDrgdwcuts/gZSbJrRyrrQT3WzocOyAm3KEBAPCWZpQnTRKVt5K26dK7oc5GMZ4NeQlFLxohRBvxVGfyphPY2+Ef8XPE1uTrC0xYVPvmZPk6YvUkfG601JbMvqRYUZom5SnHGYHwpXn1HU3dw1TZ77R8y1e7/OOrVfJcjIEhREOtgY12nyytSBWWceEXLO5tOrlnsr73vS12jVNhcDNQnqMtkJ8Nbt510ylzLwNnGbaUO+4rGT6MQmX/mycvwvt7urp4mMrXRhnuu+Dw+FwOGYZKfXJT35SXvjCF8qyZctkaGhITj31VIbtIdH4Rz7ykZlppaMlIO7f7mxskLViyGQ90LPUB82imTwqzbQxHcrVTM6QuP3NHNtqiB8dRhpV1aqHzVyLfTavTXGfoeVjI6OJ0VZP5WFGXVwK20iOmjZFTvt0Itl1naakr40ULenE81kkJADikDk/kmT+e0fen1ZaZCF2ruLPpcNVbSw0o16qp1AI/REVCmiR7JgpZDmWCcGg4aZZSipeJ8YfEubaa7j30trOeatrTLMEeL31FUivkTgH8r0YLNcKilpMcNrq5EhqxVGfjWhVsVmjSOIaWP1cU866hoTNZE4vXlMU1hcjvcGQB5I5mrOqKQKmSTSjWG7FvmhMUChpKvnKoNgGMJUojs9qb/pvK7Riasl6x+aNtSxbphkl21QQq3yBRhtJaZVnMyGbrayLpnpv5nNNhyvr3IwLUGQSuSlVF+1dh8PhcOzzaHk1R4K+q6++Wn7zm98wyXl/fz8TnyMBumPPoyGpUQo7UM3uwjZrQIRqJ83v2MXkyGSR3uVHW805Q/LcRtfYTELaycB26+zSTGnWyOlpRpXGXCfFSL5fpzJcnOsqrbChzZ7KmdKsvD3eAW4GjZQESZhJEzmW6jnqMfIcmNipM1LH8pkF1czM7aTmOTXNKi0aOU1xoYNG50MBgaBeCwrKrO9Kk2R7mrTIWx8mhL5pdaZ6+anCm6joVJaShrE0IjezyBtzkNB3rSqmGjng6dCUOOw1K3wSa1xyXEHntBKrNaE1pqjLyZE0nSrRPQlbL4FGydLTYZ9hzrX+ndOlFJuKOjge7/XO02zl0EYERUxoNErEnkWeT8W+IGmoFWjt/FlKKlNOtpJbMrYfLEn9ZBRdsS0TbwDNZEJtI6SS52adhSyt8ozbOZlwtjxlarPEcCMiudlNlTRBV8+mbGUMOxwOh2MfJKXGxsakp6dHbr31VvmLv/gL/jj2HuqFgMAQQKW70nioltXKQ7/eThrORSJIjZ6iGsONnDUjAqZiFKRDuYKxBbIJBlOo2NcIzSiDshQOaSdngsOohquFhU1VlZaVw6gZ8iF+34zppPSyGuR5+UaaPe9UkZX0Nw/1HPVWdm3TJOFkQnBaQashj1MpdBAqgdVvC8YufjrrHLg3KxS1QrClnZi8su6mjIrVMa3AlA/I0WZ/TzdqlHDYPIjmZr3P0NlE21QVVZMnbRKKsKkqYfcUMNZxzXnkqmEmFKAzgWZIr2ac9mbXs9iZzyMojNBAH3N8NSjS0Oo4mex12BrBanKRPdHs+hrbD1MZ2/F3kwTWPsJ566mXJ5Mbb8I1cI1onOw8/W+zIZtZSNRobWFdaBa4X1Z0p9G6HrfL+jfv+Lycmo3GcJx/1eFwOByzDy15ZR0dHXLwwQcn+Vscex/28E4/bIOxG3buptP5Tu/IxnluGqEVYiwPuJ7YYWrvQInxagWkup9Fni0k3G3gBGQZREaOWGhMo/Y10544AXBeO+z+mdptMv1nbYrzb+xN8Fo6apP058EM6kbHTpXwnAnMdHsY3tABBVBzqivrx9leSbQZpJ2YrDlt434q6585vXuKpGl2vWa7dD0z5cB0XHdMWsw22HoJR5O7EQ2O5fzYT9QR03UNtg400y94mxtO06wsnixsfZiOZ2GjzzZ6jse2TPw8y217k/ZDo/sGW6eZcDWzdey+TaXP+P0t5iysEketfxZoRGDFRRrqHqfh+k5IORwi//AP/yDPfOYzvSsy8IUvfIH8xsjIiPfPXkTLlsa73/1uede73iXbtm2bmRY5psXANGequ7e7YahDq4BxE8LlwsN+bzq61bY0JoHq7b41QuzkNKNWalUptSfHyt52MIxsa/aeNXvsbEIjwnE6YH3TaPxYWzBP9va9zwNDX+DYzdL2zVbYmhZXt5vKudLO7GwDnjnNbkLMtBpyX0UjgiLevCE5M0uIvT09Npt9jsebR/XONdXnbyvjeTrtioSga+EZbMQR5mqz9tlk2pR3jbaRYGN9tio/HY5mgDQ573//++XZz362LFq0iGP5q1/9akudd99998mXv/xl+u97EjfccAPJsMc+9rEUttSbh5///Oflb/7mb0gO4biXv/zlmcddc8018spXvlKOOuoo6e3tlcMPP1xe9apXyfr16+u2ZceOHcyHjXN/97vfrXkP3zU6Oipf/OIXJ3mljulAy3Ell156qdxzzz2yatUqOeSQQ2TOnDk17998883T0jBHc2i0UzSTmC1G/54yNvY1YmR/a/++htlkBM+Gebovt2+2Y7r6b7bfh9moiNzfMFv7eLa260B4/k5WlbY3sS+PFYcjxpYtW1j1HmTNox/9aLn22mtb7qBLLrlEDjvsMHn605++Rzv3yiuvJBl2wgknkDz64x//mHvsxz/+cdm9e7c8/vGPr0swvf3tb6cwBgTWIx7xCPnzn/9MbuKKK65geqEVK1Zkfu5973ufDA4OZr7X3d0t5513nnzqU5+SN7zhDb5+7Cuk1JlnnjkzLXE4HA6Hw+FwOBwOh8MhK1euJEkDsuXGG2+Uxz3ucdJqPuhvfOMb8prXvGaP9+ZrX/takkjIR/3617++Lin1i1/8IlFJ9fX15R4H4uiUU06p2USDiuzUU08lOfXhD394wmduv/12KrFATOEnC3/7t38rF198sfz85z+Xv/zLv2z5Wh17gZSChNDhcDgcDofD4XA4HA7HzKCrqytX/dMMfv3rX1Ntddppp9W8DsUVlFPf/va35U9/+hNJGxyHImYIYzvyyCOn3Pbly5c3fSyir5rBU5/61MzXENp45513Zn7mjW98o/z1X/+1POUpT8k9L0IMcY4f/OAHTkrtJcxMWSiHw+FwOBwOh8PhcDgcewXXXXcd1UePecxjMt+/6KKLqDp661vfKjt37qRa6MUvfrFcf/31yTEIe8sLfUuH7S5cuFD2Rt4t/CxZsmTCe5dffjn7AITV/fffX/c8J510kvzmN7+ZwZY66sFJKYfD4XA4HA6Hw+FwOPYj3HXXXVQAzZs3L/P94eFh5mLq7Ozk3yCVoCxCyNvxxx/P10BUfeADH2hK7dSI+JkJfPrTn2ai8nPOOafm9aGhIZJtF1xwgRx66KEN24a8V//xH/8xw6115MFJKYfD4XA4HA6Hw+FwOPYjbN26ta566RWveEVCSAEW4oYE4kZKvexlL2Mep0ZA7qg9jV/+8pckzJATKp0LCiow5NRqtuog+glEFlRhqOzn2LNwUsrhcDgcDofD4XA4HI79DJVKJfc9JBePYQTW9u3baxRE+JmNKjDkigJ5hip/MaCK+sQnPiGXXXZZ3cTpWf3k1Tv3DpyUcjgcDofD4XA4HA6HYz/C4sWLawimrDxQjYgsy9nUCDjX0qVLZU/goYcektNPP13mz58vV155pcydO7fmfVTZW716tTztaU9LwvY2bNjAfzdv3szXQMjFVfzQT1BI7Q3Fl6NJUurNb35z032FUo0Oh8PhcDgcDofD4XA49g6OOeYY+cY3vsEk5iBwJoN//ud/nlU5pRCSCEJqZGRErrnmGlm5cuWEYx588EG55557MhVe//AP/5CQUAsWLEhev+++++TYY4+d4dY7pkRK3XLLLTV/33zzzTI+Pi5HH300//7jH/9IdhTlFB0Oh8PhcDgcDofD4XDsPTzpSU+i6ummm26akHOpWcymnFIDAwPynOc8R9auXSs///nP5RGPeETmcR/+8Idly5YtNa8heft73/teufDCC9kvc+bMmcBvoPKgYxaTUrjpsRIKErmvfe1rNXGnSJRmydEcDofD4XA4HA6Hw+FwTB6XXnqp7NixQ9atW8e/f/jDH8rDDz/M39/whjfUVUCBTEII309/+tNJk1KTzSn1wAMPJNXsbrzxxoQsMlXVS1/60uRYXNPvf/97/o7k5Lfddlty7POf/3w54YQT+DtIoxtuuEFe+cpXyp133skfA3JHnXnmmcl1p2GqqMc97nHJcQaQdtu2bZMXvOAFLV+nYy/llPrkJz8p//3f/12TyR+/Y+BASveWt7xlmprmcDgcDofD4XA4HA7HgQmEz4HgMXzve9/jD/CSl7ykLimFynogci6//HL56Ec/KnsSCIeDMimG/X3qqafWkFL/9//+Xwpe4igti9Ras2ZNQkrdeuut/PcrX/kKf2KA6EqTTc0C/YMcU5Ml7hxTR6FSLyV/BqCSApuJxGFpNRWYzN27d8v+hl27dnHCIx533rx5e7s5DofD4XA4HA6HYx+C+xOOvYE///nPzC314x//WJ7xjGf4TUgBuakOPfRQecc73iFvfOMbvX/2Eqop55sESi8iVA8MLaSD+AG7ef7558tZZ501M610OBwOh8PhcDgcDofD0TQQegc//aKLLvJey8C///u/S0dHh7zmNa/x/tmXlFKDg4Py1re+lZI5xHwC7e3tHOyf+MQnJiQN2x/gOxsOh8PhcDgcDofD/QmHw+HYy6RUnP3+3nvv5e9HHHHEfklGGZyUcjgcDofD4XA4HO5POBwOx14O3zOsX7+ePyjFCEJqktyWw+FwOBwOh8PhcDgcDofjAETLpNTWrVuZJO2oo46S5zznOSSmAITveeU9h8PhcDgcDofD4XA4HA7HjJBSF1xwAZOBPfjgg9Lb25u8fs4558hVV13V6ukcDofD4XA4HA6Hw+FwOBwHINpb/cB///d/y09+8hNZs2ZNzesI43vggQems20Oh8PhcDgcDofD4ZjFKJfLsm7dOpk7d64UCoW93RyHwzFLgBRPu3fvllWrVkmxWJw+UgoJzmOFlGHbtm3S1dXVeksdDofD4XA4HA6Hw7FPAoTUQQcdtLeb4XA4ZikeeuihCaKmKZFST3nKU+TrX/+6fOhDH+LfYMPBjl988cXy9Kc/fWqtdTgcDofD4XA4HA7HPgMopMzxnDdv3t5ujsPhmCXYtWsXCWtbI6aNlAL5hETnN954o4yOjsqFF14od9xxB5VSv/nNb6bSZofD4XA4HA6Hw+Fw7EOwkD0QUk5KORyONBqF9bac6Pz444+XP/7xj3LKKafIC17wAobznXXWWXLLLbfIEUcc0erpHA6Hw+FwOBwOh8PhcDgcByBaVkqh6h4kWO9+97sz3zv44IOnq20Oh8PhcDgcDofD4XA4HI79FC0rpQ477DDZvHnzhNe3bt3K9yaLiy66iLKuN73pTclrw8PD8rrXvU4WL14sfX19cvbZZ8vGjRsnEGHPfe5zmXx92bJl8ra3vU3Gx8drjrn22mvlpJNOYiL2I488Ur761a9Oup0Oh8PhcDgcDofDMRO47LLL5NBDD5Xu7m55whOeIDfccEPd4y+//HI55phjePyjHvUoufLKK2veh3+V9fOJT3wiOQbfl34fvpnD0QiV8fulUlrnHeXYs6QUyvplxQT29/dzMZwMfve738kXv/hFOeGEE2pev+CCC+SHP/whF9tf/OIXrOyAUEFDqVQiIYXcVtddd5187WtfI+H0vve9Lznmvvvu4zFIwn7rrbeS9HrVq14lP/nJTybVVofD4XA4HA6Hw+GYbnz729+WN7/5zfL+979fbr75Znn0ox8tz3rWs2TTpk2Zx8P/edGLXiTnn38+U6mceeaZ/Ln99tuTY9avX1/z85WvfIW+HDb7Y3zwgx+sOe4Nb3iD32BHY5Q2iow/lPlWpTIslfLO8Htpq1QqtcIRh8NQqIBlagJYIIFLLrlEXv3qV1OZFJND119/vbS1tbWc7BxkFlRMn/vc5+TDH/6wnHjiifLpT39adu7cKUuXLpVvfvOb8sIXvpDH3nXXXXLsscfKb3/7W3niE58oP/7xj+V5z3seyarly5fzmC984Qvy9re/nWquzs5O/v6jH/2oZnE+99xzZceOHXLVVVc1nTV+/vz5bJMn73M4HA6Hw+FwOBytoBl/Asqoxz3ucXLppZfyb1Q4R9oUEETveMc7Jhx/zjnnML/vFVdckbwGHwn+FHyiLIC02r17t1xzzTU1Sils3McRK9N9bY79E5WR6/lvoesJE98b/Z1IpSzSeZLI6M0ibUuk0O45qA8k7GpybWhaKQX2HT/gsP7whz8kf+MHZBGY/MmExSE8D0qm0047reb1m266ScbGxmpehzQVOatASgH4FzJVI6QA7Cbg4lER0I5JnxvH2DkcDofD4XA4HA6HY28CkR/wf2K/pVgs8u88v6VVPwdpULBZD2VVGgjXQ8qUxzzmMQztS6dDiTEyMkJ/K/5xOCYAhFT4JfW3wzHJROc///nP+e8rXvEK+cxnPiNz586VqeJb3/oWpakI30tjw4YNVDotWLCg5nUQUHjPjokJKXvf3qt3DBbPoaEh6enpyVxo8WPwhdbhcDgcDofD4XDMFLZs2cLokyy/BQKALOT5OeYHpYFUJ/Dh4nQowD/+4z8ycmXRokUMCXznO9/JEL5PfepTmef52Mc+Jh/4wAdavELHgQslozJSADkcLeeUgnLpP/7jP+SBBx6Ycu899NBD8sY3vlG+8Y1vTDoX1UwBCy1kZvYD2azD4XA4HA6Hw+Fw7KtAPqkXv/jFE3wvpGl52tOexvy+r3nNa+STn/ykfPazn63ZpI8B0grhOPYDv87hyEWikHJSyjENpFRHRwfD58DiTxWQpyJpH1j59vZ2/iCZOVRY+B0sP2SsyP2Ulp2uWLGCv+PfdDU++7vRMYhpzFJJAb7QOhwOh8PhcDgcjj2FJUuWMD9vlt9ifk0aeX5O1vG/+tWv5O6772bBp0ZAbiuE791///2Z76OiOXyp+MfhyIelsHZSyjFN1ffe/e53y7ve9S7Ztm2bTAXPeMYzmJsKFfHs5+STTyZ7b7+DBIuT8GEhffDBB+VJT3oS/8a/OEdckeLqq6/mwvjIRz4yOSY+hx1j58iCL7QOh8PhcDgcDodjTwFpSx772MfW+C1IdI6/8/yWVvycf/u3f+P5kQe4EeCLIZ/VsmXLJnUtDofDMSM5pQyoBnHPPffIqlWr5JBDDpE5c+bUvI8cUc0A8czHH398zWs4FxLs2etIwgc5KeKbQTSh8gQWWVSVAE4//XSSTy996Uvl4osvZvz0e97zHiZPB7EEQIKKNl944YXyyle+Un72s5/Jd77zHSb5czgcDofD4XA4HI7ZAPg95513HjfnH//4x7MiOarrIacv8LKXvUxWr17NVCMAUqGceuqpDLdD4Sjk673xxhvlS1/6Us15kR/38ssv53FpICk6qqg//elPp3+Gvy+44AJ5yUteIgsXLtxDV+5wOA5ktExKoYzonsK//Mu/kKU/++yzGdOMahKf+9znkvchcUUJ1Ne+9rUkq0BqYSH/4Ac/mBxz2GGHkYDC4nrJJZfImjVr5Mtf/jLP5XA4HA6Hw+FwOByzAeecc45s3rxZ3ve+93Gz/cQTT5SrrroqSWaOiBH4RoYnP/nJ8s1vfpOb8ohkecQjHiHf//73J2z8g6xCBfUXvehFE74TG/l4/5/+6Z/ob8F3gt8EgszhcDj2BAoVrFCOusDuAhKeI5Gfx0w7HA6Hw+FwOByOVrA/+xP787U56qMycj3/LXQ9Ifc96TheZOx2kbalUmg/3Lv0AMKuJteGlpVScaLyO++8k78fd9xx8pjHPGayp3I4HA6Hw+FwOBwOh8Ox38E1MI76aJmUQlLxc889V6699lpZsGABX0OFPMQhQ/q5dOnSVk/pcDgcDofD4XA4HA6Hw+E4wNBy9T0kG9+9e7fccccdrMCHn9tvv53SrH/8x3+cmVY6HA6Hw+FwOBwOh8PhcDgObKUUku399Kc/lWOPPTZ5DRXwLrvsMlbDczgcDofD4XA4HA6Hw+FwOKZdKVUul6Wjo2PC63gN7zkcDofD4XA4HA6Hw+FwOBzTTkr95V/+pbzxjW+UdevWJa+tXbuWpUOf8YxntHo6h8PhcDgcDofD4XA4HPs1POG5Y5pIqUsvvZT5ow499FA54ogj+HPYYYfxtc9+9rOtns7hcDgcDofD4XA4HA7HPopKpSyV0sa93QzHgZJT6qCDDpKbb76ZeaXuuusuvob8UqeddtpMtM/hcDgcDofD4XA4HA7HbEVprUhpnVQKc6RQ7Eu96QopxzSTUkChUJBnPvOZ/HE4HA6Hw+FwOBwOh8NxoGIk/FNo29sNcezP4Xu//e1v5Yorrqh57etf/zpD95YtWyZ///d/LyMjOhgdDofD4XA4HA6Hw+FwOByO6SClPvjBD8odd9yR/P2HP/xBzj//fIbtveMd75Af/vCH8rGPfazZ0zkcDofD4XA4HA6Hw+HYr+Hhe45pIqVuvfXWmup63/rWt+QJT3iC/Ou//qu8+c1vls985jPyne98p9nTORwOh8PhcDgcDofD4dhfUHECyjGDpNT27dtl+fLlyd+/+MUv5Iwzzkj+ftzjHicPPfTQJJrgcDgcDofD4XA4HA6HY99EYW83wHEgkFIgpO677z7+Pjo6ygp8T3ziE5P3d+/eLR0dHTPTSofD4XA4HA6Hw+FwOByzD6Ut+kuGUqr0wJ5ujWN/JaWe85znMHfUr371K3nnO98pvb298pSnPCV5/7bbbpMjjjhiptrpcDgcDofD4XA4HA6HY19CeXBvt8Axy9He7IEf+tCH5KyzzpJTTz1V+vr65Gtf+5p0dnYm73/lK1+R008/faba6XA4HA6Hw+FwOBwOh2PWol5OKc835ZgiKbVkyRL55S9/KTt37iQp1dbWVvP+5ZdfztcdDofD4XA4HA6Hw+FwOByOaSOlDPPnz898fdGiRa2eyuFwOBwOh8PhcDgcDofDcYCi6ZxSDofD4XA4HA6Hw+FwOBwOx3TBSSmHw+FwOBwOh8PhcDgcU4TnjXK0DielHA6Hw+FwOBwOh8PhcDgcexxOSjkcDofD4XA4HA6Hw+GYIlwp5WgdTko5HA6Hw+FwOBwOh8PhyESlMiSV8vbwe2mzVCrjOT1VkUppg1QqTk45moeTUg6Hw+FwOBwOh8PhcDiyMXaHyNgfAxk1/meR0v3Zx5V3iow/IFLe6D3paBpOSjkcDofD4XA4HA6Hw+HIQVn/VQVUpdTccQ5HE3BSyuFwOBwOh8PhcDgcDkfTyA7RczLK0TqclHI4HA6Hw+FwOByOWYDLLrtMDj30UOnu7pYnPOEJcsMNN9Q9/vLLL5djjjmGxz/qUY+SK6+8sub9l7/85VIoFGp+nv3sZ9ccs23bNnnxi18s8+bNkwULFsj5558v/f39M3J9jn0UEwiowuROU+6XyvifpTL+0LQ0y7F/wEkph8PhcDgcDofD4djL+Pa3vy1vfvOb5f3vf7/cfPPN8uhHP1qe9axnyaZNmzKPv+666+RFL3oRSaRbbrlFzjzzTP7cfvvtNceBhFq/fn3y85//+Z8174OQuuOOO+Tqq6+WK664Qn75y1/K3//938/otTr2VbSuhKoM/0Qq/Z+RSnl3yE1V2ixSWjcjrXPsm3BSyuFwOBwOh8PhcDj2Mj71qU/Jq1/9annFK14hj3zkI+ULX/iC9Pb2yle+8pXM4y+55BISTm9729vk2GOPlQ996ENy0kknyaWXXlpzXFdXl6xYsSL5WbhwYfLenXfeKVdddZV8+ctfpjLrlFNOkc9+9rPyrW99S9atc+LAMTWCqlIpiwz9fyJjvxMZ/P+8Ox2ZcFLK4XA4HA6Hw+FwOPYiRkdH5aabbpLTTjstea1YLPLv3/72t5mfwevx8QCUVenjr732Wlm2bJkcffTR8trXvla2bt1acw6E7J188snJazgnvvv666+fxit07Bcob2tNNVXZXv295CF7jmy057zucDgcDofD4XA4HI49gC1btkipVJLly5fXvI6/77rrrszPbNiwIfN4vG6Akuqss86Sww47TO69915517veJWeccQbJqLa2Nh4LwipGe3u7LFq0qOY8MUZGRvhj2LVr16Su2TH7UQEJVeidPLFUisZQ2ceJIxtOSjkcDofD4XA4HA7Hfohzzz03+R2J0E844QQ54ogjqJ56xjOeMalzfuxjH5MPfOAD09hKx6zF2J9EClmUQUUq5SGR/s+IlDeI9L1TCsW5E9VTpQerv5e3TwztkzEpFLpmqPGOfQUevudwOBwOh8PhcDgcexFLliyhcmnjxo01r+Nv5IHKAl5v5Xjg8MMP53fdc889yTnSidTHx8dZkS/vPO985ztl586dyc9DD3lY1v6N0sSXyjtEhn8YckVBPTV2U85HH6j+XtkhlUp0rtL9IqO3zkB7HfsanJRyOBwOh8PhcDgcjr2Izs5OeexjHyvXXHNN8lq5XObfT3rSkzI/g9fj4wFU0Ms7Hnj44YeZU2rlypXJOXbs2MF8Voaf/exn/G4kPs8CEqfPmzev5sexH6OSkzuqHJGZY7UVHxOUYsKzIlLZHX1+h56+9Yp+jv0Le5WU+qd/+icpFAo1P8ccc0zy/vDwsLzuda+TxYsXS19fn5x99tkTdgMefPBBee5zn8vKFIiHRvUJsPsxIE9FJQosoEceeaR89atf3WPX6HA4HA6Hw+FwOByN8OY3v1n+9V//Vb72ta+xKh6Skg8MDLAaH/Cyl72MKiXDG9/4RlbO++QnP8m8U/CtbrzxRnn961/P9/v7++kb/c///I/cf//9JLBe8IIX0B9CQnQAVfuQdwpV/2644Qb5zW9+w88j7G/VqlV+0xwpVLKTno/foeF4KZQ3p/7ekXGujM85DijsdaXUcccdJ+vXr09+fv3rXyfvXXDBBfLDH/5QLr/8cvnFL37BsqRI1GdAMkAQUqhWcd1113EBB+H0vve9Lznmvvvu4zFPf/rT5dZbb5U3velN8qpXvUp+8pOf7PFrdTgcDofD4XA4HI4snHPOOfLP//zP9GVOPPFE+i4gnSyZOTbj4S8ZnvzkJ8s3v/lN+dKXviSPfvSj5bvf/a58//vfl+OPP57vIxzwtttuk+c///ly1FFHyfnnn0811q9+9Stu1hu+8Y1vUBiAHFPPec5z5JRTTuE5HY66iEmpSr9I6c81b1cqowzZI4pL9MWIlKqokKS0zjv6AEehshf1cmDzsXBiwU0D8clLly7lQvvCF76Qr2EHAGw+qkU88YlPlB//+MfyvOc9j2SVLdZf+MIX5O1vf7ts3ryZMlj8/qMf/Uhuv70qKQTzD5kqFvlmgIoS8+fPZ5tcnupwOBwOh8PhcDhawf7sT+zP13agozJyfe0LhUISzldBknPklDL0ni+F3r8RKW0WaT9YKiO/Fdn1DhHpEWl/hMj4beGYrqfVnrNtpRTaD94Tl+OYpWvDXldK/elPf6I0FEn3XvziF3MHAEBc89jYmJx22mnJsWDwDz74YJJSAP5FFYm4FCqkqLj4O+64IzkmPocdY+fIAkqc4hzxj8PhcDgcDofD4XA4HAcsYj2LVdMrzA//lqDiq0wM3WtbKlJckBG+53DMAlIKyfMQbgfF0uc//3mG2j3lKU+R3bt3y4YNG6h0WrBAB7ACBBTeA/BvTEjZ+/ZevWNANA0NDeWWOQWjZz8HHXTQtF63w+FwOBwOh8PhcDgc+yyMlOo8Ofw7/sfU+yrsKCyoklKVnRkn8kTnBzra9+aXn3HGGcnvJ5xwAkmqQw45RL7zne9IT0/PXmsXEggi0aABBJYTUw6Hw+FwOBwOh8PhONDBpOaWH6r9eJGRa0TKW1MHqQCk0BuIKcCVUo7ZRkqlAVUUkvDdc8898sxnPpMJzJH7KVZLofreihUr+Dv+RZWIGFadLz4mXbEPfyOmMY/4QuK/OPnfvgJLD4Yqhlb9oFAoTjgG78dAyVerfojfmXQOpyriuLbkvcm2yb6z1XOUSyUpFIu5nwvnDtdZLLZJuTSGD4m0dfDv/OPGw3HlCjJA4kX0lBSLRe3DilRQwbFQlGJ7e9KvFbQHxyf9WO1f9psC55lwLexXvT/4Hnw/2oR+KeI7cA/C5yrJuXBMge3De/H9rekHOxeEj6FRaCy+NFwnb2OXFNvaavqCn6kIrwmntnaHY0pSKIR7n9nv46Mi6GN+XfZx1WtHf4drRZ/asdVrwk91fNj368vhuthmNjb8W9Lrwv84VtH2cK5iW8eEez7hXoQvSu5HmDN6n63vcP/bGi+R+B7eA21f7dirnYfp62U70T98qThhvIdxM8Y+wDixz8THZM3p5PMY65jPhXYpFNui7yxzPFTne0EKvNZ4vlqbbTziO/Besen5K5iTgM6b0EXVOcVqK/id46IoFRzPvzHu25M5GV7HPWlHJsRwb6J+5nfx3of7xevitWNgY46H66nYvGdDwjXbuofvYn/hGrWvyzger+GaMcY4dmrnWnp81fQ9r1mvkWM0HsvF5J6E+1RJ2lMdixWRMvpQx72tBWxTIcwDXh/6o6j3s5yc184RxqeuCzgn10hdu8ZHbKJx/HJ9smcArpv/ov9srUHbKyJYI9s6pdje0dR4qB1HoQ/tWWXrH35CX5R0/nUk8zVpL+9huP5CsaOl50qytvDzbTx/zT3T/mP7ormcN4/juZDMZXYbPtf4mVf9vuqYTsZi9EzJen6m1+kwB3Rs8gD0YZizYf2w9RbHoH1h/ee9lOp8qq5R8RqNe6TnDIt+3XU/WX/xg/uFuZyzlvJ+6vM36ROeJF7zo/GB98dGRIp4L6xZOH/4DB6b42GeZM2lmkZq+3B+/FvE/cb59RpxMj4/cb06x/U5lmWXJPNMn3HVsR3GCe8R5kzqs5zLOq8TG8zujc03zOdk3Qz3OLYzkjUSY7KtU1/D2AjnzUN6bjWLXFukzrNoQl/ZOEvGVHUM2hxobU2Z2B6HwzHDqOwOvgrmYJvmg6rsCs/05JhBnaa9Hr7n2HdIKZQtvffee+WlL30pK0N0dHSwdOnZZ5/N9++++27mnHrSk57Ev/HvRz7yEdm0aZMsW7aMr1199dUknB75yEcmx1x55ZU134Nj7BytAGQWEqijkgVIKxBmK1eulLVr18qaNWvk4YcfltWrV7MqBog05KZChcA5c+bI1q1bk2PsXxBmOF9fXx+PQw4ttB2vpY9FyOG2bdtIpMHYGBzYLYsWLZZNm7dRxfXQQ/fL6hWLZO3Da2XJstWyq79fOjrapb29W/r7d8mSRQvY/tVrDpK16zaE8z54nyye1yv9Q0PS1tkrXd1zZMfWDbJyca+s27BJVh98iKx9eIOsWnOQrN+4VRbMD9eEpaavb65s2bJZVq9cIWtx3atWsB+Wr1otW7Zul745fTKOaxodknlze2XLpm2y+qCDZe36Ddreh/Satko3CMCCyNDQsCxevFg2btwkq1cslrUP/ElWH7RG1m7YJUuWrZBdO7dLR1tR2gtl6R8YkiVLcexaWb0a17RJVi/tkbXr1sriZQdL/0hF2ttBLnbK9m2bZeXSebJu3XpZvWylrL3vNlm1tEPWb94pCxavkpFyj5QKRembu1S2btsqq1fMl7X33SOr16yUtRt3h2ta/7D0dY3LeEVkTObKvDltsmXLdlm9epWsXbcxXNu6tbJs8ULZtnNYeuYsFCkNytDIkCxasFA2rXtAVi9fIGvXrpfVhxzKzyxZPE92DYxKR/c8aW9vk/7+IVmyeL5sXHefrF6xQtZuQP8ulrXrt8riBfOlf2C3tHXNka7eRbJj505ZuWyJrHvoYVm9tFvWrn1IVh10qKzfvF0WzJ0jIyPDUhoflb45vbJ1O/r+CFm7aTDcp4cfkOXLFsuWDQ9JX2+njFe6ZGxcZN7ipbJl+4CsXrVc1j50r6xetUbWrt0iy5Yvkm07dktPby8d5KFdW2RRX1k2bdklq484Ttau2yarV63keZcsXSm7BgbD2MN92q1jb9OGcN61m2X1wbhfG2Xx0lUsc1wsVqSrs0t27uqXVatWy8MYy6uWytqHHpJVq1fK+nUbZMHcLhkZG5OS9Ehfd4ds3bpBVq9YImsffCj8u2GjLF/cJ1t2l6RvwWoZr1RkbHSE82nL9t2yZs3B8vDDD8nqlctk7f1/lGWLemXb9h3S09Em0tYtQ6WiLFowTzZt2SGr16yQtX++W1avWCZrt4/KkuVrZNfuXdLR0SkdHV1cp1CEYf36dWH8o6+Wz5e167fI4uWrZWCoJO3tHQw/5thbsVTWrd8saw46mNe2asUyWb9hoyyY2ycjQ7ukVMJ96pGt2wbC2Fi7IYyrtevCfdqyTvp6umW83CFjJZF5CxbIlq07ZM2ag+ThB+4N8379Jlm2fLVs27FL5vTNo2M1NLBTFs3tkE2bMT4PkbXrcW2HyNr7/yRLFnbLriGRjs4OaZd+6d+BObZKNm7dLatXr5S1mCs4du1GWbxkvvQPjkhboShdHUXZsbNfVq5eGebTmoPZTuQFXL9unSxctEiGh4boT/W2j8rW9WjfElm7aXeYT+u3yfIVa2TLtq3S19Ml46UxGRsZlHlzF8iWDetl9QrM4W2y+tBDOe+XrTxEtm3ZID1tgyTnhkaKsmjpYtm0aUe4pocelNUrlsra9WtlycIFOp96pb08JP07N8mSJYtlI8Yp+nMD/l0iax+4TxYvmCv9AwPS1tEjXX1LZcfAsKxcukzWPfxHWb10vqxdt1lWrVou67f1y4L5vTIyWpJSuV36etpk66b1XOfXrsd6ukbWbh6U5SsOki0bH5a+uXNlXDrCNfWIbNm4XlavXC5rH34wWU+WLVss23Zsk57OLjqdQwO7ZNGC+bJp+y5ZfciR7KPVq5bJ2gfukSXzu2TXtm1hPnV1Sv9wuyxZ1CMbN2JtWMY5x3m6rSSLl6+U/m3rpU1GpKunT3bsGpKVBx8p69DOlQtl7UMPy6pl82X9xvWyYP5KGZEeKZXHpK9jWLainVhzN6INR8naDWtl+fJlsmXzNj6f4EuPDffLvPm9Yd3D+dY+JKsPPlzWbhzhGolnXG9vL51NPCcW4Jo26bMM9wnzf916WbJkiezasU06Orukvb1d+ndtlyWLF8rGTXpNmP9Y9zbtlsWLVkj/7o3S1t4pXXOWyo7tW2Tl0vmybu1aXUe2yaqDDpb1G7bIwoULZXh4UEqjw9LXVZCtO3Atj+DzbvXq8JxavmyRbNnwoPT19ch4uV3Gxsoyb36YTxz3mE/47nXrZNnSlbJt96j0zJmrz6chWbx4mWzcuCG0c+3DsvqgwzgPsB6gbR2FEWkvjEn/UFmWLD9INvL5fHDyLH/ooQdl8aJ5fH5xPrWNyo5tm2Tl6oNl3UbMz4PCWr58haxfe58s6OuUkdExKVUK0jdvmWzdPahr2drQnw/fL8tXrJYtW3ZIX1dJxke2y9jwqMyb1ytbtu4Kc2TDRlm9eg3n/7LFc2Xbjq3S0zufJMAQ7IjFi2UT1pODDg/nZV89JEuWLpNdO3ZLR2FU2tsL0t8/LEuW9MnGTVvC+R7GPFgpazdslcVLlnGtb5NR6erulR27B2XlsoWy7oF7ZPXyOZx7qw55pKzfskMWLFwkI0P9UhovS1+PruUYRxswrlbI2gf/JMsXzpUtm3Cf5sp421wZK4vMmzdftmzZKatXLZS19/2vrF65SNZu2C3LaEdsl55OEMUlGdo9IIsWLZBNO8b1WbtJn0/3yZL53bJr17B0dHVKe7HMdY1rxPqHw3q3aUBWr8G8WieL5/VI/+4t0tbWxefTjp3bZOWShbJu03ZZfRDmyHpZtWa1rN+0SxbMnycjuzdJqVKSvrkLZOsmzLml4Xm3BuNphyxf1CdbNj8offMWy3ixT8ZGR4MdsXVrWEcw99YcJmsfvleWLV4g2zZvkJ5Cv0hlVIZG22TR8iPDGnEQ5tE2WX3wYXxW4Pm6a/s26WgbkvZiRfoHi7Jk+XLZiDm9Cs8RXD8+s1EWL1vGa4a90Vkclx3bNsrKVQfLus27wvPk4Qdl1fIlsn7jJlm4aKmMjIySIIINu2XLltCPmPewI9atkxUr18iWLdv4/vj4qIwND8q8eX0cj2HMrQ/PvYcflmVLF8u2rVukp2cON0KGBvtl0fw5smnzJlm9comsxfg/GPMVa/kc2bVjp3R0dkt7V6/0DwyHNWIDxifsknVhbK99UBYvXiT9/YPSVilJV3tFdvSPyKqDDqc9Gubpg7JqzSGyceOWGbXLAawRixYtoq2dPhZrBKIuhoeHp+wrORyzBqZ4KswVKS7SF0Gm92copbpFivPrhu9VRm8SaT9SCnac44DCXiWl3vrWt8pf/dVfMWQPFfTe//73k/B50YtexFxOKFuKMDos8ngovOENbyCZhMp7wOmnn07yCSTWxRdfzPxR73nPe+R1r3tdonR6zWteI5deeqlceOGF8spXvlJ+9rOfMTwQFfn2RVR3vcf1pxx2u7CbXtopMr5LZHyxbnTqzvj4kEipTWR8WKQ8KFIalQpeG98tUh4VgeoFu5jlbpHysEgJzMuIyOiASKlfZBTn3CUyMsqfSlufVHBsaVhkbJvI0DqRwZFwvtJ8kTH8i6YVRUr4HrQPZUJ38fxltLUyLpXRfqmM7hQpdgUlRXlcKmhPaVRkDMfuFhnZKjI2IDLWIzK6TaQwTCNNRsZFhsdEhjaJDHeJjGwXGR4SGcK/PSKlbqlwp60z7IKODYoMbhQZHBQpI98YdhVx3i6RysKw0TbWLjK2U2QUbR8UGdse/h7pFhndLlLENWAXckQEZMbwFpGhsXC944tERtHecZHRcREMvwr6cGfom5FNIqPDIuPbRYZ6REa2iQyOigxjZxU7vt0i4/2wakRGd4iMz1W101h4nfdkV7j2ji6R4c3hu0c2iIx2hr5HW/nvmMjoSNhQBYsGZQi6ooR7tC0cV5ojUsa9GdX2j4gMQf0ARxmvDYgMrRcZRv+i3VBlYEd5VPukJDI2JDKin8V9Zp9iHKID8fewjoW28N0YL/hOvh8B43kcY6FfyqO4Vlwz+q5fZGB76Fdcz9BwuP8dfaGN/BzuYSXcn3F8Dh0fdqt5TAn3cZdU2DfDejzG8mDoQ8yhsbki4z0i86AKQZ8O6f3CvesWGVsQrq+twrcxd7jjjfPjHlOJpGqYMnaAx6VcxoDCWMFruBcjQUXBeTqk7UJ7MR6h/EJ70ee4jmE9r/bD4ED4G8rFMuYx5spY2BnneMVc2Coy2sG+K+Na0AeYy1zi24PiDu0d0TmFtwZxP+eJtJVCHw8+KLJ7h8hAWedTr8jQxjAmh9p0jcA5MD7nhHayX/uTfysjRZHhnVIeGRPpxljGeJsjMoaxjTZivWgXGekPKoeyrjUDuC/rRMaxZuwSGewI9xVzEGOwHTkJBkRGukT60dYBkV3omwfDGjC0S6Rnp8hQISyLbduTey+jGNdYP3aFa+P3dImU0K9dIgO7RfoLIj065sc2i4w/KDKyXmSwS6R9mUgJ4x9KTMwtzIvNIsOjIgMVkaGiyFCHyPBakfa+YHRx7uHYXSLDBZGxtbpeVUK/928W6cYivVlkbIvI2HKR4W6RoXkiA9tEdu4WGfqzSA/uH4y3ssh4n8gI1o5OXZswdh4WKW0XGayI7ED/7AxzBDuSYDBH5oV5NIQ+3iwyiPasF+kcEylg3cN83ykytj6s8VijRuaKjKAvdokMbRFp2y1S6QxjZKhbj+kO82T3QyK7R6SyG2OxJBWsN1KQ8ijWlnaO9QrGCccTlod+kREdV1gXOjH3BsI6iPuI68A1jOJaMf/XigxsEulZItI1V+cO1mxVsGH+YC0d65dKqS+sMXgOVjCO+lVlpqoYrmtYH7EOdKo6AzcK6wT6bquuT5iveB3/DomUsWmCuRIUhpzveD5gfuGZVSlXVbpFKG5UUYT3xwekPD4mlTLmJdqGBQTfh3PjM1tFhnaIDM5V9S7m/IDI6BaR4XUi7V2hH/Ee5vc4FDG4jn6RYTyvQNaaChefH9Q+0XWGz3y8rutvqV2fA0NqG6CNaIeqX3l8UNzwnFh3+JzE6XEs+hXnGw1tHGvTcYgxj2Mx50f0p11kdDCsT3ymYb7hnuG9bSIYI7hPuN+DfSLDuO7OMN+HcB143mFNxlge03mMtsD2QNt1fRzG+N6m9wznR9vGw7MYz2XeJ3wn7j36ZEykHWskrgXPEfzgddg5aNOC0E7MG6yrUO9UsIZhXJbDtYysFRnDeoa2Yf3D/dE29OCeYZ6NhWsZwdzFM2xAZHytyAjWd1X/jxb1+YbvNvsN19gRxmMXSq1jHOOZj7k3IjLWp4pHfaaPoT0bRYpBcUUGD2MDcwzr3eAmkQG0B8fhWdMplUqHSAHPbrUZKqWgjuT97w9r+Vinfk1QHodx36+22bww9ktjUsF4g42HnS28h/uBZ2epl2swxyvuE64HY6Zd7zvtT70HnBNDOk5xbzFutom0YU7j2TVWnXOYw7hfXGTxnMXajHu+VaQd31OQSmmNqs303nOeer4ah2P6nVIll4rzpVBol0oB6xPWrO0ihTkpUqqnJnxvorISC854SJTupNQBiUJlL67U5557rvzyl7/kbgV2EU455RQqn4444gi+jx2Ft7zlLfKf//mf3N1A1bzPfe5zSWge8MADD8hrX/taufbaa7nzcd5558lFF13EHVgD3rvgggvkf//3f7lr8d73vlde/vKX77NlTqGUCtJ4/KVhUXiQwziBUdXWLdK9SArFrnAcjSUsCt0i6JdCkHfT+IFBVuwID38QQzRSIbVUyXoBhggk1TCEh8MxcLzaesN3w5iCkwpipXN+IJg09IGSejruGgYCtGOR0hAcOAJwHBFKwO9vr0rpaSirIY3vbOtSwwMkx7BIsVOk0KHXi+/qUXJlVKSrR6RroUjnIkrZSeLBiez/s4ZCwXhG2EZnqAbRPTcY1jBo2c72cL62ce1XGPFg/ftF2haK9K5S0grGZSk4Dh0g42BQ7hYp9ob2wtCC4w2jlg6JhezB6FJCA33Us0ykDbsM6GYYhCC95oX+xDlAZtCw2xkIKbSNhqS2j0Z2b7hmGG1Y40v4HnR4MfQ5CQU4E0pa4TWGV6FdGBsDIu3zw7WhH0COwABFe3Gvu5Yo0QOCAoYpYsY7RLrmhWvA9Xbh/neHNpOowPV1BkOZzu9YCLnAMe09GhqifWHGOAlLkKkwruFcjmrf4O8BkbaiSM8KkXY4cWhPf5XYAWnTvkikZ56GF5kBOxjaiIcl7jOcChjzskXHwjKRziWhj3Cv4JCP3xvut6wM73HMwxnaLdKO8bhA+xn3tKP6O8hKOrqQMveG/sO949juUKMaxjfu3e7wuaLOCTjuIKZwH9sXhgc0HXbM3zGRjjlhfnV2i7QFpUPo5x0iFZzfQlE6RNpD+BvPW7YxCAIETjcc9IFwb3oWBXIADkMF/QFGZ55IBwiLzuDY8x7MUQcZ46sc2ofvKoEQwBTGOOtRkmmTSGmHnqtbpLBcpKBOOEPN2sOYxe8InyIph/lX0fvRHcZWNxwSOL1IookfyMSx7mCiYE0C8z2gzsk8ndOjetywnqdXf3C/eigrF9kVhTBh7FuYiO3clfT7+sLYIMPMySkim3TctOl3YiyuCX1JiXqnSAfWDpBHcLJxTpDg6/QcK9WRGtDrRVt36nfBWJurxxnJ26NtxXE6Ttj+edquAW0PXl+qr3OhDf9w3hZEhjdq3w7qZzCeV4h0LA6kFuYWv6dHpLNPxzMcRawzRZEOtAv3dlCECi+Q6Oij9dreBSJd6AuoIDDGQxi1dKLvO5ToG9V1BwTW9jCfMLdJLmE90f7DfWvDugIyb5NeL+YnjN0RkW5U8EEb8fwByYprw5hcGtoOYgjPHaw5nQtEOqDw1HWUa/RQeObhhzGJSmBjruFvzHfu6FbDCHkM1y4N68eaY+FlOC/DU0EK6+3leoO1DNek7QbZivFs4dYkoNbqBxaJ9GKXGWMHZCIc+7V6z+bpeJgnMmdNuB4Y+XwOdnOuFtq7pQICCMRvEet8uwiUQ1hbuCaAbN8a1nrM6+4FgQTCeoR5CBIdzyXcr86F4RmDNZREhW4yccrhHmIu4d7sDP2GdY72APppONgEnC64ZpBjGFs9IlAPY43gcxvnxAYZ+gBjpSjSibEj+l4IW5eOBeE5OI41DqQLGmH2C+4x7AQQUErcY+ygfzge7PeghuU6yecjnodYC0r6Pq4L93M8PEdJlpdFhkAkY97ieaXXyPsfQj+T+8x1TzcGcM7OpeEeY4xj7ODZiOcHiLPx+0N7oCrAGt7Zo/MD6xWe+7aRgfmF5xA2TvhFYU5jnHXBZsEYxbqpm2Lc9AvpFnifcDzGOdMZ4HqUsOqEXbE4tJ/PXNhL89QuYyyvErEaCopQQM67QtUew2DgRiL6EHYoCL1BPQZjBuskQoTRb5hHnWE8Y03Gc5ckH54LaruyP/S5gGeMfRfnI8YA2qYbYmwfzo95ukiK7T2BEMa8HtoQPoc1r3t5sP3Y3jBv88Ks9zRmmz8xndifr+1AR2Xk+pzXfyUy+CWR9kdJYe6FUtn5dpHyOpF5H5VC20Ei7QdLZceFImPXi/S8RKTr6SI7zg8fnv8FKdD+VbQtESltCQRXxzF76Mocs2lt2KtKqW9961t13+/u7pbLLruMP3mAyiodnpfG0572NLnllltkf0HI5aD5gag+gSUHIxSkQIfuaI1JAUYBFg0a321K5IAgUCeaxAmO0F03c6TxOW6RwVDFy1BawLiBEa7KHuYV6QhODYcRDB44yiBbYNDg3DDetG34AjjQlqMB343d/HY4c+pA43y0fmGnwViDA2PkDciN+YF0oMPRpgayOhgwbItjIl1z1CkEMdHOHWoCRhQcbRg1MLqRBwVOC/tK1VdlNQppCMGgXyDSDsd6sxp180V6VklxzlIpg3DpxGvWP1AegOBTAgDGF8Uy84ND34vX1BGBEVnYHFQaMGjxA4MR76P/YZzjbzhlVFBhZ7Eg0rUgGIkk03qqBB7JkG519lWBgt95D8fVWYDzAKMMThqIBrSvItIFUgBjpk9VHrgf6H84M1AkYZzovYEDQGcVTobuVMKwxP0gCYx8NO1hZxTfSWMXDpTm5wBZwjHVoYSUOWZK8GEHmUQQ7kmnOuJw5OD0rRbpAAHYUVXgwemlUwYnGYYsnBmQNCBIwtjn+8xDBCMcDtL2KEcPHJK5It2rwnXQCUBf2y4sxiA+i+/Fd6pRjp17GtampNDcSVS89VXHMfNumUOL68HvcDiws6w5uXB+OJM07lXVgOvtDDlmqHRrw/zAvER/KuEIJ4SOdXvoZzp/aA+cM3Qh+qkQdo8BjHns6JNEXRj6jMY6xpESayMgwtRR4HzD53U+FlQth3ZQkQGnAa9pVRW8DmevAw2cr7mkME4wn9BeOIzoO8xfrEVGCnWGMVjB3Ea/wsGDw421An2Cz+FY9N8cvSdwrHqDYkce1vch9bb7qmQYSRvR17eLVEAOhfxxgfzBuTBWt2tbMd7QeVjTFur7IIyU0GcbcH3ad/wX6lL0H+4bxgrGLua3qmL43UaiiZ5rUL+rS1/HdeEhXVKCqVN/79Z2FPX3rZFCdkxJrB69FpyzR9dUqDrQNyAesYkAVaQqD3nt+D5T7G0O6yXJjkVhTlFpsk3HEUhwJTtJPKBpIBRF79VCdSqVFOQjAiQxCJ3OKpFAUgMkuz5D2ux+g8hBH/dHhKRuHBTn6d9K8pZw/0ZFBgsiHYMi7VBn4P6BAFUyvwJiCus61kAQTUpAa/67sD7jHmJs4ZmhZAyumU6zKnc6hpUoRB9AvTge5gxIEs5vXVM5/nGtOFYVMbg+bCpwzhshjNPjHumzhWtzMRqDUGeCqMO60B2eAaO4T2iH5ezApkt/uF8gnXCv8RyVNqmAbAbpAvK3a3Eg+0jMY+Nnlx4PkgD3AySdEsJUQaHfldzhfcNzXZ8pWDvxzG3D+q33Bc8gbmShHbgH20VGNivJiHvaqRsBWJMxdrDOaI4y2ga6OYXnMfpMFWfhWjqqdgnWPfR1RQlTnhtrXkGPi1RdaAuP6Ql9T2IDqjUdb/gbr0N1hntAUh7n75UiianekFuNc2JIvx/PYt0ABSnbs0QKbV2a8xHPXXy3broV8RwBuTcUbBq0uwfPPs0jx7W+EtRTeP6DhMNmGO8TBgeeIyCZsEbqlAeJx/VS1Xd4NuF7cf85j3SzBSRMGWuAqtAw0Emi9Vc3PdAOtIvzAH0zHO5B5yIlhixXHN6H/aFzAyfghhrWNNgdeA/5Cau5ujiG2ZdoE+6hkkroA9pmaAdsQRDhUKHhPb0P3LjDcwXrjBJVeA2fA3nGuao5BpONl9FkAzFpA20t2Ec9CUHKnFpt3Z5nyuHYQ0qp5F+QUkx+ftCEROeFQqdU8OzChg0/G5FSjgMesyqnlKNVqFPP3UoYmCB64CQNRE5QUQodc6VSRvLeiYlJk4STNCg0yS13otqS5L6QZPJzsA9JhMH5heOhKiGqIbAjqCoNGuIwzBAqoDthNIKw067KJhiJULvAwUYIIJPvghiB4YHPW+Ld8ciR0V1tOij4fhBSaDsIlJ3BSYHxSEMrhDiFXTW0rV2kd6Uas/i8hWFgVx/9BSWKOru8PrTTCCqEb6naq70jGK8Ig8P5qeIByYb+AqmDdo1UDSXuZptaxZIjg+BBeB52PuFIjukuK/oIu5JzqoSShUiB6KExCiILJ1eDD9/FLgnhj4HcgwMRiLhCsScoxajMUoMWJBbCGzgWQGbCiIdyR9VcuHe4VyQzQXTBmYJh3K33F0487gmckEXanrCrTuWTJadleIGGh6I/mUw27ARXMG5wv5lAVp0yOC4IU+D3Y2dbnUv0F+4FnBiScAh3wP3G/YJBPiwyhF17OG1QQs0X6V5Y3fG2+0hBDAxg4z5x7h51Gi2kxQxrOPw4EI4T7gecfU0yC6eOTgKO1UTJuHc6JTn1eA9w3fgX41adAYRhcscbfYQwLA2BxfViPnTCCYQqCeMQ4wt9jjK6qnKkOAO74tvDMWgnzk2vV1Vp+E7cU5IQ+EGojO5ecwd9t6oFlBTlfdF+KWLso034AfmgYUhoN34QFk1100CV/OGYAzGobe8EEQICAqo6W4vQz1A/YW7CaYUxgs9AjYXTgKQwskDVHdj95s45TrFAHVcdB+x3hHaCqIFzqESBKUrYNvytc5Hk0u7oWMYjaZ/06mfQ1oL+rY5iQgrg9SWRQgrjWJWB6EMQAuhnOO4lXCvUdyBlQBDhHs3X8yk5x+/CPdH1E0oZ3lxVlfD7dynphu8d1M+jze3R+9oOazPDYHB9Fu4Ix3exSO9BIl2qXsSaCkUNyZwdImMgKUFkwOnEvYEKRhWLPStFCnC04YyCFMVc0U0BElVLwljDWogxT/Ui1K3oc6wzA4EkQj8h/A5zjIocjPW5YYxyqYcDqhsFUDvR+cZaiBA1hHHp5gIxUL11mAOjWNehgMF6hPGM99B+KFCwPuK9NlUYmYLRVDd4qOG7MA41CT3nrZKKFubFNqrKCfeQmxBK1jFUVxOHgwQiKQWS1tqiobeY43y2gRTCa5h3eEahfUqAk3SvhHHPz9u47tN1A/cbn8N81FBxbgRhDYSqRwkbiolAguA5tSMQiF2qyCVpoM94rnPYEECYGEgsEAIIm8L8VUKQ4VoYNxrGCMIS58P9A7nCkE0oqXXTgt2B9mLNhRpni4a+LtdNCh0b1v/c6NL1AX1F4gPzfljHWijUwPU+SaqvawrPi3VBN8CwwcLnPdqhZBTbUU0aT5IR9gOf9d1SbgubJAEYN7gfIOZADs5XWwBruIaagJCh6ljnMxORl/Q60EdKKifRZTgn3tMNBBInWCN17eRYwvgEmY9ntSqExYg0tGdc104rYmKFCDAsYOPND5tB+BzJVtgtUPai/4x8NcU6zo35hHU7KgBhYfVGzMHugT0S4m6TBPdIWB+KDQxXCSXcC8wpPK9sk4/1DGCj6pxv65JCB+wRe2biWpT0sk04zHd8F9tqhVRgf6LdHToF0cfV5PEV2jGwzUB6GeEOVVy7VNrmJInfHQ7H5FAZuzP/zTKeHZiv82v/RfheArWP+ZzTY0BK4dnUtir+Jr9FBziclNqnoQqjkOgmGLM0HmEohYSzgYRC5ZZqxZQ4jtfepy/Oqk6hCk0wzuGol6VS6JIKCC0YjfxQW9XQCx9UQxfEBthvGBkwLEG4qEEPMgVGRwfaHPJz0KDE7vDgWjXSYBBjtyuobqoyeZZ9CjvY+E7mBNH8A/gciCgqUGC49Go7tRISQwRBnoGYgEOt4WXYPWYInBIzcEpsR5GOJYxIDXUAujQUC6EJaKdVxUnk7NiZ1ApwVObA8UA36XUwZARtgGMCdQ8MZ1WJcddaK75RoQIDXasogTgoq3rNdpGJUN1Jb2hQG5AAU+UVFWoac2HKF/xOxw8qMvSRkURw/LaIlLeEew7jH7vTFXWULAwRn4GzhCS5yJMFZxT3k3m7LMxFnWYamFpZB33NMCYYyr1KrsA5RLW0Limj39thtKr6DiQLd4qhlBvSnWUdN1TqaE4YKDHQlxhv6E/kM4Lzy3AUzbHGUAhVn6HvOhAGNKz9jp1+dfapusKDEuM15EViCByIBd5WU2DBocB3Qx2GewAnD2NQHVX2Lxyl9mpOFrSJ90FDDFkWF3nA0A44jOjXhSLdIAZMyaFzjA6S3iPa3hgrqm7izvpWVbCByANZZiEmuE8gprAuwFA3bxGOB8L4oCDB9+F+dOl1KxFBokQd0cRIoGxGSWIdX5gHIKDIGYPQw2fQR3ofQEhDmWFELFVtcMpAbEAhBnLx4VC9BcRI7zIlx1TVCQcOpAXXDHwn+qaiuUlAqmCsYf6VlXzDjRrU1+LqqVZltU2PM1IHPxqqTFII5I+Rd6ZGiiphJiSShhzjdzrJqnIjoaTnY0oiKN5MCaMKEf6LtuN4fFZVCvzp0fMuisL6Qt7AKtsJA65PXx/VHxiFcJBVRUnlLD4LgnGDSD/k8ItD2CucNhKKxswaaQdSAXmfkB9rXdjpxHcMHy4yd6WGwIneP1VdcUNAK5gyB5rlMUMf6JrFMY/11XLkjVaVn1QXYh7h0nTsM1xYQ8xBumAOklzFOXEgHE8QWjqHQJb1QY2hBKptWFD1iPVQN2r4zFHFJgll9Bvmdm9Y+7mea540jEuSTzavFgdVLJUxus5x3UG7QUpivOrzgGphzIGFYZ1grjVcrxJKdMSx3igJgvWFakg8LzEXdXOBJARUsggfBTmi4YrcYcY14pmyQ9sEMhFzA89YfA/WIM0nxY2r6gYT+xDPRG7oYI5hwwUkNcgQ9D2ORT+jf/HsifIAYn3Guo3nZpuG/2Lt4PqtSjRuTpS1HZj3mOf27EG/6fPENm5sw4okNJ45CH/HOg31Kp53UC+p6oYbYKKV+GDDtEuZGyZ4X5VSWKeh6GR/4pqjOWaibfQjxhCeB5qGIFE/8fmh5+J6g7FhSnEjxNAPeCbi+zC+QEYqMWVVALkhBvtElbO4Bla0xHlwCozHot4frOPWd1hTlDjEMbRTEFoPmwDnKui5NGQObWqD+qAgFZx43MgybJBp5VXmAMP8gIqsR9fSsJ4Wtb38LMNhES4OW0BDzC2NA8PJ7dmkJhmJIpCSaM+gtk3tUq5F9szDeES/dgWFP20KtVWppsc6EXK8YeO0wo1VDY3VSoOhIqJVc9Q0C0Y2mcpYq7gmJb/cv3U4pgzmmivvyn6v9LDI2B90KV8e/rVwPKj5+e/O2pxS/FdV1/0fk8qCr7ua0ZHASal9FDWlrUmkhB28kPA0ONZx+fhQmhiJxFUKDaLKyhyHM6ohjxAf2BTI2WO70zAiYfRYqehK5PyrA8cE2HAGYIQPBOcFu+yW+4WGguaO4O4yjH+EDqiDRMJIHQ2W+calgExrkwqcHzhMMHyQqJOGljnQUJOoUgzO1si2sIjSCVKlEskp3TmE8zSMcAM4hqoc4s6lGpww9JFziO3QnXca1F2qMlDJPmX3qsywbiGBpuEuJBqUOEoSexe0FDtCL3HesNtXRvLYbuTMgiHdpiQGdjzVGW9D/iXszqqRaAldaXTB4EXCdORsGQz5qai2CqXtaWwzrMymOu5FmxQ6QFrC0NNxgjAdVs9Q8ot9y4zR+vmw00olHR2kKOSS+VqQYBShI33VvGI0wjXJNsMu5ladNg0TI1HKe0BvQcktM2a7pdDZIxU4/tjxhzoNhjkVderQYrzZjjIIJzhXVMHptVJpBicEDi7IIwsXVTIJu+ZUTaiKwZLLd+PcJX14FpSgNBUVjOzOar9i3lkhAaiJoPDgXIT6DWoLKGrgBKC74axg5Q27vVTdINF+xwJeK+8ZSulSFIgx2BfyVNFpVjKUIa/IW4I2btPrU6UT55I6ybi+ectFRuEA4fNwsKCugPpGFVHMMQbnwEJaNPSVcx/3CE6zqgHgwDLcVBUWpkQzZSEdLKlVjlABp2GcDO9RpSPHCJRFcE5xXSBE4CTDmVfymHwQHOJtSkjDAYOTCxIG+XYwVjXfCP+taPjbg+oYzVdVE94zhxaGE+a6hWia5EbnFv/eEakDcGyvHjOk722sKleQU8rUgfzbckLhOCTg36S/o11K8iahoTiHyR36I9XUqLb5UG2HET14DWsElHMYb5HaKSFtcH0jev5CVTGFez0Qq7+UzIASsBs5vzCGh0JhAebNwr8aOsU8RBjrmquIayXmvSookVQZRif3JzDnVRUE0prJ1DV8loUHkJhZEx9jjcZ4YLgY7pXmWaODrzllkDyZ/YkxsaAaes0Q566kiABfo6OvylmcC6QpQu5IeGmBCuY41LlSrhJZDMui6gZzQEPY2s0hx/fguYMcN5j7+sxgLh/kTwLhDUXNmEinKpVA4rEQCMg7PPdAJinxgmcICG7eQ8uf1x8+W8IcwbVAbYX1coWqhjR3Hp1v9LeSolSQabg8lMAkY0DoKbFGAgwkD8alzh32F8g0rFN45uI6MfcwHKFIaq+GaOFauH5pjiCGWytxawnUMS4Ybo9hpcVRoHglgTlX1XbIhaR5yUgQaeg3n526GUHSS8NklWAotPVIpdATnjt0jsJ3Y22kqcPrj1RQJLagesZar3krSCApIUeFblDH4jnMIjGhKoGuYSAU5ybKqaCMak8VmkG79TnN3T6QJGNVxbipVXHf+RzTfIrcDNOwTVYK1M0vbuRprkcSkJgX6rSB0GSfjutzT0luquSgQgy5scooYMFE7jt1/GAu4UfD66kAw7zE2OmQQnsgssI1KQHEsd2h7UX+NSgZNoZ7S5VaILIrGpLInKXsCy0OQDJSNylJQKpans8r9MW4lKkuVnKOzxdljjgvx3hfcc8L7R1Ju2izcsNN00bwWrCRqn1t3BWVWvgezWUlRSkyZYHD4Zg0SsiDl6Oe6v9o9YWi5XrWZ4ERUVmkVPuhIiXkbcVj+aci3c/U9/Hs1pQTjgMSTkrts1AVCqXfcKo1gWiHPuTbOqRMkqhfKkmeKN2lxm4VH/w9amRptbUxc1iwO42dKDWQtVpeUNXojjATR3ZImQYCSCOWrNNdMc13REfGVFWh6kuS4JVEhoaBoLISnBIaQ6FCUqW9W/MBhFwM3F3j9fVoLgXsjocy8TSIYHxgR718X6h21XWYGsNwINBG3VGjg42dR8uPoA4wczrBiNMdShjsNGqxy48EzyCwcImah4ekHAw8DQ0zZorOh+2mk8VRg0tzaSkCUQifPnKMuZNteT3U0IaRBgXbWLQbSZXPQG0oCJ0wDX0juaPObhHyfOw+2o6iklJJXjKtusMk2hpWYCEPHGaqJEM7eG4kkJ1TDc9A20GIwRimMwTDXI1itk93uHFtXUuliIS8SpAm/WC7njYuYEh39GlYAfpD20ACwwgkJJKFs60qNqoElPhhzomyhqZgTOhuO3fajRTBmMTypyEONqeYVwZzCm3CfdsVktsjIT7Ht93AcvW+GzGDucDxBKJwXB0kkEgVKXZoDjgljPk59iP6LISm8lotvwdVUpoYnmFSIIcs3wbapsoVVnbSvBwMvQxVkYJSDO1SYglkDhxT9jF22UGCwHHGfNYQUygQ4YgjTKRjjeaNwpgDQQGyDdcGNSFIsG6GYuD+Mb8aCASSRuhjDYPEesJ2FZQQQP+a060OGpJTlw8SqYAcVGUKk75r/h06ffjZHPIflTAn+6L8UpoEn9eGW2A5mbCOmXwcCqhyFIo3roZPt5I4bUre4PixlPoIqqW5es4e/cHr5gnZNYNYwHXujIgwyx9lhJHmW+FCYoorzUnE8/VoG0e1zfO1HQ9H6i7NwUPFlJFk49rOBSmFmJK/ScghzrtBj8f5lThA/0JpxLmD5wquFwoddZy5UYHxo8n8mb9Miy9QhYN2QOECElWJiO4FNY5vUDrgfAgLwvzVpNLMA6NhgyB5uD5hfKA9UPC0aaEBDfcG4UtnFusq5pySrwz9shAq/I6xrQq99g6GHMGZJtFrClZ+n14LQ0exLqBtaDFUS6rus/nKPIghtJhrE/JJIbQNedRIvGG9CFU6E1IXpBufGeocg+RGfipWJkW+PKwDOnfxWTj8mGN8duimBKvEqXqSqiVdQ0hswwHXZwXXExyvxDeJAcsHplVJGRKnqhmS10oeoB+wblD1hWca1iMN2eqYkzwv+LxiLj0NuUpCGy0cS0POEerctlgKXX1SYc4m9IEqW0h+aD/zGlU1RPJN1dVGbnBDQFWGtB1sg0vDznB/WKxFz4HnGHMv4b7CPtCQNiqNddOBQ6ZXympbhDUc9onmXURlU96v8KyohvahCVoFLiRerCq5+a/lPwrEVghF1zmPe4O11HLpkbDBeqp2AvIKYh0FmcbnrSm8QBpiHcVcQ/W/QN7w2UJ1GtZtbMZtFBnB2tcd7CmGD4IQVRuBKljYgBin0fUkz2Lc13YlKlVNZxUiSRyZ0jZO/6Dji30/t0pKUT2OvtHnla0rvHfoX723WHc4xtQW5CZWh1Q6S1KhwlHTRjAHI+yL7urmJcMNh0LbWfwDCtCqzTFbkpo7HPs8LA9gGuN/qv27/ZDwL9Z2fm4wOsdgLSnV8yKRkWvC72M3VUmpxMB2HKhwUmofBQ0yPoCDuiIYevYgVjk4d6+Q/BnGApQ4ulPMB3aozEelChM4azJRkCwM/8J54NzabiScFZXD01628L92qTBfjBqNUHZgh5rJRHG8EVpq9Nv3s9oeHAfsbsEQt5AUI5BCGeJgmxekwuowMJ5VuYDz0uFV45w7oOqo06G3nA6qIqPjo4mhC4sTwzvJe2BGDCp+sTKOVluj46M5dxgmoSEfNHo194Qa56Y8C0QKjDEQSiAAYWzDgARZMRaaRcJFHQHuGsNI0yTClM6r4zveF/Iv8R6h77BrievXcAQa0zheE6GzchL6XkNVOBDglMGhGE921umgGUlFA1EdKLtXlW7NLxYSpyIk0kI9wy5pQcqszhVITjq4VEN1qepAlWNMbF6tSBfUWbhcC4VAc8O9riQPr7CTzlBSfr8RSpYUHs40klHD4QQpEcI1k6T8lmyfCdDVMaG6Q0PgbMyjPxjCCcewJwrHVCUV82nhPFA7gZTDnDEHyVRrUq1GZAUH6OBjzOncpDJOFYt0nkMYS1DM2XhB/6OPQ/9WoBCBionOcJsU2pEfQ5055h0BeaaqCzgtVBbAGEB4japbWAgAn4GTa+oKXCvmkRLVIGkt5IEOqqqq2ucEldo41gIjSDUci+oUjJ8QjsExxSII4fXgAIkSaZgnWvKcSfRXiHSWq84Ivhtzjsn2EaKLamrrwi49HCTMe+6eqSKOpJIRTCCRMNYPC0nPmVgT5MtxIUSRih8lNMmojESqpfX6+ogm4zSllFbXIgmF82tJdiY/f0QIfa3M0+9HeCHCLzUHWNIu0X/xXcDKKKn5TiWZQEaNRsm9bb4W9RqtkuD9eh3ztA0aUpmETQMggo5WJdxDOufLSryNKrml4Wqm9LNE8CBGSFRhDVoWkiaj7SCWWNEMpK6NMa1qiYp4I5onBiQR50mxqqbq0HsZgwobOJYIadQQbaovlOBRkjo8H2wtVGeWSkQ0XxWKGE9GLtPxxbqqoYQsNa9l7amQBdm1S8rlbpJkyUYKiR2tDit4himwniBpuebpC0Q8lrGg0oOKg+FeSf4cTVZNYgPtxDzDeVTh1YFKgUWtBKYKX2ySQFXK3FGaP49Es+ZW4lAIodsMZ8LnGMqNTYOi5pEaqyaDNoKU64OG3jPXmRY04XXpvQPRDrIGzw+u3UwUWc3biHWebdV1l+RCcDLKRlLxeaEn5rpnaiLkIrMwQnzGNsi0eEYB6qSQnDrkAVJSl88cLRZAOwLP7hD2TvukDZ/R54glqddz455WmMRdQ+JgA4CkseTaVGaiTRpuiY0rVpuFGlpzy1l/WaJ1KpKDEplrruD5pGOY678lze/Uwh5YQwNBlCis2vGsQ+XfkWoIN/OdoU1asc9yNqIdvVgT+9TGACGjhA+rkIK4x/wzW0OVsVhz8Bxke/XaGQKKZ5eSPvgbNkGiCFXSjGMYt17VyWYHkJwFoaZKP4Ybok1WwbIsFdpCmvOSdifsPM1FSeLJqlRqKLtuYob5qRupoUO1uifapOQr7gdU7FSL6TOY405VeSBwrXgGK8NiDlpaglBAJ6jPQ7XB2jQVDodjKuB6PPozkbYjRSqaS4omyEelYCF5CSk1VP1MSilVQEqYeReJ7HqHyPgfNTrANvcdBzKclNpHQefYJNB8YOMhrAYCH/iWDwZOAwwyzZHAfDRKHugiwF0p7M7CsbS8FKbuIaqqkMwdKHIVeN12F+1FrdhD1YbuWAZvNRhezEkRjCWQHhUSTpZDKjgX5FaseiCTRKszwNdw7SBh4Kj3a3iRlqtmJcJC2D1kWAUMHBAmQQUVlEolqcBAZR4bla1TqQEnzKrXKdnG0MKw6LJ5VFzBaBtRI6kz7MJzx3tQDbhOKtJCX8PBh0IFu+Md4XX2zXC1QhMTl+P64VSBhFLFFUNYLMxAwzSZF0rzSzCJqN4D9rNK2jXng4VxBoIoOA90qqxcMpOzavgWd4txbzRsjbd/nDknLGGo9V1SXZFJfS1fizotifMQVHtWfYhEHI3UztRYUqeSzoOGJxQ14SrJOKjkNAG2lSG3ct90Yoyks2qD6sRwh7xUJRlpEMMhQ14U3Bs4TLbLbQ6UGsEMOVOCAuGrvN9BMZgQVFbNj2MHjgXKnCPXx1x1GEOidTOKkUOrZh5TQRJ2eEPiVs2fAUJqZIcmR+6WShkOclcgohmas13HDaopQtWneaQQBkQCQgkmJhVHu6DqwM65liBn/i4tAECSSn+nYw0HY1AqJHo0hNfULKwUCAMDx3VpJKklq+6o5nfjmjSm680ubTNKtyMBLcgotBeOD4gb5MXSnFFUWqiCCHnDMB/YR4D1nRFTuE4N/0U+IJJAS5RksjxTIGT6dG7gWEArBFpeKB63Q1/HPeuLqjMO6Q/Gwf1KSJWjZOhYX5D7bHUodGCqAxJf27Q9caW/XVHoINpQjFRYS7Qt6iBStSV6XAhHCW1EMvkukZFu/ZyqI5n3waoRdikBpmRsotiypPi7q/OO58U9QdgTCB7NzVWEElEVLUjGT0UD8rBpNUmQHgi3xO9QiaGPmUcKC+SoVKh41TBC5gCEuqYzFCGgGgNFCbZIRdfPJAk7B5U655ZLhs44iC0j7HWTAc8EbFCQaMF8CEQXyVbLIzW6heeqyAopQKVlaxKVu1hrVDGl6wWTMeu4J+HA3D2dJEBqnr1YU5g7Ec8qFFpQ1bIVmmBfYFwXpEKiBM8aDUXk51TZAZWHqYC4IaSKIxbHUNIGc47tg7OuRRSs+iaf1VYRF9MaIVBdUmlHKLAlFtciJiiaQBIR4wzrFs6ryivm8ilJBTkpAyPD9oJIKjM/larQuAGkKmAqV8O6xbWdpCSUK1DtoZv0mV+INm24GWLPAVPwKmFCYkpVQgwDVHVZQTdWwqKpCiZ7DtnntXIpnwfIeahhZ6bQompHbQjmz9LXLA8kw+90DeJXaL4lbr7gZ0CfGXrPCyj6gme6OlztcwJ5idcrxQlOVqFroVQ4ZvCs1edQomhW9XWiZtb+5WZIeH5wE5HXh/sSPc8xD1HIgLafjT9cHzbfoIhXYpVJ+MOmDNXxtC9wLlN7haI27FuEz4GcZPOtKMxopMIzYsquMcpfCeVgshkV+jBswOj3WtgenjUc03gewT7DW1qFkEV78Exskwo2J/gc0+TvFprI53JJ16mOJEywwsT8GNvdYUOP56lugjkcjlYQEUVjN4sMflXXu+PDv73nS6FNq+xxoUuF7yW+aPReEu6ndg4iEgrhmaEH+i06QOGk1D6KkLRcf/iA1hAQOuGqTKExAqNUE+JaWXoaReNIF6q7zVqRiHmatJxxsBBUHaWV46LcCkk7LKksDSXNr8AwDhjLujNM5Y0qtyxfRBuYcShwOjW0IxguMKJIFnG3Gyqv4WoSWCZ9hlGiO8DJzrAamgw90vw9rBo0UE2KqclJK0z6id0+DVPAsbpLSMOP4YqaOJO7tVZNrkDjPLlufocSL2y/Ekl0LnCdWlWODhacYs29RGUCSDOt4MW8IjgO/qMqxnhNqjgJJdE0dwLagRBMOPt9UoARzHwhyDGDvoEjqiQgd9Y1ASorJpqUVsM4zMlgniv2fjVhbrixIXcEryeU3i6jUpopzBjWhbGD0EaEHgxVy8SzVLiq6xjm2FfdzWVeJN1xN0PVEsBaImQa1qoCo/pC82cxqS+cO/QhKhlpxTISQUrE1OzgKvGCaoxtc6SIyom4BhK4Wn2KjqMSnOSHMJat/Lkl6VZHnjvsIUdHhUYydnWhlNFy62gf7iX70MJ3auesKaaSnVsa2DDE26WCpMcM90FoYn+VaGMun7JUjHxm2JQSxV3qxI7CCYdTr2pHhGVZGxkmpE46CSlTZ2jYmZ4/zBXM562hghvPZSSjhk50IIeQkjQFrVrJvDuLAyFFchP9oMpL3b1mniruvKOf0ccYjx3VkCN8lpUaQX60q8GiueeShOT9EVmk+WKoeNLy6Mm/IOw2V0NsmOcHJEhZiZoxJZ/WiAjCMjFfNZ9MQhThO3Xnj8TXmH4X8lXh/h6tx8KQQv68FWHMssolFI7rRcbt/WH9LM6hVQd57rn6vUo08driSnzqKLN9ILk0gTH7xUJOVeHF8WpVMc2gwzWuVnXXVv1uI8QsqTruHfoaCiYNZQapgHBckmhw4C1EGyGaIE4wNlSVwTx9uCTNT8RnDMYcFClaNY9zQ6u30SkHQYj3UTzAdlARoqbjjKpICzvCfdN8TgyD03BtfAfD+cyRV3UW1UD4fF91zbCw7bYRKZMgRigfyHSEVGE86iaEkkkVhLEayUVbGpsMSIathFtgUvR+KnlERSAI2xAaFhREmuwVRR6QExHnQ/J+rOXMeTOsx+icYQJu3VjCOl+AmkVJGm7YmBpZk9nz+tA2zFlNXI4cTKyUGCrKUW2Ke4F8krQN8PxVRTJUoPw+TZyuz+Uwt0OxgmIbns+2eaJhiExareF/WmSlojZFyKM1qvMOocQlJXO6GYJfYT4kzWmGcDH2vSbD5+ZIR1CHKZEWQvdC2GGl0p0k5g7rKe6JJhS3ZOmsltunz1wQlJhXuuZwAwrrn4ZNcx9Fq6+SbNNk8nyWaB5JgOMUeVE0XLTN1twdVTIT9wmqW1NRWcoEPpPDOKowubwRQEbMaVguX4ciGvdK5wrvFQjNQakk8zzaBGRyevSt5torRpXvrGBHocSNDxZ/sVyPADcKdYyzKEHYEIxDFZNNSw2VC5tDUVRwEmGpKQxsnTDFKJ6xHfOTzSc+91DYxAqg0PZUAotjU0M4qVy3ojwh/DQQxbg+zV/KYj6wR3AOTQOBecToALUhSNaH8yDsNLbfHA7HJDD+h+j3/w3/FmFDST4plZBTtgFn6wvSisA2wYYO7GjYSq6UOtDhpNQ+CIZNkQCpqIEEhQ4MXBh3lr/CZJKFYJjSKdWQKlbKwsNepfcw+JE0M0kyjRLmVsVFy1GrsipOjk3wb3XArQIT7RIYupr0FLu1psBiHiiQGMgbEAgoGrU8WSDD+BrPDyNbjUOSOpb/QWX+lq+Ku91arY7ONQyzoZD4k4YPnD8YVhrSwd3SYACHTlLCijuNamDydd2d5/VElXWoeIHqrF1D2LRCEckNvA4CTaXrWkI6nE93z7lDqRXxaMTp7iEICygVUA0R52f+L6tcpknlScxYNS8o19qlDNLFkseSoIzUZklYEEeOfk8koafhbDveHVUnhBWOEG7WVU3GSvm8kgdUH0C5hGsFeYgHCxzcuSEcjefXHVUarmpMkuQI5FO5HBLaJ5WR6ECaMgFjpi8kAqbhimu3HGKaa4ll1VEWHOfVZN2WqJxOOpK+IiQh5K0pWwJ03ndNvsyxAycAJKqWKefvUS4nM7qpbtNE+yQtdXeYCdORq0XDiqj20VLcqBImBSkbYQgjnzme7OFs1ZSgGsF7Sl7iHNz5RUiMJlknN6bKICgALA8KvheEAdqHfCIMocWaMKYEHoiEuZokVx0TVs/D9Wi4H3a3SyATNTkuw280pI/V9OC4dFXDOfB5quqUdGqfW90NN8UDYeXJVZWC+QynnyQykvqu0iTMWmiBJKKqCVhiHt8/PyRzJzkE4Pj5qcTg1r8lJXCUuKTDZUojvF7Q35eKtC0J4WogPRBOlVTeMwJMQ0mtqh1vQJRYGbnGOpaFtQmEIsYnqw1i3KwSKS4JYYskgkAY4TtUGUlSzdpslf5Got+1/0lqARpWaqFLdDAtHA9r3lb9+yhdR42ERgEAzCOsjXgfZBPG5CJNXKzV73SOBBUqnikge5CnBYn0QUDjHoNw1pAiKlV1zeFcCiRpSCzcFuYaQ6AqqpKDQ25VRJXoZ8imks4kAjAPF1aJBKr30Ca8pWoVVvLT/DGcy5rPifsSw9W1ms/HELoc8qwhUTjyXiHsHc9AkBiqKLUwXOY6Q1/acwshVyC3sBapshVtYCgfjsWcH9S+0rxERtwkod941ioRaDkA6etrCXsSQF1KnA0rya33Ho43E2KrIo4VHpEofkTXd5Ax2v9Uauraw2eZFtngOgjSW3MRUZGDPET63LF8V8xnpQRDUilPc4FxPdVcSCRM8B5CIYtSZpgx+t1IKc0vR9W1kgIgJ61oAtY5fk9X9RpIICCHZGdC3DMJOavAWmVKEFDjUuGYw2ZWCAMM+bbUduB9ASGPe1YhAcKcd1zLQ26xqu0Q5ZKiUjpSpZGg0ecWFT/6DFaiTo2wSBEHpSSITFUbasg8xkAIV0T3RTYC80ihEfo9zEmoFQv5rFHykfNiqBpGp7m0tFxldTMS5AyfTRr+avPEQjMZrt9erUrMOWfkraFUQ0gZgv2oBUVIQkEJG5SQ3DSkvTNPr3mwmk+KGzOpEF47J1R8VDxiswREN+xQnce0DWBrYF70hE03ttlMGM2XyOqOuqFEBZ99VisiskCI5tvkeITK2KIDHA5H84iIohKq8hosrcOS1ARP5ZSK8klNCKMtLlLfYZsWdnFS6kCHk1L7GEIYVkmNORgHVj4eBoom8TSlCPMGWFUoGGQwGDSXBh/iVjlMEwMzrKai4TgaGgUkyg6cb0x31JTQsVwNJHOULKHjoaQIDATmwoDRBCMJjrsaFUl4n+0U2lVqOF2n5aUIKiUmJk0qXSmJQUICxp4mr7VcnCAzcF4YgHBiGL6jCZ0pWUe+jmAEB65GjT7ujsNJ1WSpbRpewaTgVskwlrMizEiTfJMs6NUE7ZpziRX2QmhWhSXksVuuZBqNTzWCaV8HI5oKJRIX2g90MGC06rUnzoO1xUqEawlWkli6A26dSmPXiETcwmDshevVBLiVipQT5wNhHDbo1KGhE2Ghoug3JLSFU4D+1ASppi6wndDqdqoSnlYlC0bteDXHklYFpIFtai8kdsXnUY2L9wyvgWCBo655LrgzrpWvQlKqoEyAcwTlmVUShPNI439ADXIQFdhpBnGFa1DnGGQqnKEuJQxhPMOpLs7X8B0Y6bpLi+PpVCCEY3eVHLHQBlZw1NBGkEM2/xjmoaQnnZS5GtYJ9YhWaWJCZcwxDZvgLj3mA/pe8561D4sMbwrfbbnaSOJoyCbnMhwFJMWF4QDCwcIFLdRXyRhTYlA5A/Kgt0qgMITQqmhqImbmOMH9gHqqp9bYt3nEBOfq9CKPFJ0wXaegUGH/4BCtUka1iM5bqkd0x5whTitFRseiXEwafsS1DdekKsyk6p9Vj8R34v5u0mOQ3wlzWxN2W+iTJbkPcrmkFHn4jh1KhCE3i6p0SDZgLCkxNIpxByJjTKQHYcQdIqOo0rdVyTCroof2gHTBGNZcaAzzU4WY3eNETWUqLlzPPP17o8gY1jQQxEU9Pwy/w0LIDnMuWdJlKAsxNrD2LBApQ6kDogpt3qI5WZR0tohBhqyCtMT4gXLKlHVYVyxsDv2EuYG5pPcoNjihdhpDGJ2qGLmW6b3hmO8OihrmBlSSjqFkeE5pHh5OZyWIURWV6xA+r+pWjEGOUytZjX91nHIuoYADihSAZFPCgIpNzFcoX5SIMAUfK6JiTOozk+NTn5XsI4RUIwQWhArUqZgn+rzAdVCZbMUJ0C9YI0AQ4xk4GIp0MJk3zqXJnRnyCFJb83uVtgbyj0U2kGNNK3ayKmFQHFGBhH5nbLuS9lx7dY3nVLQcdlq1kBtMWDs075Ulk7f5iTWcc9zCuTR0ik6+FiAgETqaUmsrwU1FF8aJJs7HeGEoNJ4tOgfZ9xp2liQn175mhJgRk0UpS48qbMJzl7YH1VyBeERl3hCGiL8RfqmFIUBoMO+iliVXBXbZVDMs5CHR/MB9UEIOGzFII4C1R0O4+TdzWOqGBJc2zceJeUxit6hjUZ/bzM0UbBeLqgyKc1tHtdowK9zhuTBUDdskiarPBipllYC2Z6pV9+P9UxIyUanjffyUqzkp+YwJzynm8QJxjGuiSiHYCKHSsT2vo2p8tvloua8s9UFbh3KFmifP7EnmB7XNPCgeU88FezxwXFq1Xb1mhuvrxh/JS7UVLEeaKdCpyMYxGvJKh9dsSSXkWIxFK0Vyw0krVNcUgXA4HE2Bz1b7fXN6NosUF0fP/SOqCdCRj5L/pirvxSguFCndFwrd8Py28ZiTXN2x38NJqX0MNBK466OGHckpNUphvFsImVU2gdHMMB51PJhQNSTmTXI84CGOcs0lhFmpk0qp83ytrqIJu3neQDRYyF2SYJVEhhrIdDJg2CAJNXJgqPMFo78HxkRQE9AYYhgCjK9I4l1AmJU6h9iJRaJTGntq7OO74NCAtMBxJHXwnTDSLN+Jaszp3Fj5Zq0ep0nFmWPBJP8Mj4MRo5XrxuAEDYWwHDjeEnLs0EincWbhT5rslTvQITSiUsJxSu7BeO2cGwxqOEI07hZUd7Fp58KAr+ZsSvqVCgh1cpJFWh0BNZCZo8GML6gBTAnCz4BAUWUY+00deF6vhWja7qqWjkY+KxqloQJeyPsAww4HquPJnWitWscQMpB2wdAusMqV3c9Q+S8QdIEkDeFpFgOgx5EYhOEI5ZPmk6FyAA4t2mFhgrpzDMeEiVeVdKKDg3xGUHUhL46Sf/Ar+JpVNESHIbQIhJXuWDP0AWNyTJ10fB9UIyBbEUaHULYBkaFx8qvB0bR8KqqgAqnbhnlnIaFG5pqiAk4BlIhRxT4LJcG4YbJozeXE/sc5MEeVrGQuJE1siwS0VJ9p1T2Gac4PYxI7wyQ2Q1XFUK7dnAQ41CgHj7Ebqk4ySS/GDh04JYwYYqVJZzGfEQbEca4hoHB6aPBrVSReQ3A8yiTrrOIm2qhhQPy7T6Rbx9UI5gAcB50/cMxGYZTg++Bw7wxzhW225Pbq4HPYw1kJuUKS9YoKIBBHhShHFK5Dw2oQPpU41PY71hF1pkgKWc4mtGupngvhemQGNHTOQjMxx9APGkIFA4wqxnaRYSimMJbRl1BiWRiwqZss0Tj+tTLKuMcW9luKckiVtL39UUJ0VbyRTLXQRgCOM34HGYaGLQ6EAPoP6zsrBGLuVJRQ0tAnI4q6cM+RkF7LqkOxRqLFHOGg7oRKlOszxyv6EQ51qIhV5phAHpy2ECJNxUzIixZIeBBPvWFDwEKS8R2Q7kORxHmjhKQVEyAhjap1OqaZi0kVoaigx3w0GPt4VmC+KzlMh12r/OE5ZHmCmG9HC2eQFEfDLIcixhxuDUJ+u3W9AenLhV6J0rCBUeBzdI4SN1hDLU+SkTq6wdCJe6p523ANOHZ0a1ijQSKSVNJ1GCQ4iTSQOzq2Gc4LohGfBSGs7CE3hlQpzLmrya6Z77A/EDFcbsarqiiu52gO1tNqjkGOEap+Mc4wz4pSaYsJ3rIU8BweD8/ykP8ORIeFmofE7NK9XKRTw9z4jNGE3lT66nrP50xQRwW7AcrpkLcryW9VLkuZiem1AhtDrXEpUai35c/kfdb1hnMQaxMUSqGCMO8PnB3L82Wki22y8PpCkYmkGizvNfJtiua71CqNVINqUl6cGwpVzkHL2YmwaYwVhM1ZwRfd1GHYrYUA9mk4/6akSEWhK2wMhGwESsSYUssq2JKs0degNKQtoKQU1blWERAEDsJncWlY75Usg2qX/aGKYzyvi2GTMQn1t3B6hrmqPdUVqnHa5mSoeBcS2GNcsN3II8b5ohtM7AOo2/C5MH8SpQT6CgpZpo3ANSjBXVwkxc7eZAMw9AeePVpB1/LJsaCAhhUyMbypy9Be27xU+4Q5wFwl5XC0ingDPtiUUXJzzuNFmofO/jZlr242NkNKAcyRKtXzVwalUtrC5zaSojsOHDgptQ+CBmFbd1AO0fFUwxqTF7mFmGPBqmSpWgiOLHcu1SDD+wzFMIIAigg4aEoScMdNyaMkJwDUPpaMkr+oAQ6DR8P4mOtGnQEzqJgDJKiqaMypikuzslaNrGSnTlU4+GE+jG6pFBaq/Fwr8dB5gIOjZchxfVSiwLBG+6Mwkw4k1dakpcyVBENWFQ9WtYy7c7AbYUSqkYdwF5OHg8AaR9l6GHTmRKlCjMQCnDIlUgLjpQY+vsaSc/ar8ajOg+XfoWoIqi0j/zS8jvdWnQYayvguI494NUoy6W5q2/Io74iFHmiIBx1FkFS4FpALWgGIiiRN9s6QRt1l5S4sVDdwdPG67rIz54fmK9FQCwvHSYx69qkq8pJy8BgzcJbQTnPMLQwA7+mOKkMH1dFhngwY+qbisZ1QJT1AWLCP+wMxQ0JUkwFjbHRoXjLsrmIMMlymoNJ+EGmWzLazGr5GJ1t39KkkRN4ZtGlQZGQ4EFbc1dY5p4nsw1jRnV86ACFEM8mbRnWX3n86U5aUV3d+WYob/QTywDaqdX7iO5jrShOqW3JgzlkltZBjDPeXuW80rxbmGBL+lzTkkpEfmvuHvmoUcsrQG6iVcE2aPw5VyDSBSKh+hdfUScE9ZI4dVTOwGuCOKrFEZ1mr/XEtgTOohDkqRjEMR8OtqAqDUkSr7yV5n1TJMYY261iBI9u9KJwPZOUQwstGlEQqRQm8LU+TXhtVR7ieISVttPpcIg/C6236Gd2957+rNHm4qbOskt8ika7lgQhBPgSQPcy7h3VVHV0kugcZBMdzCO3C2qAEIUkzC0GEYWbEoKoDqaQyY6wnUoLhGkCaol+sol63nkvzsPFaQy4WOn5Q1kBNiLw4I1B16nyiElHVW7gvUN0xb5iqXCyBOp4Lll+uMi5lhFUyD5p+B+eH9Q/UPwuCApJqKuSd0hBz3j975mgxijGoaNXRZn4nOJn/f3vfAW5JVWb7n3Bj56ZpkkQJIqgoKoJZGMEw6oyjmAbEnEYMYxYVdMwBZRzTe4aZ0dHhGceAIqhjQgETJkwEybnjzafet9a//qp90g2d6Kb3+r4Lfc89p07Vrl1Ve6+91voXSQ2pLCi0KdoSfRfkAl4jISzrIlRE+FsDA9i6F5zguQj7MvociOdwM+N4pLTgo21pUiRhQ1XJk0SELHOYBOv+RxuCwqe9oqmKK/A6gk3QCfaCRJqs5NxfZUzR6qX8Rk3oPTsR214pUkpVxbhNdE1YECeqUPXSHo0DwPF4GDiJCVqt8R5cV+hXIv1JqojcboB00z0Cf4MKEYR4qawho1/FA9ShVAoFGwqEoL2TyUKpSkkWPLjIgC6i+w2VqHHPVVuiH5Ookz2VVkbsi5ODzACM52FUsKMSTrlUPH70FVk9mWkZpATuhWFZx/HoucOcKlW9ZWC8P++rgiB4ZoogRqYTx1Ignp1IQ7EJ9jP0QzxfeF40hoiQ8SATSURNq1/MVGog5oIlJBmthqEKa8oSr0Umjq9cEQ+VUkkesYKiLHy0N4uU4XMdYx9Z17ioBvuePzf9kY0cMiiK8XxdZEVzCReUSiKV4zeR+EllQZJzZZ/3fS2gZI4Q/MiZZF+PfCs0o4rFSA1eEpq1dKyC9os2CMtejDFEIobtnv1W1aSpPlZlSp4H2XJZFdYLhOTqexkZmwlGBHRYchsgqzsx0kFKjfcnpWDX57Y7yC4++//s95LBI/Kp24mQSakdGAxs5eoRBhcIlcRAUWHUHLTiwe2VznwyHJNEtxc5+SHFTtgUuAKnwTIHV1XVnOSbq6xXrqJHdoRW9ziI98FIZSOLCUJUzBG5UFZI87wqTH7LlVGuCoZ8O6q+hSUIA25faas1R6oqZiR5MMCPgOXhpOoPBji6qcZkvNwvDRAZ/I0yzKudKBlcJGEV2mNQVihMAEBGBPkVK7aYkOKLQskhwo/B36Eyk1ItrIjMHwJZAbm7hx1z8Md2kRokqcwGhZznhYQiydsfVQWrlUW0YwSwx0q3JgKEqujA+sNJkSbnUZkKxAjOgwapvk0P3XXiSWWvY3Apn19VfrnJ/IbK9lkDZaVVeqkfwsrAjLFQ12AfVdUw3o/+jBVYHk/k72jiHDkq4yBsNNFHf2NJbEx2vDIUyVdOqEAqoc8Mql0xwZOqhhNcnBNMJEHGrlMfwwQOxJQq+rDfSHnIfq6VaRJuCvknKeSEIgPxsdqPakZ4WPNvUQFwTEoOVZ6jGkUKD/wN4eXsj1BSaZDNdg3VoDKQsL9Q8kVpdM7mZEtlf4M6SmrGKEvOwH0M2mEDhH0Q5N0aWXmw2VAWTrEqJlfSUc2IfUv9ANcd+0XY3VToACpDEGrYbxBGUBHFRJCEqhRGJD9xfCBOVptNw4Z2hYgZDVZAdGCCRbIFFrxdvOrccMNsvVtAnfDCgWPQhD4Mcjb6MibpGPDg85CZ45hwnWGfQRBgwiyyq6x6J4sX35eoD0n2RAj6hNnkdZWVhvcL5Z7xgkEWGPrQhNk4thHWJ2XlldkJkVG1qwhJ/E0h8CRIRHLz2sB3Y2DnmXy+v6HAUnuR7NN9DGRUqAhYjEDV+VqxnduSKoAb9X37mw3vUxFsLMIQeS04lyCwVNgB92cqS1E5Z0OVn8d7MPo/7tMjlU2bCwMx+RfpiOIUtM9B2aHMOF5HIF/xOVjaQHQtc+UWlTq3Ju2M60vl4W3E7WpxHmkpUgEA7HeQcbxEMGG/zWxSYfq4PmA9g+qRpJEqT5I4jug4bNOJEe/3uq/QLikrPUkAkDvIGZLilqohkHNhdxrxCoQ4VzgOkOYks0ddwYT3T9ygqqX4Pt0TcC1xoQL9TBZZ9LnByDHEQB52cin7sL9R/Y6LJ5EvCHID5AqqYd5S5U1SBaxKZyRVpq3WhM0LijyoVpWXxLFCKKW0WEJ1DO7bWqRCW/Caj7GKP4OKuoh6Ka+dg0E2m2zpXAxSHlioclhgIoLWVSGUi0VRMRGqz0b3cz6UcmwLKQXjeU3lGhRLodyJohvxvIxMriAcI2srUaJyX0C0KEKB1x7aPuyKCgZnThv2U4uFfPZgsQznDUpJWR/LdkKmZJBzqkIZ4y4xq2V7RpXTsK2xyEXc77FQI2VsOnaKRS5GL8j2BhK18GuTOZWhlg4FM1RyZUYlJe5VlEJpG9TzOiyKkftYjkHCJq1xA/dDVkcscKhQgVdsjLB52WOp0MazO8hlEcfMA8M4D6r8uLco0xJVIUUeZ2RkbAqKWax7uET3734tlFIcO+JaTJTcXZ8XqTX1aysmfmA29DCrUeGI5xnGI7j/ZuxMyKTUjg5m1caqGn7fhSWACyhS8KAvszwq0sCBARgGNCKIOIHwMsdcXaIqqr0aC7ehMtSxiuUDDIxLFErMgZo+w/BbH6TWmql8GuWj9fdSURFB2OBZBrgiiAGOZw/4dqtVaXwWxIQP1goOfHCcGjTRyuerkUGi+IAzSJpYrVXlJSqHWspL8BuqlzKH+serRJCcaEJWjsmfBuT4XmZxeFWZgiomkUQYuGKSgRVWrhJq4kA1G9qi0KpjEFiehxVyWRAA3efM9wUElA/oNfBi9scUbYOx6krbFfaJGSuYuIs04PnzbCSfsKL8c0U+pcC+tMLiw4BYlImOqjy94WWfPYujIqmgXkAGDs61VpxD8qvgWt9nkSqc6EF5IpUfB6CeZ+GZMwgYxuegCIANAPkuYXWMfAlVMmS+yUqpjUAswX4mBVZM6mkhnajC3LkfKlFNNYHIHExay+wPVc4qrXz6d/RXVVzCvqLqlNvilN3GiliY9OEY0QdFnMFOg8kEK0/KDkbbpfKp+F1hwRG5xesGq96YuEdJ88hdCwupst9wvZAEFaEQdleQAaFQC9IrKhKSfEOGCg7QKzlRgeAzAp10Bc1C4cF9RmYPJtu3egA7J7iYXGEjmDSFOhP7hwnVBi/fHqpEEjVphhK2sb7KXQIRMQYCSjleUL2EsolBvPhM5CDMiOSKn91EAGGie41UUyulQFKlLBI02PZtet9GVeoTIULiCJaq61W1brWr7KiwQHAv7rsDZhNSzXDlfljHoWyf8ns26AekCNpvt2QwdrMmZ7tq/6SAigk6K9dgG7gnLTEbWaJ20arjBNoblmERVLhmuJ212gaOA8QV1HTXVPdO5uShvUHKIxdqsiKbQhkVJBMn57rn4PoIKzTvyar4FVmDESrN50rYwUFU6trDdRBEEggjkDfMFovsH9nRMdmeScgrTGpZTTQsf6Ea0fWiZ47bDKCeAQEGMgYqF2TSSY3ERQWRQnwu6p7IfcYbRITHvSOxfvm/PVOQfZ39XYsyrES3RAsPUd1UlVhpEYxQdpDRkWuI+8RMYk1SZdKobooqmGxnEfxUjqoACr8DbYfvSHL5RqHy9Mp8vqAhNXSQnri/Di5zCzZfjkxKXZPItmJm3iIWxPDnlFsgC5LPUrWKYPFIo8SyJQKDli6SyU4owLbe9vwhkZmomkFcMmtQlVMjK66OCAJZx6YnrGDwtj9LPC+yDEnTKn2QuA3mKvl5HKKdzZ/nUpPShierP78LJzJR+ISdjEqcEasNLpPCKpRFynuKfCU+70FkSj3OviMSiWMuLZCUz3iQfZFH5gHlTvwneZoaC+B5RKUS77t6BnFwhesS5D1Usho3Ue2lZwEX9BSOTgI5CD0fH7HgCVVYUn7BskhCEXlUWHRSNlfY5qjObiR2xRn11SCCQ/3kx+DKWwXVB4FKhTwWEUJVjmcuSD9lnZGU1HdR0YdrDM/pmtX1PT5GlFowMvAyMjK2XMh54yCzGeVGNQ/seL8qUZcfD6Uw7hVRzThBY2+971azjR/x8czww31sUxa2ydiZkEmpHRgeGKkBBh/smGz7gN/FSZ0Kp04oNyJsGEHUYDDI6msVsVB9ZwyeQsapVW8NMJBTg4GAB1h7iG3YvdJt+N+TlcwIQU2US/wMiSDZ4aLCHAfUyu5gQLmserGyypVJTC6mywDPNjUHd1+KKpYuh41Jknoqq6RU0ufLQFcGrler7W6hrKpx+UC3+jtWhb0SVCiBfDtekQeE14AVQZBEzhUH0VJaoIoSSRIQdMjXqM6nE2319vB7kAAcWENdtFSqAb5DqjPsI0KjlyXKp2QbDJN1oqus+8zMqqh6hzZejCMo96VSymBQjxV1KFvGrKACB5MGP5eoytVioKmyVcoQffVT9tu61QaXWCtsecwwilLoyjJCu4DEoNVICoShFeVKqecUibRhsK0IFmaxQLEjuxgtd2hbqZDYB6Q4jBDWMltEFklYJ8qqT5rUsB00meX7vApUreaqIp+cx2RG1xjngFBkSMlFskHB200cJ/YVE6PIjYtQbijCbvYVYwaJy8LDyZEmupbky3Buookqcm1IdkWFJGwfKhMQKZq4UVkDQmWRrIDoCzhnbn9h5auoRNiaYJA6r/eyj2ESjR2RVY/VJ0G6of/HJBsTZCkyoLKBWgq2vwlMatAOCGQXqQxbDic/IH/wk4bV3qgfHCTUBrv7QIZqP9iRgkwK1dOt2gaIpgMSZZQqAdKqBMXGqNl4tCMgEoQqK7xvRJ9dkoQl4/rF9SFVD628IDKx/1JQjoeFMCx3MekN5RX2684ekr5RuTP8roZIs4Y+e4v+tlxEq7KpMHlD/yLBtFHvQ8lm9J+lZhMHu22y2M2JcJIdK8xQuROkzEZZv3Btjl2qNlth1sJnFC4f/R39iP9WRUYQzrAHsi9rEssqc042eG6gJpLoR7zXa6IZVVZxLx7EdYqsI1j0QNjg+tG9kBbwsJ4pP41Kw6igBtWj8uZ439KzgllkTmYwQ5AWM1lo0QdZBCNUwiBoQWxg11Qlj5N9VfXivSMINT/vpZKI1nFZgXlJqOgGrWueXVdWpyTpBnUZ9g/fr/sdLKAsfAHyCESjFDVhTyI5PazFDVnKqHSVXYzflyiCUFGXx4ycPSmDgiSktVKqJhDh2Cbzw7CPEZ6uXB9mC6G9J0rVZ/ocYrVW5hm2lDGC0zLNe0NbLhCf9yAgpRQVseULGbK7MZoA/SapHMt+pMWiyMwkGY/PKheKQfCy7oIcR18qifMql8rJ9bq1aDdGP3altjvEVMSF+x0xAf6TPidLQi+yDPnsV7h3eqw8jnRxJjKj4pqQ2idIshhZMfNJhRRmQK6BSAwlceeCUFQPVAVJbicWLPCsYelKKamSsQAytILsghI2KvPxedOStS4USVG1b7o8nvb8y2RvMF6indrzCZ0IxmeV2VmgMqRyTstjCQJYhB2e76xui5MCpbqfPyecZNnDOE2WxxR+v5F6n/22vf5CRkbGJmLs3/3/A3ehosmmf282IGsdqw1j3Igx2F2s4AKe5lizZkrt1f771IVOSmXstMik1A4MkgqYPMZkkgTQ3Kc0JVlCERWV97wscxAkLr/vVMZwcEAbAQZwGHhFuLkURFEOHoOSJKuhsn85udOioiqquWHQEiuGIffmRqoVTu5XZF7JDodBNgbzCDanGkVVxVSlLlZqy0FgVP9iQ0R1Nnw/JO6DlaUgBkkRyB5V7hZ2htQuGjjyeL0tYpDsObFQOkXGhVbmSQLdaja50av/NbCiK6sLV1/DAuShqxxEgpyk1SFItwhzFWEpUs5DijdqgKiwX5aYhmIGE9pQJUn5hgk4yZUYRCfkXnqsXJGHMmeibbWkDEuUVN8HtpqgYTU41HaYsPIci6jkBAqrptonqjHwYIM1BhM72UVARDEMOSZxVXA+XmflRiqdVng/g801csIwQWNOiSpgDWJyJjUECRYMbjERAnmCAgOy1jE7aJH6Fq6HmHR7TonbO2CrBKmKOQzUXRECq9X4mnKASJphm7JiDIxafcDJWOY+YZA+I/URFWEqhc0MOK2KR8XCIOFIMGjyX54L7GfYZLAfyoCjMkPXXm2AQdY8b7QJIUvrZlk4oE5cLfJBapS4RsvqjJoQ05alMNywUpIV1Uo+7RjD6odRGQycE0iTVSIJcW4HzSZWKtwZK2fDSdW9yIRaaVbf1Yk37PtkkEadWVLIhpIiiOQX3ofrSIUHSNYtqQKY+aNKj6WCqykbIbaxu0/20S5QIY3jO0S6DaHvwlq60WwSpM6f1VZBQkWu2lSlBoN9EX2wVEgF0TGdkHB4DauIePkWvReZeiNu/cJkfGwvsylNRqMiJPs/FFPo6/tVpe1Z/a4wW7SH98/xm6WoEsEiq7dfj8h6wudwD5LqDduhRVvnlG2Iplsk8r0iczxoXf2Z16iIB1oF3RpFRQ8Dm9E/fWGh3HZYdjxdWaHZkbWGfh5FM2KRBP0H2wVZjgWIW1TBDgqUZSzQUIPShcQKSH2cpyCtRJaToBHpg2tgcsIK3B+aS/y+gms/iB+qaUE24zqMLKC6rt0Ja+EckSxbW2VncVFouuo3vP9CTYh7A/ZZldlwDnnu3FbN5wiyCXm/170H137YdHG/HsD9ZrIisakoBckslU8Zzq17bVnFVwqmWvLsB3ETBLzyfvy5HhYvkUoNVG3tpaSNrKUg8r36JpVWXAzB/dErGxa2hMpq3ldZLRWLWKNUw5DQoHgL5zyqUqpvKQbASaZQ4vjYxLOlnCjzzEqoGFH4QaH2JAehmJMCuREKr+o5V5JNcT1EhlJ6lEE6MqdR45G2z7q9vc59BAnkqtByUYjtqWqxVBRDQSobXITAJ+OQsv2pVF2kKANYPbW4FK592sLJnlUZW0lAMfe5hMZfUeiCz+rp6jqhaqqKdSjHe4p6KFiEBOMPqcm5+BO2PuVFljKrsJiKQA7FIhZlMO4hkYsMMz3PykzS3mptV6hL8Sry0CMh+qu7MzIy+kEFlSa+Xb3UPNhqIKOGHlBdd00pnngbgDUdC5NRpThIqeEe12vNitGnm238pL8w/Wfef8s7XHlvydhZkEmpHRQkTzi49IyW2sASDhzaS/uGRB8T8/RUa+AVFfMmUWkOE95RKwwWNkjN3dJUTM+4hY4DMNmiOEhXdTcNTqucA31vDWRJQkgpqLnAJEAWOV85xoAzIX44uMWkXoonSych+L/Cj0N6jpVtBiyLdCjl4qrOo6wqV/xECfiWrCZa1cZAnnk8UqZwFVmBqbWWD3IKVQTipMvzJIKQ47lglZmirZ3L0F1WNQp7YwzskxVk7BdWedmuUDwo64jWBazYL67yemBRoFAHwe9a1aZCDVabZVa0Flc3c45zZYWDvQ+2J05wFOrLlV5MSjTIj9VqqihiwA17H0JdY5s4/3gb+h1WMGPFF+83WeZUjVAhpaGk8oGugu1La2KsQEc+hfJn/CCVMaXg9FhdBwEBMgsDf4blQvETTYoBLdoxFGewfYoIYICzV50s0G8Yoh/5JbCvyGqjct4+McUAVxX7SOZhQo5/+8AX/dnfWziBGJM9TIYpQVYmGQk/VEPC5EF9D+eYAccK16bypLKkVPugSkVULzSqzzNTJXKl0DZof7R92AQRduy21DLEHuoThryj7yvImpMo7PtMe3WpIJsiLy36kwb9ZeA9zkGoAkP9wrwSWS2oHvIKSGWhBR4byBsofpCFJ4J5GMocBJjf4CQC+gveMx1VOyOnB20WKrNdZeWVnZGWJLQLzudisyHkUMXk8jrZ+HjzUKcJlSbOBwgnXYflhFcZUvz3uH5AEMEGhjyuugZe1/p3TiogH/s/dYXIsOu1P7EyKPKBZBn2Z0aV/nD/iAysUEuNiny6Vp/BNnT+fRZXkfr4/OgSz90aXyyF2HLPYwLhioFhKDph7cJ9B/2J5wDkBZ4HUP1hdyOwdJnUNOizylWi2mXMj5FkFSbS2CYUQE7I0OZTEvxxzwuLru6xpX1HxBnUnlDv0W6q6q+hbmL7K2g+yBcoZNhvcawga2PBIaqyyTobykQSzlE9NRQ5AslZtHUQaCCpMLEH6YdKfyAOoQTVPsOSRyssrh0ok1A9D4QSnk1YsIFNHdcm7r8Ihr9NBNSMVIlR1AD3XhyaKpNSJYL93aiCDYtU/QzbHXeimko0EF6ypKO6YIRqg1Bh3tsuyt1r6JoPZZ8signJEcVMKlt+NGPRnh0YuUt4LpYLCABInZClKAOy3GbkGEVwO85XkahoZIGM/a9jHKPnCZ95TmCVNkmqK3F94zpTKL8qhHrWVYw7GrIZR6nxac/1I9mKtsTCi3KyuKqvxQEQU1Jcp/2DzzGOIfQs53OyfXHG7W/RJu05j2ExLajkxgKYFvdAnOC64nhDZBAzpSKoHoSpE7lFc7EVInzLZwSvZ+Vy8hmloix4rmCCiGdxWdlWbR3OVC4O4jvH1H4I8Y9tV+O6Wm2wImBhSVcF5zIjlFEHrk6rM8pgwIlA9F+oAKnABSkqUpEKiqjSF8S1xgMkkkGw4fmJ8RGeT3juusKrPoAFumqc2wlvGxBoGgemFqSMjIwFAPfncbOxL1T3hOY95v4YSal1cyulyJcfa8Xgw8zWvFAFHi4zS0iuohij/Tlj50AmpXZQcKDHiQFk81hJwmQMq2OYDIQCaVzEAxQePhl3RK5H3VegaD1QmV+VDuagjuN7BTjHaigtbqMkrnwQBDuGv46BC7eeDDZJfnEgGZPeTrY8wi9FTDFDxKu1VaWK1U0bWIVUFgVX08LSpCo0mMygDTARYcilDwpbMQHCwIzV8TDoUyUfvJe5HGqvmERzcC+yIyo4wXLBKm74zLAVzaW+ehtk2nQLuiVOSnyflRfBbWtAyzkayJz0+KUEYGi5VuaxastB6Wg1QS0r1CS5DLJPusTd86bSPuLjRZBiWM3HXCnUJfUqs4GECPZBqhKeS1kwuMqsiQAVZagCpRwgEIoguUQqcl84kcUDCU2pYGc2n8pMJxNBDnJpoXA5f5kzE7lMtN1E9tRARbCRUAFJN5JMrHB+ZMMMJWBYJjlQVxlyBngrpwoTW2SC0Q6DicJUNdGg2gtWEigJocya1MNVkyEelCo6Mdh3poMMwXaQxVQoX0lZUlSEKJeKJCTaEjYcBbSzkt1GP7e8HhXIz6wU7KdC07FNEr2RW6IS7LQdgdTcoAEEyAZZvLhvsr3SfiWbCk9W2GKcSPTzKQUGLF7sdz4Z9bmAr6AHuVxeY6Gg4XWEIGnkE82YDUGZokIMvF5UxGAYai8pbNCnJm6tlGNscxDQ2G4oBWATAyGp76GNEhP59WYTmKxL9UnSR2XBUQiCFRn30Wdw/tAmSSVHnksErUt5EmHFfB3XRVw3k/odShbce1GRU2RmKJ5aI2aTCOUGeQaSa21H9bwozz4gckvniu+L7KiwMu8u6yD2C/1jUaLew77r+kUlLdwzQLpQ6SFVIc+p7GpUNTUrkpVEqYg3KP84KUUODa4R9F8R2yzUEFUp8UwBWagAcBLnCnpmRp9sQk1k3NFvpYBs9Tvs3wyqLwaBGOdPaiQGTyO7bbHVhrDQgs8pdDwUHnWo+YY8jJn9XHlyXFzQdU/7c62yAeHaGl4lRXCjLceIuXlc3AH5i/bEfUlkLO+LaB/ci1Qcgn1XqhHuk0gsEhs4zyCA1F9ish+EJpVauI5HrTYw7FUrScQoI6yGiTvuqbgm6maTWsggEYKvgAW5IAmL3EUuGMW54T3WLYAkPqjWcnWVH6gUKbQ9gXDpNalPqtQqGzDUQrw/814R5x6vigQk4cm7Qfk8Y/uUBSCgmkZWlcYBBos/3i/1EEi0WHgoMzCRYQjboOeXucIJCziRn+lFTjpVMMxC1LO2zBHzAURVOAXfMbJapHsUhQmFoPe11N5eonL0aVGm2UHeoVmUI1XaE9U/Qc5wYadlBSqHBsnFZyCaMu71GjcwhxPPg8h1xLMP9230rRhreV/079D4JZSo5eJhED5R7Rj37ogAiIxNt0WH5bIimtLj1yKFFiZ4eSgjrgqIT1RhoVQjWYx7kRYHo+ALF7LCch/9S5EMGFsg64sEk1cIdMJR/YCFevA9VWVofnec91LhlWQfZmRkLBAYv/7JySLMD5a9b36FA0IVNQ9Syq/fmhXNQ8ymLjKb/oPZ0NHJLuDZnEmpnQWZlNoB4QMGkCaYVC+uVv1JpmDyqvyR0gblK9ZOEOFBj3yLIFNEFNGas7Qtt4gKoakYNEf+h7KjYhAQNp6waKUDhMiM4sRZA+0y5yg9Fl/14gCLJI+qB5a5NdUEgtXMOEEJm4ZX2CuteyGvT2TuzE7g5A0DbAzilZVD+yEm8iDgMEGbqSb0OG5YjmiRUuUdfmdkmGDlc621aKURQYgJA6wQ0y0rSPZEhSJZmGiVSYNfuXe+f1TVxGjXpew+qMKvWoln5g7ON44f2xHxw7yfka6cB34PbQJhp0yk/xxMsl53mXHl2RsijETMsZQz1QAilfj/ejX5hCqqQBVIL60d9lFaP8NqWFaLE0EZYHYG+hcmg/GeIgmVrVuLZECSOcGBt+wA3H9sCIP7IP40CeRqtCr8cUAv0jVKW7MaFgKI1Q60FCm/hGqhIA5FTFEVoSwsqhRCyeIrsy0q9EAYDEs1IMUeQ8RBNujBTJsd1FGq6ofjY74JSAKomvDwFUFUQ4l7+PTRDpqYY9/ZbiBY17iygpW3VF2Q2VYiLqEO4eBgUJPcsGVIdUhrg2xKodaSItEnlCK6QPCqMmX0pa6KnD7LqfpZVKTifFz2URJ/smSyn2HbQYiA1FVgexMTcw/xdWUFVCs3VSolvj9yzxBWDZWKKjeWKjkFPFPxIsUIyR3kM6FtsR/IoFknNRHej8lunFf8PqRtRCU+dtpEYRUqq4lquySWWiKkoI5SOHQQldx2WB+rzBsFgImgGtIP7glQOqAP76Z9wz1A6rzS+oe+IHKviaB1KU7CyguiGCoW3NuguKBFDBWvpCpjXxCpSxsp3g9C1G3cfj7Rf3A/wXvR/2WvKytUNs3GccyRaxMqGrS17gVcLFC/QV+l6s9zZxBUzXMHWx1sZuxfspej700VmtRj/2eshaqJ0Y9Y+ADfJ+su7zcg6taaTa53tcmoCLky2NvvlZ6HJDsbCTQoocZlxQMB6gQWn2Us2rakKiQhUQvvByQAQ0WLjJ5kAYh/gwUaz0AoTHwxgM8GWsZwzeL8eOEJngO8H9lIINNIUAdBqgWZ6Nu0bKsiH0lBqSH5jFNVWCpt8B5ZpEqValpVNRRGyeQeimW93g5/buhB0aZQojKMNmK1D4lzLOSgH6ufR3U9ft77Jci1etMtbSkZ4gSPvieyv3ivwn2jXcmUPFi00AZ7uIo/SMXDaw0KUhKgy6zeHLEWMtZ4reA548pbX9ypSBZvM1S783ywaAcnY5RbyUtbGXWdi28xbijVwIkFFeeXhSpwnxYJyUUajNukaOb3gtTHPbHRRrpVbaVrlSrw0WrBhgsmXnEwFuriuCJrM0icqk+E2kvXYBSJQV+X5d8XrtzKmI4by34fxVSCwYygd469sF/WnTfaqFsL+87xxySzaRC6HvEPpcKf14Fb5UkgciGDPiNVGsQ+tW87IyNjEzDzV/9/8zCr9Qor74lQWeO5r0UERnXMgubBTkpNnG82elI+VTspMim1I4MV1iDTByEl7z5vAqqCQ5l2DDagmtFAjcqgAVVrw0TWFRbdD3Av0csJCHMnvNJJrFL5Kt1AReYkKAmvCJtlRkVl8Qv4gIf/SjIBMIgXMcXVvirDyAkUqXe4yi6LEzOmNNmgpUwchgLUuQKIijKcKHtlrmqVU9WwmHsQVerCKhg5OJiURQUYrQrze7R6H1L0sDkpb8crTFUVoGJw7JN+n1Rh33zFsTyxSftgLAv1jyYhsGtxIBaTWU3e+oTas72bi3wFEpND2HUYvI5zOyACYrJUpbiSCgNG9KcIh8eAHedwJCF/QPykA0zIbkHAgdiM1UwppDixwPlUgG56cLF6i+8ug+xhs4AtTHksJCEi8wRtEAH5UXpb/YeryLLDcAAc/UYKjzKvrE6FGz8GpR0mwyB4SjJrtCRsENDO88iJjUgzViv0TKyS0COh6qu5viK8oVqx5mq/KohxcI62DlWinwNXeYnw4+qvvPzTU8pyUb4VJ4HYPo4FOUKYrCAYHYOACAuOCU9kk6ECWwzaJ2XZAvGg/KyY9OKcYlJONQf+vrhUWJG0lSVTvprEuisbCPsNJjj4K+xiIvCwT7APDY6IDFegPs+TVHBQP6FkOu2GmJwj90ch7xOaRFLJBNIA6qHo70HMYBKI69pVGBWhJGUUJ08gTZSdgvBvERO+DWwfr3mor1voZP8rlVOLEtudqSoe1Eur3B43KZsqwsZZpW6FPgPiK/peXLNhIdyg7S1JquuFggt/R/ECvIaBnRSt3KfI1gprLO7lIClhcwTRuVb7Cjst/g7LXSxWJAo/2NhoV02VFFWFTyc7Ixhck3sSi2G9Qd+JjB/c61VpLqpUhl2TfVrEKK853FOW8vcCpC1yy6B0AhFDlWil1vD8OFgNUfgA28CFCcWQyJGw/pDg4MxWJCmITWWvcR9EkDPrRhYtzoylUiUxpsIXfCbC3uWLBJ6Vg2PSMYZiAwpBqrdwPS+tMuOCWGGmnN8nWgi/BwFC62uQc6rYiT6DfZi80dtmANevP789Xw7tBPWMKgyW1x5IO6lDea9XXk8UaeD2FQau0HInUyKwG+QlyCcQOKNWL0PMSylU27M6rF/+WS18kUTRPZiEGixwo1qMwflCxtFGJ6yiEmlkgVFR6vsJyx6tibj3RkB9KH+m1lvRBOEApTbslCAd+hEOOE4/Ds+QCiIZxBkUWsou0nMWz6sW2pq5TTi/alfa6kJFDkJH9wblQFVyZ1WmhCU8bGZNz9byMG49y3g+0EcjgzN2AX1TRHCpZE6qBcfCHdSDeJZTFeW2doyVImOMbcnzXLgKrywkE9mYFSFVjg0i2L7NCpeqi6o8UF4HyPoqhtWffXHQbXu9xh9SSdOCi3GmquWRPPUy8SQNOTZMxzxNKzDmxEIRFsbKqsqRKzWshUbZ8snHqk3wCwnfuYr8ZGRkzAsziB/AJY4KxPNEqZTC/TyUrbKr9wOUUkDrRismf2i15qH6Q2SXZuwMyMsIOyB8cOG2Nid6lKvDHAKvplXDKmIdg4eoPBPWLwyuwhIV5YjdegHVTazA+Z9lW+Dn0ip6mLDPqErMREJgdO6okxEM9mwrDV2t0Poqm8r5Tq631kZkyaytchso457mfrksH3kTIJmUcUJFElY6NUhmQK7GciH112ClXNXkeAXHEBMmkGqR6dAwG1ppNrTKbAA/K31ywtLNmEhBpVPXJHppRcrQ1ojXQiUTk8+4xGS/iMkIcx9uYiZKVPgrpfRdzegZMF4JSbkqERjfGOJq72yDMM/nAimhwTOr8Yi4QftQPYFJQliXgnuQVQDHylwikCe3mE1cr9XbtMKR2q60K4AgiSpYaP8W99VJyLAU4KNadY3gVA7uEfB+q+xFCBeG/U3V+HCeGf4a1T2CENUAvpy0NEXIKOdIk+LIOGM/Z9YWBrr46IDZxEaz8VtkMXHyD9ae0prAiYRfA0Gwsl+yTTFYditb1YCuvOLKNXKRhqCywCq2KvWxQpOySaB4YLaPwpIjkBiEEjOUdBzY38lbnDAdRrW4VX5uEN7OibUm/FQYieziceLzmHhhn3DuYpIa94EoDiALkoLwnejCeQglJraF8uvIfauu+XIChesq1Ccg2WCzHIYyxLePe4bbcDTRwv6VFTAxmVP2DW17Ki9OWxoIoD1E3GxIqtgpb60MBh9LAslHlae0QuG6G5IQcfShUJnic64kcFteEEINEVUgwXZNMqXW6VihvLqTZ1ZRbYp7Emxiq81G9jAbOcBs6C5mtn9C7ta0rQP0f5BW2A+p5pzhEcGG7wEBjn3Cj4KccR5R6p37H4oMHKuqNoJcCSKfhR90TtmPoXJCH4MtU5bRsKwyN8pD9N12OlktdpAYkz2YZDQOBe2sa5RKFpBKyKUaFdGuwht4P8mvQe0PSIGaMppg8bzNSTTc9/GdMUEWGWEbb6qUjBPK5gllKwP/odSKXDOQJIOqyonzsC+vEZADJJhDtYnvm7jJbBJkl3LrQJxCpTe4iwj4UBOKYCpzFSeZpedzehyf52TxctK9qFIUoqiHPwN8EcetuH4PClu0np+sIAc1GK5zXYszY9ZSCLU/j13tGQsbXslQNtu4brjYoYk6zz0uB/QNKOUQvL/OCh43vg/3VJwH/93vdyrQEWpUwe2Kuq9RsRpK2Epl4+SYW9B8f0ekBLrNbOoGKfFUsZEZelK1gZQCeUWFNPYJqkksdMj2TDIV94gW1TS+P622fWtNb+T9mPdnKcJ4L+LjJqoLS62NRbi0ki73ye3RXBThwgIUeLd62/BeqLEC7y+hPpbamv9WwZaUTKtukF6BFOeX5xhEpwhUXo8YO7jFMbK0/BmD86AMtXLMFNvE/XhMzyDZ+9CXpjY46R9kVJl96WMethXHeqoszMqUY9aa2mgtnAMtMvjCi8gojjV9Eajqz6FW7bTzhHpMC19UBWNBI8izWDDxioExHvB9SwL4yyIsQZpJQSa1F561PM+8n6iQARVvlZJ/R8YHP/hB22+//Wx4eNiOOuoo++lPfzrr+88++2y7y13uwvff7W53s69//evl36ampuxVr3oVX1+0aJHtueeedtJJJ9k116DwRwV8X4xt4uftb3/7VjvGjO0dWHi5tqqwN1+k9j3k4KZKqboK/HSigQIsytyc+N/2fcjYaZCVUjso2leWFEJKtU9k/KQEkKq9qWJbFWYKMiXyS5QVE4PlqGLEym2SwJc5J2mORQxUOxVQTpZVleYqtMnGtcrmFcwwSJaqA6vtzOYICShKb4dc29UnHtIJUgLkClZnkeckpRTzUCL/RmqsqBAECWpU/ZlAGJ9XTqo13TKHgVCLq6mayGHgjMESlBAR0tvAzTYJdOYqNSaVvn+VOk3kA3IhwqpUrio76ebnL1RJrsJpb6tqMuCKFLfc9WrTsGH4yrpC3bmSjwlhrFyLMGCJb+zKUFVKnEovtLfbSSJ7xSvlYRcHk/wi9AtNHjXgdAvHVEXCceXXj9f3UblaDGVWzozIVZaNphJKEyyO6VW5kBlW0/pOKJl84M6JVkmoYFIg9RY5D2Q1aWUaWTGh7CjtHTO6XpRzVMPqLQiZCX1PlV3h59fDtdvsqbRWRglqHSntmH7+y35A1YRCeanMQN+SUgITDkzSSPLJdkVSBhN3ESa0DA21W+NI5g20B/lTSSe1F90yICk0scHnYElCcDVLasMWIUsqCQwp8koVYORPoe2wb+pLQUYyV0cr+dxnVT3ERFhZJ2WGC687WblIFKsyICeeUZVQZC8C6Uloell1EhpoO45toGBCm6BK4R4K6L9JyqMp/U05QyR5QPzoeiNxM13lOrEIAc6lT2SqEPNQSCknqazEFwQWvgvB0yKyaSdNSOEoxw5CDh8np6Cqdfz+sPPNiNiKinw3JQOwaf1Ef8f2FdJM+yjaRcQOj1fkPK9FrEzi/0tUCWfSbOwms9paTX6V5UK1lOzMPL+JEoSTPLULryncExZVSkraRNHvVOUsMvBgUS7GrICFmeoS3afi2uM51u2CJHhYsBGmHosMmJDKNgzlHq2CspcOItcP/Uzh1syAkhKIRKpUGFCV8N7Vfp+Me5mTtapsF32VSpXR9up9VG9iEh9WRrdGlkphvt9JoSqjZ5ZJcVlAQHbocjHH7eDcFqrsgdzjMwHX8zhVRiROeE2hHUWasNgJnkd4VkbWX+TySV0SVRKpWJFqL0gn3hdAwEUBE5BSUhHrmKqKu+N+H2P+UNhvR8pqnez6KvxQqnKao1a0Vjq5znsAMvGwOAGFt0gWkoJRrU4FEUhQeYEOt+xFlUcovKN6YN1aUP+FLZCZkZPWouVRi1SsVoi+M9qtAE8U2D4+ivxE3XtxzSlAnJWE2Xdxv/WFmFR5VOCaauF6w//1/CP3LnUP+xsuaVUxZUU5EUw8D76AxfYg+T/mmV5YbCChiHtlFCfRvau0QIYiKiy4snPWFpeEmY8FoIiTMrfMuJMlPvKoGotUEVfPcX4G5LLnW7VfS77P3RkzeE3EdlldGX1XbR9B7nx2QLk7aS1cR9wo2qWVPHeCsCo6srDCUulKwKgU7YRX5CLOI/tmO8XnPvc5e9nLXmYf/vCHSUideeaZdvzxx9ull15qq1fj2dOOH/3oR/bkJz/Z3va2t9mjH/1o+8xnPmOPe9zj7Gc/+5kdfvjhtnHjRv77tNNOs3vc4x5266232qmnnmqPecxj7KKLLmrb1hlnnGHPfvazy9+XLJlD4ZJxx0brBl3WiBCYD1QMpVRKBSmF++NKs+aBZpMJwaqq1byuR59ktv49ZjNXb+GDyNhRkEmpHRjx4C1XXLnqKoWL4CtPEQiJAY/sK6XFQavLnKirBLfyGDwgOyqmwVKFlbywrsjCxfLXPkHuhTS7IpQqqWw8MiTKrAiOpVVNJixftAzESnDYI2L7CGqOFUcNUPle7B8mDcOl1cpX9DERSiwf5URRFddKGyG+WhlaHJDjezWBj5VtTzXVANAnXDWSfKGi0aoqrVlS8Uhlw7wuCowSq1u5ItjZfmlAfVSX8ZVi/3urDJBlxSuSS8odK4k1yNo9G4gViaD6Iqnmq9nI8+A2oUyAhYVBx5Xd0vOpRqygXUxECSaQzKLByq8HkEPa76ucERIfg368VSvhMZlXAHN5fhTC6+dffRgkGFUECown+YP+EJXeIl9CljX2Ea1Qs18mgapBThJucfVV5Lq1hqAiEFHAIOKYTAfphlXZKmfEodk1ibWBZAU5SMm4BjXxZPSIBv+xfU5Mw9IhUo79NvKWguSoi+zyIHrfJ69+6dcvspjwuk9A/TyLIML2oUJB2w6tiL1SkQN8VhlrtBTiPIcVIiyGYUmMamaa8HLSgolxFEuIYNsJrY4vV7ixKjCNywqDCRL7GyYQIHthe8H3gujcYDYm4o2KxEWVfYus1E2V2oilx0FSRSWm4STAfEN5nJ71c3MSKo4MKQT/r9b776pA8rDU7Z3Y7kBUYqUQk+0lUjjhtVVJTooIpPJc4P4gMo5FC3AM+4qAwv3hz9qPYWVRrdJ33ZJkUI3qx5WvftzoDIt0PYCQqqqg+iQzVEayI/PYx7wqHifAN6gqFwjLpWYju1bFMEiQi4ikbWaDrhFM8EFsog1x3pQp08Q9Y9BaVB7FvRB2W6lBINnHvWhwhZOfsZ8kIEEW43Poi1AogejBucT+K1uN91qpMamwgi1RhDKUglzBBZmC3ZRVk9eEKt3hOihtlu33U7fiRuU2WPSiImiDaqoWc5FC+Sf7cVSypXUwyMrI0ml0Wdx6TYhL+xufh2FFkvqJE3GQUVAVLqOyC/2ggIJT1UFL4iTyOng9qn9QGYp21P0FNs647/FYRYqrMp63K8jNpgoVRJB8EDbtk3+SRKHWTFRCnSIZti9IO+ZRScnCYhi6Z1BFXOj7wmKdWq9QPGTQWnX1cd7DosIc+p5IcChCWbxC2XPluRbpzftWkD2dsQG9A7BDNeQKtVDBYVU/tQoyE6CySFdHrgqgUjrFvScy6kgiQvUZtkiNY8KWX+5LVEz2a4AkGS2Wuv5AwqldCzzfykwrPS/KoPOq0EvX+IKZc7KhljuL85P0s3h/LBQlJzolhHr3cxWXod1Wi0o8P9i/WPBUZiHHDYo9KAuc4Dzg3OpawTUnxRar+vGeE20rCz+Vd+rDrY3K2GzPL92R8N73vpfE0CmnnMLfQU597Wtfs49//OP26le/uuv973//++2EE06wV7ziFfz9zW9+s5177rn2r//6r/zssmXL+HsK/O2+972vXXnllbbPPigCUpFQu+8OdXDGzoRi5jqz+i4SCug1LlBjXITLDOOUeSKCyQuo/OW+ae5h1tzf70ltb47nafIdLYzVyp3YtAPK2CGRSakdEFSccBDnq2w+8AgbTpRljkFWyKHTB3Sy+h8qhxjccUCm1UmuYIuYaSOCkPs0XJUZVlAulC5pCWQGMnM1MZRRvoJWHYgPSDFhYdZMbYkVzLFxa0Q1sU9WYnmzczuFK280MOFkXDbDyNrAWCUpnewLdxjsaJsg4cLnrHDc2KbbNRL7AvkHDfy5aqt8EU5gPG8FOUUp2E4MA9YKNrNttM+ckHiVGR90xhgQyhysdPo+UaLew5rHFVhUaeOgO4KSI6RZDwEOvJX7xUGhBpecwIAAwE8Sbh7h1pyEObkDS4R/RhYNtqeXZmZVNVV78okQvhdh705m4LyrJZyYKMlOhb6X2SwapNLCN0DFmu+PZPwYjA/ge4etNrBIhB/aL8qce86ZD1BDLeIqNOZPkPhTKe+YCGrAjcwQrrLCFkB1Hq4tTBhxDrAttT1sI2nfjapz2CcRblBThKU2yNbyeUpiCecMx40P4NqS4jAUVmgLWlU0IaIaSpa9IiVhpZIgiZdU18LqVFNB7bg/IOOEViX0PbQ/SANcWONJ1UOs7KsKFCdMCoxWxbGyelVk0kTwMPO+RMiwT6hSIPucq7rc7gtbzqRbMlmpTaQl1QiqOEWCNtR2IKAU0owS4jFx4aQ4+jeO/Taz8agIF9lRoWbCwCYUQyK+eE1E9cS4FyrAvLbSw7vtam1jebIt5ZFxWwMikVYnf1c/KyuRjZtNKGwcCqWS3AirXVTkG5Md0bTv2Odl+q5d9F3XiExLc35EDozHRG+pPreqCn4v89dgy8K9fYX2QaH3rI6Ic3KbriFYZNe5XbKskhW5RFHIAucD9jmQWtiV5daqLadKxhWOIVjCOZSytOHXkasidX/gc8CfUTWqoiLTT8rHUrGrwHQR+V68A9tZ4n0JihO0L8hWHAuJqyGzYahydO3SLorMG7+Bl9dl8BHcrkgf3sfwTJHylUqXWDAJAjmImXp5zw/Ldbdyufv16m8RDi7CJapW8rni6qXy+V6SJ25tohWeeV9QX2qRhgHwIp34PAMpjAxFkFpJntDAYmuhTaFOLMPJlaukZ5cXuEDhjBkntXnuQ6Ej0iBe082Nd1vlCLriOSruRWGRKAbg9zS/30t1SQuerFzlPVMqNKisaM1CH0ZuIt4SOVm6hmM7VL3KFsqKiSLIMS6h2jW1nXl7uO0tsi9VeS9C//lsl5qNBTc8VL3AWAmKNt6zwqJfqYZ83BFKyAgZB7lVNxuAYsor83knxOtJQRMisgv9uQ2loaut8exQgQ8sGuj5g+/nc4fPTuwngu+lPi+zLfF35RdqbIZFizLYnOMUr7QJe27Vf2OxDUQj+kSoAZ2ApxpYRXA686r8uQaCWWpdqEZJkuK5oWcJFWORkyjVFIOUo0hKPN+Uk+iD3Gr7GGM2cF6brlQDWcsCLFJkRn/m2AKLRjvGdGdyctIuvvhie81rXlO+hr573HHH2Y9//OOen8HrUFalgLLqS1/6Ut/vWbNmDc/Z8uV43lWAXQ+kFoiqpzzlKfbSl77Umszl68bExAR/AmvXel5rxo4Fjo+nrzCrI2/0oOoP0wo5Z/Zf2O9QtEPqp0aMOzpQV58qFU9YGNmtqqTevLNZ6xqJBJL7RpBSxXorijEqarN9b+fCjnGXzmgD8wJYQckDmP2hrBVsPthDeRID6hiYapWYtjl/ncSRZPFUNdCaJoYEVWhIGsQA2yux+L8jNDysf9WqvQcZRwljlHVur0RTWdIipNeVVKktyve/+j5+BgNCDo6HuWLm0vCWLAtQWyy1WtMJpQg49ypqQSwh86Sq3BPqGScvsN8xSEbVOaloWPp4RtX0VL68gawuDAYxkMJkdSqpzlUhLJM8NxxEIfB1nRb8ZfnhBB0DeWWmgKwIogKrtD0CzHlsk7CxrPVzjmpVJBiSPCMqhKoVCM8gS5RpCsKPc+o2CuXDsD00qVcJdq/mowkbC3/BjiFCagB2MDyocH6wT1A14BziXI16VUBsl8H6svuEPYYDXA9Z96D0SSfaylVrKXk4gRxpzzZJwltbnGiHpUVZJ7T2yMYIpQetodgOJm6aGDHEVkHrZUC47GZU60S+jechdYfrYvthwakn10DYU2MiFpX7dJ7KSpYhX0b/lpKPkyQUMdBgm5PCcStIKMFyhk3HdSe1AFQ1Ddg6m94+E8rlYqYPcoOkJqCFVZXGIoCe50G5QAyqhnoEg3jvT7QuRcUj2E95W0HwM/qDyG1MOkriqqro2IK9jKv8UrAxi00r3Qw11+QMzTWC7Cf1Q2bf3KLKgGivEZEvGAyh7+L+JwsaCR+8hgHOdBJoLhvddISVN5OMKKl0mIsUQeeRIQWo3/Gchl0Jf5eiYxCEmVSTJO5B7gU5iuNUe/J+EoobtAOA+2GEA6c5WK7KcAIsFF+R3bYksSVGbk3kaKkvgZiZVsg7CdUgENZqe7JHDQ4r22aDWyU5aVaeDm2fuBbRz6DMgLVZ2VMKUfbrK6qyVsoK3lsiOwrqBio18QcR25GJVyB3zwtfxL2JlumiUnnVmrB3aTLOJtQxYj+Z4aXzNn6NT/JH9rTakIfXo7KmL4T4/ZxByeQeoqqlziXvgbgmkXmEexNy0kJpyVl3UowBbYMfkWphi5IdObLmymxAkt/V653PP2+LqFIoQhgkPyfkUpjEvZr5fzjtuB+M+LOP1nqpS7hYAgJyWrZ32La8kh4Vk+XzNp7XqoI249Vt0d6uYhVhHwH37GN6VvF+yVWecsEk7M3YlxbvTUmun7IqXekDpSSIQw+wL+9/bGcRchGWPrXWCmQkiripaeGkskW2XCGE+wFtbUn0AO/toerE8wPqYew7qjwiLL4K1C6VubEoV5LVYa8MeS/+7+QU9yHOBa+tNDQ8JSVT9ZzuoZHdicwy8oye0VQSQJH5pmrA6MeRtUmSi5tRplm5ABUEZ1Ty9MUTHxviPgq7Lc4F7sfe16LasXfBRpu1z+1xMSUIRVcsBETfjedWofECAsxxLsLuHI9CFFbA9YpzG3EK3MHSlldVesRChOIQWN1T1waINj6DZFFvGw8GWZ7kdpEoVBYcCSn0A7Qrzi0Izg7ibDvFTTfdZDMzM7bbbu12Kfz++9//vudnrrvuup7vx+u9MD4+zowpWP6WLo1nntmLX/xiu9e97mUrV66kJRDE2LXXXkvlVi/ALnj66advwlFmbJ/oyLUNmx0VVLp2GvuYtX6j11dYDZa8TtSClBKphUrSKjDFXxurrMBYcPKXTnLNYPEN96RhdwNgXoVYhgZU61kptTMhk1I7IjjITuw+YemqD1oLSguuTiskk0htcwoaLgcxmJB4roZbtGDB8klyFejcO0Sbk9bBpUn4pggpDnC14ljm6lTWJ98PDVqVb8WBEQdOMdhz9VfcB31AGIPMCAzXzaoseZzK4H278Z7KMuckAfbdMy00mOXgOh2IpTdCD04tBpT5wzbUynsQPyJ8uqsL6nsxqeOq/vpErSSVlALfy8kmiQ9ZGnuBJIgGefy6Svruap5WQvJ1V9wp88c40MaKeASoa6DH5pcdiYowKRa44oqqN2F9VJluWjRgUcIgvtlR4h4ZEVLr4fhgTynzZZRpwUPwEuSee5KqmWKSM1wqm0p1TITM83wiX0w2JikjuB2QPLTxecAwJxUgMQcV7lwSLnH8sVqO/cGkCKRkWFbQXu2WBVcuVeXr8X8P4A0rZlxnOm9QztFupMloGX4sywIH1F5RkBlqbCPPlXGRhud8lJ8rryu0G+qJ4bNSrjEgd5nn07DfwCoH6xomryASR2StCiVEVOjT6n55GWGFP+xcaDdcryIKWboc5LbILtp5QYwpM2TqJqkmUI1P2VYgFqamFG69wc85yBEA+8W+POPE65RUZewPsG1ZUiVPfY3qng1JdTqQUrfq7yB6xpLMKQygpFIDkYzAbyibGCweaiy05wYRYEE4RkU/TV6x+j+0uLKu4TxNodw8to1reJHvYgR6c0UwKvthwLZe2xzTv4t2614Ngfj7VZa2knDDhBP3DXy3Auv5Ov6ONgbZ1vCJNqvtBbGmz/JeAyJKRTEwsQQJCWKbmUoNswn0LwRNb1B1RvwNRPOY2RAqScJCivNzm7WwHyQnQ+2k5iPpNGxFFCygMjBsduiHU9bCPSO9XWPiyip+6L4iZXiNKvAf3wHbISr0oQodCx+I0EP4ftj7qIDRPZIZP6GsGEtUwFHAAyQMvhvnFPdRr4jKNqIiRZNhkW+tGTwLQjES1yqs7SDTo8pfPA/dLhzEVagOQ21VLviUQdzYf1VWpYUR9wQ9Rydu0W0KxQ1wr0WfwnlC+zelfJxUQYlqEcjVS8oT4rUiS1qE2COPp8zsUwEA9F8SA1KpRbvKyuu8s1RBtGOK5JYFORSSvOWQwES2lD9HwlLGv5VETljKcDw4l3gm6fxp7FCNQdwyXWtIHY4FtDgPVI7p/kiLK1RN6B++8FMMuZW0fA4yfgDtEIHcqmjJc4I2i2qT+LwUyDwefG93XtlsIEmqvMM4lraxQtjwcF8RoRjgoiOrP/rCi+dEpbEIMR6JxQq1aU8CJsYI6d9Se1/EQjhZW1n14jgUuxCTV8Y/uGWTp0DHxpyxxhJfQOO9IVSBPkYqCTE+30EQa1EJ4w4+80JFiUDzUAsmY7II9S8rGQfhHwpV9CX0OV1zCXm+swOh50984hN5bj/0oQ+1/S1VW9397ne3wcFBe+5zn0vyaWio2w4J0ir9DJRSe+8NIiFje0ABpVLrFqsN3G3TNtC6uSSlKszjOgqlVFl5b7GeL8lWMD4YvI++Q9/D965y9e/MjZmU2gmRSakdED5I8eDX3gOj0jPU/mpS2tcHzD6g8QF3lVvEkEplzoCw8LLG/W9E1QBDq8Rl2exqINFtYwjFlXKvCkwk8EIie7cJTgJKtRcVRyJIQu8e1c0wwUSWTqiBpJRyVUa0mytWMKHGKlq5mkwpv1YZw0qgVcxkj317UHCARBtY5qQcVq65Att/Fc6JKRAEmNi1koFuTCZDzRLWL88B6x+Wi9Vx2G4Uml3arNIsKxFuVIthYBcr+6EC0GSnrF4ntQRnPlrlp/VwqEMdpMEqJ4Zud8Nkk8qYGspVj1QSf06KNWEqg/VjQhgKLg9wdveTys+HvYHnASRH9AmF+CqMvuwr5cq3l2Ankcb3h7VQ+TGoqkU7Iia7yqbCRC5I0lI9FXY7t+VRFcSJZFRITBWD7WGvbheIie9A1+TV819gUUS/ietN1S/juJjldqvnaWEf8YBWBlZbJgd+EL4fNkCsSEMBxPMWwfbKYWE2WqyIy24GFQknAVGVTCoIbHdqg08acS5YDQukDa47ZchRTYdzj7ZWUDTPHxRCmNiqOqLUIuwrVFNJRULyEOqJIVeI8HtFbEDhBgsfCRhMAr1suOc6RYg3fpQzVaSKKdwLotKTJvhUGe2p96u6Ho5jEJU2d1FVMpA5CoHmAOlmEVvLk7y5uF6hSsF1s5eTQFT2qR+RVIZ6EVYSnHOvhuXEUuReYRsxwL9J39WUggv7usz3C+QDMqAmbhZ5GkoqV4u6uhL9EgQW2hdkUdPD8Rloje3ielilyapIGrTTUMtsA+yBsO0NmQ3i/qnMp7omx1Qa4tyEnVXB3iRBcB4UkEziCGrEDSVB7eK/UB7q3gnF1JRsPXGfCdVH2KH5QRVh4IQW+wSyCpW1RBgMrhTRsdhseG8/VtpQY+FC1SJBSJCURYg6zocWMkAQcoFgRlUhdV3QkjxeEqd+7ap4AxYwcO/Hc6oMUff7BggpqjAZQI/8pFgMcKVaQYVooRDwsB9pMYC2bpBDQ9rHIK50H6EVUlYnkOxQFrJd9FzEueL1BTLX7X6h6HRCSmo9qn6i4ibuJVoEwHkmWQXyMapvurUyqq+5TTAWDyYrzi0q2pGQ4vJ313OQSmO+x9WV6d/4TGJweGRj6v4WduxYrEns/14VTmpQ5WXGopC2mih28JxEu4ns4DYG26MNcA0xR8+r33kfwH0M5wwqQYwpMN6KXEn0VT6s2tTds4HnIYL1meeWhq5rYSOs4hyPVBbwasFPi4Sd2Z1RAZn7pUUKVHGlik4keFnZN6rP+vOZfaNcjHPi3xXmylDkuew+Hh8z1a3FEHgRdzxHvmiTjhfcMtdsG3u0xQWwj6Oq54gvXkFBpfwxP+ewxeN3jedC/UmFf5rfVXa40sLvKiv8VAq5HQGrVq2yRqNh119/fdvr+L1f1hNen8/7g5C64oor7Pzzz29TSfUCQtanp6ft8ssvt0MOOaTr7yCqepFVGdsJpq/avM8zs9MVUSXmcy11qae68x2rRd2Oi5ik1OUVIUbFVHe4f8YdE5mU2kER4dC+EqksHuYuQOmUkkwVMZUGjJcrT8pcKAfeygtwG82t3HZRW1muMPZD22dV9roa0czFrGsgOZmSDrGLUdZ8wOplBkkrWX32VXkOsKbWWyuk+5zMuhKLdrCaD2jLKj3YBifDNSsamESp8k6ZORSkjggWTmYwGMKEEiuskJm63H+urILSxqdMolCtcVAGdVFjgOGuVVu2q2zCPln9W5NLWhDT90S1qGjvsGrgaCpLVUnY8eHiijUf8CIPw/tB2DKrXKiOYyKB1pmhla6AikikHU0KoMigIGFRqebKIFZMDkK5F5W0yomP+hEHoq7waaswSUUJBrReBY+KKga8ezA4+zeVXCIfqQpUADTVPU4cOQGFySIm3ugfmKRigoacF58sop8Usl9FBocfc1grQsVWEVasWgaSiWoVDxGP9iuvS04sEByvFSWWzMb7pWKKCkZUBsEKCvUIFBPKCirtJej7qixIRZBsVMzaAVmF6wj7I3KFgfVxEnHcY2aTN/l3Du9eVfWM3KQpbYckk+SMnD8qy4iKRFUKgzKJqkCt4oc1kxlBUBOBEME2QEKoP+IY8PpUBNmDIAHZs6eTRzw25Bth0ILrEaTnsMgZ5aVxEARSCZPAlZKI76o+JGUY+uL4DVLbwLKIydzNUlrh/zioIMNA8qxPFEvrzCbpN3LLGud8UALimBbLIglycUzbUgYDyakJkV1S9nF7S/RdOAaokWB7hIpMVVNxjtGX0eaT6K84fyDhcC6XOqGBvsJMobD14dwjZ2lVVdCCWCMHCgAAgalJREFUZAYUJLKoNkEAoR9gMi77HIgPBoBjX0Ai6V5B4jtUnNgf2XS4fzgnCr+HKoWqGPR79Nvl6tMTTtYhR4bqybqsaurTQTLjmYafyKDDKmt9aUIy6tqiOnix2YSOAdcnFDw4trAFo2hDAWJhCfPoqGKcjIwa2aTZJrg3KZsI+8rKlmHnEpEFtZYs1gXstbqPMwdO1SVpN0uCtVsMadZ9OWyz8RMkeCilIueqtH3iPEQxBfRjVaHj/R/troyP0gqsZ36BxRxZ/MrCHiDMwjatAGsWNsH3gBjTNavqfalKuczo4XlBfxUxQDJnJCng0b0w421URQD0fJboM5GR5GQMX1GfU9ahyA5ui88VFSjRollJgkYREZJ8OJeyCSIjkZlDyYIW+jnPXSxCNa0AUUkbZ2V75/NbNkB/NlW3vtng2ZphI8MP7JShyAyyJjI7Q/WEfzddZYj9huqSOWIx7gvLuPICW3gODFlrEvenCakJF/N5zwU/WB6pHFJfCkte5HHx3ChbkBbcIV+M7KOQL89bA4RiPONiDALbfu8czJQY4jFTZQcS3Bf23Cofi4RawGHlv1B3q2olrmn2aeRL+tjFs0ZjkchJS29nV8XvSIA66cgjj7TzzjuPFfQA3Lfw+4te9KKenzn66KP595e85CXlawg2x+udhNQf//hH+853vmO77JKqX3rjF7/4BftRr4p/GXdsMOS8dWsPkmn2m54vwu9u1jjAbOYv/uLA4bN9ov3XBsZ5Sdh55Fdl7BTIpNQODM/c8AwgkAn+QMZKVbqSGFY3awv5LG0DGhBVFVo0AWElH9keMKib47meZljF4NRX5OYuzct8Jn4f7DoIEV1kNoTAO+VWlBa7OIYYXGl/AQz6Jq7zEFeoyGhFaSok1SepnCDEJJcKAKm6mH+EQXqsuKqssCFYViWUOclRrhEnDG7LcGKhUor1UziVxAWqEmkVk+/jinR7+4SqqZ2AE6HCwbVb+6IUt1dY9JXlkkIqI4s8H6qS38NyqEpbVC5VK7PRtp7J5QPpYhoBp8p3YNv1Ca1v6wsi/pgxFQNulSfnqn+7PaHMOqNaIgaemgDhNRIeClCGcistQc7S2q60836swTWUPez3PnFjG/I9ygTxhqvUPdi3xmKvEsasI5Aia700N5VwAyJfPBcsCLKCWU6uDisnLyRXnODkfAf7AeXPNM67snuSPsHsC9pFpBSECi0mYSTX1H4qYY+S6jxOdgeoOqCygDwaxw0vvoc207JAJUJd5Iky1Khww0uoUhUKLqih8J1ertz3BWSD8sk4AVZ2DdqQk1vllFAJIiVQfdTqtCcCbtlqQSUAgpsTREw+oMrBfsf1zUApn5SNXWk2sUakCNSAaANMrGHxGzUbXaaqXLgGl5tNjGpSjWMUkclqd57L4jkuaHsNbKCaoZQcv8yYjWF1edLVN3j/ZFTZu7mqdsc+tCGp0gnVmNRZIMh4XUhBhqypxlIRENiGKwG98l9cLyoUQEIpgkLv5AHqzJxpVvlRyF8a3tMnn7S94RjXiNzFBHlPkYywCd5mNnmD9hmv7WI2vKvbN6MC59Qt3n+nYL3FPXfE+9jEZX6NDe3q+8CMKvxPZEZYADmpV3+kIkqEwMCIFSC1mPXktlmfKEqxxiyyISfs6FTcoHMDskkqD06wZcFUhT9uC0QMAlV5jcg2ykktrx5ve4Sf1zb4iurQMrMpkGv4rlCQYAEH958JbQOE7YgI62EnnJuyjJb5iEGa6/mDz9DuNc2CFKU9Hv2Sj4D2Sm9ejEJZgbyu4v4dVS1EEFH1CUIv2lbVHKPyJQlc5exQOQlCaLoifqlWk0ovcrhCBcvjR7aUrPL8Dv09CiaQJJYqkiTTQE8lKJ+fUeGRz0RZ4RK7Xr/nQTzDihYqx8UzQuePuZjpGEVq7bLCaLsVzQuFBLHkOXpBiJSvaxtYvODzMQhBPpMmy2q/ddiFS8taPAPbKyqWCnDZwMrxQ4Te9z1uKZ242BALSFqYYQWqsHLyQDQew3eIROJ1FIUkXD0U1ZRLmyFJXPyAJEfhghmzRfuSHI8cJidFqz5dVY0VIRskKe/jaCPcm9uPP85LihhLth+zK7DQ3+YGvjPUcNhgEivh31BGKsQYpcWxT2SW+UIiTesaE5Tnkc97XBexqLBjAZa4k08+2e5973uzQt6ZZ55pGzZsKKvxnXTSSbbXXnvRVgeceuqp9uAHP9je85732KMe9Sj77Gc/axdddJF99KMfLQmpf/iHf7Cf/exn9tWvfpWZVZE3hfwoEGEIS//JT35iD33oQ1mBD78j5PxpT3uarViRKGUy7vAooJCa+qNZccvspFSfyngkipe8yVXL0780G7h3/y/rfHaA0AqFVMZOh0xK7cAoq7vFTSAygjAI4WqebCL1Je2qEq7e+Yp2BLn63/Gjld4mBqEYbEMpMnvQXKnekTqkrI6GfcBAykbmrnxCCxEm7LA3jVR5N5hEaFDpY9Oq2k07YYMJFyYnyD1B8CbscHo9VuBlz0P4q5MrWjGkAgqTIa2YahJTrc5BTYPJhSbSUAmVA+F09S+k79WgHitcVZ5XrFBOK7QaP3hXEsbeu3E0KfH3+qTGB7zlSmGaLxUEib4zBvfltlhSOmxlvqLYRTCxzTGBU5U05kgkGVCzn0yt8mM1PwhAbEuqjx6lpEmepANc9LlWMlhlLhH2u1IlleG8kb8VNk8eV7P6PM9xKCJkU+JYNzKIIo+k0HmOfZNthcoPKfioLKtrldeVI169KOwO+B0TbOTgYOKNLLLFZtM36XrEJAiqK/RnBaEz2wer3SoL31xsdSiDmLuCawHzE1iS8J1OaNCKiokHCSAfiDsZJkJZ7cbCBVg9Z5Msk4sSxN1EZXVgJU3Z4SLDC+oiZA2RGFsvAgFkDcKFNWnDdjiRkf2OKoX265yTqAgupzInAoal7MJnBzERln2L77vFXx/Z12xyvCIzoTSDigVtBSUX+xgIqMVJsDnufdo/KnxAZOJ8KMwY20EgdpQkD6IIKk2QV7yeo4yxwtD5I1sdAUk8ztMqZuqx/aZvNJtARcD1Zov31P1nidkA7HsKmWZVPbQP9j0mmjh/uB9BhbOLMlVQDQ/nRYHp6KdQyUChxv6uPDpWqZQqjiHITf0dk24EjisQfkwVMdEPQWjgHknydcRJNA4c0T+xv7g+MIlT/51R3heIL7aZSCFehJUVqqyWxvs19hMEDyr5SAHFj7j1qiBBiPfIYhph0zhO9BV8BsQlyQcRkrzu0U/R50Byoq9im1COrZPiTwo43HeQOYVnI1WVbsNzshuLFCI4SSYrb5GkTc0LWnDin1iMeK04ieFB394OrTJsGfc1r85W9nmqYIPw1nOWlWUjEBzXIJ4FUIqJxGbbQhkcFQwj2y2qInrFP/9OdcVQteLah8KHSsR41hRlRpTvGyh32dbicU9CzMkoV764ArU7h1D3VLapqt/x/jff8OgINp/hQofbOkXs4B5Za1+c8XFMLH5AvVqpv6PqKXMvy/tNov5OFNpVFbmw9cX3tsuc+h1DSUiVlWOl5uUiFn7tv+hWKdNbai+1AfdJeV3licS9M6olKyOT5H1UowzyOxYTo/IdyGHcl0LNWFWgdct5g5UV29XWeN7HIpMWtrDYojw3PKPDgufHXym7Zhun+HjJVYG4BtLFte736pkB4rm0GYa6OGw9AEgujzzAGAWKcoTG+/MOGV+eWdOqLZNaS/da9i+RVzsgTjzxRLvxxhvtDW94A8mjI444ws4555wyzPzKK69ss0kec8wx9pnPfMZe//rX22tf+1o76KCDWHnv8MNdoXL11VfbV77yFf4b20oB1dRDHvIQ2vBAZr3pTW9iRb3999+fpFRnVb+MnQCR3TtXptQsakqfg6CwyjEL++5GNylVTP/Jas0DF7adjB0SO+YdO4PwwXQVauoBy+kk24OFew+aJMlvy5PqyH4CgcBB1FyDzhgAexaED+QlDedIod1zXtmcqmweqruGVioTyCuPVcfiA3lXfERpb/weK/gePMrqXbD9IG8Jkyt+v1YiRVhUFgP8mx/08teY7HLShQmU71dYJEuyR5WhIlR9Lll45Au5CkiETqzyscmwGtojFyE9SyIOUosYA1OTKhnpimWpWNP5qAafVdW6Shnlgeg9wcE++lYMwnU+VeZ7tsGpK4a86lOZbVKWWre285daPtwKoyqFsME0d9E5kU2qnACLAOQqv6rkYfKJ76LaIuxuOlfsv5ErEr4LvAT7A9RYUhtxQK1QdkwCB6Sew4A9FBsR6h65TSS4UjukujwVSHgtQseVSyR7oSvJGv6+COmPSVqXihCTd6sqYHV2GLbvlNoiSm8rB4gTVlWsqy+zWjPsuxHIPK2/gWThxvyHAfZQeClMmoHXysqKbByqZkCKKNi7XpVdT3bOJ1toO5BPzAPBPonopeto2GwA1hh851JZUEQeltX3MBlWphUIJJJQWt3nSviSpJqdrHdUk8G2Zzqvt+oyhgoIKiOpEWjLQzW62M7iKlCc1xkGR8r3Kf8OUgNEABQQA9qfa6X2QlZVVDFFH4BiB58R+cBtBSEGVVNk3UCFp2B+BkOjj4OwlBJsYl1SbS/CzOM1EPpQRyHjCm18nUh6qEbxHToH7H+YsKHt1Z4gxgZ39XtfqCpA8tCqhYlfw2oDqMwKNRFyrkQyk1j1KqheLh5kPaw/A1VFVLY1iDufRPP6ZoU5kU3s+8o3opV5afkMoE0nlBS8b2F3p8023uZqMd5Xcf2A9BEBzuqAIOUiUzCUu/h69HkpXWgp9SpkcX91BY72iZazUPGpKiuv+cgD0j0Yx0HrH4i7IBmk2qESDfcKDd65+CGSnXwAjlG5PPyeKP4g9SIUbLTscVSuSq1hb3dLshMvyuvCNdVA5b0hVRqMBRtXLZfh15HHR1WU7nGs7jmu6rTVNew2KlmpgvCj6kfPLzzfaI9szPkMK6u8kVzDsSuYPKlamnyq/D3Uu7OpifH5XiRI5Pb5QozUNny2YUFg9ud3SchwI2izUIVpAXBmXAHf/TOLKmU6FgJlgeShBfGTLmohu0r2eloj0TfU/gS25eMFJ8pkxwRpPLCb7plQ2i6uFqqgI2pNJYtX7dX3fGFPBBHvz+0K6NLuT4K//3QhtlueunktqEohyIatMq/871D/h6WwfZslYVZ+NglNF5UVeWU7MmDV62fX++53v9v12hOe8AT+9MJ+++2XuCF6A1X3Lrjggk3c24w7FvRcQdh4FymVvCsCzTuB11u3zfu72tDYy/8/c5kVGz9pNvwErcdnUmpnQCal7kAIqT0HFs2mtWYGVSmoW3aNwXwqWcfgs2vwB6KH5NK0tWj1wUpVr1DDsJbFpCsGvh6E3RnO6QMY9/u32bigPsIqOdU9GqxSQeXEW1ikyvwqvpaU4ob1ZAA2Fa0uU9HhK2f9gshJ5EWmAic47SSeEyxDVkQeh0LFe23L7Rxu32vLF5IVIPI1/Hul6tBgsR867Y+VtaH3Ci0H3VSbYEKDQN6hZHDpyiCq68I+2EF4VfkeTVZyiwEgV1Jp8QLhM6oQ0f5IV9vL7BVMjmBfpCXN7WkFyRoMjjUJg70IE3HYqQZ2oSy/xYpMbr3sCp8nYekKKvYrtmtU7KuCYzkp4wQX+y+iihXtoFBBng4G9yAPnGjyDDXY5GD3WF8FlLOSH6q2xX4EsRcr9ZqEoRS7AsCpAiPBGxXKMKFQKXqWygYBh4e7W0TT68ULB8iCxGpQociLPggLYVRjlFWjJLkiuFyE18QtzmlRGaXcFO6ySDpOUEX2gagg0aVqhrCIMNsqgvlVEY8Wrbq2A0K6qtrZoloM7Vdz25wUik60YHIq0psqERFoCB9HOWGogLAfrD4m8oFEGEhEfG4PKd1U8horcryvgKRBDkLkcqGfwuK2wgw5Ozh3vC+B6MOkR3YkHgD6zmSikELfuKFSOJI4CpIEAdq4lj0Y2u9RSyuVA/sazt2wW+LGJ2T7m0gqAYIMg8oBhJWII2RWFStc5Ul1GAieECos8X4TdiRWI7xO+4Nj1LmHoopEVWTGieTBPYx9Hw0DAgr9DcokKOjQ96Xc4d9F/mHiSLuoFjHinlaqbUTOYJIpFSOvRfbvyBYUEUx1U9jQZN0kwaV8GfQJkCIkhULtJgUjbDqwHY5DkbbGSTssYjDHasxsEOooZUDxHusKoFg4YPYiLKQAFGylUqb9PlVVIlWFSd73QBAofLw2XG2T9wQpvUDq1FA8AwRFk2Sz3wf8OwrYFWdu8xB6KthWWH1wMbP+/N4IklELMFSNIR8sCBF8x0S1z4kqk108KrlSWTVRkU1J8ZLqltkepu1ts8GVhyQAVlEtxhxGWs2kfKPSEGq0YY4peN/jIsf8UKmNQLiMWp2EPv4yxHYkwSNLlj8vpOKcc7upkqe78EvcI6t/V8/pUFL1e/462efXM7IK2zKRVExkfsphQComEvoRQt7zW1VIwv/NZz3JNN9Gm5qMVS9d7cY+SbtreuzKlGqzGXZW3wv1djx3quuhimQIgnA2i6beW94nelcjdkXWWJIhiTGlns/xHpJwfi6deIo80I4WRcVdkNg1D1f3bXSSmxkZGXOjk7DEvGhNtQhWTzPF5nF9Nfc3m/x5x4u1eZJS+1b/njjPn4GL3LaaccdHJqV2UFSrQvEwj5Wmiiyoz+Lrr4iCpGQ0V569gp224DcMDiYx+RqyFgYRHWqIyE3wz0V4c332igsMw+weQDqB4EGnqcqn1+fbByAgv7D6FnkP07Qj1GRvLPezJO+CqFFJawV++ypiZ+aRFBFq7yDG0gFc7H+1uqt8IYbO9yIG4/v63+Cr/IhuZdJsdgM/JkwmPAS2+pBW67VSmm43rJ9p+e30PLNtsdJbWgfnzgqL/Qm7gPcl5TcpINVPdFi6+K06F24jKScGIg6qdm9aIWVCuW1sg3YgHWuZRSLFHSeQ2jEGRU/rvNYrxRMmlUm5b07O0gqQnWrCtnLl6flpUJWUni/kQLmiKZRaHrjvocVSz5WBsVUfqzI3lOvTOYAgGRXHqhBwkEXcJtpk1AkGEHBQPmHyAqUQySkQM9ouKqMhEwh9B6oVqtagdIHaRqHUnKDrGif5G1UdlU8D8gCEHCc+mOSqOhuDo12hQLKO1rOaZz1hwkvCTUH2sMSR2EG+D4gAnH+QWyDKoKhSyXDyjyCCsH18BsQGiJpoN+U+YeIystrPL+yAY1ARQQmFn7GkOl+8BjWM2ySc9GmIPNpVfwfxBfUPKgcqQJgKF+QuwHqo0vYkVQb0XTcngeb7VZUD+f+YcIF4EFFGNRiORVlkfM+dzEZBrkHJhHOE7bpy0d83bTbYTNRUqkhIBSqIn2mzCRBja0W+QYkI0gUB7dgvZE35OeS2QVaQ4FDlxiA4qXSaSCpXimBA32LI6aDUNHGPVn5bZFJRBTasexSCyHXPIgmU9IMZEbkghnHekKdFKykq8OGcLtM9TcQoA69DDVKpabjwENl2muw7ue5h7T4JVtU/3od0vAz2VhtA1RPKNwHbp3WXyqy4V/fJ2onqd2GF7yDsSS7TvhWZV7I0NYesNjBqxXRk//h2vCqeyAg2/nCVj8hzA0ueLJDlPSVUorEwovtykIRQZZWWcik++buC1sMOG4Qdrzspu+ZE2NBUgbWtcXTv0DmEVa8i3eeD2UmTXuHrIM+5yMJdqojGdsz0J7vKrL7uv1ULUpUaqXyfCpp0ZzEl5Br3DYQniF5EH/R5vswjt8m/35IFk7gvBtzWGJWI2/dHzyrsu1Rms30Pn8+lojy23fEZ9m/c86elaMcYqVJ2s1/xmYHFlkRJ1e97SyV2jEcyIZWRsfnAYthfdRnv2hHvMfc1VoMlu/vFfu/ueNuAFcNPMBs/21+YusCK4uR8Ze8kyKTUDohqAINVPoUNh/w/Ub7MB+XqcFnuruNvnMirtHmSNdD+vpCKdw/Qen9nj8FKx/f2C9EOdGZUVfLxjgD0Nhm+7EflimNUaZISJZ1EdSiH2gdsyrvQKmV/6X637aCTUJz7XMWArXMb/UihQjk7qtaWvs5sFwz0Wj3ax8mfohWWl1r3vjYRnhqKuvn2sSDB6NOqzjttRFDyxSr2gBUDrsrg7yT0YvVV5Cv/P13ueefkz3NjVMUq2o2VijDpSSacQVagdDazPmRzoa2nkyxVyWuQWMq+cMI0SnZPt02A+4XdV31QSilMtEOhF4P/KP9Nq6qKGNSR9VLlrbj1Ti0bFh0QIyB5mH8lIolfr7ZBVaYINGYWiVa0qYJQpg2vC4XAw27LCde4wshV9Y9KQp3DGSjesH9REQyvyepRQFWJzzjJXfWDyGATOcrS6yoggOwk/HkCpIMrzUg8gFSBQoaVAiEHxz4MeS4UVJWsgKccFYRUk5DRSjyIpUV7mg2v1PHDWgcr3h9EzESVvkGUPHLiYRoEHNoS+xgqRyiZVqta4/Uii6DaWW82pGwghIyTeAKZA1IGxwa7FcjAa0VuoS328wl+KwgpkEMjUkot0+836f04lrgnoXGG3RqI62R0F7MN09rO1crBQq5erGhin2HnAimJ/tv0IGQSWVOq2CelEciIIOxKxZgyhCjhVzA0c9WUXYVrJ64P9FUSmlLIsrNENo4rSwtOoBHiPlmdXxAtIOKgBoN6DaoiWmMHlEN2k/+fxGJU2wP56KoxV4GC5AyyWeqKCJJO84BYvACh8qFO1LXDY8N2pWAp21qT97AYsT97JlBk+fk9SEQKbYEeio6/dxIJNaiPaL/D/dWJnmrRIe6LlTXPyerFWlSQBRaZP7RsYn+cSHcnLtSMIArxTU5m1BreFrRsh423fL5FoZMpLjQwu3Fkd1kEY/ygRauwKVPxFc96XLMgUF3lNZ9nAckR5pJ5IZZ4rvAezuIQSXVCntPez7eUwCjzwOYYK8yO1hw7Hqqf6px3qp7btsZjqMgsz3WqnrVO7vQOEXc1YiN5VnWPH8JulyrlZt39PmOQ9uOYpf1EYs1ZiS+JRKhcYj36Be4PyLJjzKfuDYlyviyyo4WnTuVT+nx1CyVyAqGyA4EHBXf78Xb2l4yM7RHF5E9pT6u1BYpvwe3jvjp5odnAXaxWj2zMHmjdZsXMdT7Gmvq1v9Y8uPr74H17zkfmh14uG6DzuqxZbeQxVgw/2uy258qafs28v6XAcTbvrKqkk1YbOGQT9zfj9sB8lri2KhDAh+oOKE86MjJid7vb3Vg1In2oIOxvjz324N+PO+44ljRNccstt9hTn/pUW7p0qS1fvtye+cxn2vr1HoAY+NWvfmUPfOADbXh42Pbee2975zvfaTsqyhWhCOIuSaVNe/AiPJKTXw4S2pU/mGzXB0asPrTc6hhYl4qadH9QAac/OdOJWIVjpZY5fO5zbafVmuRPTCJ8EIaBX7o/WvmmNSn9Pqg+kA2z2OqwJSSfo6WA+9jHosBBPfYfP60F7jfaUDazWRD703mZRsC7T2q6PuWDvcElSUWaCISHvSTax1VSFVmCSY0q7uFHRJUfX9UOfp4XUmI57AIaRFNFMVrlv5BYdYUfJnJBUnG1f0bKiHKQn1SMJNFVnRuffGJyJtVDVKoimdWS8kEBxCRh6gyAdSWIQmYbzTZyydU/sNFossgJ76TaR2QdzsHUelomUUWvmN7IIOf03LgaUcfDvCsQPQggXqzv18Q+lFFlVcAg0dI+EYNu2ahA2CDsFQoXTlonvWog1WiyRc1AvYOsomGzRbubjeyqKnFQU8UEV1lRsDBCiQR7IlRksIAO4RpZZDVUqmoktj7a54JY8tLjZV7QNFROIkhxvLToTFoBG/DY1WYb/irrpCb8rKC2xomIiavMNl7jmUiLVpst2dtsEFlJOOz1HmwNxQ/INljVqLJAHs6A1Ex7OIkEEgR9GoqXyVvM1l0tOx6IDvQdWCb3kupqxmxaqo+ZW81afxQ5hNfcIuLkZZAu6su044C0V74W+x6Ub8hGwnElfZdA5TxUCG06KcR9qIlUUs4SJ2gtKbZQlW9vkUxo93VV9TRY1koyCyTRqAd4o61IgKkaI6xjIC5BLAwtNxs82GzJYWZL93YVFTKrxjDog11PNtbh1WYju5nhnMcCAItXILNN5CX7Mfoo+ts678Nh6yRZC5KjUgPVoJAaWGa1gaVuA0ffaK4QAbnEbGiFvi/aWIsFuEfDYojg/aHFZiOusiom13nOFa6XyTVmEzdZC5lcrCSG6xC5Vmp73Peag1ZH5iArQKJPizjl5DdsR3gN5w3EG5Qc2L+lIsC8EAKucc/ni2vSiRZel1R84e/TXcoZKHfrg7C/eQ6XE8i+HSeh9XzCMYPU4iJQGuStNkF/pwW6+g4nUHUNykZZ7UBkd4VUTAUGsA1USaTF1u3ycX+pws1DBe0ZipXSBuc+tYHNDv+8W7WgXCuSZ6ertXTMketlvZ+r8Tzq9excyFiCi2tUqMJK2Pt55qSI1J3zeM5XBAi/oRwjVJXv2jMcq3EQfjwTi8/KeC4piL/tO3jt4RmUnPseQP/0sdHCxibdZJUrI/uOg3p+tjsuIZ6nzOQaWO4/XGyJ55mPD3gd4XUp9jsXwNLxiLe37Oah9u84T2gnf17Pf/8zMrYlymqiIIO22DYnnVwqoeByLqrNgekrrJi+ymzi6/77wD3MQOwM3G3ziN0GxjG90LHNVAjQlJVv+rKO4+mNMhdyGuPLGxaQa5WxveB2VUrdeuutdv/7358lSL/xjW/YrrvuSsIpLT8K8ugDH/iAfepTn2I1iNNOO82OP/54++1vf0uCCQAhde2119q5557L0qcom/qc5zyH1SiAtWvX2sMf/nASWh/+8IftkksusWc84xkksPC+HQ1leWL9O0ih7veVJXo6rGe9gsb7E0o+AA97lbKeFAbe/n1us+qtDkqtc+l+zX2svjIYweMql0yCCYNtn3AgK6ZdPZUOZJKXSIT0XkXsvuEWs4R0Rr7MJkrGO8pc9/6e7m17YKoGuhHEzsEX2iQmwAUtVNWxBWnZb7s6Tp4jbMfLg5fVg9jVwjLS244466FytR720OEykyzKpRfYr4ElCUGmkuYx6KZ9JKx/CBWWog02smTyVVkUfAIWfQFWzFIJSLVAe7g/LK4tTEQ5gZ1iZR+2B+1uUOhMud1ocJFUGB7Ejv2ODA4nZsJiFZNLD7j3KkGwY93mxzS41IlBVuJK+3isEodiwosU9JqYOGQZAwHCUHKQRbDgIcwbk1ZlCVHhqAp7ICvKiaQIMBIoIApBxkg5ReUVCKuo4MYzZgVtdjPtCqiYUNKypokeJ/XKROL1hoGCcsEwEQaBMDlpBrKLIdgg5kAQo7uhUiHIKgV8Q73TVBA31CjFbW75mwSJgv6KY93Fg9JxPxjaw6x1oL8P/YX9bEy2tFBSSR1VhqOj3cOWh/fcmmQ1YSCFymcgR6P6JIikISdopqTUglVzEgSRsl3QbuoHvkIIlQ76NGx56GurzKYbIsnwnUVFLBERIAriKpR86DNNtRfsVDN6/52dRCrDwbEPuyoHCFltCoXH+6E+AyGJ64PXJY5dllr0mWGoxhbrOkObbSwVNN6/8V6Fe7OSGc6JzjlVTs2qOpqKKpT9h+THtBUkQwdp/yxYVc7JEVrgwnINy1qxm4LEQeDheKFKElGMPkCVmMgdWj2lwGK+VxAqaDoodKqJqpMQYeEOi7kCn2mv83sO3yfCwpVFCj4n+Y1nQL9rsxOxKID7pvoQ7gUg0GamvIJmFE0gqav2TtVYKBxBIgjkJ4hBtJmHjPu12Khs0UkuogdGx/UI0lq5TvxOkeG0ZkbIugg6Pg7wHai+CwIxLH9htcMCwsJU2U7OVzbH1BLtb8CxRSZeb4VwldfYuV3cu6Y9HJubnnuRbK5CJX5sUt6V2Upzvd9z/9JqyJUK3VXZs+VYVdvotvbzmUnyG83Ua4yVtAufoTh3IM1RdCTshPNfh67GimGPm12pNZsC3M+7SH2d92j/2cZhvcaqVHTzd9hncd/RM63rc0mhggUtpGVkbEsUW25LxZjV8Eyd/rPGOwJIGr4hVORzYOJ71b8H7s5nqD+7NgPMH+2FjsX1+q6qcIz73AFm05eazfzFybL6LnMoY4t2Em4roaBSeP5CjIwdhJR6xzveQdXSJz7xifI1EE/pg+XMM89kmdPHPvaxfO3f//3fWRYV5U6f9KQn2e9+9zuWSr3wwgvt3ve+N99z1lln2SMf+Uh797vfbXvuuad9+tOftsnJSfv4xz9ug4ODdthhh9kvfvELe+9737tDklIlERKrcF05ATF4kKWPk/Gw+jWSQfLcEnBXoGgFn2RFVBnrGDDRtiObR4eFMA0mrwYXzS75ep89aK8Ww6pEa32SCVUArUXdNwcfEHLP/AUMrDUg98yo2SX/LiuvKvR02uUwoIpwzoUNzEUo9iSc2tuilxWsDL5WieyoZOcTEhFTXHEenDXstf1vyMdQhR0oD5Jw/CoUX+HKaFfJ7ucN5khgconKgagMJJKoLRC12k9v1mrw6qPhUBXgPZokcIDvA1qQqiSXOgbeXG2FEhAWlSTro41ERT5IIyWUJpW/tK6sWOa2C2RmxD6FvRVkUBLOzEnAUJnBUWZiRcA4J4g9rrmocEirkIJu+4TzV+etbgWODWqgKMfdXKz8G9jQwhYlRRaJiAnZ+UBWtRRAHt+n/aKgQoP6GRhpQmkG9SnsY8tkuVGfgN0TxQBg1UJZetxfqM5Zp2qAsoFFBTgETaM6HYK7sb+0xWFfMLlebTaIrCN816DZ1M1O3lCVhH1b6qQZQ8Jx/tDemOCvcasaCQ3sN/KqMCnDZ7GPo3pv5DBhY8N6bVL9YkNCEHnQPXOX+P+ovhd2EuQvoRNAcbaLt3maoUc71YwTcCS5miKVRGLyO/H+Vse/VXq+/L/y7vg3rPqBWMQ2xpTphHMOVQ/64biHgIPUaAbpBvte9ClVfoQNEvdP3q9BTiCMHcoM5QZBcQeSjZPGUMbhvcgoiop3IiBZkQ3/HrU67sdl/8S9GqrLKV4j7K8kzfGcgHpB2VQgUUA4sTIeCMYJKwak2G3EvQMKQ9zmYdkbdL6aIf5V1pxnHoX9SapDKrZafn3zGeKT4l4TYL+XR2GMXoHZqgZGW7QTmb3upcgAwnlrJzwqFW/5Pj6X0Q9ATI2LkJRFkNcMQtrb99OtYCDavEKsk+sRCI17tPe/zs95YQwUuAiiTiprXhOpbbgiQqqQa9//8l6GfeW9PEjK+cEXk2RtU/GHNsVtjGGooPW/9RqbRHZRe9snlUTR9xm0j8NJ8yTnGmfMgvIz7Vay3m+t993XFkn6mZKUas/gTO3yPjZoL0QTRVOgpMP11F5xzk9XKIFFLNLO3rIWFKeskur9cy4yLoDv7LTQVTEJ/ezpqhLZGSPBdRBVZWY2WV2kbmPehK48f6XiL8Ys0ZfSRdhyP7kPVXtlZNxRSakCyiAoigbv3kNJusDvCOve4AOsxqq+m4++994uN0CSR4XAdDwmpy/Tfv3WbPAec3/ZZjhw5oXJX3iFwWwN3OK4XWm+r3zlKySSUMZ09erVds973tM+9rGPlX+/7LLL7LrrrqPCKbBs2TI76qij7Mc//jF/x/+heApCCsD7MTD7yU9+Ur7nQQ96EAmpANRWl156KdVaOxpKaXWU99YAxi1nPuippORV0Gwla24fJM8NlY3mBG+oy+ZXls7WanL3zSeUOu1h0RHKjRX0ftJ7Zhxhpb81pcotG92+Q8UKVsYXWZ2qoB4kWGmZmiizPzpCD2YZQPukzbflA6Nu2+Km2CUrq2V1nrql/P5au3XOv9NX+cN+16aaYXAv7FL+EPH+UA3GZyc4pGbh7E9ZLG1/V1AvV7Nb7VlUcx4yBqlR8c/3gdZCWidHukLlUZkJEwrYSlnpiSv8RUlAOmvVTephsF1ZTGL/2o+jyqGKcxql2JWjxJL1sK4tNRva3RU6UnL5l7gqKUg53GdqrHIIG4hbAqEGqzJnQIpBaYCKcsv0tzj3sFjEanpUEnSCx9VGPIo5GhcDbymGQFCB0BnendYjtwsttfrQMquTpABRAuJFyhSEzeK6BkEB8mfyVhFomvTSioQcIlizZPHkfnr7uYrGlTSpvacAqYGMJahXZAty5Y2ye2AZG15lNrKL1WAV4/1Fap6hJWajsI7tYzawXKHrmrgzjB7nE9vEeVPguQoU8NxB4TZ2M61cfB8mguh72BYn4fiJIgxoYxVx4A8IKykRqGxC+DlIhlry943JOcF+NdSP8ZrallXaZCHliGq9Pod9bybkB45hhayG2K+YfEWxBnx2nd6HhQGOziQc0HnD9QjFDfK0OOF3FRLJnkW7mS3dz5VRUEiBgKSiJoLSpXxDdcDhPZy8RFuirWGP5O6C2EJRALURJpQgHlkgoFGRt6HgiAUBhoTj3uuWVd4nQrHHHCqpm0hwSOFEFZgTUcyKCSk+FHywxbYmpNoFyYimQrs74cz9xPFRKaMqiqm9bQ5Fa9wbKgIiCkD4dVo+T6EwSqqadoL3gM48KVnX2ibGOEewBsLC2ZRFMlS8taEeFWtFqOO8g8TlZ4Y7LIRVtdTu4xPpRiVjFCFwxQvuSfxJwqy9UIcslgwzj9dw7pzUTfPteiF9PvizXvZiWug7g8NxHbk6MxYA+iF9jvH+if7Be4yKN7D9qkWT9mfrQq32aQGOuY63xZy/zudutd8qvsH7vr+HdvCZMS7qha3fLeKuUqwU5mFDdVt69YwT2UpCCtcUrsUxqWyHdf1A0Qki2pW/+K4WLai97P9qV6lmsS+pMjrGH93hxLp+YizYMSn2wi4Yn7iVmwrBeU0cY6yaLNCE3SkhUKvzKhIreVb5eDWTUhnbKzafQCmmflURN0EO9/yOeX7XtEipAWRIdWITiP1mP+teshhaZlYlgFIKmLlSpPe4z4smfmIFVOFd2LpkVNG6ld/tv2BslnGHUkr95S9/sQ996EP2spe9zF772tdS7fTiF7+Y5NHJJ59MQgqAMioFfo+/4f8gtFI0m01buXJl23tSBVa6TfwttQsCExMT/AnA/re9IYI2YzUtLHYuk3bVRln6txaEVMiwZw+/bP8eqENisB5l0VHu3QOSvQQ2AlG1KtjDRtg3TDNyNFhVLS1zn344Qpu1UhjVgDAJpKKn515rEKmwXhF3vprmthou2Glw1x0aHgMrILF3MKc5AmRdrTNX4GhpN+S916u6+cq1h6W70mdA5ceRX6RQ4r6VhLrPXUl8GAJ3lV2BbTHTFpPdxixV8TTA5MHBJhOTlh7fXyry0pBvt631J+eUcVLDZMPVSqGaS8uSd39VVIZUNg23EefS22c2oi0tBuBKMH9YVRPGipiNyVbBiZoUMU1krHWrIVhxq1d/4bWVVmasbAydlfja9o27VflLvQoSrqew0GAC7n3QFXFYGU4UEiB5SFJoAs+uEYHtPewMrLgndQ0JNiitZNPiJVaTegokHbYJpUoQyrgP+MTDJ0sKgU9k3WWgPUgCKm5kOaOSEvunbCP0B6rXPHDZw6e1HeblSPFXX+L9DuQV9hP2JUy2UBGRBFJYJ7HzMSkKC96kwrVxjAhfRxg7+g7u7TjP14hEwj6CfDF9Zki/w45nes/6qjoeX1+h9pQVMixS/PewyDeoM1eYTWLfMICJcHP0hbD1pZlBXoTBM6LGdAy3JsotTNp3cVKIQfE4BzhWqINgQQUxs8JzuUDGTUyaDcyIwABpjbYBkQGl2qDZ+G2+aZD8ob5pyzpCvhQslrADgKDc4FlZsZ+ljRoW3EE9g7QNckC651MZgm6Eey/+FmH7UmFgAsz34/wglwoEtFRgIMqw/U5LFwkkWcGl5vTgZNh1cRrqqvgY93gn43jP1T27mJlhBbO2a1nXo1/D8VzC9a5jkY18U7M1aMGSmoQZW/gJZQetiq7c7KlopTpRNmSST05k9LMRpJVPnXBTdlxkRRGVlbEToQYmGTgzxfs3yCvEkJdB8X3Da31RJZ7Bfk/D9+unA6HIXbDqWOQNr3FkQ4pA64+FbF/EsUjFNgsiK7WmmV+eX+TtAhUa7hE9FueCQC/7mEhWtHM6HFdYf4Wo8GmJcjwiDTSx47DHry+2IxQHvB3je0b0Htk4Sdriuuj3DI57ar9Mwx4ty+s1rIKh8JKalmpjjHOg0EUf9vvCXOi29qGp9HnC7yGVPdavDx+HLqw/ZWRsDRS00UGxu7zfOzb/S+hmSTeJMUuKmdm/q4UiLXoHs5hukCr+Lnq113xgIQUmZlkQqq9QnZJ2sQNRXy37PQrIXGXW3E8KY+zzjV4MpA3dx1eg0Ex9leZZvsiH79wkbMHcr4ztkJSCPBgKp7e+9a38HUqpX//618x9Ail1e+Ftb3ubnX766bYjoKACCqtasMZowq7ruixrL+JjriD0UFl1Ei3M/mCp7nTSjQGYl7nvzLSaD/FQ2tBo7aklA632Gx2JN1oiRMJh4IOKV7Q8tFfL61aSOYEQoaplnhVWDqdbVjSWeHVBDO6ZhRKXg1QOnMREO7p6IYgkV2FB4YWqQhgQ+0pzz+NkxSscZroC3LlyH7a8ahAW0vmF50BgQBrtOAtZpDb348UK/JDV+mQYedv7ynxl3UvVeP2+R0SWCCSvBhXqpO4V185jIVkUyihOQjAZSMikHihVBX7yqsmChWWgCvStVvNFCpBodfJw1v1Kv4/EGUJc0ZcaHZUxG/3PEX+06ktCIMhUtRuVgWNWwBpWj+wd5KYgIHq4PcSY9iyRCSha0GGvLPPBqBaE8kXHwOp6da9iV1cGEQPLUa1M9jZmzkDpEKHlyt7hJLWdkOLkgKcL1d1Ushvh5lRoKQuMlj9Nykp7I67xppNHG691JQ9DuRFwLjISZO0U7nNQyCDEHDZEqH02VtXnkAFVVrdT1T6SJ8iVwuAwiiLg3OD4YvFhRPlN17dP1kmWRUYRjmFan1WWCfOuBs2mdzObAHEzQWUdQ7LxGVQ1m0bWUyitQBJHAHpdJFVM7kH44LtSi8y0/ob9RIh5EIYRro7XQTot9uDzsVvMpnEMLdlKo2rkkNpZNtOWjg32wgLVdmDhW2o2vKv/myqmcbPxm5TnJHsc1RfK18Hn8Tf0U7yXrhwQ42g/VxCWVd5AUJIYsSozLRRT7E+436YLECApcJ+fEA+uap2ssuXZFFAF4TqSFkf3Sifo3WKcqlRAJuj8IGOHSj9cWwgzX1SRvGWb+3PQ1UD+M9/7cbcNu5qkV0H2qfVbdi2G5nvbxXbajwH7J7tnWU1vlv2g1Q6VyYadEEQfJPkjpWOPirs9tqL7NZ4VMS7QfapvZdl0nBHnRYRFC/fJ3qTeJqmOZRVz4mu2nKZ2m9xc8OxGKYnaPoLjma6IJLaJVER4VrUid67XmEdq07IYS91aUFryWhqoSEBeSN6OPr4L5aVUjlxkrAibSsXbsBYqWUZfKZVIWCRYZjXlUPnLobjusyjE67i9UuB8kFbELRX07K94rmLhRza8sNqWbVNZ62f/zhiL6ZmrcU5bxT88h0D+ZoVUxvaAqd/5/4eO6vOGyHTFfALPdL8/bDp6FEEoVUV9SKnpK5N/R9W9O3s+FZE+h/Cs2sWsjoIyWxK953JFY3+z6d+YTf/OSamFAsfW2OgV+WD/m/VczLWLCdknlermVX+9fVDwOGaf59xeuF33CBX17nrXu7a9duihh9qVV/oFsvvuu/P/11/fXjEAv8ff8P8bbgCrW2F6epoV+dL39NpG+h0pXvOa19iaNWvKn7/+VSFx2yNob8HEAuG5EfCJAU51oZQZPsmAueemypW7ztWxRlIRRYOgqFDUtY0Iqw67j0/6sWKWytqrLBDZLxIyJvYlSma7oilyVTAphR0HagRXhvW1/pVVzzZoApJkbJUl6kVYJPYTX2WMldt+1o7IFopBV79Kgr7C7RaI9glGdVxadUisErEf/VbAKcGnLaa7qgztIg2Eiqdh553tgklZ7IcG0W3t7xYDtxVEvkhkjFRKvfYqh7NUXSoJu8jUmp9aLwhPfp6ZFAplnmV1iX2C1iSRnFLxcbCaVM2qbJlOWjohsxBbazKYxuRBlR37WRxS+PWJ74lKUj7JK7Nbop0iBJqTQ6kLMUHEeWGIN2xyClFnVUOQB52ZbtV++feCKJWqpZDKbmiZws2V7xQr3LyWlVVSqoGqbJi+541WRuV8hDUvcoAYVI2wcxAoCKj2zDdURyNRRxJpo5RR+BxysG42G7vVbAqTDRBmhdnwMq/Yhtwskj0gg3AsWAXDvuKceul6Ei08L+MifnDfh1p2Scc9T3bCUhUFAmyVWWMPfce41EtSIlKFBGIDdix8h5RHJOJmdF7C8qd+yO0gzDMUkRPa7jr9e40IMBzD7mYN7CfIKJBgTnz6jcnUT3APXeLnCFY6HjcIH9zDFnsAOd5Mi5wC2HHMA2F3AumJ/VO1xWGQgStlDwOxsd4MFVgR0s/vDdUqFIU4dlkouUihe3QStF0p7qSui34PlQssiNgeM3MUVs/Pg6CMa8uv91AopTY1viYbe++sqNR+F/ftIK2x3fb7Nm1kyeKB33v8eup3P+68H1SV5fxZGPcYfp7PAlej9qp0G8RXVf21vVqbt091D4m8qM4qa/5e2LmClA2L6kxlke5RIa3rOibhPdRGdPsxwK7caTFMLdGxIJXaFv0Z0l41tbKy9WvP6hnUuW81L5wBVSbHEP2fCQux2pdjGD4W3Srf1h61ftWK47kbRUJ67ki56OcLc6G+q64XH66J9JNlxa3SU3qtv5UwLOwOWZ2RJ4rcv7Iqnk96Z8uW8v7YX8nc3l7of76g2f1H7Kts96r0XB9YbPWBRR3fn143symopPQvn5/Rnn7tlAumXIyA1WcrZ8tkZGwp4Fqf/LnZ1C82bztTf5jtS+b+/KRH41izf3ZTrXmg1TDu2aJI9g2kV2DgSP//+P9YwQXIHu+f9bX5qTLn3DsQexwzJJj6ue2QmPyl2cwVtj3idlVKofIecp1S/OEPf7B99/UykLDcgTQ677zz7IgjjiitdMiKev7zn8/fjz76aLvtttvs4osvtiOP9M57/vnnc5CG7Kl4z+te9zpW5htg2XBjpb5DDjmky7oHDA0N8WeHAC1NXlYedpj+6pFY/Y1Mkx6bKleGu0Msu1eIFcLLiUg1mfbVQLzuq+Hl4KvMGHBVSqelr3NV2IktLyPvlcFUySpKOZdkzmwDp5Cfu4IsciYK5Mtwkq0BHmXx9Vnbomu1tT5irdKOEgRN935w9VOrDZ0rgOn704pQc0MTKlbD88ppC1tl1kSfCItnVVWvtM1p1aYoiZ12RdSmsOy+2p+QcfOET2SkBHKtb/I3z+ZgthGVHCoTzYmrr0C3CihFnKBswepE5QAmxLqGSuJtoav1ss3xfMTKeftqcUzSuipklhMMQFXLSARFZTxM+nF/Uj8kael2HydrEssaPs+w9vbvoM1UVal8+1LuIXukttRqA2EXVEAu+iqtsaFqkZ2rtF/IVlKG1FfKiLhG0muZdgtMHKl2GvFJMgl0BVFHxg0nIziMUbNFe3rVPVSBg32L2UQ4VyBSMMGRiiiqh6GK37isi5ycYp9AqOxiVsM28Bm034Aq0YVVbjJRWGGwg7bFYAgLFsikgr1qpX/nZJAaDX0O5M8yV2lNKigeqp7oe1AYof9NgYADiSU5vOykJMkKEGDTia1Pf+O+rNN+4u8Ns0FU11OZeUy42FaLzaZ2lQUTA6bInVK4PdRaIJdIRuF6xuICLGCorrhIbbPIqxxCFTeAypC477ndhv2P3yVCtLPPsxuMWkFCC/0xCR4vFznUz1Va3u+3sh/SAkU/js6prsWyiAcsbThe9Hc8C5Cbhgm/b98t1Oh3cWvqRcA7iUvyhn0NxJdyueog+hD8XG9bAHHb3ibcCtL2maV6XK8qRkGelaHjvsJUXcdQmuE6IPmHZ72PT/gZkta4T6NCUrLTXOBAX5B1iwpab9843lAYdf6eovO+VS7SlPveeyJQqcA62wbfH+MBVfYtr60ei0q0XHqGZu/nXKh+5yYN5wP/jgj47mXh3rRhc6fSLi340h2Q7hmDVAlLrefjFympeLzdCztVlmgsNHUrpitb+8KVUH0VZSyAEgHnuv55fboytc0h22M82a8t2r8rQs997JiSWtVnMN5SdmjOkdppUExeZNbYx2qN9iiX7Qm0xc1cYbXB+3T+pfONc28L1fUw3t2EoO1i6hKz2jKrNffpsd3LzaZ/778MHp38ZVvYYPsQSkMPNps4xy2F4982i/ZTtpQNHGa10sbXz554ixXTf9nM/esgpPh17d9XwN4Hu2DzYA+Lp1J9Zc+29vdfbTZzk9XmE96+pcFiQtsfblel1Etf+lK74IILaN/705/+ZJ/5zGfsox/9qL3whS/k3zEYeMlLXmJvectbGIp+ySWX2EknncSKeo973ONKZdUJJ5xgz372s+2nP/2p/fCHP7QXvehFrMyH9wFPecpTmFP1zGc+037zm9/Y5z73OXv/+9/PLKsdGbTaYcDYXMrVp7kUK1W4dm/WuMyeaPuOCAntXMGKyUf7aq8jgo3Tkr8YAM0lsU9/x+dlRWRFGQzSYwDrirB6c3SOAaJseLCkcRBfynyUURQCFV/d7GyLzpXCztVW/N0DYueye1UkxZaBBnBYHZznamaPvUqytmKVPgnnVhUkTgg5MfAqYLPlQM3rW6nW2UTZqCwgOJe9M8AwQJYViAPTZAWaE3opSaAuml4vlRtZk3IAv3C7gibcHAT3mohW2RydkzcOqqngwb5tVLjsRCkRZtg7spRAtNSRk1G3ehMWS1XwwzlC/hM/v94/n34zvg9ZQFBS0u6qFaMyrySysHCOVSqearGYlEnVgv3USjjvNyDGqJSMSUKry94SIbq89kGANJdYHeQOiBKEmSNja2DEs6LYhp45VYMdDsHbi+5EQqUGsgRkAo5zAPkCA2aTsOKtcxKISkvY2qDYgb1vwmwCpA6+f6XZ6L5+35i61YPdqYxCZtOAiKKb9bNex7E8CRqHkmejq564QtfQ52tSOw2bTSJA+BbZEzW5RnsycP0qKVREqLJ98TmQaeOJUgrHP6z92iPZP5ANtylrDgTRtNnYjWYbrjcbX2s2vNhs8Z2cdGBWUU0ZXLJ3goyCsirsmCpVTzUt/4b+M2A2vNJsaBer43wAVCa5TdarJVYZd2ED5bWEQPKiJdWSq2AqwkIkFPuTQo5DMRXV8ZgZhr6toh0sCABlWtgloYiDEgbXshO/URyixX69gW3DSXEcY8/rM+5z8bxSJlMT989Q87nFk4Sdcoo8I2th6FSQelv4fXN2JDlPyk2MbXA/QDoyxBp93hUhs+0f7+lNqNtQXMGzj6jiaXteyvjYWRRlAWhXRzlZ0P9YFSPAUwsla1hVQvXS80jmQX6FFW3LDWfj3G3JTKJeSrt+Y4NYIOIYhARxsjjGRZDeY7gojuILkLMrprfQUXX8RJ/AsyKeje2q4X6KqGiLCC5Pz3cZZl7aafvsDdVzeiagkm8flV3GHQfeL3CP3I4dLQCCyHtet5vQP2eQG4kFtYUCzzosSl7b/iqur8mfma07zV8YuJfVGlBzb0tSqgea+/kizvDf++8T51gxrfPMRTgnnEqA5OmHmRu7Q8tb61SY5eotc5+YuVKRBCqgxoXw9rZuw/RVPfK/tiyKmWvKhfE2oB9sh7hdlVL3uc997Itf/CLtcmeccQaVUWeeeaY99alPLd/zyle+0jZs2GDPec5zqIh6wAMeYOecc44ND1eVZz796U+TiDr22GM5QH784x9vH/jAB9oq9n3rW98i2QU11apVq+wNb3gDt7mjIoKy8dDvUmD0QBmIWdoVusNUy6p1Glz6a8q86SBnGLrKPKl2oqYkkzqIpoVP9qVMCgsQJzFBNMxPGRQTBJf/w/sb3V12HaysLlhldPvDc1MGN+Pznssym6XBLZsNazFIenIzqg1uGaRZMt19SZWiuPrqpFmrIy/DQ8ExuB9IKqPVZFcDWbWG/RYqOhz3gvYNGTYktnqF0McKcO+2Y+YS1CBxHFRtRaGCIAJikl9NTOL6pIKChNtk7wEPJzGe28TqlcwOk2KkMVBd2imRwN/dqun2IFx3sgA1KnuIqx06JwndGWOlJYW/qHIY7W9SVZYEdNhaNGllZhCKGoAYW+SqGRBMVIxgBW2prGdSNbCIAaoKYkCAgcquHqrOQRiCzvH3CChH5bhB5TjhfjCWFHLYVf/HdteYTV1X5taU5wkkEpRXsBNOY3sipEgeYZCM7bntiUQTw06jL2D/QCBC/j6WVN2DfRI2vAhfj++cMBtXwCZVNiLpYW8jAcuz4flbaDwcK4gY5oXh77JOFlLEcP9kHYpcvpmWFE9BOknloOw8ElhU4oXasbObScXBP0A5Ef057N7IfgqV0sYqR6zc/1DyeP9qBXlEwgmkWyiHUmuryKWybH3vAO2qXDyI3cGS1KlsVMpn6qES3hS029B9f30CPhuhL3ImtT2W20Pb4XWcT1WP5ICyzgxAZsz1WNjpv386x21EzuwqldmR2B/nzOLDsUgFp/vlrAtVGmd4f8RzvHthayGFW3ZMhDIK/y5lgT0niu1ZUr2xKVmV/bcVBQbCdh6h4/7sQOyD/7tjX2HZxDVMdX/nfvg4NFX1+7g0+kz3ddQZ6s8MORZ7wfdAYTyLpTJjx0brpsr+1lMlu+lj5c2BXw8Tc7wHi4TdFeCLYizJc5rre8b6/w3jjtqSqu/3U2FNnme28VPV7yNP7HjDVr52EFFQR6ZnB6BmRnGVwfuZjf2nV7ybusiVSB2jELY31GjxO2yIG/7NbPjxVht5XMd7xyqbY2NPs5lrqBT3KIhOdxGeQVEEacdCAcshSLzGtJnUWts7SX+7klLAox/9aP70Ay4mEFb46QdU2oPKajbc/e53t+9///t2x8LCbhQ+YJl9pSkGPJUFJ/JWujM7tkxY6dyD583dJAdMLHQ20zH43zIkS2e1tR0B/UqHd8Ir5jW2i4F/rwyMWG3tVMz1Or4aSJjack7O68zmSSpiQTXFcydL3ALQaUXt/vvs2R1OtsUkudY3/LXMOkm2yfDYBkge5IYM9giJHEkqlWkizxwWLx5QthOseSW55xWySjsn2xakF8qVQ93iE8POSoRRKCFIONqrEuLX34vmB6Ej1QwnNSC3uRNOmozf4qQOrGWw2pbKisJsSiQFBhAgt6gWKfx4xqecIOJAEJP2DW4DZKVBqK1qZtMgWqCykpKKVfRgncPAEGQOFjvQJmjLyaTqHt6HAcvaSvkE8hIDJpB9qHAFchMDFyiLGDJeMxsaNhuf1HdFBT4MIjfo/1HpEtu82awl0oE2QpwzDJQWueUR+4Sgc7QRwtVB1ICAQ95WE+2BwHUQWjjHsCuCBIr9wXtBzOGr0JbYZxwrzvc4t1MUK6wGyyTJO/Yg37+6D86gzAligUorDno88wfXn89JoxR7p6VZBEOQYOyHqMiJPqTKjGhnCLAKvB4V29DvoXyorgWqIVmBdahvaHYn3BqH89CQKraWXEsgd6pFrhb6OCKZZ8ncmT9iv1MyYTaiKN3nmOTjT9g/9GNcQDiWyBTrfy/vDh1Pv68Xeb5w+OcWFiLu5zzygGb/3hhntFiYobsa3PaILT8eiIq9UbGvPf8xRSxgzDcLqiKxWpu8v9XiCa4p31/9pc/2IrAdz4v+6vn27/D97H+9h4UzyOnkvrOFx6UZ2xv63BNgn4IKZVNDrbeEamauam3IJOqlYpn8lRWD95ozRJt2sene2UDF2JfMxj9vNvQ3Voz8I9XevXKgWjM3m41/zX8BKTP6NKs19rJtiVpngHlthRTseOattFprrRXNw8ymfuLnlaRUB1rXyh2ASKBJJ6SA8c9bMXBPqzU9FoiY/NU8+s8vFA9xlBksj515Ur2wvRE+MxFg36OPbae43UmpjE3DQgYf1Wc0yejzkK4GmB2DidtRIbMlwAk9dz9W23pnU/TOzpodVWZQ5JFsv+002yRlLrXZ9og0r2m26kvtZcd7WCiao1Yog8JzmbYtfFLZKw8HqhIQN3gwu0oklIxlbo+sVphU9880Q9WrULyBZIDltF3N4RN0BUxTfdnoqIC5SLa/9olhRUjFNjTRaVUV2aB08Fwyyew5IQFJsViTjEal0pzG6jbsU1OyV4UCB2wFiBlkS2lwQBII75e9jIqqUbMxEEDYFyi8QL5gIIZMHlkNyQ2gap7yBCcVsE7yKUh4kFFhK8LndxN5dYP+juyKutmQLIVoX5Bp2F8SO9gm2gA2OOUBkdBaIYtgqLmCnApl1pS+F6ThiNngHk5swbIH0mkIdkeQa+O+TbRXGXSO45pxRROIO0z8m1LKSTVgM1IG0uqJzDIoxkTYMBh4UXtRB1ThUkWvSvEThKQUYbDToUIh1XVRmKLeX32pKmJBPOH9VPEFqaXy7lEdLAhYKvOoCASJPNh3glplzM3I6ivlF37KirQqGFBWV+28HrcM2kmb2bfreXKoTueqjir7R6QyiDneDyJXsb9lLVVSb+3qQAsltDblmRLqnu35+dr+TOpffXW2z/YafwRh6Qqk/mqh9vfPhlDER6RDWslu84jYuRZo4j2sBjmLurGTsJx7vNtZYRoLMot1n9mS0QkZ2wOYJcTH+CyE01a3RSEj6tr+eUDzsdf1IqSqP/b5SFIpr49KivsGQgqYONcMeUozf7Zi6FirjT69m7ig2qxmtuw9PRVa23r+V2vsYgXIqFIljMfo4U5KjX/RivEvmi061WqD967uYVAE4XX8dGLjp6xYclrv4yjtdR1/S1VlsxBSBVTLIK3aDmCe7RVOhq2FYqyyLjYPiBdte8b2OdvMmBc2Z1Wr/9+7Q047Q8h3RPhKW3/rX1nOnhfs7BXl2reLG2J7psL2iG05Sdm2mF2B0PXunpPlGomp7QmlZVWBx+kqdBVIj0m6Ey0std7HdugP9sghq0v1En0hPqP+y0p5hbVqCICubLgkpkr7VH3OcODKMhZht2T/dHBODvjkO6nMpQkXQ7hbSz14OxQkzUVukWTouaq/YdA3tdaJqOZyVwSBYBlZaTatHCIoSxiQjawitCVImbrnS03cKoUc9gHWt/Uih/Agx7+nZe9zJZof9xL9W4HwzGwa9u8dRB9abDa43MmpKeRBQf0T/XORbHmDIqTSAHTkH+7ux4H7CS2dUIWBhFhuNoISzMNmg1JmzUCWDxXYsNnQcmZCOVklWx+qAWI7IOxIFun8sCgGLJSe31QbWGTFVGQ7ORnSpdopK4K257y0ZcmkFs05rsXOog7ej0GKgcBDhliVYRXqO68WVrcWzt0clS2rvjRtRQuh4F6hr2h5Wfq0kMW2UH/O5zvcxuGkqCtTq4DqMg+SCka9SkJutu1u38+jhaJ3aPr2h4pAWtj+pmRWv/FHRDDMVx04y162KYgqddO2aV+3ZXqGZ39ird8zZpZtdhBq/RZ7Mu64cEUsFsPGZn8fCSM8D/B830TMIA/IK4f27Jt9SLFi+k+Vvb/cb6iV/2DW2Mtq9aryHO8JU78xG4AyCItf13dkFHVUXcXfYHkb/5+Off2z/3/iPCsGH2y15v5WIJcK+zHxv/63xn7dhBSC1OcRvL410KayBqCUSjH2/6wYONJqLRzzUrfkheIrMPpss40fN5v5o9nUBR3h7fNDjHn4//GzzZC9tfilVmNVZPxhU7K9Oucvc+zDzDVm9dWbIBDo1S83dlv82McO36SKir54fr1Zfc8twhNkUipjTuzohNR8V/A2dVA2n0yv7QM7/nnsTYTcMfpo98A9CRvv2YfxHg+FnuthhfBXZrPwIaTgeuY4Bck1IKIKihpMkD17p32f5lKipSvbA8z18uIEHnZNYotZR2nAd4dFpTlQWuhSxQrbY2DYCsjKUVGO+wg1FWxggyIzQDyhUiAGYb5KXuZj0TKIH2RTjXru0hjCQmETXOlEEgezsNvdbFZcJ2JKfYwKur3Mil2dxAIRhG0xLwkDw0mplBAgDnIHdjaE0G8wG26ZTe+nbC8QYmtE1InconLqULORu5gNr/LvnFjr7xsYdWJNljha6/BvhMZP11ztxTBrz0kicdHQwJxklFsxyyqOZai851HxnA2MuEWur9UrXmtXK1TW0y2gLmJ2FAhWhHIPdKnvQjmFftwC0TSreleVK9Xnom+m9tbtwY6cwjPvUCFUxGyPBSEnJYYXsLjUnRuZsfWxKYVNKnJoNuJly/TZzr5xeyw85n55x0fBCs+9KzzGAvBseU8F1Snd4/Y0Q4kT6pSAomXuhp7bafu+KVV976G08u23K8+hhkGlWf87LtTxnpEneL0kdvqpYGCXI5wcKGC/W/f6amvDT7DayGP0XgVhw26GsU9XkHfRXoFww/uT6AGsg52q1xKMf8Ns8QvMUMEPAEkGNA/s2tVaHWOT7QMIXi+GHmE2+QPPlmqhct0VZrX9PER+8kI/7voqs5GnkpyrNQ+yAkHoUI1t/JwVA/eZZaxcZUa1Lb5FlbrJ71dk3/q3W7HoBU7k9doU+uUs6OxDs91/CxCoUIHV11jRPHiBz5Ye2wQB1et32CIXYHX166rueVwgQ1l0aXHf62m+yKRURsYdnOBoD8u+Y+GOeK4Ccz18FmqDKa125XY7q2fC6gclTbFZQfqdK9UMKy/3t5OM6pUf11/xxf0iwQaLFogpKZdYBRNFDaQuYwYRn+gKBh9w4gYTMORPzSzxPCgMnPEwxWuwfKFtQAxtXOrEEKu/Ictpib8PRB0G1MrV0p5Z0UD2EwgkJ6R4PM0hK0BmgbwC6RJVtCZuMVs3KnUU9nMPs6V7W20klGFmxeBiK2ZWldUMbRqEGooTgHQatGJ4t5JYCqulVzoc9raZASHo+T0eRpy2ZHOT+1Hn9bYlrG4kZJB9hn4iBUW36qQ+7+/cni3Hs8HJuIFZ23vhdv2MHQUVgbr1z9vm9KuMjHlh8hdeoAS2q55ZSsXsk+DJn/v/k/eQzErzgDon2B2EVNt2OrbVV7FKAmiPKhgaGZRTv7Vi4CCrIYwbVf4wCS+f/1o0aSHf6UorBu/ZRrZxm/hMY48uEq5AJMGGs9p3Ava0oQdoZJYooXqqsRLyZOJbccD+v/qdzAaONFvyRidsBo4wW/9Ws6kfWzF5hNUGj/H3BTnVuHP7ttuq792eSMaoo08xG32KFev/1a18kz9ihb4Ci4sT5/ubBh8iW58w/EiziW+bFTebTXzTbPhRvb8Gwedl/0jJRMUWpCos2B3XnWFW382KJad3K4zmsm5GHyoxi9tjSgQqQuuRlzVwV5s3UDinJEG3MHBdMRJll4oQrrfvW3m9Nu8kl8Hc2PFGbhkZWwl39IHZHf34MjZ98lv2D2bw1Lb7fucEFVRX7XLz+REWeJAiLL1Dqi7VD0mfwQPK1bLubfZ4bIIwQn5TL2UDFWfVdxWN3awYWe2WP34WFee6c2RqIMRCMVQbaasUiqykWY8Rtr4dCKHk654sL1x1kpGxIyI/nzPucGAOZIUCRBUVVJuKzcvDKa1KHdlUNnCY1eqLKxJoBqHZa6w2cLcqT6iY9M+3kQnJPoVii/EErjxmttPal/nrtVErlpxR2b4AKHhgfQKWvsts/Xuc3Jq8wGz4WM8Cmg2tWxT1cKvZ9O/b/zb0MC2OHViqoIqhv/GMKWQsgaTCWGbmsnalVGM17X3bDXo5XAaPUuj5xVYUT/ZQcloUh8yGHtj+cVTPGzrO23rss07/9CGm2B8aq8xgbQxM/d5s+ldmrWt8HLfkn802fMiJKZy7De+3YvGr52fTn75c9rmO985cacXM9SQCa80DrJj6rcdCNDrOQ7HeFUpBtII4LMat1o+oonLp5va+nm6OVXzT32+1Wl1Zq/NBZNHy3xusmLzYLaiN3fWGVnJtZFIqIyMjI2MByBOjqh22liql3PZ8K2AGAXcHR+57GRkZGTs+Oie71R9mJ6SYc8QFmD7ZNpy8X2s29hmzxkGlzY05TbCkphXWeqFTWRUAwUBSKn0tjqGo1C2q9uwvx4R7nVkNxVU0BgCpVD/A/77xE8n7N5qtO92KpW/zf098xwkiYPErOZEvho43G/uU2eRPXBnTRwVGqx4rq02350c1DjYberC389Cx3cc58jRvAxAsE+eZNQ+RknwpM4scW2Pxuj37aiGo1ZdZgfMKom/qj/4iyEJmbCFs/s9mE1/314f+xtVsnRh+jNvwoJQCMdU8yI8XBW94Hqf5PURKSAVCJTX0UKs1D7Zi6Xs9p2rdv5hN/85s8nwrBkEi/sVs/MtuoRx6GFVcNSjoAyCegE7iJ16fuZGFiVghGpWaGx1VCVld8PLkc3OQln2sgVDo8RqbudpVYNO/cSvi1B+sKAnaUPld40TTXGNctmOoAoOUWjiyUiojIyMjIyMjIyMjIyNj8zD9WxX2mB/KzCZZyYrBI7v+RsXw9NVm699h1rqZ6piiAQt8Sxa4mhWLXmi1waMUEH4xlSK1gY6A7L6Kozt1KbEKWp+kaE4JqRRTf7QCFfhCUaVKZwWOZVpV2UZPMdv4X05grXlR++eHHumKLAC2s7F/J7kBZUsNqp1yZ3z7BWxqKdnVtq2jrTb0oNmt8sN/a7bxI2bj55oNivhqHrJ1F4U2MyydhF0SHF9DRWmopZAvte50vYrohb/p/jCq+CFXavRpnm80+b9m696smIjYr5oVo8+w2tBDuncdlQupQsP2j9f3Q4F2sBUgnmAN3Pgpz+oCSRaAkstGrFj8QpFoaQ5Z/2p+hvyo6pfuv7du7d5Hvqb8WSjLmIM1YAWqAq55tRXNQ80WPdffswHWxwutGH6M1Uae4P0NBGV9lRVL3mw1kJZhY2zd6DlmiPVoVAH8Hd/e8buKMPEYi56KydmQSamMjIyMjIyMjIyMjIyMzcMCXHYMogaxk5JHCF0u/32JFZjUY4I8/hUnpAJjn04Ij4IT7oLvuUUT85oVi19nNVSRi3epmEQbCcPsm4vNBu/VvnMRAt5rv/E3ZDUNHtOlLSpATE3+1H8ZAFH0MCugzAGhRiA/cXe32CVECoLFqeJBJT5Y0hrHtSldCiioNn66e2dqK8wadzIbfHD768jymb6q/TWQOWy3W80mztFr97etis2pctiLrgCBOXKisslEeAzer1slRRtiw/sDABIGpBSREmWF2cb/tKJ5OInAKgdsH7Pxr/ff/siTFUT/g3ZCipUVoQocM9vwf6xoHtaecymSpmitcZKpsU9v+9/kz1VV8BtuxYMSrBd5iDysXlj/YSdCp35qtu5Gv3YKEZHjX7GisXeVxQW14PgXzEZPam+Xtv/3Qq8w/8tccRbqwz6VKHshk1IZGRkZGRkZGRkZGRkZWwzMsqHyqXvSXaBqGuxKnda6TpsfiClM3sdFoow+zxUemEgHKQN7FzJ+aGsrN2S24d+sWPpW2pWKsS+ZjX+J9ila5TjJT6zxkz+zAgQAbHUIzA57IMPOf+mT7PqeZjOXm234oKu0Jr5jxbJ3MIunmLmO2VE1qGtAKgFSfdUGDrdiOfb5Bq8MF8fdiYF7ipT6uRWwAk6cZwUCywfuYbbxo/6e5uFmi1/qgdr1XfuqnGqNvazoIKVY5Xj47739AJBj2HZUC5ylIuKmoLaAim6zbofVm4X6aqvVN1qx6J9YCY/nBIRTZGOJTKw1VouETEg/nHfY+JDXBCIPNkAEiKOa37ozrFjyKrOxLzMQ3hoHms2ImETlv659GqQCqRg6wfsVAvKH/17Vl6fM1rzUrLjNz+XAvUkQ1UTQFRPfNdv4cRXm2dcK5FwV0yQNIxCfeWEb/q3qSwguHzzaClZhREEi7H9vkPAKpR4Q2WGqREmwDyckGvry8KMrkhWVIX1r1XaxjyBw43dYKid/zD5U7k9YIJMqhK6emhuZlMrIyMjIyMjIyMjIyMjYLBRTv7Ji4xUMnQYxYlM/M2ugeMhGs/Fvu7WueYDZyFPnXymV2UlTtE1BnUQSIfKURp/kr4/9t1ltuStkmnf1CmkggdY8zwp8BtXaAJBZUAthEg67G0iN5t6u0EJeFb/vbCugjEGe0bp3mxVS23QBld/OtaJxkNmG9zFPqFj0TAVjN5xAaismkwSd9yOlxj7n4dr4ARjqraBqqKFGTya5hFDyeQPVBKedsIM6i9ZH2NKGjrVaE9V8x111BJJqewfzry6nNZNEHwgaKI2a+1itsYsyxgIdhN3Ik5yEax5a9j3mlKGvQD229tXVe4OQgoIK/WDgULOp3yWbHqStkn9bfGo3+QcFGvKuoHBDhtg0VH/39P42kVTzm7nCySdg48fcYjn8WFeCBSHFv/27Ffid/RiWw2eRpOL2oYgauLsTkcgfw/cBDV0Lkz80gzJq+NEkRduOc9ELfD9Bzo3/DytNtlXBnrnGCnwG102abQbF19o3ebtBebXk9VbDd6R/hzIN6r9WYkWdBZmUysjIyMjIyMjIyMjIyNg8ILcGhTwmv2fFkjex4lyB0vDr3lDZnBAKXd/FisEHcLLNgHDYpTBpH7iP7ERfE7nTNJuWpW/470juFJi0M2dpwGzgfk5KYHKdoMDv69/pweJBSA0+jDlDbgW8hsHXfYHspX6AeglWOJAJadg4FCdBMDQP7h/aXl/uPwiuxr43ENJeuI4FJAJzubCNQz1Mm995lBmyj/pVeuN29jODUqvTakYip1KRMWsrLJP4G+xq/hfbIoB1EFlEWwE8/8m/y33uUTmOOVrI5sK+gEBCqHhkeMV7GntYsfSdIjGv07b2dGsdPjf6VL2xo+oxg9JnyYdCXwbZE4QiAKLJVD0P/XzooX69gAQqEK4/430TaqRiTRXUPvUrV+hFP6bl8GOeZxUZVWOfsaK+qlIQAlBeQYUF4jYBCTMQVSBzUYkRxwLV2cT3rBh+XBX8zjfDovjzRDWIfUMly185IVUG+b/VikXPd0vt5PfMUEUQpK01rGi92OaDTEplZGRkZGRkZGRkZGRkbCaiTPx6t0QNP9IVJiCkass8YwgkyNj/Mxv/VjWxxWuYKBOwMHVM+IeOpw0OqGESPfq0Wfei1ryzFUveIBXMWKIyqnuGFb4fdj+oTPwTtPTZyFM8/ynIIBBGi1/jFkDawQpZtFpmjW9VihpUsYvMHmDgXhVZ0hlQ3TyQ1sFC1dRgNWOT4XeEUkP1Vd/FbPgfnJADMTBwZEVIMdB6ygwh65O/1EbrVmvsaoafFI3V/l1lw+izWxFUyG1pIGyb4fP9EG0z3NUP2jLM4tiRNTZ1qb+nvqSy7jX3Mxt8qHKnUC252Z8ywXlL1ENtgEKotqTqXyBESeisMRt5oofc47wsC1LqNv/+yfNdCchDQh94NDOtbJ0qN6Lfw1o3+V2/RvAdaG8o31JCCtcQlFS9QJXVg9UP606ENg5wsnj9u6xo3sWPF5ZYtB9sj7h+1721vY8Di15qNv55v5bWv6vHl4Fo+7zNB7WCpsWM2bB27VpbtmyZrVmzxpYu3RKBbRkZGRkZGRkZGRkZOwvmO5/44Ac/aO9617vsuuuus3vc4x521lln2X3ve9++7z/77LPttNNOs8svv9wOOugge8c73mGPfOQjy79jqvfGN77RPvaxj9ltt91m97///e1DH/oQ3xu45ZZb7J/+6Z/sf/7nf6xer9vjH/94e//732+LFy9e0LHd+ocDbOkerzbb8H+7bW9LTjOD1W392yrSx4bNRp9shkwmZO1QXSG1yuB9pCpaZda8R5WfJOvUfIEsnNmsgswAItk0WGXyQMGFfKtFzyVp0fNzUI5sQKD0WrNFz/Pg6IlvOfm27F1Wg9IG+4/8Jx7TMqsN3KU9c6teVQnk7/MBbIBQ/Qzes1SxIHOoNnDXebRFUQWxAyD6Wtc64TN4361biW8LoYAKB22fYvDe7Rlhs32u1rAaqh3Ot81RxW/goPb3NnaxWvPAWT9fTPzAs6NgHx19phM0xVjf/gTQfgdSEqTu6FNLSxxDz9GPQaCBEEXAOt4z9BCr1UatAKmLbDaQYfie2hKqwOaLAp+FshBZaZ1Af8b3gwSr7+Y2T1zbQ8d5kD+uRVwHUxf6+0FyMQvtbmZrX2dr143bioP/Mud9L5NS80AmpTIyMjIyMjIyMjIytuZ84nOf+5yddNJJ9uEPf9iOOuooO/PMM0k6XXrppbZ6dXeO0I9+9CN70IMeZG9729vs0Y9+tH3mM58hKfWzn/3MDj/clUX4HX//1Kc+Zfvvvz8JrEsuucR++9vf2vCwK0se8YhH2LXXXmsf+chHbGpqyk455RS7z33uw+0t5NhuvewkW7bHC1yVgnLztB5dRYVHbejYShG07i1e9n7Ri62myncFyBt8BqoNhCenVjUQDsiiwgSYNqWb3f7WKz8Jk+ipJOi53MawGexcnVXpZkOEgM8DJAugbKrvXqqfmOEDkov/Xt5eDRBh0LUhz4jqRZCAvOgkXwCQdVDgQJ0VBNPgvcrtzLmfyfcgjJwKsGJDGcS9vYMESgRps18cPK99J/k4+TPIp6ymEPo5SSlkSdUWuaoJfQ+VIKFOitdaa6U+m2kP7C+/0/tODZbW7VEHNHh3s+k/mrXGPI8Lai62bc1toBPfrqyEzUPMFp3aTqoleWUFrKPo6wNHVFUjN3zC1t58bialthQyKZWRkZGRkZGRkZGRsTXnEyCiQAb967/C1mPWarVs7733porp1a9OAoqFE0880TZs2GBf/epXy9fud7/72RFHHEFiC5PiPffc017+8pfbP//zP/Pv+P7ddtvNPvnJT9qTnvQk+93vfmd3vetd7cILL7R739sVJOeccw7VVldddRU/P99ju/XG79myJUNdZE2b9QyBzMiZsharotGaBSVGC7k6fZAQCdV2x53wSmxdUfGtJBtSUoj2tv3dphRVwuYioECEYbLdCQRcg3jrRRrx7/u4lRH2vZlr9P179a+8V9rLxrXdDVT/0JIFAiqOsbm31RBUnlYxZEW6PvlVvb5n8kJ82RatkLctUaCfMP+pQYtbDZUR5/tZ9IvaQEWEoppdJ0mJc4TzsMD26SK4ku20Wy0FEpQDHrI/V0ZXPyK1PiLr6HrvMyniO2npxPmueU4WbX4gnXa1WmN3v45AqKG6XgdYoABEHvpx867tSjr0Q7zeScaBIARZJ6J57VUvsxUH/3ZOpVSftLSMjIyMjIyMjIyMjIyMbYHJyUm7+OKL7bjjjitfg5UOv//4xz/u+Rm8nr4fOP7448v3X3bZZbQBpu8BeQTyK96D/y9fvrwkpAC8H9/9k5/M01IW+zt4RFUZTuqVkpCqLyIZgPBzKFtISJFvOtBDvWfdcEdWErc77J8NgNwq/+37QLtcfVTbWM5JdZozVL1/V6sN9rBIhipEKiSQFPxp7N5tl0u2C+sUyCNY+PB9/JmFkOJnYBPDZwYO9++AzQxthWOM8GmGliefae6/IEJKB2s7Mmr1Uas1D2Dlu4UQUr36Ulf+FbYJMqezP81ruwqYhw0UfS4soyASce4HDq6+F+cX/T8C4ZsHaBt+TZTZYAOH+j7Kbhj7yGB735LVkIMVRCXINvUzXh/4HrbVgd4H2b/ubrWBu7EPx/tYlbAHYA2sDT2AFtNaA8RUdb3VULVSlte41vk61GU8trr/e/TkeTVfDjqfB0J6h1WAjIyMjIyMjIyMjIyMhSDmEf3ifG+66SabmZmhiikFfv/973/f8zMgnHq9H6/H3+O12d7TaQ1sNpu2cuXK8j2dmJiY4E8AKog4xmJ6o9kMlD4gaVZLrbHaalAPjcVc6tBKQTVRvcb2mbhIyqgjOr613zzs0B7vAaGwi7a9b1kcr/p7LxJsbffrE5Ptr5X76igmXJ1SG7o3t19MIvunZbWhLTtnLKYn1abr5sxOmnNbU9NU1fg+72xz2ziX1XFX58zPYXs/WEj74BqrrjPaVHnORqxWw3Ya1Xbb2v1QfW98Z2RBrerdZ/naIX6d1AetNrBWlA62M5ac3/nvu+dUbXAiDqTd1O+p9oMNFfer0o4Hi+1U9PnO6/ba5PU9yuNY13qimb2q730vkEmpeWDdOpdmQj6bkZGRkZGRkZGRkZGxqfMKqJV2ZCCj6vTTT+96Pc+VMjIyNuW+l0mpeQBe6r/+9a+2ZMmS7aIqAVYhcNPHPuVqgLmdd2Tkvpzb+Y6C3JdzO99RkPtybuc7Eran/gylACZm/TKaVq1aZY1Gw66//vq21/H77ru71aYTeH2298f/8doee1TVuPA7cqfiPTfc0F7afnp6mhX5+n3va17zGnvZy15W/o6qfvvuu69deeWVOzzhdkfpb7cncjvkNpjvfS+QSal5AJ7qO93pTra9ATe7nfmGt62Q2zm38R0FuS/nNr6jIPfl3MZ3FOS+vHO182yEzeDgoB155JF23nnn2eMe97gy6By/v+hFL+r5maOPPpp/f8lLXlK+du655/J1ANX2QCzhPUFCgTBAVtTzn//8chsglZBnhe8Hzj//fH43sqd6YWhoiD+9jm97aOfbG9tLf7u9kdshtwEwH6I6k1IZGRkZGRkZGRkZGRm3M6A+Ovnkkxk6ft/73tfOPPNMVtc75ZRT+PeTTjrJ9tprL9rngFNPPdUe/OAH23ve8x571KMeZZ/97Gftoosuso9+9KP8OxweIKze8pa32EEHHUSS6rTTTqNqIYivQw891E444QR79rOfzYp9U1NTJMFQmW8+lfcyMjIyNheZlMrIyMjIyMjIyMjIyLidceKJJ9qNN95ob3jDGxgyDnXTOeecUwaVwx4HB0fgmGOOsc985jP2+te/3l772teSePrSl75khx9+ePmeV77ylSS2nvOc51AR9YAHPIDbHB6uqsF9+tOfJhF17LHHcvuPf/zj7QMf+MA2PvqMjIydFZmU2gEBuewb3/jGnrLZjNzOOxJyX87tfEdB7su5ne8oyH05t/MdCTtifwY51M+u993vfrfrtSc84Qn86Qeopc444wz+9AMq7YHc2pnaeWsgt0Nuh9wXNg21Yq76fBkZGRkZGRkZGRkZGRkZGRkZGVsYlf4zIyMjIyMjIyMjIyMjIyMjIyNjGyGTUhkZGRkZGRkZGRkZGRkZGRkZ2xyZlMrIyMjIyMjIyMjIyMjIyMjI2ObIpNR2hH/5l39hFY3R0VFbvnx5z/eg6gZKvuI9q1evtle84hU2PT3dFYJ4r3vdi2F7Bx54oH3yk5/s2s4HP/hB22+//Vh546ijjrKf/vSntjMCbYUAyF4/F154Id9z+eWX9/z7BRdc0Lats88+2+5yl7uwTe92t7vZ17/+9dvpqLZPoL91tuHb3/72tvf86le/sgc+8IFsw7333tve+c53dm0nt3NvoJ8+85nPZLnnkZERu/Od78zQ0cnJybb35L68dZDvqZsOlDa/z33uY0uWLOFzDWXKL7300rb3POQhD+nqu8973vMW/HzcWfGmN72pq/3wvAqMj4/bC1/4Qttll11s8eLFrLx1/fXXt20jt++mPefwg7YFcj/eNPzv//6v/e3f/q3tueeebE9Ul0uBeFxUq9tjjz34/DvuuOPsj3/8Y9t7brnlFnvqU59qS5cu5Rgbz8v169cveAyyMyLPT3ojj2t3vvFQfpZuRSDoPGP7wBve8Ibive99b/Gyl72sWLZsWdffp6eni8MPP7w47rjjip///OfF17/+9WLVqlXFa17zmvI9f/nLX4rR0VFu47e//W1x1llnFY1GozjnnHPK93z2s58tBgcHi49//OPFb37zm+LZz352sXz58uL6668vdjZMTEwU1157bdvPs571rGL//fcvWq0W33PZZZehGEDx7W9/u+19k5OT5XZ++MMfsp3f+c53st1f//rXFwMDA8Ull1xyOx7d9oV99923OOOMM9racP369eXf16xZU+y2227FU5/61OLXv/518V//9V/FyMhI8ZGPfKR8T27n/vjGN75RPP3pTy+++c1vFn/+85+LL3/5y8Xq1auLl7/85eV7cl/eOsj31M3D8ccfX3ziE5/gdf+LX/yieOQjH1nss88+bfeHBz/4wXxWpfcP3DMW8nzcmfHGN76xOOyww9ra78Ybbyz//rznPa/Ye++9i/POO6+46KKLivvd737FMcccU/49t+/8cMMNN7S18bnnnsvxw3e+8x3+PffjTQOu59e97nXFF77wBbbnF7/4xba/v/3tb+e4+Utf+lLxy1/+snjMYx7DcdzY2Fj5nhNOOKG4xz3uUVxwwQXF97///eLAAw8snvzkJy9oDLKzIs9PeiOPa3e+8VB+lm49ZFJqOwQG571IKTyU6/V6cd1115WvfehDHyqWLl1KcgV45StfyYFnihNPPJGD/sB973vf4oUvfGH5+8zMTLHnnnsWb3vb24qdHSCadt11V5InnRN5THT64YlPfGLxqEc9qu21o446qnjuc5+7Vfd3RwIe3u973/v6/v3f/u3fihUrVpR9GXjVq15VHHLIIeXvuZ0XBpCkGJgHcl/eOsj31C0/scc993vf+175Gibzp556at/PzOf5uDMDA2lMyHvhtttu4yLK2WefXb72u9/9jufgxz/+MX/P7btpQJ+9853vXC5y5X68+egkpdC2u+++e/Gud72rrU8PDQ2RWAKwWIjPXXjhhW0LObVarbj66qvnPQbZ2ZHnJ+3I49qdbzyUn6VbD9m+twPhxz/+MW1hu+22W/na8ccfb2vXrrXf/OY35XsgW06B9+B1AFaeiy++uO099Xqdv8d7dmZ85StfsZtvvtlOOeWUrr895jGPoSXkAQ94AN+XYq52z3DArgd7yD3veU9717ve1WatQVs96EEPssHBwbY2hI3n1ltvze28CVizZo2tXLky9+WtiHxP3Tr9Fujsu5/+9Kdt1apVdvjhh9trXvMa27hx44Kejzs7YGeC/emAAw6gjQl2PABjgqmpqbZnGKx9++yzT/kMy+27afeG//zP/7RnPOMZtJwFcj/esrjsssvsuuuua+u/y5Yto20o7b+w7N373vcu34P3Y/z7k5/8ZN5jkIze2JnnJ3lcW2FHPYcLRX6Wbh00t9J2M7YC8NBNb/hA/I6/zfYePBjGxsb4YJ2Zmen5nt///vc7/Xn7v//3//Iheac73alsC+RrvOc977H73//+vLl+/vOfZ+YJMg1AVM3W7nFeMsxe/OIXM+sME80f/ehHnFRee+219t73vrdsQ+Qh9evfK1asyO28APzpT3+ys846y9797nfnvrwVcdNNN+V76hZEq9Wyl7zkJbzfgnwKPOUpT7F9992XpApyX171qldxsviFL3xh3s/HnRmYoCNf8pBDDuF99/TTT2d2zq9//Wu2DybinVmW6TMst+/CgTHCbbfdZk9/+tPL13I/3vKIPjrbGAz/x6JiimazyfFI+p65xiAZ/c/Bzjg/yePanW88lJ+lWw+ZlNrKePWrX23veMc7Zn3P7373u7bA0Yzbp92vuuoq++Y3v2n//d//3fY+rMy/7GUvK39HIO8111xDpU+QUjsrFtLOaRve/e535yTouc99LkOOEcqfsfltHLj66qvthBNOsCc84Qn27Gc/u3w99+WM7R0IhAZR8oMf/KDt9ec85znlv7Eij0DjY4891v785z8z1D9jdjziEY9ou/9iYA2SD887BENnbJ1FLrQ7iNRA7scZ2wvy/GTz2yWPa3c+5Gfp1kMmpbYyXv7yl7etkvUCpPTzwe67795VwSCq4+Bv8f/Oijn4HdVGMPBsNBr86fWe2MbO2u6f+MQnaC2bD9GEAf25555b/t6v3e9Ibbql+zfaEPY9VITD6n2/NpxP/74jt/NC2xiE6UMf+lBW8vzoRz865/ZzX948gOjbGe6p2wIvetGL7Ktf/SorbaVq1X79NhSBIKXm83zMqABV1MEHH8z2+5u/+RvaLqDqSdVSaR/O7bswXHHFFfbtb3+7VPLlfrz1EH0U/RVkdQC/H3HEEeV7brjhhrbPYfyBinxzjS/S77gjIc9Ptny77Ozj2p1xPJSfpVsOOVNqK2PXXXclmz7bT+pfnw1HH320XXLJJW0PVhAjIJzuete7lu8577zz2j6H9+B1AN915JFHtr0Hdgn8Hu/ZGdsd2ZkgpU466SQbGBiYc/u/+MUv2gY/c7X7HRWb07/RhrBDhqQebYXJKLJN0jbEgz1k8ztjOy+kjaGQQslxXOPoz2jfuZD78uZhZ7mnbk3g/gtC6otf/KKdf/75XRaafv0WiPvwfJ6PGRXWr19PlRnaD/0Xz720D8Maicyp6MO5fRcG3H/xbHvUox6V+/FWBu4XmPCm/ReWMGRFpf0XpCvybgK41+BeHQT3fMYgdyTk+cmWb5edfVy7M46H8rN0C2IrhqhnLBBXXHEFK7ydfvrpxeLFi/lv/Kxbt66tJPPDH/5wls0+55xzWCkuLXn9l7/8pRgdHS1e8YpXsHrOBz/4waLRaPC9ablOVCX55Cc/yYokz3nOc1iuM61atLPh29/+NiuzoM06gXb6zGc+w7/h51/+5V9Y5QnlTgM//OEPi2azWbz73e/me1CdAdWMLrnkkm18JNsnfvSjH7HyHvrtn//85+I///M/2XdPOumktmo5KMf8j//4jyzHjH6KvpyWY87t3B9XXXUVS1wfe+yx/HdaljyQ+/LWQb6nbh6e//zns+Lsd7/73bZ+u3HjRv79T3/6EyuiXnTRRawg+eUvf7k44IADigc96EHlNubzfNyZ8fKXv5zti/bDffS4444rVq1axUqHwPOe97xin332Kc4//3y289FHH82fQG7f+QPVptCWqNyWIvfjTQfGwTEmxljtve99L/+NcTPw9re/neNY3Bt+9atfFY997GNZeXZsbKzcxgknnFDc8573LH7yk58UP/jBD4qDDjqoePKTn7ygMcjOijw/6UYe1+6c46H8LN16yKTUdoSTTz6ZD9vOn+985zvley6//PLiEY94RDEyMsIBJS6Oqamptu3g/UcccUQxODjIgTtKuHbirLPO4qAJ70H5zgsuuKDYmYGByTHHHNPzb7ixHnrooRycoLw42istnR347//+7+Lggw9mmx522GHF1772tW2w5zsGLr744uKoo47ixHN4eJjt+da3vrUYHx9ve98vf/nL4gEPeAAfaHvttRcHmp3I7dwbuM573T/StYfcl7ce8j1109Gv38az68orryQBtXLlSt4bQL5i4WXNmjVt25nP83FnxYknnljssccefD7h3orfQZIEMHl/wQteUKxYsYLPur/7u79rI7SB3L7zwze/+U3230svvbTt9dyPNx0Y1/a6R2DcDLRareK0004jqYR7BBZnOtv/5ptv5lgPi74Yy51yyinlou9CxiA7I/L8pBt5XLtzjofys3TroYb/bEnlVUZGRkZGRkZGRkZGRkZGRkZGxlzImVIZGRkZGRkZGRkZGRkZGRkZGdscmZTKyMjIyMjIyMjIyMjIyMjIyNjmyKRURkZGRkZGRkZGRkZGRkZGRsY2RyalMjIyMjIyMjIyMjIyMjIyMjK2OTIplZGRkZGRkZGRkZGRkZGRkZGxzZFJqYyMjIyMjIyMjIyMjIyMjIyMbY5MSmVkZGRkZGRkZGRkZGRkZGRkbHNkUiojIyMjIyMjIyMjIyMjIyMjY5sjk1IZGRkZOxhqtZp96Utfsjsi3vSmN9luu+12hz7GwH777Wdnnnnm7b0bOwz+8R//0d761rdu0fa76aabbPXq1XbVVVdtgT3MyMjIyMjIyMhYKDIplZGRkbEd4OlPfzqJGPwMDAyQmPmbv/kb+/jHP26tVqvtvddee6094hGPmNd2dyRy53e/+52dfvrp9pGPfGRBx7ij4sILL7TnPOc5dkcgEo844oit+h2//OUv7etf/7q9+MUv3qLbXbVqlZ100kn2xje+cYtuNyMjIyMjIyMjY37IpFRGRkbGdoITTjiBZMzll19u3/jGN+yhD32onXrqqfboRz/apqeny/ftvvvuNjQ0ZHc0/PnPf+b/H/vYx/Y9xsnJydthz7bO9++66642Ojq6xba3o2O2tj3rrLPsCU94gi1evHiLf+8pp5xin/70p+2WW27Z4tvOyMjIyMjIyMiYHZmUysjIyNhOABIGZMxee+1l97rXvey1r32tffnLXyZB9clPfrKn+gkT+Re96EW2xx572PDwsO277772tre9rbQ3AX/3d3/Hz8TvIH9A/ECNhUn+fe5zH/v2t7/dti94L6xSz3jGM2zJkiW2zz772Ec/+tG298Dy9OQnP9lWrlxpixYtsnvf+972k5/8pPw79h3Hgf064IADqIJKybVOtc3f/u3f8t/1ep37Gwqyxz3ucfYv//Ivtueee9ohhxzC1y+55BJ72MMeZiMjI7bLLrtQcbR+/fpye/E5HAOOc/ny5XbGGWfw+1/xildwn+90pzvZJz7xiVnPyUMe8hC270te8hKqao4//ni+/utf/5pKLrQftg9rGaxggXXr1tlTn/pUtgvOzfve9z5uC9vpZz+78soreV6wzaVLl9oTn/hEu/7667sUSf/xH//Bzy5btsye9KQn8btmww9/+EN+NwiwFStW8BhuvfVW/g0qPPSX/fffn215j3vcw/7f//t/5We/+93v8lycd955PL/YxjHHHGOXXnop/45+ifMKJVMo/aKv3nbbbfasZz2L5BuOB+cL7+s8nv/zf/4Pvx/9pBdmZma4T9E/UuDY0QfRzrhuPvjBD7b9HfvzoQ99iOcKx4d+mB4fcNhhh7FvffGLX5y1HTMyMjIyMjIyMrY8MimVkZGRsR0DE3kQBV/4whd6/v0DH/iAfeUrX7H//u//JlEAxUeQT7CHASBeoMCK30HePPKRjyTR8POf/5wKLUz4QYqkeM973kMiAu95wQteYM9//vNLMgLbePCDH2xXX301vx9kwytf+crSavj973+ftigovX7729/SkgeyAuRSL/zzP/9zSRBhX/ETwH7ie88991z76le/ahs2bCCxAoIFx3T22WeTVAN5lOL888+3a665xv73f//X3vve99KiBdUZPgfy7HnPe54997nPnTNP6FOf+pQNDg6S3Pnwhz9MsgXn5Z73vKdddNFFds4555A8AokUeNnLXsb3o22w32iPn/3sZ32/A+0GQgpqne9973v8zF/+8hc78cQT294HQhGEJNoBP3jv29/+9r7b/cUvfmHHHnus3fWud7Uf//jH9oMf/IDnGkQPAELq3//933lcv/nNb+ylL32pPe1pT+N2U7zuda9jf8DxNptNkpUA9u/lL385iZ04b7HPUDbdcMMNJFUvvvhiEpTYl1SR9Kc//ck+//nPs39jX3vhV7/6la1Zs4Z9sRPvete7eH2gj7761a9mf0PbpTjttNPs8Y9/PPsoiEIQebCKprjvfe/Lc5SRkZGRkZGRkbGNUWRkZGRk3O44+eSTi8c+9rE9/3biiScWhx56aPk7bt1f/OIX+e9/+qd/Kh72sIcVrVar52fT986Gww47rDjrrLPK3/fdd9/iaU97Wvk7tr969eriQx/6EH//yEc+UixZsqS4+eabe27v2GOPLd761re2vfYf//EfxR577NF3H7CfnY8ltMtuu+1WTExMlK999KMfLVasWFGsX7++fO1rX/taUa/Xi+uuu678HI5hZmamfM8hhxxSPPCBDyx/n56eLhYtWlT813/9V999evCDH1zc8573bHvtzW9+c/Hwhz+87bW//vWv3PdLL720WLt2bTEwMFCcffbZ5d9vu+22YnR0tDj11FPL17B/73vf+/jvb33rW0Wj0SiuvPLK8u+/+c1vuM2f/vSn/P2Nb3wjt4HtB17xilcURx11VN/9f/KTn1zc//737/m38fFxbu9HP/pR2+vPfOYz+TngO9/5Dvfh29/+dltb47WxsbFyv+5xj3u0beP73/9+sXTpUn5Hijvf+c7sO/E5tNMNN9xQzAb0C7RNZx9H+51wwgld18ojHvGI8nfs5/Oe97y296C9nv/857e99tKXvrR4yEMeMut+ZGRkZGRkZGRkbHk0tzUJlpGRkZGxMGBuHXa2TsCmhkB02NqgeIIS6OEPf/is24PKCdapr33ta1S2wNI2NjbWpZS6+93vXv4b3w9rIZQvAFQtUArBBtcLUKVAKZQqo6DOGR8ft40bNy4oS+lud7sblUoBqFygjoFlK3D/+9+faiMoqmCnA6DegRUwgNcPP/zw8vdGo0HrXxxTPxx55JFdx/ad73ynZ74RlExoy6mpKapvArDahfWwF3BMe++9N38CUDfBdoi/wWIJQAUHO2UA1sDZ9h/nCYqlXoBKCecC/ScFLKE4t/36Ar4TwPfC1tkLaCP0M7RvCrRNZIcBsJvC3jcb8BlYW3tdA0cffXTX750V+Xq9p1OVBWsf2iIjIyMjIyMjI2PbIpNSGRkZGds5QEogc6cXYIm67LLLaJGChQ0WsuOOO64rN6fTKgeL07vf/W478MADOSH/h3/4h66gaVQBTAFSIOx5+MxsACGBrKG///u/7/pbv+ygfkjJp4Wg1/7Pdkzz/X4cGyxw73jHO7reC8IGZM/WwkL3f7bzFBlcICeRx5SiM2Q+/d4gh2b7XmwbbYFMqk6AaFvIuUWWFwgj9M+UnNySgKVwLnIsIyMjIyMjIyNjyyNnSmVkZGRsx0AuEkK9kYnTDwiRRo7Pxz72Mfvc5z7HjJ7I7QGZEPlBASiYoLBCADpUSFBAoeLfQgDlDNQm/SqWgSyDagmkV+dPql7aFBx66KFU4iBbKj0mbHc2NdKWAo4N+UtQLXUeG0gWhGmj3SPDC0Am0h/+8IdZj+mvf/0rfwLI4kJ+FRRTmwqcJ2Ry9QK2C/IJCrnO40gVW3MBRFFnH0MbXXfddcyf6tw2SKaFAGHo0R6duOCCC7p+R1su9D0Iru9Uh2VkZGRkZGRkZGx9ZFIqIyMjYzvBxMQEJ/IID0coNirHIfwaljyEhvcCArz/67/+y37/+9+T9EDoN0imUKOAOAEpge1GxbWDDjqoDJYGufOUpzxlTrVQJ1DxDN+DCncghBDKDTIMYdrAG97wBgZoQy0FAgdqr89+9rP2+te/frPbCWHVUFudfPLJJBNgpfunf/onVsAL697WxAtf+EKScWgDEE+wo33zm9+0U045heQM7HXYN1T5w77h+J/5zGe2VRXsBNRtIAhxbDj3P/3pT3nOESbfK+B7vnjNa17DfURQPQLD0U9QjQ6VArGfUM0h3Bxh7jgOfPdZZ53F3+cL9DGo9dCfsF30YxwPbHLoH9/61rdIev7oRz9iYDrC0hcCKJhAciGkvRPoe+985zvZ91F5D/0fYecp8NrHP/5xvgdh92jbNBQfKiwEsc9le83IyMjIyMjIyNjyyKRURkZGxnYCVHGD5QmTfORDgdBAdb0vf/nLzD/qBRALmJSDuEDuECb/X//610s1EiqmwaoH5UsoQUBkoQLdMcccQxsaKtlh0r8QQB0DsmH16tWs5AdCBVXgYj+xTVSHw3uwX/e73/3sfe97HzOENhfIowIJBGII24b1EFXd/vVf/9W2Bfbcc0+SISCgQGTg2F/ykpeQCIx2RxuDlAGhCIIGmVdQ5/SzLoKswnnGeXnQgx7Ez0BxBeXb5uDggw/mOQD5iIwr7BO+Bwom4M1vfjOr06EKH/YP/Q52vn520V6Aig+fe+hDH0oCCSQpjgf9EMcCsg77gap3V1xxxSYRh8961rNYWbITqPwHkgt9+y1veQvbHX0vBYhREKJQjYEoxf6l6jO0B7KxHvjABy54vzIyMjIyMjIyMjYPNaSdb+Y2MjIyMjIyMmYBrIbIbQJJCNVUxsKAsHNYM0HSdQaXzwaQY1/84hep2OoHEKYvfvGLqRjMyMjIyMjIyMjYtshB5xkZGRkZGVsYP//5z2mVgzoJeVJnnHEGX4cdM2PhQGA7VE6wB25JYHsI44cVMyMjIyMjIyMjY9sjk1IZGRkZGRlbAahuiLB3WB2PPPJI+/73v7/gkO+MCg95yEO2eHPgfLzyla/MzZyRkZGRkZGRcTsh2/cyMjIyMjIyMjIyMjIyMjIyMrY5ctB5RkZGRkZGRkZGRkZGRkZGRsY2RyalMjIyMjIyMjIyMjIyMjIyMjK2OTIplZGRkZGRkZGRkZGRkZGRkZGxzZFJqYyMjIyMjIyMjIyMjIyMjIyMbY5MSmVkZGRkZGRkZGRkZGRkZGRkbHNkUiojIyMjIyMjIyMjIyMjIyMjY5sjk1IZGRkZGRkZGRkZGRkZGRkZGdscmZTKyMjIyMjIyMjIyMjIyMjIyNjmyKRURkZGRkZGRkZGRkZGRkZGRoZta/x/gg0CZ7/H3XEAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from dimelo import cluster\n", + "import numpy as np\n", + "import pandas as pd\n", + "import inspect\n", + "from bisect import bisect_left, bisect_right\n", + "\n", + "# Backend-safe path: infer one shared window size and enforce it for both extractions\n", + "# Fixed shared window_size for tutorial reproducibility.\n", + "shared_window = 1000\n", + "region_window_size = 1000\n", + "region_label_mode = \"overlap_any\" # \"center\" | \"overlap_any\"\n", + "\n", + "# Exposed plotting handles for tuning\n", + "plot_point_size = 1.2\n", + "plot_point_alpha = 0.015\n", + "profile_smoothing = \"gaussian\" # None | \"gaussian\" | \"boxcar\"\n", + "show_unsmoothed_overlay = True\n", + "\n", + "# Compatibility helpers for mixed dimelo versions\n", + "\n", + "def _supports_kwarg(callable_obj, name):\n", + " try:\n", + " return name in inspect.signature(callable_obj).parameters\n", + " except Exception:\n", + " return False\n", + "\n", + "\n", + "def _filter_supported_kwargs(callable_obj, kwargs):\n", + " try:\n", + " sig = inspect.signature(callable_obj).parameters\n", + " except Exception:\n", + " return kwargs\n", + " return {k: v for k, v in kwargs.items() if k in sig}\n", + "\n", + "\n", + "def _cluster_window_kwargs(callable_obj, window_size):\n", + " if _supports_kwarg(callable_obj, \"window_size\"):\n", + " return {\"window_size\": window_size}\n", + " return {\"window_size\": window_size}\n", + "\n", + "\n", + "def _region_plot_window_kwargs(window_size):\n", + " if _supports_kwarg(cluster.plot_region_cluster_profiles, \"window_size\"):\n", + " return {\"window_size\": window_size}\n", + " if _supports_kwarg(cluster.plot_region_cluster_profiles, \"window_size\"):\n", + " return {\"window_size\": window_size}\n", + " return {}\n", + "\n", + "\n", + "def _read_window_config(window_size, orientation_aware=True):\n", + " if _supports_kwarg(cluster.ReadWindowExtractionConfig, \"window_size\"):\n", + " return cluster.ReadWindowExtractionConfig(\n", + " window_size=window_size,\n", + " orientation_aware=orientation_aware,\n", + " )\n", + " return cluster.ReadWindowExtractionConfig(\n", + " window_size=window_size,\n", + " orientation_aware=orientation_aware,\n", + " )\n", + "\n", + "\n", + "def _merge_read_windows(results, source_labels):\n", + " if hasattr(cluster, \"merge_read_window_results\"):\n", + " return cluster.merge_read_window_results(\n", + " results,\n", + " source_labels=source_labels,\n", + " align=\"error\",\n", + " )\n", + "\n", + " # Backward-compatible fallback for older dimelo versions\n", + " widths = {r.data_matrix.shape[1] for r in results}\n", + " if len(widths) != 1:\n", + " raise ValueError(\n", + " f\"Read-window widths do not match: {sorted(widths)}. \"\n", + " \"Use one shared extraction window for all groups.\"\n", + " )\n", + "\n", + " data = np.vstack([r.data_matrix for r in results])\n", + " all_have_val = all(r.val_matrix is not None for r in results)\n", + " val = np.vstack([r.val_matrix for r in results]) if all_have_val else None\n", + " metadata = []\n", + " for label, result in zip(source_labels, results):\n", + " metadata.extend([dict(m, source_label=label) for m in result.metadata])\n", + "\n", + " return cluster.ReadWindowExtractionResult(\n", + " data_matrix=data,\n", + " val_matrix=val,\n", + " metadata=metadata,\n", + " datasets=list(results[0].datasets),\n", + " regions_dict=None,\n", + " )\n", + "\n", + "\n", + "def _plot_cluster_profiles_compat(**kwargs):\n", + " fn = cluster.plot_cluster_profiles\n", + " safe_kwargs = _filter_supported_kwargs(fn, kwargs)\n", + " return fn(**safe_kwargs)\n", + "\n", + "\n", + "def _plot_region_cluster_profiles_compat(**kwargs):\n", + " fn = cluster.plot_region_cluster_profiles\n", + " safe_kwargs = _filter_supported_kwargs(fn, kwargs)\n", + " return fn(**safe_kwargs)\n", + "\n", + "\n", + "def _plot_classification_profiles_compat(data_matrix, predictions, **kwargs):\n", + " if not hasattr(cluster, \"plot_classification_profiles\"):\n", + " print(\"plot_classification_profiles not available in this dimelo version; skipping profile view.\")\n", + " return None\n", + "\n", + " fn = cluster.plot_classification_profiles\n", + " call_kwargs = dict(kwargs)\n", + " call_kwargs.update({\"data_matrix\": np.asarray(data_matrix), \"predictions\": predictions})\n", + " call_kwargs = _filter_supported_kwargs(fn, call_kwargs)\n", + " return fn(**call_kwargs)\n", + "\n", + "\n", + "def _confusion_labels(predictions, split=\"test\", positive_label=None):\n", + " df = predictions[predictions[\"split\"] == split].reset_index(drop=True)\n", + " classes = sorted(pd.unique(df[\"true_label\"]))\n", + " if len(classes) != 2:\n", + " raise ValueError(\"Confusion grouping requires exactly two classes.\")\n", + " positive = positive_label if positive_label is not None else classes[-1]\n", + " true_vals = df[\"true_label\"].to_numpy()\n", + " pred_vals = df[\"pred_label\"].to_numpy()\n", + " labels = np.empty(len(df), dtype=object)\n", + " labels[(true_vals != positive) & (pred_vals != positive)] = \"TN\"\n", + " labels[(true_vals != positive) & (pred_vals == positive)] = \"FP\"\n", + " labels[(true_vals == positive) & (pred_vals != positive)] = \"FN\"\n", + " labels[(true_vals == positive) & (pred_vals == positive)] = \"TP\"\n", + " idx = df[\"row_index\"].astype(int).to_numpy() if \"row_index\" in df.columns else None\n", + " return labels, idx\n", + "\n", + "\n", + "def _plot_region_classification_profiles_compat(pileup_matrix, predictions, **kwargs):\n", + " if hasattr(cluster, \"plot_region_classification_profiles\"):\n", + " fn = cluster.plot_region_classification_profiles\n", + " call_kwargs = dict(kwargs)\n", + " call_kwargs.update({\"pileup_matrix\": pileup_matrix, \"predictions\": predictions})\n", + " call_kwargs = _filter_supported_kwargs(fn, call_kwargs)\n", + " try:\n", + " return fn(**call_kwargs)\n", + " except Exception as exc:\n", + " print(f\"Falling back from plot_region_classification_profiles due to: {exc}\")\n", + "\n", + " # Backward-compatible fallback: derive confusion labels and call region cluster plot\n", + " split = kwargs.get(\"split\", \"test\")\n", + " group_by = kwargs.get(\"group_by\", \"pred_label\")\n", + " matrix = np.asarray(pileup_matrix)\n", + "\n", + " df = predictions[predictions[\"split\"] == split].reset_index(drop=True)\n", + " if group_by == \"confusion\":\n", + " labels, idx = _confusion_labels(predictions, split=split, positive_label=kwargs.get(\"positive_label\"))\n", + " else:\n", + " labels = df[group_by].to_numpy()\n", + " idx = df[\"row_index\"].astype(int).to_numpy() if \"row_index\" in df.columns else None\n", + "\n", + " if idx is not None:\n", + " matrix = matrix[idx]\n", + "\n", + " window_kwargs = _region_plot_window_kwargs(kwargs.get(\"window_size\", None))\n", + "\n", + " return _plot_region_cluster_profiles_compat(\n", + " pileup_matrix=matrix,\n", + " labels=labels,\n", + " **window_kwargs,\n", + " motif_index=kwargs.get(\"motif_index\", 0),\n", + " motif_count=kwargs.get(\"motif_count\", None),\n", + " plot_all_motifs=kwargs.get(\"plot_all_motifs\", False),\n", + " motif_labels=kwargs.get(\"motif_labels\", None),\n", + " motif_colors=kwargs.get(\"motif_colors\", None),\n", + " motif_profile_mode=kwargs.get(\"motif_profile_mode\", \"single_axis\"),\n", + " color_points_by=kwargs.get(\"color_points_by\", \"cluster\"),\n", + " point_size=kwargs.get(\"point_size\", 1.0),\n", + " point_alpha=kwargs.get(\"point_alpha\", 0.01),\n", + " smoothing=kwargs.get(\"smoothing\", None),\n", + " smooth_win=kwargs.get(\"smooth_win\", 21),\n", + " smooth_sigma=kwargs.get(\"smooth_sigma\", 6.0),\n", + " show_unsmoothed_overlay=kwargs.get(\"show_unsmoothed_overlay\", False),\n", + " )\n", + "\n", + "\n", + "def _load_intervals_by_chrom(path):\n", + " intervals = {}\n", + " with open(path) as handle:\n", + " for line in handle:\n", + " if not line.strip() or line.startswith(\"#\"):\n", + " continue\n", + " fields = line.strip().split()[:3]\n", + " if len(fields) < 3:\n", + " continue\n", + " chrom, start, end = fields[0], int(fields[1]), int(fields[2])\n", + " intervals.setdefault(chrom, []).append((start, end))\n", + " for chrom in intervals:\n", + " intervals[chrom].sort()\n", + " return intervals\n", + "\n", + "\n", + "def _contains_point(intervals, point):\n", + " i = bisect_right(intervals, (point, float(\"inf\"))) - 1\n", + " return i >= 0 and intervals[i][0] <= point < intervals[i][1]\n", + "\n", + "\n", + "def _overlap_bp(start_a, end_a, start_b, end_b):\n", + " return max(0, min(end_a, end_b) - max(start_a, start_b))\n", + "\n", + "\n", + "def _has_overlap(intervals, start, end, min_overlap_bp=1):\n", + " if not intervals:\n", + " return False\n", + " i = max(0, bisect_left(intervals, (start, -1)) - 1)\n", + " while i < len(intervals):\n", + " s, e = intervals[i]\n", + " if s >= end:\n", + " break\n", + " if _overlap_bp(start, end, s, e) >= min_overlap_bp:\n", + " return True\n", + " i += 1\n", + " return False\n", + "\n", + "\n", + "def _label_regions_from_targets(region_info, on_bed, off_bed, mode=\"overlap_any\", min_overlap_bp=1):\n", + " on_intervals = _load_intervals_by_chrom(on_bed)\n", + " off_intervals = _load_intervals_by_chrom(off_bed)\n", + " labels = []\n", + " for chrom, start, end, _ in region_info:\n", + " start_i, end_i = int(start), int(end)\n", + " if mode == \"center\":\n", + " center = (start_i + end_i) // 2\n", + " in_on = _contains_point(on_intervals.get(chrom, []), center)\n", + " in_off = _contains_point(off_intervals.get(chrom, []), center)\n", + " elif mode == \"overlap_any\":\n", + " in_on = _has_overlap(on_intervals.get(chrom, []), start_i, end_i, min_overlap_bp=min_overlap_bp)\n", + " in_off = _has_overlap(off_intervals.get(chrom, []), start_i, end_i, min_overlap_bp=min_overlap_bp)\n", + " else:\n", + " raise ValueError(\"mode must be 'center' or 'overlap_any'.\")\n", + "\n", + " if in_on and not in_off:\n", + " labels.append(\"on_target\")\n", + " elif in_off and not in_on:\n", + " labels.append(\"off_target\")\n", + " elif in_on and in_off:\n", + " labels.append(\"on_target\")\n", + " else:\n", + " labels.append(\"unlabeled\")\n", + " return np.array(labels, dtype=object)\n", + "\n", + "\n", + "rw_on = cluster.extract_read_windows(\n", + " hdf5_file=extract_file,\n", + " motifs=[\"A,0\"],\n", + " regions=ctcf_target_regions,\n", + " config=_read_window_config(shared_window, orientation_aware=True),\n", + " span_full_window=False,\n", + ")\n", + "\n", + "rw_off = cluster.extract_read_windows(\n", + " hdf5_file=extract_file,\n", + " motifs=[\"A,0\"],\n", + " regions=ctcf_off_target_regions,\n", + " config=_read_window_config(shared_window, orientation_aware=True),\n", + " span_full_window=False,\n", + ")\n", + "\n", + "rw_single = _merge_read_windows(\n", + " [rw_on, rw_off],\n", + " source_labels=[\"on_target\", \"off_target\"],\n", + ")\n", + "\n", + "feat_single, _ = cluster.read_window_feature_matrix(\n", + " rw_single,\n", + " n_pca=6,\n", + " use_peak_features=False,\n", + ")\n", + "clust_single = cluster.cluster_read_windows(\n", + " feat_single,\n", + " method=\"kmeans\",\n", + " n_clusters=2,\n", + " random_state=42,\n", + ")\n", + "\n", + "_plot_cluster_profiles_compat(\n", + " data_matrix=rw_single.data_matrix,\n", + " labels=clust_single.labels_size_ordered,\n", + " val_matrix=rw_single.val_matrix,\n", + " metadata=rw_single.metadata,\n", + " **_cluster_window_kwargs(cluster.plot_cluster_profiles, shared_window),\n", + " point_size=plot_point_size,\n", + " point_alpha=plot_point_alpha,\n", + " smoothing=profile_smoothing,\n", + " show_unsmoothed_overlay=show_unsmoothed_overlay,\n", + ")\n", + "\n", + "sample_labels_single = np.array([m.get(\"source_label\", \"unknown\") for m in rw_single.metadata])\n", + "cluster_vs_group = pd.crosstab(\n", + " clust_single.labels_size_ordered,\n", + " sample_labels_single,\n", + " rownames=[\"cluster\"],\n", + " colnames=[\"region_set\"],\n", + ")\n", + "cluster_vs_group_frac = cluster_vs_group.div(cluster_vs_group.sum(axis=1), axis=0)\n", + "purity = cluster_vs_group.max(axis=1).sum() / cluster_vs_group.values.sum()\n", + "\n", + "print(f\"Reads used: on_target={rw_on.data_matrix.shape[0]}, off_target={rw_off.data_matrix.shape[0]}, total={rw_single.data_matrix.shape[0]}\")\n", + "print(f\"Cluster purity vs on/off labels: {purity:.3f}\")\n", + "print(\"Counts by cluster and region set:\")\n", + "print(cluster_vs_group)\n", + "print(\"Within-cluster fractions:\")\n", + "print(cluster_vs_group_frac.round(3))\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Multiple motif (merged on-target vs off-target reads)\n", + "\n", + "This example plots both motifs with motif-matched colors. You can switch between:\n", + "- `motif_profile_mode=\"single_axis\"` (shared y-axis) and\n", + "- `motif_profile_mode=\"separate_axes\"` (one y-axis per motif).\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/cluster.py:1592: UserWarning: *c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n", + " ax_left.scatter(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Multi-motif reads used: on_target=2173, off_target=4030, total=6203\n", + "Multi-motif cluster purity vs on/off labels: 0.807\n", + "col_0 off_target on_target\n", + "row_0 \n", + "0 3942 1112\n", + "1 88 1061\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from dimelo import cluster\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "# Reuse shared_window from cell 75 when available\n", + "if \"shared_window\" not in globals():\n", + " shared_window = 1000\n", + "\n", + "rw_on_multi = cluster.build_multimotif_read_windows(\n", + " hdf5_file=extract_file,\n", + " motifs=[\"A,0\", \"CG,0\"],\n", + " regions=ctcf_target_regions,\n", + " **_cluster_window_kwargs(cluster.build_multimotif_read_windows, shared_window),\n", + " orientation_aware=True,\n", + " span_full_window=False,\n", + " require_all_motifs=True,\n", + ")\n", + "\n", + "rw_off_multi = cluster.build_multimotif_read_windows(\n", + " hdf5_file=extract_file,\n", + " motifs=[\"A,0\", \"CG,0\"],\n", + " regions=ctcf_off_target_regions,\n", + " **_cluster_window_kwargs(cluster.build_multimotif_read_windows, shared_window),\n", + " orientation_aware=True,\n", + " span_full_window=False,\n", + " require_all_motifs=True,\n", + ")\n", + "\n", + "rw_multi = _merge_read_windows(\n", + " [rw_on_multi, rw_off_multi],\n", + " source_labels=[\"on_target\", \"off_target\"],\n", + ")\n", + "\n", + "feat_multi, _ = cluster.read_window_feature_matrix(\n", + " rw_multi,\n", + " n_pca=6,\n", + " use_peak_features=False,\n", + ")\n", + "clust_multi = cluster.cluster_read_windows(\n", + " feat_multi,\n", + " method=\"kmeans\",\n", + " n_clusters=2,\n", + " random_state=42,\n", + ")\n", + "\n", + "_plot_cluster_profiles_compat(\n", + " data_matrix=rw_multi.data_matrix,\n", + " labels=clust_multi.labels_size_ordered,\n", + " val_matrix=rw_multi.val_matrix,\n", + " metadata=rw_multi.metadata,\n", + " **_cluster_window_kwargs(cluster.plot_cluster_profiles, shared_window),\n", + " motif_count=2,\n", + " motif_labels=[\"A,0\", \"CG,0\"],\n", + " plot_all_motifs=True,\n", + " color_points_by=\"motif\",\n", + " motif_profile_mode=\"single_axis\", # switch to \"separate_axes\" if desired\n", + " point_size=plot_point_size,\n", + " point_alpha=plot_point_alpha,\n", + " smoothing=profile_smoothing,\n", + " show_unsmoothed_overlay=show_unsmoothed_overlay,\n", + ")\n", + "\n", + "sample_labels_multi = np.array([m.get(\"source_label\", \"unknown\") for m in rw_multi.metadata])\n", + "table_multi = pd.crosstab(clust_multi.labels_size_ordered, sample_labels_multi)\n", + "purity_multi = table_multi.max(axis=1).sum() / table_multi.values.sum()\n", + "\n", + "print(f\"Multi-motif reads used: on_target={rw_on_multi.data_matrix.shape[0]}, off_target={rw_off_multi.data_matrix.shape[0]}, total={rw_multi.data_matrix.shape[0]}\")\n", + "print(f\"Multi-motif cluster purity vs on/off labels: {purity_multi:.3f}\")\n", + "print(table_multi)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Read Classification" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Single Motif" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'test': {'accuracy': 0.8356164383561644, 'roc_auc': 0.8820826559425002, 'confusion_matrix': [[707, 99], [105, 330]]}, 'train': {'accuracy': 0.8369609028617493, 'roc_auc': 0.8732761088441978, 'confusion_matrix': [[2875, 349], [460, 1278]]}}\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#import numpy as np\n", + "\n", + "# Use true on/off labels from the merged clustering example above\n", + "sample_labels_single = np.array([m.get(\"source_label\", \"unknown\") for m in rw_single.metadata])\n", + "\n", + "clf_single = cluster.classify_read_features_binary(\n", + " feat_single,\n", + " sample_labels=sample_labels_single,\n", + " classifier=\"logreg\",\n", + " random_state=42,\n", + ")\n", + "print(clf_single[\"metrics\"])\n", + "cluster.plot_confusion_matrices(clf_single[\"predictions\"])\n", + "\n", + "_plot_classification_profiles_compat(\n", + " rw_single.data_matrix,\n", + " clf_single[\"predictions\"],\n", + " val_matrix=rw_single.val_matrix,\n", + " metadata=rw_single.metadata,\n", + " split=\"test\",\n", + " group_by=\"confusion\",\n", + " **_cluster_window_kwargs(cluster.plot_classification_profiles, shared_window),\n", + " point_size=plot_point_size,\n", + " point_alpha=plot_point_alpha,\n", + " smoothing=profile_smoothing,\n", + " show_unsmoothed_overlay=show_unsmoothed_overlay,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "70a3b81c", + "metadata": {}, + "source": [ + "*Tip*: For concatenated motif windows, use `motif_index` in plotting helpers to choose which motif slice to visualize (e.g., 0 for the first motif, 1 for the second)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Multiple motifs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'test': {'accuracy': 0.8356164383561644, 'roc_auc': 0.9029776674937966, 'confusion_matrix': [[705, 101], [103, 332]]}, 'train': {'accuracy': 0.8405884723901652, 'roc_auc': 0.9012457275268627, 'confusion_matrix': [[2865, 359], [432, 1306]]}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/cluster.py:1592: UserWarning: *c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n", + " ax_left.scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAGSCAYAAAAy+nL5AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsvQecLEd1PXx78mx4OUdFEEoIhBI5YxM+Y7AtMNnY/MEgcjbZJgkwUSaYaGMMyDbCJBkhsiQQCiBAOb6c3+admZ7u/n7nVldPdU91mpndt/teHf1W+3amu7pyV52691zL8zyPDAwMDAwMDAwMDAwMDAwMDAwM5hGF+XyYgYGBgYGBgYGBgYGBgYGBgYEBYEgpAwMDAwMDAwMDAwMDAwMDA4N5hyGlDAwMDAwMDAwMDAwMDAwMDAzmHYaUMjAwMDAwMDAwMDAwMDAwMDCYdxhSysDAwMDAwMDAwMDAwMDAwMBg3mFIKQMDAwMDAwMDAwMDAwMDAwODeYchpQwMDAwMDAwMDAwMDAwMDAwM5h2GlDIwMDAwMDAwMDAwMDAwMDAwmHcYUsrAwMDAwMDAwMDAwMDAwMDAYN5hSCkDAwMDAwMDAwMDAwMDAwMDg3mHIaUMDAwMDAwMDAwMDAwMDAwMDOYdhpQyMDAwMDAwMDAwMDAwMDAwMJh3GFLKwMDAwMDAwMDAwMDAwMDAwGDeYUgpAwMDAwMDAwMDAwMDAwMDA4N5hyGlDAwMDAwMDAwMDAwMDAwMDAzmHYaUMjAwMDAwMDAwMDAwMDAwMDCYdxhSysDAwMDAwGDB45prrqFisUhPecpTUq/1PI/e8Y530Pr166ler9PjH/94uuOOO+Yln4sZe/bsoYsuuohOOOEEqlartHnzZnra055GV155ZXDNjTfeSBdeeCHXLa7ZunUrPfWpT6XvfOc7XO9xMG1iYGBgYGBgoIMhpQwMDAwMDAwWPL7whS8wYfLzn/+cdu3alXjtxRdfTJ/4xCfoM5/5DP3617+m4eFhetKTnkSNRmPe8rvYcO+999LZZ59NP/7xj+lDH/oQ/f73v6fLL7+cHvOYx9DLX/5yvubb3/42nX/++TQ1NUVf+cpX6JZbbuFr/vzP/5ze9ra30fj4eGz6pk0MDAwMDAwMdLC8pGMtAwMDAwMDA4MjDJAgsMy57rrr6J3vfCedeeaZ9Na3vlV7LZY1GzZsoNe97nX0+te/nj8DWbJ27Vr68pe/TM961rPmOfeLA09+8pPppptuottuu41JPBVjY2NULpfZKuqRj3wk/c///E9s3VuWpf3ctImBgYGBgYGBDsZSysDAwMDAwGBB45vf/CadcsopdP/735+e+9zn0he/+MVYV7F77rmH3dDgsiexdOlSOu+889gF0KAbhw4dYosnWERFCSlg2bJl9MMf/pAOHjxIb3zjG2OrUEdImTYxMDAwMDAwSEIp8VsDAwMDAwODoxZP++Qvaf9kc96fu3q0St+56OG5XPdARgF/8id/wpZPP/vZz+jRj35017UgpABYRqnA3/K7ecVnH0U0tW/+nzuyhuj//SzTpXfeeSeTfCD+4nD77bfzbxCDEr/5zW/YvU/i61//OutLLfg2MTAwMDAwMFgwMKSUgYGBgYHBMQoQUnsmFrbOEtzJrr32WvrWt77Ff5dKJRbaBlGlI6UWHEBITSZrYB1p9KrkADfK3/72t/zvk08+mdrt9oBzZmBgYGAwn8D79uEPfzgHB4HL9rEAuPW7rstW2QZHBsZ9z8DAwMDA4BgFLJbWLanN+w+emxUgn0B2QJMIhBR+Pv3pT9N///d/a4W1161bx7/37t0b+hx/y+/m3WJpdMP8/+C5GQFCCa53t956a+I1kiSUQPS9k046iX+SsODaxMDAwGARADqImJt1P29+85uD64477jj+DMFAovjpT3/K3/3Xf/1Xpmf+wz/8Az372c+eV0IKupHQi4Ql9IoVKzi/KHscEGQD146MjPD1z3ve82j//v2haxAQBRbWsO4dHR1lN/Rzzz2Xg3RED2Le9KY38Zrid7/73ZyV0SAZxlLKwMDAwMDgGEUeF7ojAZBR//Zv/0Yf+chH6IlPfGLou6c//en0n//5n/TSl7409Pnxxx/PRMeVV15JZ511Fn82MTHBUfhe9rKX0bwjowvdkQQW9YhOeMkll9ArX/lKrdA56h/XffCDHwys1rJiwbWJgYGBwSLCe97zHp5HVZx++uld1/3rv/4rveUtb+FDnF4Ay9cf/ehHdPXVV9N84sCBA1zGLVu20AMf+EAm0uKwY8cODrgBrcj3ve99TGh9+MMf5oixsPKqVCpBmrj2L/7iLzhd27bpiiuuoBe+8IV8uIJ7JR70oAfRQx7yEF5rYM1hcASA6HsGBgYGBgYGBgsN3/rWt7xKpeKNjY11fffGN77Re8hDHqK97wMf+IC3bNky79vf/rZ30003eX/2Z3/mHX/88d7s7Ow85Hpx4q677vLWrVvnnXrqqd5//dd/ebfffrt38803ex//+Me9U045ha/5n//5H69cLntPfvKTvcsvv5zv+d3vfud98IMfxLGz97//+7+x6Zs2MTAwMMiHL33pSzy3/uY3v0m8buvWrd5pp53mlUol76KLLgp995Of/ITTuPTSS1Of98pXvtLbsmWL57ruvDZVo9Hwdu/ezf9GWZFflF2Hl73sZV69Xvfuu+++4LMrrriC7/nsZz+b+qynPvWp3vDwsNdut0Off/jDH+bPJycn+y6PQX4Y9z0DAwMDAwODBQm47iGKHk5Eo3jmM59J1113Hd10003suvCud70r+A4R4uDG8JKXvITOOeccPklFdLlarTbPJVg8OOGEE+iGG25g4fLXve51fAr/hCc8ga2b4C4J/Pmf/zmfoA8NDdHzn/98dot47GMfSz/+8Y+7RM5NmxgYGBjMHzDnYl6GtRRc13rBZZddxnN6NJIq0sb8/stf/pJd4PAuxTtjUFZFcAXP6soNNzvkBdZPElgn3O9+98ukCYWyzMzMUKvVCn2O99309DRbUxnMP4z7noGBgYGBgcGCxHe+853Y77Awhi4EFpfQJlJFz7GghisAfgyyY/369fSpT32Kf+IAF4dLL700MR3TJgYGBgaDA/QT4Y6mYtWqVVo9KBBFH/jAB+gTn/hErmfs3LmTtm3bRg9+8INjo7TCFe7FL34xveAFL6AvfvGL7Ap39tln02mnncbXQCz80KFDmZ6Hw6ZyuZw7j/v27eP3kG5N8P3vf7/r89nZWSabcDiFqL1f+tKX6IILLqB6vR667tRTT+XPrrrqKj6AMZhfGFLKwMDAwMDAYNHiJz/5CZ/sLopIfMcITJsYGBgYDA6wBMoSNRXWSxD9ltpSOGjIChnoIqpdJQEdpp///Of0iEc8gv/+q7/6K9q8eTOTPNB0AkBqxd2ve0/kfW/v3r2bf+vKhc9AiDWbTba8kvj4xz/OdSHxuMc9jvMcBYKooDw333xzrjwZDAaGlDIwMDAwMDBYtHjKU57CPwYLB6ZNDAwMDAYHBKGAe1oWvO1tb6N///d/Z2spEDJZcfDgQf69fPly7fewJJKEFLB69Wp24b777ruDz+CCl9X9DYLmeQGrJ0AlnSSkez6uUb9HJEFYViE633e/+122rJbpRIGyRy3SDOYHhpQyMDAwMDAwMDAwMDAwMFiAgGuazmVNB2kt9bnPfY7e/OY3536WzgILUDWcVBLn8OHDIWJIZ9U1KEiXO1hDRdFoNELXSGzdupV/JEEFrUnkEZZf0WtR9qielsH8wAidGxgYGBgYGBgYGBgYGBgcBYC2VLvdpg9+8IOZ71m5ciX/VkkmFcViMZXEchyH9uzZk+knKjSeBdJtT7rxqcBnK1as0FpRqYAu1vbt29kVMQqUXafVZTD3MJZSBgYGBgYGBgYGBgYGBgZHAU488UR67nOfS5/97GfpvPPOy3TPKaecwr/vueeenp8LsmcuNaU2btzIboOIvBvFtddeS2eddVZqGtJ1D+LxKkDiIf//3//3/+XKk8FgYEgpAwMDAwMDAwMDAwMDA4OjBFJb6uKLL85M+EDoW0f4ZMVca0oBz3zmM+krX/kKE0jIL3DllVfS7bffTq95zWuC66AhBQIrii984QvsoheNMgiBc7gAPvShD+0pXwb9wZBSBgYGBgYGBgYGBgYGBgZHmbUUCJys+LM/+zP61re+1bO2Uj+aUp/61KdobGyMdu3axX9/5zvfoR07dvC/L7roIlq6dCn/+61vfStdeuml9JjHPIZe9apX0dTUFH3oQx+iM844g170ohcF6b33ve+lq666iv7kT/6E9bAQme+///u/6Te/+Q2nd9JJJ4WeDzJtaGiInvCEJ/SUf4P+YEgpAwMDAwMDAwMDAwMDA4OjzFrqq1/9Kms9ZcHf/M3fMDkEMufhD384zSc+/OEP03333Rf8/T//8z/8A4Bck6QUrKN+9rOf0Wtf+1oWcq9UKhzx9SMf+UhITwqf3XXXXfTFL36RraZAmJ155pn0pS99iV7wghd0PR9E1zOe8QwaHR2dl/IahGF5cRL7BgYGBgYGBgYGBgYGBgYGxwQe97jH0YYNG9j171jBb3/7W3bnu+GGGzLpUhkMHoaUMjAwMDAwMDAwMDAwMDA4xvHrX/+aHvGIR9Add9xBW7dupWMBz3rWs8h1XfrmN795pLNyzMKQUgYGBgYGBgYGBgYGBgYGBgYG847C/D/SwMDAwMDAwMDAwMDAwMDAwOBYhyGlDAwMDAwMDAwMDAwMDAwMDAzmHYaUMjAwMDAwMDAwMDAwWCS45JJL6LjjjuOIYueddx5de+21idcjstgpp5zC159xxhn0/e9/P/T9C1/4QrIsK/TzJ3/yJ3NcCgMDAwMBQ0oZGBgYGBgYGBgYGBgsAnzjG9+g1772tfTOd76To4U98IEPpCc96Um0b98+7fVXX301PfvZz6YXv/jFdOONN9LTn/50/vnDH/4Qug4k1O7du4Of//zP/5ynEhkYGBzrMELnGQA1/l27dtHo6CifHBgYGBgYGBgYGBgYGGSF53k0OTlJGzZsoEKhd7sAWEadc8459KlPfSrYp2zevJkuuugievOb39x1/YUXXkjT09P03e9+N/js/PPPp7POOos+85nPBJZSY2NjdNlll/WUJ7NXMjAw6GfeK8V+YxAAhBQmewMDAwMDAwMDAwMDg16xfft22rRpU0/3tlotuv766+ktb3lL8Bk2eo9//OPpmmuu0d6Dz2FZpQKWVVEC6qc//SmtWbOGli9fTo997GPpn/7pn2jlypWZ8mX2SgYGBv3Me4aUygBYSMnKXLJkSZZbDAwMDAwMDAwMDAwMGBMTE3zILfcVveDAgQPkOA6tXbs29Dn+vvXWW7X37NmzR3s9Pldd957xjGfQ8ccfT3fddRe99a1vpT/90z9lQqtYLHal2Ww2+Ue1hgDMXsnAwKCXec+QUhkgXfZASBlSysDAwMDAwMDAwMCgFyxEKZBnPetZwb8hhH7mmWfSiSeeyNZTj3vc47quf//730/vfve7uz43e6UUTB8g2ncL0ZbziYrlQTSdgcFRMe8ZoXMDAwMDAwMDAwMDA4MFjlWrVrHl0t69e0Of4+9169Zp78Hnea4HTjjhBH7WnXfeqf0e7oPj4+PBDyykDDJg5pD47bRMdRkYKDCklIGBgYGBgYGBgYGBwQJHpVKhs88+m6688sqQyDj+vuCCC7T34HP1euCKK66IvR7YsWMHHTx4kNavX6/9vlqtBlZRxjoqBxaglZyBwUKAIaUMDAwMDAwMDAwMDAwWASBa/q//+q/0la98hW655RZ62ctextH1XvSiF/H3z3/+80NC6K961avo8ssvp4985COsO/Wud72LrrvuOnrFK17B309NTdEb3vAG+tWvfkX33nsvE1h/9md/RieddBILohsYGBjMNYymlIGBgYGBgYGBgYGBwSLAhRdeSPv376d3vOMdLFZ+1llnMekkxcy3bdsWCr3+0Ic+lL72ta/R2972NhYwP/nkkzny3umnn87fwx3wpptuYpJrbGyMQ7c/8YlPpH/8x39kiyiDOYAvDG9gYCBgeTJcgkGiavzSpUvZZ9oInRsYGBgYGBgYGBgY5MHRvJ9YNGXDthdi4yOre7u/MU5UqhGVeiTrDtxBNLmHaMODiKojNDC0Zog8h6jae2RHA4MjOTcY9z0DAwMDAwMDAwMDAwODoxtTe4n239oRHM+L3TcR7byhjwzMkabUzuuJdv12btI2MJgHGFLKwMDAwMDAwMDAwMDA4OiG2xa/Pbf/NPqCcVQyMDhmSalLLrmEjjvuOKrVanTeeefRtddee6SzZGBgYGBgYGBgYGBgYDBfMOo1BgYLCscMKfWNb3yDo1W8853vpBtuuIEe+MAHckSJffv2HemsGRgYGBgYGBgYGBgYGMwprCP8+CP8fAODBYpjhpT653/+Z/q7v/s7Dpd66qmn0mc+8xkaGhqiL37xi0c6awYGBgYGBgYGBgYGBgbzAuM+Z2CwkHBMkFKtVouuv/56evzjHx98hlCp+Puaa67pur7ZbLJSvPpjkAzX9chuO/w7y9/Rz+L+nfacLHk5WpGnno6VOjEwOBIw4+vIIu39oZsPZxs2Tc00qd125zQ/CxX95DFa381Wm+sTv3tND/f2er/B3GCh9GOM0ZlGa07GqsEix9g2ont+QbTvlvDnris+xw8i3fVrqWQ3iLb9mqjd6n7O9t8QNVL2iVP7u0XI58F9sO24dP19h2i25dBRiUN3Ex28S/sV5q1r7jpIN+0Yo+vvO0wzLY0O2MRuor1/nPe8HREcultEfpTjot0Mfz9ziO763c9p32RD/L3jeqLZw/OaxWOClDpw4AA5jkNr164NfY6/9+yJTFZE9P73v59DF8qfzZs302LCkVjgOa5Ljuvxb/VvLGiwWB2fnqVmywm+j94T9++052TJixb4zrHF717Q7/0DSCdPPemuVfsJFnuJi08/n2273bU4PCIL1yz1Nqg2WoRA+2DDjbGX1i5554uFslEZJPotU6Y55yitu0EirS/qvsfvRssmuy3fHd1toZsPZ22bZtttarXbczI3Iz+NZpNcu9WVxkIgYbrqKa28yvfBvU6bHLtJLdSlbVOrHX7HZ+3/uAf3pt2flKfEyxyHmrOz1Gy2up49yLZQCbosJF10nk6dHzKUNzYN/17URdIz1PuzzmuDQFI7YIy2HNcf52b+NFBw+D7xe/pAuFochTzCRrxfzBwQaTYj5JNrE7UbRBM7k+8/dBdRc5LmG9MtzKteh2g42jC+k2hil/arpr9PmW6iDlzaNxEhYYCDd/YehbGPvB0RjO8ME7SzY+HvD91DjalJunv/tCBM7RlB+s4jSvP6tEWCt7zlLaw/JQFLqcVETMkFnkShYFGxUODfcwG5mELqeA4Fv11xIm3bZLsuFQoOFQvl4D55jbwn/t/iGSiXRShL5zk6yHRxLRY4QLlUDJefXyQtolKFqFDNVVYsisAwly2HCuVqcL/MY6661uQjKR25cMP3lVKJin7bxtUBfuvaR+0nLp/WeFQulnhGKBSK4bKi/iyXCuRSCy84wvdtKiHPygas6ba5nrvqei4QU29BfpEH5RqXKkH/8cib8/GQux/0/1AizyGyimhAXsRjw120LCqVCkGbps0XyG/ctbJc+O3TAYnpzhUGVb9qOnLz1WuZuucyPfI8J285464/Iv2xR2D8TjdbQV6jdYRyNOw22Y5DtVKJhmpiXAuNEDGuOaKSh74f/67B73q5HMyjWmA8uY5/dJfv/A7p24T7XT4QE/XePfdyyn45e3t/dMY91t8Y9ygPxrz83nXaZHMVFThtOf919dm08irfFwuoM5eKqGvLo0qBqFQsB2uNvP0f91RK4u+0MRSqpwxthOunpmdoutmgWqVKI8Vi6NmxfS4yp2aBbFf0T6CMZ1keFTwuMTkehdo3Ok+LNJT6ieYhQ3llHbuu6HfB8/x7bRA8nqjvaqWU2EbRPsLvWNtmcovfsf4aoKue+qg7Lllk7Isx2ub3dz/ztIFBCEbo3MBgQeGYIKVWrVpFxWKR9u7dG/ocf69bt67r+mq1yj+LCsoiQF3gAZle4j0sIjrpu7xJBUEiF1vqQrvulqniulSriEWrRHThEfdv+QyUA4QUFkNJkOlisRm72faCfUyuOgkWTm2HCkWXF5vRPGrrOq5+NflISkee8Dv+yxR1gcWnSgSp5AzqS9c+4rsClQoFatg2Ffk5/qZOeVZQf2VBbFSwiHXCGzm5AUOePNumgtemQhlk0QANMbsW5/whUdtG5vizrkWtUrfhhbpYaBfwZY99Pgn9Ehw9IbJZQfugH3Q2nzHWA40m2bxREhvZLBtKQW4mbz67njVAYmRQ9Ru3+eolr5J0EARJ/H1Zyateyhl3fa9EmLw3ieQCJEmO+R19KCupLq/X1RE26epGWBLKklznvHlKPkrKZt9BOflOpBbzrrGoXuuQVkoGO3MCzwuYQ/L3MaSP8jmORUVMQJE0dCRMtJ1gRSNJJqSnrVNl3OM0HNYkrmtTsS36Yq2IfVebWjzIy1QsIG3RB8U7Q8lXWnnl94S5te3fWyLyLKqiLBn6dFz/R5mq6AsoT/BSDLe9JNO6+rMuz2hHHEpg7qcCtfzfkphL63N8P6wf+EvOYWrZ1HbFe1WWq4h+yHl2yLEEmSfrXT9PJxCFGfqkeiAYqid5L16MYMeCqgqPV/VQL9rn+B3banHdFLwSFYqSwIsQZT0QuknEJOYJHIJF5x4Dg95gLRACa+6tZI9lTXV5fGqweAjbY4KUqlQqdPbZZ9OVV15JT3/60/kz13X571e84hV0VEBZBBSK5eAELPNLXN5vYVEuFz/ZFxNxG63YxX9O5NnMMVBmz6FK0dIvRIuCyEjccGgWVsHCqVChIk7CI6e9sXmMW6Thfq+YOR31hB//VkkYpAsyCj/YsBUsQUIlbQSw2KsS2sfrIg1Di0QsPvm0FRs9V7sBKyIvjk1Fy/M3F72fmkpw/3XaVHRaIm9yg4D242f4dUuF7kWt16nboiXqoFQoBZsbWFP0agkx0L7aKWwfJJlsGzHu0a4jpWRiHW43s7OT5BTKNDw0oj01jytXXmIpCzEiyVRsxtFGSaRFT/WbkI5KWvD46YH0SitjFrJLvSZvOXXXx1lJZimD+DuZ5AIkSS7mk0pmUl1er0KS69GNsEoow/pEAhtnde7jNIq4tzcyKTRPY47pY14QfUr/7mMSJjLeou0nXZZgIYJ6gcUVu26VymQ7ol1hhVNGXVlFEsm1yfKglzVDjoXPy1QrlalidVtKaTKVXF75PbuPZaujaJ+Ps8Tksd9scv2XyxUqFCpdbY/WxuGHsBD26ytigRZqR1jJ4pVRqNJwtUa1cqXrHRfX54J3C2AVu61wY8ZvtF3F+wtjoUBFvJt8Syn5Hf6DtV/4sC5CFGJN5uBd5Yr6xo9049O8K3SWd7L9XNci12uT5wnSSnXRk+NVPdRTP5fXl0plKhQtUR45xqLjTUOeqW6BeEa0HnVjQle/g7YwNTAwMDBYGDgmSCkA7ngveMEL6CEPeQide+659LGPfYymp6c5Gt/RgfCmtOslzouYdvyGVy4i2D2nTY7nULFczfRSz7JQ6HcBkfsZHs5FXXGCC7e07gS7F7OSFAhMlyxBFikLq2DhhIUm78m8bHmMPeHEKXohczoqyceLu8AiqhByx8OpLxZ9cW4wEl1WBpFnRReJ6kZJ3VAG17r+abdazj7cYHjBDM0XnMyzuZd4Js5xbQ/Pc8QmVJdfp1O32jpw00+dQZBAxwL1g7R1lh9MmvEz/GdZcGvINx7ctk3O7CQVy2UqlGvJ9RQhrzgPvgsItpxZx1hAcFql4MR+rhbzcYSJutGT/XemBQKyoCUtsswF/c4pqqUA8pe1PuLKmMdFULrCYvONDXSaVWhaeeKsJLOWAWSA3IzK+6PXRN3gspLqOrc5XRlkepJQZk801wqdhIatJEtUKPV2EILmcVpNKmLjrXlXBu2JV4PIiT+H+3lOIpUV653gUCSh7NJliS2lQPQ7TWH52rSp5ZXIduFyXaRCEfMSrF5BRleEhpUDVzGLKiB4+OBhgNC9y2LKltVKj9vPP+8olDGPdbe90P4SFlPBuNAR+ZwXEDiovwLXT71cyDcPID185KfrJFldJ4DL76GzCDJVzUWmuuHDkwKRKwi2YN2S4Z0aNx+0/R8LLoMBaaWMV79O+SBHsYiVc0mpXKJy14FHIXV9Jcdos93mA7NhqqSSUL0gTJqLedcQVPOM5hRRuybkFWBxAUFlrGuwB2Fmtof5WU0n2w3Bv7BmLbVtwWG77Y4VpLpeak2TbbfIqi2lUrFAjUaDauViJ6+BRpXVSROu2VIs2v/dsB1xn58mwdWZ92Y+mEz238VMtkdgzxKV652/ka7vDdD5DHN8i6g6Eq4bBaF8+LpKQVHbLtcFyhlF9D4dcA0sWzGHiMd7NNNyaLgaHs/NtiMOTQpWKF1cD70n9Tm8HnT9PZsGtoM1mT7PseADlLZoA9+6WhWAx19BT7Qb1C5UyHNaVMb6gQ+AqsmmZmhftG2pHt5nRtuQC+jP2fy+wtzavQaYmpmlarnIxH9QPzIt//f4rE2j1VLHWyZaH+qzIb5fHuK8cf1H86+UjdtUjgdf0iUT0BfZYlnfbrKts+KYIaUuvPBC2r9/P73jHe9gcfOzzjqLLr/88i7x88UA/aldZwOu3ZRlJQYKRXLanjB1d+fe/WjOXJ16cb2QdcQ6GWxy1nkhRRe/fbh2DNJFJLyo61gKZdV1ii5c0zb06kYpM5Qyqi4pOisYPWlWoiKIMNnP5QLXP4EGWaVNSZ4yo77xO7pRTLMM0Gh+aN1KsVmC5hY2H9xvOPH0elHTaTXIwcsT3oiV4eSLI2OZ88AbFSw0wvlDe0KYHi+wGm8mikITBGReuUT1kdGgT6dZCPUzVuM2SOpGT1q6YQuNjWeuPpZhUyK/y0pW5bWY0pURrmrTrRZVikUaqlYy6eGxFpHvOpO1nnVuTklWklnLINzGRNry8+g1UUvYrKR6VujmKAlZLi4vWdRy2uS53f0mqsUnyazoPAlrJHbBbLd8Yqt7Y819gt3XSHlXyAelaDL51jtZ5h7psiQebAuiGwvlYokqbryGE5MwdWvgbsmdB2jyHikbLHJUq5i0/sdjv4z6LgurXE3bw+pMEoKBlZBuXQNyDBs21J1CnuQi3SNlTHItS7JwTSNoM41NpMube2Wd0OO6QXUvVK3DwtIGok7ZEE0hd5NIdwyDtuskvtfls7FJmUvHEDWfR8SV3oBo901EU8NExz9CRPyC2DP+veNaMV7x77xQ04kDSC/NIfQde6do6dTPadPS7kOuADtvoNt3TdDE2nPpwcetoLuuv5LWL63RitMfJ76PCFYjzdHWdbSl7pNVzUnaO9FgkegHbVlGNa/BaXZh26+Ilm4U/0bUN7U8U/uI9t9GtPFsosqQ+Gz7tUTDq4jWPKBz3fZfi9/y3vHtHcF3JqDadNOOcbrf2hEq++MRZAaIHZAYiERXKRXo7K3LQ1k7PN2iW/dM0ukbl9BozHsaY/7GbWO0aXmdNq8QeTw43eL6OG3jElqi3HfDfWO0fLhMm5YP0e93jNP9143SiuEK7Tg8yz/nHLc8IJlu3zdJh6dtuuDEldrnXnfvYd4CnHeC/nsdCjt+TUv2z9DE2vP4bwidn7haEHk3bh+jtuPRBXK62vEbusE9hYb3XEunHb9BEKtLNxGtOF6fOMTRZdQ+HJZvOa8jJo6+uvnc8PV7fh8Wuq8vJ1p3euiS+278MRNFS055NNfPeRurVNh9I1FtCRNM46vOopv3tahUtDjvQKi+GuNi7K09Texdd/9OlHvVOXTXvml6MJN++vkZbbq10YMYPvoiSLBND9F+fe/BGdoz3qDTVmdb9x0zpBQAV72jwV0v2MxhEyr1e5RFSteLWJ4cghWNW8QEi7siW0jRPPnt9+OKk0hwZFj0x2tmYFhEdECii9+86Yfup4G5iKjIYv6ehrRFXGijpINuk6DUVaPRZJIHL7Y09zLVBcZl0sQmUBaFrMK48pQZeVLdCXMgSZspcI3CmOGTAt/iTTPG0jZExUot+M1WYL5Av+puE9wX2ZB0NuY4ebE0J/XhqGOsCQJLQlxbrvqbdZtK0LFxHfL8skbzOSi3OQkQKNKtTD4P/bea0L362ZQAeTYoOosptGMeUlWQp+LZddXCI02LKOf8q9VMU1xxekXWNp9PlxndPIfPwA1ZXkFsjn0tKT9z5NgtmkU/B9nH5K0oT7R+mBCByxefIFrx9YH0QX7gBFa+V1lgvdtaOZFciCKO4JCWO8UKW0NWkwinXt59fcPq1IO/BpGEMwTp0/pELtct1X1QR87E6EX2S6pr85eiPZVG0GbRoRPskFiTifer/xl+q3/3Wo6uPpdida+p06Ztk3ASDltQ654trWJzvUeyuraDPOd3my83IMz/52UtaxADNVqdzjIoK7DhToNqkRTBLNyDqZKum8PrJfH5rBIwSpvm5CGi+kiHp2iJ6/l+WDfmBSxvOAHc65NS0uIlCSBQFIB84vzZIIoVElkpL6ylomj45YVly2jMo2QKk412yMoGkESJionZNjVHnCA/wLS/vlWvHp+xM1ky54Ew+NHfpMurXCcH9dkK12uXRVJwY6u7DaN9PRp5MdKfQdYzPC+oWw/vOqX9W81WbN7FF9JqrxEaC7N+v4SFbFWzNpDPltdxy+TRlFLrIoKJ2fR2PWZJqaMFwYbccTv6PawzQFqz60A8VL7QdS94ZXGXupHpS/uG0t0LZZ5T0mdXMlipONhQ18PXRl3xsqSbtJiPs7qJcx/gyUQsNrltoovnXq2s5hj9Ew/6BW2soGxGYA5mkVjfKiozAZfnRFnTlknaTIFrFNwyMB6DPtedJtYI7MYRsyFi/S/W6LDYhFlu6FRh4qTNTdx3kvjBybgkDKCxhxcmXJRUjZ8KhPstbOpddutQozDKTUQaqZKHnADZVmIX02yuZVkRro9of07u21ErVLYsUyymOHiCxn01rg5AMAXkoktstZZGaPVCJEVd3KJlzGuhmBf9WiRk1eyJ62dCN8uikmV1W9jxO9GjerFADmsv+W6APqmMiKKBlQc8rXA/Pz5hUYYFG7NgluLe4Zvlx90nyYUkxGoPzgPRlPZeT/weEzNCt4rv4M6cNZpebqTN6TF6kYMm1XXaU7GIqbtc4wb387oCbiW1rr6SOvfGBluJ9rluSYE4yDqtlyvBGMo6r+ZCNI9ZyoJlWoigMjgqhJN57o1rT6/redIuT7qaDRJWz9/GfBfkceELdKv2jrJp01olKN3CL97CUJC3+rh3gVSyFyXdUmBIqUWIWP2eGLPrrkVcijXLwBYIeRBnSZSQJ14AObYQM49awnS54mVPN5fVjdMkas0SVerUdqtCf8hzqFpoUwHsOS+Oh303AvWZc7TByNkWWYVosyN5QYt+mxblTYe8G4pQubLqF+TUvurKk+5+/zNWE0mIhMcnLf5pS7FUD23oukiGHPnEvYHfv697VVVNkVyPqvA3h94CiWiMUXeb6MYpafOTZ5M1J5vEVHe05Dx1RXBkK7hOPi2wFiCkfPc+tQ5kvcioV1IXamRIEBEgpNIIrUGVM4o4Lbg0xLVnXMSuXttSV+9J81o0X+y6yBHcNKQbDlqKRPVIhDhJNjbsFuszQctsWb0m6oenL6tLTDp4LgeRCOsNppElmQjbftzC+wUsv+CCh/KrljlBxNOEeSeS77hDg4FY1KlrFdVqKmUt0/+7TYOI9lTmuvWROm6irv5eM7BoF5oknTpPnXtj8tDV53L0QbVOQ9aJecd3GrKsYaPX9aFlaTAHOEKb5PyPTbnBEi7y/M+ecxWbeL5MJxJ0c1PlklzQpZ3G08jvFwhf0gW0bJ6rB4kYo70+kOVmqQkWuZPfI4NtpKxlMaTUYkZ08RW3mMh6XVZE7nedNjmIusYaF71ttlw2Y/c3eZi5MuSPXclgIRUV1ta44iF9PqmDOGxFuIDlRpCmslnB6Tg0YByHWuTrD8ECBOKz/GhYstHcIc/GIXqfa7OAqwhTnb5hz4SUvtXrxiBv1J2eLDdyjouuPOnu9z9j8XONFkewOfMF3Nk9J8EKTJw4e5n7cZqbo7CcQtByLxhT0VPs6MYpqW7zkBNqlCi4EObRQktD5s2vMn7gqMfRpSLEXFjXRoiv6/SmZL1ICjCqC9WTHtuA0Ouzu4XPO8Sb6DEJboI5CPJUd1xlXuMIYpGIgon9LoakUK087AbMzwtCvLZWjSU8Os/RWF/EHexErCWFi2Uk2ls0jYToaono54Ao6vYWfZckzY8ZD7Uyzct5ynAkSbw8h3kxLoWJ44bXGeKgwrU8tvIr8rsaOoYOFSuV0IFL6twbk4euMsyBVV4md/tBr3XdhWuRfmxiHiylQjtfaSklYGXMUxZiItMGuxdLmrmw5hpwmr20YseSKhygZKGSU5kwD/Xq9fOMHJU7l82Q1UJKwpBSixX9LD5TFs+paUbuFzod/PbveSkTcs9i4btCf2WJ5pHdblKEsbM+S92s8Km6w78rpOgPMangu1bO5aIoz8Yhel+7RUXfDaXIBFvCJihP3+hB62IQUDc8vPD12lSEpRwidWXJR7+Lcd39MWl2bc4gzqmLEqm5T9uPY9oni5tjFuIqpLuj2/z4z+8l8qD2FL1P68vMpKQ/fkDKNTgLiFqZ7qaoqwP1szIJSyo1cl1Uj22uXepyacFlEE2PEm9wu0zcYOawVEjtpxHNxGhEwV7IbvWeZYWhoC10z9TdkxkRa0lpSZfYN3u18ujHOiTq9tblct4/WZGJtNaUIZZkng+3xkEgxqUwhEAzqu1LGfiBMzyMuTY5LJGENqloA9GkBi3Jkoc5Qur4zmvh7a85RcRZXXI46BBBC2oVCLv3l3+DfJhqtalsO3TbDb+mYfsgnbxmNBAKh57Q7IEDtGq4RPbMGO2ZaNH+8Wk6/sT7092Hmqx1tKXeoAO77iXPKtK64iRVVx9Ps2MN8lozNLbnh3TimhE6ZFfo4OExWlrxaPVoleqIVDaxU2hYNaeo7Xp0255JOnGNCBzTsMMaSodnW1Tet40md++mdauW0d5xoQ1XH7uTbpk9wJHKxqZtKvz2Cv780HSLquUClWbuIGda6AZhiN65f4qW1su0eqRK1R1XUZXWkD3lEtl7g+fMNNscfXN8tkWrR2t02J6k5W2bpps2uTt30uYhBGewafbQThZKX1KeptVWje743TX0gNVlOjgxScuqt9N+WsFcwyrbYd2hAzsO0rL2fqo4s7R37wSN1Eq0ZrRKd9y7nai6jHbtP0QTt95EhRWnk1seZs0g1InE7IFt9PtDBTr7pI20f7IZaGLdvW0n7Z64m47fvIGaS0+kfZNN2jTUpkOHD9NsE1b1IzTZqNP4dIsm9txJO9xVPDfdsnuS38u1coE2LhMR4ApTe+nuJiLA1engH39M1v3Pp4lZQVTs37+HVtSKNFZYEuhFXXvPoUDTC0Ls0MS65c67qGgXyKksoevuPUS241F5dj8tWzJCG33drBv+eAfdf8NS2obmH9tD1ZVbyNo/3VkDNQ5RbfI+mi6tpHt37KLKkuPIKdbpj4cnWDgcovBRImfv4UkaHvsJ182+pWfQ0iWjtKS5l6Ynx8mb3kfLhyosnr515RDtvulXVKlUaergLhqtlWhk+hqqV4qiXx64k9NDvg9ONVkYfuVIhbb/4TZav2yI3PpKrjMJe9dNVCvW6b6Jado6igh74p13cPutNNT2qF1bTq2hdVSZ3kl0z800u/Qk+t1Yhc5Z5bG96sHd99KusQbVrSaNVst0cPx2sobW0q6xWTp+FdrOpqbt0mjrD+SNrKU73Q0hzbHK7F7ae/udHFny0J6dRONF8uwGrfDGaO8M0cknnUS1okU7Ds/QxJ4JOmnNCE3vuI1ao1toWdmmu7fvJstp0pblVaqMT1FlYg/ddtcMZYEhpRYrElyFejZXznG/uuApYjMNYiPH5nHQ7h9zflKnIrRYd4KwoYgiEdYfkkKbc4ikjUPSQs8X3WVig/XIYkz7JdK+V3GEzObVPsQLdMyvWNxDdwwaHHnbvVdiJMN9vfb32H7cR53nFcjXbsz7eL62THk2pjFpwiJFJYWSxo+vC8pEch4rr7yR69RywDqszYuAwbjzqSSXeHa4rrLqNjmwfEUwAhwyMFHayX90jM2bFYsyr8ESNW7sdPURnbag5j4taTcowiNiLanmse+6yxMVNm1emgeLmUzRXjVlyEwyD1DvcqDIUpdyzmNtMukaCJkGVxyueC4Vi9XOZynl66qzQbfnIOs65/sjrT+oWonSutVg/rDt4Aw13BKV7WkKJKAP38u/7j0wQ3Tg17RqwxLaPz5LE9M2YUV5z10WtUY38zVj9/w22JwexP+mbyOnPERFW1hU37VHiESjp0xC03nqAG1dHZbm3nvfrXT8bz9NjaXHk3Xy88iT1ug+dh0GCSWIqFFvgokCoNQa5x8JkFES2Mg3xw6E/gb22U0mpWAVUp3ZSXvv2EXL1o4qzwFE3nceniWydtCMJEDu/S3RhiX8TxBSAKKVje29gQpOg+492OLnHLjzDrJrK6jYmqQJrMfR+2d+R4edTsS0qUabf4boVppYdz4NHbqZDk416Ac3/oLW3u+crna6+7bfU71Yo70TK+m+gx3SYPjwLfz7vnvvoYl1IkK9e/evgu+HilWaWv0guu2+HTR8+B6qjtjUHNnE32FcTjcdun2vEAmvT9zNvxujW5j0OXDrNUTrzhftfPeNNFW06NBqP3JdEIxG4M59U0x4uHtvJVCLKBOIHU53/C5qjhMh9TVLqjQ0cTttHyNyqsuo1hyjmVJdlYqnobHbRXXvEORobUL0R24ZB+77mMvCpNSBQ4dJtvbI/t/S4eL55OwR6QD7x1DGgl93M0FfB2EoxcpPQ9tO7uZ/7x6fDT4/ONWiIbqTxsdFuYAl/v0lFIzGCbLle70SRy/kupkZ43GB/glSqja5nWh0Cd19yw3krTufycP16D8HDvPYwP1Nu0lV2kXV6V2cv0M7b6fhG/6VJo57Kh1c/WCiA/fQ7JqVrAkJ4hb31Sa3BeUWmRWRHff7Y+6eO26mB6wbpfHdE0Fkx31776SZZdBO3UnuhOjH945Bz9binl+Z2klZsIDe2ga5wAsBnaZF5zO5CVFDaOdOM2VRIDZcVm63G/V+oJc08qAT2Ss9ElCGxMKnjhnrLA7adpLuGyBV2DLLDX8u/1bzEkWgq+V034vrQaAh0iJbFcWY9gdpRb6Pyx8wgDrJDCUfiERZVkWz1edHBcjT0pMLbvwbkSzU8umuTap3DXrt72o/BoJ+k6HOc88HecDubwXCGi1v+tqxqSlPdM5ISxM/zEsmXe+PHxDrsJCCBtSg5iARVbDbmkiWg8m4Igi50kDaSepG4beurqRFGn6S6gSkT9FyqcJ5D+c/V79Nmpv6QFIeusodbPRbqWNyzhCph0x1mLXuonNNnvdBL4ib8/JekzSmNWXAQXERlq9p3S6tjAPO/0Ah57xyTRyi4P2MeoAsAuansnDtzjoG4+afgWEQ/anHNUNc2aQrOAh6aCXWSyWeY49Ie84DLrnkEjruuOOoVqvReeedR9dee23i9ZdeeimdcsopfP0ZZ5xB3//+90Pfg1R5xzveQevXr6d6vU6Pf/zj6Y477sidr22HZjhgSxrCb7je1iVL9lxNW3/y90TfeqmwlALsGVp9/T/T0MTdtGz7lbT67v+JPLj7WQV7ioYO36qN4Fcbv4vW3/JFWr7jytDnsLCxnAYt334F0e2Xk5exj9XG7qQTr34Drbnj6zFXeEFaKkljefBLUZ+hfx6s0a6+6wBNzjbp0ut20B93HKRP/vhOOjDlR2cLQYo35IHU1BK/D0036ebdE6G8SuCZX//Ndvq3q+/hqH75npItZ+HmDPzP6d6D0/TVX91LH/q/W+mjP7qdfnPvIf96j27fO0k3bj8cRATM9GzlQegrp/zkJXS/X1xEtXFBvM0FvAG6yllOi5Zf+2EaHruVtv72wzR06I+95cnzQpEc1cd6mvFjuW3a8rt/zpS2sZRarMjgKpRbVyfHSVq/lk09uVdFkfEUPPb6rPep90av7dcVMq6dtELtOTSj8oiDAmmm/dHvpeUU63+VsuVnLk5g4+qJfxU6UYqyEmRqHfE9fjjTqJB+9NpBarZlRKjfsKVRD/1sUGAdL7hWQe9qAOlrxlXeOQfXtdttaraxkBPuc1ksOAblVqemGbIsleWI2VhyhL82TNKLuSzYVN0okW63e2EWa1FsgPn+QVhA9GlNkVcYu6uPRLQFF5q+TN/C33nmmkHMS5HoZtmiucUj65gu8JxF/kOLvZcxS96OlEB2RimC7MnNgbD7PFhCpgLvl5ioeky820JeoVarMpGnFcM/CvCNb3yDXvva19JnPvMZJqQ+9rGP0ZOe9CS67bbbaM2aNV3XX3311fTsZz+b3v/+99NTn/pU+trXvkZPf/rT6YYbbqDTTz+dr7n44ovpE5/4BH3lK1+h448/nt7+9rdzmjfffDMTWVlx/5s/Tpv3VeiWk/6OSkuEpU1WhIgNz6OiPUFOOWwFpW52N9z8BfGHPU1041eJHvUmolu/S5VpYZ0CrL73f8nDOtU9g6jdJLr643Sq3aBdp72ExjY8iqzGGJ34q7dQpXGQdq56BB086//xq6sM74f9N9Lm336E5yDOUqFE42svIA8HHbVh2vK7j9LIwd/zd6P330fjW54uthewDPvlR+l4p0B77vccWr7rZ7R01y9oYu15bLVTaeyn2vROmlr1QKINHUshWe5YesHzaOnuX1KpNUEHtvyJH1hIfL5s10/JmthBX9hxGv1Po0S/tm6jggV3+wpbDV55yz668JzN7CLJAaKCJDtPg0vWgTv208rhKp26vrveYb1012GbVp0ySQ9YRrRvskEfuOpWutPeTw9YP0pvfNIpVIPLGhHdsXeSrrxKkFE7vEM0NDNDzzpnM0d4hkWXtAwC9k006Pe7xum09Uvpj7vHaf2SGp13wkomh6aaNt2xb4qWDDdo1UiVdo7N0uamza5pgEqQNGyHxsdmyC016Bu/2c4HdTe4Y3R+oU2X/3EPjVRLdP19h+getm7yaO2tX6UzqrcTnfUcsk64n1rNjOGDv6die4Ym1pwTEJZwTdv4h3+hgtukQqtJm3//Cbr9govJtUqJwYyGt/+Ulu6+kSZXP4gmVz+Y3JJqy0V0eHqWVrf3kjOynjxYxUocvIvonp/RROsE+tnEOjpr0zJauo4VyYVbrCfSUfuMNbmblh2+iSbXnkvjNEr3HJimR4/9N5WnOuNi7Z3foHvOeTdZniAmUY/37J+ioUqJ1i9NHu+onxu2HWbLr6eeCfssPcp3/ZBW3fM9KrfGEtML8u3lVaE6BjExMUFLly6l8fFxWrJEHUYLGwOJdDOXCBYLMFMv935/QEikpBO9Put9veQ1x/Xadooj3PrZ5A3S3N5GFCCQUr4WkprmoNo1y/15ick0RISv4coEyxF2Y4qme4RdRfKO77meD47kfBP3bBnxDqflQ7VsLhy93JMGKYyO0/00vSqc9CeRUgt+XlfR51yQp94Ghfms377Kl3f+GcR8paYRkDeRtp2LeTFPmknXZklnoboAGqTOKWxl2oQ/lyMsy0BKLbD2HNR+AkTUOeecQ5/61Kf4b9d1afPmzXTRRRfRm9/85q7rL7zwQpqenqbvfve7wWfnn38+nXXWWUxsYSu4YcMGet3rXkevf/3r+Xvkce3atfTlL3+ZnvWsZ2Uv25tHaUnVooZXpqusB9FDN1WofuLDiHbdSI3dt9DBrU+mjQ95Gu08PE0/ue0AEx3NkQ109aFRtrL6qxV306bmXfSX7f+ldXSQGkMb6JbT30Cl3dfRyNS9NFKrUKPZoDWHr6eq13GvYxz3CKJt17A2220nvZhWb/sBrWgJl60oPKtAe096Nq3a90sqjQsXJeBbzsNoj7eSHjRymM5pXENF3/UuDaB/rlx+IRWOfzg99tZ3Es0cTK+z5afRkqf8E+d5501Xch1esfxZdM4DH0jL7vs/2jj+G3LLo+z+tn/rU2jVfT+g9bf/O99729DZ9Pvj/5ZGi0065dZ/oa0t4Vp2u7uR/rT1Afrz4i/pgsIfacfQ6fTR8UdStVSg41cN0617JumhJyyn19//II21LDr+rEfT7vEG/eiWvfRv19xHj6Lr6IGFu2j56s209U9eSY22S8O7rqGr7jxAN2wfo5ZXoj8UTqF/fOIG+tkvfko3TS+hHV6HCH3wluV08poR+taNO+nB3h/4s13ecjrbupNa1RV0tXUWHZ6x6W837aRnnr2RbiycQe/9/s3s9qfir8/dQhc99iR61yc+Q+ONNl1Hp7FWGHB+4WZ62qp99Azn+zy2vzV8IR2orKefbmtTxR6nfe4y+rvS92iChuij3nPoXO93dIq1je5X2EFY3V/lnEFnFe+i5xaFZhj0y37zsM/Rql0/oROq4+SWarRv715at+/n/P0P6QL60rq30XPXbaOT7/53ut/E1dS0agjRRWXPpt97J9BVzqk0PLqczhw6RCe2bqGh6R1UGFpOtPZ07vs0Kyy1gBlrmH664q9o59IH0eE159Htd95Jb9n3ejqxsJvGvSH6UeFhdEJtmk6n26k8K5zp2l6BLnH+jG5wT6bWpofRR8ZfSxuad9HsyFb60cO/Rg+u76P1N32KDt/3e1rZ3sf32FaV3uc+l5Y7B+mVpcv4sx2nvoQ23PplKrgt2r/lyfRva99Ed425dMo9/0bHNW+lMW+EHrzao03tbXTYHaK7vXW0zJugje4umiivodaWR9J0y6Htt11Hd7obaXjNVjrv9AfQoZH70Yb2ffSzm+6kLc42Or90O63d8zN+5oFGkVZ/8HDqvGdIqaOYlFqwGBSRkDcddjVrCcsejmrQo6UU0M/Ctt9FUtb753LTklY+WFKxGnFO9x3pOiFD58yB+8+C2RAPerHcT70vcsQROb1YPUXvGQRJkSeNtGuPBFHTM+ScCz2PDEL+iXWhBo6Yw749n/WbqV/EzRODOChZKIccg0S/hyKLrQ7m4j2iprcQypiUv+h3HLAFy4eF+Q4cxH6i1WrR0NAQ/dd//RdbO0m84AUvoLGxMfr2t7/ddc+WLVvYsurVr3518Nk73/lOuuyyy+h3v/sd3X333XTiiSfSjTfeyESVxKMe9Sj+++Mf/3jmsu1+0wpaV0smcmaLo1RxpmnaqzIBdJe3nn7nnkij1gw9q/gTWmlNZqsLr0RfcJ9Mj126l+4/9evg8+ut0+kjzf+PzrTupleULqMRq6O9NFbdQLudpfSAttBOAma8Ct3qbaEHF4QotYqb3OPpQ+0L6d2lL9MJhT2h78CRfNL5czrXuo0uKN4c+q5tlTmIU5VszmeDyrTEQqRXop84D6THFH8n0kDgmhhXvPCzLLZ8UjHhDdESq1tEev/QSbRs5l4q+4Tapd7j6Nb2ev4bP0utaTq7cDu1vDJdU3wQWYUyNZsNTuu5xR8F9fVz5wy6wT2Jzi7cQVutvVSyHNrhrqar3NNorXWYzijcQwcLq8k6/qF01Z2HyHJtKpGDsE80ZDXokbW7aNNIgQoze2m4dZAJl/90HsuE5bmF27i9r/LOpN3uMr4H9YD7QRwVyaHRUpvO9G6jCrW5zppUoSXWND288Ac6s3BPqMy7vRW0y1tJS2maNln7qWYJT4d2aZitgYqOqPtecZu7iTZb+2nIEm6QF9sXUplsek054h6aAxAZR10+oXgDbbDSSUyg5RVpnEZotTUe6huI0CrbOw4/oIfRf9MT6KHtX9HflC7nz250T+SaRxv3CvRDlGMdHaYzC3dRUemn/+ecTV+dOZ+++s/vT533jPve0YD5WDTMiailZtGYZxOT26xdRJpjQirvYpUXZ37eWXRUhj4r5M/bfAnS531OnuuTQpeza6bvaqhze0vLA28+0Vb+JvQImdzPtfj+wN1E/IiKYkHem8vH0YY8Uefi7hmE22MeV5q0a+e8Xw4U/pzbo15IqC7wbpgHN5z5rN9M/WJQbsK66/uZgxbqHDNP7tOZ62+u12dz8R5R08sT5GQ+kLa2GoTF9ALHgQMHyHEctmJSgb9vvfVW7T179uzRXo/P5ffys7hromg2m/wjgQ0n8L7pp1OlXaEXDf+aDrYKNOWU6aGFP9IYjbAVz/nF27CN9cURZmgd/2ynh5GvieUQ7aUazZRX0mX2OfSn3s9pg3WIdtFqOkDLaI+zhKa8GtWWb6A/uFvplsMWXTezgV5fvoOXjj91z6Ir3Qdh+07XW5vpfcveQnftn6LlziGqWG3aNbmK9ZBeVZqhU6ztbBX/2fZT6H4PfCiN7v8Wrd1/Fc2Wl9PN1kl0Y2M17Vv6YHrhGZvoW7c9jx5/6Ot0++i5NLT6RBrbfTv90V5Pd7dG6FfOZrqjuISeWLiehqwWNb0SfaT9TLrD20j3K+yi8dJKallD9KLKj6hJJbpk5hG0t1ihJxdRZodmvTJf6xZrdJYn2nDCq9O17in89jyjcC+tsw4HJNnv3RPoOSVoXE0T5KYnaIQucx9BjuvQi0o/pGrzDgIFM1FZxq5TT6If0ZOiDegbJqnkHIDhvw+kYXuKzrJuorPoppB81Sl0kE4hv585RFvpHqJbryXUeBemibxp8Sjk06Jp+mv6jv8g8Yvvj4NiCHcCKYShI9JD+6+wJrl/DNNBOllI4/NtU4U6ld0WWU0hut4ojtKdxRNpfbVBKydF/g8sO5P+6fBj6c30Fa7fCa9GN7j3Y/KpSWX6uXU2nUjb6QnWdbSetjPls4vqdEXtT2ln/X60YqhCn50o0hPcX9IIzVDRnqZbrBPpJPdu+qV7Bvez0wr30h3uRrrMeThNWqN09qYhOn/6Snrg1C9pDe2kP6edos8XR+mTzl/QA5xb6OGVO/mg9afOmXSnt5Hu89YwifSQ4l1U8hAcYIwOexZ903k0Pa14NY0wUQZXxc100FtCy5evpP9zz6U/m/gqnegTqTd496Mv2OfBIZK+R6fTZMFhAvhES9Qr6vNQ/Tgamd1Bh7xRusI5m86q7OS6aBVqdHfpRFrS2E2b3G0Iz0OuVaFSucRkY9maDsYvZM7303K6z11Nv3ZPpeMf9Bhac+eebLpXxn3vKLCUmo+TwUE+I2mR1prpkFKVocGm3e8JoKwD7PqlLJW0SOnVygjIu2AdlKXUIE5E4/pFv5HrkqzY8pZ/UK59g4axlFoULlcDT/tYsmgbpLXmQrPYyINBWSQBc2kVYzD4+pvr9dlcW0pJV/1CRQRGWWgIuZS6fVlmzgcGsZ/YtWsXbdy4kXWiLrjgguDzN77xjfSzn/2Mfv3rjsWQRKVSYa0o6EpJ/Mu//Au9+93vpr1793JaD3vYwzhtCJ1L/NVf/RVZlsUaVlG8613v4vsNDAwMsmD79u20aZOI1KjDwpy1DRbeyeB8iVrKsK2R8K0DOTVUn4uFDKKq8bM016bVgbQCkpY8vZ5W5j2FzLMATTvJltHlcF4FQfCk6+Oeq9ZJ1zU9nBxnOX1X8839JI68mkMx9kFgkJYGsk4XqMvCnCJB+HYQGLhg8LFk0Za3fFnn78XmojQIi6Re3llZ09bBEFb91V+vaydd30wisQc9h0TTSwuCEpfv+UJobFFflpmLBatWraJischkkgr8vW4dFJC7gc+Trpe/8ZlKSuFv1Z1PxVve8hZ2CZSA6+DWrVtp27ZtTLwdqwDxCH0vbMAXpCHDPMHUg6kDCVhITU5Osm5dEgwpdTQgy6Kk3wXDfG2ecLrVzwlX1gWgGsY4z2Ir0OLwq0Pem2fhqS6ilCCAc7650UYfVNNNOIWPe67aL5Ki3GgFcnsoA0Wi4uFUNBp1L8izX8Sc4aYXJY5UxKhBolfLti53kwVg/ZGUB3wGEtrrY6N6tKLfw4+s9RTtM3M9fgYV+Q5w4caIydrq712ZVldHYk6ZS6uwvM8fhBg80uiXmJ1LEjtLebM+M66/zPXcFR1b/AhLWHgtYG2pfgCrp7PPPpuuvPLKQFMKQuf4+xWveIX2HlhU4XtVU+qKK64ILK0QbQ/EFK6RJBRIBVhdvexlL9OmWa1W+ScKEFLHMhkjgTow9WDqwfQFgSxEtSGljhUcDZvWLAucrAsovh9p0WA2vXkWi+oiquinkXmzYolNCWsu5VzkyXKoUQdhISXL4jSJWrNElTpRoR6f5yzlint2YQAbNJRZ5lslMKJQT3gX66I064J+PnVU5gpd/bMHC8aFMtelWfzk1WZZCGXqBXk3pP1a7mStp2ifmevxMwgygd8Xsh6k9mIfS7i0ujoSc0rU6mW++/wgxlm/OlO6vpmXxB5kXrMirr/MtSZV19gq+AdkLVFn5Xk6UJ1nwEIJwuYPechD6Nxzz6WPfexjHF3vRS96EX///Oc/n1383v/+9/Pfr3rVq1i0/CMf+Qg95SlPoa9//et03XXX0ec+9zn+Hi56IKz+6Z/+iU4++WQmqd7+9rezZYMqpm5gYGAwVzCk1NGK6KLnaNi09rvA6TKLl5Y2lJxWtO76XWTpFlG6/OkgT03ZTclLdl+LKwcPew2R44DkQfq2H6EwJ+kWdY+MWmVJayVdWlorroRy5c3PoPVt8qCfdLJuGo4GN7C0/pm17Athrht0HhZCmXrp44O0nsgyFrLWU7TPzOX4GdQ8IvOIAwkb6fmb717TTaurtDrJUq68Wov4gbu11AfCz3wuU4M5yOqjbq1OvvOOi7j36FxZ+8yHLIPOGnxerKcqHUvpoxAXXngh7d+/n97xjnewEDmsmy6//PJAqBwudAWlbh/60IfS1772NXrb295Gb33rW5l4QuS9008/PaRJBWLrJS95CbviPfzhD+c0a7XaESmjgYHBsQUjdJ5DmPD222/nSR6+3DBZxaQN3+udO3eycNeOHTv4ZGL37t20bNkyjkqBCBnDw8N08ODB4Br5G6ayeKmMjIzwdbZts6knPoteixfNoUOHqF4XFiyzs7O0YsUK9vfetGED7dixjTZt2kI7du2i1atX08Thg1QuirxONWxavWoV7dmzK7hGprty5Up+CQVlOnSI1q9dRTt37qZNW7bytfNepj17aNOGdbRj1x7atHkzX8tlmpigsuVR0XJpaqZFq9dv4JdxNN2uMsl22nYvbVq3mnbs2U8btxxHu7ffR8uWDFGz5ZFTKGYv08w0LRmt0f6DE7TpuOOzt1Mk3aBM5bJop4kxWr1yBe3Zt582bTkudC3SmJicojK5VK9YNHboMK3ftJl27tpNmzZtph27d9PGzVuDdpqcnKHpRoOWjS6h6elx9m9X01uzZi3t3bePlg7XyXVsDoO+ZMlS2r8X6W2iHTt3cd1v37WHVq5aTeNjYzQ8PJS9TEWLihbR1OQkrV6zRlumUDuVCjR2GH1vjSjT+jW0Y/c+2rh5C+3ed6Cvvrdv3z5ah76yYxtt3riB62rt+o20f/8BKpYrVC4Wybab3WVav5Z2bN/O+Z+YnuV2wvgfn5iktWvW0L59e7P1vTWraOeOHbRh42batms3bdywkXbu2kXLli4lx2mT57lcpn37DtCqNWtpz+5ddPxxW2nXrp20bs0a2r9/L42MLuU2mpyapfrwEE1PTNDxx29hzYK169bTffdtp5WrV9HU+AQtWTLCOki5+t7UFH+WazwdwXkP+USb7tq5i9auW0fbt++gDevX0czMVKhMK1euol27d9OWzZu5Po9kmTZs2Ejbtm+n9evW0djY4dxzhOx7q1auop27d9FxW7bynL5u3Qa66557acXKFeTaLapUyrnKhNDi+/YfoE0bMe53BHWVq51WraBDBw9QfWiYLRRT53K8n0pFHn9TM43YdkIaY+OTLDI/PFSjibHDtHb9BtqO+WnjJu7/q1av5fpYt3o1eV6bbLtN9aEhnk+i817SHIFxtHPHTtq6dQvnAX3vwIGDVKlW+fkIl93TePLnES7/7r29972hITp4YJ//vt9Bmzaupx07d/M42H/ocE/jaWpqmoZHl/B7f+vWzfnmCLxP16/n+XTl6rVBmcrlCh06fIjnud07twXXyPcT3jMzs7PkuS5VqnWOJIb5bs+uzrVr1m2kPbt20vBwnSyrQE3bpfrwMI0fPhzkE+Ppvvu2ifl5fIxK5QpHK2o1G7R+7Vo6eHB/7/PetntpxbKlNDE1Q+VqndspKNPuXcntVK/SQdQ92httqpSJ37lLRsltt8luNWjJ0uW0XzOfBO1UEcTWLPe9lbR3/0GRLvrThnW0feduWr5yFU1PTVG1WuEyTU5OcT/dv38fbdy4ieccOa6OyFzur0/Xrl1Ph8bGRN9rt2h2aoJWrF5Dew+Ozdn7Sc65mzdtor1798zvujymTI1Gg84444yFGzipD6BuYZkFrSmdW9+xAlMPph5MX+gNxlLqaACfuklLEx98OuQfTbEgt0seXrBtWxuSERGmsOl1sFhqNsiDBZGannJd23FDaeDfuDcp3bgwkPL7UPhtvzye0+6+FxY8YDuKSnzSrIie2HFaVaKi7w6XAZxfssi1cF/38Gm3XWo0bSqXqxxaXq0z/E6C41o023L4t/o83Gu3RVj6QhGua1Wiitj8xYmQNts2zbTbVLZbfjj7aDlEfhyyyGILJl/Pq1wT1ld+mrgXPy6f/CbXS7iMcFFCO5VF3hJOK7lOcUiOe6TAvRSWTrkvW70i/6Ksal2hb7lw4YyDamWopsU/Ofqfnw5GE+5tYYw5DrUcYRkgtbltp02Ndpua7TZHexP1gHoscZdt2W2atpvktivcvjI/rbZLs22bplvi/mGkqQhzJ43PeQFbQEgdnMFAtIPLG7vZVosamCscR9Sv7fD0gOIG/TzDs7kf2g7X81zUlaPkReSzHTw3U97abe7vs7bNfWeq2eT8Nrlf2FRstKjk2GQVClQux6fJz261+QdGKZhbZls2jU3PcHpxdRU3lzuORzNy3oqOV0vOAVaoL/JYV3TegnZy2qG+Ivp3m9qexyGeJ2dt8sanaWx6lpbMNqjZdmii2aRJ26bKzAxVPKKG3SK3UOK5GD/Tsy06PDXL99DYBO0fm6LlXoGKKIfn0og/x2Ec2Q7mWTfIJ+qDCng/udyvZhs2f6ZrMzzLcW2qVTvz/sysTfsmZmmm6bBxE+5vNNvUxN9ei0Zci9Obmmnyd+gTtu3STKPFn3Ndcb24NDMzSzMzDZqebZLj4R1UorZH1LQ9OjQ5Q+Mtl4qWRxUqUL3uUKNlc55QFryTkD7+lnlDOXENtWwan53lNJBfXCvLiB/kt+3aNDUzS0vwbznnRuZHvt5zyLLQF0R/x3dtz6LZpkPTMy2uw7ZfJv5dtGm23aaZVos87hMiPR7brjAIK5UsHtslvAfRP5TxhPbHvRgDbavAc6Bjt7nP9AW8+zyLHCpQwRV9IihThnuDelH+3ZmLPB6jmSJvSksmdDd2bXZCaySMF363KfnivPJnnbkmLd/oI6Lv6ft2r+Bx5HrkdVmKpWtpyve7au0T8xAxZ/hzjIqs5TcYDEBEISLfsQ5TD6YeTF/oDcZSap5CuM4V5EK+iLd7oUi2I97yOIXGgttuwdWryH87bZvwNTgdnGaqiwQsWLHZKVlElYJHxYJFVhEnj22qFCwqlcUCqomNr93m9US1XBLpYgHZdsl12uy+X65UqFDsbPyxOEJ6nCcV2Eg2Z8kplKlYKvP3anlAImBhGNyb1xUgeu0Awo0nloeINxPYMFaKBRqqVTLdk+VeoXFqZQ5L32o5NN1sUqVYonqt3HVP1jD3Wa/LWsZM92raQm6IAVyDvKQ9Exsw9N9SocieLtEyyO8rpVJAIKaVXU2T+73jUNEq8P0yX3HpWGSRR2hLK1gkq/fINkPapaJ4pvxejjtsTrH2Hq5WqVIR4wX10Gi1efwOVyo0XK+E8tFP2wwEcxASnevUbpKFOQ7BGK0i1Splrl/UBVCrlLjtsvRfWU8zTZuvH65WqAorhQFC7QfoQ9hQ4+9SocA/yL+uH8q8NUH8YNPvFWisMUvVUomGcE+hwBtzG+W0LCrBWsVPD/URLbvsL9jM4vq269JEo8maIvVykZYNDWnzEdePdPNWHOLSCMYaoijCr9rvK0zsNFo02WxRA1YwIDVwf9GiFUNVGiqXeU860WiwOxusDjFAYKk5Uq7SbLtFM7ZDDfy02jTTbPMmt1Yu0FC1TMvqFVo6VBOWUCA0XJfrDb9nWjaTHfyeKxR4/4zxDstK9C2040yzxXnE/bM23rUFqhYLNFqvcRp7x6dooulQvWTRkjrIZLS3GP8t16NaqUC1UonrD6TFUKXCBwBilvCoCksRf67D3IATeGx4MP7Fu9ejqUaD9k02aWKmRUPVEq1dUqNaGUS2xW2C6yaZyPJouFLmNpLtACIChDZII3CK3IYor19GYHymQQemm1RCnVaK4p1SLvN7RQXqD3UGsgl1NlQVfWFsZoaJCfQolK/iz2loKhCr002bRmtVGq6JNYBuvpdkvjpXy76BclX89QYI/YJl8bPjxlJWqPM/kHUeyZJe7jT8dyLIXLmGwzgJ/lbSVJ8TV2/RfMg5AUC7J70ndO/i4ECuZXO6mDvlO5rXhq7L18rrXRyQyrUpW4F214e8F8wV8i/nMrVMuA/vAZCxBQ6SUx5cnR+D+wkDAwODIwljKbXIIU7FfAsQj9h8HQg2uh50J/DCxvu6yhFJ8AIXJ26FrtM1bIiLFSyEC7zAaNnQF/L8BU1ncYYNjef/G4sDLDoarSY5fNiJE3OxGbT8xTUWLFgghDbuToucVpOm2rM0MrKCyqVweXgxqCwKc4ly6q5N0sjImLbIi5InBYKwwIm4Q2WrwuWVRFLcPSpQj0RisaV7Xp5FFQiLSkW42/UT5j56HYgTbL7q5Qo/QwIbDFisVApis6bbDMehq3407cSbOKVvI09p9YqFK1sj+Zshmf/pVpNKVpEqZUFkxOVRnI7zEXVQBygXNrVtFxtdWCaBlCIagn1CTJ3KdGDkJhf7JU0fA3FWr6LfuEwU8N5cSRObrVotTJbge/zN1h0WXB2srvJk7X9ZkXuhP2A9pIBMLJaohLmpEiYvsekFZP6y9HN5PUiaXjROstSJzIvY0EF3RhwgzNrtgIREz1A3XNJSBhYD6LflYokcr8V9sIG52fOYQEBdFCyH0F1xf6Fc5vkbRBWuAUkiN6XII+qIiQnP474GEgPX1UoV7uNx9aPrR7p5K6mOdWkE7QRmRIm+hs9BojBpBIupCt4PLpcZxIjc/Narorxs/ESiTgTxW+BDlnIVsxLGX4EJjFq5KAg8f5OLsYl0sAfGfehjh6Znmair+vOEJBDlnI7nTaGOHZCBftlAUpfEtfh7aa1Gntfg+i0iL75RaqVUoaJr03C5yvNl021wG/JhD8g4DH62nBVzKuYNzLloH3RR2T9QlyOVGjnDHg1VClQtFamG58OamVw+TGKSoFiiRhtu2nB9b/L9ILvwTH6H10tMhvGY8vuibCPU15Iq5kkcWMGCqNvyBPUFgm7GFgdfeDqIKdkGRXJouCKsh1Wina3++J0Pa7R4dx/cV4KGY6TPoG+o465O5VzjM45g0d2P/KqESxwRE4c8c5HmZn4fOLB8ZoviIkZRaK7QPQdlxlyhjmnde03OCfLfSdC9iwHkBVZvPK5KheAdbZOYZ7y2E1yPPtJZm4YteyXkvRgxPKf5cwfaS7zX24KYZZ01WBwXB1vnBgYGBgbzCkNKLXJEF/nBwoLXqw5V8A9LEDz8goaFlBpy2YfcnKsnarzJwEKVSSZxPRYBwyQIF7HgFASEOLWtUNFzg0W53IgjXSxiXMfjk2feXOOEv1ihpjdLrUKZJpqzZBXqYmOoWLWoCwo+FXTZ4Yw8XsSGTzDVfxdiNsKqtYI4LRYn4yDjsmyckxY57JblE3ZYlIsFoeLa4Draha+6YI5aGgxyUZVmGZTlpBabpFm2xoN2TSdCH0gaWDBA08VqI9+iX/ZCfOmgWzSn3adulmUdY2M/0bSp1Z5lKwtYDtQr4oReR+agzaQbi0owlnzyDZtUaSmFv2FxGPQphQTIQgqpactNn7xH5k9NQ91Qcf/1f2PzJF0wpLWVtDaQrrJRy688fUK3qUlEDBnc6ym2SjZCRyb8KEHS5YXMi2pdJKHWERAlP1C3+AwbL5AP0edHy8lpl9A/hTUNu1j51gBIBxs73IN0JMmNH7hqWZ5DQ6UKFSyb2pZFDcfln1rJoVq5TGVYiRTEXI40pmGNYIlNndzUyzpCvtFXmKzxy6GWPZpvOd6i/UhHGKjo7mPiwIJtPXyrhwIJole6Cg9XC+TzyEF+ZZlUC0IJpDsCt+bIc8U7TdTzUEVsmOUcK1175OGKCnyKz+G6tnKoLsoY6cMoz0hFpIG6kGSRapU5Olxly0UmjV24FtpMMJLl0Wi1xuVg60gQCxbKUSTPH7ttrzOn4vmog+hYQXuAT6zVRsOWay2Q5XDNFvXHVpUEN0tBaDKhU4HFVItdyYSVWyTiqg+2Oipi/hX9Wh0LEvgMllmw+uJ84cHBHCz6unZ+8Sy+tlwIt2eI+IAVDBNdBTHf4T3qW2NnfT8ykdEW66FqkQcvW9Wgv+FwAeMLeUffkPlQ5zncHyVcZLl1nw8K6iFQCaSzA5dbaLEJElaSMxh/0fEq31us9e2vd/BbfqbOceq8KQk4ILBs8j+Th5A6Aku+Z8UarvOOxpxa9NtSfo5lacUSFpFd70V/rYE1nCSD1YMuC+b8CgmOJuL5Z7FG2DUwMDAwYJhZfJFDXaDLhQUv4HkJ51K11FnQ+zdotQywoMKCrMvEGyfwiqufuqEB5OIGfw/VqjQ0PMyLRbEwERswSShg4dZyxOKONR/gBjC8jCqlMhUtnPo5AcHFp9Y4fW20Ah0McCGOJVwdpF4C60q0HJqEvggvmnyyLKaccqGJ52PDNgG3EOhqKNfLTZdOW0EuztSNv/wcC6dqsUgjlaoor0KUsQCrT4JFIfM0l7oHvEFtNoULDCwOInWbCt+SrA4x0WKBLY3kohd1BTKkXhJuHfIUflCWOUCob6e4G8q2U/u0rGNYHdRhLVEQ/QhWKnHtIseUummV4w1pwn1lyXAtcI/ENTj5D/q3kk6WU3i50Zcb0GhZo/1S7VfYA6Ks+I2/OR+wQlDKputnkuDJo8Giju08iI6dpH6Pzdj49Cz/BtBPx6ZmaffhSXYnAiskN0FscdGw+Teuixu7ah1Gr5MuyJgLoveqdSQ3oePNJlvJiDpua61HJKLlVPsQ2nh4qEIjQ8KKhDddeCbmyaZN+AtjagiC/OiPHix3SrRiZJiW1mu0tFahpdUKzzkgxNAH0B9lf8Pnw/6Y1NVFy8EhgehzURfUuPbJO1+p9SddruAmKYgC8d0UtMHabTo0M0tTcCmDK1zkmbJfd41X/JtdRMP5keNflkfWjxzXkqyVfRn/lq5LsKSqWy67w4EkC8YeIpT6z0L6GP/LRutMPqENQf5Ex7p8FsYmrNIajiOsvrhMIDTwbiQmHpAXLqtPuso5VdRBtjpHW+M+WEehnwviEeRckftRiS3ExPubCQbM574Fn27cSOtQ/I6uE9R3H9JZOlSn5SNDNFKvBH08er0Evl8xXKfVw7XA1U9Crhn4PYoZGIRl26ZWC7pULf63DknvbnGBH73WFZqZgXUkry869Ss0r0AYCyJH1inaQrqQRd97IB3zvFNT88pWlC2a5X4PCymLtZkKvmWUbDs5tqPjkolQv/+h7eS6R36WZCEcXa9AUmG2McP5AHmsez8xMTxU7ZILkES8JIF57m/bVC4Sr0+78gE3RUg7+HOA7EdyXKl9Su2bBnOL9773vRzBD4ExIBivAyL+PeUpT+Fr1qxZQ294wxuoHVlb/PSnP6UHP/jB7IZ80kkn0Ze//OWudC655BI67rjjOOrfeeedR9deey0tVCCfsKhVfz7wgQ+ErrnpppvoEY94BJcHwTcuvvjirnQuvfRSOuWUU/gaCOF///vfp8WMxdSGeQHdtGibo+0kEMzg5S9/OQdhQMCEZz7zmRz8IO9YORZhLKWOVuRwmdFZLERNtOXptrxGis9iOSDvUU8JoyeYiK5WtuDmAPcT/wQVp25FlxemUguLLbz8UMwdiwhxEqhakqgn+nBnYRFSCyScOE2Og5oGn1hrzNWTLEHiTNflAlDkx0WWQ4tN1e1Dhdw08OI4Re+nH30Evo/7gsN1H63brP2pUi2S5Yu1dha/QiMGC9JBaDj0k4Z0CYlqnsh2r9TE50wCKXpQcX0mi5WT7C/C9Ua4yUD8Gc9Is4yTZBZbEvriyiHtDVUYW+O+GD2xDj6D4HNbkBrCcUlfljyuV9qxjbw5bd4wMYGd0F7RsaO6fEbberLZoMOzLRoq27SShrhexhstGp9psdsl3BQdF6fosD6B3pYtLIXY9ahjpRcQfn5by00M+b9hCYfnijryutxMdHWENGtFMQdJCyMIYQM6LZY87pPY6CFd1jNChKiKID9ZX8WV7nYOu1HhWtl3o/UuxwH6I76Ha5XVhEYf3FwsritsMHneLWJz3u32JKwqsPEudW2idXNZHNT6k27icu6Q39WKNVGuoSKTQCBoJORGVmpvdT0bhDneGV6TCOWIHEbIuRlzFAt3t+zAaivalwuYuGFh5Tm0erjKVqH1arXzTvDgRoTKgTWHL2YdqYe4+Qt/Y15SrSvxmXiXdTbyUnMsqgMk617Wfxyk1VigE+TCErpzONVsWdz2hYIgQjH/S/0euEtFXZrj+q/ME6yf0abQ3eqQHcKqSb4DhUWaF6Qt6wd9W53jOmsJxeLRt5zhuQ0vIVe4SOoQ9+4OLE15mAupA7SddAEst8PzKFsw+n1UHpSplniqNhree6q2muvaVKXOnBbXH7JYnIpxICylijAh963eZTur7+5oO3W3W/faSZc37XuFPD7MgbRC0rsirqzqeiPN5U6IzDviGt/aPOpmKesPY0Va1hvMLUAI/+Vf/iVdcMEF9IUvfKHre0QqxCYb0QuvvvpqjuD4/Oc/nzXD3ve+9/E199xzD1/z0pe+lP7jP/6DrrzySvrbv/1bjpb4pCc9ia/5xje+Qa997WvpM5/5DJMZH/vYx/i72267jTfvCxHvec976O/+7u+Cv0dHR0MaYk984hPp8Y9/PJfp97//Pf3N3/wNE3sveclL+BrU17Of/WyOXPjUpz6Vvva1r9HTn/50uuGGG+j000+nxYbF2IZ5cdppp9GPfvSj4G9YO0u85jWvoe9973tMNEI/7hWveAU94xnPoKuuuirzWDlWYYTOj3JhwugiQeeuoy6wsGjDKZYFFyKfU5Fi5qpArS6dRDJBJ3ac8lnbK2ZyLerVLS1JZyJqBq+6COo0KORmB5tJLL5YTN4XX5WisVmF0ePQq+i5rkxtWAi1mlSBzgf8P+KuhTKJQjoAHEGqbfs6NuIUVrhAEp9uYjHJocGzimorxAZcE4TVDvqZOB1NbN+IACysS7CZx+m13CyErkO0KohZw9Wk6kdIjAqr5xHUjwQbQLoNWwigx7V7MN4sbOR8txTHj34JopfdW8V9CEeNiJgiQmLYlS8J6FfT0DqxLBqtC1HkgYq/yjpyEdq8SQ70rCrCHanrOheEAXFENNX9BuLTcXkcm5ylA7MNqhYKtGyoxht5WJfgepDJEPiG5YvURoKuDwipqLg3voPIs9T+ksSVJEgQdQ6bTwjEYxOcpC+jI2UkuZJ0PaBaCmSxnONIbE47JGgvxx00g7CZj87JKjiaG1z2eHyCoES+QQhhPirQMFzB/M0fNrzS0kDNV1SUHH2x0WiyO2CtBDFxf97WjRF/TCOCGvqtzJ8kCHGvJB2i7jnRekkT6of1UnN6ipx2U4zp2lBI8Fjt79LlSTvf4t1jN0R/xdhHGqVaYD0riH0hMC2sskRwkai48lwEFsAcOAkxdw8i3kJLS4e0dxW+h1Ux+AFYg8k6kBZscD8vQyOvUhTC0SlBP0B6yWihGFu4D3Ma2l3Og3ytA6IX/U5Y8YX61QDrK+s7PUs6aXNBND35nmKKm+cHfflUCYE07UX13aeSeT3P2xFkrvuM70SMb3aTLHXGd9ZyRPuuek1UiF18fwSDdxyj+wkAlk2vfvWraWxsLPT5D37wAyZUdu3aRWvXruXPQEq86U1vov3791OlUuF/Y7P+hz/8IbjvWc96Fqd1+eWX898gMc455xz61Kc+xX/jvQXroosuuoje/OY300IDrIFQH/jR4dOf/jT9wz/8A+3Zs4frAEA5LrvsMrr11lv57wsvvJCmp6fpu9/9bnDf+eefT2eddRbX4WLDYmvDXiyl0H6//e1vu77DuF69ejUTi3/xF3/Bn6GdH/CAB9A111zD7ZplrByrMMcLixhRd5ioOXjUVSLkSgHTaN8NQXXH4Qh9Tps8tx0y0Ran5mIhBbAJNU7qLRGaOGo+LjdR2ByxOTsvZvwQybi+3eToeyzEIT9DfpC+fx2eITeZSSbu0pwbkKG1k66XUDeH0Q2nXOiIqFdtXhDh3zo3MtkO2CzDMmGkUma3GbbWYdcZjW6Cj6gJvqaRu9pJ1HU+d7/oRhgC0YhAhXZW64o3P+wK6Zvu48TSEcRI4C7ptKmJEOV2i/+Nu3lTi9NsyyOWYM1zcqk8QxJSSFGmkehi5rsVIpIP2ggWCNj4oN/ornPgJsQ/zU56UuQ+FG5b+TsL/OtBTKG949pdWsZBN0a6pbCbbUW4FkmiRd5n8ebe5t9pZIaKqLvJwN1FZR3BAinBna9t2zQ1OUnTU1PcRlxmT7SX6voSvXekXqV1I0O0YqgebHCWjdRpzZJhWjk8xBHMQFShPsRGpyP+rM6LmK+QPsYkXJdAgKlWMuxCxe7AbtfY1rkbqi5kwp0v2S1Xfi+v1bqfZXQb5eAFcFn09eqS6h10shxLmJNqsL5jUkDMTyCiqpUiC6BLl89ovqLpc98uElXIoaLXDlyg4voHIsUdmpyk8dlGoN+H+oapu6x/1Z06rk+muYsyGU1FmvVQZoxDL+TOp46b0HwbdfvDewiWJ6W6IKN8QiqUhiTimIzz32cZ8xvn+q27Bu+w6ZkWTUw3BBkJMg3upY7N5KCL93eKK7juXYXfIDpBSKnvHFk+D1ZsOCBgyzMn9X2EsQlCd0lNRPxDHwEZ6XKEUmEZJsZflcc6a25F1hJp7Ru1EpNulKgDrgulLrvmSD+/KFOce66ufQB1DRC9RzcXy3WI0P5Sxk2kfLKNJCEl10s6qO++uXDzz+yKHSOHkBWqy13ceyzad9VrQu6cviREbL5lH8X6UuPWazA3wIYbbmdykw3AOgYk3B//+MfgGlgMqcA1+FxaY11//fWha0Bm4295zUIE3PXgqvWgBz2IPvShD4XcsJDvRz7ykSGiQVoNHT58OFO9LCYs1jbMizvuuIM2bNhAJ5xwAj3nOc9hdzwAZcd7SS0/XPu2bNkSlD/LWDlWYdz3FjFEmOhWxO2uYw4uXSWE64p4yUt3iRJCqdstKhbLrBkVmI/7ZvGqeby0AmIRb9ejoYKv0xGJWKe6e0h9Hbb8wAaSSSN/AYGFAnQdWIHTX/jHhI3PYuIu0Y/oqO45WReBallFyO34KEKyPuWmMmqC33UCq9RxAW3lm7KrJ4o9QZrIc5zzZqAbxnodiOpVQvpoB1hI+b/956kuKHIDzd9Jd070nciCM9HaCZoq/jOgVRU9PU52MUMdgfQULhlSp0dXXg5aVClS3YP7gOKGEHV1zRktTmzi0EYWlbEJTGiXkNsrLBFglYH+ZYkoSdIqkcuECFrM0ZbhVESFHOLiOuHnXtzJYiHrqAD9Olh34e9usgxh70EWcLh7VxAbdtsj22szKapq/kTHhS7/ol84VC10hOTHG7M0Ntui4bJNy4fqTHzweHThBiaE7LEpVjeDMq0669l1xPClhRJIG0RAgwUWLNdkH8emSLqQifnOd73V1CW+Z60qBwLLJebfQRAluYtKRN3cZH7xbGllEXWRVsWIQRbjKpQF+j4y+IDeIlMfeSuaPvprldvKn5d8F6j4+cUihw8cOvWtczdltyK4VqIurW63LNV9nOk2TUCCeqVKTc8llLoNwhPWn/57SUVovg3eOf51yEtCBLhIpmLP9KL1lub6rbtGittjfq6VRD/GuwUuviCxQRrJeokb23HWQeLdKFxCnZYbbP5lEBPMPXCJ0rZt5H3UNdeiv9sueeirxY6FnApxuNPRAUprX/XdLP4WbpR8mMEulN3v+sDSyRHaRbAKFCpUYkxmaR8grb106Bo3kb/VNkpb3wTvPrgls6US5qE+LYMUqycheh9Td1msciMWVLqAHFmR9F4KuXMGn8XUQ3Co5K8LNPOAweABSyB1kw3Iv/Fd0jXYjM/OzjJJg7WU7hppVbTQ8MpXvpI1slasWMGuWG95y1vYHeuf//mfgzIff/zxsfWyfPny2HqR9baYcODAgUXXhr1YgsFi8P73vz+39bvf/W7WDIMFoLSIi+quqe2ZZawcqzCk1CIHTp3lqaNYPIQ1Bfj0kjdVYgEkRCMrvlsQ7ypCr2uOaOO7nUU3SDLUOJ94t4UeDISvoTMEqKKTUj8D13aRCfJE2ksnAuRChcNmRyLCRKGL/tLPgijYMPnWWnF5SCyrhpBJ06wKfaeplzwL5FigjspVJqRg3SROxSEAjhBQRJWyPF3Hs1jJIwBchxB6u2vTgx0Uu5h5WreZSbaUadKyoaFQhCrkJfoM3UZSLpbDmyzxTNYSSrBIk5tI/B9EhO672L9TwNY/HKU72d2li2BjIg8/0iqr0KVdA+KPIE6suHr0i0H0H4xIbAjTXEkqIHc8QeBIMgZ/24o4eJQEximjjEaHe6KbJBmRCWkxMd9o03RTCHaPwE0ILmueR402ImGKcO1yoySjKcqId5ynkoiONj3dpPFGk6ORQXupUiyzex/mUDm/qhsjFjr2hbJ1dcAWnjgU4IhyNkc7k0LYaZDaO1KAWpaBozy6oi9Ex5hKjhdhIVWAlVglFLEqmp6aRjS0fNf45voTrjTo9YkbVrx76kO0rCjqX17bvbH0I/rB6tIWYvW4L0pcJ82ZSANzEiKytmCJRkK4O5VUzkk+9wvhDm2xCyYbSbqdoB7qNZL4BIEJHTH0Z1yHeUt1FdblWx3b0jUrqzairn1UCNLTZYvWWg2u2xrSS75XlAi30TlC965Nal+dNhKTly76Y0dzLKrXJKzmpFVTiWqsQxdP2OlIUx1Z24v7c3QO68wByQcEAYnqW/xw3fTruhc5TOyFPI1Lq593y0DWNeq45u2NfpwYCMCV6oMf/GBiddxyyy0hEedjAXnqBdpJEmeeeSYTEv/v//0/1oeCmLvB0Yc//dM/DbU5SKqtW7fSN7/5TarX9VFsDbLBkFKLGFjYVPl0EZswh8Mmq4sWuciU1hchwgUbaEU0MwmS3Kr4IZhxAHVwepp42WKByOgW1pQbBS10J9IxRIBcqMiQzupneaxD0qBLU/0ssBZTLCfkd4llhb5Ps8WRuhA+fEmpFtSTjNajWg91LcBzEiS5ywwLKXnSyYZyvgVKhoVcdCPBuk4QoeXNV/h73jRDyKRQYJHdKkeUymb1E/c8dQEKSx0hYD3/gAUJb06S6sw/UcZmGVaD0qqFpECwf2/Q/mwx4nbKJa2n/ADfRxpZLRjVMamSinD5iZ6oy7I3ER0PLli+CH90kxSEN2eihWgUbiEc6h1RzEAyFajuCZdAWOBggw8SysUE6VOmTLD7ke5AKuGZLdYMAhlQoJFKjZpwm4QbH8TPNdGd0izO4oSts2xapTULRwZ1BVGMekYXAHkjhcDVdmDijMlClwp+GaDLJjfOUs9GGF912i0u6EHX+PbdwRvtNmtCRefH6EZdvn+ybN5huTjbdsmB1Uu7O/hCFus+EKD8PgLhWyxw5MZZe5brCmRgFzLMrVFdsCQNoDQLE+67rCFH7PpMlowEGD5wiBKfqnWfuD7+XZO1znQETBqY9GTdO4sK0HCzLO0coL6zk77PmldhienPfaplD/qg/4yo9VOnfEURQATPVKxrdHnTkXJIhyMkuuEgMFmtt9W6k3OYfJbsR5nSyEugJmlApaSVq2/EpaU8HzNTZsurrmLksNqSmMM109GG173udfTCF74w8Rq4J2UBRJujEdZkxDF8J39Ho5Dhb2hrYTMPLVL86K6RaSz0egFBgYO1e++9ly1p4sqcpV7ms8yDwqpVqxZEG84nYBV1v/vdj+688056whOewC6M0ElTraXU8mcZK8cqDCm1iIEXdGA1wCdW2PTzN7kIlyzPURdr2JiwCbkrRHJ7STNu4ZQUuSjvInogCxwfwrUAQvDi1LrfPDDJZdvk+eGo5SZsYKeFWeFbP3CdB5HJkssmLb9AsIS0MiDlYpXE6XRko1GsFGi5W2d3omoRhEF2E39VGLYr0o6fXxFmuvtUPnp/VrHpXMiyCHZ9l1W0c6EaJlqY1Opo16A9EFGOyUr2o0k/3U7DQMTNEzaR6BMgXwGEd4+GjBfRvbqF3FXIvq9GH9ONfSlWzVHbKmVaMlSlERdi3eDtYAUlIu2N1jqEvIxCJjRJrFAUKkm0Q7C5Wq2wnhV/1hLWkSBg4lxKksaqJKthVahCF0hBR/awnp2vkVSBvhFK7Dpss8mR6rDhVixJUS9tT2g24UfVZZMbaUnCqeWJc4+NtrG0mOXv2I0o2dIlLhKmtj8VS1SvDcVam2aZF6Ou0CC/QaIgelmlEn96meRarI5TRFjkoQPXOd/dOe7awAIs0tbSmle1HJSIs95R3fHyvL+S6izNKkoHzjOIXr/PRC2zo8hCJCblNagPHLhh8GrmvrhnpJUva97QL2bsNk01mzRarQUka173ZybIFf0oHil+5M/onNwlqh+sj3LM+0nvi5S0grrj9RnmzQRx87i0lOfDorYXN8jcVlsDWusdS4AgM34GAUTle+9730v79u0LIqxdccUVTDideuqpwTXf//73Q/fhGnwOwMro7LPP5qh8iD4HwBMEfyOC2WKoF4hfYz0n6wBlg9A5vFMQXU2WGYQVXPfkNSijKpau1stiwkJpw/nE1NQU3XXXXfS85z2Py452Rnmf+cxn8vfQD4PmlGzPLGPlWIUhpRY55MvX4lDoKdYaA9rEYkE6wr/ruaLdZVk4xZ1CZllEp2285QKHXWraTsiMHn9jcwIrg2hkKOkOCEsLkHF5Fzm8SVcifknNECZZLLkpnBtkISPCmh2F1OuxUBfRzBwWStZtoHSLSFgr4MQ5b8QcmT/wM3H3ZXGJxCYAv2X0LxVqmOlBETchCE9Z6dnYIVqg38LjQFgBxFquBC4JcJP0o4Pl2BT1crqfhIA8a9ncf5FnWAMC6Oucbz/yHsjClmMxdaKSummaNyqBqI79QBfP180T41OGcfeo5YuvV3yXpKhmknAzFi7NErBgkeMQ3zOBA1KpJKKFDXKzE20LlexhJztYdfkuSXBDlHlWyy7zKscYB2Not3luq5VKVC13SD9+PyiErs6CJ0tZpMUsfnRuZ1qXrIguVhzSrE17gTgwaYnfCZYjQoReiCKXCvVQBE6Qm6G+47RC7s4qdAcn0bZOsuaV1sBq5LKoO17aBj0r+dwLSc0utZAD8N1IRT6SSdkkrag0BHXHlsl6d8yuelCifSYJc2clOKDlNDPb5GiFs94MlYpDvOHQ3pvQx9j1FkXwSWPMPaINuufkoB9YLlVLfjAGrxOgIVObDsI1tZ+DEOX5IrhE/IFiUl/MfRgpg7O4RC0bhBrcX3HIMNi55VgENtWHDh3i39AMkpHHTjrpJBoZGaEnPvGJvKHGxvziiy9mbZy3ve1t9PKXvzxwY3vpS1/KEdne+MY30t/8zd/Qj3/8Y3Z5QkQ+CbjDveAFL6CHPOQhdO6559LHPvYxjkz3ohe9iBYaIFj961//mh7zmMfQ6Ogo//2a17yGnvvc5waE01//9V+z5tCLX/xijq4G3aGPf/zj9NGPfjRI51WvehU96lGPoo985CP0lKc8hb7+9a/TddddR5/73OdoMWIxtWEveP3rX09Pe9rT2GUPEfTe+c53snXYs5/9bI6sibZGHUBnDEQTog6CiELkPSDLWDlWYUipRY7OBhauV4MLI5m0iY2eSKcibrGmWTiBpMHpnE7wtp88qwscabHh+dH0ACwCZ1qtQFhWLv5kenIT1hE+TydvdPWFBZgqltzXKV60XjX1nIWMUDeUWa7H4liI54sNter+kLTQ7+WEOet9aa4qrA3mC/DLugeE7ohLBZwIgyCAsnhe4iZLuGy5QQL50JqhQlFEaQrElj1YzwlLLtbDCQiIyIk0RxUC+WOHooOFCBMQqyxE3NG4kkEICohS1oAbqkNl9D+WtSqwpYrOwiyJgFHJMyaqK9BwElYgTCahTtotKsLSB5uCYpjMSNO8ibqORYMDqPeLdMV1TFIpljwqqaV7ZqAxBVfKkFVUd39KO7lXxcY50piGCBKEnCDBZX4l2SPq1QmsuoarYt5Q9eyk3lT0uah7lFu1VOuEfO8mdGVeYbFZhog5P0rodMn6RlUhIEKtJEStZT1G9d10dSHzmYV0nwvLBo5WKC2koqLm6nXIn2NTBS8fSTb5G3I0f1WN5FkIuzuriHP/4vcZTPEU4jlqccpufQkRYyVJKeeuuLkwK/ncC0kt+61Ow2mQz1GfJ8ZgDh0lf85hdncAblyIUrusXqWZ2QYYJY6C2iuJI3TA4LZvUdPRW8uF4JebI2NyHXa7tcbWNbvqqhbQPYynHoit8DgW7xQkkXSgmKYXl8uiz2+DIutjCpaf692gb7zjHe+gr3zlK8HfiDQH/OQnP6FHP/rRvCn/7ne/Sy972ct4Az48PMzExHve857gHgh+g4ACcQNiZtOmTfT5z3+eI49JXHjhhbR//35+HjbrZ511Fl1++eVdwtALASAQQCC9613v4mizKB/KpupMgaT44Q9/yIQDrGjg3oayveQlLwmueehDH0pf+9rXmJh461vfSieffDJddtlldPrpp9NixGJqw16wY8cOJqAOHjzIFnUPf/jD6Ve/+lVgXQfCEQcPsJRCv0D//pd/+Zfg/ixj5ViF5WElbpAIRIbAxDI+Ps6s50JCrOtBlo2yDJ3LCzh/0+zfx/pAnv5kPRPU5weLtXBkPS2p0m6I72TY7VyPzH5KrG6AslhKSTcbVVRYbPbyWf0MFNGIhZoIhnlPxOfypH0Q6GXzGpfXaIQmjhiGk928ZYqJHKlFa4bIaSEMIFFlKDQGIIid2qcSxgjKwm5qDsS5LSpDZNwqRVxGXHYNhEtK2WvTcLnIZHaxXOl6ZpAeEwzd7na6uadDgoDwshKtFpL6UPS7ULp+PnT3p/VL3fdp5czT//DdJCwrQMQVC6ydpmtPXDcx22Qh9eX1OlsJqS6m0fTVPIKsirr9gFxCJFZYYVR9MXipg4frkBYrE0HHDuS76zLRhCh9iKpaKxXZ6lG6OsKVkcvrgayDC2OBRuvV0Hw5yPkvTxv0hMi7pqsfpBD8fc13MfMDXDZB6kK2Hv1E8Cjd7lx56lvmE+3MWkgQTK/oCWdVZzLuPRe9D/0sas2VhHl/T0Qspdp+PaRZGSWm58GyGREPXSqWSoELTty1sWsu//uZlkPTtoiIrI6puLVXYuRaBbhOjne0TXSNopu7Bk0G9zKOo31Rl8fMfUhtAyBtDXwEsJD3EwYGBgZHEsZSapEj1mopi+k1X9MSCziYTEDBgMPb21QslnlT2zPU58eduEXzyKfUPuJO53QLP/8zFoXOsAjSnb4JKwDdtXECrb1Z/QwEsg5Y+FVxa8BvCMLyphYLQy+9TiKLeO4FVrqg9pxqXyltHNpUsKFQi1qIGslhwIWwc1AXMtKO2iZYmNstgo2QyHe3S6jrWGS3Wtyk5XIPm6c8J8ogo9TfeS3J8B0spPzNi61EgxQS4DBIKlOxCHc5ob/EWmgsEC4sbhDVC2cRsJrCddhoqdpQsr7ZtdRyOR01Yp3cHOjmnlAZOGJbxxRZtwFK0ryRlk9R97PoNRJq3uPaUHcPNtqFjBo/QZ9RtOFUi8doJE6OwBexLMEzZ5s2TTWa5FoF1lmruMXAokmdm6Q1k7BMFFZiQNSygKOzuWUmnJq2qCd2Z+R2FkLZuAci6eONFhOgSyouDVeqVCl6ivWVsCZF/8ATSpaIPMqua0pghri+Gq2zaJsMzE0nA7o38wkaWFGrGiam5DtK1HfP7q8x84PqhqqzqOvFylT2b1j2zDYbbAEp3GGLoXlVagcGhDUa19fK6qusMflJRZRMyOCCF7pPnf8V90gIzna5ZuYrANcTu2wWMszNlP59pVwMooKG0lOs8wpKhNislulSDh/ufqWA5AkTj1Erz141m+LQyzhOc1HNZW3X1QYLh4wyMDAwMEiGIaWOViRtlEOkBiIWda7D9s/GJt1zqVbs0ew7+vyYxVo0Wpu4FnnT55evb9u8QBRrk8GIQPeCOSVl0hC1PAss3kBK+eQerHHwb79OomLfAG+ku9wdaN7rMr58IKSgEYT2b1GpKFwRONqjdLMCqcr5R18udeebdWGgAYPFuf6EG6fSLY8VWalQ7GEjlsdNBC51+NGUtQBSMMuz5YYysoAHSr6QN4hIQQCJzRpcKdiCgjfDBWGZ44eWL0BfK3Bn7LjkDZVhdWMJCy4lYl3U9U0lGpLGRS8boCx6YpzvlsMRQWEWDb07dROXdNKOMoG4getW1DUNP1xeP/KdrixSn0yWJ6qNJC1cVDdXPLPpOFQFKWFB48ylselZGkKUuIiuEkc8s222vBquCAuIqGWBrE/evDpiExfVnxLldllfCbbRsJar+VHp1HrVRWyVdSbE2EWZYVWFa6R1hiR+ohtItT+JNAfkppMBcVEFM5M8ytgsYm7p9RAiZn7I4waf931TASHIjxRuYrr3ZEj8niN+Cq2spLKq5OtAEcobhd5JcEOLjYAo7wOpprzvEl0zj/D7PlZXrE8dqCghFM1zcGihkGFJJFIvVm5J41jOq/JwA0Q46kJ9ji4/SS6wBgYGBgZHDxb07P7+97+fzjnnHBaQg0I9lPyhYq+i0Wiwr+7KlStZbA8+nNFQlBDmg3jc0NAQp/OGN7yBQ3Ye1eCNe8wpo1zIYYtaroqTRbkAkJtmXy9oTp7vQ0Zrw28AVjEzzTa1HaGxE80vCClYvLDuj7pw48WcXgh1vqFaUOj+Hgii5fXrB1ZuNtZtvIuqhK6RGxAh6ivIDG5fPlmu+ORkcWHUpZIHbCrgBoVNFoDIbfDjD1xSpIB4XL5hFcBaRiWhG+VbBqhtIhfCIjKbYn3HbjcpYyDrdRnKmhfRfIufzoZRuG0VAisY9Xu27uE9nCSoBYL6ZsJE5I0tr3xtoGjkNtmvUucKP4oWNoehes5QxrhIjWo7TreaNGOLCIBSkytLHkPljRJOrkvNth1oP0XzxZHImFAXLibyB5pdUzNNvk/NP4izw5MzZLddqhaLtLReo5FKlSPETbagGyO0qKRVGkgg7MM4eh3yqYibq6420poK91SKQocK32PDN1QT+lLyHpBQy0bqtGbpCNWrHQu5KHR6d9J6TmrJqcQPfsvyy40vgLaAFQ5zBr7FntAm6p4XZTnwM4j5Ute2ceXTPlsZm33r/80HlLmoxBEPa1SpVgOR/NBc449HEFEc8KNcERp0KWWds3pQ8xZ5J8nxKH7a4bEs71Pfd2o9YAzU61wfC2F90O+aKendIwkhnbsm4HkOlSyXBdejlp+6ezLP7anZ7JD8aMOpVpNmZXCByHN0+ZHvKrynoM8yqPnBwMDAwGBhYUFbSv3sZz9jwgnEFEgkCMBBtf7mm29mYTAAonIQzrv00kvZTxshJ5/xjGfQVVddxd8jSgQIqXXr1tHVV19Nu3fvpuc///msC/C+972PjkkknMhhAYBNLFtRRKKCDRrR02re4IBwcjwqVaKkkzwxw28s3JQF1AAETQcFbWStPlwhXEeQcSAG2KJFV16/fmAUwIQdNsqR6HJRse/gs4iLlf+AHkqeVpAMGmfB4zvlg9dNEMkN1kyR+2Hr02oXqIJTV9UCSX1eSG9LhKgGMdB0hfUGfrpOd7Na38Vcl/mUuY++qzuVFu6MIow3rHzi3U/180C39YawYozLoRRQR79KhB/WHXpHIUuxDGVMsrySY6tSKFG1ZFO9VGGDiaxWMXEuiCDOLHj9eF7gDhPNBzb7JR5nYtsvx5W0bELeQQrJ+2btFk1A8wUhp0eH+Tl206HhSomJHJRBlofd+1o2jVTKtGS4pi2/KlQOS0EQZFLHJSpEnqQhlBWoq9FCLZSOao0lLfHYUs9/JuZ0WILZTotrSdRHRyNMnRdVSzpK0FfKk9+slkhaK74F9F7JBHUuKpapiAMn1aJOLQ9c9QLXRemqfQTL2uU+2XknsXVsJHqmtkwSUVH7xdaOWZHTQlwKrWcV/s7qMpoG1SKP9fBIEKWSLM70HJCTni/4jnfJkbRUNzAwMDCYEywqoXOo+cPSCWTVIx/5SBYKhNo9ohb8xV/8BV9z66230gMe8AAOzYnwiz/4wQ/oqU99KodtlMr/n/nMZzg0J9KrVNIXrcekMGEe8eYBIaug55FCFqIhek2/Qq92syEIQlj7VGt95+9o609SLBgWEdjwxj5PIangxAiXI2yWYXmlFWRNItEyiKkOWgh6ruq57/6ZtZwJ9ZkmeC41lWQAAp1Ar8yL/FtXFt38kjTnRIWD1TTFyT+LDgXaUXJTJaPvSQs1WTakNzYzw9HERmrQ7nFDfVeth6nZZoiU0ulxSVF1WHTBpRVR9yQhNdlocJWDBETaqugxkKXN8s7HOnH6maZNM6xrRjRUKdNQtRzkUSdSL8sISIJLFzWwF3HmpPvSvlsUQR3yBCnJc0iw2HA0li1BSzNzOY9QvQxq/MxFhM4jgWNyP2FgYGCw2C2losAkDqxYsYJ/X3/99WTbNj3+8Y8PrjnllFNoy5YtASmF32eccUYoFCXCMyIU4x//+McgrOnRgoEtoFXRbPzOY1Le48In08l2SpSkvuopJa0sVk/RE7zgbza1b+deVMJCSv2dVCdZhd6PCPrUy4iDaqmR+DzltBz/B2FQVHRKupB0uh6xSNCG/x7QKfNc13O/lnyZy5lQn0l5kJpK0DKqlYQ7jrRAVK1y5EZFuonoNi06jaEk3SG2hGIBeeoSNefywtNZM8/qNKXYmqtSpFWlkUDbjbVVfFer6NwBgqmkuJ7pLHmkqHrFF1WHhRhra81MU7MNNx2LSkXVskltp/Q2AyEHNxuUe6hQSYwOGM0/gPRrZbjQic9ULaKokL2sR1XXK6qbpfYJ1IXriXultWPa+y5J0yxJC6ffMdIrcmuwKVpzqfnt13roSBE/g3ruQkonEmwkUXJBtYrK24Zx1/dbhpT7tX23h2cm6s4djUSkgYGBwTGGRUNKIZT5q1/9anrYwx5Gp59+On+2Z88etnRatmxZ6FoQUPhOXqMSUvJ7+Z0O7LfebIZONhYLBraAZlc5XzQ7j0DoXIuO6yL29fA8bT2lpNUX0aBLO0Pe4YYXdcXLlPag0e+iL+cCOiu5GktkpjwvWOByuYS7W+ZyZSB+5t29IOqumBFJfTquDbrFzfuP2BSXB0m8wDUNllIgRaZnILhtU61UDoTBkSfV+k2XLx2BGUtqKvkSbmhC4Jtd7nIQIdGyyXwxyeW7/0XdDeV1uId1VlxLKwAsCTKvjah6EE9vM4HX8uUCl1SqTArp2ilLmzFx5jjUtkSZObIXk3gdEikpnSzi5XHvq6S0ZV0w4YcogSxIn94Pe4kMJq+Fi2o0iuJco5/8zjkhfgSCi2R+7qCuGVR+sqQRCjZSSH/nDJKEyVMGHKwhiAo0vKQbdi91kPeeNOvkhPQWtAW5gYGBgcHiI6WgLfWHP/yBfvnLX86LwPq73/3urs8hoA6XP0R4gtjy2NgYrV+/nnbu3EmbNm2iHTt20MaNG1m3CkQZiC1oWkH/6uDBg8E18jd0rpAeBNpxHay+YM6Lz6LXgkg7dOgQ1et1zsvs7CxbjCFP8poNGzbSPffeR8tXrKTm7AzV61XO69TUFC1fvpK279hJmzdvov379tDmzZv5HgjET/tRq7rKtGED7dixjTZu3Ey79+6lkZElNDE1DZ9PWr58CedHzef27dtp6dIVtGvPTlq2dAUvADzXoWXLlobKhHxu276d1q9bR2NjhxPLJH+vXLmKDo+NUQ0uKkWLpqZnafWaNbRn927atGEd7di1hzZlKZOf3vr1G2jnrp20YvkKsu2WaKehITp4YB9t2rSFduzalaudUKb77tvGeZqcGKfh4aFwmfbs6crn6pUraWL8MJUrNSqWy9xOcEcFWRqt15HRZTQ5NUn1apWGh+uJ7TQnfW//PqpXISZboNlWO7adkH+QuGwF4RHNzszSipUraeeuXbR1y+bMfW/V6rV093330XGbt9DY4QO0ZMlSmp6eoXbboZHREa43mU7eMqE+V65aTWOHD/OmGWK/zaZNK1avSSwTdOiQ1/HxSVq6fDkdOnCAtm4N5wFlmpiYJNvxaKheo5npKdq4cUNfc8S+ffupPjTEVjXNZouq9SE6fOggHX/cVtq1y0932720dtVKOjQ2QfWR0dTxFC2Tru+tXbeetm/Htauo2ZgN2unAwYO0es062rtnNx23dcu8znuTU1NkVeq0e98+Ovm4rTRxzwG+9t77ttGy5StofGyc6vUa1apl7lu68XTPXdnmCFkmte/V6nXa75fpwL49QfnzlunAgYNU9l3H7VaLVq1ayflct34D7dm9i3/fc+82WrlqFTVnp7kvsVvfJFzW19KefZinNtGdd99Dq9dtoG333Uejy1fQ7PQ0lctFWjY8QjsP7Oa+d2ePfW/FylW0fdduDjRSsmDZZdPw8Ajt3ruPNmMc3bM3GINZ3k+6vgcCcXx8jNauXUf7NHWV1E5yzl2/YQNt27+PVqxYnns8wTUa7bRv3z6u8107d9GGjX4brFsXlAkE2PTMLK1auYIOHtgftJMsf6hMhQKNT0zSqpWraNuOnbRh40Y6gHrYvJHvWbVqFZfJsgpsJTc5MZE6R9h2m6q1Oh06eJC2bt3SGfdzsI7INEf47xz5rswznqJ978CBA1yfO7bvpDXr1tF2/9lTcG9aOsq6io1mk8s0duggbd64PvQeVcvEQQ+mp2jV8mW0/+Ch4JquMiF6q7qOiMwRWdcRG9evp927dvLc04SWXKRMah9R+15XmTas47l23abNYh5Q+l60nXj9dN89tGXTBtq1ew+tXrs+dS5PLNPatbRz5/agLRPniLUr+V2zactxtGPvQdH39u2jkeE6v/NmG36ZDh9Syo257D5up+mpCbE2cl1up9Gly2n//gOhPn3ffdv5/Yq5LFjDTozR6pUraM++/bRp40bavm0brV2/kbbv2sPjqdmYYa2sYqVKY+OTtHGDWN9t2byZ15p4l2HtsWrlynlfl0f7HoIzGRgYGBh0Y1HYuUK8/Lvf/S795Cc/4QleAi+PVqvFL1YVeCHgO3lNNBqf/FteE8Vb3vIWdhWUP9jELlRAEoxPsT0vOHXGubOMuIPPoXECLZNp26ZZW0Svkd+1ne7IUgFYCJvjofOftiNO4xt+BBzc32jaHG0Krij4bLpt01TboslWiy0LdJFbZISppKguHIFKyRvf43lMdHCeLP/EC79hGSL/zggOoe6Hcg+ANJTy5gHyx4K+7FYSjvCGuplstOjQjE0t26WW3SbbhqWEn3cpPoxFXRML20hEKltYQDTZWqOd2k5RoJ3wTPQD/O5JRo7DbftC4xmAPEMTZ6rZoJlWi92A0PdQF7K/JoGj8fh9Wq1f9L2OS1RvwL3QA5pt2dR2LT+ao95SKDo+kO/ZViu+LXyXLR4ndpv7QujZjsc6WI7jcl0gShv0g9Q2786vGFvsroTNTLtNTR6DriZ6VaFbjwl9zR+v0bqXZdQ1hzxZljpEEgVLRpSb/1NnPHu4XKGhUpEtqDp5xXguMBlVKRfJyjkfJD4TkQcREapaYtc86DRVSqIOgnmU6zV8H88BtqMdc5wmXNvKHa0q2cZC7wmWYbCU6YRvF9YAsBjotHu5KCLMDVerNAr9qVqVlg8P0VBdCIr3A8yPqOMqNKWKiORY5PxCg61eLQ+kji0EX8C0qxFfjr6fRF8NRzZ1vPwWEOp46nwmxxfGrB/9cKZFE9MNbkN2W4TVWFuMW9lO+vT9KIx437bbNN2C+2mLmra4XwJ9hj9j91E95HsE17BrquP2HQ1tIIDguFVk11fUTz/SpLLuEekSc9tEo0nT7TbN4LAoiNzmUsN2eN5te7CSE+/R6HO5bT2LHJYfiO8TePe2PfQ6K9N4VedTrHemZzGHeyId7sXRyHWdsdyVP6VMLaybcEmpQk6hxOmkvdt4LYTrolGIe4Ssi2gZtOAgM/5PZN2EbMsytWyH64gjWmL90m7TVLPZ6euwPoQFpuNxm081Ou9AjEERHMFfP3Gft2imAQ09m2abHk00WrR/pkFjsw2abrao7Xjc5rAS5XdkC2stjBsneFfh3WFgYGBgsHCxoIXOkbWLLrqIvvWtb9FPf/pTOvnkk0PfS6Hz//zP/6RnPvOZ/Nltt93GulJRoXOc/EAkHfjc5z5Hb3jDG/h0FKdFi1mYUBUalq4lOjFcLOYQznu0VgtEe/OKMUeFf7E4QtogD4YrZdbpwYINrjUVbJbKeheXNHNqfI+NOwR8i5ZFVd8FRRUTPlKCl0kuTarAMfIqhZDx3cGZBi8+RyoIIy/0YKTob5JoNy+AWy22KIA2C9KWosNZzdJRVw1fLFpudqUIc1wZ1fqVUbTyCNAj3xONBpcVz+O0fBIwTsA4TmSZ66bZ4nwgDeQhqd2z9C/0Yyxksa3Ahj5aLnmN2P95obTQrogEpLsvTSBbbWNgbFa4CS+rV8NC7THlkfnidoTrViRvunYHQCQA0fE+H4LsR7v7RFwdRus/rX5T62mx6abI/HJESEevmZNQpmi9Rv+ODXKQmi29yLrUzOJZwfVobGaWo30tqUKgvRK0JUcQS4gMKNMCd8iREVFsC5t+EUVOujTyIUHbCX0WhSyz+pR+33mDGo9SyB5pDVcrqa6aaflBfWHOF4SOS1XuKx57ZU21GkyCDlewXvMCF9LoO1RXNp1gf3TdJA/KpIaXOl7l+1AcNjg0NtPg71bUxVqq2XK63gdxfUyuEWRwBLU9s7ZLL+0X1WiTB2b8b0e45sLVN6kN0wIfyPLhwAQHMuDMqrDIKpZosgnrIIuW1mtM7KuHdhgj6OG1sgjKoD4HdSRIXhzsNXk8gsTGWmq2heAXFo1UyzRaqwZzhMwLoqZibOHzhfT+Wcj7CQMDA4MjidJCd9lDZL1vf/vb7EIgNaAwocNcFr9f/OIX02tf+1o2mcUEDxLrggsuYEIKeOITn0innnoqPe95z6OLL76Y03jb297GaWchpBY6VP2IqIaH1MDAoiBKaKhaGXzyiw1/ymIX946U1DorcNotp83kA+4dHqrQMMVvrrOQSeK0UxAhyCMWo7VKeCOdSwA2B9IWfPLZ0Y0EW16VCmS5YlOD+5tum8tRgnVHpcRubxYVmCCslzuivxJYhLWdFqfvzbQ4PbY28zwm52Q49VA9cRsLTZW4PEttkgJZ3FY4oWStmph6U4WE5WK9zdx1txh0HFA3ywr1rrZOEjCO04rC5hObAdQBxKLTNvdpumrIC8YCyB1MgXJzIPPHmw9pUWjhO4uJwVq5zAv3MqxXYGHl6/1E61wdJ1EhZ7Sx69q8+cVniK4GiM+7x4e6QBd93QrSVkW0ZTnV+tVr0oTrfj70Z+LaQ7dRUsu+WBBXh3k1gVLnsh7EqaPzWdLGspfNbuJGVeq8gG3Ab51mTkKZovUa/TtODyytHLp6jn6GNEYqVZ4v6+VKqC3T+qeaFuaraJ4kZDpJfSP6fs+CaPkhfj9rt7gcyE+vupPRdHmOYSuZ/uYOtb7Qh+QzZD5nWg2yPbFYZWNdvMlcl61gWi0R1VLqq+naFv1zxm6zxe6yoSF+hoiGCQJFzM1WATOyIBwBtU1C70Mmw4pMsMo51vFg0SWeI99ZunwgHRAlAIx2ov1Wd49ufMXNE0kHZuJdZwUrfqmRx997Hh96pSEpKITMF/I4a4s3KnIIS0u20uX3XeddKQNV4PrRUk3Una+1xwESKmXR/m2PZtstKllFGkL/dR0mK9ueQyPl7kMqrDskOYYnqf1ovgMVGBgYGBgcRaTUpz/9af796Ec/OvT5l770JXrhC1/I//7oRz/KGg6wlIKvOCLr/cu//EtwLfzR4fqHaHsgq+BH/oIXvIDe85730NGApI2MfPHHbeTlJpcJHjc/wSPcWopUdLGo018TDfMtySQV0UW+jNoEEgVWV/JEreXMUrlQ5FPrXgRgs6CfBUx0AyFEiB1eNFW8IrWKMElvUxkLTCV8vKwDJmLaBXb3wGnjEEE/y7eGscRmIhrdSgoxw3rHJkdrASUXa4WCQ1Yb33UsztKEhEkuJvmUv6S1CtOdmsaJHPdCIkrCRm4C0pCFaJHEVHSjKDcgOInHQr1eEtdA1BUbMHkaC5IKi/mhcjlEFkY3BtH+hLqqEqwMPR4zS4ZrwbN1ZGvSRkBXTvV5yGu0DdI243OBuPZQ8wrMFdE814jLbxah77lGtP8l9ade5r7EjaoUZ8Yyo+BbSuVwN9JFyFP/jgtyMKhNKN5t9UJnPk1qy7gDF9UiRBA5+vLFWVf2MhbY1bnt8qEI0oOVStvn3SuVetd4jM5ZcVY+KrGBPMk5VB4exSHJcjSp7WQ+R6C5WGhRpQDXUUHisyWyY7GbNDkdK1wZ0VHNP94fIKTQGSVxJCx2/cMW12UX1bRDHQCHcMVCky3fZDvDQkq16o1DGkmtI6DSiKC4ulP7jHD3DL/3kQ+5BgHkeiUKtS5VEjiuvwcRQZVDULioc/q+dS8AChCHaaWCKCvKph6yiHx71HTgYu+RZzk0Woc1lDwUjQ/moZJ/Hev6IxAJ18DAwMDg6HHfWyhYTOa20RNZ1SUhuuiSi0X0AEF8FGJdo6KnrdE08Ax1IS3dvsZnZ1kLYqhS5h/VTWK2bWs39rIck7MNDgWPDEJjYMZ2qFou0urhei53jV7rL866J6s1gXofdIOgsVTjxVopME2Puveo9SnbIu2Z6oYBVjxxlkR5LSGiLi3yPhBSh6Zn2IR+Wa1KI0NV7eYjKd9ZI7vNN6KbSF39o/xwJUCf5H6tuJBEXYx0fQeGI23X6bIu0ZF9aS4TuvzPd/31+syjxVIqDlncSOe6rY6opdQRwiDqNa9ba5yrpnRxg4sSLC3lXBF15ZpuNWm61aZaqUhLh4Sofa9lUCNR8nzD73eXltTqoXd3XFl1ZZcaSEhJPfhIrCdY2TptmkT5HY9JCUEsxNdnVoJMdT8DVEspXZ5065de+m5cOzcabZpozlK9VGG9tSS36jjo3FFlHmFFhEOMuLVctF7U+uhnPMS1L/outJyiLpRp1r4690n1Xt27UpKeaYRmtB7UPCwkLKb9hIGBgcF8YkFbShnkR9RSQoYf152g4WWPk0IscyACiVNHl/Qm8FjQzfKLvsWnrRJYICHlln9iCchTSzwXfv+269GQJ9wDmeRwsVBxugSto6d7sA6qFDzWpwJ5VS3ZbCmVdiLZD+LM7qN1mjctWHdBLFhdmGHxFD057XaRlGkVc1v9ZClblvzr+g8IzKjFFfoTBE1hUSTLGGexkHSqG+fqJReaeGZ0YZ608NZtzCUZC68FucmS6WPhD4u2tu1SycaiW7jvqM8frlTYxQ9PEo4fHXdZ6TYQfa7UkMH3JV8PKlrfqgtokjWIDuE6onlDr5Yp0f54pK2K5rte5sOtJKt1ke7aNAi3nDBJsRAwCEu7LNYV6mabxzhZQpzbcWmkLvSFhEWIK3QErY6rHtoeQuh493FQBNYlwgFAUWhR4cAGXo9eR5MqTUsvmn+el/x3sZwzJWERvRZWK3L+0pWd/13qBD/IVE8eIpe1yG2L8sOCJs1aJdp2ujGiun7pCC5dnvC6qpbLIYvuPHNrmrUTNK8mmrCwbXJUP1jv5x3XOnfUqBWRcNXXpx1n+d7PeEhqX+m+qbM07uTHtwDPYOXbbRkZdoHNioVgoWpgYGBgkB9m5j7KEF1gdjQruhcWchGEBSMWrDDnjtO4wAkjCCnxO/w8nSk4L4pLFi3xT/ywsReLWZGXUqVzYqx7pjgZIxpS3CdGaTAaYFHh6LTT0kGYf+sWZoNcPPW7EZMn99CZwGYGZA36BSx6pNWWLH/ZP82X/052s4tf0Mbp8ASfKyLI0PJoNZscYQ4uudGFedIGn7+DfoZjU6FcCcgzkEoQ0ZenynIxDZFdWC3MtNo0VOlEHpO6Iqyjwhsd1FOHQJKbJamdESLzsEF0bKFFwi4g+nHWT1/TbQhioRGY1vUBnXumTlsmT56PpDXcfD6b68NrU5E1lbq1dxa7W4luzOVx1VrIyDKfqq5VsGwB4YEDGNttU6WNzXiF5waQIVELI+nmxK5Gjkulkkdlz6J6pcJzLqhuxxNRyPAMBCmBO3coXzEi8TrSJu5gqlNWEfUN9+oOXpJcVHluc0E+iQhomN+4nBwBr0ilMqI2llPdH3XjMpYgSxg3urwOYqwlWVbBxdD1hKUUvpdajDoSMM79PYkk67i7CYsplEM31tJcBPMirt1VPbRoe2V5fpbx1Y/FU5zVmIGBgYHBwoUhpRYx4l686gIz6aQsz0khTqtUC6ksxAq+W1KqxYuaUu+Lln7cRtTNFOv4pGg2DOLkfZCIui/oTPXZ2oc3ImFXsLgNozy5h7skTvZB1lgkouIIgfFqyD1T1+Y6K688gqwy7eAeWN9hg4ZFOKz5POS/TYViFS1HtVI5EzHC5KPdohZCtDdtsooVjgpUK5ZENGuIzyNdn3yzCGW32JUGZKsUGZc6W7BuAISVVMdSKpoH9W+XCSmHKohGmLBZ7/dUO/OGRIpQ82WF2D4grLeStYck2dxsttgyolyuUNUnoXVz1MAthHJEpZtP0VtuS0+NQhfOWxaC4YiScil5Qr/HmOJgGn7krqi15EKaNweNqGULfo9UhJaN/CzOwgj/RhQyAPNyReOiVSlVeexUOMiDsJQKjWvNGO6VyIk7DAiek9Qv8X0bFmIO2VShpiWILf6p1qiQYMEbCiwBa2q4g/mu/HGWn73MkYN4hyfpO9VqJarVRoO/nZbLEeiQf12AEmklp5tfdUB/wEEM+kfgMtiyu8Za8G7mNsT7s4/5JGH8J5GUgzpoUw9ZVGQhmOS9OGBR9cYMDAwMDBYuDCm1iBH34pULTBzQQ6dgIel95F4ExSyM5IKMoySVqrlO1dQFuIfTbUecQOYlwI6Unora7oDa9qx5YaNeRARD6SAGcW0QL3EbRnlyDxJGWsmg6iGSO1KtajcVOs0pmb+kTa8U4o0TZu8SSraKMJAiq1gk14MWWYvdTS2rTRVXnOonLTr5u1KJSZOG61EtEE0V12OMwI21UuwsqHUuA/hODTsNoH5lLXe7H3T+hiivBysCn+CaC+TaECh1m9QHdK6ycvxI4lPq38w2G9SwW1SDuxITWkXtHDVwC6GYzbkO826dpKnn3GUYIGGVi5RLqVcWinZdQWLC0hYBHSLWkgtd36UfRA918Lc8hJHWMECWqLYyneg7BT/1OFHnmL6lmwvTNuVxhwGiMCljC88vwcUZ2o/CZRsBPuRYZ2tkuEv71mLqu1INLMGC3BAlb7Q6WlAxlp9pljD4fLZhs6wAhMjzuoDpEBftMQ5cHn9u1L1rpZ5YFujmrcQAIJGx25OFaI55dS6gHrIAWa2ApYUa3mNJ1v8GBgYGBgsLhpRaxOCNox8RRj1FlS9tKZyZJXLLfCJ2o6JbBCWcBoNckRtjFnfFyaTjcOQXnCzrFsHRRY1OayLrCWmeyDiDdCOKukxGF12SKIJgKiLICdJALF7rvv5JdJEmT+7VDdDhqRlyLQvx/bR5lBtcVedCfB7Z9EY21Xg2IkOBNCu2nXgihdNUFuHVOrkWLKTEhhgkh3ax6QvswglNaL2Ieq7XhqjkkyPRxX3sZkNDCKj1nabjJQGXFnSypGu1fSKwshHRkwZmSROp27g+0JVHbB7bNhURlZC14DqRsurVGvdJWErJzajcHIDmgmYONt3FSrwY/5wSP0fC6lFTz5nKoPa7HJvDtHklFymXUq8qiSnHFJ6pWkvath243WZ12UmbF3sVZM/qVjgIIi1q5YE00kSqcQ+ILI4IR20qFDo6gdo8ZO1bGRAiwwqRdk8bW8hHoQq/Zypi1rU6LvmyHhD9Du+IqGUQrkH/8dB/SkIgnA9TYCFWKsZafqZZwuD7qVaTWj5ppVp569znsrh75bEsx/3DJK6NHg6qVnJZ+3ZgjRrJt05/Ujd2VTLadTxqNBpc39KiNUsakYzOuWUnH7Jg7eaB9MYzslkBp2mOGRgYJOPv//7v6Y477qArrrjimKiqgwcP0pYtW+jSSy+lJz/5yUc6O8c0zPHBIgbrQGHhVhGh36OLCyyCQEzMpTB4EuRCDwte1d0sOB313csC8AJH6FAkfuZbrcDaBQsPsdiCGKwoP05dsSCFVRAW2kkQBE3ySVpcPfZTv9JaCBslNYpQFHGRhlB+JhBq5VDb82K4WuGIOBDbRWQ8fI8y4jf+xj1ZNloIwQ3rIfxOqjsh9CvqUFufclPN5Iriboj2woodrm1qP4gBL8KHqjQ6XKUlw7X4cngOOY5NTrvNBAqeDWIK1+vuQ7pwsdBau0XyLhf34vQ7u1ZFlmvVtLue77RC+eiCm70e+wHq0wHhB2JKaWveaNWrtGTJKP8WLsSdzQHmKOhvwbImVL4eERoX6GvF8py6vc05omVQ+13MHJi5D6VAbtLxE5qLUupVbq6TxiLcbmGkUvF1cPrNfxBZrh3fj3Rz5kyzRQdnGjTZbHbdJ8sPyxrWVPPfTV3vp7T60hwcSFIFZcK7KK5sstx8n/9Oke8Ijtw60+T36FxBHrDw+1Jtd5DLVomabbervNF6lla6HV0qQcShVwyVK3wgEn1XCpKqQJVyiecIzMM1/LtUDB04xdUvSFH81mkTjlSqNFIuBTqYMr8cgAWu3Mr6AJ8hmtx0qxXb7nld6vG+lS6t0y3bj5DbAdqTrXSVdk3q/9LtL8u6Jjp21bm6hbWR3aTpxiw/P7YfJ43/yHsxz/ovF/zn4P0t6zNqERdNO8uazsBgseHLX/4yr6F0P29+85uD64477rjQd2vWrKFHPOIR9K1vfSvTc+655x76/Oc/T29961tpPnHttdcyGXb22WdTGYYC/n4uDl/4whfoAQ94ANVqNTr55JPpk5/8ZNc1t912G73mNa+hhz70oXwd0rz33nu7rlu5ciX97d/+Lb397W8faJkM8sNYSi1ipJ16Y49dKkNwNMMJcNaTrxzXOYhEhOUE7xtFXqV7ofYEVHfyyxoXcnGCxbNH080mR+TDRghaE/JkkTUs2kI8nU8cOZqR0KbQbZiynrjHnZD2Er1HAs+E+xoL2kbM+/vRwNG5cPVqHYL6xUYh2r/UU3XdSWTXszQnroFQqsYKJOrCktsygsV2cRLdcRXLsqGPlhGbCMuDpY9H5QqsfebG/SvY5NqwjrA4KIBaFlEtaFMEdi9Qs2F3ieTy+AApRTYRXIgi+Yurw6gLJn7LDZGORMPpuvyd1q+idaWO+ajlCpDHOkU3Lo6EgHrwTNYm8/tZSt/IlE91zOSwiEnrn3HRzDIL5OdEoViiKpfRyqRx05X/iKUgDFOZf/UwP1RzzZm8UYWlEs85HeH5qNWNzkJHfXcCafWlzsOyvUuFUsjNWVtu2ffZ2tMh24PQucPkblb9oV6QZC2q7R/K+118Dos+fNbEoiN4p8mDM9R9nNVKXJ9N0ieLdVX2+0vBKtLwUIXqri8m779TxDvB0rrPsdWWP0/lnd+T3tPSqltXvqilddL4lZaJMhBF3LpGN8eo/RT6kLxGsgpkw/220aZaqdSlfZUM/0ApYQuhs6TOPbekWGsK60LoPLbYTZP7CUeTdhXVRwODowfvec976Pjjjw99dvrpp4f+Puuss+h1r3sd/3vXrl302c9+lp7xjGfQpz/9aXrpS1+amP7HP/5xTv8xj3kMzSe+//3vMxl25pln0gknnEC333577LUoD8rxzGc+k1772tfSL37xC3rlK19JMzMz9KY3vSm47pprrqFPfOITdOqppzKB9dvf/jY2TaSHa3/84x/TYx/72IGXzyAbLM/zVXsNYjExMUFLly6l8fFxWrJkyeKpKbacwIa/yCdefJLp61zUfH2cuGuzppl0HbtQeRYLS/NiPG3jFkd4Kc8cb7RprNFiQ+7Vo8OJGjoy4lDcgjjt++7sDXbTm8VN5IhEKkshHqVbKE70sZBV86q6F0hrmURXHMUdrFDsaDxBpwY0yVBFpC8W/NnDzyeRMHFuGuo9IExwug1tLuSha7wMEMjP5GyTywxxdVXvivNri/5frlTI8YivhYvLcKXcqX+0WbvB0QEdKlKx3BGml8+wbZACbarBZYPX60WOFiY2DtgwQJAdVlCwlijyddIFp6/+F+1PrkszM9Ncv8VShUaHhGtN7NyUsX3zjudBIHim16Yyc0cp8+IRymdS5FEZfTXLYUXP81HW90bcfdgAW3h7FKjBUybqTu+eo8tjQHRbgmRW85HFdUt9d4K0aNmwtmnRklqdRa4HDr/cTEI7Yh7VuaLPB7TvKeX9LueadrNJjWaDDwSq9TqTA4EbdTEb8azWM9z6ZDtmjuSoWfPI+U0Sm7p3SL/v2bj7k9xGe9WkzDJ/CIswN1Re3WGPeNe2mYyFdXXm+ShtPCsu9JYl5pfYuo26qCuu6jguSWoXlGFytsFkda0sLO04b3xAQ9oDmiONRbufMDjillIvetGL6De/+Q095CEPib0OllIgqb773e8Gn+3Zs4dOOukk2rhxI1sPxQFrzQ0bNjBB84//+I80n9i7dy+Ph3q9Tq94xSvokksuIR09MTs7S5s3b6bzzz8/VMbnPve5dNlll9H27dtp+fLl/NmhQ4fY6mp0dJQ+/OEP0xve8Aa2BEMd6XDGGWfQgx70IPq3f/u3OSypQRIW1mxtkA9pLjscktlXrPZf7PIUuOskLs1FRD4LC4YMriRYTPPCyRIWW7wIBSGVZPItrT3aDSG2Ksvm5w1p8n+eR1X/hFNu2hFdTZZT3odnF90WFV07nF6PZt69uMYkQZ5gYtqNSzOPi9hA4JMbXFdKO6kbN44ShRNw9C2lTqPuBWp96czs+R6PyLFK/FuC3QF5XWqJE3p28WsRednrPq6t5Kk/8hl101DvQR7gbgIXkF5OzqNAuadnWnR4coZaLUd7Aj5SKfPvqD5YCy4lsErwXeZwTZcrDEf5qjEhBesFRxkLIP74ZByujLBmaDWCcRh1wWR7LLdNntMOrKb67vPQBHHaHJmP2x9RCC2X6vgpSpdPzdwUmd/SyIMj4bYRPBMWZBld7OQ9Se5JcwW13qSlRtsVum7ajX+C+2ouaN4vanvGuvrI+4oVoUtVLPEmG4RUXDvr+kbgolsu83vExjTnPwuQ7tBx5IfaP5E2dPagt9eUm98+gHzAPQ/ug9Fyo7zIF9yW44gLeRiA+SXVzU+OKafN78zp6YZ2TlKhuqIFdcPBJ0pCW85PC3acJcwhZb/uYbFELpO18oAicIuMvo/9fGHel/Wc191c18/QbjJCKsacStAwIdNo82/UYT/v2bj3NMYYNMJE9LxujapYt/EEyDLJcSOhjiH8NDkyZmdtEXLR9POM54/WquwymWveTFsvKm0vtZ1i6zbqoq64qqfNN0gTFlIgpIL3oZonz9G6SRoYHEtYt24dWwqBkEnCL3/5Szpw4AA9/vGPD33+05/+lF3fvvnNb9J73/te2rRpE7vDPe5xj6M777xzIHlcu3YtE1Jp+MlPfsIaUHD1U/Hyl7+cpqen6Xvf+17w2YoVK5iQyoonPOEJ9J3vfEdLhhnMD4z73mJGmgAuFhkIL4frsEjACaZqWdRlEVPI8KxsJ91MNnggxBwqgBRCPiShhd9YkEYtcXgx4S/ysTCB+nhErBN015JKkcplsTngRQsWWZYixu3XCZfIkpuqNpMaiBLEoqw9uKr07LqVYHmUKc1+RUXlRoS1UlO0d1TCUFncqe4JHJa6WKJ2u0Ulq8BN6rrCnQCi+yKcudzAiLIF93ttDhHOTFyxrC0/FrGjhVrnVB0hxssFIYyesfxx9So3l7qoPOo9IcHmmPDaeSI8JQnvBgLjSJ/rX54W+/ktl4ggEO4L+uJaeTIfdeEQZbAEqWfPcN+3vRI1PGg6QZAalg0QXfc3lpExAHchq13icdpxNerTXdEqkoMNBkak79ZTqtZopFLzNUtE/rusHiPzW5or66Bdz7Ig/MxirnukxUNPbi19Av0GG3UQy0maeOJwQZCXfbmvat4vanuKvzWuPjpBfp2LcNZ5kucivDeEFU9Wt6Kou5jQKWoFekX9QOumlsNlMxATbzZ81yW4zIkogF0ISEZR91ONJrWsUteclGrJ4+fPQR/2379cgyCVoR0HC6Fmm90lqyCVItHUQOu1bZAkLQ5gUZLvaSZvOqL5WS2TusTL4dcfOfiR/5Z1zoSR3aRSWczzqmtkL5ZTOouyvBH7skCWo6NtGBYzxxjCbyEs33FB1eUl2q+jZZDWlPKecH8oDCT4hLCIgoUv3GstJjulpZTQCU2ebzjPagRl/4BGzgUt7mcLL+CPgUEvgIUdiCMVq1atSrwHB/ewIIJ2UhKuvvpqJp9gLaTDBz7wAZ5XXv/613M+Lr74YnrOc55Dv/71r4Nr4EKHnzRgPSstmvLgxhtv5N9RazFoUSFv+B5WU70AaXz0ox+lP/7xj10ukQbzA0NKLWZkefEnXZNAagWaOti44KQLkdyyLjLk5gXWF1hcgAzCs2DtBKsYu0lFROjhpCKaUnIxoUYb8/MJWysI5sL6CyflMiJN8BxdtKBCRbg0OWKBDM+NXtHzpjehnuPSVE89PadFtXIBUh29GTfy88VJYQuLUmwC4k5nUW/MG4Y3dtHNKOthFWDhhE2QIAdRtSBm5GI2vKj374fVUxuEo2hvEKWpdQqLASxWefFKiaHW0/WuYrRIkto3pv1Qvolmg2ZxAosT/spQbBGk8C4IrNiNrOY5nN+ybymiFFVL0Pin02KzKKwhxN+lTluUy1RIcNGAm02l2iHEBkL0wDIIGz8ZqRBt5hPDsZCWXtiUKFYPg9bz6gWDcqk9kuVhHTELJDIsHxOu8y0ZMbgFGRTpD9xOdkAyB3NGBoKou/wJuktZCKeMUQrlc5M0ntKeh3kuSuL0CsxV6FPSYjAPAmsZtA8ExllUPqFPKhp1RculkVqRWq6rnZPw/p9stahoNWnF8HDXO0M+22ISCXOx0PPBM2YaNo01Yflk0Yoy3Fsjbmxww2zZ1MLBFVxIMSezPqQmeqsG0flPWuny+0gT4S86zphkcWyqwXLOEocoSelngU57S5CMZe0Bgo70yzq3CEtiEJllbb/W6QJqNTAj/TxaBhb99wkdEJktuJJ7rp70zHPIqSOKsU5EtF+2kEa9IM/d7x9Y9cF1Fn0W4xD/nuU8tzhfHVKtNGfEoIHBkULUigmIWvaAhJLEFTSl3v/+97N73EUXXZSY9q233srWRXFupYjaCV2mii+rAVLpVa96Ff3hD38ISBwQVe9+97tTy7F161at6Hgadu/ezYQWBNxVIE8g3VDeXgEtK+Dmm282pNQRgpmlFyHCp1kpWgtJi4MEwkqe3rKmDkGDxielMoIXZWA3sGHBYgU3++QFW0x4LpMMmfIr9tl8PSxxgoVPECq5JFw+Wjhlt8J1UqiK01w2srKzLTAHHe44z6mhj1AobezhHY9KCZY46c+vUMtrUYv8TUDciWG0/hXhWJXMwGm0XDwjg0wKYuGPam83RZ1jM+tbNXQEckEyiE1UUn2EF8doT0FOoh1bvhm+ukGWC/y2A8caGuypaEz78QarWCLbsankf6fbVMjPsEHgkOe8QdFsOiLP6YhodxPCWkLDv583djxgKqzTVS6UaNj3j8yy6ZUWZIN0Gc1CboXqTlqMKWPwSFhC6dqzlw2rbl6Z7/KoZeF+wO5S/oGBDCaRQkZ31QfuUUjmYO7IQBB1lz9Bv0yXHruAtQRhi/dCxnk2tt7V9slIcCXppuV5h2Ry09akKQ8DMOuVYa0JK6lygiWzEjgEFinDwwUajrlUWrjCNJa1x9T51Bc69/CWhwVnKU7c29Jbg8FFr1rndxGTBX7f4f4o3ysJiPZL6dYcFS+Pa28maAr1/iyYNXnSBXCJmy+iQucysiQPJq6S+H7M6mr8CNzfWQvJe0D7qYgluyL9PFoGq8Qv9IDEw6meSnp2zdl+WrCcTtIPU+8D2JXWDzTAwvS8yda/w1USCsSwarUo1w04iMTzZXmzalEaGCx0QGvpfve7X+I1P/zhD2n16tXB35ijn/e859EHP/jBxPvgFpdkvQRNK0lIAYjqB9x9990BifP85z+fHv7wh6eWI4urng7QlFLzoAIuhfi+V8iyRy3RDOYPhpRahBhYtKQEwkqe3kpLKbZRYXKJb8yWvrphsYTgpCAvsODpuO3kz2ehWyi60STbgSh1d1QwXvhAX4oXqx39EkC7Eci7Icmd/3TIxWGBqsIdrtJHyHsmjrBhKXc2ARnRhvaS3aRKuUqlase6JVrHwd+sCdaiIp96YpFb1uYl9wKf3ed8aznNwl8u8PEJXJLSohNlKnvoJFu4zNkRK63hWoX/3Qn9ro9uhs+g8YE86qJJBXUTscTitFC3ftS7xL6rbuzgTuOPMXxazapf2yvhoonkl5fY6np2TiI3mo9BEGu6+ogjalLLPeh5JWeZ1bJw38FmLoWEiY7zrvrAvdg4+iRzEpHaV9/TEU4gpPADgJRKmGezBJUI1UHeg4Ro/SW0tawjNhp1nexEuiZN2RexIUdaHYInR15j+hAsmlbSkJboYT06JjT9eSYC3LsCpI9f30VXCGsLPSRBWODfaqCMPOsZ3fsHbs25kNBfpHWvsDjqFi+PCoaHXAdL2QiuqAWPeJawEE8lwxL6p66vx46tSDpRS+KQ1VnBL1uMW786Z6etUaOuuxBbn24igl6FIwHC4k6uQaNlibrOqlaLuB7vYnaN9jy27JLkqiGmDI4GnHvuuYlC58B5551H//RP/8SueENDQ6wntWzZskzpJ+kpbdmyRUviHD58OGRtJC2O5gIgs6CzGmfJ1SvZpZYd9WZwZGBIqUUIseWWgrmFOdmssQhnQZw8CT0Rf6GdZ5MY2bB0LVAGZZHEQtg49e+EXu4KiaxswFJJvR4smyR0C9Q4bY7oaWE0hLMQl6WBQWu+nwJoILVg3QSB8xxtLgJc5SAeNXUS1j8rdqzldO40/gIf/ZTFh12xEO/HEiV6kq3rN3KhrJ7YRzcg6sax6DVYeL9I2EAl5y2Ulj9WHAjVNpoiD4hwpdkQJm7sUsacIPOgz5H/1dBvCPCgvLwv631e6IdY01oURdozjqhJLXcf88ogytxVFnVT7lujpuVNm4ZCMgur1DCRmhWJ1ik6AgEWUurvfg9y1PbJe5AQbduEtlZJahz74DJEMk09LNCkqZalEjOfdL1/lHRUVyhoBUb7EK6vsqWqIPmDdxQLnYv5WDfH68gNqdF3JLXU8kC2U9sP2iHfSbr3QpzrYFJ/i76PheRBx206EQn9U9fXY8eWnw63rWJZlPWZoXQDN3282QQ51LmGugh8yH4F30m9SASxUQT12X0wUpYk11nZ75DWxEyDyS6IuEsLrIXc3wwMBgVoTOnc/NIA9zeVYIoCFldpRNbU1BT/pAFpqdZcWbF+/XpyHIf27dsXcuEDUQVLL0QP7BWy7GkaXQZzB0NKLULgNL4Eke+2S+Mzs1QpiAg9aQuZvJu10PW8wMi5QUyzisloOZBGpiHCy2hVuG+UEe7e10IIn+AVUhdMoXz3aMmgW6Cqi1iQCDK6lFgkiYWouHcwC/UuPbCIZUAecrICMs/KsGHK0OY6cdpY1ygIoksyk9PstInu9FQu8BFlh6u6gJN833JLbuJyEh3Rk2yde0asxVioStSNI0T+4aICN43kTXsoLce3FIM1BESB/X7cayQ8B8RYsSREZZX6EFGicE6dM220I9cv2qI3XaCQtV0fFkW9ajWp4vGi9L5FUcp4zKRRlDCvDMKyK0uZM7mtJdyfJZ/91n1s2ro8ou+yKHKKMLffNyuYUHgM4Td8ovUb9JgM6rWz4u5NSEtn3ZQpAltCmkmi5FESRU1n1p4NXKFG69AJCh+SRHWb+loPzLeWWlq/jvk+Spw0Ea1VcT3UvRfiXAfzYFDuvPyeArOPvm5lsxjUrg019aO7Py7ohE67UT4H9apqPqLvVf3+q45/9Z3rtCHMP8Ou8pWyINow3+osVPF302lTw3GpWkJkxfx6bQYGxxpOOeUU+o//+A8WMV+6dGlPaXz4wx+eU02ps846i39fd9119OQnPzn4HH9DbkZ+3wtkdEJYlhkcGRhSahFCLupmnTZN2W2qFB0/8lchFE4bUXg4HLO/cJebRo5ooot+pyy+OeqKTdRwHKqVRJS0vHoX3ZdEFjQZLQe6FkxRbZZiiarIm3Jqq134KvpIcWLX/UK3QFUXsfi8YbepYdv8N/LdyeNgFupdemBpLjgDtq6KQ9hkXwjdCrkxJzCtD9oN1m8gCFiDKRyNKcnqQa3zAsTYA3KDshEdSt9Sy66Gr+/LJSzBukOSifJEPvQcf6xAX6uKMvLmWO/ekCkSHruKQGOtc7qda8MYHe++yDq3hR/5qmf3tT4tinrd3Mn+KaxQw5EZ8zxPtklWkglBGDiCGW/IcrogxeQh1zydsV2yzBv91n1s2hny2EW+KPeib1YLInorW9Z6OUmVGO2sXgjFLNZNAaK6WTGILXtM1DXZD+r+ZyDItG7vEd2mQbyjdOMltg7xDsD4AEHklz9zfaf1mYQAFipxIuzSO5bpUWuonlwHcyBvH2NCCFpQIF59zaloZD55XZxLclz99CsdEdeH4tYZKrk1Pj1LU602nD9pqVWjYkEc6uksVNFmhcAKUR/0xMDAIIwLLriArZ6uv/56euxjH9tT9cy1phTyBTH2T3/60yFSCn/DVfEpT3kK9QqUG2Tcaaed1nMaBv3BkFKLEHIxgDD0HPWrgEg64Jma1GqL8LhYTJRxXaWzUQ02jawPhY0JFnxWsOBThWthHtm0LWp6BbKsNlXcFIsBzQImenrbtaCJO231F8xYO9l2m8OSQ7C5Y+odeZbmBFm7YPIcoZEkw1BnOZ3uYfEYJRSi5AZIQV4oFQohnYMsQtBZCIguPbDIKackVnSbi2hkm0FCXZBK/QwHFlF+dLguQXRf2Fyn6SNPT7G/nJppBkROaHEbdUnKQnToNiq+qG/Ldmi21SLPKtCS+lC2jUiUBIhYd6SGhlfvh4UGo3M/XC50m4TYjYyMhFcQ0Sij9SEs2CwmxxItOKL1FCWSdORH0jUyTTXqZi+b3z5cgoXbr2+FljMUvFrXeS1S0Q4u5jsYw8l5eICIEyMO+ncWElCxhEOktUHqdmUiPDLkMTbKln+v62Fzjshlwv0sDtqyaVzRgTxt7TqOiDyLdAOLpRRI3SxMdFSNjwaolj0yBoI5EZ/LwyhYfbVbVClVhOC4BmlWoIPqA4l1yC7LsDzGHCOJkfgDqlx9JiGAhdoXUX/S9TAVPolm8+ut20o5M5RyobxJfYzbQUYXlpavkbLpIvOpbuHRQCZx9aOzFk7Ke7RN+rEGw5oEAuZsKVXqWEp1Wai6MmKxcK+HVZWBgUE6QCbBhe9HP/pRz6RUr5pS9913H/37v/97YPUEQBdLWlVBqF2SWf/4j/9IL3/5y+kv//Iv6UlPehL94he/oK9+9av03ve+lwkrCVh8ffKTn+R/X3XVVfz7U5/6FOtr4ecVr3hFKA9XXHEFPe1pTzOaUkcQhpRaxBC+9X4Yel5sIjKKH3mlINxwitjI6jblvEZxQws+VbjWwgLG82iIcOomfPQToVnARE9vMy1oAH/j5IBAQqQ1q8i6AKENQi+WFNDQcFqdMNQ5LYDSFuFZLQkg7trLYj7rKWXcIlq9n8VENc+ORrYZJMJ5Fm6LlZIQco/TutBFY1JPT+GuFyVyogLlSqLpmdT1LV/Ut0IOtQiRgaQobQ53OaRRria2tzY0fMppf9yYSu2LFihquLnCXa3Tp7CIT7K60NWTGBfIt2gTiMG7dssnlgvkgXzFxhhRwQJiLVo235INm29sPhMsYhLHYVZrLM3GSWq5iU1gvlDwal3ntSjBRrLgRyWdC92TVAH5NLc11BOipbJrp7BGHbQuUOpmNYNLdZpVJ9cD5n5swBPaRjt2+PqyIHPwrsW/YzTHYtNt20xKsd4Wa3Nk6B+BRaWV2K9DZY9zf1XHBpNr/u80RKyVEl2+eiCGE+vQKoo1DMVYFCeN90KB2rZLrRaiNVWpVC5l6lN9udH5JFrL9niu6zktpVxiXhVl1ulQsrsxLOos8U5iy2J4p8aUKRSZz3cLz+oqHeeWF5f3Xl08U9e7CcDB4/TMLKEJhmrDxkrKwCDzGKvQc57zHLr00kvpfe9737zWG1zn3v72t4c+k38/6lGPCkgp4O///u+pXC7TRz7yEfrf//1f2rx5M330ox+lV73qVV0aUdE0cY8kulRS6tZbb6U//OEP9LGPfWxOymeQDZaXJLVvwJiYmGCTPrCuS5YsWZi1orM6SFsUxiw2AbnpgBtLr6bPSToXXXnWuNlJSykoqmICit3Q51gEp+YpAWl1MmjrgVRLKewocmhmqJZSKgmh5jWLpZSunLndyGLyGFgUtG0qlsr+5i0eOpc3EFUgVSAeHI3u1BNkHsmiNiyTEOGnXOn0n6Rw8EzSNES/KVdYcDWXJY8u7SRtm4R6kW2EH7EpF2QSW1ai3YpFqlVKbGGXZ4yo4wJotNpkt8XGGBsD9NPhcoGGYK6tklJq2ThYQYsIGzC4F8fMCfjcDkgwzTjMOhcEG3fVAq23MTyIcT+Xc0c/c15QT2AwAguM7kASUYS+T5unYvJbKsD2Q8xVPVucKGXgeYUFVssi8EUMYqMpIh27IcicUo37jU6/jx+pqZueLKU6mcpehynv1dwae45Ntt3iwyuew/wydiItCivsoG/gWgQeSanngQQ6SUljZnqaWm1YfZZpaHi4t2fkzE+cpVT0/Su06zxtxL64ckXnWuluDKkGjBas5UC8Fj0c1Hji30mHIUn1FzNHZqmDgQSwyTCfSctUdaxNTc/SwalpsopFWlqvsV7VXKzHjur9hMExi7vvvpu1pX7wgx/Q4x73ODpW8OpXv5p+/vOfswufib535GAspY4W8EZBeUFnWUTwi7yiPcsahH5E7Mm13FizdReOAjkzoXxxGGY4LGSJ4OS7IrB7RZKweg8aSSrZIixY4q28BiVUqpIgqiuT0IrwoyDic9ffJOGZ5aHuBWDkxFKecqI8IA6wj+jSZEqIbBPSwIElDLuH1vi5iVZcyiIVhm8hssTPo9SOYkKk2fDdVVC0dM2rqFVYrBuPtqozkGnyRJ2tWFxCLtmixRWWNYnh4ItlXwsFEfe8/KfI0dP8GG2bKMR2ByHnXSr51jeyjeACIUNu47OSYimk00xJIyOxSQCxBVKL3SVKxSDNKjZeEJn2o36F01DyD2IMcwEIKd3cFWM5kFpfcYixtuxlDCe5NXHRNBv3uDTy6lFlQc/i9dqIdOH8dkFGiQTHCKskWNFYHXdxYqvc5M2qtNRDnyr4Llt9za2KHhsTZH4/VF2Z1bEvn9VlDaZx4dPp9wE6CyLMZYViuqWHFln7ddK1XZ9ntETUWispbRKxzBLECHea5BwPwqImpV5gIaX+7geZiGN/TaV7mpx/5SEA9++4+TamXN3rskh+WMQf801ZWOYF762YAya/rWBp3PW0Xi3S8/TVHqBa8mLcdrn3FxH4p+ZLJZioewYGeQDXuxe/+MX0gQ984JghpRC17/Of/zx985vfNITUEYYhpY4iJLnsxG0ooyfCMh38O4uFlG5Tn3qKDlKjNSs2aliMdW1WrXxR2yKuCIO0Ogi5vFXE5qWvjWOWU0S5WNe5MikLeS6n3RIWRSXksZBZMyOTG2UMBLliU9GTBFkhOU0lz9A8m7Zh6ePRskKdqriHQ5GLjRxcyUD7OIhK5buD5UVm4lFqRcEfj91XUza+ca4ZunDwvBFH+7nCPUsK8QO6hb6uX+gsGVlbqiRIHF+AV5eGrj3Uz4KohTk2D7r5BZ+1/R+cLiG9JPcOaGBp56gs+i9+nRaKXrf+SU7oNmN5542468OC/j5BAe20YK+W03Wsz3mlrwOGvBtMf6zDjrPj3oZ+68KvxtdV44RjywALR0C1lMqU97g6UMugkGYthUzVEemqhlYobbgUJ+n3sZA6LFUi5GqSReUcWJT0Cu6DmF8cW1g6RQ6vdKRVSL8I85OVIdpZZJ7MUwdZrf/gsgcyULq5zZn2VQbI+RcC3I7nUrlQZA4+a8S+8AFZPJEtP3MtWL0mjx2UCdbottumWq1GBWRItaY7UkgYG+qhk2jP8NwmtSWj61oDA4NsgGj4sQToaE1NTR3pbBgYUuroQtLmI25DKYkAGb0EgM5M0xWnUGluEzoLmbTFG5+kYsHOYufC0gY6NEgHiza5qZWLrabd5q0JdKXwnUy/3cbnHlWKiJRWCxZSWRaPWmsGzWZUt7nva3Ga5XRYLvKZM46IUSsbAAceJSVYSFl64V7NZkzqqfQTfZBJFojjKhYDgdYEP4cVm8MC1/7mA21VkRtVmUeIDxM0MUAolahFbSoU6+RhgTyXcG0qui2qsAWEiDCZCN9ioIJsqZuu6MadN6Y+YYcftjJIsVDQ9YuIyK/Q80G6Jb0gjJIGLCVDVnWwWsiiB5JzfpHjA5ZRceL5aWlkIj+iddrLSXyKeHDauM4qaK61ZmCCwreU6qV+0giMhHllYBacWRDMXWirSNup84EOfhlARpVyuH0F7eLaVID1aJLFrEKaafttjIZWoL0TOSjA5neoENEIdNAfkJRwX+0cniRYVM6hZUlecF3A/Q7km2asRaOoSj25qKVZKpQxzQFIPCuzi2km3TtNfudM+yoD5PyLaLOOW0iURtAR3nKthQMAarU4KrK6HorOZezh7evkJZUJhBT6NSyrQPYHGojseguykHOfWLZUQj8vAZswNqKHTtG+Nq/znYGBgYHBwGAspRYpdIsAnRtJkuuZGpFFPVGC0bfjeeSx9kzn5E236IizyBC2CEIQt+se9SQ1A+HVYjcOq+sEu8kWGjjR9agEvZrI80OLx8iiSGvNoNmM6jbyPS1OVZc8lIWFstv6SGNJG3TlO7iRZalHRoYNUNTqDX9rT6P5edXsz1E2H6WCR0uH6yFCUIZs57ovoq+Uw9/H5C/t1Dt1oez57QuLrKgIri49JlOhb5ZuSYMtbbNlk40T8ZI4vU3W1sGmFX1CWF4Ily8/UAEspfA4GTkrzqoo+nm0LXq1zJARmkBssZUIs3LCaslzfGu3bOkNwg2r51P8FBfAtHGdKGgO0gKaWMWKbxmnRi2T/y72Xj9p41cSv0yeuIl6YwHmwlLHn5+6LOLYwq/bDTDNckY7hiN1EbQLl8fjZxc50Iei56SMKbgTFlyHqujLlUg9IW12R3OZqFatH9nFGGORx0ExZG3JblKyrf1+arc9ajntzkGLzqJS/XsuLadypM19EKSgfF/JeUfzfu3XekjWAb/nOZ1sAUh0Ltpo42arzXlSdZpi1yNpYypSZ4MiO4L6U+f0SJvo6lWutdpNrIlc8jxbia6rn8u4zLYdjsynAGWChZTUcMTaBISU6M+KJXAK2OIq6TAzLwGbda5foNaGBgYGBgb5YUipRYosi0Gd65mKuEUWFnSWv7jDoibpeTrSRqvJwZvujqVO9LlyEZNkhcH5hxuMnwerUqZWs00VrO6UE11tuUJubxCsRnlcKvi6OqytUylncuHpaXEaPB+LPP+UHJvYlEhjSVDzkZrvyCIv6SRWpo32C06jsYnPsvjTLSZdudGUka8i9Re5J/ieQ5i3Q0RiC65/sOyzIN6arDcW12c7ZQd54GvcaCA3OaqLjy9Rm9r+jkc060AEGaGp21SyQFagn3ox7S1cCIX4uJ9v9Pmy7zaj6rZ0WV7FkJlpJFVWxLmTzrelR79aJUp96MZw2riObv5C17daYjzzhXPwWk3bpEni143ojcmgESBvVKsdIGf75XFv7NooZ2k7jTVc1xiOzCWhZxWr5LShaSRIwoK05FTJE7Yq1dSTWs8EooD9zInkHANLErtJDv5mt6EOoS4silDWyHzkueS2bWrCalS+45K0HudyPPWqZaeJ5BceJ/1ZD8nnVMpFRISgih9tNY1g0Lloo41nbViWCkJSfp+oEeaPqSzk56AQp8WlQkc0ybUWPpO6jKrLnu4ZXOa2iMwnytVdDqF11iFGpcstHx5mdHdkiyvNYWbS+iPxgEkzX2jvydBGfQV6MDAwMDCYNxhSapEi7VSfNQVcL949gU9+BfEARIVe2SffFT75Mi2dPkHS4iKUR3bpil88xC2sutyNXP/EGsYARUtE9MqigaC6vfkaOAAsrcRCVQgC69x68kInois2WP4pLTZUinsebxj7FDdOJSkjizwWK8dilTdYZa3Vm1WyOqfRGRfoWuFU6UKmIbTEZiDs/hHUYbPJ9zIxU6iI/In1stC16nGMhDaoCUL6cpMzY7dZnaJWKtFQpUJFjctFdOGLZ9aLBSqVC1RGZCQLYwjitmhv6CKJE+WgzEr/RN115bsXK6E0kior4txJM6Y311Ep54vUSiStipXw70GXPUveo0Lc6HDtBn8VCI8r4z1T+0VdHlWtIU7YJ3CQpvKOgQVd4PqWhGhEuDjCSSGBonMJtwtb7vl5gdUv8oXy+vpV4XSsLsHy4NlIQ9Vqk4cdTku4GOO9o1qJguDkYipl9efKMjbpBY9s12Gyv6v/ROfUfi0Bk9D32O+2mAIGZT3EJBP32XT33Liofzznlst8iIDDNEQ7RHpSky+WKGVrt2bY2k0t+1zpKyWkn1SvHNwD402St2CblXZR5xwua6kk3pe6cnTpnNlUcFpC6xP34FAoEnBFB7a4qpSpqFjmJ64/kgKjxEB7T4Y2yuPqaWBgYGBw5GBIqUWKtBe51BRQw1RHF8IgD+IWBlET/Th9gqTFRehvV2+pA+MLEEOZT7E4P37EFZyGyzTTTmpVtzeI6bJ7CIRGcUra7izgRO76EsdUo+xICxv+3AK5g8dGFmhx4s85kNelUCxS3RC5EyUBQ1GBhHxI6gJdS44lLBx1orry8xaeiWYqC4KL81etZhZi1Y2RJIK1q478TY7nedSwHWrjFJh1ZqzUhS+uqddrVPeE+x0aHmHCW54vrux18hcitOC+qNHJGEhEoyxp6Nwh4u7LmKe+XXwWA2BVoLGQ0pV9zki6qFstSASZPd5wOmEyN0v7RV0eQ1pDKExLkDtlxTKr3eAIj3haYjj6SPr+B12Ek7SYwu9CnDg20rEbggwDMRjRrwrPBZbe/TgU2dJPQ84zcMtkqxJ8biXXoRLtr1aE1lVYgy44tID2FHlUrogx38kHGMQBC6L3On8kWEwNHBlJoGBMKcEDYP0sXffwzrWg+da2WR+p0faoWKrQUK3SZS0ug4VYsHQDh6lauw1izk1CP+knBENR5xxx8JHDOs/3zuZ3kjPLVui8LMtg0Z1Hs1An+9DTPRnqME80XgMDAwODIwczSx+liCUpIhYZcQsDdcOMxR6TNhoLkcyLC81JGRZOTdsmQRFkP8UKyoYFGZv68wMy3SuudKkKKyC4qHkg7oohwq3fjXO8+LOeNOpXQLWXE+uuiHDpD8hUx9qyJNwbJ6rLdVjGYrpMRelakCMfccgqACseZVG9UqRqsUzNcokPpHlhq4mixW4nhUgkpUheUcYK62qF+0XcSa4kqyD8jD3BvFgaDdplRWrAwXoFlisuxl3hmNEGkVaiYq6yqO0STTebHKq8yrzHHJJ0io4T98ReompFXR6l1pBMB+SNFXERZUtMlxy4qrlh1+0ukiVKRGhICalXA/cgWGMg7L1jN6hY9qhQqfE1eAo0nOAeWwaxi2fn7UuqpVlUkyuGdNRCGfdo3ij9BUJqutlia13MBcNFj6rFwbvJDtRtaa6thjLO7SCRpOs9yuS2m2S7NtlUogZ0loioXipRFdZBlnDHt7022e02ldudICqhdQgs6Sxii1yVcFwwFp55rFfzriei7er3+1bLYeF51ussVzvPGNA8nURgoX2le2IV+o2+NVw0QEvW9skcjdegb7iuS7t27aLR0VGOxmtgYGAA4HB/cnKSNmzY0JE/GAQpdeutt9Ipp5yi/e7//u//6ElPelLeJA3mAHHhgkMLZj98btJLHotaWIiISESDe8nIhVO9XAkspfKWjTe4fWy0sJEJFri+nlQeIe0kQVTdgituA9q3C0Q0GpUDHQmbyRxe0Ok2WXN0CpybHNNtdHOeuuaBKgALsjW1rX0RdpBTQsspou9EHQF3kJscTSAGcWWKO8mVZBUsq6pM0KVYGvW4YQi5w0Tcp9KA8TPTFFpKQ9VKePPrW82EZhyda47iZibdrQaKfjdSWe9Xgxn4mzjWz/M637XawvWYCpiTkzXR+kbXGO/DUib276qWCIO+E6pA67qtkiwZIlNKvRrUK1tMKcLm8moQxi3khSPJlpO1m2LaKjGAwyABqxzP8cnxwsDcZPt2W0rq54N6X/Q5FlXXew86X45NrUaT3PIQlYoVXvhiHpUWUeVqjWpei7WOdOgEZxHRgHNZePZTln7npIT2iHsHa0mcmPHNGl+W/05S32k9WszlIUhx3Wy7zYemJY46Kx9VOPYscBcZQEht3rz5SGfDwMBggWL79u20adOm2O9z7/oe/OAH04c+9CF6+ctfHnzWbDbpda97HX3+85+nRsPfXBgsCOR5ceuuTTN97kUbIHptJUNUqphE+tpowW0uWOD6elINWwhbV4pFqpZL2cipIx3aOxqNqm2zZhS7xPFmZh5cEfrBPOZNFYDN1G91G8LoZ31aEcSd5Mqxp1pKzUU/7HKHybFRwgZiqiXcxOB6GCqHdPEKtJaUjba6KVOvy1CHuS0Y+h2fWe+Ps3RR+ofkJNG2C876Is/mOe5zfyyHRnTUdVvV10t5lgw20HaEWxaPAVhuwB1O0YOLtayMLZftu+qBiYWgM2ee5gPwdCxUCmRZJfICraP+3WT7dlvKGKE109iLI/0iz+D0nHZsdLioUD8OEwLLbLDobpkqFTZ35miJ7H3mJyH7DlxJ8T6Puu6lzf2pFkeyD2HOy0tmDmLNENVji7NGVFzis64FBXFU4vkdvwMiqcd3HSyfJlvQZWvSipFhdgmEa6XU+1Ij06K/ou2Edb5oA93zBmFhvthxySWX8H5sz5499MAHPpA++clP0rnnnht7/aWXXkpvf/vb6d5776WTTz6ZPvjBD9KTn/zk4PsXvvCF9JWvfCV0DwwNLr/88kz5gYWU3HguWbKk53IZHHu49u5DPFU95LgVRzorBnOAiYkJJqzlHDEwUurLX/4yvexlL6Pvfe979KUvfYl2795Nf/3Xf81mm7/4xS/6ybPBHEB9ceNFP9uwOUw1LJSKJSu0uNS95KMb5qhlRC/aAHNmHp/z9FGXd5zOYYvdglgqxLqzEG29khIaN7CeTk8jz5ebNbE58y2leiBMBtk+A23rvJYrmut6dTvVfjYHpBrqC//BXSlYsAs/qYH3w06I8rJv1RLR60kANhAjFUHsdm1+pfuYTihX3ZQpbmZZnpn7hLxf1yPd/bq+FWfpovQP7LHyupIMauz0lE7cxjvPpjrquu0p+nrqdX6aIpCFIKDUiGqst8b5VqKF9WpZ6WvniDbrhL3v2Vo2B0Ku03O4oc7ttpRhnKSNvaD+HJtgbMNWbfwuKnOwiugzOL02iCOHrTS7NMj8PgESE30GRjuhdq4OUxUunH7gFtm/ZdrdfSc7Ut/9sg+lx9zohlIPkjxDfjHfZ3a1jOqxxVkjKi7xeUickKWdGn03zQpRAx7LSAuugXBJL1ts5QZdU7CIBdaJE/ktlco0UlJJvjmyMF/k+MY3vkGvfe1r6TOf+Qydd9559LGPfYwJpNtuu43WrFnTdf3VV19Nz372s+n9738/PfWpT6Wvfe1r9PSnP53+f/beA96SosofPze/PG9ynmHImSGDoq6CoOC6KutiWNPPFdeAIiZYFxHFdcU1LMKa/gbUNa85oIhiImcGBhiYPPPCzLx5+ebb/8853dWvbt2q7qruvvfdN9NfPo83797u6spd9a1zvueBBx6A448/3r3uRS96Ee3tGEjHUxPMZQ8JqZiUimGC7l77cDPuNwc2/Nx6ExbaOxti586d8KY3vQkefPBBmJqaInb905/+NHR1dcGByvDNmzcPxsbG5vSAwcXiyOQ0lGoWdGIEl44O0taRnSCqMF0owWi+SP/u78yReGiY/NiR18zyoIRrWh5s4aSKnKdazIbeLIr5jSD/2uSNBrFD7VNFueKao7eRbI+25uuJWdrIyqF73WzpGXk8162vhAUZyxGsxj4RRb/w6suOu6JvnZlA1q9D1HlbaL1EPVZbMHYCpVMu2mLmSCiQtgw0r/2cNMtOpEDMJ16js2E37hMKSx6so4Lj1tuRddzAIp4fdPPaFv3cME9u/Vk16EDdxgSSDzVIoUsdWbLVJWZby1gWib5byRQdpPB9E13Ry6USWUohEUnvY86qxkufDu8plmvmZI9+ZRj3CxnpiX9P5ItUD93ZjOeaqu7+FAYAsa2IKLAAuuyn0XXV7rN1lkgB+k+dy13CJhoJ6Q7P8sr6CE+8YXoWtg+SkWgBR9aDCdL5lFrL+aAdx0kr9hNIRJ1++ulw44030t9oGICWCJdddhlceeWVDddfcskltF/75S9/6X521llnwfr164nYQuBebnR0FH7605/OatliHHy485l99PvswxbOdlZiNAG6c0Pgt3SpVKINK/4sX74cOjpswdEY7Qt8afdkc9CTQesGm5BSm6bXnI2XbQVRbxmRgZ5MyhZ3Fr7n76+VS1Aul2nRoMqPZx5MQcK5KM5ZcTZTirx5gJ24d3Zk6LfXIoedGtuRocCoHukrXDRXLPqhOhJO7V3LtEKJfnsRaN7uRDPuUTORnxydF951StY+ZEHDRdsyeX6z2pqvJ0kZda5ji2Ry79Coi6bAI+9uffHH8Fy/MKl7Hbh9mSKTqeuW74/aeZD0a9p4iDpnmvAji5sJt9/gmGWueeaJKOcE07ET5RiUpoVthJtQkXhTtZ9G2ZTt56SJm2iWTwo20JGBnq6cSyrI8okuYBhFjdyWdcDyj+OL6+PMghJ/3HrymmMCQPbeqCuTU4dUJse9rVIswnS+MPMeYPXsuGk31LdhH/O8nvvOb+xR/aUSkMXqTWco6l0KrbIdkfi691mtDMlqkdwZUfsJCSk7SuTM80grzEoCatjbljEJ//ZwvictQKHvRArZGPCpdyZ3gD+s/VmUVxRo93O1rLuf04pk1of0mZO3aiJF5K7n+sQj31hnSJBR3fHznM84kPVvfhyje2WpakElkYIKWFCsViGP0YqtJJSd6LjawGeVi/ZeJMB6b64C91/3338/nHfeee5nqF+If995553Se/Bz/noEWlaJ199+++1kaXXUUUeRV8y+fTZZECNGjBjNhvGb+nvf+x6ccMIJxHg99dRT5Mb35S9/GZ7znOfA5s2bm5PLGKHBTpNwYTC/tws6Our1khoWxSg8jIsUWuDNLFhwgdLX3QE9uTSUyyUYn5wil8CGhYSFhGWZTPNVi4XINpcsfwzlPEC10JB3r7pxCQqDBRG/yVNuDtH9pVywfwtgC25coFEdiYtcXIAW87YZPWk7GJJiEjLAvQcNJFH7RuYO5tQZhSvPZO3TS8G9hWmBVEsFqJbyvpufMG3dQMxx9URRt3B/o9JiYfUp1EXd4p4nYloJGVkj1hdF/XKIAW7zo0WI+vT3fL4IxXyerBHcvsyex9WZHdnMbnPm0oG/tfMQgoBqN7j9BsdsUMsZQ5LDa+zUtYEHUVFnTYBEjGRObGhPEzdZ9lz+vWECnvjAeSdh/5ZB1u+QvE0lavUkLr3HiuoDClZnnLA/O5SoO5DwGKfG5I+CHKwrk9M/qEwOMV0qF6FULs+8B1gfqpZm+hKfF/beqRb18of343XYfuK1Bv2V6i/tWL2Qi1993+XnD979re467nlSktCrPXS+D9huWvCpK1l5ZMSrCtL6UPQpk4MgPJjB9Rwd0MiAaTBy2uc92fBcoa75MqCMBJJxSMohjN9p2EcSln14dgC8X3Sxd+9eIuKWLl1a9zn+jfpSMuDnftej6943v/lNuO2220hv6k9/+hO8+MUvpmfJgHrCaAHB/8TQBzoqPT08AYVyiw9EI8SOkWkYm27c33gBNSI3DU04ruD12LBrjL6P4jkx5h6MNaXe/OY3w3/9138Rg4544QtfCI8++ii89a1vJTPQeFJqT/hpQdR9j/79DLzFBKdPgBv5PIburQF0QJHMuymKGrdwRB0JXHWGXSz4mmfz+aPTQyxfSpl3Mb0oxNqZa0xD/XroTvjqGlkouG6HZZadoPpqREi0jtx7MNyzW2EekdCE6Fh8P6ENoFWGlKWIqhYRUCQVo/Fgu9VrTXjo0/jURV3dY39pktWNp0aNhxYVc1vBzRW6vYj9XtSKM9HBYf29XCrYosu4Icx1NPZ7LiAAa3NePNl+TrjNwGy6XphEhGIIo6EXmcaVkB+3DZwodxR9k9fxkc3vEj2ohvkkiMA7X0YTKPRxarVEgzu1dN6jaKyO2ymfJomZK8YazVkzrnvKvuilGRdAsFr2jqkvE5LkOCXZ0RsxymwWXSdr3HtApl8mvgexCLSZtNNzKlRONFJ7lWcIikpyZj4x7a8e19eJr1O1SqwNufulWmGsPRjpKEaX1dH4a1ZwEp+6ChRVlmsz7A/yyL6NfUq5lpGJoKMeF77HAclEBTS1ExueK9S1WAdZjGwrvAu0gXVCr+/mvcMPJrzqVa9y/43GByeeeCIcdthhZD117rnnNlyP+lTXXntti3N54KBQrsGeCdToTcDhS3pgLmLn/jwA5I3c7vZOluinv6sEi3vr1/QThQrsmSzC8nmdoZ8TY+7B+G2MoniMkGKYP38+/OAHP6BIEM3Ef/7nf5JI1uWXX+5+htH+MBLgwoULoaenBy6++GIYGhqqu2/79u1w0UUXkeYVmqW+//3vh4rE8uRAht+pWd33TMySWWdITh7RoqKzowt6cjnoTCUbXbxwYZ/JSjfUpjCyCMJ8Z7oAsl3KvIvpqU4fI6lflfuL6lReKFc6k4Guzk7ppjmI9VGdBY7sNNknEhpfTkwjk+uEJBJFTbQyomcm5H03iFsgW/xiPfi5aHrBy7XSy11DB6gPUiqXbDdpyX182/s9gwU4GJ8q0G8Wwaoz1wHpVIYsobwsBPk65l06WB4QjDgwdSsMY/FlBIkVUZ3VhiZ8x6xeIjOWfiHdMOvmAGeuqybRjQe1WhINbYj/uZaFwphtmE8klnJSsDkWIyxKrPq0wM/T3L9Z30bBata/ZfNeg/sSS5ME2h2Bba9nSvqiVtvoWOVooK5MomUhjrtcDro6O2beA+waiWVj3fs701GfP5UlD/bFVM5xoYL6+cTU0tHj+jqXMNV1us9jpCNqnpla5kXUbi2xCo3YfVSWHrnMcm6WkUKjrgMfToRwI57LWLRoER2miXsd/HvZsmXSe/Bzk+sRhx56KD3r6aefln5/1VVXkUYM+8GoezFi+IFpXWMwnxgxeBi/OdHPGAmd3//+9/ClL30JJiYm6PPdu3fDy1/+cmgW7r33XnoeMvc83vOe98AvfvELCnWKpqaYj1e84hXu92h2ioQUbu4w+gSGO8UIgh/+8IfhYIIfgeG3KHZJFU5bAk3O0ZWvs7OjzsUravgSD3XuXAlaWONv8TtVemE3mmzzguREwyYG85RIQ7FSM3YPbKrbkyptkZD06ydISOEpfhNN57FdejtzyhNiU2IuKiJESWpwC+KghCfqsWQzWchm7QiXUjjPQWM6r2egm2W+MA2TxSJt7nEhQLppnTna7FoJO8qZClTHePrNIvMJBI+rfUP1ala32qRikE0Gf4/E3QmtNbIpbB+9jVhQN9+WkXLOmE4kM1BLpCDBzcdsnGDbk86Mhushm0vL5F5su+vOuOlxbnEygiRg3uk39282ftC9x2sMSfuR3/wkzIFiGlpt006uqbI6FNvEgyBwrU4Tdp2nHdJU1tf9CLuoNe+kcEjHWiJjE61OXrXGaAvbLWhduPeR2VyEBJqkD4jv0YY8S+Zf7XJp1HXkhxNRE3ltBlwXnHrqqeRmx4BC5/j32WefLb0HP+evR9x6663K61lQK9SUQt1gGTAyH4u0F0fci6ELd7WuksONuaqDFsbHItu2bSO/Y7Q+Qn9idN/r7e0l/2P8m0VxiBKTk5Pw2te+Fr7yla/Adddd536OzPxXv/pVCm36ghe8gD7DUKbHHHMM3HXXXRRZ4ne/+x08/vjjRKKh/zS6GH7sYx+DD37wg/CRj3yEJveDFcbhr1Um75pm3c5D5e4DHvolJi51OuHiG9Lz007x+d51h6pWIZNKNaQf1D1wVmDSljrwiQLknpCSh0nNuP39Tlhl3zNXGbIaqdi6JUHISN4Vpe453DhJpmzBfG04fQ3dEXKd9ebLSkFfCpOujgCHVARG20zXgCwXRd2RBlcoWX9nZWKuXwwJFMO3N8EzaTRB3yOIuw1/j8TdCcPEp9GSRhM0jst21L1kAkPXG0bdk9SraZh2HSDxhG4+slNIk+exuRRHBpE16J5HZXD6gMotzg+y/qWYY3XdnUxclVR5wnFLaQjzRBArzCjcUZvi2sq1l/j+d8vrzMVl23PcsU5LNfYNdA1E7UFJZFad93AkZUnmZtyLHUKj3d610rrQ6JfufViOdCa6/uI1Zp18oaQLktdunmUSDhG2sWys+bmwi3muq8sIXaTbFVdccQW84Q1vgNNOOw3OOOMM+NznPkfR9TAyOuL1r389rFy5klzsEO9+97vhec97HkVKx4N61Ae+7777SBOY7bPQFQ+9TdB66plnnoEPfOADcPjhh5MgeowYMWI0G8YrYZzYcBLcv38/dHKbJrSSEln4qIDueTiJipEjMPoERnfjPz/66KNhzZo1bkQJ/I2+0bzAH06wqH312GOPHdTifcauRbom715WDaoTrIhOtlSWF56neprRfPzES3OptC0fVZtxZ4rKPXC24VV/pVIV9k9Ow9R0qeF7JKQKxQKUS2VpH3NPSCvlQO3vd8KqigTkWo2EOJ3lXVHqnhPGNcRkHGg+B60Y0Zqxr6ebrBv5xb3U0kyWB/YsvnnRXStpu4KyNPAH+zjWA+sLXn1H+4Q8SJ3y9+hY87B5C12CStO2RRBfXBzHSQCUQKkT1NaFpF6bEUnQy/rM5HksHbzedfklu/uEXY+OW1xjkAzOikr2LpD1rzDzf5D3TdRtI0bMi8Dio9mureL73y0vHg7wQusqt2mPyKxI+KPlBv5uhhWVG6yhUCYLZZs4TUrftS2x2uLyJT5LOh41+qXsvkjmUi+IIvseFnZBXOdVkLrk+riwi3kW5SPaxoKxSbjkkktI3xe9PvCw/aGHHoJbbrnF3eug4cDAwIB7/bOe9Sw6wEcS6qSTToIf/ehH8NOf/hSOP/54+h7dAR955BF46UtfCkceeSTpB6M11l/+8heyiGoGxgtluPOZfVLB6xjtg3u3jsCD2/fD3Zv3UXt5zaV7J4twz5YR7wSdYb5j/zSlt33ftHZe8HpeCP2+rSMwPOHo4Ppg12geHt4xCnsmilQmLAemN5Y3F1B/aMco7B5FnSuDcseI3lIKJyh0gxMtjA455BDYtWsXRA1k81HHCt33RGDUCMxHf3+/MqKEKuIE+06Gg0W8jzRinA2kbPHod8LGn7RiWrjJFy1FGnhP1QlWRCdbqtNRz1M9v2dripcmk/aJbYXCUSfdZ/Gn/Ujg5MslijrDBD4DQdcCICJ41R+WZ7JUgWyqSmWqsxLDfkUuIQAp6heO25+DmdN5PAl2CB0NsFNh7LcpXH96uPWorB2YOLRtAVKfL1PUPYcW1gHTMhkHulYqptYssjywNNBSCgVxdU74nb7i1Xe0rVGCWORo3CO1cENShZFOnMYKjWNcnLNxZzomm316z1nZ2VHM0N0ymPUnwt4gMtdOtL5IOm2P1huOmy9tHrkgD9g/6sTFZ0TL3baQ1UOYugnyvom6bZw8JGoJqFkJSCfDa/M0w4pOS7TfqQtXaF31nkULKct2L8M+wFvoMGs97DtWxaKDGnwvolUpOwxomA8M3mmidXKHG3jBdvduudWWx7PENYk95yCxnbQFug3WMpHMpV5Qtb1kLm22JRq5sJOlmM9h3kFgFaXCO9/5TvqRAcXJRbzyla+kHxnQyOC3v/0ttBJIDiCKlSp0mQYAiNEyVKoW/bh/Y9ANxWHNrv15X5KR7TdLFcsli3j4UZSFSg16cOGPeqZVi0TQl/R2+JaDkV87909TeVB+AzE8XoB5nWaW7/lSFbbtm4YV/Z3a5Y7hD+NZAE+/ZOFB0fcY3fiiBIrmoWUW+j13dPh3uKiA4n1oGsuAllKrV6+GuQ6ZebeFmxirBhZFXvF2b2iI2MK5paWSuEiaIWKUiwTVRtFnAynm3dT10HPB5rd59fiezxd7Bm5IGEEnAgmcPOW7BNmsj3vWbEQPClB/SLDVLHxJpRu+J+HUXJIIKTqBF6L00cIWX1CGBBtbnDNCStUXvBbO9B2t7xvzJUKMDCSOozAL9Pq+rehr3PhDKs7UrcfIFcjJA90jujdqED1iX/HqO9r1FgUJS5Y75bpoXQ2bPEw60wlQq9iWYI0ZVpffb0xG7Rorez5aDGEUNbJqQzdFUjVvjFCmOX+49WNV7LFCkdwaLSbqIsehSyRFf3OuURGcPPjPfNq6oS97bUqjIm41CUcsdtJKNEXANag7n+o+/rCEvU895yARznUuKcn6CEbedfqE/Wy0aiqCRVpkSejoxCAkEgsbg3caI9TwUI1ZZ84WuWf6LBpT6Brn1rV+G3u5WxOR5JCMgdHsOcpgbk6mNFzYZzPPMWKEBHtPMOHvgwVhy5toQw2qNsjCAQHjmfz8888n32UGjIaHvsjXXHMNXHjhhZFmDt3zhoeH4ZRTToE0he1Ok5j5DTfcQP9Giyc07R0dHVVGlFBFnGDfHUzifaJ5N/2mBU3F3x1FFrGFM5XHE1DXlFtiOh1WJFiWd9H10Mu0vRluMmK+2DPQnUv1LCRwOkm4N6SWWbOiByngVX9oHTW/pwu6u7IN3/tG+wvousO7DgSNcGdSj3w7R+1WI0uPHy8koF8ukSukrfdh/vxW3SPrK5GMvSjceyXRuupcUNi8haQKRu80jUQVxZgMEzWKfy6xI467pSxCGZdXr7nZrR9MiLTEbD0uuz1q8uAHSW7u13WjkYnSK9oa5/hCqeIS0Rj8crqMFqrmVaaVH4P+F6VLk+ydF2Q86twXZk5r6COkzTXj9onfdaZSkEX9vQTF+pTPBwbjhxFq6I7sF6AkzPyDc+/kdJHcBHXWLTrPwvoitSaJiLxfO/Dpu+sdfC/MdVHvMJEUY8SI0TRYhoyPztWJNqOEDjZS8ICylEKRPNRkOvbYY6FQKMBrXvMa2LRpE4UN/e53vxtp5s4991x49NFH6z5DET/UjUKhcrReQgFE1LJCcT7Ek08+Sb7ULKIE/v74xz9O5NaSJUvoM7S8QqIJy3AggW0ucEHTkc3MhI/mFkAW/rZqUKlWaBGPVhfZVJai10Cpol5QSU6jdUVooxD7lllfiK4HQQVFw8D0FBYJHGYhFUrINujpoIYVgpH4fUih86Dm9/V9SOGGEmE98iLAtsgzbjxTzelD2I9RSwNNm1FIHK0QE2iGgb9TkKI3qKLPKdo3iLVAKy0MfBGFi4YTravOisedG6vh+3sUJ/ZhLCDx+Rg1k29/tJQioTu1tRJauqjmZvdvdG9l6frlUfK9bK6rm2scsqJOlF6zrVkUTAw6YCJc7wm02sBNMhKTVlpqISYrM3FyGqLUOjCxOPQU06f2rzgu0nrPUqUlg7SPiNY7yQRkM/i9R7t6WWjOErBv5StYdwlaT0Xhrsa092YOs1J1azSmj+UHd72TcOo/qgOqFksDeM3NMQ48YB/X1ulT9D9GlKBRRBBiRfe+WS1/i9PHOqLpxJmj8G+sNkth4YXf8/WIf6NbH/83/z3OVewZOmVghH3VsiDjuOoxsGRZu/Jp8n1DVRfseov7TXMvGl47ifP3soAvMx5GjYUQP2P555/Ppyn24XIVvWwS7t+yPs7aRBXUKWi/anafbCoptWrVKnj44YdJ6wlF8dBKCgXxMDoeL3weBdAdkInwMXR3d8PChQvdz/HZ6Gq3YMECIpouu+wyIqIw8h6z7ELy6XWvex1cf/31pCP17//+7ySe3izxvtkCLlIw5DsOYuxg/AKdtB3YZFKrQqlahnItAWVIQhEP2UAeOS6qDZdSv0ITss2SSIhJF9ZNdnOT1ZcXOdhsrQtfosunPiKPFIiWPSgATFo0ikW9pnukatI0IUd105Q9g/JO7lHM1SuaSbyhnq0qCQijqDakbFcY2x0ULU7Q3RHv8d4ci+0bpC3bJXqV0fzjtaEixiAnCFPXoFQs2xs7KyWNJBYpmqE7xVxf2CJetFRiZQ4zN9e510lc8nzKIIvWVjfXZJy5wa0XdRsw8pDlNZ1MkbYQ/o4MtDnGjFdnCClHQ0urzBFs7JUEoWe+G8c/kn12FrDhNCPSKtLyjZzI6oiszLh7JWPPK5qt7nuxKREKObDIqjPu+dFAFgF2ptwWZIR28ooii4cj2LI2wauwQmtjaQDdeSrGgYG7t4zA6gWdsGp+l/eF2/4GMP8QgP5G6ZRHdo5BoVyFMw9dqPXMB7ajN41NiODG/+Q182E2gKQClv+QRV2wfF4nPLY72iBaY9NleHxgHNav7odOQ81aFOlmZM0RS3tgy96pOh0pHg9sG4XFvTk4fEmP+9ldm22R7zSdggA8PTwJRyztdfWXUBicoSfXuF4vVWp0zfEr+0gjCn8YjlkulwZiPBCfz817p2B4vAhnH7aQ6nrNwi5Y6eg+8c9CbNg9Rr/3TpZg76Sdf7yP5ffYFX3UZhsHJtx6WdSTqysLiqzzelZ4/e6xgqtfhekxHasdI3n3b6yvhT1ZOHJpL0wVK9SnOzJJt2/iM1GAnV2PQA2rgbFC3WeIHSPTVF/i5zpAgfZNQ5Nw2iHzG8i/2UAgZTl0nfvnf/5naAd89rOfJb98tJTCqHloxfU///M/7vcYUeKXv/wlvO1tbyOyCkktDKP60Y9+FA404CKlM5OhxQuFq+cWi3V6RzUL0hYuVRNkIYULIVrko/UHzico9CtqkISEKXHgueD0CB/uKWLeohNAL3Kw2ZYo4oK+wfJJsmEUBeu1yUNFfda1G/Y92qh4u7TwwuWuYD6dJkdP3MnqSHdjg/Yc5UoFhWMgk4j2dMHNB5J3qTTkyMLAv2+I9d0uoq/N3jCG2lCxKFMovoxVhf8mazRvbbGm5y8I+e+6vqCWVAYgY5aG59zMj3H2LJ58kCfY8Hwa+9UyF61tJlIafZ/iSF6feVqc57HZcpkM/daCznvAffc5ZmZ+40kss8nGPsr3EqZBOmJoIeeQlEHnBNl9snLJPvN6pk/dmLwXmy1ijgdKPenoyRLWh/G9y/JP2ohgk6C8BZVYzlotQRZcuMbDdzoC09E+TIqCGJ8Na6q59B6K4YmRqZI3KcXYhul9UlJqumTm4slICISKaGkFGOmD5UdSKuq8TOABGwqBl6vGpBRvbYRkiF/eUKSeJ6UY2H1I9BzhxBjLl+vba7JYH9kY8bW/bYE/PbUHunMp+MrrTquzEBLb2yswFxPPZxiZLDWQUmJeRbD8Yj75SH+j02UipQrkWmRj/1S5QWR9/1SpIU28TrQg2zdZAlg6U74Cl64sIiASSDJgfwoKLBOz1JozpNTPf/5z7QQxnGgzIUaUQAH0m266iX5UWLt2Lfz617+GAx34wkWNBRfcaWUyhaHgnUmqigvVNHRBEjJITiEplbBoL5PEiE24wWGi1OgOEsWiI8AiRrngNFnw85sF8fS2SQurBnKwhZYo4oK+wfKJFrH1J9w457KXdkdWsUGV1ZWiHerajUKMp+3IZq75QSPYPehGRetGtKhAnTIM2xShq5yqjnQ3NvgOK6HVV9WCZCrajZCbD2onfRcgsb7bRfQ1qg2j0aaCbaiwn3lYY7hRppJpyLn9UoN8CAsSqneib0VFajLXl1p6hoSICmyME9HhLAyJxAOjuZOP1sbypyTDDC01VCSGst/opB+R8LlWW2jkR9utGvOC8xOmyQhWzi2u7OiGaeksyepAN3KiV/0p6oZvL0a2zCkX4wDg849tgZbVfEAN2XWFUrnBXdXoMCkoMc73eScNey6zDz29+pIsUE2riKJWRl+MERHaQbm6idCKdn4Q6VINjOWJkEJMFauwfWQa1i7s9k9X+iy9Z0YN9jTVYxnHhlORY0zW8J0fVNeFKemMKyS0BbRIqZe97GV1fyPLp/LRlUXmizFLUC2MubC/uaRA2GBUGFzoVByWVrQcCErkYOho1BZC16RMrnEhItPCUC04ozr5jdpMndPRqCMHWxi5hshHbkHvLlatGkXAI90P1+3C1k1BtzBGnikXtAan4Q3tplHPdZZ81ZJtUVEtkZZSlK5yMjLQZGODLxMU6/UNUx2g35Cljo5IsjBWZJpUochWFM6top5O1lzsuwkbRqNNBdtQiQS06rooYFLf5KaTsssjWEM0y/UFxZpxI4vtIBWF9so/G+O88LKOrpQqnzrX+s3vQn5V5L6y30RhTRilxZtGfozcqhXWsNgH8DQU0/J01feCrFymY4ldL7jx+Vr5clpkPKHRSqLBVHMRxx5aNaFrKYu0JQaB0HHR5D+339W2pVQgS/Sg/Z/v804ayI3pzM1i2zaMTUn0PVNL+QOVuDyQoCIKGj92t/hwIKIZ0VmbDXQxe3TXGJy4ah50GXq9+JWWEVIM+BwtUsqDSWkVyWLalhipPCWQkrp5tZpQpnajR7Vm6RqKFTs/v/vd72D9+vXwm9/8hqLe4Q/+GyPk3XLLLc3PcQx94EtY5oIn+5xFvqHoUzkn+lSmceGiikLkFzUqkaIwyFUMIS27RpKu8jRXVS4/iPdFES3Lqwy1GlSKRZicymtH74k6cg1brObSqEXkLObc+xy5lIRzjVcUI1ldKdqhod006rkucmEma0frQ1LEpH0CRi6T9TNsK2wzjLxUKVfcdLEOsS6pPjWJMq+okHUiyUwPBBvGqxxCP6P846YFrRw1opf5Agkp9hMCWA4kQqvVCtSqVaiVS1AslowjcPpGNJO2O4oq16J75Xr1LcP6lpYnSN9l9xCJqL6XiTWTS7Fp/nnLKxyLaDnLnk2qoKnI8qk9vweJhMfnIQrrWNmcFjRyosb7jI9067u5lqRnt7vtoo9WvCwdfm7ynaeijBQpaUdxXKiiqkYd/VQJTL9ctOUMnL5brZSgVCxASTWWFCL8eQpc4REh1qAu8R3Z1ZFValUq02R/I4Ksn/g+7/QxDF6iE21SbNuGOVCyhlG2s+F826zIyzHUQNcjdCGr5MdhujTjqlWs1CBRLcL0dB7GC2WYLrIIqhZd78KySP4C3ZmmJkZJ4wdJ9WLe1vbhgX1kolCuc5nCz0anS/QMLRQnpR9XWb6wD5amoZCfgkq55LqJoZYP5g1/EPjbJlvlsErTVH6sBy+XM1p/lqpQLOZpvqlPxAKrOAnD4wWqZywj/qC3A7mDoTvXdInyje5n+B1qTSGppAuR/EAXtvf84CH479s2wSd+84RLBu1TuJPxbmVD4wX6URE0WM4Nu2xtp0MW2i6dD3OaTTL3v4ozJ/DZxPLxfYiJrmMdYP9ATScVkpWCawmOBzfYdyh/NQvG8zP1huUV2wqBnxUd1ztsE949ETWnEMxFD/t80TnYYN/X5buK7TjzDPwOf0rTcv0xzC/rfzKSDvsj+x6B/cQdk1y/Z2NWTNvNq3MtPoPdj3Uu61f4GV6HzzXd9xofg19++eXwxS9+Ec455xz3M9Rx6urqgksvvRQ2btxommSMVsDvdEl2einTDVGdsilOjvnTLrSQwvTdTUJdlKgQp9dBLUNCWks0nORJLLFK5SLkyzVIpa1A0Xt0zNyRKqkCRmVzNIVkkNUvW5jq1HmYugp6km6KCC3f6nTBrAqk0T+fOyE26ae+lj6mFnx+Wi9hLUGQDOR/RyFyj32XxgPaLmeMLBx8r5XWlx25kC1bwrqLkJUnaiJR3oV6MaxvbVFpP7ibMySIksp70aKC6SJI3Qb88s9cb9n8Shtb7m/dfNaQEEKlWSSbc8Hneb9IeLJ6RlJBo650wKxfsF7TvAZDEwWig2gy8qB3LvL8yfqDB17TCGHk5hS2vEK/k1mwylzSmmX50jBHUPmQJHEIWYyEyjToEnoBW5hVE28pxYubu23RjL4jphn2GZL3MmszRmjK5lfZ3Cu2NWk11uy0M7hOaoalfIyW4cmBCdg9WoCevQ9Boe8QOOGYYyCbTsKD20ehb8+DdM1jKTsYFWLT0ASUqxYn1GyRcPNkYQJg5yBMLloP2andkM0Pw3HPvqjuWRsHxmGiYG+MT1nbT1qc/Ge+4s/TIwBDjwEsOx6gs14AnaVzdt8+gMkheGb3OKRznbBu/d+RkDcC84nnM2cdupAEsJl4tRS7H4DukSJMLj657mN8LSIRsbDHfi8+s2eSNJn6Bu+iv+vKPLodRnZtgs2548FCDUkJUOgbf0Qcu7wP5nU13oOklRe++tctbn1iubfum4Z1i7rhqSE5mcfw5GA9iYj3omYU6mk9NTQBn/jNxjodpdedtRY+9quNsHFwgsgQ0lV1ysNj695pOGHVvDryDIXCeaDgO8OGXd6C8thPq5kemFp4PNy3dX+dhhOfP3w9snbntaKYXhTiCaHMzwxPwWQBA19ZDfli3/O4l3s+AsdMqjQB3SOPQWbRkVBOL6j7ns+vDJhfJAfZOMA2QdLs7FVZgN0PQSqFmm29JKKOP/x4wWdjvs9eWgXY8yTAivWwYzIFu0bzJEjP6pXvV9hu2BZrF3ZReqIgvh+MVznPPPMM9Pf3N3w+b9482Lp1q2lyMcIArddws4QnoCkPK5cAAsC+bgliBB3FQgGtJKooDI2inJlM4yaBPScM6aFTNhPiSrxWcW8D2SCWIZGCbCYHtUTNOVE0Lx9ff0nFCwh1jqq4UaaFXrJ5bhftDDL/N7DeUG12nc12nS5YBtuW34Sb1ZnvJkrSbzwX3fz1fN6x7Ph3SkEoS1wk5BnG3WvwDTCfpzqR+1oSsljFuLmLckOpoXMTVlcE51gi18COflgHjT7hS4oF2Wi5+llpTz0sJMM7AfsyxV5tvMAv/2LeNPIqFd+nFSQSUxBynvcRWpcXwiakkulgcwSHyUIRxgolmNeRhf6ezjmxWa4jASQBUGbGow/Zw88h9M4ztGTl36Oyfie4osuIuAZS1+TdzrsmIznJzYe2VQ43R1B6eB1rU2tGg4604WxSz4voxrEnBjrhiUC3HBH0nTqyFK2oRH09TTI3CLzmV525F9cwBcuOopm1ypDLWGTdJNUWO5DWLQcwEji2HCsUL+shBBJSdSBrDN5yqgKpipwA4a1SGEkhE9JWAi0hEcyKkAMjYqA08+xKMU8WPkJ2XXhaJOEhZ1VuXVTgrKc881+etq/NmluKFklep/HdaWvUyfGp3z4JD2yvJz4e2TlKpBQCrZDufGYfnLByHixXCIoj7ts6Ap++9SmaTk9a3V8XwQ6B9x+zvA8WdGeJREGyZfdYnoTFn3/UkrprWf2I7cCDtw5qKG8F9X7r55BUedJTID8Mxlk/CjmWEuWCJ2uD1SHqTk064vczf1fq+nuS+r+cRHXHLVqSOfdMlayGMcv3H3YPs7riLSV1YLzzOP300+GKK66Ab33rW7B0qS2tPzQ0BO9///vhjDPOME0uRlSWCEx7R6WBYKGQuf0yr3otpHQXRyIR5KRNC6NSyV0Y4flgDfWkkIPiibMIF/BkKVRzyqQqf7UMxC3Q45KRnDDqkA3pXA6cw49AwPpDkWH63YaaCaYaG02DaM1heq9gRYEboqh0wYx1T0wW3fxGnUWPU0WQYy4SiSYv7Lk8obi1+5RUCpoS9FuDcA07RpBUDkOm+W7MgrSHwT2hyi8+R3Uw4Se+T1pUWI8GY4EnHEK8M1B6oIwLzEQVMrmOUPMUlQ0PAkS3ormyWebeZ3UBUKgIGu99dw7pMCMHdQ6PgsxRJhZAvFsylrU4ZZP45E6Wrh8jjlbbDMFa/37DdZTbx4n09CHGvLQDI+g7zFXQFUBv0NfTIHO9CD6P77zmF525hyzpEwnAbVKpWiWNWt33Zhxd78DXUErw5EPkwjrRpBdEWBtdpn6zYQDWLuiG1Qs6DR4GTYb9AHRPZIRUX2cGXr5+Bdx85zayhPmH9SuJFPrYLx+HHfvzdM3VFx1DVmK3bhyCM9ctJIIJgZba37t3h5syI6TWLuiCfzxtFQyOFeDFxy+ncX/Kmvnw+41DcOMfn3Zz05lJkSUaWhx1ZWfmYaxydGOcKFbgsMV61jg/e2gXfP++HXDmugXwzucfQW7EXkBXwT8/tZdIluceuRh6cmki4rBeTl4zH/paoR+cSGg1fNO6haRv84QgT4SJl5oOC2NS6mtf+xq8/OUvhzVr1sDq1Xaozh07dsARRxwBP/3pT02TixEGeNLJWyL4CaTixooW04abI9lixNkgVDA8cXmGhBIXRvjMJC7iHS0p95kRLuBpg5Cwy5ZUlR+/w0WOzobGxzLAJEpQ2AUT1R9zDVRdE0DsNSoyaaZ+a+TmRhG2ZkNQNAzJKVqcQIL0j7QsEIMiisiPvHUYboooSppHX8HPcbNiNdmaow0tRtwxgvWFm14/azHV/QEx22K7JvnXnrM8yABpeYPM+fwz6F0XkBSEBNDBKfIBIQXmezs6IJ0qQSfOdXMRYefKoHOIznODpG9SHt41GfsVElIYTjKhFn6vI1g58on1cXTHKxaL9DnpIYruvWxMle0AHvRON4iuqguZALpx/fDRNumwU4i2S6fr5YaozLK6M1kn4f2ok5Wp2K6A+LfuXBlH12t/6As5W07QLPEGM1KKTyGMlitmRfY42WfsMSzolwzifd+9Z7sr8n3aIfNh1bIPmDoAAQAASURBVHxbU8kf0dIPsiwj6YD5Q6ye3wmfvPhEGERtqDu3kQsauoUh2cQIKQS63jH87KHdcMOrTqa0b7htE7l8Ibk0vztDrp1oafXRlx5X7wIPAH9/4nL44xPDJJ3B8LvHB2H/dAm+dec2WDW/Ez7y0uPo86HxPHzg/x4hja73n38UrFnYBT+6fyesX90Pp62dD9+4YyvsmyrBv5yzjmoMLZ9+eN9Oaoe7No/AEUsG4cITlsO2fVPw16f3wor1R8Gpa+tdOH/y4C748QO76N8P7xyFl560Aq5zyrmkN0f1gnn74p+eIffLt5xzKHRmU3DbE0PkZojXY76wb5OBsW6ovTowN28IDDavipAON530eFIqwp5pTEodfvjh8Mgjj8Ctt94KTzzxBH12zDHHwHnnnec5GGNEC/uFbxEphSLHKsh1GQw3R7LNh7PBQEKKJ6EaFkaillQT4HdKl04mydSwYqUo6kEyqGVAgEVQ6AVTk07fjaI5ecDtX9WaHTFPZaXTbESpeYXWhz4WiKHJvSg0RHjrMHoV+FiKOSf/s9YWURBxYdEqazEBXmMsaB9qcNcJCJGE0p6zPDa7kUVFi4jgRHI5m0vIo5AaIptNQTbrc6rdDn29WXOl7hyi464XJv0g5eFdk8liSSBe/NYXFEyi3soMx24Jl0DoHZqRry9oTJHVdU3vYEwCXoheJt4tcxU0rh823ljb8e8nyrft8kGyETWbmFPNV7J5xIvwDqqbNtuEf4xGJKwypB1h5FRpDJ7cuAFW5KahIz9DxnaMb4Uny4uhPD4MR65eBrnJnXD/hj76bnFPuo5MSqCFYdkWqt69eztkpyahku0FKOYgWZwAC91p0x3wxKP3Qd/yw6CGUcQdbBqegP/549O0Qnr16athaWocHtiUh0qlDF19C2BVqgzTY3kYr4zBis590JMowOh0GfKpHrBqi2me2D64h7SQGAY23Q9T050wVO2DQ/sAOorDsGVvFlKlcShWsjBd7Ibdu7bDVLkG3fMWQ3VsAKatNPSO2/pByfIk3PfQThje/AgshRyUIQ2/uPtxOK1rIQyml5Nodia/z33e47vHYWlHBaa3PQAT+aLtptVVg8zUbrt+0BUFErA53wnjA0/DUYcfBsnuxW49lzsWQjXbC6P7hmB8optI+eq+LTBudcK8RcuhY3wzDG/YCH/eNw9OOvYYcuf65SMD8OCOUUgnE/DOv1sH2cJeWNa3CJb1dRA5dfXPNpB1I+KkVfNgYKwAw5wIOFqB/eGJYbh/+34SMkeLpMvPOwKOWNILj+wahZNW9TcQUoglfR3w7vOOgN2jeSKXrvrxo7BxYIJ+clACGB2CP91TgK7smXD7YzugozIOReiBXzyyGzJJgMHdO2DjJoAd64+D254YpjTf+9274YTEZtgH86BqLYPFMAbj0AV3PPokXDRvC/zw/p0kpv6H2x+CU196KCT6loGVypH75j0bnoQkdNGRBFqI8dpVYxMT8OBTW+H3z0zBvqEB2D9kwZcqZThlUQ1+dv9OKEMK9g3vhreeexxc+5vNsMjaC//6whNhwYJFsHXnLvjJk0XSXHrtmWuIqFucGIWeDLp4FqCW7oJkJQ+1VAdpqdFYGt8BWUjBnqeehvHudVBMdMBkvggPPv4kHLFyIWzMJiBVGIEEWLB8xRoYmS6DNTEM0LkYNj/9OCzpqEKq1Aup8gRs2lyCvmoRRmqjAL0LIFPYB9V0Fzz62G7om78E9oxOAOTmQ7q4H/YPDUC+kIeMtQOmpjKQzM6Dkb04HrsgXRyFZ3aMw47ufqhNDEEp0weZ4hjsK6QgnUhCbmoE9k6X4cm9em58CSuIzeFBhvHxcdLMGhsbg74+e9KcbTBdAhzofqdQoeGxwNbZGM22eTXWVcHxa+3IpkPXl0l5ZrvsKhhvhGV9gP8MEdUmLIz+V4u12gL3Lb986+ShWfXfLJi4kTQLPrpa4rhANGv8srkBfzOC2KQPTRfsA4Fsyo7GFdW7hJ+zEO04f81GHzSay9uhr882DsQ6kMzbuAbCyGDYL1QRbKNYB7B3DeouZVKpurki8nWG6v3kfI7av3ZQMjtirGwNIctTS9etbYp23E9EXba//uE30J/1jo64Y/80/NsdFhwJ28jV64XHLGkwbGCWU9V0J6QqMxY5DIcs6iJrFEShdw10TNiWPePLzqIIamixcuvjQ/C/d9ufL09PwJuOKJKYM1qs4HXZ6UEiblDoGnWFlvTlXGHtYvdyKHUtg15HnJ0B0/7KXzfD7cWj4dVLtsFrzlgD04tPJsFsxHT/EdA1uon+Xc7Nh0yxUYz6we374ZePDrh/93Wk4V0vOILKW+xeATmHcGLlYaLniCcGxuGHj+yFJZ0WvPLU1eRahmPq63dsoQN4dDFbe+oFcMaaXlg48iBZKLE0aqkslYnV1eTCE6C47T740l8209h8MHk8fPxlJ8BHfvEY6Q+9+Zx1cNGqAuSmBkhw/vG9Jbj2F4/XleWqFx9NVl7/9bsnYcveKVjal4MhQZwc6+jvT1oBpkD3QCYO/uz0E7bOayoBr7vktfDTX/8c9o2Ow121Y+n7VYk99IPYWFsDY2C79J2VnMnvmNUNH3jeUvjmXdukulP/cNIKWLWwBzakj4eBkQl46r5bIdGzDA456iT4ruOCiHj+UYshv+lPVO+7qv2wLGG3MRKiSTyg5zCvIw2PTi+ANclhWNnfCcPVHihP7IG7a0ejUiEs7slBfnI/PLdnN/zr8w4lkXsUWT96ea/t7q0AtukPfvtHGNi5hcjDN7742bAcRui7Qu9q26J3/2aY6D8aFkw8VWflxFts8WNHTJ/vdzymShX4/p61cEptAxGM+flHQdfoU2S1hjpWC7qy1JdzmSSRrJNT03DWBf/kO+8FUrO97bbb6Gd4eJheSqJ7X4zmo1WnQ65FlhC1R3U6x0gqjDaDYwnzx07Mahj23jHLbuUGRxXFJygijRwWBBEQMcankjLLHgPXGqNFs4kVkXCt33O08kHfcVpIzehbfqfXGnpxjWnMAhnlR1bydSIK70ZFoJmMBx9LDAwsUEJXHKe+bd2gBL0pQ41jXmDZsdRg8yL2wiB9SOmuE/Jdws9ZUlHmuYwQlleeFmRRRpM9UOBVB7pBF9oNknkbnTLSabQaQisp1BKwrRZ4y9Uo1gHsXYOW36J7W0PfFPqj6UEa6a8BEkeC5ZdTfrSKLtP7yQKrUpWWT/ZZbNUULW666Sb41Kc+BYODg3DSSSfB5z//eU9t3x/+8Idw9dVXU1AqlFz55Cc/CRdeeGEdCXTNNdfAV77yFRgdHYVnP/vZ8IUvfIGuNcH/d/sTcOzybnj24YvJtQm1hVB7Z3iiQBY46MpFz6utouF095Z9RPScc/gimhJWdJRg5MGfw9axGgwv/zs4/6RDSfx6XmeaNtPbR6ZJ42it1UXp//C+HfDY9D547pJpuOC4ZUREIUHTkU6RBQxDpVKBPzw5DI/uGoNjlvfC2t4SLGMyt2R5bg8dhtHJPPz4kW2wamo3POfwxdDvRBj729OoMWRfiCTMrx4dgOf+3UmUFzwkSqI+qYMHtw7D41t2kVsY6i2h5RZu2B9ziJbnHrEI7tq8j8SwsV6Q3ElYFdrYo3UQWiCND+6C1yy16N/3bhmBR3ePEfkxXLHgpttntJcYkEzCiHnfhAqcmd4E5x2zFI5aZn+XrJZgulCE3zy4C/ZMFOD401bCnqf30v6MvF8qFXjfjx6maxf1ZElkPDGxmf7uzCbh6GV98J1/OZNEy+/fth9OWdMPx6+cR+3yHy8/ga4rV2twxQ8eInIFcdyKPl9C6sRV86A7l4ZHd47VCb2/8VmHkBXU/K4svGW1BV/5y2ayyLriBw/AMeUJSCUAVvR3kKVRCmba2g5FAfCxfzgO5g9PkaXbzpE8rFi8AJZ0WXDmIQvh9qdsCyQEtg1GBLz9yWEoVYfgj8U0ZKACpyYBnnt4P6xfvxJOX7eAXADXLMB+V4ZvbbLlcNJQhWNX9BG5xNwxkRg8fsU8uGvLPhgrVCCVsPOGbTxuJaAPlTYcH4c9k0XoAwtGpkvw84cHYMNu2xrr+KE+cg/HzzGa3THL+kj4nYm0Y9/bsGMfLEyglI4Ff3liAP7paHt9m6jV4Om9E/DrvzwFT1an4KrTEnDoom4iQtHy7vxjl5ImFmJiugBj43ZAgq5s2u3nMiF57JeDY0X4w5ND8LPRNOxKDtBYOKm/CttHpuD79+4gIf5jlvXCK05ZBaYwXs1ee+218NGPfhROO+00WL7cFiaL0XooFzkRW46Yup8xTSk8zctlMtxmx7YIKJaqULVK0J3LhXI5UaFu8YXD3aqSuXyYcNpRI/SpZhNDj4eJcKbbj/AmTystkw2dYZS1qPQn+DY07VtKKzVB1NlPL65Z7lxG8CMrZW6wrgWF8L0pWH3hAhBfnvY00xBJ0WQexIACLOS7DTsdXPhQlB6dTbRsDuYFlh1Sit+g1Y0BccOOkMzpSncdPwj589owSzeRXtFJFXk1yU+7uq7V1YWYZ0Xgj4MaXnWgcKPVfjf6WPK0pC/JhMuZex8XNMO0H6jqwD1IcqOb2vqH0nGKwWXQ0hbzl8kZSw74ufbj5x3ZDKSc63wjNjptgtGBVQF5DiiLzBbg+9//PgWd+uIXvwhnnnkmfO5zn4MLLrgAnnzySViypD5aGeKOO+6AV7/61fCJT3wCXvKSl8B3vvMdeNnLXgYPPPAAHH/88XTN9ddfDzfccAPcfPPNsG7dOiKwMM3HH38cOjo6tPM2NFGEfLkEm7dvhwnogsOSQ3Bq5yBsKCyEf07cCUdldsKvqmfCjdnXwXPWLoK/bNoLTw5N0E835OEj6Zvh+OReeG4KYOvgQ/CpHa+ETKIGSzoqsCuxAvblK0QCX/mio0nzB59XsKrw+MAE/dxVs9+bjJBCQuLGV58CD298Au6+d4BIgD2bivDEjkfhuucvhNx4HiZqFThiXhUyezfDxOB++MmObrh3rA92WYvgWclBSO68F5asPBTGc0vgAUeoGwmwsY2Pk3D3N26+F9Ynn4FMKgHPe9YSODpdIp2iv2wvQW9iGgb3owvbndCZKMMPqmdDETJwaGIPnLRsNUxNpOGJwXEiC5CUQuHvH/95Exxb3gh7rMXw4+0rYKz7aVhX2ggnw2Y4PNkJv66eCUXINljkvPHZ6+D+rfvhoa1JqJUtIitueWwQHsnsgHPS42TB9IttI9BXtImPu257BL6S/R94X2Y7bFj4IvjH3Wi9A275eCFw9jnu+9EVb9u+adKGEnWSMqkkXH7ekaQlNa8zA+87/yjfPsOSECmF1Qu64O1/dzj9Ozm4m4jLHz+4C/LooZAAev4LTlsHn771SZifzcBbTz8UvvLnLXT9IQu74PAlvdBfSsG8gb/AYR3zYKz3uQDVAjzrsAVQLkzBqYPfh2NzQ7BnwQVw9dAqIpDcPIFFVmanrFlAS8vl82bc9pFoPXxxDzy9x3ZTPWllPxy62I5IODRWgItPXUVEKpJSdttk4Jj5vbBxcAJy6RS87ZzD4F2HnAbv/8lGl6RFbNw9AithBFKJGmzZnYdp6IAzkxvh5ImnYPOW5fDdxGlw+mHLYN9kCb41mIQ12L+zabJc+tvTe6A8VoXFvR1w/DGL4OY7tkFvuQblWg1+/tAQWQg+umMfvCD5IHQ8PgUPDBwNzyQPg98PDcOqxF5gwDrF98WP9tbg7/u3wHHLeqkd+7tz8N17t7uELAMK2989sRlKgzYhReUYnIDfPDoAFx+Vhdz+rbC9tAia4r6HRBROXK973evgYMGcMreN0GRey8VLWATKLKXYfZjeRB7ZWICOTCqUy4kKdebhKNY5C+4DfgssIxN2E0uUNgZfJ/g7iMubzsI1EkspDYRxQ1C6/FXLtJGgdRRqxRkK0EflzqU7D1BdVitE5FAQBd3+GVX/ZXMdhTpn0d3ESIrc2Nd5LncNShi7fQU3mxiOF4uOIr9e84lsDpZYSnnezz+L8hXhPBbWha1cdAWbqS5ZuGC3ng3SJuF57v5ZdvPSnh+wDnG84vWprHMIUptTc3IDTPpo2HGssJTSnldVfTho3w5SFtmzXMJIIMV108cokRRkIwmplO0Wp112MZ2SffKdymTJBdzMUipCF2aN/B5Mbn1R7SeQiMJo6DfeeCP9jV4rGHzqsssugyuvvLLh+ksuuQSmpqbgl7/8pfvZWWedBevXrydiC7eCK1asgPe+973wvve9j77HPGKU9W984xvwqle9SrtsH3nvG+CNXX+DtckZSxQZth7yT5DpnAfj2x6C5dNPQMYqk25QOlEjS6BqIkXWKjxGrF7YbC2DTbVVMAbdNFZqiTScvHoedA7cAzsq8+ALlZfCghWHQ9Iqw5O7R+FVp66A5x+5gLSTis/8DfYM74Yt0zn4WfE0OC95Pzwn9ShF+Ds9NePiNGZ1wfeqz4fJzCL4l9oPYV7CdhNEVK0EbE+ugtrpl0J1859gZHgXkWzzYIrWDRtra+Hs1GOwIDEBw7X5cGJqC5yYeAb6uDQKVgY6EmXSw2JWWttqS+DJ3Alwb34ZvD75W1idtImCb1VfCCclnoYTkzbZgihm58N45ypI5vdDRyYJ07UMJLvmQ9/kM1DsXgXPnHIV1PZvg56NP4RnJpLwjeqL4JTEU5CBKvQkpuHi9N9IJ2kR2AQbw3cXvxv+Y8cJsKAD4D//4RjIJmvQs/dhcs0qrD4H9vceBVYiwUVEdH47fyORU/+ZJXwHdd+xz45d3gudmSQ8OThB1jg0fXLpoPXYyke/AH2Dd8DechY+O/1imA/j8KLDOyF9wsUwnVkA83ffDosH/wIDEyX4ZelUOOasC2BdxzQc/Yc3Q27adpWcWHwKTCw8idxB+3f9EXL5ITdLeeiAcasDHk4cA+Xn/huMjo3AacX7INW/AvavfqG9pqxVaD2YQEvRjb+Ch596BnoWroTnzd8L6co0VNPdkC6NQaJWBCuZg23jVXh8vBNWr1oNJ1Q2wFglDdOLToTujg4YX3oajGSWw5bBETg5swOG/vo1eJb1EPQlGl1VeWDfebB2OFxXeR08t+MZeP2ybfD43go8ML0EDk3uprfPXbVjYLTWDafltkE1kYWX1X4HPVCASeiE5QnbxQ/xVG0l9a9DEoP0OZLCSA3vtfrgntpR8JLU3fDc5COktTZszYMna6thi7UcKrn5cPixp8D8p/8P9k0W4RfVZ8GRyR1wcnYXrMuOwubpDlgAE3BYYhee2cDeQhIWf3LUd94zJqUWLlwI99xzDxx22GFwsGDOkFK0wLejwNgbJwMLDsmiqViq0IkZmowrrUGcxTmBRWQJqUEVtaUUTrzoZx1KP8kAfgusOs0WCxePJVqwZTKZxrxhe+KJMlpEpFsgUh10o2ZQZ0GFnWdt4Sopm231h2KvNToxbujLHvXhZSmFG5JCxe6rHekERXPS7YPNGlsqEi1Ue0QVfVBF2MospcIQ9ibuRmHLpmkpFTiPIfJHbV6tkmk89U03IhdHoJmkLXt/tBpcfZRdd3WfPu2QaWgRXIU0bfyjJNdnBShMXM4DZDoBcj2zohkVyFIKEVZbL0hZTMaRbvrOwQRuetHCSXkQqDHOKYJstUwWtxgVN2i/k87zJgS/htWqbN2me3hAmEOHdFHsJ0qlEnR1dcGPfvQjsnZieMMb3kBudz/72c8a7sGI6WhZdfnll7ufoaseRk1/+OGHYfPmzbSve/DBB4moYnje855Hf//3f/93Q5oYdZIiTzrAMuFzdrynB/owsIQDpB52wyJYCXtgqmsVlHtWQv/w3cry4Zz62LFXQHdvPyx59IvQO23r3eARGLpKNRNjViftGeYnbFFyBtvGPxzyiS6SNUeyDIF6QgnHzUwHSMCNLzgJesefhnRlAqICCq1PdB8CC6YaXQEPFGAfrCPFHJSz82F63uHQt+c+6fezgSo6saUykKra5FQ1mYXxJadBz74NkCmPh08/1Qk7sofCivyTkBVI32ZgxOqBdGkCVn92kuYnnP9UMPZp+pd/+Rcy+0SzzhhtBrISsE0ajQMzBnUJ4yKyuJHXPNIK7HKiCd7cHNctqMnDCwlraTuEdI9rMKX3cJcpF8sUwZBM21OpxrwxC30qjKPD0+JFmJbpv0GdtTTKThSi6ZKyYRlQS6RiYd+yI0/q1gcuunMpLmoeWig4z8SNSBZ9z3EzoRHNkF/MN2tsSXWz8JlUV+i2EoAgVNWPqT6UWDdeLkNhdH5MooKFjT4oPkvQbQwbWZAswCzUhdGIRCqAtX8qiZvhhL1SJ3dHvkwG4wx/Gu73utVUG0eD/Ob6Imonas0x+H26A1IJWz/IZE5q2xD21AZOm2hfH61ultf7uYF0Z666vPuuj7ZhpBpgQaLa+aVP6wAcWvQ/9XNRa5DKrn4/oCUj9XlN13aj967O+969xp/oq2t3fB9qp+383Wo5g1nG3r176XAArZh44N8sKroI1J2SXY+fs+/ZZ6prRKArIEq6iMDNZyPYZnqj8+OH2dpjTrR52n+G5qBRjP3gALZJo8h3++G3EZfZ24qxWf1+YmIiWlKqUCjAl7/8Zfj9738PJ554Ill38PjMZz5jmmSMgGhYpOHiAzelRGSYRmWxw2XzXYIt5D0X3M7ivO7UqpkirwabVldI2KpBFl35knYIY9/0Qua/YWHtsYBLpTOQpYWiBSl0Y0nk6i3c2EkonY7OziJMiwxqRpsbaN8o7+U3LIai6WLZKrUEEYhsvHkLTQvjiS+Lx4J6RjfE2XT41GcrNrhSEhG12tgzg1h7KPoLWQmw0/1kxATbbOj8KNvdIB+690nmf2WfqdrEJ1pQmGg/JbHd+TZX1SnvCoYm7yr9JZ5E0HAfc/u7hSb0ApklzBekjVO2LVSSCbQ6yfj2RaM5xiAgAg/SJ7NQ+FTtehXloUPDGkCVPlriMpfMqBGBBhTTq8Q5l8h31o/IfdebTGuog1ZrgOmmr3udzvtWSMvvPa6yVmI6UIzkpe91ns9fY9Kn/QTyLUmbe+VlDsodzBVcddVVZH3FgFYQa9euhe3bt3tuPA90oDUculLu2LGjvb1rmoy4HuI6YECnPCSk0EXYC8ak1COPPOKadm7YsKHuu1j0vLVoWKRJTvP1NyBouZGss7CiBTptrvHkyuOFLi6kmrDAcxdMzmZY3KDJFt6uJQdJzuD/nB+/DZ+JpYPOgsdjkYXWUbnOToDStOPKkmjcxOHNSKrxJIUJARRyUaa1UQvb5rI8Bt3E8zo1Jqf/qnZyyoaEFD/evC2ThPHEl0V8jscz/RA4mpGXWLVOWmIZTKNpKcpXdax4cNNhVKJ21V5TtXuATRq6FFQrWEO2lV7DQYOmNRf1FU1LPGVZ/O6pE3bP1N+nGmcSMXhlf0fCF+uQzwvLH82VaAmWhKzdlUj3rBWuP75uSEjsVYvOa4iZmUVrqetLXKvSN53DPfLpSwJppCGmhTqVCPcQgO9HmgdUbh2EPURp0tyifYjo11ZI8NIhFxLVuZlDHY/1XF0duXqcTjfFaLBkeU5m25Aky1mDOd4kuIVX2ZTWVx5pRjye2gGLFi0izbGhoRk9HAT+vWyZE2ZNAH7udT37jZ+hdjB/De/OxyOXy9GPCCSkDmYyhgHrIK6HuB7ivmBDh6g2JqX++Mc/mt4So0lAQWPUHMpiM9ICPSlfxFeKkKKFSEK9aVEt0qJ6oSsWcbo6OO6CCV1OJCSDbOHtWnIk0mqrE3IhcTY4ZE3lcYorqwud+tFZ7KN1APutRZQ5RALpsfhoNvjlMcgCO4JFed0CXJbHoBsHRzSSoBtuXKM8NN6qZcjqaLWJeW/YQAltGRCBQ42L9W06zsUyaLqO+QEFeZHM84z2Jvs86NjUQRgSQ2z3GrMGs6MH2U2nt0lDQgrnODt0cwLKUCU9M1NdIuozTA8KBd1VgvVeZREhthE/n7EoZC4Jq+gf/D1eeaeQ9w7RweeF5c/JCz6GNkzidU10/VFu7Pk+yee3BVanDVEDyR3Ukr/zTOCRT20SyK+smA4n/N2V5fqGwTzTQN6HPUTxmVuC6ibqWL66701cznHi+nXvUyR3UR+MyJu01pxYX0eUeN3cmnIsyowPQCLt040W/a17dvsgm83CqaeeCrfddpurKYVC5/j3O9/5Tuk9Z599Nn3Pa0rdeuut9DkCo+0hMYXXMBIKLV3uvvtueNvb3taScsWIEePghrmwS4y2AJE5pSK5paVR18LiFh7iIj6Fi3h0ZQqwIY/qhS5bDKF7RTEPJTp9Q70p9WZkZsEkdxdqWHR6kgCa+gxinmV1oaqfWs2OpIbrp0TSf2GKC0dGdjALAL86Z/nzCz/t14ZBNu8RbPgbFuBiHoNuHAx1anTLk05akM5imhp6bS2wHgwFL9IsaHqi65hJNC9GJKCFFFrwELvljBcdKwuTsWkKDRJDaeEgIe/QPZEM7hKOG4wOkDTCoAdJJO8zRORj/eAzA5GSXL6I7ML0EpgWsYq+9zRAbCN+PrNv9s9Twz16+W/4DCM3IfFXw/cCSskK0LFUDCjcrNzYm8xNEc8VDXo9LBqSqaWcbj5lenOqa/3KalUdiz6s04Bi6jK307DwmVvIddREx1LXtVN0YXWrL1n/PsU5N+MQVppzYn0+uXnAUXhOOq589mHYjA6iFlhGeW1M1b2ehwC2BTISMGXqyxqkX7u9eyMCus2hsPlpp50GZ5xxBnzuc5+j6HpvetOb6PvXv/71sHLlStJ9Qrz73e8m0fJPf/rTcNFFF8H3vvc9uO+++0iOhXm6IGF13XXXwRFHHEEkFWoHo7sNL6YeI0aMGM2C1grwFa94BYUERTNE/LcXfvzjH0eVtxh+rntWAmpVC3K4CMb3t2pjxKxFPEiJSrkMpWoJsrnOeoulqF7ossWQVYUsrsKqlkKXh8+G98Ku4XuTRZDuKa7XRkiEs/kslS2qf1OtEq06Z/mjYcyEswOkF2Tz7mVhpom6DRy/GQ5rhRWkz+rUwYF04ho1aSZzHdNwx9IiWHXGp8nYNIUGiaGl7eVYqdBGPZWyrcJ0N8nVEkXsIfebtK2P5EbwDAlKI522XdzCkJLtMjZITyplt0elXLdxZ98HslTUOARQbuzbBbrvjDDgrZSxzkqaxLSCACTB7oQhocS7ExPRo6krqAvF3MLIaXSxbQgOoZMs1ZtNTBGr6kV8EnHlXCN7n6YkERQ150TRgr1WswlwsqYMcyBlJJDu/C05GMSqkZF+dZGNnXm57aJcRoRLLrkE9uzZAx/+8IdJiBytm2655RZXqBx1nYhEdPCsZz2LglT9+7//O/zbv/0bEU8Yee/44493r/nABz5AxNall15K+lDnnHMOpdnR4URW9QFapmJEP5lL38GEuB7ieoj7QjAkLFSf8gEy7zfccAP09va6LLwKX//61+FAQxQhXKMGWzQkqhVIJJCUskNIBgrRXqvBdN62WMJFSFdHCIFhCaGgtCJoheZLyLDVgcN3m1pKGaRbd4poouMTpjxedZtwdLD4dvRqW792b0Ko8UgQpr96aTghZlv7qBkIYCmlEz68HaE1rsKEncfXNEZWNd3cH6RQuTiFTJTaArku1GnEIBVkhWwCjT4Q6RwdIbTzxc9tqGvE5oBsl/7Dwr4D8P4yaioha+FoabZgTkGXPXENZtSerO6Yi+UsvQOnC7Z+Irqs43qwrlxMI8yjPkOt+TTejSr3SD6fiEDr4YNwPxEjRowYc4aUOtjRzi+RWhVdL8q0QEZiIOhiVlfbyT+hoq0tg648KLCpWKg1DbLNvyFxw6PZeTeud36xThl0Ft4YAVFj8RppebwW0F6bCr8NhyH5E1S/wxhhNkrivWI7tiMJ10rMlih5K5+rSdLVa61V5H2jHUTcg2Iu591gDpVuzDXK3tL3pQE886UqlwkxrZOeyf0h3vtBIWvzQO05y2Ok0VLKjCg1LrNziEdhHBIpN5ADS0v33T4XLKXaeT8RI0aMGLOJ+Mh1jgNPavnT2jrXEQNrjLpIYn73eUW6IneuuiB+wSOEBVmwyUI9qzSjNBAo7waRzRoiKJq6yTAdH6x0LzdFZ5GeIrH41IzWhyzfrAFl1hn8Yt/VC0k1uoJ4ufP4ufoYul156nfoLu51NjFhXJRkGk7M/TFpECGwGTA9vRZFdZ0Fv9bGhUsHnVykQvdOtCftDZnJBk4neEEEkNdFY4RT2VzBhJ0pRzKttXaJKKWa58IGXvB6RhtA950gdenUmNsif19GhIZ8+QUaMNUJ49EMd2LNsRrGUk3mph+oPWdZB0mMLGsaUMO4zI7cQbEMULAs6EhnIec83kSbS7wmkN5ejBgxYsSYFcSk1IGMoFGG+NDaFOmJRa527vOKdIWbrlRH3SYqcIQw1cldovH5rrWMZUEGF5MRCR4Hyju6eOCpH4q0ZnK04a77m1vo2lpadrmCaQHl9EIuO9HR8NFEYsoW26JmClq9sQ0021jwUdYsJFKScgsfP3H5CBfcuPBV6nfoboB1oseZ5FvcTMs0nBhZinVsYiEV9UYdyThm3ajayAn1KNtwa+kqcelQiHEU2E6nnT5ZH+1Jm3AxuV4neEFA8JtZaV0odPXEKIh1ws4q4XGDfEdmBSuWl6IIliFFmnnZ8IEXZP26Hci3gO8ETxLHY9z6ph/F+OctmLCtNA6eKF8U/Qyt94RxGnQchXHzjgjiWNWaxwwQxfrHCG1A5BqXGQ/KUH6iggdDSXut5AjbB9HmihEjRowYcw8xKXUgQ0Og1/M+csviPlOlK37WhMUDWRThBrZahnRHrsGypM5aBoVR+TzwhEAAqxBjJFK0qCJrB7IcS0KhZEfLwnyjSLHqRDIw/DYFsuhofiK4mc4ZSylZOjILKR2rmIhN6TG9XFYxlelulnTqxwQ6m+mgG7moN+quGLDHNUJeZSfhWqfjXDopsCO+kcB23Rg1mKskeTO6NkKClN/MSutC8qwaEXzktAIWEVJJPWFng3wbW2NqAnNdRWIVxahNRLRVeZf1a922bZVGm5eVsPC8ho15VOM2inTqghBk1IdM4jNURJRHf/S0PPIqi2Y5w2pw4dir1aqQRnIOSVYiVDFyYIQEbhQ6YbouiW1I5PqC6iUL3Ym0S6CzelK+22PEiBEjxgGFOfLGiqFa6BRLFfrBfzcAFy1s8cL/2w/sWvaDekXi5kpMi/+MRbzjSa2QwEVKNmHZ0fqYZYmwIcYTNfzxXEy6p/nVcNcwyMqaTJJFVAojbKHVhEt0OBtw3XRM4Ne++DlqfGVyrvsVWpbV9Ru33W3RfCJpUJyWd7/g02HX+S2OkaBzNuz4u6Uw6fdk5ReR/kjC3yUPibpiNQHFSk0+fkOkbdS/2Bj3stZiQsG4KSoXIQlWg8YH/rvuM/ZMsspwns21B5IvmUyWfjc8y6QdgsxtBlplum2DYx01VNjGU0cDBeeGKm7Eqs74aIIGDs2dKZwfA27uFH0Hg2ukMlk7yIZs/jAtg6xfc+3l2R78nM3+jX3Vb041nXdl7wb+M6/0xPIFnfODjH8R5JLt/MjSUz2D/1xzLHnO/V5l0Sxn2HcL6hfhIZaFBzA1O3JgaG1CoW0jef8xa95ayXtt4ldvsn7XhDVbEOAhHQqrY93LxnrdHNAmeT5Y8PGPf5wi+HV1dUF/f7/0Goz4d9FFF9E1S5Ysgfe///1QwcNkDrfffjuccsopFKHu8MMPp8juIm666SY45JBDKOrfmWeeCffccw+0KzCfiUSi7uc///M/66555JFH4DnPeQ6VZ/Xq1XD99dc3pPPDH/4Qjj76aLrmhBNOgF//+tcwlzGX2tAUH/nIRxraHNuOoVAowDve8Q5YuHAh9PT0wMUXXwxDQ0PGY+VgRExKzWEw6yD8acpm33RzGITUMVmsdHZCGk25ndDqMmsZ/PFcTOosdE0W/Yqy8ptS5NEyKYCOrGQDrkiHLb7Q9cZkY6yLlpBEXD3yG/aWQncBHpaIDDB2Ao/fIOPSq3y66eluisRnokWG7NlB55cWwXSM6BJRPNi4QMKoWeODbfQCu+457UjRRLm5KEh5PeHTH7TJDfZvMlqL8ABCfI7sM5NxFvQ9GcW4wfcQO3DwOmRC8HNdgGc3zP38/OmVnioPDE46+H41HjtcHtz8YbCYKLT9MG2KOlh22zaS9x+z5kVXWa88+rWRH7EaAUEfFqqxXvd5E9aZMdQolUrwyle+Et72trfJ26xapU02XnfHHXfAzTffTITThz/8YfeaLVu20DXPf/7z4aGHHoLLL78c/uVf/gV++9vfutd8//vfhyuuuAKuueYaeOCBB+Ckk06CCy64AIaHh9u2eT760Y/CwMCA+3PZZZfVCduff/75sHbtWrj//vvhU5/6FJEaX/7yl91rsL5e/epXw5vf/GZ48MEH4WUvexn9bNiwAeYi5mIbmuK4446ra/O//vWv7nfvec974Be/+AURjX/6059g9+7d8IpXvMJorBys0Iq+d8MNN2gn+K53vQsONLRrtAzfqGOabmhi+GxyKUFjJJWpuZ+gbTM1DcKGipYhTH517tXJs5BOuVwmvR20pkEiyySKjdSNhf+3TKi6DXQolAiTN1ndyz7T0TZxBeDxb81w3R7ptixqoE8+jCJ9lot2n6HNkU86XL3VcDMBCbKqaVUkpLAuM5G43BwIcNqxjPt4KzFrUeGM26MVrtph0mvmnBtV2cO+b2XR9yQRer3TUOQhymioUYKsQ8v2v0Ur83aAgQtqqMiLOs81HOt1n9O7WCOwQpuhXfcTusDNM5JJo6OjdZ//5je/gZe85CW0AV+6dCl99sUvfhE++MEPwp49eyCbzdK/f/WrX9WRLa961asorVtuuYX+Rqua008/HW688Ub6G9cOaF2ERM+VV14J7Qa0BsL6wB8ZvvCFL8CHPvQhGBwcpDpAYDl++tOfwhNPPEF/X3LJJTA1NQW//OUv3fvOOussWL9+PdXhXMNca0NTIKmI7YfEqggc14sXL4bvfOc78I//+I/0GbbzMcccA3feeSe1q85YOVihZc//2c9+tu5vrLTp6WnXhBMnFGaCdiCSUu0KTy0dA20BVwvFqtA7HTVO0KVEKfTpJ2gboU5LA8IKE+uI6ZpsFnTKqpNnIR1y80vUIJ1Ig+V3wqqMggRKofum6Z00Y0OvkzdVm/npn/H3kogvPou1h6K/O9pgRpZ0krz7jl9TePVb1r+YhUCABTy5muEpPfUdTVc555nVGob7RhdA+ZwSqr8oyh1WsLjlAsXtCqcdSYCdC7fe+mwYtofO3Bz1u8okvYifXTeGdObMILp3pkRanXZV2l/DTpa+6v0ZZC3Az/XNiniKaWKy7UqSyPqdT1/01AvUXTsYrDFUY73+czzsSNgHJQnLCQbchvV9kAA33Oh2xjbZCLSOQcuqxx57DE4++WS65rzzzqu7D69hhA5ajqA10VVXXeV+j2sNvAfvbVegu97HPvYxWLNmDbzmNa8hS5m04y6P+X7uc59bRzRgmT/5yU/C/v37Yf78+XQNWhbxwGuQ+JhrmKttaIpNmzbBihUryD3x7LPPhk984hPU/lh2NCrg+zm69uF3jJTSGSsHK7R2RGhyyYDs3//8z//AV7/6VTjqqKPosyeffBLe8pa3wFvf+tbm5TSG+UaOBKbxGrBf2orNnrvgSGRmFh6OpZQUOoK2zToFDruQ1xHTjYqg4evA8DTWFmtP6NWfVxQk1b+jJvsERBrBSCdvqjbTWYD7kayy/q7bpyOuV09EtRGNOlS9GFEu6v6iKFPg/EaAoCRbq+8zmbelG8V2trA8mIDjp1yyiV9qK415RzU3NbRpMsQBQdohwZ1orixARrI+Qm9d+uT2VgTAucJP5870/ezmvwkWUmHypUKbjC9PQlj3HWfyLtQsN703MFGrVh9xuU3q7WACWgLxm2wE+xu/87oGrcfy+TyRNOjaJLuGWRW1G9AQAzWyFixYQK5YSMagO9dnPvMZt8zr1q1T1guSUqp6YfU2l7B3794514ZBLMHQYhA5EGzra6+9ljTD0AKQWcSJumt8e+qMlYMVxsf0V199NfzoRz9yCSkE/hutqdBU7bWvfW3UeYyhgO9GjkKTY4hj+4Sbv0bcxMx8l6J1QzLsoqtdI8DIFkZieaIiEgLUQV278Itmr0UWn9+GtlH8W0wv4lP7SAmBqKzR/O5Vkaxh6kZ1bzMWzTqbTN16UoWEx3mCrK0q+i5KOPegYUKCmUckjPqLDvkuK9NsWjoFJdlafZ/RnCV1+ynPuGIlNVyxvBBvJINDJH5pnAS0EvPqA6YHBDjm0UUPCf8qWihhH5IET+HTB8e1zo3KWW/lGwqtPCTw69c6/b1d11Ea/ahh3jZ5j2qWm70vZvq82f0HO9CVCi12vLBx48Y6EeeDASb1wls4nXjiiURIoIEGWs6gmHuMAw8vfvGL69ocSSrUDPvBD34AnZ2ds5q3g46UQlZQphCPzKioLh+judDZ+NtWTxVI4aKwxhYGEVuySMBCndu+/y1YvEUVThkhLp6CPp9IAEeUHX9rlEnZLl6LrFAnxpL0IoAfISDqmIUmZ5pBHDUTzah/nU0mEZ1J/zHByAZ0uakl668xyTu5yliOJRoSWXhLzqi/KMeESLZRtDX96HWeumos7wH7ZVBS1g4uWnGsVusyq85PtQKpcp7IvlSqM5BmjNamXUZAebliNdzvkwcxfdP3gY4unKxO3AII2jSm6UWFIGknUrYBEt2TCJe+Vx9w5hgaOxXn/S4+T2ati0vNJAZKcLSWqN4VfZMIK0eoXsfKt9VzvWn7qObLIO6Tcwih1piKcjcepireG3O43lqJ9773vfDGN77R85pDDz1UK61ly5Y1RFhje0L8jv0W94n4N2pr4WaeIlanUtJrWBrtXi9IUOAeeevWrWSwoSqzTr20ssxRYdGiRW3Rhq0EWkUdeeSR8PTTT8MLX/hCcmFEWSPeWoovv85YOVhh/HY+99xziQVGRX0G9KFEX0jRVzhGc6ET/YiuIY8ktgCH8NFgNKKPsVDnFOJcF6poKuLnzvNReFk7IoxB5LCGSDNBo7xg3ZIGERPk9C+rsl1okUVCFW7dU/kL01ArFbwjwckgSa+VcKPo4CblYIygw+q/FYtm1bO8xgTbo1cl15jknb9Wl7wQoBwTfFS4cglq5aJ+ZEBZhCd+TAYd8w6CRqajcPQ4XyOBx49Lr/xUS5CsTEOmMmXfJ7tWtzxYxypST0ZA4bVIIui4QvnlQUxf932gk75XnbDokGKUSNP0okKQtL3azTR9jbQ8IyHy97N/I7mNFlMU8S9TP3eI+SFiKgeQydWn0S5uWCy/RIJrvDtl8yWLIIyWZF7zqFh2iuxXBKC5rrXvbFOEWmMq2ryu33mtQ9utz7QpUJAZrX28fnRFl1FX59FHH62LsHbrrbcS4XTssce619x222119+E1+DkCn3XqqafWXYMi2fg3u6bd6wXFr1FDCTWWEZjvP//5z6QzxJcZCSt03dOpl7mEdmnDVmJychKeeeYZWL58OZU9k8nUlR8ljrZv3+6WX2esHLSwDDE8PGy9+MUvthKJhJXNZuknmUzSZ0NDQ9aBiLGxMVwm0+85iWrVsiol+3cUwLRKefu38pE1q1Su0O/Q+RQ/d55fKuStfLFMz9FKu1ywrFLBtx4wvbp0w9SfbpkC1D2Vf3zEKk3u92wL3fRCw6BMbv+oVKLtmzH04TUmWFtWyvXXiG2s2+ZRz0EIzFtxyioVpq381KRVmp7QGt8sP9VS0SqVSjNzFF8fmLaYX4M5JPS8gM/gx6VX/WFep0bsH5Y3Wd4V92vP1WHb0O9+3b4VZE71qhPW1kKb49yEcyzNUaZlCYNmph1R+oHe76p7hfyESbslUI1Rk/uLU/aPeK9f2+B3+XHLKoxH886eY6jrG5prl3brT3N1P7Ft2zbrwQcftK699lqrp6eH/o0/ExMT9H2lUrGOP/546/zzz7ceeugh65ZbbrEWL15sXXXVVW4amzdvtrq6uqz3v//91saNG62bbrrJSqVSdC3D9773PSuXy1nf+MY3rMcff9y69NJLrf7+fmtwcNBqN9xxxx3WZz/7WSrvM888Y33729+mMr/+9a93rxkdHbWWLl1qve51r7M2bNhA5cM6+NKXvuRe87e//c1Kp9PWf/3Xf1G9XHPNNVYmk7EeffRRay5iLrVhELz3ve+1br/9dmvLli3Uduedd561aNEi4kcQ//qv/2qtWbPG+sMf/mDdd9991tlnn00/DDpj5WCFMSnF8OSTT1o/+9nP6Af/fSBjrr5EmgXPxXpLMmAv3CgfTVhstNsiRrVopfLnp6xqMd+8jaIJJIvEdqrLWctLszeZUUJnU8S3cZSkpimcZ1fzk1YpP0kkk+m9Dfn2Ko9kQxi4T/nVm2mfCUF+N5DwMaKvF0Oi8GCu17brj804WGKklHival5QHRJEjbnUJzXz2m79aa7uJ97whjdQvsWfP/7xj+41W7duJQOFzs5O2qTj5r1cLtelg9evX7+eDBoOPfRQ6+tf/3rDsz7/+c/Tph6vOeOMM6y77rrLakfcf//91plnnmnNmzfP6ujosI455hjrP/7jP6xCoVB33cMPP2ydc845RNSsXLnS+s///M+GtH7wgx9YRx55JJX5uOOOs371q19ZcxlzpQ2D4JJLLrGWL19OZcP2xL+ffvpp9/t8Pm+9/e1vt+bPn08E5Mtf/nJrYGCgLg2dsXIwIoH/m21rrXYHRoaYN28ejI2NkXndwQ50bUMNMYztl8lkozGRjkVu5xY0dWuor9QsMuNHdybfNKLIhwKeeWkCXP0LC+MD1cwiPgXRs4miPskdwiM6lfiM2Ry3oiaQSR6C6hIJGlyB+1QYvSKTOpe1p3C/ceS+gG0eWYRA0zzp9FnJZ575NU2Tj/rG/kadR1x+6c4LJv3doz6k5YpyHPvURQ0Snv1Au94RKg04k/L4XauaE037jM7zVN/5zctRwfA5TR3TEaHd8hjvJ2LEiBEjIqFzxM6dO+HnP/85+UiioBcPFgYzKuzatQs++MEPwm9+8xuYnp6Gww8/HL7+9a/DaaedRt8jp3bNNdfAV77yFRIWe/aznw1f+MIX4IgjjnDTGBkZgcsuuwx+8YtfkK/vxRdfDP/93/8NPT09keb1YAFpBFTLTrQfTrA0DDAdXBBh5B1JZB6vhcWsLjpmY1MedtOqI/rutQEiXYuC/W8KxsZtMoSNbwo1tVS6El5Cr7r1KktDlnfMqiO6nbISdaL/zSLHXKHXhCPGaqIf5VU3QYRzdTe0fgKxTCiY6XkkNDYvzRgjYdNUCR57CSGTvk3OTNBclU+v5/gJIPPfo5yKqWi1kL5xlEIdgWYJmhpcw2S8yK6VfOZZL6Zp8u3APsex6DUviH3H1V5CLSISigzUh6TtYNimnu9cn7rAd4RX++vXOx+VT4jQZzJGfNYeyjlRUk6tPu43x8i+i1K4WzeSrwa0yjvLB46zGYU1RowYMWI0kZRC8a6XvvSlFHngiSeegOOPP56iDCA5dMopp0CU2L9/P5FMz3/+84mUQvG5TZs2ueJwiOuvvx5uuOEGuPnmm2HdunVw9dVXwwUXXACPP/44dHR00DWvfe1rKWogComh2Nyb3vQmuPTSS+E73/kOzHkEPa0L+5JHCyn+lDIsKB1JZB6NxU9TNjthSJFmw2TTqvoexasTHotgFgkLhViT6fq0eIHcRMpzk0P7+HTGPDohV4Y60ssv0hN/b93mzRaRJosltmnx2JAaQ5LGDGGhERFLBCsXE6Ln+6Fq4+C1oZDViWyzphudyqTOoqhf1Qa9leMuyIYnSD79NoYygkOVvrQ9E3Y/CHYmFXiDrB2RMIgliVeexHlGdq1pmcTr/dLkyVwmcE1h7A3eLe6ckK4j27Xy59cOqrnYNEqs+OwqCvaXnHdIBIEdxHKp/m0yRnzWHiZEUdCom82MGtiwHvSqD8PnaJV3FubqdrOOihEjRowY/jB23zvjjDPgxS9+MVx77bXQ29sLDz/8MEUZQOLnRS96EUXhiwpXXnkl/O1vf4O//OUv0u8x6ytWrKDwne973/voM3SxW7p0KXzjG9+AV73qVbBx40ZSs7/33ntd66pbbrkFLrzwQrL4wvvntLktM7emCG8WQCoLZSvRUjelSKx4XMsLkC7WW24ppeH2olVeEa1wWYvCUopFMkuk7chJHmUO5Q7i5Rrh5LEMSahaCf3+rLCU8rT8aqEboWefFdOJym1DVie8SxGXdmgXlDDXqiDWQ1Sn76ZuThGmHwmCpN8qV6Cg8Mpf0Lw3o/80u+51yTlEFH1MljdFft2xgdwastuqZ5embVIqlbUj780GdNopSFu2m+SAIj8NLsatzvcs1FOrXfVN0Nb7iRgxYsSYRRi/IZDkef3rX0//TqfTkM/nyQ3uox/9KHzyk5+MNHPoIohE0itf+Uoivk4++WRy02PYsmULDA4Ownnnned+hpP9mWeeCXfeeSf9jb/7+/tdQgqB16Mb39133y19brFYpBcH/9O2oBc9nkg6Ia2rpWCheL3C65rAN+y3Rzhv2iw7IaCFvGGo8wxZJSQiC7+uVa9SC5xq8NDDfvWjA79n6nzPh9yWgYV6x+vEtIT0pfWvWy+yemb3Y19Adzv8MenP7NlIpslCk/uUJxAM01CGVBf7h6p+guaPL78ibc9w70HKG0X9inmNIk2f8ahVD36IKp866evO4VH1KROYvF+88hc07+J9rN2R+A763gsyl5vk36vv8M+O4p2iypsiv+6cj4SU17ORjGI/swWdMRhknEZV71FBkZ+G9SCb++n6WvRrQBGq5zURdWVuVrlixIgRI0akMF4pd3d3uzpSy5cvh2eeecb9bu/evZFmbvPmza4+1G9/+1uywnrXu95FrnoIJKQQaBnFA/9m3+FvJLR4IJm2YMEC9xoRn/jEJ4jcYj+rV6+Gtkd6ZvEXiKRp5sIWwRYGKh0Ndh9zV+IXEGHyFnRBIlukyspmmr5f/cjSmY1FVdjNtG6evZ7j1FUyldbvz7rPneWFqpI4Dkq+BCmPIm2UIk5V8vS7DuiKQ5YPFf+0xfyErW8xr5G1H3Nla+xbgch9EUHz6Vd/snSRYCkX7N/iNfy/w4xtv/JI8+Vo0OHnOnO4V/6C5p3dh+DfQ+SBFvDdEoQgi4qk5J8dNXFtQtj7PRtJcLSQwt8miHp+ZumRO2FE6c4GuesFPwKRf3/K1lSqdZZOW/hdE3QNF7Af1JW53cjDGDFixIghhbGoxFlnnQV//etf4ZhjjiEXOHSde/TRR+HHP/4xfRclarUaWTj9x3/8B/2NllIbNmyAL37xi/CGN7wBmoWrrroKrrjiCvdvtJRqW2KKd8FByxZ2GmW66A2oE9IAlSaBwlWo4T7XXYA+DJ+3KPUMZGUzTd+3fiTpNFuToRnm9VHkOYiOhu5zZ1mTSKlFxJfZpF0iLE+yVoZkwrEiAW6sOpaYBLRi8xMPFoWHvcSETRFZeR3rTGInmiCQGzSfsvrzFdae8c5sTEMQgm5WeaT5crTM8HOZxUwr3XvE91BCcINrkc5PaDQ8exbzwbTpSK6vjd4fsvR0ROLnQvuHzY+JrppOW/heI9Gx0xn3funqpBHV2jZGjBgxYrQXKYXR9SYnJ+nfqCuF//7+979P1kxRR95DSyzUg+KBZNj//d//0b+XLVtGv4eGhuhaBvx7/fr17jXDw8N1aVQqFYrIx+4Xkcvl6KetwWvE8GGmgy7kdBY0OlpEyvsccVeZcLPfAkJn4avSpHLFYZ3nou5WreJYlaWDafEwk3CsC0YARi3gqisIHgWaQdDM1kJQ97liv2j2hjiIBpMbMh4/1HGDJKE925pJp3+rxjMjDkQCgf+c9Rna1DNXwGTjJgS/Y5YpjJgg4fdcuPqKqn81u596pe9VRv4+fv6U/c3Au2XKns3/O+hc7jduxHxTP8Y5F8uJ95QaXbRbSRA31EmTiIXZ0BpsNYLMU80el8p6dOYfFFznx5FKZ1BMz2V7faKXBkUr2r/hGcJzVGNBpy18r5GQ/zrj3i9dnTTajTyMESNGjBjRkFIYdY935UOrpWYBI+89+eSTdZ899dRTsHbtWvo3RttDYgkjAjISCq2aUCuKCa6fffbZMDo6Cvfffz+ceuqp9Nkf/vAHssJC7ak5C5nlkRNYrGkbLJ2obar7XMFpy3sREcSSyP2+ZK95MlwaogVWpTizMNIhpVQnrHxdJCKw/PCqT/wON/dMP8R0gdWqDX47LAR1n+tlmdeMDYPJxls3ZLysPEhIMVepXK93flXjGfs5WZEkG8vPxIoZQVopO5pdIjnlbEKQAKZxg5/jPGXZLjTMakY1Bv3qK6r+1ex+6pW+Vxn5+4jU4zbC4t+ye6R9Nqk/l8vu5z9T5V3MN5s7sT9VFRHOghJ3XlDdF9QS0TRPpkQbT/LSAYwmWTibZFaQeUoXpu3kS5A58xESUqKIO85RbC2V6ZITpuz9r7K0CtsOqv4ipqt6jo4oPpYT516UevA7FDCdI1XXiIenPJmts+5Q9QOEeCgbI0aMGDHmNALFhEaS50c/+hHpSb3//e8nfaYHHniAtJxWrlwZWebe8573wLOe9Sxy3/unf/onuOeee+DLX/4y/SASiQRcfvnlcN1115GlFpJUV199NUXUe9nLXuZaVmFUwLe85S1EoJXLZXjnO99Jkfl0Iu+1LVQWRVFusMSFDv7GBQ0dGBosArxO7E3TEE/o6xY9WYckkqXtnJSicDdtkrKGzxXCcLO6cK0WHM0DnYWpzgmtKh/NcGFsprVAEGuMVkKnXlvtQsBfa1pn2K9xfJBejg+BqRrPKlcxccPMW7zgZxZ3D7Pus5w+ThaFWJ4OJ7KjQ1CoSKl2cblo5qbf1KpPZQEVpM/6zeXYPkha8RtY3gUT+5nfZlCcO2nO5ebQsMSdFyJxOdJMW9ZHZBZjOvMDWfwaHPzMphtymHnKBCZt6alZKfZ1Tk+O+ja+xwv17sViHxbXASZ5FMH3C9WY1nHb9Xs++w6D4fDuva2YF8XDU0YE4ruBSELJOk61JmLzj1WsPzxpxwiiMWLEiBGj+aTUI488QtHrUAB869atRPYgKYWaUtu3b4dvfvObEBVOP/10+MlPfkIaTxjdD0mnz33uc/Da177WveYDH/gATE1NwaWXXkpk2TnnnAO33HILdHR0uNf87//+LxFR5557LkXdu/jii+GGG26AOQ22YCUR2WJzNv78Qoe5z/GucQxeCwq/E3tdqCxb+EUPRpNTF2bGYiM10zcCmbmz77EuEoKIpqdLUwh9izDaHbO1wQ9qWddK6OSr1S4EYeoKSR60kNLRySELp5w+CSJumPFzOvwWwtKztGkMWE4/J9bK2UA4blxexLCuO3GzrUSauek3teqLss+q2t61qqg1bmApLYdMdNtSuE/sC+KG0U1fcw4LOnfJ7pMdssgOOkzT5sk6RmjILMZ05gfarDNPMUkwDC/ySwcmLmt+9RF0njIdtzpl9CPIpHnlrafSttUnfcyR+bplDNJP+bmFxkkyOCHt9Xz2HbouMhdEPBgQpQ6aMS96vUv4QwydNRGbf9h4ynTM/qFFjBgxYsSIDAnLQltnfSAhdcopp8D1118Pvb298PDDD5NL3x133AGvec1riKg60IAugUjCjY2NQV9fH7QVqk7EJVxg4II4ylMjqbuGZKPBu2m4xI9gIi/ep9rEmLor+LmZeJJjCqjyLPue32Az8WeKFGOp7zfVqWhwTRDSpYhCTh6Y5UlUG3a/dPzcBrwspUzSRui6Lfj1Ed260e2jpuk3W29G10LN1GLP1PItiEWgCXTmliDPCzo3BUG7aQmxOiWLk6T+eEOXUYTrSq5oF3YdWbN4EPfNLFvD/Okz3/tBLL+KiAtbVr986jzH613t9RzZWEboutXx14St76i1+3TmbdM51e89gZBpYDYDYp7wudhfSerAWTPqztVh5nSvedUvXf57zDv2H1zveh1EttvcOhf2EzFixIgxlyyl7r33XvjSl77U8Dm67Q0ODkaVrxi68HPDCIM6f36F2x0vuovuc6Jpu5ZZukFkKB2rAdkpnnidrsiwDPz3lAb+YdWfdntZqoh58TpJR8KpNDWjySNzTUBCStQRisrCwy8dXzchpicU4F6dPiJLw8/lQbdudPuo2J5h68zremYt57XQ1rVQM7XY461ryGpKsC5xrTadDQMRpIYklxHBp4jo5BIEHvXlla5owSCzUIxqwzOb7lcy8NZDMj8fmcYLadU4LqOupZxiznf/Lbh7yhA1eauc1zUig3mljX+zyLeyOT8qiyI/6y/Wl/D9w/b3jPBwDzasRsFvMS2ZC5xsrsB/iy6eOm6gQa3fohpPfJ0xQoYFY/BKF8uBkwCb32SkU3l6xopHrBO+ferqssnuZw11gv0drcO4NhbbV2Xt7XU4GYllmBAEgaFaBCjlAbKdtu6XjiUwX99elusxYsSIEWNuklIYlQ6ZfhEoQL548eKo8hVDFyo3jKihWljTItYhomT6MKr7xIVplItUnUWv1+LVj8DyI+tMNyFe+UXCiW2IRRFWLx2hqBb+JgSdXx3rbLK80pZdK0tD5TKg+lu37Lr1GabO/K7X2XTpEtUuAaHQSTEVFKaNW97ZCKDeh8/rRUaeGRGIiohOfPlU93ulK7aPDvGpgyjcr5oNlZu0DLxWDc2LvMWHYs5XuXt6pa9bxzICRFa2IJHB/PKiO+ebEG3iM/0OYFhfIrJXCPrRQDpwgt8NaQlkDaYrmytkLp6y8iKhQHOF0z+idM0N4pKpals/1zHsVzIXPzFdmh9lmWURSR3yi4I9JOVpNVg3SayhdSGbz1w5A2EewvaledkJYEG3cHkLM195tY0fgYRzDDKt+JsPZKNzuCi6CsaIESNGjAODlHrpS19K+k4/+MEPXLFx1JL64Ac/SFpNMeYAdE3Mm6n5Qae3bIHkcUKpC2Z1QQtlRwDTK/8m+TYhsILUo9cinenukLCwYiEm0xGK6nRep3yqE1PV5p5feHqdtrJn+1kp+LWJjnWd1/NnPvC/Ryd907bRsVgMQlSb5oO3BGD9kRf5x3+ncgApJmrtAxl55kUg6pCaPPHB5hhdMlNVLzrEpw68LDhllmcmcK09nAKH1RfUKZ+oVeNXF6rxpBrfunXspYOlgyDEdlCXYBOizaQN3Oc6Vi70nST/XgS0FxkrtWxx+phn/pIzhJ+MfFEhkDUr975Ci00VQalqW5FwE9+DmA4SayoyFT9DCylm+dmYWacuHNdYlfC/rFxISOEPwpSUarDklRhC8tdUMU+OBbc4j8veGaq+r1pL8IQ3vwZEMlRFIJHlGaszj3qS5dXPcj1GjBgxYsxNUurTn/40/OM//iMsWbIE8vk8PO95zyO3vbPPPhs+/vGPNyeXMaKF14tcdzHoRUpon3I6J9vk+pcOd5LFrC4wTXdDFpAYaMi/xL2jVW45uAAVF6Fem1s+/376DDKLBd71yWQzIINqc697cslb5ZDODVska+hwmUB3UT0bkC3sVYL3zc4vbwnANpvUPsw6ybI3gbpuHTLyzItAFK13ghCSfp+r8qlLRnuBLE64aJ1StxhK3DsdWTvT/ejGi2LbHvOfOPZVOjm686NXW4clanTr2CW7cdOqIX7Mu42SLqBkHvHrR6aWVDpEk+6BgI5Vr4qUJFJEMX/I5muxv4out35jnayuUG+R6S/6EK/84ZIf4aXKo4p4EcvpuhtL+r/KUlD2nhWJK3VmZyL/qogllQslfzjl9x7nSVLZe5KVVVW3VKc4lhwy0Q+qvq+yXBTbDK3oyJXUcfWXEXX8Oogvtw5xG/SALkaMGDFitDcphQJ9t956K/ztb38jkfPJyUkSPkcB9BhzBF4vctl3yk1QSGKLLRwpXZ/w4irwiy9c/NRQK0NjMesFPv+4cGcnlF4LNFPXNB0EtSDwc0dQaiVxkJ0Wi9+blk92cqmj7cNb0lH0t6RZ5EITDSGvjadpumHg5yYXNL9hILME4PuASX/QqbdmjKnZBJbB4ok8vtwGxLe0nR2dGBT+TaTVY0sc+17aY6qNrZebHHMzwkMG1JrSIbjDtmuDtZAPMP/FKVtTx8qYzSOqPOuWwZPsc+oVN99W2twKS3tu0NRwlPVX44iqlnPg5JANOi6hLP2ERLdJBnpH4L1cfvyIF/FZOtaRsvuN5luJm6hI8okulNqHU0Kbeq0BdA7svDTSRKjqSkUM1vUr0UJKQ6vK14IvRowYMWIc8KRUuVyGzs5OeOihh+DZz342/cSYI2hY2Hqc9slIJjHktSmxJQO/cDTZ0MvEXXExkw6greWn8+JagRguUKM4nQtqQaBy1VCdwvJtxbs+4SkyRnbEa0U9Kx1LDE8rHuc7L+2aun7kLNjdVa6BDpJXXTY8R+Nz3XTDgI05rDe0fOHzECa/YSC1BODLbFB+sd50iG8/6x2TyICzBWUbSTasfmnwlid4H25apZFP8Y9k473khumI0Xu5EIkbW9VmE9sAgzKIVlRi2iYWQTqEjN9cJEY5JTdTzJNjxWMyj6ieGcl872SxyuZoSjgalz/xc795QvWuMA2s4vdcGfEsS19lFaR6P6ssyMT3vKosOu1pOt+K17OgDKQH6YwDkzTFscwL16vWALoIa0kqru+8DhiSmi52XkL8MWLEiBFjzsNoFZXJZGDNmjVQpUVTjDkF3vVG53Me/MufXUf+/YrNn9d3Qa7zdCMKYWUlpiXLF9tcyaLt8MDrcFFIm2NH00PUexE/94OqbH7psfzT6SpXv67lEW5gOdFZ2b/pes3+YdLPkDjg8+7VfrK8sTKJZfOD7nO8PpfVe9j+55VflgcxIlHQcRMVZPXAXGHKRb1+LtabrN+Y1C2zeiCB5ya+n1RjT2eMoxURucc6mjI8TMrK2p9ZnrCNGkXBq6jHVt3G3pqxYkHrKqmrl3M/6YfxrkTOfCgTymZzIB4QqOZNkznF5FqxDdi9aLnF/8bxhCR7tst8HmkmWH2Rfo5ABJn2DWZhxerDa56XQfauYOlj26r6jFd+ZM8V21eVPn+d+P7XeT+r3vMmZfEqW5Dr3TJj+zoujiZp8vOAKFyuWgMEXYsEAV8WWTuL/Spon4wRI0bkuP766+Hoo4+GWivmijbA448/Dul0GjZs2DDbWTmoYTyrf+hDH4J/+7d/g5GRkebkKEa0cAVwJadLjEBhJ2zsWnLB4BYuzJybFkDO6fxsTlT8Il13Eacqm9+C34RgqxN05ReAjsWCyWZZx92MT09nsWlKoGC5s9122xudBkuewT7H9bPX4rRZiOI5fgSmiqAxJWzEMYfue6Vpu+/65Q/7QGkSoDjpf70uVJt9vh50SSF3PhIsmmT9xqTNmNUD29yFgddYEstuMsaZWLHrDhyyf9bVmbMxRWJKNbZ0yXzsN9jfSP9GsrFVkbX0jknbZA+z2PIiu7StQQyIybo2cFwimfsYI9eYFtJsb2rFfqYiEqI4vDGFjNAM8t73u0+3ffnrgrz/gx4eiOsGcf2gU0avPGHekSANSoyFHiMaCENkea0/TdPh16oxYhwEwEBiOj+33347bN261f37//7v/xrS+shHPkLf7d271/e54+Pj8MlPfpICmCVb+J485JBDlGU84ogjGq7/6le/Cscccwx0dHTQ95///OeV5RZ/8B4exx57LFx00UXw4Q9/uKlljBGxptSNN94ITz/9NKxYsQLWrl0L3d3ddd8/8MADpknGaCZUGgXsO14rhLl7eOn10EmloHETFEF0ZYK6SqhcUYK6Xfi5/fHPDLIgM3U346+vi2rIta9pWekeQ5dI1TNM9aTaEbquFQ1aJT7aPSqwa4mQ4iIvqbR+KF+OLg07Oed1SILWt9i3ZJsDXbcev9DfQaHbV3XqQDX2ZBsjkzEuEyvWgSrPfF8i0Wok5DzqX3SZUfVD00hfdS7UGlo0QcZAoPHpjAFsL13x/VaiWa6/Qd3LvOo9aF797tNt34brDOsr6HueXzcAi0iHxCGXh6B1EzRPYdLR6RPifBOmn3qtP70gy4NJYJO5traIEUOCb33rW3V/f/Ob3yRNZ/FzJGYw8BjDRz/6UXjFK15B5EsQfO1rX4NKpQKvfvWrW9oun/vc50inmse2bdvg3//93+H888+v+/xLX/oS/Ou//itcfPHFcMUVV8Bf/vIXeNe73gXT09NEpon4whe+AD09Pe7fKXLhrwemd+GFF8IzzzwDhx12WKRli9EkUuplL3uZ6S0xZhP8IsRPOJhOIfGaROOmMwzBEkQsPeqFu4nGQtCNq7g4bNgEBsivkYUSp4PlRy7OFnT1pKJAkIWp1z26i38ZQWOiw+JHZngRrEgKkIUI6gVlFfprzvW65Rb7lipamQ4pxNJyhW2dvHgSQRFqRemQYu5cIUQLk5XdZIzLxIpN8uw1TnTqX7f/mpJnumRXs8ex1/zbTJjOM63SxjFti6gDW4S5r13ArxtIwJ9bK801Cx5Rl4uf28T3BK8hGqYNg94rznmm6TSb8I0RowX453/+57q/77rrLiKlxM8RaCmFWL9+Pek+/+QnPyFiKgi+/vWvw0tf+tIGa6JmQ8YvXHfddfT7ta99rfsZEnDotYWWTT/60Y/os7e85S3kavixj30MLr30Upg/f35dOv/4j/8IixYt8nw+BmzD+26++WYi9mK0HsYr5GuuuaY5OYnRehJAXLTSxgsXAII+QViCRbVI0FloRLWoNVmg6yxodPIVZoPmda8fIUZWEyFETluFqDcsUZzwRrGYlREEphZnPJDIoIiDVWcD5EGw4rOznTN/82Peq769yi3rW0HbTGYx50cEkeWXc72fdowf2HNIe4mLICcT4ufrTmUhxq5lbipB58cghIDKYi4sxP6m47rczI1fFJYougEYghDZpvkLaj0iyzNLL4q2150DTNDsvmEK0/bl88/GhHiwFuXYayZ4Qp5FLGQWX3zbM4tbdk/QCHdhrJXYASnNuTXzeXauk6ExYgTEq171KrIWQlLl5S9/ubG11JYtW+CRRx4h6yOR9Fq3bh186lOfgr6+PnLv27lzJ5x44onwP//zP3D66ac3pc2+853v0HOf9axnuZ/98Y9/hH379sHb3/72umvf8Y53wP/+7//Cr371qwbizrIsckvs7e1V1gnqZv/d3/0d/OxnP4tJqVlCm79FY0QKelH7nMyqrlHpiHjpDNRdw0KeJ/TSVGnPhAXTS8GNrjL/kryKCKrzEYVeg187qrRJwj5XvFemr2GCqOpQjGTE9DJ0+rsIr3vCiFyHhUwLhFyTmAWUhmaLV32z6/w046JqMzEdmXg3mwfIuojbgIuQzRt++ae64/uyE2kSrbJkdYJ9izZYAlkfhX6P3/2qOmf3MAHvoM82zU+r54kg41i3POLnuuXm+5lp/nSu19U1i1QjSOO9J9PH053/jNcMAdPwuhbHeX7M1t0zzb9sHEbRN8PApD5YXvmomXWHAtx7gukZNmPM6YAs+QWNTpM0o1xbxIgxh4Buaeju9vDDD5O1lCnuuOMO+n3KKacoSSIkpt761reSFROSVWiRVS7PrJ2KxSJpV+n8eOHBBx+EjRs3wmte85qGzxGnnXZa3eennnoqaWCx73kceuihMG/ePCKlkLAaGhqSPhPTQLFzJLBitB4BfAlizFnonDbpnmwau96Bf8hz8XqVO0+Yk2FXbBhN03OK/BuEZ58NK4AoTp/DaPs00z0wqPVHHVnDRa4zzZfqHsxXeXpGUwTFaU3cUPmyhXXn1BknfuVRXddsl0o/yFwFUag6lVNrFZnUBwMfoYyIHUxbGPKsTnATTmHbPTafYU/mg9wvWsyJVmZBEZVLUth5gh8vvEVRkHGkql/xc9124PucqSWJzpj0mlPEPIr59asfZdoa7z1mucjr4+nOf1G465u8L2XX4jivFrj3f06uxxjEkmo2YFIfdVaqwjtfZjUf1jpKZf2qC9lYjC2gYsTwBZI46MYWxFrqiSeeoN9onSTD9u3bYdOmTa573FFHHQX/8A//AL/97W/hJS95CX323e9+F970pjdpPQ8tmFRAqyfRdQ8xMDBA5NuSJUvqPs9ms7Bw4ULYvXu3+xnm853vfCecffbZkMvlSHvqpptugnvuuQfuu+8+svoSySt0A8R6OOOMM7TKECM6xKTUwYgoXJSCuN6prldpbMiuD6qLw8B0UnCjq9p0ycoWhlDw0sXxq0d2L20SIzz9U2n7mNzbDPfAoBtZ2rh6uJfquu/45QsJTde1iROU1zkt99JN8suDlwtdGDJERFSL/qDjRVVOr02S7jzj5UaY9OjLblmymu0TwL0qLIHKLAURvAhzEDAykGmTUTsYjKmo5gnVeImSyA+6GW/25tgr/YY8Cvn1qx8VWaD7Thf18bzu49/taDHnjjWP9HFMknutE/2RlYknOnTqXXZtpgOg5gTnca2xufnbpG+1g5i2Tt2L+WsWkSbOQYys1Tno0HWjpe/Ae17ySztGjIPEWuoNb3gD/PSnPyViShfoFpdOp+tEwXlccskldXpNz3nOc+j35s2b3c8uuOAC0r4KAySGvve978HJJ59MQu48UFMKCSgZUAeLF31/97vfXfc9CqMj2YREF7odXnnllXXfs7LpRCmMET1iUupggJ/AeRDoLGz8Fs++Ghuy6xNO2HNuk8PKprOgbKbYsO7psio6np9LmktIGTxftiCrs0Bw6s2kLzTzdJjfyDIXLldTIkSewm5wMV+4oUFSs85tzkAbRjXuTPsW34dEK5KwZKlXPfr1Jb6NwpLHrJxh68PvWTIyiXnCuBthzuVPB62w+JQ904WhZYLq/eBHWMva2MvS0ctCV1ofzJ0sbX5oEEX9eqXRbAuZMOmbWHvxkXR13+kNenke9/GHDGSZSx+q6xd/oxVPTYheGsQqTZYvfPd3zJt5t/Dzt6mFYNjDvSj6qE7dm+YvaL5Ea2V3PsX1TxEgw2sdoktvyX6fYpuIefXKu2m5ojiEjRFjjgFJF2YtFWWAsjVr1khJnP3797ufLV++nH7C4E9/+hPs2rUL3vOe9zR819nZCaWSEyFYQKFQoO/9LMne+973wu9///sGUopZbgWNXBgjHGJS6mBAGPP0KBcwqmt1rIVc4sRydGeQmHK6r46Qswlki5gwaYuny7rWQGyRR6e4HBkStixhXE+aDX6RXXX0JKgeQuZR1X667Ur5QmKC3/gaWimpNhBB+lYUJ/oyVxzTZ6ry4VWmZmwSorCqUZFJjLDTbR8dyy2/fJluDHlLwbCbNtGKTFVuWRt7zW3GG02FO5msr5psanURdRs1Gyp3R1W5ooykq3PIkMR+wfUXr7lDtMaK4r3OoOrfzELQZMyFyVezyZKg+QuaL34OSnIWUkhIsTUbZOtlFNzACgZutKblarZVY4wYbWwt9cY3vpGEu3WB7m+VSgUmJiZIf0mWrp8bHloqjY2NaT1v2bJlStc91Id69atf3fAdEl7VahWGh4frXPiQqEJLrxUrVvg+d/Xq1TAyMtLwOSPX/CL1xZhFUkpU4ffCZz7zmTD5idEM8C9ltIyocFGnwiLwpi+pr3XF30ffIUEjWbDqbKx1FtSyRYyOHpfu6bIsOp54cqjjkqYDd1PAWU/MlUWaTj7DWt2YWCSoNu9h4ZeOrIwmbWiy+fOC7JmqfKjc2aKy1NTJm9fnOmmYzCumFqJ++RLbTDY/qJ5pQpZ6WYfIXGUa+mJSXi6ydsFNKJdX041mmLaLoo95pRGlu2RUMLH6ZO+EILqJJnqEdX1Ew+KN3dOwNmlC/Yr917TPhJ3/m/0eDpq/uvWigXVsw/McS0fU7sLfTDqBrk07On1p9fpKRayGno9jxDg4gILeKEZ+7bXXwktf+lKte44++mg3Ch9G1guC73//+6E0pVAo/f/+7/8oEp6MYFq/fj39Rk2oCy+80P0c/0a3P/a91zNRoB1dA0VguZEMO/LII7XyH2MWSClRyf6BBx4gJhUFzhBPPfUUsaeoWh9jlqDrasB5Vmil45Wurrm7TDNKlq6O1UXYBavOwr0ZJvF+6ZcK9SeHfvkQ4bdQ5HUd2s06SoWg1jvNQpBNRBTWFLIymvQNo82fjqufhKw1yX8U/Too6YjkDpIJRMih0HGAOUDMFyujKVGtQxyw9EXLgjBp82CWiNiuyYx/2/kdavDzjWjl1Ix2b+ZG1O89wKB6n7UauvOT7J2gKqcXIR5Ej1CWj2YGwGhWfubi83RRt14U+ogRGetYOpJ7ZEf9V7hmxPmXuci4rn5IvleiOzSNEeMgBm8tpQsUBGcET1BSKqym1K9//WsYHR1tEDhneMELXgALFiyAL3zhC3WkFP7d1dUFF110kfvZnj17YPHixXX343X4+Yte9KKGtO+//3447rjjKFJfjDYlpf74xz/WWUKhSd/NN99c50uKrCgTPIsxC9DdnPu5opj69ussEGXaO7IFsZ/VRRArpahPJ2WWR6q8qDaueGoobozZKSJ/mmiy0fFr/yhPZXXz1YqNWivLJbMcaYULUCRkmEZeVXnBTUJpyjntTnunJ9OpEvNvcvpuYtnpV5f4fXHCLgumh5nE0OduHgyepaMbFTSflIxQxzgvkL4SauppaKzpPpfaxAnlzPo1v/kXXbwsTQMbVZ/V1SCTWeOw66QHJFzboZutKrCETl68rmN5wEqgd5kjBo9tw+szQYhDH9PP3Dz4lNfUEkxWLl09QmbZxwcUCdMOvFso/V20SVQ+iqZ0/tAgs8Rr+PrEvq+zxmkFaeYVMEWHJI8iaqVIxnrfXK8JV5dH4TvWvrIoqK0I/BIjxgGuLfXQQw9pXY/R544//njSW/p//+//BXpmWE0pdN3DSHkoSi4DakZhmd7xjnfAK1/5SiLBMKret7/9bfj4xz9OhBXD2rVrSZz9hBNOIBH0v/71rySgjtZUb33rW+vSLZfLpGX19re/PXDeY7RYU+rTn/40/O53v6tT38d/o4ng+eefT+JhMebAKaluOqYuF7ruOrLP/PLWLCulIPczUs3LhUG1ccV7y3mHpMMhmJQLsJuUV6ctggpii1DlS2z3ZlgxyRb/UZRL9wTYtEx+4zKI5Z7JJs6k7lX34ObStXTMes8xMp0qMf+y56ierUOCqDbQsrzRVxQaivuM5cHAo0lsVxPSMEjb0NyQczbmATXWVBZ3SMy5hLmoCSWML119LdU8q2MNq7TG8SD/+LbDTWtxyiZNorB6lc7jTr2w90DQCJy6Y8HrM15EnCfO/ayddeqmgZTU1CNkln34nsM0sp0Ayc7g7eAeBqHbV8nJmzVTBuX8oaHfKF7D16flBDrQ7SOmUWNNIJtbxeeL44TvCybzjmrdQH/zbs2eGa63lhTzyH/H2tcrCipfBzjGgwR+iRHjIANG0kNrKV13OgSSUR/+8IdJG8pPNDxqjI+Pw69+9SuydvKyVkLiKJPJECfx85//nDSiPvvZzzZE20NS7o477iB3QBRBR5LqAx/4AHzoQx8iqyoet912G+lMYdTCGLODhCVz6PQAWkn94he/IF9P0ZoKfVZRHO1AAw4SHBwo3NbX1zfb2Wl/uFZQERIhYS1vvE4ZgzzXNTenVZ+8rCaWUlGXN+q20DmJFZ/VDEsp9gzVpjlMuhQeHOqtZ5oh7B80PZM2DZKul6WUl56R6TgzspTSKEcdMeChccPnDa030FWEWXKQBRLb2Df59D3ouAg7nkz6Y1CLD7++Yjp+yBqVcy1U5Y1Pl8YyEswpgGyX/tjT6YMsD373RGkpJdaD+BkjHNiYczf/AnFmMleGGY98P0ACwUICoROgo8dcIkB3jpnrllK6Y9PUUorvC+xvnbxF8Y7xamc+jybjhrXNHLaUivcTMdoduNdFi6nrr78e3vzmN8PBAoxSiFH3fvKTn8x2Vg5aGFtKvfzlLyfGFdnJM844gz67++674f3vfz+84hWvaEYeYzQLzXKv0rXaMoXOqVgUkcZ0LH50IlQ1PIf9GxdTPdGUt1VtoXNC3mA9IuQ/is04f2LudaJq+jydE2BxUe3nvhnECkqnDLptSif+SJpqLtxVeZFZ8Xml4ef6JnuO6tk6Y4CvD69y8nljmkdITDHrCBbdstmbnKDjOiorz2Y+A8l2tI7J1ORznEn6tAkVN/gKLaS6dHm3UZ/+UDc/Kdw3lfO4h2u5rnWSzlhg9eBuyIW6obHJjU9R6F42X+i4KnuNRz9XejZnIDnJSMqoAkbI5pgw84f0GsOlcdhxo/uu0NFZ4vPC94W6z32IQZ13jF+effu6wVqOJ9fwIE/3vjlGWMWI0Q5AIwy0JvrUpz5F+30U/j7QsXHjRvjlL3+p7eYYo00spaanp+F973sffO1rXyP/S2YeiGwqduDu7m440DDnTzZ0TtGCWpu02wJAdcJnYinVCouf2UbYE/4gaQS12mr1fSpgaGu2aSVCownWSkHLID6LXETRGs+x/AprIXGgQWYd0SwtmIMJpTxAJQ+Q7rRdtvyga/2ha7kUBuUiQA11kLIAmVy4cRrl3COzysXy6r7PZPUYNn9h3pHtNse0Q37C5sG0PaPor82uNz5PJlZe/Hvaj8CaBcz5/USMGDFitAspxTA1NQXPPPMM/fuwww47IMmoA+YlotpM677ovTYBJosZVTpimqaIepMSxtUvSoR1czBZuPFl1nVZMF38tdptKepFM25amVtQpiMciSHrs35uSaZEapA+rOvGqCoLzQkG7n66aUaJVogSHyjQdS8LOv8GJU/5+6Mmf4L0h2bO1apn6JZddl3UrqBRHwBE2RazJTfQSjTDjXQ28hXFvWHI5RZgzu8nYsSIEaNJCLhjABgYGKCf5z73uSSEhtwW+mLGaEPwIrC48JKZcweNNGXiHiamQ5vfsp0nnchFOul6ia/qglz2HLc92rzO0oZVNI/XMfHXTlsQdebdG7XFXQ2EoWfDbSkK90ceTK+FYIXbwMjGlEwkV7cMMtfJICG1xWhsKncPZVmSMyLHiKCkVJR9fTZEiQ8UyNrBa14ynX+xPyGpbQV0MY7SVTyMu7GOW17U+dMtezPc6YPmpRXj3/TeZskNtBJBXCCb3V/DtqMqT37jUjcYQ4wYMWLEaCsYv4X27dsH5557Lhx55JFw4YUXEjGFQPe9OPJem4JZRZEFjARMH4LcA2RwwvcicUQCk06IZ0pbEJv0SovlgWkDMTCyTGcRIUufT9crD+Lnunk1hW99atyL1iZiXevmSef5Yp9gm0M8XUTxZxZ+3gvY7kGsG9oRWFdo+UWnrIp6wz7OymvaL8Q2EccCndJnG9tXpy3DWJKJaavKWHMsWvC3CLFfkoWU8yN7JtYx1rXXODQZf6bjzau+Y8jrCuf+0rQ9L4lt4zX/+s3FCLSydAW6DedM8f3TFPKSEdFtBt2yy66LumxRt0OY96/pvc3sQ3MVumuoKNrCNE2/vnsQtedNN90EhxxyCIW6P/PMM+Gee+7xvP6HP/whHH300XT9CSecAL/+9a/rvn/jG99IxgX8z4te9KImlyJGjBgxbBjP2u95z3soDOP27dvrwilecsklcMstt5gmF6Ml4ELzyl7ovgtUa0YUmP1b9cL3SotfLPCbX/ajo0WBQrq4gOHTFxchqjyIn+vm1RSydHUJMXYvWZoIda2bJ60NhxCumdojZ5u7ExHmfOe1YNTJTxiCrpVglmJo9u9Vb3yZTcomtok4FmgMpP03jzxp6W78PQgjkzzJyqhjFceu5wXEMeqZzEqKnsmiclX1xrSsnvnPTDfYXvXdTn13tp/P1xXO/cwCTuwfXvNvFHNxVKSyad3KNtTt0CazTfq0AmHev3OVlPAjc1V93OSwTRd+4xbfNTrPUM3j+P5iJDf/LB1Cu937bovw/e9/H6644gq45ppr4IEHHoCTTjoJLrjgAhgeHpZef8cdd8CrX/1qMiB48MEHKdIY/mzYsKHuOiShmCcM/nz3u99tUYlixIhxsMNYU2rZsmXw29/+libA3t5eePjhhyl05ObNm+HEE0+EyclJONAw533AvTQ/2IvfKxQ62/jib9pE+2zkotB0kqWhq3ejun82dRR0hUVVejcmedW51usa/jvX/D4iQdx2RRANJr+yiePOS7PLq8+ysUfR4fBWi3M9SznXcBoaun3F5Dp+jkDI+qisPpi+FFrfkXt3YoaAwjGM9/uNaWm6hiK4Qcb6bAvmNnPsGOvuGOiEeb1vVONNdZ0uTLWpgmoh8vOhTr8Lima9m5qVj3bJ71zKnzim+D6JkM15sj4uzlNRzBt+ayhedF9LWB1JqKmZ6Hm0lnPKjmWRjS9ZHRwAiGo/gZZRp59+Otx44430d61Wg9WrV8Nll10GV155ZcP1aDiAWsAYYYzhrLPOgvXr18MXv/hF11JqdHQUfvrTnwbKE+Zh9+7dtDeM5VxixIjBgFTTxMQErFixwjOao7HgB05qvIUUw8jICORy7ScqGMM5rWJhpBOC2ClaKdA1HhtxprGU8LGSYteG1jtS6BBQ3jVDvwcKURwRZOmKuhXktuWcBuJv3upAlidWJ3gttYVHHeiUi79GXICqQkoHWeiL5W7HzQHLk9cYCKJFImrtMJ0yXIyLWkaqPs/GHpJORAo5Lmc0dbOQ8FwYb6+0ROj2fyKgJOSTqMkkqw9mXYP34GaENhhpgBpHaPmNaVm6/Gc65QiibWKqmRY1mql1o1sf/HhF6zfxM1mbNbRH0l+3L6wWoKk2lUnd8nXF3xekDnXnFyTsGNHAa8O1ev7ULWMUGnBh3JD97vPLX6sOrHiI2nsNawRhfUBzJZJX7ECAlY0KAFBBfc5MNPOG7xrKIdT4LYRXneG11AZsDDmHEXhYwa9PsVy8FZRXOfyIswM4kEWpVIL7778frrrqKvcz3Oidd955cOedd0rvwc/RsooHWlaJBNTtt98OS5Ysgfnz58MLXvACuO6662DhwoXSNIvFIv0w7Nq1C4499tiQpYsRI8aBih07dsCqVauiI6We85znwDe/+U342Mc+Rn8jG47s+PXXXw/Pf/7zw+U2RvMgW5Txptl+C5hmbpB0n9UsEqnVcBdNMONS6VcuVicugQLR1YXXgt2rzlUbJ69FYxSbl6gRNE9+/VFGRNLlHKGkula14VZacSWbN1Z1yyGrD6YrxSylxM2Gqg4b+o5Bv9Qpgw5mWzC3mfOdbn2o3ht+4yUIYW1yrzQ9x3IQQZZ9IYh73opFlc8wdagCb4kiI0RlaTWTQNEtY9g5hz8goyQMykFEvxM0RWVtaXKAIIr3N2sM4pzIiBlZn5QFW6GAMMn6jsEH4IiC4NWygBTc/9mzVXWG44gOMdg7JGEfUrDgSO6hG5MO0BijqucdBIEs9u7dC9VqFZYuXVr3Of79xBNPSO8ZHByUXo+f8657r3jFK2DdunUUXf3f/u3f4MUvfjERWik8/BLwiU98Aq699lrpxnNOepXEiBGjaRaiaMmJVpReMCalkHxCofP77ruP2PoPfOAD8Nhjj5Gl1N/+9rcweY4RBl6nQ8w/n98UmlgeIfjTrKpjuu3lnhFmsRx2MxZ2kd6ME9u6BZRjli6eCnqlw+okIbjGRIGgGwo/SxLZZqFZ5GaYNmdWa0xcXkX8mD5DZo2mOr316vNkvWZgLaE7fnTLw9Jz3fgkLqcqEoAsAJzNlWq+CEte6pyMB5lToiaF2slKULdsflZqKui0n59VqMlmUja/mvQdsU14KxayEHO+c12jDCINBrHKwjGT6tAjwkzrS9e9XdZGMjdn3r03KMHokioa87CYNhI1RO441mtsruLnBGZZhNpolcoMWa4iHsW/m2F9IxIzDd8LeVAdImI+eBe4IDC1NjOdF8jlF13LHZJNVd/U9h4HXTz8yGLZ4U8MT7zqVa9y/41C6CjJcthhh5H1FO77RKClFm99xTaeSEjFpFSMGDFE+Ln1GpNSxx9/PDz11FPkx4yMF2pIIbP+jne8A5YvX26aXIyo4HU6JLrfBN10SZ/hsQGYLasYnZNTv/uD5NvrPnEB5S7sDDdl7WQt5mdJQp87ekFssxCEMGH36y6Yg5APdS5yEW6Wozq9leraBMiHLE+66fidTKvS4V1PiYwVrCFk9+tu5HkLC7ov2ejiqquf1myiqB2tBP0Q1EotDPkc5F7V/Bq0TRhpIUaQDJI3kzmbT1+XcHY34Y5em1dfFi2SeLd+nf6J11SEeZICLUw5VjxpgGz3jO6YKk1RT4kdkBHB5TEP8/dRIA5nTmUkOaYjmxPYvEtRP8sAxUnnQCjRSDzK6rkZ1jd+fUnMg3iI6GdNagKdtm/om4bzgtf9/MGHrsu0rkzDAYhFixaR5dLQ0FDd5/g36v7KgJ+bXI9AvWB81tNPPy0lpVCyJZZtiREjRlQwJqUw6h4y4R/60Iek361ZsyaqvMUwgdfpkMlC2muTxtKxWCQ+xwpClbbJxjLKjaGMDNF5Hn8aiotVUe9J57mq8urorOikE1So2+ukN6z7mspSRucEV9UWKssHfhPFXx/WAktHkyaKjTYbn2wDqXvy7ndKHQgJe5MlvgZUbeJ1Mi3TR+O/Rw2SYt7Rv3I2obJ06/qpAJVFFZYB6ybTOTNueRdXr/7dbKKIz3PQdmsnC6uorfVkCGrVJtNNVIHvZzJrVYrMmG79hjeMRR9vxcVbC4njhUEkonT6p2yeZP+uFu3xR6SRU3eqNEU9Jd4S2DVukuSDv48OnOgfjZp3DIy8YtfgHFFwAi3Q1JdrJB5N11dBEGRMq4iyKAkyL2IzbN+X3S/Wg3jQ1Y5zXxsgm83CqaeeCrfddhtF0EOgjAr+/c53vlN6z9lnn03fX3755e5nt956K32uws6dO2Hfvn2xwUGMGDFaAuNZHn2N9+zZ0/A5Tlz4XZRAn+mrr76a0u3s7CQzUtSy4gMG4r8//OEP06SJ16DQ36ZNm+rSQdfC1772tWRO2t/fTyFRD7gogV5hzvmXvR+8QnOzdFy/f8s7bfE7Rl5Q5BbNZwYBI0MorxJ3AlkIej4fvF6CSZ5M6jmqdNw6dfSd0NpHlmdWNlzQi3UdNsSyTp/xs3AS7+XzxP9bdX3Yuqc+k7Oj10Xhuuc3PtkpPxMBpz5ZUYfZ5usgTFnrxqBEFwQ/L0/b4bqxT8nKINus8OOFD/fNvsc5GwMl4G/RepFP16ufytqe+gc3L1EdZ+r7s1f/1u37qrlL9bksz0HbLer50QRB5mz+Hr/6iRIm9cTP9VHM2e0AsS+rxguWt86d2mBekc2TeA9aGnX2O+9djuRRpUkWUs6PX/qq+1RrHr6M7Dv2Gwk1zGe2F6CjFyDX6x9NkuWL6jUi170oxnTY9zYPVpeu9VkT5xp+ThDrgdUzfS75PoYLdJv7yle+AjfffDNs3LgR3va2t1Egqje96U30/etf//o6IfR3v/vdcMstt8CnP/1p0p36yEc+QjIsjMTCPdH73/9+uOuuu2Dr1q1EYP3DP/wDHH744SSIHiNGjBhtZymFJJDMJxAntI4ODPEdHT75yU/CF77wBZp0jzvuOJpAccLFcKrvete7XI2rG264ga5B8gpJLJxAH3/8cTc/SEgNDAzQqUC5XKY0Lr30UvjOd74TaX4PCMhONsUNedATf9XJXmSWHxy8XLD455q6gLTy5M5E5wFPOPkTbFWbyU56mZUBkhCYlNfGRJYnnfZThZRX3Su2nyo6jymCtl/UFjV8e7CTfzEqn597RpCy+FlG8JsAy8CVkk+LCDbOCkJ0h/LKq6nFp2iNp6OLE+T0P6jrYpi5zc+apxUIMmerrByb7lKjsPyjPEjmQy/rvlYgardSmbuXbLywa6J6l9U9V8PqyMsSzeQ+z3kp6ZNGj/mzm2GZFMYiqBlWezKrVa88+Wltyb7XfQfpWu954QC2tLrkkkvIQAAP5VGsfP369UQ6MTFz9FzhQ68/61nPoj3Pv//7v5OA+RFHHEGR91CSBYHugI888gjtpUZHRyl0+/nnn0+GALGLXowYMVqBhMWbHXmAidn993//N7zlLW+Brq6uOoumu+++mya1KMXOX/KSl9AE+9WvftX97OKLLyaLqG9/+9tEkOHE+d73vhfe97730fdjY2N0zze+8Q0S7cMTBAxReu+998Jpp51G1+DEfeGFF5JpKt7vBxTvQyIM055z4n1RvJRdtwANt4hm5yUswuYhqrqI6llKoV7DfOL15YK9dmRWZkHzJANZzjikFAstPxv1HjSdZvZd1cLeL69ByuJXDpkbKP8cusbnmSoCshXjv1nj00QcOiq0cq5RlSdI+Uz14FpRX7LvZqN+w+S3Vc9vh/e0af6RjGSRYNHSqhlo5hww230xaJ7YNa7WlnCt7HtGTHm9g6Lqf21Yr3N6P3EQly1GjBjNnxu0j6oefPBB+o1E0KOPPko+zQz475NOOsklhqICMvtf/vKXSVj9yCOPhIcffhj++te/wmc+8xn6fsuWLXRCgC57DFjoM888k0KYIimFv9FljxFSCLweTxCQSHv5y18Ocxp+L/AoTveismRqth5HK/JgUhdhF1d+Vmv0NyMQAoYr5wkRP02lIOm6biEK4eBW98Gg6fCaNfg7ys2aqk/65TVIWfz6P34vRj3SsSDUsYJotn6TLK9RQVVvzZzTWhEBzK+NvMqnmt8a7mnRnO/V9rK6lEWkbSWJZ5Jf2bPCQvX8KMdpMwku0apHVyA7aJ68rK/bZY0VFEEtoL0sW1Xf67yDopozZrteY8SIESOGNrRJqT/+8Y/0G13f0F0OI+81G1deeSWxa0cffTRZYaFF1sc//nFyx0MgIYVg5qoM+Df7Dn8vWbKk7vt0Og0LFixwrxFRLBbphwHz0LZgCyIx4lSQyDwqBNmYtHKh2sqTXZ0FkxuqGn+j7hbdGM2zRNcYMRKSaX246aX0TpiDujt5uWvo5DeqhWqYdFpBqvAIu3gPMy48XQcD9DOdDUIU47gdiO9mCxtHGQEszCZONh5UVnIIE3cg/hpdMs7ETZPSi4DYE+vAZI4wdSv1S9u0jwUlw03AtA7xwEMku8OiLv8+kWBb4Yodpr5me96S1YlOnlTX8H1xNi2UZrteY8SIESOGNoxma9Rj+ta3vgXbtm2DVuAHP/gB/O///i/5QT/wwAPk6/xf//Vf9LuZ+MQnPkEWV+wHow22LWhBhObQjqky6rnworLNFrAMIkRpeo+JmHA7wM0PRK8Fw9o74fzQYj8r12TQqQ8+PVN4tYtXuuJ9rWo/ErkvApSLM882EWUOU1d8HtpR+DnIvabpq0SPTdJrZf1FiSj6OOt/pMsl9MOo6sWvjWT54fPBoqMxTbEo+pSX+H1QRDGWZelElS4P1rZ+2mJe9WvSP0z6gB+cQKNaFkym4MsUtt9GASuiMSh7TwVJwyQvUdeJqi8Gmafm6pwfI0aMGDGMYKQ0mclkYM2aNWSx1ApgJAi0lkI3PMQJJ5xAhBiSRm94wxtg2bJl9PnQ0FBdyFL8G0X/EHjN8PBwXbqVSoUi8rH7RWDECqahxSyl2paYYidBaClVcdqFFgLJ1pgxB0lX5ZYS2AWRE7gNam0RpbUVX76oLbdYe7P8JiULcZ02ieIk06tdvE4oxftaZWKPzxUty0xEmaM4dRUtG5vpihWmXk1cN6JqN9EdRzYeW22tFhWabU3RinoR20SWHy833aB9ys9FKAiaZXnZDMsM3prVa672qt9Wjhvx3aJrwWSKoGWKuo10LBhNrZdlFtBeELUATesm6jqJ0jU0bN+dKxppMWLEiHGQw3iG/tCHPkSRG5DUaTamp6frokcg0I2v5pyYYLQ9JJYwdClPIKFW1Nlnn01/42+MJHH//fe71/zhD3+gNFB7SgaMNIFCXPxP2wPriQlU82QPO3EDjahqosUIumLgveW8+tTO5ITSPfEV8uJ7gs5Ip8aoj04C9SHpvdJSWcaw+ygCXchw5lGeNKvgVU7XOg7U+Y/iVD3o6ap4n1hfzToZlVmWiZZnzY5yxls26lh/mNSFeMLu1Q/D1rGOYLpp+nx+Vf2zFW0kQ9j6YhtzKlcTTvxZvTA3bZklYFjoWDqhyx4GMhAF7kv4Dpl2rH2SZhYv7DNyAQ4xr85FiwsT7Suv8d5KK0++n6jyFMX8E4UmmM5z/MaTlwVjUOtlmQW0lyUVI7JqpZl5GeuG1dNsQGY5FqQfhu27NSeIC/6OESNGjBhtC+OYvDfeeCM8/fTTFLVu7dq10N3dXfc9utlFhb//+78nDSm0zjruuONIbB1Fzv/f//t/9H0ikYDLL78crrvuOgpviiTV1VdfTXl72cteRtccc8wx8KIXvYgiBn7xi18kF8R3vvOdZH2lE3lvTkGmm6F74iazGCFNJEyjDJBmC8sQRIvqxMv3BJ0jnVThvfn7vdJSWcawNFwLJOH72bbK8CuzX1mZSLfO/bw1D92nIDRl/SGKU8kgJ6O6ulReuiZieZpxwspbNtIGxcP6gzYfBfvf9LVPXQce78nWf+8HlRbebGmERGFp0kxrFVYvbrQp5xlRPjOotRf1y7wzpzj6cuL3rZhn56KVXVTaV1FaefrVn+67iQ6ocG3RYV62qOpF5zl+40mnbk3Gjt97SjbPMyKLBSqh94GTX5nlfLOhehcF6Yeh151NdCGNESNGjBizR0oxsqcV+PznP08k09vf/nZywUMS6a1vfSt8+MMfdq/5wAc+AFNTU3DppZeSRdQ555wDt9xyC3R0dLjXoC4VElHnnnsuWV5dfPHFJNZ+wENcqPhdKxI75A5XBchiNzEwwVdt5lULMz+RbvE+0QWqwQXNYMHsElIcWVBjp/YRWmXw5aK/OVN7LSszRzAWN3RWWs/tji+ruJj2WujxBF3V0I3AiwjTEYB3T3Yt5yTcsZ4wea4sn0HcwcTvwpJUnuLhijIx6LjkhBnvrf5erAuv9gkTLKCd3O+idnfUeUaUz9QRNRbFyZkFYrrT/juoW5/OnCr7t9f7J8h49itrkHnBSxxeJGfJapjTK+R33M0maHTbyW9uY3M8c3cLQpq0YiyJ0gBhnhsFKegXKZdcB52/dTTImmEdWzfmhTzqjJNmHAQ104U0RowYMWJEhoRl4Yo/hhfQJRAFz8fGxuaGK19QRLVocE/rA+gV6dzruts55IXJc0zyT64BkoiGQcCXC4Hm5LiXYC6XfiBTfTTNT9gbF9O6DboBMybPuOeIWiisDpgLjywv7BpXn0OznH7lU/Urr/vE78il1XEBMD3dr7N6ykRUJmczm3SsrfiNarM3qGEhtofqb6++EgRB+nQMs7ZUfRY1xDlV9m+vZwfJYzPKWpqeIaXQ9dHruTgv0rvJ2ewTqWM4V0aFoARCs8Z2MyCuBVpFAKryonr/qMZClP3Br5+H/V73mjmuIXUg7ycO5LLFiBGj+XODsaUUA2o0bdy4kf6NrnUnn3xy0KRitAt0zPN1rqHFcs3M0oW/1+8kUnSBMjkB081/gytfxK4vspNOL+sRdwPNLYpNFl8mVg78PaZhvOus3gRXSr4OVPkNKmrsdxKtY6Xnlybd62wKTE/3/ayedJ7fmKi9UapVZjaqlrNRnW3LIh461o9ef0e5sQgiItxumK1Nl4kF7GxYhan+rXt/kGfqpuPVZl7i8LJ5MelYSpFmUMUmpb20lXQtXEwJFy+rWC80a2w3A+JawEvMvNnj1uv94zUWospPs61nda85EN10Y8SIESOGOSmFbnSox3T77bdDf38/fYZuc89//vPhe9/7HixevDiu1rmCBpcyDbcpXdIoqJ6ByUYxyKay2aSXX5ru3xKyp8FdzHHZQwIrjdcrrIrc6z1cS1xRBWHj0QqdG9XfqntMNjgmBFvY8mEaeELt1Se8Nu6piDdiqo2qK56OY9gnuEErrIaYfoxVdJ4j0acL0z4mmyuZW8lcI5C89HiicDEV+4TM7bZhjHqMt2a4vInPsD9Q/Fvjft38+JVVecDAzeXi3E8C7j5LsbpnONeS1hq+pxLeViWqOV5sV1PChX+XmrxH5hIZ7OaVs0oNKq7u1QfCvn88x4ICsjYzfYd6uaSL35m+/+lQK9meAvgxYsSIESNyGK8MLrvsMpiYmIDHHnuMIvDhz4YNG8g0613velf0OYzRPLBFiUse4cLUmoliJwMuEnQ2sLMVJcsPuvk3vTYKiHXmJ9DZcL0kwg/7jBEVYrS3dmwnWTmivE8V+UknIpRfn1DloRlRqFiauKFF0jKTsxfjOIarRXsD5FUXYsQmE8jyrSqLS3o7z9N5lkkfMGl3snzM2HXVinEdtC97gR+rYrphnyfrE26ajnsoT0IEaR/mykpEZYT1EmZcRd1OYnq6Yssm+dadu1XXie3qFT1OBn5Oa8f3iA6069uqJwCDzB1RCG5HuSaRtZnpOOCvF+uy2e9x1b2srdrdCi9GjBgxYoSzlEIR8d///vcU1Y7h2GOPhZtuugnOP/980+RizCZkJt+mblOtdC8xEdoM+tyorEd086I6aWQLO9ooeGkgeZjw85+xdhXbV0eUtpmuQjLXkaAm/Lr3qU71/SwKePJPVR+yPHjVYdSWaswSqJbWEHdNzJwo69a1l1i9lzsPnvDTczTb1aQPhG33ZvZ93byZuuKKFhP8OApDDsgsydw5hNtRh2mfIK6spnVn2tZRuA15pacrtmxivaJr6aWa40U3OrcPBYCu9ZPfXBr4van5nQjdfhJF/2g3wW1Zm5mW08tartnv8ajvjREjRowYc4uUqtVqkMk0morjZ/hdjDmEICbfrTBTD7qAjGKDr6M5o0NS6ObFiyCR6Xt41a2ua4kJGlwKFQv+oBt491SUcx0hV5Rk9C56Xht3L7P/ujqA+vqQ5smAeIp6EW2kA4akkiOar9tmrCyyOvTaoPjlK4irB4PutaZ1HcV8ops302eJ6br3hwyAIGsn9izeXZgfo1rueRqurF7aRqbEbhAyUAyAQO5xLA1DcWtWZjcdzXaR5Vunb3gRwn55NHlOWPjNpbrvG6+8mtSFbj/RGcd+78Ao0tC9L2g6sn7rNQb5MlWdiIpsWxF07RFmzTKXXENjxDABHgKWJgFyvXG9xThgYTx7v+AFL4B3v/vdsHv3bvezXbt2wXve8x4499xzo85fjLmIsGbqbEFE0cU4c3A/FwH2PQufHYQkZZYCifQMUeFlXq4yNdd1ZxDzzMqssnjQqdsgLmHiPexvMR+q8gY1uWflV7mOkKtP0Yk+WAtv2k+EitVoBedl9s+3paxd/fLk1ReidMcwbncW7hw7lO4tWA7nepnlRlB3nma4uYWta9MyhEHYZwW936TeVc+QpeGVrqod2D3o2ofRSZGA10lPli+dtvZyI6TnlewDANHl2WTMmfZrWb512pa/Juxc3Mz+7jeXip/pvF/FNjCpC5M5Ieq2jjIN8b6weTEd0/YFToTCOKB3jBiRY2wnwO6H7HdjjAMDU/vs/U2M4JZSN954I7z0pS+FQw45BFavXk2f7dixA44//nj49re/bZpcjAMRYc3UZdYzzNpCR2hTFACXXqcAsxRwQ3BLhNrF01XZSauf6Kf4WUOZ+UU1J/ipU7dBTrzFe1SWF6zsjERj5ZGdOOvUud/Jpmi51izTfq/v/CwK/fLUqtNb43Z3Ng+46WZknI7ViyqIgZ/FWLu7XZi4aUaNsG60QfuYSaRU1fwrszAM0p7sHtI1rNTvbY3GpyaQ9MI5TEbE0POyjZZSpmMu6LxoWr46Vz7FOymK54SFzEUd33lV1bzhRBjEPqG00CmrLaOC1oUMqrYO6jor6wdB50HxvrDzqex+vzRNnhmVZVeMgxvYb/ZvAehf6x8sYq6DkRd+RPP4boBsN0DHPDigUc4DTA4DzF8LbU064dqhe5H8++HHATJdAKtObXXO2hbGoxiJqAceeIB0pZ544gn6DPWlzjvvvGbkL0Y7olkbJARaCqFVTMqxnmGmQaIpuanrhumGPQxJIYPs+fxnLtnDaT7JXPV06jbIRkh3Uasi/kzd1oJq3DTLtP9AcBkw3RRQn3BIUEZ+ouUI+4xFdhPdYRgJwY9L4O5FoA6aygLBzw2EB1kOluy5wG/RGda1VHQtkkW4i0rLxhSmY0nLpQ7UJKNJnclc23Rcn1Xut0TGp2esYGTudVGABL6TcvJf5sbIW4/q6t/JDidwnCDolqSepqGp5lg7zEdeYPWA8wX2awrYAJJ8YzRg7JsltQsw3wbiONF1mdPRkVS1NT6T+oWjASn2JZMx3cy2C9uH/A7aVN/z4wUh0yRshetojAMPhVGbhMGfdc+BOYv8KMDeTQCrTrN/Tw4BLFgHMG/VzDXMQp0ObTyw7xn791yuDx3seQKgOGmTUvu32nulxUdCWwFJJ7+2KE/DnEce++9TAKtOn+mnARGIWk4kEvDCF76QfmK0EfwWV80SB41yM4YbUAtPRtGsngt9baLJI1tQeW0eWnFqpzp5ZFYKKcmmiw5EcPGOp/kGbkdBCCLxHr/FsQ4BEoX1i2oj0krMlVNckw0NIxNYv2IbOgRtEp2NAiMJ+E2fu8FwNoz8I8k9kh6gzo+sL6rqGOcD/EH4kVKqPq674Wnor85GkydrvNJq5sbKdCz5keB8/sKQ+Kp8BdECYlBZwURdp+wdSe9Njf5oqn8nA3/KrbK8kmka+tVbkDlqNuc1fq4h93UvC1YkJzW9woK8c1R1LkL1HT2rLFid0g3R59XY0pnLR9j5qcFiVlPjs87inb0jBKuyKOsiRvsCD5mYfMLO++39ypqzglkN7bgHoG+F3rVIFicSYFkWFCs16KDlC667MzP7JoxgzECfVWzNTYxkvPM+gCXH2BYvOFfg57j53vpXgEVHAPQu03q+EqPbZ0h6JKQQI1vqSSkXwkSI7nwTA7Z73/IT67/Dcmz7m/3vtc+aGY+Yf9YOiC1/AejsB1h8tD02o7Q6wzbffqf979Vn2ofMfN6x3rFuBjcA5PfrkWlYp4ycw7wzeJFS2N9w3lpxsv33xJBNpKx9tt3+2Ea8vIfvPtsCyHSAEbC8eA/7zaeJeRt6DIqT+yF32Dkez3cOQejgmKvLwUcBSlP64wnrENf/WBbsfxOD6rpHolNF/GL7orUipkd7h8a+U6rUoFbTc+vW7nl33nkn7Nu3D17ykpe4n33zm9+Ea665BqampuBlL3sZfP7zn4dcbpY3kAcLZEQK08eQnVpFuqFiWjTp6Ddj9BLAMqSjdd3wuk60SApaHlMRbj8rBVy0Wc7kKHMjNMlP2EVfECHqZpz6zsZGqp1Ocf2sgWQi0TLw/cG1xsDiORpTvIuozDWI3GqqM25bzEIq02k/n4/e5vVsvzoma0nutxdUrmji83SimSHQQgrnBj49r3HUzI1VFO6QftaPfveb5MuEADMpR5Tj37XMEtw2VfmXWbOagiy+hHHnF/2Qf7bqmVG4bDcDKos9WoRz1tCq+sDP0L1BbB8+bd7qxpQk9KpzXfDRMEWrIL/7VJZHCJN+LvYPk/GvC7G/+KWnGi/ie0c1j+iO9blyaHQwojhhb1Y75sEYSvNtuxPm5xI2wcMsREZ3AHQtsF3OeCBBkeubIa2nR+z1Bo51/A6BG2Ue+B26dGF6OBfg30hezVsJsOBQGBidhl0Dg3By1zCk8fAbN9k77rYJqJWnOPql0wCFcYDpfXYazAoS/+7oh/zmOyDZvRByS4+yP8fnqUgpJB923mt/j+QV32fRygvROX+mLhwXPSTOJgplWGhZZATSUEYxfYbxgfprsVwM2+6o/8qyYKL/GJjX1+fU9yjA9rvsf/evBuhbOVP2bJc99ovjdn5ZGcZ3AXQv9iZn2KEilQ9JqOzM/Zj3/jW2tRNrU/6gQgT2Aewn2KYqYJ0Uxux/Y95KEwCZbreOa9UqTBRrMC8/MpOnXffbBCASgljm1WfY+Wai8nxf3IeWbMP259iPKbJ00k4H+x3L59Te+nwhYbTrATtPU3sAlh43893AgwBdi2By/zBs2zcNq1cUoa8zN5MW1jnrB3w7rjnbJoHQlRHbTxdYRqxDlhcGtg9mwPGF5UbSs+7+ii26j+UeeJgr46RNbgq4f9t+SFXy0ZJSH/3oR+Hv/u7vXFLq0UcfhTe/+c3wxje+kdz3PvWpT8GKFSvgIx/5iG6SMaI+GaN/4os5Y75pMlqwCIKWUW7GcOAx5rxV7giieDhfnjAWZDrw3KA7i3aa1H1MIr1O9oMu1sOWrRlwXSUEtyoZdNpO5xovaxAdtw/T54WxBmL6K36RL71I0oRC8J2/DxdP5FaXntkY4j04bunEySlnpWLnycv9TqVLhMA0sW5pvvEB05DBxQG2C25mZQSqbl+WkcZB3NLCIkjadURiABc4Vpeku+RjeSslQoWDC1m+TMvRrMiuuqScad6DzA8qy1DVpp2lnwwgUi4rY9QWVyqLHdZfvOaEujQ9iE/e6kbsk+JvGeFjYo2ratMo1iii+7BpNE6mp8VcBzEaHs6FbO5leWRuqKbvRbG/+JVZ+b1uv9Ic682wIpwjuOmmm2jvNTg4CCeddBIZBpxxxhnK63/4wx/C1VdfDVu3boUjjjgCPvnJT8KFF17ofo+WRGho8JWvfAVGR0fh2c9+NnzhC1+ga00wvHcE+iY3QzU/DvunS7CoJwc7BqcgUavC/BV9MLbtEcimk9CZScHk4NNkSTG98mxY2d9pkzC46UXLGcSK9VArFWDP5odhQXcWKrUaXT+vU/Iuw00xWr8gmYBkR4ezQR7bBWOjI7B/YAi6sEtke2xr8H3PQK1ahn1TJVi4835IigQQI2UQuI7Zfids3jMF1t48rOtcBJV8GeYxPmb/Nupnpb5D4KmhCVi3qBu6dzuEEZIduB5Bcgyx+wGbSEAsONR9TnHH/bB5eMK1KtmycTOcuKILcrgMKYzB3skiLJwYgmRHHxFsnbvvgnQyAckEQKUG0Ad7GgkcB3jv/K4spPDi/CgM55Owb+Ae6F7WC+kEv69ziEL8YUDybuAhgNK0bWmU6wEY3WZbZ6HrXM9Suxw4zyA5gu9+RtDUgSPU2EEmWunw6zsLrWqSsHssDyvmdUIS80v1u7U+T0gUje0AyM2zCSV8BzDrJ4Z9m2DvRAH6+3rclcjuLRthz3geju/LQyaVsIk16iM7Z+7b/aDdJgsPt0mWwQ0wnZ0P0/OOgEX5/TBZsjUvezBPrB1ZW2IbDz1WX2wkyZgXASOB+GuwXkvboVixr9m34Y/QcdRpkIUSjGzfCD0dacguOdK2SOIx/BjA8pNgbNOd7ngqTo3CptEEHLq4G7qyaRgaL0B/bT/kMlnYVe6Cpb05SA5ugK17pmBpqQKZVBJGp8vUjxYgQYv7KrQIRAISyVkeWOc4j/JEFLWqBXsnS7Bg9yMw2HssLOuoQKpvGfW5zkQFstOD8MjeRLSk1EMPPQQf+9jH3L+/973vwZlnnkmTF9OawsksJqVaBNnJmNcJrI4mgLio0d1ARkkaBSW4/E4ZvTZQonh4UPeRIHmXtQlfv1QOjgBUwetkPxKysE3M6+n5ErcqGXTIB1N3IvFeXDTjgMF/e2kPyU71g5wMqzaSvM4TRg2rpZvXzmSViW3g/E44Zu64IOHHH0VSK870XbYBlRLqCmsJUzLU4gSsaVz7aNBEUR9B8mmCsGnr3K8itVn/xjoVdcKk7jkiIY6/k9FtCv2ij0a1AQ36ThODV4huYaq2CKIlVZd+hz/hqKMBhKfJmD88+ZZpapnOaUEtdrwICZWwOJ8XVytP+M2yxx9ssHtldSyuG3BjWsrb7vb8milof+PTb1hXKepI1zWWoljmATLoptSj116qtKJe50UZxbkZVoRzAN///vfhiiuugC9+8Yu0F/vc5z4HF1xwATz55JOwZMmShuvvuOMOePWrXw2f+MQnyLjgO9/5Dnm4oEYwBqpCXH/99XDDDTfAzTffDOvWrSMCC9N8/PHHoaND31Vp64Y7oLjQFtpOFvbD0N4MVFMdUJ0YhuGpp2CimoVsfhBWl7bAJMyHPYvOgsTYHwHtW6xkCnqzCejNpaFYrsJyeAg2DU7A0N490FfdD+n5q6BzagA6u4pQqVQhse2vUOtcBJvGu+HoeTXoQAIILVnQSgtd9sCCbfvyMFkYg8HxIm388+Uq9HdlYE1pM1Q3/hrSw5uhsOQwKHavhGwqAd0LlpNrYDk/AUP79sOizgR09IyBleuFVHEMqpke2PrYPdAxsR32jyyD/HgWrL2boDubhGrXXoDxEdi6tQrHLeuG/MhO2FnqgeLOUYC+3TC/OgIr+5EaA3hmzyTkdz0InfndsC45DA9X1sHQrm2weuw+2JNZCfmVE7Bgch7ldf/Op6BnZANM7V4FXSuPgaHSCujZswm69j8BtXQHVLLzoJrfBv27/gyJpcfCvmNeD6lUEvpHH4dypgfG9xdhqjwBa8fuBdjyJ1iSykHnovWQfCJpkxs4X6D73tLjYH96CXT0LYTO3gUA3UtsomnXgwC77rOtik55g01QIHnTucAeX8zt0MHOzFroHX8a5q062k4bCaV5awAGHrEvwLkb2wjXjqij9dhPbILoyAvg/vkXQee+DdDVm4I9/SfCuqlHIbv5VoDNf7LnYOZy5lrodwGsPBXg1DcRUWWV87C743DombcQhsaLUMmPw7KhP9OzMj1HwaK92yA5cpc9vxzxIhhbeCIUsQh7d0JnfojGz97sKti7+wHIZZKwen4XbNm9DazEDhhLVqlfJKwaLFmyFOZ354ikGs+XYX55Ezy94RE4uvAATIyNwmRmIaxZc6idZ5yfBh+Fqa33QhEJro6lMG/rLVDNdEPnIadDLpWAZHY5JKcsmMp0w1OP3AW9ex+CnpFHYWjekTC5eC+9rxZOPA5LtvzM7uPHX0wWWLuH9xHx09PXB3t3jRGx+9jY0TB/fj9MbX8Y9lbysKQvB4OwHCAzDZAfgf35EkwUy9CTtqA6NQKJWgmGM32QznXA4cvy9todyaeOXpjsXgvbR/KQGroTlvV1wLyOFIw9fRfk926H1NKjoTb/UNi57RnYUSlAYv5ueKaWJaKrvzMD/d0ZuOfpfbB9g2OF54OEhdS4BnBC2rRpkxtx75xzzoEXv/jF8KEPfciehLZuhRNOOAEmJibgQMP4+DjMmzcPxsbGoI+ZOh4IcAkX5wRd/FvnnnYBny+EmEc3mh4X3U4n/60+ZRPrdy6YsDfj2V6bNDrlxZdapjWWUn55JM0vx6JH7G9s08Q2e+zUWkaeBh1b/H2UJ9Q8yAJkmuRKjc9zTxDRIqbS+Dx3A2Q1WkqJ4uVRiofzG2vccDarDkzdKsOMDROxd5O81T1D0vf4/k3uxI6bEv+9iujHYBWsH9LmXaNfBx2vIhHUzPeT3/wjjnt+DmPfMx9Yfl7Dz9HtANPl69hrTjC1xFKl5bYzuq4U7HSyvY1jR7Ve4N19o5r/+f7jlw/+M5YXP0spV2ye9WVFHYvrBtLEIdNB26UlbH8Lsi7xakd+bCB5hi4T6U6AbKfdvkwPh72DmvFejApR5aEdytKE/QQSUaeffjpFREfUajXan1122WVw5ZVXNlx/ySWXkNTKL3/5S/ezs846C9avX0/EFm4F0dvlve99L7zvfe+j7zGPS5cuhW984xvwqle9Srts933gKFiGRjqWBSutQd/7qlYCJqALuqAISCPZjgEJyEAFSukeeLqyFA6ztkEOD8AUGE0tgFKyC5aUbYuX8c7VMNRzNGRK45CeHoJseQy6rDzkoAw1fEAiCbVkBjprU9L08JqkwIgWEh3QYRVgCrogkUxBV20CSpCBp9OHw2GVZyAFVdiaXgeVZA5y2Rwsmt4MvbVRKFkp2AiHwmDXkdCbrsBCaxSW1wahUinDRMmCtSC4Rzl4srYKhruPhCOsbbCs4AiYO8DnZtkBrQT5ZDekrApkLSdqX0BYyTRY89ZAYv8Wu23wsyXHkaVUAi3TsP1SnTDdtRLSlUlIZjpgf9c6mO5cTnpciWoJVgz/BXLlUchnF8Cu+WdCby4Fi0s7IDn4MFi4rsl0QcJxZ7QgAVu6jofe0l5YVBmEQm4hpKtFyFQauYVyZh4ka0VIVZ35XGi/6VQfVBMZ6K2MQJLeu2pUIUXtxzCd7Iah1HLI1Aowz5ogd8fttUVwZGIn5MB2SSwmOyHT0UMkDz5nMj0fElYV+svDDWmX0t3QWREsjxSoWQAj0AeLEvXXu+oZHEY610JvYQAyGAwE2z3RCYOwAB6Co+BPcDo8v/IXODu1keb96dxiqHUvg6mJUVhZeAr6YBrSKF8g7TtVyFr19bqvYy0MdBwKi8c3wtKaelwPWvOhAinYb/XAo8mjYWV1F5xceQTm/eeE77ynvcLFiWnLli006ZVKJWLXr732Wvd7JKMymTYiKQ4WhHrhci4WXi40YYRtWwWWL1HrpuF7hR6Irs5Ms2FqIj9b+Wz2SaTMyoB9LrOqkbWfTp2EqTfm9oHPZC6WslN816LEsXpr2HBSYsGt0fj72Al+FBZtqjHBW2UiWKQ0Zb2KelCOmTi5YjI3nky49uHzqtKgaSb8XIxCjQ3BXTqqvOm4q2H/ZmKYouaOV7q89SlZZuCPQ7yq3hFBrRb5+5pt0UnPwmAceDoryQv/fNEtjAgptOLB9rTqLT1FXSOVNRAPE7czMW+yuZbmW4F49Lqff+cG7ZsqiNbLfuUQ690PTAPKzyqJXzcQMevIIzBCku0Sgq6H/NYlXvd4zrmYZE44AHGain8HeeZ5lgmcqPLQDmWJGLgHu//+++Gqq65yP0smkxQFHfV/ZcDP0bKKB1pB/fSnP6V/4/4O3QD5SOpIMCH5hffKSKlisUg/DLjhRCwt74LevO2uw2+rK1YSRqEH5sEUDEM/bKythnWJQTgsOQhJmASRWiDHqOIErIIJwKeMWWnoSFSI5NkL84ho2GkthkMTA7AgsQ86YB+M0lSUgGRxOyxFaxoOOFzrlW2KMGT1wH21o2BRYgyWJUaIeFkI45BN2ARF2UoRwYEEWTKRd+iIKa5sJVhVfJzyh1hS3OSmbrnXVGAdPAXrSpxrmTPqUaFJpCr2JRdDb20/LIcdsNxxWcNyPWGtoTwuSCAZVIJJKwlPWqtoWPfBFBQhA09aa+Cs5ON0Db5xdls9UHP6f8HKQhHS8NPqOVCCNByZ2EHfPWWthgJk4LDEbiJd5icmoT8xCX2JPHRjq+RtQmwzrIK1sBtSO2zXynGrk4ixjsQ0wPQmlyLrgi3kJjlTy/YPFPfBkolf02eTwreTVg52wFI4JrEdFhVtayqioYp7KN1dVg/8tno6DFnziTzC/oNtj+11WGIA3pS+BVYkRmDE6oFpqwNWJVHTaZTqBp+1x+qDcasL1iT2wD7og/tqRxJB+bzkI5AlsrNCbY2EysLEOHQlJmEhbKqbOtfCmFsWJI6SiWko5ln0PKRh7N41ZGVgk7USFsAELEvshzSmXxyDCSsNj9QOhdXJPbA8sR8eqR0CBSsHhyQHYczqhtWJYeprXYkyZGEM9lsJeNg6FFYl9sKShD22MI+3106i9rooeTeki1vpqcNWB5Unm5iGhTAN58JOOBduY1kjdOSHAUYfg0VOjlnOMc0SpKA7wfS/ZvpOGirQl7BHZqa4FdaMbaV/D1oZ6jdHJ7bTmJy2sjQe8d9dYOt1oTvpWrBdDseLDqHpYwelTUqh3zGy7+iDjJNYV1cXPOc5M0rsjzzyCBx22GG6ycWICqE2Pdxmx8uFpmWbrxAQtW7I7N+AXDJ1cWH3RE3CzcUFVDM2guImze9Zs9r/hHHUYHGCszlugriTebEsJqSur+h8hMSgrE7DPo+V2xX059IISm5HqZ+mA9NNZ5ixoRJwD4Ig5Lsp+SGmV3XIWDJh94hMFgUp2+z5k56BkZQU+fR6vkhw8O0pI7CitvhS5Y3NtWhB4xKJEjd+mSZRnYU1XdTcvKq+M2133Tmsrh9bjXp7YddDQfpr0IMqL6LPJM8xZh179+6FarVKxgI88O8nnnhCeg8STrLr8XP2PftMdY0IdAXkjRMYVn92hnJohCNCDWgZY29wg4EJO3M6Q4GA1IfcUmn2oPI4ErSK6uqTYZNGWuI1utiokXZQYFp7fb7/ufLb633zNCH0nXrCsv67KOAIqTfgfu7fj2qk85Dksz9JPmuGl9pEwDJ6pDgxQWR3aFIK9aRe8YpXwPOe9zzo6ekhn+NsduYE/Gtf+xqcf/75xhmMERI6C3nlBoqzlGKbBd0TP5mgqKnQajM2g0TCOlo3fu5dpvXoJ0RqGgHNCyauLOLzwhAcQa5pxkZQtRH22ljx7efVFn4uQCoLLITKcoh/ttiPdMqi2tj5CdizTWIQIsfvPlWd+j1HpT0jkmgJro3IigR/Oyc19MikmfVW1MSoF5q16VT2Q8esHK2NvOrFb+5h+aa6N3C58mt7L1cyRqpZiRkLVplLIrM8kREiXmjG/ONF3gUVWBcJDnJvVejiBSWsddEwJmWEGGXav+9HOfZMXBLDirLj2kfXLVbXkpwhTJ00y+rcb5y0qxV8jLYFWmrx1lcojr527VrYvn2758bzQAe6MaJX0Y4dOw4syRdDxPUQ1wEDWkghIYUuwl7QJqUWLVoEf/7zn8k8E0mpFLqJCFEd8PMYLYbOgly5geIsPHRO/NiGgd88MtFMPGlFc3ERUS9o/CKykA6Ts6gmcd5c81xcxAUcyxs7BUcdh2SnSelm6gutCnDj5hV5RiU0bGL1pSO8rSOMOtsQ209VN6o+hJ+Rnorj/iUjgDAt/j6+b9dZM/hs2kn3TCAOVJtQWVuK/TDoCbffWBLrNGg0JD+LK6Z1Qhs+roy6eZ6NTZNsA6dD3PiRobK6ojmXe67XfX7RF1m+iRSS9HcV/Noevy/gqVrNcf/KzYwJNodg3pjGVKnAEZBps3mvFWi21YgfaRGUsI6ifH55a3gPBiQTTdy2o3ov8eUmDS1OCNzvPpODpjBE6WxYLPkJ6scWVG0F3I/hHmxoqF5cGv9etmyZ9B783Ot69hs/W758ed01qDslQy6Xox8RSEgdzGQMA9ZBXA9xPcR9wYYOUZ2OKtEFC2ThHw8s4OS8Z88eehngRIynAjh579q1C1atWgU7d+6ElStXwsDAAPT395OvNZrYdnd3w759+9xr2G98CWB6SObhdeVymSYw/Ey8Fk1oR0ZGoLPTJjny+TzVOeZJvHbx4sUwun8/hf7M5jpI3HDxwgUwOLwHVq1ePXPtjh2wcEE/TE3l7TJl0zA6NgHLV66cKdOOHbBy+VIYGBiC/t4uu0y1GnR3d8G+fSPOM7fDqlWHwM6h4cYyFaahr6cH9oyMwKo1h3iXaWoKFsyfB0N79tXn0ykTsu6ZhAWpRA0mp0uwcCnW/W5YuWolDA0OwLJlK+DprVtgaX8/VEqTkMl0Qq6n126npUthF+ZzxUrYMTAIi5cuh4HdAxSdAOu9WqtCX28P5WfFipWwbdt2N128d8+eIejpnUdlx+t7enphaHgY1qxeDbt3O3WFz17UDyN7hqGzEzdlOchXQFomPEGZv2AhTE1OQi6XpfqfnJyExQvmw+DAbli1fCnspHTtel24cCG1Y13fwzLt2gGrVq6Cnbuw762GgaEh6OvtpXTxML6np4/yuXr1KtgzPAgrV66C7Tt2wIqli2HfnmG7nSwLyuUq9PX31/c9zMOOHbB0yRIYGR2Dzq5uWrBOTU1Dd08fDAwOwupVq2FocDesXbuG6sFtp0zGLdP8+Qthx85dsHzFShjYvQsOWbsGdu3eBUsWL4Lp6WlIJJKQzmRgYnwcVq5cYfeNZcthx46dsHz5ChgeHoL+ef0wXZiGhJWAnt5uGNk3AstX2Ndg2bCdFi9eCgNDgzB/Xj9tbnGMdHZ3w9j+/XR6t3P37vp2GpuEzl57PstPjMGCnhwM7tkHS1etgx27B+10B3bDkkULYHxiisLHsr63ePkKGNyNdbQcduzaDYuXr4Jt23fAksWLoVwqQCaTpnYaGdkPS5YuhaFdO2D18sVUD0uXrYDhvXtp/OZLVSiWytDZ2QWj+0fsety5jdLdOTAAS5Yuh8GBAejq6SUfdqtWhf7+efXttALrbDssXbocRkZH6+aI/v751E6sj7D+Su20by+kkhbUEhkYnSrAsqVLYd/ePVSvu3buctsU8zk+MWkLH6YTMDGVh5VrDoFd9OxlsHP3IKxcsYLatn/+AmfeK1MfGRzaC/MWLYDBnTvhkLXrYGgI++AK2LdvL82LhWIZitOT0N/TCaN4urhmLezYNQBLl6+gPKxYsRxGR/dDJy58rao9R/T3wtDeUVh1yLq6frp4yRIYn8q7fW9iYhL658+HgQG7LXG8r1i5gsYXLuppPCUS9rw3Og7Lly+FXQNDsMIZI6tXraL88nN5R0cX7BoYhGUrVsDeoUFYd8haqqNlS5bAnsFd9niCBJSrFs17w0ODsHQF9o2dsGzpYhge2Amrli2F0fEJ6OyyVRfy+Wnon78QBvbsgzWrVsJuHNOr1lB/pXYaHYVMJgXJVAbGJiZh8aLFMIjpYP/fuRtWrl5D/WvR4oUwhe2UtCDX0QOjU9Pu+wnntLoydXdBcWo/Ccx29y+EffvHvN9PxTyUi9PQN28h7Bkdc+ewZTgOBnbDsoXzYWR4F4UkRgvVfKUKCxYvo7mH+vKO7bBixTLYvnsIli5fBZNj++3xlO2g/rSgvw/2DA3C6hXLYAeO/xWrYdfgHli6dDHNEeI7d/v2nbBk2TIYHhyENWtWGb9z8XvUZamWStRH9nDXYl1t2bIVFi6YT8/u6e2hEN1T01OwaOEi2LNn2K1PfjyNjo6BhdK4CYBiPg8rli+juUvMgziX4xyxYOFiaifsT4ODu+vXEfm8O5724XuU5XPpUti2bSvNldifenrs8VQul2DB/Pk0xpTriFwOKpUKTExPw5LFS2HfvsY1h2wux88wX/hMfo5YOH8eTE2MQyqdgVxXD7UTzsdbt22vm/fxPerZTjiX7dhGc9GekZ3Q09vbuDZyxjvNaQO7pfOecm20cCGMY9/LdgAqxUyO7YPFy1bC4L5t3u2UydD8jGXZNTAQ6XpveHi4vj537YSlixfC3pFRyHZ0Ehc2OTVF7xZVO4l9D+sP88XWMGi1Iet77hp2h/PO2e30vcFh6F/gzOXlMnR3d8K+kdGGdVnYNSy+n3bu2g1Lli2H4cEBdz5V9T10I6tLl1/DZjJtvy7HMhUKjaLMpkAvlVNPPRVuu+02iqDHhM7x73e+853Se84++2z6/vLLL3c/u/XWW+lzBEbbw7LjNYyEwvzefffd8La3vS10nmPEiBHDDwHjhsdod1QpSkwSqhUkXADyFYt+M+Aiu1ypQaEMUKpakEMlNArdXaPvKlX7N1kv0Ik3J07GooyRkGbW2/ydnbwpTl3xGaVyxfldhhrmm7cMEEGRYzBPmL8alKs1KFVqUK1ZkC+XYbpchalaDTKJTH2erCpYlRKUy3molMtQxrCwlTLkSmWoVSpUTEyD6q5Wo7Cxk4USFIoVWryXS2XITxegZFlQLVchkS5BoVSh7/OFMm0GMJRtBTJQSGQhk8hBMpWFUn4KisUS3T+FITinijA8NgkT00Xo7q1BsVxxFl5OfTgbWhQhtMQyCPVWrGD5EyQeiT94L22eihUYLVapmqBYgHylAvlyhcqHdT1dLEGp4ljHpTJQq1ShVC3Td7wIXaWWgEK5CqVaEiqYNkUjQYG/GhQqZUp3qlSkNsA6UwHLOFUuw2ghD4Uq5qVM+eTrGzsn6weUzwq2QYWeU6pUYLJYoP6KYVg7se9WK5S3qWKJflcqNZgqFmG6VIGOUgkyqSSU8LC5loB8pWZHW3H7bxpqySyUagmw8mWo1KowXahAKtsJ05UEFKoWTBZLMDwxDZPFMixKOForpO9i9z2+byMJgfWbd/Kb4OoQ66pYqsJUuQIVSEM1kYJqMk0EEwpMFssFKl+iUqZ6rFSrUEGjEsctBq8rW0koYNkxLgkLgVs3JjBvTh45VKs1mCwUiHAsV6vOuEYSDDejRShUAXLJNJRqQO0zVsCwyQW732OfoQ1uleod28Ru/wwUKnnq88VCkTb2Fhuz7Icsd9I0Y2D/qBXKsK9Ygb5CgcYVjlu73bEPV2CqUoVcLQnFWhLKtSRMFctU79hPMK9UJ5UK1KplChGdryYpfC+OOczHVLFK5ArWGZFclRp0ZLIULpr1I/yNfQYjqLB+x+YFnPdqNDeUoOqUG3+mCyV7DuSAbYXtPF4s2fljY8aqUehpzCtFk8EoLlYVqrUK1RFeO4V5oXGI0QvRUigDNaz/KlCIapxzMZ+FikV9AIH1P14oQqachVqyApVSlcbveKFE47xcs0Vvq/isKsB0BfW3k5BJpqj9sQzVKpbZns/dcYrzClpIkd5T/dxcN//Xzbv18zz1CVaf+D7AaGTs1LxWdNz2nPk/nYVqMgs17P+YB3o+umfZf1fxXYVjNJ2DajIDJSvpzCsW5aNmVSGVsscHvbuqFShV7TYVwfLvJaiJ6WJbU1vguwGJ+Yr9m+b/ahUKFs7FrK9iXpy5yvm7rj6dz8q1GmmKUn/1mBPr8uvMpzg34jhtgDOe6CXFlwH7B7a/ky8sE95vj9eaxFIT3/HO58kklLF8eH+lIr+Gq08c/aw62fxcN+9TOyPNk6R6pL5XLNpjpVCgsrnP8YLzTiJLOaG8Lqhf4XeYX3kbS/swnz6bM7HP0njVyVfjHBsFGurTWXNhzeL4KuDao1KhwwtZ2WgtUEaRXuwLFhTzBeiYnoZpnHOKZXo3us+qWjRH5rIJd6gSnHFq4f3For0WY3XH6krVHsJabjpvr3Xw8AZ/4/PwuTiX43xdtZKQTiXd8UPvgBLO2zge/cdMXfmZFRfYf+OzpvJFeo5mYPE5C3Sbe8Mb3gCnnXYanHHGGfC5z32OCMc3velN9P3rX/96IuNQ9wnx7ne/m+RXPv3pT8NFF10E3/ve9+C+++6DL3/5y/Q9hpFHwuq6666DI444gkiqq6++mtxtGPEVI0aMGM1EwjrQZ+42CuHabNDipGQvbHGbkU5akMlmYbpokwLZZBLmdXdCMpmghWPBuTaTSkFHBjcy9uKk7BADaGmVSTvuRE4o65qVoI11IpGiTVgqmaT0xHzg4oJ9R5sIXOSUbXeNWiJNC2p8Ln5fqlRpQYLhVztTSUimbY0rfDZ+XyhUYDSfh2w6BX2dHZBOJ2mhhYu1BCTob7y2VKrCaGEassk09HV10L2sPtDCKlktEnFUhQyUariJBMpj1skHgsqLUQmcjTnmEesFNzDTuNiGpM1LYNkS+HSMKILWWwnIJZMwnp+CVCYLXZmsU8+4yK9CGTc7FpAlB9ZfVzYD8zqzkKINoUXPxR9sFyRaMP2uXMbNDwLLjAv7bBo3/LhYtRf52E4YeQV/I8amC1CoVCGbsKAjZQc57cBTxHQCpktIxlWgM5mAnm7bbQefiUQEpt3X0QGdHRm3DnDjh2RILo3hUmuQyWSJ0JooFGgRg2VGOgw3I1ULyUCAXAcScjP5xgXiBJ1O1qhO2IzT39kJHR1pKtdYPk+bKayXrlyW8lSulCFlWXT6Sxt2JKTSWcgiN5TOEBmFJAcWG8tXKONGtQSd2Ka5HO23p8pFsKwEZJMAvbkMWWSxMmP9TZeQ1KpQ/0RysDuXhY50mkipyXIVutMJWNSdo3KrNiRs3FEfTiQo/9gn2XcT+QJtaDsyKejIZtyxQZtYJMy4sYKw+6U99lg/p4BdWM5sxk1blg+WNgKfiwQnWqR053LUZ2zSEvt2FTrSKSovfob1wEgGfH46maD2teeGNOUN/0NCBDcQmL90Aqi9OzpydnmwvdIZt+2J+C1WYKxQoCkkl05CTy4LXR322KDnFkrOxt8iawQkGfDPUqVs9+lEAjpRuxBJFySHSb7OLl+lhv2mSNct7u6EzlwGJvJFt2ydlJ5NYuQyacp/vlKi+QH7ONW347aCeSgWKzBdrUDFSlDavbkc9HRk3THItzODHYQtCelEAsbzk5DAENPZLLWTZVUhQYQLznEWlKoVui5RK4OFpAbWc6aD5gYaS9je1RqNTzZXYxuOI0FWxDpPQV9HisoxUapALpWgZ+dSKaSwYaJcgQLO24kE9OQykMKQ13iqnkq6/a5asaBYLUOGiFYL0skUVSemiS2Pv7G/ofUkzosIvA/vZ+8N7JN4Lc5DFETRITawD6DVmTvnV2yChc3jYv/EusS/WTp17wvnXvzMJjNsrSxsa6IjnLRYvvj3DZEi/PtLNVaqGC3HguT/z957wMuSVeXiq6o6n3TT3Ds5MAGGCQxhhpweCAKCCOqAKIg8ER6gYEAkgygIjycgCKK8P+oPBHlPUBDmAQMISpyBYWaYnOPN4aTuruqq+v++tWtV7969q7q6zzn3nnNvrfmdOfd0V9ipdu317W99y6sMvPNwHSmbPG/Wd5pWPxnvaBueBxPmsfluzJo38G846pg79PpI++vzg5QFfdkOfKp5ajxLGfQypefGvSHhdP19wnOKRVwd91psd8kHs6RW4/tI3WUc6HMS6oP3OZaVmJsxt+KZ577IaBOek9qYV3y+x1RTtUGeYS0R+suqbgiTN8Tgi4yB9WB5bSn9jHVNN+zxfIb2N+um3pURtfEuw7/DSL2vMT9XKjxHyJwr73TMCfjMNLwHO50uj4FGvT/3FTH9nYq1Dt5reF4xF+MdgjLLd/hspqneG+kaDWutyvC6UtqBo+cjzKYOOfycYv5zeJMRYBzWpAD/Zf7H9ddj36+mP/HhD3+Y3ve+9zGDDOymD33oQ5wtD/akJz2JTj/9dPrkJz85ILPy5je/me644w4Gnt773vdyEisxPLdve9vbGKgC4+xxj3sc/fVf/zWdc845hcoDQBMgGLSmbGF9x4qV7VC2QzkWJrMSlDqKQCksCnSnTF7KAAWwW4nF63RTLTRkMYTfePmL4wAzF+DpYjXGTjDAFZd3vAUIMYETMFYAttRrfaClA9Chq9KoBk6Vd8PFKYYx4wBOiAPnSFmjVuHz984v0t6lgLBWO3FuihdTtsWVLIrkXNjCcps6vk8NdszhMFeoy+yimB1ELJIFINAXerrTgUUQFu9MiMCCyVHtIo66OGSdzjIvrPHvTdOzXA/ZLcemXgjNIuwMxjHVa00GGbAYw3H1SoVBKN7tC3rcDrKQFNPrjMWr7rjJQm7A2XOwUAPDQBxwsHBUeWueowAa7MhGMe1bWKJFv0ebm3UOpRKHKXUaYzCAIoodsFQcWsauZhjS1kaN77HQAUsopIZHNNNqUbXeSMvNdfIVE6gTAKDq8djZ2qqx4416AEhb8ns0VavQXEudGyDVcKwcdICIQeQw6NOoOgwSAdzEddFDAshhrHoOgCyM0Qq3JQAx7DvP1DxqgWaf1BnPBRbJTuKwIfyh1ZzihT8cgflOm+oMeKn74TzTWS3iCA05f1q7ZDmc8hnut4y26/WoVaunz1TW8w9WVhCB1wbHFs820UxDAblSFgBLAJ8w5jD+GRzCZ8yMVDumkr5AxiHOgwOMPlwOFLgyl1wX5TGfH70uqizRkAMvY1dYJ/I8wfGAAwJHDNd0nJimaw2VwE1jPqDvDiz7XM4dM02abtaZAXaw3aGpmgIYAS7JfMCALwPZxOCnABrSJvNg2nUVmwpzxVyjziCBzorBuK0mdUbfCIAMMG3JB2gf0pZWk5l6aEz0O0AHtBuOW0qcMjAKHDhsnkubp5rsOGJeWUzYJQKI+UFIh7od8n0Awi5tajR4zlgMfHJjPMMeg4Mun5tsSLguh9E1qxUGOvRxh+d833KX56Et0y126gAGigMp7FMFlKj5Hu07k4DFABzQ7mhVtCMAXLQL5lPUQd455lws/awDR3hXgVnEc3itNjCPyfMggDbGIcaxjAEduB147gAYYdxgTvDyQSHdbM/iqO/1+/LUYxn/o+YLeV/znA4AITlX6qeOUwwxnvsAdpIC0LpBwDBiJsAwZrtEYWgFljE384ZF1Us3MvT3kf4e5X4HKzQE+zbkMTWTgBuoB2omz520EebwvYtg9uA5d2nH3PRIMIFD7gM8ew6H4qkOQEZAMHsw2w8ClUfcEvAb71+weWF4nqQv5fnTSyptYIK3AiDrAKk+z2LOwBzaxDsyeVJ5ztIAnFq1v3EyWMxhMHkSgA3ArJRTwCaeJyygrf5s2d4jMo55vGPdFvq8webVW+RWqgPjUM3FYSFQ+EjZRvEnSiuttNIOt5Xhe0eRKWekShU4Tp6XghR4OW9KBLflM7ys8bnNFODiWVNZQ1OHGeaxclxxPX1RgcUrEx9cOEdq95LZSLUaO09gAoC9gV28uqcW4QKKmQ6slBUOaS/EzrzHCzMYfkfMOFCLNpyvWE8KfOHQNcdl5lUFLDDcC+wlr8LVMUGCKMLiiHlQimKu7cILmwMLJTAuzMVaDdQdduBb/Hmz3uRFPRbbKFO6+9eYZlYRCoCFKRzkXrIA40W8rxaZ2FU0QUIOLYGGsONwubP6T5x79F/FQ7iVCqFhppEfUq1Wp1azOpBRjq9VUWwBOD4w7ovkc8WWc1R4E6mFM4NBjkvtMGQGUrOOtgQjTbGYpCwyLtCWXi+kChhwnseLSyyapZ+xQw5mBr7DGGCWDahOYUw9RPq4FapBV4d3SNWYxL/RFooxl7QzGCDMQlGLXVxzc6PJrJUaGA8c0qocdyzwof0E5gx6aBngUdijelQhr+LQbKvJjhw7Dqh1BGBGsUhw7wpCTIznD2xCGbdiGGPmsVlO8NCzl4SMMagZ958p2zV4UR+D8QZwRLHbUDduH1+BqDi+wk6Cai/FnOrSIthYUcz9AJZSvQLQpu9o7ltaovluj7wYzlSF5xmMe7kGfmQ+sNUFYZRqR18B4QBnYDNg1YE9lxyP69XAyQNzpOfSYqfLoWwIb8K8prNxmPmEkE8wjcSdAyPSQ2gSHBn0tsNOEMY+ACqw9TCPwFFTIJOngCOECIYAwFyq4RnGM+ip7ySshts5YROhHjxuE1C9ys9Ym1wA7knoGJ4llA/AGcqIOQmsPe4DhO2hLZhxSTyvLHS6zMbEmEXfqfooJpbXUAxN1AWA1EI7YAYKIAoOu/aIpusVDq8EqAinVEDg2QbGn+oXzNsAi1AT9PtUtQYYkJmGeB5QLs9V7D2wrhg0xy2SYYe2c6nOYZkIM+z2fAbAABzjGtL/qnfUeNCdTQ5MddVcjTHkBAifQ5gw+jFicA31R3nlPMyRrgd2hHKUTcbVwHMXo27qHtywlvmx6HOnnyPgN1ZMctzw8z747IcF5gt5X/PxYCmi//ldpp5nWEAK4JFnRL37MNdWKIh7zHbLmg/SMvGzj3csU1iG6qo2Q/BsIpQ1INfpqTk7mZsbYN2CMqxlC1Tv4j4AjnvJexwAKzOhtfcV6oHBFAZdchPmqXrXOzTN879iY5nzJ55dAOJ4X6TvWoTSOWqMULpx5gt1kfXXsvrzcNgQsw6AIIcfx7TI4bkqZHOqmsx/YBsmoag8DgCMk9qUEmAdzzSeW7z/dNBOH7uYAdQ87/F8jnKkY4nHSkwVnMsv0WGzrSvSjYyEcWoDk2STDt8lU+KQoWzmd8KWRZ1l3YOxLe8UfRyj/3tBh2pOjyrppFRNx6Gs55o0yJorrbTSSittY1gJSh1FxoBIozr0Us4DoApeOF2I8lqfARIBP/rhElg46KCRLPr5/liN1BXDyQVYg8VqrQ+8qN9qkWqCPlhozDbrAyASftcJDrcKFxCHFjtoAFBYb8L1qNlsUDOuDmSVwSVMBwHAA3YqsfCDgySOBC+y45j8CA65yw5flgNTq1f5B8YgUhJixK5iuohUv5VjEZNTUbuJuAeYIVXyeMdcrz/vfia7lwAKssK3zGNdt8I7iTAf7YR7Y0exij4avAaHnCWsCi6l5tCI/lgUS7/AqVbhevVKi9wqQAqipi0UACwHr8I7+VUnIreKMapCSLPGLe+2cnilS2HiyIOa31+0xrTUCXgRD/Yf2g76JdSJmU2kFuVxsivfZx/ItQfHqlrMcrt12xwjByACDpmqp9rNFkcJTqTsWpuW59ja+olDLsIgZUDY+hVlR0ilDpLq15C6oD95hzsFPeC+OLQc+NRlQFWBwAKsDIQGccY/xfhhFgzYir2A204xfRDe2aP5ZZ9mW3UGSdAXqdPM2k3Kmc4K5WW9EYAwsWIF8O84ZtCJQYkwoM2NVtpXMmfBIZrvdmjZj8jzsNvfZwcg5BN1Q/sFkQKhmB0AxzeMmfmEssGR4vGKMcXAeEgOAJEEXIJT36yAOekyiIBj8aP0fRRgDCebwaJaRdvNV/3DjnWFaIrqStMHzmPkUrNSodl6PcVGMFb53hgnuDez8wBm4y+EtSKczmGWl4TboRzTtXrisCoHtd1F2CrCvZTwPMLwcAUVZonQZpSBaM/CEoOpANy2u4p90qxVaetUg/s0hmYcs1n6gA8M8xWD6RDg51BhhFr3w6nVVF4ZYtzpfY9nBs6vsH2Y3cS6ZMrJxffKga1oYKUCEEMOcVTzjHoOEzZoRLS4jHBcBc6hYOIkC4CFivCwtGgY6uGiqI+wjkaxaQQ4wQ2zQFf1t2cFnfLmC5n38hgqKKds1kjoNrPaKKK6q8BEeQ7BqkQDzSRh7nqZbKC5PJ/oE9a0i5QOm7zbMW9zaCDAIG0jQwfbTXCiH6I8OF/x5wFYb4kWUDLO8Ow0aoPvBN0ASEE4n8inGkL1MjbOkLCBtZV6AeEVlxUqKMC4XGcUIyivbyS8WgfLYSYIi+cQDHMPIcwuwtiU1ife+Q1oDEKPToBWANga4KpA9GFGdJZJP+MZB4MRZymmdE5WxZzse6zpmDCdZ/i5VuPKrOMkxteAnhvmRa29BYiTNpXr1ypNol4CjiZaYPo4lM2C9ciQKq200korLd9KUKq0sc1c3Op/23aEdRMwRnbQdcta5GBRBHo2AAT92uaCLTNddYG0ylIHMAV0B0CYS6Kv0t+5G329obJphoXUNITijYWy7fqjrlXkWB2AkXuau5z6gltfCAroAANgxsEz0PqpVJlRlGUQkO/4HapV69TtAIBYZnHxTVMzNNXKHiPCssD19fLoQMqi3+UwBCTyxucQxuZx5bk0V2sOse309rGNVTB5BPyRfrcttEW7ZaXGWhqRYstJ+2c9N1IWc6Gt10XASOy+o28SaWJ24FmXyauwAy8isWADChsFIYHHVabZIQWgC90lnAfACAzDKAFHAEiBRQQRcQGjleg0QBAVYiS6H8IQFD0gzgSahFoBpKx6ici5DyYR9MlUKHCrNdi+DD6HSo8kBgiaCG0DPEKCBowUhKVgSMJBhBOzudZi8OLggq/E8Z2I2YFg8IHhIw5VDLH/pGwcXgTwyVOOH7OvmHHU43BF6QcA4Wa7c4hhyiJSgJM45yg/xnr/GVegFkCFKVdppzHonTA3GchIQnMlbG2u1SSv59LB9jIDaNtnWuyoA8wCow0MOgbmmOmngCJckxk0CegowD3aZ5vbYucdTiuHFmLccEIHBUbo7FWdWWv2y2ylkTu+9TZSELFKttEJ1LjC6kO09GAYcwDfWD8tmQdEZwe/OVwyCFj/Dq8JgOhzicOdAkcAdt1KolPjD4TxiAOMDQYXYurQgGPQXbVNljPLwDyyVEZqLswDMcx5teh8MYq5rF9HASrqXSWAkjBL+HlzlC4YxgyPaWQ3TZiRZmithELymISGHOYZBseVZphWiMz36DA4pzaYJJSLQdpEa4/DoA2WLs6V50M0z3RWlGLUKqZUXntDEqDNovEhNTA+DFAOJvOkCMqLrmUeqDK40TN4rCQ+wHOq329ojYR5NAYjCozJmN+jGK4AdNXGDzTi1IaTgE8CmguI69X67FaMb5v0gl5GtOVyt01OXOX5XvU1niePH5MBQ2ghz6k+kVPjdwDuj7kI88h0TQGneIfY1n1Z4NwoYxY1rukAtFMbF7ln4p4JMGnrp5WCZKWVVlpppR05K0GpjWqys5WqvyS/LTtdq222RWjRRYAOxpiWFf5kAiq5C3lt8Zyn2aPrMsD6+lHKedKZK5OwzMZhp406djWuZYaQDe3kZi3o0H4IfUPsUBIuobMX8kAyCNYDwFBhRzEtBjFnfGqFPQ5NyDKdZWHTFvE09ogIeEPs2XeU3hfrWCSLdzAjzIWycuD6zqWMCfOYNGmA5tSZIZWTaG9w2yR1a4SVYQewoEM0+LcCI8EfBItEdM9APtMdF7QHdKd6cNh7ipXH2mUVhypRovtTqbNWEoAm7OFD7wdhVdBNQn8iLJQ1uZC8AFpCHgAd6MionX8IcittuP68BKgGYJUuau35yJAI5xqhrghv6bNo5Jlldk8EEfuAql6dHVUGbqJ+2JM41cxKTEKTMEY3NWu00PFZu07ACfxwtkMwiBAiGviclACOM8A6x5hO59s+7V9WQu2KYaOuI4brYCz1WZw98hPWlhjaan65QwfbXb4+WDoIw93UaqmQZ7CzPADfLnE6iQToQ0Y+PANNDiEMqQvQIQpoS7NJc1NKi0SBEh4DWKgrbqDCNh3aNq1067iNEBKEfBVJiJVyfLvM3kBmxyjoctgqgLgI7DUeXyqZAydiAH/KEvaVN771sSkgCuvvgdXCgIiThmbhs14MQWfmjFCjXtH0dpQ2EQPuwj5CuI+n/i09IdfE8X3B4ygFC8QBlsQW4vyr5z/bmRXQmJ/DKP99dzgcYx3I6fhhmpADdRNgHXWTNsD820pCwaRMOpjKSQsS4M/UK7KZDkDowtRyXR0k50QSPRX6juPA4EJoXVa77W8v0WI3pM2tkLZWphRbsKI2Gka1d5Z8gW74DN/jeZB5XQ/HzQIlszaFsjbZBsYInhsGjpEdL+I2YVBaEy63ve9kM4iPZ0Ikwu+w4aLAG9FOUu8wZ1iSAEHsDp5vhJCCCaeeI+sGCIDr0Cc/dqjttzljLe7R6HZZEwzAuMnk1cchEp9ggwFzbQrOZbGvwPoE+OUpOQXMp6INNw4jrND6MYcBVlpppZVW2vqycpbeqCapcPFy138zUJVvJoVd/7zb9anbblOPafD9Y3QRS84YlOzUwTjEZqlDBxdVqnjbMen1k8/lmKVln8/Fb1yfF4hItd5us/CqGBZIB5aW+Thk4zuwqP5t1kG/D7IGzbe7fKzsFMoiVmlfyd/QXlGixWBSgKq+Z2GRHSZb2W333GimFtF99pH5d2pYTCNMpKLALrWgdWm6Ve9nMMswZLNrQSy6UWWHafP0NIcOAUgap2xiOhAE9snmmVaqa7RlqknHTTV451n6VXaxWddFS+WOsYQf/TNOp65pHokeDMYCs7K047OuM66h3Eg8ALH3rJBMcYiUzow7EoxEu8yijVsq7AY/OtgGpwUhWWChcT3AqjHaAQbnDk4T+grnQ4QfQtP1JIOgOPVw8NG3jURMnzPbVRLNKdYjUyAm+gKsMIBLev3h8CC74ZYZJQ6uP5dSL2ZLVXH9foY21Av1hLg57q/u19cj49AjFueustMODSvl/PVBVTzrEB3v9gIt6yD0aFhNmAXjoWflRCpsEC67CrtMMpdyiK4KpVJna8zOZPxJuy50fdq/1GUtKLD6DnXwu0ttH0kouipzY5LxEOAanE0kHZit11SfVWucbQ/AElK9Sx0FAFCadwhD9Bjcgj6QAoAA/IF15bPjCECSs+vxPVRmLhZF96rM1ICY8MGOT0tghyVZRSVDaNbzOGo+FHBR2h7PNrPrEvF8sKfA9sLYQdkxpsTJVww7sDPU+MazsnW6yWyxrbMqKYFiAAlAogzjAewO/NbZXriGPBM6e0ifb2z1KvIcZmmrrZUJ84vL5yQAbqPKczPXE/MvQp5dpeGX6q5pc6zUX9rCBN9thvFzsKMSCqix1H+Pyr+F7QrAdw4hgJwNLgl1zZvzeUkaI/absyPqc0HueTIv1FSGSvy21UHmkxrAyZoCmAX8zLqPjBsbA6jQuzBZq2F0YvxgQwVzpGxEKGBbtZlu0oYcoo7nBNqCDPqrsShzHgPbyA4c9Ojg8nLKnMNc4SZ9oJ6HwfuK8XiHhl+1wd/N1Zs0V6/SNGfMA3NWzSVZxu0WY56A6L72fMga1VyTYq0qP5Y2LjIGjQpwNkbO8GzORVllKG1s+7M/+zN6zGMeQ61WizZt2mQ95q677qJnPetZfMz27dvpj/7oj6hnjJ1vfetb9LCHPYyz85111lkD2QHFPvKRj3DmwEajwdkEf/jDH67bHkM5OTmM9vOe97xn4Jirr76aHv/4x3N9TjnlFM56aBoyIz7oQQ/iYy644AL68pe/TBvZNlIfjmtvf/vbh/ocfSfW6XToVa96FW3dupWmp6fp+c9/Pu3atWvsZ+VYtJIptWENIStYdYAGjpe3YlyYegF65q80m1e3Q24cU6vZYK0nEbLknbQYYtQxedjdq9aHmDTYhRbH1YWoMGeSCvuaA3VFEU+PMXZnhfUBMV0cf6jdSVIEuzRNSBEc8QKMwRCcm4gNHwLDA4stzn6HhRKyNkG4G4uXfp2FHQNHFI6m0odS5Aehxsuuvb4bh2vC64WuTCdAmSBS3NewyGOsrIlZdvjMNObyeVZ2t7xr8o4pjyHsWoLHkoiccyY6bVfRDIccw7idWJwUYESP6mBxTGGn3JsoC1YWC0EPb9HPh16XvostTiMDDwYgx/vKGmMi3XWHcDtCobxBkGyckMrc9hkxjnTmm4DGWGRXwV7yvMy08hgHtnEhTEWdCYbj+m2kxrjJGpPwKDPUU/qJ26PnZY5Bvn4qoi/ziApjm8U8lLCBoAUVg03AwsBJxilmF8F5VuFKYAUIq0McSSmvaIbh+vgejKSQ9aFU/8IkNM7vAVCKqF5tUuzEBBl/+PioNsActAu6ePtsg+cdZiBJ+KpWLz2EBdeGE4gy604nZHQAujUTDSVkr0S4IzRfAFQtt3p0PGfRc3jeQltgnEpfwjZTi8XQdZM2BLgn2mRwTCHaD6Fy/AemClhv6XhKxPIB5FTcRpo9lL8Lq+ygAqwCIIl7m8+jjCtJzS7P46gMdnJ/VSqE66gMYcKgY1AzUk5tf+wloWgYPzXXygTVGRsDoXMFBY/N59A2zxRhq0qYIkCSPId6qJ0KsjlMdqYwv8zEGPqciGQBkgVRH7e5c49ZHuNveZYRhgYWLZ4VAKLJySlQqrN/THF685pSns1TLWp4sQKxUF6DgWQLOx+oh4AQfIq9LRHWtuh3qFWpq82xZK2A543njDT5yejxPMpUn0GUO2Y9KZk7OVRaimwBtkVcn0FHtHO1Rl0AW0GPEDSLzRd9rOD5AaMKdcazyW2eMHBNXcWh9tAy3oEVC2tRNV0XyvWzDO0D8B8/A+MQ7Mdk3YQkJel7IdGCSn8Xb0z7c4KkFmFAfoBY9Wq6LuXJvOerCR0adQ7THMe7Z2mp+b5Pv/Irv0KPfvSj6ROf+MRQyyAbM5zs448/nr773e/S/fffTy9+8Yt5c/LP//zP+Zjbb7+dj3nFK15Bn/rUp+jyyy+n//7f/zudcMIJ9PSnP52P+exnP0u///u/Tx/72McYzPjABz7A3914443svK9He+c730m//du/nf49MzMzkG3xaU97Gj31qU/lOl1zzTX0W7/1WwzsvfzlL+dj0F4vfOEL6d3vfjf9wi/8An3605+m5z73ufTjH/+Yzj//fNpothH7cFw777zz6Otf/3r6d0WbI1/3utfRv//7vzPQiEybr371q+l5z3se/dd//VfhZ+VYNSfGFlppGy+FK2ebweILmVSyF9+SLhc70FgwIAX1YnsZEtK0dWqGmlNKf2XPUpsXEFNwWsGGqDfI8dSCUA9xGkjvDuFqwqKD6EA34HAYZNGZbqiQKj4mI+QJ18WCZ99Sm8+DUzXTqHEGJ2RK0x1vLI6gbwNHDQ4fhyb0fMXKMHYo2eHrAiBTWaxYZyNCGAfYHn3Rav0cc7GP+5nZflYarqXfa9RClwGDdpsXWuiHSsIsYoebQ12QHr6W9rvex7bU4JljRv4GuImYqlhlrQMg5yVZgVZjYY7yLbWXkVONZlotqtaztWgG0pgbC+mVliXv2nJ9AWrY4XaIGh7YM/HI52yUFQYOR5S/027zIrxRr3M7Slr5BYz5KGJmxKYm2Gm1gXEBsEIfvzA4PXj2WEcLYWksgN9PR6+nJAeoCEeUQ/0KZDUzndB+eKwKM4ETiJBAZFzje3AGPFVWlOBQm3N1Ud11aLoBlhASDkC3SmlLKUF7BXDB9EyBUh4O5xPdp1hlYoTNdzp0AILZRDTbqNFso87HgPmBy80163yPRTA6Q4jno5yY90IlXt5ospaaOQ4VGK7CpThMKWkHfL7YVRmmUL/lbkjzXaXbBZZoJ4ho22yTdsw1GfjC+AOQxOOvAsCpwYAIXytxEiVbni3cCkzSg51lzrRXSdqN9WA4nLavWyMgnoAWArIqFhbeF/0EDXp/YtxICnYRGdcBwaznK+9ZsIVVS7gpGHbMukkE4EU7yXZ+0bnBnM/1MaqHD40zBxY9bqidRr3LE2cc4vUYK7BRQENWPQvNm5b3BGePS94LaVuFCKnFYZW03Fn9OFSfXkf9G+dJnU1JAgtIN3KMFQD4Di0hPA2bb8ArEN4GVhzA6QonGZB36MC9WLdOE3ovGBKm9NrURoIH4DVhIwKUlfc1GOFhL2DNO9mwkXUMNqGwmROzsL3D4dTQ49Pf/1kbkLn9rrUTv/Mnea8WaGt+B6FMDjZBkxDMCGL8Sd9ntZ/t2lnPCTYqwh4/H5gUZV1KvW4/FhuSESt8hx/V/sQYBmbTa1/7Wjp48ODA51/5ylcYULnvvvtox44d/BlAiT/+4z+mPXv2cAZu/BvO+rXXXpue94IXvICvddlll/HfADEuvvhi+vCHP8x/49kEu+g1r3kNveENb6D1ZmADoT3wY7OPfvSj9KY3vYl27tzJbQBDPb7whS/QDTfcwH9feumltLS0RF/60pfS8x71qEfRRRddxG240Wyj9eEkTCn031VXXTX0HZ7r4447joHFX/7lX+bP0M/nnnsufe973+N+LfKsHKtWbhtsVOOXtTeSwYIFCodEiIhuEpIzhWw3WqY1Bq3AFPIq5FRqDEiZi3Wh96dUdoh3QismuQYcGZVRqp9Zydy91SnaWATCScJvCV2BowX2Vr3ZTBdoOHbTdJOOm5vmsKRGA6FgLf63uYiS3WOkmkdoD0J8Nk81+d9ZNH3Z4ZadVwBRCBMRQMose97CjXcXOz7/FtPDQfQQhyzj0DGIUYcA1AZZGVjYelhYaf2u9/F4Y0Zj2/GCrcaOBwL2zJAus7wI71xeWiIfYMiIEB4OP0LoQK3BC+88ywwjzMmUxPpGCIda7g60e/JlspiFzhKRww7WcHml37DbjJC/Q50OA5M+WHvM8FFpx3EuQBrcb1Qopx7yKY58XhiEfp6tTfk5rUHTqUq9SLEe4fwh7KpV9WhTvcYhS3oGTBkXZrhhKgyd7EkgxKvPYhxufxZBznFqzXGi/60/X4x9Jq6CyuaussOhbRT7QoWLsT5OtUJbWk0GgriMAKcRhgcWQc/n9OislZSEJun3YQAHmQSjmB0/7OLjc4RkLgeYo3Afpe3EzDnWwFI/cBoBRoGpxXNSEpoSBDE/kxBiFvD6wMIyLSx1uS9Qnl6IbKBqLKXPOzPtXJpDKGu1RtUKxOJx75iajRptm2vStmmE6tXTMBuEPKFsi90e3XtogXYeXOBwZHaxOMRPhb/xuPLDdM7h8DGXaAbPmuPSQhchVj0O10QbiH6L9KOECLEOD7KX1pJMmSmrdLh/ZVwBINKvlffs6ob5HPfQwVkzrFpCaVVmREk0ofpYEl/oz5JePtvzY37W1zwK6NBym9sWwCs+E006qVeROducn/JCG4fayZiXh841wr/QVxL+XiR00nxv2d5Rue8JhN1p74X0msgsCUBKexdJW5ltOGB6KJVjYTlhlHtVBkvMkPlRYwzntAMkaVAyAjbDZhOYWGBKMRuxWqG5RmMotG3gXnoY2IiQMN5EW+6yvACezSDwOeFHt+NTu+tT1VHPD8Y2b4L42GhClrxoaB3T9DA3RVR1VYbcKsJfuW0UAM/ge9KfMHmuRq5XEmHzZcgkgBk55kabYu12+QfXkXei/Eif8VzhAIxPQL04ZP26bmeZ2u3OwDkD50J3ymzjrOcEDF6EN2PdmKxL+bhqU7Gx8LvAWrm0lRkcboSdiZMNAzsGINzPfvaz9BgwhnTDMfhc2FhXXnnlwDHwK/C3HLMeDeF6CNV66EMfSu973/sGwrBQ7ic84QkDQIOwhg4cOFCoXTaSbdQ+HNduvvlmOvHEE+kBD3gAvehFL+JwPBjqjlBivf4I7Tv11FPT+hd5Vo5VK8P3NqoVzCpnClyLnobOYpCMTLLw00ObcoVbmYWAlz12/dT+JnYei+7Y4vemZmNATNq22BxnF9we3jEouGvewyqQmVPurPoxmNQNGNSoBT0GtnC8HvrIu5lhL8kkZBdXxfoNu6MdF6wJlQYdC1jwmLCYNYupFqFV3lWNgt5AaF/+mMFuNOgWiFdKxMuxcNPGRlbb+KyzpBhp9UYrV9hXhYw1B4CarPY0wzF09pKeSUs30X9K9VWSrFN8vJcs9gGA8PhEX+CcwbBP0Z8CwAExZehgOVFANTjOPKYRggFABwCK0sQZlblJD/lk4CNH0LxomCIW3oGnhMGhLN6oKRDVqzSG2AP6s68cBCPcsALgSgkjZ2Vy0vspD2wwx4n+t3KceoToCmHtcBgXCHoMqsFBHGQ8ghUj5ebwFg42jWlTo8HsKswzAGYA0EibwSRrG54xyUIofSROKlgPDWTjQ/a6BBCvktJw4vA5PPNxxHpOMeO2CctousKC7vXkWQFouRj0yIkDmnNU+yMbHnSzRKtLdLcAagHEUZ8pBhOcqaYT0TRAdoBvBuuz3qnQnsVlWuhAsNpn4XNoskEPB3XE/XtRzFp4WPRB5UMJuStx5AUGq5CxFM9NQC138PrCOMK54sjKODPHtN6fSpdneCfP9uzmzdv63IqxAI0vyfiFsEBhqUCzR2fgAIyDPhbAO89VoUp6+fTnB089h6yzWLQKMxJ2F56HXjcBRF2VEU3POJg1totY3ntzqH2NeXno3CSE2nU8qidsQH7+DdH1rAxoMofiuqLvZstmm1UeDqEDQ0oPv7MdV7StUB/GGA2GjREqbguZt42xgQx1icA7nr+scYr5EmH5zAiM+tk3h5uhf68oxLhK3tcc6j8IqOnjc6nbZfYVSRIInveQbTWkeow+VEA57g+NNxWl6HD/6vdGHwZOTJ1OxH3dANCXCPsLiwtfsCB6Xn9m9IEIm1NvjPMS477BLSOsGZDts5/RECbvRt7IdJsDLLPQqZAP2TCUGawpw/jcaiKW7ozxnFiPO3YZB4fbwATSnWyY/I3v8o6BM95utxmkQWiT7RhhFa03+93f/V3WyNqyZQuHYv3Jn/wJh2P9r//1v9I6n3HGGZntsnnz5sx2kXbbSLZ3794N14eTMMHAGHzgAx/Iff2Od7yDNcPAABRGnKm7pvdnkWflWLUSlDoGzVzY5elljFpkwplo806fS80KdA/UDmW1onbw4DjBiQOggkWIyubUB75YjDlD+0MWesox5U/GcnombQ/dimpJKQFkleEGVFXszIkYMf5DVBI7BxwGodgWStvF4rQAfKpivebQci9gp9EhlaELbJ0KEEBDM4PvD12vGJmrEDpUYDFm0YtS7ShMKQWkAMgRd18Mi1gGpKoN/lT0mkb1g60984A/AZzMTFq6CQNQxsLA8SzA3V/cMsuM+yM7i1Lq0EXVwZCNRGi7EkcMXgFoMq+jj0ldd6rwTnSS7ZCFpeNEC8PQdbHrWeU7gnlgLRyzvOdowDkzwnh1MEt37PRzhMG0DLFekCCAgZLqJzggYDWyA6aFy0QJ2IKwPgA4CKeLk0xw0D1BaJ7UF8fMtwMGHRD+1iOMGYQDhiwjglBBsAxw/f3LbTrURsa9Ch033UpD+gCCTDFDyGN2AxxLPLQQuWcQk+J0/hIADMCy0ijrC2BDE0/P7gbjDG8x8TVxDjKkVb2ADrW71HUVA6yDeaGtri9C8rBp6LSwcLlqB7k3O+COR0tBm89H5CW3CXSwkuyUnhPwZgHk39HeSx2fRa91BpDSCRud6Spr7suag0UTR4XO6BsDfcN5YCqhbo6DcEvFnGsQwKHBjRO5PwMyAMPRnj2fNZNk/Mm8JfOtAFQYZwjXqnoRa+Xoz4OEI5pATpG651nWe7PIO0vOHcgKp4Ud2Z//PrAOAFSfJ3XQnpnAGdls86xoGxQ6LmtDzfg8q5669RlvCpiVJAvC6Jukj2zhpZi3AKYwgMQhxoPn6BtPeC5rLthBajyByQowXkLCpVz8LmG9u5j80KUIjKjKoB6Zh6yc9T4T0VZ2aCeO25+s4+XVqed3qDFBwAT3DQNk1b6GmJF9MC2v2a+1JtXckCrYrAgjfp55gyAJO+RzMS9L6KyRGVFnEpqbJau1JjxWDKFUf/EXf5F7zPXXXz8g4nws2DjtAu0ksQsvvJABid/5nd9hfSiwSUs7+uwZz3jGQJ8DpDrttNPon//5n6kpYcqlTWQlKLWRzRZ3X0CXYRwbtcgEWwFaMFggIaU3h8DEPRasBSAFZyDoBdRC2BnBeVBDzrrDZdTHTFttLh5zWVwWyzs+azFTZGEs30EFB0wJLK7EQVdOtgIlcA+kspcFMwg41msCePCqVAMewRupscaUgoc3LGjP92fwokJQRFpJXO5AOzlKrwE7oaInwiAD9GTqDdaJwkqbwzsKpIy3tWce8FckzTeAMzCiQs8lJ2mX9HhuLz2EtGZtGxEAH7yw6XwApCOqMMFM7bDbWFvSdhIONZYl2Q5VKEcSNiK/EwFfOKgD4uc5TLIiWlYmsyRvUa87XxxmVYAxJn3uUp2dMzggwpgyj+uLhiPzHdpBMani2OOQypiz/UFbSAEKKM+Sr/Sf8JxVvAaXDSF+CMGbjwPqJZA2GEwL7R7tPdilRl2lYVci0dWUZaG0qJSmEo6Hw9hGltAOQgZjdirVPbusLYUMkLpVtPGCtj/UblM3CLm+AKSqXpiG2MBJ3b/cUfUIIbIOxgEyYYUMHgnzb7peY0Yp2F+oE5JDAHgASwwaQ4D8AIRDeylOWGbMEgkRmlRlkAxtiexcntPj/sLfANmQwh1ZFXUmTVHNszzgKQ0PzUntrsKiVJ3B/WpCw8pTYvJZ4wnnIAQyCDscVskhlglY3hds7gNSzLzS5g+TEZM+9/zuUUkeMjV2RrxbObS30+X5lzXf5F7ae02FAQ6+g7LEu3U2jCnkLhpjOpivA+smgAFgBOMH7xHVvxWlT9ZVYWFpn+fpBFnqj7aybSjoZdU1wCBCbeonZZnM66osTqG5BY8MGMPQYqsAkQZ7J2MNlDXGbEyyAQDL0kYDCVTikFr4KvaJqg113EC79e/PCSkAGmLzKXRoilQIml5G2ztEL/sQI0w0llAHsLUSbU7TMHNgoyviZCcj1ooWYXq9XJWouM6Wfi6HHYaIqxfG96BWn23Npq8XwG40N7HGWRMe6/YHf/AH9Ju/+Zu5xyA8qYhBtNnMsCYZx/Cd/DazkOFvaGvBmQcYiR/bMXKN9d4uACiwfrnjjjuYSZNV5yLtcjjrvFq2bdu2ddGHh9PAijrnnHPolltuoZ/7uZ/jEEbopOlsKb3+RZ6VY9VKUGoDWrrgSxzYAdZMqneQiFcbjJoRFy68sBDDQnO6pnbvAZjAoZNFsQpR85FTjzwvUgCBp3QUeGctCdHJypxjhowM1D1deBcPq8g73lzMjCsQi+/74Tl2sWc9S9yIizF4AohknH0W1b7AiFSIx8jdwoxMRQOhVzGxMDOkhquhn6ZdZ6AQxyCtmCVLUnbVhhfZecCftFluJq0k+w5CJLxqPvtONxOwKbrLmjeORo3JLCHgNAwFekcR2G41qqAMmq6LLQviKCbZyFAdo8w66GQ6CPqxLnnUCbocRlRt2MFCsb6+Sf8zsJGUwHofwB1ytFhDzaVmXWWCYuCVwZSQzxEwDuyaqVqFamAsIVsn+32KccWhgYmAO1od2iZbZhXDqdPt0YFKh7YkWQW7kdLo6jGrQaVSX+wGtNjxmS2FUM6peo38QAHwrtuhRmM6s97MXPFD6oQhp1eveqiTp7RToMMS9Dgcl7MLugqkdph9RtSJACCoUCEc10HoJ57vhHEaey7FEEgGqBOqbHno50bCpILTBtYM2GLgjkHMvVV1mJkAIEcFRSptL8zZKkvpcMjTKBZjFvDEwGJSVtTXluYd/4a+IQx1M8MXs8ZSo16hIKoqgeq0JuqeGLeKtYkNEia7pfNBP4uk5fnW5sIghBg/MgIaoPKIdyvAlrbfYe0lgABpO2rX9qDfZ8wPWc8cj0WEFCdzq/mOMsF8tO8QsJ58xyG+kasikZOxiYy5MOid2co6tG6w1B9zrm1DQS+rHl4GEWpkEA06AIZbQyD6wBxcIJOeGINqPaJ9y8tEUY+2NKo07VTHXwOlmeYGmUcDAJboHWnXHfw+JPIh5I5j0OnVzHGDj5CFE8/5OOGhuSbZ6AD4CNCZJH3R329pPfEOH9HO0I3ygy7VqvU08Yp5z6J9pZsOpMIAzoMNDo2o/ppi8HnJWy/Yji/ZU9kGQWb8rIYhK9+f/dmf0e7du9MMa1/72tcYcHrwgx+cHvPlL3954Dwcg89hYBk9/OEP56x8yD6n+i/iv5HBbCO0C8SvsaklbYC6QegcOkMSfos6A7BC6J4cgzrqYul6u2wkWy99eDhtcXGRbr31VvqN3/gNrjv6GfV9/vOfz99DPwyaU9KfRZ6VY9VKUGoDWrrgc5KFUKIDlO7G8eIIXTvMqMm1CRYWWAzOVhrWISXaDTrYBacSO4N8Oy0Fss3xtu1kmkyUrN0wmzNlhiGZ6bX1xYy54EfBTOHaftiIOh7nZoUwTWJZGiE2kxApOOIi6M4OTaJjhHOHABfe6VYpq6MgGNAUknIH2ER1K9Txk9CrRH+GryMMHgfnrIyNNzajyMIss4Xl5S1KwRSAYwZQddqt54YbmQDWKJZDlvXDPMFYqaT3AsCCrHB4Nri/IhoEbTNCXkYxyYqE6gw+FwDIVPZBW8isAtAcTqk+3+mSw1mhlPjxOAYgBGw7gDsIATHbEeMQrAEd4FDtp5g16AsAKZhPIAgORhBAYYz3JR9ZBxUo1axVOCxPdKY2TTVpBsBPHLNGE5hGyxVoM0XMroKeGHSmAPII8I3MeygfGEvHz7aYjYFwIQglmxlFcX8BHAFAIbvfNNgKCUMFnwOQQrZEZD7krHhVj/yoR61KjVmWYGjBeeXMgXFMC8mz16ggS2mdZsBMg15WjDlU8YSYOQXAJkkkgHMhnH6w3aaY0a6YAbUDSeaxmXqVpgBUJHWsuBHP3OY4yWMxwqHu9gLOgmobU6grQLEoCqhFNeuzgaI16zUr6zDLZMxLKLgAlvL8sdA2GIQsmh4xEwzvolymLM/vPWah2rTD1fhUYaes2Wd5t4L9g2QOeHoG2lF7r9naQMA0gI+4NSf/qFVSuI2zSKabG4O6bVnOuQl+o6/gGIDJA0P5WlUFDDMLV8Yxj1WAoZYweUf0DPv151BBZvr1yAFYg/mB1POixiWWKdi0oD5TquuTHzkUBwqsNBl2A31kAeL1uQL39RFqC804Ps/pvw8gcj3uGsiiwzlkGRsEA99j3QOABWVIgSgAMErTkIXNXZWwAHNoVctkuWITpjVSx8ZxmlzEbNu0nvpmZMbmJBKuoM/wcFQmaROLiV6gZHTlfmU2Z5wyhNPnhROW9NK1RtZ6AUCmGyE5CfpPWPkle2o1DE71/v37+TfAQ8k8dtZZZ9H09DQ97WlPY4cajvl73/te1sZ585vfTK961avSMLZXvOIVnJHt9a9/Pf3Wb/0WfeMb3+CQJ2TkE0M43Ete8hJ6xCMeQZdccgl94AMf4Mx0L33pS2m9GQSrf/CDH9CTn/xkmpmZ4b9f97rX0a//+q+ngNOv/dqvsebQy172Ms6uBt2hD37wg/SXf/mX6XV+7/d+j574xCfS+9//fnrWs55Fn/nMZ+iKK66gj3/847QRbSP14ST2h3/4h/TsZz+bQ/aQQe9tb3sbs8Ne+MIXcmZN9DXaADpjAJqQdRBAFDLvwYo8K8eqHVFQ6tvf/jZnKoBaPcTCPv/5z6fIKgzhDOjsv/3bv2Uq3GMf+1hOr3n22Wenx2CSRId/8Ytf5JcVkEk88Jgkxa6++mru7B/96EeMfuN4TIob1fqLU43WPiqtdI4NLTrHXMSN3InSHGrJINSvh/24LBtg8eTcd5QWlHwP51TCVnRACYt4OL5oE9H2gMYNjpfzEUbUp5nbnZ0i4VNZ9cjSCBnVLslV2entcXmVGPBQGROhejjrCiQZdppwPThJSeDBABCXSNvTSqxI+xQCHav2sDwdCGrjGUmEVGVRC4dvEWEsSX1iQsYvpT+ks5myGEfjhoRKmCcLymsME2ZwIGGAZBsboQ+it1seM2ykg2WUVel0YMwbuiCacVsACIDwsofwqNrIekt54QCLk8xsJkdpB8Eg+tsNO+o7hxhMQPnRF8wsYvafyoTH4a/4LwgYROgk2W7wHIMt1YKYUkwctiTl2NRqMfAo4V7zXWRYDJk9xILpiTAxiow2AKiBe22bqTP7cLqGLJKKtdVxFcjl9RSrRvUhyqieIxWG5nH2TxjPH52AdaU4NJBD7ZQ+FoTX0eL8w22OZzKgquNRN/A5RAUlnqrVqFb1KOzFtBh0OIsXmGAI92PguqKADIxHZM8TsB0AInT9GIBiRgZElVXfgmmGH+hV4RzzGRQmB5hM5liAQw0gQMK1zfEvLAi0d1YSi0mYDcKehJ4UmHoM2oQ9jmrGfM3ASAxGTpuQoxFMIGyO5DJlYyI/ZuoPM+LQ5kNsJmi8sRaPfR7G582pwXDOpMC586SAaZhF5FmQtjHflZI0QObhLOdcZ1/hSQN4CM01aJ4hxBT9AbCWw+Nd433JWkj9cL4QWnBM8/LIleypCXAB8IpDUYEjAAxAyKEDcDgZZzwvxhwqy7Q1jOPWNHnJZksu0yXZDNKNs2qCuRjHKvSWM7upV1GVQSjFuquDkbxWmkKj1ilc9iawdv1D/j/C4Pl9kYS665sG47z/CjGtjVdC5vg362PZnKxhjndyMvzmtUkGA998d/JzgPvIsfp5RTdMQ4QDJu9zTvWqkuhgLKwaE+0Ytbe+9a3093//9+nfyDQH++Y3v0lPetKT2Cn/0pe+RK985SvZAZ+ammJg4p3vfGd6DgS/AUABuIGfdvLJJ9Pf/d3fceYxsUsvvZT27NnD94OzftFFF9Fll102JAy9HgwAAgCkt7/97ZyJEvVD3XSdKYAUX/3qV9kHBYsG4W2o28tf/vL0mMc85jH06U9/moGJN77xjezjfuELX6Dzzz+fNqJtpD6cxO655x4GoPbt28eYwuMe9zj6/ve/n7LrADgKHoFxgfH913/91+n5RZ6VY9WcGMjPEbKvfOUr9F//9V/8oD7vec8bAqUgNAexOEyEeNjf8pa30DXXXEPXXXcdNRqNVHAMgNbf/M3fMD0SSOzFF1/MDzgMWR0Q64n0jMiKgPOB0AO51SeFPMM1MLEcOnSIUc/1ZiolcIdf2q1mkypJuEpRE+0K3REdh/mgCxTbstisxPIclLz7ZoWdmELNSowcDtwgywkLX2i0wImbaSpGBAvyJt+z4+ep1Obqb3sZcR2AGRVtJ9Q8RsJ5sPuvh/eNYkqNct504MLKlLKIhmaFKq4VBV7ap6a1pVl2WawP7JBHaBsBIvohYHnaNxBVTu8F3R1y6UB7mUENCGSjP5m9xBnbAHpisazSgjPTxgKeTTI+beyaFATV+joPsEO7QSMITudMvTGSSbeac8CocalfKwW74pi5TnC9JUMna8EkbYtzFrodWuwq0XJkP9wx3WC9m+VuQAeWOwxKQfh727QK+5F2BMPET7StkF0N1zu03GbHFcwiM9uojPfFbpe1qJAeHiwoqbOMr3mkLIdANkJdADLBWXegA9WmpV6PGp5HW1oQLVf1WOx0aRnHI5ywXhsI/8L9dh1aoHYv5vcU2Eton61TCNNUDFKAkXgGFtodZlMg4143iJPsfK2UhbVrfoEOdXpUr0BfyeM2A/CyqQmmFVhnikWqgGgFyGJMA7Bjpx7hU0noH0AleR50gXUpM5eFWVrewPMp44B1iWhQl8h8JsaZpwSElOeGgbOM8MGBOd5JdNiSTZkIeobtDjM8AIKAKZV3X1xXrsVhc1E4ENY7Tij3JFbkHpJ1T3Tc8uY9/T2HOkLXDOMH4zIF5LXnWMbK0P3DINEUdFhT0LVsgkUAlgHQhhAbd9TfSUIGzG7jSgLkGdoA8wHKynXBmEtZ2PGqr0NW+723IULJJpBxyLWMDdOhtjDvq58nwNSoMoFNFfrYOiI/QKIHhyoImRpzo3Ytbb37E6WVVlppxyRTCoCSrmKvG7AyAEdAjn/xF3+RP/uHf/gHRlqBIL/gBS/g7AdAX8GAAk0Q9ld/9Vf0zGc+k/7n//yfdOKJJ9KnPvUpFh373//7f3Os63nnnce0U6TrLApKrTszXt6sDxEkqecBgIz5/pUdNLVIGF8kcpSOTuYip8DiJ4+JknffrJAwXQwX38ti3Bb2BAYFDAt7gFY6c8RcWGa1l+yEKhDMXg+1Cy96JyPEt0e0jb7QM1kytjIWDZ1baShilmWFl9mYSeJgQ/tHhRwN9kle2aU/VdgTGAScdo6magjb61ATO+04hrPqeUnEhcflgKYL2kh3ys006zroqQNOIrpslkfCjHB9Ab4UeKL6D22dpweF+iCEDF+3/S5VnJB3mZn5pwkJj3KCdOdVyjrKWTLHpXkPfT6RrF9g9AD8EKaU7vyylhaAFLdCnhOq8CWwYaoKKJLwtBZC8RKmUjfocF3BcAJgxKnY/S6zjcAmAsgDsAbfobzynEhWPw7X6ymAEvfTwwaZtdJT4wBt3+0pkBKhIXCIwa6CLwygBlcVvSRmYHWVAHfFEsq7udkir9smp9qkAGMYzFTHowVkxZOQ2ERnCX0f9FyKGWxRjD0e+72A4shhfaq5eo3Hc9tBCBZYdqiHwzpY8/NLHDoIdhUyCAJ8mg0BCDp0YLlNy0FIURjRpqk6NSt1HsMwYQgKYA+ui+f0M5mZ4x56Xxwup4Vi27SP8t4r5jjX5/UsxusQYGuEIIHtMzXVpKmcd4t+XzzbuviyXh49NHqtgAQZe+Y7QDdhTmXNe+ZzCPLgfKfNYZ4w9JFkxpXwyjQ8EFLhxnsgDVl0AHAOJowYDkmE46+AA3cgnHvlbFqzDfC8wvj5SthUikEWMlMRY1zYeablzYe277LG7qRA5Vq9R0dZ0c2nooz1UfcaaMeM0L6httDYUAgRh/adxzprleJlYl3NCutp+WA2hrHKVlxaaaWVVtq6t3WrKXX77bcz7Q8MJzHsLiCzAeJ2AUrhN9TtBZCC4XgsiBDn+0u/9Et8zBOe8AQGpMRApQML68CBA2ncr26g2+FH39lYVyYvb2SXiV12rKYTp2KstMDG4sAU5h73/JHlNanXBSjZo4An0Xoqujg0r2cru2gdQFtGiQGLtHfB+momwFBe2wqoUaTvRgm9jxKqXm9mCy9LQ36SMC0xCX0DyBGz9pLoXqnwJT2DmoRpCWDA2lrVCmuziDizAGJ4dqrI8oQglURwGufgurqmi6l9oqdZ14GzNDNQLXvHfiBb04BQdL8/8/SgUC8JR0PCA+hwgNHAuligXSXhRLpThYU+mC1RonEEQzpuMJfAMJpU18sahuEOZpvMy+omzjb/IBFC2FM6WQlrhsEnCFAzGNUj31XCyQi7DIKIjptpss/Sxbjp+ZyBjwW9E/26VN8myeqH6wGYZEaFp8LeWOcORJuk7DiWWVcOsvb1eHZiDaUACRtc2txQTCg9BAlsHNQXZUOfms9do1Ehr9JKQPEGn7d/cYk1ZVTIoGIVqVDdKte3F3epmQA1GPsUI6GCR5sqdR4XCAeca9UY9APLEu11YKlLC0hOAJHxXkD75jvkVj0Ow8N4PbDoc52mGw0GLFBuAQf1zIo8TgDa1RoDTro+7hWYNRhOrQOc+li3zX081+I1hmcsEYEVBxqp7rN0k4YAW9NpLeDEZj1f5ucjN11WydLnKFahiGZWXYCiYHQW3cBB9ttD3YDbs1FVOmR4tiTUMk+TaihksUio/ag2L7AJlQkaaeGCmKeE5SWgpDzrDEphwwKhwpaw5TyAlL8rILRdRB7gSJsJ2kp5i2RLLWQ5fTmsC1YQUNLAK9UXHOPNbLtxQUB5dtNnG6yr1WJ+lVZaaaWVdmyBUgCkYGYMKv6W7/BblOvFKpUKi4vpxyD0z7yGfGcDpRAyCGG6dWvJyxspqMPIZ1FL0S5ZiY2zUBmLhp4lgmn53C5Q7uVq4IyzOCxyDEIRwl6PHCzcE/HolYpl5t1XnNC+pk8/G5u5CONMRlpmKHP3FotRLDzZEYfTmIjmrtZu6lihOOzJ9xeuRccMO7ZgDhlha+IEe0m7wKTvoZWiHCfF8IAWF8KYRGDZBgLJDn8YghkTMnsEmh9gTwGgcuKYagB+EwdOawQGgpqe2s0FKCw2ytFL68JhbFHSNjqjxssdF2Y/cJgWwspQb2Z/VTj7lIjb6k4VnDgIuwOsQMp0WJfZY0pceRwrkgVTtH9Gmc7WA4sDTrPOkhFWUzdECGBIU1VoWbk034OQNtGhtk/bppvUrBBNVRWDi/XPElacznLhcc3MKmI2FTK4eU6PAWgZJ8IGgoOLZwkgFECT0FHgWLvr056gR8fNTtFMEr4ozw4AFgFTbWGO0lY4DuGDAJmaVYcaHnR41PNNyW9oRbEuE2qdCOALiwnPAZ4zhNbhejpwNNusURx3mX2171CHGQMNDuFTgtrQEto8VWegAuGNJniEZ0QBVInovpF9ETpd0NMCk0yf1/phdwmLpcDcx2MbovDoEzefwaRbHmBrm2eYtdcJaDnwmaEGbTAb+1FANSm/MMcko99ahe/B0udIqZLbs+qOsYEDpuFcPamPp4B5SYZgzvVFrrdiK1AH/T2LY9J+NM7Fc7WE8KygR3NTSi+Mw4HjKmcvxZycpemn8nA6/Izr7zr+LgzIA/jb6xBV8EwNazmqsRAXZuoeCbOxD5llxyAP9AAnuGiGxhOzmixM2bHbxdAeJei6JUL144KAA5tdaRggnz1BxUsrrbTSSjumQakjadCe0oXqwJQ65ZRTaN1Y8vLGmgM71thOOtyv2rFAmqydMl4cJwuahFnAWkHIqhUixX0lzail65Oww5ZoQcHZ1EGAUfR8DhXqKSZDFntDLYSUkLybOleTLbTGAWKy0n2rpsrOLCeOLKwn7BAwGZAtZwwrsps6VihO1RlYDBYdM0XDMvVMiDpTCgwLU2BZr4v0ST+7T5WWw5iWe0mK9DCgulslL4ZuD1bxyY+0OUBLPobIBZjDtIZ++XA/1oeKcvo8WdRjJEJsPmt8ZLWZPCeptgqeE4hWR2AZNVIxZr3ecOCRaVBnSlUSppQN8MoL+dMzFeZlwRzXBsdcP1wJQAhYXXg0mzWVrc2ZRcieT7P1BmtQCWAAZxPhfgClAJz4SCGZMJ2gyYO08WBisax9HLNzy+PKVTpV6Dvojy3hOiysjvHlcZ0Bjs0vA/TzqN7p0FS9nzmwz5BTYCrCwMxEBVI/fAeAkI93PVrodqkWelwueX5Rb4BqSnMrYqYTWEp4vpBBkEXSPYAmCqDCOEYbzDXrrBF1qN2lVrNO0xTRppbatEDWPehPidi/PqeKthC3FfSrkCHNyJDKjE5k7YvcFEQSK+qM6oAIzHTui2SMzBPwtz0z+AxhjNDiwpDegqGbkflNsUzdgd/qepOxYoqG0Kbtj3lbz4amb0RhHk36yryWWTb009balLVMeEYWOl0GqFlfz8KWXg0G0MD1RmRoE7BHWI3DjJv+uTxWkrWPgPMYz3UwXnlqjxl0NseB1Ik3d4KAgsCnKpJkyCYMGFIApGBJBjjTJJxTWLjrzWzsQzEFSKkQbzzAQ+Mxj82mA4Mmq8nClF2JpSGhieUmyBllE2QGLK200kor7fDbugWljj/+eP69a9cuOuGEE9LP8TeU/OWY3bt3D5yH8Axk5JPz8Rvn6CZ/yzG2jAobIS2jh/h5zqgzJhV+Ne69Sruo5oKGmReOQ3DXJPW7MGB0sIZBF+z8Gjv5slufRc/HudDiUTug/bCr1BAmAYCMNTT6j8ekC63ckIzkfrYMMTrjRl1H1UkcbzlOd4YlBApOnpR5nEXzKM2SItmyxKEU8WZOoa47EuaYMRfBSZiKckKyx6zOFLI5Z+NqcQlgA0BALehjih2Pxau9ikP1ep9RABggRKYuLwlrMRa7Asz1Qp8zhFkzKyULZQaWc4C6rOdMnhNhoMHJRGhe7CQizTR8LZRhtjLIqJTwOlsIaFaZQi0EcqznfwwBXbN/fR8hez3WkMKd8R3EteemVBicrsWDc5rQiQJbIo7IB4UMrCmKaaGL0DWUvEczrE/lM/CM7H34wfGA+BVLCs8WMgS61Ak6nPAA190yrcLTpqo12r+0TM1KlaabCKdTTr38QOaZQfBElw7Xhlg6NK/wfEjINQCweQBgAKlaqm4ADSV8GIw/jEeIuc93VLnwjILxNNNspAChtJewCaFFNVMPWaMKdReGpeiZiXaZrb/z5ve8OYCBv14/rMpmeiZTsCEB4vX7cFgLr8g7bRRzD/+ertVV1kEwpaoqG6GtXsKm1H8LWzHt2zHep6NCqm3hTtCDApiaiq0DmAwBTibvQ5bZKa5xZH7fr7PKZqm/T/Ke/bHWFHrmvjTcPvt6w9pdej9q4GgUMfi0qanmeLBWGciTuTgBIHhzKQYoPMzW5HeVmwCT2IDSr4E50gQFx1j72AS8sZGB55YzfNZqA3p/wn7UN1lG6j5ZTFjKPNcI+xBsXA5lxnsJ91cAj5vosHEfF81yp4M7JqtpHE3RCYTU9c2osW2FGlmllVZaaaUd46AUQu4AGl1++eUpCAXGErSikEYRhlSKBw8epCuvvJIz+MG+8Y1v8CIe2lNyzJve9CbOeFRNdo2+9rWv0QMf+EBr6N5GslFASZEFprmQLbroXC0dBXOBh+sipKLa6ztHuuaODtbYFm2jnCl2ykg5adadeN4djUcumEZlhxsKFwiRJUzpGlTr/VAbWQTiMKTb1lkLOiMoa/d6VHuMY0UWfrZ+N0MK4VAqNhsxuNjwFJNPjS9nQAtkaBFcMPXzJOGUuuMMh0+cYlVmBdiIyDGLAsdEbWSd6oVUqWoOuw4GW9pbgDnoGmUJlctCmbWg0H5+SO1uMMBgyWpv/TkZDGFVrJ6iunL68w/IRhdox9+6E66Pda439GTHBbuLpvXO0ceBA63wW+XceAlgYO7UC1jDyQrQho4KZwJQVHG7DA6BIdUJMbcAiKiyQDjrTYFqESO7PXSViOa7XQ7jRfsg89+2aZXZDnpQS5xgwmFwT9oiTsPSFBiGMdBpdxgwrHk9mnMaDMRIyDXKdHAZ37sq4ycDK33mqACAYItN1xCaGnPYaAjArNZniJpjSDH2JGzRBJr7c6Rtzsyb3/MYlG0fIvJqzGSJ4UsboW+aiW5UkecZc+4CsszGzpAGmn6+Al36IJeMXxw/1RoM15O5VkI7M0OsE4BRB/OK2qhEIrb2N8OvzM0Y8/0m3wO4jDsRzTaaAxkHzfAntNFMoz703hgFuOQJfw+tGxKtO0y4HlgvcW/o+devZ1sLpPcI9XMV44f1tfjmYcpqAu4CIBlDo4IkAXw82nFYZBsbj1Hocbg+nw/9rALgxdjrrjhkZi3Et5U+lzOg9ydMPDCUxSbRfZIxo8KHk3cV6p5sDqnP1MbfgI5hBgPKUnFr+4ws54Tv+KMik2FppZVWWmkbA5RaXFykW265ZUDcHJnxoAl16qmn0mtf+1p617veRWeffTaDVG95y1s4o95zn/tcPv7cc8+ln//5n6ff/u3fpo997GMMPL361a9mEXQcB/u1X/s11od62cteRn/8x39M1157LX3wgx+kv/zLv6SNbPoumx7epluRBaYsdCEgLIYdNnMndtLymeUSnRVdhBo/cKhU9iwVkpcVWjcKODHDtEyNJKb42zfhlWUsysz6ZGWHs+2IozzdEPULyfEcqsbItqUWhxBqhn4VRJBdR4VFKdKHyjDH940jpQVSG7891sLMtuB2DpGRbJCZwMLMyS6w9AnYPAhbAiuJWTtoZ+zmotKpxtJoqv0kTD3RCsNT00v0hDhMSgvjMUOHJAxQZ0iYi3AzI5loQclneSCRXA8CxChPoxL1yzNiR1kPuVFlV89S3gLdZCbomlzYyZdwQJ1Nw6CjNtaFxaCHQBaypG97kUN+4OeyabL0ccByAYuoF6sQN+gE4fnA5zFnHMNYU9m38DmLHnNmRZWFD+UHU0nGbBXgb6XCAusz9T6bCeeyllWoNKxQ7k31BovlY37i8F+E+jh9HaswDT1y0jBSCZdEeZjphfk6+TvtR49oulHnlPYNAErVSqr9o/pMhZEBysFxYRssPoyZgJyeEmJHaB8ACWhMtSDon4jEo9+iKEjZMWB4Sf/1AUnFrkN5J3XupL+QATAGOyVH/Jj7InDIgUaWVp5RzzPPuUAdnJhaNMh+ScF/DnVUc756KobHr61MRd51k7KDbaFxtu9Hia2P2ozB9wwKAkzH81VrDn0v/856b4wCGLLawNqWPLdjgycpq2Vu57EHbTReD8Q5LC+E5YFlBGaTYgIpHWyHwVnQkKuOAh/Tvkb9MuYb7gtoL0IHDoMQl5ByrRA0GWojsLa8KtUaAKjiIb0/YeLx+5P1xEJyvfG1qnSWchp2y30BUN6jejqfCDiaz4CahNFkN4Sjok8qqxpOt1Kdz9JKK6200taXHVFQ6oorrqAnP/nJ6d+i4/SSl7yEPvnJT9LrX/96Wlpaope//OXMiHrc4x5Hl112GTUa/RCUT33qUwxEPeUpT+GF+/Of/3z60Ic+NJCx76tf/Sq96lWvYjbVtm3b6K1vfStfcyObqX8hL+ZxNCFkoYpFeydZzHHadi87JLAoAJW1YMCi0RShFibEog+nQ2XeguWFYBUpA+pl083ItYzdQLM+Nt2T3B1xMGvAhOoFFCKUqKeAAAARyHDkhhFVefEOZ1oF/LDmReJoDoAVK7SV7jDamCmysyuGfwOgsTlhA8YL8WT3FD8e+t4dyUyzsa5G1Uu0wipOhZxqlZ0bubacY2ZLFDZSHkPClokvS6zdZrg3Z5uDpowGRhR1jsYBJgGUQYcJIAzC3wb12AKKAHYEPS4HjPHRyKFe2KOG1xhIMCBO/0jGRL+gXA84iJkMsgL6OKJphecaOkGY/2oeNNRcfl4Q4tcJwDjyqM6aVxiHMS0ttTlsDKynqVqVZpsNatZuTuhCAACk9ElEQVQUMANHTrWDYs7JPdBOc02AfWpO1MdzvQqRecV61NkHOuOUAabE0eZ51k/0rbRwJNy7XgF/k2iu2We4oK8AGmJcYAwxw6+nhLoVRuVweKnSFST+vOY5zKjCmA5DOPM9CmIl6i5huRKyJ5pkeAwcFojK7g/dbH0s1+V3SqKRluWo41iEFMrmRB/szZ/b8JxP1VQbm2HJulaQDRy0aVSNCzKtlB08cP4Ih98MYSyyGYPvZ6MmLfodqnt91i1MNmTGzWKWW4dRbcnPC8YaAKUo0WccrKvKc0sM2DKfJ4OF18F4jmKa8mKq17z0ulhHcCh1GJPryQZA0tf6fIN4yDCgittMyqU2gxywudwKeQCWpS1WCJoM1YHHfI3q1ezjwMRTlQ0owuZAkkE1z8x3omyGyNyI9xuyyYKBbbanGS5qanuyrRKjSTHPtRDMVQqnM8dcyZwqrbTSStvY5sTYti0t1xA2CHDr0KFDNDs7u66ZUv0MSMX1hCQzEbRAGpUqZ8yShUmRF73tnuMwpUQzBkwpOFLMPqjVCmXuyiuDiLmCqdCqVhlgGKjDBBo3RYCcrOxPYdAlJ07SbHtK00SyXAHAkXAdZH2DECnUraJYMT7MsK6VmN5WuqMNt7pIe9iYUkXbxhb2mNcP4kSJXlKj4qUZsyTUDkAqPssa+2n5ksxDch8dJIDDLs+TlEv0TVK9kwi77iojmg402ZhSq7JAXrWd6r4tLndpvgtQyqW5VoPbSWcUssMCcI11ZlTYF8JO4ebjHBwvTr9NH6fIXMBhZoHPjjP0ukaNI5mf5rsd6gYhh+1M1+sMniMEDH0CJpWK6IsZkALrCA4LWEzyXO1f7tB8t0fQ3z9hbop1oPrgPtLJh5wRD0wsgHUAjCvQJ2PwTrEZYAJAqXvpYvN90EAfWwjVw9g5sLzMguVzzQZNNftzkRzLAvSem84FAkpJWCyD7G0FQqEvGGgDGNqLaHOryfdR/YM5ViWL4JAghPO4LjUAxGr9gucH16o4SrQ8j7mm2yTvGJvpoBtMf35krphvd2i5G3Dd8E4wxdlNcGXceXoUQLNmjm6aEcxLgPic+XEM475BxkjMcxDn55Scagyijua4HGeNMC6YhezAXYCm5FADzyvjEoPzmY3NrPelfBf0AoqjkK9Tr9fSdtJZQVnl4mO7bQZsWfg7AezAnGUQBuHYqzS/Fhkzue9PhFEnOlwAz6s4P+MdMPD+w9wTI9EFESKKMZ8JC93GPLNt4A0906v1/kF4ZOhThEyyzIQ31kXJuxnPAw9XsGHHBEwx1joI7XUrVE02AtbyPXq0+ROllVZaaevB1q2mVGmruGNZ4FqcUakCLRkRMlYLhyIU6XE0SbDQtjGgcH/XbTD4ABvX2bGVIUs3I03VHodUr0LfgUu8arvkmceCVQRNG20RPAjMQMQWFH+wohLRVc1hKbrAGskY0tpqoH85jK4YM0ev3zhtozMABspp1jOxfojZsF6SLcQlN7QE5dR2jXEcHGI47gAjlgAwhBFtmWoys04AKQkvWuh2mLWm6jHIYjAB1JWyKpKLDPXDOM6h7Vg4/VJ3aSc9jI8BAi0TGBw+AD4ioIv/EAKmn6uH8Nn6QIUARhzOifsDAKlX4RhivPVZnrbwVxieVQBSexY6tOyH7IAhvGVLvcWgFMTLsbWyabqZOrYcBhtDFwxCv0k5kbmvQjTbaDDIKyAk6oMQGjDE4MR3XaJpjC8PzCMlHG6GOgKsYzZOIjavt7lcV2ehYewcgsI6xMe5vn1gxQ/AVFWZ+DxHsexYHyfJuAe2nVwHLCiwSgDoxR40nAIOg+tBtyZyVVa8JEQQ/2oBrHMozWIqjD+0kbAArU5iDlBo6+NxwRvUjef6RLheCc2HNBWGrAeGsgK02r/cpcVOjxoAUqbhcIcJYAr9oGjoWRvnuTN1lnBeWi4iZhJKm616iJDGxtHbTg8/w/JsXICK+ySE9hrKPJyxzAzjK2q2thp5Tg+abkpHkYGjePj9kscA0+9Zhy4hsxXVd7geP4MJmDrynQOGlCZerupQfNNrnPdv7pppSPw9mfcAHocBZ/9j1hYAM2Yqod3w7uKjBy418P5LWE1YYeBFyZp0jmQPNBKBoO3wrufPc7TExmE05baLYkqhjmCJm1kxJREMzvdB6/QUeA721sD4z7kHZxPk8YXQYYPtuWqMr9JKK6200tbSSlBqo1rGCzpdMOJ77FDp3+e81LNCz4YWK5ZrrIoDnoT2QXsJjt5AKvJRC8GMjG1ZC14JIcRSGWwLXqDhx6xjIjC8EgBITDFQlAOrwi3JvnBCOThLH2JqLLt9EXYde0QARVwD3EuO4YxuLNpqd6QG+0vvX2fAUVprFkFRwFOyCprlsIW4jAPUSrgeZ9yLoTmFnWKl+2HeS+3m4tqKKTWqLdaKYaHrwIlelS1sTFh4CFdDOFtdY6EIKCx9rAMoSsMsVjovyTnQcYHzh77Cf8Kukqxvuv4cs5q6QerUizB6N+rxdSEarwDnvpaK6HXZ5iBlDme4O26G+kypap2PB+NqmbfXA5qJwIpS2lF1ArMI11KaThAx78YhVR2XWZOwRQgPxzGDIDhHgSGYH0KVqc3rO7wok66Zhh4VJoK0NwCNQ+0237dRrVCTgU0F/AJE2txUrI+KBkRwNtDAZ2YX5j1oWkWRS74f0J6lJQZB+Rlg0F5tHsQ+sZ4UwEIAbO2ez/4YwLla0ON2R597nurXNBSxovSw5DnICpUSYBAGoA5tgvrkhY+Nq++COThOgGaMMfQRZydD2HKSYQ7l3NKqU4PZY0r3i4W8oTEGHbBJU8QnpgM0aD8wTwByQvMOhneDAnHH15Ea+fxrDn+oZYwVoEGJ3y8nYU+DIHjeffgHWmfJ+1J0hPq3VaCtsP6yrmlm6sPYBtA5EF48whCuXuPNAG/o/VLofF1Hy6v0Wa6TbL5lAPyjQNkhKwBwcJmgq4Z3NbQ6+XlI1hGm+LsJJGIdA1BGpd1U4us43/Gs4XrpuFA4NmtHYS1EnFQlo97QVsT9GPypFXpX5bFY+XOUm9l5lnZJdCO5fk7yjtXaCnMNdL8QJl5BNmXP4+fxUGdZHSRhl0bb62VKdboqfZb/wP1XEI5ZWmmllVba4bESlNqoNmpxZPs+55wsMdYhx2WMXadxQxFwnDinA4vNjHsWWhCNuo+XOL9J9p6B+2Fl5ODKuI9nXZDZHHOb5S2iOfyr26PQ71CDHXlvGAiTMnE4zmCGbPMY3i012zDDBvvXGXCUsnbGs3SFxgViRjkWK9U/sddx8NoCNiA0CE4vjoVTb96LWSqsa61AIHbSNDDIdMpN536ldbDpwOkOvHlfAXTUol85+6YmlhwL9oEADhyGCLYQwqoA2CYaWWZfqf6HVhFCcav90Lxeb8CpF2F0Zl1ZxlPcG2TvWAWhKwAuGrQJjolhyDKGYdtMy9hvp8hVDhCu16xWaHG+S06tSn7Uo1ZFsb8A/nI4se+wPhXqjXEQJaCZMGXQojKH4W8BAJQp4Gmp49P+xS4h8HY6hFYTtNYUCI0wxeMa09y+850u7d23zLpW0BIDAAZgSjJwIdEE2FBBCOHmiNq1gOq+CklhsDHq8ue9qKNIFI5i/EEjB5nvwPRBWBNwbQYJNb2zVq2W+2zpwKBkc+PPUZfkOBsANS5IIGCfvBum3Trrb8m1+NmqeMxA3DKTHSY7qen1x/2WugiLRMY2iNNX07JNuuGSBdKNYp7J8waATGUqy0+UYL3PCIbLKADRZEXBANxjPEub61kLs+Z9gAv1pv7MFstul72pNBk7d5x2GAmuFgA4uGy4hABDMd7nbnqe2jvrb6CZQOLQfZJnyvdztPgGBMoxWeF69nJiG4J1uCCAXhBQzjom/Zz1q5J1S2ID4wI6eI7KMozi4TmGyZzSCZRwPZJKoM/T8R92qVara5uS/TrpZeLrJDqIWgH652UwsUsrrbTSSls/VoJSG9SgNxQCgGAdAstL2Fw8caiMSlGeuaCyMY5MltIYu062DHV5lhXal3XPvAVRpkHw1wlpGuFWSajSwGJQvx8/HmqxlC7IOJOMOl59phCiPCbZqEU0C2X7cEqVIESVIbaIXK/XdxilTK4qk5VFxTvRntotxeecglvLKGRjfJnlTf5m0WQbE0ELP4A4ss68MMMQEMSUB1KNciwmCRkZaRqbjDN5JdoqXE+EPyVgQ5bTNRhi1geDTKfcdO7NOkzKpBJHTdgOuqacfl8F7KrjOUOVxkjSnWHUQ/8c121GGIGqHcQhlhBGCS1T9wFAEHPolaQzx72Q/Q0hVrozLRne3B7u0S8DPu/4PjNyEKbGLB9MM9rYseqDJe2GrJWNxoylm8GOUhp1ABynoDI8M0XtsKeiPKKYwSBpu/lOh/Yt+cxymmoSh2+ihNC/SrNfJqwj7nvyUscKhpmAGVFg9IQRg2AIvYNeE+tPJSA9xtV8u0vLfsThomBPbW62GJxCO8J5w9UgBA72EELaOHOfpvmF8mOcOjEy+kHYHaGGHofqoR4x2h0OIOYRhP8l2QTRFtAUk3BEFn3XtX2QjTDRrpMwKdFaw1iXvo9SIfFi85vNbCxHGdPqWsPghS1MdlIzwzGFBSmAtGj9udFkGQlHhhKPYJSZoN2498kzjB+8b5Ap0Tb/6AwlyWbIbcGhltkAfF6dRs13K9XSmsSk7aSO/c2wnPYcFdKmv4sFGNKZUlnnM1sKooVKFyldp2nlSMP18HAmYZE2BjdqFCTvfcxi5hEe5AP43T38zhisisZE0o6xfz7IUocNjYtkDQctL7/bVWuVZP1ghkFzHb2Yao0pqoBOaWm7zL6SPsBAzwh9LK200korbf1ZCUptUMOubuhAS0B73eqMIjOLGS+U8kPRCrGrxtAZwG497/wXcFZGUuktO115C6JMK1Ifc/ED2rkwNxjoUecjaw+eoIGF9hhMMp2tU6/WKQYbq1IlH9my4CDGmrOX1+7pPbUdwURIV7G8FHXeqp1lljf5G7erJ4wB8/g0/MCgypthCNiN7bN2NEH1gn01qf5JrmlsMgltEtYc4B0BHXQGmL64ljEnLBqTUShsDphitvRvjdTly912KspdlEmhm/69TXdtWO9rmJE0qL/jDHwuIY2OqzS1dAfR3JlmECFWIuE+Z8gKWZh3U6s5FOoFQAosnjjucXa2tFzQDur16FC3R3Wwi1K9qUHQz1aGvHZjHap2wEMaAFOzVlMi9gGnmmPmB/pfQDsAVHIdgGMAZxjY8rt8vLDGRBA4ilRYGwzXQVtN1SC+HqjMZxRxOBqePwVbKxYZnFUwceoV9X03jGn34iJtajapgftqYaqbKy2+H2fSiyNa9n3qIQTSAeOpqrLxQRwY4GrV4Xui7TgMzK1SG5o+YKAlziMYU9Ln4lCyM0jE36H/JMunZGsz25ZBsSQBAEwHb4uaDkAI80oHfFei31SUTWXOLVyGJANZ0FPssn5IXH5ZbKwz/Ty9vjZH2lZvE7TLMnPeEQZnXt2znkX9mtL3PP6SENiUwZYBwOfN0aP6dtwNrNUwaTszoYBoi42T2dX6Lh4jezBb6Cc/gTpXW0MoVjI0wioUQzQczMcMLUwT9DHfvcPvCPsYH2IiJcfIHGh+btrAuEjKwZ+HANYUbidl0vXtYBU3pgoOwnna2m84XNXL7oNkk64M2yuttNJK2xhWglIb1DhbSYyUxiork2JMgcXD3O3hE4ownGzHrCAeXxzMRBYj09j5a3d511/PujdqITsR82SC+gwsfrADKTR826LIcv2ssnE2rU6X/w1B9nqtoRgrSUYqcR7161gzFeX0G7O8kjAQDhkY1R6j2scSfjDQTloYgnJ4x3M49TrKQlyykZnHTaTZlNTPTfRWZIGthHOdoXTytvCacdhdunN/aKlNbf7OZ/0im1i0ZEQTDR+zntKOovmEjWARstYdfCmLMKlMgXIxm0OZ5WSan8v4E6aBQ37C9Ckemot/s34TwsNcLwXswESC8wwh9KDnp86hyW7AdIdsewAR8BmeI8wfHG5ZhbguwjP7YFudlMC6AHoSvjjVqvEPTMYEnNJeCEdwkPUFh5A1pZJwz374W0h1AfMI9Q0GBOMBZOKa6KtN1QqXd8/iImtIhXFI000l1C4mz/9y6LPWHtAgzs5XUfVj+CFWoYVB1KMGZzPE89Lgc+NOzDpTYGThoFrF5Sx8AgYJOwoOONhUmHNQJ9FXkuP6YW45SRK0sEszI6w+vvE9gwCc7bDHfe4moZb8eFoA6HGedWadcvZFBeTNuKotbNfTwxYB2vJzCzKxJAJIBNVH2ShGpw64qAyw3orZTlllAHDpamGAZr257cHGxfORgGR5YdIC3omemnqGBxORFAHuRtXRTFphtRVmURtHO6nbhb4YnhuAtA0GehAeS/xMVLOvl/X+zCu7fMcs6IQNbTDaBxi6Ts77nIMcY6q5uCY2o2oTg70j2VE85WUztrLGBbId1nnjCn9hwy8eZujb2tEiEm81S+hjaaWVVlpp699KUGqDGlwSvG/hjDBjirOnqSwnVsEhYdqwAHr2QoKNM1bpCyh3RcCZ51RHL6hD6JdE1NAEWAsv1rMWKxyyiKwsCXOMd+wK1CdnAckC0wAB8ZXtGMv100UhsuslWcAGNA64vcFsUvozo7IRSZhNYWeAdyRR/wLgTVb7FNFnMNqNr2QVVM8+D+0kdUQacM4UFAdUQZY2D6JObr6Y+yjHRX8Oel3yOPwzAdBYaB4C0coZnyQ0KY/dBcAFgBR+267J4yQRMB/4zJJ4ANpHEOuHYw/nsh/+1NeT0sMMTUdSB/9gvSQjXJ/pUYSFZWY9U21mY3BlhebiHAaEaNCBRtkwghBmBFYHh9tV6uk9BTjqBgEt+T1a6PjkACDjKBBVD2g2YZyAQdRnxCEDoWr/flr5wedN2phDEKFx4ik2xUK7x30HYIjVxRJGkRjAGLS3sOigDWeyzbyey+GKaKnpZp02NZqcWRCheLpJ/0AfqhOGqcA7NKFwPdG1AoiPsD8OE3UU2CB9AQCEQS0f+iyOOp9BEafPUkP4H8LWakrbCt8BkAJrSkAj1qPiEGkZH/ZnOiu01RzL0k4ILArB4FTiNykDywQMssAvAQN0MIyZbh4AP7x3RNB7kCliZoMU8E+YkzyGk8/k/DwwzBbupgMVmYBL8n4CHsdM4BHzcx6oImUA7CqMGvM8XV9sqlrl9wzGNUBdMPAA1kI4Xw+RNFlTJtsSdWDhbBqeN3UbNYfamGFD9bWwkG1jwbpxk7PJJcfgGpwNE3MPwvwBfiftBqAnQna4DkLt++9fnVGbVDRT45PbCUzjqnrOrOyqWsvaPsMM3ezxwqBPos/G7wKe34qDnml24mQtojNEB9hRCRt77PA4ZpwnrGxm8NPwdWztaBGJL6200kor7eixEpTaqJbsBqmQsgQAGqUZNSq8rKDA97jAmXKSs3WsIFQ+Va1Qw4uo4SX1KBg6kbtYQX16SDteQAuiYBsh9TB2TZVuUtV6jGkpuIbMWkFX7UpXGrw4BbMD16qy7IQmtm4BWPRd6wEWVU7YJeNwSWaaces69nEFhPStBuAQ/cRi1bW0juxecYhJgFjVpDGr+WLu49SnB2aPEuRVY1S0LybPNKg7caYhc1qtNizWLYZrgyEFE7DDBGalHeH8whpwwKEplABTg87HcJihDeBU7REhAoxcBw6TZbyMAPv0sK5RLIRRbSgAEo5AprpO2KUe5qMEMGh3AhYGB2DCocFxQPWERQXmmArFgS5JhUJHCUWLsykhe3pa+VSuX2OMsAZWqDTSHK/CYXx+4ugCmELWv4qRelyuJ6CiMG4YDOggPC5gsWh1rHLyA4TfMRtLwEh1fl+LzKGG51ET/ayF3glbDM4nACOEAnJ4YKXPxhINJoxHW7sLew0bAgfbHXLbXdoy1VLtFcKxhyCyChcUkfW8ZzortNX83qm41HLrKWOtz1qz69qYGlZZmkYChuE5a7pKN8vG6GLwgVTb6mGraCdxvhXgMJiJNgvwsAE3hULxxnw/6fXQgTb5zgy5FHCsDwYSA3YQ0efQeuibdTpq5gvBCMrPymfdJMIGQQigC5sfbmHwvshcMAQiWdgztrGQtXGTtcllezdV8PyQxxtd3LYA3BJ2Hz9flYim6nhfFWPTocxB2KNOGJEX+gPgsNSLdUIzwmH1ME1V37z2dHl9IfP1OJsqmOf9Lhi9ShYBY9eahVkrt7neLDTPIwNpotepjivAXs9haQ/YGBIKpZVWWmmlrR8rQamNaskiNl3KYtdqlGbUqPAsQ+Ab2hpYwIrWwthWJFQOtO24R00cAmQGXqUJzhS4j+tCpJ0vmLiDyX1zstBMUu409TCADKdYmF66KIzgPFZYMwqeABLQc7uCBWSKrVsWV5mAx0rCLlfzuElDPft68YN1hKYE76aC4t/rM6Uk9bVtnKdj2MlnBBpjgxlwZuKAHIdQtH5G6beI5YXISFgNxL7N7H+iCYLvdSFqYR7JmLNrhWT3gxmW0wPoEnQVK6Da1+NJy50ApzYdExtwYLOiYSQ6wMVMpajCmdE5Sx45tG95mZaDkOaaVWoJA4wjl5UeVMpawVhKwv5Cf9jZVoCR6kcImiMrH2ekchzq9sDAUiLibuBzyFwthoB5jZklYGehLABApA1Y+yl5/nFvXTQfbKiFLsKTPZpr1PkY9PcSQgTjiBY7XfISkIkZX4lWVS0HtJF2EmCnESnwCSGHC+0Oi6Urp3JQd0gHVaZbdRY/37vUQRQN1atd2jzd4rC3cTNfjnJ+9XJEie6aPlcCBANLS2do2MBO00G2gWED90rGJlpVdJdS8XoLcCbi/ypUaRAMG8VUHSsUL+P9lPUeyQqdBKAc+AEFALXrioWjJ53gd1YCnjCoGWF8qr0nALcoQLPRZEZhZvicLQlKUgcPGwUAL/l9NShYvZK5YKgtLcCdbSxYN24KMl511pTUm/+Nz6p1asYeVZL+L5xNNQ3P81QIYMKGNdlVAKRWkgUP7L9uCLCeqAo2KMYU94mCsItqYtU8h6JQhWnyZmdW22UAqYXmeR7DCbM3HrFxlnc/22aJLcnPCsI+SyvtWDJsFl144YX0whe+kN70pjfRsWDXXXcd1/mqq66i888//0gX55i2coY+WoxfuAVEHfFSllC2rO+wUMXvUWJQoyzvXnq5xSRTzbigBoeouZztan5xieaXOux44PPIrVHgMBF/rOtFToWCxKEZ+AqL0XpDLaKMusliLHO3GU5OrUm1Rotq0NpKQj24bLZ2WkmfFmn71T6u6LVMwznY2dXCAtF/y3Ag48RxQ1gDxuWoe8j3rFWhhQfYjgOo49Wo24tovu3TgU6PFjtB2uc6M0I5qP0QD2iBARxZCoJEwHrY9PPxG9nOOoHSgrLp4Bzq+jQPDaCuAofM7xd9pZ1kC+/LYzjYq6/APzBpWIOpWqHI8Wgh6HFYIAAgZvIkDCNfwiVtKcYT4EAP4TMN/ckC1L0o/bf5bInpbc1hePUah6UJswWZ5hrIEuhVGSRqgiWGp4nnAQX0KmZP37lk0Cb5XO8brl8Y0mLQVdkYodEUxxyig37tdBHYCADHpc0zrRSEsrVBT2sHU5OsWakyIIWwKbAkABYxoOSBj0G02O3RrsVlZmLgXGG9CDgjIBLKfWi5TYttn9uxl4wvzprYqDKY6IcBs6/McSmgypKPMYZMg+rZwDmbmzWaqVc4I5s+PuT+q21gjS34PoNnMg5QXow9fYzrYyHLpG0knFIvrz42AVih/mC9IWxRdOTMa0lYFr7XryeABzIlKnH74TKZIWO5lsxBVK0Xeo/o19bbBaFlKgFHNNhurPuD8MjIfh7rrnmsb4csljIurZayqPvzGfcbQI4kpBX3yZxvE5NzlcZdRr8mEgN4Qka1pdne+rw2ydg1GXDmtXHd2SkV4tgHU5NNhaw5LU5A/TigqVqF2bDpu187XvrG9p15jNluOAfszQNLS3RoeYkC3+dwwSBQvwu/JxyPKtUqhxY3a0mfjmlFntlxjss1bVym4wvrNkhamEzyEWOztNLWo4FdXeTnW9/6Ft1xxx0Dn2Hz/NRTT6Vf+qVfYsCliP3TP/0T3X333fTqV7+aDqe97nWvo4c97GG0ZcsWarVadO6559Lb3/52WlxcHDjuZz/7Gf3Kr/wKPeABD+Djtm3bRk94whPoi1/84hC49slPfpKe85zn0CmnnEJTU1MMOL3rXe+iTqczcOyDH/xgetaznkVvfetbD0tdS8u2kil1FJsslrCz6zmuddE+1q7hGhj8QD+EAC+0VyYANMQcj/zQp0VcMAw4WxZCJgZ27ZhOUWzHzLrbp++4wYxrFdklHwr1SHazWSDcPG+c9NNFWHJHaMdwJJ3fUk84qMtBj/VwNrVaKeMEJs65MGes47oga0sc9XagxIjBkpFd7KzsQ2IAR0Q4OuvausZTlngygxZVhIsgXAoQiMuMEWHAyPciRK2fPxYzI6c/atUaRbFDjUQ4XbExFMNEMY+QGdIeNlGkDOhP6NbEcchDUMLaRP9GnGHRM1H9qpxSAZkYYIhcaokQfHJerVbna8ApQ+Y7hMrhWF0g39zpl36PJJtdpcbC6jh/f3uJDix3mKC3ZbpJKBrcMxH/BpMN84ve76gP+keFvSkQUx+vcGSnIqXxpPSsiEF0jKFK3aVOTzmgGH/MojKYcVIPFs3GHOfEDATgLIBhlWTMMnMP8x4YD0l4Xl+oXIEqIo4uhjbcOjNlDZ9bC2PHOAZrNEQ1uF0BiNjE8G0MDdvc3On0aB6ZLSs1mmr2mYbm2MzSXdItL8xrIsbwmGa7v57BT2e/KatQo95Quk56u2lJJ/Q6yHlqnuuHr+bOFRyal4ShaaGwaXuMMd9KcgGb9pwO4vR6XfKdClU8lSxl4P0x7rtvDW2U0L1qE5X5sg7qkafCRJnZFPUGMm7qennjZGblmTSGcpnLcwFocJz9FmGV6bgo8Hzje35dFZCCyLxEsXDBscIKs8wYd0NzA+u2TV6X0ko70vaP//iPA3//wz/8A33ta18b+hwgTrvd5n+D5fTMZz6T/Yvrr7+ePvrRj9JXvvIV+v73v08XXXRR7v3e97730Qte8AKam5ujw2k/+tGP6PGPfzy99KUvpUajQT/5yU/oPe95D33961+nb3/722lkxJ133kkLCwv0kpe8hE488URaXl6m//t//y+DT3/zN39DL3/5y/k4fI5rPepRj6JXvOIVtH37dvre975Hb3vb2+jyyy+nb3zjG6mcAgzHoM1uvfVWOvPMMw9r3UvrmxNjhVpars3Pz/MDeujQIZqdnV2frZWKTvaFqJnR0e6yaC3WQhDJ1dkCK7aVghxRRMvtNvmxym4Fx2QlxuyaLkR9STmOZipn3k0ebKPsolkWgHob80HFrpV7j6CrdrOFnTZGmaLA551QtGMVDvioa1jGyOEwWWQLA0S3LKFaZIhCyBO0PKbrilUG/ROMk+lGTTGPfLCaohWNawFuwRxZDgIWtd4MXZ1adjaxvFC8rLrBssSZdf0dYe+IuPSqPq/JM3Ko3easdJKpzlbucUO3itwXTjVChhCuhisClICIN2o312yygwtAKq9fUa6OBtiY36Mv9y4uM6usVanQjtnpAXZTVnZH0Q+CsPru+TbNtwOaqldp23SNtkxPpRnUap6bzlMmUCBlg2Gsi/aLrQ8BxKCeAMQAOIq2F+YtlAXzNkBZfA/BdoT16WCssMiE+SD9ZD5PepmkHBNnrlyl94P0AcIX/aQfW/Vq4XEuz6wAj2j7vfOLdLDTo0bF4T6fdC4Yt11Wuy2zdKuW2x3yA2y2VKgKLcMCz6Y5Picpu23u5gx+Jig1Rv1Gthcnoejwu9yPPdZ0QxbfgfeHvMsS/cvD/U4be740noUIc1+nw6we9EyjUVf9Cj25nq/aCILorHeozse7HhpX3A4CxCTPlTwTYBnGQYdmqi5VAFRyNtCkrYuu147QOqFQ+UYcMzC+AFb2EkYERwCsD3H0DeFPlLZuDQymj3zkI7y5ZBqYUmeccQYDS3/4h3+Yfg4WEUAbADYAbrIMQBDYSgCCnvKUp9CRtve///1cD4BJAJeyDODbwx/+cJ5Tb7jhBv7M93264oor6DGPeczAse985zsZmAKw99SnPjX9PAgC2rFjB7cvjintyFgZvne0mBbqxeBMx+f1Ghye6SSzUlbIwcS2Ulp0ol9Qc7J3rccxLLzBSMCPyazhRRmLa7oU8OZZPhZrDcPQw+mKhtaNugcysQFMMlIfq4XhcJiXUPBR/mU/pIVujzq8Izq4E2hmVxsq/2G0PJq+GVaQ6rZEIbWqNRawxn8LnQ4zbVi7JGEnIWxLxrXoxeghFNY2sBgAAQAA3TBiIVoJe5IxAJAAu9oAA8RZLBLalBcKIvXGvaT+ukYQmECr8byaoSUcIuWH1A7hbNpDM4qE4xU1mYtgAHMAggGAUALdLoOPfphkBUNoXqWiMsgxX0yNGb0fGcRLFmPM+ImUkwx2lN73vh/RchDRfKfNelHQTVpY6tKhpTYt+wGDIT3WyFFMERmjCF+baVZp20ydts80aKbRUPfiyD7oFvWfHQGqZLwIE0n9qP7L6kN8DwCU2ZtJJj6Zt5gt5LiskcUhZ3BgAxVSyZpjSZiVPg5hOtimh53q5dDBUAaGkjZDP6GNlpZ9/sG/OQR6Bf2+uLRMbYTnITGEZlJu1BnAKMa6tNHIUCgtFA/zgbT9dK1Bs3WP5uqNkc9M1j0mCYWdNHx2NHMTYcH9ZxRM4pqrssBxOK32XZaZ43OSUEPb3G2Gwmaa5T2We085HlZpUK1ap5pLPM9j40ZpVkWD7zLoDK7WOy3jvTvKJgl1xQZZww2pgayMqIaw1VhjM6Aqw0/RUDIXDsm0hKZLaCE/S57HrE9sagy0ddH12gTrBJk/MA+Pet9mWpHyjThmYHzpx5QsqdKOYftv/+2/8e/bb78997gvfOELVKvVOBxON4TRgVV0yy230G/+5m/Spk2bGFgFEwmMpLWy008/nX8fPHgw9zjMeQjR049DPUxACoZQRhgYZLphU+BJT3oS/eu//usqlb60SawM3zsKTRajqSNIa7RDNKmwtXY+IvYqtdWn3lvD73RxTV1otMAOrmS98Vx94bkKZbaF6GVkj9Ep+MyACCOKXCxCoQmExbkzsv5rikNn7GLm0fRHCdVigamccY/qFLH+iYAlEPoW4/ZI9JqmqJZmHBsluIrzDnW6rF9V9cBasYsfm9m6Vmo2ceakEUezLsZgKJqhJQBDZhOmD1gmeWVbDQC7Pxf1OJxWF6BG8nOEr+mi06qMcIigEaXKrIezwIRyjd+s+9QDcwrMKuWUbWo0qJIwlWoI5wt8LgOYORhPCLlkgCZWguYOVTlDOTO5YuUEz9Yb7NjtX17ma6PvZxqKxSThgQCoMHWhTYWVAjgNySG4faEbl9GEAJUg4A6GHkCnSqSyXKVsB4pZSytO2kaZGn+qXwEk9dIwNHyO8Y+QQLDsEJYI0Ati5xKCrbclxLxRL3leWLesB5BGXd9NjrdmjSvY723MlwDy6gAYh80WDjcyFCoxtYmhWEDc1o0KNRozhcqWdY9Jxv1qPit5Qt3Q+cGY6SEjYqASMuhA3tC7CwAvYiNdaavJTNpHwGXWoUoAKQm1zWJijZ0FTY53FPsJ0wCX3EvYUGnInsq8mnlNPbSPE2UkTJlRfbRaWds4ZCzo3xcGxo6wujgzHl7XSMyAOMZEv5MBOQjFI6HHcOKSNPOclNWy7uK+jgHmDWo05q7XzPfJBOsE0YMDs1My9o1tq51MBcfgsFLgvLRj3BCSBtu6dWvucd/97ndZd0nYuKb96q/+KjOx3v3ud9OPf/xj+ru/+zsOi/uLv/iL9BgwAME6GmUI0Zuenh74DGsaAEtgOV177bX05je/mWZmZuiSSy4ZOn9paYnDFXG/f/u3f+PwxEsvvXTkfXfu3Mm/oUVlGthWAKXAZixZjEfGSlDqaDFtQWUu2FfFbI7wSkGONQRJspyFrM9NAMNc6Fu1CtZKnylj4WU6aezIQw9HTy89op552ljgTzC7DI4wR0RoYqFFDAtxpDiHI+smgFFeO+kZnbBKD3u86DYdVRnHmc6Pptek30PaQFghaYgcXphRyBmKuF2TrGebG0qPxqYlAwBnNTV3shxu62LebMMc58kMJVGyuUoIVwliKzahfrzp0K6K1kdiWXNRn10w+hyUDYuVLocMVVKnndmCgc/hySwYnugxAUDEcZy30CGqIITFCanhJQBgghSFyLbnOKzJBCAJ12n7yDLo0UyS4QwZ+NrdUAECYZtBHxyHqWBrS7EyUQ4IdoeMdQNkUkwBgG0AriTDoR5uJmbqjPE8E8dUdVzOPOiQysYnrCnVm7hPSL0wYrYQwDbccbEbMBgHsA6AE34jcyBCn2Tewvloy3Rc4NikXZuV/vXzNJeK9nuqD8UZ3vKBf53dZcucZjN9rOvhtUWBH5gwLOVzxTQLVy3j4LiWqVuVvCuhyVZJRPxN1uUA+I7j3JiPhYDTOGGGtmNtoIMJOFtBIY1xYwvVVnpVqFmUHo/QtjDskAetRZRfEqAUBSMSTaqUdVUUaBlzky0zbA/3x3uQJyDtnpizIabFonrVPpOH56OE/YR6QvjetKHy2+uCvqkA9LJZVhusAhhn04Mb24r00ThrxrXehCuttHVqYC/t3buXw9oQzgYRcRgEwvMMxz7ykY/M/P6hD30ofeITn0j/3rdvH/+tg1K/+Iu/SP/xH/8xsozQhIIQuW4It3v0ox+d/v3ABz6QASeIn5v2B3/wB2koIjbRnve859GHP/zhkfd973vfy4DTM57xjKHvIJ6OjTm0gw0IK23trQSljhbTFlQi8r2qtlq7iBPoaUxiQ85CslAG6MELXcNMEMdc6Jvfc0YbpNv2IKa88rYeXLAPLqZsTgJryiRiy7Y2ynWWBvoy0ZCAK+9UlYgyC6+L0zNGX3Nq8+S3OCYq7sk+bsxymOMruQY79mD3SHiFBeCSsCYdOLIJx8KwC8NjgcMn67RlqmkFDAq351qb+ezlOE8mCwQGxxRZ2sCkAeiirqlATYRJApSZqqnQutU21Z4VpfXW7Wu9jTpHn78kXMvHMxn4zP5BXyKDG5xi9G2r6va1oZKwLnGQvApCn5QOGX6gaYUsdzivmYRJxpHH4I7S+FKC4xy65xCFjZgBMWBNCAkMw4jp4nqbewB14x5VwXzDb2TphIPNWlUAvRKdMI19JPMb/lMhuQqIAVNLxqLMiegjzAsq9TvCWyMWCXfwPwArYGkB0Kh4rMWli8iLSLTqdiVrjf8DiFXMK8VKm27VV7XfdSajtFMWc1Eft0VCw3SQRGXRU/MzHoxR4IuZbEIYlmDtxYfreUd/4x2CEFVvcA7PA5Bsmw3WDYhRAtA5ZjvWBjpkbn6l81WiSZTM28CvOMw8uW56nxhjVwFPyJoGnbmoi/mZqEEVclOWk33eGGqvRFg81X50wUQq0JcZ98jqj0xWH+6FZ5wfzeQzzhVRGxRlZ8ZUsiEUx2o9wQyqyTe6JtI44w0pnEdK33KCNZfteZ+4PKtgR+q+pZW2HgyaSfgRAwgD4AjATZ4BZNq8eXPm9xAD1w3C5J///OcHmEXQgTpw4MDIMkKk3DRkwYPWE1hQYG1B28rMvif22te+ln75l3+Z7rvvPvrnf/5nBuB4bZ9jf/7nf87X/Ou//msOQTRN6g5Ar7QjYyUodbTYWu0KZex6roYopWmpnlAifpvnGIxcdIzBLuFPjHuZC33zezgTktlmNVo9L9ufuZiHiSOWlzkp2xDWAAcOWlYovQIq4JIxg8CDc1xwx1hvZ3Ee8G9pb3Pc6KeyA6kYTAABdCeKnfFulx03MLaq9QazqjL7UGNd9RIxaAHsoCkERg0YMpyxDWMLYycZY03EYHE9wKAaHeaRueO/VgtgE4TKedaFBSLaQsqJJIpd6DcFDK5IaG8DoAcIapwVrzsSmJvU0Bd7ltpcnuPimJpJ2CDKJuyfUULy6EuVRVQxNJQzC8Ff/Kg+lWsxe7CKDHQR604JUw6hcgovjajtY1wpfSoRDJ9uNKhWASNLCd/jPAiwM5ATEWeCxHUYIIVAekJxVyFNRI5PtOh3uaxTDcW4E/0mr6f+rTvwom0EhxTlxzUxDLmePcmwJj8Jm4LnHQW6Kf0tBZgrQCUeALNw7U6gmF8exHkMlhBn/SJVd127S2/31RzbeexNvVxFmBY6SCK6b9Le5jyaJ/itMyz18Sc/a+bQYl4HUIN3CGe2GwQ5swAk2zvR+p6ULGo8Z+a0veUdDeYSgCLPqeaCDiZ4nDlfJfM2FNSknfk+Uia+D0LbEuF+/K5UVSZU3vTJHw9D7WUAPmMDPEZmP9v7N3fMMjPLBGgsZdD6KL0HtKCSPpuk/ANAn4BiBTLuZckacHMAUO8F5KFPNDB+rPIUAENH2hhrTm5PfrkFiH3lDYUSoCrtWDEImoMVhbkT4Mt5551Hdd7MG215uc9OPfVUK4gDEEpAKYTATWq4hoiPg3H16U9/mn8jVPAhD3nIwLEPetCD+Af24he/mJ72tKfRs5/9bPrBD34wkFVP7LOf/SyHA77sZS+jV77ylbl1t51f2uGxEpTaoDaUvUso8KsIEll3PYc+xx/uqrCrsGhA6AYmBvzOc04GFjuJdgSDHLL4KMoumUAHicvK4uQroKob97Y5AtbFfHIOhyDlhLjkO5PYrVVAHRx03EE5Zh4vZD23ag2vsV5Pb2ceH8JySv6ZM9bQV5BzpR6YWbWB8cUAJRz0XkRVFE0Wy9AbYcclUteFfk+IUAkVpIbL+b04DSuBw9oNe7QcwMlAWxPN1FwWmE8ilRRjwW9bWWpFFtqrsfDOyvTHNoIlYGYiAwtE2GH4D20g16t7EbOjhCkFQ+gawr3APFmJjlCW9R1/JwWeAcSgEMiuiN9od4RNwfTsg/Icol4zbiNtIwXwoF71VGdJQAlcKwh7vLDAjwC3CniJKHYS3ark/izsHhFn3gMjqY2scBh7UUSbwNVIwqUANCk9JnUP0YuSMi51kMFRCQxLe8t4MMEQDvnrdGihC00r6E95VHU8CmJklezRgXaHZmo1mkZWLk4Z76bgGo6HwD9AN5QRJhkBJQkCa0QFAQv4A7jb5KrshlJefXyBoQXgkEP7Uk0pVfbVdCrz5tSssDUAyksA+twKM/n67D87M0M9J4PgS2aYmYVhqeturZZ+nNUw5/N8NzyHr5pOlTY3g22k3pPIQJvMyUmWO3VT/C/ZgOG+xr/QZmNuTNhC5ZJ3L7OUM9+xSThlcq2m55GD5y4J/cwza3utZJMuFdNWGlAmmJbeAmxDUJu4fhM6Mfo7HoLuwqSakJmetgXKjrYcY+2VNeYASIWJTt64oNQ4YOhIG2PNye3JgKfKcMyAH29SrY8MfKWVtpZ29tlnD2SWK2rQnMpjOekM8Swga//+/SMZS7Bms8li6XkGZtdv/MZv0Gc+85khUMo0sKZ+53d+h2666SYO+9MN7CsAV8961rPoYx/7WOY1pO42vanSDo+VoNQGNXEW4MjxQi+lwE8IEmUtEgTM4TgWLXRqFUQpbTvzcDagoaJrZuQtdpjB0G1zFr/YcSl0KtqOqca8SZhNcI4Haj7h4g8LUhfASKLYs2KnIZWf0BwB22Iei0PucyK3IqERvaF+y3UmpV9wTBhQEDoUeBXywJjhcg3vsmZeL6uPC4YgYkxh4SgCtgPaMh4YMIrtxMdyRp2E9SaCtwCkGJSqKC0OB5nGcHXFjGAmVMJowf3rqCcDEgmAK6w3gIEYGwXYYeZCezWcSNQZYA1aBiCIADSwvDBWAR/M0DAb0y9Lw6kZVVNgazV06EQAWUSR8bNjZiq9PrOW/C55YPk4CkzjbGq9iA6027TYCZi91qpWmQmEHhoCebSxJf+WLHIKXAL7K6aZej1li3EYYETMHgKzSITI8T1CAZF9EYAUjmGHE06iln1M9IYocqgbBtQEsJkYj9swmcsSBp7NZHyrMa7wYWbz9SLqYkyCBRVA2wqMLRWyOAWRa2hmQVsryYyIcoPl1Ev6Hv0HcBFMMvQxM4gAKoU+ksinGbFsz7GANpUUrOszP1YNIJnQIFK/6CNDWUi1GtrVs743dDaUGfo3FGZmvOtGsWTXxPi+tUwBeFvo+disnwzGUvquy8pOVuTdrpdp1DvUBIgs9eE+DQIKfJ+neacCBmQxsGfVQy05uy7KiILg2skMI4Ae/3tEaLppGX3IG2l4B+J5Zi1GY1PHXHcVbYsoEXkvqI+Vm4wE6wztd2qyIYSwxAzwkK9rgqGTrrvGWHPymon3HZLNKAaqJswKWFppx4iBeTQqQ98oA5A0qaaUaV1ES0QRi5mPMoiew8xjwZxCxr1HPOIRHOZXyVnjou7wtc4555yR9yttbawEpTao8YI57lHFiSlGqmDede072tbFkPlSL7KwlAUlp0rWvl8FUUo4SMvdLvl+l2ZbU9Rs1gs5BLpTojRisHCLqQFNnIQppRazBUCaSTMIrkRjKysk0iyHtf200LuccuS2o1zXQXpphwK+ngBFjnWXNfN6BXekbe3PC1Y49trieaS2jNlfrNNBAwtjkFIAzggQBlAEYKfKnugku72enfU2gRO0mk6RgCAoe5EsZKxBVK0OAUrjlImBuwJ6UnlhULoBkJrv+iy6rQM1IsiPrHaOAz5GxP0r10Kd235I3R58vZBBo3bPp0oEoHFYAN80tAFAG4A0y0HAmfgkg5+qp9IXqyFteqLlxBn3MJWyngoxqwjTCQAp6E3pad6FhQVAKk7OFVCLv+MxlGgWZ4R+yfhmjSgHYulNPg56VmCqgfkEAXOUIcBnTKEkqsUea02hHdTcp0B7ZOiDMdAVxhSQT41aSwG5nsNtgHbmtukpFhWuqIfroe4ApGyhm6PGUabYs+U4HfiUdhsVHgfgD6w6MKV0vT/z2chjQw2FmdkSMoxR51G26uG8k75rMhhL6dxpZCcb1nTMCU3XyzTuO9RSH+5T36coQlgtGFJgsq5SuJcIHRYF9XhthfdjwihONk+G9A9zQtNH1jkpWwDgOYCeWUR12XRJy2lZdx0BOQf0h5UhJRtCsDxGmwjPQyYAYZVFNzWHCjLJmhPSAGCAFwfoSivtWDWIjL/nPe9hMKhouJ9pk2hKIePe1NTUUNY/ZPeDAVAS2717N2f80w0bGv/wD//A7CvoUoldf/31zI46/fTT6Utf+hJ/n2dXXnklhzqOYnCVtnZWglIb1HjhrGgtSejUoKOdGkK0EJ6EkK9qXYmGTrKwnBS8yTHFlAEtPGKKOJFKXz4qAxnABejjoOwV6BywswZBVCRkz7nXpKCKbXG7kvawCcHadsKtnycLZeX5qh/5t4S0ZTlWljAL7NY3PMOJsuyyDux4hmMu8jUQVQFeWpY8o/1HasuY/YXFcMaCWAfC8kC6XCfUzFRopvq2ZDGcRKRWHHpd1yatYs71igJKE5kxXvIcf92URhjC4VTGPITQtaoKyOJQPNejGkT6vUHQEf/ePt2iJd9nECuKAVqDBdijTY2GleVlhj6yaHmsMuyhDCbzSx8HAM9QHwBnAJRwT5S1gxA8I9ECM7C6Snut6lSoGwXU6cXU6fVYJJ4ZYaxtBPaVCi8c0mZJmFyqfGC1KXBM9bsC7PYtIZMehNnBMquy7lfVdWm5G3AGPmQFRPsBGKu4NWYPSb1UWKanWFM9dsdoqlZlUMdN+g+/5Z44bqHT5fNnGmrulUx0KpQvzAUgUR+0IUI/9VDLUYw+hB3qGQHzDPWr1VpDfWjOEWNlnNUTMqwBoLSqOjow412DMcSJAzjss88yFE0xlNusg6oXQHkFspp/j6PpqM7FakM5/HlMKGYom+1peXdynyIbauRxVtRxw8Ss70ojDC+J6CqmS8TvUxFN74uBA0SC4ZksnJ3Wdj0BRiOOrVQFwxoI15NQStt54wJvGZl2VyVjsL4hlPfsiPC83L/opqZp3B5Y9yX9mQrgl1Zaaath0G/60z/9U2Y6QaNpEptEU+pb3/oW/e7v/i6H4CH0EBsU3/nOd+hf/uVfGJD69V//9fRYhOhBWP0JT3gCnXTSSbRz50761Kc+xRnzAIhNT0/zcQsLC/T0pz+dAbI/+qM/on//938fuOeZZ545kOkPwBbq/T/+x/+YqN6lrY6VoNRGtoJ0ZgBSrN1jOkr6+aMWCau489a/pEMzU1PMlKrVRqDyGoCGhTTr9oLZgN1cLYwm714TOwj64pYt2fHTAb5xbFRYhXlf/XP9XF7gIfQNi9F+CNzIRbpxn6G2yepr2yK/4JhIQdR0Ee2OpS0ziekAxMT9b2YINFN952UPHMNs7Ksi7bCaGSuHzBgvAEPgsOK3fm+Yfl+UuxkiCx0xINKoeMzmEgABQ6dZrw2F6Kr5oM4/uO5Cu0sdZiURTUVhCpiYdRQQACwl3FuEy7OABQnDk3rgN+tKJTpWCBtCZktcR9hhyNAG/adm1aPpuktQf+kESji9oWla4XyEBwJAmm7WU0AH11lod5gJBRYWwgeZvRTintDCU44l2FkAxuqeR/UqADyXhdcRWrgUdBgEAyAD8IVBo2QjAvdB1j2ACgjjc2KAfiqjntRB6slAYcKM5Kxfiai3zkACIKg4VdkApGTuA8AmumVZzDoO5fQqXLa6h7EwqR6e/dnQ2VAj2Vt6QoY1AJRWPfzPmI/RpotJFk1OeOG4LMIPwFHmALMORXTwBOzDmEtDpi3G54LKl2rwZc8bCJnvZz51tX4ZzDjIfZqFOhexvHclL3NHaDWZrHET4EnEwDF++U8OKy/Yv8b1eHz3Qg6XV+OzSh6HA6prD6wLRm3+jHonj8pwuxIzNoQynx1TeH5Sw/kM5AXpMww9vJEg8mHIHF1aaUeDAVC68MILOcxtUlBqErvgggvoyU9+Mv3rv/4r3X///bwWA2j01re+lQEl3rBI7NJLL6VPfOIT9NGPfpSzBc7MzHC5kV3wOc95Tnocvrv77rv53294wxus4YM6KHX55ZezHhY+L+3ImRPnSe2XxgZUFnQ+xKpKhoGjQQy9yK7wukmta4Isk+psrOTerO8gdPXqEChlbatJshQWDTvIOy6l/WsC9QU0IAq3wxhMqbRdiojxj7q3ee5K6zTOfdeQKTWpcUp7v5eyG6whjxOE4NnaXASgASjgHnJvmHlfU1dKnzuKzjvtTkCHOh0lRg39pyQjSs3CKjOzIZri78IuYVZUAh4BeEI7YG7EOUKgEUN9FttdBgCihLFQ91yaTmjt6hzFTsFvtAXAgQ7E+T2XNjXrqQD5csenhS7Ck2IGnlA2AFRSDmQQBBDUN4f8MKBGBUBTj/a3O9Tt9pgVB9ZZs1ahqbpiN4mjj/pLpkAAVmBKQSsLgBoAq2Zd6XmJfhQnAYCGFjNuVP/JtYoypfL6EXXGvcCKQzuY4yfLih6XVQYZlwDc0LbCHioy/tfN+85iArahDmDFYeyMx5RSawHOytjD2KoOiMePU46imW91phR+Z80XE90n456582/me0R7XwowZeo/FQxVHXVPHt/IsInwZWyoZa1nks8GEriY99TeyZijAsaJFaDO1YLOHIBLeTcm10Oo79j1GFnNYvO6rQ0L9bWFKRWkjL+cueJwrhWPYn+itGPD/vEf/5Fe9apX0V133cWZ+44Ve+5zn8trzM9//vNHuijHtJVMqY1sI162OoOAX9i97oCWRpFd4YlSDK+FmeydNWBuFbp3krWu8C57kV06sy6pBgP1NRgy+9zNF2sdCOvTQv+s1yrQDmb4Q4FrcLuwtlCkWG2TjJ+sdhRdC3bo6wVDIDMWuwI26ccNjTt7qm8FwgB4AxPGyQ7tmHSBnHFeUXaDWF4I3pBjYAmtNAXes0Its7KjFXVcRLgbAFDFQ1ieAnLE9OfMZJnZxN+FXeKzM6hAGM9RnwOkArMJ/8l9lgFEdbqs/QRwA6AYHGkMM1wDJa8nQI4AYQyWUZ3qFQUY6KFkYCkBCILIPr7rRjEt+2AvudSsVDm7XjdQ8wewt07PpzBCf/aYWQW2GX7XPYdmOJRRXVsPn2vU+o4ZGFTzSx2679ASP7LbXaLpZo0FpNH3aqNC1UE3uS7rT/WUA6na185YymMTmSF1RRlERY4TcImVwbhsw4wf0d7SQyll/EdRQNVEtFp3jvU6rTeASmeyIROk7oSbJCOzX6ReaJNFv0s+J5JQ4dujzGyHkaxTbd7gf6XHjgjNXglrreh6IOu4AqzxiVm81nlUZblNNQyNY9LwSrAokf1O2tNsB+08sC2ZyRUH5IJ15TgUYq5nVlryrk7H0WCWzZGWA5rJWgi6TSrBTPazMqAH58TpmpKzXWKNEAYsx2Dd9OJ/IyFJvxxKvPzIJWIorbSjzV70ohcx6+gjH/kIvelNb6JjwaA9Bc2pq6666kgX5Zi3EpTayJYhnpm+sM3FfbrTVMnX+RmVYriILsPhtJXshI2ruSCLQM56N5gVx+pMTaI9ZdNgGJeKLmKteqa6omGDeSbncHYidzgDkaUvbFn2dIvCkBfeyO6TqSWS1Y6iawGYYEQIpEn1T50tLKY5g994YKfOAPO7Hc7c5kHrp6UYLNbrRAFFSFHtVMirKZHrQveCLhzaEKndE0dS15Zp1WujmU8jtHeYYYI6QAMqESVfjRBD3ZghhExzUW8gM6AODAio1AX7K46oUW2mgFTKAEj60bb7bhN/x+/pGsCmRFKINZAUWMTC6ywcrphGAl4gZA6JAKbqFQaC0L4Ay8BYAjAF7SvoSSFMT9oiKwIJWLCUhQHEJAsoy7dRzIwlMKkQhoswN7CcQgdhmSokB/fBkTNNVQ7pL1v4nIxLFghHe8VEU9ATTMGlimKxASSoKRCOnUIDvFkKFENsKqwNAXADDNwM0MYUGDcBH73P+vVRf49i0egZAyVLon4fCeOU0FYJb5Xxr0Tu8xMJDGS4RTIRYZwUYbzCRrFc0tOywS/9O/xg7EjbT2K4xnStzuCFnj0ysx7J/QbAoVEARcamAJ6vceYL1vjH+gSZUdfaMub9FQOTlnYpAgTpm4HqvYky5LdDukmAeQvn8HsaElXxwLvQGxMc1M8deL9OEBo4sJFB/TWlg796AW9A4P3ICTLw3NRb/PzAeP4xyjHUlmPIFpRWWmnDhnn62muvPaaa5txzz6VeLwmfLu2IWglKbWQbATIMvbBFHJLZMsV0ftJr6OLXI8Cww24rWXRYFlYsaApMKAqHRVelrpZ00NbFZrLYTXUkzMWtre3yNBjGAbn0Y233mRQwc3MyCFrGBu+g6rufhvFOcKrVkSWsOyjKO6RrodcvI+OkyfrDJjJrowAggPMsTMCCpl+vxovpiLxalXe3M6/D940oZKehuG4NYBPos3DWNYu2DFgPRTR1hjKRWeokISZiqxnigfHfDgNa4tA+h51sU1RZQCWl8aQEum0x5pzpzpKNDeU1xd9Zc4mS9oljBjJwHK4tmezwo5z9mB33Si/g+ze0ED85gvlGsWJN2UTN85wxaU+EWnHdIqKDnQ4tBz1qgvVWVeE3AA5wR9wbLCdz7mCHEsPfeC44RK8XsjbW8TOtFNAAc0pMKfxIhsBhMB3gTS3oUZDUUYF4qo8GwJoEiB9XfwnXWOz61PYD2txssqB5kWyTNnA1C4yVPtUBNxn/DFJpYY82k00GNXeDeRJlg80Z75IQP06lGBvZcoz+nWSqdCI1JiYxlH+qVaOp5FkYXY/hzS0ByOPYo56jQmArzhi6iEXLyu3Bd7QncVlDS4HdJKw3q/+sc60eUicAi1ular1ReB5N29ypqnbg9wleHr2Bd3i6oYM5lLOGekRgqOL+Ht4V2js3eRfiWvUcFi+GG1hLjluhGOxOBtEtawXzs6y1hAWY5PZltEldm+f6CkJR8W50yO+oTSLPVxs4A/NC3ppllA5naaWVVlpp69ZKUOposlEvX1PgtUh2F9tOovJoVsa4KWj6rrwsEocEnVey6LAsrABWQHwd9eKFkA6USF3HSQed53hkpSfPYmTpIXQchpWj7aT3mS219CQhkHKOY2GYRXlAqaZtZRgYUvrvUW1nF/fW6qKHqWKBnrQXg0UIcYt6SLWhdp4dT+0kcyjFeG1hOg7TzDww+sMEAyHyXFOwhs0ZztK88QC8OeIg0gD7R/6tt9c4Dr4Y2lF3VlPRay20rQgbK8+YaRMja11IraoSQDfDDvG3aN2gDCYYY9ZtZMbGxMAqm+/6DPygrvh7EQLR5NCWqVbKrBF3n0PwEsBMxh+zqgCa4ScBuNBnJvvOZBH1Baj7IYgCkCwt+wzQzIPGNV1PQgtdvjaAO9HFknGvXxNjXl1zmMmBc4SZAn0nATCna1WV/TAZM7YxgnPnppoDz5ketom2qMBpTepYxEzWTzcIaNEPqV7xqdmYyuxD2zMxClwVA+CH+5isoCIsP2kXLnfClMqd7y3vEsVGzh+XeeGK+nfC+EIvr2m4klGPofDYBCAHkxGYPocCoy1t7+DVfDePY0Wy0tlCtpPzZMNCtXVGWDTeS4FPPtBpZPtMN/CSdzrC52JkCg6JMM+NsQkx2OZe5js83dDpdTn7cPrOs73Xs9730lZ4LwJw7CFbM/YhK+TWeJYjl59Nd8T1ioC1rlUsX9hcwgarNRXzGWsCYUpxH+igcNGNtsMp9VBaaaWVVtrEVoJSG9XwQu4lO9+SQnjUy9emXTSGYHXmddZwJ0rCfQJm0ihgaihd9UoWHea5nOq6RzVorcSeAkoymDfjtFmm45GTnnwkbX6cLHiT9FEeAy4L8GLgqeDYSK6PnVK33ijcdiNTl5ttmrQXr2nRnwF2mxXooC6dnxFwLMdhVP/xIryWeacszSezjgIUSeiY2V5jh2cYjjquL8biypwPIzsT2ziGdseOPgApYTSZgAtMgGdTsFmvp5RbAB9dawjAxXCmvlg5itzOIS37ITWqKoQPOkwy1tphj7rsRIas+SRgimgyiUA6hJtxnaCtdKTwn+StwyALwq7KWhgp9pIIjktforxL0PjpgRXmURDEFNSQla9LPOP1esx4ChHGlw7p7KxqZrvZAMyioZ5ZwM04QGce66dVrVEQ+1y/PJAoTwdtlKFf0Rt6psLUCjJ8VX2rE71LUp0dC8tlYP7DGIUOEHSuDIBW2poFypPw2lHhjWOZ2Q4j3qcCkDchU5mI4Q/XXbtmgSy11jA57Zr6RoT6akSm0SJZ6QYyqbpDIW4igZB3D4TJcSZgT8s+Ke8fbHggUyY2m4wNhYnM8i5NN3T4CxXyNq6B+RYE0GbssbadAlKhOVbBFZW+XBRPzpjVyq2D9sDQ9Dlcn1P0TIyZToptbVQCUKWVVlppG9ZKUGqjGtOsQYGOyPPqk0Ey5iJnwuxqI3fgVhDWh0VLEAfkJWFFNQuzoojpi15Ypk4EnASKOB17P2udBrqMAnUy6tzfRY36zklaSbCkMhbuebR5SXXNWQEH9a2GLG+xltVPRRlwecCTcd+BzGiINEAc3YjrmwvWkeLeJiPQKF/kVvrhgGg/Fklfo6lwTDAwT/OpaMhPERZIEa0UaVv8CFNlrOx9GcagiMbUQVmgccTjmP1bO0NDr5uUXxhC0h5gxSgh64jD9XS2CwDMzc06/4aDxcBVMnYYTEoYQTieM9sFPjNs5DPJKCisTV1Qu5OEGELjqJI4qAi/8yOATgEtByH14FgjJNibSsfsQqdD3RBC6h7NNasM0IApBfbWgXaboEcchEs0Xa+xrhTKuBD4XAbcG9nXMpkcmqGvZhESrGU21LMTHg4zwWUAqrWqN3KsF30mbPNY7rlrrTUzSnNnAk0eCa8tEjI6WTmLgZVy7yGgr8A1bXPPKFFz3ogIAgWeuHh+1Togsw3Md6SNwWUL2dZC3BT7Ns9UeBwnC0A4tryLtfcPh6vRKpnlHQ4WNzO5TT2zMQzMN5+XfWhTtG3yXkRYXQQAX7GgR4HRmRlXtXJDwmAg+U5RWy35gdJKK6200tatlaDURjVo5JBHIRZA4tePazbm1LgMnDxbhUU/a69UlOgv6yZUJxM91Re96u+MBbBlocNitdg9xSJ6VJ3G+p4/mFBYXTveFpo3jmWVuQDLyVqeHBvIjAZQgNethiYUhyhmA5p5oIsCvRSLCrvYKVsGz0nShhyaAZ0KPDeOkZEwr57SVgXKqBV2rD4pGpZUNJNZlonuEIANvS1tWipKy6aWhoEVYa3YQywHw9s4NXoazqaA8KL1MZ1YaQ+ASJ7TZ0rpIDSytKlMd33QS8LicCXd0YfGUY1DV/pA6kK3w6EkuCIAL2S7E0Ftz3epC90h/l6F1jVdVZYY9/R8agdK5wkZ/SpJvXshsvApwfQpXAsi5wmDYC5usPi5QIYczhj2aAHsrCCk2aYC9xoJkwtC/qgJnEPcw+xbqQv6ENeVEMBR/bhaGehMp7boWC96XFZSA4j2W80Eq3O02CayUZo7RTV5LOG1qxq+txbOfc41bQDUqPmMAWAHwvYqFBzhZF7eHFyENW5mUtU35SQcPbedk3cHwt709dI4c/5q6XGugCEE5lutrsY6mF169jyE1RVl3WKzot1TTD48szYAa+L31kpYUUda8/QYMmwG3XfffTQzM8M6hKWVVlppMOgGLiws0Iknnpi74VOCUhvY1It9fNZQpo3aXZz0eiu8DjIesYOwgusML4YyFkYWEAiOaApijBLaHFXnLEdk1MIpD+xaaTtnnZ+36MvJapdnA5nRcDvZYTbrZ/xd1DkW0AuaRcjepLNlbKEZKo6vqHCqwWZYZabFOCwkWyYzHQCStshqLz4nDFOmkOkwZmmpjMPksoVY6p/D8B2cHgkbyctQBmBIgY0J0BSrUF5Tj0rqrwMLNmdI6go2gJRHwCzd0LYH220GlQD71LwKdYKAxdJ15h/C95APwo96FPVUvaZbyvGdimpD+kwMhnFWLZeWurieR/UqMXsJ1iJi1pReL5Rvrh5RXFNMkV4Y8f0BuInwuK5bZesXAMLo2yozvSZn5K070+axLNA1b36bVIutkNk2F3LKYr8Ewl6TeSeNEVvFsq0mCJm5mWJ/Fke1N9cdz4IHyk4VD7f6AqzjcefgUczgoptyq7FeWgeZ4fI2eYqwbsUwl2D8CLs263oTPVcrWeOsgzY+VgyA1CmnnHKki1FaaaWtU7v77rvp5JNPzvy+BKU2qiVhZgokWf3F6bq63ipcx1wMjVwYaQLknlvrL6Lzsi8VK4hxvjvMdhIh86JU9ZW2zyTna+UZx3EVEWsrC0mvn1HfQk6mBnoBbAF4obNl7KEZI/ozj82wygyDSbVzbACQ+nxYHF4Ha/RjxXSH0eaUjsPksoVY6p8X0oYx2D0BwB92gFTGJgAsIratEomiHaBBF3LWPLBkhBFkjs00uxpaPIh4lx8hcw2vQtP1eiq2zsdiLLkKzAHg2UZ2OwBqkUfLfsD3ruNvz6U4wsysRKkBGMm9pB2Eg6b6A+CQk4xZJWou97SNczC4ttamBlhr6H8AZCI8Xqkhi5WddYbPAHThpwgbaKWMvHFtRaDIwDyWDcxl2aRabJlmS2KhO8gAP+R7qhZic/QQnhp0qVatU6W+aoFhqw9CjpultoiZYdmTzsGjmMFZIFNB7a2xxrCt/ADaQl+F9UO/6whYbh0yQD28G6ZZZH3M65nXhNkyEk8KOpZhfofNwJASx3N2dvbw3bi0I2537FviqJbj5xTD3Gb37F/m3ydvwZZbaceSzc/PM2Atc0SWlaDURrXD/aI9GijQ49RBE8seaxE96a4ci6hLNsRkIc+/ZVGVsSibpF9GnTNmWJrHzgdo+9XVAeis3xW9pAK9mnDyRt1vovC7lZcxy0axkGRhz75sIjAsoJtdY2tYHN4Egkzne1RGt6KWJ5JddOfdxu6BigvAIAmdCRIhcCWai289WuoCwAqoV1Ohh7oGlehBwYSthFA4aPP1ehA+j2iJlAAyACDp35lGnfAqBTPJD5ZZhBzAF/qAM/Q5g1nyJARS2txzOTUlJ2zweM7uMaMPmlMI3QNTTPSrTAcuy6GT8QIhdWlbgK0SwtqN1FgC6UPP2GfT5Mrrx0Jz3yq8H7K0xSYxc3zremA2AfxJx2au2ZJY6O9tnuuT70e8N6S/uhyaicxk8eos3ox+WzUQcsIstblmm29XuKEy1rUKvtvHAvZs9wQghR+YBkqtenhpjuXWYYI1zsg2mUBfLdMsyUVKhtThMQnZAyBVglLHli3tCWjJJzonB4w8tEdlAH5wCVges+aMCOstQamNapM42IV2NpELuDe8S7cSCvR6AbSy6mArn21XNsMGnMZJwULcCwAU90GykJdy5bX5JP2in2OysmxZHe2VTvU33NBPyHq42NqApFkgyorM1nZjaFut9rgexULSxbxVgJ1iVGUDQMPi8PJvWzY/GcPrLWRLZ/cAVEDonITBgSGEppfxwRnKeiEtdRVDaa7RZyUBINIxAgBFqOdyAH0ll+YaDWrVQgae6p66F4OASd/gHhAIh46TE0cqq17YYzBJAVjKdGF0B8p/rjoXTDgAUmHy3GCqrXpKsNx1XNascjpKF6peqRISUEnII2cgpXCASaV0W6rMmAJoh/bBOJAQVrDKOr2AWrU6RW4/bFAXhl+1Pl6FEBkFko2nLZZl5vgWvRtTAH9NzfYOGXhvG9/nvDekv6D/A2HrkaLvE/abNSHHJH2hvwfXySaWHgIMYLteA4g9xjxeUGNxLGDPuvaoDf4+HOGlhuXWYYI1zsD1ioiWr2TDtWRGlVZaaaVtSDuiq4Vvf/vb9OxnP5uFr4CefeELX0i/C4KA/viP/5guuOACmpqa4mNe/OIXc8yybvv376cXvehFjMpv2rSJXvayl9Hi4uLAMVdffTU9/vGPp0ajwfSx9773vXTUWaqHoBYthUz0HmSRgPOD9uBO3cCL3mPRbz0180rLZqZ6HqvMtr/zLKnDwGJHQBhcQy8fqw0nToPt3tq/xWHI03IpZFI+3Fd+Ru0yZ9Upr030c8y+0dsg775ynj5O1pC1VyTMa2yztZ2tPbKeK+27scfxBKa0OhDqVeMwMXZMC45/Aa4GsiJpxhnk4LBBiyu5z2oCgCtpH73sYP1AxDuIlYZTveYNADV8fJKZDhpNZl0BNHHYH57ZEJpOyHxXo2alwtngjpubpi3TLdZoArMGrDQAGfiN8sOhdRIwDOAJwEGw1mzGoXQsEt9nsIERhcx+AJAQsldzEfJXYaAKQNrupTYtBT3+Ww95FNoNnGqAUAC8YJL5DyLr+LekbweoVktA8mW/y5/LHIV/4zrQ0pJ7rHj8Osm7gdtrsmtI+5j9uRqGZ4X7uFbnsXFYwhFt75Cs70ccK88kngGEpK4kY+JAXyf91u0pwCbtu0nWE1l1WycmYO2iH6hkGzJnFq1rXp20a4z1rrLdG5uBtdZQ6J5sLFjH7zjroAKWW4cJ+nbgerY6j/EsbMSxt1b2kY98hE4//XT2bR75yEfSD3/4w9zjP/e5z9GDHvQgPh6+1Ze//OWB73/zN3+TfTH95+d//ufXuBallVZaacqO6Ky9tLRED3nIQ3hiNW15eZl+/OMf01ve8hb+/S//8i9044030nOe85yB4wBI/exnP6Ovfe1r9KUvfYmBrpe//OUDcYxPe9rT6LTTTqMrr7yS3ve+99Hb3/52+vjHP04b3czF5dg0eX1xIOezJgCYOhXri56ducCnELuoRYGinLINATqjFlfmgga6HQFApS5Rr0sUdLPPtS1WioIw5r21fw848bYFV9EFo1m+IourrDrlLbL1c8y+wW98h/TxI3eNvYRRV+B4Bv9G9M9qLq5t1zE/s7WdrT2ynivtu1UDJgss7MHKSR1Tva9Xqe3WAgAs2j7CZgAjCT/iKMtcB1AJYA4ABjCV2t2ADi62aX6pw2ALyr1lqkknzLZoS6s5IHreqKlwRyy0ozimIAr537WqCvGT+rKGle/Tou/TUrfL8yGYNgDtwG6quQ5NI1tevd4HBy2mzwt6/QVk8zyHHITbUcTXmqoBNKlSBfTm2OE64QflEVYWwCfoSKE8YmB9QLQcbC98LsyuVr1GDicScDlrnxKvV8f0Ei2uvv7YCscv6sgssH545LoAnnW9m1adplq1TGDWZocDbB67beQ5Z+2h8Z93vLvTd3jSb36oQk3Tviu6nlhlMGRVr2tcQ/QG8Yzht2QAZZW6lYYY6u2VsXk16rxRYy1vYyEKexQEPv9eL2M20yZZq5Y2ZJ/97Gfp93//9+ltb3sb+0jwpZ7+9KfT7t27ra313e9+l174whfyxv1PfvITeu5zn8s/11577cBxAKHuv//+9Oef/umfytYvbVWtE0y42VHaUW9OjK3idWBwDj7/+c/zJJllP/rRj+iSSy6hO++8k0499VS6/vrr6cEPfjB//ohHPIKPueyyy+iZz3wm3XPPPcyu+uhHP0pvetObaOfOnVSrKTr0G97wBmZl3XDDDYXKBmBrbm6ODh06tK7ipFVK9SSTUuJ8jWU2GnUquJ2AE+YpvJgNyPOq5FZr9nNGXGOwCIZeyqhzzTIzyOGrkDfWmYEH0hh539w2yDpGgn+yxDgnadO1CG1cL+GSuoUJeDiqf8YYOyPvZ15nta5tsdXKWjX2dfS+TkNxxq/fOPctom0yShcp6xrC2AL4guMb1Sq16tVUn0kXugdj6GC7S8t+j1q1Cm1q1hmsyyoHg01dP80QJQARQB31EoyZpYMyLHS6LJgOsfR6VWW9A0Orx0wpl8Eo815F9ZLABkKdzWyLOGax3VWC7mFIaJ2K49LWVoOvgfCzaqofloT1JaFIuJ7ibanwP87sx1raMQNSCBsEq0zui7KgDcTBHegfyYY55vyxapnbVsFWUhZbKOvE79i1MJnH0ixx4z3v5jt8RVpF2pwaOZXV6//VmKtHXGPF66ci94UVrMdKyoPIghDhwQDIHXdNx+x6es43oq2WPwFm1MUXX0wf/vCH+W8wehEJ8prXvIZ9HNMuvfRSJgJg817sUY96FF100UX0sY99LGVKHTx4cCBq5UjUrbSNZ9+7dR//fvSZW0cec8a2KTp+Tq1r9ix0eT0111rdNXlp68uKzg3rxGMtZqgMwCuE6cG+973v8b8FkII99alP5R3jH/zgB+kxT3jCE1JACobdBLCuDhw4YL1Pt9vlBtR/1qOtOMymCFPEPMWrUBWCvDq1vAi7JGPHcGh3HBgpGDVZWKlZZmHpVBtJlqPaeDtwRdhIqWhrPJpiPm6brjRMYow6HdEdVNS9SP+s1i6q7TpruEO7WiyPsRkreay3NSq/aJsMMCty6mEbd3INZK5baCuWk4SVcfgdZ7KrkOdkz28Ac8B62NKs829JSS5hbBxulzh6+A3WE4CdXqy0luYlmx/XWYXHoVxoBwibb2o2Uh0r6EwhTK/uVa3sKNx3admnAwvL5PvDzzLuAcALgJTUB5/hPwBlYIXxZw5AJWT786jpetSsqlAd/kG4YpJREJDTfKfD9VFhggrokt/4kXCvmWaDASm5L45RoZB9VtPI8JrDyXTSmUC9LkV+h7pdfzC8bISthPmln7sWoawrNp2lOsHzbr7DR4X2FirLarBF9TUCJ/7AJlWvz64dmz2FsSw6ZeatFHAr7MHcsoxbBy6/k9Sh+JycjjWWC8xgFWeUC1pjXrWmfvNcEasEJGvA3M3q53XJ0ForJt8RNt/3OfID/o4Y/B78DZ/HZvhcP158IfP4b33rW7R9+3Z64AMfSK985Stp3z4FJJRWmm7dRLuz7auMxzoLatQcgDWLn0gK3LJ7ka67f37gGqUdu7ZhhM47nQ5rTIF+Kigb2E+YPHWrVCq0ZcsW/k6OOeOMMwaO2bFjR/rd5s2bh+717ne/m97xjnfQerc1EbsclamkSAYc2zFFhXAhsg63jH8XYCKwcGZyfXeNdARWKpyZlzlPX8COshWmil5zAWsbQ0v/TNJFy0Ixi3lWYGd85G7tamVqOsy2ouxXh6l+pmj6qHrYBHrlGr1uyCFfEo6GsLKah/C4+kD/2oTuAa7MApDWTECoKIK2C+AtlZWP2VGORzVXsaQWOj75UUwNMI0A4pByqkXcXO4nzK15v0OowuamS7ONwXvCcM6i3+Vr4rxarTlyvsY5C90uHWz7HLq3zW0xAwrhgc16jRlQXTBakjbAQk5nPgC0w/PDYYwdpZEjGQDlXhIOKd/JfVFPlbFwfCHjtWRK8LUDn4Xk4yhk55rHT1TheUFvw7xyrOQ50s89LILoh/s5H3X+OO8Z7VqKbxgpUAXze1GmXZpkJck6i1PwDkDiD7CgOSGovE8KiunzO0b0DocdJElggLkBJlp6/c2xCYX7GcgVOQUps1xPq4fF0rGGtuvp9baE5hvlMsepG+sM79V9J2Q9W0c8QYZt/bEKCRjWo+3du5fCMEx9GTH8nRUBAn/Hdrz4ShK697znPY99pltvvZXe+MY30jOe8QwGrjzOeju8gY8fsfW6gV/a6tuP7zxo/fwndx2krdM1OmcH8hVn25V3HqCmliDmijsO5LKsSjs2bEOAUqAm/+qv/iqL0iIcb63tT/7kTzhWW59oQYstbUIbB3zJyDyTa2u98FgrZ9+2gM2zjFTRRW3V0n2P0w95n6XhJ8n5Y/ThEV8Ar5GtphM8CXhQJJQnK9tfdj2GQaxUVynROOozj9S/h5wsS7vY6gewBYAUgBoVwKbuCUiHs9dVwVbyyHNcavQCBnZQX3yGcxc6HQ4FBlML52OMgSHlxgrEybo3fgNIQ6gchOhNMMgmTI3h3w3CAZcZ+lK1apX1pvBvEVKvuugLBNapo1HeaU2vCtpayMCHsugZHEXcWb7DeSq0R10jo/MKpbxXwF8/o99qGF+bXIrCkFwGpyPyqi7VAFA4fZZZ3hywUtBsXQJRK3XSYUVDMs33TMFw8AFQZZz3ccpEdoYZ1xjLTGJEeDLKAWTHmHu08nG+S/Q9BMfle8uawwTNh8bRpBtRtvOiBGRCW8aV7E0baQsAczrTyrg+ZgWQCjz1pNj7ZQ0z0GU9H6u+vsgYd5gbwl5AXqXKmShTs6w1oBcWAtzmsOTSRtkLXvCC9N8QQr/wwgvpzDPPZPbUU57ylA27gV/a4bV9iz4F2yKq6osmze7Yu8y/wbIyDcwpsKgefGIZ/nksWmWjAFLQkfrGN74xEIt4/PHHD4n69Xo9zsiH7+SYXbt2DRwjf8sxptXrdf4pbZV0isYBX7BwGxdwORIpgFdDt2ncctsAu/WgSaVrbllD5sj+GU8/KmwqzX5oCuwfKYDtKLBJgLu1SDueB2IBrNFBFP3fNtN1mADQBAjTA9iUZGxTOkuqDtjEqHr9kCS0xHIQUOx3abbRZMF4sKA6yHbHelERHWr71A171ED2uqpH3QDhcQ61qh7N1GoDbCO9bXEPiGhPJexOAF06GGSrF8CmZq1K9YpLM42GAssijGc7SKePd6UDpTIEAoCDcDPKZIYVirizfGdep6jpQI88e+qz1QWG0xBDZCRE6Ce/EjyqW8ClVWNs6PMXgwIJU2e9zC2TzvEDTvoYoL/5nhl302fUe80EYgY2rDSIlsPktXVYiHPcYeaTVr4wVnpKuB6DmhltZoLmKcOLpQOS/tcZu6MAvgF2mcH0TV5xXH5+R2rtKGV3sHGnZ6OrqHepRR4gjBSwTL1Aw49XyAoexXJmRnrOOEQYNGcexHfO+Ne2Wca4AyAliXYGQCnLuAtjotABGHg08aSItm3bxswlm2+T5ddk+UJZx8Me8IAH8L1uueUWKyhVbuAfe7Z7vmPhng7bcjdkiYGTNjUV07ugfDU0pko7ds3dCIDUzTffTF//+tdp69ZBat+jH/1oFuVDbLUYgCsI/kEEUI5BRj5cSwyZ+hAvbQvdO6pMi6dfcby/LBCw6zdujP5aZ1spogu1Um0B8/ws3ZVxMiONm7rYlioa92e6f2dk3QprfoyrKWPT3Mqro3zGAGRVC9dkaebJ9GuOUu2Ildgkeji5acfXysboO1/LPqfK19eCGmQH9cjHeE+zY7pUcV0GcTq9iJb8bpLVTmk16bozna7SSoijiLP8waBlCGBNGE+j2lbAIAiTsx5Vr18+mYsBJkGgHQAZADYco4cQYmxLlkVhJIlGF37A6oIoOtqi2ahydjmYZO3D9XCefCfXmUT3ycweqOtW5Y6TMZ9L0dlCPwEQzJuvsuqS2ze28sj8BVABjBZOnLFyjb9V09iZVHdQf++O8w423zPjvr9HvdfMLLa8YZU8y3n1zCqH9nna9/JuKTCHpeMIEKjZ/+l4CayZd4fYZWnIoGa67mWWzqHKSpCEPbqZWlh8ubSOXu5xY5mtTuZneeNw3O+KjOmM/ka9wWMdCiezjLt1qQm3CgaN3Ic//OF0+eWXp5/B78Hf8Hlshs/148UXyjoehoRR0JQ64YQTrN9j8x5EAf2ntKPTwGrC+/jWPUt0256lkcfvXerSPQfatDsBmZh1HkZ0xZ37OTlNaaWtO6bU4uIiI/Bit99+O1111VWsCYVJ8Jd/+Zc51SmyRSB+WmKf8T0m5XPPPZdjoH/7t3+bs0cAeHr1q1/NFFRk3oP92q/9GtNLkQYVmlRIf/rBD36Q/vIv/5I2rNmywdleuvoOYhhR6HeJanVyaxOwwGQXSu69UWL0bXoVk5Tb3LXL2g22hqatYTvx/RPAVdeP4JDJYGDXP2UWjNL8yNvptu2eFgnNzNsZNcM0JrG8EIkiZVmPGQtXaJMynSYJyTIzyY1lYzAxFBOozx4Cc0kYPDA4l2Ar1T0EuahselKPSsJI8sOAai6YVonot6tC+BzyaLZRUwLuGBIxUaPi0eZqhQXGdcdmVNsKGBR3kP1OtQ3YUpwBsOMzgwoi6gCd8DeOQSY913HTjHo2DSphAMmQxbFxpZqKgHeCgJaCHgumczl8BfKIALrep+OEudlYSYXG1wSh1WgrCLhzok5vMGSviOWWy1YenbnpJkypVdhAKczYGjX3TMoEHmLLuOsjfN2sT9a/i5ZD+5z/NSlrz/YeygotNMuZJzuQ137yHZhSuBfCXWTtYNugCXvkhj65cp+s4yZ5B2cxmvVwyqz+Gfc7a5ijUT6z3ZLvAR66VbDgRtSTHM4kamVvHQUGiZGXvOQlnOgJWck/8IEPcHa9l770pfz9i1/8YjrppJM4xA72e7/3e/TEJz6R3v/+99OznvUs+sxnPkNXXHEFffzjH0/9MfhKz3/+85k9BU2p17/+9XTWWWexIHppx7ZddfdBmm3aIQOsJb5w1b3U7UX0rAtOoNlmNWVGieTAHfuW6ZPfvYMuv2E3XXL6Fnrdz50zdJ2dhzprXIvS1rsdUVAKE+KTn/zk9G/RccJE+/a3v53+7d/+jf9GylLdvvnNb9KTnvQk/venPvUpBqJALYXmBibUD33oQ+mxSEH41a9+lV71qlfxzgKoqG9961vp5S9/OW1YKwp8aC9+j3f/uuQFEVFlgtAEc/GEa2PXPuwRu3NamMzQ4iLLMVktICDvOlmLynHBvqGFdMZC0wxNmxSoyfrOtnDDLqweWsDHBUTdJWwrpmXlBRr3XwLQ8b8FYHOLLaLNvtRDM8kAu2SXWdaDJiioA2fcNwUW11khBQyMZYRIjKpD1mdFyiDnriWYNeo5WeFzZIbETRKSJQwmAEajQvBW4nSb4X5qznFVOEcYc0YxlUksg71Ur9A0MkAmoEFfzFplvYOW1HHTLVr2ARwRdcKQNtXqDOiAvSNgWBaYY2py6SAajIXTua3AxvKpVUU2P4SqheTEAI8cqntJP/RwLT8F+kxgqI5se57LeDCANABUAKCaYDElLAKAO9hBbyVhhTrgOE6Y28ShnBMAKpJFEeWUjHCrJq5uK8/AfLd6S6LCIcaj5h69fEcDoJ4Llq2w/CtpCzNc0BwvA9dzVy47YN5b3uNmAhC9XggvZFYxhmpjvGdLWNXYxOJzV2FM6cdlJSgpCmqOeg6KruUO98bgEbJLL72U9uzZw/4MNuzhJ1122WWpmPldd93FPpHYYx7zGPr0pz9Nb37zm1nA/Oyzz6YvfOELdP755/P3YJ5dffXV9Pd///ccgYKN/ac97Wn0p3/6p6WcSWlsix07w+myn+2kz115D//7tr1L9KZnnjvA4LznwDLde6DNgBTsh3fsp4PLPm1qDS7Ubt87moFV2tFtTlw00PMYNgidA9w6dOjQ+qCnFmVK6QanzV9SL3NkQSuQ4Sz33rhnHFIQwHlzOR1xKpybCp0mC5WsRQ9Czsii3zCucbhcwhbSF1tmeUe2UWAsZiwLrdV0AMx2KvJdXl11QzrpEO3rqVAMHCfX5EVdAujw+AHLyQJO2SxPZyJdVCZllrBCZmshfblxD3wfoIy4hjYOpL62e5ljxqxTkWdipY6d3jd8bkYfrpaFgQJ/IbZdradOeeqoJ7vHk5ZBmDo1zx1gHh02ptQKjTPuBT55TsSp7iNHMZ9gOjtIB4wkFE6OgUnoHAAhTAFgHcFa9VoKuqGN+mLhKuzHLAt0qmCNWmXo+26iYbXY6dISwuuIaOtUnfHaALpPrpuwpMCYUnpWuCcYVWLS7yhjTxN1x+d6SBv6BECaMKVgknEMx6xlFr3VNsmqaGvzDW+Tzj3yrNs+m1QnaxwdofVoee/U1bBVbo/Cz2C6NklC3CfJwJu15io6pop+Nuk7LadtuZ3CHoftYeOhEFA2zvr4WPYnVtGO5rqtpcENB5Po5M3NTHHwtb7/nfuW6YRNDd7s0p+72/Yu0vbZBv3s3nkmHNqi0d/4+WsGAKV3Pfd8etQDtrI+1KZWlQ4uBxy29/6v3pQe88onnklPOOe4zDI94vTNR6QtSjuyc8O6FzovbZXo9HiR12eGGTXjLrr03SwwsHghYsTsF2EV6VoC44YlmGXMCmEb14qwnCYIR8ksexaLIDckLhEFZx2KnLry91h4Js4sA1nJDqMs1uQavSDRY0gig/L63+xLdlyk3S3Zk8BKYTKLxSGScAm+v/ZZLivLOM7cyU4XpDlmG4/jPFN54SdrYY7H2kicT4o1ffogSirquwLNNjMkTq5fJBNfFoMpz1YbDOGMewBeIGiLtsoQa9c/91xhCfXZQ0r7J1agh0vUdKtaGQcZTyrDXyVTk0v+bS0rmEvVGjmOmrMALiHcrpJoW7E4OsWcxQ+gkzCHpM362e8wFlzGk/vlEg0m9IdL09iAsLS72Tbr3Y7qxAYF5x7Vf5imXXJHhULpbBEW0i54H114GyxasHKwoYVn22QRrUfm1qShjpOKb6+wroXZiunaRICWCdo1i1VdJLwua00ySXsn12K9uIRxr0Lssscnt1OsNp509k+u8cbiUThflHbU2ZIfpqFrZ2ybOuz3R9jd/Yc6vPF2zo6Zgc/3LPgUgDaeSBqI3XD/PP3LT+6lE+YaDEhhmXTBSXP003sO0Tdv2M2gFAyAFOxHt+8fuOeXr72fHn/2NtbrtNkVdxygR56xZd1vmJW2ulaCUseSjVqUDuyk8QnDxxgggOvWho8qsvhlureNFl/AzIVh1mLLdmyeFS33SkAIvTwM6GUAf5k7fImYuJQl+0Z9vQkbg0n+1hduA2wnfFCwX8zr54VD6CbfA7CyLextmhbmmDH7bKWg4eHUahnjfthNxvOpO+V9R31lmhlZgNJaZOKT665m1rY42T2P0QZoK4qtwJAJGAlTSv6t11WVs19GvY0A1MExEq2EopkGYQCZIMAOxsPmlhI4R7ZAgFJNhFUnJmwgYANmqJ0CtgBRAkiLBsCxvLbdSCCUaRu57KtlmY657b01qU6WnCdgC2e8y5EtWmko9GqbvknC2OwY9y9SbvOdtMK6FgZbpY/Td/dk9yu8IWN7r9rWJJNskCbXYjH6RJx+VUHpIzn+SittAusrXKyvwKVIdKEsxfrsFXfTDTsX6Jp7D/HfDzl5Ez3tvOMZlPrxXQcG6tKLIvrxXQf536976jn00f+4hZlZv/Z3P6DnP+wkevhpW2jHbJ0Tv8y3A2rVPU5CA6H0U7e2Dld1S1sHVoJSpY3HXlot0dOVXGekLsiIY1diK61/kfLkHVMUzMtj85jf6ddTJIvx2mulbZzVpjZW1lqDhhvIKV9rR30U62e9sF7M62UBQ+bnFQNYHK6rvYwrKT8YTbUA4X1Kx6oKAfUMNpqErPXv1WdKAZQQppQOjh3VjKJj3Mbq20l1skztSHeENmIRls3htklBiSLlNt9BK6zr2HP4kWrb1bxvci2w/YqynsZqpyM9/korbUyTxCQrTdS6mva9W/el/z7U7mevhxYUinnzrsWB43/+/OPpQcfPUr3i0gEO1ztAp29VrK8b7l+gxW6PZhsVesRpm+mFF5/Koue4zv/98b38M1X36PFnH0eXXbuTHnT8DL3lFx5M3WRtVNqxYyUoVdrqsJcOp40DDK0WiLZaVqQ8eccUrU8em2es7zZYG6+nsmxwG8X6Wcl1VxNMW43r2eqadc2V3A+Mq7mp5kD4YlYb6yDE4D3V52BIAZAaOyNeaRvSDmvfTvyeWQdz8KSgxEZ49x2ptl3N+651HY70+CuttIltbVApsJZu3LXAIFGjOnpezGJs3bxrgd7xpetS6YO5ZpWe/MDtdOKmBl148ib+7NwTZjlTHzSoBJT60R0qdO/hp23m9xgYVadvm6K3/dvP0msvdUMGpGBgYP3kroP0tPOUaP9KbNd8hxlfJ8w1V3yt0tbeSlCqtL6VL/PSSiuttHUBLmQdVwJPpZWW++CUoERppZW24WytmFLQhjqwFJDnLNPZmmaUaQidAzupqm10QS/qg5ffxElG7juYyLskBs2nSy8+ZeCz805MQKn7DtGzLjyBAS6wpmAXn74lPQ7aVf/024+iew+2ye9F9Odfvp7ZVGL/ecseBrEOzQQ015o8acVte5QAewlKbQwrtxNKK6200korrbTSSiuttNJKK+0wGUAbgDLq35NfB+ylHjJhGMkxcH25bmwcbzKiIGj+07sPseA57Ns37aG3fOFa2jXfHQKkpusV+vnzjk//PmVLk7ZN1+i8E+dSthO0pABq7V/yqVF16fyT5obkT0/a1GRx9z//pfPpOQ85kV795LP48+/ftp/2Lnbpuvvnaa1NmF/HqoXrqP4lU6q00korrbTSSiuttNJKK6200g6T3bV/OQV8bMlTitoPk+x2jz5TZb2D/eD2/bSpVU0z4OkYFI7fMlWjBx4/MwRQIHQOYNLffPtWZm8BbKpXPAaJfuPRp9GFJ82xBifC98RO3tzipC2757usD4VwvN/4xA/T7y88aRNVPZce+YCtA3pVYsfNNOiFl5zKQNkXrrqXRc5f808/oT977vl09o5p2jadkzRpBbZvsUs37Vqkh566qVBo49Fmi90eXXPPITrvpFmabUzOSFstK0Gp0korrbTSSiuttNJKK6200o643blviUPGAHYcDQZtIwAAZx43PfD53kU//XeSEHik3b1/mQGmrMx0379tXwpACSAFA2OpE4Qp+IK/dQMgBFHzWsWlj/2HAqQuOWMLvfYpZ5PjOPw9fmcZQKeHnLqJHnzCLP3oDhWyJ/aI0zczW2qU4fq/+9/Optf/36v57//vu3fQmcdNsRj87oUOi6nbbKnb41A9RB4iVA+hiDrIhJBCsLuqnkOnJVpXsIWOChkEOywPlALg9rP75lmE/WgCr5aTkMmOH44HSh28myj0ibaeuarlKUGp0korrbTSSiuttNJKK6200o64CXsIAAPAqdT8ZaKwS9TczCyX6UaFWTwrtvZBlW20noBGS3uJ6rNElVqh0xE6d+9999CWLVtpZqoPeqCMM41qqm30gG1TDPbgc4A4CN3Dz32H2nTBSXbAxTSwiGA2UArXsoUBCqAErSddX2nZ79G1984zM+pvv3Mb/xZDtryXPub0FIgyASkANAjT061Z9egXLjwxBbwA4GyfadBjz9yW9tOO2TqHBOpWqzjk91TBT9nSor9+0cPoNZ/+Cd2ye5F+es8hislJwadeFA+wtGBX33Mo/fd8e7BMsLYf8g9MQKmFTpDqWGVDbX3wCufvW/I55NBm8x3odjk0Va/QgSWfmjVvAMDSv7fZnl330+a5Wdrve7R9tjE0hgAWTmpyb/TPnsUu7UiuL5F7qNfmqRqPyaFyLXRpc6tKFf27A3eo3yUoVVpppZVWWmmllVZaaaWVVtq6MqAiPb8P6PS6RBV7+BXAEghxp857r0vtqO+0AySB5hCYKjXPpejuK6gCkOqMx9NN9x+iqbpLF566LT0eTCCAWMi4ZgOrAB4BXIHekRMT1ZxQlXPnNeqAMx6vNHZ2Xkdec4boxIcO1isM+HiUe7kb0JQbENWm6M79y9S56xo6dP8UXfiwRxNFPYrcOt18335yvGoKe+yc79CyH3KYG5fH79Dbvngj3bG/TU8/bwd94NKHMpghBuHxLNANdRkACojoykRUHIY2+9p1u+gr195PnSCi33rsGRzed+e+5fQYaEjdumeR3vHFn7GmlNhss0p/8HPn0KaW6sOTNzdTMEysVR8ul5OImL/ruRdQltmYRnPNGgNEp25p0Y07F2hzq8bZ975y7U763JX3JHpUTgo+gcGFPsYP6ob+wHfAzS44aS6X0QUgDsAWMgQWNQf9Hqv7wPC7HYQM8qhrhun1Ljh5jsG6iufQw07dzMeibeV7CbGUsYjxCoBs9y0/pl2OSws7LqEpL6SpBNxEeCFAu4eftiW91gBAJeMSpoGoca9LndADmkjX3bWHPztt+ya6c/chcp0tdNxMndtPGHUAAM/aPk1VPF9Rj8irMhCHz4+bqdFZ2+0i+QyEkva84dl3XCKv0qcAAkwuYCVTqrTSSiuttNJKK6200korrbSV2T1XEiFj2hmPV87ovVcSbT+XaKoPHomBMQPgiTV9gkO0fPdP6Zr4TKLqVMrSwA8M+kjRzgXO8AbnfGbPlVTzEMf2TP4eoWfX3dcHGuBgw/HWTQ8rqy/cTRdMz1P1zMcPHHP1PQephvuc2mersO27lWjhfq4XQrmie39CZ8zENHPygymMFGvJC5aI7lZaSrsWe9Q4sEi9qeMp2vQA/uyOvYPO+V0//Sa5DPacSP/vZ7von354F730sYqdJPXR9X7uO9geqAsADgBXAHSuuGM/nXvCLLNgwIx5/1dvZEBDDCF5S36PtaS2z9Q5NBIg3l9942YGOgDm/PfHnUH3HGzT2dunmZ0jBvaSCUqBeTOOSRY9YQpBq0rCFwE0XnTKpoHjn/2QE+kbN+xmUOQvv3YTvfJJZ1KrVhnQ0IJhLPzNt2+j/7hJAS+PPWsbXfqIk+kndx+kW3cv0oNOmKUnnXNcClQBiDNtlNZ35d4f0tSCQ/GWS1Jm0c27FpktBnBKB/qg0QTrQTj+noPUDexxmeg/hBQCxJLbO3FEle4BonvuJjr94pS5Jywy0SDTtcPowO1Eh+5V/z7tsSoDbRTS3uu/Q3dF2yny6jRz6Bb+2qUdNLNnF93iPlI9T3HMgBjaFcDUFRhTc/uJFnbSoR2PSoXmAeLZDGL6AoQ+5JQ51T/3/USB0CdepA7aeyPRzjvzG1jaudBRpZVWWmmllVZaaaWVVlpppR1x+8hHPkLve9/7aOfOnfSQhzyE/uqv/oouuUQ5zTb73Oc+R295y1vojjvuoLPPPpv+4i/+gp75TAXoiHP/tre9jf72b/+WDh48SI997GPpox/9KB87lkFrhqoMztwwX6Edjk+b/UW660CXFu68imZPPJsOHNhPDz51O7VpB58Cce1NwS6K4NzPtel7d3XoOzfvoYtO3UQ/d+4OBhTgNCPADYDQfLSfZmM4+w4LZ29auIm2bd0CqIOvV+nsp91Xf5/c08+lPd42DkvafahNs7sUYBRVmgwE3LTUpvl4Nz1guUv7lroU3/fvFGx5MIFvEgUdcm//Dh8P4AzhTZsQNhaFRHd+l7w4orv2Ez3Au572OQ+muB0wywqhemDJoPxfuvp+arbupoc+ehM5u64hz5+n6akpOrj1IgZ1fnrTHtru9GgTLdLV8QPoJ//573TBcb/IbdgEkHDcwxnUWHR6dP398wx0gNl0z4FlesRpW7jui50evf2LP6N7E8Dq3BNmGMgD4DNV8+hXHnEK60yBvfOJ/7w97aZLTt9CM40KA4Nbp2r0u085m0ESPXQMDKkTM8LVbGykLJyqVfPSsDeE3l18+mZmeR0349P19y9Q1RKaBrbUbz7mdAacrrjzAL39i9fRO559Hus/6eF7V951IAWkYP91y17+Efv2zXsZzDtuus7gClhgYN0hJO2ae8GuchiguW0PBM8VswnZ/6ba99KF21yi48/nejHgmNh913yL/uO+GfpqbY77AcylbhByOQDq4fpPedB2OnvHMLvo6h9+k85/4IMQtEjhruuJgoDcOZV1kNvqwI0Ub2vRzdf8gEHDytwD+LPImaH52kP4GPT77M7v01yzQicfv71/8Tii+U5I19+5m6bnu9Sgu6nb2sGsOTwDe/fskgN5rH75m9+mb1xxDbfFLz7z2TQ3t4morUCmgcyHcUTtm77FY3tx20Noeu88nbatRXTHj6jS3UKVzgG6aYHooosuVs9/6DNgddXNd9ADaScVtRKUKq200korrbTSSiuttNJK2wD22c9+ln7/93+fPvaxj9EjH/lI+sAHPkBPf/rT6cYbb6Tt2zUnNbHvfve79MIXvpDe/e530y/8wi/Qpz/9aXruc59LP/7xj+n888/nY9773vfShz70Ifr7v/97OuOMMxjAwjWvu+46ajQM1lCOtXfeQFHlQuoEHQoXfboPmjbR/bRn3z4Kwx7RfTcTAn123T1PzvQy7btjFy1WN9N05T4OA/qb/7iVfnb3PuqRR/49P6G79z+KGU9tv0cX0wHaOlWnq+Z308zO3cwgOriwjx7h7KKDe3fRf926l65YPp4e6N7DLJYovo6Wt11AFX+Bbjrg0V3X3MMgDkLIcE2EXx2460ryt3TSDG/h/P20a6HDLJLj5xoMMCA8a9lv8/F3/PS7dNvueQ7FAxtr81SVdt72DfrcFfcQApkAop20uUn/fs1OBr6Wl5fo/339Mpp2lE4W0R66LoqpQT49wO0x0PXrjzqN3vCdLu2Zb9MX/v2LfN+ZZpXqzgIdbAcMwni9Nl11y7303v/cx9fdOnUP/eqDavTFGxbp3qWYTqR9dD9tYZBHmEh//PMPYkbUkx+4nf7he3fQj+86QIjSgxD4D+/os41+5REnMyBlGsCWAU0vzWyfA+AB0CUC4jBk4zMFyiXsEPV6wHFTDIqZ+lKSGRCsrg9efjMLvP/W3/+IPwNT6Lcf9wBmKX3mh3fzZ7940Ykssv6P37+TWV24NsIBATwBHNRtB+2nfTRLvQQGuX3vIr3mv53N4A2uWVveSd783fSzQ0R193Sa7vb4u+9e+WM6VDuerv/eTXT/fIeujM6h//dfB+k+2koPdu6kZarT7ngzLVOD/vOWvfSaR26ix59SpTuXa3TXfffTZq9DF27z6Bv/9V/0vdvAlPIoPuc4WvK/T/95816Of3x4AoyhLW+6f56+8Y3raet0nV795LNoqbFEt+1dpnB+Fz10GsL0PWoeWqROp839seu666je3k2b5++hhbuupst3T9O1S3PUCg/Ro+cO0OzpD6U9HY/m9n6fOnc36FtXXsv1P7Ac0Je++R36rUceT7c1Pep0ffI6/0k3+sfRqbNEtS1N2reMTIULtHffLfTIzRHduXeZds7vp6/+7EfMNHv82dtotgKm1zKFKH/rANX3Xke7Dt5Em6/7VM6MoY2fWAIkS8u0+fl5mpubo0OHDtHsbDEhutJKK6200korrbTSSiuttNX0JwBEXXzxxfThD3+Y/46iiE455RR6zWteQ294wxuGjr/00ktpaWmJvvSlL6WfPepRj6KLLrqIgS24gieeeCL9wR/8Af3hH/4hf48y7tixgz75yU/SC17wgsJ1O/iGWdp33MX0nepjafdSSGdW99FS4wS6d+f99ID4XqpuP5vOP2UbVTt76f/tmqNv7gbg5dAZMyHNxYv0tYVT6Hhvnk5uhXTnoks3RKdShSICL+o53ndph3OA/k/vCXSyu5e20SH6fvRgOtXdTac4u+k4OkgheXS+ezud4uyh73sP5++he3NzeDxd7N5AD3FvpXOdu2jOWSKfqrQnnqMKhbSjskQHva30g+6pNBsv0Fm1/XTOTEDbF66jTuTS9+kCunnusXTT8gxtWr6NHuVeT6c5uyiYPpluWqwxg+p+2kqPcG6ik5099KP4gXTX9ENpq7dMNyxUaXPNoXOcu2k/zdEt7um0OdxDZ3m76eKtPjW2nECfj59M3/jxddSiDrWpzsDTndHxDJ40Kg5dUr+TFto+16dKPQa1znOV4PTeyg5646On6MaFKt3pnkKNWo1BAoRTbamHrC3U7nbJgdZVpcnAxie/ewfdsmeRnv7g4+nFl5xIwJiajTp12m2KKg1mD7HGUAIg/eCGuymqtuiULU0G6sCoAoMMoBpYZGJoa13bCsePk0UROkZ37FtiUBGssL0HF+jqexfoL756K4MdsBoFFJJLLepSh2rUbDTof/3qRRwa6AZKDD+qzRK5Hn3mR3fRd666gbbOtGjb1q20d6FNDwqup11LIS20TqVbFzwKyKPzNsf035/0IHKqDbr9yq/TobbPouinn/couu+G79O3rruH5nsVuiY6gy5wb+c2aFZdOtTp0f3xFjrV2U2nbmrQaTu20Hfmj6Ob7t1Lj3Gvo63OPM1Ti/bEm6hOPm2uBLQt3Es1x+exFzW20q6wSVuDnfRo93ru/wPOJrrXO4m6fkDHOYd43FRrNbpq09Pp8vuq9AD3Pvql6g9pezOmO2YeRu3KHDUooE5zO52+8GN64O6vUIV6FMUO3RqfSKc7O6nqhBTGDl0WXUI74y10a3wCTVGHnlG9itqRS/8RXkAHqsfTaTs209lLP6Fo/l66Njyd7nRPoqectYl2HjhEV+x26ProNHr27C30hMattHRgF90cn0j74xl+Lk/b3KDz45uZifWz2SfS1sUb6KHz36DFbkRz71kYOe+VoFQBK0Gp0korrbTSSiuttNJKK+1I+hO+71Or1aL/83/+D7OdxF7ykpdw2N2//uu/Dp1z6qmnMrPqta99bfoZQvW+8IUv0E9/+lO67bbb6Mwzz6Sf/OQnDFSJPfGJT+S/P/jBDxav2xtmaLZeXG9odzxH98bb6DznDhYeb8c1qngeVaM2dd0pupeOY12c7eEumo0OpudF5JJLEQMKflyhKWcwo5vYwXiKXIopIoc2Of0QrEkNjr0HlfRVtsipcJY5L1ai1SjvPbSdbgxPooPxNIMwNadH1c2n0kXHxbR0/03U7O5lhkx1ZjvVoefjuOQ3jqOlrRdQ0NxGVTemM4LbaD6IaWn+AINSvfoW6k6fTGGlxWw0YE6tg9AciuiUE06gu++7n9qbzqJzdkwrEW1Y5xDdfedt1J0+hc46EXpGcf87UUTS/r5j3yKHGuIzhP+1qhKel3+e+d1iJ6D5e2+k2HHpfmc7hyU2Ki7dd/vPqAcRePKpVqvRcQ98DJ20fSvF7QM0deAG8nrL1KvO0NLW87jO1Xt/QFPxIoW1TRTWpqmxcDeHUoa1WdoTNuk/7q/SXHSIKk6P7ox20GnuLtpK87TVWeAxdpKzl+acZbqbttN9tINOcvfRtkqHwtZx1Glsp2pvkab3X0tuFJDfPI6C+hZy5++hZrTy8aYbxvkBmqYdTv85yLJDcYvLvJrWi126M95BZzg7yR3jGbhs+UH0jPf9cOS8V4bvFTAhk2HCLa200korrbTSSiuttNJKG8fEj1hJkMrevXspDENmMemGv2+44QbrOdCdsh2Pz+V7+SzrGNO63S7/iMHhhP1t47foMb0f0Dm9GwlQxJ7K8bS5t4uzp+2bPpuaC3dw/XfFm+lMdyc16CCdSQcJwW2LVKEKdQmwjFJIWqRt1BfrPkgV8lvbqbGMoMAw+RShYj3a71TJnzqRvLBNQWMrtatbaNvu75KbnI+yHCKX2rOn09KW88hvbKdNVZ+ai3fTnqBBe6IZmlq+h7Z17yTXq9FN8cl075JLN4Un0EO2EV3o/4Q2L93GDJTQrdPCtovohugU6u27g7Z5i7R9bopmD91I8/UT6J7mOXTO0pVU7+6jbgOssH2qpJvOpFpnDznLeylya7Q0dw7FU1v5PIhLD1pMm2gnPdLU5IF80h6iOf2zxb5WFHhnDfqX9G/xXJV0fL7h2Lnkx/R45X5FPGGoe5HWOyvxnpXUNxGC+c5J/v1w/QAMlKv+39B5dUud+0pUyhBGejyYhObJUVbb7OIfGEu0L+yjKqlnLh2l3d2AWnl0dpwadWqbqR4uUqW3xKBj4NRpubqJqo0p1j7z/AUeUzG5NH/cwxhUjBd2UrN9H3lehXqNbbQr3kTO/pvpLOc+atIBOkQO3TX9ENodNOnB3Z9S5LgEBakt8T7aRdvoh60nUuOsx9HD4uupsucaWjjuYbS09SE0tecqmt5/DdHSHppauIPBVe+0S+hgJ6bpvT8lL1hkEO6As4WWNp1NO5ZupKp/kPzYo8Cp0BR16Ti6j+t6i3c2OdNb6aQeAL5FOlTbQX63Q7fQybQpnqcLw2tpn3scfdF5En3HPwHy9CPnvRKUKmALCyo+F9TY0korrbTSSiuttNJKK620Sf0KsIo2skGf6h3veMfQ53/4dpNV1Q/lIlLgjDIRXR7X9OuZJjpJt+Yc89PkZ5Rdk/Md/MKvZ3wH/aIfW8pk1h/2vQLlKG1jm9nnsL4w+6B9c4zrKhF+O3x2GxH9f9pnw6Bd3/49Y3yPypinj3HYPcnvnxnXua3wvFeCUgUMcdZ33303zczMWLMNHImdFgBkKFOpcVW280a2ciyX7Xy0WDmWy3Y+mqwcz2UbHy22nsYymAJwzOBXTGrbtm0jz/No165BUAd/H388eB/Dhs/zjpff+OyEE04YOEYP59PtT/7kTzgkUAyhg6eddhrdddddGx5wO1rG25G0sh3KNhh33itBqQLmui6dfPLJtN4Mk92xPOEdLivbuWzjo8XKsVy28dFi5Vgu2/losXIsH1vtvFLABho6D3/4w+nyyy9PNaUgdI6/X/3qV1vPefSjH83f65pSX/va1/hzGLLtAZjCMQJCAVT4wQ9+QK985Sut16zX6/xjq996aOcjbetlvB1pK9uhbIOi814JSpVWWmmllVZaaaWVVlpppW0AA0MJwuaPeMQj6JJLLqEPfOADnF3vpS99KX//4he/mE466SQOsYP93u/9HouWv//976dnPetZ9JnPfIauuOIK+vjHP87fIwoEgNW73vUuOvvssxmkestb3sLMBl1MvbTSSittrawEpUorrbTSSiuttNJKK6200jaAXXrppbRnzx5661vfykLkYDdddtllqVA5QugQ5SH2mMc8hj796U/Tm9/8ZnrjG9/IwBMy751//vnpMa9//esZ2Hr5y1/OoXiPe9zj+JqNBqSzSyuttNLW1kpQagMa6LJI5WqjzZZWtvNGsnIsl+18tFg5lst2PpqsHM9lGx8tdrSOZYTqZYXrfetb3xr67Fd+5Vf4J8vAlnrnO9/JP5PY0drO41rZDmU7lGNhMnPileQlLa200korrbTSSiuttNJKK6200korrbQJrM/tLK200korrbTSSiuttNJKK6200korrbTDZCUoVVpppZVWWmmllVZaaaWVVlpppZVW2mG3EpQqrbTSSiuttNJKK6200korrbTSSivtsFsJSq0j+7M/+zPOkNFqtWjTpk3WY5BRA+lcccz27dvpj/7oj6jX6w0JHD7sYQ9jsb2zzjqLPvnJTw5d5yMf+QidfvrpnFXjkY98JP3whz+kY9HQVhB3tP386Ec/4mPuuOMO6/ff//73B671uc99jh70oAdxm15wwQX05S9/+QjVan0axpvZhu95z3sGjrn66qvp8Y9/PLfhKaecQu9973uHrlO2s90wTl/2spdxKudms0lnnnkmi476vj9wTDmW18bKOXVyQ9ryiy++mGZmZvi9hhTkN95448AxT3rSk4bG7ite8Yqx34/Hqr397W8faj+8r8Q6nQ696lWvoq1bt9L09DQ9//nPp127dg1co2zfyd5z+EHbwspxPJl9+9vfpmc/+9l04okncnsic5xukMdFJroTTjiB339PfepT6eabbx44Zv/+/fSiF72IZmdneY2N9+Xi4uLYa5Bj0Ur/xG7luvbYWw+V79I1NAidl7Y+7K1v/f/buw8oJ6q3DeAXlt4X6VX6oUgRpPe6gIKogPTeO0j7gyIgvXlcEUEFFBAEYYFDZ2nSm/TmYeldkCpL273fed7vzDjJJtkNm4SFPL9zoiSZTGbu3J258+be936hp06dqvv3769Tp04d5f0XL17oIkWK6Jo1a+pDhw7pNWvW6HTp0umhQ4eay5w7d04nS5ZM1nHy5EkdHBysAwIC9Lp168xlFi1apBMlSqRnz56tT5w4oTt16qTTpEmjb968qf3N06dP9fXr120eHTt21Lly5dKRkZGyzPnz5zEZgA4NDbVZ7tmzZ+Z6du7cKeU8ceJEKffhw4frhAkT6mPHjr3CvYtbcubMqUeNGmVTho8ePTLfv3//vs6YMaNu0aKFPn78uF64cKFOmjSpnjlzprkMy9m5tWvX6rZt2+r169frsLAwvWLFCp0hQwY9YMAAcxnWZe/gOTV26tSpo+fMmSN/94cPH9b16tXTOXLksDk/VKlSRa5V1vMHzhnuXB/92YgRI3ThwoVtyu/vv/823+/atavOnj273rRpkz5w4IAuW7asLl++vPk+yzdmbt26ZVPGGzdulPbDli1b5H3W45eDv+dhw4bpZcuWSXmGhITYvD9+/HhpNy9fvlwfOXJEN2jQQNpx4eHh5jJBQUG6WLFies+ePXr79u06b968ulmzZm61QfwV708cY7vW/9pDvJZ6D4NScRAa546CUrgox48fX9+4ccN8bcaMGTpVqlQSXIFBgwZJw9OqadOm0ug3lC5dWvfo0cN8HhERobNkyaLHjRun/R0CTenTp5fgif2NPG50nGnSpImuX7++zWtlypTRXbp08er2vk5w8Z42bZrT97/77jsdGBho1mUYPHiwLlCggPmc5eweBEnRMDewLnsHz6mev7HHOXfbtm3ma7iZ79Onj9PPxOT66M/QkMYNuSP37t2TH1GWLFlivnbq1Ck5Brt375bnLN+XgzqbJ08e80cu1uPYsw9KoWwzZcqkJ02aZFOnEydOLIElwI+F+Nz+/fttfsiJFy+evnr1aozbIP6O9ye22K71v/YQr6Xew+F7r5Hdu3fLsLCMGTOar9WpU0c9ePBAnThxwlwG3ZatsAxeBwzlOXjwoM0y8ePHl+fGMv5s5cqV6s6dO6pdu3ZR3mvQoIEMCalYsaIsZxVdudP/w3A9DA8pUaKEmjRpks3QGpRV5cqVVaJEiWzKEMN47t69y3J+Cffv31dp06ZlXfYinlO9U2/Bvu4uWLBApUuXThUpUkQNHTpUPX782K3ro7/DcCYMf8qdO7cMY8JwPECb4Pnz5zbXMAzty5Ejh3kNY/m+3Llh/vz5qn379jLkzMB67Fnnz59XN27csKm/qVOnlmFD1vqLIXulSpUyl8HyaP/u3bs3xm0Qcsyf70/Yrv3P63oM3cVrqXck8NJ6yQtw0bWe8MF4jvdcLYMLQ3h4uFxYIyIiHC5z+vRpvz9uP/30k1wks2XLZpYF8mtMmTJFVahQQU6uS5culZwnyGmAQJWrcjeOCynVu3dvyXWGG81du3bJTeX169fV1KlTzTJEPiRn9TswMJDl7IazZ8+q4OBgNXnyZNZlL7p9+zbPqR4UGRmp+vbtK+dbBJ8MzZs3Vzlz5pSgCvK+DB48WG4Wly1bFuProz/DDTrySxYoUEDOuyNHjpTcOcePH5fywY24fS5L6zWM5es+tBHu3bun2rZta77Geux5Rh111QbD//GjolWCBAmkPWJdJro2CDk/Bv54f8J2rf+1h3gt9R4GpbxsyJAhasKECS6XOXXqlE3CUXo15X7lyhW1fv16tXjxYpvl8Mt8//79zedIyHvt2jXp6WMEpfyVO+VsLcOiRYvKTVCXLl0kyTGS8lPsy9hw9epVFRQUpBo3bqw6depkvs66THEdEkIjULJjxw6b1zt37mz+G7/II6FxjRo1VFhYmCT1J9fq1q1rc/5FwxpBPlzvkBiavPMjF8odgVQD6zHFFbw/iX25sF3rf3gt9R4GpbxswIABNr+SOYKu9DGRKVOmKDMYGLPj4D3j//Yz5uA5ZhtBwzMgIEAejpYx1uGv5T5nzhwZWhaTQBMa9Bs3bjSfOyv3N6lMPV2/UYYYvocZ4fDrvbMyjEn9fpPL2d0yRsC0WrVqMpPnrFmzol0/63LsINDnD+dUX+jZs6datWqVzLRl7a3qrN4aPQIRlIrJ9ZH+g15R+fPnl/KrVauWDLtArx5rbylrHWb5uufixYsqNDTU7MnHeuw9Rh1FfUWw2oDnxYsXN5e5deuWzefQ/sCMfNG1L6zf8Sbh/Ynny8Xf27X+2B7itdRzmFPKy9KnTy/RdFcP6/h1V8qVK6eOHTtmc2FFYAQBp0KFCpnLbNq0yeZzWAavA76rZMmSNstguASeG8v4Y7kjdyaCUq1bt1YJEyaMdv2HDx+2afxEV+5vqtjUb5QhhkMaXepRVrgZRW4Taxniwm50m/fHcnanjNFDClOO428c9RnlGx3W5djxl3OqN+H8i4BUSEiI2rx5c5QhNM7qLRjn4ZhcH+k/jx49kl5mKD/UX1z3rHUYQyORc8qowyxf9+D8i2tb/fr1WY+9DOcL3PBa6y+GhCFXlLX+IuiKfDcGnGtwrjYC3DFpg7xJeH/i+XLx93atP7aHeC31IC8mUSc3Xbx4UWZ4GzlypE6RIoX8G4+HDx/aTMlcu3ZtmTZ73bp1MlOcdcrrc+fO6WTJkumBAwfK7DnTp0/XAQEBsqx1uk7MSjJ37lyZkaRz584yXad11iJ/ExoaKjOzoMzsoZx+/fVXeQ+PMWPGyCxPmO7UsHPnTp0gQQI9efJkWQazM2A2o2PHjvl4T+KmXbt2ycx7qLdhYWF6/vz5Undbt25tM1sOpmNu1aqVTMeMeoq6bJ2OmeXs3JUrV2SK6xo1asi/rdOSG1iXvYPn1Njp1q2bzDi7detWm3r7+PFjef/s2bMyI+qBAwdkBskVK1bo3Llz68qVK5vriMn10Z8NGDBAyhflh/NozZo1dbp06WSmQ+jatavOkSOH3rx5s5RzuXLl5GFg+cYcZptCWWLmNivW45eHdrDRJkZbberUqfJvtJth/Pjx0o7FueHo0aO6YcOGMvNseHi4uY6goCBdokQJvXfvXr1jxw6dL18+3axZM7faIP6K9ydRsV3rn+0hXku9h0GpOKRNmzZysbV/bNmyxVzmwoULum7dujpp0qTSoMQfx/Pnz23Wg+WLFy+uEyVKJA13TOFqLzg4WBpNWAbTd+7Zs0f7MzRMypcv7/A9nFgLFiwojRNML47ysk6dbVi8eLHOnz+/lGnhwoX16tWrfbDlr4eDBw/qMmXKyI1nkiRJpDzHjh2rnzx5YrPckSNHdMWKFeWCljVrVmlo2mM5O4a/c0fnD+tvD6zL3sNz6stzVm+Na9elS5ckAJU2bVo5NyD4ih9e7t+/b7OemFwf/VXTpk115syZ5fqEcyueI0hiwM179+7ddWBgoFzrGjVqZBPQBpZvzKxfv17q75kzZ2xeZz1+eWjXOjpHoN0MkZGR+vPPP5egEs4R+HHGvvzv3LkjbT386Iu2XLt27cwffd1pg/gj3p9ExXatf7aHeC31nnj4jyd7XhEREREREREREUWHOaWIiIiIiIiIiMjnGJQiIiIiIiIiIiKfY1CKiIiIiIiIiIh8jkEpIiIiIiIiIiLyOQaliIiIiIiIiIjI5xiUIiIiIiIiIiIin2NQioiIiIiIiIiIfI5BKSIiIiIiIiIi8jkGpYiIXjPx4sVTy5cvV2+iL7/8UmXMmPGN3kfD22+/rb7++utXvRmvjVatWqmxY8d6tPxu376tMmTIoK5cueKBLSQiIiIidzEoRUQUB7Rt21YCMXgkTJhQAjO1atVSs2fPVpGRkTbLXr9+XdWtWzdG632dgjunTp1SI0eOVDNnznRrH19X+/fvV507d1ZvQiCxePHiXv2OI0eOqDVr1qjevXt7dL3p0qVTrVu3ViNGjPDoeomIiIgoZhiUIiKKI4KCgiQYc+HCBbV27VpVrVo11adPH/X++++rFy9emMtlypRJJU6cWL1pwsLC5P8NGzZ0uo/Pnj17BVvmne9Pnz69SpYsmcfW97pzVbbBwcGqcePGKkWKFB7/3nbt2qkFCxaof/75x+PrJiIiIiLXGJQiIoojEIRBMCZr1qzq3XffVf/73//UihUrJEA1d+5ch72fcCPfs2dPlTlzZpUkSRKVM2dONW7cOHN4EzRq1Eg+YzxH8AeBH/TGwk3+e++9p0JDQ222BctiqFT79u1VypQpVY4cOdSsWbNslsGQp2bNmqm0adOq5MmTq1KlSqm9e/ea72PbsR/Yrty5c0svKGtwzb63zQcffCD/jh8/vmyv0YPsww8/VGPGjFFZsmRRBQoUkNePHTumqlevrpImTareeust6XH06NEjc33G57AP2M80adKoUaNGyfcPHDhQtjlbtmxqzpw5Lo9J1apVpXz79u0rvWrq1Kkjrx8/flx6cqH8sH4MLcNQMMPDhw9VixYtpFxwbKZNmybrwnqcDT+7dOmSHBesM1WqVKpJkybq5s2bUXokzZs3Tz6bOnVq9emnn8p3ubJz5075bgTAAgMDZR/u3r0r76EXHupLrly5pCyLFSumfv/9d/OzW7dulWOxadMmOb5YR/ny5dWZM2fkfdRLHFf0ZDJ6+hl19d69e6pjx44SfMP+4HhhOfv9+fHHH+X7UU8ciYiIkG0y6ocV9h11EOWMv5vp06fbvI/tmTFjhhwr7B/qoXX/oHDhwlK3QkJCXJYjEREREXkeg1JERHEYbuQRKFi2bJnD97/55hu1cuVKtXjxYgkUoMeHEXzC8DBA4AU9sIznCN7Uq1dPAg2HDh2SHlq44UdQxGrKlCkSiMAy3bt3V926dTODEVhHlSpV1NWrV+X7EWwYNGiQOdRw+/btMiwKPb1OnjwpQ/IQrEBwyZHPPvvMDBBhW/EwYDvxvRs3blSrVq1S//77rwRWEGDBPi1ZskSCaggeWW3evFldu3ZN/fHHH2rq1KkyRAu9zvA5BM+6du2qunTpEm0+oZ9//lklSpRIgjvff/+9BFtwXEqUKKEOHDig1q1bJ8EjBJEM/fv3l+VRNthulMeff/7p9DtQbghIobfOtm3b5DPnzp1TTZs2tVkOAUUEJFEOeGDZ8ePHO13v4cOHVY0aNVShQoXU7t271Y4dO+RYI9ADCEj98ssvsl8nTpxQ/fr1Uy1btpT1Wg0bNkzqA/Y3QYIEEqwEbN+AAQMksGMcN2Ob0bPp1q1bElQ9ePCgBCixLdYeSWfPnlVLly6V+o1tdeTo0aPq/v37UhftTZo0Sf4+UEeHDBki9Q1lZ/X555+rjz/+WOooAoUI5GGoqFXp0qXlGBERERGRj2kiInrl2rRpoxs2bOjwvaZNm+qCBQuaz3HqDgkJkX/36tVLV69eXUdGRjr8rHVZVwoXLqyDg4PN5zlz5tQtW7Y0n2P9GTJk0DNmzJDnM2fO1ClTptR37txxuL4aNWrosWPH2rw2b948nTlzZqfbgO20vyyhXDJmzKifPn1qvjZr1iwdGBioHz16ZL62evVqHT9+fH3jxg3zc9iHiIgIc5kCBQroSpUqmc9fvHihkydPrhcuXOh0m6pUqaJLlChh89ro0aN17dq1bV67fPmybPuZM2f0gwcPdMKECfWSJUvM9+/du6eTJUum+/TpY76G7Zs2bZr8e8OGDTogIEBfunTJfP/EiROyzn379snzESNGyDqwfsPAgQN1mTJlnG5/s2bNdIUKFRy+9+TJE1nfrl27bF7v0KGDfA62bNki2xAaGmpT1ngtPDzc3K5ixYrZrGP79u06VapU8h1WefLkkbpjfA7ldOvWLe0K6gXKxr6Oo/yCgoKi/K3UrVvXfI7t7Nq1q80yKK9u3brZvNavXz9dtWpVl9tBRERERJ6XwNdBMCIicg/urY3hbPYwTA0J0TGsDT2e0BOodu3aLteHXk4YOrV69Wrp2YIhbeHh4VF6ShUtWtT8N74fQwvR8wXQqwU9hTAMzhH0SkFPIWvPKPTOefLkiXr8+LFbuZTeeecd6alkQC8X9I7BkC1DhQoVpLcRelRhOB2g9w6GAhrwepEiRcznAQEBMvTP2CdnSpYsGWXftmzZ4jC/EXoyoSyfP38uvW8MGGpnDD10BPuUPXt2eRjQuwnDDvEehlgCesFhOKUBQwNdbT+OE3osOYJeSjgWqD9WGBKKY+usLuA7Ad+LYZ2OoIxQz1C+VigbI3cYYLgphve5gs9gaKujv4Fy5cpFeW4/I5+jZex7ZWFoH8qCiIiIiHyLQSkiojgOQQnk3HEEQ6LOnz8vQ6QwhA1DyGrWrBklb479UDkMcZo8ebLKmzev3JB/8sknURJNYxZAKwQFjOF5+IwrCEgg19BHH30U5T1nuYOcsQaf3OFo+13tU0y/H/uGIXATJkyIsiwCNgj2eIu72+/qOBk5uBCcRD4mK/sk89bvNYJDrr4X60ZZICeVPQTa3Dm2yOWFgBHqpzU46UkYUhhdcIyIiIiIPI85pYiI4jDkRUJSb+TEcQZJpJHH54cfflC//fab5Ogx8vYgmGDkDzKgBxN6WCEBOnohoQcUZvxzB3rOoLeJsxnLECxDryUEvewf1t5LL6NgwYLSEwe5paz7hPW66o3kKdg35F9CryX7fUOQBcm0Ue5GDi9ATqS//vrL5T5dvnxZHgbk4kL+KvSYelk4TsjJ5QjWi+ATesjZ74e1x1Z0ECiyr2Mooxs3bkj+Kft1I8jkDiRDN8rD3p49e6I8R1m6uwwS19v3DiMiIiIi72NQiogojnj69KncyCN5OJJiY+Y4JL/GkDwkDXcECbwXLlyoTp8+LUEPJP1GkMnojYLACYISWK8x41q+fPnMxNII7jRv3jza3kL2MOMZvgcz3CEghKTcCIYhmTZ88cUXkkAbvaUQwEFvr0WLFqnhw4fHupyQrBq9rdq0aSPBBAyl69Wrl8yAZwzd86YePXpIMA5lgMAThqOtX79etWvXToIzGF6HbcMsf9g27H+HDh1sZhW0h95tCBBi33Ds9+3bJ8ccyeQdJfiOqaFDh8o2IlE9EoajnmA2OswUiO1ErzkkN0cyd+wHvjs4OFiexxTqGHrroT5hvajH2B8Mk0P92LBhgwQ9d+3aJQnTkSzdHejBhCAXkrTbQ92bOHGi1H3MvIf6j2TnVnht9uzZsgyS3aNsrUnx0QsLidijG/ZKRERERJ7HoBQRURyBWdww5Ak3+cgPhYAGZtdbsWKF5D9yBIEF3JQjcIG8Q7j5X7NmjdkbCTOmYageer4YPUEQyMIMdOXLl5dhaJjJDjf97kDvGAQbMmTIIDP5IaCCWeCM7cQ6MTsclsF2lS1bVk2bNk1yCMUW8lEhCITAENaNoYeY1e3bb79VvpAlSxYJhiAAhUAG9r1v374SCDTKHWWMoAwCigjQIOcVeuc4G7qIYBWOM45L5cqV5TPocYWeb7GRP39+OQYIPiLHFbYJ34MeTDB69GiZnQ6z8GH7UO8wnM/ZcFFH0IsPn6tWrZoEkBAkxf6gHmJfEKzDdmDWu4sXL75U4LBjx44ys6Q9zPyHIBfq9ldffSXljrpnhcAoAqLoNYZAKbbP2vsM5YHcWJUqVXJ7u4iIiIgoduIh23ks10FEREQuYKgh8jYhSIheU+QeJDvH0EwE6ewTl7uC4FhISIj02HIGAdPevXtLj0EiIiIi8i0mOiciIvKwQ4cOyVA59E5CPqlRo0bJ6xiOSe5Dwnb0csLwQE/C+pCMH0MxiYiIiMj3GJQiIiLyAsxuiGTvGOpYsmRJtX37dreTfNN/qlat6vHiwPEYNGgQi5mIiIjoFeHwPSIiIiIiIiIi8jkmOiciIiIiIiIiIp9jUIqIiIiIiIiIiHyOQSkiIiIiIiIiIvI5BqWIiIiIiIiIiMjnGJQiIiIiIiIiIiKfY1CKiIiIiIiIiIh8jkEpIiIiIiIiIiLyOQaliIiIiIiIiIjI5xiUIiIiIiIiIiIi5Wv/ByvGwrKR3+/IAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "sample_labels_multi = np.array([m.get(\"source_label\", \"unknown\") for m in rw_multi.metadata])\n", + "\n", + "clf_multi = cluster.classify_read_features_binary(\n", + " feat_multi,\n", + " sample_labels=sample_labels_multi,\n", + " classifier=\"logreg\",\n", + " random_state=42,\n", + ")\n", + "print(clf_multi[\"metrics\"])\n", + "cluster.plot_confusion_matrices(clf_multi[\"predictions\"])\n", + "\n", + "_plot_classification_profiles_compat(\n", + " rw_multi.data_matrix,\n", + " clf_multi[\"predictions\"],\n", + " val_matrix=rw_multi.val_matrix,\n", + " metadata=rw_multi.metadata,\n", + " split=\"test\",\n", + " group_by=\"confusion\",\n", + " **_cluster_window_kwargs(cluster.plot_classification_profiles, shared_window),\n", + " motif_count=2,\n", + " motif_labels=[\"A,0\", \"CG,0\"],\n", + " plot_all_motifs=True,\n", + " color_points_by=\"motif\",\n", + " motif_profile_mode=\"single_axis\",\n", + " point_size=plot_point_size,\n", + " point_alpha=plot_point_alpha,\n", + " smoothing=profile_smoothing,\n", + " show_unsmoothed_overlay=show_unsmoothed_overlay,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Read-Cluster to Region Association\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Read-level clustering stays the primary inference step. Here we aggregate those cluster labels back onto regions, then plot the region-by-cluster association matrix. The plotting prep accepts the long-form association table directly, and it also normalizes the legacy wide summary output from `summarize_read_clusters_by_region`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from dimelo import plotting, plotting_matplotlib\n", + "import pandas as pd\n", + "\n", + "region_sort_mode = \"genomic\" # initial sort before source-label refinement\n", + "association_strength_aggregate = \"max\" # used when region_sort_mode=\"association_strength\"\n", + "top_regions_per_cluster = 8\n", + "\n", + "association_summary_A = cluster.summarize_read_clusters_by_region(\n", + " metadata=rw_multi.metadata,\n", + " labels=clust_multi.labels_size_ordered,\n", + " include_strand=True,\n", + ")\n", + "association_payload_A = plotting.prepare_read_cluster_region_association_data(\n", + " association_summary_A,\n", + " value_mode=\"fraction\",\n", + " top_n_regions_per_cluster=top_regions_per_cluster,\n", + " region_sort=region_sort_mode,\n", + " association_strength_aggregate=association_strength_aggregate,\n", + ")\n", + "\n", + "axis_table = association_payload_A[\"region_axis_table\"].copy()\n", + "\n", + "# Primary source labeling from read metadata (most frequent source per region_id).\n", + "meta_df = pd.DataFrame(rw_multi.metadata).copy()\n", + "if not meta_df.empty and {\"chromosome\", \"region_start\", \"region_end\"}.issubset(meta_df.columns):\n", + " if \"region_strand\" not in meta_df.columns:\n", + " meta_df[\"region_strand\"] = \".\"\n", + " meta_df[\"region_id\"] = meta_df.apply(\n", + " lambda row: f\"{row['chromosome']}:{int(row['region_start'])}-{int(row['region_end'])}:{row.get('region_strand', '.')}\",\n", + " axis=1,\n", + " )\n", + " if \"source_label\" not in meta_df.columns:\n", + " meta_df[\"source_label\"] = \"unknown\"\n", + " source_by_region = (\n", + " meta_df.groupby([\"region_id\", \"source_label\"], dropna=False)\n", + " .size()\n", + " .reset_index(name=\"n\")\n", + " .sort_values([\"region_id\", \"n\"], ascending=[True, False])\n", + " .drop_duplicates(subset=[\"region_id\"], keep=\"first\")\n", + " .loc[:, [\"region_id\", \"source_label\"]]\n", + " )\n", + " axis_table = axis_table.merge(source_by_region, on=\"region_id\", how=\"left\")\n", + "\n", + "if \"source_label\" not in axis_table.columns:\n", + " axis_table[\"source_label\"] = \"unknown\"\n", + "axis_table[\"source_label\"] = axis_table[\"source_label\"].fillna(\"unknown\")\n", + "\n", + "# Optional fallback from region overlap for unresolved labels.\n", + "if (\n", + " {\"chrom\", \"start\", \"end\"}.issubset(axis_table.columns)\n", + " and \"ctcf_target_regions\" in globals()\n", + " and \"ctcf_off_target_regions\" in globals()\n", + " and \"_label_regions_from_targets\" in globals()\n", + "):\n", + " unresolved = axis_table[\"source_label\"].isin([\"unknown\", \"unlabeled\"])\n", + " if unresolved.any():\n", + " region_info = [\n", + " (str(row.chrom), int(row.start), int(row.end), str(getattr(row, \"strand\", \".\")))\n", + " for row in axis_table.loc[unresolved].itertuples(index=False)\n", + " ]\n", + " inferred = _label_regions_from_targets(\n", + " region_info,\n", + " on_bed=ctcf_target_regions,\n", + " off_bed=ctcf_off_target_regions,\n", + " mode=\"overlap_any\",\n", + " min_overlap_bp=1,\n", + " )\n", + " axis_table.loc[unresolved, \"source_label\"] = inferred\n", + "\n", + "source_priority = {\"on_target\": 0, \"off_target\": 1, \"unlabeled\": 2, \"unknown\": 3}\n", + "axis_table[\"_source_rank\"] = (\n", + " axis_table[\"source_label\"].map(source_priority).fillna(99).astype(int)\n", + ")\n", + "\n", + "# Final ordering for this tutorial: source bed first, then genomic coordinates.\n", + "axis_sorted = axis_table.sort_values(\n", + " [\"_source_rank\", \"chrom\", \"start\", \"end\"],\n", + " ascending=[True, True, True, True],\n", + ").drop(columns=[\"_source_rank\"]).reset_index(drop=True)\n", + "region_order = axis_sorted[\"region_id\"].tolist()\n", + "\n", + "matrix_table = association_payload_A[\"matrix_table\"].copy()\n", + "matrix_sorted = (\n", + " matrix_table.set_index(\"region_id\")\n", + " .loc[region_order]\n", + " .reset_index()\n", + ")\n", + "\n", + "association_payload_A[\"region_axis_table\"] = axis_sorted\n", + "association_payload_A[\"matrix_table\"] = matrix_sorted\n", + "association_payload_A[\"metadata\"] = {\n", + " **association_payload_A.get(\"metadata\", {}),\n", + " \"region_sort\": \"source_bed_then_genomic\",\n", + "}\n", + "\n", + "print(\"Association payload metadata\")\n", + "display(pd.DataFrame([association_payload_A[\"metadata\"]]))\n", + "print(\"Region axis preview (sorted)\")\n", + "display(axis_sorted[[\"region_id\", \"chrom\", \"start\", \"end\", \"source_label\"]].head())\n", + "print(\"Source label counts\")\n", + "display(axis_sorted[\"source_label\"].value_counts(dropna=False).rename(\"n_regions\"))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Top regions per cluster\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
region_idchromstartendstrandclustercountfractiontotal_readsvaluerank
0chr12:57871837-57871987:-chr125787183757871987-0241.000000241.0000001
1chr12:57871885-57871987:-chr125787188557871987-0241.000000241.0000002
2chr12:57875753-57875855:-chr125787575357875855-0251.000000251.0000003
3chr12:57875753-57875903:-chr125787575357875903-0251.000000251.0000004
4chr14:17377273-17377423:+chr141737727317377423+0231.000000231.0000005
5chr9:145236510-145236828:+chr9145236510145236828+1190.904762210.9047621
6chr9:145236511-145236827:-chr9145236511145236827-1190.904762210.9047622
7chr20:33337048-33337366:-chr203333704833337366-1170.894737190.8947373
8chr2:44484677-44484995:+chr24448467744484995+1190.863636220.8636364
9chr20:33337049-33337365:+chr203333704933337365+1160.842105190.8421055
\n", + "
" + ], + "text/plain": [ + " region_id chrom start end strand cluster \\\n", + "0 chr12:57871837-57871987:- chr12 57871837 57871987 - 0 \n", + "1 chr12:57871885-57871987:- chr12 57871885 57871987 - 0 \n", + "2 chr12:57875753-57875855:- chr12 57875753 57875855 - 0 \n", + "3 chr12:57875753-57875903:- chr12 57875753 57875903 - 0 \n", + "4 chr14:17377273-17377423:+ chr14 17377273 17377423 + 0 \n", + "5 chr9:145236510-145236828:+ chr9 145236510 145236828 + 1 \n", + "6 chr9:145236511-145236827:- chr9 145236511 145236827 - 1 \n", + "7 chr20:33337048-33337366:- chr20 33337048 33337366 - 1 \n", + "8 chr2:44484677-44484995:+ chr2 44484677 44484995 + 1 \n", + "9 chr20:33337049-33337365:+ chr20 33337049 33337365 + 1 \n", + "\n", + " count fraction total_reads value rank \n", + "0 24 1.000000 24 1.000000 1 \n", + "1 24 1.000000 24 1.000000 2 \n", + "2 25 1.000000 25 1.000000 3 \n", + "3 25 1.000000 25 1.000000 4 \n", + "4 23 1.000000 23 1.000000 5 \n", + "5 19 0.904762 21 0.904762 1 \n", + "6 19 0.904762 21 0.904762 2 \n", + "7 17 0.894737 19 0.894737 3 \n", + "8 19 0.863636 22 0.863636 4 \n", + "9 16 0.842105 19 0.842105 5 " + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "association_payload_A[\"top_regions_table\"].head(10)\n" + ] + }, + { + "cell_type": "markdown", + "id": "bddc5271", + "metadata": {}, + "source": [ + "#### Karyotype view of top associated regions\n", + "\n", + "This adds a genome-level view under **Top regions per cluster**:\n", + "- each chromosome is vertical and proportional to true chromosome length,\n", + "- coordinate increases downward (0 near the top, chromosome length near the bottom),\n", + "- loci are colored by cluster assignment, and\n", + "- optional haplotype-aware backbone shading is enabled when maternal/paternal naming is detected.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9c0b1226", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import pandas as pd\n", + "\n", + "from dimelo import cluster\n", + "\n", + "karyotype_chromosome_order = \"natural\" # \"length_desc\" | \"length_asc\" | \"natural\" | custom list\n", + "karyotype_min_visible_bp = 20_000\n", + "karyotype_detect_haplotype_shading = True\n", + "\n", + "matrix_table = association_payload_A[\"matrix_table\"].copy()\n", + "axis_table = association_payload_A[\"region_axis_table\"].copy()\n", + "cluster_columns = [c for c in matrix_table.columns if c != \"region_id\"]\n", + "\n", + "if matrix_table.empty or axis_table.empty or not cluster_columns:\n", + " print(\"No region-association rows available for karyotype plot.\")\n", + "else:\n", + " dominant_cluster = matrix_table.loc[:, cluster_columns].astype(float).idxmax(axis=1).astype(str)\n", + " dominant_by_region = pd.DataFrame({\n", + " \"region_id\": matrix_table[\"region_id\"].astype(str),\n", + " \"cluster\": dominant_cluster,\n", + " })\n", + "\n", + " karyo_table = axis_table.merge(dominant_by_region, on=\"region_id\", how=\"inner\")\n", + " karyo_table[\"name\"] = karyo_table[\"cluster\"].astype(str)\n", + " karyo_table[\"score\"] = 0\n", + " if \"strand\" not in karyo_table.columns:\n", + " karyo_table[\"strand\"] = \".\"\n", + " karyo_table[\"strand\"] = karyo_table[\"strand\"].fillna(\".\")\n", + "\n", + " artifacts_dir = Path(\"artifacts/notebook\")\n", + " artifacts_dir.mkdir(parents=True, exist_ok=True)\n", + "\n", + " karyotype_bed = artifacts_dir / \"association_regions_by_dominant_cluster.bed\"\n", + " karyo_table.loc[:, [\"chrom\", \"start\", \"end\", \"name\", \"score\", \"strand\"]].to_csv(\n", + " karyotype_bed,\n", + " sep=\"\t\",\n", + " header=False,\n", + " index=False,\n", + " )\n", + "\n", + " chrom_sizes_path = None\n", + " if \"ref_genome_file\" in globals():\n", + " ref_path = Path(str(ref_genome_file))\n", + " candidate = ref_path.with_suffix(ref_path.suffix + \".fai\")\n", + " if candidate.exists():\n", + " chrom_sizes_path = candidate\n", + "\n", + " if chrom_sizes_path is None:\n", + " inferred_sizes = (\n", + " karyo_table.groupby(\"chrom\", as_index=False)[\"end\"]\n", + " .max()\n", + " .rename(columns={\"chrom\": \"Chromosome\", \"end\": \"Length\"})\n", + " )\n", + " inferred_sizes[\"Length\"] = (inferred_sizes[\"Length\"] * 1.05).astype(int)\n", + " chrom_sizes_path = artifacts_dir / \"inferred.chrom.sizes\"\n", + " inferred_sizes.to_csv(chrom_sizes_path, sep=\"\t\", header=False, index=False)\n", + "\n", + " fig = cluster.plot_cluster_karyotype(\n", + " region_bed=karyotype_bed,\n", + " chrom_sizes=chrom_sizes_path,\n", + " chromosome_order=karyotype_chromosome_order,\n", + " invert_position_axis=True,\n", + " detect_haplotype_backbone_shading=karyotype_detect_haplotype_shading,\n", + " min_visible_bp=karyotype_min_visible_bp,\n", + " )\n", + "\n", + " print(f\"Wrote karyotype BED to {karyotype_bed}\")\n", + " print(f\"Using chromosome sizes from {chrom_sizes_path}\")\n", + " for chrom in [\"chr9\", \"chr12\", \"chr20\"]:\n", + " n = int((karyo_table[\"chrom\"].astype(str) == chrom).sum())\n", + " print(f\"{chrom}: {n} plotted region(s)\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Association heatmap\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "fig, ax = plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib(\n", + " association_payload_A,\n", + " title=\"Read-cluster association by region (sorted: source bed -> genomic)\",\n", + " region_label_mode=\"chromosome\",\n", + " max_region_labels=24,\n", + " row_annotation_column=\"source_label\",\n", + " row_annotation_title=\"Source bed\",\n", + " row_annotation_palette={\n", + " \"on_target\": \"#D95F02\",\n", + " \"off_target\": \"#1B9E77\",\n", + " \"unlabeled\": \"#7570B3\",\n", + " \"unknown\": \"#999999\",\n", + " },\n", + " group_region_labels=True,\n", + " group_label_columns=[\"source_label\", \"chrom\"],\n", + ")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Export" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For some use cases, such as loading pileup information into a genome browser, it can be desireable to create files with less information content than the full bedmethyls. The `export` module contains functions to do these sorts of exports. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dimelo/test/output/ctcf_demo_pileup_on_target/pileup.sorted.bed.gz\n", + "dimelo/test/output/chm13.draft_v1.0.fasta\n" + ] + } + ], + "source": [ + "pileup_file = 'dimelo/test/output/ctcf_demo_pileup_on_target/pileup.sorted.bed.gz'\n", + "ref_genome_file = 'dimelo/test/output/chm13.draft_v1.0.fasta'\n", + "print(pileup_file)\n", + "print(ref_genome_file)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a85e91c8cf3948b5bee38f190df7e898", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Step 1: Indexing contigs in pileup.sorted.bed.gz to set up bigwig header for pileup.fractions.bigwig: 0%| \u2026" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "170c2c79356e495e985dcce8d773153f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Indexing chr1.: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cb1ea1cf21a64a019609fcd304558236", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Indexing chr12.: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ac828e27245b4d36a6d10c1e0ffaf8b6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Indexing chr14.: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c6059480d63440298b2059deb9b67ef6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Indexing chr15.: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "38672117e5af493cbf99a81b093d0f75", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Indexing chr16.: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0b247661073b4a18827d21d4503f11fa", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Indexing chr17.: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6f71eb588552492fa74744d98fd8518b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Indexing chr19.: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "906b8f4b2a324d7c97f6e16d8a285052", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Indexing chr2.: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4a7d2c3a5a364b5ca236e25c0fef2070", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Indexing chr20.: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "37dca57a7d7944c49b494f0f5d6abab4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Indexing chr21.: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4affe992946b4b9499b4380450ad4fb7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Indexing chr3.: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a1484a3a698f4ac18b5f8d4efb4c3039", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Indexing chr5.: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "778c9abd083740679fdd7ff41594ab04", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Indexing chr6.: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "112e59a192494ea1927af3a38e738a2a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Indexing chr7.: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b4c19e4460694ba996b60e5a93e67b60", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Indexing chr8.: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6bc03339e6514195a91907ca1d868cfd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Indexing chr9.: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9c766b687a45474da11a677373de6b96", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Indexing chrX.: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e7f7fcc9fd37427385b8258edbe7a28b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Step 2: Writing pileup.sorted.bed.gz contents to pileup.fractions.bigwig: 0%| | 0/17 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sort_by = ['chromosome','region_start'] # you can sort reads also!\n", + "plot_reads.plot_reads(\n", + " mod_file_name=extract_file_no_thresh,\n", + " regions=ctcf_target_regions,\n", + " motifs=['A,0', 'CG,0'],\n", + " window_size=1000,\n", + " single_strand=False, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", + " regions_5to3prime=True, # if set to True, regions on the reverse (-) strand will be flipped so everything is 5 prime to 3 prime\n", + " thresh=190,\n", + " sort_by=sort_by,\n", + " s=2, \n", + ")\n", + "plt.title(f'CTCF target data, 100 known binding locations\\nsort_by={sort_by}')\n", + "plt.xlabel('position relative to annotated CTCF site')\n", + "plt.ylabel('reads')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Manually Loading Processed Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load sum total modified/valid base read counts by genomic regions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from dimelo import load_processed" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6eee32d678974206800070b0d856c773", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading data: 0%| | 0/50 [00:00" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from dimelo import plot_enrichment_profile\n", + "plot_enrichment_profile.by_modification(\n", + " mod_file_name=pileup_file_coded,\n", + " regions=ctcf_target_regions,\n", + " window_size=1000,\n", + " motifs=['A,0,a','CG,0,m'], # We know from above that these mod codes aren't present in our file!\n", + " single_strand=False, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", + " regions_5to3prime=False, # if set to True, regions on the reverse (-) strand will be flipped so everything is 5 prime to 3 prime\n", + " smooth_window=50,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `modkit` command below will make the bam file work for the to-spec mod codes m and a. However, you must use this command with caution: `modkit` can and will adjust any mod code to any other mod code; you need to verify yourself that they are actually equivalent and thus that the operation is in fact valid." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "run_modkit_checked([\n", + " \"adjust-mods\",\n", + " \"dimelo/test/output/ctcf_demo.updated.bam\",\n", + " \"dimelo/test/output/ctcf_demo.recoded.bam\",\n", + " \"--convert\",\n", + " \"Y\",\n", + " \"a\",\n", + " \"--convert\",\n", + " \"Z\",\n", + " \"m\",\n", + "])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "''" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ctcf_bam_file_recoded = output_dir / 'ctcf_demo.recoded.bam'\n", + "pysam.index(str(ctcf_bam_file_recoded))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pileup_file_recoded, pileup_regions = parse_bam.pileup(\n", + " input_file=ctcf_bam_file_recoded,\n", + " output_name='ctcf_demo_pileup_on_target_mod_code_specified_adjusted',\n", + " ref_genome=ref_genome_file,\n", + " output_directory=output_dir,\n", + " regions=[ctcf_target_regions,ctcf_off_target_regions],\n", + " # motifs=['A,0','CG,0'],\n", + " # parsing can optionally specify mod codes. \n", + " # The default is Y or a for adenine and m or Z for cytosine, corresponding to methylation\n", + " motifs = ['A,0,a','CG,0,m'], \n", + " thresh=190,\n", + " window_size=1000,\n", + " # cores = 1, # uncomment this line if your process appears to be terminating early (reduces memory usage)\n", + " # quiet = True,\n", + " # cleanup = False,\n", + " # log=True,\n", + " modkit_executable=MODKIT_BINARY,\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d93bed01607e4fa482ad1dc0fc4d902d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading data: 0%| | 0/50 [00:00" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from dimelo import plot_enrichment_profile\n", + "plot_enrichment_profile.by_modification(\n", + " mod_file_name=pileup_file_recoded,\n", + " regions=ctcf_target_regions,\n", + " window_size=1000,\n", + " motifs=['A,0,a','CG,0,m'],\n", + " single_strand=False, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", + " regions_5to3prime=False, # if set to True, regions on the reverse (-) strand will be flipped so everything is 5 prime to 3 prime\n", + " smooth_window=50,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d54a6201", + "metadata": {}, + "outputs": [], + "source": [ + "# Two-window raster demo\n", + "# What it does:\n", + "# - selects window pairs from the same read,\n", + "# - keeps row sorting matched across motifs,\n", + "# - renders either scatter or heatmap panels.\n", + "#\n", + "# Flexible window specification options:\n", + "# 1) spacing-driven: n_windows + min_separation_bp\n", + "# 2) center-driven: window_center_offsets in primary-region coordinates\n", + "\n", + "raster_render_mode = \"scatter\" # \"scatter\" | \"heatmap\"\n", + "raster_x_axis_mode = \"relative_to_primary\" # \"relative_to_primary\" | \"centered\"\n", + "raster_plot_all_motifs = True\n", + "raster_window_centers = [0, 2000]\n", + "raster_center_tolerance_bp = 800\n", + "show_heatmap_variant = True\n", + "\n", + "try:\n", + " fig, stats = cluster.plot_multisite_read_raster(\n", + " read_windows=rw_multi,\n", + " motif_index=0,\n", + " motif_count=2,\n", + " plot_all_motifs=raster_plot_all_motifs,\n", + " motif_labels=[\"A,0\", \"CG,0\"],\n", + " window_center_offsets=raster_window_centers,\n", + " center_tolerance_bp=raster_center_tolerance_bp,\n", + " smoothing=\"gaussian\",\n", + " render_mode=raster_render_mode,\n", + " x_axis_mode=raster_x_axis_mode,\n", + " scatter_size=5.0,\n", + " scatter_alpha=0.75,\n", + " )\n", + "except ValueError as exc:\n", + " print(f\"Center-driven window selection failed ({exc}); using spacing-driven selection.\")\n", + " fig, stats = cluster.plot_multisite_read_raster(\n", + " read_windows=rw_multi,\n", + " motif_index=0,\n", + " motif_count=2,\n", + " plot_all_motifs=raster_plot_all_motifs,\n", + " motif_labels=[\"A,0\", \"CG,0\"],\n", + " n_windows=2,\n", + " min_separation_bp=1800,\n", + " smoothing=\"gaussian\",\n", + " render_mode=raster_render_mode,\n", + " x_axis_mode=raster_x_axis_mode,\n", + " scatter_size=5.0,\n", + " scatter_alpha=0.75,\n", + " )\n", + "print(\"Two-window raster stats:\", stats)\n", + "\n", + "if show_heatmap_variant:\n", + " fig_hm, stats_hm = cluster.plot_multisite_read_raster(\n", + " read_windows=rw_multi,\n", + " motif_index=0,\n", + " motif_count=2,\n", + " plot_all_motifs=raster_plot_all_motifs,\n", + " motif_labels=[\"A,0\", \"CG,0\"],\n", + " n_windows=2,\n", + " min_separation_bp=1800,\n", + " smoothing=\"gaussian\",\n", + " render_mode=\"heatmap\",\n", + " x_axis_mode=\"centered\",\n", + " )\n", + " print(\"Heatmap variant stats:\", stats_hm)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Three-site raster demo (`-2500`, `0`, `+2500`)\n", + "\n", + "This example uses explicit centers (`window_center_offsets=[-2500, 0, 2500]`) to select three windows from the same read.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "try:\n", + " fig3, stats3 = cluster.plot_multisite_read_raster(\n", + " read_windows=rw_multi,\n", + " motif_index=0,\n", + " motif_count=2,\n", + " plot_all_motifs=True,\n", + " motif_labels=[\"A,0\", \"CG,0\"],\n", + " window_center_offsets=[-2000, 0, 2000],\n", + " center_tolerance_bp=1000,\n", + " render_mode=\"scatter\",\n", + " x_axis_mode=\"relative_to_primary\",\n", + " smoothing=\"gaussian\",\n", + " scatter_size=4.5,\n", + " scatter_alpha=0.65,\n", + " )\n", + "except ValueError as exc:\n", + " print(f\"Center-driven 3-window selection failed ({exc}); using spacing-driven selection.\")\n", + " fig3, stats3 = cluster.plot_multisite_read_raster(\n", + " read_windows=rw_multi,\n", + " motif_index=0,\n", + " motif_count=2,\n", + " plot_all_motifs=True,\n", + " motif_labels=[\"A,0\", \"CG,0\"],\n", + " n_windows=3,\n", + " min_separation_bp=1800,\n", + " render_mode=\"scatter\",\n", + " x_axis_mode=\"relative_to_primary\",\n", + " smoothing=\"gaussian\",\n", + " scatter_size=4.5,\n", + " scatter_alpha=0.65,\n", + " )\n", + "print(\"Three-window raster stats:\", stats3)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dimelo-toolkit", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/dmr_multi_sample.ipynb b/dmr_multi_sample.ipynb new file mode 100644 index 0000000..d1e71d6 --- /dev/null +++ b/dmr_multi_sample.ipynb @@ -0,0 +1,122 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# modkit DMR multi-sample tutorial\n", + "\n", + "This notebook is for multi-sample DMR analyses using native `modkit dmr` wrappers in `dimelo.workflows`.\n" + ] + }, + { + "cell_type": "code", + "metadata": {}, + "execution_count": null, + "outputs": [], + "source": [ + "import importlib\n", + "from pathlib import Path\n", + "from dimelo import run_modkit, workflows\n", + "\n", + "importlib.reload(run_modkit)\n", + "importlib.reload(workflows)\n", + "run_modkit._get_modkit_capabilities_cached.cache_clear()\n", + "caps = run_modkit.get_modkit_capabilities()\n", + "print(caps.version_raw)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example inputs\n", + "\n", + "Set these to your sample pileup bedMethyl outputs (`*.bed.gz`) and reference FASTA.\n" + ] + }, + { + "cell_type": "code", + "metadata": {}, + "execution_count": null, + "outputs": [], + "source": [ + "ref_genome = Path(\"dimelo/test/output/chm13.draft_v1.0.fasta\")\n", + "regions_bed = Path(\"dimelo/test/data/ctcf_demo_peak.bed\")\n", + "sample_pileups = {\n", + " \"sample_a\": Path(\"path/to/sample_a.pileup.sorted.bed.gz\"),\n", + " \"sample_b\": Path(\"path/to/sample_b.pileup.sorted.bed.gz\"),\n", + " # \"sample_c\": Path(\"path/to/sample_c.pileup.sorted.bed.gz\"),\n", + "}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Pairwise DMR + HMM segmentation\n", + "\n", + "Use this when you want single-site beta-binomial statistics plus segmented DMR blocks.\n" + ] + }, + { + "cell_type": "code", + "metadata": {}, + "execution_count": null, + "outputs": [], + "source": [ + "pair_result = workflows.modkit_dmr_pair_workflow(\n", + " control_bed_methyl=sample_pileups[\"sample_a\"],\n", + " experiment_bed_methyl=sample_pileups[\"sample_b\"],\n", + " ref_genome=ref_genome,\n", + " out_path=\"artifacts/dmr/sample_a_vs_sample_b.sites.bed\",\n", + " segment_path=\"artifacts/dmr/sample_a_vs_sample_b.segments.bed\",\n", + " bases=[\"A\"],\n", + " threads=4,\n", + ")\n", + "print(pair_result.output_path)\n", + "print(pair_result.segment_path)\n", + "display(pair_result.high_confidence_sites.head())\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Multi-sample regional DMR\n", + "\n", + "`modkit dmr multi` requires a region BED and emits all-vs-all pair BED outputs.\n" + ] + }, + { + "cell_type": "code", + "metadata": {}, + "execution_count": null, + "outputs": [], + "source": [ + "multi_result = workflows.modkit_dmr_multi_workflow(\n", + " samples=sample_pileups,\n", + " regions_bed=regions_bed,\n", + " ref_genome=ref_genome,\n", + " out_dir=\"artifacts/dmr/multi\",\n", + " bases=[\"A\"],\n", + " threads=4,\n", + ")\n", + "display(multi_result.pair_files)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/docs/benchmarks/hdf5_openzl_compression_benchmark.py b/docs/benchmarks/hdf5_openzl_compression_benchmark.py new file mode 100644 index 0000000..46e4ef7 --- /dev/null +++ b/docs/benchmarks/hdf5_openzl_compression_benchmark.py @@ -0,0 +1,334 @@ +#!/usr/bin/env python3 +"""Benchmark HDF5 vs OpenZL for dimelo-toolkit intermediate read data. + +This script is intended as a local/private benchmark harness. It compares the +existing HDF5 read/write path with an optional OpenZL-backed serialization path. +The OpenZL benchmark is only enabled if an importable `openzl` package is available. +""" + +from __future__ import annotations + +import argparse +import gzip +import json +import pickle +import time +from pathlib import Path +from typing import Any + +import h5py +import numpy as np + +try: + import openzl +except ImportError: # pragma: no cover + openzl = None + +from dimelo.load_processed import read_vectors_from_hdf5 + + +DEFAULT_MOTIFS = ["A,0", "CG,0"] + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser( + description="Benchmark HDF5 and OpenZL compression performance for dimelo intermediate data." + ) + parser.add_argument( + "--output-dir", + type=Path, + default=Path("docs/benchmarks/tmp_bench"), + help="Directory to write benchmark outputs.", + ) + parser.add_argument( + "--benchmark-hdf5", + action="store_true", + help="Run the HDF5 benchmark.", + ) + parser.add_argument( + "--benchmark-openzl", + action="store_true", + help="Run the OpenZL benchmark if available.", + ) + parser.add_argument( + "--use-synthetic-data", + action="store_true", + help="Use synthetic sample data instead of trying to ingest a real sample file.", + ) + parser.add_argument( + "--num-reads", + type=int, + default=200, + help="Number of synthetic reads to generate for the benchmark.", + ) + parser.add_argument( + "--save-results", + action="store_true", + help="Save benchmark results to benchmark_results.json.", + ) + return parser.parse_args() + + +def ensure_directory(path: Path) -> Path: + path.mkdir(parents=True, exist_ok=True) + return path + + +def compress_uint8_vector(data: np.ndarray, compress_level: int = 1) -> bytes: + return gzip.compress(np.asarray(data, dtype=np.uint8).tobytes(), compresslevel=compress_level) + + +def generate_synthetic_data(num_reads: int) -> dict[str, list[Any]]: + data = { + "read_name": [], + "chromosome": [], + "read_start": [], + "read_end": [], + "strand": [], + "motif": [], + "mod_vector": [], + "val_vector": [], + } + start_position = 0 + for read_index in range(num_reads): + read_length = int(40 + 20 * (read_index % 4)) + read_name = f"read_{read_index:06d}" + motif = DEFAULT_MOTIFS[read_index % len(DEFAULT_MOTIFS)] + strand = "+" if (read_index % 2 == 0) else "-" + chromosome = "chr1" + read_start = start_position + read_end = read_start + read_length + start_position += read_length // 2 + + mod_vector = np.zeros(read_length, dtype=np.uint8) + val_vector = np.zeros(read_length, dtype=np.uint8) + positions = np.arange(0, read_length, 5) + mod_vector[positions] = np.random.randint(0, 255, size=len(positions), dtype=np.uint8) + val_vector[positions] = 1 + + data["read_name"].append(read_name) + data["chromosome"].append(chromosome) + data["read_start"].append(read_start) + data["read_end"].append(read_end) + data["strand"].append(strand) + data["motif"].append(motif) + data["mod_vector"].append(compress_uint8_vector(mod_vector, compress_level=1)) + data["val_vector"].append(compress_uint8_vector(val_vector, compress_level=1)) + + return data + + +def write_hdf5_direct( + data: dict[str, list[Any]], + output_h5: Path, + compress_level: int = 1, +) -> dict[str, Any]: + start = time.perf_counter() + with h5py.File(output_h5, "w") as h5: + dt_str = h5py.string_dtype(encoding="utf-8") + dt_vlen = h5py.vlen_dtype(np.dtype("uint8")) + + h5.create_dataset("threshold", data=np.array(np.nan), dtype="f8") + h5.create_dataset( + "read_name", + data=np.asarray(data["read_name"], dtype=dt_str), + dtype=dt_str, + compression="gzip", + compression_opts=9, + ) + h5.create_dataset( + "chromosome", + data=np.asarray(data["chromosome"], dtype=dt_str), + dtype=dt_str, + compression="gzip", + compression_opts=9, + ) + h5.create_dataset( + "read_start", + data=np.asarray(data["read_start"], dtype="i"), + dtype="i", + compression="gzip", + compression_opts=9, + ) + h5.create_dataset( + "read_end", + data=np.asarray(data["read_end"], dtype="i"), + dtype="i", + compression="gzip", + compression_opts=9, + ) + h5.create_dataset( + "strand", + data=np.asarray(data["strand"], dtype=dt_str), + dtype=dt_str, + compression="gzip", + compression_opts=9, + ) + h5.create_dataset( + "motif", + data=np.asarray(data["motif"], dtype=dt_str), + dtype=dt_str, + compression="gzip", + compression_opts=9, + ) + h5.create_dataset( + "mod_vector", + shape=(len(data["mod_vector"]),), + maxshape=(None,), + dtype=dt_vlen, + data=None, + ) + h5["mod_vector"][:] = [np.frombuffer(b, dtype=np.uint8) for b in data["mod_vector"]] + h5.create_dataset( + "val_vector", + shape=(len(data["val_vector"]),), + maxshape=(None,), + dtype=dt_vlen, + data=None, + ) + h5["val_vector"][:] = [np.frombuffer(b, dtype=np.uint8) for b in data["val_vector"]] + end = time.perf_counter() + return { + "write_time": end - start, + "file_size": output_h5.stat().st_size, + "path": str(output_h5), + } + + +def read_hdf5_via_dimelo(output_h5: Path, motifs: list[str]) -> dict[str, Any]: + start = time.perf_counter() + records, datasets, _ = read_vectors_from_hdf5( + file=output_h5, + motifs=motifs, + regions=None, + calculate_mod_fractions=False, + quiet=True, + ) + elapsed = time.perf_counter() - start + return { + "read_time": elapsed, + "records": len(records), + "datasets": datasets, + } + + +def openzl_available() -> bool: + return openzl is not None + + +def compress_with_openzl(payload: bytes) -> bytes: + if not openzl_available(): + raise RuntimeError("OpenZL is not installed") + if hasattr(openzl, "compress"): + return openzl.compress(payload) + if hasattr(openzl, "compress_bytes"): + return openzl.compress_bytes(payload) + raise RuntimeError("Unsupported OpenZL API: no compress() or compress_bytes()") + + +def decompress_with_openzl(payload: bytes) -> bytes: + if not openzl_available(): + raise RuntimeError("OpenZL is not installed") + if hasattr(openzl, "decompress"): + return openzl.decompress(payload) + if hasattr(openzl, "decompress_bytes"): + return openzl.decompress_bytes(payload) + raise RuntimeError("Unsupported OpenZL API: no decompress() or decompress_bytes()") + + +def write_openzl_standalone( + data: dict[str, list[Any]], output_file: Path +) -> dict[str, Any]: + if not openzl_available(): + return { + "status": "skipped", + "error": "OpenZL package not installed", + } + payload = pickle.dumps(data, protocol=pickle.HIGHEST_PROTOCOL) + start = time.perf_counter() + compressed = compress_with_openzl(payload) + output_file.write_bytes(compressed) + elapsed = time.perf_counter() - start + return { + "write_time": elapsed, + "file_size": output_file.stat().st_size, + "path": str(output_file), + } + + +def read_openzl_standalone(output_file: Path) -> dict[str, Any]: + if not openzl_available(): + return { + "status": "skipped", + "error": "OpenZL package not installed", + } + payload = output_file.read_bytes() + start = time.perf_counter() + decompressed = decompress_with_openzl(payload) + data = pickle.loads(decompressed) + elapsed = time.perf_counter() - start + return { + "read_time": elapsed, + "record_count": len(data.get("read_name", [])), + "dataset_keys": sorted(data.keys()), + } + + +def compare_results(results: list[dict[str, Any]], output_dir: Path) -> None: + print("\nBenchmark results") + print("-----------------") + for result in results: + print(json.dumps(result, indent=2, sort_keys=True)) + results_path = output_dir / "benchmark_results.json" + with results_path.open("w", encoding="utf-8") as handle: + json.dump(results, handle, indent=2) + print(f"Saved results to: {results_path}") + + +def main() -> None: + args = parse_args() + output_dir = ensure_directory(args.output_dir) + data = generate_synthetic_data(args.num_reads) + + results: list[dict[str, Any]] = [] + if args.benchmark_hdf5: + hdf5_path = output_dir / "benchmark_data.h5" + write_metrics = write_hdf5_direct(data, hdf5_path, compress_level=1) + read_metrics = read_hdf5_via_dimelo(hdf5_path, motifs=DEFAULT_MOTIFS) + results.append( + { + "format": "HDF5+gzip", + **write_metrics, + **read_metrics, + "status": "success", + } + ) + + if args.benchmark_openzl: + openzl_path = output_dir / "benchmark_data.openzl" + write_metrics = write_openzl_standalone(data, openzl_path) + read_metrics: dict[str, Any] = {} + if write_metrics.get("status") != "skipped": + read_metrics = read_openzl_standalone(openzl_path) + results.append( + { + "format": "OpenZL standalone", + **write_metrics, + **read_metrics, + } + ) + + if not results: + print("No benchmark selected. Use --benchmark-hdf5, --benchmark-openzl, or both.") + return + + if args.save_results: + compare_results(results, output_dir) + else: + print("\nResults summary") + for result in results: + print(f"- {result['format']}: {result.get('write_time', 'n/a'):.4f}s write, {result.get('read_time', 'n/a'):.4f}s read, {result.get('file_size', 'n/a')} bytes") + + +if __name__ == "__main__": + main() diff --git a/docs/modkit-dmr.md b/docs/modkit-dmr.md new file mode 100644 index 0000000..760d9bd --- /dev/null +++ b/docs/modkit-dmr.md @@ -0,0 +1,58 @@ +# modkit DMR Workflows + +`dimelo` now exposes native wrappers for `modkit dmr` so region discovery and differential methylation can be driven directly by ONT's maintained DMR implementation. + +## Pairwise DMR (+ optional HMM segmentation) + +Use `workflows.modkit_dmr_pair_workflow(...)` (or `dimelo.dmr.run_dmr_pair(...)`) for two-sample comparison. + +- Site-level output includes `map_pvalue` and `effect_size` columns from `modkit dmr pair`. +- Optional HMM segmentation is enabled by passing `segment_path=...`. +- `regions_bed` and `segment_path` are mutually exclusive in a single run because `modkit dmr pair` enforces that constraint. + +Example: + +```python +from dimelo import workflows + +result = workflows.modkit_dmr_pair_workflow( + control_bed_methyl="sample_a.pileup.sorted.bed.gz", + experiment_bed_methyl="sample_b.pileup.sorted.bed.gz", + ref_genome="ref.fa", + out_path="dmr_sites.bed", + segment_path="dmr_segments.bed", + bases=["A"], + threads=8, +) + +print(result.sites.head()) +print(result.segments.head()) +print(result.high_confidence_sites.head()) +``` + +## Multi-sample regional DMR + +Use `workflows.modkit_dmr_multi_workflow(...)` when comparing all sample pairs over a fixed region BED. + +Example: + +```python +multi = workflows.modkit_dmr_multi_workflow( + samples={ + "s1": "s1.pileup.sorted.bed.gz", + "s2": "s2.pileup.sorted.bed.gz", + "s3": "s3.pileup.sorted.bed.gz", + }, + regions_bed="regions.bed", + ref_genome="ref.fa", + out_dir="dmr_multi", + bases=["A"], + threads=8, +) + +print(multi.pair_files) +``` + +If you already use `SampleSpec`, you can route through: + +`workflows.modkit_dmr_multi_from_samples_workflow(...)` (reads `sample.metadata["pileup_path"]`). diff --git a/docs/region-discovery.md b/docs/region-discovery.md index cd439b7..c15f84f 100644 --- a/docs/region-discovery.md +++ b/docs/region-discovery.md @@ -100,10 +100,11 @@ For broad whole-sample summaries instead of locus discovery, use [global analysi - For formal region testing, convert discovered hits into BED and write them to disk before passing the BED path into `region_contrasts.score_regions(...)`. - This handoff works the same for paired discovery outputs; the paired score columns stay in `result.hits`, while `hits_to_bed()` projects the ranked loci into a plain BED table for downstream region testing. -- For downstream clustering, use the discovered loci to focus the region set before running the clustering workflow. +- For downstream clustering, the recommended next step is read-window clustering on the discovered loci, followed by region-level occupancy follow-up from the resulting read-cluster labels. +- If you specifically want shape-based exploratory analysis, you can still pass the discovered loci into the optional `mode="region_anchored"` workflow. - Keep discovery and contrast roles separate: discovery finds candidates, contrasts tests known regions, and clustering explains state mixtures. -The combined discovery-to-clustering workflow uses the same handoff, but keeps it in memory: +The combined discovery-to-clustering workflow uses the same handoff, but keeps it in memory. It is most useful when you explicitly want the optional region-anchored exploratory path on discovery hits: - discovery produces ranked hit rows - `hits_to_bed()` turns those rows into BED-style `selected_regions` diff --git a/docs/roadmap-2026-04-wrapup.md b/docs/roadmap-2026-04-wrapup.md new file mode 100644 index 0000000..79ae3df --- /dev/null +++ b/docs/roadmap-2026-04-wrapup.md @@ -0,0 +1,85 @@ +# Dimelo Toolkit Wrap-up And Roadmap (April 2026) + +## What Was Completed + +### 1) Native `modkit dmr` integration +- Added `dimelo.dmr` with native wrappers for: + - pairwise DMR (`run_dmr_pair`) + - multi-sample DMR (`run_dmr_multi`) +- Added support for: + - optional HMM segmentation output in pair mode + - high-confidence site filtering from pair outputs + - direct pass-through of core `modkit dmr` controls (threads, priors, segmentation knobs, coverage constraints, etc.) + +### 2) Workflow-level API integration +- Added new workflow entry points: + - `workflows.modkit_dmr_pair_workflow` + - `workflows.modkit_dmr_multi_workflow` + - `workflows.modkit_dmr_multi_from_samples_workflow` (uses `SampleSpec.metadata["pileup_path"]`) + +### 3) New result models +- Added: + - `ModkitDMRPairResult` + - `ModkitDMRMultiResult` +- Exported via package root. + +### 4) Parse reliability fixes for mixed modkit versions in notebooks +- Hardened `run_modkit` capability caching to invalidate when executable file changes in-place. +- Hardened `parse_bam` pileup targeting so modkit 0.6+ always builds `--modified-bases` path even if stale capability flags are encountered. +- Added/updated regression tests for both. + +### 5) Notebook strategy updates +- Kept `dimelo_test.ipynb` focused on single-sample analysis. +- Added `dmr_multi_sample.ipynb` as a separate multi-sample DMR template notebook. +- Added notebook-side modkit cache reset/reload and executable pinning patterns to reduce kernel-state drift. + +### 6) Documentation updates +- Added `docs/modkit-dmr.md`. +- Updated README analysis guide references and DMR workflow notes. + +### 7) Test coverage added +- New/updated tests across: + - `tests/test_dmr.py` + - `tests/test_workflows.py` + - `tests/test_models.py` + - `tests/test_parse_bam.py` + - `tests/test_run_modkit.py` + + +## Known Current Constraints + +1. `modkit dmr pair` does not allow `--regions-bed` together with `--segment` in a single invocation. +2. Historical bedMethyl files generated by older modkit output schemas may fail modern `modkit dmr` validation. +3. Some demo BAMs still trigger early motif-warning messages (first-100-read motif scan), even when downstream processing succeeds. + + +## Remaining Work + +### High priority +1. Replace exploratory region-discovery notebook paths with a `modkit dmr`-first multi-sample tutorial using real replicate inputs. +2. Add plotting/prep helpers for DMR outputs (site and segment summaries) in `plotting`/`plotting_matplotlib`. +3. Add end-to-end integration tests that run parse -> pileup -> dmr workflow in a deterministic small fixture. + +### Medium priority +1. Add a convenience utility that auto-runs both pair modes when user requests both region-level + segmentation results. +2. Add optional schema normalization for legacy bedMethyl data prior to DMR calls. +3. Expand docs with recommended DMR parameter presets for: + - high-sensitivity segmentation + - high-specificity site calling + - sparse-coverage datasets + +### Lower priority +1. Add richer metadata/provenance outputs to DMR results (input hashes, command runtime, elapsed time). +2. Add optional artifact registration for DMR outputs in workflow provenance tables. + + +## Next Session Quick-start Checklist + +1. Activate the environment and confirm modkit: + - `modkit --version` +2. In notebooks, run cache-reset/reload cell before parse calls if modkit changed. +3. Use `dimelo_test.ipynb` only for single-sample parsing/clustering examples. +4. Use `dmr_multi_sample.ipynb` for multi-sample DMR. +5. Continue roadmap from: + - DMR plotting layer implementation + - full multi-sample tutorial with real sample set diff --git a/docs/shared-clustering.md b/docs/shared-clustering.md index 06c1ab3..e6a3bb0 100644 --- a/docs/shared-clustering.md +++ b/docs/shared-clustering.md @@ -4,8 +4,9 @@ ## Preprocessing Choices +- Recommended default: run `parse_bam.extract()`, cluster read windows, then summarize the resulting read-cluster labels at the region level with `SharedClusterResult.region_summaries` and `region_contrasts.score_regions(..., analysis_unit="cluster_occupancy")`. - Run `parse_bam.extract()` when you want read-level clustering or single-read pattern analysis. -- Run `parse_bam.pileup()` when you want matched-region clustering from pileup-derived summaries. +- Run `parse_bam.pileup()` when you specifically want matched-region or shape-based exploratory clustering from pileup-derived summaries. - Run both when you want region-level summaries plus read-level follow-up on the same samples. ## Workflow Entry Point @@ -27,7 +28,9 @@ result = workflows.shared_cluster_distribution( ) ``` -### Region-anchored clustering +### Optional region-anchored clustering + +Use this when you want region-aligned exploratory clustering on pileup-derived summaries rather than the recommended read-window-first workflow. ```python from dimelo import workflows @@ -258,9 +261,9 @@ Inference boundary: ## Current V1 Scope - `mode="read_global"` supports shared read clustering from extract outputs. -- `mode="region_anchored"` supports matched-region clustering from pileup-derived region vectors. -- `discovery_cluster_workflow()` composes discovery and `region_anchored` clustering by passing derived matched regions into this workflow. -- `discovery_cluster_contrast_workflow()` composes discovery, `region_anchored` clustering, and defined-region contrasts on the selected loci by default, with an explicit custom contrast-region override. -- `result.region_summaries` is the v1 handoff table for `cluster_occupancy` region contrasts. +- `mode="region_anchored"` supports optional matched-region exploratory clustering from pileup-derived region vectors. +- `discovery_cluster_workflow()` composes discovery and optional `region_anchored` clustering by passing derived matched regions into this workflow. +- `discovery_cluster_contrast_workflow()` composes discovery, optional `region_anchored` clustering, and defined-region contrasts on the selected loci by default, with an explicit custom contrast-region override. +- `result.region_summaries` is the v1 handoff table for `cluster_occupancy` region contrasts after read-window clustering. - The default supported clusterer is `minibatch_kmeans`. - Results are data-first: tables are the stable contract, while plotting is optional. diff --git a/environment.yml b/environment.yml index d74efd5..f57a32e 100644 --- a/environment.yml +++ b/environment.yml @@ -1,8 +1,13 @@ name: dimelo-toolkit channels: - conda-forge + - bioconda - nanoporetech - defaults dependencies: - python=3.11 - - nanoporetech::modkit==0.2.4 \ No newline at end of file + - pip + - libcurl + # Conservative default pin; runtime supports both 0.2.4 and 0.6.x. + - nanoporetech::modkit==0.2.4 + - bioconda::crossmap=0.7.3 diff --git a/modkit_update_tests.ipynb b/modkit_update_tests.ipynb new file mode 100644 index 0000000..9003c44 --- /dev/null +++ b/modkit_update_tests.ipynb @@ -0,0 +1,436 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "36fd64e1", + "metadata": {}, + "source": [ + "# Modkit Update Testing: v0.2.4 vs v0.6.1\n", + "\n", + "This notebook systematically tests the compatibility and performance of updating modkit from the pinned version (0.2.4) to the latest (0.6.1) in the dimelo toolkit.\n", + "\n", + "## Objectives\n", + "- Compare raw modkit outputs for pileup and extract commands\n", + "- Test dimelo integration (parse_bam functions and plotting)\n", + "- Measure performance improvements\n", + "- Identify any breaking changes or incompatibilities\n", + "\n", + "## Setup\n", + "First, ensure both modkit versions are available. We'll modify the environment to allow switching between versions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3b970ec8", + "metadata": {}, + "outputs": [], + "source": [ + "# Notebook setup (autonomous, no in-cell environment mutation)\n", + "import json\n", + "import gzip\n", + "import hashlib\n", + "import re\n", + "import shutil\n", + "import subprocess\n", + "import time\n", + "from glob import glob\n", + "from pathlib import Path\n", + "from typing import Dict, List, Tuple\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "# Optional plotting style\n", + "try:\n", + " import seaborn as sns # type: ignore\n", + " sns.set_style(\"whitegrid\")\n", + "except Exception:\n", + " pass\n", + "\n", + "plt.rcParams[\"figure.figsize\"] = (11, 6)\n", + "\n", + "ROOT = Path(\".\").resolve()\n", + "TEST_DATA_DIR = ROOT / \"dimelo\" / \"test\" / \"data\"\n", + "BAM_FILE = TEST_DATA_DIR / \"ctcf_demo.sorted.bam\"\n", + "BAM_INDEX = TEST_DATA_DIR / \"ctcf_demo.sorted.bam.bai\"\n", + "OUTPUT_DIR = ROOT / \"cache\" / \"modkit_benchmark\"\n", + "OUTPUT_DIR.mkdir(parents=True, exist_ok=True)\n", + "\n", + "BENCH_REGION = \"chr1\"\n", + "THREADS = 2\n", + "BENCH_RUNS = 3\n", + "\n", + "if not BAM_FILE.exists() or not BAM_INDEX.exists():\n", + " raise FileNotFoundError(f\"Missing BAM test assets under {TEST_DATA_DIR}\")\n", + "\n", + "print(f\"BAM: {BAM_FILE}\")\n", + "print(f\"Output dir: {OUTPUT_DIR}\")\n", + "print(f\"Region benchmark target: {BENCH_REGION}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "9819cca5", + "metadata": {}, + "source": [ + "## Modkit Version Management\n", + "\n", + "We'll create a way to switch between modkit versions by temporarily modifying the PATH." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a9935c54", + "metadata": {}, + "outputs": [], + "source": [ + "def _parse_modkit_version(text: str) -> str | None:\n", + " match = re.search(r\"(\\d+\\.\\d+\\.\\d+)\", text)\n", + " return match.group(1) if match else None\n", + "\n", + "\n", + "def discover_modkit_versions() -> Dict[str, str]:\n", + " \"\"\"Discover installed modkit binaries and map version -> binary path.\"\"\"\n", + " candidates: set[str] = set()\n", + "\n", + " active = shutil.which(\"modkit\")\n", + " if active:\n", + " candidates.add(active)\n", + "\n", + " conda = shutil.which(\"conda\")\n", + " if conda:\n", + " conda_base = Path(conda).resolve().parents[1]\n", + " for pattern in (\"pkgs/modkit-*/bin/modkit\", \"envs/*/bin/modkit\"):\n", + " for p in conda_base.glob(pattern):\n", + " candidates.add(str(p))\n", + "\n", + " version_to_path: Dict[str, str] = {}\n", + " for binary in sorted(candidates):\n", + " try:\n", + " result = subprocess.run([binary, \"--version\"], capture_output=True, text=True, check=True)\n", + " except Exception:\n", + " continue\n", + " version = _parse_modkit_version((result.stdout + result.stderr).strip())\n", + " if version and version not in version_to_path:\n", + " version_to_path[version] = binary\n", + "\n", + " return version_to_path\n", + "\n", + "\n", + "MODKIT_VERSIONS = discover_modkit_versions()\n", + "PREFERRED_ORDER = [\"0.2.4\", \"0.6.1\"]\n", + "TEST_VERSIONS = [v for v in PREFERRED_ORDER if v in MODKIT_VERSIONS]\n", + "if not TEST_VERSIONS:\n", + " TEST_VERSIONS = sorted(MODKIT_VERSIONS.keys())\n", + "\n", + "print(\"Detected modkit backends:\")\n", + "for version in TEST_VERSIONS:\n", + " print(f\" {version}: {MODKIT_VERSIONS[version]}\")\n", + "\n", + "if len(TEST_VERSIONS) < 2:\n", + " print(\"WARNING: Only one backend detected; cross-version comparisons will be limited.\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "de63818e", + "metadata": {}, + "source": [ + "## Raw Modkit Output Comparison\n", + "\n", + "Test pileup and extract commands directly with both versions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0a038eaf", + "metadata": {}, + "outputs": [], + "source": [ + "def _count_lines(path: Path) -> int:\n", + " if path.suffix == \".gz\":\n", + " with gzip.open(path, \"rt\") as handle:\n", + " return sum(1 for _ in handle)\n", + " with path.open(\"rt\") as handle:\n", + " return sum(1 for _ in handle)\n", + "\n", + "\n", + "def _sha256_file(path: Path) -> str:\n", + " digest = hashlib.sha256()\n", + " with path.open(\"rb\") as handle:\n", + " while True:\n", + " chunk = handle.read(1024 * 1024)\n", + " if not chunk:\n", + " break\n", + " digest.update(chunk)\n", + " return digest.hexdigest()\n", + "\n", + "\n", + "def run_modkit_pileup(version: str, *, run_label: str = \"single\") -> Dict:\n", + " \"\"\"Run a standardized pileup command for one backend and return metrics.\"\"\"\n", + " binary = MODKIT_VERSIONS[version]\n", + " output_file = OUTPUT_DIR / f\"pileup_{version}_{run_label}.bed\"\n", + "\n", + " cmd = [\n", + " binary,\n", + " \"pileup\",\n", + " str(BAM_FILE),\n", + " str(output_file),\n", + " \"--threads\",\n", + " str(THREADS),\n", + " \"--region\",\n", + " BENCH_REGION,\n", + " ]\n", + "\n", + " # v0.2.4 needs this for this BAM's implicit tags; v0.6.1 rejects it.\n", + " if version.startswith(\"0.2.\"):\n", + " cmd.append(\"--force-allow-implicit\")\n", + "\n", + " t0 = time.perf_counter()\n", + " proc = subprocess.run(cmd, capture_output=True, text=True)\n", + " runtime_s = time.perf_counter() - t0\n", + "\n", + " metrics = {\n", + " \"version\": version,\n", + " \"run_label\": run_label,\n", + " \"runtime_s\": runtime_s,\n", + " \"exit_code\": proc.returncode,\n", + " \"output_file\": str(output_file),\n", + " \"rows\": _count_lines(output_file) if output_file.exists() and proc.returncode == 0 else 0,\n", + " \"sha256\": _sha256_file(output_file) if output_file.exists() and proc.returncode == 0 else None,\n", + " \"stderr_tail\": \"\\n\".join(proc.stderr.strip().splitlines()[-6:]),\n", + " }\n", + " return metrics\n", + "\n", + "\n", + "single_run_metrics = []\n", + "for version in TEST_VERSIONS:\n", + " metrics = run_modkit_pileup(version, run_label=\"single\")\n", + " single_run_metrics.append(metrics)\n", + "\n", + "single_run_df = pd.DataFrame(single_run_metrics)\n", + "display(single_run_df[[\"version\", \"runtime_s\", \"rows\", \"exit_code\", \"output_file\"]])\n", + "\n", + "comparison = None\n", + "if {\"0.2.4\", \"0.6.1\"}.issubset(set(TEST_VERSIONS)):\n", + " m024 = next(row for row in single_run_metrics if row[\"version\"] == \"0.2.4\")\n", + " m061 = next(row for row in single_run_metrics if row[\"version\"] == \"0.6.1\")\n", + " comparison = {\n", + " \"row_delta\": int(m061[\"rows\"] - m024[\"rows\"]),\n", + " \"row_delta_pct_vs_024\": (float(m061[\"rows\"] - m024[\"rows\"]) / float(m024[\"rows\"]) * 100.0) if m024[\"rows\"] else None,\n", + " \"outputs_identical_sha256\": bool(m061[\"sha256\"] == m024[\"sha256\"]),\n", + " }\n", + " print(\"Single-run comparison:\", comparison)\n" + ] + }, + { + "cell_type": "markdown", + "id": "ea26f007", + "metadata": {}, + "source": [ + "## Dimelo Integration Tests\n", + "\n", + "Test parse_bam functions and plotting with both modkit versions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e48291ba", + "metadata": {}, + "outputs": [], + "source": [ + "# Optional dimelo compatibility smoke-check\n", + "# This notebook avoids hard dependency on dimelo optional extras; this block is best-effort.\n", + "\n", + "dimelo_smoke = {\"available\": False, \"note\": \"dimelo import not attempted\"}\n", + "try:\n", + " import dimelo # noqa: F401\n", + " dimelo_smoke[\"available\"] = True\n", + " dimelo_smoke[\"note\"] = \"dimelo import succeeded\"\n", + "except Exception as exc:\n", + " dimelo_smoke[\"available\"] = False\n", + " dimelo_smoke[\"note\"] = f\"dimelo import unavailable in this kernel: {type(exc).__name__}: {exc}\"\n", + "\n", + "print(dimelo_smoke[\"note\"])\n" + ] + }, + { + "cell_type": "markdown", + "id": "9e62e6e0", + "metadata": {}, + "source": [ + "## Performance Analysis\n", + "\n", + "Detailed performance comparison with multiple runs." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de59b4ce", + "metadata": {}, + "outputs": [], + "source": [ + "def benchmark_modkit(version: str, runs: int = BENCH_RUNS) -> pd.DataFrame:\n", + " records = []\n", + " for i in range(runs):\n", + " records.append(run_modkit_pileup(version, run_label=f\"bench{i+1}\"))\n", + " return pd.DataFrame(records)\n", + "\n", + "\n", + "bench_results: Dict[str, pd.DataFrame] = {}\n", + "for version in TEST_VERSIONS:\n", + " bench_results[version] = benchmark_modkit(version, runs=BENCH_RUNS)\n", + "\n", + "benchmark_df = pd.concat(bench_results.values(), ignore_index=True)\n", + "display(benchmark_df[[\"version\", \"run_label\", \"runtime_s\", \"rows\", \"exit_code\"]])\n", + "\n", + "runtime_summary = (\n", + " benchmark_df.groupby(\"version\", as_index=False)\n", + " .agg(\n", + " runtime_mean_s=(\"runtime_s\", \"mean\"),\n", + " runtime_std_s=(\"runtime_s\", \"std\"),\n", + " runtime_min_s=(\"runtime_s\", \"min\"),\n", + " runtime_max_s=(\"runtime_s\", \"max\"),\n", + " )\n", + ")\n", + "display(runtime_summary)\n", + "\n", + "fig, ax = plt.subplots(1, 1, figsize=(8, 4))\n", + "for version, frame in bench_results.items():\n", + " ax.plot(frame.index + 1, frame[\"runtime_s\"], marker=\"o\", label=version)\n", + "ax.set_xlabel(\"Benchmark run\")\n", + "ax.set_ylabel(\"Runtime (s)\")\n", + "ax.set_title(f\"modkit pileup runtime by backend ({BENCH_REGION})\")\n", + "ax.legend()\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "721119b6", + "metadata": {}, + "source": [ + "## Edge Cases and Compatibility Checks\n", + "\n", + "Test specific scenarios that might reveal differences." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "180f0d63", + "metadata": {}, + "outputs": [], + "source": [ + "# Edge-case / interface compatibility checks\n", + "\n", + "def supports_flag(version: str, flag: str) -> bool:\n", + " binary = MODKIT_VERSIONS[version]\n", + " help_text = subprocess.run([binary, \"pileup\", \"--help\"], capture_output=True, text=True).stdout\n", + " return flag in help_text\n", + "\n", + "\n", + "edge_case_rows = []\n", + "for version in TEST_VERSIONS:\n", + " edge_case_rows.append(\n", + " {\n", + " \"version\": version,\n", + " \"supports_force_allow_implicit\": supports_flag(version, \"--force-allow-implicit\"),\n", + " \"supports_modified_bases\": supports_flag(version, \"--modified-bases\"),\n", + " \"supports_reference_long_opt\": supports_flag(version, \"--reference\"),\n", + " \"supports_reference_short_opt\": supports_flag(version, \"--ref\"),\n", + " }\n", + " )\n", + "\n", + "edge_case_df = pd.DataFrame(edge_case_rows)\n", + "display(edge_case_df)\n" + ] + }, + { + "cell_type": "markdown", + "id": "b5423112", + "metadata": {}, + "source": [ + "## Summary and Recommendations\n", + "\n", + "Compile all findings into a structured report." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "393269d2", + "metadata": {}, + "outputs": [], + "source": [ + "# Compile summary and recommendations\n", + "\n", + "summary_payload: Dict[str, object] = {\n", + " \"versions_tested\": TEST_VERSIONS,\n", + " \"single_run\": single_run_df.to_dict(orient=\"records\"),\n", + " \"benchmark_runs\": benchmark_df.to_dict(orient=\"records\") if \"benchmark_df\" in globals() else [],\n", + " \"runtime_summary\": runtime_summary.to_dict(orient=\"records\") if \"runtime_summary\" in globals() else [],\n", + " \"pileup_comparison\": comparison,\n", + " \"edge_case_flags\": edge_case_df.to_dict(orient=\"records\") if \"edge_case_df\" in globals() else [],\n", + " \"compatibility_issues\": [],\n", + " \"recommendations\": [],\n", + "}\n", + "\n", + "if comparison is not None and not comparison.get(\"outputs_identical_sha256\", True):\n", + " summary_payload[\"compatibility_issues\"].append(\n", + " \"Pileup outputs differ across versions (non-identical output hash).\"\n", + " )\n", + "\n", + "if {\"0.2.4\", \"0.6.1\"}.issubset(set(TEST_VERSIONS)) and \"runtime_summary\" in globals():\n", + " rt = {row[\"version\"]: row[\"runtime_mean_s\"] for row in runtime_summary.to_dict(orient=\"records\")}\n", + " v024 = rt.get(\"0.2.4\")\n", + " v061 = rt.get(\"0.6.1\")\n", + " if v024 and v061:\n", + " delta_pct = (v024 - v061) / v024 * 100.0\n", + " if delta_pct > 0:\n", + " summary_payload[\"recommendations\"].append(\n", + " f\"Prefer modkit 0.6.1 for pileup runtime in this workflow (~{delta_pct:.1f}% faster on average).\"\n", + " )\n", + " else:\n", + " summary_payload[\"recommendations\"].append(\n", + " f\"No runtime win from 0.6.1 observed in this benchmark ({-delta_pct:.1f}% slower).\"\n", + " )\n", + "\n", + "# Flag version-specific command behavior\n", + "if \"edge_case_df\" in globals() and not edge_case_df.empty:\n", + " flag_024 = edge_case_df.loc[edge_case_df[\"version\"] == \"0.2.4\", \"supports_force_allow_implicit\"]\n", + " flag_061 = edge_case_df.loc[edge_case_df[\"version\"] == \"0.6.1\", \"supports_force_allow_implicit\"]\n", + " if not flag_024.empty and not flag_061.empty and bool(flag_024.iloc[0]) and not bool(flag_061.iloc[0]):\n", + " summary_payload[\"recommendations\"].append(\n", + " \"Backend-aware command building is required: use --force-allow-implicit for 0.2.4 only.\"\n", + " )\n", + "\n", + "results_path = ROOT / \"modkit_test_results.json\"\n", + "with results_path.open(\"w\") as handle:\n", + " json.dump(summary_payload, handle, indent=2)\n", + "\n", + "print(\"Results saved to\", results_path)\n", + "print(json.dumps(summary_payload, indent=2)[:4000])\n" + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/scripts/bootstrap_dimelo_env.sh b/scripts/bootstrap_dimelo_env.sh new file mode 100755 index 0000000..b06ff66 --- /dev/null +++ b/scripts/bootstrap_dimelo_env.sh @@ -0,0 +1,63 @@ +#!/usr/bin/env bash +set -euo pipefail + +REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" +ENV_NAME="${1:-dimelo-toolkit}" +KERNEL_NAME="${2:-dimelo-test}" +KERNEL_DISPLAY_NAME="${3:-Python (${KERNEL_NAME})}" +MODKIT_VERSION="${4:-}" + +if ! command -v conda >/dev/null 2>&1; then + echo "ERROR: conda is not on PATH." + echo "Install conda/mambaforge first, then rerun this script." + exit 1 +fi + +if command -v mamba >/dev/null 2>&1; then + ENV_TOOL="mamba" +else + ENV_TOOL="conda" +fi + +echo "==> Using ${ENV_TOOL} to provision environment '${ENV_NAME}'" +if conda env list | awk '{print $1}' | grep -Fxq "${ENV_NAME}"; then + CONDA_CHANNEL_PRIORITY=flexible \ + "${ENV_TOOL}" env update -n "${ENV_NAME}" -f "${REPO_ROOT}/environment.yml" --prune +else + CONDA_CHANNEL_PRIORITY=flexible \ + "${ENV_TOOL}" env create -n "${ENV_NAME}" -f "${REPO_ROOT}/environment.yml" +fi + +echo "==> Installing dimelo-toolkit in editable mode with clustering extras" +conda run -n "${ENV_NAME}" python -m pip install --upgrade pip +conda run -n "${ENV_NAME}" python -m pip install -e "${REPO_ROOT}[clustering]" +conda run -n "${ENV_NAME}" python -m pip install pytest pre-commit nbformat + +if [[ -n "${MODKIT_VERSION}" ]]; then + echo "==> Installing modkit ${MODKIT_VERSION} in '${ENV_NAME}'" + "${ENV_TOOL}" install -n "${ENV_NAME}" -y "nanoporetech::modkit==${MODKIT_VERSION}" +fi + +echo "==> Registering Jupyter kernel '${KERNEL_NAME}'" +conda run -n "${ENV_NAME}" python -m ipykernel install \ + --user \ + --name "${KERNEL_NAME}" \ + --display-name "${KERNEL_DISPLAY_NAME}" + +echo "==> Validating environment health" +conda run -n "${ENV_NAME}" python "${REPO_ROOT}/scripts/ensure_dimelo_kernel.py" \ + --modkit-version "${MODKIT_VERSION:-supported}" \ + --expected-env "${ENV_NAME}" + +cat < +EOF diff --git a/scripts/ensure_dimelo_kernel.py b/scripts/ensure_dimelo_kernel.py new file mode 100644 index 0000000..1c587c9 --- /dev/null +++ b/scripts/ensure_dimelo_kernel.py @@ -0,0 +1,365 @@ +#!/usr/bin/env python3 +""" +Verify that the active Python/kernel environment can run the DiMeLo notebooks. + +Usage: + python scripts/ensure_dimelo_kernel.py + python scripts/ensure_dimelo_kernel.py --fix + python scripts/ensure_dimelo_kernel.py --fix --skip-modkit + python scripts/ensure_dimelo_kernel.py --expected-env dimelo-toolkit +""" + +from __future__ import annotations + +import argparse +import importlib.util +import os +import shutil +import subprocess +import sys +from dataclasses import dataclass +from pathlib import Path + + +REPO_ROOT = Path(__file__).resolve().parents[1] +DEFAULT_MODKIT_REQUIREMENT = "supported" +DEFAULT_MODKIT_INSTALL_VERSION = "0.2.4" +SUPPORTED_MODKIT_PREFIXES = ("0.2.4", "0.6.") + +# setup.py install_requires +CORE_MODULES = { + "numpy": "numpy", + "seaborn": "seaborn", + "pysam": "pysam", + "h5py": "h5py", + "pyBigWig": "pyBigWig", + "notebook": "notebook", + "ipykernel": "ipykernel", + "ipywidgets": "ipywidgets", + "tqdm": "tqdm", + "plotly": "plotly", + "kaleido": "kaleido", +} + +# setup.py extras_require["clustering"] +CLUSTERING_MODULES = { + "scikit-learn": "sklearn", + "scipy": "scipy", + "hdbscan": "hdbscan", + "umap-learn": "umap", + "pyranges": "pyranges", + "xgboost": "xgboost", +} + + +@dataclass +class CheckReport: + missing_core: list[str] + missing_clustering: list[str] + runtime_failures: dict[str, str] + missing_modkit: bool + modkit_version: str | None + missing_crossmap: bool + crossmap_executable: str | None + conda_env: str | None + expected_env: str | None + + @property + def ok(self) -> bool: + env_ok = self.expected_env is None or self.conda_env == self.expected_env + return ( + len(self.missing_core) == 0 + and len(self.missing_clustering) == 0 + and len(self.runtime_failures) == 0 + and not self.missing_modkit + and not self.missing_crossmap + and env_ok + ) + + +def _module_installed(module_name: str) -> bool: + return importlib.util.find_spec(module_name) is not None + + +def _check_python_modules() -> tuple[list[str], list[str]]: + missing_core = [ + package for package, module in CORE_MODULES.items() if not _module_installed(module) + ] + missing_clustering = [ + package + for package, module in CLUSTERING_MODULES.items() + if not _module_installed(module) + ] + return missing_core, missing_clustering + + +def _modkit_version_ok(version_text: str, required_version: str) -> bool: + normalized = required_version.strip().lower() + if normalized in {"supported", "dual", "auto"}: + return any(prefix in version_text for prefix in SUPPORTED_MODKIT_PREFIXES) + return required_version in version_text + + +def _check_modkit(required_version: str) -> tuple[bool, str | None]: + modkit_path = shutil.which("modkit") + if modkit_path is None: + return True, None + + try: + result = subprocess.run( + ["modkit", "--version"], check=True, capture_output=True, text=True + ) + except Exception: + return True, None + + version_text = (result.stdout or result.stderr).strip().splitlines()[0] + version_ok = _modkit_version_ok(version_text, required_version) + return (not version_ok), version_text + + +def _check_crossmap() -> tuple[bool, str | None]: + for candidate in ("CrossMap.py", "CrossMap"): + path = shutil.which(candidate) + if path is not None: + return False, path + return True, None + + +def _check_runtime_imports() -> dict[str, str]: + runtime_failures: dict[str, str] = {} + runtime_modules = ("numpy", "pysam", "h5py", "pyBigWig") + for module_name in runtime_modules: + try: + __import__(module_name) + except Exception as exc: # pragma: no cover - exception type varies by platform + runtime_failures[module_name] = f"{type(exc).__name__}: {exc}" + return runtime_failures + + +def run_checks( + required_modkit_version: str, + skip_modkit: bool, + expected_env: str | None, +) -> CheckReport: + missing_core, missing_clustering = _check_python_modules() + runtime_failures = _check_runtime_imports() + if skip_modkit: + missing_modkit = False + modkit_version = None + else: + missing_modkit, modkit_version = _check_modkit(required_modkit_version) + missing_crossmap, crossmap_executable = _check_crossmap() + + return CheckReport( + missing_core=missing_core, + missing_clustering=missing_clustering, + runtime_failures=runtime_failures, + missing_modkit=missing_modkit, + modkit_version=modkit_version, + missing_crossmap=missing_crossmap, + crossmap_executable=crossmap_executable, + conda_env=os.environ.get("CONDA_DEFAULT_ENV"), + expected_env=expected_env, + ) + + +def _run_command(cmd: list[str], cwd: Path | None = None) -> None: + print(f"$ {' '.join(cmd)}") + subprocess.run(cmd, check=True, cwd=cwd) + + +def fix_python_packages(report: CheckReport) -> None: + # Install core and clustering extras in one shot; safe if already installed. + if report.missing_core or report.missing_clustering: + _run_command( + [sys.executable, "-m", "pip", "install", "-e", ".[clustering]"], + cwd=REPO_ROOT, + ) + + +def fix_modkit(required_modkit_version: str) -> None: + requested_version = ( + DEFAULT_MODKIT_INSTALL_VERSION + if required_modkit_version.strip().lower() in {"supported", "dual", "auto"} + else required_modkit_version + ) + conda_path = shutil.which("conda") + if conda_path is None: + print( + "modkit is missing/incompatible and `conda` is not on PATH.\n" + "Install manually with: conda install -y nanoporetech::modkit==" + f"{requested_version}" + ) + return + + _run_command( + ["conda", "install", "-y", f"nanoporetech::modkit=={requested_version}"] + ) + + +def fix_crossmap() -> None: + conda_path = shutil.which("conda") + if conda_path is None: + print( + "CrossMap is missing and `conda` is not on PATH.\n" + "Install manually with: conda install -y bioconda::crossmap=0.7.3" + ) + return + _run_command(["conda", "install", "-y", "bioconda::crossmap=0.7.3"]) + + +def print_report( + report: CheckReport, + required_modkit_version: str, + skip_modkit: bool, +) -> None: + print("=== DiMeLo Kernel Environment Check ===") + print(f"Python executable: {sys.executable}") + print(f"Conda env: {report.conda_env or '(not set)'}") + if report.expected_env is not None: + print(f"Expected env: {report.expected_env}") + print(f"Repo root: {REPO_ROOT}") + print("") + + if report.missing_core: + print("Missing core Python packages:") + for pkg in report.missing_core: + print(f" - {pkg}") + else: + print("Core Python packages: OK") + + if report.missing_clustering: + print("Missing clustering Python packages:") + for pkg in report.missing_clustering: + print(f" - {pkg}") + else: + print("Clustering Python packages: OK") + + if report.runtime_failures: + print("Runtime import failures:") + for module_name, message in report.runtime_failures.items(): + print(f" - {module_name}: {message}") + else: + print("Runtime imports: OK") + + if report.expected_env is not None: + if report.conda_env == report.expected_env: + print("Conda env match: OK") + else: + print( + "Conda env match: FAIL " + f"(active='{report.conda_env}', expected='{report.expected_env}')" + ) + + if skip_modkit: + print("modkit check: skipped") + else: + requirement_text = ( + "any supported version (0.2.4 or 0.6.x)" + if required_modkit_version.strip().lower() in {"supported", "dual", "auto"} + else f"version containing '{required_modkit_version}'" + ) + if report.missing_modkit: + if report.modkit_version is None: + print(f"modkit: MISSING (required {requirement_text})") + else: + print( + "modkit: version mismatch " + f"(found '{report.modkit_version}', required {requirement_text})" + ) + else: + print(f"modkit: OK ({report.modkit_version})") + + if report.missing_crossmap: + print("CrossMap: MISSING (expected CrossMap.py or CrossMap on PATH)") + else: + print(f"CrossMap: OK ({report.crossmap_executable})") + + print("") + print("Overall status:", "PASS" if report.ok else "FAIL") + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser() + parser.add_argument( + "--fix", + action="store_true", + help="Attempt to install/fix missing dependencies automatically.", + ) + parser.add_argument( + "--skip-modkit", + action="store_true", + help="Skip modkit checks and install attempts.", + ) + parser.add_argument( + "--modkit-version", + default=DEFAULT_MODKIT_REQUIREMENT, + help=( + "Required modkit version marker. " + "Use 'supported' (default) to allow 0.2.4 or 0.6.x, or pass an explicit marker." + ), + ) + parser.add_argument( + "--expected-env", + default=None, + help=( + "Expected active CONDA_DEFAULT_ENV name (e.g. dimelo-toolkit). " + "When provided, mismatch is treated as failure." + ), + ) + return parser.parse_args() + + +def main() -> int: + args = parse_args() + + report = run_checks( + required_modkit_version=args.modkit_version, + skip_modkit=args.skip_modkit, + expected_env=args.expected_env, + ) + print_report( + report, + required_modkit_version=args.modkit_version, + skip_modkit=args.skip_modkit, + ) + + if report.ok: + return 0 + + if not args.fix: + print("\nRun with `--fix` to install missing dependencies.") + if report.expected_env and report.conda_env != report.expected_env: + print( + f"Activate expected env first: `conda activate {report.expected_env}`" + ) + if report.runtime_failures: + print("For runtime linker/import issues, run scripts/bootstrap_dimelo_env.sh") + return 1 + + try: + fix_python_packages(report) + if not args.skip_modkit and report.missing_modkit: + fix_modkit(args.modkit_version) + if report.missing_crossmap: + fix_crossmap() + except subprocess.CalledProcessError as exc: + print(f"\nInstall step failed: {exc}") + return exc.returncode or 1 + + print("\nRe-checking environment after attempted fixes...\n") + post = run_checks( + required_modkit_version=args.modkit_version, + skip_modkit=args.skip_modkit, + expected_env=args.expected_env, + ) + print_report( + post, + required_modkit_version=args.modkit_version, + skip_modkit=args.skip_modkit, + ) + return 0 if post.ok else 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/run_tutorial_offline.py b/scripts/run_tutorial_offline.py new file mode 100644 index 0000000..6e6b697 --- /dev/null +++ b/scripts/run_tutorial_offline.py @@ -0,0 +1,95 @@ +#!/usr/bin/env python3 +""" +Execute the deterministic offline tutorial notebook and capture logs/artifacts. +""" + +from __future__ import annotations + +import argparse +import os +import subprocess +from pathlib import Path + + +REPO_ROOT = Path(__file__).resolve().parents[1] +DEFAULT_NOTEBOOK = REPO_ROOT / "tutorial_offline.ipynb" +DEFAULT_ARTIFACT_DIR = REPO_ROOT / "artifacts" / "tutorial_offline" + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser() + parser.add_argument( + "--notebook", + type=Path, + default=DEFAULT_NOTEBOOK, + help=f"Notebook path to execute (default: {DEFAULT_NOTEBOOK}).", + ) + parser.add_argument( + "--artifact-dir", + type=Path, + default=DEFAULT_ARTIFACT_DIR, + help=f"Directory for executed notebook and logs (default: {DEFAULT_ARTIFACT_DIR}).", + ) + parser.add_argument( + "--timeout-seconds", + type=int, + default=0, + help="Per-cell timeout for nbconvert execution (0 means no timeout).", + ) + return parser.parse_args() + + +def main() -> int: + args = parse_args() + notebook = args.notebook.resolve() + artifact_dir = args.artifact_dir.resolve() + artifact_dir.mkdir(parents=True, exist_ok=True) + + if not notebook.exists(): + raise FileNotFoundError(f"Notebook not found: {notebook}") + + executed_name = notebook.with_suffix(".executed.ipynb").name + log_path = artifact_dir / "tutorial_offline_execution.log" + + command = [ + "python3.11", + "-m", + "jupyter", + "nbconvert", + "--to", + "notebook", + "--execute", + str(notebook), + "--output", + executed_name, + "--output-dir", + str(artifact_dir), + "--ExecutePreprocessor.timeout", + str(args.timeout_seconds), + ] + + env = os.environ.copy() + env.setdefault("MPLBACKEND", "Agg") + + result = subprocess.run( + command, + cwd=REPO_ROOT, + env=env, + capture_output=True, + text=True, + ) + combined_log = "\n".join( + part.strip() for part in (result.stdout, result.stderr) if part and part.strip() + ) + log_path.write_text(combined_log + ("\n" if combined_log else "")) + + print(f"Wrote execution log to {log_path}") + print(f"Executed notebook target: {artifact_dir / executed_name}") + + if result.returncode != 0: + print(combined_log) + return result.returncode + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/update_modkit_version.sh b/scripts/update_modkit_version.sh new file mode 100755 index 0000000..48aa9cf --- /dev/null +++ b/scripts/update_modkit_version.sh @@ -0,0 +1,32 @@ +#!/usr/bin/env bash +set -euo pipefail + +ENV_NAME="${1:-${CONDA_DEFAULT_ENV:-dimelo-toolkit}}" +MODKIT_VERSION="${2:-}" + +if [[ -z "${MODKIT_VERSION}" ]]; then + echo "Usage: bash scripts/update_modkit_version.sh " + echo "Example: bash scripts/update_modkit_version.sh dimelo-toolkit 0.6.1" + exit 1 +fi + +if ! command -v conda >/dev/null 2>&1; then + echo "ERROR: conda is not on PATH." + exit 1 +fi + +if command -v mamba >/dev/null 2>&1; then + ENV_TOOL="mamba" +else + ENV_TOOL="conda" +fi + +echo "==> Installing nanoporetech::modkit==${MODKIT_VERSION} in env '${ENV_NAME}'" +"${ENV_TOOL}" install -n "${ENV_NAME}" -y "nanoporetech::modkit==${MODKIT_VERSION}" + +echo "==> Verifying in '${ENV_NAME}'" +conda run -n "${ENV_NAME}" modkit --version +conda run -n "${ENV_NAME}" python scripts/ensure_dimelo_kernel.py \ + --modkit-version "${MODKIT_VERSION}" \ + --expected-env "${ENV_NAME}" + diff --git a/tests/test_chip_atlas.py b/tests/test_chip_atlas.py new file mode 100644 index 0000000..3c2fbd1 --- /dev/null +++ b/tests/test_chip_atlas.py @@ -0,0 +1,267 @@ +import pandas as pd +import pytest + +from dimelo import chip_atlas + + +def test_region_ids_to_bed_dataframe_parses_region_ids(): + frame = chip_atlas.region_ids_to_bed_dataframe(["chr1:100-200,+", "chr2:500-700"]) + assert frame.shape[0] == 2 + assert frame.loc[0, "chrom"] == "chr1" + assert int(frame.loc[0, "start"]) == 100 + assert int(frame.loc[0, "end"]) == 200 + assert frame.loc[0, "strand"] == "+" + assert frame.loc[1, "strand"] == "." + + +def test_submit_enrichment_extracts_request_id_from_json(monkeypatch): + captured = {} + + def fake_request(**kwargs): + captured.update(kwargs) + return 200, "application/json", '{"id":"REQ123"}' + + monkeypatch.setattr(chip_atlas, "_http_request", fake_request) + result = chip_atlas.submit_enrichment( + regions=pd.DataFrame({"chrom": ["chr1"], "start": [0], "end": [100]}), + genome="hg38", + ) + assert result["request_id"] == "REQ123" + assert captured["url"] == chip_atlas.DEFAULT_SUBMIT_URL + payload = captured["data"].decode("utf-8") + assert "format=text" in payload + assert "result=www" in payload + assert "typeA=bed" in payload + assert "bedAFile=" in payload + assert "typeB=rnd" in payload + assert "bedBFile=empty" in payload + assert "antigenClass=TFs+and+others" in payload + assert "cellClass=No+description" in payload + assert "threshold=100" in payload + + +def test_get_status_uses_request_path_endpoint(monkeypatch): + captured = {} + + def fake_request(**kwargs): + captured.update(kwargs) + return 200, "text/plain", "current-state: running" + + monkeypatch.setattr(chip_atlas, "_http_request", fake_request) + status = chip_atlas.get_status("REQ-PATH") + assert status["status"] == "running" + assert captured["url"] == f"{chip_atlas.DEFAULT_STATUS_URL}REQ-PATH" + + +def test_poll_request_collects_history_until_finished(monkeypatch): + states = iter( + [ + {"status": "running", "raw_status": "running", "status_code": 200}, + {"status": "finished", "raw_status": "finished", "status_code": 200}, + ] + ) + + def fake_get_status(*args, **kwargs): + payload = next(states) + return {"request_id": "REQ1", **payload} + + monkeypatch.setattr(chip_atlas, "get_status", fake_get_status) + poll = chip_atlas.poll_request("REQ1", poll_interval_seconds=0.0, timeout_seconds=5.0) + assert poll["status"] == "finished" + assert [step["status"] for step in poll["history"]] == ["running", "finished"] + + +def test_fetch_result_parses_tsv(monkeypatch): + captured = {} + + def fake_request(**kwargs): + captured.update(kwargs) + return 200, "text/tab-separated-values", "target\tcount\nCTCF\t42\n" + + monkeypatch.setattr(chip_atlas, "_http_request", fake_request) + result = chip_atlas.fetch_result("REQ2") + assert isinstance(result, pd.DataFrame) + assert result.loc[0, "target"] == "CTCF" + assert int(result.loc[0, "count"]) == 42 + assert captured["url"] == f"{chip_atlas.DEFAULT_RESULT_URL}REQ2?info=result&format=tsv" + + +def test_run_enrichment_raises_on_terminal_failure(monkeypatch): + monkeypatch.setattr( + chip_atlas, + "submit_enrichment", + lambda **kwargs: {"request_id": "REQ-ERR", "query": {}, "submit_url": "u"}, + ) + monkeypatch.setattr( + chip_atlas, + "poll_request", + lambda *args, **kwargs: {"status": "error", "history": []}, + ) + with pytest.raises(RuntimeError, match="status 'error'"): + chip_atlas.run_enrichment( + regions=["chr1:0-100"], + wait=True, + fetch_results=False, + raise_on_failure=True, + ) + + +def test_submit_enrichment_runs_crossmap_when_regions_genome_differs(monkeypatch): + captured = {} + + def fake_convert(**kwargs): + captured.update(kwargs) + return pd.DataFrame( + { + "chrom": ["chr1"], + "start": [10], + "end": [60], + "name": ["region_0"], + "score": [0], + "strand": ["+"], + } + ) + + def fake_resolve(**kwargs): + return "/tmp/hs1_to_hg38.over.chain.gz" + + def fake_request(**kwargs): + return 200, "application/json", '{"id":"REQX"}' + + monkeypatch.setattr(chip_atlas, "_resolve_chain_file", fake_resolve) + monkeypatch.setattr(chip_atlas, "convert_regions_with_crossmap", fake_convert) + monkeypatch.setattr(chip_atlas, "_http_request", fake_request) + + result = chip_atlas.submit_enrichment( + regions=["chr1:100-200,+"], + genome="hg38", + regions_genome="chm13", + ) + + assert result["request_id"] == "REQX" + assert captured["source_genome"] == "hs1" + assert captured["target_genome"] == "hg38" + assert captured["chain_file"] == "/tmp/hs1_to_hg38.over.chain.gz" + assert result["query"]["crossmap"]["applied"] is True + + +def test_cache_chain_files_uses_resolver(monkeypatch): + calls = [] + + def fake_resolve(**kwargs): + calls.append((kwargs["source_genome"], kwargs["target_genome"])) + return f"/tmp/{kwargs['source_genome']}_to_{kwargs['target_genome']}.over.chain.gz" + + monkeypatch.setattr(chip_atlas, "_resolve_chain_file", fake_resolve) + cached = chip_atlas.cache_chain_files(source_genome="chm13", target_genomes=("hg38", "hg19")) + + assert calls == [("chm13", "hg38"), ("chm13", "hg19")] + assert str(cached["hg38"]).endswith("chm13_to_hg38.over.chain.gz") + assert str(cached["hg19"]).endswith("chm13_to_hg19.over.chain.gz") + + +def test_resolve_crossmap_executable_falls_back_to_crossmap(monkeypatch): + def fake_which(cmd): + return "/usr/local/bin/CrossMap" if cmd == "CrossMap" else None + + monkeypatch.setattr(chip_atlas.shutil, "which", fake_which) + resolved = chip_atlas._resolve_crossmap_executable("CrossMap.py") + assert resolved == "CrossMap" + + +def test_search_peak_datasets_filters_metadata_rows(monkeypatch, tmp_path): + rows = [ + { + "Experimental ID": "SRX1", + "Genome assembly": "hg38", + "Antigen class": "TFs and others", + "Antigen": "CTCF", + "Cell type class": "Blood", + "Cell type": "K562", + "Cell type description": "", + "Processing logs": "", + "Title": "CTCF K562", + "Meta data": "", + "BigWig": "bw1", + "Peak-call (BED) (q < 1E-05)": "http://example.org/srx1.bed", + "Peak-call (BigBed) (q < 1E-05)": "http://example.org/srx1.bb", + }, + { + "Experimental ID": "SRX2", + "Genome assembly": "mm10", + "Antigen class": "TFs and others", + "Antigen": "CTCF", + "Cell type class": "Blood", + "Cell type": "MEL", + "Cell type description": "", + "Processing logs": "", + "Title": "CTCF mouse", + "Meta data": "", + "BigWig": "bw2", + "Peak-call (BED) (q < 1E-05)": "http://example.org/srx2.bed", + "Peak-call (BigBed) (q < 1E-05)": "http://example.org/srx2.bb", + }, + ] + + monkeypatch.setattr(chip_atlas, "_ensure_experiment_list_zip", lambda **kwargs: tmp_path / "fake.zip") + monkeypatch.setattr(chip_atlas, "_iter_experiment_rows", lambda path: iter(rows)) + + found = chip_atlas.search_peak_datasets( + antigen="CTCF", + genome="hg38", + cell_type="k562", + threshold="05", + ) + assert found.shape[0] == 1 + assert found.loc[0, "dataset_id"] == "SRX1" + assert found.loc[0, "bed_url"] == "http://example.org/srx1.bed" + + +def test_download_peak_datasets_writes_variants_and_crossmapped(monkeypatch, tmp_path): + datasets = pd.DataFrame( + [ + { + "dataset_id": "SRX3", + "bed_url": "http://example.org/srx3.bed", + "genome_assembly": "hg38", + } + ] + ) + bed_payload = ( + "chr1\t10\t20\tp1\t100\t.\n" + "chr1\t30\t40\tp2\t10\t.\n" + "chr1\t50\t60\tp3\t50\t.\n" + "chr1\t70\t80\tp4\t5\t.\n" + ).encode("utf-8") + monkeypatch.setattr(chip_atlas, "_download_bytes", lambda **kwargs: bed_payload) + monkeypatch.setattr( + chip_atlas, + "convert_regions_with_crossmap", + lambda **kwargs: pd.DataFrame( + { + "chrom": ["chr1"], + "start": [100], + "end": [200], + "name": ["mapped"], + "score": [1], + "strand": ["+"], + } + ), + ) + + manifest = chip_atlas.download_peak_datasets( + datasets=datasets, + output_dir=tmp_path, + include_complete_sorted=True, + include_top_n=2, + include_bottom_n=2, + stratify="quartiles", + crossmap_target_genome="hg19", + ) + variants = set(manifest["variant"].tolist()) + assert "full_sorted" in variants + assert "top_2" in variants + assert "bottom_2" in variants + assert "quantile_1_of_4" in variants + assert "full_sorted_crossmapped" in variants + assert manifest.loc[manifest["crossmapped"] == True].shape[0] > 0 # noqa: E712 diff --git a/tests/test_cluster.py b/tests/test_cluster.py index 5a83a78..cdc41a5 100644 --- a/tests/test_cluster.py +++ b/tests/test_cluster.py @@ -1,4 +1,5 @@ import numpy as np +import pandas as pd import pytest from dimelo import cluster @@ -106,6 +107,75 @@ def test_read_mod_fraction_table(monkeypatch): assert regions_dict == {"chr1": [(0, 100, "+")]} +def test_summarize_read_cluster_region_associations_counts_and_fractions(): + metadata = [ + {"chromosome": "chr1", "region_start": 0, "region_end": 100, "region_strand": "+"}, + {"chromosome": "chr1", "region_start": 0, "region_end": 100, "region_strand": "+"}, + {"chromosome": "chr1", "region_start": 0, "region_end": 100, "region_strand": "+"}, + {"chromosome": "chr1", "region_start": 200, "region_end": 300, "region_strand": "-"}, + {"chromosome": "chr1", "region_start": 200, "region_end": 300, "region_strand": "-"}, + ] + labels = [0, 0, 1, 1, 1] + + summary = cluster.summarize_read_cluster_region_associations(metadata, labels) + + region1 = summary[ + (summary["chrom"] == "chr1") + & (summary["start"] == 0) + & (summary["end"] == 100) + & (summary["strand"] == "+") + ].sort_values("cluster") + assert region1["count"].tolist() == [2, 1] + np.testing.assert_allclose(region1["fraction"].to_numpy(), np.array([2 / 3, 1 / 3])) + assert region1["total_reads"].tolist() == [3, 3] + + +def test_summarize_read_cluster_region_associations_enrichment_and_multiple_testing(): + metadata = [ + {"chromosome": "chr1", "region_start": 0, "region_end": 100, "region_strand": "+"}, + {"chromosome": "chr1", "region_start": 0, "region_end": 100, "region_strand": "+"}, + {"chromosome": "chr1", "region_start": 0, "region_end": 100, "region_strand": "+"}, + {"chromosome": "chr1", "region_start": 200, "region_end": 300, "region_strand": "-"}, + {"chromosome": "chr1", "region_start": 200, "region_end": 300, "region_strand": "-"}, + ] + labels = [0, 0, 1, 1, 1] + + summary = cluster.summarize_read_cluster_region_associations(metadata, labels) + + enriched = summary[ + (summary["chrom"] == "chr1") + & (summary["start"] == 200) + & (summary["end"] == 300) + & (summary["strand"] == "-") + & (summary["cluster"] == 1) + ].iloc[0] + assert enriched["log2_enrichment"] > 0 + assert 0.0 <= enriched["p_value"] <= 1.0 + assert 0.0 <= enriched["q_value"] <= 1.0 + + assert set(["p_value", "q_value"]).issubset(summary.columns) + assert summary["p_value"].between(0.0, 1.0).all() + assert summary["q_value"].between(0.0, 1.0).all() + + +def test_summarize_read_cluster_region_associations_min_reads_filter(): + metadata = [ + {"chromosome": "chr1", "region_start": 0, "region_end": 100, "region_strand": "+"}, + {"chromosome": "chr1", "region_start": 200, "region_end": 300, "region_strand": "-"}, + {"chromosome": "chr1", "region_start": 200, "region_end": 300, "region_strand": "-"}, + ] + labels = [0, 1, 1] + + summary = cluster.summarize_read_cluster_region_associations( + metadata, + labels, + min_reads_per_region=2, + ) + + assert summary["start"].tolist() == [200, 200] + assert summary["total_reads"].tolist() == [2, 2] + + def test_cluster_features_invokes_kmeans(monkeypatch): class DummyKMeans: def __init__(self, n_clusters, random_state, **kwargs): @@ -173,7 +243,7 @@ def fake_loader(**kwargs): result = cluster.extract_read_windows( hdf5_file="reads.h5", motifs=["A,0"], - config=cluster.ReadWindowExtractionConfig(window_size=4, orientation_aware=True), + config=cluster.ReadWindowExtractionConfig(window_size=2, orientation_aware=True), ) np.testing.assert_allclose(result.data_matrix, np.array([[7.0, 6.0, 5.0, 4.0]])) @@ -247,7 +317,7 @@ def fake_loader(**kwargs): hdf5_file="reads.h5", motifs=["A,0"], config=cluster.ReadWindowExtractionConfig( - window_size=4, orientation_aware=False, filter_multi_region_reads=True + window_size=2, orientation_aware=False, filter_multi_region_reads=True ), ) assert result.data_matrix.shape[0] == 1 @@ -292,7 +362,7 @@ def test_plot_cluster_profiles_motif_index(monkeypatch): import matplotlib matplotlib.use("Agg") - fig = cluster.plot_cluster_profiles(X, labels, motif_index=1, view_bp=2) + fig = cluster.plot_cluster_profiles(X, labels, motif_index=1, view_window_size=1) assert fig is not None @@ -303,7 +373,7 @@ def test_plot_region_cluster_profiles_motif_index(monkeypatch): matplotlib.use("Agg") fig = cluster.plot_region_cluster_profiles( - X, labels, motif_index=1, motif_count=2, window_bp=2 + X, labels, motif_index=1, motif_count=2, window_size=2 ) assert fig is not None @@ -376,6 +446,309 @@ def test_plot_multisite_read_raster_smoke(monkeypatch): ) assert fig is not None assert stats["pairs"] >= 1 + assert stats["render_mode"] == "scatter" + + +def test_plot_multisite_read_raster_supports_multimotif_grid(): + import matplotlib + + matplotlib.use("Agg") + # 3 windows from one read, 2 concatenated motifs of width 4 each + motif_a = np.array( + [ + [0, 1, 0, 1], + [1, 0, 1, 0], + [0, 1, 1, 0], + ], + dtype=float, + ) + motif_c = np.array( + [ + [1, 0, 1, 0], + [0, 1, 0, 1], + [1, 1, 0, 0], + ], + dtype=float, + ) + data = np.hstack([motif_a, motif_c]) + meta = [ + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 2500, + "region_end": 2504, + "region_strand": "+", + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 5000, + "region_end": 5004, + "region_strand": "+", + }, + ] + r = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=meta, + datasets=[], + regions_dict=None, + ) + fig, stats = cluster.plot_multisite_read_raster( + r, + n_windows=3, + min_separation_bp=2000, + motif_index=0, + motif_count=2, + plot_all_motifs=True, + motif_labels=["A,0", "CG,0"], + x_axis_mode="relative_to_primary", + smoothing=None, + ) + assert fig is not None + assert stats["pairs"] >= 1 + assert stats["n_windows"] == 3 + assert stats["motifs_plotted"] == ["A,0", "CG,0"] + + +def test_plot_multisite_read_raster_supports_explicit_window_centers_and_length_filter(): + import matplotlib + + matplotlib.use("Agg") + motif_a = np.array( + [ + [0, 1, 0, 1], + [1, 0, 1, 0], + [0, 1, 1, 0], + ], + dtype=float, + ) + data = motif_a + meta = [ + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + "read_length": 7000, + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 2500, + "region_end": 2504, + "region_strand": "+", + "read_length": 7000, + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 5000, + "region_end": 5004, + "region_strand": "+", + "read_length": 7000, + }, + ] + r = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=meta, + datasets=[], + regions_dict=None, + ) + fig, stats = cluster.plot_multisite_read_raster( + r, + motif_index=0, + window_center_offsets=[-2500, 0, 2500], + x_axis_mode="relative_to_primary", + smoothing=None, + ) + assert fig is not None + assert stats["n_windows"] == 3 + assert stats["window_center_offsets"] == [-2500.0, 0.0, 2500.0] + assert stats["required_read_length_bp"] > 0 + assert stats["min_read_length_bp"] == stats["required_read_length_bp"] + + +def test_plot_multisite_read_raster_heatmap_centered_titles(): + import matplotlib + + matplotlib.use("Agg") + data = np.array( + [ + [0, 1, 0, 1], + [1, 0, 1, 0], + ], + dtype=float, + ) + meta = [ + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 6000, + "region_end": 6004, + "region_strand": "+", + }, + ] + r = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=meta, + datasets=[], + regions_dict=None, + ) + fig, _ = cluster.plot_multisite_read_raster( + r, + n_windows=2, + min_separation_bp=5000, + motif_index=0, + render_mode="heatmap", + x_axis_mode="centered", + rotate=False, + smoothing=None, + ) + titles = [axis.get_title() for axis in fig.axes if axis.get_title()] + assert "Window 1" in titles + assert "Window 2" in titles + + +def test_plot_multisite_read_raster_multimotif_nonrotated_uses_effective_window_count(): + import matplotlib + + matplotlib.use("Agg") + motif_a = np.array( + [ + [0, 1, 0, 1], + [1, 0, 1, 0], + [0, 1, 1, 0], + ], + dtype=float, + ) + motif_c = np.array( + [ + [1, 0, 1, 0], + [0, 1, 0, 1], + [1, 1, 0, 0], + ], + dtype=float, + ) + data = np.hstack([motif_a, motif_c]) + meta = [ + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + "read_length": 7000, + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 2500, + "region_end": 2504, + "region_strand": "+", + "read_length": 7000, + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 5000, + "region_end": 5004, + "region_strand": "+", + "read_length": 7000, + }, + ] + r = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=meta, + datasets=[], + regions_dict=None, + ) + fig, stats = cluster.plot_multisite_read_raster( + r, + motif_index=0, + motif_count=2, + plot_all_motifs=True, + motif_labels=["A,0", "CG,0"], + window_center_offsets=[-2500, 0, 2500], + center_tolerance_bp=500, + rotate=False, + render_mode="scatter", + x_axis_mode="relative_to_primary", + smoothing=None, + ) + assert stats["n_windows"] == 3 + # 2 motifs x 3 windows + 1 colorbar axis + assert len(fig.axes) == 7 + + +def test_plot_multisite_read_raster_rejects_too_small_min_read_length(): + data = np.array( + [ + [0, 1, 0, 1], + [1, 0, 1, 0], + [0, 1, 1, 0], + ], + dtype=float, + ) + meta = [ + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + "read_length": 7000, + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 2500, + "region_end": 2504, + "region_strand": "+", + "read_length": 7000, + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 5000, + "region_end": 5004, + "region_strand": "+", + "read_length": 7000, + }, + ] + r = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=meta, + datasets=[], + regions_dict=None, + ) + with pytest.raises(ValueError, match="min_read_length_bp"): + cluster.plot_multisite_read_raster( + r, + motif_index=0, + window_center_offsets=[-2500, 0, 2500], + min_read_length_bp=100, + smoothing=None, + ) def test_cluster_read_windows_kmeans(): @@ -399,3 +772,326 @@ def test_cluster_label_mapping_round_trips_labels(): assert mapping == {3: 1, 7: 0} np.testing.assert_array_equal(remapped, np.array([0, 1, -1])) + + +def test_extract_read_windows_infers_shortest_region_window(monkeypatch): + dataset_names = [ + "chromosome", + "mod_vector", + "motif", + "read_end", + "read_name", + "read_start", + "strand", + "val_vector", + "region_start", + "region_end", + "region_strand", + "read_length", + ] + records = [ + ( + "chr1", + np.arange(20, dtype=float), + "A,0", + 120, + "r1", + 100, + "+", + np.ones(20, dtype=float), + 104, + 110, # length 6 -> shortest + "+", + 20, + ), + ( + "chr1", + np.arange(20, dtype=float), + "A,0", + 120, + "r2", + 100, + "+", + np.ones(20, dtype=float), + 102, + 112, # length 10 + "+", + 20, + ), + ] + monkeypatch.setattr( + cluster.load_processed, "read_vectors_from_hdf5", lambda **kwargs: (records, dataset_names, None) + ) + result = cluster.extract_read_windows( + hdf5_file="reads.h5", + motifs=["A,0"], + config=cluster.ReadWindowExtractionConfig(window_size=None, orientation_aware=False), + ) + assert result.data_matrix.shape == (2, 6) + + +def test_classify_read_features_binary_includes_row_index(): + X = np.vstack([np.zeros((8, 3)), np.ones((8, 3))]) + labels = np.array(["a"] * 8 + ["b"] * 8) + result = cluster.classify_read_features_binary( + X, + labels, + classifier="logreg", + random_state=0, + ) + preds = result["predictions"] + assert "row_index" in preds.columns + assert preds["row_index"].between(0, X.shape[0] - 1).all() + assert preds["row_index"].nunique() == X.shape[0] + + +def test_plot_classification_profiles_confusion_smoke(): + import matplotlib + + matplotlib.use("Agg") + data = np.array( + [ + [0, 1, 0, 1], + [1, 0, 1, 0], + [0, 0, 1, 1], + [1, 1, 0, 0], + ], + dtype=float, + ) + preds = pd.DataFrame( + { + "true_label": ["neg", "neg", "pos", "pos"], + "pred_label": ["neg", "pos", "neg", "pos"], + "proba": [0.1, 0.7, 0.4, 0.8], + "split": ["test"] * 4, + "sample_label": ["s"] * 4, + "row_index": [0, 1, 2, 3], + } + ) + fig = cluster.plot_classification_profiles( + data, + preds, + split="test", + group_by="confusion", + show_valid_profile=False, + ) + assert fig is not None + + +def test_plot_region_classification_profiles_smoke(): + import matplotlib + + matplotlib.use("Agg") + X = np.array( + [ + [0.1, 0.2, 0.1, 0.2], + [0.8, 0.7, 0.8, 0.7], + [0.2, 0.1, 0.2, 0.1], + [0.7, 0.8, 0.7, 0.8], + ], + dtype=float, + ) + preds = pd.DataFrame( + { + "true_label": ["neg", "pos", "neg", "pos"], + "pred_label": ["neg", "pos", "pos", "neg"], + "split": ["test"] * 4, + "row_index": [0, 1, 2, 3], + } + ) + fig = cluster.plot_region_classification_profiles( + X, + preds, + split="test", + group_by="confusion", + ) + assert fig is not None + + +def test_plot_classification_profiles_accepts_split_aligned_matrix_with_global_row_index(): + import matplotlib + + matplotlib.use("Agg") + full_matrix = np.array( + [ + [0.0, 0.1, 0.0, 0.1], + [0.9, 0.8, 0.9, 0.8], + [0.2, 0.1, 0.2, 0.1], + [0.8, 0.9, 0.8, 0.9], + [0.1, 0.2, 0.1, 0.2], + [0.7, 0.6, 0.7, 0.6], + ], + dtype=float, + ) + split_rows = np.array([5, 2, 4], dtype=int) + split_matrix = full_matrix[split_rows] + preds = pd.DataFrame( + { + "true_label": ["pos", "neg", "neg"], + "pred_label": ["pos", "neg", "pos"], + "proba": [0.9, 0.2, 0.7], + "split": ["test"] * 3, + "sample_label": ["s"] * 3, + # Global row indices do not fit split_matrix bounds. + "row_index": split_rows, + } + ) + fig = cluster.plot_classification_profiles( + split_matrix, + preds, + split="test", + group_by="pred_label", + ) + assert fig is not None + + +def test_plot_region_classification_profiles_accepts_split_aligned_matrix_with_global_row_index(): + import matplotlib + + matplotlib.use("Agg") + full_matrix = np.array( + [ + [0.1, 0.2, 0.1, 0.2], + [0.8, 0.7, 0.8, 0.7], + [0.2, 0.1, 0.2, 0.1], + [0.7, 0.8, 0.7, 0.8], + [0.3, 0.2, 0.3, 0.2], + [0.6, 0.5, 0.6, 0.5], + ], + dtype=float, + ) + split_rows = np.array([4, 5, 2], dtype=int) + split_matrix = full_matrix[split_rows] + preds = pd.DataFrame( + { + "true_label": ["neg", "pos", "neg"], + "pred_label": ["neg", "pos", "pos"], + "split": ["test"] * 3, + "row_index": split_rows, + } + ) + fig = cluster.plot_region_classification_profiles( + split_matrix, + preds, + split="test", + group_by="confusion", + ) + assert fig is not None + + +def test_plot_cluster_karyotype_handles_non_numeric_cluster_names(tmp_path): + import matplotlib + + matplotlib.use("Agg") + bed = tmp_path / "clusters.bed" + bed.write_text( + "chr1\t0\t10\talpha\t0\t+\n" + "chr1\t20\t40\tbeta\t0\t+\n" + "chr2\t5\t15\talpha\t0\t+\n" + ) + sizes = tmp_path / "chrom.sizes" + sizes.write_text("chr1\t100\nchr2\t80\n") + fig = cluster.plot_cluster_karyotype(bed, sizes) + assert fig is not None + + +def test_infer_shared_window_size(monkeypatch): + def fake_regions_dict_from_input(regions, window_size=None): + if regions == "a.bed": + return {"chr1": [(0, 100, "+"), (50, 120, "+")]} + if regions == "b.bed": + return {"chr1": [(0, 30, "+")], "chr2": [(10, 70, "-")]} + raise ValueError("unexpected input") + + monkeypatch.setattr(cluster.utils, "regions_dict_from_input", fake_regions_dict_from_input) + shared = cluster._infer_shared_window_size(["a.bed", "b.bed"]) + assert shared == 15 + + +def test_merge_read_window_results_center_crop(): + r1 = cluster.ReadWindowExtractionResult( + data_matrix=np.arange(24, dtype=float).reshape(3, 8), + val_matrix=np.ones((3, 8), dtype=float), + metadata=[{"read_name": "r1"}, {"read_name": "r2"}, {"read_name": "r3"}], + datasets=["read_name"], + regions_dict=None, + ) + r2 = cluster.ReadWindowExtractionResult( + data_matrix=np.arange(10, dtype=float).reshape(2, 5), + val_matrix=np.ones((2, 5), dtype=float), + metadata=[{"read_name": "r4"}, {"read_name": "r5"}], + datasets=["read_name"], + regions_dict=None, + ) + merged = cluster.merge_read_window_results( + [r1, r2], + source_labels=["on", "off"], + align="center_crop", + ) + assert merged.data_matrix.shape == (5, 5) + assert merged.val_matrix is not None + assert merged.val_matrix.shape == (5, 5) + assert {m["source_label"] for m in merged.metadata} == {"on", "off"} + + +def test_merge_read_window_results_error_on_mismatch(): + r1 = cluster.ReadWindowExtractionResult( + data_matrix=np.zeros((2, 4), dtype=float), + val_matrix=None, + metadata=[], + datasets=[], + regions_dict=None, + ) + r2 = cluster.ReadWindowExtractionResult( + data_matrix=np.zeros((2, 6), dtype=float), + val_matrix=None, + metadata=[], + datasets=[], + regions_dict=None, + ) + with pytest.raises(ValueError, match="do not match"): + cluster.merge_read_window_results([r1, r2], align="error") + + +def test_extract_read_windows_rejects_nonpositive_window_size(monkeypatch): + dataset_names = [ + "chromosome", + "mod_vector", + "motif", + "read_end", + "read_name", + "read_start", + "strand", + "val_vector", + "region_start", + "region_end", + "region_strand", + "read_length", + ] + records = [ + ( + "chr1", + np.arange(20, dtype=float), + "A,0", + 120, + "r1", + 100, + "+", + np.ones(20, dtype=float), + 104, + 112, + "+", + 20, + ), + ] + monkeypatch.setattr( + cluster.load_processed, + "read_vectors_from_hdf5", + lambda **kwargs: (records, dataset_names, None), + ) + with pytest.raises(ValueError, match="window_size must be a positive integer"): + cluster.extract_read_windows( + hdf5_file="reads.h5", + motifs=["A,0"], + window_size=0, + ) diff --git a/tests/test_dmr.py b/tests/test_dmr.py new file mode 100644 index 0000000..43348ae --- /dev/null +++ b/tests/test_dmr.py @@ -0,0 +1,127 @@ +from __future__ import annotations + +from pathlib import Path + +import pandas as pd + +from dimelo import dmr, run_modkit + + +def _fake_capabilities() -> run_modkit.ModkitCapabilities: + return run_modkit.ModkitCapabilities( + executable="modkit", + version_raw="modkit 0.6.1", + version="0.6.1", + version_tuple=(0, 6, 1), + supports_mod_threshold=True, + supports_mod_thresholds=False, + supports_modified_bases=True, + supports_force_allow_implicit=False, + supports_extract_subcommands=True, + extract_supports_reference_long=True, + extract_supports_reference_short=True, + ) + + +def test_run_dmr_pair_builds_command_and_parses_outputs(tmp_path, monkeypatch): + a = tmp_path / "a.bed.gz" + b = tmp_path / "b.bed.gz" + ref = tmp_path / "ref.fa" + out = tmp_path / "pair.bed" + seg = tmp_path / "pair.segment.bed" + for path in (a, b, ref): + path.write_text("x") + + captured: dict[str, object] = {} + + def fake_run(cmd, check): + captured["cmd"] = list(cmd) + out.write_text( + "#chrom\tstart\tend\tscore\tmap_pvalue\teffect_size\ta_total\n" + "chr1\t1\t2\t0.3\t0.001\t0.4\t10\n" + "chr1\t3\t4\t0.01\t0.6\t0.01\t3\n" + ) + seg.write_text("#chrom\tchrom_start\tchrom_end\tname\tscore\nchr1\t1\t10\tdiff\t0.2\n") + return None + + monkeypatch.setattr(dmr.subprocess, "run", fake_run) + monkeypatch.setattr(run_modkit, "_ensure_modkit_available", lambda **_: _fake_capabilities()) + + result = dmr.run_dmr_pair( + control_bed_methyl=a, + experiment_bed_methyl=b, + ref_genome=ref, + out_path=out, + segment_path=seg, + bases=["A"], + threads=2, + io_threads=1, + min_total_coverage=5, + ) + + assert isinstance(result.sites, pd.DataFrame) + assert isinstance(result.segments, pd.DataFrame) + assert result.high_confidence_sites.shape[0] == 1 + command = captured["cmd"] + assert "--segment" in command + assert "--base" in command + assert "--header" in command + + +def test_run_dmr_pair_rejects_regions_and_segment_together(tmp_path): + a = tmp_path / "a.bed.gz" + b = tmp_path / "b.bed.gz" + ref = tmp_path / "ref.fa" + regions = tmp_path / "regions.bed" + for path in (a, b, ref, regions): + path.write_text("x") + + try: + dmr.run_dmr_pair( + control_bed_methyl=a, + experiment_bed_methyl=b, + ref_genome=ref, + out_path=tmp_path / "out.bed", + regions_bed=regions, + segment_path=tmp_path / "seg.bed", + ) + except ValueError as exc: + assert "does not allow --regions-bed with --segment" in str(exc) + else: # pragma: no cover + raise AssertionError("Expected ValueError for regions_bed + segment_path") + + +def test_run_dmr_multi_collects_pair_files(tmp_path, monkeypatch): + sample_a = tmp_path / "a.bed.gz" + sample_b = tmp_path / "b.bed.gz" + regions = tmp_path / "regions.bed" + ref = tmp_path / "ref.fa" + out_dir = tmp_path / "dmr_multi" + for path in (sample_a, sample_b, regions, ref): + path.write_text("x") + + captured: dict[str, object] = {} + + def fake_run(cmd, check): + captured["cmd"] = list(cmd) + out_dir.mkdir(parents=True, exist_ok=True) + (out_dir / "s1_vs_s2.bed").write_text("chr1\t1\t2\n") + return None + + monkeypatch.setattr(dmr.subprocess, "run", fake_run) + monkeypatch.setattr(run_modkit, "_ensure_modkit_available", lambda **_: _fake_capabilities()) + + result = dmr.run_dmr_multi( + samples={"s1": sample_a, "s2": sample_b}, + regions_bed=regions, + ref_genome=ref, + out_dir=out_dir, + bases=["A"], + threads=2, + ) + + assert result.pair_files.shape[0] == 1 + assert result.pair_files.iloc[0]["pair_name"] == "s1_vs_s2" + command = captured["cmd"] + assert "--sample" in command + assert "--regions-bed" in command diff --git a/tests/test_load_processed_aliases.py b/tests/test_load_processed_aliases.py deleted file mode 100644 index 1999bdb..0000000 --- a/tests/test_load_processed_aliases.py +++ /dev/null @@ -1,81 +0,0 @@ -import numpy as np - -from dimelo import load_processed - - -def test_counts_from_pileup_alias_forwards_arguments(monkeypatch): - captured = {} - - def _fake_counts_from_bedmethyl(**kwargs): - captured.update(kwargs) - return (3, 9) - - monkeypatch.setattr( - load_processed, - "pileup_counts_from_bedmethyl", - _fake_counts_from_bedmethyl, - ) - - result = load_processed.counts_from_pileup( - bedmethyl_file="reads.bed.gz", - motif="A,0", - regions="chr1:10-20", - window_size=50, - single_strand=True, - quiet=True, - cores=2, - chunk_size=123, - ) - - assert result == (3, 9) - assert captured == { - "bedmethyl_file": "reads.bed.gz", - "motif": "A,0", - "regions": "chr1:10-20", - "window_size": 50, - "single_strand": True, - "quiet": True, - "cores": 2, - "chunk_size": 123, - } - - -def test_vectors_from_pileup_alias_forwards_arguments(monkeypatch): - captured = {} - expected = (np.array([1, 2, 3]), np.array([4, 5, 6])) - - def _fake_vectors_from_bedmethyl(**kwargs): - captured.update(kwargs) - return expected - - monkeypatch.setattr( - load_processed, - "pileup_vectors_from_bedmethyl", - _fake_vectors_from_bedmethyl, - ) - - result = load_processed.vectors_from_pileup( - bedmethyl_file="reads.bed.gz", - motif="CG,0", - regions="chr2:100-200", - window_size=25, - single_strand=False, - regions_5to3prime=True, - quiet=False, - cores=4, - chunk_size=999, - ) - - np.testing.assert_array_equal(result[0], expected[0]) - np.testing.assert_array_equal(result[1], expected[1]) - assert captured == { - "bedmethyl_file": "reads.bed.gz", - "motif": "CG,0", - "regions": "chr2:100-200", - "window_size": 25, - "single_strand": False, - "regions_5to3prime": True, - "quiet": False, - "cores": 4, - "chunk_size": 999, - } diff --git a/tests/test_models.py b/tests/test_models.py index d20e12c..76d1444 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -6,8 +6,11 @@ from dimelo import models from dimelo.models import ( BatchJob, + ChipAtlasEnrichmentResult, CohortSpec, ContrastSpec, + ModkitDMRMultiResult, + ModkitDMRPairResult, GlobalAnalysisResult, DatasetArtifact, SampleSpec, @@ -25,6 +28,12 @@ def test_dimelo_package_exports_models(): assert models.SampleSpec is SampleSpec +def test_dimelo_package_exports_dmr_module(): + from dimelo import dmr as root_dmr + + assert root_dmr is not None + + def test_dimelo_package_root_exports_region_discovery_cluster_result(): from dimelo import RegionDiscoveryClusterResult as RootRegionDiscoveryClusterResult @@ -39,6 +48,18 @@ def test_dimelo_package_root_exports_region_discovery_cluster_contrast_result(): assert RootRegionDiscoveryClusterContrastResult is RegionDiscoveryClusterContrastResult +def test_dimelo_package_root_exports_chip_atlas_enrichment_result(): + from dimelo import ChipAtlasEnrichmentResult as RootChipAtlasEnrichmentResult + + assert RootChipAtlasEnrichmentResult is ChipAtlasEnrichmentResult + + +def test_dimelo_package_root_exports_modkit_dmr_pair_result(): + from dimelo import ModkitDMRPairResult as RootModkitDMRPairResult + + assert RootModkitDMRPairResult is ModkitDMRPairResult + + def test_sample_spec_fields(): sample = SampleSpec( sample_id="sample-1", @@ -57,6 +78,36 @@ def test_sample_spec_fields(): assert sample.metadata == {"batch": "A"} +def test_chip_atlas_enrichment_result_requires_request_id(): + with pytest.raises(ValueError, match="request_id"): + ChipAtlasEnrichmentResult( + request_id="", + status="finished", + results=pd.DataFrame(), + ) + + +def test_modkit_dmr_pair_result_requires_core_outputs(): + with pytest.raises(ValueError, match="output_path"): + ModkitDMRPairResult( + output_path=None, + segment_path=None, + command=["modkit", "dmr", "pair"], + sites=pd.DataFrame(), + segments=None, + high_confidence_sites=pd.DataFrame(), + ) + + +def test_modkit_dmr_multi_result_requires_pair_files(): + with pytest.raises(ValueError, match="pair_files"): + ModkitDMRMultiResult( + out_dir=Path("/tmp"), + command=["modkit", "dmr", "multi"], + pair_files=None, + ) + + def test_dataset_artifact_stores_metadata(): artifact = DatasetArtifact( sample_id="sample-1", diff --git a/tests/test_parse_bam.py b/tests/test_parse_bam.py index f8423e4..cfa3598 100644 --- a/tests/test_parse_bam.py +++ b/tests/test_parse_bam.py @@ -1,7 +1,7 @@ import pytest from pathlib import Path -from dimelo import parse_bam +from dimelo import parse_bam, run_modkit class _FakeRead: @@ -109,3 +109,198 @@ def test_create_region_command_list_writes_processed_bed(tmp_path): assert bed_path == Path(tmp_path) / "regions.processed.bed" assert command == ["--include-bed", str(bed_path)] assert bed_path.exists() + + +def test_build_pileup_targeting_command_list_routes_to_modified_bases_on_modkit_0_6(): + capabilities = run_modkit.ModkitCapabilities( + executable="modkit", + version_raw="modkit 0.6.1", + version="0.6.1", + version_tuple=(0, 6, 1), + supports_mod_threshold=True, + supports_mod_thresholds=False, + supports_modified_bases=True, + supports_force_allow_implicit=False, + supports_extract_subcommands=True, + extract_supports_reference_long=True, + extract_supports_reference_short=True, + ) + + command = parse_bam._build_pileup_targeting_command_list( + motifs=["A,0,Y", "CG,0,Z"], + capabilities=capabilities, + ) + + assert "--modified-bases" in command + assert "A:Y" in command + assert "C:Z" in command + assert "--cpg" in command + assert "--motif" not in command + + +def test_build_pileup_targeting_command_list_uses_version_fallback_for_modkit_0_6(): + capabilities = run_modkit.ModkitCapabilities( + executable="modkit", + version_raw="modkit 0.6.1", + version="0.6.1", + version_tuple=(0, 6, 1), + supports_mod_threshold=True, + supports_mod_thresholds=False, + # Simulate stale/incorrect capability detection. + supports_modified_bases=False, + supports_force_allow_implicit=False, + supports_extract_subcommands=True, + extract_supports_reference_long=True, + extract_supports_reference_short=True, + ) + + command = parse_bam._build_pileup_targeting_command_list( + motifs=["A,0", "CG,0"], + capabilities=capabilities, + ) + + assert "--modified-bases" in command + assert "A:Y" in command + assert "A:a" in command + assert "C:Z" in command + assert "C:m" in command + assert "--motif" not in command + + +def test_build_mod_threshold_command_list_routes_flag_by_modkit_capabilities(): + legacy = run_modkit.ModkitCapabilities( + executable="modkit", + version_raw="modkit 0.2.4", + version="0.2.4", + version_tuple=(0, 2, 4), + supports_mod_threshold=False, + supports_mod_thresholds=True, + supports_modified_bases=False, + supports_force_allow_implicit=True, + supports_extract_subcommands=False, + extract_supports_reference_long=False, + extract_supports_reference_short=True, + ) + modern = run_modkit.ModkitCapabilities( + executable="modkit", + version_raw="modkit 0.6.1", + version="0.6.1", + version_tuple=(0, 6, 1), + supports_mod_threshold=True, + supports_mod_thresholds=False, + supports_modified_bases=True, + supports_force_allow_implicit=False, + supports_extract_subcommands=True, + extract_supports_reference_long=True, + extract_supports_reference_short=True, + ) + + legacy_flags = parse_bam._build_mod_threshold_command_list( + motifs=["A,0,Y"], + motif_thresholds={"A,0,Y": 0.75}, + capabilities=legacy, + ) + modern_flags = parse_bam._build_mod_threshold_command_list( + motifs=["A,0,Y"], + motif_thresholds={"A,0,Y": 0.75}, + capabilities=modern, + ) + + assert legacy_flags == ["--mod-thresholds", "Y:0.75"] + assert modern_flags == ["--mod-threshold", "Y:0.75"] + + +def test_build_mod_threshold_command_list_rejects_conflicting_thresholds_for_shared_mod_code(): + capabilities = run_modkit.ModkitCapabilities( + executable="modkit", + version_raw="modkit 0.6.1", + version="0.6.1", + version_tuple=(0, 6, 1), + supports_mod_threshold=True, + supports_mod_thresholds=False, + supports_modified_bases=True, + supports_force_allow_implicit=False, + supports_extract_subcommands=True, + extract_supports_reference_long=True, + extract_supports_reference_short=True, + ) + + with pytest.raises( + ValueError, + match="Cannot apply different thresholds to motifs that share mod code", + ): + parse_bam._build_mod_threshold_command_list( + motifs=["A,0,a", "GATC,1,a"], + motif_thresholds={"A,0,a": 0.7, "GATC,1,a": 0.8}, + capabilities=capabilities, + ) + + +def test_resolve_motif_thresholds_accepts_scalar_and_per_motif_dict(): + motifs = ["A,0", "CG,0", "GCH,1"] + + scalar = parse_bam._resolve_motif_thresholds( + motifs=motifs, + thresh=0.7, + quiet=True, + ) + assert scalar == {"A,0": 0.7, "CG,0": 0.7, "GCH,1": 0.7} + + by_motif = parse_bam._resolve_motif_thresholds( + motifs=motifs, + thresh={"A,0": 0.6, "CG,0": 0.8, "default": 0.9}, + quiet=True, + ) + assert by_motif == {"A,0": 0.6, "CG,0": 0.8, "GCH,1": 0.9} + + +def test_resolve_motif_thresholds_supports_canonical_key_alias(): + thresholds = parse_bam._resolve_motif_thresholds( + motifs=["A,0,a", "CG,0,m"], + thresh={"A,0": 0.65, "CG,0": 0.75}, + quiet=True, + ) + assert thresholds == {"A,0,a": 0.65, "CG,0,m": 0.75} + + +def test_build_extract_command_prefix_uses_full_subcommand_for_modkit_0_6(): + modern = run_modkit.ModkitCapabilities( + executable="modkit", + version_raw="modkit 0.6.1", + version="0.6.1", + version_tuple=(0, 6, 1), + supports_mod_threshold=True, + supports_mod_thresholds=False, + supports_modified_bases=True, + supports_force_allow_implicit=False, + supports_extract_subcommands=True, + extract_supports_reference_long=True, + extract_supports_reference_short=True, + ) + legacy = run_modkit.ModkitCapabilities( + executable="modkit", + version_raw="modkit 0.2.4", + version="0.2.4", + version_tuple=(0, 2, 4), + supports_mod_threshold=False, + supports_mod_thresholds=True, + supports_modified_bases=False, + supports_force_allow_implicit=True, + supports_extract_subcommands=False, + extract_supports_reference_long=False, + extract_supports_reference_short=True, + ) + + modern_prefix = parse_bam._build_extract_command_prefix( + input_file=Path("input.bam"), + output_txt=Path("out.txt"), + capabilities=modern, + ) + legacy_prefix = parse_bam._build_extract_command_prefix( + input_file=Path("input.bam"), + output_txt=Path("out.txt"), + capabilities=legacy, + ) + + assert modern_prefix == ["modkit", "extract", "full", Path("input.bam"), Path("out.txt")] + assert legacy_prefix == ["modkit", "extract", Path("input.bam"), Path("out.txt")] diff --git a/tests/test_parse_bam_vectors.py b/tests/test_parse_bam_vectors.py index c456829..89f921c 100644 --- a/tests/test_parse_bam_vectors.py +++ b/tests/test_parse_bam_vectors.py @@ -1,4 +1,5 @@ import gzip +import json from pathlib import Path import h5py @@ -229,6 +230,73 @@ def test_read_by_base_txt_to_hdf5_thresholds_at_write_time(tmp_path): ) +def test_read_by_base_txt_to_hdf5_stores_per_motif_threshold_metadata(tmp_path): + input_txt = tmp_path / "extract.txt" + output_h5 = tmp_path / "reads_thresholded_multi_motif.h5" + _write_extract_file(input_txt) + + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=0.6, + quiet=True, + ) + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="CG,0", + thresh=0.8, + quiet=True, + ) + + with h5py.File(output_h5, "r") as h5: + assert np.isclose(h5["threshold"][()], 0.0) + threshold_map_raw = h5["threshold_by_motif_json"][()] + if isinstance(threshold_map_raw, bytes): + threshold_map_raw = threshold_map_raw.decode("utf-8") + assert json.loads(threshold_map_raw) == {"A,0": 0.6, "CG,0": 0.8} + + read_tuples, datasets, _ = load_processed.read_vectors_from_hdf5( + file=output_h5, + motifs=["A,0", "CG,0"], + calculate_mod_fractions=False, + quiet=True, + ) + mod_vector_index = datasets.index("mod_vector") + val_vector_index = datasets.index("val_vector") + + assert len(read_tuples) == 4 + assert all(read_tuple[mod_vector_index].dtype == np.bool_ for read_tuple in read_tuples) + assert all(read_tuple[val_vector_index].dtype == np.bool_ for read_tuple in read_tuples) + + +def test_read_by_base_txt_to_hdf5_rejects_mixed_raw_and_thresholded_motifs(tmp_path): + input_txt = tmp_path / "extract.txt" + output_h5 = tmp_path / "reads_mixed_threshold_modes.h5" + _write_extract_file(input_txt) + + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=None, + quiet=True, + ) + + with pytest.raises( + ValueError, + match="Cannot mix raw-probability and thresholded motifs", + ): + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="CG,0", + thresh=0.7, + quiet=True, + ) + + def test_read_vectors_from_hdf5_loads_thresholded_vectors_as_binary(tmp_path): input_txt = tmp_path / "extract.txt" output_h5 = tmp_path / "reads_thresholded.h5" diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 2a5a13b..ba2549f 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -10,7 +10,14 @@ SharedClusterModel, SharedClusterResult, ) -from dimelo import plot_enrichment_profile, plot_reads, plotting +from dimelo import ( + plot_depth_histogram, + plot_depth_profile, + plot_enrichment, + plot_enrichment_profile, + plot_reads, + plotting, +) @pytest.fixture(autouse=True) @@ -35,6 +42,151 @@ def test_axis_spec_accepts_fixed_window_region_5to3(): plotting.validate_axis_spec(spec, plot_family="aggregate_profile") +def test_plot_enrichment_by_regions_accepts_regions_alias(monkeypatch): + captured = {} + + def fake_plot_enrichment(**kwargs): + captured.update(kwargs) + return "axes" + + monkeypatch.setattr(plot_enrichment, "plot_enrichment", fake_plot_enrichment) + + axes = plot_enrichment.by_regions( + mod_file_name="pileup.fake", + regions=["one.bed", "two.bed"], + motif="A,0", + ) + + assert axes == "axes" + assert captured["regions_list"] == ["one.bed", "two.bed"] + assert captured["sample_names"] == ["one.bed", "two.bed"] + + +def test_plot_depth_profile_by_regions_accepts_regions_alias(monkeypatch): + captured = {} + + def fake_plot_depth_profile(**kwargs): + captured.update(kwargs) + return "axes" + + monkeypatch.setattr(plot_depth_profile, "plot_depth_profile", fake_plot_depth_profile) + + axes = plot_depth_profile.by_regions( + mod_file_name="pileup.fake", + regions=["one.bed", "two.bed"], + motif="A,0", + ) + + assert axes == "axes" + assert captured["regions_list"] == ["one.bed", "two.bed"] + assert captured["sample_names"] == ["one.bed depth", "two.bed depth"] + + +def test_plot_enrichment_profile_by_regions_accepts_regions_alias(monkeypatch): + captured = {} + + def fake_plot_enrichment_profile(**kwargs): + captured.update(kwargs) + return "axes" + + monkeypatch.setattr( + plot_enrichment_profile, + "plot_enrichment_profile", + fake_plot_enrichment_profile, + ) + + axes = plot_enrichment_profile.by_regions( + mod_file_name="pileup.fake", + regions=["one.bed", "two.bed"], + motif="A,0", + ) + + assert axes == "axes" + assert captured["regions_list"] == ["one.bed", "two.bed"] + assert captured["sample_names"] == ["one.bed", "two.bed"] + + +def test_make_enrichment_profile_plot_defaults_motif_legend_title(): + import matplotlib + + matplotlib.use("Agg") + + axes = plot_enrichment_profile.make_enrichment_profile_plot( + trace_vectors=[np.array([0.1, 0.2, 0.3]), np.array([0.2, 0.1, 0.0])], + sample_names=["A,0", "CG,0"], + ) + + legend = axes.get_legend() + assert legend is not None + assert legend.get_title().get_text() == "Modifications (motif, mod_index)" + + +def test_make_depth_profile_plot_defaults_axis_and_legend_labels(): + import matplotlib + + matplotlib.use("Agg") + + axes = plot_depth_profile.make_depth_profile_plot( + trace_vectors=[np.array([1.0, 2.0, 3.0]), np.array([3.0, 2.0, 1.0])], + sample_names=["A,0 depth", "CG,0 depth"], + ) + + assert axes.get_xlabel() == "Position (bp)" + legend = axes.get_legend() + assert legend is not None + assert legend.get_title().get_text() == "Mod, index" + + +def test_plot_depth_histogram_by_regions_accepts_regions_alias(monkeypatch): + captured = {} + + def fake_plot_depth_histogram(**kwargs): + captured.update(kwargs) + return "axes" + + monkeypatch.setattr( + plot_depth_histogram, + "plot_depth_histogram", + fake_plot_depth_histogram, + ) + + axes = plot_depth_histogram.by_regions( + mod_file_name="pileup.fake", + regions=["one.bed", "two.bed"], + motif="A,0", + ) + + assert axes == "axes" + assert captured["regions_list"] == ["one.bed", "two.bed"] + assert captured["sample_names"] == ["one.bed depth", "two.bed depth"] + + +def test_get_depth_counts_forwards_split_large_regions(monkeypatch): + captured = {} + + def fake_regions_to_list(*, split_large_regions=False, **kwargs): + captured["split_large_regions"] = split_large_regions + return [(np.array([1, 0, 2]), np.array([4, 0, 6]))] + + monkeypatch.setattr( + plot_depth_histogram.load_processed, + "regions_to_list", + fake_regions_to_list, + ) + + depth_vectors = plot_depth_histogram.get_depth_counts( + mod_file_names=["pileup.bed.gz"], + regions_list=["regions.bed"], + motifs=["A,0"], + window_size=1000, + split_large_regions=True, + ) + + assert captured["split_large_regions"] is True + assert len(depth_vectors) == 1 + np.testing.assert_array_equal(depth_vectors[0], np.array([4, 6])) + + def test_axis_spec_rejects_segment_map_without_segments(): spec = plotting.AxisSpec( orientation="region_5to3", @@ -1085,6 +1237,255 @@ def test_plot_shared_cluster_region_matplotlib_rejects_duplicate_row_cluster_val plotting_matplotlib.plot_shared_cluster_region_matplotlib(payload) +def _make_read_cluster_region_association_table() -> pd.DataFrame: + return pd.DataFrame( + [ + { + "chrom": "chr1", + "start": 10, + "end": 20, + "strand": "+", + "cluster": "C0", + "fraction": 0.25, + "log2_enrichment": -1.0, + }, + { + "chrom": "chr1", + "start": 10, + "end": 20, + "strand": "+", + "cluster": "C1", + "fraction": 0.75, + "log2_enrichment": 1.5, + }, + { + "chrom": "chr1", + "start": 30, + "end": 40, + "strand": "-", + "cluster": "C0", + "fraction": 0.60, + "log2_enrichment": 0.25, + }, + { + "chrom": "chr1", + "start": 30, + "end": 40, + "strand": "-", + "cluster": "C1", + "fraction": 0.40, + "log2_enrichment": -0.10, + }, + ] + ) + + +def test_prepare_read_cluster_region_association_data_accepts_long_form_fraction_table(): + table = _make_read_cluster_region_association_table() + + payload = plotting.prepare_read_cluster_region_association_data(table) + + association_table = payload["association_table"] + matrix_table = payload["matrix_table"] + top_regions_table = payload["top_regions_table"] + + assert list(association_table["region_id"].drop_duplicates()) == ["chr1:10-20:+", "chr1:30-40:-"] + assert list(matrix_table.columns) == ["region_id", "C0", "C1"] + assert list(matrix_table["region_id"]) == ["chr1:10-20:+", "chr1:30-40:-"] + np.testing.assert_allclose( + matrix_table.loc[:, ["C0", "C1"]].to_numpy(), + np.array([[0.25, 0.75], [0.60, 0.40]]), + ) + assert top_regions_table.iloc[0]["cluster"] == "C0" + assert top_regions_table.iloc[0]["region_id"] == "chr1:30-40:-" + assert top_regions_table.iloc[0]["value"] == pytest.approx(0.60) + + +def test_prepare_read_cluster_region_association_data_uses_requested_log2_enrichment_values(): + table = _make_read_cluster_region_association_table() + + payload = plotting.prepare_read_cluster_region_association_data( + table, + value_mode="log2_enrichment", + top_n_regions_per_cluster=1, + ) + + matrix_table = payload["matrix_table"] + top_regions_table = payload["top_regions_table"] + + assert list(matrix_table.columns) == ["region_id", "C0", "C1"] + np.testing.assert_allclose( + matrix_table.loc[:, ["C0", "C1"]].to_numpy(), + np.array([[-1.0, 1.5], [0.25, -0.10]]), + ) + assert list(top_regions_table["cluster"]) == ["C0", "C1"] + assert list(top_regions_table["region_id"]) == ["chr1:30-40:-", "chr1:10-20:+"] + assert list(top_regions_table["value"]) == [pytest.approx(0.25), pytest.approx(1.5)] + + +def test_prepare_read_cluster_region_association_data_supports_genomic_sort(): + table = _make_read_cluster_region_association_table() + + payload = plotting.prepare_read_cluster_region_association_data( + table, + region_sort="genomic", + ) + + assert payload["metadata"]["region_sort"] == "genomic" + assert list(payload["matrix_table"]["region_id"]) == ["chr1:10-20:+", "chr1:30-40:-"] + assert "region_axis_table" in payload + + +def test_prepare_read_cluster_region_association_data_supports_association_strength_sort(): + table = _make_read_cluster_region_association_table() + + payload = plotting.prepare_read_cluster_region_association_data( + table, + region_sort="association_strength", + association_strength_aggregate="max", + ) + + # chr1:10-20:+ has max value 0.75, chr1:30-40:- has max value 0.60 + assert list(payload["matrix_table"]["region_id"]) == ["chr1:10-20:+", "chr1:30-40:-"] + assert payload["metadata"]["association_strength_aggregate"] == "max" + + +def test_prepare_read_cluster_region_association_data_accepts_legacy_wide_region_summary(): + legacy_summary = pd.DataFrame( + [ + { + "chrom": "chr1", + "start": 10, + "end": 20, + "strand": "+", + 0: 2, + 1: 1, + "total_reads": 3, + "dominant_cluster": 0, + "dominant_fraction": 2 / 3, + "entropy": 0.6365141682948128, + }, + { + "chrom": "chr1", + "start": 30, + "end": 40, + "strand": "-", + 0: 3, + 1: 2, + "total_reads": 5, + "dominant_cluster": 0, + "dominant_fraction": 3 / 5, + "entropy": 0.6730116670092565, + }, + ] + ) + + payload = plotting.prepare_read_cluster_region_association_data( + legacy_summary, + top_n_regions_per_cluster=1, + ) + + association_table = payload["association_table"] + matrix_table = payload["matrix_table"] + top_regions_table = payload["top_regions_table"] + + assert list(association_table["region_id"].drop_duplicates()) == ["chr1:10-20:+", "chr1:30-40:-"] + assert list(matrix_table.columns) == ["region_id", 0, 1] + np.testing.assert_allclose( + matrix_table.loc[:, [0, 1]].to_numpy(), + np.array([[2 / 3, 1 / 3], [3 / 5, 2 / 5]]), + ) + assert list(top_regions_table["cluster"]) == [0, 1] + assert top_regions_table.iloc[0]["region_id"] == "chr1:10-20:+" + assert top_regions_table.iloc[0]["value"] == pytest.approx(2 / 3) + + +def test_prepare_read_cluster_region_association_data_rejects_missing_requested_mode(): + table = _make_read_cluster_region_association_table().drop(columns=["log2_enrichment"]) + + with pytest.raises(ValueError, match="log2_enrichment"): + plotting.prepare_read_cluster_region_association_data( + table, + value_mode="log2_enrichment", + ) + + +def test_plot_read_cluster_region_association_heatmap_matplotlib_returns_figure_and_axis(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_read_cluster_region_association_data(_make_read_cluster_region_association_table()) + + fig, ax = plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib(payload) + + assert fig is not None + assert ax is not None + assert [tick.get_text() for tick in ax.get_xticklabels()] == ["C0", "C1"] + assert [tick.get_text() for tick in ax.get_yticklabels()] == ["chr1:10-20:+", "chr1:30-40:-"] + np.testing.assert_allclose( + np.asarray(ax.images[0].get_array()), + np.array([[0.25, 0.75], [0.60, 0.40]]), + ) + + +def test_plot_read_cluster_region_association_heatmap_matplotlib_supports_row_annotations(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_read_cluster_region_association_data( + _make_read_cluster_region_association_table(), + region_sort="genomic", + ) + axis_table = payload["region_axis_table"].copy() + axis_table["source_label"] = ["on_target", "off_target"] + payload["region_axis_table"] = axis_table + + fig, ax = plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib( + payload, + row_annotation_column="source_label", + row_annotation_title="Source bed", + row_annotation_palette={"on_target": "#D95F02", "off_target": "#1B9E77"}, + ) + + assert fig is not None + assert ax is not None + ytick_text = [tick.get_text() for tick in ax.get_yticklabels()] + assert "on_target" in ytick_text[0] + assert "off_target" in ytick_text[1] + + +def test_plot_read_cluster_region_association_heatmap_matplotlib_grouped_region_labels(): + from dimelo import plotting_matplotlib + + table = pd.DataFrame( + [ + {"region_id": "chr1:10-20:+", "cluster": 0, "fraction": 0.20}, + {"region_id": "chr1:10-20:+", "cluster": 1, "fraction": 0.80}, + {"region_id": "chr1:30-40:+", "cluster": 0, "fraction": 0.25}, + {"region_id": "chr1:30-40:+", "cluster": 1, "fraction": 0.75}, + {"region_id": "chr2:10-20:+", "cluster": 0, "fraction": 0.70}, + {"region_id": "chr2:10-20:+", "cluster": 1, "fraction": 0.30}, + {"region_id": "chr2:30-40:+", "cluster": 0, "fraction": 0.65}, + {"region_id": "chr2:30-40:+", "cluster": 1, "fraction": 0.35}, + ] + ) + payload = plotting.prepare_read_cluster_region_association_data(table, region_sort="genomic") + axis_table = payload["region_axis_table"].copy() + axis_table["source_label"] = ["on_target", "on_target", "off_target", "off_target"] + payload["region_axis_table"] = axis_table + + fig, ax = plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib( + payload, + region_label_mode="genomic", + row_annotation_column="source_label", + group_region_labels=True, + ) + + assert fig is not None + assert ax is not None + ylabels = [tick.get_text() for tick in ax.get_yticklabels()] + assert "on_target | chr1" in ylabels + assert "off_target | chr2" in ylabels + + def _minimal_region_contrast_result() -> RegionContrastResult: regions = pd.DataFrame( [ @@ -2754,6 +3155,68 @@ def set_xlim(self, limits): assert list(captured["table"]["region_strand"]) == ["+"] +def test_plot_reads_defaults_read_index_axis_and_legend(monkeypatch): + captured = {} + + def fake_loader(**kwargs): + return ( + [np.array([100.0, 101.0]), np.array([200.0])], + np.array(["read-1", "read-2"]), + np.array(["A,0", "CG,0"]), + {"chr1": [(90, 210, "+")]}, + ) + + real_prepare = plotting.prepare_single_read_plot_data + + def spy_prepare(table, *, plot_family, axis, **kwargs): + captured["table"] = table.copy() + return real_prepare(table, plot_family=plot_family, axis=axis, **kwargs) + + class FakeAxes: + def __init__(self): + self.legend_ = None + self.xlabel = None + self.ylabel = None + + def legend(self, *args, **kwargs): + self.legend_args = (args, kwargs) + + def get_legend_handles_labels(self): + return ([], []) + + def set_xlim(self, limits): + self.xlim = limits + + def set_xlabel(self, label): + self.xlabel = label + + def set_ylabel(self, label): + self.ylabel = label + + monkeypatch.setattr( + "dimelo.plot_reads.load_processed.readwise_binary_modification_arrays", + fake_loader, + ) + monkeypatch.setattr( + "dimelo.plot_reads.plotting.prepare_single_read_plot_data", + spy_prepare, + ) + monkeypatch.setattr("dimelo.plot_reads.sns.scatterplot", lambda **kwargs: FakeAxes()) + + axes = plot_reads.plot_reads( + mod_file_name="sample.h5", + regions="regions.bed", + motifs=["A,0", "CG,0"], + window_size=50, + relative=True, + ) + + assert list(captured["table"]["read_index"]) == [0, 0, 1] + assert axes.xlabel == "Position (bp)" + assert axes.ylabel == "Read index" + assert axes.legend_args[1]["title"] == "Mod, index" + + def test_prepare_aggregate_plot_data_builds_concatenated_segment_axis(): table = pd.DataFrame( [ diff --git a/tests/test_regulatory_enrichment.py b/tests/test_regulatory_enrichment.py new file mode 100644 index 0000000..b5b9c2d --- /dev/null +++ b/tests/test_regulatory_enrichment.py @@ -0,0 +1,400 @@ +from pathlib import Path + +import pytest + +from dimelo import regulatory_enrichment, workflows +from dimelo.models import UniBindJobResult + + +def test_regulatory_spec_defaults_to_human_and_enables_screen_and_unibind(): + spec = regulatory_enrichment.RegulatoryEnrichmentSpec() + + assert spec.species == "homo_sapiens" + assert spec.target_genome == "hg38" + assert spec.enabled_providers == ("screen", "unibind") + assert spec.provider_notes == {} + + +def test_regulatory_spec_infers_mouse_from_target_genome(): + spec = regulatory_enrichment.RegulatoryEnrichmentSpec( + species=None, + target_genome="mm10", + ) + + assert spec.species == "mus_musculus" + assert spec.enabled_providers == ("screen", "unibind") + + +def test_regulatory_spec_filters_screen_for_non_screen_species(): + spec = regulatory_enrichment.RegulatoryEnrichmentSpec( + species="rat", + providers=("screen", "unibind"), + ) + + assert spec.species == "rattus_norvegicus" + assert spec.enabled_providers == ("unibind",) + assert "screen" in spec.provider_notes + assert "supports only homo_sapiens and mus_musculus" in spec.provider_notes["screen"] + + +def test_regulatory_spec_can_raise_on_filtered_screen_when_strict(): + with pytest.raises(regulatory_enrichment.RegulatoryEnrichmentSpecError, match="SCREEN disabled"): + regulatory_enrichment.RegulatoryEnrichmentSpec( + species="rattus norvegicus", + providers=("screen",), + strict_provider_support=True, + ) + + +def test_regulatory_spec_rejects_species_not_supported_by_unibind(): + with pytest.raises(regulatory_enrichment.RegulatoryEnrichmentSpecError, match="Unsupported species"): + regulatory_enrichment.RegulatoryEnrichmentSpec( + species="bos_taurus", + providers=("unibind",), + ) + + +def test_regulatory_spec_preserves_arbitrary_genome_and_chain_fields(): + spec = regulatory_enrichment.RegulatoryEnrichmentSpec( + species="human", + providers=("unibind",), + reference_genome="custom_build_v2", + target_genome="custom_build_v3", + crossmap_chain_file=Path("cache/chains/custom.over.chain.gz"), + crossmap_chain_url="https://example.org/custom.chain.gz", + crossmap_chain_cache_dir=Path("cache/chains/custom"), + crossmap_executable="CrossMap", + ) + + serialized = spec.as_dict() + assert serialized["reference_genome"] == "custom_build_v2" + assert serialized["target_genome"] == "custom_build_v3" + assert serialized["crossmap_chain_file"] == "cache/chains/custom.over.chain.gz" + assert serialized["crossmap_chain_url"] == "https://example.org/custom.chain.gz" + assert serialized["crossmap_chain_cache_dir"] == "cache/chains/custom" + assert serialized["crossmap_executable"] == "CrossMap" + + +def test_workflow_wrapper_returns_regulatory_spec(): + spec = workflows.resolve_regulatory_enrichment_spec( + species="mouse", + providers=("screen", "unibind"), + reference_genome="mm39", + ) + + assert isinstance(spec, regulatory_enrichment.RegulatoryEnrichmentSpec) + assert spec.species == "mus_musculus" + assert spec.enabled_providers == ("screen", "unibind") + + +def test_provider_alias_normalization_and_deduplication(): + spec = regulatory_enrichment.RegulatoryEnrichmentSpec( + species="human", + providers=("SCREEN2.0", "screen", "UniBind2021", "unibind"), + ) + + assert spec.providers == ("screen", "unibind") + assert spec.enabled_providers == ("screen", "unibind") + + +def test_unibind_trackhub_url_supports_named_collections(): + robust = regulatory_enrichment.unibind_trackhub_url("robust") + permissive = regulatory_enrichment.unibind_trackhub_url("permissive") + assert robust.endswith("/UniBind_hubs_Robust/UCSC/hub.txt") + assert permissive.endswith("/UniBind_hubs_Permissive/UCSC/hub.txt") + + +def test_search_unibind_trackhub_tracks_and_resolve_to_cache(monkeypatch, tmp_path): + hub_url = "https://example.org/hub.txt" + genomes_url = "https://example.org/genomes.txt" + trackdb_url = "https://example.org/hg38/trackDb.txt" + bigbed_url = "https://example.org/hg38/CTCF_track.bb" + other_url = "https://example.org/hg38/ATAC_track.bb" + + payloads = { + hub_url: ( + "hub test\n" + "shortLabel Test\n" + "longLabel Test\n" + "genomesFile genomes.txt\n" + "email test@example.org\n" + ).encode(), + genomes_url: ( + "genome hg38\n" + "trackDb hg38/trackDb.txt\n\n" + "genome mm10\n" + "trackDb mm10/trackDb.txt\n" + ).encode(), + trackdb_url: ( + "track CTCF_track\n" + "shortLabel CTCF\n" + "longLabel CTCF example\n" + "type bigBed 9 .\n" + "bigDataUrl CTCF_track.bb\n\n" + "track ATAC_track\n" + "shortLabel ATAC\n" + "longLabel ATAC example\n" + "type bigBed 9 .\n" + "bigDataUrl ATAC_track.bb\n" + ).encode(), + bigbed_url: b"fake-ctcf-track", + other_url: b"fake-atac-track", + } + + class FakeResponse: + def __init__(self, payload: bytes) -> None: + self._payload = payload + + def read(self) -> bytes: + return self._payload + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc, tb): + return False + + def fake_urlopen(req, timeout=60.0): # noqa: ARG001 + url = req.full_url if hasattr(req, "full_url") else str(req) + if url not in payloads: + raise RuntimeError(f"unexpected url: {url}") + return FakeResponse(payloads[url]) + + monkeypatch.setattr(regulatory_enrichment.request, "urlopen", fake_urlopen) + + rows = regulatory_enrichment.search_unibind_trackhub_tracks( + trackhub_url=hub_url, + assembly="hg38", + search_terms=["ctcf"], + ) + assert len(rows) == 1 + assert rows[0]["track"] == "CTCF_track" + assert rows[0]["url"] == bigbed_url + + cached = regulatory_enrichment.resolve_unibind_track_paths( + trackhub_url=hub_url, + assembly="hg38", + search_terms=["ctcf"], + cache_dir=tmp_path, + ) + assert len(cached) == 1 + assert cached[0].exists() + assert cached[0].read_bytes() == b"fake-ctcf-track" + + +def test_resolve_unibind_track_paths_prefers_explicit_local_paths(tmp_path): + p = tmp_path / "local_track.bed" + p.write_text("chr1\\t0\\t10\\n", encoding="utf-8") + + resolved = regulatory_enrichment.resolve_unibind_track_paths( + track_paths=[p], + ) + assert len(resolved) == 1 + assert resolved[0] == p.resolve() + + +def test_workflow_wrapper_resolve_unibind_track_paths_uses_regulatory_spec(monkeypatch): + captured = {} + + def fake_resolve(**kwargs): + captured.update(kwargs) + return [Path("/tmp/fake.bb")] + + monkeypatch.setattr(regulatory_enrichment, "resolve_unibind_track_paths", fake_resolve) + spec = workflows.resolve_regulatory_enrichment_spec( + species="human", + target_genome="hg38", + providers=("unibind",), + ) + + paths = workflows.resolve_unibind_track_paths( + search_terms=["ctcf"], + regulatory_spec=spec, + ) + assert len(paths) == 1 + assert captured["assembly"] == "hg38" + + +def test_submit_unibind_tfbs_extraction_parses_job_page(monkeypatch): + endpoint = "https://example.org/TFBS_extraction/" + landing_html = ( + '
' + ) + submitted_html = ( + "" + "" + "" + "
Job status:Queued
Results URL:" + "https://example.org/TFBS_extraction/jobA/" + "
" + ) + + class FakeResponse: + def __init__(self, payload: str, url: str) -> None: + self._payload = payload.encode("utf-8") + self._url = url + + def read(self) -> bytes: + return self._payload + + def geturl(self) -> str: + return self._url + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc, tb): + return False + + class FakeOpener: + def open(self, req, timeout=60.0): # noqa: ARG002 + url = req.full_url if hasattr(req, "full_url") else str(req) + data = getattr(req, "data", None) + if url == endpoint and data is None: + return FakeResponse(landing_html, endpoint) + if url == endpoint and data is not None: + assert b"performTFBSextraction" in data + assert b"collection" in data + return FakeResponse(submitted_html, "https://example.org/TFBS_extraction/jobA/") + raise RuntimeError(f"Unexpected request url={url!r}") + + monkeypatch.setattr(regulatory_enrichment.request, "build_opener", lambda *args: FakeOpener()) + + result = regulatory_enrichment.submit_unibind_tfbs_extraction( + regions=["chr1:10-20"], + species="human", + collection="robust", + endpoint_url=endpoint, + ) + assert isinstance(result, UniBindJobResult) + assert result.job_id == "jobA" + assert result.status == "queued" + assert result.job_url == "https://example.org/TFBS_extraction/jobA/" + assert result.query["species"] == "homo_sapiens" + + +def test_submit_unibind_enrichment_requires_required_inputs(): + with pytest.raises(ValueError, match="background_regions"): + regulatory_enrichment.submit_unibind_enrichment( + regions=["chr1:10-20"], + analysis_type="oneSetBg", + endpoint_url="https://example.org/enrichment/", + ) + + with pytest.raises(ValueError, match="comparison_regions"): + regulatory_enrichment.submit_unibind_enrichment( + regions=["chr1:10-20"], + analysis_type="twoSets", + endpoint_url="https://example.org/enrichment/", + ) + + +def test_poll_unibind_job_waits_until_terminal(monkeypatch): + pages = [ + "Job status:Running", + ( + "Job status:Completed" + 'Download' + ), + ] + state = {"i": 0} + + def fake_fetch_text(url: str, timeout_seconds: float = 60.0): # noqa: ARG001 + index = state["i"] + if index < len(pages) - 1: + state["i"] += 1 + return pages[index] + + monkeypatch.setattr(regulatory_enrichment, "_fetch_text", fake_fetch_text) + + start = UniBindJobResult( + job_id="jobB", + status="queued", + job_url="https://example.org/TFBS_extraction/jobB/", + endpoint_url="https://example.org/TFBS_extraction/", + ) + result = regulatory_enrichment.poll_unibind_job( + start, + poll_interval_seconds=0.01, + timeout_seconds=1.0, + ) + assert result.status == "completed" + assert "https://example.org/temp/jobB/extraction_results.bed" in result.download_urls + assert len(result.status_history) >= 2 + + +def test_download_unibind_job_outputs_writes_files(monkeypatch, tmp_path): + payloads = { + "https://example.org/temp/jobC/a.tsv": b"a", + "https://example.org/temp/jobC/b.bed": b"b", + } + + def fake_fetch_bytes(url: str, timeout_seconds: float = 60.0): # noqa: ARG001 + return payloads[url] + + monkeypatch.setattr(regulatory_enrichment, "_fetch_bytes", fake_fetch_bytes) + job = UniBindJobResult( + job_id="jobC", + status="completed", + job_url="https://example.org/enrichment/jobC/", + endpoint_url="https://example.org/enrichment/", + download_urls=list(payloads.keys()), + ) + outputs = regulatory_enrichment.download_unibind_job_outputs( + job=job, + output_dir=tmp_path, + ) + assert len(outputs) == 2 + assert outputs[0].exists() + assert outputs[1].exists() + + +def test_workflow_wrapper_unibind_tfbs_uses_regulatory_spec(monkeypatch): + captured = {} + + def fake_run(**kwargs): + captured.update(kwargs) + return UniBindJobResult( + job_id="jobD", + status="completed", + job_url="https://example.org/TFBS_extraction/jobD/", + endpoint_url="https://example.org/TFBS_extraction/", + ) + + monkeypatch.setattr(regulatory_enrichment, "run_unibind_tfbs_extraction", fake_run) + spec = workflows.resolve_regulatory_enrichment_spec( + species="mouse", + providers=("unibind",), + ) + _ = workflows.unibind_tfbs_extraction_workflow( + regions=["chr1:1-2"], + regulatory_spec=spec, + wait=False, + ) + assert captured["species"] == "mus_musculus" + + +def test_workflow_wrapper_unibind_enrichment_uses_regulatory_spec(monkeypatch): + captured = {} + + def fake_run(**kwargs): + captured.update(kwargs) + return UniBindJobResult( + job_id="jobE", + status="completed", + job_url="https://example.org/enrichment/jobE/", + endpoint_url="https://example.org/enrichment/", + ) + + monkeypatch.setattr(regulatory_enrichment, "run_unibind_enrichment", fake_run) + spec = workflows.resolve_regulatory_enrichment_spec( + species="human", + providers=("unibind",), + ) + _ = workflows.unibind_enrichment_workflow( + regions=["chr1:1-2"], + background_regions=["chr1:1-3"], + regulatory_spec=spec, + wait=False, + ) + assert captured["species"] == "homo_sapiens" diff --git a/tests/test_run_modkit.py b/tests/test_run_modkit.py new file mode 100644 index 0000000..22ae7c6 --- /dev/null +++ b/tests/test_run_modkit.py @@ -0,0 +1,125 @@ +from pathlib import Path + +import pytest + +from dimelo import run_modkit + + +def _fake_capabilities() -> run_modkit.ModkitCapabilities: + return run_modkit.ModkitCapabilities( + executable="modkit", + version_raw="modkit 0.6.1", + version="0.6.1", + version_tuple=(0, 6, 1), + supports_mod_threshold=True, + supports_mod_thresholds=False, + supports_modified_bases=True, + supports_force_allow_implicit=False, + supports_extract_subcommands=True, + extract_supports_reference_long=True, + extract_supports_reference_short=True, + ) + + +def test_ensure_modkit_available_forwards_executable_override(monkeypatch): + captured: dict[str, object] = {} + capabilities = _fake_capabilities() + + def fake_get_modkit_capabilities(quiet=False, executable=None): + captured["quiet"] = quiet + captured["executable"] = executable + return capabilities + + monkeypatch.setattr(run_modkit, "get_modkit_capabilities", fake_get_modkit_capabilities) + + result = run_modkit._ensure_modkit_available( + quiet=True, + executable=Path("/opt/modkit-0.6.1/bin/modkit"), + ) + + assert result == capabilities + assert captured == { + "quiet": True, + "executable": "/opt/modkit-0.6.1/bin/modkit", + } + + +def test_resolve_modkit_executable_prefers_env_override(monkeypatch): + monkeypatch.setenv(run_modkit.MODKIT_EXECUTABLE_ENV, "modkit-0.6") + monkeypatch.setattr(run_modkit.shutil, "which", lambda name: f"/usr/local/bin/{name}") + + resolved = run_modkit._resolve_modkit_executable(None) + + assert resolved == "/usr/local/bin/modkit-0.6" + + +def test_resolve_modkit_executable_raises_for_missing_path(): + with pytest.raises(FileNotFoundError, match="does not exist"): + run_modkit._resolve_modkit_executable("/tmp/does-not-exist/modkit") + + +def test_configure_modkit_executable_sets_and_clears_env(monkeypatch): + monkeypatch.delenv(run_modkit.MODKIT_EXECUTABLE_ENV, raising=False) + + run_modkit.configure_modkit_executable("/opt/modkit-custom/bin/modkit") + assert ( + run_modkit.os.environ.get(run_modkit.MODKIT_EXECUTABLE_ENV) + == "/opt/modkit-custom/bin/modkit" + ) + + run_modkit.configure_modkit_executable(None) + assert run_modkit.MODKIT_EXECUTABLE_ENV not in run_modkit.os.environ + + +def test_modkit_cache_fingerprint_changes_when_binary_changes(tmp_path): + fake_modkit = tmp_path / "modkit" + fake_modkit.write_text("v1") + fp1 = run_modkit._modkit_cache_fingerprint(str(fake_modkit)) + + # Ensure metadata changes (mtime and size) to trigger new fingerprint. + fake_modkit.write_text("v2-updated") + fp2 = run_modkit._modkit_cache_fingerprint(str(fake_modkit)) + + assert fp1 != fp2 + + +def test_get_modkit_capabilities_uses_resolved_path_and_fingerprint(monkeypatch): + captured: dict[str, object] = {} + capabilities = _fake_capabilities() + + def fake_prepare_modkit_path(quiet=False): + captured["prepared_quiet"] = quiet + + def fake_resolve_modkit_executable(executable): + captured["resolved_from"] = executable + return "/resolved/modkit" + + def fake_modkit_cache_fingerprint(executable_path): + captured["fingerprint_path"] = executable_path + return "fingerprint-123" + + def fake_cached(*, executable_path, executable_fingerprint, quiet=False): + captured["cached_executable_path"] = executable_path + captured["cached_executable_fingerprint"] = executable_fingerprint + captured["cached_quiet"] = quiet + return capabilities + + monkeypatch.setattr(run_modkit, "_prepare_modkit_path", fake_prepare_modkit_path) + monkeypatch.setattr(run_modkit, "_resolve_modkit_executable", fake_resolve_modkit_executable) + monkeypatch.setattr(run_modkit, "_modkit_cache_fingerprint", fake_modkit_cache_fingerprint) + monkeypatch.setattr(run_modkit, "_get_modkit_capabilities_cached", fake_cached) + + result = run_modkit.get_modkit_capabilities( + quiet=True, + executable="modkit-0.6.1", + ) + + assert result == capabilities + assert captured == { + "prepared_quiet": True, + "resolved_from": "modkit-0.6.1", + "fingerprint_path": "/resolved/modkit", + "cached_executable_path": "/resolved/modkit", + "cached_executable_fingerprint": "fingerprint-123", + "cached_quiet": True, + } diff --git a/tests/test_workflows.py b/tests/test_workflows.py index 5a4ea3a..d058e80 100644 --- a/tests/test_workflows.py +++ b/tests/test_workflows.py @@ -1,3 +1,5 @@ +from pathlib import Path + import numpy as np import pandas as pd import pytest @@ -5,6 +7,7 @@ from dimelo import plotting, workflows from dimelo.models import ContrastSpec, DatasetArtifact from dimelo.models import ( + ChipAtlasEnrichmentResult, RegionContrastResult, RegionDiscoveryResult, SampleSpec, @@ -781,6 +784,220 @@ def fake_features(result, **kwargs): assert set(result.metadata["cache_misses"]) == {"s1", "s2"} +def test_shared_cluster_distribution_read_global_builds_region_summaries_from_coordinates( + monkeypatch, +): + fake_samples = [ + SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5"), + SampleSpec(sample_id="s2", condition="15min", extract_h5="s2.h5"), + ] + + def fake_extract(*args, **kwargs): + hdf5_file = kwargs["hdf5_file"] + + class R: + if hdf5_file == "s1.h5": + data_matrix = np.array([[0.0, 0.0, 0.1, 0.1], [0.0, 0.1, 0.0, 0.1]]) + metadata = [ + { + "read_name": "s1-r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + }, + { + "read_name": "s1-r2", + "chromosome": "chr1", + "region_start": 10, + "region_end": 14, + }, + ] + else: + data_matrix = np.array([[1.0, 0.9, 1.0, 0.9], [0.9, 1.0, 0.9, 1.0]]) + metadata = [ + { + "read_name": "s2-r1", + "chromosome": "chr1", + "region_start": 20, + "region_end": 24, + "region_strand": "+", + }, + { + "read_name": "s2-r2", + "chromosome": "chr1", + "region_start": 30, + "region_end": 34, + "region_strand": "-", + }, + ] + val_matrix = np.ones((2, 4), dtype=float) + datasets = [] + regions_dict = None + + return R() + + monkeypatch.setattr(workflows.cluster, "extract_read_windows", fake_extract) + monkeypatch.setattr( + workflows.cluster, + "read_window_feature_matrix", + lambda result, **kwargs: (result.data_matrix, ["f0", "f1", "f2", "f3"]), + ) + + result = workflows.shared_cluster_distribution( + samples=fake_samples, + mode="read_global", + motifs=["A,0"], + n_clusters=2, + training_sample_per_dataset=2, + make_plots=False, + ) + + assert result.region_summaries is not None + assert {"region_id", "sample_id", "condition", "cluster", "count", "fraction"} <= set( + result.region_summaries.columns + ) + assert set(result.region_summaries["sample_id"]) == {"s1", "s2"} + assert set(result.region_summaries["condition"]) == {"NS", "15min"} + + +def test_shared_cluster_distribution_read_global_leaves_region_summaries_empty_without_coordinates( + monkeypatch, +): + fake_samples = [ + SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5"), + SampleSpec(sample_id="s2", condition="15min", extract_h5="s2.h5"), + ] + + def fake_extract(*args, **kwargs): + class R: + data_matrix = np.array([[0.0, 0.0], [1.0, 1.0]]) + val_matrix = np.ones((2, 2), dtype=float) + metadata = [{"read_name": "r1"}, {"read_name": "r2"}] + datasets = [] + regions_dict = None + + return R() + + monkeypatch.setattr(workflows.cluster, "extract_read_windows", fake_extract) + monkeypatch.setattr( + workflows.cluster, + "read_window_feature_matrix", + lambda result, **kwargs: (result.data_matrix, ["f0", "f1"]), + ) + + result = workflows.shared_cluster_distribution( + samples=fake_samples, + mode="read_global", + motifs=["A,0"], + n_clusters=2, + training_sample_per_dataset=2, + make_plots=False, + ) + + assert result.region_summaries is None + + +def test_shared_cluster_distribution_read_global_prefers_cluster_summarizer(monkeypatch): + fake_samples = [ + SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5"), + SampleSpec(sample_id="s2", condition="15min", extract_h5="s2.h5"), + ] + called = {"count": 0} + + def fake_extract(*args, **kwargs): + hdf5_file = kwargs["hdf5_file"] + + class R: + if hdf5_file == "s1.h5": + data_matrix = np.array([[0.0, 0.0], [0.0, 0.1]]) + metadata = [ + { + "read_name": "s1-r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 2, + }, + { + "read_name": "s1-r2", + "chromosome": "chr1", + "region_start": 10, + "region_end": 12, + }, + ] + else: + data_matrix = np.array([[1.0, 1.0], [0.9, 1.0]]) + metadata = [ + { + "read_name": "s2-r1", + "chromosome": "chr1", + "region_start": 20, + "region_end": 22, + }, + { + "read_name": "s2-r2", + "chromosome": "chr1", + "region_start": 30, + "region_end": 32, + }, + ] + val_matrix = np.ones((2, 2), dtype=float) + datasets = [] + regions_dict = None + + return R() + + def fake_summarizer(*, metadata, labels, include_strand=True): + called["count"] += 1 + if metadata: + first = metadata[0] + chrom = first.get("chromosome") + start = int(first.get("region_start")) + end = int(first.get("region_end")) + else: + chrom, start, end = "chr1", 0, 1 + return pd.DataFrame( + [ + { + "chrom": chrom, + "start": start, + "end": end, + "strand": "+", + "cluster": labels[0] if len(labels) else "C0", + "count": len(labels), + "fraction": 1.0 if len(labels) else 0.0, + "source": "summarizer", + } + ] + ) + + monkeypatch.setattr(workflows.cluster, "extract_read_windows", fake_extract) + monkeypatch.setattr( + workflows.cluster, + "read_window_feature_matrix", + lambda result, **kwargs: (result.data_matrix, ["f0", "f1"]), + ) + monkeypatch.setattr( + workflows.cluster, + "summarize_read_cluster_region_associations", + fake_summarizer, + raising=False, + ) + + result = workflows.shared_cluster_distribution( + samples=fake_samples, + mode="read_global", + motifs=["A,0"], + n_clusters=2, + training_sample_per_dataset=2, + make_plots=False, + ) + + assert called["count"] == len(fake_samples) + assert result.region_summaries is not None + assert "source" in result.region_summaries.columns + assert set(result.region_summaries["source"]) == {"summarizer"} + + def test_shared_cluster_distribution_propagates_sample_metadata_into_assignments_read_global( monkeypatch, ): @@ -1496,3 +1713,233 @@ class R: assert seen_paths[0] == "s1.h5" assert "s1" not in result.metadata["cache_hits"] + + +def test_chip_atlas_enrichment_workflow_forwards_to_module(monkeypatch): + captured = {} + + def fake_run_enrichment(**kwargs): + captured.update(kwargs) + return ChipAtlasEnrichmentResult( + request_id="REQ1", + status="finished", + results=pd.DataFrame({"target": ["CTCF"]}), + ) + + monkeypatch.setattr(workflows.chip_atlas, "run_enrichment", fake_run_enrichment) + + result = workflows.chip_atlas_enrichment_workflow( + regions=["chr1:0-100,+"], + genome="hg38", + regions_genome="chm13", + cell_type="K562", + crossmap_chain_cache_dir="cache/chains", + fetch_results=False, + ) + + assert result.request_id == "REQ1" + assert captured["regions"] == ["chr1:0-100,+"] + assert captured["genome"] == "hg38" + assert captured["regions_genome"] == "chm13" + assert captured["antigen_class"] == "TFs and others" + assert captured["cell_type_class"] == "No description" + assert captured["threshold"] == "100" + assert captured["cell_type"] == "K562" + assert captured["crossmap_chain_cache_dir"] == "cache/chains" + assert captured["fetch_results"] is False + + +def test_chip_atlas_cluster_enrichment_workflow_per_cluster(monkeypatch): + region_summaries = pd.DataFrame( + [ + {"region_id": "chr1:0-100,+", "cluster": "C0", "fraction": 0.8}, + {"region_id": "chr1:100-200,+", "cluster": "C0", "fraction": 0.2}, + {"region_id": "chr2:0-100,-", "cluster": "C1", "fraction": 0.9}, + ] + ) + cluster_result = SharedClusterResult( + model=SharedClusterModel( + mode="read_global", + motifs=["A,0"], + feature_names=["f0"], + preprocessing={}, + estimator=object(), + cluster_labels=["C0", "C1"], + fit_metadata={}, + ), + assignments=pd.DataFrame( + [ + {"sample_id": "s1", "condition": "NS", "cluster": "C0"}, + {"sample_id": "s2", "condition": "TX", "cluster": "C1"}, + ] + ), + cluster_distribution=pd.DataFrame( + [{"sample_id": "s1", "condition": "NS", "cluster": "C0", "count": 1, "fraction": 1.0}] + ), + condition_distribution=pd.DataFrame( + [{"condition": "NS", "cluster": "C0", "fraction": 1.0, "replicate_n": 1}] + ), + distribution_change=None, + cluster_profiles=pd.DataFrame([{"cluster": "C0", "count": 1, "f0": 0.1}]), + region_summaries=region_summaries, + plot_data={}, + ) + + called = [] + + def fake_chip_atlas_workflow(*, regions, **kwargs): + called.append(regions.copy()) + return ChipAtlasEnrichmentResult( + request_id=f"REQ-{len(called)}", + status="finished", + results=pd.DataFrame({"target": ["CTCF"]}), + ) + + monkeypatch.setattr(workflows, "chip_atlas_enrichment_workflow", fake_chip_atlas_workflow) + + results = workflows.chip_atlas_cluster_enrichment_workflow( + cluster_result=cluster_result, + clusters=["C0", "C1"], + min_fraction=0.5, + cell_type="K562", + ) + + assert set(results.keys()) == {"C0", "C1"} + assert len(called) == 2 + assert all(frame.shape[0] >= 1 for frame in called) + assert all({"chrom", "start", "end", "strand"}.issubset(frame.columns) for frame in called) + + +def test_chip_atlas_search_peak_datasets_workflow_forwards(monkeypatch): + captured = {} + + def fake_search(**kwargs): + captured.update(kwargs) + return pd.DataFrame([{"dataset_id": "SRX1", "bed_url": "http://example.org/srx1.bed"}]) + + monkeypatch.setattr(workflows.chip_atlas, "search_peak_datasets", fake_search) + out = workflows.chip_atlas_search_peak_datasets_workflow( + antigen="CTCF", + genome="hg38", + cell_type="K562", + ) + assert out.shape[0] == 1 + assert captured["antigen"] == "CTCF" + assert captured["genome"] == "hg38" + assert captured["cell_type"] == "K562" + + +def test_chip_atlas_download_peak_datasets_workflow_forwards(monkeypatch): + captured = {} + + def fake_download(**kwargs): + captured.update(kwargs) + return pd.DataFrame([{"dataset_id": "SRX1", "variant": "top_3000"}]) + + monkeypatch.setattr(workflows.chip_atlas, "download_peak_datasets", fake_download) + datasets = pd.DataFrame([{"dataset_id": "SRX1", "bed_url": "http://example.org/srx1.bed", "genome_assembly": "hg38"}]) + out = workflows.chip_atlas_download_peak_datasets_workflow( + datasets=datasets, + dataset_ids=["SRX1"], + stratify="quartiles", + ) + assert out.shape[0] == 1 + assert captured["datasets"].equals(datasets) + assert captured["dataset_ids"] == ["SRX1"] + assert captured["stratify"] == "quartiles" + + +def test_modkit_dmr_pair_workflow_forwards(monkeypatch): + captured = {} + + def fake_run_dmr_pair(**kwargs): + captured.update(kwargs) + from dimelo.models import ModkitDMRPairResult + + return ModkitDMRPairResult( + output_path=Path("/tmp/out.bed"), + segment_path=None, + command=["modkit", "dmr", "pair"], + sites=pd.DataFrame(), + segments=None, + high_confidence_sites=pd.DataFrame(), + metadata={}, + ) + + monkeypatch.setattr(workflows.dmr, "run_dmr_pair", fake_run_dmr_pair) + out = workflows.modkit_dmr_pair_workflow( + control_bed_methyl="a.bed.gz", + experiment_bed_methyl="b.bed.gz", + ref_genome="ref.fa", + out_path="out.bed", + bases=["A"], + ) + assert out.output_path == Path("/tmp/out.bed") + assert captured["control_bed_methyl"] == "a.bed.gz" + assert captured["bases"] == ["A"] + + +def test_modkit_dmr_multi_workflow_forwards(monkeypatch): + captured = {} + + def fake_run_dmr_multi(**kwargs): + captured.update(kwargs) + from dimelo.models import ModkitDMRMultiResult + + return ModkitDMRMultiResult( + out_dir=Path("/tmp/out"), + command=["modkit", "dmr", "multi"], + pair_files=pd.DataFrame([{"pair_name": "s1_vs_s2"}]), + metadata={}, + ) + + monkeypatch.setattr(workflows.dmr, "run_dmr_multi", fake_run_dmr_multi) + out = workflows.modkit_dmr_multi_workflow( + samples={"s1": "s1.bed.gz", "s2": "s2.bed.gz"}, + regions_bed="regions.bed", + ref_genome="ref.fa", + out_dir="out", + bases=["A"], + ) + assert out.pair_files.shape[0] == 1 + assert captured["samples"] == {"s1": "s1.bed.gz", "s2": "s2.bed.gz"} + assert captured["bases"] == ["A"] + + +def test_modkit_dmr_multi_from_samples_workflow_reads_pileup_paths(monkeypatch): + captured = {} + + def fake_multi(**kwargs): + captured.update(kwargs) + from dimelo.models import ModkitDMRMultiResult + + return ModkitDMRMultiResult( + out_dir=Path("/tmp/out"), + command=["modkit", "dmr", "multi"], + pair_files=pd.DataFrame([{"pair_name": "s1_vs_s2"}]), + metadata={}, + ) + + monkeypatch.setattr(workflows, "modkit_dmr_multi_workflow", fake_multi) + samples = [ + SampleSpec( + sample_id="s1", + condition="A", + extract_h5="s1.h5", + metadata={"pileup_path": "s1.bed.gz"}, + ), + SampleSpec( + sample_id="s2", + condition="B", + extract_h5="s2.h5", + metadata={"pileup_path": "s2.bed.gz"}, + ), + ] + out = workflows.modkit_dmr_multi_from_samples_workflow( + samples=samples, + regions_bed="regions.bed", + ref_genome="ref.fa", + out_dir="out", + ) + assert out.pair_files.shape[0] == 1 + assert captured["samples"] == {"s1": "s1.bed.gz", "s2": "s2.bed.gz"} diff --git a/tutorial.ipynb b/tutorial.ipynb index 1b98c1d..554a39a 100644 --- a/tutorial.ipynb +++ b/tutorial.ipynb @@ -1954,13 +1954,28 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "vscode": { - "languageId": "julia" + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] Unable to synchronously open file (unable to open file: name = 'output/extract.h5', errno = 2, error message = 'No such file or directory', flags = 0, o_flags = 0)", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mFileNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[5]\u001b[39m\u001b[32m, line 4\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mdimelo\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m cluster\n\u001b[32m 3\u001b[39m \u001b[38;5;66;03m# Combine motifs per read; windows are concatenated in the order given\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m4\u001b[39m rw_multi = \u001b[43mcluster\u001b[49m\u001b[43m.\u001b[49m\u001b[43mbuild_multimotif_read_windows\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 5\u001b[39m \u001b[43m \u001b[49m\u001b[43mhdf5_file\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43moutput/extract.h5\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 6\u001b[39m \u001b[43m \u001b[49m\u001b[43mmotifs\u001b[49m\u001b[43m=\u001b[49m\u001b[43m[\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mA,0\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mCG,0\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 7\u001b[39m \u001b[43m \u001b[49m\u001b[43mregions\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43moutput/regions.processed.bed\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 8\u001b[39m \u001b[43m \u001b[49m\u001b[43mwindow_size\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m2000\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 9\u001b[39m \u001b[43m \u001b[49m\u001b[43morientation_aware\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[32m 10\u001b[39m \u001b[43m \u001b[49m\u001b[43mspan_full_window\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[32m 11\u001b[39m \u001b[43m \u001b[49m\u001b[43mrequire_all_motifs\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[32m 12\u001b[39m \u001b[43m)\u001b[49m\n\u001b[32m 14\u001b[39m feat_multi, _ = cluster.read_window_feature_matrix(\n\u001b[32m 15\u001b[39m rw_multi,\n\u001b[32m 16\u001b[39m n_pca=\u001b[32m6\u001b[39m,\n\u001b[32m (...)\u001b[39m\u001b[32m 19\u001b[39m min_valid_fraction=\u001b[32m0.05\u001b[39m,\n\u001b[32m 20\u001b[39m )\n\u001b[32m 21\u001b[39m clust_multi = cluster.cluster_read_windows(feat_multi, method=\u001b[33m\"\u001b[39m\u001b[33mkmeans\u001b[39m\u001b[33m\"\u001b[39m, n_clusters=\u001b[32m8\u001b[39m, random_state=\u001b[32m42\u001b[39m)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/Documents/GitHub/dimelo-toolkit/dimelo/cluster.py:514\u001b[39m, in \u001b[36mbuild_multimotif_read_windows\u001b[39m\u001b[34m(hdf5_file, motifs, regions, window_size, orientation_aware, single_strand, subset_parameters, span_full_window, require_all_motifs)\u001b[39m\n\u001b[32m 491\u001b[39m \u001b[38;5;250m\u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 492\u001b[39m \u001b[33;03mGroup per-motif rows by read and return a combined window per read, concatenating motifs.\u001b[39;00m\n\u001b[32m 493\u001b[39m \n\u001b[32m (...)\u001b[39m\u001b[32m 510\u001b[39m \u001b[33;03m and val_matrix if available, metadata per combined read, and datasets info.\u001b[39;00m\n\u001b[32m 511\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 513\u001b[39m \u001b[38;5;66;03m# Load all per-motif rows\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m514\u001b[39m read_tuples, dataset_names, regions_dict = \u001b[43mload_processed\u001b[49m\u001b[43m.\u001b[49m\u001b[43mread_vectors_from_hdf5\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 515\u001b[39m \u001b[43m \u001b[49m\u001b[43mfile\u001b[49m\u001b[43m=\u001b[49m\u001b[43mhdf5_file\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 516\u001b[39m \u001b[43m \u001b[49m\u001b[43mmotifs\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mmotifs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 517\u001b[39m \u001b[43m \u001b[49m\u001b[43mregions\u001b[49m\u001b[43m=\u001b[49m\u001b[43mregions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 518\u001b[39m \u001b[43m \u001b[49m\u001b[43mwindow_size\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# we handle windowing here\u001b[39;49;00m\n\u001b[32m 519\u001b[39m \u001b[43m \u001b[49m\u001b[43msingle_strand\u001b[49m\u001b[43m=\u001b[49m\u001b[43msingle_strand\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 520\u001b[39m \u001b[43m \u001b[49m\u001b[43msubset_parameters\u001b[49m\u001b[43m=\u001b[49m\u001b[43msubset_parameters\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 521\u001b[39m \u001b[43m \u001b[49m\u001b[43mspan_full_window\u001b[49m\u001b[43m=\u001b[49m\u001b[43mspan_full_window\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 522\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 523\u001b[39m idx = _build_dataset_index(dataset_names)\n\u001b[32m 525\u001b[39m \u001b[38;5;66;03m# Group rows by read+region key\u001b[39;00m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/Documents/GitHub/dimelo-toolkit/dimelo/load_processed.py:1119\u001b[39m, in \u001b[36mread_vectors_from_hdf5\u001b[39m\u001b[34m(file, motifs, regions, window_size, single_strand, sort_by, calculate_mod_fractions, quiet, cores, subset_parameters, span_full_window)\u001b[39m\n\u001b[32m 1057\u001b[39m \u001b[38;5;250m\u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 1058\u001b[39m \u001b[33;03mUser-facing function.\u001b[39;00m\n\u001b[32m 1059\u001b[39m \n\u001b[32m (...)\u001b[39m\u001b[32m 1115\u001b[39m \u001b[33;03m the available parameters.\u001b[39;00m\n\u001b[32m 1116\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 1117\u001b[39m _validate_subset_parameters(subset_parameters)\n\u001b[32m-> \u001b[39m\u001b[32m1119\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[43mh5py\u001b[49m\u001b[43m.\u001b[49m\u001b[43mFile\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mr\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m h5:\n\u001b[32m 1120\u001b[39m datasets: \u001b[38;5;28mlist\u001b[39m[\u001b[38;5;28mstr\u001b[39m] = [\n\u001b[32m 1121\u001b[39m name \u001b[38;5;28;01mfor\u001b[39;00m name, obj \u001b[38;5;129;01min\u001b[39;00m h5.items() \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(obj, h5py.Dataset)\n\u001b[32m 1122\u001b[39m ]\n\u001b[32m 1123\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[33m\"\u001b[39m\u001b[33mthreshold\u001b[39m\u001b[33m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m h5:\n\u001b[32m 1124\u001b[39m \u001b[38;5;66;03m# we are looking at an .h5 file with the new, much better compressed format that does\u001b[39;00m\n\u001b[32m 1125\u001b[39m \u001b[38;5;66;03m# not know the data type intrinsically for mod and val vectors, so we must check\u001b[39;00m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/opt/homebrew/Caskroom/mambaforge/base/envs/dimelo-toolkit/lib/python3.11/site-packages/h5py/_hl/files.py:564\u001b[39m, in \u001b[36mFile.__init__\u001b[39m\u001b[34m(self, name, mode, driver, libver, userblock_size, swmr, rdcc_nslots, rdcc_nbytes, rdcc_w0, track_order, fs_strategy, fs_persist, fs_threshold, fs_page_size, page_buf_size, min_meta_keep, min_raw_keep, locking, alignment_threshold, alignment_interval, meta_block_size, **kwds)\u001b[39m\n\u001b[32m 555\u001b[39m fapl = make_fapl(driver, libver, rdcc_nslots, rdcc_nbytes, rdcc_w0,\n\u001b[32m 556\u001b[39m locking, page_buf_size, min_meta_keep, min_raw_keep,\n\u001b[32m 557\u001b[39m alignment_threshold=alignment_threshold,\n\u001b[32m 558\u001b[39m alignment_interval=alignment_interval,\n\u001b[32m 559\u001b[39m meta_block_size=meta_block_size,\n\u001b[32m 560\u001b[39m **kwds)\n\u001b[32m 561\u001b[39m fcpl = make_fcpl(track_order=track_order, fs_strategy=fs_strategy,\n\u001b[32m 562\u001b[39m fs_persist=fs_persist, fs_threshold=fs_threshold,\n\u001b[32m 563\u001b[39m fs_page_size=fs_page_size)\n\u001b[32m--> \u001b[39m\u001b[32m564\u001b[39m fid = \u001b[43mmake_fid\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43muserblock_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfapl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfcpl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mswmr\u001b[49m\u001b[43m=\u001b[49m\u001b[43mswmr\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 566\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(libver, \u001b[38;5;28mtuple\u001b[39m):\n\u001b[32m 567\u001b[39m \u001b[38;5;28mself\u001b[39m._libver = libver\n", + "\u001b[36mFile \u001b[39m\u001b[32m/opt/homebrew/Caskroom/mambaforge/base/envs/dimelo-toolkit/lib/python3.11/site-packages/h5py/_hl/files.py:238\u001b[39m, in \u001b[36mmake_fid\u001b[39m\u001b[34m(name, mode, userblock_size, fapl, fcpl, swmr)\u001b[39m\n\u001b[32m 236\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m swmr \u001b[38;5;129;01mand\u001b[39;00m swmr_support:\n\u001b[32m 237\u001b[39m flags |= h5f.ACC_SWMR_READ\n\u001b[32m--> \u001b[39m\u001b[32m238\u001b[39m fid = \u001b[43mh5f\u001b[49m\u001b[43m.\u001b[49m\u001b[43mopen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mflags\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfapl\u001b[49m\u001b[43m=\u001b[49m\u001b[43mfapl\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 239\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m mode == \u001b[33m'\u001b[39m\u001b[33mr+\u001b[39m\u001b[33m'\u001b[39m:\n\u001b[32m 240\u001b[39m fid = h5f.open(name, h5f.ACC_RDWR, fapl=fapl)\n", + "\u001b[36mFile \u001b[39m\u001b[32mh5py/_objects.pyx:54\u001b[39m, in \u001b[36mh5py._objects.with_phil.wrapper\u001b[39m\u001b[34m()\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32mh5py/_objects.pyx:55\u001b[39m, in \u001b[36mh5py._objects.with_phil.wrapper\u001b[39m\u001b[34m()\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32mh5py/h5f.pyx:102\u001b[39m, in \u001b[36mh5py.h5f.open\u001b[39m\u001b[34m()\u001b[39m\n", + "\u001b[31mFileNotFoundError\u001b[39m: [Errno 2] Unable to synchronously open file (unable to open file: name = 'output/extract.h5', errno = 2, error message = 'No such file or directory', flags = 0, o_flags = 0)" + ] } - }, - "outputs": [], + ], "source": [ "from dimelo import cluster\n", "\n", @@ -1969,7 +1984,7 @@ " hdf5_file=\"output/extract.h5\",\n", " motifs=[\"A,0\", \"CG,0\"],\n", " regions=\"output/regions.processed.bed\",\n", - " window_size=2000,\n", + " window_size=1000,\n", " orientation_aware=True,\n", " span_full_window=True,\n", " require_all_motifs=True,\n", @@ -1989,7 +2004,7 @@ " rw_multi.data_matrix,\n", " clust_multi.labels_size_ordered,\n", " motif_index=0, # 0 for A, 1 for CG\n", - " view_bp=400,\n", + " view_window_size=200,\n", ")\n" ] }, @@ -2002,13 +2017,28 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "vscode": { - "languageId": "julia" + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] Unable to synchronously open file (unable to open file: name = 'output/extract.h5', errno = 2, error message = 'No such file or directory', flags = 0, o_flags = 0)", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mFileNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[2]\u001b[39m\u001b[32m, line 4\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mdimelo\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m cluster\n\u001b[32m 3\u001b[39m \u001b[38;5;66;03m# Combine motifs per read; windows are concatenated in the order given\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m4\u001b[39m rw_multi = \u001b[43mcluster\u001b[49m\u001b[43m.\u001b[49m\u001b[43mbuild_multimotif_read_windows\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 5\u001b[39m \u001b[43m \u001b[49m\u001b[43mhdf5_file\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43moutput/extract.h5\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 6\u001b[39m \u001b[43m \u001b[49m\u001b[43mmotifs\u001b[49m\u001b[43m=\u001b[49m\u001b[43m[\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mA,0\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mCG,0\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 7\u001b[39m \u001b[43m \u001b[49m\u001b[43mregions\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43moutput/regions.processed.bed\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 8\u001b[39m \u001b[43m \u001b[49m\u001b[43mwindow_size\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m2000\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 9\u001b[39m \u001b[43m \u001b[49m\u001b[43morientation_aware\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[32m 10\u001b[39m \u001b[43m \u001b[49m\u001b[43mspan_full_window\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[32m 11\u001b[39m \u001b[43m)\u001b[49m\n\u001b[32m 13\u001b[39m feat_multi, _ = cluster.read_window_feature_matrix(rw_multi, n_pca=\u001b[32m6\u001b[39m, use_peak_features=\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[32m 14\u001b[39m clust_multi = cluster.cluster_read_windows(feat_multi, method=\u001b[33m\"\u001b[39m\u001b[33mkmeans\u001b[39m\u001b[33m\"\u001b[39m, n_clusters=\u001b[32m8\u001b[39m, random_state=\u001b[32m42\u001b[39m)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/Documents/GitHub/dimelo-toolkit/dimelo/cluster.py:514\u001b[39m, in \u001b[36mbuild_multimotif_read_windows\u001b[39m\u001b[34m(hdf5_file, motifs, regions, window_size, orientation_aware, single_strand, subset_parameters, span_full_window, require_all_motifs)\u001b[39m\n\u001b[32m 491\u001b[39m \u001b[38;5;250m\u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 492\u001b[39m \u001b[33;03mGroup per-motif rows by read and return a combined window per read, concatenating motifs.\u001b[39;00m\n\u001b[32m 493\u001b[39m \n\u001b[32m (...)\u001b[39m\u001b[32m 510\u001b[39m \u001b[33;03m and val_matrix if available, metadata per combined read, and datasets info.\u001b[39;00m\n\u001b[32m 511\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 513\u001b[39m \u001b[38;5;66;03m# Load all per-motif rows\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m514\u001b[39m read_tuples, dataset_names, regions_dict = \u001b[43mload_processed\u001b[49m\u001b[43m.\u001b[49m\u001b[43mread_vectors_from_hdf5\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 515\u001b[39m \u001b[43m \u001b[49m\u001b[43mfile\u001b[49m\u001b[43m=\u001b[49m\u001b[43mhdf5_file\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 516\u001b[39m \u001b[43m \u001b[49m\u001b[43mmotifs\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mmotifs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 517\u001b[39m \u001b[43m \u001b[49m\u001b[43mregions\u001b[49m\u001b[43m=\u001b[49m\u001b[43mregions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 518\u001b[39m \u001b[43m \u001b[49m\u001b[43mwindow_size\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# we handle windowing here\u001b[39;49;00m\n\u001b[32m 519\u001b[39m \u001b[43m \u001b[49m\u001b[43msingle_strand\u001b[49m\u001b[43m=\u001b[49m\u001b[43msingle_strand\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 520\u001b[39m \u001b[43m \u001b[49m\u001b[43msubset_parameters\u001b[49m\u001b[43m=\u001b[49m\u001b[43msubset_parameters\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 521\u001b[39m \u001b[43m \u001b[49m\u001b[43mspan_full_window\u001b[49m\u001b[43m=\u001b[49m\u001b[43mspan_full_window\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 522\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 523\u001b[39m idx = _build_dataset_index(dataset_names)\n\u001b[32m 525\u001b[39m \u001b[38;5;66;03m# Group rows by read+region key\u001b[39;00m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/Documents/GitHub/dimelo-toolkit/dimelo/load_processed.py:1119\u001b[39m, in \u001b[36mread_vectors_from_hdf5\u001b[39m\u001b[34m(file, motifs, regions, window_size, single_strand, sort_by, calculate_mod_fractions, quiet, cores, subset_parameters, span_full_window)\u001b[39m\n\u001b[32m 1057\u001b[39m \u001b[38;5;250m\u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 1058\u001b[39m \u001b[33;03mUser-facing function.\u001b[39;00m\n\u001b[32m 1059\u001b[39m \n\u001b[32m (...)\u001b[39m\u001b[32m 1115\u001b[39m \u001b[33;03m the available parameters.\u001b[39;00m\n\u001b[32m 1116\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 1117\u001b[39m _validate_subset_parameters(subset_parameters)\n\u001b[32m-> \u001b[39m\u001b[32m1119\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[43mh5py\u001b[49m\u001b[43m.\u001b[49m\u001b[43mFile\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mr\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m h5:\n\u001b[32m 1120\u001b[39m datasets: \u001b[38;5;28mlist\u001b[39m[\u001b[38;5;28mstr\u001b[39m] = [\n\u001b[32m 1121\u001b[39m name \u001b[38;5;28;01mfor\u001b[39;00m name, obj \u001b[38;5;129;01min\u001b[39;00m h5.items() \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(obj, h5py.Dataset)\n\u001b[32m 1122\u001b[39m ]\n\u001b[32m 1123\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[33m\"\u001b[39m\u001b[33mthreshold\u001b[39m\u001b[33m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m h5:\n\u001b[32m 1124\u001b[39m \u001b[38;5;66;03m# we are looking at an .h5 file with the new, much better compressed format that does\u001b[39;00m\n\u001b[32m 1125\u001b[39m \u001b[38;5;66;03m# not know the data type intrinsically for mod and val vectors, so we must check\u001b[39;00m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/opt/homebrew/Caskroom/mambaforge/base/envs/dimelo-toolkit/lib/python3.11/site-packages/h5py/_hl/files.py:564\u001b[39m, in \u001b[36mFile.__init__\u001b[39m\u001b[34m(self, name, mode, driver, libver, userblock_size, swmr, rdcc_nslots, rdcc_nbytes, rdcc_w0, track_order, fs_strategy, fs_persist, fs_threshold, fs_page_size, page_buf_size, min_meta_keep, min_raw_keep, locking, alignment_threshold, alignment_interval, meta_block_size, **kwds)\u001b[39m\n\u001b[32m 555\u001b[39m fapl = make_fapl(driver, libver, rdcc_nslots, rdcc_nbytes, rdcc_w0,\n\u001b[32m 556\u001b[39m locking, page_buf_size, min_meta_keep, min_raw_keep,\n\u001b[32m 557\u001b[39m alignment_threshold=alignment_threshold,\n\u001b[32m 558\u001b[39m alignment_interval=alignment_interval,\n\u001b[32m 559\u001b[39m meta_block_size=meta_block_size,\n\u001b[32m 560\u001b[39m **kwds)\n\u001b[32m 561\u001b[39m fcpl = make_fcpl(track_order=track_order, fs_strategy=fs_strategy,\n\u001b[32m 562\u001b[39m fs_persist=fs_persist, fs_threshold=fs_threshold,\n\u001b[32m 563\u001b[39m fs_page_size=fs_page_size)\n\u001b[32m--> \u001b[39m\u001b[32m564\u001b[39m fid = \u001b[43mmake_fid\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43muserblock_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfapl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfcpl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mswmr\u001b[49m\u001b[43m=\u001b[49m\u001b[43mswmr\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 566\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(libver, \u001b[38;5;28mtuple\u001b[39m):\n\u001b[32m 567\u001b[39m \u001b[38;5;28mself\u001b[39m._libver = libver\n", + "\u001b[36mFile \u001b[39m\u001b[32m/opt/homebrew/Caskroom/mambaforge/base/envs/dimelo-toolkit/lib/python3.11/site-packages/h5py/_hl/files.py:238\u001b[39m, in \u001b[36mmake_fid\u001b[39m\u001b[34m(name, mode, userblock_size, fapl, fcpl, swmr)\u001b[39m\n\u001b[32m 236\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m swmr \u001b[38;5;129;01mand\u001b[39;00m swmr_support:\n\u001b[32m 237\u001b[39m flags |= h5f.ACC_SWMR_READ\n\u001b[32m--> \u001b[39m\u001b[32m238\u001b[39m fid = \u001b[43mh5f\u001b[49m\u001b[43m.\u001b[49m\u001b[43mopen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mflags\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfapl\u001b[49m\u001b[43m=\u001b[49m\u001b[43mfapl\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 239\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m mode == \u001b[33m'\u001b[39m\u001b[33mr+\u001b[39m\u001b[33m'\u001b[39m:\n\u001b[32m 240\u001b[39m fid = h5f.open(name, h5f.ACC_RDWR, fapl=fapl)\n", + "\u001b[36mFile \u001b[39m\u001b[32mh5py/_objects.pyx:54\u001b[39m, in \u001b[36mh5py._objects.with_phil.wrapper\u001b[39m\u001b[34m()\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32mh5py/_objects.pyx:55\u001b[39m, in \u001b[36mh5py._objects.with_phil.wrapper\u001b[39m\u001b[34m()\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32mh5py/h5f.pyx:102\u001b[39m, in \u001b[36mh5py.h5f.open\u001b[39m\u001b[34m()\u001b[39m\n", + "\u001b[31mFileNotFoundError\u001b[39m: [Errno 2] Unable to synchronously open file (unable to open file: name = 'output/extract.h5', errno = 2, error message = 'No such file or directory', flags = 0, o_flags = 0)" + ] } - }, - "outputs": [], + ], "source": [ "from dimelo import cluster\n", "\n", @@ -2017,7 +2047,7 @@ " hdf5_file=\"output/extract.h5\",\n", " motifs=[\"A,0\", \"CG,0\"],\n", " regions=\"output/regions.processed.bed\",\n", - " window_size=2000,\n", + " window_size=1000,\n", " orientation_aware=True,\n", " span_full_window=True,\n", ")\n", @@ -2027,7 +2057,7 @@ "\n", "# QC plot (shows the first motif window for readability)\n", "motif1_len = rw_multi.data_matrix.shape[1] // len([\"A,0\", \"CG,0\"])\n", - "cluster.plot_cluster_profiles(rw_multi.data_matrix[:, :motif1_len], clust_multi.labels_size_ordered, view_bp=400)\n" + "cluster.plot_cluster_profiles(rw_multi.data_matrix[:, :motif1_len], clust_multi.labels_size_ordered, view_window_size=200)\n" ] }, { @@ -2046,9 +2076,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'feat_single' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[3]\u001b[39m\u001b[32m, line 3\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;66;03m# sample_labels must align to feat_single rows (e.g., [\"sampleA\", \"sampleA\", \"sampleB\", ...])\u001b[39;00m\n\u001b[32m 2\u001b[39m clf_single = cluster.classify_read_features_binary(\n\u001b[32m----> \u001b[39m\u001b[32m3\u001b[39m \u001b[43mfeat_single\u001b[49m,\n\u001b[32m 4\u001b[39m sample_labels=sample_labels_single,\n\u001b[32m 5\u001b[39m classifier=\u001b[33m\"\u001b[39m\u001b[33mxgboost\u001b[39m\u001b[33m\"\u001b[39m, \u001b[38;5;66;03m# or logreg/sgd/random_forest/svc/knn\u001b[39;00m\n\u001b[32m 6\u001b[39m random_state=\u001b[32m42\u001b[39m,\n\u001b[32m 7\u001b[39m )\n\u001b[32m 8\u001b[39m \u001b[38;5;28mprint\u001b[39m(clf_single[\u001b[33m\"\u001b[39m\u001b[33mmetrics\u001b[39m\u001b[33m\"\u001b[39m])\n\u001b[32m 9\u001b[39m cluster.plot_confusion_matrices(clf_single[\u001b[33m\"\u001b[39m\u001b[33mpredictions\u001b[39m\u001b[33m\"\u001b[39m])\n", + "\u001b[31mNameError\u001b[39m: name 'feat_single' is not defined" + ] + } + ], "source": [ "# sample_labels must align to feat_single rows (e.g., [\"sampleA\", \"sampleA\", \"sampleB\", ...])\n", "clf_single = cluster.classify_read_features_binary(\n", @@ -2079,9 +2121,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'feat_multi' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[4]\u001b[39m\u001b[32m, line 3\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;66;03m# sample_labels_multi must align to feat_multi rows\u001b[39;00m\n\u001b[32m 2\u001b[39m clf_multi = cluster.classify_read_features_binary(\n\u001b[32m----> \u001b[39m\u001b[32m3\u001b[39m \u001b[43mfeat_multi\u001b[49m,\n\u001b[32m 4\u001b[39m sample_labels=sample_labels_multi,\n\u001b[32m 5\u001b[39m classifier=\u001b[33m\"\u001b[39m\u001b[33mxgboost\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 6\u001b[39m random_state=\u001b[32m42\u001b[39m,\n\u001b[32m 7\u001b[39m )\n\u001b[32m 8\u001b[39m \u001b[38;5;28mprint\u001b[39m(clf_multi[\u001b[33m\"\u001b[39m\u001b[33mmetrics\u001b[39m\u001b[33m\"\u001b[39m])\n\u001b[32m 9\u001b[39m cluster.plot_confusion_matrices(clf_multi[\u001b[33m\"\u001b[39m\u001b[33mpredictions\u001b[39m\u001b[33m\"\u001b[39m])\n", + "\u001b[31mNameError\u001b[39m: name 'feat_multi' is not defined" + ] + } + ], "source": [ "# sample_labels_multi must align to feat_multi rows\n", "clf_multi = cluster.classify_read_features_binary(\n", @@ -2128,7 +2182,7 @@ "region_labels, _ = cluster.cluster_features(pileup_matrix, n_clusters=4)\n", "\n", "# Visualize mean profiles + heatmap of loci sorted by cluster\n", - "cluster.plot_region_cluster_profiles(pileup_matrix, region_labels, window_bp=1000)\n", + "cluster.plot_region_cluster_profiles(pileup_matrix, region_labels, window_size=1000)\n", "\n", "# Export cluster-labeled BED and karyotype view\n", "cluster.export_region_clusters_to_bed(region_info, region_labels, \"region_clusters.bed\")\n", @@ -2310,7 +2364,7 @@ "version_minor": 0 }, "text/plain": [ - "Step 1: Indexing contigs in pileup.sorted.bed.gz to set up bigwig header for pileup.fractions.bigwig: 0%| …" + "Step 1: Indexing contigs in pileup.sorted.bed.gz to set up bigwig header for pileup.fractions.bigwig: 0%| \u2026" ] }, "metadata": {}, @@ -2562,7 +2616,7 @@ "version_minor": 0 }, "text/plain": [ - "Step 2: Writing pileup.sorted.bed.gz contents to pileup.fractions.bigwig: 0%| | 0/17 [00:00 0\n", + " if read_window_min_valid_fraction > 0 and rw_single.val_matrix.shape[1] > 0:\n", + " valid_mask &= (valid_sums / rw_single.val_matrix.shape[1]) >= read_window_min_valid_fraction\n", + " assignments_single = assignments_single.loc[valid_mask].reset_index(drop=True)\n", + "\n", + "cluster_labels_single = [f\"C{int(v)}\" for v in np.asarray(read_clusters_single.labels_size_ordered)]\n", + "if len(assignments_single) != len(cluster_labels_single):\n", + " raise ValueError(\n", + " f\"Cluster/metadata length mismatch after alignment: {len(cluster_labels_single)} labels vs {len(assignments_single)} rows\"\n", + " )\n", + "assignments_single['cluster'] = cluster_labels_single\n", + "if 'source_label' not in assignments_single.columns:\n", + " assignments_single['source_label'] = 'merged'\n", + "\n", + "def _region_id_from_assignment(row):\n", + " strand = str(row.get('region_strand', '.'))\n", + " strand = strand if strand in {'+', '-', '.'} else '.'\n", + " return f\"{row['chromosome']}:{int(row['region_start'])}-{int(row['region_end'])},{strand}\"\n", + "\n", + "assignments_single['region_id'] = assignments_single.apply(_region_id_from_assignment, axis=1)\n", + "\n", + "region_summaries_single = (\n", + " assignments_single.groupby(['region_id', 'cluster', 'source_label'], dropna=False)\n", + " .size()\n", + " .reset_index(name='count')\n", + ")\n", + "region_summaries_single['fraction'] = (\n", + " region_summaries_single['count']\n", + " / region_summaries_single.groupby(['region_id', 'source_label'])['count'].transform('sum')\n", + ")\n", + "\n", + "cluster_result_for_chip_atlas = SharedClusterResult(\n", + " model=SharedClusterModel(\n", + " mode='read_global',\n", + " motifs=['A,0'],\n", + " feature_names=feature_names_single,\n", + " preprocessing={'tutorial_object': True},\n", + " estimator=read_clusters_single.model,\n", + " cluster_labels=sorted(pd.unique(assignments_single['cluster'])),\n", + " fit_metadata={'random_state': 42},\n", + " ),\n", + " assignments=assignments_single,\n", + " cluster_distribution=pd.DataFrame(),\n", + " condition_distribution=pd.DataFrame(),\n", + " distribution_change=None,\n", + " cluster_profiles=pd.DataFrame(),\n", + " region_summaries=region_summaries_single,\n", + " plot_data={},\n", + " metadata={'source': 'tutorial on/off-target merged read clustering'},\n", + ")\n", + "\n", + "print(f\"Prepared {len(assignments_single):,} reads across {assignments_single['cluster'].nunique()} clusters and {region_summaries_single['region_id'].nunique()} regions.\")\n", + "region_summaries_single.sort_values(['source_label', 'fraction'], ascending=[True, False]).head(12)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from dimelo import workflows\n", + "\n", + "RUN_CHIP_ATLAS = False # switch to True to submit enrichment jobs\n", + "\n", + "chip_atlas_kwargs = {\n", + " 'genome': 'hg38',\n", + " 'mode': 'per_cluster',\n", + " 'top_n_regions': 50,\n", + " 'min_fraction': 0.5,\n", + " # Optional specificity knobs (set to None for broad scans):\n", + " # 'antigen_class': 'TFs and others',\n", + " # 'antigen': 'CTCF',\n", + " # 'cell_type_class': 'Blood',\n", + " # 'cell_type': 'K562',\n", + " 'wait': True,\n", + " 'fetch_results': True,\n", + " 'timeout_seconds': 900,\n", + "}\n", + "\n", + "if RUN_CHIP_ATLAS:\n", + " try:\n", + " chip_results = workflows.chip_atlas_cluster_enrichment_workflow(\n", + " cluster_result=cluster_result_for_chip_atlas,\n", + " **chip_atlas_kwargs,\n", + " )\n", + " for cluster_name, result in chip_results.items():\n", + " print(f\"\\n[{cluster_name}] request_id={result.request_id} status={result.status}\")\n", + " if result.results is not None and not result.results.empty:\n", + " print(result.results.head(10).to_string(index=False))\n", + " else:\n", + " print('No parsed result table returned.')\n", + " except Exception as exc:\n", + " print(f\"ChIP-Atlas query failed: {exc}\")\n", + "else:\n", + " print('Skipping ChIP-Atlas query. Set RUN_CHIP_ATLAS=True to run enrichment.')\n" + ] } ], "metadata": { "kernelspec": { - "display_name": "dimelo", + "display_name": "dimelo-toolkit", "language": "python", "name": "python3" }, diff --git a/tutorial_offline.ipynb b/tutorial_offline.ipynb new file mode 100644 index 0000000..096e404 --- /dev/null +++ b/tutorial_offline.ipynb @@ -0,0 +1,314 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Offline End-to-End Tutorial Gate\n", + "\n", + "This notebook is a deterministic local-data tutorial path for stabilization verification.\n", + "It demonstrates core parse/load/plot paths, workflow outputs, and an offline-safe regulatory/chip-atlas setup flow.\n" + ], + "id": "cell-000" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import json\n", + "from matplotlib import pyplot as plt\n", + "\n", + "from dimelo import parse_bam, plot_depth_profile, plot_enrichment, plot_reads, workflows\n", + "from dimelo.models import SampleSpec\n", + "\n", + "repo_root = Path.cwd()\n", + "data_dir = repo_root / \"dimelo\" / \"test\" / \"data\"\n", + "reference_dir = repo_root / \"dimelo\" / \"test\" / \"output\"\n", + "artifact_dir = repo_root / \"artifacts\" / \"tutorial_offline\"\n", + "artifact_dir.mkdir(parents=True, exist_ok=True)\n", + "\n", + "ctcf_bam_file_updated = reference_dir / \"ctcf_demo.updated.bam\"\n", + "ctcf_target_regions = data_dir / \"ctcf_demo_peak.bed\"\n", + "ctcf_off_target_regions = data_dir / \"ctcf_demo_not_peak.bed\"\n", + "ref_genome_file = reference_dir / \"chm13.draft_v1.0.fasta\"\n", + "\n", + "required_paths = [ctcf_bam_file_updated, ctcf_target_regions, ctcf_off_target_regions, ref_genome_file]\n", + "missing = [str(path) for path in required_paths if not path.exists()]\n", + "if missing:\n", + " raise FileNotFoundError(\"Missing required local tutorial assets: \" + \", \".join(missing))\n", + "\n", + "print(\"Using local assets:\")\n", + "for path in required_paths:\n", + " print(f\" - {path}\")\n" + ], + "id": "cell-001" + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Parse BAM (Pileup + Extract)" + ], + "id": "cell-002" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pileup_file, pileup_regions = parse_bam.pileup(\n", + " input_file=ctcf_bam_file_updated,\n", + " output_name=\"offline_tutorial_pileup\",\n", + " ref_genome=ref_genome_file,\n", + " output_directory=artifact_dir,\n", + " regions=[ctcf_target_regions, ctcf_off_target_regions],\n", + " motifs=[\"A,0\", \"CG,0\"],\n", + " thresh=190,\n", + " window_size=1000,\n", + " cores=1,\n", + " quiet=True,\n", + ")\n", + "\n", + "extract_file, extract_regions = parse_bam.extract(\n", + " input_file=ctcf_bam_file_updated,\n", + " output_name=\"offline_tutorial_extract\",\n", + " ref_genome=ref_genome_file,\n", + " output_directory=artifact_dir,\n", + " regions=[ctcf_target_regions, ctcf_off_target_regions],\n", + " motifs=[\"A,0\", \"CG,0\"],\n", + " thresh=190,\n", + " window_size=1000,\n", + " cores=1,\n", + " quiet=True,\n", + ")\n", + "\n", + "print(\"pileup_file:\", pileup_file)\n", + "print(\"extract_file:\", extract_file)\n", + "print(\"pileup_regions:\", pileup_regions)\n", + "print(\"extract_regions:\", extract_regions)\n" + ], + "id": "cell-003" + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting Modules (Enrichment / Depth / Reads)" + ], + "id": "cell-004" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure(figsize=(5, 3))\n", + "plot_enrichment.by_regions(\n", + " mod_file_name=pileup_file,\n", + " regions_list=[ctcf_target_regions, ctcf_off_target_regions],\n", + " motif=\"A,0\",\n", + " sample_names=[\"on-target\", \"off-target\"],\n", + " single_strand=False,\n", + ")\n", + "enrichment_png = artifact_dir / \"enrichment_by_region.png\"\n", + "plt.tight_layout()\n", + "plt.savefig(enrichment_png, dpi=150)\n", + "plt.close()\n", + "\n", + "plt.figure(figsize=(6, 3))\n", + "plot_depth_profile.by_modification(\n", + " mod_file_name=pileup_file,\n", + " regions=ctcf_target_regions,\n", + " motifs=[\"A,0\", \"CG,0\"],\n", + " window_size=1000,\n", + " single_strand=False,\n", + " smooth_window=50,\n", + ")\n", + "depth_png = artifact_dir / \"depth_profile.png\"\n", + "plt.tight_layout()\n", + "plt.savefig(depth_png, dpi=150)\n", + "plt.close()\n", + "\n", + "single_region = \"chr1:114357437-114359753\"\n", + "plt.figure(figsize=(7, 3))\n", + "plot_reads.plot_reads(\n", + " mod_file_name=extract_file,\n", + " regions=single_region,\n", + " motifs=[\"A,0\", \"CG,0\"],\n", + " window_size=500,\n", + " single_strand=False,\n", + " thresh=0.5,\n", + " s=0.8,\n", + ")\n", + "reads_png = artifact_dir / \"single_read_raster.png\"\n", + "plt.tight_layout()\n", + "plt.savefig(reads_png, dpi=150)\n", + "plt.close()\n", + "\n", + "print(\"Saved:\")\n", + "print(f\" - {enrichment_png}\")\n", + "print(f\" - {depth_png}\")\n", + "print(f\" - {reads_png}\")\n" + ], + "id": "cell-005" + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Workflow-Level Output (Shared Clustering)" + ], + "id": "cell-006" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "samples = [\n", + " SampleSpec(\n", + " sample_id=\"demo_A\",\n", + " condition=\"baseline\",\n", + " extract_h5=str(extract_file),\n", + " regions_bed=str(pileup_regions),\n", + " metadata={\"pileup_path\": str(pileup_file)},\n", + " ),\n", + " SampleSpec(\n", + " sample_id=\"demo_B\",\n", + " condition=\"treated\",\n", + " extract_h5=str(extract_file),\n", + " regions_bed=str(pileup_regions),\n", + " metadata={\"pileup_path\": str(pileup_file)},\n", + " ),\n", + "]\n", + "\n", + "shared_result = workflows.shared_cluster_distribution(\n", + " samples=samples,\n", + " mode=\"region_anchored\",\n", + " motifs=[\"A,0\"],\n", + " matched_regions=pileup_regions,\n", + " n_clusters=2,\n", + " training_sample_per_dataset=2000,\n", + " make_plots=False,\n", + " quiet=True,\n", + " cores=1,\n", + ")\n", + "\n", + "shared_result.condition_distribution.head()\n" + ], + "id": "cell-007" + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Regulatory / ChIP-Atlas Setup Spec (Offline-Safe)" + ], + "id": "cell-008" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "regulatory_spec = workflows.resolve_regulatory_enrichment_spec(\n", + " species=\"homo_sapiens\",\n", + " providers=[\"screen\", \"unibind\"],\n", + " target_genome=\"hg38\",\n", + ")\n", + "\n", + "regulatory_spec\n" + ], + "id": "cell-009" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "RUN_CHIP_ATLAS = False # Optional live-network step\n", + "\n", + "chip_atlas_kwargs = {\n", + " \"genome\": \"hg38\",\n", + " \"mode\": \"per_cluster\",\n", + " \"top_n_regions\": 25,\n", + " \"timeout_seconds\": 120.0,\n", + "}\n", + "\n", + "if RUN_CHIP_ATLAS:\n", + " chip_result = workflows.chip_atlas_cluster_enrichment_workflow(\n", + " cluster_result=shared_result,\n", + " **chip_atlas_kwargs,\n", + " )\n", + " display(chip_result)\n", + "else:\n", + " print(\"Skipping live ChIP-Atlas request (RUN_CHIP_ATLAS=False).\")\n", + " print(\"Prepared call arguments:\", chip_atlas_kwargs)\n" + ], + "id": "cell-010" + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Persist Tutorial Summary" + ], + "id": "cell-011" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "summary = {\n", + " \"pileup_file\": str(pileup_file),\n", + " \"extract_file\": str(extract_file),\n", + " \"pileup_regions\": str(pileup_regions),\n", + " \"extract_regions\": str(extract_regions),\n", + " \"plot_outputs\": {\n", + " \"enrichment\": str(artifact_dir / \"enrichment_by_region.png\"),\n", + " \"depth_profile\": str(artifact_dir / \"depth_profile.png\"),\n", + " \"single_read_raster\": str(artifact_dir / \"single_read_raster.png\"),\n", + " },\n", + " \"workflow\": {\n", + " \"cluster_labels\": list(shared_result.model.cluster_labels),\n", + " \"condition_rows\": int(shared_result.condition_distribution.shape[0]),\n", + " \"region_summary_rows\": int(0 if shared_result.region_summaries is None else shared_result.region_summaries.shape[0]),\n", + " },\n", + " \"regulatory_spec\": {\n", + " \"species\": regulatory_spec.species,\n", + " \"providers\": list(regulatory_spec.providers),\n", + " \"target_genome\": regulatory_spec.target_genome,\n", + " },\n", + "}\n", + "summary_path = artifact_dir / \"offline_tutorial_summary.json\"\n", + "summary_path.write_text(json.dumps(summary, indent=2))\n", + "print(\"Wrote\", summary_path)\n", + "summary\n" + ], + "id": "cell-012" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file From 1fda0c7af44d600796e84654ea844fc199a1f62a Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Tue, 28 Apr 2026 13:54:18 -0700 Subject: [PATCH 269/272] Update modkit defaults and clean ruff findings --- .github/workflows/formatting.yml | 4 +- .pre-commit-config.yaml | 2 +- README.md | 30 +- dimelo/__init__.py | 10 +- dimelo/artifacts.py | 20 +- dimelo/chip_atlas.py | 148 +- dimelo/cluster.py | 1590 +++++++++++++++++---- dimelo/distribution.py | 29 +- dimelo/dmr.py | 23 +- dimelo/export.py | 187 ++- dimelo/global_analysis.py | 11 +- dimelo/load_processed.py | 175 ++- dimelo/models.py | 15 +- dimelo/parse_bam.py | 386 +++-- dimelo/plot_depth_histogram.py | 8 +- dimelo/plot_depth_profile.py | 8 +- dimelo/plot_enrichment.py | 9 +- dimelo/plot_enrichment_profile.py | 19 +- dimelo/plot_reads.py | 6 +- dimelo/plotting.py | 479 +++++-- dimelo/plotting_matplotlib.py | 444 ++++-- dimelo/region_analysis.py | 10 +- dimelo/region_contrasts.py | 220 ++- dimelo/region_discovery.py | 279 +++- dimelo/regulatory_enrichment.py | 71 +- dimelo/run_modkit.py | 265 ++-- dimelo/shared_cluster_tests.py | 160 ++- dimelo/test/dimelo_test.py | 177 +-- dimelo/utils.py | 9 +- dimelo/workflows.py | 110 +- dimelo_test.ipynb | 2046 +++++++-------------------- environment.yml | 4 +- scripts/bootstrap_dimelo_env.sh | 2 +- scripts/ensure_dimelo_kernel.py | 25 +- scripts/run_tutorial_offline.py | 1 - tests/test_artifacts.py | 6 +- tests/test_chip_atlas.py | 32 +- tests/test_cluster.py | 1339 ++++++++++++++++-- tests/test_distribution.py | 16 +- tests/test_dmr.py | 14 +- tests/test_export.py | 337 +++++ tests/test_global_analysis.py | 22 +- tests/test_load_processed.py | 139 +- tests/test_models.py | 24 +- tests/test_parse_bam.py | 320 ++++- tests/test_parse_bam_vectors.py | 129 +- tests/test_plotting.py | 656 +++++++-- tests/test_region_analysis.py | 22 +- tests/test_region_contrasts.py | 142 +- tests/test_region_discovery.py | 381 +++-- tests/test_regulatory_enrichment.py | 74 +- tests/test_run_modkit.py | 72 +- tests/test_shared_cluster_tests.py | 204 ++- tests/test_workflows.py | 375 ++++- tutorial.ipynb | 177 +-- 55 files changed, 8016 insertions(+), 3447 deletions(-) create mode 100644 tests/test_export.py diff --git a/.github/workflows/formatting.yml b/.github/workflows/formatting.yml index 5cac669..907168e 100644 --- a/.github/workflows/formatting.yml +++ b/.github/workflows/formatting.yml @@ -7,7 +7,7 @@ jobs: - uses: actions/checkout@v4 - uses: chartboost/ruff-action@v1 with: - version: 0.6.8 + version: 0.15.12 # TODO: Is it really necessary for these to be separate jobs? This seems redundant. ruff-format-check: runs-on: ubuntu-latest @@ -15,5 +15,5 @@ jobs: - uses: actions/checkout@v4 - uses: chartboost/ruff-action@v1 with: - version: 0.6.8 + version: 0.15.12 args: 'format --check' diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 5194a15..9d00577 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,6 +1,6 @@ repos: - repo: https://github.com/astral-sh/ruff-pre-commit - rev: v0.6.8 + rev: v0.15.12 hooks: # Run the linter. - id: ruff diff --git a/README.md b/README.md index 36ff0bd..a7ffece 100644 --- a/README.md +++ b/README.md @@ -106,8 +106,8 @@ bash scripts/bootstrap_dimelo_env.sh " Path, Path: @@ -267,6 +264,7 @@ def extract( cores: int = None, log: bool = False, cleanup: bool = True, + overwrite: bool = True, quiet: bool = False, override_checks: bool = False, modkit_executable: str | Path | None = None,) -> Path, Path: @@ -891,6 +889,8 @@ def read_vectors_from_hdf5( cores: int | None = None, # currently unused subset_parameters: dict | None = None, span_full_window: bool = False, + random_sample_n_reads: int | None = None, + min_read_length_bp: int | None = None, ) -> tuple[list[tuple], list[str], dict | None]: """ User-facing function. @@ -940,6 +940,8 @@ def read_vectors_from_hdf5( reads to be returned. If not None, at least one of n or frac must be provided. The array parameter should not be provided here. span_full_window: If True, only load reads that fully span the window defined by region_start-region_end + random_sample_n_reads: Optional global random sample size by unique read name. + min_read_length_bp: Optional minimum read length filter (bp) applied before loading vectors. Returns: a list of tuples, each tuple containing all datasets corresponding to an individual read that @@ -1120,6 +1122,8 @@ For **clustering read-window extraction APIs** (`cluster.extract_read_windows`, `cleanup` will keep the (often large) human-readable outputs that are inefficient for plotting and vector extraction but may be helpful for other use cases. +`overwrite` controls whether parse outputs for the target `output_name` are regenerated. When `True` (default), existing outputs are replaced. When `False`, complete existing outputs are reused; if partial/conflicting artifacts exist, parsing raises `FileExistsError`. + `quiet` suppressed progress bars and other outputs. `override_checks` lets you run modkit even if the bam format checking and reference alignment checking are anomalous. @@ -1130,6 +1134,12 @@ For **clustering read-window extraction APIs** (`cluster.extract_read_windows`, ## No progress bars The most common culprit for progress bar issues in notebooks (Jupyter or Colab) is an incompatibility between your notebooks interfaces and your `ipywidgets` version. The latest jupyter notebooks or jupyter lab install and the latest ipywidgets should work together, but on Google Colab, VS Code, Open On Demand, and other jupyter interfaces this may not be the case. [setup.py](setup.py) contains details on which versions you can try downgrading to for different platforms. The following code run in your activated conda environment will downgrade `ipywidgets` to your specified version. **Our Colab instructions in the [Colab Installation](#google-colab-installation) section and the [tutorial](tutorial.ipynb) already handle this for you.** +Live parse/extract progress bars now auto-disable in notebook/non-TTY contexts to avoid mangled carriage-return output. You can force behavior with: +- `DIMELO_PROGRESS_MODE=off` to disable live bars everywhere +- `DIMELO_PROGRESS_MODE=on` to force live bars + +In notebooks, you can also pass `quiet=True` to `parse_bam.pileup(...)` and `parse_bam.extract(...)`. + ``` pip install ipywidgets==X.XX.X ``` diff --git a/dimelo/__init__.py b/dimelo/__init__.py index 5d4dba6..f732dac 100644 --- a/dimelo/__init__.py +++ b/dimelo/__init__.py @@ -1,25 +1,25 @@ from . import ( chip_atlas, cluster, - dmr, distribution, + dmr, export, global_analysis, load_processed, models, parse_bam, - plotting, - plotting_matplotlib, plot_depth_histogram, plot_depth_profile, plot_enrichment, plot_enrichment_profile, plot_read_browser, plot_reads, - regulatory_enrichment, - region_discovery, + plotting, + plotting_matplotlib, region_analysis, region_contrasts, + region_discovery, + regulatory_enrichment, shared_cluster_tests, workflows, ) diff --git a/dimelo/artifacts.py b/dimelo/artifacts.py index fed49ac..5c99fb5 100644 --- a/dimelo/artifacts.py +++ b/dimelo/artifacts.py @@ -40,11 +40,15 @@ def _normalize_source_files(values: object) -> tuple[str, ...] | None: return tuple(sorted(str(value) for value in normalized)) -def _normalize_source_fingerprints(values: object) -> tuple[dict[str, object], ...] | None: +def _normalize_source_fingerprints( + values: object, +) -> tuple[dict[str, object], ...] | None: if values is None: return None normalized = [dict(value) for value in values] - normalized.sort(key=lambda value: json.dumps(value, sort_keys=True, separators=(",", ":"))) + normalized.sort( + key=lambda value: json.dumps(value, sort_keys=True, separators=(",", ":")) + ) return tuple(normalized) @@ -78,7 +82,9 @@ def artifact_fingerprint(artifact: DatasetArtifact) -> dict[str, object]: "schema_version": artifact.metadata.get("schema_version"), "package_version": artifact.metadata.get("package_version"), "source_files": _normalize_source_files( - artifact.provenance.get("source_files", artifact.metadata.get("source_files")) + artifact.provenance.get( + "source_files", artifact.metadata.get("source_files") + ) ), "source_fingerprints": _normalize_source_fingerprints( artifact.provenance.get( @@ -86,7 +92,9 @@ def artifact_fingerprint(artifact: DatasetArtifact) -> dict[str, object]: ) ), "upstream_lineage": _normalize_sequence( - artifact.provenance.get("upstream_lineage", artifact.metadata.get("upstream_lineage")) + artifact.provenance.get( + "upstream_lineage", artifact.metadata.get("upstream_lineage") + ) ), "params_hash": _params_hash(artifact.params), } @@ -102,7 +110,9 @@ def _has_required_fingerprint_fields(fingerprint: dict[str, object]) -> bool: ) if any(fingerprint[field] is None for field in required_fields): return False - return bool(fingerprint["source_files"]) and bool(fingerprint["source_fingerprints"]) + return bool(fingerprint["source_files"]) and bool( + fingerprint["source_fingerprints"] + ) def artifact_is_compatible( diff --git a/dimelo/chip_atlas.py b/dimelo/chip_atlas.py index f451f36..22f309f 100644 --- a/dimelo/chip_atlas.py +++ b/dimelo/chip_atlas.py @@ -9,8 +9,9 @@ import tempfile import time import zipfile +from collections.abc import Iterable, Mapping from pathlib import Path -from typing import Any, Iterable, Mapping +from typing import Any from urllib import error, parse, request import numpy as np @@ -23,9 +24,7 @@ DEFAULT_RESULT_URL = DEFAULT_SUBMIT_URL DEFAULT_CHAIN_CACHE_DIR = Path("cache/chains") DEFAULT_METADATA_CACHE_DIR = Path("cache/chip_atlas") -DEFAULT_EXPERIMENT_LIST_URL = ( - "https://dbarchive.biosciencedbc.jp/data/chip-atlas/LATEST/chip_atlas_experiment_list.zip" -) +DEFAULT_EXPERIMENT_LIST_URL = "https://dbarchive.biosciencedbc.jp/data/chip-atlas/LATEST/chip_atlas_experiment_list.zip" _SUCCESS_STATUSES = {"finished"} _TERMINAL_STATUSES = {"finished", "error", "cancelled", "unknown"} @@ -63,8 +62,14 @@ } _CHAIN_URL_OVERRIDES = { - ("hs1", "hg38"): "https://hgdownload.soe.ucsc.edu/goldenPath/hs1/liftOver/hs1ToHg38.over.chain.gz", - ("hs1", "hg19"): "https://hgdownload.soe.ucsc.edu/goldenPath/hs1/liftOver/hs1ToHg19.over.chain.gz", + ( + "hs1", + "hg38", + ): "https://hgdownload.soe.ucsc.edu/goldenPath/hs1/liftOver/hs1ToHg38.over.chain.gz", + ( + "hs1", + "hg19", + ): "https://hgdownload.soe.ucsc.edu/goldenPath/hs1/liftOver/hs1ToHg19.over.chain.gz", } _BED_THRESHOLD_COLUMN_MAP = { @@ -120,7 +125,9 @@ def _http_request( detail = exc.read().decode("utf-8", errors="replace") hint = "" lowered = detail.lower() - if exc.code == 404 and ("chip-atlas: 404" in lowered or "" in lowered): + if exc.code == 404 and ( + "chip-atlas: 404" in lowered or "" in lowered + ): hint = ( " The endpoint may be outdated. The current API base URL is " "'https://dtn1.ddbj.nig.ac.jp/wabi/chipatlas/'." @@ -170,7 +177,11 @@ def _resolve_chain_file( source = _normalize_genome_name(source_genome) target = _normalize_genome_name(target_genome) - cache_root = Path(chain_cache_dir) if chain_cache_dir is not None else DEFAULT_CHAIN_CACHE_DIR + cache_root = ( + Path(chain_cache_dir) + if chain_cache_dir is not None + else DEFAULT_CHAIN_CACHE_DIR + ) cache_root.mkdir(parents=True, exist_ok=True) cached_path = cache_root / f"{source}_to_{target}.over.chain.gz" if cached_path.exists() and cached_path.stat().st_size > 0: @@ -179,9 +190,11 @@ def _resolve_chain_file( url = chain_url if chain_url is not None else _chain_url_for_pair(source, target) request_obj = request.Request(url, headers={"User-Agent": "dimelo-toolkit/1.0"}) try: - with request.urlopen(request_obj, timeout=timeout_seconds) as response: - with cached_path.open("wb") as handle: - shutil.copyfileobj(response, handle) + with ( + request.urlopen(request_obj, timeout=timeout_seconds) as response, + cached_path.open("wb") as handle, + ): + shutil.copyfileobj(response, handle) except Exception as exc: raise RuntimeError( "Failed to download CrossMap chain file for " @@ -282,7 +295,9 @@ def _download_bytes( f"ChIP-Atlas download failed with HTTP {exc.code}: {url}\n{detail[:300]}" ) from exc except error.URLError as exc: - raise RuntimeError(f"ChIP-Atlas download failed for {url}: {exc.reason}") from exc + raise RuntimeError( + f"ChIP-Atlas download failed for {url}: {exc.reason}" + ) from exc def _ensure_experiment_list_zip( @@ -306,13 +321,17 @@ def _ensure_experiment_list_zip( def _iter_experiment_rows(experiment_list_zip: Path) -> Iterable[dict[str, str]]: with zipfile.ZipFile(experiment_list_zip) as archive: - member = next((name for name in archive.namelist() if name.lower().endswith(".csv")), None) + member = next( + (name for name in archive.namelist() if name.lower().endswith(".csv")), None + ) if member is None: raise RuntimeError( "ChIP-Atlas experiment-list archive did not contain a CSV file." ) with archive.open(member, "r") as handle: - reader = csv.DictReader(io.TextIOWrapper(handle, encoding="utf-8", errors="replace")) + reader = csv.DictReader( + io.TextIOWrapper(handle, encoding="utf-8", errors="replace") + ) for row in reader: yield {str(k): ("" if v is None else str(v)) for k, v in row.items()} @@ -335,8 +354,12 @@ def _coerce_bed6(table: pd.DataFrame) -> pd.DataFrame: out = pd.DataFrame( { "chrom": table.iloc[:, 0].astype(str), - "start": pd.to_numeric(table.iloc[:, 1], errors="coerce").fillna(-1).astype(int), - "end": pd.to_numeric(table.iloc[:, 2], errors="coerce").fillna(-1).astype(int), + "start": pd.to_numeric(table.iloc[:, 1], errors="coerce") + .fillna(-1) + .astype(int), + "end": pd.to_numeric(table.iloc[:, 2], errors="coerce") + .fillna(-1) + .astype(int), "name": table.iloc[:, 3].astype(str) if table.shape[1] > 3 else ".", "score": table.iloc[:, 4] if table.shape[1] > 4 else 0, "strand": table.iloc[:, 5].astype(str) if table.shape[1] > 5 else ".", @@ -369,7 +392,9 @@ def _extract_request_id(body: str) -> str: if request_ids: return str(request_ids[0]) - id_match = re.search(r"\b(?:id|requestId|request_id)\s*[:=]\s*['\"]?([A-Za-z0-9._-]+)", stripped) + id_match = re.search( + r"\b(?:id|requestId|request_id)\s*[:=]\s*['\"]?([A-Za-z0-9._-]+)", stripped + ) if id_match: return id_match.group(1) @@ -453,7 +478,9 @@ def region_ids_to_bed_dataframe(region_ids: Iterable[str]) -> pd.DataFrame: "strand": strand, } ) - return pd.DataFrame(rows, columns=["chrom", "start", "end", "name", "score", "strand"]) + return pd.DataFrame( + rows, columns=["chrom", "start", "end", "name", "score", "strand"] + ) def _regions_dataframe_from_input( @@ -477,7 +504,9 @@ def _regions_dataframe_from_input( if not isinstance(source, pd.DataFrame): raise TypeError("Could not coerce ChIP-Atlas regions to a DataFrame.") if source.empty: - return pd.DataFrame(columns=["chrom", "start", "end", "name", "score", "strand"]) + return pd.DataFrame( + columns=["chrom", "start", "end", "name", "score", "strand"] + ) if source.columns.dtype == object and {"start", "end"}.issubset(source.columns): chrom_column = "chrom" if "chrom" in source.columns else "chromosome" @@ -490,9 +519,13 @@ def _regions_dataframe_from_input( "chrom": source[chrom_column].astype(str), "start": source["start"].astype(int), "end": source["end"].astype(int), - "name": source.get("name", pd.Series(".", index=source.index)).astype(str), + "name": source.get("name", pd.Series(".", index=source.index)).astype( + str + ), "score": source.get("score", pd.Series(0, index=source.index)), - "strand": source.get("strand", pd.Series(".", index=source.index)).astype(str), + "strand": source.get( + "strand", pd.Series(".", index=source.index) + ).astype(str), } ) return normalized @@ -537,7 +570,9 @@ def _regions_dataframe_from_lines(lines: Iterable[str]) -> pd.DataFrame: "strand": strand if strand in {"+", "-", "."} else ".", } ) - return pd.DataFrame(rows, columns=["chrom", "start", "end", "name", "score", "strand"]) + return pd.DataFrame( + rows, columns=["chrom", "start", "end", "name", "score", "strand"] + ) def _regions_to_bed_text(regions: pd.DataFrame | str | Path | Iterable[str]) -> str: @@ -646,12 +681,18 @@ def convert_regions_with_crossmap( "chrom": mapped.iloc[:, 0].astype(str), "start": mapped.iloc[:, 1].astype(int), "end": mapped.iloc[:, 2].astype(int), - "name": mapped.iloc[:, 3].astype(str) if len(mapped.columns) > 3 else ".", + "name": mapped.iloc[:, 3].astype(str) + if len(mapped.columns) > 3 + else ".", "score": mapped.iloc[:, 4] if len(mapped.columns) > 4 else 0, - "strand": mapped.iloc[:, 5].astype(str) if len(mapped.columns) > 5 else ".", + "strand": mapped.iloc[:, 5].astype(str) + if len(mapped.columns) > 5 + else ".", } ) - normalized = normalized[normalized["end"] > normalized["start"]].reset_index(drop=True) + normalized = normalized[normalized["end"] > normalized["start"]].reset_index( + drop=True + ) if normalized.empty: raise RuntimeError( "CrossMap conversion filtered all regions after coordinate validation." @@ -660,7 +701,9 @@ def convert_regions_with_crossmap( def _build_url(base_url: str, params_dict: Mapping[str, Any]) -> str: - query = parse.urlencode({key: value for key, value in params_dict.items() if value is not None}) + query = parse.urlencode( + {key: value for key, value in params_dict.items() if value is not None} + ) return f"{base_url}?{query}" if query else base_url @@ -767,7 +810,9 @@ def submit_enrichment( payload.update(dict(params)) encoded = parse.urlencode( { - key: ",".join(map(str, value)) if isinstance(value, (list, tuple, set)) else str(value) + key: ",".join(map(str, value)) + if isinstance(value, (list, tuple, set)) + else str(value) for key, value in payload.items() if value is not None } @@ -980,7 +1025,9 @@ def run_enrichment( submit_url=submit_url, status_url=status_url, result_url=result_url, - metadata={"submission": {k: v for k, v in submission.items() if k != "response"}}, + metadata={ + "submission": {k: v for k, v in submission.items() if k != "response"} + }, ) @@ -1044,9 +1091,13 @@ def _matches(value: str, query: str) -> bool: continue if not _matches(raw.get("Antigen", ""), antigen_norm): continue - if antigen_class_query and not _matches(raw.get("Antigen class", ""), antigen_class_query): + if antigen_class_query and not _matches( + raw.get("Antigen class", ""), antigen_class_query + ): continue - if cell_type_class_query and not _matches(raw.get("Cell type class", ""), cell_type_class_query): + if cell_type_class_query and not _matches( + raw.get("Cell type class", ""), cell_type_class_query + ): continue if cell_type_query and not _matches(raw.get("Cell type", ""), cell_type_query): continue @@ -1062,7 +1113,9 @@ def _matches(value: str, query: str) -> bool: "antigen": str(raw.get("Antigen", "")).strip(), "cell_type_class": str(raw.get("Cell type class", "")).strip(), "cell_type": str(raw.get("Cell type", "")).strip(), - "cell_type_description": str(raw.get("Cell type description", "")).strip(), + "cell_type_description": str( + raw.get("Cell type description", "") + ).strip(), "processing_logs": str(raw.get("Processing logs", "")).strip(), "title": str(raw.get("Title", "")).strip(), "metadata": str(raw.get("Meta data", "")).strip(), @@ -1113,8 +1166,7 @@ def download_peak_datasets( missing = required - set(datasets.columns) if missing: raise ValueError( - "datasets is missing required columns: " - f"{', '.join(sorted(missing))}" + f"datasets is missing required columns: {', '.join(sorted(missing))}" ) if include_top_n is not None and int(include_top_n) < 0: raise ValueError("include_top_n must be non-negative.") @@ -1124,7 +1176,11 @@ def download_peak_datasets( stratify_bins = _resolve_stratification_bins(stratify) selected = datasets.copy() if dataset_ids is not None: - wanted = {str(dataset_id).strip() for dataset_id in dataset_ids if str(dataset_id).strip()} + wanted = { + str(dataset_id).strip() + for dataset_id in dataset_ids + if str(dataset_id).strip() + } selected = selected.loc[selected["dataset_id"].astype(str).isin(wanted)].copy() if selected.empty: return pd.DataFrame( @@ -1150,9 +1206,9 @@ def _write_variant(path: Path, frame: pd.DataFrame) -> Path: return path for row in selected.itertuples(index=False): - dataset_id = str(getattr(row, "dataset_id")) - bed_url = str(getattr(row, "bed_url")) - source_genome = str(getattr(row, "genome_assembly")) + dataset_id = str(row.dataset_id) + bed_url = str(row.bed_url) + source_genome = str(row.genome_assembly) dataset_dir = output_root / dataset_id raw_path = dataset_dir / "raw.bed" @@ -1171,9 +1227,19 @@ def _write_variant(path: Path, frame: pd.DataFrame) -> Path: if include_complete_sorted: variants.append(("full_sorted", sorted_table)) if include_top_n is not None and int(include_top_n) > 0: - variants.append((f"top_{int(include_top_n)}", sorted_table.head(int(include_top_n)).copy())) + variants.append( + ( + f"top_{int(include_top_n)}", + sorted_table.head(int(include_top_n)).copy(), + ) + ) if include_bottom_n is not None and int(include_bottom_n) > 0: - variants.append((f"bottom_{int(include_bottom_n)}", sorted_table.tail(int(include_bottom_n)).copy())) + variants.append( + ( + f"bottom_{int(include_bottom_n)}", + sorted_table.tail(int(include_bottom_n)).copy(), + ) + ) if stratify_bins is not None and len(sorted_table) > 0: chunks = np.array_split(np.arange(len(sorted_table)), stratify_bins) for i, idx in enumerate(chunks, start=1): @@ -1207,7 +1273,9 @@ def _write_variant(path: Path, frame: pd.DataFrame) -> Path: ) if crossmap_target_genome is None: continue - if _normalize_genome_name(source_genome) == _normalize_genome_name(target_genome): + if _normalize_genome_name(source_genome) == _normalize_genome_name( + target_genome + ): continue bed6 = _coerce_bed6(variant_table) if bed6.empty: diff --git a/dimelo/cluster.py b/dimelo/cluster.py index 2246031..02e1752 100644 --- a/dimelo/cluster.py +++ b/dimelo/cluster.py @@ -1,11 +1,14 @@ from __future__ import annotations +import contextlib +import math +import warnings from collections import Counter, defaultdict +from collections.abc import Sequence from dataclasses import dataclass from functools import partial -import math from pathlib import Path -from typing import Any, Sequence +from typing import Any import numpy as np import pandas as pd @@ -61,6 +64,11 @@ class ReadWindowExtractionConfig: window_size: int | None = None orientation_aware: bool = True filter_multi_region_reads: bool = False + # Require thresholded/binary read vectors for downstream clustering/classification. + # If raw probabilities are detected, apply this threshold automatically unless set to None. + auto_threshold_if_raw: float | int | None = 190 + enforce_thresholded_vectors: bool = True + warn_on_auto_threshold: bool = True @dataclass @@ -167,7 +175,9 @@ def region_feature_matrix_from_pileup( modified = np.asarray(vector[0], dtype=np.float32) valid = np.asarray(vector[1], dtype=np.float32) if modified.shape != valid.shape: - raise ValueError("Modified and valid vectors must have matching shapes.") + raise ValueError( + "Modified and valid vectors must have matching shapes." + ) denominator = valid + (2 * pseudo_count) with np.errstate(divide="ignore", invalid="ignore"): fraction = np.divide( @@ -357,7 +367,9 @@ def cluster_features( def _get_kmeans(): try: from sklearn.cluster import KMeans - except ImportError as exc: # pragma: no cover - exercised in environments w/o sklearn + except ( + ImportError + ) as exc: # pragma: no cover - exercised in environments w/o sklearn raise ImportError( "scikit-learn is required for k-means clustering. " "Install it with `pip install scikit-learn`." @@ -370,8 +382,7 @@ def _get_xgb_classifier(): from xgboost import XGBClassifier except Exception as exc: # pragma: no cover - optional dependency raise ImportError( - "Install xgboost to use classifier='xgboost'. " - "Try `pip install xgboost`." + "Install xgboost to use classifier='xgboost'. Try `pip install xgboost`." ) from exc return XGBClassifier @@ -585,7 +596,9 @@ def merge_read_window_results( A merged ReadWindowExtractionResult. """ if len(results) == 0: - raise ValueError("results must contain at least one ReadWindowExtractionResult.") + raise ValueError( + "results must contain at least one ReadWindowExtractionResult." + ) if source_labels is not None and len(source_labels) != len(results): raise ValueError("source_labels length must match results length.") if align not in {"error", "center_crop"}: @@ -641,7 +654,9 @@ def merge_read_window_results( ) -def _prepare_group_labels(labels: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]: +def _prepare_group_labels( + labels: np.ndarray, +) -> tuple[np.ndarray, np.ndarray, np.ndarray]: labels_arr = np.asarray(labels) codes, uniques = pd.factorize(labels_arr, sort=True) # Handle NaN/None labels from factorize (-1 code): convert to explicit category name @@ -684,6 +699,10 @@ def _extract_window_from_record( idx: dict[str, int], window_span: int, orientation_aware: bool, + *, + enforce_thresholded_vectors: bool, + auto_threshold_if_raw: float | None, + notify_auto_threshold, ) -> tuple[np.ndarray, np.ndarray | None] | None: required = ["read_start", "read_end", "region_start", "region_end", "mod_vector"] for key in required: @@ -695,9 +714,7 @@ def _extract_window_from_record( region_start = int(record[idx["region_start"]]) region_end = int(record[idx["region_end"]]) mod_vector = np.asarray(record[idx["mod_vector"]]) - val_vector = ( - np.asarray(record[idx["val_vector"]]) if "val_vector" in idx else None - ) + val_vector = np.asarray(record[idx["val_vector"]]) if "val_vector" in idx else None if read_end <= read_start or region_end <= region_start: return None @@ -717,9 +734,25 @@ def _extract_window_from_record( return None mod_window = mod_vector[slice_start:slice_end] - val_window = ( - val_vector[slice_start:slice_end] if val_vector is not None else None - ) + val_window = val_vector[slice_start:slice_end] if val_vector is not None else None + + if enforce_thresholded_vectors and not _is_binary_mod_window( + mod_window=mod_window, + val_window=val_window, + ): + if auto_threshold_if_raw is None: + raise ValueError( + "Loaded extract vectors appear unthresholded (ML/probability values), " + "but thresholded vectors are required. " + "Set ReadWindowExtractionConfig.auto_threshold_if_raw to a value " + "(for example 190) or disable enforcement explicitly." + ) + mod_window = _threshold_mod_window( + mod_window=mod_window, + val_window=val_window, + threshold=auto_threshold_if_raw, + ) + notify_auto_threshold(auto_threshold_if_raw) if orientation_aware: region_strand = ( @@ -727,9 +760,7 @@ def _extract_window_from_record( if "region_strand" in idx else None ) - read_strand = ( - _coerce_strand(record[idx["strand"]]) if "strand" in idx else None - ) + read_strand = _coerce_strand(record[idx["strand"]]) if "strand" in idx else None # If read/reference strands disagree, flip to align everything 5'->3' if _should_flip(region_strand, read_strand): mod_window = np.flip(mod_window) @@ -739,6 +770,51 @@ def _extract_window_from_record( return mod_window, val_window +def _resolve_raw_vector_threshold(threshold: float | int | None) -> float | None: + if threshold is None: + return None + try: + numeric = float(threshold) + except Exception as exc: + raise ValueError("auto_threshold_if_raw must be numeric or None.") from exc + if numeric <= 0: + raise ValueError("auto_threshold_if_raw must be > 0 when provided.") + return float(utils.adjust_threshold(numeric, quiet=True)) + + +def _is_binary_mod_window( + mod_window: np.ndarray, val_window: np.ndarray | None +) -> bool: + arr = np.asarray(mod_window) + if arr.size == 0: + return True + if arr.dtype == np.bool_: + return True + if val_window is not None: + valid = np.asarray(val_window).astype(bool) + if valid.shape == arr.shape: + arr = arr[valid] + if arr.size == 0: + return True + unique_vals = np.unique(arr) + return bool(np.all(np.isin(unique_vals, [0, 1]))) + + +def _threshold_mod_window( + *, + mod_window: np.ndarray, + val_window: np.ndarray | None, + threshold: float, +) -> np.ndarray: + arr = np.asarray(mod_window, dtype=float) + if val_window is None: + return (arr >= threshold).astype(float) + valid = np.asarray(val_window).astype(bool) + out = np.zeros(arr.shape, dtype=float) + out[valid] = (arr[valid] >= threshold).astype(float) + return out + + def build_multimotif_read_windows( hdf5_file: str | Path, motifs: Sequence[str], @@ -750,6 +826,9 @@ def build_multimotif_read_windows( subset_parameters: dict | None = None, span_full_window: bool = False, require_all_motifs: bool = True, + enforce_thresholded_vectors: bool = True, + auto_threshold_if_raw: float | int | None = 190, + warn_on_auto_threshold: bool = True, ) -> ReadWindowExtractionResult: """ Group per-motif rows by read and return a combined window per read, concatenating motifs. @@ -770,6 +849,10 @@ def build_multimotif_read_windows( subset_parameters: passed to loader for subsetting span_full_window: passed to loader (if True, only reads spanning the region are loaded) require_all_motifs: if True, drop reads that are missing any requested motif + enforce_thresholded_vectors: require thresholded/binary vectors for clustering-style workflows + auto_threshold_if_raw: threshold applied when raw probability vectors are detected + (default 190 interpreted in 0-255 space) + warn_on_auto_threshold: emit a warning when auto-thresholding is applied Returns: ReadWindowExtractionResult with data_matrix shape @@ -790,7 +873,9 @@ def build_multimotif_read_windows( idx = _build_dataset_index(dataset_names) # Group rows by read+region key - groups: defaultdict[tuple[Any, Any, Any, Any, Any], dict[str, tuple]] = defaultdict(dict) + groups: defaultdict[tuple[Any, Any, Any, Any, Any], dict[str, tuple]] = defaultdict( + dict + ) for rec in read_tuples: key = ( rec[idx.get("read_name")], @@ -818,21 +903,47 @@ def build_multimotif_read_windows( if requested_window_span is not None else _infer_window_span_from_records(read_tuples, idx) ) + resolved_threshold = _resolve_raw_vector_threshold(auto_threshold_if_raw) + auto_threshold_notified = False + + def _notify_auto_threshold(thresh_scaled: float) -> None: + nonlocal auto_threshold_notified + if auto_threshold_notified or not warn_on_auto_threshold: + return + auto_threshold_notified = True + threshold_255 = int(round(thresh_scaled * 255)) + warnings.warn( + "Detected unthresholded extract vectors; applying automatic thresholding " + f"at {thresh_scaled:.6f} (~{threshold_255}/255) for clustering/classification.", + RuntimeWarning, + stacklevel=2, + ) for key, motif_map in groups.items(): motif_windows = [] motif_val_windows = [] motifs_present = [] + representative_record: tuple | None = None for motif in motifs: if motif in motif_map: + if representative_record is None: + representative_record = motif_map[motif] extracted = _extract_window_from_record( - motif_map[motif], idx, effective_window_span, orientation_aware + motif_map[motif], + idx, + effective_window_span, + orientation_aware, + enforce_thresholded_vectors=enforce_thresholded_vectors, + auto_threshold_if_raw=resolved_threshold, + notify_auto_threshold=_notify_auto_threshold, ) if extracted is None: # If window cannot be extracted, treat as missing motif_windows.append(np.zeros(effective_window_span, dtype=float)) motif_val_windows.append( - np.zeros(effective_window_span, dtype=float) if has_val else None + np.zeros(effective_window_span, dtype=float) + if has_val + else None ) else: mw, vw = extracted @@ -854,7 +965,12 @@ def build_multimotif_read_windows( if has_val: combined_vals.append( np.concatenate( - [vw if vw is not None else np.zeros(effective_window_span, dtype=float) for vw in motif_val_windows], + [ + vw + if vw is not None + else np.zeros(effective_window_span, dtype=float) + for vw in motif_val_windows + ], axis=0, ) ) @@ -862,6 +978,21 @@ def build_multimotif_read_windows( { "read_name": key[0], "chromosome": key[1], + "read_start": ( + int(representative_record[idx["read_start"]]) + if representative_record is not None and "read_start" in idx + else None + ), + "read_end": ( + int(representative_record[idx["read_end"]]) + if representative_record is not None and "read_end" in idx + else None + ), + "read_length": ( + int(representative_record[idx["read_length"]]) + if representative_record is not None and "read_length" in idx + else None + ), "region_start": key[2], "region_end": key[3], "region_strand": key[4], @@ -870,7 +1001,9 @@ def build_multimotif_read_windows( ) if not combined_windows: - raise ValueError("No reads produced combined motif windows; check inputs and window_size.") + raise ValueError( + "No reads produced combined motif windows; check inputs and window_size." + ) data_matrix = np.vstack(combined_windows) val_matrix = np.vstack(combined_vals) if has_val and combined_vals else None @@ -904,13 +1037,14 @@ def extract_read_windows( hdf5_file: path to the extract .h5 file motifs: motifs to pull from the file regions: optional region specifier - config: controls windowing and orientation handling + config: controls windowing, orientation handling, and raw-vector threshold enforcement window_size: half-window override in bp (full span = 2 * window_size); when omitted, falls back to config.window_size. When omitted in both places, full span is inferred from the shortest selected region length. Returns: - ReadWindowExtractionResult containing raw mod/val matrices and metadata + ReadWindowExtractionResult containing thresholded/binary mod windows by default, + plus val matrices and metadata. """ cfg = config or ReadWindowExtractionConfig() @@ -923,6 +1057,21 @@ def extract_read_windows( else None ) effective_window_span = requested_window_span + resolved_threshold = _resolve_raw_vector_threshold(cfg.auto_threshold_if_raw) + auto_threshold_notified = False + + def _notify_auto_threshold(thresh_scaled: float) -> None: + nonlocal auto_threshold_notified + if auto_threshold_notified or not cfg.warn_on_auto_threshold: + return + auto_threshold_notified = True + threshold_255 = int(round(thresh_scaled * 255)) + warnings.warn( + "Detected unthresholded extract vectors; applying automatic thresholding " + f"at {thresh_scaled:.6f} (~{threshold_255}/255) for clustering/classification.", + RuntimeWarning, + stacklevel=2, + ) # Load all requested reads/vectors from extract output read_tuples, dataset_names, regions_dict = load_processed.read_vectors_from_hdf5( @@ -954,7 +1103,13 @@ def extract_read_windows( continue extracted = _extract_window_from_record( - rec, idx, effective_window_span, cfg.orientation_aware + rec, + idx, + effective_window_span, + cfg.orientation_aware, + enforce_thresholded_vectors=cfg.enforce_thresholded_vectors, + auto_threshold_if_raw=resolved_threshold, + notify_auto_threshold=_notify_auto_threshold, ) if extracted is None: continue @@ -968,6 +1123,9 @@ def extract_read_windows( meta_fields = [ "read_name", "chromosome", + "read_start", + "read_end", + "read_length", "region_start", "region_end", "region_strand", @@ -975,10 +1133,7 @@ def extract_read_windows( "motif", ] metadata.append( - { - field: rec[idx[field]] if field in idx else None - for field in meta_fields - } + {field: rec[idx[field]] if field in idx else None for field in meta_fields} ) if not matrices: @@ -1068,7 +1223,9 @@ def read_window_feature_matrix( cumsum = np.pad(cumsum, ((0, 0), (1, 0)), mode="constant", constant_values=0) for lag in autocorr_lags: - values = np.array([compute_autocorrelation_feature(row, lag) for row in data_matrix]) + values = np.array( + [compute_autocorrelation_feature(row, lag) for row in data_matrix] + ) columns.append(values[:, None]) names.append(f"autocorr_{lag}") @@ -1155,18 +1312,12 @@ def _safe_scores(X: np.ndarray, labels: np.ndarray) -> dict[str, float | None]: ) if not valid: return scores - try: + with contextlib.suppress(Exception): scores["silhouette"] = float(silhouette_score(X, labels)) - except Exception: # pragma: no cover - pass - try: + with contextlib.suppress(Exception): scores["calinski_harabasz"] = float(calinski_harabasz_score(X, labels)) - except Exception: # pragma: no cover - pass - try: + with contextlib.suppress(Exception): scores["davies_bouldin"] = float(davies_bouldin_score(X, labels)) - except Exception: # pragma: no cover - pass return scores @@ -1197,7 +1348,7 @@ def cluster_label_mapping( """ mapping: dict[int, int] = {} - for raw_label, ordered_label in zip(labels_raw, labels_size_ordered): + for raw_label, ordered_label in zip(labels_raw, labels_size_ordered, strict=False): raw = int(raw_label) ordered = int(ordered_label) if raw in mapping and mapping[raw] != ordered: @@ -1259,7 +1410,7 @@ def sample_rows( unique, counts = np.unique(labels_arr, return_counts=True) probs = counts / counts.sum() selected = [] - for lbl, p in zip(unique, probs): + for lbl, p in zip(unique, probs, strict=False): k = max(1, int(round(p * n))) choices = np.flatnonzero(labels_arr == lbl) k = min(k, len(choices)) @@ -1292,12 +1443,12 @@ def cluster_read_windows( """ from sklearn.cluster import ( + DBSCAN, + OPTICS, AgglomerativeClustering, Birch, - DBSCAN, KMeans, MiniBatchKMeans, - OPTICS, SpectralClustering, ) from sklearn.mixture import GaussianMixture @@ -1376,7 +1527,7 @@ def fit( raise ImportError("Install hdbscan to use method='hdbscan'.") model = _hdbscan_lib.HDBSCAN( min_cluster_size=kwargs.get("min_cluster_size", 30), - min_samples=kwargs.get("min_samples", None), + min_samples=kwargs.get("min_samples"), ) labels = model.fit_predict(X) noise_label = -1 @@ -1488,8 +1639,8 @@ def plot_cluster_profiles( import matplotlib.pyplot as plt from matplotlib import gridspec - from matplotlib.lines import Line2D from matplotlib.colors import Normalize + from matplotlib.lines import Line2D X_full = np.asarray(data_matrix) labs = np.asarray(labels) @@ -1504,7 +1655,7 @@ def plot_cluster_profiles( if val_matrix is not None: val_matrix = np.asarray(val_matrix)[mask] if metadata is not None: - metadata = [row for row, keep in zip(metadata, mask) if keep] + metadata = [row for row, keep in zip(metadata, mask, strict=False) if keep] V_full = np.asarray(val_matrix) if val_matrix is not None else None if V_full is not None and V_full.shape != X_full.shape: @@ -1524,8 +1675,12 @@ def plot_cluster_profiles( view_window_size=view_window_size, ) if motif_index < 0 or motif_index >= n_motifs: - raise ValueError(f"motif_index {motif_index} out of range for {n_motifs} motif slices.") - motif_ids = list(range(n_motifs)) if plot_all_motifs and n_motifs > 1 else [motif_index] + raise ValueError( + f"motif_index {motif_index} out of range for {n_motifs} motif slices." + ) + motif_ids = ( + list(range(n_motifs)) if plot_all_motifs and n_motifs > 1 else [motif_index] + ) if motif_labels is None: motif_labels = [f"motif_{i}" for i in range(n_motifs)] @@ -1554,8 +1709,14 @@ def plot_cluster_profiles( if window_size is not None else primary_matrix.shape[1] ) - view_span = _window_span_from_size(view_window_size) if view_window_size is not None else None - x_axis = _centered_x_axis(primary_matrix.shape[1], view_span or inferred_window_span) + view_span = ( + _window_span_from_size(view_window_size) + if view_window_size is not None + else None + ) + x_axis = _centered_x_axis( + primary_matrix.shape[1], view_span or inferred_window_span + ) mod_fraction = primary_matrix.mean(axis=1) labs_arr, lab_codes, unique_codes = _prepare_group_labels(labs) @@ -1565,7 +1726,9 @@ def plot_cluster_profiles( lab_codes = lab_codes[order] V_full = V_full[order] if V_full is not None else None - unique_labels = np.array([np.unique(labs_arr[lab_codes == code])[0] for code in unique_codes]) + unique_labels = np.array( + [np.unique(labs_arr[lab_codes == code])[0] for code in unique_codes] + ) cmap = plt.get_cmap(cmap_name) norm = Normalize(vmin=int(unique_codes.min()), vmax=int(unique_codes.max() or 1)) @@ -1648,8 +1811,12 @@ def plot_cluster_profiles( color=motif_colors[motif_id], linewidth=1.5, ) - motif_ax.set_ylabel(str(motif_labels[motif_id]), color=motif_colors[motif_id]) - motif_ax.tick_params(axis="y", colors=motif_colors[motif_id], labelsize=8) + motif_ax.set_ylabel( + str(motif_labels[motif_id]), color=motif_colors[motif_id] + ) + motif_ax.tick_params( + axis="y", colors=motif_colors[motif_id], labelsize=8 + ) if show_valid_profile and V_full is not None: mean_val_raw = V_full[row_mask, s:e].mean(axis=0) mean_val = _smooth_profile_vector( @@ -1685,14 +1852,18 @@ def plot_cluster_profiles( ax.plot( x_axis, mean_profile_raw, - color=motif_colors[motif_id] if len(motif_ids) > 1 else cmap(norm(code)), + color=motif_colors[motif_id] + if len(motif_ids) > 1 + else cmap(norm(code)), linewidth=1.0, alpha=0.25, ) ax.plot( x_axis, mean_profile, - color=motif_colors[motif_id] if len(motif_ids) > 1 else cmap(norm(code)), + color=motif_colors[motif_id] + if len(motif_ids) > 1 + else cmap(norm(code)), linewidth=1.5, ) if show_valid_profile and V_full is not None: @@ -1720,15 +1891,35 @@ def plot_cluster_profiles( if len(motif_ids) > 1 or color_points_by == "motif": legend_handles.extend( [ - Line2D([0], [0], color=motif_colors[m], linewidth=2, label=str(motif_labels[m])) + Line2D( + [0], + [0], + color=motif_colors[m], + linewidth=2, + label=str(motif_labels[m]), + ) for m in motif_ids ] ) if show_valid_profile and V_full is not None: legend_handles.extend( [ - Line2D([0], [0], color="black", linewidth=2, linestyle="-", label=signal_label), - Line2D([0], [0], color="black", linewidth=1, linestyle="--", label=valid_label), + Line2D( + [0], + [0], + color="black", + linewidth=2, + linestyle="-", + label=signal_label, + ), + Line2D( + [0], + [0], + color="black", + linewidth=1, + linestyle="--", + label=valid_label, + ), ] ) if legend_handles: @@ -1842,7 +2033,7 @@ def classify_read_features_binary( model = RandomForestClassifier( n_estimators=kwargs.get("n_estimators", 200), - max_depth=kwargs.get("max_depth", None), + max_depth=kwargs.get("max_depth"), random_state=random_state, n_jobs=kwargs.get("n_jobs", -1), class_weight=kwargs.get("class_weight", "balanced_subsample"), @@ -1863,7 +2054,7 @@ def classify_read_features_binary( model = KNeighborsClassifier( n_neighbors=kwargs.get("n_neighbors", 5), weights=kwargs.get("weights", "distance"), - n_jobs=kwargs.get("n_jobs", None), + n_jobs=kwargs.get("n_jobs"), ) else: raise ValueError(f"Unknown classifier '{classifier}'.") @@ -1917,7 +2108,10 @@ def classify_read_features_binary( "model": model, "metrics": metrics, "predictions": all_preds, - "label_mapping": {cls: int(code) for cls, code in zip(classes, le.transform(classes))}, + "label_mapping": { + cls: int(code) + for cls, code in zip(classes, le.transform(classes), strict=False) + }, } @@ -1930,7 +2124,7 @@ def plot_confusion_matrices(predictions: pd.DataFrame, *, cmap: str = "Blues"): from sklearn.metrics import confusion_matrix fig, axes = plt.subplots(1, 2, figsize=(8, 4)) - for ax, split in zip(axes, ["train", "test"]): + for ax, split in zip(axes, ["train", "test"], strict=False): df_split = predictions[predictions["split"] == split] labels_true = df_split["true_label"] labels_pred = df_split["pred_label"] @@ -2043,7 +2237,9 @@ def plot_classification_profiles( M_full = list(metadata) if metadata is not None else None if V_full is not None: - row_idx_max = int(row_idx.max()) if row_idx is not None and row_idx.size > 0 else -1 + row_idx_max = ( + int(row_idx.max()) if row_idx is not None and row_idx.size > 0 else -1 + ) if row_idx is not None and row_idx.size > 0 and row_idx_max < V_full.shape[0]: V = V_full[row_idx] elif V_full.shape[0] == len(preds): @@ -2057,7 +2253,9 @@ def plot_classification_profiles( V = None if M_full is not None: - row_idx_max = int(row_idx.max()) if row_idx is not None and row_idx.size > 0 else -1 + row_idx_max = ( + int(row_idx.max()) if row_idx is not None and row_idx.size > 0 else -1 + ) if row_idx is not None and row_idx.size > 0 and row_idx_max < len(M_full): M = [M_full[i] for i in row_idx] elif len(M_full) == len(preds): @@ -2071,7 +2269,9 @@ def plot_classification_profiles( M = None if group_by not in {"pred_label", "true_label", "confusion"}: - raise ValueError("group_by must be one of {'pred_label', 'true_label', 'confusion'}.") + raise ValueError( + "group_by must be one of {'pred_label', 'true_label', 'confusion'}." + ) if group_by == "confusion": class_values = sorted(pd.unique(preds["true_label"])) @@ -2153,7 +2353,9 @@ def plot_region_classification_profiles( ) if group_by not in {"pred_label", "true_label", "confusion"}: - raise ValueError("group_by must be one of {'pred_label', 'true_label', 'confusion'}.") + raise ValueError( + "group_by must be one of {'pred_label', 'true_label', 'confusion'}." + ) if group_by == "confusion": class_values = sorted(pd.unique(preds["true_label"])) @@ -2202,21 +2404,36 @@ def plot_multisite_read_raster( motif_count: int | None = None, plot_all_motifs: bool = False, motif_labels: Sequence[str] | None = None, + window_centers_bp: Sequence[int] | None = None, + window_widths_bp: int | Sequence[int] | None = None, + window_match_tolerance_bp: int | None = None, + symmetric_side_windows: int | None = None, + symmetric_max_offset_bp: int | None = None, + enforce_full_window_span: bool = True, + # Legacy aliases window_center_offsets: Sequence[int] | None = None, center_tolerance_bp: int | None = None, min_read_length_bp: int | None = None, smoothing: str | None = "gaussian", # None, "boxcar", "gaussian" smooth_win: int = 21, smooth_sigma_bp: float = 6.0, - max_rows: int = 500, - cmap: str = "viridis", + max_rows: int | None = 500, + downsample_method: str = "bin_mean", # "bin_mean" | "uniform" + cmap: str = "magma", vmin: float | None = None, vmax: float | None = None, render_mode: str = "scatter", # "scatter" | "heatmap" + render_values: str = "auto", # "auto" | "raw" | "smoothed" + axis_orientation: str | None = None, # "position_x" | "position_y" scatter_size: float = 4.0, scatter_alpha: float = 0.7, - x_axis_mode: str = "relative_to_primary", # "relative_to_primary" | "centered" - sort_by: str = "mod_fraction", # or "cluster" + scatter_color_values: str = "ml_score", # "auto" | "ml_score" | "raw" | "smoothed" + ml_score_thresholds: Sequence[float] | None = None, + motif_colors: Sequence[str] | None = None, + x_axis_mode: str | None = None, # "relative_to_primary" | "centered" + sort_by: str = "mod_fraction", # "mod_fraction" | "cluster" | "window_center" | "read_name" | "region_start" | "read_length" | "none" + sort_window_index: int | None = None, + sort_descending: bool | None = None, sort_labels: Sequence[int] | None = None, beds: Sequence[str | Path] | None = None, rotate: bool = True, @@ -2226,7 +2443,7 @@ def plot_multisite_read_raster( Args: read_windows: ReadWindowExtractionResult from extract_read_windows / build_multimotif_read_windows - n_windows: number of windows per read to plot when ``window_center_offsets`` is not provided + n_windows: number of windows per read to plot when explicit centers are not provided min_separation_bp: minimum separation between site centers (distance_mode="center") or read starts (bounds) distance_mode: "center" uses region_start/end center; "bounds" uses read_start/read_end window_size: half-window in bp; if provided, per-motif slice width is ``2 * window_size``. @@ -2234,43 +2451,104 @@ def plot_multisite_read_raster( motif_count: total motif slices concatenated in data_matrix; inferred when possible plot_all_motifs: when True, render all motif slices in a motif x window panel grid motif_labels: optional motif names aligned to motif slices - window_center_offsets: explicit desired window centers in primary-region coordinates + window_centers_bp: explicit desired window centers in primary-region coordinates (for example ``[-2500, 0, 2500]``). When provided, this replaces ``n_windows``. - center_tolerance_bp: matching tolerance for ``window_center_offsets``. Defaults to half window span. + window_widths_bp: per-window display widths in bp (common width when scalar). Defaults + to the extracted span for each panel. + window_match_tolerance_bp: matching tolerance for explicit centers. Defaults to half + the extracted span. + symmetric_side_windows: when set with ``symmetric_max_offset_bp``, generate centers as + evenly spaced offsets from ``-symmetric_max_offset_bp`` to ``+symmetric_max_offset_bp`` + with ``2 * symmetric_side_windows + 1`` windows total. + symmetric_max_offset_bp: max absolute offset used for symmetric center generation. + enforce_full_window_span: when True (default), drop read-sets that cannot span the + full displayed windows based on read_start/read_end (or read_length when available). + window_center_offsets: legacy alias for ``window_centers_bp``. + center_tolerance_bp: legacy alias for ``window_match_tolerance_bp``. min_read_length_bp: optional minimum read length filter. Must be at least the required span implied by requested centers/separation plus plotted window width. smoothing: None, "boxcar", or "gaussian" smooth_win: smoothing window length smooth_sigma_bp: sigma for gaussian smoothing - max_rows: cap rows; downsample by averaging if exceeded + max_rows: cap rows; when exceeded, downsample according to ``downsample_method``. + Pass None to disable downsampling. + downsample_method: "bin_mean" averages adjacent sorted read rows; "uniform" takes + evenly spaced sorted rows. cmap: matplotlib colormap vmin/vmax: color scale limits; None auto-scales render_mode: "scatter" or "heatmap" + render_values: value source used for plotting. + - "auto": scatter uses smoothed values when smoothing is enabled; heatmap uses raw per-read values + - "raw": always plot raw per-read values + - "smoothed": always plot smoothed values + axis_orientation: controls which axis encodes position. + - "position_x": x=position, y=reads + - "position_y": x=reads, y=position + When None, preserves legacy behavior for heatmaps based on ``rotate`` and uses ``position_x`` for scatter. scatter_size: marker size for scatter mode scatter_alpha: marker alpha for scatter mode - x_axis_mode: "relative_to_primary" offsets window axes by each read-pair - center distance from window 1; "centered" centers each window at 0 - sort_by: "mod_fraction" or "cluster" + scatter_color_values: scatter color source. + - "ml_score": normalized ML score from mod_vector values (clipped to 0..1) + - "raw": raw per-read values + - "smoothed": smoothed per-read values + - "auto": ml_score (default behavior) + ml_score_thresholds: optional per-motif ML score thresholds for scatter mode. When provided, + only points with ML score >= threshold are plotted in motif-specific colors. + motif_colors: optional colors aligned to motifs for thresholded scatter display + x_axis_mode: coordinate mode. ``relative_to_primary`` preserves primary-region offsets; + ``centered`` keeps each panel centered at zero for legacy compatibility. + sort_by: ordering strategy for paired reads + sort_window_index: optional window index used by window-aware sorting modes + sort_descending: descending/ascending order toggle for supported sort modes. + If None, defaults are mode-aware (descending for mod_fraction, ascending otherwise). sort_labels: cluster labels to sort by when sort_by="cluster" beds: optional list of BED/GTF/GFF paths; only reads intersecting all beds are retained - rotate: if True, rotate rasters for vertical stacking + rotate: subplot layout orientation (legacy compatibility); does not force data-axis orientation """ - import matplotlib.pyplot as plt import math + import matplotlib.pyplot as plt + if render_mode not in {"scatter", "heatmap"}: raise ValueError("render_mode must be 'scatter' or 'heatmap'.") - if x_axis_mode not in {"relative_to_primary", "centered"}: - raise ValueError("x_axis_mode must be 'relative_to_primary' or 'centered'.") + if render_values not in {"auto", "raw", "smoothed"}: + raise ValueError("render_values must be 'auto', 'raw', or 'smoothed'.") + if axis_orientation is not None and axis_orientation not in { + "position_x", + "position_y", + }: + raise ValueError( + "axis_orientation must be None, 'position_x', or 'position_y'." + ) + if scatter_color_values not in {"auto", "ml_score", "raw", "smoothed"}: + raise ValueError( + "scatter_color_values must be 'auto', 'ml_score', 'raw', or 'smoothed'." + ) + if x_axis_mode is not None and x_axis_mode not in { + "relative_to_primary", + "centered", + }: + raise ValueError( + "x_axis_mode must be None, 'relative_to_primary', or 'centered'." + ) + effective_x_axis_mode = x_axis_mode or "relative_to_primary" if distance_mode not in {"center", "bounds"}: raise ValueError("distance_mode must be 'center' or 'bounds'.") if n_windows < 1: raise ValueError("n_windows must be >= 1.") if min_separation_bp < 0: raise ValueError("min_separation_bp must be >= 0.") + if downsample_method not in {"bin_mean", "uniform"}: + raise ValueError("downsample_method must be 'bin_mean' or 'uniform'.") if center_tolerance_bp is not None and center_tolerance_bp < 0: raise ValueError("center_tolerance_bp must be >= 0 when provided.") + if window_match_tolerance_bp is not None and window_match_tolerance_bp < 0: + raise ValueError("window_match_tolerance_bp must be >= 0 when provided.") + if max_rows is not None and max_rows <= 0: + raise ValueError("max_rows must be > 0 when provided.") + if sort_window_index is not None and sort_window_index < 0: + raise ValueError("sort_window_index must be >= 0 when provided.") def _kernel(kind: str, win: int, sigma: float): if win % 2 == 0: @@ -2287,7 +2565,11 @@ def _kernel(kind: str, win: int, sigma: float): def _smooth(M: np.ndarray) -> np.ndarray: if smoothing is None: return M - k = _kernel("gaussian" if smoothing == "gaussian" else "boxcar", smooth_win, smooth_sigma_bp) + k = _kernel( + "gaussian" if smoothing == "gaussian" else "boxcar", + smooth_win, + smooth_sigma_bp, + ) r = len(k) // 2 out = np.empty_like(M, dtype=float) for i in range(M.shape[0]): @@ -2323,15 +2605,21 @@ def _smooth(M: np.ndarray) -> np.ndarray: if n_motifs <= 0: n_motifs = 1 if slice_width <= 0: - raise ValueError("Unable to infer motif slice width from read_windows.data_matrix.") + raise ValueError( + "Unable to infer motif slice width from read_windows.data_matrix." + ) if width % slice_width != 0: raise ValueError( "read_windows.data_matrix width is not divisible into consistent motif slices. " "Pass an explicit motif_count or compatible window_size." ) if motif_index < 0 or motif_index >= n_motifs: - raise ValueError(f"motif_index {motif_index} out of range for {n_motifs} motif slices.") - motif_ids = list(range(n_motifs)) if plot_all_motifs and n_motifs > 1 else [motif_index] + raise ValueError( + f"motif_index {motif_index} out of range for {n_motifs} motif slices." + ) + motif_ids = ( + list(range(n_motifs)) if plot_all_motifs and n_motifs > 1 else [motif_index] + ) if motif_labels is None: motif_labels_resolved = [f"motif_{i}" for i in range(n_motifs)] else: @@ -2341,24 +2629,85 @@ def _smooth(M: np.ndarray) -> np.ndarray: [f"motif_{i}" for i in range(len(motif_labels_resolved), n_motifs)] ) X_by_motif = [X_full[:, m * slice_width : (m + 1) * slice_width] for m in motif_ids] + ML_by_motif = [np.clip(matrix.astype(float), 0.0, 1.0) for matrix in X_by_motif] + + if ( + window_center_offsets is not None + and window_centers_bp is not None + and list(window_center_offsets) != list(window_centers_bp) + ): + raise ValueError( + "Pass either window_centers_bp or window_center_offsets (legacy alias), not both with different values." + ) + resolved_centers = ( + window_centers_bp if window_centers_bp is not None else window_center_offsets + ) + if ( + center_tolerance_bp is not None + and window_match_tolerance_bp is not None + and int(center_tolerance_bp) != int(window_match_tolerance_bp) + ): + raise ValueError( + "Pass either window_match_tolerance_bp or center_tolerance_bp (legacy alias), not both with different values." + ) + match_tolerance_bp = ( + int(window_match_tolerance_bp) + if window_match_tolerance_bp is not None + else (int(center_tolerance_bp) if center_tolerance_bp is not None else None) + ) + + if symmetric_side_windows is not None or symmetric_max_offset_bp is not None: + if resolved_centers is not None: + raise ValueError( + "Do not combine symmetric center spec with explicit window_centers_bp." + ) + if symmetric_side_windows is None or symmetric_max_offset_bp is None: + raise ValueError( + "symmetric_side_windows and symmetric_max_offset_bp must be provided together." + ) + if int(symmetric_side_windows) < 0: + raise ValueError("symmetric_side_windows must be >= 0.") + if int(symmetric_max_offset_bp) < 0: + raise ValueError("symmetric_max_offset_bp must be >= 0.") + n_side = int(symmetric_side_windows) + max_offset = float(symmetric_max_offset_bp) + if n_side == 0: + resolved_centers = [0] + else: + resolved_centers = ( + np.linspace(-max_offset, max_offset, (2 * n_side) + 1) + .round() + .astype(int) + .tolist() + ) - if window_center_offsets is None: + if resolved_centers is None: n_windows_effective = int(n_windows) target_offsets = None else: - offsets = [int(offset) for offset in window_center_offsets] + offsets = [int(offset) for offset in resolved_centers] if len(offsets) == 0: - raise ValueError("window_center_offsets must contain at least one center when provided.") + raise ValueError( + "window_centers_bp must contain at least one center when provided." + ) n_windows_effective = len(offsets) target_offsets = np.asarray(offsets, dtype=float) if target_offsets is None: - required_read_length_bp = int(max(slice_width, ((n_windows_effective - 1) * min_separation_bp) + slice_width)) + required_read_length_bp = int( + max( + slice_width, + ((n_windows_effective - 1) * min_separation_bp) + slice_width, + ) + ) else: required_read_length_bp = int( max( slice_width, - np.ceil(float(target_offsets.max() - target_offsets.min()) + float(slice_width)), + np.ceil( + float(target_offsets.max() - target_offsets.min()) + + float(slice_width) + ), ) ) @@ -2368,12 +2717,36 @@ def _smooth(M: np.ndarray) -> np.ndarray: f"({required_read_length_bp} bp)." ) effective_min_read_length = ( - required_read_length_bp if target_offsets is not None and min_read_length_bp is None else min_read_length_bp + required_read_length_bp + if target_offsets is not None and min_read_length_bp is None + else min_read_length_bp ) + if window_widths_bp is None: + default_width_bp = int( + slice_width if window_size is None else max(1, 2 * int(window_size)) + ) + panel_widths_bp = [default_width_bp for _ in range(n_windows_effective)] + elif isinstance(window_widths_bp, (int, np.integer)): + panel_widths_bp = [int(window_widths_bp) for _ in range(n_windows_effective)] + else: + panel_widths_bp = [int(width) for width in window_widths_bp] + if len(panel_widths_bp) != n_windows_effective: + raise ValueError( + "window_widths_bp must be a scalar or a sequence with one entry per window center." + ) + if any(width <= 0 for width in panel_widths_bp): + raise ValueError("window_widths_bp values must be > 0.") + if any(width > slice_width for width in panel_widths_bp): + raise ValueError( + "window_widths_bp values cannot exceed extracted window span; increase extract/parse window_size." + ) + panel_half_widths = [0.5 * float(width) for width in panel_widths_bp] + def _apply_index_filter(index_vector: np.ndarray) -> None: - nonlocal X_by_motif, meta, filtered_original_indices + nonlocal X_by_motif, ML_by_motif, meta, filtered_original_indices X_by_motif = [matrix[index_vector] for matrix in X_by_motif] + ML_by_motif = [matrix[index_vector] for matrix in ML_by_motif] meta = [meta[i] for i in index_vector] filtered_original_indices = filtered_original_indices[index_vector] @@ -2413,7 +2786,9 @@ def _apply_index_filter(index_vector: np.ndarray) -> None: if joined.df.empty: candidate_indices = np.array([], dtype=int) break - candidate_indices = joined.df["read_idx"].drop_duplicates().to_numpy(dtype=int) + candidate_indices = ( + joined.df["read_idx"].drop_duplicates().to_numpy(dtype=int) + ) keep_idx = np.sort(candidate_indices) else: @@ -2430,18 +2805,105 @@ def _apply_index_filter(index_vector: np.ndarray) -> None: parsed_length = int(read_length_val) except Exception: parsed_length = None - if (parsed_length is None or parsed_length <= 0) and {"read_start", "read_end"}.issubset(m.keys()): + if (parsed_length is None or parsed_length <= 0) and { + "read_start", + "read_end", + }.issubset(m.keys()): try: parsed_length = int(m["read_end"]) - int(m["read_start"]) except Exception: parsed_length = None - if parsed_length is not None and parsed_length >= int(effective_min_read_length): + if parsed_length is not None and parsed_length >= int( + effective_min_read_length + ): keep_by_length.append(idx) _apply_index_filter(np.asarray(keep_by_length, dtype=int)) + span_check_warning_emitted = False + dropped_for_window_span = 0 + + def _safe_int(value: Any) -> int | None: + try: + if value is None: + return None + return int(value) + except Exception: + return None + + def _read_bounds(meta_row: dict[str, Any]) -> tuple[int, int] | None: + start = _safe_int(meta_row.get("read_start")) + end = _safe_int(meta_row.get("read_end")) + length = _safe_int(meta_row.get("read_length")) + if start is not None and end is not None and end > start: + return (start, end) + if start is not None and length is not None and length > 0: + return (start, start + length) + if end is not None and length is not None and length > 0: + return (end - length, end) + return None + + def _read_length(meta_row: dict[str, Any]) -> int | None: + length = _safe_int(meta_row.get("read_length")) + if length is not None and length > 0: + return length + bounds = _read_bounds(meta_row) + if bounds is None: + return None + return bounds[1] - bounds[0] + + def _window_is_covered( + meta_row: dict[str, Any], center_bp: float, half_width_bp: float + ) -> bool | None: + bounds = _read_bounds(meta_row) + if bounds is None: + return None + left = float(center_bp) - float(half_width_bp) + right = float(center_bp) + float(half_width_bp) + return left >= float(bounds[0]) and right <= float(bounds[1]) + + def _selection_spans_all_windows( + selected: Sequence[tuple[int, float, int]], + ) -> bool: + nonlocal span_check_warning_emitted + if not enforce_full_window_span: + return True + + unresolved_present = False + left_edges: list[float] = [] + right_edges: list[float] = [] + candidate_lengths: list[int] = [] + for row_idx, center_bp, window_pos in selected: + half_width_bp = float(panel_half_widths[window_pos]) + covered = _window_is_covered(meta[row_idx], center_bp, half_width_bp) + if covered is False: + return False + if covered is None: + unresolved_present = True + left_edges.append(float(center_bp) - half_width_bp) + right_edges.append(float(center_bp) + half_width_bp) + length_value = _read_length(meta[row_idx]) + if length_value is not None: + candidate_lengths.append(int(length_value)) + + if unresolved_present: + if candidate_lengths: + required_span = max(right_edges) - min(left_edges) + if max(candidate_lengths) < required_span: + return False + elif not span_check_warning_emitted: + warnings.warn( + "Unable to fully verify window-span coverage for some reads because " + "read_start/read_end/read_length metadata are missing. " + "Re-extract windows with current APIs for strict filtering.", + RuntimeWarning, + stacklevel=2, + ) + span_check_warning_emitted = True + return True + # Group by read key groups = defaultdict(list) - for i, m in zip(range(len(meta)), meta): + for i, m in zip(range(len(meta)), meta, strict=False): key = ( m.get("read_name"), m.get("chromosome"), @@ -2472,12 +2934,23 @@ def _apply_index_filter(index_vector: np.ndarray) -> None: ): continue idxs = [items[j + k][0] for k in range(n_windows_effective)] + candidate = [ + (int(idxs[k]), float(centers[k]), int(k)) + for k in range(n_windows_effective) + ] + if not _selection_spans_all_windows(candidate): + dropped_for_window_span += 1 + continue for k, idx in enumerate(idxs): pair_indices_per_window[k].append(int(idx)) panel_centers[k].append(float(centers[k])) continue - tolerance = float(center_tolerance_bp if center_tolerance_bp is not None else max(1, slice_width // 2)) + tolerance = float( + match_tolerance_bp + if match_tolerance_bp is not None + else max(1, slice_width // 2) + ) best_candidate: tuple[float, list[int]] | None = None for anchor_pos in range(len(items)): anchor_center = centers_arr[anchor_pos] @@ -2494,6 +2967,13 @@ def _apply_index_filter(index_vector: np.ndarray) -> None: if pos in used_positions: continue if float(distances[pos]) <= tolerance: + candidate_idx = int(idx_arr[pos]) + window_half = float(panel_half_widths[len(selected_positions)]) + covered = _window_is_covered( + meta[candidate_idx], float(centers_arr[pos]), window_half + ) + if covered is False: + continue chosen = pos break if chosen is None: @@ -2511,34 +2991,92 @@ def _apply_index_filter(index_vector: np.ndarray) -> None: if best_candidate is None: continue _, selected_positions = best_candidate + candidate = [ + (int(idx_arr[pos]), float(centers_arr[pos]), int(k)) + for k, pos in enumerate(selected_positions) + ] + if not _selection_spans_all_windows(candidate): + dropped_for_window_span += 1 + continue for k, pos in enumerate(selected_positions): pair_indices_per_window[k].append(int(idx_arr[pos])) panel_centers[k].append(float(centers_arr[pos])) if not all(len(p) > 0 for p in pair_indices_per_window): + if enforce_full_window_span and dropped_for_window_span > 0: + raise ValueError( + "No read sets found after enforcing full-window span coverage; " + "increase read length, reduce window widths/offsets, or relax constraints." + ) raise ValueError("No read sets found meeting separation criteria.") - window_indices = [np.asarray(values, dtype=int) for values in pair_indices_per_window] - panel_centers = [np.asarray(center_values, dtype=float) for center_values in panel_centers] + window_indices = [ + np.asarray(values, dtype=int) for values in pair_indices_per_window + ] + panel_centers = [ + np.asarray(center_values, dtype=float) for center_values in panel_centers + ] panels_by_motif = [] panels_smooth_by_motif = [] + panels_ml_by_motif = [] for motif_matrix in X_by_motif: motif_panels = [motif_matrix[idx] for idx in window_indices] panels_by_motif.append(motif_panels) panels_smooth_by_motif.append([_smooth(panel) for panel in motif_panels]) + for motif_ml_matrix in ML_by_motif: + panels_ml_by_motif.append([motif_ml_matrix[idx] for idx in window_indices]) + + if render_values == "raw": + panels_render_by_motif = panels_by_motif + render_value_mode = "raw" + elif render_values == "smoothed": + panels_render_by_motif = panels_smooth_by_motif + render_value_mode = "smoothed" + else: + if render_mode == "heatmap" or smoothing is None: + panels_render_by_motif = panels_by_motif + render_value_mode = "raw" + else: + panels_render_by_motif = panels_smooth_by_motif + render_value_mode = "smoothed" # Sorting uses the reference motif to keep all motif panels aligned. try: ref_motif_pos = motif_ids.index(motif_index) except ValueError: ref_motif_pos = 0 - reference_panels = panels_smooth_by_motif[ref_motif_pos] + reference_panels = panels_render_by_motif[ref_motif_pos] + + if sort_window_index is None: + sort_window_pos = 0 + else: + sort_window_pos = int(sort_window_index) + if sort_window_pos >= n_windows_effective: + raise ValueError( + f"sort_window_index {sort_window_index} out of range for {n_windows_effective} windows." + ) + + if sort_descending is None: + effective_sort_descending = sort_by == "mod_fraction" + else: + effective_sort_descending = bool(sort_descending) # Sorting if sort_by == "mod_fraction": - means = [p.mean(axis=1) for p in reference_panels] - order = np.lexsort(tuple(-m for m in reversed(means))) - elif sort_by == "cluster" and sort_labels is not None: + if sort_window_index is not None: + score = reference_panels[sort_window_pos].mean(axis=1) + order = np.argsort(score, kind="stable") + if effective_sort_descending: + order = order[::-1] + else: + means = [panel.mean(axis=1) for panel in reference_panels] + if effective_sort_descending: + order = np.lexsort(tuple(-m for m in reversed(means))) + else: + order = np.lexsort(tuple(m for m in reversed(means))) + elif sort_by == "cluster": + if sort_labels is None: + raise ValueError("sort_labels must be provided when sort_by='cluster'.") labels_array = np.asarray(sort_labels) if labels_array.shape[0] == len(read_windows.metadata): labels_filtered = labels_array[filtered_original_indices] @@ -2550,17 +3088,102 @@ def _apply_index_filter(index_vector: np.ndarray) -> None: "or the filtered metadata length." ) pair_labels = labels_filtered[window_indices[0]] - order = np.argsort(pair_labels) + order = np.argsort(pair_labels, kind="stable") + if effective_sort_descending: + order = order[::-1] + elif sort_by == "window_center": + center_values = panel_centers[sort_window_pos] + order = np.argsort(center_values, kind="stable") + if effective_sort_descending: + order = order[::-1] + elif sort_by == "read_name": + values = np.asarray( + [str(meta[idx].get("read_name", "")) for idx in window_indices[0]] + ) + order = np.argsort(values, kind="stable") + if effective_sort_descending: + order = order[::-1] + elif sort_by == "region_start": + values = np.asarray( + [int(meta[idx].get("region_start", 0) or 0) for idx in window_indices[0]], + dtype=float, + ) + order = np.argsort(values, kind="stable") + if effective_sort_descending: + order = order[::-1] + elif sort_by == "read_length": + + def _resolved_read_length(read_meta: dict) -> int: + length_value = read_meta.get("read_length") + if length_value is not None: + try: + return int(length_value) + except Exception: + pass + try: + return int(read_meta.get("read_end", 0)) - int( + read_meta.get("read_start", 0) + ) + except Exception: + return 0 + + values = np.asarray( + [_resolved_read_length(meta[idx]) for idx in window_indices[0]], dtype=float + ) + order = np.argsort(values, kind="stable") + if effective_sort_descending: + order = order[::-1] + elif sort_by == "none": + order = np.arange(reference_panels[0].shape[0], dtype=int) else: - order = np.arange(reference_panels[0].shape[0]) + raise ValueError( + "sort_by must be one of 'mod_fraction', 'cluster', 'window_center', " + "'read_name', 'region_start', 'read_length', or 'none'." + ) panels_sorted_by_motif = [ + [panel[order] for panel in motif_panels] + for motif_panels in panels_render_by_motif + ] + panels_raw_sorted_by_motif = [ + [panel[order] for panel in motif_panels] for motif_panels in panels_by_motif + ] + panels_smooth_sorted_by_motif = [ [panel[order] for panel in motif_panels] for motif_panels in panels_smooth_by_motif ] - centers_sorted = [c[order] for c in panel_centers] + panels_ml_sorted_by_motif: list[list[np.ndarray]] = [ + [panel[order] for panel in motif_panels] for motif_panels in panels_ml_by_motif + ] + expected_rows = panels_raw_sorted_by_motif[0][0].shape[0] + for motif_panels in panels_raw_sorted_by_motif: + for panel in motif_panels: + if panel.shape[0] != expected_rows: + raise RuntimeError( + "Inconsistent read ordering across multisite panels; panel row counts diverged." + ) + centers_sorted = [center_values[order] for center_values in panel_centers] primary_centers = centers_sorted[0] - center_offsets = [c - primary_centers for c in centers_sorted] + if effective_x_axis_mode == "centered": + center_offsets = [ + np.zeros_like(center_values, dtype=float) + for center_values in centers_sorted + ] + else: + center_offsets = [ + center_values - primary_centers for center_values in centers_sorted + ] + if render_mode == "heatmap" and effective_x_axis_mode == "relative_to_primary": + for offsets in center_offsets: + if offsets.size > 1 and not np.allclose( + offsets, offsets[0], equal_nan=True + ): + raise ValueError( + "Heatmap rendering with x_axis_mode='relative_to_primary' requires constant " + "per-read offsets within each panel because imshow uses one rectangular extent. " + "Use render_mode='scatter', x_axis_mode='centered', or fixed/explicit centers " + "producing constant offsets." + ) # Downsample rows if too tall def bin_rows(M, k): @@ -2580,31 +3203,158 @@ def bin_vector(vector: np.ndarray, k: int) -> np.ndarray: return out P = panels_sorted_by_motif[0][0].shape[0] + rows_before_downsample = int(P) downsampled = False - if P > max_rows: + downsample_factor = 1 + if max_rows is not None and max_rows < P: step = math.ceil(P / max_rows) - panels_sorted_by_motif = [ - [bin_rows(panel, step) for panel in motif_panels] - for motif_panels in panels_sorted_by_motif - ] - center_offsets = [bin_vector(v, step) for v in center_offsets] + downsample_factor = step + if downsample_method == "bin_mean": + panels_sorted_by_motif = [ + [bin_rows(panel, step) for panel in motif_panels] + for motif_panels in panels_sorted_by_motif + ] + panels_raw_sorted_by_motif = [ + [bin_rows(panel, step) for panel in motif_panels] + for motif_panels in panels_raw_sorted_by_motif + ] + panels_smooth_sorted_by_motif = [ + [bin_rows(panel, step) for panel in motif_panels] + for motif_panels in panels_smooth_sorted_by_motif + ] + panels_ml_sorted_by_motif = [ + [bin_rows(panel, step) for panel in motif_panels] + for motif_panels in panels_ml_sorted_by_motif + ] + center_offsets = [bin_vector(v, step) for v in center_offsets] + else: + keep = np.unique(np.round(np.linspace(0, P - 1, max_rows)).astype(int)) + panels_sorted_by_motif = [ + [panel[keep] for panel in motif_panels] + for motif_panels in panels_sorted_by_motif + ] + panels_raw_sorted_by_motif = [ + [panel[keep] for panel in motif_panels] + for motif_panels in panels_raw_sorted_by_motif + ] + panels_smooth_sorted_by_motif = [ + [panel[keep] for panel in motif_panels] + for motif_panels in panels_smooth_sorted_by_motif + ] + panels_ml_sorted_by_motif = [ + [panel[keep] for panel in motif_panels] + for motif_panels in panels_ml_sorted_by_motif + ] + center_offsets = [vector[keep] for vector in center_offsets] P = panels_sorted_by_motif[0][0].shape[0] downsampled = True + if scatter_color_values == "auto": + effective_scatter_color_values = "ml_score" + else: + effective_scatter_color_values = scatter_color_values + + threshold_map: dict[int, float] | None = None + if render_mode == "scatter" and ml_score_thresholds is not None: + thresholds_list = [float(value) for value in ml_score_thresholds] + if len(thresholds_list) == len(motif_ids): + threshold_map = { + motif_id: float(thresholds_list[idx]) + for idx, motif_id in enumerate(motif_ids) + } + elif len(thresholds_list) == n_motifs: + threshold_map = { + idx: float(value) for idx, value in enumerate(thresholds_list) + } + elif len(thresholds_list) == 1: + threshold_map = { + motif_id: float(thresholds_list[0]) for motif_id in motif_ids + } + else: + raise ValueError( + "ml_score_thresholds must have length 1, motif_count, or motifs_plotted length." + ) + + motif_color_map: dict[int, str] = {} + if threshold_map is not None: + if motif_colors is not None: + colors_list = [str(value) for value in motif_colors] + if len(colors_list) == len(motif_ids): + motif_color_map = { + motif_id: colors_list[idx] for idx, motif_id in enumerate(motif_ids) + } + elif len(colors_list) == n_motifs: + motif_color_map = { + motif_id: colors_list[motif_id] for motif_id in motif_ids + } + elif len(colors_list) == 1: + motif_color_map = {motif_id: colors_list[0] for motif_id in motif_ids} + else: + raise ValueError( + "motif_colors must have length 1, motif_count, or motifs_plotted length." + ) + else: + tab10 = plt.get_cmap("tab10") + motif_color_map = { + motif_id: tab10(idx % 10) for idx, motif_id in enumerate(motif_ids) + } + + def _default_ml_cmap_name(motif_label: str, motif_pos: int) -> str: + normalized = motif_label.strip().upper() + if normalized == "A,0": + return "Blues" + if normalized == "CG,0": + return "Oranges" + sequential_cycle = ( + "Greens", + "Purples", + "Reds", + "Greys", + "YlGnBu", + "BuPu", + "PuRd", + "YlOrBr", + "BuGn", + ) + return sequential_cycle[motif_pos % len(sequential_cycle)] + + ml_cmap_names = { + motif_id: _default_ml_cmap_name(str(motif_labels_resolved[motif_id]), motif_pos) + for motif_pos, motif_id in enumerate(motif_ids) + } + if vmin is None or vmax is None: - vmax_auto = max(panel.max() for motif_panels in panels_sorted_by_motif for panel in motif_panels) - vmin = 0.0 if vmin is None else vmin - vmax = vmax_auto if vmax is None else vmax + if ( + render_mode == "scatter" + and threshold_map is not None + or render_mode == "scatter" + and effective_scatter_color_values == "ml_score" + ): + vmin = 0.0 if vmin is None else vmin + vmax = 1.0 if vmax is None else vmax + else: + vmax_auto = max( + panel.max() + for motif_panels in panels_sorted_by_motif + for panel in motif_panels + ) + vmin = 0.0 if vmin is None else vmin + vmax = vmax_auto if vmax is None else vmax x_positions = np.arange(slice_width, dtype=float) - (slice_width // 2) + if axis_orientation is None: + if render_mode == "heatmap": + effective_axis_orientation = "position_y" if rotate else "position_x" + else: + effective_axis_orientation = "position_x" + else: + effective_axis_orientation = axis_orientation + share_x_axes = True - if ( - rotate - and render_mode == "scatter" - and x_axis_mode == "relative_to_primary" - and n_windows_effective > 1 - ): + if effective_axis_orientation == "position_x" and n_windows_effective > 1: + # When each window has a different positional frame (relative-to-primary), + # sharing x limits forces misleading axis alignment across panels. share_x_axes = False n_plot_motifs = len(motif_ids) @@ -2653,68 +3403,169 @@ def _axis_for(motif_pos: int, window_pos: int): return axes[motif_pos, window_pos] first_mappable = None + threshold_legend_entries: dict[str, tuple[str, float]] = {} for motif_pos, motif_id in enumerate(motif_ids): motif_panels = panels_sorted_by_motif[motif_pos] + motif_raw_panels = panels_raw_sorted_by_motif[motif_pos] + motif_smooth_panels = panels_smooth_sorted_by_motif[motif_pos] + motif_ml_panels = panels_ml_sorted_by_motif[motif_pos] motif_label = str(motif_labels_resolved[motif_id]) for window_pos in range(n_windows_effective): ax = _axis_for(motif_pos, window_pos) panel = motif_panels[window_pos] - row_offsets = ( - center_offsets[window_pos] - if x_axis_mode == "relative_to_primary" - else np.zeros(panel.shape[0], dtype=float) - ) + panel_raw = motif_raw_panels[window_pos] + panel_smooth = motif_smooth_panels[window_pos] + panel_ml = motif_ml_panels[window_pos] + row_offsets = center_offsets[window_pos] axis_center = float(np.nanmedian(row_offsets)) if row_offsets.size else 0.0 + window_half_width = panel_half_widths[window_pos] + window_lo = axis_center - window_half_width + window_hi = axis_center + window_half_width if render_mode == "scatter": - rows, cols = np.nonzero(panel > 0) - values = panel[rows, cols] + rows, cols = np.nonzero(panel_raw > 0) + if ( + effective_scatter_color_values == "ml_score" + and panel_ml is not None + ): + color_panel = panel_ml + elif effective_scatter_color_values == "smoothed": + color_panel = panel_smooth + else: + color_panel = panel_raw + values = color_panel[rows, cols] + if threshold_map is not None: + threshold_value = float(threshold_map[motif_id]) + keep = panel_ml[rows, cols] >= threshold_value + rows = rows[keep] + cols = cols[keep] + values = panel_ml[rows, cols] + threshold_legend_entries[motif_label] = ( + str(motif_color_map[motif_id]), + threshold_value, + ) if rows.size > 0: x_scatter = x_positions[cols] + row_offsets[rows] - first_mappable = ax.scatter( - x_scatter, - rows, - c=values, - s=scatter_size, - alpha=scatter_alpha, - cmap=cmap, - vmin=vmin, - vmax=vmax, - linewidths=0, - rasterized=True, - ) - x_min = float(np.nanmin(x_scatter)) - x_max = float(np.nanmax(x_scatter)) + in_window = (x_scatter >= window_lo) & (x_scatter <= window_hi) + rows = rows[in_window] + cols = cols[in_window] + values = values[in_window] + x_scatter = x_scatter[in_window] + if rows.size > 0: + if effective_axis_orientation == "position_x": + if threshold_map is None: + scatter_cmap = ( + ml_cmap_names[motif_id] + if effective_scatter_color_values == "ml_score" + else cmap + ) + first_mappable = ax.scatter( + x_scatter, + rows, + c=values, + s=scatter_size, + alpha=scatter_alpha, + cmap=scatter_cmap, + vmin=vmin, + vmax=vmax, + linewidths=0, + rasterized=True, + ) + else: + ax.scatter( + x_scatter, + rows, + c=motif_color_map[motif_id], + s=scatter_size, + alpha=scatter_alpha, + linewidths=0, + rasterized=True, + ) + x_min = float(np.nanmin(x_scatter)) + x_max = float(np.nanmax(x_scatter)) + else: + if threshold_map is None: + scatter_cmap = ( + ml_cmap_names[motif_id] + if effective_scatter_color_values == "ml_score" + else cmap + ) + first_mappable = ax.scatter( + rows, + x_scatter, + c=values, + s=scatter_size, + alpha=scatter_alpha, + cmap=scatter_cmap, + vmin=vmin, + vmax=vmax, + linewidths=0, + rasterized=True, + ) + else: + ax.scatter( + rows, + x_scatter, + c=motif_color_map[motif_id], + s=scatter_size, + alpha=scatter_alpha, + linewidths=0, + rasterized=True, + ) + y_min = float(np.nanmin(x_scatter)) + y_max = float(np.nanmax(x_scatter)) else: - x_min = float(x_positions[0] + axis_center) - x_max = float(x_positions[-1] + axis_center) - x_pad = max(1.0, 0.02 * (x_max - x_min + 1.0)) - ax.axvline(axis_center, linestyle="--", linewidth=1, color="0.7") - ax.set_ylim(-1, panel.shape[0] + 1) - ax.set_xlim(x_min - x_pad, x_max + x_pad) + if effective_axis_orientation == "position_x": + x_min = float(window_lo) + x_max = float(window_hi) + else: + y_min = float(window_lo) + y_max = float(window_hi) + if effective_axis_orientation == "position_x": + x_min = min(x_min, float(window_lo)) + x_max = max(x_max, float(window_hi)) + x_pad = max(1.0, 0.02 * (window_hi - window_lo + 1.0)) + ax.axvline(axis_center, linestyle="--", linewidth=1, color="0.7") + ax.set_ylim(-1, panel.shape[0] + 1) + ax.set_xlim(window_lo - x_pad, window_hi + x_pad) + else: + y_min = min(y_min, float(window_lo)) + y_max = max(y_max, float(window_hi)) + y_pad = max(1.0, 0.02 * (window_hi - window_lo + 1.0)) + ax.axhline(axis_center, linestyle="--", linewidth=1, color="0.7") + ax.set_xlim(-1, panel.shape[0] + 1) + ax.set_ylim(window_lo - y_pad, window_hi + y_pad) else: - if rotate: + x_lo = float(x_positions[0] + axis_center) + x_hi = float(x_positions[-1] + axis_center) + if effective_axis_orientation == "position_y": first_mappable = ax.imshow( panel.T, aspect="auto", origin="lower", + extent=[-0.5, panel.shape[0] - 0.5, x_lo, x_hi], vmin=vmin, vmax=vmax, cmap=cmap, ) - ax.axhline(slice_width // 2, linestyle="--", linewidth=1, color="0.7") + ax.axhline(axis_center, linestyle="--", linewidth=1, color="0.7") + y_pad = max(1.0, 0.02 * (window_hi - window_lo + 1.0)) + ax.set_ylim(window_lo - y_pad, window_hi + y_pad) else: first_mappable = ax.imshow( panel, aspect="auto", origin="upper", + extent=[x_lo, x_hi, panel.shape[0] - 0.5, -0.5], vmin=vmin, vmax=vmax, cmap=cmap, ) - ax.axvline(slice_width // 2 - 0.5, linestyle="--", linewidth=1, color="0.7") + ax.axvline(axis_center, linestyle="--", linewidth=1, color="0.7") + x_pad = max(1.0, 0.02 * (window_hi - window_lo + 1.0)) + ax.set_xlim(window_lo - x_pad, window_hi + x_pad) - if render_mode == "heatmap" and x_axis_mode == "centered": + if render_mode == "heatmap": heatmap_title = ( f"{motif_label} | Window {window_pos + 1}" if len(motif_ids) > 1 @@ -2727,57 +3578,208 @@ def _axis_for(motif_pos: int, window_pos: int): if not rotate and motif_pos == 0: ax.set_title(f"Window {window_pos + 1}") - if rotate and motif_pos == 0: - ax.set_ylabel(f"Window {window_pos + 1}\nReads") - if (not rotate) and len(motif_ids) > 1 and window_pos == 0: - ax.set_ylabel(f"{motif_label}\nReads") + if effective_axis_orientation == "position_x": + if rotate and motif_pos == 0: + ax.set_ylabel(f"Window {window_pos + 1}\nReads") + if (not rotate) and len(motif_ids) > 1 and window_pos == 0: + ax.set_ylabel(f"{motif_label}\nReads") + else: + if rotate and motif_pos == 0: + ax.set_ylabel(f"Window {window_pos + 1}\nPosition") + if (not rotate) and len(motif_ids) > 1 and window_pos == 0: + ax.set_ylabel(f"{motif_label}\nPosition") if rotate: - bottom_axes = [_axis_for(motif_pos, n_windows_effective - 1) for motif_pos in range(len(motif_ids))] + bottom_axes = [ + _axis_for(motif_pos, n_windows_effective - 1) + for motif_pos in range(len(motif_ids)) + ] + position_label = "Position relative to primary center (bp)" xlabel = ( - "Position relative to primary window center (bp)" - if render_mode == "scatter" and x_axis_mode == "relative_to_primary" - else "Position from window center (bp)" - if render_mode == "scatter" + position_label + if effective_axis_orientation == "position_x" else "Reads (sorted)" ) for ax in bottom_axes: ax.set_xlabel(xlabel) else: for motif_pos in range(len(motif_ids)): - _axis_for(motif_pos, 0).set_ylabel("Reads (sorted)" if len(motif_ids) == 1 else _axis_for(motif_pos, 0).get_ylabel()) + if effective_axis_orientation == "position_x": + _axis_for(motif_pos, 0).set_ylabel( + "Reads (sorted)" + if len(motif_ids) == 1 + else _axis_for(motif_pos, 0).get_ylabel() + ) + else: + _axis_for(motif_pos, 0).set_ylabel( + "Position (bp)" + if len(motif_ids) == 1 + else _axis_for(motif_pos, 0).get_ylabel() + ) for window_pos in range(n_windows_effective): - _axis_for(motif_pos, window_pos).set_xlabel("Position (bp)") - - if first_mappable is None: - first_axis = _axis_for(0, 0) - first_mappable = first_axis.scatter([], [], c=[], cmap=cmap, vmin=vmin, vmax=vmax) - cbar = fig.colorbar(first_mappable, ax=np.ravel(axes).tolist(), shrink=0.6, pad=0.02) - sigma_txt = f", σ={smooth_sigma_bp}" if smoothing == "gaussian" else "" - scale_label = "fraction modified signal" - if render_mode == "heatmap": - scale_label = "window signal (row-aggregated heatmap)" - cbar.set_label( - f"{scale_label} (smoothed={smoothing}, win={smooth_win}{sigma_txt})\\n" - f"{'downsampled' if downsampled else 'full'}" - ) + if effective_axis_orientation == "position_x": + _axis_for(motif_pos, window_pos).set_xlabel( + "Position relative to primary center (bp)" + ) + else: + _axis_for(motif_pos, window_pos).set_xlabel("Reads (sorted)") + + if threshold_map is None: + if first_mappable is None: + first_axis = _axis_for(0, 0) + fallback_cmap = ( + ml_cmap_names[motif_ids[0]] + if effective_scatter_color_values == "ml_score" + else cmap + ) + first_mappable = first_axis.scatter( + [], [], c=[], cmap=fallback_cmap, vmin=vmin, vmax=vmax + ) + cbar = fig.colorbar( + first_mappable, ax=np.ravel(axes).tolist(), shrink=0.6, pad=0.02 + ) + sigma_txt = f", σ={smooth_sigma_bp}" if smoothing == "gaussian" else "" + if render_mode == "scatter" and effective_scatter_color_values == "ml_score": + cbar.set_label( + f"normalized ML score (0-1)\\n{'downsampled' if downsampled else 'full'}" + ) + elif render_mode == "scatter": + scale_label = "fraction modified signal" + smoothing_label = ( + f"{smoothing}, win={smooth_win}{sigma_txt}" + if render_value_mode == "smoothed" + else "none" + ) + cbar.set_label( + f"{scale_label} (values={render_value_mode}, smoother={smoothing_label})\\n" + f"{'downsampled' if downsampled else 'full'}" + ) + else: + scale_label = "window signal heatmap" + smoothing_label = ( + f"{smoothing}, win={smooth_win}{sigma_txt}" + if render_value_mode == "smoothed" + else "none" + ) + cbar.set_label( + f"{scale_label} (per-read smoothing along position axis; " + f"values={render_value_mode}, smoother={smoothing_label})\\n" + f"{'downsampled' if downsampled else 'full'}" + ) + else: + from matplotlib.lines import Line2D + + handles = [ + Line2D( + [0], + [0], + marker="o", + linestyle="", + color="none", + markerfacecolor=color, + markeredgecolor=color, + markersize=6, + label=f"{label} (ML >= {threshold:.2f})", + alpha=scatter_alpha, + ) + for label, (color, threshold) in threshold_legend_entries.items() + ] + fig.legend( + handles=handles, + title="Motif thresholds", + loc="upper right", + bbox_to_anchor=(0.98, 0.98), + frameon=False, + ) return fig, { "pairs": panels_sorted_by_motif[0][0].shape[0], "downsampled": downsampled, + "downsample_method": (downsample_method if downsampled else "none"), + "downsample_factor": int(downsample_factor), + "rows_before_downsample": rows_before_downsample, + "rows_after_downsample": int(panels_sorted_by_motif[0][0].shape[0]), "vmin": vmin, "vmax": vmax, "render_mode": render_mode, - "x_axis_mode": x_axis_mode, + "render_values": render_value_mode, + "scatter_color_values": effective_scatter_color_values, + "axis_orientation": effective_axis_orientation, + "x_axis_mode": effective_x_axis_mode, + "sort_by": sort_by, + "sort_window_index": sort_window_pos, + "sort_descending": effective_sort_descending, "motifs_plotted": [motif_labels_resolved[m] for m in motif_ids], "n_windows": n_windows_effective, - "window_center_offsets": target_offsets.tolist() if target_offsets is not None else None, + "window_centers_bp": target_offsets.tolist() + if target_offsets is not None + else None, + "window_center_offsets": target_offsets.tolist() + if target_offsets is not None + else None, + "window_widths_bp": [int(value) for value in panel_widths_bp], "required_read_length_bp": required_read_length_bp, "min_read_length_bp": effective_min_read_length, - "center_tolerance_bp": center_tolerance_bp, + "window_match_tolerance_bp": match_tolerance_bp, + "center_tolerance_bp": match_tolerance_bp, + "enforce_full_window_span": bool(enforce_full_window_span), + "dropped_for_window_span": int(dropped_for_window_span), + "read_order_consistent": True, + "ml_score_thresholds": ( + None + if threshold_map is None + else { + motif_labels_resolved[key]: value + for key, value in threshold_map.items() + if key in motif_ids + } + ), + "ml_score_cmaps": ( + { + motif_labels_resolved[motif_id]: ml_cmap_names[motif_id] + for motif_id in motif_ids + } + if threshold_map is None and effective_scatter_color_values == "ml_score" + else None + ), } +def plot_two_site_read_raster( + read_windows: ReadWindowExtractionResult, + *, + second_site_offset_bp: int, + window_width_bp: int | None = None, + window_match_tolerance_bp: int | None = None, + **kwargs, +): + """ + Convenience wrapper for two-site raster plots in primary-region coordinates. + + Args: + read_windows: ReadWindowExtractionResult from extract_read_windows / build_multimotif_read_windows + second_site_offset_bp: secondary site center (bp) relative to the primary site at 0 + window_width_bp: common width (bp) applied to both windows when provided + window_match_tolerance_bp: tolerance used when matching explicit centers + **kwargs: forwarded to plot_multisite_read_raster + """ + + if "window_centers_bp" in kwargs or "window_center_offsets" in kwargs: + raise ValueError( + "plot_two_site_read_raster manages centers internally; do not pass window_centers_bp." + ) + if "n_windows" in kwargs: + raise ValueError("plot_two_site_read_raster always uses exactly two windows.") + + forwarded: dict[str, Any] = dict(kwargs) + forwarded["window_centers_bp"] = [0, int(second_site_offset_bp)] + if window_width_bp is not None: + forwarded["window_widths_bp"] = [int(window_width_bp), int(window_width_bp)] + if window_match_tolerance_bp is not None: + forwarded["window_match_tolerance_bp"] = int(window_match_tolerance_bp) + return plot_multisite_read_raster(read_windows, n_windows=2, **forwarded) + + def plot_region_cluster_profiles( pileup_matrix: np.ndarray, labels: np.ndarray, @@ -2816,8 +3818,8 @@ def plot_region_cluster_profiles( import matplotlib.pyplot as plt from matplotlib import gridspec - from matplotlib.lines import Line2D from matplotlib.colors import Normalize + from matplotlib.lines import Line2D X_full = np.asarray(pileup_matrix) labs = np.asarray(labels) @@ -2840,7 +3842,9 @@ def plot_region_cluster_profiles( raise ValueError( f"motif_index {motif_idx} out of range for {n_motifs} motif slices." ) - motif_ids = list(range(n_motifs)) if plot_all_motifs and n_motifs > 1 else [motif_idx] + motif_ids = ( + list(range(n_motifs)) if plot_all_motifs and n_motifs > 1 else [motif_idx] + ) if motif_labels is None: motif_labels = [f"motif_{i}" for i in range(n_motifs)] @@ -2866,7 +3870,9 @@ def plot_region_cluster_profiles( primary_matrix = X_full[:, primary_start:primary_end] x_axis = _centered_x_axis( primary_matrix.shape[1], - _window_span_from_size(window_size) if window_size is not None else primary_matrix.shape[1], + _window_span_from_size(window_size) + if window_size is not None + else primary_matrix.shape[1], ) labs_arr, lab_codes, unique_codes = _prepare_group_labels(labs) @@ -2874,7 +3880,9 @@ def plot_region_cluster_profiles( X_sorted_full = X_full[order] lab_codes_sorted = lab_codes[order] - unique_labels = np.array([np.unique(labs_arr[lab_codes == code])[0] for code in unique_codes]) + unique_labels = np.array( + [np.unique(labs_arr[lab_codes == code])[0] for code in unique_codes] + ) cmap = plt.get_cmap(cmap_name) norm = Normalize(vmin=int(unique_codes.min()), vmax=int(unique_codes.max() or 1)) @@ -2949,8 +3957,12 @@ def plot_region_cluster_profiles( color=motif_colors[motif_id], linewidth=1.5, ) - motif_ax.set_ylabel(str(motif_labels[motif_id]), color=motif_colors[motif_id]) - motif_ax.tick_params(axis="y", colors=motif_colors[motif_id], labelsize=8) + motif_ax.set_ylabel( + str(motif_labels[motif_id]), color=motif_colors[motif_id] + ) + motif_ax.tick_params( + axis="y", colors=motif_colors[motif_id], labelsize=8 + ) for motif_pos, motif_ax in enumerate(axes_for_motifs): motif_ax.set_ylim(0, max(motif_maxima[motif_pos], 0.05) * 1.05) else: @@ -2969,14 +3981,18 @@ def plot_region_cluster_profiles( ax.plot( x_axis, mean_profile_raw, - color=motif_colors[motif_id] if len(motif_ids) > 1 else cmap(norm(code)), + color=motif_colors[motif_id] + if len(motif_ids) > 1 + else cmap(norm(code)), linewidth=1.0, alpha=0.25, ) ax.plot( x_axis, mean_profile, - color=motif_colors[motif_id] if len(motif_ids) > 1 else cmap(norm(code)), + color=motif_colors[motif_id] + if len(motif_ids) > 1 + else cmap(norm(code)), linewidth=1.5, ) ax.set_title(f"{unique_labels[i]} (n={row_mask.sum()})") @@ -2986,7 +4002,9 @@ def plot_region_cluster_profiles( if len(motif_ids) > 1 or color_points_by == "motif": handles = [ - Line2D([0], [0], color=motif_colors[m], linewidth=2, label=str(motif_labels[m])) + Line2D( + [0], [0], color=motif_colors[m], linewidth=2, label=str(motif_labels[m]) + ) for m in motif_ids ] fig.legend( @@ -3025,7 +4043,9 @@ def export_region_clusters_to_bed( output_path = Path(output_path) lines = [] - for (chrom, start, end, strand), label in zip(region_metadata, labels): + for (chrom, start, end, strand), label in zip( + region_metadata, labels, strict=False + ): name = f"{name_prefix}_{label}" score = str(label) strand_field = strand if strand in {"+", "-"} else "." @@ -3051,6 +4071,8 @@ def plot_cluster_karyotype( chromosome_order: str | Sequence[str] = "length_desc", invert_position_axis: bool = True, detect_haplotype_backbone_shading: bool = True, + show_position_axis: bool = False, + coordinate_label_stagger: bool = True, ): """ Plot cluster-labeled regions along chromosomes (ideogram-style), colored by cluster. @@ -3067,10 +4089,13 @@ def plot_cluster_karyotype( invert_position_axis: if True, chromosome position increases downward detect_haplotype_backbone_shading: if True, apply subtle maternal/paternal-like backbone shading when paired haplotype naming is detected + show_position_axis: if True, show y-axis ticks/label; default hides them for cleaner ideogram view + coordinate_label_stagger: if True, alternate end-label vertical offsets to reduce overlap """ + import re + import matplotlib.pyplot as plt from matplotlib.colors import Normalize - import re clusters_df = pd.read_csv( region_bed, @@ -3135,7 +4160,9 @@ def _split_haplotype(chrom: str) -> tuple[str, str | None]: df["cluster_id"] = pd.factorize(df["Name"].astype(str))[0] else: fallback = pd.factorize(df["Name"].astype(str))[0] - df["cluster_id"] = parsed_cluster.fillna(pd.Series(fallback, index=df.index)).astype(int) + df["cluster_id"] = parsed_cluster.fillna( + pd.Series(fallback, index=df.index) + ).astype(int) chrom_sizes_series = df.groupby("Chromosome")["Length"].max() if isinstance(chromosome_order, (list, tuple, pd.Index, np.ndarray)): @@ -3146,11 +4173,21 @@ def _split_haplotype(chrom: str) -> tuple[str, str | None]: else: order_mode = str(chromosome_order).lower() if order_mode == "length_asc": - chrom_order = chrom_sizes_series.sort_values(ascending=True).index.astype(str).tolist() + chrom_order = ( + chrom_sizes_series.sort_values(ascending=True) + .index.astype(str) + .tolist() + ) elif order_mode == "natural": - chrom_order = sorted(chrom_sizes_series.index.astype(str).tolist(), key=_natural_chrom_key) + chrom_order = sorted( + chrom_sizes_series.index.astype(str).tolist(), key=_natural_chrom_key + ) else: - chrom_order = chrom_sizes_series.sort_values(ascending=False).index.astype(str).tolist() + chrom_order = ( + chrom_sizes_series.sort_values(ascending=False) + .index.astype(str) + .tolist() + ) haplotype_pairs: dict[str, set[str]] = {} if detect_haplotype_backbone_shading: @@ -3178,8 +4215,8 @@ def _backbone_color(chrom: str) -> str: cmap = plt.get_cmap(cmap_name) unique_clusters = np.sort(df["cluster_id"].unique()) - if hasattr(cmap, "colors") and len(getattr(cmap, "colors")) > 0: - color_cycle = list(getattr(cmap, "colors")) + if hasattr(cmap, "colors") and len(cmap.colors) > 0: + color_cycle = list(cmap.colors) cluster_to_color = { int(cid): color_cycle[i % len(color_cycle)] for i, cid in enumerate(unique_clusters) @@ -3187,16 +4224,22 @@ def _backbone_color(chrom: str) -> str: else: norm = Normalize(vmin=0, vmax=max(1, len(unique_clusters) - 1)) cluster_to_color = { - int(cid): cmap(norm(i)) - for i, cid in enumerate(unique_clusters) + int(cid): cmap(norm(i)) for i, cid in enumerate(unique_clusters) } fig_height = max(3.0, figsize_per_chrom * len(chrom_order)) fig, ax = plt.subplots(figsize=(max(8, len(chrom_order) * 0.7), fig_height + 1.5)) max_length = float(df["Length"].max()) x_positions = np.arange(len(chrom_order), dtype=float) + cluster_counts = df["cluster_id"].value_counts().to_dict() + # Draw dense clusters first and rarer clusters on top for visibility. + draw_order = sorted( + unique_clusters, + key=lambda cid: int(cluster_counts.get(int(cid), 0)), + reverse=True, + ) - for xi, chrom in zip(x_positions, chrom_order): + for xi, chrom in zip(x_positions, chrom_order, strict=False): chrom_len = float(df.loc[df["Chromosome"] == chrom, "Length"].max()) # Backbone for full chromosome (proportional in bp units) ax.plot( @@ -3209,36 +4252,71 @@ def _backbone_color(chrom: str) -> str: zorder=1, ) # Cluster-assigned regions - sub = df[df["Chromosome"] == chrom] - for _, row in sub.iterrows(): - start_bp = float(row["Start"]) - end_bp = float(row["End"]) - region_len = max(0.0, end_bp - start_bp) - min_len = max(float(min_visible_bp), chrom_len * float(min_visible_fraction)) - if region_len < min_len: - center = 0.5 * (start_bp + end_bp) - start_bp = max(0.0, center - (0.5 * min_len)) - end_bp = min(chrom_len, center + (0.5 * min_len)) - ax.plot( - [xi, xi], - [start_bp, end_bp], - color=cluster_to_color[int(row.cluster_id)], - lw=linewidth + 2.0, - alpha=0.95, - solid_capstyle="butt", - zorder=2, - ) - # Per-chromosome coordinate summary below each chromosome. - label_y = -0.055 * max_length if invert_position_axis else 1.055 * max_length - label_va = "top" if invert_position_axis else "bottom" + sub = df[df["Chromosome"] == chrom].copy() + for z_rank, cid in enumerate(draw_order, start=2): + sub_cluster = sub[sub["cluster_id"] == int(cid)] + if sub_cluster.empty: + continue + for _, row in sub_cluster.iterrows(): + start_bp = float(row["Start"]) + end_bp = float(row["End"]) + region_len = max(0.0, end_bp - start_bp) + min_len = max( + float(min_visible_bp), chrom_len * float(min_visible_fraction) + ) + if region_len < min_len: + center = 0.5 * (start_bp + end_bp) + start_bp = max(0.0, center - (0.5 * min_len)) + end_bp = min(chrom_len, center + (0.5 * min_len)) + ax.plot( + [xi, xi], + [start_bp, end_bp], + color=cluster_to_color[int(row.cluster_id)], + lw=linewidth + 2.0, + alpha=0.98, + solid_capstyle="butt", + zorder=z_rank, + ) + + # Per-chromosome coordinate labels centered on each ideogram. + # Use per-chromosome padding (not global max length) so labels stay close. + x_label = xi + y_pad = max(1.0, 0.0015 * chrom_len) + if coordinate_label_stagger: + bottom_extra = 0.0 if (int(xi) % 2 == 0) else (0.6 * y_pad) + else: + bottom_extra = 0.0 + if invert_position_axis: + top_label_y = -y_pad + bottom_label_y = chrom_len + y_pad + bottom_extra + top_label_text = "0" + bottom_label_text = f"{int(chrom_len):,}" + else: + top_label_y = chrom_len + y_pad + bottom_extra + bottom_label_y = -y_pad + top_label_text = f"{int(chrom_len):,}" + bottom_label_text = "0" ax.text( - xi, - label_y, - f"0 .. {int(chrom_len):,} bp", + x_label, + top_label_y, + top_label_text, ha="center", - va=label_va, - fontsize=7, + va="bottom", + fontsize=8, color="0.35", + bbox={"facecolor": "white", "edgecolor": "none", "alpha": 0.75, "pad": 0.2}, + zorder=4, + ) + ax.text( + x_label, + bottom_label_y, + bottom_label_text, + ha="center", + va="top", + fontsize=8, + color="0.35", + bbox={"facecolor": "white", "edgecolor": "none", "alpha": 0.75, "pad": 0.2}, + zorder=4, ) ax.set_xlim(-0.7, len(chrom_order) - 0.3) @@ -3248,14 +4326,25 @@ def _backbone_color(chrom: str) -> str: ax.set_ylim(-0.1 * max_length, 1.08 * max_length) ax.set_xticks(x_positions) ax.set_xticklabels(chrom_order, rotation=45, ha="right") - ax.set_ylabel("Position (bp)") + if show_position_axis: + ax.set_ylabel("Position (bp)") + else: + ax.set_ylabel("") + ax.yaxis.set_visible(False) + ax.spines["left"].set_visible(False) ax.set_title("Clustered Regions by Chromosome (Vertical, Proportional Length)") ax.spines["top"].set_visible(False) ax.spines["right"].set_visible(False) from matplotlib.lines import Line2D legend_handles = [ - Line2D([0], [0], color=cluster_to_color[int(cid)], linewidth=3, label=f"C{int(cid)}") + Line2D( + [0], + [0], + color=cluster_to_color[int(cid)], + linewidth=3, + label=f"C{int(cid)}", + ) for cid in unique_clusters ] ax.legend( @@ -3350,7 +4439,12 @@ def summarize_region_cluster_annotations( return pd.DataFrame() df = overlaps.df.copy() - df["cluster"] = df["Name"].astype(str).str.replace(f"{name_prefix}_", "", regex=False).astype(int) + df["cluster"] = ( + df["Name"] + .astype(str) + .str.replace(f"{name_prefix}_", "", regex=False) + .astype(int) + ) df["feature"] = df[feature_col].astype(str) counts = df.groupby(["cluster", "feature"]).size().reset_index(name="count") @@ -3437,11 +4531,13 @@ def summarize_read_cluster_region_associations( raise ValueError("prior_count must be non-negative.") rows: list[dict[str, Any]] = [] - for meta, cluster_label in zip(metadata, labels): + for meta, cluster_label in zip(metadata, labels, strict=False): chrom = meta.get("chromosome", meta.get("chrom")) start = meta.get("region_start", meta.get("start")) end = meta.get("region_end", meta.get("end")) - strand_value = meta.get("region_strand", meta.get("strand")) if include_strand else "." + strand_value = ( + meta.get("region_strand", meta.get("strand")) if include_strand else "." + ) strand = strand_value if strand_value in {"+", "-"} else "." rows.append( { @@ -3475,16 +4571,24 @@ def summarize_read_cluster_region_associations( region_cols = ["chrom", "start", "end", "strand"] cluster_order = list(pd.unique(df["cluster"])) - region_totals = df.groupby(region_cols, sort=True).size().reset_index(name="total_reads") - kept_regions = region_totals.loc[region_totals["total_reads"] >= min_reads_per_region, region_cols] + region_totals = ( + df.groupby(region_cols, sort=True).size().reset_index(name="total_reads") + ) + kept_regions = region_totals.loc[ + region_totals["total_reads"] >= min_reads_per_region, region_cols + ] if kept_regions.empty: return pd.DataFrame(columns=columns) - region_grid = kept_regions.assign(_key=1).merge( - pd.DataFrame({"cluster": cluster_order, "_key": 1}), - on="_key", - how="outer", - ).drop(columns="_key") + region_grid = ( + kept_regions.assign(_key=1) + .merge( + pd.DataFrame({"cluster": cluster_order, "_key": 1}), + on="_key", + how="outer", + ) + .drop(columns="_key") + ) observed_counts = ( df.groupby(region_cols + ["cluster"], sort=True) @@ -3503,7 +4607,9 @@ def summarize_read_cluster_region_associations( global_counts["global_count"] / global_total if global_total > 0 else 0.0 ) - summary = region_grid.merge(observed_counts, on=region_cols + ["cluster"], how="left") + summary = region_grid.merge( + observed_counts, on=region_cols + ["cluster"], how="left" + ) summary["count"] = summary["count"].fillna(0).astype(int) summary = summary.merge(region_totals, on=region_cols, how="left") summary = summary.merge(global_counts, on="cluster", how="left") @@ -3531,6 +4637,7 @@ def summarize_read_cluster_region_associations( summary["count"], summary["total_reads"], summary["global_fraction"].fillna(0.0), + strict=False, ) ] summary["q_value"] = _adjust_p_values_bh(summary["p_value"]) @@ -3603,7 +4710,7 @@ def _dominance_and_entropy(row: pd.Series) -> tuple[int, float, float]: entropy = float(-(probs * np.log(probs + 1e-12)).sum()) return dominant_cluster, dominant_fraction, entropy - dom, dom_frac, ent = zip(*pivot.apply(_dominance_and_entropy, axis=1)) + dom, dom_frac, ent = zip(*pivot.apply(_dominance_and_entropy, axis=1), strict=False) pivot["dominant_cluster"] = dom pivot["dominant_fraction"] = dom_frac pivot["entropy"] = ent @@ -3635,5 +4742,6 @@ def _dominance_and_entropy(row: pd.Series) -> tuple[int, float, float]: "sample_rows", "cluster_label_mapping", "apply_cluster_label_mapping", + "plot_two_site_read_raster", "plot_multisite_read_raster", ] diff --git a/dimelo/distribution.py b/dimelo/distribution.py index 530f166..8b4de4a 100644 --- a/dimelo/distribution.py +++ b/dimelo/distribution.py @@ -114,17 +114,22 @@ def build_distribution_change( merged["reference_fraction"] = merged["reference_fraction"].fillna(0.0) merged["delta_fraction"] = merged["fraction"] - merged["reference_fraction"] merged["log2_fc"] = np.log2( - (merged["fraction"] + pseudo_count) / (merged["reference_fraction"] + pseudo_count) + (merged["fraction"] + pseudo_count) + / (merged["reference_fraction"] + pseudo_count) ) - return merged[ - [ - "condition", - "cluster", - "count", - "fraction", - "replicate_n", - "reference_fraction", - "delta_fraction", - "log2_fc", + return ( + merged[ + [ + "condition", + "cluster", + "count", + "fraction", + "replicate_n", + "reference_fraction", + "delta_fraction", + "log2_fc", + ] ] - ].sort_values(["condition", "cluster"], kind="stable").reset_index(drop=True) + .sort_values(["condition", "cluster"], kind="stable") + .reset_index(drop=True) + ) diff --git a/dimelo/dmr.py b/dimelo/dmr.py index 9de4bd7..fecc014 100644 --- a/dimelo/dmr.py +++ b/dimelo/dmr.py @@ -1,8 +1,9 @@ from __future__ import annotations import subprocess +from collections.abc import Iterable, Sequence from pathlib import Path -from typing import Any, Iterable, Sequence +from typing import Any import pandas as pd @@ -162,9 +163,13 @@ def run_dmr_pair( region_path = None if regions_bed is None else _coerce_path(regions_bed) segment_output_path = None if segment_path is None else _coerce_path(segment_path) if not control_path.exists(): - raise FileNotFoundError(f"Control bedMethyl file does not exist: {control_path}") + raise FileNotFoundError( + f"Control bedMethyl file does not exist: {control_path}" + ) if not experiment_path.exists(): - raise FileNotFoundError(f"Experiment bedMethyl file does not exist: {experiment_path}") + raise FileNotFoundError( + f"Experiment bedMethyl file does not exist: {experiment_path}" + ) if not reference_path.exists(): raise FileNotFoundError(f"Reference FASTA does not exist: {reference_path}") if region_path is not None and not region_path.exists(): @@ -210,12 +215,18 @@ def run_dmr_pair( _append_if_value(command, "--interval-size", interval_size) if prior_alpha is not None or prior_beta is not None: if prior_alpha is None or prior_beta is None: - raise ValueError("prior_alpha and prior_beta must both be provided together.") + raise ValueError( + "prior_alpha and prior_beta must both be provided together." + ) command.extend(["--prior", str(prior_alpha), str(prior_beta)]) if max_coverages is not None: if len(max_coverages) != 2: - raise ValueError("max_coverages must be a 2-tuple: (control_max, experiment_max).") - command.extend(["--max-coverages", str(max_coverages[0]), str(max_coverages[1])]) + raise ValueError( + "max_coverages must be a 2-tuple: (control_max, experiment_max)." + ) + command.extend( + ["--max-coverages", str(max_coverages[0]), str(max_coverages[1])] + ) resolved_threads = utils.cores_to_run(threads) command.extend(["--threads", str(resolved_threads)]) diff --git a/dimelo/export.py b/dimelo/export.py index e2c973c..9eb4a85 100644 --- a/dimelo/export.py +++ b/dimelo/export.py @@ -81,21 +81,17 @@ def pileup_to_bigwig( # count up the number of rows, for progress tracking, and pull out the last row so as to grab the length of the chromosome # note: the tqdm progress bar slows things down by about 33%, which was deemed better at the time of writing this than # 90 seconds without any status updates - rows_count, last_row = list( - tail( - n=1, - iterable=enumerate( - tqdm( - tabix.fetch(contig), - mininterval=1.0, - desc=f"Indexing {contig}.", - leave=False, - ) - ), - ) - )[0] - fields = last_row.split("\t") - max_coord = int(fields[2]) + rows_count = 0 + max_coord = 0 + for row in tqdm( + tabix.fetch(contig), + mininterval=1.0, + desc=f"Indexing {contig}.", + leave=False, + ): + rows_count += 1 + fields = row.split("\t") + max_coord = max(max_coord, int(fields[2])) contig_lengths_tuples.append((contig, max_coord)) lines_by_contig[contig] = rows_count # If we have a fasta file we can just reference that for contig lengths @@ -123,11 +119,112 @@ def pileup_to_bigwig( tabix.contigs, desc=f"Step 2: Writing {bedmethyl_file.name} contents to {output_file_path.name}", ): + contig_is_sorted = True + previous_coord: int | None = None + + for row in tabix.fetch(contig): + keep_basemod, genomic_coord, _modified_in_row, valid_in_row = ( + load_processed.process_pileup_row( + row=row, + parsed_motif=parsed_motif, + region_strand=strand, + single_strand=(strand != "."), + ) + ) + if keep_basemod and valid_in_row > 0: + if previous_coord is not None and genomic_coord < previous_coord: + contig_is_sorted = False + break + previous_coord = genomic_coord + + pending_coord: int | None = None + pending_modified = 0 + pending_valid = 0 contig_list = [] start_list = [] end_list = [] values_list = [] + def _queue_entry( + target_contig: str, + target_contig_list: list[str], + target_start_list: list[int], + target_end_list: list[int], + target_values_list: list[float], + coord: int, + modified_sum: int, + valid_sum: int, + ) -> None: + if valid_sum <= 0: + return + target_contig_list.append(target_contig) + target_start_list.append(int(coord)) + target_end_list.append(int(coord) + 1) + target_values_list.append(float(modified_sum) / float(valid_sum)) + + def _flush_chunk( + target_contig_list: list[str], + target_start_list: list[int], + target_end_list: list[int], + target_values_list: list[float], + ) -> tuple[list[str], list[int], list[int], list[float]]: + if not target_values_list: + return ( + target_contig_list, + target_start_list, + target_end_list, + target_values_list, + ) + bw.addEntries( + target_contig_list, # Contig names + target_start_list, # Start positions + ends=target_end_list, # End positions + values=target_values_list, # Corresponding values + ) + return [], [], [], [] + + if not contig_is_sorted: + rows_by_coord: dict[int, list[int]] = {} + for row in tqdm( + tabix.fetch(contig), + desc=f"Writing {contig}.", + total=lines_by_contig[contig], + leave=False, + ): + keep_basemod, genomic_coord, modified_in_row, valid_in_row = ( + load_processed.process_pileup_row( + row=row, + parsed_motif=parsed_motif, + region_strand=strand, + single_strand=(strand != "."), + ) + ) + if keep_basemod and valid_in_row > 0: + counts = rows_by_coord.setdefault(int(genomic_coord), [0, 0]) + counts[0] += int(modified_in_row) + counts[1] += int(valid_in_row) + + for coord in sorted(rows_by_coord): + modified_sum, valid_sum = rows_by_coord[coord] + _queue_entry( + contig, + contig_list, + start_list, + end_list, + values_list, + coord, + modified_sum, + valid_sum, + ) + if len(values_list) >= chunk_size: + contig_list, start_list, end_list, values_list = _flush_chunk( + contig_list, start_list, end_list, values_list + ) + contig_list, start_list, end_list, values_list = _flush_chunk( + contig_list, start_list, end_list, values_list + ) + continue + for row in tqdm( tabix.fetch(contig), desc=f"Writing {contig}.", @@ -143,25 +240,45 @@ def pileup_to_bigwig( ) ) if keep_basemod and valid_in_row > 0: - contig_list.append(contig) - start_list.append(genomic_coord) - end_list.append(genomic_coord + 1) - values_list.append(modified_in_row / valid_in_row) - - if len(values_list) > chunk_size: - bw.addEntries( - contig_list, # Contig names - start_list, # Start positions - ends=end_list, # End positions - values=values_list, # Corresponding values + if pending_coord is None: + pending_coord = genomic_coord + pending_modified = int(modified_in_row) + pending_valid = int(valid_in_row) + elif genomic_coord == pending_coord: + pending_modified += int(modified_in_row) + pending_valid += int(valid_in_row) + else: + _queue_entry( + contig, + contig_list, + start_list, + end_list, + values_list, + pending_coord, + pending_modified, + pending_valid, ) - contig_list = [] - start_list = [] - end_list = [] - values_list = [] - bw.addEntries( - contig_list, # Contig names - start_list, # Start positions - ends=end_list, # End positions - values=values_list, # Corresponding values + if len(values_list) >= chunk_size: + contig_list, start_list, end_list, values_list = ( + _flush_chunk( + contig_list, start_list, end_list, values_list + ) + ) + pending_coord = genomic_coord + pending_modified = int(modified_in_row) + pending_valid = int(valid_in_row) + + if pending_coord is not None: + _queue_entry( + contig, + contig_list, + start_list, + end_list, + values_list, + pending_coord, + pending_modified, + pending_valid, + ) + contig_list, start_list, end_list, values_list = _flush_chunk( + contig_list, start_list, end_list, values_list ) diff --git a/dimelo/global_analysis.py b/dimelo/global_analysis.py index 2784b90..dea40ad 100644 --- a/dimelo/global_analysis.py +++ b/dimelo/global_analysis.py @@ -1,8 +1,8 @@ from __future__ import annotations +from collections.abc import Iterable, Sequence from functools import partial from pathlib import Path -from typing import Iterable, Sequence import pandas as pd import pysam @@ -27,9 +27,7 @@ def _global_counts_for_motifs_from_bedmethyl( if len(unique_motifs) == 0: return {} - parsed_motifs = { - motif: utils.ParsedMotif(motif) for motif in unique_motifs - } + parsed_motifs = {motif: utils.ParsedMotif(motif) for motif in unique_motifs} counts_by_motif = {motif: [0, 0] for motif in unique_motifs} with pysam.TabixFile(str(bedmethyl_file)) as tabix_file: @@ -229,10 +227,9 @@ def build_window_summary( for window_row, (modified_count, valid_count) in zip( windows.itertuples(index=False), counts_by_window, + strict=False, ): - window_fraction = ( - 0.0 if valid_count == 0 else modified_count / valid_count - ) + window_fraction = 0.0 if valid_count == 0 else modified_count / valid_count rows.append( { "sample_id": sample.sample_id, diff --git a/dimelo/load_processed.py b/dimelo/load_processed.py index 5b4e83e..533481b 100644 --- a/dimelo/load_processed.py +++ b/dimelo/load_processed.py @@ -2,6 +2,7 @@ import gzip import multiprocessing import os +import warnings from functools import partial from multiprocessing import shared_memory from pathlib import Path @@ -164,7 +165,10 @@ def apply_loader_function_to_region(region_string, function_handle, **kwargs): def _apply_loader_function_to_region_batch(region_batch, function_handle, **kwargs): - return [function_handle(regions=region_string, **kwargs) for region_string in region_batch] + return [ + function_handle(regions=region_string, **kwargs) + for region_string in region_batch + ] def _iter_batches(items: list[str], *, batch_size: int): @@ -190,7 +194,9 @@ def _clear_tabix_cache() -> None: _TABIX_CACHE.clear() -def _resolve_cores_for_task_count(*, requested_cores: int | None, task_count: int) -> int: +def _resolve_cores_for_task_count( + *, requested_cores: int | None, task_count: int +) -> int: """ Resolve worker count for loader-style fanout. @@ -315,7 +321,9 @@ def _memory_limited_cores( if available is None: return baseline - budget = int(available * AUTO_PARALLEL_MEMORY_FRACTION) - max(0, int(extra_shared_bytes)) + budget = int(available * AUTO_PARALLEL_MEMORY_FRACTION) - max( + 0, int(extra_shared_bytes) + ) if budget <= 0: return 1 @@ -352,7 +360,9 @@ def _pileup_counts_from_bedmethyl_single_core( if chromosome not in source_tabix.contigs: continue - for row in source_tabix.fetch(chromosome, max(subregion_start, 0), subregion_end): + for row in source_tabix.fetch( + chromosome, max(subregion_start, 0), subregion_end + ): keep_basemod, _, modified_in_row, valid_in_row = process_pileup_row( row=row, parsed_motif=parsed_motif, @@ -411,12 +421,16 @@ def _pileup_vectors_from_bedmethyl_single_core( modified_base_subregion = np.zeros(subregion_len, dtype=np.int32) if chromosome in source_tabix.contigs: - for row in source_tabix.fetch(chromosome, max(subregion_start, 0), subregion_end): - keep_basemod, genomic_coord, modified_in_row, valid_in_row = process_pileup_row( - row=row, - parsed_motif=parsed_motif, - region_strand=strand, - single_strand=single_strand, + for row in source_tabix.fetch( + chromosome, max(subregion_start, 0), subregion_end + ): + keep_basemod, genomic_coord, modified_in_row, valid_in_row = ( + process_pileup_row( + row=row, + parsed_motif=parsed_motif, + region_strand=strand, + single_strand=single_strand, + ) ) if keep_basemod: if flip_coords: @@ -425,12 +439,16 @@ def _pileup_vectors_from_bedmethyl_single_core( pileup_coord_in_subregion = genomic_coord - subregion_start if pileup_coord_in_subregion < subregion_len: valid_base_subregion[pileup_coord_in_subregion] += valid_in_row - modified_base_subregion[pileup_coord_in_subregion] += modified_in_row + modified_base_subregion[pileup_coord_in_subregion] += ( + modified_in_row + ) - valid_base_counts[subregion_offset : subregion_offset + subregion_len] += valid_base_subregion - modified_base_counts[ - subregion_offset : subregion_offset + subregion_len - ] += modified_base_subregion + valid_base_counts[subregion_offset : subregion_offset + subregion_len] += ( + valid_base_subregion + ) + modified_base_counts[subregion_offset : subregion_offset + subregion_len] += ( + modified_base_subregion + ) return modified_base_counts, valid_base_counts @@ -811,8 +829,12 @@ def _pileup_vectors_process_chunk_batch( source_tabix = _get_tabix_file(bedmethyl_file) existing_valid = shared_memory.SharedMemory(name=shm_name_valid) existing_modified = shared_memory.SharedMemory(name=shm_name_modified) - valid_base_counts = np.ndarray((region_len,), dtype=np.int32, buffer=existing_valid.buf) - modified_base_counts = np.ndarray((region_len,), dtype=np.int32, buffer=existing_modified.buf) + valid_base_counts = np.ndarray( + (region_len,), dtype=np.int32, buffer=existing_valid.buf + ) + modified_base_counts = np.ndarray( + (region_len,), dtype=np.int32, buffer=existing_modified.buf + ) updates: list[tuple[int, np.ndarray, np.ndarray]] = [] for chunk in chunk_batch: @@ -829,11 +851,15 @@ def _pileup_vectors_process_chunk_batch( if updates: with lock: - for subregion_offset, valid_base_subregion, modified_base_subregion in updates: + for ( + subregion_offset, + valid_base_subregion, + modified_base_subregion, + ) in updates: subregion_span = len(valid_base_subregion) - valid_base_counts[subregion_offset : subregion_offset + subregion_span] += ( - valid_base_subregion - ) + valid_base_counts[ + subregion_offset : subregion_offset + subregion_span + ] += valid_base_subregion modified_base_counts[ subregion_offset : subregion_offset + subregion_span ] += modified_base_subregion @@ -851,16 +877,20 @@ def pileup_counts_process_chunk( lock, single_strand, ) -> None: - modified_subregion_counts, valid_subregion_counts = _pileup_counts_process_chunk_batch_local( - bedmethyl_file=bedmethyl_file, - parsed_motif=parsed_motif, - chunk_batch=[chunk], - single_strand=single_strand, + modified_subregion_counts, valid_subregion_counts = ( + _pileup_counts_process_chunk_batch_local( + bedmethyl_file=bedmethyl_file, + parsed_motif=parsed_motif, + chunk_batch=[chunk], + single_strand=single_strand, + ) ) existing_valid = shared_memory.SharedMemory(name=shm_name_valid) existing_modified = shared_memory.SharedMemory(name=shm_name_modified) valid_base_counts = np.ndarray((1,), dtype=np.int32, buffer=existing_valid.buf) - modified_base_counts = np.ndarray((1,), dtype=np.int32, buffer=existing_modified.buf) + modified_base_counts = np.ndarray( + (1,), dtype=np.int32, buffer=existing_modified.buf + ) with lock: valid_base_counts[0] += valid_subregion_counts modified_base_counts[0] += modified_subregion_counts @@ -889,7 +919,9 @@ def _pileup_counts_process_chunk_batch_local( if chromosome not in source_tabix.contigs: continue - for row in source_tabix.fetch(chromosome, max(subregion_start, 0), subregion_end): + for row in source_tabix.fetch( + chromosome, max(subregion_start, 0), subregion_end + ): keep_basemod, _, modified_in_row, valid_in_row = process_pileup_row( row=row, parsed_motif=parsed_motif, @@ -950,10 +982,32 @@ def process_pileup_row( if not keep_basemod: return (False, 0, 0, 0) - pileup_info = tabix_fields[9].split() genomic_coord = int(tabix_fields[1]) - valid_in_row = int(pileup_info[0]) - modified_in_row = int(pileup_info[2]) + + # Modern modkit pileup bedMethyl format (0.6.x) emits full 18-column rows: + # chrom, start, end, mod, score, strand, thickStart, thickEnd, color, + # valid_cov, frac_mod, N_mod, N_canonical, N_other_mod, N_delete, N_fail, + # N_diff, N_nocall. + # Legacy/older formats may encode summary info in tabix_fields[9] as a + # whitespace-delimited payload where [0]=valid and [2]=modified. + try: + if len(tabix_fields) >= 13: + valid_in_row = int(float(tabix_fields[9])) + modified_in_row = int(float(tabix_fields[11])) + else: + pileup_info = tabix_fields[9].split() + valid_in_row = int(float(pileup_info[0])) + modified_in_row = int(float(pileup_info[2])) + except Exception: + if not getattr(process_pileup_row, "_warned_malformed_bedmethyl_row", False): + warnings.warn( + "Skipping malformed bedMethyl row while loading pileup data. " + "This warning is shown once per process.", + RuntimeWarning, + stacklevel=2, + ) + process_pileup_row._warned_malformed_bedmethyl_row = True + return (False, 0, 0, 0) return (True, genomic_coord, modified_in_row, valid_in_row) @@ -997,6 +1051,8 @@ def read_vectors_from_hdf5( cores: int | None = None, # currently unused subset_parameters: dict | None = None, span_full_window: bool = False, + random_sample_n_reads: int | None = None, + min_read_length_bp: int | None = None, ) -> tuple[list[tuple], list[str], dict | None]: """ User-facing function. @@ -1048,6 +1104,10 @@ def read_vectors_from_hdf5( reads to be returned. If not None, at least one of n or frac must be provided. The array parameter should not be provided here. span_full_window: If True, only load reads that fully span the window defined by region_start-region_end + random_sample_n_reads: Optional global random sample size applied after filtering and + region/motif selection. Samples unique read names (not tuple rows), then retains all + motif rows associated with those reads. + min_read_length_bp: Optional minimum read length filter (bp) applied before loading vectors. Returns: a list of tuples, each tuple containing all datasets corresponding to an individual read that @@ -1059,6 +1119,16 @@ def read_vectors_from_hdf5( the available parameters. """ _validate_subset_parameters(subset_parameters) + if random_sample_n_reads is not None and int(random_sample_n_reads) <= 0: + raise ValueError("random_sample_n_reads must be > 0 when provided.") + if min_read_length_bp is not None and int(min_read_length_bp) < 0: + raise ValueError("min_read_length_bp must be >= 0 when provided.") + random_sample_n_reads = ( + int(random_sample_n_reads) if random_sample_n_reads is not None else None + ) + min_read_length_bp = ( + int(min_read_length_bp) if min_read_length_bp is not None else None + ) with h5py.File(file, "r") as h5: datasets: list[str] = [ @@ -1085,6 +1155,7 @@ def read_vectors_from_hdf5( read_chromosomes = np.array(h5["chromosome"], dtype=str) read_starts = np.array(h5["read_start"]) read_ends = np.array(h5["read_end"]) + read_lengths = read_ends - read_starts read_motifs = np.array(h5["motif"], dtype=str) ref_strands = np.array(h5["strand"], dtype=str) @@ -1105,6 +1176,11 @@ def read_vectors_from_hdf5( & (read_starts < region_end) & (read_starts <= region_start if span_full_window else True) & (read_ends >= region_end if span_full_window else True) + & ( + read_lengths >= min_read_length_bp + if min_read_length_bp is not None + else True + ) & np.isin(read_motifs, motifs) & (read_chromosomes == chrom) & ( @@ -1133,11 +1209,19 @@ def read_vectors_from_hdf5( [region_start for _ in relevant_read_indices], [region_end for _ in relevant_read_indices], [region_strand for _ in relevant_read_indices], + strict=False, ) ) else: regions_dict = None - relevant_read_indices = np.flatnonzero(np.isin(read_motifs, motifs)) + relevant_read_indices = np.flatnonzero( + np.isin(read_motifs, motifs) + & ( + read_lengths >= min_read_length_bp + if min_read_length_bp is not None + else True + ) + ) relevant_read_indices = _subset_indices( relevant_read_indices, subset_parameters=subset_parameters ) @@ -1158,6 +1242,7 @@ def read_vectors_from_hdf5( [-1 for _ in relevant_read_indices], [-1 for _ in relevant_read_indices], ["." for _ in relevant_read_indices], + strict=False, ) ) # We add region information (start, end, and strand; chromosome is already present!) @@ -1179,6 +1264,22 @@ def read_vectors_from_hdf5( for tup in read_tuples_raw ] + # Optional global random sample by unique read name, applied after filtering/loading. + if random_sample_n_reads is not None and read_tuples_processed: + read_name_idx_pre = readwise_datasets.index("read_name") + unique_read_names = np.array( + sorted({row[read_name_idx_pre] for row in read_tuples_processed}, key=str) + ) + if random_sample_n_reads < unique_read_names.size: + sampled_names = set( + utils.random_sample(unique_read_names, n=random_sample_n_reads).tolist() + ) + read_tuples_processed = [ + row + for row in read_tuples_processed + if row[read_name_idx_pre] in sampled_names + ] + read_start_idx = readwise_datasets.index("read_start") read_end_idx = readwise_datasets.index("read_end") read_name_idx = readwise_datasets.index("read_name") @@ -1294,6 +1395,8 @@ def readwise_binary_modification_arrays( quiet: bool = True, # currently unused; change to default False when pbars are implemented cores: int | None = None, # currently unused subset_parameters: dict | None = None, + random_sample_n_reads: int | None = None, + min_read_length_bp: int | None = None, ) -> tuple[list[np.ndarray], np.ndarray[int], np.ndarray[str], dict | None]: """ Primarily designed as a helper function for single-read plotting, but can be used by a user. @@ -1344,6 +1447,8 @@ def readwise_binary_modification_arrays( subset_parameters: Parameters to pass to the utils.random_sample() method, to subset the reads to be returned. If not None, at least one of n or frac must be provided. The array parameter should not be provided here. + random_sample_n_reads: Optional global random sample size by unique read name. + min_read_length_bp: Optional minimum read length filter (bp) applied before loading vectors. Returns: Returns a tuple of three arrays, of length (N_READS * len(mod_names)), and a dict of regions. @@ -1369,6 +1474,8 @@ def readwise_binary_modification_arrays( quiet=quiet, cores=cores, subset_parameters=subset_parameters, + random_sample_n_reads=random_sample_n_reads, + min_read_length_bp=min_read_length_bp, ) read_name_index = datasets.index("read_name") mod_vector_index = datasets.index("mod_vector") @@ -1416,7 +1523,9 @@ def readwise_binary_modification_arrays( next_read_int += 1 read_ints[idx] = read_int - for read_int, read_data in zip(read_ints, sorted_read_data_converted): + for read_int, read_data in zip( + read_ints, sorted_read_data_converted, strict=False + ): if thresh is None: mod_pos_in_read = np.flatnonzero(read_data[mod_vector_index]) else: diff --git a/dimelo/models.py b/dimelo/models.py index ccb0347..3dafc8d 100644 --- a/dimelo/models.py +++ b/dimelo/models.py @@ -6,7 +6,6 @@ import pandas as pd - _SELECTED_REGION_CHROM_COLUMNS = {"chrom", "chromosome"} _SELECTED_REGION_REQUIRED_COLUMNS = {"start", "end"} @@ -19,7 +18,9 @@ def _validate_selected_regions_dataframe( if not isinstance(selected_regions, pd.DataFrame): raise TypeError(f"{owner}.selected_regions must be a pandas DataFrame") - has_chrom_column = bool(_SELECTED_REGION_CHROM_COLUMNS & set(selected_regions.columns)) + has_chrom_column = bool( + _SELECTED_REGION_CHROM_COLUMNS & set(selected_regions.columns) + ) has_required_columns = _SELECTED_REGION_REQUIRED_COLUMNS.issubset( selected_regions.columns ) @@ -314,13 +315,11 @@ def __post_init__(self) -> None: ) if not isinstance(self.discovery, RegionDiscoveryResult): raise TypeError( - "RegionDiscoveryClusterResult.discovery must be a " - "RegionDiscoveryResult" + "RegionDiscoveryClusterResult.discovery must be a RegionDiscoveryResult" ) if not isinstance(self.clustering, SharedClusterResult): raise TypeError( - "RegionDiscoveryClusterResult.clustering must be a " - "SharedClusterResult" + "RegionDiscoveryClusterResult.clustering must be a SharedClusterResult" ) @@ -416,7 +415,9 @@ def __post_init__(self) -> None: if self.sites is None: raise ValueError("ModkitDMRPairResult.sites cannot be None.") if self.high_confidence_sites is None: - raise ValueError("ModkitDMRPairResult.high_confidence_sites cannot be None.") + raise ValueError( + "ModkitDMRPairResult.high_confidence_sites cannot be None." + ) if self.metadata is None: raise ValueError("ModkitDMRPairResult.metadata cannot be None.") diff --git a/dimelo/parse_bam.py b/dimelo/parse_bam.py index c3a8b73..02150a6 100644 --- a/dimelo/parse_bam.py +++ b/dimelo/parse_bam.py @@ -3,7 +3,9 @@ import itertools import json import multiprocessing +import os import subprocess +import sys from collections import defaultdict from pathlib import Path @@ -28,6 +30,22 @@ ThresholdInput = int | float | dict[str, int | float] | None +def _should_render_live_progress() -> bool: + """ + Decide whether tqdm live bars should be rendered in this process context. + + "auto" mode avoids notebook/non-TTY contexts where carriage-return bars are + frequently rendered as mangled output. + """ + mode = os.environ.get("DIMELO_PROGRESS_MODE", "auto").strip().lower() + if mode in {"off", "none", "false", "0"}: + return False + if mode in {"on", "force", "true", "1"}: + return True + in_notebook = "JPY_PARENT_PID" in os.environ or "IPYKERNEL_PARENT_PID" in os.environ + return sys.stderr.isatty() and not in_notebook + + def _unique_preserve_order(items: list[str]) -> list[str]: seen: set[str] = set() ordered: list[str] = [] @@ -146,7 +164,7 @@ def _build_extract_command_prefix( output_txt: Path, capabilities: run_modkit.ModkitCapabilities, ) -> list[str | Path]: - if capabilities.supports_extract_subcommands: + if _extract_requires_subcommands(capabilities): return [capabilities.executable, "extract", "full", input_file, output_txt] return [capabilities.executable, "extract", input_file, output_txt] @@ -155,12 +173,11 @@ def _build_extract_reference_command_list( ref_genome: Path, capabilities: run_modkit.ModkitCapabilities, ) -> list[str | Path]: - if capabilities.supports_extract_subcommands: + if _extract_requires_subcommands(capabilities): if capabilities.extract_supports_reference_long: return ["--reference", ref_genome] - if capabilities.extract_supports_reference_short: - return ["--ref", ref_genome] - return [] + # modkit 0.6+ extract subcommands require --reference for motif filtering. + return ["--reference", ref_genome] if capabilities.extract_supports_reference_short: return ["--ref", ref_genome] if capabilities.extract_supports_reference_long: @@ -168,6 +185,18 @@ def _build_extract_reference_command_list( return ["--ref", ref_genome] +def _extract_requires_subcommands( + capabilities: run_modkit.ModkitCapabilities, +) -> bool: + if capabilities.supports_extract_subcommands: + return True + return bool( + capabilities.version_tuple is not None + and len(capabilities.version_tuple) >= 2 + and (capabilities.version_tuple[0], capabilities.version_tuple[1]) >= (0, 6) + ) + + def _build_implicit_tag_command_list( capabilities: run_modkit.ModkitCapabilities, ) -> list[str]: @@ -176,11 +205,40 @@ def _build_implicit_tag_command_list( return [] +def _modkit_requires_multi_motif_pileup_split( + capabilities: run_modkit.ModkitCapabilities, +) -> bool: + if capabilities.version_tuple is None or len(capabilities.version_tuple) < 2: + return False + return (capabilities.version_tuple[0], capabilities.version_tuple[1]) >= (0, 6) + + def _canonical_motif_key(motif: str) -> str: parsed = utils.ParsedMotif(motif) return f"{parsed.motif_seq},{parsed.modified_pos}" +def _group_motifs_for_pileup( + motifs: list[str], + capabilities: run_modkit.ModkitCapabilities, +) -> list[tuple[str, list[str]]]: + if ( + not _modkit_requires_multi_motif_pileup_split(capabilities) + or len({_canonical_motif_key(motif) for motif in motifs}) <= 1 + ): + return [("combined", motifs)] + + grouped: dict[str, list[str]] = {} + ordered_keys: list[str] = [] + for motif in motifs: + canonical_key = _canonical_motif_key(motif) + if canonical_key not in grouped: + grouped[canonical_key] = [] + ordered_keys.append(canonical_key) + grouped[canonical_key].append(motif) + return [(key, grouped[key]) for key in ordered_keys] + + def _resolve_motif_thresholds( motifs: list[str], thresh: ThresholdInput, @@ -249,6 +307,22 @@ def _unlink_existing(*paths: Path) -> None: path.unlink(missing_ok=True) +def _text_file_has_any_rows(path: Path) -> bool: + try: + with open(path) as handle: + for line in handle: + if line.strip(): + return True + except FileNotFoundError: + return False + return False + + +def _sanitize_motif_group_label(label: str) -> str: + sanitized = "".join(char if char.isalnum() else "_" for char in label).strip("_") + return sanitized or "motif" + + def _reference_oriented_read_offset( *, pos_in_read: int, @@ -288,6 +362,7 @@ def pileup( cores: int | None = None, log: bool = False, cleanup: bool = True, + overwrite: bool = True, quiet: bool = False, override_checks: bool = False, modkit_executable: str | Path | None = None, @@ -354,6 +429,9 @@ def pileup( cleanup: a boolean specifying whether to clean up to keep intermediate outputs. The final processed files are not human-readable, whereas the intermediate outputs are. However, intermediate outputs can also be quite large. + overwrite: when True (default), existing outputs for `output_name` are + replaced. When False, existing completed outputs are reused and parsing + is skipped. If partial/conflicting outputs exist, raises FileExistsError. override_checks: convert errors from input checking into warnings if True modkit_executable: optional executable name or path to a specific modkit binary. If None, dimelo resolves modkit from PATH (or @@ -367,11 +445,6 @@ def pileup( """ ## Verify and prepare inputs and outputs - capabilities = run_modkit._ensure_modkit_available( - quiet=quiet, - executable=modkit_executable, - ) - input_file, ref_genome, output_directory = utils.sanitize_path_args( input_file, ref_genome, output_directory ) @@ -379,17 +452,6 @@ def pileup( ref_genome = Path(ref_genome) output_directory = None if output_directory is None else Path(output_directory) - try: - verify_inputs(input_file, motifs, ref_genome) - except Exception as e: - if override_checks: - if not quiet: - print(f"WARNING: {e}") - else: - raise Exception( - f'{e}\nIf you are confident that your inputs are ok, pass "override_checks=True" to convert to warning and proceed with processing.' - ) from e - output_path, (output_bedmethyl, output_bedmethyl_sorted, output_pileup_path, _) = ( prep_output_directory( output_directory=output_directory, @@ -401,8 +463,65 @@ def pileup( "pileup.sorted.bed.gz", "pileup.sorted.bed.gz.tbi", ], + overwrite=False, ) ) + output_pileup_tbi = Path(f"{output_pileup_path}.tbi") + processed_regions_candidate = output_path / "regions.processed.bed" + processed_regions_existing = ( + processed_regions_candidate if processed_regions_candidate.exists() else None + ) + + if not overwrite: + final_outputs_exist = output_pileup_path.exists() and output_pileup_tbi.exists() + regions_ready = regions is None or processed_regions_existing is not None + if final_outputs_exist and regions_ready: + if not quiet: + print( + f"overwrite=False and existing outputs found. Reusing {output_pileup_path}." + ) + return output_pileup_path, processed_regions_existing + + existing_paths = [ + output_bedmethyl, + output_bedmethyl_sorted, + output_pileup_path, + output_pileup_tbi, + ] + if processed_regions_existing is not None: + existing_paths.append(processed_regions_existing) + conflicting_paths = [path for path in existing_paths if path.exists()] + if len(conflicting_paths) > 0: + conflict_names = ", ".join(path.name for path in conflicting_paths) + raise FileExistsError( + "overwrite=False but output directory contains existing parse artifacts " + f"for '{output_name}': {conflict_names}. " + "Set overwrite=True to regenerate, or remove stale files." + ) + else: + _unlink_existing( + output_bedmethyl, + output_bedmethyl_sorted, + output_pileup_path, + output_pileup_tbi, + processed_regions_candidate, + ) + + capabilities = run_modkit._ensure_modkit_available( + quiet=quiet, + executable=modkit_executable, + ) + + try: + verify_inputs(input_file, motifs, ref_genome) + except Exception as e: + if override_checks: + if not quiet: + print(f"WARNING: {e}") + else: + raise Exception( + f'{e}\nIf you are confident that your inputs are ok, pass "override_checks=True" to convert to warning and proceed with processing.' + ) from e ## Build up the command list to be sent to modkit, then run modkit @@ -414,21 +533,16 @@ def pileup( if len(motifs) == 0: raise ValueError("Error: no motifs specified. Nothing to process.") - motif_command_list = _build_pileup_targeting_command_list( - motifs=motifs, - capabilities=capabilities, - ) - - if log: - if not quiet: - print("Logging to ", Path(output_path) / "pileup-log") - log_command_list = ["--log-filepath", Path(output_path) / "pileup-log"] - else: - log_command_list = [] - cores_command_list = _threads_command_list(cores=cores, quiet=quiet) - mod_thresh_command_list: list[str] = [] + motif_groups = _group_motifs_for_pileup(motifs=motifs, capabilities=capabilities) + split_pileup_runs = len(motif_groups) > 1 + if split_pileup_runs and not quiet: + print( + "Detected multiple motif contexts with modkit 0.6.x; running per-motif pileups " + "and merging outputs to avoid mixed-motif empty output behavior." + ) + motif_thresholds = _resolve_motif_thresholds( motifs=motifs, thresh=thresh, @@ -444,44 +558,94 @@ def pileup( print( f"WARNING: thresh {thresh} is very low and may lead to unexpected behavior. Typical thresholds are at least 0.5 or 128." ) - mod_thresh_command_list = _build_mod_threshold_command_list( - motifs=motifs, - motif_thresholds=motif_thresholds, - capabilities=capabilities, - ) - ref_genome_command_list = ["--ref", ref_genome] filter_command_list = ["--filter-threshold", "0"] implicit_tag_command_list = _build_implicit_tag_command_list(capabilities) - pileup_command_list = ( - [capabilities.executable, "pileup", input_file, output_bedmethyl] - + region_command_list - + motif_command_list - + ref_genome_command_list - + filter_command_list - + implicit_tag_command_list - + mod_thresh_command_list - + cores_command_list - + log_command_list - ) + intermediate_pileup_files: list[Path] = [] + for index, (group_key, group_motifs) in enumerate(motif_groups, start=1): + group_suffix = _sanitize_motif_group_label(group_key) + group_output_bedmethyl = ( + output_bedmethyl + if not split_pileup_runs + else output_path / f"pileup.part{index}.{group_suffix}.bed" + ) + _unlink_existing(group_output_bedmethyl) + intermediate_pileup_files.append(group_output_bedmethyl) - run_modkit.run_with_progress_bars( - command_list=pileup_command_list, - input_file=input_file, - ref_genome=ref_genome, - motifs=motifs, - load_fasta_regex=r"\s+\[.*?\]\s+(\d+)\s+Reading", - find_motifs_regex=r"\s+(\d+)/(\d+)\s+finding\s+([A-Za-z0-9,]+)\s+motifs", - contigs_progress_regex=r"\s+(\d+)/(\d+)\s+contigs", - single_contig_regex=r"\s+(\d+)/(\d+)\s+processing\s+([\w]+)[^\w]", - buffer_size=50, - progress_granularity=25, - done_str="Done", - err_str="Error", - expect_done=True, - quiet=quiet, - ) + group_motif_command_list = _build_pileup_targeting_command_list( + motifs=group_motifs, + capabilities=capabilities, + ) + group_mod_thresh_command_list: list[str] = [] + if motif_thresholds is not None: + group_motif_thresholds = { + motif: motif_thresholds[motif] for motif in group_motifs + } + group_mod_thresh_command_list = _build_mod_threshold_command_list( + motifs=group_motifs, + motif_thresholds=group_motif_thresholds, + capabilities=capabilities, + ) + + if log: + log_path = ( + Path(output_path) / "pileup-log" + if not split_pileup_runs + else Path(output_path) / f"pileup-log.{index}.{group_suffix}" + ) + log_command_list = ["--log-filepath", log_path] + if not quiet and not split_pileup_runs: + print("Logging to ", log_path) + else: + log_command_list = [] + + base_pileup_command = ( + [capabilities.executable, "pileup", input_file, group_output_bedmethyl] + + region_command_list + + group_motif_command_list + + ref_genome_command_list + + filter_command_list + + implicit_tag_command_list + + cores_command_list + + log_command_list + ) + + def _run_pileup_command( + extra_args: list[str], + *, + base_command: list[str] = base_pileup_command, + motifs_for_progress: list[tuple[str, int, str]] = group_motifs, + ) -> None: + run_modkit.run_with_progress_bars( + command_list=base_command + extra_args, + input_file=input_file, + ref_genome=ref_genome, + motifs=motifs_for_progress, + load_fasta_regex=r"\s+\[.*?\]\s+(\d+)\s+Reading", + find_motifs_regex=r"\s+(\d+)/(\d+)\s+finding\s+([A-Za-z0-9,]+)\s+motifs", + contigs_progress_regex=r"\s+(\d+)/(\d+)\s+contigs", + single_contig_regex=r"\s+(\d+)/(\d+)\s+processing\s+([\w]+)[^\w]", + buffer_size=50, + progress_granularity=25, + done_str="Done", + err_str="Error", + expect_done=True, + quiet=quiet, + ) + + _run_pileup_command(group_mod_thresh_command_list) + + if split_pileup_runs: + with open(output_bedmethyl, "w") as merged_file: + for intermediate_file in intermediate_pileup_files: + if not intermediate_file.exists(): + continue + with open(intermediate_file) as part_file: + for line in part_file: + merged_file.write(line) + for intermediate_file in intermediate_pileup_files: + _unlink_existing(intermediate_file) ## Sort, compress, and index the output bedmethyl file @@ -510,6 +674,7 @@ def extract( cores: int | None = None, log: bool = False, cleanup: bool = True, + overwrite: bool = True, quiet: bool = False, override_checks: bool = False, modkit_executable: str | Path | None = None, @@ -574,6 +739,9 @@ def extract( cleanup: a boolean specifying whether to clean up to keep intermediate outputs. The final processed files are not human-readable, whereas the intermediate outputs are. However, intermediate outputs can also be quite large. + overwrite: when True (default), existing outputs for `output_name` are + replaced. When False, existing completed outputs are reused and parsing + is skipped. If partial/conflicting outputs exist, raises FileExistsError. override_checks: convert errors from input checking into warnings if True modkit_executable: optional executable name or path to a specific modkit binary. If None, dimelo resolves modkit from PATH (or @@ -586,11 +754,6 @@ def extract( """ ## Verify and prepare inputs and outputs - capabilities = run_modkit._ensure_modkit_available( - quiet=quiet, - executable=modkit_executable, - ) - input_file, ref_genome, output_directory = utils.sanitize_path_args( input_file, ref_genome, output_directory ) @@ -598,6 +761,47 @@ def extract( ref_genome = Path(ref_genome) output_directory = None if output_directory is None else Path(output_directory) + output_path, (output_reads_path,) = prep_output_directory( + output_directory=output_directory, + output_name=output_name, + input_file=input_file.parent, + output_file_names=["reads.combined_basemods.h5"], + overwrite=False, + ) + processed_regions_candidate = output_path / "regions.processed.bed" + processed_regions_existing = ( + processed_regions_candidate if processed_regions_candidate.exists() else None + ) + + if not overwrite: + final_output_exists = output_reads_path.exists() + regions_ready = regions is None or processed_regions_existing is not None + if final_output_exists and regions_ready: + if not quiet: + print( + f"overwrite=False and existing outputs found. Reusing {output_reads_path}." + ) + return output_reads_path, processed_regions_existing + + existing_paths = [output_reads_path] + if processed_regions_existing is not None: + existing_paths.append(processed_regions_existing) + conflicting_paths = [path for path in existing_paths if path.exists()] + if len(conflicting_paths) > 0: + conflict_names = ", ".join(path.name for path in conflicting_paths) + raise FileExistsError( + "overwrite=False but output directory contains existing parse artifacts " + f"for '{output_name}': {conflict_names}. " + "Set overwrite=True to regenerate, or remove stale files." + ) + else: + _unlink_existing(output_reads_path, processed_regions_candidate) + + capabilities = run_modkit._ensure_modkit_available( + quiet=quiet, + executable=modkit_executable, + ) + try: verify_inputs(input_file, motifs, ref_genome) except Exception as e: @@ -609,13 +813,6 @@ def extract( f'{e}\nIf you are confident that your inputs are ok, pass "override_checks=True" to convert to warning and proceed with processing.' ) from e - output_path, (output_reads_path,) = prep_output_directory( - output_directory=output_directory, - output_name=output_name, - input_file=input_file.parent, - output_file_names=["reads.combined_basemods.h5"], - ) - ## Build up the command lists shared across motifs to be sent to modkit region_command_list, processed_regions_path = create_region_command_list( @@ -658,7 +855,9 @@ def extract( capabilities=capabilities, ) filter_command_list = ( - [] if capabilities.supports_extract_subcommands else ["--filter-threshold", "0"] + [] + if _extract_requires_subcommands(capabilities) + else ["--filter-threshold", "0"] ) implicit_tag_command_list = _build_implicit_tag_command_list(capabilities) @@ -1015,7 +1214,8 @@ def read_by_base_txt_to_hdf5( # Check file length line_index = 0 - for line_index, fields in enumerate(reader, start=1): + for fields in reader: + line_index += 1 read_id_value = fields[first_pass_read_name_idx] if read_name != read_id_value: read_name = read_id_value @@ -1065,7 +1265,11 @@ def read_by_base_txt_to_hdf5( if has_binary: unique_thresholds = sorted( - {float(value) for value in threshold_by_motif.values() if value is not None} + { + float(value) + for value in threshold_by_motif.values() + if value is not None + } ) if len(unique_thresholds) == 1: threshold_to_store = unique_thresholds[0] @@ -1100,6 +1304,7 @@ def read_by_base_txt_to_hdf5( compression="gzip", compression_opts=9, ) + def ensure_dataset_capacity( *, name: str, @@ -1167,8 +1372,8 @@ def ensure_dataset_capacity( read_counter = 0 # Keys (strings): dataset names, values: lists of dataset values by read; string or ints or arrays # Contents reset at the end of each chunk, after writing to h5 - chunk_rows: defaultdict[str, list[str | int | np.ndarray]] = ( - defaultdict(list) + chunk_rows: defaultdict[str, list[str | int | np.ndarray]] = defaultdict( + list ) chunk_row_count = 0 @@ -1265,7 +1470,7 @@ def _column_index(*candidates: str, fallback: int) -> int: canonical_base_idx = _column_index("canonical_base", fallback=15) iterator = reader - if not quiet: + if not quiet and _should_render_live_progress(): iterator = tqdm( iterator, total=num_lines, @@ -1334,6 +1539,7 @@ def prep_output_directory( output_name: str, input_file: Path, output_file_names: list[str], + overwrite: bool = True, ) -> tuple[Path, list[Path]]: """ As a side effect, if files exist that match the requested outputs, they are deleted. @@ -1346,6 +1552,8 @@ def prep_output_directory( containing the intermediate and final outputs, along with any logs. input_file: default output directory when output_directory is None output_file_names: list of names of desired output files + overwrite: when True, existing requested output files are deleted. When + False, existing files are preserved. Returns: * Path to top-level output directory @@ -1359,10 +1567,10 @@ def prep_output_directory( output_files = [output_path / file_name for file_name in output_file_names] - # Ensure output path exists, and that any of the specified output files do not already exist (necessary for some outputs) - # Delete the files that do already exist + # Ensure output path exists. output_path.mkdir(parents=True, exist_ok=True) - for output_file in output_files: - output_file.unlink(missing_ok=True) + if overwrite: + for output_file in output_files: + output_file.unlink(missing_ok=True) return output_path, output_files diff --git a/dimelo/plot_depth_histogram.py b/dimelo/plot_depth_histogram.py index 27a179e..93e8909 100644 --- a/dimelo/plot_depth_histogram.py +++ b/dimelo/plot_depth_histogram.py @@ -122,7 +122,9 @@ def by_regions( raise ValueError("by_regions requires motif.") sample_names_for_plot = ( - sample_names if sample_names is not None else [str(region) for region in regions_list] + sample_names + if sample_names is not None + else [str(region) for region in regions_list] ) n_beds = len(regions_list) return plot_depth_histogram( @@ -200,7 +202,9 @@ def get_depth_counts( mod_file_paths = [Path(fn) for fn in mod_file_names] depth_vectors = [] - for mod_file, regions, motif in zip(mod_file_paths, regions_list, motifs): + for mod_file, regions, motif in zip( + mod_file_paths, regions_list, motifs, strict=False + ): match mod_file.suffix: case ".gz": pileup_vectors_list = load_processed.regions_to_list( diff --git a/dimelo/plot_depth_profile.py b/dimelo/plot_depth_profile.py index 31744bc..6effc62 100644 --- a/dimelo/plot_depth_profile.py +++ b/dimelo/plot_depth_profile.py @@ -114,7 +114,9 @@ def by_regions( raise ValueError("by_regions requires motif.") sample_names_for_plot = ( - sample_names if sample_names is not None else [str(region) for region in regions_list] + sample_names + if sample_names is not None + else [str(region) for region in regions_list] ) n_beds = len(regions_list) return plot_depth_profile( @@ -192,7 +194,9 @@ def get_depth_profiles( mod_file_paths = [Path(fn) for fn in mod_file_names] trace_vectors = [] - for mod_file, regions, motif in zip(mod_file_paths, regions_list, motifs): + for mod_file, regions, motif in zip( + mod_file_paths, regions_list, motifs, strict=False + ): match mod_file.suffix: case ".gz": _, valid_base_counts = load_processed.pileup_vectors_from_bedmethyl( diff --git a/dimelo/plot_enrichment.py b/dimelo/plot_enrichment.py index de97973..6fd8bba 100644 --- a/dimelo/plot_enrichment.py +++ b/dimelo/plot_enrichment.py @@ -81,6 +81,7 @@ def by_modification( **kwargs, ) + def by_regions( mod_file_name: str | Path, regions_list: list[str | Path | list[str | Path]] | None = None, @@ -108,7 +109,9 @@ def by_regions( raise ValueError("by_regions requires motif.") sample_names_for_plot = ( - sample_names if sample_names is not None else [str(region) for region in regions_list] + sample_names + if sample_names is not None + else [str(region) for region in regions_list] ) n_beds = len(regions_list) return plot_enrichment( @@ -182,7 +185,9 @@ def get_enrichments( mod_file_paths = [Path(fn) for fn in mod_file_names] mod_fractions = [] - for mod_file, regions, motif in zip(mod_file_paths, regions_list, motifs): + for mod_file, regions, motif in zip( + mod_file_paths, regions_list, motifs, strict=False + ): match mod_file.suffix: case ".gz": n_mod, n_total = load_processed.pileup_counts_from_bedmethyl( diff --git a/dimelo/plot_enrichment_profile.py b/dimelo/plot_enrichment_profile.py index 3af421f..0a9a504 100644 --- a/dimelo/plot_enrichment_profile.py +++ b/dimelo/plot_enrichment_profile.py @@ -61,7 +61,9 @@ def _prepare_legacy_aggregate_profile_vectors( ) -> list[np.ndarray]: prepared_vectors: list[np.ndarray] = [] for sample_name in sample_names: - sample_table = prepared_table.loc[prepared_table["sample_name"] == sample_name].copy() + sample_table = prepared_table.loc[ + prepared_table["sample_name"] == sample_name + ].copy() sample_table = sample_table.sort_values("plot_x") prepared_vectors.append(sample_table["value"].to_numpy()) return prepared_vectors @@ -209,6 +211,7 @@ def by_modification( **kwargs, ) + def by_regions( mod_file_name: str | Path, regions_list: list[str | Path | list[str | Path]] | None = None, @@ -236,7 +239,9 @@ def by_regions( raise ValueError("by_regions requires motif.") sample_names_for_plot = ( - sample_names if sample_names is not None else [str(region) for region in regions_list] + sample_names + if sample_names is not None + else [str(region) for region in regions_list] ) n_beds = len(regions_list) return plot_enrichment_profile( @@ -314,7 +319,9 @@ def get_enrichment_profiles( mod_file_paths = [Path(fn) for fn in mod_file_names] trace_vectors = [] - for mod_file, regions, motif in zip(mod_file_paths, regions_list, motifs): + for mod_file, regions, motif in zip( + mod_file_paths, regions_list, motifs, strict=False + ): match mod_file.suffix: case ".gz": modified_base_counts, valid_base_counts = ( @@ -378,7 +385,11 @@ def make_enrichment_profile_plot( if not utils.check_len_equal(trace_vectors, sample_names): raise ValueError("Unequal number of inputs") legend_title = kwargs.pop("legend_title", None) - if legend_title is None and sample_names and all(_looks_like_motif_spec(name) for name in sample_names): + if ( + legend_title is None + and sample_names + and all(_looks_like_motif_spec(name) for name in sample_names) + ): legend_title = "Modifications (motif, mod_index)" resolved_legend_title = "variable" if legend_title is None else str(legend_title) axes = utils.line_plot( diff --git a/dimelo/plot_reads.py b/dimelo/plot_reads.py index 832fc89..45bb00b 100644 --- a/dimelo/plot_reads.py +++ b/dimelo/plot_reads.py @@ -1,7 +1,7 @@ """Single-read plotting entrypoints and legacy axis routing helpers.""" -from collections.abc import Sequence import math +from collections.abc import Sequence from pathlib import Path import pandas as pd @@ -148,7 +148,9 @@ def plot_reads( regions_5to3prime=regions_5to3prime, ) if y_axis_mode not in plot_table.columns: - raise ValueError(f"Unsupported y_axis {y_axis_mode!r}. Use one of: {sorted(plot_table.columns)}") + raise ValueError( + f"Unsupported y_axis {y_axis_mode!r}. Use one of: {sorted(plot_table.columns)}" + ) axis = _legacy_single_read_axis_spec( relative=relative, regions_5to3prime=regions_5to3prime, diff --git a/dimelo/plotting.py b/dimelo/plotting.py index 7fc2392..fa46950 100644 --- a/dimelo/plotting.py +++ b/dimelo/plotting.py @@ -55,7 +55,9 @@ def validate_axis_spec(axis: AxisSpec, *, plot_family: str) -> None: raise ValueError("AxisSpec.orientation must be 'genomic' or 'region_5to3'.") if axis.coordinate_mode not in {"fixed_window", "segment_map"}: - raise ValueError("AxisSpec.coordinate_mode must be 'fixed_window' or 'segment_map'.") + raise ValueError( + "AxisSpec.coordinate_mode must be 'fixed_window' or 'segment_map'." + ) if axis.coordinate_mode == "segment_map" and not axis.segments: raise ValueError("segment_map requires segments.") @@ -67,14 +69,19 @@ def validate_axis_spec(axis: AxisSpec, *, plot_family: str) -> None: if axis.upstream_bp is None or axis.downstream_bp is None: raise ValueError("fixed_window requires upstream_bp and downstream_bp.") if axis.upstream_bp < 0 or axis.downstream_bp < 0: - raise ValueError("fixed_window upstream_bp and downstream_bp must be non-negative.") - - if plot_family == "single_read_raster" and axis.segments: - if any(segment.mode == "scaled" for segment in axis.segments): raise ValueError( - "single_read_raster plots must preserve coordinates and cannot use scaled segments." + "fixed_window upstream_bp and downstream_bp must be non-negative." ) + if ( + plot_family == "single_read_raster" + and axis.segments + and any(segment.mode == "scaled" for segment in axis.segments) + ): + raise ValueError( + "single_read_raster plots must preserve coordinates and cannot use scaled segments." + ) + def validate_aggregation_spec(spec: AggregationSpec) -> None: if spec.weighting not in {"equal_region", "equal_observation", "coverage_weighted"}: @@ -83,7 +90,12 @@ def validate_aggregation_spec(spec: AggregationSpec) -> None: if spec.within_region_summary not in {"mean", "fraction", "density"}: raise ValueError("Unsupported within_region_summary.") - if spec.signal_normalization not in {"none", "per_region", "global", "control_regions"}: + if spec.signal_normalization not in { + "none", + "per_region", + "global", + "control_regions", + }: raise ValueError("Unsupported signal_normalization.") if spec.layout not in {"concatenated", "faceted"}: @@ -91,7 +103,11 @@ def validate_aggregation_spec(spec: AggregationSpec) -> None: def _region_contrast_grouping_key(result, position_table: pd.DataFrame) -> str: - available_keys = [column for column in ("sample_id", "condition") if column in position_table.columns] + available_keys = [ + column + for column in ("sample_id", "condition") + if column in position_table.columns + ] if not available_keys: raise ValueError( "region contrast plotting requires position_table to include sample_id or condition." @@ -177,7 +193,9 @@ def _ordered_non_null_values(table: pd.DataFrame, column: str) -> list[object]: return table.loc[table[column].notna(), column].drop_duplicates().tolist() -def _filter_motif_table(table: pd.DataFrame, motifs: list[str] | None, *, owner: str) -> pd.DataFrame: +def _filter_motif_table( + table: pd.DataFrame, motifs: list[str] | None, *, owner: str +) -> pd.DataFrame: _require_columns(table, ("motif",), owner) if motifs is None: return table.copy() @@ -191,18 +209,26 @@ def _filter_motif_table(table: pd.DataFrame, motifs: list[str] | None, *, owner: def _validate_region_discovery_result(result) -> None: if result is None: raise ValueError("plotting helpers require a RegionDiscoveryResult.") - if not hasattr(result, "windows") or not hasattr(result, "hits") or not hasattr(result, "metadata"): + if ( + not hasattr(result, "windows") + or not hasattr(result, "hits") + or not hasattr(result, "metadata") + ): raise TypeError("plotting helpers require a RegionDiscoveryResult-like object.") -def _select_discovery_score_column(windows: pd.DataFrame, score_column: str | None) -> str: +def _select_discovery_score_column( + windows: pd.DataFrame, score_column: str | None +) -> str: if score_column is not None: if score_column not in windows.columns: raise ValueError(f"Unknown discovery score column: {score_column}") return score_column if "score_value" in windows.columns or windows.empty: return "score_value" - raise ValueError("Could not infer a discovery score column from RegionDiscoveryResult.windows.") + raise ValueError( + "Could not infer a discovery score column from RegionDiscoveryResult.windows." + ) def _empty_discovery_scan_table(score_column: str) -> pd.DataFrame: @@ -273,12 +299,16 @@ def _relative_position(position: float, anchor: float) -> float: return float(position) - float(anchor) -def _orient_position(relative_position: float, region_strand: str, orientation: str) -> float: +def _orient_position( + relative_position: float, region_strand: str, orientation: str +) -> float: if orientation != "region_5to3": return relative_position if region_strand not in {"+", "-"}: - raise ValueError("region_5to3 fixed_window prep requires region_strand values of '+' or '-'.") + raise ValueError( + "region_5to3 fixed_window prep requires region_strand values of '+' or '-'." + ) if region_strand == "-": return -relative_position @@ -294,20 +324,32 @@ def _prepare_fixed_window_plot_data( region_strand_column: str | None = None, ) -> tuple[pd.DataFrame, pd.DataFrame]: if axis.coordinate_mode != "fixed_window": - raise ValueError("fixed_window prep only supports coordinate_mode='fixed_window'.") + raise ValueError( + "fixed_window prep only supports coordinate_mode='fixed_window'." + ) _require_columns(table, (position_column, anchor_column), "plot_table") if axis.orientation == "region_5to3": if region_strand_column is None: - raise ValueError("region_5to3 fixed_window prep requires region_strand_column.") + raise ValueError( + "region_5to3 fixed_window prep requires region_strand_column." + ) _require_columns(table, (region_strand_column,), "plot_table") plot_table = table.copy() - relative_position = plot_table[position_column].astype(float) - plot_table[anchor_column].astype(float) + relative_position = plot_table[position_column].astype(float) - plot_table[ + anchor_column + ].astype(float) if axis.orientation == "region_5to3": plot_table["plot_x"] = [ - _orient_position(relative_position=rel, region_strand=strand, orientation=axis.orientation) - for rel, strand in zip(relative_position, plot_table[region_strand_column], strict=True) + _orient_position( + relative_position=rel, + region_strand=strand, + orientation=axis.orientation, + ) + for rel, strand in zip( + relative_position, plot_table[region_strand_column], strict=True + ) ] else: plot_table["plot_x"] = relative_position @@ -329,7 +371,9 @@ def _prepare_fixed_window_plot_data( def _build_segment_axis_table(segments: list[SegmentSpec]) -> pd.DataFrame: segment_id_counts = Counter(segment.segment_id for segment in segments) - duplicate_segment_ids = sorted(segment_id for segment_id, count in segment_id_counts.items() if count > 1) + duplicate_segment_ids = sorted( + segment_id for segment_id, count in segment_id_counts.items() if count > 1 + ) if duplicate_segment_ids: raise ValueError( "segment_map axis.segments contains duplicate segment_id values: " @@ -350,7 +394,11 @@ def _build_segment_axis_table(segments: list[SegmentSpec]) -> pd.DataFrame: "segment_map axis.segments contains invalid bins values: " f"{segment.segment_id} has bins={segment.bins!r}." ) - if segment.mode == "scaled" and segment.bins is None and segment.end_ref <= segment.start_ref: + if ( + segment.mode == "scaled" + and segment.bins is None + and segment.end_ref <= segment.start_ref + ): raise ValueError( "segment_map axis.segments contains invalid scaled span values: " f"{segment.segment_id} has start_ref={segment.start_ref!r} and end_ref={segment.end_ref!r}." @@ -361,7 +409,11 @@ def _build_segment_axis_table(segments: list[SegmentSpec]) -> pd.DataFrame: f"{segment.segment_id} has start_ref={segment.start_ref!r} and end_ref={segment.end_ref!r}." ) - span = segment.bins if segment.bins is not None else segment.end_ref - segment.start_ref + span = ( + segment.bins + if segment.bins is not None + else segment.end_ref - segment.start_ref + ) rows.append( { "segment_id": segment.segment_id, @@ -411,7 +463,8 @@ def _prepare_segment_map_plot_data( } ) axis_lookup[_SEGMENT_AXIS_INTERNAL_SEGMENT_SPAN] = ( - axis_lookup[_SEGMENT_AXIS_INTERNAL_PLOT_END] - axis_lookup[_SEGMENT_AXIS_INTERNAL_PLOT_START] + axis_lookup[_SEGMENT_AXIS_INTERNAL_PLOT_END] + - axis_lookup[_SEGMENT_AXIS_INTERNAL_PLOT_START] ) plot_table = plot_table.merge( axis_lookup, @@ -421,34 +474,46 @@ def _prepare_segment_map_plot_data( ) unknown_segment_mask = plot_table[_SEGMENT_AXIS_INTERNAL_PLOT_START].isna() if unknown_segment_mask.any(): - unknown_segment_ids = sorted(plot_table.loc[unknown_segment_mask, segment_id_column].astype(str).unique()) + unknown_segment_ids = sorted( + plot_table.loc[unknown_segment_mask, segment_id_column].astype(str).unique() + ) raise ValueError( "segment_map plotting received unknown segment_id values: " f"{', '.join(unknown_segment_ids)}." ) - segment_positions = pd.to_numeric(plot_table[segment_position_column], errors="raise") + segment_positions = pd.to_numeric( + plot_table[segment_position_column], errors="raise" + ) missing_position_mask = segment_positions.isna() if missing_position_mask.any(): - invalid_rows = plot_table.loc[missing_position_mask, [segment_id_column, segment_position_column]] + invalid_rows = plot_table.loc[ + missing_position_mask, [segment_id_column, segment_position_column] + ] raise ValueError( "segment_position_column contains missing or NaN values. " f"Invalid rows: {invalid_rows.to_dict(orient='records')}." ) - invalid_position_mask = ( - (segment_positions < 0) | (segment_positions >= plot_table[_SEGMENT_AXIS_INTERNAL_SEGMENT_SPAN]) + invalid_position_mask = (segment_positions < 0) | ( + segment_positions >= plot_table[_SEGMENT_AXIS_INTERNAL_SEGMENT_SPAN] ) if invalid_position_mask.any(): - invalid_rows = plot_table.loc[invalid_position_mask, [segment_id_column, segment_position_column]].copy() - invalid_rows["segment_span"] = plot_table.loc[invalid_position_mask, _SEGMENT_AXIS_INTERNAL_SEGMENT_SPAN].values + invalid_rows = plot_table.loc[ + invalid_position_mask, [segment_id_column, segment_position_column] + ].copy() + invalid_rows["segment_span"] = plot_table.loc[ + invalid_position_mask, _SEGMENT_AXIS_INTERNAL_SEGMENT_SPAN + ].values raise ValueError( "segment_position_column values must stay within the declared segment span " "for each segment." f" Invalid rows: {invalid_rows.to_dict(orient='records')}." ) - plot_table["plot_x"] = plot_table[_SEGMENT_AXIS_INTERNAL_PLOT_START] + segment_positions + plot_table["plot_x"] = ( + plot_table[_SEGMENT_AXIS_INTERNAL_PLOT_START] + segment_positions + ) plot_table = plot_table.drop( columns=[ _SEGMENT_AXIS_INTERNAL_SEGMENT_ID, @@ -473,7 +538,9 @@ def _prepare_region_contrast_position_table( "position_table", ) summary_region_ids = result.summary["region_id"].dropna().astype(str) - filtered = position_table[position_table["region_id"].astype(str).isin(summary_region_ids)].copy() + filtered = position_table[ + position_table["region_id"].astype(str).isin(summary_region_ids) + ].copy() if filtered.empty: raise ValueError( "position_table does not contain any region_id values present in the contrast result." @@ -494,11 +561,21 @@ def _prepare_region_contrast_value_modes( numerator = position_table.loc[numerator_mask].copy() denominator = position_table.loc[denominator_mask].copy() if numerator.empty or denominator.empty: - raise ValueError("position_table does not contain rows for both contrast sides.") + raise ValueError( + "position_table does not contain rows for both contrast sides." + ) join_keys = ["region_id", "position", "anchor", "region_strand"] - numerator = numerator.loc[:, join_keys + ["value"]].groupby(join_keys, as_index=False, sort=False).mean(numeric_only=True) - denominator = denominator.loc[:, join_keys + ["value"]].groupby(join_keys, as_index=False, sort=False).mean(numeric_only=True) + numerator = ( + numerator.loc[:, join_keys + ["value"]] + .groupby(join_keys, as_index=False, sort=False) + .mean(numeric_only=True) + ) + denominator = ( + denominator.loc[:, join_keys + ["value"]] + .groupby(join_keys, as_index=False, sort=False) + .mean(numeric_only=True) + ) coordinate_match = numerator.loc[:, join_keys].merge( denominator.loc[:, join_keys], @@ -507,7 +584,9 @@ def _prepare_region_contrast_value_modes( indicator=True, ) if not (coordinate_match["_merge"] == "both").all(): - mismatched_rows = coordinate_match.loc[coordinate_match["_merge"] != "both", join_keys + ["_merge"]].copy() + mismatched_rows = coordinate_match.loc[ + coordinate_match["_merge"] != "both", join_keys + ["_merge"] + ].copy() raise ValueError( "position_table contains mismatched coordinates between contrast sides. " f"Mismatched rows: {mismatched_rows.to_dict(orient='records')}." @@ -520,11 +599,15 @@ def _prepare_region_contrast_value_modes( how="inner", ) if paired.empty: - raise ValueError("Unable to compute delta because numerator and denominator positions do not align.") + raise ValueError( + "Unable to compute delta because numerator and denominator positions do not align." + ) if "rank" in result.summary.columns: _require_columns(result.summary, ("region_id", "rank"), "result.summary") - rank_table = result.summary.loc[:, ["region_id", "rank"]].drop_duplicates(subset=["region_id"]) + rank_table = result.summary.loc[:, ["region_id", "rank"]].drop_duplicates( + subset=["region_id"] + ) else: rank_table = None @@ -533,12 +616,16 @@ def _attach_rank(table: pd.DataFrame) -> pd.DataFrame: return table return table.merge(rank_table, on="region_id", how="left") - numerator_table = numerator.loc[:, ["region_id", "position", "anchor", "value", "region_strand"]].copy() + numerator_table = numerator.loc[ + :, ["region_id", "position", "anchor", "value", "region_strand"] + ].copy() numerator_table["value_mode"] = "numerator" numerator_table[grouping_key] = "numerator" numerator_table = _attach_rank(numerator_table) - denominator_table = denominator.loc[:, ["region_id", "position", "anchor", "value", "region_strand"]].copy() + denominator_table = denominator.loc[ + :, ["region_id", "position", "anchor", "value", "region_strand"] + ].copy() denominator_table["value_mode"] = "denominator" denominator_table[grouping_key] = "denominator" denominator_table = _attach_rank(denominator_table) @@ -554,16 +641,34 @@ def _attach_rank(table: pd.DataFrame) -> pd.DataFrame: "value_denominator", ], ].copy() - delta_table["value"] = delta_table["value_numerator"] - delta_table["value_denominator"] + delta_table["value"] = ( + delta_table["value_numerator"] - delta_table["value_denominator"] + ) delta_table[grouping_key] = "delta" delta_table["value_mode"] = "delta" delta_table = delta_table.loc[ :, - ["region_id", grouping_key, "position", "anchor", "value", "region_strand", "value_mode"] + [ + "region_id", + grouping_key, + "position", + "anchor", + "value", + "region_strand", + "value_mode", + ], ] delta_table = _attach_rank(delta_table) - ordered_columns = ["region_id", grouping_key, "position", "anchor", "value", "region_strand", "value_mode"] + ordered_columns = [ + "region_id", + grouping_key, + "position", + "anchor", + "value", + "region_strand", + "value_mode", + ] if rank_table is not None: ordered_columns.append("rank") @@ -603,7 +708,9 @@ def prepare_region_contrast_profile_data( if value_mode != "all": if value_mode not in {"numerator", "denominator", "delta"}: raise ValueError("Unsupported region contrast value_mode.") - contrast_table = contrast_table.loc[contrast_table["value_mode"] == value_mode].copy() + contrast_table = contrast_table.loc[ + contrast_table["value_mode"] == value_mode + ].copy() prepared = prepare_aggregate_plot_data( contrast_table, @@ -640,7 +747,8 @@ def prepare_region_contrast_heatmap_data( _require_columns(result.summary, ("region_id", "rank"), "result.summary") plot_region_ids = ( - profile_payload["plot_table"].loc[:, ["region_id"]] + profile_payload["plot_table"] + .loc[:, ["region_id"]] .drop_duplicates() .reset_index(drop=True) ) @@ -658,7 +766,11 @@ def prepare_region_contrast_heatmap_data( ), rank_count=("rank", lambda values: pd.Series(values).dropna().nunique()), ) - conflicting_rank_ids = sorted(summary_ranks.loc[summary_ranks["rank_count"] > 1, "region_id"].astype(str).unique()) + conflicting_rank_ids = sorted( + summary_ranks.loc[summary_ranks["rank_count"] > 1, "region_id"] + .astype(str) + .unique() + ) if conflicting_rank_ids: raise ValueError( "result.summary must provide exactly one rank value per plotted region. " @@ -666,13 +778,19 @@ def prepare_region_contrast_heatmap_data( ) row_order = summary_ranks.loc[:, ["region_id", "rank"]].copy() - missing_rank_ids = sorted(summary_ranks.loc[summary_ranks["rank_count"] == 0, "region_id"].astype(str).unique()) + missing_rank_ids = sorted( + summary_ranks.loc[summary_ranks["rank_count"] == 0, "region_id"] + .astype(str) + .unique() + ) if missing_rank_ids: raise ValueError( "result.summary does not provide rank values for all plotted regions. " f"Missing region_id values: {', '.join(missing_rank_ids)}." ) - row_order = row_order.sort_values(["rank", "region_id"], kind="stable").reset_index(drop=True) + row_order = row_order.sort_values(["rank", "region_id"], kind="stable").reset_index( + drop=True + ) row_order["row_order"] = range(len(row_order)) plot_table = profile_payload["plot_table"].merge( @@ -680,7 +798,9 @@ def prepare_region_contrast_heatmap_data( on="region_id", how="left", ) - plot_table = plot_table.sort_values(["row_order", "value_mode", "position"], kind="stable").reset_index(drop=True) + plot_table = plot_table.sort_values( + ["row_order", "value_mode", "position"], kind="stable" + ).reset_index(drop=True) profile_payload["plot_table"] = plot_table profile_payload["metadata"] = { @@ -745,7 +865,9 @@ def prepare_global_analysis_summary_data( motif_values = sample_summary["motif"].drop_duplicates().tolist() if aggregate_conditions: condition_summary = ( - sample_summary.groupby(["condition", "motif"], as_index=False, sort=False) + sample_summary.groupby( + ["condition", "motif"], as_index=False, sort=False + ) .agg( global_fraction_mean=("global_fraction", "mean"), global_fraction_median=("global_fraction", "median"), @@ -851,7 +973,9 @@ def prepare_global_analysis_window_data( } window_table = window_table.copy() - windows_contig_column = _discovery_contig_column(window_table, owner="result.windows") + windows_contig_column = _discovery_contig_column( + window_table, owner="result.windows" + ) window_table["contig"] = window_table[windows_contig_column] if contigs is not None: @@ -862,7 +986,9 @@ def prepare_global_analysis_window_data( else: contig_order = window_table["contig"].drop_duplicates().tolist() - window_table["window_midpoint"] = (window_table["start"] + window_table["end"]) / 2.0 + window_table["window_midpoint"] = ( + window_table["start"] + window_table["end"] + ) / 2.0 window_table = _sort_discovery_table( window_table, contig_order=contig_order, @@ -939,7 +1065,14 @@ def prepare_region_discovery_scan_data( if windows.empty: empty_scan = _empty_discovery_scan_table(active_score_column) empty_hits = pd.DataFrame( - columns=["window_id", "contig", "start", "end", "strand", active_score_column] + columns=[ + "window_id", + "contig", + "start", + "end", + "strand", + active_score_column, + ] ) return { "scan_table": empty_scan, @@ -969,7 +1102,9 @@ def prepare_region_discovery_scan_data( windows = windows.loc[windows["contig"].isin(contigs)].copy() hits = hits.loc[hits["contig"].isin(contigs)].copy() if windows.empty: - raise ValueError("Requested contigs are not present in RegionDiscoveryResult.windows.") + raise ValueError( + "Requested contigs are not present in RegionDiscoveryResult.windows." + ) contig_order = list(contigs) else: contig_order = windows["contig"].drop_duplicates().tolist() @@ -993,7 +1128,9 @@ def prepare_region_discovery_scan_data( windows["window_midpoint"] = (windows["start"] + windows["end"]) / 2.0 windows["is_hit"] = windows["window_id"].isin(hit_window_ids) - scan_table = windows if include_all_windows else windows.loc[windows["is_hit"]].copy() + scan_table = ( + windows if include_all_windows else windows.loc[windows["is_hit"]].copy() + ) scan_table = _sort_discovery_table( scan_table, contig_order=contig_order, @@ -1034,7 +1171,9 @@ def prepare_region_discovery_hit_context_data( ) -> dict[str, pd.DataFrame | dict[str, object]]: _validate_region_discovery_result(result) if padding_bp is not None: - raise ValueError("padding_bp is not supported for region discovery hit context prep.") + raise ValueError( + "padding_bp is not supported for region discovery hit context prep." + ) if padding_windows is not None and padding_windows < 0: raise ValueError("padding_windows must be non-negative.") @@ -1086,7 +1225,9 @@ def prepare_region_discovery_hit_context_data( ) if hit_ids is not None: - selected_hits = hits.loc[hits["window_id"].isin(hit_ids)].copy().reset_index(drop=True) + selected_hits = ( + hits.loc[hits["window_id"].isin(hit_ids)].copy().reset_index(drop=True) + ) else: selected_hits, selection_mode = _select_region_discovery_hits(hits, top_n=top_n) @@ -1143,7 +1284,7 @@ def prepare_region_discovery_hit_context_data( end_index = min(len(contig_windows), hit_position + padding + 1) context = contig_windows.iloc[start_index:end_index].copy() context["selected_hit_id"] = hit_window_id - context["selected_hit_rank"] = getattr(hit, "rank") if has_rank else np.nan + context["selected_hit_rank"] = hit.rank if has_rank else np.nan context["relative_window_offset"] = np.arange( start_index - hit_position, end_index - hit_position ) @@ -1212,7 +1353,9 @@ def prepare_aggregate_plot_data( if axis.coordinate_mode == "segment_map": if segment_id_column is None or segment_position_column is None: - raise ValueError("segment_map plotting requires segment_id_column and segment_position_column.") + raise ValueError( + "segment_map plotting requires segment_id_column and segment_position_column." + ) plot_table, axis_table = _prepare_segment_map_plot_data( table, axis=axis, @@ -1221,7 +1364,9 @@ def prepare_aggregate_plot_data( ) else: if position_column is None or anchor_column is None: - raise ValueError("fixed_window plotting requires position_column and anchor_column.") + raise ValueError( + "fixed_window plotting requires position_column and anchor_column." + ) plot_table, axis_table = _prepare_fixed_window_plot_data( table, axis=axis, @@ -1244,23 +1389,31 @@ def prepare_aggregate_plot_data( return {"plot_table": plot_table, "axis_table": axis_table, "metadata": metadata} -def prepare_cluster_distribution_bar_data(cluster_distribution: pd.DataFrame) -> pd.DataFrame: +def prepare_cluster_distribution_bar_data( + cluster_distribution: pd.DataFrame, +) -> pd.DataFrame: _require_columns( cluster_distribution, ("sample_id", "condition", "cluster", "count", "fraction"), "cluster_distribution", ) if cluster_distribution.empty: - return cluster_distribution.loc[:, ["sample_id", "condition", "cluster", "count", "fraction"]].copy() + return cluster_distribution.loc[ + :, ["sample_id", "condition", "cluster", "count", "fraction"] + ].copy() return ( - cluster_distribution.loc[:, ["sample_id", "condition", "cluster", "count", "fraction"]] + cluster_distribution.loc[ + :, ["sample_id", "condition", "cluster", "count", "fraction"] + ] .sort_values(["sample_id", "condition", "cluster"], kind="stable") .reset_index(drop=True) ) -def prepare_cluster_distribution_heatmap_data(condition_distribution: pd.DataFrame) -> pd.DataFrame: +def prepare_cluster_distribution_heatmap_data( + condition_distribution: pd.DataFrame, +) -> pd.DataFrame: _require_columns( condition_distribution, ("condition", "cluster", "fraction"), @@ -1278,7 +1431,9 @@ def prepare_cluster_distribution_heatmap_data(condition_distribution: pd.DataFra fill_value=0.0, ) .sort_index(axis=0) - .reindex(sorted(condition_distribution["cluster"].unique()), axis=1, fill_value=0.0) + .reindex( + sorted(condition_distribution["cluster"].unique()), axis=1, fill_value=0.0 + ) .reset_index() ) heatmap.columns.name = None @@ -1291,7 +1446,9 @@ def prepare_shared_cluster_distribution_data( ) -> dict[str, pd.DataFrame | dict[str, object]]: _validate_shared_cluster_result(result) - sample_distribution = prepare_cluster_distribution_bar_data(result.cluster_distribution) + sample_distribution = prepare_cluster_distribution_bar_data( + result.cluster_distribution + ) _require_columns( result.condition_distribution, @@ -1345,7 +1502,9 @@ def prepare_shared_cluster_distribution_data( "mode": result.model.mode, "cluster_labels": list(result.model.cluster_labels), "has_distribution_change": not distribution_change.empty, - "change_condition_order": distribution_change["condition"].drop_duplicates().tolist(), + "change_condition_order": distribution_change["condition"] + .drop_duplicates() + .tolist(), } return { "sample_distribution": sample_distribution, @@ -1375,13 +1534,21 @@ def prepare_shared_cluster_profile_data( "Requested features are not present in cluster_profiles: " f"{', '.join(missing)}" ) - requested_features = [feature for feature in feature_names if feature in features] + requested_features = [ + feature for feature in feature_names if feature in features + ] - _require_columns(cluster_profiles, ("cluster", "count", *feature_names), "result.cluster_profiles") + _require_columns( + cluster_profiles, + ("cluster", "count", *feature_names), + "result.cluster_profiles", + ) if cluster_profiles.empty: return { - "profile_table": pd.DataFrame(columns=["cluster", "feature", "value", "count"]), + "profile_table": pd.DataFrame( + columns=["cluster", "feature", "value", "count"] + ), "metadata": { "feature_names": requested_features, "cluster_labels": list(result.model.cluster_labels), @@ -1410,7 +1577,9 @@ def prepare_shared_cluster_region_data( ) -> dict[str, pd.DataFrame | dict[str, object]]: _validate_shared_cluster_result(result) if result.region_summaries is None: - raise ValueError("SharedClusterResult.region_summaries is required for region plotting.") + raise ValueError( + "SharedClusterResult.region_summaries is required for region plotting." + ) _require_columns( result.region_summaries, @@ -1427,7 +1596,9 @@ def prepare_shared_cluster_region_data( if aggregate_conditions and not region_table.empty: condition_region_table = ( - region_table.groupby(["region_id", "condition", "cluster"], as_index=False, sort=False) + region_table.groupby( + ["region_id", "condition", "cluster"], as_index=False, sort=False + ) .agg( count=("count", "sum"), fraction_mean=("fraction", "mean"), @@ -1462,7 +1633,14 @@ def prepare_shared_cluster_region_data( _READ_CLUSTER_ASSOCIATION_VALUE_MODES = {"fraction", "log2_enrichment"} -_READ_CLUSTER_ASSOCIATION_REGION_COLUMNS = ("region_id", "chrom", "chromosome", "start", "end", "strand") +_READ_CLUSTER_ASSOCIATION_REGION_COLUMNS = ( + "region_id", + "chrom", + "chromosome", + "start", + "end", + "strand", +) _READ_CLUSTER_ASSOCIATION_LEGACY_EXCLUDE_COLUMNS = { "count", "fraction", @@ -1513,12 +1691,16 @@ def _synthesize_read_cluster_region_id(table: pd.DataFrame, *, owner: str) -> pd def _ensure_read_cluster_region_ids(table: pd.DataFrame, *, owner: str) -> pd.DataFrame: normalized = table.copy() if "region_id" not in normalized.columns: - normalized["region_id"] = _synthesize_read_cluster_region_id(normalized, owner=owner) + normalized["region_id"] = _synthesize_read_cluster_region_id( + normalized, owner=owner + ) return normalized missing_region_ids = normalized["region_id"].isna() if missing_region_ids.any(): - replacement_ids = _synthesize_read_cluster_region_id(normalized.loc[missing_region_ids], owner=owner) + replacement_ids = _synthesize_read_cluster_region_id( + normalized.loc[missing_region_ids], owner=owner + ) normalized.loc[missing_region_ids, "region_id"] = replacement_ids normalized["region_id"] = normalized["region_id"].astype(str) return normalized @@ -1556,8 +1738,14 @@ def _infer_read_cluster_columns(table: pd.DataFrame) -> list[object]: for column in _READ_CLUSTER_ASSOCIATION_REGION_COLUMNS if column in table.columns } - excluded_columns.update(col for col in _READ_CLUSTER_ASSOCIATION_LEGACY_EXCLUDE_COLUMNS if col in table.columns) - cluster_columns = [column for column in table.columns if column not in excluded_columns] + excluded_columns.update( + col + for col in _READ_CLUSTER_ASSOCIATION_LEGACY_EXCLUDE_COLUMNS + if col in table.columns + ) + cluster_columns = [ + column for column in table.columns if column not in excluded_columns + ] if "region_id" in cluster_columns: cluster_columns.remove("region_id") return cluster_columns @@ -1575,7 +1763,9 @@ def _normalize_legacy_read_cluster_region_association( cluster_columns = _infer_read_cluster_columns(table) if not cluster_columns: - raise ValueError("Could not infer cluster columns from the legacy association table.") + raise ValueError( + "Could not infer cluster columns from the legacy association table." + ) normalized = _ensure_read_cluster_region_ids(table, owner="association_table") if normalized["region_id"].isna().any(): @@ -1586,7 +1776,9 @@ def _normalize_legacy_read_cluster_region_association( if "total_reads" not in normalized.columns: normalized["total_reads"] = normalized.loc[:, cluster_columns].sum(axis=1) if (normalized["total_reads"] <= 0).any(): - raise ValueError("Legacy association rows must have positive total_reads or cluster counts.") + raise ValueError( + "Legacy association rows must have positive total_reads or cluster counts." + ) id_vars = [column for column in normalized.columns if column not in cluster_columns] melted = normalized.melt( @@ -1635,15 +1827,23 @@ def _region_coordinate_table_for_association(table: pd.DataFrame) -> pd.DataFram if has_chrom and has_start_end: chrom_col = "chrom" if "chrom" in table.columns else "chromosome" coords = ( - table.loc[:, ["region_id", chrom_col, "start", "end"] + (["strand"] if "strand" in table.columns else [])] + table.loc[ + :, + ["region_id", chrom_col, "start", "end"] + + (["strand"] if "strand" in table.columns else []), + ] .drop_duplicates(subset=["region_id"]) .copy() ) coords = coords.rename(columns={chrom_col: "chrom"}) if "strand" not in coords.columns: coords["strand"] = "." - coords["start"] = pd.to_numeric(coords["start"], errors="coerce").fillna(-1).astype(int) - coords["end"] = pd.to_numeric(coords["end"], errors="coerce").fillna(-1).astype(int) + coords["start"] = ( + pd.to_numeric(coords["start"], errors="coerce").fillna(-1).astype(int) + ) + coords["end"] = ( + pd.to_numeric(coords["end"], errors="coerce").fillna(-1).astype(int) + ) return coords.loc[:, ["region_id", "chrom", "start", "end", "strand"]] parsed = regions["region_id"].map(_parse_region_id_components) @@ -1682,17 +1882,16 @@ def _read_cluster_region_association_region_order( coords = _region_coordinate_table_for_association(table) coords = coords.copy() coords["chrom_sort"] = coords["chrom"].map(_chromosome_sort_key) - coords = coords.sort_values(["chrom_sort", "start", "end", "region_id"], kind="stable") + coords = coords.sort_values( + ["chrom_sort", "start", "end", "region_id"], kind="stable" + ) if region_sort == "genomic": return coords["region_id"].tolist() if region_sort == "association_strength": grouped = table.groupby("region_id", sort=False)["value"] - if strength_aggregate == "mean": - strength = grouped.mean() - else: - strength = grouped.max() + strength = grouped.mean() if strength_aggregate == "mean" else grouped.max() coords = coords.merge( strength.rename("association_strength"), left_on="region_id", @@ -1706,7 +1905,60 @@ def _read_cluster_region_association_region_order( ) return coords["region_id"].tolist() - raise ValueError("region_sort must be 'input', 'genomic', or 'association_strength'.") + if region_sort == "cluster_fraction": + # Assign each region to its dominant cluster, then rank by dominant fraction. + cluster_order = _read_cluster_region_association_cluster_order(table) + cluster_rank = {cluster: index for index, cluster in enumerate(cluster_order)} + dominant_rows = table.copy() + dominant_rows["cluster_rank"] = ( + dominant_rows["cluster"] + .map(cluster_rank) + .fillna(len(cluster_order)) + .astype(int) + ) + dominant_rows["value"] = pd.to_numeric( + dominant_rows["value"], errors="coerce" + ).fillna(0.0) + dominant_rows = dominant_rows.sort_values( + ["region_id", "value", "cluster_rank"], + ascending=[True, False, True], + kind="stable", + ) + dominant_rows = dominant_rows.drop_duplicates( + subset=["region_id"], keep="first" + ) + dominant_rows = dominant_rows.rename( + columns={"cluster": "dominant_cluster", "value": "dominant_sort_value"} + ).loc[ + :, ["region_id", "dominant_cluster", "dominant_sort_value", "cluster_rank"] + ] + + coords = coords.merge(dominant_rows, on="region_id", how="left") + coords["cluster_rank"] = ( + pd.to_numeric(coords["cluster_rank"], errors="coerce") + .fillna(len(cluster_order)) + .astype(int) + ) + coords["dominant_sort_value"] = pd.to_numeric( + coords["dominant_sort_value"], errors="coerce" + ).fillna(0.0) + coords = coords.sort_values( + [ + "cluster_rank", + "dominant_sort_value", + "chrom_sort", + "start", + "end", + "region_id", + ], + ascending=[True, False, True, True, True, True], + kind="stable", + ) + return coords["region_id"].tolist() + + raise ValueError( + "region_sort must be 'cluster_fraction', 'input', 'genomic', or 'association_strength'." + ) def prepare_read_cluster_region_association_data( @@ -1714,7 +1966,7 @@ def prepare_read_cluster_region_association_data( *, value_mode: str = "fraction", top_n_regions_per_cluster: int | None = 5, - region_sort: str = "input", + region_sort: str = "cluster_fraction", association_strength_aggregate: str = "max", ) -> dict[str, pd.DataFrame | dict[str, object]]: if not isinstance(association_table, pd.DataFrame): @@ -1723,8 +1975,15 @@ def prepare_read_cluster_region_association_data( raise ValueError("value_mode must be 'fraction' or 'log2_enrichment'.") if top_n_regions_per_cluster is not None and top_n_regions_per_cluster < 0: raise ValueError("top_n_regions_per_cluster must be non-negative.") - if region_sort not in {"input", "genomic", "association_strength"}: - raise ValueError("region_sort must be 'input', 'genomic', or 'association_strength'.") + if region_sort not in { + "cluster_fraction", + "input", + "genomic", + "association_strength", + }: + raise ValueError( + "region_sort must be 'cluster_fraction', 'input', 'genomic', or 'association_strength'." + ) if association_strength_aggregate not in {"max", "mean"}: raise ValueError("association_strength_aggregate must be 'max' or 'mean'.") @@ -1741,7 +2000,9 @@ def prepare_read_cluster_region_association_data( normalized = normalized.copy() if normalized.duplicated(["region_id", "cluster"]).any(): - raise ValueError("association_table contains duplicate region and cluster rows.") + raise ValueError( + "association_table contains duplicate region and cluster rows." + ) region_order = _read_cluster_region_association_region_order( normalized, @@ -1749,9 +2010,15 @@ def prepare_read_cluster_region_association_data( strength_aggregate=association_strength_aggregate, ) cluster_order = _read_cluster_region_association_cluster_order(normalized) - normalized["region_id"] = pd.Categorical(normalized["region_id"], categories=region_order, ordered=True) - normalized["cluster"] = pd.Categorical(normalized["cluster"], categories=cluster_order, ordered=True) - normalized = normalized.sort_values(["region_id", "cluster"], kind="stable").reset_index(drop=True) + normalized["region_id"] = pd.Categorical( + normalized["region_id"], categories=region_order, ordered=True + ) + normalized["cluster"] = pd.Categorical( + normalized["cluster"], categories=cluster_order, ordered=True + ) + normalized = normalized.sort_values( + ["region_id", "cluster"], kind="stable" + ).reset_index(drop=True) normalized["region_id"] = normalized["region_id"].astype(str) normalized["cluster"] = normalized["cluster"].astype(object) @@ -1764,9 +2031,7 @@ def prepare_read_cluster_region_association_data( matrix_table.columns.name = None region_axis_table = _region_coordinate_table_for_association(normalized).copy() region_axis_table = ( - region_axis_table.set_index("region_id") - .reindex(region_order) - .reset_index() + region_axis_table.set_index("region_id").reindex(region_order).reset_index() ) region_axis_table["axis_index"] = np.arange(len(region_axis_table)) chromosome_blocks: list[dict[str, object]] = [] @@ -1806,18 +2071,28 @@ def prepare_read_cluster_region_association_data( else: top_regions_table = ( normalized.loc[:, top_columns] - .sort_values(["cluster", "value", "region_id"], ascending=[True, False, True], kind="stable") + .sort_values( + ["cluster", "value", "region_id"], + ascending=[True, False, True], + kind="stable", + ) .groupby("cluster", as_index=False, sort=False, group_keys=False) .head(top_n_regions_per_cluster) .copy() ) - top_regions_table["rank"] = top_regions_table.groupby("cluster", sort=False).cumcount() + 1 - top_regions_table = top_regions_table.sort_values(["cluster", "rank"], kind="stable").reset_index(drop=True) + top_regions_table["rank"] = ( + top_regions_table.groupby("cluster", sort=False).cumcount() + 1 + ) + top_regions_table = top_regions_table.sort_values( + ["cluster", "rank"], kind="stable" + ).reset_index(drop=True) metadata = { "plot_family": "read_cluster_region_association_heatmap", "value_mode": value_mode, - "source_format": normalized["source_format"].iloc[0] if not normalized.empty else "long_form", + "source_format": normalized["source_format"].iloc[0] + if not normalized.empty + else "long_form", "region_order": [str(value) for value in region_order], "cluster_order": cluster_order, "top_n_regions_per_cluster": top_n_regions_per_cluster, diff --git a/dimelo/plotting_matplotlib.py b/dimelo/plotting_matplotlib.py index ad9643a..2250f98 100644 --- a/dimelo/plotting_matplotlib.py +++ b/dimelo/plotting_matplotlib.py @@ -26,10 +26,14 @@ def save_figure( return output_path -def _require_payload_keys(payload: Mapping[str, object], keys: tuple[str, ...], *, owner: str) -> None: +def _require_payload_keys( + payload: Mapping[str, object], keys: tuple[str, ...], *, owner: str +) -> None: missing = [key for key in keys if key not in payload] if missing: - raise ValueError(f"{owner} payload is missing required keys: {', '.join(missing)}") + raise ValueError( + f"{owner} payload is missing required keys: {', '.join(missing)}" + ) def _require_payload_table(payload: Mapping[str, object], key: str) -> pd.DataFrame: @@ -79,14 +83,20 @@ def _make_axes(*, axes=None, n_axes: int, figsize=(8, 4)): return fig, list(created_axes.ravel()) -def _ordered_cluster_labels(metadata: Mapping[str, object], observed_clusters: list[object]) -> list[object]: +def _ordered_cluster_labels( + metadata: Mapping[str, object], observed_clusters: list[object] +) -> list[object]: cluster_labels = list(metadata.get("cluster_labels") or []) if not cluster_labels: return list(observed_clusters) observed_cluster_set = set(observed_clusters) - ordered_clusters = [cluster for cluster in cluster_labels if cluster in observed_cluster_set] - ordered_clusters.extend([cluster for cluster in observed_clusters if cluster not in cluster_labels]) + ordered_clusters = [ + cluster for cluster in cluster_labels if cluster in observed_cluster_set + ] + ordered_clusters.extend( + [cluster for cluster in observed_clusters if cluster not in cluster_labels] + ) return ordered_clusters @@ -107,7 +117,9 @@ def _prepare_region_contrast_value_mode_table( filtered = plot_table.loc[plot_table["value_mode"] == value_mode].copy() if filtered.empty: - raise ValueError(f"plot payload does not contain rows for value_mode={value_mode!r}.") + raise ValueError( + f"plot payload does not contain rows for value_mode={value_mode!r}." + ) return filtered @@ -124,8 +136,14 @@ def plot_region_contrast_profile_matplotlib( owner="plot_region_contrast_profile_matplotlib", ) plot_table = _require_payload_table(payload, "plot_table") - metadata = payload.get("metadata", {}) if isinstance(payload.get("metadata", {}), Mapping) else {} - plot_table = _prepare_region_contrast_value_mode_table(plot_table, value_mode=value_mode) + metadata = ( + payload.get("metadata", {}) + if isinstance(payload.get("metadata", {}), Mapping) + else {} + ) + plot_table = _prepare_region_contrast_value_mode_table( + plot_table, value_mode=value_mode + ) fig, ax = _make_axis(ax=ax, figsize=(8, 4)) @@ -144,7 +162,11 @@ def plot_region_contrast_profile_matplotlib( ax.plot(grouped[x_column], grouped["value"], marker="o", linewidth=1.5) axis_table = payload.get("axis_table") - if isinstance(axis_table, pd.DataFrame) and not axis_table.empty and {"axis_min", "axis_max"}.issubset(axis_table.columns): + if ( + isinstance(axis_table, pd.DataFrame) + and not axis_table.empty + and {"axis_min", "axis_max"}.issubset(axis_table.columns) + ): ax.set_xlim(axis_table["axis_min"].min(), axis_table["axis_max"].max()) ax.set_title(title or "Region contrast profile") @@ -173,7 +195,9 @@ def plot_region_contrast_heatmap_matplotlib( summary_table = payload.get("summary_table") if summary_table is not None and not isinstance(summary_table, pd.DataFrame): raise TypeError("plot payload key 'summary_table' must be a pandas DataFrame.") - plot_table = _prepare_region_contrast_value_mode_table(plot_table, value_mode=value_mode) + plot_table = _prepare_region_contrast_value_mode_table( + plot_table, value_mode=value_mode + ) fig, ax = _make_axis(ax=ax, figsize=(8, 4)) @@ -187,12 +211,16 @@ def plot_region_contrast_heatmap_matplotlib( y_column = "row_order" if "row_order" in plot_table.columns else "region_id" heatmap_table = plot_table.loc[:, [x_column, y_column, "value"]].copy() - heatmap = heatmap_table.pivot_table( - index=y_column, - columns=x_column, - values="value", - aggfunc="mean", - ).sort_index(axis=0).sort_index(axis=1) + heatmap = ( + heatmap_table.pivot_table( + index=y_column, + columns=x_column, + values="value", + aggfunc="mean", + ) + .sort_index(axis=0) + .sort_index(axis=1) + ) image = ax.imshow( heatmap.to_numpy(), @@ -203,7 +231,10 @@ def plot_region_contrast_heatmap_matplotlib( ax.figure.colorbar(image, ax=ax, label="value") if y_column == "row_order": - if isinstance(summary_table, pd.DataFrame) and {"region_id", "row_order"}.issubset(summary_table.columns): + if isinstance(summary_table, pd.DataFrame) and { + "region_id", + "row_order", + }.issubset(summary_table.columns): summary_lookup = ( summary_table.loc[:, ["region_id", "row_order"]] .drop_duplicates() @@ -226,7 +257,9 @@ def plot_region_contrast_heatmap_matplotlib( ax.set_ylabel("region") ax.set_xticks(range(len(heatmap.columns))) - ax.set_xticklabels([str(value) for value in heatmap.columns.tolist()], rotation=45, ha="right") + ax.set_xticklabels( + [str(value) for value in heatmap.columns.tolist()], rotation=45, ha="right" + ) ax.set_title(title or "Region contrast heatmap") ax.set_xlabel("position" if x_column == "position" else x_column) @@ -246,9 +279,16 @@ def plot_region_discovery_scan_matplotlib( ) scan_table = _require_payload_table(payload, "scan_table") hit_table = _require_payload_table(payload, "hit_table") - metadata = payload.get("metadata", {}) if isinstance(payload.get("metadata", {}), Mapping) else {} + metadata = ( + payload.get("metadata", {}) + if isinstance(payload.get("metadata", {}), Mapping) + else {} + ) score_column = str(metadata.get("score_column") or "score_value") - contigs = list(metadata.get("contig_order") or scan_table.get("contig", pd.Series(dtype="object")).dropna().unique()) + contigs = list( + metadata.get("contig_order") + or scan_table.get("contig", pd.Series(dtype="object")).dropna().unique() + ) fig, axes = _make_axes(axes=axes, n_axes=len(contigs) or 1, figsize=(8, 3)) @@ -268,15 +308,21 @@ def plot_region_discovery_scan_matplotlib( marker="o", linewidth=1.5, ) - contig_hits = hit_table.loc[hit_table["contig"] == contig] if not hit_table.empty else hit_table + contig_hits = ( + hit_table.loc[hit_table["contig"] == contig] + if not hit_table.empty + else hit_table + ) if not contig_hits.empty and {"start", "end"}.issubset(contig_hits.columns): for _, hit in contig_hits.iterrows(): - ax.axvspan(float(hit["start"]), float(hit["end"]), color="tab:red", alpha=0.15) + ax.axvspan( + float(hit["start"]), float(hit["end"]), color="tab:red", alpha=0.15 + ) ax.set_title(str(contig)) ax.set_xlabel("Window midpoint") ax.set_ylabel(score_column.replace("_", " ").title()) - for ax in axes[len(contigs):]: + for ax in axes[len(contigs) :]: ax.set_visible(False) if title: @@ -297,10 +343,17 @@ def plot_region_discovery_hit_context_matplotlib( ) context_table = _require_payload_table(payload, "context_table") selected_hits = _require_payload_table(payload, "selected_hits") - metadata = payload.get("metadata", {}) if isinstance(payload.get("metadata", {}), Mapping) else {} + metadata = ( + payload.get("metadata", {}) + if isinstance(payload.get("metadata", {}), Mapping) + else {} + ) score_column = str(metadata.get("score_column") or "score_value") hit_ids = list( - selected_hits.get("window_id", pd.Series(dtype="object")).dropna().astype(str).tolist() + selected_hits.get("window_id", pd.Series(dtype="object")) + .dropna() + .astype(str) + .tolist() ) fig, axes = _make_axes(axes=axes, n_axes=len(hit_ids) or 1, figsize=(8, 3)) @@ -313,7 +366,9 @@ def plot_region_discovery_hit_context_matplotlib( for index, hit_id in enumerate(hit_ids): ax = axes[index] - hit_context = context_table.loc[context_table["selected_hit_id"].astype(str) == hit_id] + hit_context = context_table.loc[ + context_table["selected_hit_id"].astype(str) == hit_id + ] if not hit_context.empty: ax.plot( hit_context["window_midpoint"], @@ -333,7 +388,7 @@ def plot_region_discovery_hit_context_matplotlib( ax.set_xlabel("Window midpoint") ax.set_ylabel(score_column.replace("_", " ").title()) - for ax in axes[len(hit_ids):]: + for ax in axes[len(hit_ids) :]: ax.set_visible(False) if title: @@ -348,7 +403,9 @@ def plot_shared_cluster_distribution_matplotlib( ax=None, title: str | None = None, ): - _require_payload_keys(payload, ("metadata",), owner="plot_shared_cluster_distribution_matplotlib") + _require_payload_keys( + payload, ("metadata",), owner="plot_shared_cluster_distribution_matplotlib" + ) if level not in {"sample", "condition"}: raise ValueError("level must be 'sample' or 'condition'.") @@ -366,10 +423,16 @@ def plot_shared_cluster_distribution_matplotlib( x_column = "sample_id" if level == "sample" else "condition" value_table = table.loc[:, [x_column, "cluster", "fraction"]].copy() if value_table.duplicated([x_column, "cluster"]).any(): - raise ValueError("plot payload contains duplicate cluster fractions for the same x value.") + raise ValueError( + "plot payload contains duplicate cluster fractions for the same x value." + ) x_order = _ordered_unique_values(value_table, x_column) - cluster_order = _ordered_cluster_labels(metadata, _ordered_unique_values(value_table, "cluster")) - pivot = value_table.set_index([x_column, "cluster"])["fraction"].unstack("cluster", fill_value=0.0) + cluster_order = _ordered_cluster_labels( + metadata, _ordered_unique_values(value_table, "cluster") + ) + pivot = value_table.set_index([x_column, "cluster"])["fraction"].unstack( + "cluster", fill_value=0.0 + ) pivot = pivot.reindex(index=x_order, columns=cluster_order, fill_value=0.0) pivot.plot(kind="bar", stacked=True, ax=ax) ax.tick_params(axis="x", rotation=45) @@ -386,7 +449,9 @@ def plot_shared_cluster_change_matplotlib( ax=None, title: str | None = None, ): - _require_payload_keys(payload, ("metadata",), owner="plot_shared_cluster_change_matplotlib") + _require_payload_keys( + payload, ("metadata",), owner="plot_shared_cluster_change_matplotlib" + ) change_table = _require_payload_table(payload, "distribution_change") metadata = payload.get("metadata") if not isinstance(metadata, Mapping): @@ -394,9 +459,13 @@ def plot_shared_cluster_change_matplotlib( fig, ax = _make_axis(ax=ax, figsize=(8, 4)) if not change_table.empty: - value_table = change_table.loc[:, ["condition", "cluster", "delta_fraction"]].copy() + value_table = change_table.loc[ + :, ["condition", "cluster", "delta_fraction"] + ].copy() if value_table.duplicated(["condition", "cluster"]).any(): - raise ValueError("plot payload contains duplicate delta fractions for the same condition.") + raise ValueError( + "plot payload contains duplicate delta fractions for the same condition." + ) condition_order = list(metadata.get("change_condition_order") or []) if not condition_order: condition_order = _ordered_unique_values(value_table, "condition") @@ -404,11 +473,17 @@ def plot_shared_cluster_change_matplotlib( cluster_order = list(metadata.get("cluster_labels") or []) if cluster_order: cluster_order.extend( - [cluster for cluster in observed_clusters if cluster not in cluster_order] + [ + cluster + for cluster in observed_clusters + if cluster not in cluster_order + ] ) else: cluster_order = observed_clusters - matrix = value_table.set_index(["condition", "cluster"])["delta_fraction"].unstack("cluster") + matrix = value_table.set_index(["condition", "cluster"])[ + "delta_fraction" + ].unstack("cluster") matrix = matrix.reindex(index=condition_order, columns=cluster_order) finite_values = pd.Series(matrix.abs().to_numpy().ravel()).dropna() max_abs = float(finite_values.max()) if not finite_values.empty else 0.0 @@ -425,7 +500,9 @@ def plot_shared_cluster_change_matplotlib( ) ax.figure.colorbar(image, ax=ax, label="Delta Fraction") ax.set_xticks(range(len(matrix.columns))) - ax.set_xticklabels([str(value) for value in matrix.columns.tolist()], rotation=45, ha="right") + ax.set_xticklabels( + [str(value) for value in matrix.columns.tolist()], rotation=45, ha="right" + ) ax.set_yticks(range(len(matrix.index))) ax.set_yticklabels([str(value) for value in matrix.index.tolist()]) @@ -454,34 +531,46 @@ def plot_shared_cluster_profile_heatmap_matplotlib( value_table = profile_table.loc[:, ["cluster", "feature", "value"]].copy() if value_table.duplicated(["cluster", "feature"]).any(): - raise ValueError("plot payload contains duplicate profile values for the same cluster and feature.") + raise ValueError( + "plot payload contains duplicate profile values for the same cluster and feature." + ) feature_order = list(metadata.get("feature_names") or []) observed_features = _ordered_unique_values(value_table, "feature") if feature_order: - feature_order.extend([feature for feature in observed_features if feature not in feature_order]) + feature_order.extend( + [feature for feature in observed_features if feature not in feature_order] + ) else: feature_order = observed_features observed_clusters = _ordered_unique_values(value_table, "cluster") cluster_order = list(metadata.get("cluster_labels") or []) if cluster_order: - cluster_order.extend([cluster for cluster in observed_clusters if cluster not in cluster_order]) + cluster_order.extend( + [cluster for cluster in observed_clusters if cluster not in cluster_order] + ) else: cluster_order = observed_clusters if feature_order: ax.set_xticks(range(len(feature_order))) - ax.set_xticklabels([str(value) for value in feature_order], rotation=45, ha="right") + ax.set_xticklabels( + [str(value) for value in feature_order], rotation=45, ha="right" + ) if cluster_order: ax.set_yticks(range(len(cluster_order))) ax.set_yticklabels([str(value) for value in cluster_order]) if feature_order and cluster_order: if value_table.empty: - matrix = pd.DataFrame(index=cluster_order, columns=feature_order, dtype=float) + matrix = pd.DataFrame( + index=cluster_order, columns=feature_order, dtype=float + ) else: - matrix = value_table.set_index(["cluster", "feature"])["value"].unstack("feature") + matrix = value_table.set_index(["cluster", "feature"])["value"].unstack( + "feature" + ) matrix = matrix.reindex(index=cluster_order, columns=feature_order) if matrix.notna().any().any(): image = ax.imshow( @@ -492,7 +581,11 @@ def plot_shared_cluster_profile_heatmap_matplotlib( ) ax.figure.colorbar(image, ax=ax, label="Value") ax.set_xticks(range(len(matrix.columns))) - ax.set_xticklabels([str(value) for value in matrix.columns.tolist()], rotation=45, ha="right") + ax.set_xticklabels( + [str(value) for value in matrix.columns.tolist()], + rotation=45, + ha="right", + ) ax.set_yticks(range(len(matrix.index))) ax.set_yticklabels([str(value) for value in matrix.index.tolist()]) @@ -521,12 +614,16 @@ def plot_shared_cluster_profile_series_matplotlib( value_table = profile_table.loc[:, ["cluster", "feature", "value"]].copy() if value_table.duplicated(["cluster", "feature"]).any(): - raise ValueError("plot payload contains duplicate profile values for the same cluster and feature.") + raise ValueError( + "plot payload contains duplicate profile values for the same cluster and feature." + ) feature_order = list(metadata.get("feature_names") or []) observed_features = _ordered_unique_values(value_table, "feature") if feature_order: - feature_order.extend([feature for feature in observed_features if feature not in feature_order]) + feature_order.extend( + [feature for feature in observed_features if feature not in feature_order] + ) else: feature_order = observed_features feature_lookup = {feature: index for index, feature in enumerate(feature_order)} @@ -534,14 +631,20 @@ def plot_shared_cluster_profile_series_matplotlib( observed_clusters = _ordered_unique_values(value_table, "cluster") cluster_order = list(metadata.get("cluster_labels") or []) if cluster_order: - cluster_order.extend([cluster for cluster in observed_clusters if cluster not in cluster_order]) + cluster_order.extend( + [cluster for cluster in observed_clusters if cluster not in cluster_order] + ) else: cluster_order = observed_clusters for cluster in cluster_order: - cluster_table = value_table.loc[value_table["cluster"] == cluster, ["feature", "value"]].copy() + cluster_table = value_table.loc[ + value_table["cluster"] == cluster, ["feature", "value"] + ].copy() if feature_order: - cluster_table["feature_order"] = cluster_table["feature"].map(feature_lookup) + cluster_table["feature_order"] = cluster_table["feature"].map( + feature_lookup + ) cluster_table = cluster_table.sort_values("feature_order", kind="stable") cluster_series = cluster_table.set_index("feature_order")["value"].reindex( range(len(feature_order)) @@ -598,28 +701,42 @@ def plot_shared_cluster_region_matplotlib( value_column = "fraction_mean" if level == "condition" else "fraction" label_column = "condition" if level == "condition" else "sample_id" - value_table = table.loc[:, ["region_id", label_column, "cluster", value_column]].copy() - value_table["row_id"] = value_table.loc[:, ["region_id", label_column]].astype(str).agg(" | ".join, axis=1) + value_table = table.loc[ + :, ["region_id", label_column, "cluster", value_column] + ].copy() + value_table["row_id"] = ( + value_table.loc[:, ["region_id", label_column]] + .astype(str) + .agg(" | ".join, axis=1) + ) if value_table.duplicated(["row_id", "cluster"]).any(): - raise ValueError("plot payload contains duplicate region occupancy values for the same row and cluster.") + raise ValueError( + "plot payload contains duplicate region occupancy values for the same row and cluster." + ) row_order = _ordered_unique_values(value_table, "row_id") observed_clusters = _ordered_unique_values(value_table, "cluster") cluster_order = list(metadata.get("cluster_labels") or []) if cluster_order: - cluster_order.extend([cluster for cluster in observed_clusters if cluster not in cluster_order]) + cluster_order.extend( + [cluster for cluster in observed_clusters if cluster not in cluster_order] + ) else: cluster_order = observed_clusters if cluster_order: ax.set_xticks(range(len(cluster_order))) - ax.set_xticklabels([str(value) for value in cluster_order], rotation=45, ha="right") + ax.set_xticklabels( + [str(value) for value in cluster_order], rotation=45, ha="right" + ) if row_order: ax.set_yticks(range(len(row_order))) ax.set_yticklabels([str(value) for value in row_order]) if row_order and cluster_order: - matrix = value_table.set_index(["row_id", "cluster"])[value_column].unstack("cluster") + matrix = value_table.set_index(["row_id", "cluster"])[value_column].unstack( + "cluster" + ) matrix = matrix.reindex(index=row_order, columns=cluster_order) if matrix.notna().any().any(): image = ax.imshow( @@ -628,7 +745,9 @@ def plot_shared_cluster_region_matplotlib( origin="upper", interpolation="nearest", ) - ax.figure.colorbar(image, ax=ax, label=value_column.replace("_", " ").title()) + ax.figure.colorbar( + image, ax=ax, label=value_column.replace("_", " ").title() + ) ax.set_xlabel("Cluster") ax.set_ylabel("Region / Condition" if level == "condition" else "Region / Sample") @@ -641,6 +760,8 @@ def plot_read_cluster_region_association_heatmap_matplotlib( *, ax=None, title: str | None = None, + region_sort: str | None = None, + association_strength_aggregate: str | None = None, region_label_mode: str = "auto", max_region_labels: int = 50, row_annotation_column: str | None = None, @@ -659,6 +780,60 @@ def plot_read_cluster_region_association_heatmap_matplotlib( if not isinstance(metadata, Mapping): raise TypeError("plot payload key 'metadata' must be a mapping.") + if region_sort is not None: + association_table = payload.get("association_table") + if not isinstance(association_table, pd.DataFrame): + raise ValueError( + "region_sort override requires payload['association_table']; " + "build payload with prepare_read_cluster_region_association_data(...)." + ) + from dimelo import plotting as plotting_api + + value_mode = str(metadata.get("value_mode") or "fraction") + top_n_regions_per_cluster = metadata.get("top_n_regions_per_cluster") + aggregate_mode = ( + association_strength_aggregate + if association_strength_aggregate is not None + else metadata.get("association_strength_aggregate", "max") + ) + override_payload = plotting_api.prepare_read_cluster_region_association_data( + association_table=association_table, + value_mode=value_mode, + top_n_regions_per_cluster=top_n_regions_per_cluster, + region_sort=region_sort, + association_strength_aggregate=str(aggregate_mode), + ) + + matrix_table = _require_payload_table(override_payload, "matrix_table") + metadata = override_payload.get("metadata") + if not isinstance(metadata, Mapping): + raise TypeError( + "region_sort override produced payload metadata that is not a mapping." + ) + + original_axis_table = payload.get("region_axis_table") + region_axis_table = override_payload.get("region_axis_table") + if ( + isinstance(original_axis_table, pd.DataFrame) + and isinstance(region_axis_table, pd.DataFrame) + and "region_id" in original_axis_table.columns + and "region_id" in region_axis_table.columns + ): + extra_cols = [ + c + for c in original_axis_table.columns + if c not in region_axis_table.columns + ] + if extra_cols: + extras = original_axis_table.loc[ + :, ["region_id", *extra_cols] + ].drop_duplicates(subset=["region_id"]) + region_axis_table = region_axis_table.merge( + extras, on="region_id", how="left" + ) + else: + region_axis_table = payload.get("region_axis_table") + if matrix_table.empty: fig, ax = _make_axis(ax=ax, figsize=(8, 4)) ax.set_title(title or "Read-cluster association heatmap") @@ -666,15 +841,24 @@ def plot_read_cluster_region_association_heatmap_matplotlib( ax.set_ylabel("Region") return fig, ax - region_column = "region_id" if "region_id" in matrix_table.columns else matrix_table.columns[0] - cluster_columns = [column for column in matrix_table.columns if column != region_column] + region_column = ( + "region_id" if "region_id" in matrix_table.columns else matrix_table.columns[0] + ) + cluster_columns = [ + column for column in matrix_table.columns if column != region_column + ] fig_width = max(8.0, 4.5 + (0.75 * len(cluster_columns))) + if row_annotation_column is not None: + fig_width += 1.6 fig_height = max(4.5, min(16.0, 2.0 + (0.10 * len(matrix_table)))) fig, ax = _make_axis(ax=ax, figsize=(fig_width, fig_height)) value_mode = str(metadata.get("value_mode") or "fraction") - region_axis_table = payload.get("region_axis_table") - if region_axis_table is not None and not isinstance(region_axis_table, pd.DataFrame): - raise TypeError("plot payload key 'region_axis_table' must be a pandas DataFrame when provided.") + if region_axis_table is not None and not isinstance( + region_axis_table, pd.DataFrame + ): + raise TypeError( + "plot payload key 'region_axis_table' must be a pandas DataFrame when provided." + ) if region_label_mode not in {"auto", "region_id", "genomic", "chromosome"}: raise ValueError( "region_label_mode must be 'auto', 'region_id', 'genomic', or 'chromosome'." @@ -688,9 +872,17 @@ def plot_read_cluster_region_association_heatmap_matplotlib( origin="upper", interpolation="nearest", ) - ax.figure.colorbar(image, ax=ax, label=value_mode.replace("_", " ").title()) + ax.figure.colorbar( + image, + ax=ax, + label=value_mode.replace("_", " ").title(), + fraction=0.045, + pad=0.05, + ) ax.set_xticks(range(len(cluster_columns))) - ax.set_xticklabels([str(value) for value in cluster_columns], rotation=45, ha="right") + ax.set_xticklabels( + [str(value) for value in cluster_columns], rotation=45, ha="right" + ) n_regions = len(matrix_table) default_ticks = np.arange(n_regions) @@ -709,14 +901,18 @@ def plot_read_cluster_region_association_heatmap_matplotlib( if {"chrom", "start", "end"}.issubset(axis_table.columns): genomic_labels = [ f"{chrom}:{int(start):,}-{int(end):,}" - for chrom, start, end in axis_table[["chrom", "start", "end"]].itertuples(index=False) + for chrom, start, end in axis_table[ + ["chrom", "start", "end"] + ].itertuples(index=False) ] chrom_labels = axis_table["chrom"].astype(str).tolist() effective_mode = region_label_mode if effective_mode == "auto": default_region_sort = str(metadata.get("region_sort") or "input") if default_region_sort == "genomic": - effective_mode = "chromosome" if n_regions > max_region_labels else "genomic" + effective_mode = ( + "chromosome" if n_regions > max_region_labels else "genomic" + ) else: effective_mode = "region_id" if effective_mode == "genomic": @@ -730,7 +926,10 @@ def plot_read_cluster_region_association_heatmap_matplotlib( ax.axhline(boundary - 0.5, color="white", linewidth=0.6, alpha=0.6) elif effective_mode == "region_id": labels = [default_labels[idx] for idx in ticks] - if row_annotation_column is not None and row_annotation_column in axis_table.columns: + if ( + row_annotation_column is not None + and row_annotation_column in axis_table.columns + ): annotation_values = axis_table[row_annotation_column].astype(str).tolist() if group_region_labels is None: @@ -740,22 +939,32 @@ def plot_read_cluster_region_association_heatmap_matplotlib( and n_regions > max_region_labels and ( ("chrom" in axis_table.columns) - or (row_annotation_column is not None and row_annotation_column in axis_table.columns) + or ( + row_annotation_column is not None + and row_annotation_column in axis_table.columns + ) ) ) if axis_table is not None and group_region_labels: requested_group_cols = list(group_label_columns or []) if not requested_group_cols: - if row_annotation_column is not None and row_annotation_column in axis_table.columns: + if ( + row_annotation_column is not None + and row_annotation_column in axis_table.columns + ): requested_group_cols = [row_annotation_column, "chrom"] elif "chrom" in axis_table.columns: requested_group_cols = ["chrom"] - requested_group_cols = [col for col in requested_group_cols if col in axis_table.columns] + requested_group_cols = [ + col for col in requested_group_cols if col in axis_table.columns + ] if requested_group_cols: group_parts = axis_table.loc[:, requested_group_cols].astype(str) group_key = group_parts.agg(" | ".join, axis=1).tolist() - boundaries = np.flatnonzero(np.array(group_key[1:]) != np.array(group_key[:-1])) + 1 + boundaries = ( + np.flatnonzero(np.array(group_key[1:]) != np.array(group_key[:-1])) + 1 + ) group_starts = np.concatenate(([0], boundaries)) group_ends = np.concatenate((boundaries, [len(group_key)])) centers = ((group_starts + group_ends - 1) / 2.0).astype(float) @@ -772,9 +981,15 @@ def plot_read_cluster_region_association_heatmap_matplotlib( ax.set_yticks(np.asarray(ticks).tolist()) if annotation_values is not None and not group_region_labels: - labels = [f"{labels[pos]} | {annotation_values[idx]}" for pos, idx in enumerate(ticks)] + labels = [ + f"{labels[pos]} | {annotation_values[idx]}" for pos, idx in enumerate(ticks) + ] ytick_fontsize = 8 if len(labels) <= 30 else 7 ax.set_yticklabels(labels, fontsize=ytick_fontsize) + if labels: + max_label_len = max(len(str(label)) for label in labels) + left_margin = min(0.42, max(0.14, 0.08 + (0.0035 * max_label_len))) + fig.subplots_adjust(left=left_margin) ax.set_xlabel("Cluster") ax.set_ylabel("Region") ax.set_title(title or "Read-cluster association heatmap") @@ -793,10 +1008,54 @@ def plot_read_cluster_region_association_heatmap_matplotlib( row_annotation_palette = { value: cmap(i % 10) for i, value in enumerate(ordered_annotations) } - annotation_colors = [row_annotation_palette.get(value, "0.6") for value in ordered_annotations] + annotation_colors = [ + row_annotation_palette.get(value, "0.6") for value in ordered_annotations + ] color_lookup = {value: i for i, value in enumerate(ordered_annotations)} - color_codes = np.array([color_lookup.get(value, 0) for value in annotation_values], dtype=int) - strip_ax = ax.inset_axes([-0.07, 0.0, 0.022, 1.0], transform=ax.transAxes) + color_codes = np.array( + [color_lookup.get(value, 0) for value in annotation_values], dtype=int + ) + # Place the annotation strip in figure coordinates so it never overlaps + # the main heatmap region, regardless of y-label length. + fig.canvas.draw() + renderer = fig.canvas.get_renderer() + ax_pos = ax.get_position() + tick_labels = [tick for tick in ax.get_yticklabels() if tick.get_text()] + if tick_labels: + tick_left = min( + tick.get_window_extent(renderer) + .transformed(fig.transFigure.inverted()) + .x0 + for tick in tick_labels + ) + else: + tick_left = ax_pos.x0 + + strip_width = 0.010 + strip_gap = 0.006 + strip_x1 = tick_left - strip_gap + strip_x0 = strip_x1 - strip_width + min_left = 0.012 + if strip_x0 < min_left: + needed_left = min(0.48, ax_pos.x0 + (min_left - strip_x0) + 0.01) + fig.subplots_adjust(left=needed_left) + fig.canvas.draw() + renderer = fig.canvas.get_renderer() + ax_pos = ax.get_position() + tick_labels = [tick for tick in ax.get_yticklabels() if tick.get_text()] + if tick_labels: + tick_left = min( + tick.get_window_extent(renderer) + .transformed(fig.transFigure.inverted()) + .x0 + for tick in tick_labels + ) + else: + tick_left = ax_pos.x0 + strip_x1 = tick_left - strip_gap + strip_x0 = max(min_left, strip_x1 - strip_width) + + strip_ax = fig.add_axes([strip_x0, ax_pos.y0, strip_width, ax_pos.height]) strip_ax.imshow( color_codes.reshape(-1, 1), aspect="auto", @@ -808,14 +1067,13 @@ def plot_read_cluster_region_association_heatmap_matplotlib( ) strip_ax.set_xticks([]) strip_ax.set_yticks([]) - strip_ax.set_title( - row_annotation_title or row_annotation_column, - fontsize=8, - pad=2, - ) legend_handles = [ - Patch(facecolor=row_annotation_palette.get(value, "0.6"), edgecolor="none", label=str(value)) + Patch( + facecolor=row_annotation_palette.get(value, "0.6"), + edgecolor="none", + label=str(value), + ) for value in ordered_annotations ] if legend_handles: @@ -823,7 +1081,7 @@ def plot_read_cluster_region_association_heatmap_matplotlib( handles=legend_handles, title=row_annotation_title or row_annotation_column, loc="upper left", - bbox_to_anchor=(1.01, 1.0), + bbox_to_anchor=(1.18, 1.0), frameon=False, ) return fig, ax @@ -844,7 +1102,9 @@ def plot_global_analysis_summary_matplotlib( if level not in {"sample", "condition"}: raise ValueError("level must be 'sample' or 'condition'.") - table = _require_payload_table(payload, "sample_summary" if level == "sample" else "condition_summary") + table = _require_payload_table( + payload, "sample_summary" if level == "sample" else "condition_summary" + ) fig, ax = _make_axis(ax=ax, figsize=(8, 4)) if not table.empty: @@ -875,8 +1135,15 @@ def plot_global_analysis_window_matplotlib( owner="plot_global_analysis_window_matplotlib", ) window_table = _require_payload_table(payload, "window_table") - metadata = payload.get("metadata", {}) if isinstance(payload.get("metadata", {}), Mapping) else {} - contigs = list(metadata.get("contig_order") or window_table.get("contig", pd.Series(dtype="object")).dropna().unique()) + metadata = ( + payload.get("metadata", {}) + if isinstance(payload.get("metadata", {}), Mapping) + else {} + ) + contigs = list( + metadata.get("contig_order") + or window_table.get("contig", pd.Series(dtype="object")).dropna().unique() + ) fig, axes = _make_axes(axes=axes, n_axes=len(contigs) or 1, figsize=(8, 3)) @@ -895,12 +1162,17 @@ def plot_global_analysis_window_matplotlib( .groupby("window_midpoint", as_index=False, sort=True) .mean(numeric_only=True) ) - ax.plot(grouped["window_midpoint"], grouped["window_fraction"], marker="o", linewidth=1.5) + ax.plot( + grouped["window_midpoint"], + grouped["window_fraction"], + marker="o", + linewidth=1.5, + ) ax.set_title(str(contig)) ax.set_xlabel("Window midpoint") ax.set_ylabel("Window Fraction") - for ax in axes[len(contigs):]: + for ax in axes[len(contigs) :]: ax.set_visible(False) if title: diff --git a/dimelo/region_analysis.py b/dimelo/region_analysis.py index 3290876..5eb6034 100644 --- a/dimelo/region_analysis.py +++ b/dimelo/region_analysis.py @@ -1,8 +1,8 @@ from __future__ import annotations import concurrent.futures +from collections.abc import Sequence from pathlib import Path -from typing import Sequence import numpy as np from tqdm.auto import tqdm @@ -99,7 +99,9 @@ def build_region_feature_table( ordered_results: list[tuple[np.ndarray, list[dict[str, object]]] | None] = [ None ] * len(sample_list) - with concurrent.futures.ThreadPoolExecutor(max_workers=sample_workers) as executor: + with concurrent.futures.ThreadPoolExecutor( + max_workers=sample_workers + ) as executor: future_by_index = { index: executor.submit( _build_sample_region_features, @@ -128,7 +130,9 @@ def build_region_feature_table( shared_regions_executor = None try: results = [] - for sample in tqdm(sample_list, desc="Building region features", disable=quiet): + for sample in tqdm( + sample_list, desc="Building region features", disable=quiet + ): result = _build_sample_region_features( sample=sample, motif=motifs[0], diff --git a/dimelo/region_contrasts.py b/dimelo/region_contrasts.py index 90b01d4..c534b1a 100644 --- a/dimelo/region_contrasts.py +++ b/dimelo/region_contrasts.py @@ -1,8 +1,8 @@ from __future__ import annotations -from functools import partial import math -from typing import Iterable +from collections.abc import Iterable +from functools import partial import pandas as pd from scipy import stats @@ -118,7 +118,9 @@ def build_region_evidence_table( ) -> pd.DataFrame: motifs = list(motifs) if len(motifs) != 1: - raise ValueError("build_region_evidence_table currently supports exactly one motif.") + raise ValueError( + "build_region_evidence_table currently supports exactly one motif." + ) motif = motifs[0] regions_dict = utils.regions_dict_from_input(regions, window_size) @@ -157,7 +159,7 @@ def build_region_evidence_table( for (chromosome, start, end, strand), ( modified_count, valid_count, - ) in zip(ordered_regions, counts_by_region): + ) in zip(ordered_regions, counts_by_region, strict=False): mod_fraction = 0.0 if valid_count == 0 else modified_count / valid_count rows.append( { @@ -215,7 +217,9 @@ def build_single_read_mod_fraction_evidence_table( :, selected_columns, ].copy() - evidence["modified_count"] = pd.to_numeric(evidence["modified_count"], errors="coerce") + evidence["modified_count"] = pd.to_numeric( + evidence["modified_count"], errors="coerce" + ) evidence["valid_count"] = pd.to_numeric(evidence["valid_count"], errors="coerce") invalid_counts = ( evidence["modified_count"].isna() @@ -235,10 +239,14 @@ def build_single_read_mod_fraction_evidence_table( ) evidence["modified_count"] = evidence["modified_count"].astype(int) evidence["valid_count"] = evidence["valid_count"].astype(int) - evidence["read_mod_fraction"] = evidence["modified_count"].div( - evidence["valid_count"].where(evidence["valid_count"] != 0), - fill_value=0, - ).fillna(0.0) + evidence["read_mod_fraction"] = ( + evidence["modified_count"] + .div( + evidence["valid_count"].where(evidence["valid_count"] != 0), + fill_value=0, + ) + .fillna(0.0) + ) return evidence @@ -259,9 +267,7 @@ def build_single_read_feature_evidence_table( ) feature_columns = [ - column - for column in feature_table.columns - if column not in required_columns + column for column in feature_table.columns if column not in required_columns ] if not feature_columns: raise ValueError( @@ -272,19 +278,20 @@ def build_single_read_feature_evidence_table( selected_columns.append(pairing_key) selected_columns.extend(feature_columns) evidence = feature_table.loc[:, selected_columns].copy() - evidence.loc[:, feature_columns] = evidence.loc[:, feature_columns].apply( + numeric_features = evidence.loc[:, feature_columns].apply( pd.to_numeric, errors="coerce", ) - finite_feature_values = evidence.loc[:, feature_columns].apply( + finite_feature_values = numeric_features.apply( lambda column: column.map(math.isfinite) ) - invalid_feature_values = evidence.loc[:, feature_columns].isna() | ~finite_feature_values + invalid_feature_values = numeric_features.isna() | ~finite_feature_values if invalid_feature_values.to_numpy().any(): raise ValueError( "build_single_read_feature_evidence_table feature columns must be numeric " "and finite." ) + evidence.loc[:, feature_columns] = numeric_features return evidence @@ -324,14 +331,11 @@ def _validate_single_read_matched_sample_summary( "to exactly one pairing key." ) - side_counts = ( - sample_summary.groupby( - ["region_id", pairing_key, "condition"], - dropna=False, - sort=False, - )["sample_id"] - .nunique() - ) + side_counts = sample_summary.groupby( + ["region_id", pairing_key, "condition"], + dropna=False, + sort=False, + )["sample_id"].nunique() if (side_counts > 1).any(): raise ValueError( "single_read matched_pairwise scoring requires exactly one sample " @@ -371,7 +375,9 @@ def _load_builtin_single_read_feature_table(*, samples, regions, motifs): ) rows = [] - for metadata, feature_values in zip(extracted.metadata, feature_rows): + for metadata, feature_values in zip( + extracted.metadata, feature_rows, strict=False + ): chromosome = metadata.get("chromosome") start = metadata.get("region_start") end = metadata.get("region_end") @@ -395,7 +401,9 @@ def _load_builtin_single_read_feature_table(*, samples, regions, motifs): row.update( { feature_name: float(feature_value) - for feature_name, feature_value in zip(feature_names, feature_values) + for feature_name, feature_value in zip( + feature_names, feature_values, strict=False + ) } ) rows.append(row) @@ -403,7 +411,13 @@ def _load_builtin_single_read_feature_table(*, samples, regions, motifs): if not sample_frames: return pd.DataFrame( - columns=["region_id", "sample_id", "condition", "read_id", *(selected_feature_names or [])] + columns=[ + "region_id", + "sample_id", + "condition", + "read_id", + *(selected_feature_names or []), + ] ) return pd.concat(sample_frames, ignore_index=True) @@ -493,7 +507,9 @@ def _estimate_beta_binomial_prior( ) denominator_unmodified_count = denominator_valid_count - denominator_modified_count - return float(denominator_modified_count + 1), float(denominator_unmodified_count + 1) + return float(denominator_modified_count + 1), float( + denominator_unmodified_count + 1 + ) def _log_beta_function(alpha: float, beta: float) -> float: @@ -512,7 +528,9 @@ def _beta_binomial_logpmf(k: int, n: int, alpha: float, beta: float) -> float: ) -def _beta_binomial_two_sided_p_value(k: int, n: int, alpha: float, beta: float) -> float: +def _beta_binomial_two_sided_p_value( + k: int, n: int, alpha: float, beta: float +) -> float: if k < 0: raise ValueError("beta-binomial modified_count must be >= 0.") if n < 0: @@ -526,9 +544,7 @@ def _beta_binomial_two_sided_p_value(k: int, n: int, alpha: float, beta: float) logpmf = [_beta_binomial_logpmf(x, n, alpha, beta) for x in support] observed_logpmf = logpmf[k] tail_probability = sum( - math.exp(value) - for value in logpmf - if value <= observed_logpmf + 1e-12 + math.exp(value) for value in logpmf if value <= observed_logpmf + 1e-12 ) return min(max(tail_probability, 0.0), 1.0) @@ -537,7 +553,9 @@ def _adjust_p_values_bh(p_values: pd.Series) -> pd.Series: if p_values.empty: return pd.Series(dtype=float, index=p_values.index) - ranked = sorted(enumerate(p_values.tolist()), key=lambda item: item[1], reverse=True) + ranked = sorted( + enumerate(p_values.tolist()), key=lambda item: item[1], reverse=True + ) total = len(ranked) adjusted = [1.0] * total running_min = 1.0 @@ -577,6 +595,7 @@ def _add_beta_binomial_scores( scored["numerator_valid_count"], scored["denominator_modified_count"], scored["denominator_valid_count"], + strict=False, ) ] scored["adjusted_p_value"] = _adjust_p_values_bh(scored["p_value"]) @@ -665,7 +684,9 @@ def _validate_occupancy_table_numeric_columns(occupancy_table: pd.DataFrame) -> ( "fraction", "occupancy_table fraction values must be finite and between 0 and 1.", - lambda values: values.isna() | ~values.map(math.isfinite) | (values < 0) | (values > 1), + lambda values: ( + values.isna() | ~values.map(math.isfinite) | (values < 0) | (values > 1) + ), ), ( "cluster_entropy", @@ -744,7 +765,10 @@ def _pool_cluster_occupancy_groups( .agg( value=(value_column, "mean"), replicate_n=("sample_id", "nunique"), - sample_values=(value_column, lambda values: tuple(float(v) for v in values)), + sample_values=( + value_column, + lambda values: tuple(float(v) for v in values), + ), ) .reset_index() .assign(contrast_side=side) @@ -813,7 +837,9 @@ def _select_complete_matched_pairs( complete_pair_index, names=["region_id", pairing_key], ) - paired_index = pd.MultiIndex.from_frame(pair_summary.loc[:, ["region_id", pairing_key]]) + paired_index = pd.MultiIndex.from_frame( + pair_summary.loc[:, ["region_id", pairing_key]] + ) return pair_summary.loc[paired_index.isin(complete_pairs)].copy() @@ -899,17 +925,16 @@ def _score_single_read_mod_fraction( (regions_table["sample_summary_numerator_mean"] + 1e-6) / (regions_table["sample_summary_denominator_mean"] + 1e-6) ).map(math.log2) - regions_table = ( - regions_table.groupby("region_id", as_index=False, sort=False) - .agg( - sample_summary_numerator_mean=("sample_summary_numerator_mean", "mean"), - sample_summary_denominator_mean=("sample_summary_denominator_mean", "mean"), - delta_summary_mean=("delta_summary_mean", "mean"), - numerator_read_n=("numerator_read_n", "sum"), - denominator_read_n=("denominator_read_n", "sum"), - numerator_replicate_n=("numerator_sample_n", "size"), - denominator_replicate_n=("denominator_sample_n", "size"), - ) + regions_table = regions_table.groupby( + "region_id", as_index=False, sort=False + ).agg( + sample_summary_numerator_mean=("sample_summary_numerator_mean", "mean"), + sample_summary_denominator_mean=("sample_summary_denominator_mean", "mean"), + delta_summary_mean=("delta_summary_mean", "mean"), + numerator_read_n=("numerator_read_n", "sum"), + denominator_read_n=("denominator_read_n", "sum"), + numerator_replicate_n=("numerator_sample_n", "size"), + denominator_replicate_n=("denominator_sample_n", "size"), ) regions_table["log2_fc"] = ( (regions_table["sample_summary_numerator_mean"] + 1e-6) @@ -941,14 +966,19 @@ def _score_single_read_mod_fraction( pooled_frames = [] for side, conditions in side_specs.items(): - side_evidence = sample_summary.loc[sample_summary["condition"].isin(conditions)].copy() + side_evidence = sample_summary.loc[ + sample_summary["condition"].isin(conditions) + ].copy() pooled = ( side_evidence.groupby("region_id", dropna=False, sort=False) .agg( sample_summary_mean=("sample_summary_mean", "mean"), read_n=("read_n", "sum"), replicate_n=("sample_id", "nunique"), - sample_values=("sample_summary_mean", lambda values: tuple(float(v) for v in values)), + sample_values=( + "sample_summary_mean", + lambda values: tuple(float(v) for v in values), + ), ) .reset_index() .assign(contrast_side=side) @@ -991,7 +1021,9 @@ def _score_single_read_mod_fraction( regions_table["sample_summary_denominator_mean"] = regions_table[ "sample_summary_denominator_mean" ].fillna(0.0) - regions_table["numerator_read_n"] = regions_table["numerator_read_n"].fillna(0).astype(int) + regions_table["numerator_read_n"] = ( + regions_table["numerator_read_n"].fillna(0).astype(int) + ) regions_table["denominator_read_n"] = ( regions_table["denominator_read_n"].fillna(0).astype(int) ) @@ -1048,11 +1080,11 @@ def _summarize_single_read_features_by_sample( group_columns.append(pairing_key) excluded_columns.add(pairing_key) feature_columns = [ - column - for column in evidence.columns - if column not in excluded_columns + column for column in evidence.columns if column not in excluded_columns ] - return evidence.groupby(group_columns, as_index=False, sort=False)[feature_columns].mean() + return evidence.groupby(group_columns, as_index=False, sort=False)[ + feature_columns + ].mean() def _score_single_read_features( @@ -1138,8 +1170,12 @@ def _score_single_read_features( row = {"region_id": region_id} effect_sizes = [] for feature_name in feature_columns: - numerator_mean = float(region_table[f"{feature_name}_numerator_mean"].mean()) - denominator_mean = float(region_table[f"{feature_name}_denominator_mean"].mean()) + numerator_mean = float( + region_table[f"{feature_name}_numerator_mean"].mean() + ) + denominator_mean = float( + region_table[f"{feature_name}_denominator_mean"].mean() + ) delta_mean = numerator_mean - denominator_mean row[f"{feature_name}_numerator_mean"] = numerator_mean row[f"{feature_name}_denominator_mean"] = denominator_mean @@ -1162,8 +1198,12 @@ def _score_single_read_features( summary_rows = [] for region_id, region_table in sample_summary.groupby("region_id", sort=False): - numerator_table = region_table[region_table["condition"].isin(contrast.numerator)] - denominator_table = region_table[region_table["condition"].isin(contrast.denominator)] + numerator_table = region_table[ + region_table["condition"].isin(contrast.numerator) + ] + denominator_table = region_table[ + region_table["condition"].isin(contrast.denominator) + ] row = {"region_id": region_id} effect_sizes = [] for feature_name in feature_columns: @@ -1259,7 +1299,13 @@ def _score_cluster_occupancy( if representation == "cluster_fraction": _require_occupancy_columns( evidence, - required_columns={"region_id", "sample_id", "condition", "cluster", "fraction"}, + required_columns={ + "region_id", + "sample_id", + "condition", + "cluster", + "fraction", + }, ) pooled = _pool_cluster_occupancy_groups( evidence, @@ -1296,7 +1342,9 @@ def _score_cluster_occupancy( sort=False, ) regions_table["fraction"] = regions_table["fraction"].fillna(0.0) - regions_table["reference_fraction"] = regions_table["reference_fraction"].fillna(0.0) + regions_table["reference_fraction"] = regions_table[ + "reference_fraction" + ].fillna(0.0) regions_table["numerator_replicate_n"] = ( regions_table["numerator_replicate_n"].fillna(0).astype(int) ) @@ -1324,7 +1372,13 @@ def _score_cluster_occupancy( multiple_testing=multiple_testing, ) regions_table = regions_table.sort_values( - by=["adjusted_p_value", "p_value", "effect_size", "region_id", "cluster"], + by=[ + "adjusted_p_value", + "p_value", + "effect_size", + "region_id", + "cluster", + ], ascending=[True, True, False, True, True], kind="mergesort", ).reset_index(drop=True) @@ -1355,7 +1409,12 @@ def _score_cluster_occupancy( if representation == "dominant_cluster": _require_occupancy_columns( evidence, - required_columns={"region_id", "sample_id", "condition", "dominant_cluster"}, + required_columns={ + "region_id", + "sample_id", + "condition", + "dominant_cluster", + }, ) side_specs = { "numerator": contrast.numerator or [], @@ -1392,9 +1451,10 @@ def _score_cluster_occupancy( how="outer", sort=False, ) - missing_region_side = regions_table["numerator_replicate_n"].isna() ^ regions_table[ - "denominator_replicate_n" - ].isna() + missing_region_side = ( + regions_table["numerator_replicate_n"].isna() + ^ regions_table["denominator_replicate_n"].isna() + ) if missing_region_side.any(): raise ValueError( "Missing dominant_cluster evidence for one or more requested contrast " @@ -1413,7 +1473,9 @@ def _score_cluster_occupancy( ), axis=1, ) - regions_table["effect_size"] = regions_table["dominant_cluster_changed"].astype(int) + regions_table["effect_size"] = regions_table["dominant_cluster_changed"].astype( + int + ) regions_table = regions_table.sort_values( by=["effect_size", "region_id"], ascending=[False, True], @@ -1439,8 +1501,9 @@ def _score_cluster_occupancy( required_columns={"region_id", "sample_id", "condition", "cluster_entropy"}, ) pooled = _pool_cluster_occupancy_groups( - evidence.loc[:, ["region_id", "sample_id", "condition", "cluster_entropy"]] - .drop_duplicates(), + evidence.loc[ + :, ["region_id", "sample_id", "condition", "cluster_entropy"] + ].drop_duplicates(), contrast, value_column="cluster_entropy", group_columns=["region_id"], @@ -1537,7 +1600,9 @@ def score_regions( ) evidence = build_single_read_mod_fraction_evidence_table( extract_table=read_table, - pairing_key=contrast.pairing_key if contrast.mode == "matched_pairwise" else None, + pairing_key=contrast.pairing_key + if contrast.mode == "matched_pairwise" + else None, ) regions_table, summary = _score_single_read_mod_fraction( evidence=evidence, @@ -1550,7 +1615,9 @@ def score_regions( "signal_source": signal_source, "test": test, "multiple_testing": multiple_testing, - "normalization_mode": contrast_metadata.get("normalization_mode", "none"), + "normalization_mode": contrast_metadata.get( + "normalization_mode", "none" + ), "biological_interpretation": contrast_metadata.get( "biological_interpretation", "region-level difference in sample-level read modification fraction", @@ -1575,7 +1642,9 @@ def score_regions( ) evidence = build_single_read_feature_evidence_table( feature_table=feature_table, - pairing_key=contrast.pairing_key if contrast.mode == "matched_pairwise" else None, + pairing_key=contrast.pairing_key + if contrast.mode == "matched_pairwise" + else None, ) regions_table, summary = _score_single_read_features( evidence=evidence, @@ -1588,7 +1657,9 @@ def score_regions( "signal_source": signal_source, "test": test, "multiple_testing": multiple_testing, - "normalization_mode": contrast_metadata.get("normalization_mode", "none"), + "normalization_mode": contrast_metadata.get( + "normalization_mode", "none" + ), "biological_interpretation": contrast_metadata.get( "biological_interpretation", "region-level difference in sample-level read feature summaries", @@ -1698,7 +1769,8 @@ def score_regions( merged["delta_fraction"] = merged["fraction"] - merged["reference_fraction"] pseudocount = 1e-6 merged["log2_fc"] = ( - (merged["fraction"] + pseudocount) / (merged["reference_fraction"] + pseudocount) + (merged["fraction"] + pseudocount) + / (merged["reference_fraction"] + pseudocount) ).map(math.log2) integer_columns = [ @@ -1757,7 +1829,9 @@ def score_regions( if test == "beta_binomial": summary_columns.extend(["p_value", "adjusted_p_value"]) if representation == "modified_count": - summary_columns.extend(["count", "reference_count", "delta_count", "log2_fc_count"]) + summary_columns.extend( + ["count", "reference_count", "delta_count", "log2_fc_count"] + ) summary = regions_table.loc[:, summary_columns].copy() metadata = { diff --git a/dimelo/region_discovery.py b/dimelo/region_discovery.py index 74bbba7..a189a0c 100644 --- a/dimelo/region_discovery.py +++ b/dimelo/region_discovery.py @@ -1,6 +1,6 @@ from __future__ import annotations -from typing import Iterable +from collections.abc import Iterable import pandas as pd @@ -26,12 +26,17 @@ def _validate_motifs(motifs: Iterable[str]) -> list[str]: def _safe_fraction(modified_count: pd.Series, valid_count: pd.Series) -> pd.Series: - return modified_count.div(valid_count.where(valid_count != 0), fill_value=0).fillna(0.0) + return modified_count.div(valid_count.where(valid_count != 0), fill_value=0).fillna( + 0.0 + ) def _aggregate_window_counts(summary: pd.DataFrame) -> pd.DataFrame: if summary.empty: - return pd.DataFrame(columns=_WINDOW_KEY_COLUMNS + ["modified_count", "valid_count", "window_fraction"]) + return pd.DataFrame( + columns=_WINDOW_KEY_COLUMNS + + ["modified_count", "valid_count", "window_fraction"] + ) aggregated = ( summary.groupby(_WINDOW_KEY_COLUMNS, as_index=False, sort=False) @@ -50,7 +55,8 @@ def _aggregate_window_counts(summary: pd.DataFrame) -> pd.DataFrame: def _aggregate_condition_counts(summary: pd.DataFrame) -> pd.DataFrame: if summary.empty: return pd.DataFrame( - columns=_WINDOW_KEY_COLUMNS + ["condition", "modified_count", "valid_count", "window_fraction"] + columns=_WINDOW_KEY_COLUMNS + + ["condition", "modified_count", "valid_count", "window_fraction"] ) aggregated = ( @@ -74,7 +80,10 @@ def _condition_spread_scores(condition_counts: pd.DataFrame) -> pd.DataFrame: spread = ( condition_counts.groupby(_WINDOW_KEY_COLUMNS, as_index=False, sort=False) .agg( - score_value=("window_fraction", lambda values: float(values.max() - values.min())), + score_value=( + "window_fraction", + lambda values: float(values.max() - values.min()), + ), ) .copy() ) @@ -89,11 +98,19 @@ def _side_counts( ) -> pd.DataFrame: side_conditions = list(conditions) if not side_conditions: - return pd.DataFrame(columns=_WINDOW_KEY_COLUMNS + [f"{side_name}_modified_count", f"{side_name}_valid_count"]) + return pd.DataFrame( + columns=_WINDOW_KEY_COLUMNS + + [f"{side_name}_modified_count", f"{side_name}_valid_count"] + ) - side = condition_counts.loc[condition_counts["condition"].isin(side_conditions)].copy() + side = condition_counts.loc[ + condition_counts["condition"].isin(side_conditions) + ].copy() if side.empty: - return pd.DataFrame(columns=_WINDOW_KEY_COLUMNS + [f"{side_name}_modified_count", f"{side_name}_valid_count"]) + return pd.DataFrame( + columns=_WINDOW_KEY_COLUMNS + + [f"{side_name}_modified_count", f"{side_name}_valid_count"] + ) grouped = ( side.groupby(_WINDOW_KEY_COLUMNS, as_index=False, sort=False) @@ -128,8 +145,7 @@ def _validate_contrast_conditions( if missing: raise ValueError( - "scan_genome contrast requested missing condition(s): " - + "; ".join(missing) + "scan_genome contrast requested missing condition(s): " + "; ".join(missing) ) @@ -149,7 +165,9 @@ def _is_paired_contrast(contrast: ContrastSpec | None) -> bool: def _resolve_pair_ids(samples, pairing_key: str) -> dict[str, object]: if not pairing_key: - raise ValueError("scan_genome paired discovery requires an explicit pairing_key.") + raise ValueError( + "scan_genome paired discovery requires an explicit pairing_key." + ) pair_ids: dict[str, object] = {} for sample in samples: @@ -184,25 +202,33 @@ def _build_paired_window_table( ) required_condition_set = set(required_conditions) complete_pair_ids = [ - pair_id for pair_id, conditions in pair_conditions.items() if required_condition_set.issubset(conditions) + pair_id + for pair_id, conditions in pair_conditions.items() + if required_condition_set.issubset(conditions) ] dropped_pair_count = int(len(pair_conditions) - len(complete_pair_ids)) if pairing_policy == "error_on_missing" and dropped_pair_count: raise ValueError("scan_genome paired discovery found incomplete matched units.") if not complete_pair_ids: - raise ValueError("scan_genome paired discovery found no complete matched units.") + raise ValueError( + "scan_genome paired discovery found no complete matched units." + ) paired = paired.loc[paired["pair_id"].isin(complete_pair_ids)].copy() paired = ( - paired.groupby(_WINDOW_KEY_COLUMNS + ["pair_id", "condition"], as_index=False, sort=False) + paired.groupby( + _WINDOW_KEY_COLUMNS + ["pair_id", "condition"], as_index=False, sort=False + ) .agg( modified_count=("modified_count", "sum"), valid_count=("valid_count", "sum"), ) .copy() ) - paired["window_fraction"] = _safe_fraction(paired["modified_count"], paired["valid_count"]) + paired["window_fraction"] = _safe_fraction( + paired["modified_count"], paired["valid_count"] + ) return paired, { "n_pairs_used": len(complete_pair_ids), "n_pairs_dropped": dropped_pair_count, @@ -216,7 +242,9 @@ def _score_matched_pairwise( rank_by: str = "mean_abs_delta", ) -> pd.DataFrame: if rank_by != "mean_abs_delta": - raise ValueError("scan_genome matched_pairwise currently supports rank_by='mean_abs_delta'.") + raise ValueError( + "scan_genome matched_pairwise currently supports rank_by='mean_abs_delta'." + ) numerator = paired_window_table.loc[ paired_window_table["condition"].isin(contrast.numerator or []) @@ -255,7 +283,12 @@ def _score_matched_pairwise( merged = numerator.merge( denominator[ _WINDOW_KEY_COLUMNS - + ["pair_id", "denominator_modified_count", "denominator_valid_count", "denominator_fraction"] + + [ + "pair_id", + "denominator_modified_count", + "denominator_valid_count", + "denominator_fraction", + ] ], on=_WINDOW_KEY_COLUMNS + ["pair_id"], how="inner", @@ -283,7 +316,9 @@ def _score_matched_pairwise( sign_agreement=( "delta", lambda values: float( - max((values.gt(0)).mean(), (values.lt(0)).mean()) if len(values) else 0.0 + max((values.gt(0)).mean(), (values.lt(0)).mean()) + if len(values) + else 0.0 ), ), n_pairs_used=("pair_id", "nunique"), @@ -296,9 +331,13 @@ def _score_matched_pairwise( return scored -def _validate_time_order(paired_window_table: pd.DataFrame, time_order: list[str]) -> None: +def _validate_time_order( + paired_window_table: pd.DataFrame, time_order: list[str] +) -> None: available_conditions = set(paired_window_table["condition"].dropna().tolist()) - missing = [condition for condition in time_order if condition not in available_conditions] + missing = [ + condition for condition in time_order if condition not in available_conditions + ] if missing: raise ValueError( "scan_genome paired time_course requested missing time_order condition(s): " @@ -321,7 +360,9 @@ def _score_paired_time_course( scored["adjusted_p_value"] = pd.Series(dtype="object") return scored - ordered = paired_window_table.loc[paired_window_table["condition"].isin(time_order)].copy() + ordered = paired_window_table.loc[ + paired_window_table["condition"].isin(time_order) + ].copy() _validate_time_order(ordered, time_order) ordered["condition"] = pd.Categorical( ordered["condition"], @@ -363,7 +404,10 @@ def _score_paired_time_course( per_pair = ( ordered.groupby(_WINDOW_KEY_COLUMNS + ["pair_id"], as_index=False, sort=False) .agg( - trajectory_amplitude=("window_fraction", lambda values: float(values.max() - values.min())), + trajectory_amplitude=( + "window_fraction", + lambda values: float(values.max() - values.min()), + ), ) .copy() ) @@ -372,7 +416,10 @@ def _score_paired_time_course( per_pair.groupby(_WINDOW_KEY_COLUMNS, as_index=False, sort=False) .agg( trajectory_amplitude_mean=("trajectory_amplitude", "mean"), - trajectory_amplitude_sd=("trajectory_amplitude", lambda values: float(values.std(ddof=0))), + trajectory_amplitude_sd=( + "trajectory_amplitude", + lambda values: float(values.std(ddof=0)), + ), n_pairs_used=("pair_id", "nunique"), ) .copy() @@ -391,7 +438,9 @@ def _score_with_contrast( score: str, ) -> pd.DataFrame: if score == "beta_binomial": - available_conditions = sorted(condition_counts["condition"].dropna().unique().tolist()) + available_conditions = sorted( + condition_counts["condition"].dropna().unique().tolist() + ) if contrast is not None and contrast.numerator and contrast.denominator: numerator_conditions = list(contrast.numerator) denominator_conditions = list(contrast.denominator) @@ -416,7 +465,9 @@ def _score_with_contrast( condition_counts, conditions=denominator_conditions, side_name="denominator" ) - scored = window_totals.merge(numerator_counts, on=_WINDOW_KEY_COLUMNS, how="left") + scored = window_totals.merge( + numerator_counts, on=_WINDOW_KEY_COLUMNS, how="left" + ) scored = scored.merge(denominator_counts, on=_WINDOW_KEY_COLUMNS, how="left") for column in [ @@ -427,11 +478,18 @@ def _score_with_contrast( ]: scored[column] = scored[column].fillna(0).astype(int) - scored["score_value"] = _safe_fraction( - scored["numerator_modified_count"], scored["numerator_valid_count"] - ).sub( - _safe_fraction(scored["denominator_modified_count"], scored["denominator_valid_count"]) - ).abs() + scored["score_value"] = ( + _safe_fraction( + scored["numerator_modified_count"], scored["numerator_valid_count"] + ) + .sub( + _safe_fraction( + scored["denominator_modified_count"], + scored["denominator_valid_count"], + ) + ) + .abs() + ) scored["p_value"] = [ _beta_binomial_two_sided_p_value( @@ -447,6 +505,7 @@ def _score_with_contrast( scored["numerator_valid_count"], scored["denominator_modified_count"], scored["denominator_valid_count"], + strict=False, ) ] scored["adjusted_p_value"] = _adjust_p_values_bh(scored["p_value"]) @@ -478,11 +537,17 @@ def _score_with_contrast( ]: scored[column] = scored[column].fillna(0).astype(int) - scored["score_value"] = _safe_fraction( - scored["numerator_modified_count"], scored["numerator_valid_count"] - ).sub( - _safe_fraction(scored["denominator_modified_count"], scored["denominator_valid_count"]) - ).abs() + scored["score_value"] = ( + _safe_fraction( + scored["numerator_modified_count"], scored["numerator_valid_count"] + ) + .sub( + _safe_fraction( + scored["denominator_modified_count"], scored["denominator_valid_count"] + ) + ) + .abs() + ) if score == "beta_binomial": scored["p_value"] = [ @@ -499,6 +564,7 @@ def _score_with_contrast( scored["numerator_valid_count"], scored["denominator_modified_count"], scored["denominator_valid_count"], + strict=False, ) ] else: @@ -514,7 +580,14 @@ def _rank_windows(scored: pd.DataFrame, *, score: str) -> pd.DataFrame: if score == "beta_binomial": ranked = scored.sort_values( - by=["adjusted_p_value", "p_value", "score_value", "chromosome", "start", "end"], + by=[ + "adjusted_p_value", + "p_value", + "score_value", + "chromosome", + "start", + "end", + ], ascending=[True, True, False, True, True, True], kind="mergesort", na_position="last", @@ -541,7 +614,9 @@ def _apply_min_coverage( filtered = scored.copy() covered = filtered["valid_count"] >= min_coverage - filtered.loc[~covered, ["score_value", "p_value", "adjusted_p_value", "rank"]] = pd.NA + filtered.loc[~covered, ["score_value", "p_value", "adjusted_p_value", "rank"]] = ( + pd.NA + ) hits = filtered.loc[covered].copy() return filtered, hits @@ -601,14 +676,18 @@ def _build_merged_hit(group: pd.DataFrame) -> dict[str, object]: if {"modified_count", "valid_count"}.issubset(merged): valid_count = int(merged.get("valid_count", 0)) modified_count = int(merged.get("modified_count", 0)) - merged["window_fraction"] = 0.0 if valid_count == 0 else modified_count / valid_count + merged["window_fraction"] = ( + 0.0 if valid_count == 0 else modified_count / valid_count + ) if "score_value" in group.columns: merged["score_value"] = _merge_value(group["score_value"], prefer="max") if "p_value" in group.columns: merged["p_value"] = _merge_value(group["p_value"], prefer="min") if "adjusted_p_value" in group.columns: - merged["adjusted_p_value"] = _merge_value(group["adjusted_p_value"], prefer="min") + merged["adjusted_p_value"] = _merge_value( + group["adjusted_p_value"], prefer="min" + ) if "rank" in group.columns: rank_values = group["rank"].dropna() if not rank_values.empty: @@ -621,7 +700,8 @@ def _build_merged_hit(group: pd.DataFrame) -> dict[str, object]: "denominator_valid_count", ] contrast_counts_present = any( - field in group.columns and group[field].notna().any() for field in contrast_count_fields + field in group.columns and group[field].notna().any() + for field in contrast_count_fields ) if contrast_counts_present: for field in contrast_count_fields: @@ -636,7 +716,8 @@ def _build_merged_hit(group: pd.DataFrame) -> dict[str, object]: merged["merged_window_count"] = merged_window_count if contrast_counts_present and all( - field in merged and not pd.isna(merged[field]) for field in contrast_count_fields + field in merged and not pd.isna(merged[field]) + for field in contrast_count_fields ): numerator_fraction = _safe_fraction( pd.Series([merged["numerator_modified_count"]], dtype="float64"), @@ -646,10 +727,14 @@ def _build_merged_hit(group: pd.DataFrame) -> dict[str, object]: pd.Series([merged["denominator_modified_count"]], dtype="float64"), pd.Series([merged["denominator_valid_count"]], dtype="float64"), ).iloc[0] - merged["score_value"] = abs(float(numerator_fraction) - float(denominator_fraction)) + merged["score_value"] = abs( + float(numerator_fraction) - float(denominator_fraction) + ) if {"chromosome", "start", "end"}.issubset(merged): - merged["window_id"] = f"{merged['chromosome']}:{int(merged['start'])}-{int(merged['end'])}" + merged["window_id"] = ( + f"{merged['chromosome']}:{int(merged['start'])}-{int(merged['end'])}" + ) return merged @@ -696,7 +781,9 @@ def merge_adjacent_hits(hits: pd.DataFrame, merge_distance: int) -> pd.DataFrame same_strand = ordered["strand"].eq(ordered["strand"].shift()) within_distance = ordered["start"].le(ordered["end"].shift().add(merge_distance)) - merge_with_previous = (same_chromosome & same_strand & within_distance).fillna(False) + merge_with_previous = (same_chromosome & same_strand & within_distance).fillna( + False + ) merge_group = (~merge_with_previous).cumsum() merged_rows = [ @@ -706,14 +793,20 @@ def merge_adjacent_hits(hits: pd.DataFrame, merge_distance: int) -> pd.DataFrame merged = pd.DataFrame.from_records(merged_rows) merged = _sort_hits_for_output(merged) - if "window_id" not in merged.columns and {"chromosome", "start", "end"}.issubset(merged.columns): + if "window_id" not in merged.columns and {"chromosome", "start", "end"}.issubset( + merged.columns + ): merged["window_id"] = _build_window_id_series(merged) if "merged_window_count" not in merged.columns: merged["merged_window_count"] = 1 - if {"modified_count", "valid_count"}.issubset(merged.columns) and "window_fraction" not in merged.columns: - merged["window_fraction"] = _safe_fraction(merged["modified_count"], merged["valid_count"]) + if {"modified_count", "valid_count"}.issubset( + merged.columns + ) and "window_fraction" not in merged.columns: + merged["window_fraction"] = _safe_fraction( + merged["modified_count"], merged["valid_count"] + ) ordered_columns = list(hits.columns) if "rank" in merged.columns and "rank" not in ordered_columns: @@ -721,7 +814,9 @@ def merge_adjacent_hits(hits: pd.DataFrame, merge_distance: int) -> pd.DataFrame for column in ["window_id", "window_fraction", "merged_window_count"]: if column in merged.columns and column not in ordered_columns: ordered_columns.append(column) - merged = merged.loc[:, [column for column in ordered_columns if column in merged.columns]] + merged = merged.loc[ + :, [column for column in ordered_columns if column in merged.columns] + ] return merged.reset_index(drop=True) @@ -737,7 +832,9 @@ def hits_to_bed(hits: pd.DataFrame) -> pd.DataFrame: name = ordered["window_id"] else: name = ordered.apply( - lambda row: f"{row.get('chromosome', row.get('chrom'))}:{int(row['start'])}-{int(row['end'])}", + lambda row: ( + f"{row.get('chromosome', row.get('chrom'))}:{int(row['start'])}-{int(row['end'])}" + ), axis=1, ) if "score_value" in ordered.columns: @@ -752,7 +849,11 @@ def hits_to_bed(hits: pd.DataFrame) -> pd.DataFrame: else: score = pd.Series([0] * len(ordered), index=ordered.index, dtype="int64") strand = ordered["strand"] if "strand" in ordered.columns else "." - strand = strand.where(strand.isin({"+", "-"}), ".") if isinstance(strand, pd.Series) else strand + strand = ( + strand.where(strand.isin({"+", "-"}), ".") + if isinstance(strand, pd.Series) + else strand + ) bed = pd.DataFrame( { @@ -792,9 +893,13 @@ def scan_genome( ) -> RegionDiscoveryResult: motif_list = _validate_motifs(motifs) if score not in {"effect_size_only", "beta_binomial"}: - raise ValueError("scan_genome requires score in {'effect_size_only', 'beta_binomial'}.") + raise ValueError( + "scan_genome requires score in {'effect_size_only', 'beta_binomial'}." + ) if score == "beta_binomial" and contrast is None: - raise ValueError("scan_genome score='beta_binomial' requires an explicit contrast.") + raise ValueError( + "scan_genome score='beta_binomial' requires an explicit contrast." + ) if contrast is not None and contrast.mode not in { "pairwise", "group_vs_group", @@ -823,7 +928,9 @@ def scan_genome( if _is_paired_contrast(contrast): if contrast.mode == "time_course": if not contrast.pairing_key: - raise ValueError("scan_genome paired discovery requires an explicit pairing_key.") + raise ValueError( + "scan_genome paired discovery requires an explicit pairing_key." + ) active_rank_by = active_rank_by or "trajectory_amplitude_mean" if active_rank_by != "trajectory_amplitude_mean": raise ValueError( @@ -831,7 +938,11 @@ def scan_genome( ) time_order = list(dict.fromkeys(contrast.time_order or [])) available_conditions = set(window_summary["condition"].dropna().tolist()) - missing_time_order = [condition for condition in time_order if condition not in available_conditions] + missing_time_order = [ + condition + for condition in time_order + if condition not in available_conditions + ] if missing_time_order: raise ValueError( "scan_genome paired time_course requested missing time_order condition(s): " @@ -844,8 +955,12 @@ def scan_genome( raise ValueError( "scan_genome matched_pairwise requires exactly one numerator and one denominator condition." ) - required_conditions = list(contrast.time_order or []) if contrast.mode == "time_course" else list( - dict.fromkeys((contrast.numerator or []) + (contrast.denominator or [])) + required_conditions = ( + list(contrast.time_order or []) + if contrast.mode == "time_course" + else list( + dict.fromkeys((contrast.numerator or []) + (contrast.denominator or [])) + ) ) window_summary, pairing_metadata = _build_paired_window_table( window_summary, @@ -856,9 +971,13 @@ def scan_genome( ) if contrast.mode == "matched_pairwise": if score != "effect_size_only": - raise ValueError("scan_genome matched_pairwise currently supports score='effect_size_only'.") + raise ValueError( + "scan_genome matched_pairwise currently supports score='effect_size_only'." + ) if merge_hits: - raise ValueError("scan_genome matched_pairwise does not support merge_hits=True.") + raise ValueError( + "scan_genome matched_pairwise does not support merge_hits=True." + ) active_rank_by = active_rank_by or "mean_abs_delta" window_totals = _aggregate_window_counts(window_summary) scored = _score_matched_pairwise( @@ -897,7 +1016,11 @@ def scan_genome( ] window_table.loc[~covered_mask, paired_score_columns] = pd.NA covered_hits = ranked.merge( - window_totals.loc[:, _WINDOW_KEY_COLUMNS + ["modified_count", "valid_count", "window_fraction"]], + window_totals.loc[ + :, + _WINDOW_KEY_COLUMNS + + ["modified_count", "valid_count", "window_fraction"], + ], on=_WINDOW_KEY_COLUMNS, how="left", sort=False, @@ -923,8 +1046,12 @@ def scan_genome( "merge_hits": merge_hits, "merge_distance": merge_distance, "motifs": motif_list, - "include_contigs": list(include_contigs) if include_contigs is not None else None, - "exclude_contigs": list(exclude_contigs) if exclude_contigs is not None else None, + "include_contigs": list(include_contigs) + if include_contigs is not None + else None, + "exclude_contigs": list(exclude_contigs) + if exclude_contigs is not None + else None, "contrast_mode": contrast.mode, "contrast_numerator": list(contrast.numerator or []), "contrast_denominator": list(contrast.denominator or []), @@ -945,9 +1072,13 @@ def scan_genome( ) if contrast.mode == "time_course": if score != "effect_size_only": - raise ValueError("scan_genome time_course currently supports score='effect_size_only'.") + raise ValueError( + "scan_genome time_course currently supports score='effect_size_only'." + ) if merge_hits: - raise ValueError("scan_genome time_course does not support merge_hits=True.") + raise ValueError( + "scan_genome time_course does not support merge_hits=True." + ) time_order = list(dict.fromkeys(contrast.time_order or [])) window_totals = _aggregate_window_counts(window_summary) scored = _score_paired_time_course(window_summary, time_order=time_order) @@ -980,7 +1111,11 @@ def scan_genome( ] window_table.loc[~covered_mask, paired_score_columns] = pd.NA covered_hits = ranked.merge( - window_totals.loc[:, _WINDOW_KEY_COLUMNS + ["modified_count", "valid_count", "window_fraction"]], + window_totals.loc[ + :, + _WINDOW_KEY_COLUMNS + + ["modified_count", "valid_count", "window_fraction"], + ], on=_WINDOW_KEY_COLUMNS, how="left", sort=False, @@ -1006,8 +1141,12 @@ def scan_genome( "merge_hits": merge_hits, "merge_distance": merge_distance, "motifs": motif_list, - "include_contigs": list(include_contigs) if include_contigs is not None else None, - "exclude_contigs": list(exclude_contigs) if exclude_contigs is not None else None, + "include_contigs": list(include_contigs) + if include_contigs is not None + else None, + "exclude_contigs": list(exclude_contigs) + if exclude_contigs is not None + else None, "contrast_mode": contrast.mode, "contrast_numerator": list(contrast.numerator or []), "contrast_denominator": list(contrast.denominator or []), @@ -1080,8 +1219,12 @@ def scan_genome( "merge_hits": merge_hits, "merge_distance": merge_distance, "motifs": motif_list, - "include_contigs": list(include_contigs) if include_contigs is not None else None, - "exclude_contigs": list(exclude_contigs) if exclude_contigs is not None else None, + "include_contigs": list(include_contigs) + if include_contigs is not None + else None, + "exclude_contigs": list(exclude_contigs) + if exclude_contigs is not None + else None, } if contrast is not None: metadata["contrast_mode"] = contrast.mode diff --git a/dimelo/regulatory_enrichment.py b/dimelo/regulatory_enrichment.py index 7dd7969..3a3e1df 100644 --- a/dimelo/regulatory_enrichment.py +++ b/dimelo/regulatory_enrichment.py @@ -1,14 +1,15 @@ from __future__ import annotations -from dataclasses import dataclass, field import html import http.cookiejar -from pathlib import Path import re import shutil import subprocess import time -from typing import Any, Iterable +from collections.abc import Iterable +from dataclasses import dataclass, field +from pathlib import Path +from typing import Any from urllib import error, parse, request from .models import UniBindJobResult @@ -175,7 +176,9 @@ def normalize_species_name(species: str) -> str: return canonical -def _infer_species_from_genomes(*, reference_genome: str | None, target_genome: str | None) -> str | None: +def _infer_species_from_genomes( + *, reference_genome: str | None, target_genome: str | None +) -> str | None: for genome in (target_genome, reference_genome): if genome is None: continue @@ -292,24 +295,22 @@ def _build_multipart_form( boundary = f"----dimelo-{int(time.time() * 1000)}" chunks: list[bytes] = [] for key, value in fields.items(): - chunks.append(f"--{boundary}\r\n".encode("utf-8")) - chunks.append( - f'Content-Disposition: form-data; name="{key}"\r\n\r\n'.encode("utf-8") - ) + chunks.append(f"--{boundary}\r\n".encode()) + chunks.append(f'Content-Disposition: form-data; name="{key}"\r\n\r\n'.encode()) chunks.append(str(value).encode("utf-8")) chunks.append(b"\r\n") for key, (filename, payload, content_type) in files.items(): - chunks.append(f"--{boundary}\r\n".encode("utf-8")) + chunks.append(f"--{boundary}\r\n".encode()) chunks.append( ( f'Content-Disposition: form-data; name="{key}"; ' f'filename="{filename}"\r\n' - ).encode("utf-8") + ).encode() ) - chunks.append(f"Content-Type: {content_type}\r\n\r\n".encode("utf-8")) + chunks.append(f"Content-Type: {content_type}\r\n\r\n".encode()) chunks.append(payload) chunks.append(b"\r\n") - chunks.append(f"--{boundary}--\r\n".encode("utf-8")) + chunks.append(f"--{boundary}--\r\n".encode()) return b"".join(chunks), boundary @@ -460,7 +461,9 @@ def _fetch_bytes(url: str, *, timeout_seconds: float = 60.0) -> bytes: def _fetch_text(url: str, *, timeout_seconds: float = 60.0) -> str: - return _fetch_bytes(url, timeout_seconds=timeout_seconds).decode("utf-8", errors="replace") + return _fetch_bytes(url, timeout_seconds=timeout_seconds).decode( + "utf-8", errors="replace" + ) def _parse_kv_blocks(text: str) -> list[dict[str, str]]: @@ -550,7 +553,9 @@ def _select_trackdb_url( ) genomes_url = parse.urljoin(hub_url, genomes_file) - genome_blocks = _parse_kv_blocks(_fetch_text(genomes_url, timeout_seconds=timeout_seconds)) + genome_blocks = _parse_kv_blocks( + _fetch_text(genomes_url, timeout_seconds=timeout_seconds) + ) candidates: list[tuple[str, str]] = [] for block in genome_blocks: genome = block.get("genome") @@ -642,7 +647,9 @@ def search_unibind_trackhub_tracks( search_terms: Iterable[str] | None = None, timeout_seconds: float = 60.0, ) -> list[dict[str, str]]: - resolved_hub_url = trackhub_url if trackhub_url is not None else unibind_trackhub_url(collection) + resolved_hub_url = ( + trackhub_url if trackhub_url is not None else unibind_trackhub_url(collection) + ) resolved_assembly, trackdb_url = _select_trackdb_url( hub_url=resolved_hub_url, assembly=assembly, @@ -650,7 +657,9 @@ def search_unibind_trackhub_tracks( ) stanzas = _load_trackdb_stanzas(trackdb_url, timeout_seconds=timeout_seconds) - terms = [str(term).strip().lower() for term in (search_terms or []) if str(term).strip()] + terms = [ + str(term).strip().lower() for term in (search_terms or []) if str(term).strip() + ] rows: list[dict[str, str]] = [] for stanza in stanzas: @@ -703,7 +712,9 @@ def resolve_unibind_track_paths( for raw in track_paths: candidate = Path(raw).expanduser().resolve() if not candidate.exists(): - raise FileNotFoundError(f"UniBind track path does not exist: {candidate}") + raise FileNotFoundError( + f"UniBind track path does not exist: {candidate}" + ) resolved_paths.append(candidate) if not resolved_paths: raise ValueError("track_paths was provided but empty.") @@ -898,9 +909,13 @@ def poll_unibind_job( output_urls = list(current.download_urls) while True: - page_html = _fetch_text(current.job_url, timeout_seconds=request_timeout_seconds) + page_html = _fetch_text( + current.job_url, timeout_seconds=request_timeout_seconds + ) status = _extract_unibind_job_status(page_html) - extracted_results_url = _extract_unibind_results_url(page_html, base_url=current.job_url) + extracted_results_url = _extract_unibind_results_url( + page_html, base_url=current.job_url + ) results_url = extracted_results_url or results_url or current.job_url output_urls = _extract_unibind_output_urls(page_html, base_url=current.job_url) @@ -1089,19 +1104,26 @@ class RegulatoryEnrichmentSpec: def __post_init__(self) -> None: requested = self.providers if self.providers else ("screen", "unibind") - normalized_providers = _unique_preserve_order(_normalize_provider(p) for p in requested) + normalized_providers = _unique_preserve_order( + _normalize_provider(p) for p in requested + ) inferred = _infer_species_from_genomes( reference_genome=self.reference_genome, target_genome=self.target_genome, ) - resolved_species = self.species if self.species is not None else (inferred or _DEFAULT_SPECIES) + resolved_species = ( + self.species if self.species is not None else (inferred or _DEFAULT_SPECIES) + ) canonical_species = normalize_species_name(str(resolved_species)) enabled: list[str] = [] notes: dict[str, str] = {} for provider in normalized_providers: - if provider == "screen" and canonical_species not in _SCREEN_SUPPORTED_SPECIES: + if ( + provider == "screen" + and canonical_species not in _SCREEN_SUPPORTED_SPECIES + ): message = ( "SCREEN disabled for species " f"{canonical_species!r}; SCREEN supports only " @@ -1119,7 +1141,10 @@ def __post_init__(self) -> None: f"Requested providers={normalized_providers}, species={canonical_species!r}." ) - if self.target_genome is None and canonical_species in _DEFAULT_TARGET_GENOME_BY_SPECIES: + if ( + self.target_genome is None + and canonical_species in _DEFAULT_TARGET_GENOME_BY_SPECIES + ): self.target_genome = _DEFAULT_TARGET_GENOME_BY_SPECIES[canonical_species] self.providers = tuple(normalized_providers) diff --git a/dimelo/run_modkit.py b/dimelo/run_modkit.py index ffbaefb..5344f26 100644 --- a/dimelo/run_modkit.py +++ b/dimelo/run_modkit.py @@ -1,6 +1,4 @@ import os -from dataclasses import dataclass -from functools import lru_cache # I believe that pty does not currently work on Windows, although this may change in future releases: https://bugs.python.org/issue41663 # However, it may be that pywinpty, which is installable from pip, would work fine. That just needs to be tested with a Windows machine @@ -11,8 +9,10 @@ import shutil import subprocess import sys +from dataclasses import dataclass +from functools import lru_cache from pathlib import Path -from typing import Optional, TypeAlias, cast +from typing import TypeAlias, cast from tqdm.auto import tqdm @@ -47,6 +47,22 @@ def _strip_runtime_noise(text: str) -> str: return cleaned +def _should_render_live_progress() -> bool: + """ + Decide whether tqdm live bars should be rendered for modkit subprocess output. + + The default "auto" mode disables live bars in notebook/non-TTY contexts where + carriage-return updates tend to produce mangled output. + """ + mode = os.environ.get("DIMELO_PROGRESS_MODE", "auto").strip().lower() + if mode in {"off", "none", "false", "0"}: + return False + if mode in {"on", "force", "true", "1"}: + return True + in_notebook = "JPY_PARENT_PID" in os.environ or "IPYKERNEL_PARENT_PID" in os.environ + return sys.stderr.isatty() and not in_notebook + + def _prepare_modkit_path(quiet: bool = False) -> None: # Add conda env bin folder to path if it is not already present current_interpreter = sys.executable @@ -90,7 +106,7 @@ def _resolve_modkit_executable( raise FileNotFoundError( f"Executable not found for modkit candidate '{requested}'. " 'Install dimelo using "conda env create -f environment.yml" ' - 'or install modkit manually using "conda install nanoporetech::modkit==0.2.4". ' + 'or install modkit manually using "conda install nanoporetech::modkit==0.6.1". ' "Without modkit you cannot run parse_bam functions." ) return discovered @@ -126,15 +142,16 @@ def _get_modkit_capabilities_cached( try: version_result = subprocess.run( [executable, "--version"], - stdout=subprocess.PIPE, - stderr=subprocess.PIPE, + capture_output=True, text=True, check=True, ) - except Exception as exc: # pragma: no cover - direct subprocess failures are environment-specific + except ( + Exception + ) as exc: # pragma: no cover - direct subprocess failures are environment-specific raise FileNotFoundError( 'Executable not found for modkit. Install dimelo using "conda env create -f environment.yml" ' - 'or install modkit manually using "conda install nanoporetech::modkit==0.2.4". ' + 'or install modkit manually using "conda install nanoporetech::modkit==0.6.1". ' "Without modkit you cannot run parse_bam functions." ) from exc @@ -144,8 +161,7 @@ def _get_modkit_capabilities_cached( pileup_help = subprocess.run( [executable, "pileup", "--help"], - stdout=subprocess.PIPE, - stderr=subprocess.PIPE, + capture_output=True, text=True, check=True, ) @@ -153,35 +169,54 @@ def _get_modkit_capabilities_cached( extract_help = subprocess.run( [executable, "extract", "--help"], - stdout=subprocess.PIPE, - stderr=subprocess.PIPE, + capture_output=True, text=True, check=True, ) extract_help_text = (extract_help.stdout or "") + "\n" + (extract_help.stderr or "") - supports_extract_subcommands = "extract " in extract_help_text + supports_extract_subcommands = ( + re.search(r"(?m)^Usage:\s+modkit\s+extract\s+", extract_help_text) + is not None + ) + if ( + not supports_extract_subcommands + and version_tuple is not None + and len(version_tuple) >= 2 + and (version_tuple[0], version_tuple[1]) >= (0, 6) + ): + supports_extract_subcommands = True extract_command_help_text = extract_help_text if supports_extract_subcommands: - extract_full_help = subprocess.run( - [executable, "extract", "full", "--help"], - stdout=subprocess.PIPE, - stderr=subprocess.PIPE, - text=True, - check=True, - ) - extract_command_help_text = (extract_full_help.stdout or "") + "\n" + ( - extract_full_help.stderr or "" - ) + try: + extract_full_help = subprocess.run( + [executable, "extract", "full", "--help"], + capture_output=True, + text=True, + check=True, + ) + extract_command_help_text = ( + (extract_full_help.stdout or "") + + "\n" + + (extract_full_help.stderr or "") + ) + except subprocess.CalledProcessError: + # Fall back to top-level extract help text if subcommand help probing fails. + extract_command_help_text = extract_help_text minor_version = ( - (version_tuple[0], version_tuple[1]) if version_tuple and len(version_tuple) >= 2 else None + (version_tuple[0], version_tuple[1]) + if version_tuple and len(version_tuple) >= 2 + else None ) - if minor_version is not None and minor_version not in SUPPORTED_MODKIT_MINOR_VERSIONS: - if not quiet: - print( - "modkit found with version " - f"{version or version_raw}. Officially tested series are {', '.join(SUPPORTED_MODKIT_SERIES)}." - ) + if ( + minor_version is not None + and minor_version not in SUPPORTED_MODKIT_MINOR_VERSIONS + and not quiet + ): + print( + "modkit found with version " + f"{version or version_raw}. Officially tested series are {', '.join(SUPPORTED_MODKIT_SERIES)}." + ) return ModkitCapabilities( executable=executable, @@ -189,8 +224,12 @@ def _get_modkit_capabilities_cached( version=version, version_tuple=version_tuple, supports_mod_threshold=_help_supports_flag(pileup_help_text, "--mod-threshold"), - supports_mod_thresholds=_help_supports_flag(pileup_help_text, "--mod-thresholds"), - supports_modified_bases=_help_supports_flag(pileup_help_text, "--modified-bases"), + supports_mod_thresholds=_help_supports_flag( + pileup_help_text, "--mod-thresholds" + ), + supports_modified_bases=_help_supports_flag( + pileup_help_text, "--modified-bases" + ), supports_force_allow_implicit=_help_supports_flag( pileup_help_text, "--force-allow-implicit" ), @@ -309,13 +348,15 @@ def run_with_progress_bars( f"{ref_genome.name} is gzipped, which will cause modkit to fail.\ngunzip {ref_genome.name} and try again." ) - # Set up progress bar variables to display progress updates when not in quiet mode + render_progress = (not quiet) and _should_render_live_progress() + + # Set up progress bar variables to display progress updates when enabled format_pre = "{bar}| {desc} {percentage:3.0f}% | {elapsed}" format_contigs = "{bar}| {desc} {percentage:3.0f}% | {elapsed}<{remaining}" format_chr = "{bar}| {desc} {percentage:3.0f}%" - pbar_pre: Optional[tqdm] = None - pbar_contigs: Optional[tqdm] = None - pbar_chr: Optional[tqdm] = None + pbar_pre: tqdm | None = None + pbar_contigs: tqdm | None = None + pbar_chr: tqdm | None = None finding_progress_dict: FindingProgressDict = {} in_contig_progress = (0, 1) @@ -357,84 +398,80 @@ def run_with_progress_bars( if not data: break # No more data - if quiet: - # If we are in quiet mode, nothing gets grabbed - continue - else: - # Create the progress bars when first entering this code block - if not progress_bars_initialized: - pbar_pre = tqdm( - total=100, - desc=f"Step 1: Identify motif locations in {ref_genome.name}", - bar_format=format_pre, - ) - pbar_contigs = tqdm( - total=100, - desc=f"Step 2: Parse regions in {input_file.name}", - bar_format=format_contigs, - ) - pbar_chr = tqdm( - total=100, - desc="", - bar_format=format_chr, + if render_progress and not progress_bars_initialized: + pbar_pre = tqdm( + total=100, + desc=f"Step 1: Identify motif locations in {ref_genome.name}", + bar_format=format_pre, + ) + pbar_contigs = tqdm( + total=100, + desc=f"Step 2: Parse regions in {input_file.name}", + bar_format=format_contigs, + ) + pbar_chr = tqdm( + total=100, + desc="", + bar_format=format_chr, + ) + progress_bars_initialized = True + + buffer_bytes += data # Accumulate bytes in the buffer + + try: + # Try to decode the accumulated bytes + # This will throw a UnicodeDecodeError if not complete, which is ok! Then we just continue on + text = buffer_bytes.decode("utf-8") + readout_count += 1 + buffer_bytes.clear() # Clear the buffer after successful decoding + # If we have hit an error or modkit is done, just accumulate the rest of the output and then deal with it: + # no need to check the progress tracking stuff in that case + if err_flag or done_flag: + tail_buffer = _strip_runtime_noise(tail_buffer + text) + # If we haven't hit an error or a done state, first check for that + else: + tail_buffer = _strip_runtime_noise( + (tail_buffer + text)[-buffer_size:] ) - progress_bars_initialized = True - - buffer_bytes += data # Accumulate bytes in the buffer - - try: - # Try to decode the accumulated bytes - # This will throw a UnicodeDecodeError if not complete, which is ok! Then we just continue on - text = buffer_bytes.decode("utf-8") - readout_count += 1 - buffer_bytes.clear() # Clear the buffer after successful decoding - # If we have hit an error or modkit is done, just accumulate the rest of the output and then deal with it: - # no need to check the progress tracking stuff in that case - if err_flag or done_flag: - tail_buffer = _strip_runtime_noise(tail_buffer + text) - # If we haven't hit an error or a done state, first check for that - else: - tail_buffer = _strip_runtime_noise( - (tail_buffer + text)[-buffer_size:] - ) - if err_str in tail_buffer: - index = tail_buffer.find(err_str) - tail_buffer = tail_buffer[index:] - err_flag = True - elif done_str in tail_buffer: - index = tail_buffer.find(done_str) - tail_buffer = tail_buffer[index - 2 :] - done_flag = True - # If the process is ongoing, then go through the possible cases and create/adjust pbars accordingly - # We only sometimes want to update progress because otherwise the constant updates slow us down - elif ( - readout_count % progress_granularity == 0 - and progress_bars_initialized - ): - region_parsing_started, in_contig_progress = ( - update_progress_bars( - pbar_pre=pbar_pre, - pbar_contigs=pbar_contigs, - pbar_chr=pbar_chr, - tail_buffer=tail_buffer, - contigs_progress_regex=contigs_progress_regex, - single_contig_regex=single_contig_regex, - find_motifs_regex=find_motifs_regex, - load_fasta_regex=load_fasta_regex, - region_parsing_started=region_parsing_started, - in_contig_progress=in_contig_progress, - finding_progress_dict=finding_progress_dict, - ref_genome=ref_genome, - input_file=input_file, - motifs=motifs, - ) + if err_str in tail_buffer: + index = tail_buffer.find(err_str) + tail_buffer = tail_buffer[index:] + err_flag = True + elif done_str in tail_buffer: + index = tail_buffer.find(done_str) + tail_buffer = tail_buffer[index - 2 :] + done_flag = True + # If the process is ongoing, then go through the possible cases and create/adjust pbars accordingly + # We only sometimes want to update progress because otherwise the constant updates slow us down + elif ( + render_progress + and readout_count % progress_granularity == 0 + and progress_bars_initialized + ): + region_parsing_started, in_contig_progress = ( + update_progress_bars( + pbar_pre=pbar_pre, + pbar_contigs=pbar_contigs, + pbar_chr=pbar_chr, + tail_buffer=tail_buffer, + contigs_progress_regex=contigs_progress_regex, + single_contig_regex=single_contig_regex, + find_motifs_regex=find_motifs_regex, + load_fasta_regex=load_fasta_regex, + region_parsing_started=region_parsing_started, + in_contig_progress=in_contig_progress, + finding_progress_dict=finding_progress_dict, + ref_genome=ref_genome, + input_file=input_file, + motifs=motifs, ) + ) - except UnicodeDecodeError: - # If decoding fails, continue accumulating bytes - continue - except Exception as e: - raise e + except UnicodeDecodeError: + # If decoding fails, continue accumulating bytes + continue + except Exception as e: + raise e except OSError: break @@ -515,9 +552,9 @@ def run_with_progress_bars( def update_progress_bars( - pbar_pre: Optional[tqdm], - pbar_contigs: Optional[tqdm], - pbar_chr: Optional[tqdm], + pbar_pre: tqdm | None, + pbar_contigs: tqdm | None, + pbar_chr: tqdm | None, tail_buffer: str, contigs_progress_regex: str, single_contig_regex: str, diff --git a/dimelo/shared_cluster_tests.py b/dimelo/shared_cluster_tests.py index 66012d1..d6ba032 100644 --- a/dimelo/shared_cluster_tests.py +++ b/dimelo/shared_cluster_tests.py @@ -1,6 +1,5 @@ from __future__ import annotations -from itertools import combinations from typing import Any import numpy as np @@ -40,9 +39,13 @@ def _require_requested_conditions_present( ) -def _require_time_order_present(sample_table: pd.DataFrame, time_order: list[str]) -> None: +def _require_time_order_present( + sample_table: pd.DataFrame, time_order: list[str] +) -> None: available_conditions = set(sample_table["condition"].dropna().unique()) - missing = [condition for condition in time_order if condition not in available_conditions] + missing = [ + condition for condition in time_order if condition not in available_conditions + ] if missing: raise ValueError( "Shared cluster time_course requested missing time_order condition(s): " @@ -83,7 +86,11 @@ def _cluster_order(result: SharedClusterResult) -> list[str]: if cluster_labels: return cluster_labels return ( - result.cluster_distribution["cluster"].drop_duplicates().astype(str).sort_values().tolist() + result.cluster_distribution["cluster"] + .drop_duplicates() + .astype(str) + .sort_values() + .tolist() ) @@ -91,7 +98,9 @@ def _composition_effect_size(summary_table: pd.DataFrame) -> float: return float(summary_table["delta_fraction"].abs().sum() / 2.0) -def _composition_effect_size_from_vectors(observed: np.ndarray, reference: np.ndarray) -> float: +def _composition_effect_size_from_vectors( + observed: np.ndarray, reference: np.ndarray +) -> float: return float(np.abs(observed - reference).sum() / 2.0) @@ -174,7 +183,9 @@ def _add_pairing_metadata( ) pairing = assignments.loc[:, ["sample_id", pairing_key]].drop_duplicates() - pair_counts = pairing.groupby("sample_id", dropna=False)[pairing_key].nunique(dropna=False) + pair_counts = pairing.groupby("sample_id", dropna=False)[pairing_key].nunique( + dropna=False + ) if (pair_counts > 1).any(): raise ValueError( "Shared cluster matched_pairwise requires each sample_id to map to exactly one pairing key." @@ -199,7 +210,9 @@ def _prepare_unpaired_group_table( } _require_requested_conditions_present(sample_matrix, side_specs=side_specs) requested_conditions = set(side_specs["numerator"]) | set(side_specs["denominator"]) - filtered = sample_matrix.loc[sample_matrix["condition"].isin(requested_conditions)].copy() + filtered = sample_matrix.loc[ + sample_matrix["condition"].isin(requested_conditions) + ].copy() filtered["contrast_side"] = np.where( filtered["condition"].isin(side_specs["numerator"]), "numerator", @@ -232,19 +245,18 @@ def _prepare_paired_group_table( } _require_requested_conditions_present(sample_matrix, side_specs=side_specs) requested_conditions = set(side_specs["numerator"]) | set(side_specs["denominator"]) - filtered = sample_matrix.loc[sample_matrix["condition"].isin(requested_conditions)].copy() + filtered = sample_matrix.loc[ + sample_matrix["condition"].isin(requested_conditions) + ].copy() filtered["contrast_side"] = np.where( filtered["condition"].isin(side_specs["numerator"]), "numerator", "denominator", ) - grouped = ( - filtered.groupby([contrast.pairing_key, "contrast_side"], as_index=False, sort=False)[ - cluster_order - ] - .mean() - ) + grouped = filtered.groupby( + [contrast.pairing_key, "contrast_side"], as_index=False, sort=False + )[cluster_order].mean() side_sets = ( grouped.loc[:, [contrast.pairing_key, "contrast_side"]] .drop_duplicates() @@ -252,16 +264,24 @@ def _prepare_paired_group_table( .agg(lambda values: set(values)) ) complete_pairs = [ - pair_id for pair_id, sides in side_sets.items() if {"numerator", "denominator"} <= sides + pair_id + for pair_id, sides in side_sets.items() + if {"numerator", "denominator"} <= sides ] if not complete_pairs: - raise ValueError("Shared cluster matched_pairwise found no complete matched units.") + raise ValueError( + "Shared cluster matched_pairwise found no complete matched units." + ) - return grouped.loc[grouped[contrast.pairing_key].isin(complete_pairs)].copy(), cluster_order + return grouped.loc[ + grouped[contrast.pairing_key].isin(complete_pairs) + ].copy(), cluster_order def _permutation_p_value(observed: float, permuted: np.ndarray) -> float: - return float((1 + np.count_nonzero(permuted >= observed - 1e-12)) / (len(permuted) + 1)) + return float( + (1 + np.count_nonzero(permuted >= observed - 1e-12)) / (len(permuted) + 1) + ) def _run_unpaired_permutations( @@ -312,10 +332,16 @@ def _score_unpaired_group( n_permutations: int, random_state: int | None, ) -> tuple[pd.DataFrame, dict[str, Any]]: - numerator = group_table.loc[group_table["contrast_side"] == "numerator", cluster_order] - denominator = group_table.loc[group_table["contrast_side"] == "denominator", cluster_order] + numerator = group_table.loc[ + group_table["contrast_side"] == "numerator", cluster_order + ] + denominator = group_table.loc[ + group_table["contrast_side"] == "denominator", cluster_order + ] if numerator.empty or denominator.empty: - raise ValueError("Shared cluster tests require evidence for both contrast sides.") + raise ValueError( + "Shared cluster tests require evidence for both contrast sides." + ) observed_fraction = numerator.mean(axis=0) reference_fraction = denominator.mean(axis=0) @@ -367,7 +393,9 @@ def _score_paired_group( ) common_pairs = numerator.index.intersection(denominator.index) if common_pairs.empty: - raise ValueError("Shared cluster matched_pairwise found no complete matched units.") + raise ValueError( + "Shared cluster matched_pairwise found no complete matched units." + ) numerator = numerator.loc[common_pairs] denominator = denominator.loc[common_pairs] @@ -479,7 +507,9 @@ def _build_pooled_omnibus_p_value( } _require_requested_conditions_present(condition_table, side_specs=side_specs) requested_conditions = side_specs["numerator"] + side_specs["denominator"] - filtered = condition_table.loc[condition_table["condition"].isin(requested_conditions)].copy() + filtered = condition_table.loc[ + condition_table["condition"].isin(requested_conditions) + ].copy() contingency = ( filtered.pivot_table( index="condition", @@ -488,11 +518,15 @@ def _build_pooled_omnibus_p_value( aggfunc="sum", fill_value=0, ) - .reindex(index=requested_conditions, columns=_cluster_order(result), fill_value=0) + .reindex( + index=requested_conditions, columns=_cluster_order(result), fill_value=0 + ) .astype(float) ) if contingency.shape[0] < 2 or contingency.shape[1] < 2: - raise ValueError("shared_cluster_tests pooled screening requires at least 2x2 counts.") + raise ValueError( + "shared_cluster_tests pooled screening requires at least 2x2 counts." + ) if test == "chi_squared": _, omnibus_p_value, _, _ = stats.chi2_contingency( @@ -539,20 +573,30 @@ def _score_time_course( cluster_order = _cluster_order(result) filtered = sample_matrix.loc[sample_matrix["condition"].isin(time_order)].copy() - filtered["condition"] = pd.Categorical(filtered["condition"], categories=time_order, ordered=True) - filtered = filtered.sort_values(["condition", "sample_id"], kind="stable").reset_index(drop=True) + filtered["condition"] = pd.Categorical( + filtered["condition"], categories=time_order, ordered=True + ) + filtered = filtered.sort_values( + ["condition", "sample_id"], kind="stable" + ).reset_index(drop=True) n_timepoints = len(time_order) - condition_codes = filtered["condition"].cat.codes.to_numpy(dtype=np.int64, copy=False) + condition_codes = filtered["condition"].cat.codes.to_numpy( + dtype=np.int64, copy=False + ) if (condition_codes < 0).any(): - raise ValueError("Shared cluster time_course found rows with conditions outside time_order.") + raise ValueError( + "Shared cluster time_course found rows with conditions outside time_order." + ) value_matrix = filtered.loc[:, cluster_order].to_numpy(dtype=float) observed_matrix = _mean_by_group_codes( value_matrix, condition_codes, n_groups=n_timepoints, ) - counts = np.bincount(condition_codes, minlength=n_timepoints).astype(int, copy=False) + counts = np.bincount(condition_codes, minlength=n_timepoints).astype( + int, copy=False + ) time_course_table = pd.DataFrame(observed_matrix, columns=cluster_order) time_course_table.insert(0, "timepoint", time_order) time_course_table["n_samples"] = counts @@ -560,7 +604,9 @@ def _score_time_course( observed_first = observed_matrix[0] observed_last = observed_matrix[-1] observed_delta = observed_last - observed_first - observed_omnibus = _composition_effect_size_from_vectors(observed_last, observed_first) + observed_omnibus = _composition_effect_size_from_vectors( + observed_last, observed_first + ) observed_trend = _trend_statistic(observed_matrix) rng = np.random.default_rng(random_state) @@ -577,9 +623,11 @@ def _score_time_course( ) permuted_delta = permuted_matrix[-1] - permuted_matrix[0] permuted_cluster_stats[permutation_index] = np.abs(permuted_delta) - permuted_omnibus_stats[permutation_index] = _composition_effect_size_from_vectors( - permuted_matrix[-1], - permuted_matrix[0], + permuted_omnibus_stats[permutation_index] = ( + _composition_effect_size_from_vectors( + permuted_matrix[-1], + permuted_matrix[0], + ) ) permuted_trend_stats[permutation_index] = _trend_statistic(permuted_matrix) @@ -619,7 +667,9 @@ def _score_time_course( if include_pairwise: pairwise_rows = [] - for left_timepoint, right_timepoint in zip(time_order[:-1], time_order[1:]): + for left_timepoint, right_timepoint in zip( + time_order[:-1], time_order[1:], strict=False + ): pair_table = filtered.loc[ filtered["condition"].isin([left_timepoint, right_timepoint]) ].copy() @@ -695,13 +745,17 @@ def shared_cluster_tests( ) -> SharedClusterContrastResult: _require_supported_shared_cluster_mode(contrast) if multiple_testing != "fdr_bh": - raise ValueError("shared_cluster_tests currently requires multiple_testing='fdr_bh'.") + raise ValueError( + "shared_cluster_tests currently requires multiple_testing='fdr_bh'." + ) if n_permutations <= 0: raise ValueError("shared_cluster_tests requires n_permutations > 0.") if contrast.mode == "time_course": if test != "permutation": - raise ValueError("shared_cluster_tests time_course currently requires test='permutation'.") + raise ValueError( + "shared_cluster_tests time_course currently requires test='permutation'." + ) return _score_time_course( result=result, contrast=contrast, @@ -712,7 +766,9 @@ def shared_cluster_tests( if test == "permutation": if contrast.mode == "matched_pairwise": - pair_table, cluster_order = _prepare_paired_group_table(result, contrast=contrast) + pair_table, cluster_order = _prepare_paired_group_table( + result, contrast=contrast + ) details, stats_metadata = _score_paired_group( pair_table, cluster_order=cluster_order, @@ -722,7 +778,9 @@ def shared_cluster_tests( ) sample_plot_table = pair_table.copy() else: - group_table, cluster_order = _prepare_unpaired_group_table(result, contrast=contrast) + group_table, cluster_order = _prepare_unpaired_group_table( + result, contrast=contrast + ) details, stats_metadata = _score_unpaired_group( group_table, cluster_order=cluster_order, @@ -750,14 +808,22 @@ def shared_cluster_tests( "contrast_mode": contrast.mode, "contrast_id": _contrast_id(contrast), "paired": bool(stats_metadata["paired"]), - "pairing_key": contrast.pairing_key if contrast.mode == "matched_pairwise" else None, + "pairing_key": contrast.pairing_key + if contrast.mode == "matched_pairwise" + else None, "test": test, "multiple_testing": multiple_testing, "n_permutations": int(n_permutations), "random_state": random_state, "inference_level": "replicate_aware", } - metadata.update({key: value for key, value in stats_metadata.items() if key.startswith("n_")}) + metadata.update( + { + key: value + for key, value in stats_metadata.items() + if key.startswith("n_") + } + ) plot_data = { "summary_table": summary.copy(), "cluster_effect_table": details.copy(), @@ -776,7 +842,9 @@ def shared_cluster_tests( "'chi_squared', or 'g_test'." ) - group_table, cluster_order = _prepare_unpaired_group_table(result, contrast=contrast) + group_table, cluster_order = _prepare_unpaired_group_table( + result, contrast=contrast + ) details, stats_metadata = _score_unpaired_group( group_table, cluster_order=cluster_order, @@ -787,7 +855,9 @@ def shared_cluster_tests( details, permuted_cluster_stats=stats_metadata["permuted_cluster_stats"], ) - omnibus_p_value = _build_pooled_omnibus_p_value(result=result, contrast=contrast, test=test) + omnibus_p_value = _build_pooled_omnibus_p_value( + result=result, contrast=contrast, test=test + ) summary = _build_summary( details, contrast=contrast, @@ -806,7 +876,9 @@ def shared_cluster_tests( "random_state": random_state, "inference_level": "pooled_screen", } - metadata.update({key: value for key, value in stats_metadata.items() if key.startswith("n_")}) + metadata.update( + {key: value for key, value in stats_metadata.items() if key.startswith("n_")} + ) plot_data = { "summary_table": summary.copy(), "cluster_effect_table": details.copy(), diff --git a/dimelo/test/dimelo_test.py b/dimelo/test/dimelo_test.py index 170397a..f20bc6d 100644 --- a/dimelo/test/dimelo_test.py +++ b/dimelo/test/dimelo_test.py @@ -62,12 +62,12 @@ def test_unit__pileup( # Read and compare file contents file1_contents = f1.read() file2_contents = f2.read() - assert ( - file1_contents == file2_contents - ), f"{test_case}: {pileup_bed} does not match {pileup_target}." - assert filecmp.cmp( - regions_processed, regions_target, shallow=False - ), f"{test_case}: {regions_processed} does not match {regions_target}." + assert file1_contents == file2_contents, ( + f"{test_case}: {pileup_bed} does not match {pileup_target}." + ) + assert filecmp.cmp(regions_processed, regions_target, shallow=False), ( + f"{test_case}: {regions_processed} does not match {regions_target}." + ) else: print(f"{test_case} skipped for pileup.") @@ -119,13 +119,13 @@ def test_unit__extract( for target_item in target_dataset ], f"{test_case}: {dataset} does not match." else: - assert ( - test_dataset == target_dataset - ), f"{test_case}: {dataset} does not match." + assert test_dataset == target_dataset, ( + f"{test_case}: {dataset} does not match." + ) # assert os.path.getsize(extract_h5) == os.path.getsize(extract_target), f"{test_case}: {extract_h5} does not match {extract_target}." - assert filecmp.cmp( - regions_processed, regions_target, shallow=False - ), f"{test_case}: {regions_processed} does not match {regions_target}." + assert filecmp.cmp(regions_processed, regions_target, shallow=False), ( + f"{test_case}: {regions_processed} does not match {regions_target}." + ) else: print(f"{test_case} skipped for extract.") @@ -159,9 +159,9 @@ def test_integration__pileup_load_plot( motif=motif, **kwargs_counts_from_bedmethyl, ) - assert ( - actual == expected - ), f"{test_case}: Counts for motif {motif} are not equal" + assert actual == expected, ( + f"{test_case}: Counts for motif {motif} are not equal" + ) kwargs_vectors_from_bedmethyl = filter_kwargs_for_func( dm.load_processed.pileup_vectors_from_bedmethyl, kwargs @@ -173,16 +173,16 @@ def test_integration__pileup_load_plot( motif=motif, **kwargs_vectors_from_bedmethyl, ) - assert len(expected_tuple) == len( - actual_tuple - ), f"{test_case}: Unexpected number of arrays returned for {motif}" + assert len(expected_tuple) == len(actual_tuple), ( + f"{test_case}: Unexpected number of arrays returned for {motif}" + ) - for expected, actual in zip(expected_tuple, actual_tuple): + for expected, actual in zip(expected_tuple, actual_tuple, strict=False): # TODO: The following was the original assertion error message, but it was not written in a functional way. Find a way to make it work as intended. # assert np.array_equal(expected, actual), f"{test_case}: Arrays for motif {motif} are not equal: expected {value} but got {actual[key]}" - assert np.array_equal( - expected, actual - ), f"{test_case}: Arrays for motif {motif} are not equal." + assert np.array_equal(expected, actual), ( + f"{test_case}: Arrays for motif {motif} are not equal." + ) else: print( f"{test_case} loading skipped for pileup_load_plot, continuing to plotting." @@ -277,13 +277,13 @@ def test_integration__extract_load_plot( {value[np.where(value != actual[key])[0]]} vs {actual[key][np.where(value != actual[key])[0]]}. """ elif isinstance(value, (str, int, bool)): - assert ( - actual[key] == expected[key] - ), f"{test_case}: Values for {key} are not equal: expected {value} but got {actual[key]}." + assert actual[key] == expected[key], ( + f"{test_case}: Values for {key} are not equal: expected {value} but got {actual[key]}." + ) else: - assert np.isclose( - actual[key], value, atol=1e-4 - ), f"{test_case}: Values for {key} are not equal: expected {value} but got {actual[key]}." + assert np.isclose(actual[key], value, atol=1e-4), ( + f"{test_case}: Values for {key} are not equal: expected {value} but got {actual[key]}." + ) else: print("{test_case} skipped for read_vectors_from_hdf5.") kwargs_plot_reads_plot_reads = filter_kwargs_for_func( @@ -301,9 +301,9 @@ def test_integration__extract_load_plot( mod_file_name=extract_h5, **kwargs_plot_reads_plot_reads, ) - assert "No threshold has been applied" in str( - excinfo.value - ), f"{test_case}: unexpected exception {excinfo.value}" + assert "No threshold has been applied" in str(excinfo.value), ( + f"{test_case}: unexpected exception {excinfo.value}" + ) # providing a threshold should be enough to run plot_reads.plot_reads without an error kwargs_plot_reads_plot_reads["thresh"] = 0.75 ax = dm.plot_reads.plot_reads( @@ -384,9 +384,9 @@ def test_unit__pileup_counts_from_bedmethyl( motif=motif, **kwargs_counts_from_bedmethyl, ) - assert ( - actual == expected - ), f"{test_case}: Counts for motif {motif} are not equal" + assert actual == expected, ( + f"{test_case}: Counts for motif {motif} are not equal" + ) else: print(f"{test_case} skipped for pileup_counts_from_bedmethyl.") @@ -407,14 +407,14 @@ def test_unit__pileup_vectors_from_bedmethyl( motif=motif, **kwargs_vectors_from_bedmethyl, ) - assert len(expected_tuple) == len( - actual_tuple - ), f"{test_case}: Unexpected number of arrays returned for {motif}" - - for expected, actual in zip(expected_tuple, actual_tuple): - assert np.array_equal( - expected, actual - ), f"{test_case}: Arrays for motif {motif} are not equal" + assert len(expected_tuple) == len(actual_tuple), ( + f"{test_case}: Unexpected number of arrays returned for {motif}" + ) + + for expected, actual in zip(expected_tuple, actual_tuple, strict=False): + assert np.array_equal(expected, actual), ( + f"{test_case}: Arrays for motif {motif} are not equal" + ) else: print(f"{test_case} skipped for pileup_vectors_from_bedmethyl.") @@ -450,13 +450,13 @@ def test_unit__read_vectors_from_hdf5( {value[np.where(value != actual[key])[0]]} vs {actual[key][np.where(value != actual[key])[0]]}. """ elif isinstance(value, (str, int, bool)): - assert ( - actual[key] == expected[key] - ), f"{test_case}: Values for {key} are not equal: expected {value} but got {actual[key]}." + assert actual[key] == expected[key], ( + f"{test_case}: Values for {key} are not equal: expected {value} but got {actual[key]}." + ) else: - assert np.isclose( - actual[key], value, atol=1e-4 - ), f"{test_case}: Values for {key} are not equal: expected {value} but got {actual[key]}." + assert np.isclose(actual[key], value, atol=1e-4), ( + f"{test_case}: Values for {key} are not equal: expected {value} but got {actual[key]}." + ) else: print("{test_case} skipped for read_vectors_from_hdf5.") @@ -560,9 +560,9 @@ def test_unit__plot_enrichment_plot_enrichment( sample_names=["label" for _ in regions_list], **kwargs_plot_enrichment_plot_enrichment, ) - assert isinstance( - ax, Axes - ), f"{test_case}: plotting failed for {motif}." + assert isinstance(ax, Axes), ( + f"{test_case}: plotting failed for {motif}." + ) else: print(f"{test_case} skipped for plot_enrichment.plot_enrichment.") @@ -589,9 +589,9 @@ def test_unit__plot_enrichment_by_regions( sample_names=["label" for _ in regions_list], **kwargs_plot_enrichment_by_regions, ) - assert isinstance( - ax, Axes - ), f"{test_case}: plotting failed for {motif}." + assert isinstance(ax, Axes), ( + f"{test_case}: plotting failed for {motif}." + ) else: print(f"{test_case} skipped for plot_enrichment.by_regions.") @@ -720,9 +720,9 @@ def test_unit__plot_enrichment_profile_plot_enrichment_profile( sample_names=["label" for _ in regions_list], **kwargs_plot_enrichment_profile_plot_enrichment_profile, ) - assert isinstance( - ax, Axes - ), f"{test_case}: plotting failed for {motif}." + assert isinstance(ax, Axes), ( + f"{test_case}: plotting failed for {motif}." + ) else: print( f"{test_case} skipped for plot_enrichment_profile.plot_enrichment_profile." @@ -753,9 +753,9 @@ def test_unit__plot_enrichment_profile_by_regions( sample_names=["label" for _ in regions_list], **kwargs_plot_enrichment_profile_by_regions, ) - assert isinstance( - ax, Axes - ), f"{test_case}: plotting failed for {motif}." + assert isinstance(ax, Axes), ( + f"{test_case}: plotting failed for {motif}." + ) else: print(f"{test_case} skipped for plot_enrichment_profile.by_regions.") @@ -886,9 +886,9 @@ def test_unit__plot_depth_profile_plot_depth_profile( sample_names=["label" for _ in regions_list], **kwargs_plot_depth_profile_plot_depth_profile, ) - assert isinstance( - ax, Axes - ), f"{test_case}: plotting failed for {motif}." + assert isinstance(ax, Axes), ( + f"{test_case}: plotting failed for {motif}." + ) else: print(f"{test_case} skipped for plot_depth_profile.plot_depth_profile.") @@ -917,9 +917,9 @@ def test_unit__plot_depth_profile_by_regions( sample_names=["label" for _ in regions_list], **kwargs_plot_depth_profile_by_regions, ) - assert isinstance( - ax, Axes - ), f"{test_case}: plotting failed for {motif}." + assert isinstance(ax, Axes), ( + f"{test_case}: plotting failed for {motif}." + ) else: print(f"{test_case} skipped for plot_depth_profile.by_regions.") @@ -1046,9 +1046,9 @@ def test_unit__plot_depth_histogram_plot_depth_histogram( sample_names=["label" for _ in regions_list], **kwargs_plot_depth_histogram_plot_depth_histogram, ) - assert isinstance( - ax, Axes - ), f"{test_case}: plotting failed for {motif}." + assert isinstance(ax, Axes), ( + f"{test_case}: plotting failed for {motif}." + ) else: print(f"{test_case} skipped for plot_depth_histogram.plot_depth_histogram.") @@ -1077,9 +1077,9 @@ def test_unit__plot_depth_histogram_by_regions( sample_names=["label" for _ in regions_list], **kwargs_plot_depth_histogram_by_regions, ) - assert isinstance( - ax, Axes - ), f"{test_case}: plotting failed for {motif}." + assert isinstance(ax, Axes), ( + f"{test_case}: plotting failed for {motif}." + ) else: print(f"{test_case} skipped for plot_depth_histogram.by_regions.") @@ -1168,9 +1168,9 @@ def test_unit__plot_reads_plot_reads( mod_file_name=results["extract"][0], **kwargs_plot_reads_plot_reads, ) - assert "No threshold has been applied" in str( - excinfo.value - ), f"{test_case}: unexpected exception {excinfo.value}" + assert "No threshold has been applied" in str(excinfo.value), ( + f"{test_case}: unexpected exception {excinfo.value}" + ) # providing a threshold should be enough to run plot_reads.plot_reads without an error kwargs_plot_reads_plot_reads["thresh"] = 0.75 ax = dm.plot_reads.plot_reads( @@ -1208,9 +1208,9 @@ def test_unit__plot_read_browser( region=kwargs["regions"], **kwargs_plot_read_browser, ) - assert isinstance( - fig, plotly.graph_objs.Figure - ), f"{test_case}: plotting failed." + assert isinstance(fig, plotly.graph_objs.Figure), ( + f"{test_case}: plotting failed." + ) else: with pytest.raises(ValueError) as excinfo: fig = dm.plot_read_browser.plot_read_browser( @@ -1222,22 +1222,23 @@ def test_unit__plot_read_browser( isinstance(kwargs["regions"], list) or Path(kwargs["regions"]).suffix == ".bed" ) and kwargs["thresh"] is None: - assert ( - "Invalid region" in str(excinfo.value) - ), f"{test_case}: unexpected exception for no-threshold bad-region case {excinfo.value}" + assert "Invalid region" in str(excinfo.value), ( + f"{test_case}: unexpected exception for no-threshold bad-region case {excinfo.value}" + ) elif ( kwargs["thresh"] is not None and not isinstance(kwargs["regions"], list) and Path(kwargs["regions"]).suffix != ".bed" ): - assert ( - "A threshold has been applied" in str(excinfo.value) - ), f"{test_case}: unexpected exception thresholded valid-region case {excinfo.value}" + assert "A threshold has been applied" in str(excinfo.value), ( + f"{test_case}: unexpected exception thresholded valid-region case {excinfo.value}" + ) else: - assert ( - "A threshold has been applied" in str(excinfo.value) - or "Invalid region" in str(excinfo.value) - ), f"{test_case}: unexpected exception thresholded bad-region case {excinfo.value}" + assert "A threshold has been applied" in str( + excinfo.value + ) or "Invalid region" in str(excinfo.value), ( + f"{test_case}: unexpected exception thresholded bad-region case {excinfo.value}" + ) else: print(f"{test_case} skipped for test_unit__plot_read_browser") diff --git a/dimelo/utils.py b/dimelo/utils.py index 9f87fbb..38daa6b 100644 --- a/dimelo/utils.py +++ b/dimelo/utils.py @@ -1,3 +1,4 @@ +import contextlib import multiprocessing import os from collections import defaultdict @@ -65,10 +66,8 @@ def _parse_positive_int(value: str | None) -> int | None: def _effective_cpu_count() -> int: candidates: list[int] = [] - try: + with contextlib.suppress(Exception): candidates.append(int(multiprocessing.cpu_count())) - except Exception: - pass try: affinity = os.sched_getaffinity(0) @@ -393,7 +392,9 @@ def line_plot( ValueError: raised if any vectors are of unequal length """ # construct dict of {vector_name: vector}, including the x vector using dict union operations - data_dict = {indep_name: indep_vector} | dict(zip(dep_names, dep_vectors)) + data_dict = {indep_name: indep_vector} | dict( + zip(dep_names, dep_vectors, strict=False) + ) hue_column = legend_title if legend_title else "variable" # construct long-form data table for plotting try: diff --git a/dimelo/workflows.py b/dimelo/workflows.py index a6c711d..209ffc7 100644 --- a/dimelo/workflows.py +++ b/dimelo/workflows.py @@ -1,29 +1,30 @@ from __future__ import annotations +from collections.abc import Iterable from pathlib import Path -from typing import Any, Iterable +from typing import Any import numpy as np import pandas as pd from tqdm.auto import tqdm -from .artifacts import resolve_artifact from . import ( chip_atlas, cluster, - dmr, distribution, + dmr, plotting, - regulatory_enrichment, region_analysis, region_contrasts, region_discovery, + regulatory_enrichment, ) +from .artifacts import resolve_artifact from .models import ( ChipAtlasEnrichmentResult, + DatasetArtifact, ModkitDMRMultiResult, ModkitDMRPairResult, - DatasetArtifact, RegionDiscoveryClusterContrastResult, RegionDiscoveryClusterResult, SampleSpec, @@ -192,13 +193,23 @@ def _normalize_read_windows( raise ValueError(f"Unsupported signal_normalization: {signal_normalization}") data_matrix = np.asarray(result.data_matrix, dtype=float) - val_matrix = None if result.val_matrix is None else np.asarray(result.val_matrix, dtype=float) - offset_source = result if signal_normalization == "per_sample_global" else control_result + val_matrix = ( + None + if result.val_matrix is None + else np.asarray(result.val_matrix, dtype=float) + ) + offset_source = ( + result if signal_normalization == "per_sample_global" else control_result + ) if offset_source is None: - raise ValueError("control_regions normalization requires control-region read windows.") + raise ValueError( + "control_regions normalization requires control-region read windows." + ) offset_matrix = np.asarray(offset_source.data_matrix, dtype=float) offset_val_matrix = ( - None if offset_source.val_matrix is None else np.asarray(offset_source.val_matrix, dtype=float) + None + if offset_source.val_matrix is None + else np.asarray(offset_source.val_matrix, dtype=float) ) if offset_val_matrix is not None and offset_val_matrix.sum() > 0: global_offset = float(offset_matrix.sum() / offset_val_matrix.sum()) @@ -231,7 +242,9 @@ def _select_feature_columns( else: keep = [name in _LEVEL_FEATURES for name in feature_names] - selected_names = [name for name, keep_name in zip(feature_names, keep) if keep_name] + selected_names = [ + name for name, keep_name in zip(feature_names, keep, strict=False) if keep_name + ] if not selected_names: raise ValueError(f"No features available for cluster_basis={cluster_basis!r}.") selected_matrix = feature_matrix[:, keep] @@ -276,7 +289,9 @@ def _cluster_profiles( labels = np.asarray(cluster_labels, dtype=str) unique_labels = np.unique(labels) codes = pd.Categorical(labels, categories=unique_labels, ordered=True).codes - counts = np.bincount(codes, minlength=len(unique_labels)).astype(np.int64, copy=False) + counts = np.bincount(codes, minlength=len(unique_labels)).astype( + np.int64, copy=False + ) sums = np.zeros((len(unique_labels), feature_matrix.shape[1]), dtype=np.float64) np.add.at(sums, codes, np.asarray(feature_matrix, dtype=np.float64)) @@ -329,7 +344,9 @@ def _build_region_summary(assignments: pd.DataFrame) -> pd.DataFrame: .size() .reset_index(name="count") ) - totals = summary.groupby(["region_id", "sample_id", "condition"])["count"].transform("sum") + totals = summary.groupby(["region_id", "sample_id", "condition"])[ + "count" + ].transform("sum") summary["fraction"] = summary["count"] / totals return summary @@ -390,12 +407,21 @@ def _build_read_global_region_summary(assignments: pd.DataFrame) -> pd.DataFrame if association_frames: region_summaries = pd.concat(association_frames, ignore_index=True) - required_columns = {"region_id", "sample_id", "condition", "cluster", "count", "fraction"} + required_columns = { + "region_id", + "sample_id", + "condition", + "cluster", + "count", + "fraction", + } if required_columns.issubset(region_summaries.columns): return region_summaries summary_source = assignments.copy() - summary_source["region_id"] = summary_source.apply(_region_id_from_coordinates, axis=1) + summary_source["region_id"] = summary_source.apply( + _region_id_from_coordinates, axis=1 + ) return _build_region_summary(summary_source) @@ -468,8 +494,8 @@ def _selected_regions_to_region_spec(selected_regions: pd.DataFrame) -> list[str region_spec: list[str] = [] for row in selected_regions.itertuples(index=False): chrom = getattr(row, chrom_column) - start = int(getattr(row, "start")) - end = int(getattr(row, "end")) + start = int(row.start) + end = int(row.end) strand = getattr(row, "strand", ".") strand_value = strand if strand in {"+", "-", "."} else "." region_spec.append(f"{chrom}:{start}-{end},{strand_value}") @@ -576,7 +602,9 @@ def _require_region_summary_table_for_chip_atlas( assignments = cluster_result.assignments.copy() if "region_id" not in assignments.columns: if _assignments_have_region_coordinates(assignments): - assignments["region_id"] = assignments.apply(_region_id_from_coordinates, axis=1) + assignments["region_id"] = assignments.apply( + _region_id_from_coordinates, axis=1 + ) else: raise ValueError( "SharedClusterResult does not include region_summaries, and assignments " @@ -601,7 +629,9 @@ def _rank_cluster_regions_for_chip_atlas( min_fraction: float | None, top_n_regions: int | None, ) -> list[str]: - cluster_rows = region_summaries.loc[region_summaries["cluster"] == cluster_label].copy() + cluster_rows = region_summaries.loc[ + region_summaries["cluster"] == cluster_label + ].copy() if cluster_rows.empty: return [] @@ -631,7 +661,11 @@ def _rank_cluster_regions_for_chip_atlas( if top_n_regions is not None: ranked = ranked.head(int(top_n_regions)) - return [str(region_id) for region_id in ranked["region_id"].tolist() if pd.notna(region_id)] + return [ + str(region_id) + for region_id in ranked["region_id"].tolist() + if pd.notna(region_id) + ] def resolve_regulatory_enrichment_spec( @@ -645,7 +679,7 @@ def resolve_regulatory_enrichment_spec( crossmap_chain_cache_dir: str | Path | None = None, crossmap_executable: str | None = "CrossMap.py", strict_provider_support: bool = False, - ) -> regulatory_enrichment.RegulatoryEnrichmentSpec: +) -> regulatory_enrichment.RegulatoryEnrichmentSpec: return regulatory_enrichment.RegulatoryEnrichmentSpec( providers=tuple(providers), species=species, @@ -928,7 +962,9 @@ def chip_atlas_cluster_enrichment_workflow( raise ValueError("mode must be 'per_cluster' or 'combined'.") region_summaries = _require_region_summary_table_for_chip_atlas(cluster_result) - available_clusters = [str(value) for value in pd.unique(region_summaries["cluster"])] + available_clusters = [ + str(value) for value in pd.unique(region_summaries["cluster"]) + ] selected_clusters = ( [str(cluster_label) for cluster_label in clusters] if clusters is not None @@ -953,11 +989,15 @@ def chip_atlas_cluster_enrichment_workflow( per_cluster_region_ids[cluster_label] = region_ids if not per_cluster_region_ids: - raise ValueError("No regions met the requested filters for ChIP-Atlas enrichment.") + raise ValueError( + "No regions met the requested filters for ChIP-Atlas enrichment." + ) queries: dict[str, list[str]] if mode == "combined": - union_region_ids = sorted({region_id for ids in per_cluster_region_ids.values() for region_id in ids}) + union_region_ids = sorted( + {region_id for ids in per_cluster_region_ids.values() for region_id in ids} + ) queries = {"combined": union_region_ids} else: queries = per_cluster_region_ids @@ -1138,7 +1178,9 @@ def modkit_dmr_multi_from_samples_workflow( ) -> ModkitDMRMultiResult: sample_list = list(samples) if len(sample_list) < 2: - raise ValueError("modkit_dmr_multi_from_samples_workflow requires at least two samples.") + raise ValueError( + "modkit_dmr_multi_from_samples_workflow requires at least two samples." + ) dmr_samples: dict[str, str | Path] = {} for sample in sample_list: @@ -1252,7 +1294,9 @@ def discovery_cluster_contrast_workflow( contrast_config = dict(contrasts) contrast_spec = contrast_config.get("contrast") if contrast_spec is None: - raise ValueError("discovery_cluster_contrast_workflow requires contrasts['contrast'].") + raise ValueError( + "discovery_cluster_contrast_workflow requires contrasts['contrast']." + ) region_contrasts.validate_region_contrast_request( analysis_unit=str(contrast_config.get("analysis_unit", "ensemble_region")), @@ -1269,7 +1313,9 @@ def discovery_cluster_contrast_workflow( clustering=clustering, selection=selection, ) - selected_region_spec = _selected_regions_to_region_spec(discovery_cluster_result.selected_regions) + selected_region_spec = _selected_regions_to_region_spec( + discovery_cluster_result.selected_regions + ) contrast_regions = contrast_config.pop("regions", None) contrast_scope = "selected" if contrast_regions is None: @@ -1352,15 +1398,21 @@ def _build_shared_cluster_result( clustering_result.labels_size_ordered, ) if not hasattr(clustering_result.model, "predict"): - raise TypeError("Fitted clustering model does not support prediction for full assignment.") + raise TypeError( + "Fitted clustering model does not support prediction for full assignment." + ) predicted_raw = _predict_in_chunks(clustering_result.model, full_scaled) - predicted_ordered = cluster.apply_cluster_label_mapping(predicted_raw, label_mapping) + predicted_ordered = cluster.apply_cluster_label_mapping( + predicted_raw, label_mapping + ) assignments = pd.DataFrame(metadata_rows) assignments["cluster"] = _cluster_label_strings(predicted_ordered) cluster_distribution = distribution.build_cluster_distribution(assignments) - condition_distribution = distribution.build_condition_distribution(cluster_distribution) + condition_distribution = distribution.build_condition_distribution( + cluster_distribution + ) cluster_profiles = _cluster_profiles( full_matrix, feature_names, diff --git a/dimelo_test.ipynb b/dimelo_test.ipynb index 03735a4..9b9fa2a 100644 --- a/dimelo_test.ipynb +++ b/dimelo_test.ipynb @@ -6,7 +6,8 @@ "source": [ "# Mac and Linux setup\n", "\n", - "Make sure to have enabled the environment set up for running `dimelo` analysis. See the readme for details. If you are running your jupyter notebook some way other than by the `jupyter notebook` command in the command line from within your activated `conda` environment, you may need to use `ipykernel` to connect this notebook appropriately to the environment with `dimelo` and `modkit` installed." + "Use a conda/mamba environment with `modkit 0.6.1` installed (see `README.md`).\n", + "If you launch notebooks outside an activated shell, connect the correct kernel (`dimelo-test` by default) so Python, `dimelo`, and `modkit` resolve from the same environment.\n" ] }, { @@ -15,49 +16,38 @@ "source": [ "# Colab setup\n", "\n", - "If you are running in Google Colab, run the cells below. **It is expected that Colab will make you restart your runtime to enable new package versions.** " + "If you are running in Google Colab, run the cells below. **It is expected that Colab will make you restart your runtime to enable new package versions.**\n", + "This notebook is pinned to `modkit 0.6.1`.\n" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "You don't seem to be running on Google Colab so this cell is not going to be useful for you.\n", - "Make sure you are running you notebook in a conda environment set up as per README.md.\n", - "Once you have this notebook running in a correctly configured environment, proceed to the rest of the cells.\n", - " \n" - ] - } - ], + "outputs": [], "source": [ "# Lets Colab access your Google drive\n", "try:\n", " from google.colab import drive\n", "except:\n", - " print(\"\"\"\n", - "You don't seem to be running on Google Colab so this cell is not going to be useful for you.\n", - "Make sure you are running you notebook in a conda environment set up as per README.md.\n", - "Once you have this notebook running in a correctly configured environment, proceed to the rest of the cells.\n", - " \"\"\")\n", + " print(\n", + " \"You don't seem to be running on Google Colab so this cell is not going to be useful for you.\\n\"\n", + " \"Make sure you are running your notebook in a conda environment set up as per README.md.\\n\"\n", + " \"Once you have this notebook running in a correctly configured environment, proceed to the rest of the cells.\"\n", + " )\n", "else:\n", " drive.mount('/content/drive')\n", " # Install condacolab to let us get the modkit dependency\n", " !pip install -q condacolab\n", " import condacolab\n", " condacolab.install()\n", - " # Install modkit\n", - " !conda install nanoporetech::modkit==0.2.4\n", + " # Install pinned modkit version for this notebook\n", + " !conda install -y nanoporetech::modkit==0.6.1\n", " # Clone the repo, change the active path to be inside the repo, and install the package\n", - " !rm -r dimelo\n", - " !git clone https://github.com/streetslab/dimelo\n", + " !rm -rf dimelo-toolkit\n", + " !git clone https://github.com/streetslab/dimelo-toolkit\n", " import os\n", - " os.chdir('dimelo')\n", + " os.chdir('dimelo-toolkit')\n", " !pip install ipywidgets==7.7.1 .\n" ] }, @@ -78,7 +68,7 @@ " from google.colab import drive\n", " drive.mount('/content/drive')\n", " import os\n", - " os.chdir('dimelo') \n", + " os.chdir('dimelo-toolkit') \n", "except:\n", " pass" ] @@ -196,35 +186,25 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Modkit Version Selection (Demo)\n", + "## Modkit Version Requirement (`0.6.1`)\n", "\n", - "Use this cell to pin a preferred `modkit` version for reproducible runs.\n", - "It detects your installed version and records a `MODKIT_VERSION_SELECTED` value for downstream cells.\n" + "This notebook is intentionally pinned to `modkit 0.6.1`.\n", + "It will fail fast if your active `modkit` version does not match, so parsing/extraction behavior is reproducible.\n" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "modkit selected: 0.6.1\n", - "modkit active : 0.6.1\n" - ] - } - ], + "outputs": [], "source": [ "import re\n", "import shutil\n", "import subprocess\n", "\n", - "# Target modkit version for this notebook run.\n", - "# Auto-install is enabled so Run All upgrades PATH to this version when needed.\n", - "MODKIT_VERSION_SELECTED = \"0.6.1\"\n", - "AUTO_INSTALL_SELECTED_MODKIT = True\n", + "# Notebook requirement: keep parsing/extract behavior fixed to 0.6.1.\n", + "REQUIRED_MODKIT_VERSION = \"0.6.1\"\n", + "AUTO_INSTALL_REQUIRED_MODKIT = False\n", "\n", "\n", "def _installed_modkit_version(binary: str = \"modkit\") -> str | None:\n", @@ -237,49 +217,47 @@ " return m.group(1) if m else text\n", "\n", "\n", - "def ensure_selected_modkit(\n", - " selected: str = MODKIT_VERSION_SELECTED,\n", + "def ensure_modkit_061(\n", + " required: str = REQUIRED_MODKIT_VERSION,\n", " binary: str = \"modkit\",\n", - " auto_install: bool = AUTO_INSTALL_SELECTED_MODKIT,\n", + " auto_install: bool = AUTO_INSTALL_REQUIRED_MODKIT,\n", ") -> str:\n", " installed = _installed_modkit_version(binary)\n", - " if installed != selected and auto_install:\n", + "\n", + " if installed != required and auto_install:\n", " installer = shutil.which(\"mamba\") or shutil.which(\"conda\")\n", " if installer is None:\n", " raise RuntimeError(\n", " \"modkit version mismatch and no conda/mamba installer found on PATH. \"\n", - " \"Install modkit manually or set a matching environment.\"\n", + " \"Install modkit manually or switch to the intended environment.\"\n", " )\n", - " subprocess.run(\n", - " [installer, \"install\", \"-y\", f\"nanoporetech::modkit=={selected}\"],\n", - " check=True,\n", - " )\n", + " subprocess.run([installer, \"install\", \"-y\", f\"nanoporetech::modkit=={required}\"], check=True)\n", " installed = _installed_modkit_version(binary)\n", "\n", - "\n", - " # Clear cached capability detection so command flags match the active binary version.\n", + " # Clear cached capability detection so flags match the active binary.\n", " try:\n", " from dimelo import run_modkit\n", + "\n", " run_modkit._get_modkit_capabilities_cached.cache_clear()\n", " except Exception:\n", " pass\n", "\n", - " if installed != selected:\n", + " if installed != required:\n", " raise RuntimeError(\n", - " f\"Notebook requires modkit {selected}, but PATH resolves to {installed!r}. \"\n", - " \"Activate the intended environment or enable AUTO_INSTALL_SELECTED_MODKIT.\"\n", + " f\"Notebook requires modkit {required}, but PATH resolves to {installed!r}. \"\n", + " \"Activate the intended environment, or set AUTO_INSTALL_REQUIRED_MODKIT=True.\"\n", " )\n", "\n", - " print(f\"modkit selected: {selected}\")\n", + " print(f\"modkit required: {required}\")\n", " print(f\"modkit active : {installed}\")\n", " return binary\n", "\n", "\n", - "MODKIT_BINARY = ensure_selected_modkit()\n", + "MODKIT_BINARY = ensure_modkit_061()\n", "\n", "\n", "def run_modkit_checked(args: list[str]) -> None:\n", - " ensure_selected_modkit(binary=MODKIT_BINARY)\n", + " ensure_modkit_061(binary=MODKIT_BINARY)\n", " cmd = [MODKIT_BINARY, *[str(a) for a in args]]\n", " print(\"$\", \" \".join(cmd))\n", " subprocess.run(cmd, check=True)\n" @@ -296,212 +274,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
versionruntime_mean_sruntime_std_sruntime_min_sruntime_max_s
00.6.12.0819530.2763181.7662932.280039
10.2.45.2468480.3708825.0062305.673964
\n", - "
" - ], - "text/plain": [ - " version runtime_mean_s runtime_std_s runtime_min_s runtime_max_s\n", - "0 0.6.1 2.081953 0.276318 1.766293 2.280039\n", - "1 0.2.4 5.246848 0.370882 5.006230 5.673964" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Compatibility flags\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
versionsupports_force_allow_implicitsupports_modified_basessupports_reference_long_optsupports_reference_short_opt
00.2.4TrueFalseFalseTrue
10.6.1FalseTrueTrueTrue
\n", - "
" - ], - "text/plain": [ - " version supports_force_allow_implicit supports_modified_bases \\\n", - "0 0.2.4 True False \n", - "1 0.6.1 False True \n", - "\n", - " supports_reference_long_opt supports_reference_short_opt \n", - "0 False True \n", - "1 True True " - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pileup comparison summary\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
row_deltarow_delta_pct_vs_024outputs_identical_sha256
016030.312757False
\n", - "
" - ], - "text/plain": [ - " row_delta row_delta_pct_vs_024 outputs_identical_sha256\n", - "0 1603 0.312757 False" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Recommendations\n", - "- Prefer modkit 0.6.1 for pileup runtime in this workflow (~60.3% faster on average).\n", - "- Backend-aware command building is required: use --force-allow-implicit for 0.2.4 only.\n", - "\n", - "Re-checking selected modkit binary after comparison...\n", - "modkit selected: 0.6.1\n", - "modkit active : 0.6.1\n" - ] - } - ], + "outputs": [], "source": [ "import json\n", "from pathlib import Path\n", @@ -512,6 +287,7 @@ "results_path = Path(\"modkit_test_results.json\")\n", "if not results_path.exists():\n", " print(f\"No benchmark file found at {results_path}.\")\n", + " print(\"This notebook still requires modkit 0.6.1 even without cached comparison results.\")\n", "else:\n", " results = json.loads(results_path.read_text())\n", "\n", @@ -527,6 +303,13 @@ " ax.set_title(\"Cached modkit runtime comparison\")\n", " plt.show()\n", "\n", + " best_version = str(runtime_summary.iloc[0][\"version\"])\n", + " if best_version != REQUIRED_MODKIT_VERSION:\n", + " print(\n", + " f\"WARNING: cached benchmark fastest version is {best_version}, \"\n", + " f\"but notebook remains pinned to {REQUIRED_MODKIT_VERSION} for reproducibility.\"\n", + " )\n", + "\n", " edge_flags = pd.DataFrame(results.get(\"edge_case_flags\", []))\n", " if not edge_flags.empty:\n", " print(\"Compatibility flags\")\n", @@ -541,8 +324,8 @@ " for rec in results.get(\"recommendations\", []):\n", " print(f\"- {rec}\")\n", "\n", - "print(\"\\nRe-checking selected modkit binary after comparison...\")\n", - "MODKIT_BINARY = ensure_selected_modkit(binary=MODKIT_BINARY)\n" + "print(\"\\nRe-checking required modkit binary after comparison...\")\n", + "MODKIT_BINARY = ensure_modkit_061(binary=MODKIT_BINARY, auto_install=False)\n" ] }, { @@ -676,6 +459,8 @@ "outputs": [], "source": [ "import importlib\n", + "import gzip\n", + "from pathlib import Path\n", "from dimelo import parse_bam, run_modkit\n", "\n", "# Ensure notebook uses latest local backend code and capability logic.\n", @@ -683,7 +468,91 @@ "importlib.reload(parse_bam)\n", "\n", "# Reset cached capability detection after reloads/version changes.\n", - "run_modkit._get_modkit_capabilities_cached.cache_clear()\n" + "run_modkit._get_modkit_capabilities_cached.cache_clear()\n", + "\n", + "# Notebook-safe default: suppress live tqdm progress from parse/extract in Jupyter.\n", + "# This avoids mangled carriage-return output while preserving deterministic results.\n", + "PARSE_QUIET = False\n", + "\n", + "# Output overwrite policy for parse cells below.\n", + "# False: reuse existing complete outputs under output_name.\n", + "# True: force regeneration and replace existing outputs.\n", + "PARSE_OVERWRITE = True\n", + "\n", + "print(f\"PARSING quiet mode for notebook progress: {PARSE_QUIET}\")\n", + "print(f\"PARSING overwrite mode: {PARSE_OVERWRITE}\")\n", + "\n", + "\n", + "def _has_any_bed_rows(bgzip_bed: Path) -> bool:\n", + " if not bgzip_bed.exists() or bgzip_bed.stat().st_size < 80:\n", + " return False\n", + " try:\n", + " with gzip.open(bgzip_bed, \"rt\") as f:\n", + " next(f)\n", + " return True\n", + " except Exception:\n", + " return False\n", + "\n", + "\n", + "def _has_any_extract_rows(extract_h5: Path) -> bool:\n", + " if not extract_h5.exists() or extract_h5.stat().st_size < 1024:\n", + " return False\n", + " try:\n", + " import h5py\n", + "\n", + " with h5py.File(extract_h5, \"r\") as h5:\n", + " return \"read_name\" in h5 and len(h5[\"read_name\"]) > 0\n", + " except Exception:\n", + " return False\n", + "\n", + "\n", + "def ensure_pileup_output(*, output_name: str, overwrite: bool | None = None, **pileup_kwargs):\n", + " if overwrite is None:\n", + " overwrite = PARSE_OVERWRITE\n", + " out_dir = Path(pileup_kwargs[\"output_directory\"])\n", + " pileup_out = out_dir / output_name / \"pileup.sorted.bed.gz\"\n", + " regions_out = out_dir / output_name / \"regions.processed.bed\"\n", + "\n", + " existing_complete = (\n", + " pileup_out.exists()\n", + " and Path(str(pileup_out) + \".tbi\").exists()\n", + " and regions_out.exists()\n", + " and _has_any_bed_rows(pileup_out)\n", + " )\n", + "\n", + " if (not overwrite) and existing_complete:\n", + " print(f\"Reusing existing pileup outputs: {pileup_out}\")\n", + " return pileup_out, regions_out\n", + "\n", + " if (not overwrite) and pileup_out.exists() and not _has_any_bed_rows(pileup_out):\n", + " print(f\"Detected empty/invalid pileup output at {pileup_out}; regenerating.\")\n", + " overwrite = True\n", + "\n", + " return parse_bam.pileup(output_name=output_name, overwrite=overwrite, **pileup_kwargs)\n", + "\n", + "\n", + "def ensure_extract_output(*, output_name: str, overwrite: bool | None = None, **extract_kwargs):\n", + " if overwrite is None:\n", + " overwrite = PARSE_OVERWRITE\n", + " out_dir = Path(extract_kwargs[\"output_directory\"])\n", + " extract_out = out_dir / output_name / \"reads.combined_basemods.h5\"\n", + " regions_out = out_dir / output_name / \"regions.processed.bed\"\n", + "\n", + " existing_complete = (\n", + " extract_out.exists()\n", + " and regions_out.exists()\n", + " and _has_any_extract_rows(extract_out)\n", + " )\n", + "\n", + " if (not overwrite) and existing_complete:\n", + " print(f\"Reusing existing extract outputs: {extract_out}\")\n", + " return extract_out, regions_out\n", + "\n", + " if (not overwrite) and extract_out.exists() and not _has_any_extract_rows(extract_out):\n", + " print(f\"Detected empty/invalid extract output at {extract_out}; regenerating.\")\n", + " overwrite = True\n", + "\n", + " return parse_bam.extract(output_name=output_name, overwrite=overwrite, **extract_kwargs)\n" ] }, { @@ -721,12 +590,13 @@ " # parsing can optionally specify mod codes. \n", " # The default is Y or a for adenine and m or Z for cytosine, corresponding to methylation\n", " # motifs = ['A,0,Y','CG,0,Z'], \n", - " thresh=190,\n", + " thresh=128,\n", " window_size=1000,\n", " # cores = 1, # uncomment this line if your process appears to be terminating early (reduces memory usage)\n", " # quiet = True,\n", " # cleanup = False,\n", " # log=True,\n", + " quiet=PARSE_QUIET,\n", " modkit_executable=MODKIT_BINARY,\n", " )\n", " print('The code executed successfully.')\n", @@ -744,43 +614,50 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "modkit selected: 0.6.1\n", - "modkit active : 0.6.1\n", - "$ modkit update-tags dimelo/test/data/ctcf_demo.sorted.bam dimelo/test/output/ctcf_demo.updated.bam --mode ambiguous\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[0;32m>\u001b[0m done, 1024 records processed\n" - ] - } - ], + "outputs": [], "source": [ + "import shutil\n", + "from pathlib import Path\n", + "\n", + "import pysam\n", + "\n", + "ctcf_bam_file_updated = output_dir / \"ctcf_demo.updated.bam\"\n", + "ctcf_bam_file_updated_tmp = output_dir / \"ctcf_demo.updated.tmp.bam\"\n", + "\n", + "# Always regenerate this file for deterministic notebook reruns.\n", + "for stale in [\n", + " ctcf_bam_file_updated,\n", + " Path(str(ctcf_bam_file_updated) + \".bai\"),\n", + " ctcf_bam_file_updated_tmp,\n", + " Path(str(ctcf_bam_file_updated_tmp) + \".bai\"),\n", + "]:\n", + " stale.unlink(missing_ok=True)\n", + "\n", "run_modkit_checked([\n", " \"update-tags\",\n", - " \"dimelo/test/data/ctcf_demo.sorted.bam\",\n", - " \"dimelo/test/output/ctcf_demo.updated.bam\",\n", + " str(ctcf_bam_file),\n", + " str(ctcf_bam_file_updated_tmp),\n", " \"--mode\",\n", " \"ambiguous\",\n", - "])\n" + "])\n", + "\n", + "# Quick sanity check before promoting the file into the main path.\n", + "pysam.quickcheck(str(ctcf_bam_file_updated_tmp))\n", + "shutil.move(str(ctcf_bam_file_updated_tmp), str(ctcf_bam_file_updated))\n", + "Path(str(ctcf_bam_file_updated_tmp) + \".bai\").unlink(missing_ok=True)\n", + "\n", + "print(f\"Updated BAM ready: {ctcf_bam_file_updated}\")\n" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "ctcf_bam_file_updated = output_dir / 'ctcf_demo.updated.bam'" + "print(f'Using updated BAM: {ctcf_bam_file_updated}')" ] }, { @@ -792,24 +669,19 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "''" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "import pysam\n", + "from pathlib import Path\n", "\n", - "pysam.index(str(ctcf_bam_file_updated))" + "index_path = Path(str(ctcf_bam_file_updated) + \".bai\")\n", + "index_path.unlink(missing_ok=True)\n", + "\n", + "# Rebuild the BAM index from scratch for deterministic reruns.\n", + "pysam.index(str(ctcf_bam_file_updated))\n", + "print(f\"Indexed {ctcf_bam_file_updated} -> {index_path}\")\n" ] }, { @@ -825,31 +697,43 @@ "metadata": {}, "outputs": [], "source": [ - "pileup_file, pileup_regions = parse_bam.pileup(\n", + "pileup_file, pileup_regions = ensure_pileup_output(\n", " input_file=ctcf_bam_file_updated,\n", " output_name='ctcf_demo_pileup_on_target',\n", " ref_genome=ref_genome_file,\n", " output_directory=output_dir,\n", " regions=[ctcf_target_regions,ctcf_off_target_regions],\n", " motifs=['A,0','CG,0'],\n", - " # parsing can optionally specify mod codes. \n", + " # parsing can optionally specify mod codes.\n", " # The default is Y or a for adenine and m or Z for cytosine, corresponding to methylation\n", - " # motifs = ['A,0,Y','CG,0,Z'], \n", + " # motifs=['A,0,Y','CG,0,Z'],\n", " thresh=190,\n", " window_size=1000,\n", - " # cores = 1, # uncomment this line if your process appears to be terminating early (reduces memory usage)\n", - " # quiet = True,\n", - " # cleanup = False,\n", + " # cores=1, # uncomment to reduce memory usage\n", + " # cleanup=False,\n", " # log=True,\n", + " quiet=PARSE_QUIET,\n", " modkit_executable=MODKIT_BINARY,\n", ")\n" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "## Extract" + "import gzip\n", + "with gzip.open(pileup_file, \"rt\") as f:\n", + " n = sum(1 for _ in f)\n", + "print(\"pileup rows:\", n)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extract" ] }, { @@ -858,22 +742,22 @@ "metadata": {}, "outputs": [], "source": [ - "extract_file, extract_regions = parse_bam.extract(\n", + "extract_file, extract_regions = ensure_extract_output(\n", " input_file=ctcf_bam_file_updated,\n", " output_name='ctcf_demo_extract',\n", " ref_genome=ref_genome_file,\n", " output_directory=output_dir,\n", " regions=[ctcf_target_regions,ctcf_off_target_regions],\n", " motifs=['A,0','CG,0'],\n", - " # parsing can optionally specify mod codes. \n", + " # parsing can optionally specify mod codes.\n", " # The default is Y or a for adenine and m or Z for cytosine, corresponding to methylation\n", - " # motifs = ['A,0,Y','CG,0,Z'], \n", + " # motifs=['A,0,Y','CG,0,Z'],\n", " thresh=190,\n", " window_size=2000,\n", - " # cores = 1, # uncomment this line if your process appears to be terminating early (reduces memory usage)\n", - " # quiet = True,\n", - " # cleanup = False,\n", + " # cores=1, # uncomment to reduce memory usage\n", + " # cleanup=False,\n", " # log=True,\n", + " quiet=PARSE_QUIET,\n", " modkit_executable=MODKIT_BINARY,\n", ")\n" ] @@ -1329,18 +1213,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "This is expected to fail. Read the error message below:\n", - "\n", - "\n", - "A threshold has been applied to this .h5 single read data. plot_read_browser must be used with an .h5 file extracted using thresh=None.\n" - ] - } - ], + "outputs": [], "source": [ "try:\n", " plot_read_browser.plot_read_browser(\n", @@ -1348,7 +1221,7 @@ " region='chr1:114357437-114359753', # you can only browser a single region, not a bed file or list of regions.\n", " # The only cap on region size is your computer's memory and your patience\n", " motifs=['CG,0','A,0'],\n", - " thresh=0.5,\n", + " thresh=190,\n", " single_strand=False,\n", " sort_by=\"collapse\",#you can sort by anything that the loading function accepts, but the special \"collapse\" option doesn't allow other sorting\n", " hover=False, #turning off hover will remove the hoverover read names and other info \n", @@ -1364,22 +1237,19 @@ "metadata": {}, "outputs": [], "source": [ - "extract_file_no_thresh, _ = parse_bam.extract(\n", + "extract_file_no_thresh, _ = ensure_extract_output(\n", " input_file=ctcf_bam_file_updated,\n", " output_name='ctcf_demo_extract_no_thresh',\n", " ref_genome=ref_genome_file,\n", " output_directory=output_dir,\n", " regions=[ctcf_target_regions,ctcf_off_target_regions],\n", " motifs=['A,0','CG,0'],\n", - " # parsing can optionally specify mod codes. \n", - " # The default is Y or a for adenine and m or Z for cytosine, corresponding to methylation\n", - " # motifs = ['A,0,Y','CG,0,Z'], \n", - " # thresh=190,\n", + " # thresh=None -> raw probabilities in read vectors\n", " window_size=1000,\n", - " # cores = 1, # uncomment this line if your process appears to be terminating early (reduces memory usage)\n", - " # quiet = True,\n", - " # cleanup = False,\n", + " # cores=1, # uncomment to reduce memory usage\n", + " # cleanup=False,\n", " # log=True,\n", + " quiet=PARSE_QUIET,\n", " modkit_executable=MODKIT_BINARY,\n", ")\n" ] @@ -1388,25 +1258,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Resorting to unclean kill browser.\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from IPython.display import Image, display\n", "from plotly.io import to_image\n", @@ -1415,7 +1267,7 @@ " region='chr1:114357437-114359753', # you can only browser a single region, not a bed file or list of regions.\n", " # The only cap on region size is your computer's memory and your patience\n", " motifs=['CG,0','A,0'],\n", - " thresh=0.5,\n", + " thresh=190,\n", " single_strand=False,\n", " sort_by=\"collapse\",#you can sort by anything that the loading function accepts, but the special \"collapse\" option doesn't allow other sorting\n", " hover=False, #turning off hover will remove the hoverover read names and other info\n", @@ -1868,7 +1720,6 @@ }, { "cell_type": "markdown", - "id": "6f031f5a", "metadata": {}, "source": [ "### Read analysis tips\n", @@ -1899,7 +1750,6 @@ }, { "cell_type": "markdown", - "id": "efbdf960", "metadata": {}, "source": [ "*Motif semantics*: extract output stores one row per motif per read. For multi-motif analyses, use\n", @@ -1910,7 +1760,6 @@ }, { "cell_type": "markdown", - "id": "d5ae7b69", "metadata": {}, "source": [ "**Sampling for speed**: Use `cluster.sample_rows` to downsample reads or loci before clustering/classification. Example:\n", @@ -2484,7 +2333,6 @@ }, { "cell_type": "markdown", - "id": "70a3b81c", "metadata": {}, "source": [ "*Tip*: For concatenated motif windows, use `motif_index` in plotting helpers to choose which motif slice to visualize (e.g., 0 for the first motif, 1 for the second)." @@ -2934,7 +2782,6 @@ }, { "cell_type": "markdown", - "id": "bddc5271", "metadata": {}, "source": [ "#### Karyotype view of top associated regions\n", @@ -2949,7 +2796,6 @@ { "cell_type": "code", "execution_count": null, - "id": "9c0b1226", "metadata": {}, "outputs": [], "source": [ @@ -2964,951 +2810,189 @@ "\n", "matrix_table = association_payload_A[\"matrix_table\"].copy()\n", "axis_table = association_payload_A[\"region_axis_table\"].copy()\n", - "cluster_columns = [c for c in matrix_table.columns if c != \"region_id\"]\n", - "\n", - "if matrix_table.empty or axis_table.empty or not cluster_columns:\n", - " print(\"No region-association rows available for karyotype plot.\")\n", - "else:\n", - " dominant_cluster = matrix_table.loc[:, cluster_columns].astype(float).idxmax(axis=1).astype(str)\n", - " dominant_by_region = pd.DataFrame({\n", - " \"region_id\": matrix_table[\"region_id\"].astype(str),\n", - " \"cluster\": dominant_cluster,\n", - " })\n", - "\n", - " karyo_table = axis_table.merge(dominant_by_region, on=\"region_id\", how=\"inner\")\n", - " karyo_table[\"name\"] = karyo_table[\"cluster\"].astype(str)\n", - " karyo_table[\"score\"] = 0\n", - " if \"strand\" not in karyo_table.columns:\n", - " karyo_table[\"strand\"] = \".\"\n", - " karyo_table[\"strand\"] = karyo_table[\"strand\"].fillna(\".\")\n", - "\n", - " artifacts_dir = Path(\"artifacts/notebook\")\n", - " artifacts_dir.mkdir(parents=True, exist_ok=True)\n", - "\n", - " karyotype_bed = artifacts_dir / \"association_regions_by_dominant_cluster.bed\"\n", - " karyo_table.loc[:, [\"chrom\", \"start\", \"end\", \"name\", \"score\", \"strand\"]].to_csv(\n", - " karyotype_bed,\n", - " sep=\"\t\",\n", - " header=False,\n", - " index=False,\n", - " )\n", - "\n", - " chrom_sizes_path = None\n", - " if \"ref_genome_file\" in globals():\n", - " ref_path = Path(str(ref_genome_file))\n", - " candidate = ref_path.with_suffix(ref_path.suffix + \".fai\")\n", - " if candidate.exists():\n", - " chrom_sizes_path = candidate\n", - "\n", - " if chrom_sizes_path is None:\n", - " inferred_sizes = (\n", - " karyo_table.groupby(\"chrom\", as_index=False)[\"end\"]\n", - " .max()\n", - " .rename(columns={\"chrom\": \"Chromosome\", \"end\": \"Length\"})\n", - " )\n", - " inferred_sizes[\"Length\"] = (inferred_sizes[\"Length\"] * 1.05).astype(int)\n", - " chrom_sizes_path = artifacts_dir / \"inferred.chrom.sizes\"\n", - " inferred_sizes.to_csv(chrom_sizes_path, sep=\"\t\", header=False, index=False)\n", - "\n", - " fig = cluster.plot_cluster_karyotype(\n", - " region_bed=karyotype_bed,\n", - " chrom_sizes=chrom_sizes_path,\n", - " chromosome_order=karyotype_chromosome_order,\n", - " invert_position_axis=True,\n", - " detect_haplotype_backbone_shading=karyotype_detect_haplotype_shading,\n", - " min_visible_bp=karyotype_min_visible_bp,\n", - " )\n", - "\n", - " print(f\"Wrote karyotype BED to {karyotype_bed}\")\n", - " print(f\"Using chromosome sizes from {chrom_sizes_path}\")\n", - " for chrom in [\"chr9\", \"chr12\", \"chr20\"]:\n", - " n = int((karyo_table[\"chrom\"].astype(str) == chrom).sum())\n", - " print(f\"{chrom}: {n} plotted region(s)\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Association heatmap\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "fig, ax = plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib(\n", - " association_payload_A,\n", - " title=\"Read-cluster association by region (sorted: source bed -> genomic)\",\n", - " region_label_mode=\"chromosome\",\n", - " max_region_labels=24,\n", - " row_annotation_column=\"source_label\",\n", - " row_annotation_title=\"Source bed\",\n", - " row_annotation_palette={\n", - " \"on_target\": \"#D95F02\",\n", - " \"off_target\": \"#1B9E77\",\n", - " \"unlabeled\": \"#7570B3\",\n", - " \"unknown\": \"#999999\",\n", - " },\n", - " group_region_labels=True,\n", - " group_label_columns=[\"source_label\", \"chrom\"],\n", - ")\n", - "plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Export" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For some use cases, such as loading pileup information into a genome browser, it can be desireable to create files with less information content than the full bedmethyls. The `export` module contains functions to do these sorts of exports. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "dimelo/test/output/ctcf_demo_pileup_on_target/pileup.sorted.bed.gz\n", - "dimelo/test/output/chm13.draft_v1.0.fasta\n" - ] - } - ], - "source": [ - "pileup_file = 'dimelo/test/output/ctcf_demo_pileup_on_target/pileup.sorted.bed.gz'\n", - "ref_genome_file = 'dimelo/test/output/chm13.draft_v1.0.fasta'\n", - "print(pileup_file)\n", - "print(ref_genome_file)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a85e91c8cf3948b5bee38f190df7e898", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Step 1: Indexing contigs in pileup.sorted.bed.gz to set up bigwig header for pileup.fractions.bigwig: 0%| \u2026" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "170c2c79356e495e985dcce8d773153f", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Indexing chr1.: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "cb1ea1cf21a64a019609fcd304558236", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Indexing chr12.: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "ac828e27245b4d36a6d10c1e0ffaf8b6", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Indexing chr14.: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "c6059480d63440298b2059deb9b67ef6", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Indexing chr15.: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "38672117e5af493cbf99a81b093d0f75", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Indexing chr16.: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0b247661073b4a18827d21d4503f11fa", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Indexing chr17.: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6f71eb588552492fa74744d98fd8518b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Indexing chr19.: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "906b8f4b2a324d7c97f6e16d8a285052", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Indexing chr2.: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "4a7d2c3a5a364b5ca236e25c0fef2070", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Indexing chr20.: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "37dca57a7d7944c49b494f0f5d6abab4", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Indexing chr21.: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "4affe992946b4b9499b4380450ad4fb7", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Indexing chr3.: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a1484a3a698f4ac18b5f8d4efb4c3039", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Indexing chr5.: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "778c9abd083740679fdd7ff41594ab04", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Indexing chr6.: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "112e59a192494ea1927af3a38e738a2a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Indexing chr7.: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "b4c19e4460694ba996b60e5a93e67b60", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Indexing chr8.: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6bc03339e6514195a91907ca1d868cfd", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Indexing chr9.: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "9c766b687a45474da11a677373de6b96", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Indexing chrX.: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "e7f7fcc9fd37427385b8258edbe7a28b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Step 2: Writing pileup.sorted.bed.gz contents to pileup.fractions.bigwig: 0%| | 0/17 [00:00 genomic)\",\n", + " region_label_mode=\"chromosome\",\n", + " max_region_labels=24,\n", + " row_annotation_column=\"source_label\",\n", + " row_annotation_title=\"Source bed\",\n", + " row_annotation_palette={\n", + " \"on_target\": \"#D95F02\",\n", + " \"off_target\": \"#1B9E77\",\n", + " \"unlabeled\": \"#7570B3\",\n", + " \"unknown\": \"#999999\",\n", + " },\n", + " group_region_labels=True,\n", + " group_label_columns=[\"source_label\", \"chrom\"],\n", + ")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Export" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For some use cases, such as loading pileup information into a genome browser, it can be desireable to create files with less information content than the full bedmethyls. The `export` module contains functions to do these sorts of exports. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "pileup_file = Path(pileup_file)\n", + "ref_genome_file = Path(ref_genome_file)\n", + "\n", + "if not pileup_file.exists():\n", + " raise FileNotFoundError(\n", + " f\"Expected pileup file not found: {pileup_file}. Run parsing cells above first.\"\n", + " )\n", + "\n", + "bigwig_out_no_ref = pileup_file.parent / 'pileup.fractions.no_ref.bigwig'\n", + "bigwig_out_with_ref = pileup_file.parent / 'pileup.fractions.with_ref.bigwig'\n", + "\n", + "for p in [bigwig_out_no_ref, bigwig_out_with_ref]:\n", + " p.unlink(missing_ok=True)\n", + "\n", + "print('pileup_file:', pileup_file)\n", + "print('ref_genome_file:', ref_genome_file)\n", + "print('bigwig_out_no_ref:', bigwig_out_no_ref)\n", + "print('bigwig_out_with_ref:', bigwig_out_with_ref)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ + "from dimelo import export\n", + "\n", "export.pileup_to_bigwig(\n", - " bedmethyl_file = pileup_file,\n", - " motif = 'A,0', # the file will contain mod fraction for a specified motif\n", - " bigwig_file = None, # if None, this will default to pileup.fractions.bigwig in the pileup_file directory'\n", - " ref_genome = ref_genome_file, # if None, export will estimate contig lenghts from the bedmethyl file, which is slower\n", - " strand = '.', # specifying + or - will save only mod fractions for the strand in question so you can see strand-specific features\n", - " chunk_size = 1000, # mod positions per bigwig write operation. defaults to 1000. minor effect on performance for most reasonable values\n", - ")" + " bedmethyl_file=pileup_file,\n", + " motif='A,0', # file contains mod fraction for this motif\n", + " bigwig_file=bigwig_out_no_ref,\n", + " strand='.',\n", + " chunk_size=1000,\n", + ")\n", + "print(f\"Wrote {bigwig_out_no_ref}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can specify a ref genome when exporting to bigwig to speed up the setup for the bigwig header that defined contig lengths." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "export.pileup_to_bigwig(\n", + " bedmethyl_file=pileup_file,\n", + " motif='A,0',\n", + " bigwig_file=bigwig_out_with_ref,\n", + " ref_genome=ref_genome_file,\n", + " strand='.',\n", + " chunk_size=1000,\n", + ")\n", + "print(f\"Wrote {bigwig_out_with_ref}\")\n" ] }, { @@ -3958,28 +3042,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'reads')" - ] - }, - "execution_count": 51, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "sort_by = ['chromosome','region_start'] # you can sort reads also!\n", "plot_reads.plot_reads(\n", @@ -3989,7 +3052,7 @@ " window_size=1000,\n", " single_strand=False, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", " regions_5to3prime=True, # if set to True, regions on the reverse (-) strand will be flipped so everything is 5 prime to 3 prime\n", - " thresh=190,\n", + " thresh=128,\n", " sort_by=sort_by,\n", " s=2, \n", ")\n", @@ -4207,49 +3270,16 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "chromosome\n", - "\tchr1\n", - "mod_vector\n", - "\t[False False False ... False False False]\n", - "motif\n", - "\tA,0\n", - "read_end\n", - "\t9206582\n", - "read_name\n", - "\tbc8057e5-935b-4a1a-a0de-f7a4c0dbe4bb\n", - "read_start\n", - "\t9127032\n", - "strand\n", - "\t-\n", - "val_vector\n", - "\t[False False False ... False False False]\n", - "region_start\n", - "\t9169918\n", - "region_end\n", - "\t9170236\n", - "region_strand\n", - "\t+\n", - "read_length\n", - "\t79550\n", - "CG,0_mod_fraction\n", - "\t0.13551401869158877\n", - "A,0_mod_fraction\n", - "\t0.017008797653958945\n", - "[{'chromosome': 'chr14', 'mod_vector': array([False, False, False, ..., False, False, False], shape=(239917,)), 'motif': 'CG,0', 'read_end': np.int32(44230138), 'read_name': 'b35229d7-6592-48fa-ab21-53154531c984', 'read_start': np.int32(43990221), 'strand': '-', 'val_vector': array([False, False, False, ..., False, False, False], shape=(239917,)), 'region_start': 44125008, 'region_end': 44125326, 'region_strand': '+', 'read_length': np.int32(239917), 'CG,0_mod_fraction': np.float64(0.08125), 'A,0_mod_fraction': np.float64(0.0076164874551971325)}, {'chromosome': 'chr14', 'mod_vector': array([False, False, False, ..., False, False, False], shape=(239917,)), 'motif': 'CG,0', 'read_end': np.int32(44230138), 'read_name': 'b35229d7-6592-48fa-ab21-53154531c984', 'read_start': np.int32(43990221), 'strand': '-', 'val_vector': array([False, False, False, ..., False, False, False], shape=(239917,)), 'region_start': 44125009, 'region_end': 44125325, 'region_strand': '-', 'read_length': np.int32(239917), 'CG,0_mod_fraction': np.float64(0.08125), 'A,0_mod_fraction': np.float64(0.0076164874551971325)}]\n" - ] - } - ], + "outputs": [], "source": [ "read_data_list, datasets, _ = load_processed.read_vectors_from_hdf5(\n", " file=extract_file, # binarized modification calls\n", " regions=ctcf_target_regions,\n", " motifs=['CG,0','A,0'],\n", " single_strand=False, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", + " # Optional subsetting controls:\n", + " # random_sample_n_reads=5000, # sample this many unique reads globally after filtering\n", + " # min_read_length_bp=5000, # keep reads with length >= this value (bp)\n", " sort_by = ['chromosome','read_start','read_name']\n", ")\n", "# Print out the data from the first read\n", @@ -4274,49 +3304,16 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "chromosome\n", - "\t chr14\n", - "mod_vector\n", - "\t [0. 0. 0. ... 0. 0. 0.]\n", - "motif\n", - "\t A,0\n", - "read_end\n", - "\t 44230138\n", - "read_name\n", - "\t b35229d7-6592-48fa-ab21-53154531c984\n", - "read_start\n", - "\t 43990221\n", - "strand\n", - "\t -\n", - "val_vector\n", - "\t [0 0 0 ... 0 0 0]\n", - "region_start\n", - "\t 44125008\n", - "region_end\n", - "\t 44125326\n", - "region_strand\n", - "\t .\n", - "read_length\n", - "\t 239917\n", - "CG,0_mod_fraction\n", - "\t 0.09485774253731344\n", - "A,0_mod_fraction\n", - "\t 0.020627618192698982\n", - "[{'chromosome': 'chr14', 'mod_vector': array([0., 0., 0., ..., 0., 0., 0.], shape=(239917,), dtype=float16), 'motif': 'CG,0', 'read_end': np.int32(44230138), 'read_name': 'b35229d7-6592-48fa-ab21-53154531c984', 'read_start': np.int32(43990221), 'strand': '-', 'val_vector': array([0, 0, 0, ..., 0, 0, 0], shape=(239917,)), 'region_start': 44125008, 'region_end': 44125326, 'region_strand': '.', 'read_length': np.int32(239917), 'CG,0_mod_fraction': np.float64(0.09485774253731344), 'A,0_mod_fraction': np.float64(0.020627618192698982)}]\n" - ] - } - ], + "outputs": [], "source": [ "read_data_list, datasets, _ = load_processed.read_vectors_from_hdf5(\n", " file=extract_file_no_thresh, # raw modification probabilities\n", " regions='chr14:44125008-44125326',\n", " motifs=['CG,0','A,0'],\n", " single_strand=False, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", + " # Optional subsetting controls:\n", + " # random_sample_n_reads=2000,\n", + " # min_read_length_bp=5000,\n", ")\n", "# Print out the data from the first read\n", "for idx,dataset in enumerate(datasets):\n", @@ -4412,22 +3409,19 @@ "metadata": {}, "outputs": [], "source": [ - "pileup_file_coded, pileup_regions = parse_bam.pileup(\n", + "pileup_file_coded, pileup_regions = ensure_pileup_output(\n", " input_file=ctcf_bam_file_updated,\n", " output_name='ctcf_demo_pileup_on_target_mod_code_specified',\n", " ref_genome=ref_genome_file,\n", " output_directory=output_dir,\n", " regions=[ctcf_target_regions,ctcf_off_target_regions],\n", - " # motifs=['A,0','CG,0'],\n", - " # parsing can optionally specify mod codes. \n", - " # The default is Y or a for adenine and m or Z for cytosine, corresponding to methylation\n", - " motifs = ['A,0,a','CG,0,m'], \n", - " thresh=190,\n", + " motifs=['A,0,a','CG,0,m'],\n", + " thresh=128,\n", " window_size=1000,\n", - " # cores = 1, # uncomment this line if your process appears to be terminating early (reduces memory usage)\n", - " # quiet = True,\n", - " # cleanup = False,\n", + " # cores=1,\n", + " # cleanup=False,\n", " # log=True,\n", + " quiet=PARSE_QUIET,\n", " modkit_executable=MODKIT_BINARY,\n", ")\n" ] @@ -4561,22 +3555,19 @@ "metadata": {}, "outputs": [], "source": [ - "pileup_file_recoded, pileup_regions = parse_bam.pileup(\n", + "pileup_file_recoded, pileup_regions = ensure_pileup_output(\n", " input_file=ctcf_bam_file_recoded,\n", " output_name='ctcf_demo_pileup_on_target_mod_code_specified_adjusted',\n", " ref_genome=ref_genome_file,\n", " output_directory=output_dir,\n", " regions=[ctcf_target_regions,ctcf_off_target_regions],\n", - " # motifs=['A,0','CG,0'],\n", - " # parsing can optionally specify mod codes. \n", - " # The default is Y or a for adenine and m or Z for cytosine, corresponding to methylation\n", - " motifs = ['A,0,a','CG,0,m'], \n", - " thresh=190,\n", + " motifs=['A,0,a','CG,0,m'],\n", + " thresh=128,\n", " window_size=1000,\n", - " # cores = 1, # uncomment this line if your process appears to be terminating early (reduces memory usage)\n", - " # quiet = True,\n", - " # cleanup = False,\n", + " # cores=1,\n", + " # cleanup=False,\n", " # log=True,\n", + " quiet=PARSE_QUIET,\n", " modkit_executable=MODKIT_BINARY,\n", ")\n" ] @@ -4648,77 +3639,120 @@ ")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Two-window raster demo\n", + "## What it does:\n", + " - selects window pairs from the same read,\n", + " - keeps row sorting matched across motifs,\n", + " - lets you choose representation (scatter/heatmap) independently from axis orientation.\n", + "\n", + "## Flexible window specification options:\n", + " 1) spacing-driven: n_windows + min_separation_bp\n", + " 2) center-driven: window_center_offsets in primary-region coordinates" + ] + }, { "cell_type": "code", "execution_count": null, - "id": "d54a6201", "metadata": {}, "outputs": [], "source": [ - "# Two-window raster demo\n", - "# What it does:\n", - "# - selects window pairs from the same read,\n", - "# - keeps row sorting matched across motifs,\n", - "# - renders either scatter or heatmap panels.\n", - "#\n", - "# Flexible window specification options:\n", - "# 1) spacing-driven: n_windows + min_separation_bp\n", - "# 2) center-driven: window_center_offsets in primary-region coordinates\n", - "\n", "raster_render_mode = \"scatter\" # \"scatter\" | \"heatmap\"\n", - "raster_x_axis_mode = \"relative_to_primary\" # \"relative_to_primary\" | \"centered\"\n", + "raster_render_values = \"raw\" # \"auto\" | \"raw\" | \"smoothed\"\n", + "raster_axis_orientation = \"position_x\" # \"position_x\" | \"position_y\"\n", "raster_plot_all_motifs = True\n", - "raster_window_centers = [0, 2000]\n", - "raster_center_tolerance_bp = 800\n", + "raster_second_site_offset_bp = 2000\n", + "raster_window_width_bp = 2000\n", + "raster_window_match_tolerance_bp = 800\n", + "\n", + "# Optional motif-specific ML thresholds for thresholded motif-color rendering.\n", + "# Set to None to use continuous ML-score coloring (default behavior).\n", + "raster_ml_thresholds = None # example: [0.70, 0.80]\n", + "raster_motif_colors = [\"#1f77b4\", \"#ff7f0e\"]\n", + "\n", + "# Sorting controls (rich ordering options)\n", + "# sort_by: \"mod_fraction\" | \"cluster\" | \"window_center\" | \"read_name\" | \"region_start\" | \"read_length\" | \"none\"\n", + "raster_sort_by = \"mod_fraction\"\n", + "raster_sort_window_index = 0\n", + "raster_sort_descending = True\n", + "\n", + "show_vertical_axis_variant = True\n", "show_heatmap_variant = True\n", "\n", - "try:\n", - " fig, stats = cluster.plot_multisite_read_raster(\n", - " read_windows=rw_multi,\n", - " motif_index=0,\n", - " motif_count=2,\n", - " plot_all_motifs=raster_plot_all_motifs,\n", - " motif_labels=[\"A,0\", \"CG,0\"],\n", - " window_center_offsets=raster_window_centers,\n", - " center_tolerance_bp=raster_center_tolerance_bp,\n", - " smoothing=\"gaussian\",\n", - " render_mode=raster_render_mode,\n", - " x_axis_mode=raster_x_axis_mode,\n", - " scatter_size=5.0,\n", - " scatter_alpha=0.75,\n", - " )\n", - "except ValueError as exc:\n", - " print(f\"Center-driven window selection failed ({exc}); using spacing-driven selection.\")\n", - " fig, stats = cluster.plot_multisite_read_raster(\n", + "fig, stats = cluster.plot_two_site_read_raster(\n", + " read_windows=rw_multi,\n", + " second_site_offset_bp=raster_second_site_offset_bp,\n", + " window_width_bp=raster_window_width_bp,\n", + " window_match_tolerance_bp=raster_window_match_tolerance_bp,\n", + " motif_index=0,\n", + " motif_count=2,\n", + " plot_all_motifs=raster_plot_all_motifs,\n", + " motif_labels=[\"A,0\", \"CG,0\"],\n", + " motif_colors=raster_motif_colors,\n", + " ml_score_thresholds=raster_ml_thresholds,\n", + " smoothing=None,\n", + " render_mode=raster_render_mode,\n", + " render_values=raster_render_values,\n", + " scatter_color_values=\"ml_score\",\n", + " axis_orientation=raster_axis_orientation,\n", + " sort_by=raster_sort_by,\n", + " sort_window_index=raster_sort_window_index,\n", + " sort_descending=raster_sort_descending,\n", + " scatter_size=1,\n", + " scatter_alpha=0.5,\n", + ")\n", + "print(\"Two-window raster stats:\", stats)\n", + "\n", + "if show_vertical_axis_variant:\n", + " fig_vert, stats_vert = cluster.plot_two_site_read_raster(\n", " read_windows=rw_multi,\n", + " second_site_offset_bp=raster_second_site_offset_bp,\n", + " window_width_bp=raster_window_width_bp,\n", + " window_match_tolerance_bp=raster_window_match_tolerance_bp,\n", " motif_index=0,\n", " motif_count=2,\n", " plot_all_motifs=raster_plot_all_motifs,\n", " motif_labels=[\"A,0\", \"CG,0\"],\n", - " n_windows=2,\n", - " min_separation_bp=1800,\n", - " smoothing=\"gaussian\",\n", - " render_mode=raster_render_mode,\n", - " x_axis_mode=raster_x_axis_mode,\n", - " scatter_size=5.0,\n", - " scatter_alpha=0.75,\n", + " motif_colors=raster_motif_colors,\n", + " ml_score_thresholds=raster_ml_thresholds,\n", + " smoothing=None,\n", + " render_mode=\"scatter\",\n", + " render_values=\"raw\",\n", + " scatter_color_values=\"ml_score\",\n", + " axis_orientation=\"position_y\",\n", + " sort_by=raster_sort_by,\n", + " sort_window_index=raster_sort_window_index,\n", + " sort_descending=raster_sort_descending,\n", + " scatter_size=4,\n", + " scatter_alpha=0.05,\n", " )\n", - "print(\"Two-window raster stats:\", stats)\n", + " print(\"Vertical-axis scatter stats:\", stats_vert)\n", "\n", "if show_heatmap_variant:\n", - " fig_hm, stats_hm = cluster.plot_multisite_read_raster(\n", + " fig_hm, stats_hm = cluster.plot_two_site_read_raster(\n", " read_windows=rw_multi,\n", + " second_site_offset_bp=raster_second_site_offset_bp,\n", + " window_width_bp=raster_window_width_bp,\n", + " window_match_tolerance_bp=raster_window_match_tolerance_bp,\n", " motif_index=0,\n", " motif_count=2,\n", " plot_all_motifs=raster_plot_all_motifs,\n", " motif_labels=[\"A,0\", \"CG,0\"],\n", - " n_windows=2,\n", - " min_separation_bp=1800,\n", " smoothing=\"gaussian\",\n", " render_mode=\"heatmap\",\n", - " x_axis_mode=\"centered\",\n", + " render_values=\"smoothed\",\n", + " smooth_sigma_bp=7,\n", + " smooth_win=21,\n", + " axis_orientation=\"position_x\",\n", + " sort_by=raster_sort_by,\n", + " sort_window_index=raster_sort_window_index,\n", + " sort_descending=raster_sort_descending,\n", " )\n", - " print(\"Heatmap variant stats:\", stats_hm)\n" + " print(\"Heatmap variant stats:\", stats_hm)\n", + " print(\"Smoothing note: gaussian smoothing is applied independently within each read along the position axis; rows (reads) are not smoothed together.\")\n" ] }, { @@ -4727,7 +3761,7 @@ "source": [ "### Three-site raster demo (`-2500`, `0`, `+2500`)\n", "\n", - "This example uses explicit centers (`window_center_offsets=[-2500, 0, 2500]`) to select three windows from the same read.\n" + "This example uses explicit primary-coordinate centers (`window_centers_bp=[-2500, 0, 2500]`) to select three windows from the same read.\n" ] }, { @@ -4736,39 +3770,39 @@ "metadata": {}, "outputs": [], "source": [ - "try:\n", - " fig3, stats3 = cluster.plot_multisite_read_raster(\n", - " read_windows=rw_multi,\n", - " motif_index=0,\n", - " motif_count=2,\n", - " plot_all_motifs=True,\n", - " motif_labels=[\"A,0\", \"CG,0\"],\n", - " window_center_offsets=[-2000, 0, 2000],\n", - " center_tolerance_bp=1000,\n", - " render_mode=\"scatter\",\n", - " x_axis_mode=\"relative_to_primary\",\n", - " smoothing=\"gaussian\",\n", - " scatter_size=4.5,\n", - " scatter_alpha=0.65,\n", - " )\n", - "except ValueError as exc:\n", - " print(f\"Center-driven 3-window selection failed ({exc}); using spacing-driven selection.\")\n", - " fig3, stats3 = cluster.plot_multisite_read_raster(\n", - " read_windows=rw_multi,\n", - " motif_index=0,\n", - " motif_count=2,\n", - " plot_all_motifs=True,\n", - " motif_labels=[\"A,0\", \"CG,0\"],\n", - " n_windows=3,\n", - " min_separation_bp=1800,\n", - " render_mode=\"scatter\",\n", - " x_axis_mode=\"relative_to_primary\",\n", - " smoothing=\"gaussian\",\n", - " scatter_size=4.5,\n", - " scatter_alpha=0.65,\n", - " )\n", + "three_site_ml_thresholds = [0.65, 0.50] # example: [0.75, 0.80]\n", + "three_site_motif_colors = [\"#1f77b4\", \"#ff7f0e\"]\n", + "fig3, stats3 = cluster.plot_multisite_read_raster(\n", + " read_windows=rw_multi,\n", + " motif_index=0,\n", + " motif_count=2,\n", + " plot_all_motifs=True,\n", + " motif_labels=[\"A,0\", \"CG,0\"],\n", + " motif_colors=three_site_motif_colors,\n", + " ml_score_thresholds=three_site_ml_thresholds,\n", + " window_centers_bp=[-2500, 0, 2500],\n", + " window_match_tolerance_bp=800,\n", + " window_widths_bp=[2000, 2000, 2000],\n", + " render_mode=\"scatter\",\n", + " render_values=\"raw\",\n", + " scatter_color_values=\"ml_score\",\n", + " axis_orientation=\"position_x\",\n", + " smoothing=None,\n", + " sort_by=\"mod_fraction\",\n", + " sort_window_index=1,\n", + " sort_descending=True,\n", + " scatter_size=4,\n", + " scatter_alpha=0.05,\n", + ")\n", "print(\"Three-window raster stats:\", stats3)\n" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -4792,4 +3826,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/environment.yml b/environment.yml index f57a32e..99af718 100644 --- a/environment.yml +++ b/environment.yml @@ -8,6 +8,6 @@ dependencies: - python=3.11 - pip - libcurl - # Conservative default pin; runtime supports both 0.2.4 and 0.6.x. - - nanoporetech::modkit==0.2.4 + # Project default for parsing/DMR workflows and notebooks. + - nanoporetech::modkit==0.6.1 - bioconda::crossmap=0.7.3 diff --git a/scripts/bootstrap_dimelo_env.sh b/scripts/bootstrap_dimelo_env.sh index b06ff66..334d24e 100755 --- a/scripts/bootstrap_dimelo_env.sh +++ b/scripts/bootstrap_dimelo_env.sh @@ -46,7 +46,7 @@ conda run -n "${ENV_NAME}" python -m ipykernel install \ echo "==> Validating environment health" conda run -n "${ENV_NAME}" python "${REPO_ROOT}/scripts/ensure_dimelo_kernel.py" \ - --modkit-version "${MODKIT_VERSION:-supported}" \ + --modkit-version "${MODKIT_VERSION:-0.6.1}" \ --expected-env "${ENV_NAME}" cat < bool: def _check_python_modules() -> tuple[list[str], list[str]]: missing_core = [ - package for package, module in CORE_MODULES.items() if not _module_installed(module) + package + for package, module in CORE_MODULES.items() + if not _module_installed(module) ] missing_clustering = [ package @@ -95,7 +96,7 @@ def _check_python_modules() -> tuple[list[str], list[str]]: def _modkit_version_ok(version_text: str, required_version: str) -> bool: normalized = required_version.strip().lower() - if normalized in {"supported", "dual", "auto"}: + if normalized in {"supported", "auto"}: return any(prefix in version_text for prefix in SUPPORTED_MODKIT_PREFIXES) return required_version in version_text @@ -180,7 +181,7 @@ def fix_python_packages(report: CheckReport) -> None: def fix_modkit(required_modkit_version: str) -> None: requested_version = ( DEFAULT_MODKIT_INSTALL_VERSION - if required_modkit_version.strip().lower() in {"supported", "dual", "auto"} + if required_modkit_version.strip().lower() in {"supported", "auto"} else required_modkit_version ) conda_path = shutil.which("conda") @@ -255,8 +256,8 @@ def print_report( print("modkit check: skipped") else: requirement_text = ( - "any supported version (0.2.4 or 0.6.x)" - if required_modkit_version.strip().lower() in {"supported", "dual", "auto"} + "any supported version (0.6.x)" + if required_modkit_version.strip().lower() in {"supported", "auto"} else f"version containing '{required_modkit_version}'" ) if report.missing_modkit: @@ -296,7 +297,7 @@ def parse_args() -> argparse.Namespace: default=DEFAULT_MODKIT_REQUIREMENT, help=( "Required modkit version marker. " - "Use 'supported' (default) to allow 0.2.4 or 0.6.x, or pass an explicit marker." + "Use 'supported' (default) to allow 0.6.x, or pass an explicit marker." ), ) parser.add_argument( @@ -334,7 +335,9 @@ def main() -> int: f"Activate expected env first: `conda activate {report.expected_env}`" ) if report.runtime_failures: - print("For runtime linker/import issues, run scripts/bootstrap_dimelo_env.sh") + print( + "For runtime linker/import issues, run scripts/bootstrap_dimelo_env.sh" + ) return 1 try: diff --git a/scripts/run_tutorial_offline.py b/scripts/run_tutorial_offline.py index 6e6b697..36f83cb 100644 --- a/scripts/run_tutorial_offline.py +++ b/scripts/run_tutorial_offline.py @@ -10,7 +10,6 @@ import subprocess from pathlib import Path - REPO_ROOT = Path(__file__).resolve().parents[1] DEFAULT_NOTEBOOK = REPO_ROOT / "tutorial_offline.ipynb" DEFAULT_ARTIFACT_DIR = REPO_ROOT / "artifacts" / "tutorial_offline" diff --git a/tests/test_artifacts.py b/tests/test_artifacts.py index a4af33e..b892506 100644 --- a/tests/test_artifacts.py +++ b/tests/test_artifacts.py @@ -4,7 +4,11 @@ import pytest -from dimelo.artifacts import artifact_fingerprint, artifact_is_compatible, resolve_artifact +from dimelo.artifacts import ( + artifact_fingerprint, + artifact_is_compatible, + resolve_artifact, +) from dimelo.models import DatasetArtifact diff --git a/tests/test_chip_atlas.py b/tests/test_chip_atlas.py index 3c2fbd1..95b6f0d 100644 --- a/tests/test_chip_atlas.py +++ b/tests/test_chip_atlas.py @@ -66,7 +66,9 @@ def fake_get_status(*args, **kwargs): return {"request_id": "REQ1", **payload} monkeypatch.setattr(chip_atlas, "get_status", fake_get_status) - poll = chip_atlas.poll_request("REQ1", poll_interval_seconds=0.0, timeout_seconds=5.0) + poll = chip_atlas.poll_request( + "REQ1", poll_interval_seconds=0.0, timeout_seconds=5.0 + ) assert poll["status"] == "finished" assert [step["status"] for step in poll["history"]] == ["running", "finished"] @@ -83,7 +85,9 @@ def fake_request(**kwargs): assert isinstance(result, pd.DataFrame) assert result.loc[0, "target"] == "CTCF" assert int(result.loc[0, "count"]) == 42 - assert captured["url"] == f"{chip_atlas.DEFAULT_RESULT_URL}REQ2?info=result&format=tsv" + assert ( + captured["url"] == f"{chip_atlas.DEFAULT_RESULT_URL}REQ2?info=result&format=tsv" + ) def test_run_enrichment_raises_on_terminal_failure(monkeypatch): @@ -150,10 +154,14 @@ def test_cache_chain_files_uses_resolver(monkeypatch): def fake_resolve(**kwargs): calls.append((kwargs["source_genome"], kwargs["target_genome"])) - return f"/tmp/{kwargs['source_genome']}_to_{kwargs['target_genome']}.over.chain.gz" + return ( + f"/tmp/{kwargs['source_genome']}_to_{kwargs['target_genome']}.over.chain.gz" + ) monkeypatch.setattr(chip_atlas, "_resolve_chain_file", fake_resolve) - cached = chip_atlas.cache_chain_files(source_genome="chm13", target_genomes=("hg38", "hg19")) + cached = chip_atlas.cache_chain_files( + source_genome="chm13", target_genomes=("hg38", "hg19") + ) assert calls == [("chm13", "hg38"), ("chm13", "hg19")] assert str(cached["hg38"]).endswith("chm13_to_hg38.over.chain.gz") @@ -203,7 +211,11 @@ def test_search_peak_datasets_filters_metadata_rows(monkeypatch, tmp_path): }, ] - monkeypatch.setattr(chip_atlas, "_ensure_experiment_list_zip", lambda **kwargs: tmp_path / "fake.zip") + monkeypatch.setattr( + chip_atlas, + "_ensure_experiment_list_zip", + lambda **kwargs: tmp_path / "fake.zip", + ) monkeypatch.setattr(chip_atlas, "_iter_experiment_rows", lambda path: iter(rows)) found = chip_atlas.search_peak_datasets( @@ -228,11 +240,11 @@ def test_download_peak_datasets_writes_variants_and_crossmapped(monkeypatch, tmp ] ) bed_payload = ( - "chr1\t10\t20\tp1\t100\t.\n" - "chr1\t30\t40\tp2\t10\t.\n" - "chr1\t50\t60\tp3\t50\t.\n" - "chr1\t70\t80\tp4\t5\t.\n" - ).encode("utf-8") + b"chr1\t10\t20\tp1\t100\t.\n" + b"chr1\t30\t40\tp2\t10\t.\n" + b"chr1\t50\t60\tp3\t50\t.\n" + b"chr1\t70\t80\tp4\t5\t.\n" + ) monkeypatch.setattr(chip_atlas, "_download_bytes", lambda **kwargs: bed_payload) monkeypatch.setattr( chip_atlas, diff --git a/tests/test_cluster.py b/tests/test_cluster.py index cdc41a5..9e27244 100644 --- a/tests/test_cluster.py +++ b/tests/test_cluster.py @@ -12,7 +12,9 @@ def test_region_feature_matrix_from_pileup(monkeypatch): "chr2": [(5, 8, "-")], } monkeypatch.setattr( - cluster.utils, "regions_dict_from_input", lambda *args, **kwargs: fake_regions_dict + cluster.utils, + "regions_dict_from_input", + lambda *args, **kwargs: fake_regions_dict, ) monkeypatch.setattr( cluster.load_processed, @@ -109,11 +111,36 @@ def test_read_mod_fraction_table(monkeypatch): def test_summarize_read_cluster_region_associations_counts_and_fractions(): metadata = [ - {"chromosome": "chr1", "region_start": 0, "region_end": 100, "region_strand": "+"}, - {"chromosome": "chr1", "region_start": 0, "region_end": 100, "region_strand": "+"}, - {"chromosome": "chr1", "region_start": 0, "region_end": 100, "region_strand": "+"}, - {"chromosome": "chr1", "region_start": 200, "region_end": 300, "region_strand": "-"}, - {"chromosome": "chr1", "region_start": 200, "region_end": 300, "region_strand": "-"}, + { + "chromosome": "chr1", + "region_start": 0, + "region_end": 100, + "region_strand": "+", + }, + { + "chromosome": "chr1", + "region_start": 0, + "region_end": 100, + "region_strand": "+", + }, + { + "chromosome": "chr1", + "region_start": 0, + "region_end": 100, + "region_strand": "+", + }, + { + "chromosome": "chr1", + "region_start": 200, + "region_end": 300, + "region_strand": "-", + }, + { + "chromosome": "chr1", + "region_start": 200, + "region_end": 300, + "region_strand": "-", + }, ] labels = [0, 0, 1, 1, 1] @@ -132,11 +159,36 @@ def test_summarize_read_cluster_region_associations_counts_and_fractions(): def test_summarize_read_cluster_region_associations_enrichment_and_multiple_testing(): metadata = [ - {"chromosome": "chr1", "region_start": 0, "region_end": 100, "region_strand": "+"}, - {"chromosome": "chr1", "region_start": 0, "region_end": 100, "region_strand": "+"}, - {"chromosome": "chr1", "region_start": 0, "region_end": 100, "region_strand": "+"}, - {"chromosome": "chr1", "region_start": 200, "region_end": 300, "region_strand": "-"}, - {"chromosome": "chr1", "region_start": 200, "region_end": 300, "region_strand": "-"}, + { + "chromosome": "chr1", + "region_start": 0, + "region_end": 100, + "region_strand": "+", + }, + { + "chromosome": "chr1", + "region_start": 0, + "region_end": 100, + "region_strand": "+", + }, + { + "chromosome": "chr1", + "region_start": 0, + "region_end": 100, + "region_strand": "+", + }, + { + "chromosome": "chr1", + "region_start": 200, + "region_end": 300, + "region_strand": "-", + }, + { + "chromosome": "chr1", + "region_start": 200, + "region_end": 300, + "region_strand": "-", + }, ] labels = [0, 0, 1, 1, 1] @@ -160,9 +212,24 @@ def test_summarize_read_cluster_region_associations_enrichment_and_multiple_test def test_summarize_read_cluster_region_associations_min_reads_filter(): metadata = [ - {"chromosome": "chr1", "region_start": 0, "region_end": 100, "region_strand": "+"}, - {"chromosome": "chr1", "region_start": 200, "region_end": 300, "region_strand": "-"}, - {"chromosome": "chr1", "region_start": 200, "region_end": 300, "region_strand": "-"}, + { + "chromosome": "chr1", + "region_start": 0, + "region_end": 100, + "region_strand": "+", + }, + { + "chromosome": "chr1", + "region_start": 200, + "region_end": 300, + "region_strand": "-", + }, + { + "chromosome": "chr1", + "region_start": 200, + "region_end": 300, + "region_strand": "-", + }, ] labels = [0, 1, 1] @@ -243,7 +310,11 @@ def fake_loader(**kwargs): result = cluster.extract_read_windows( hdf5_file="reads.h5", motifs=["A,0"], - config=cluster.ReadWindowExtractionConfig(window_size=2, orientation_aware=True), + config=cluster.ReadWindowExtractionConfig( + window_size=2, + orientation_aware=True, + enforce_thresholded_vectors=False, + ), ) np.testing.assert_allclose(result.data_matrix, np.array([[7.0, 6.0, 5.0, 4.0]])) @@ -317,7 +388,10 @@ def fake_loader(**kwargs): hdf5_file="reads.h5", motifs=["A,0"], config=cluster.ReadWindowExtractionConfig( - window_size=2, orientation_aware=False, filter_multi_region_reads=True + window_size=2, + orientation_aware=False, + filter_multi_region_reads=True, + enforce_thresholded_vectors=False, ), ) assert result.data_matrix.shape[0] == 1 @@ -401,7 +475,11 @@ def test_read_window_feature_matrix_filters(): regions_dict=None, ) features, _ = cluster.read_window_feature_matrix( - result, require_nonzero_valid=True, min_valid_fraction=0.5, n_pca=0, autocorr_lags=() + result, + require_nonzero_valid=True, + min_valid_fraction=0.5, + n_pca=0, + autocorr_lags=(), ) # Second row should be dropped due to zero valid fraction assert features.shape[0] == 1 @@ -516,6 +594,70 @@ def test_plot_multisite_read_raster_supports_multimotif_grid(): assert stats["pairs"] >= 1 assert stats["n_windows"] == 3 assert stats["motifs_plotted"] == ["A,0", "CG,0"] + assert stats["ml_score_cmaps"] == {"A,0": "Blues", "CG,0": "Oranges"} + + +def test_plot_multisite_read_raster_ml_scatter_uses_sequential_cmaps_for_other_motifs(): + import matplotlib + + matplotlib.use("Agg") + motif_1 = np.array( + [ + [0, 1, 0, 1], + [1, 0, 1, 0], + ], + dtype=float, + ) + motif_2 = np.array( + [ + [1, 0, 1, 0], + [0, 1, 0, 1], + ], + dtype=float, + ) + motif_3 = np.array( + [ + [0, 0, 1, 1], + [1, 1, 0, 0], + ], + dtype=float, + ) + data = np.hstack([motif_1, motif_2, motif_3]) + meta = [ + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 6000, + "region_end": 6004, + "region_strand": "+", + }, + ] + r = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=meta, + datasets=[], + regions_dict=None, + ) + fig, stats = cluster.plot_multisite_read_raster( + r, + n_windows=2, + min_separation_bp=5000, + motif_index=0, + motif_count=3, + plot_all_motifs=True, + motif_labels=["X,0", "Y,0", "Z,0"], + smoothing=None, + ) + assert fig is not None + assert stats["ml_score_cmaps"] == {"X,0": "Greens", "Y,0": "Purples", "Z,0": "Reds"} def test_plot_multisite_read_raster_supports_explicit_window_centers_and_length_filter(): @@ -578,7 +720,7 @@ def test_plot_multisite_read_raster_supports_explicit_window_centers_and_length_ assert stats["min_read_length_bp"] == stats["required_read_length_bp"] -def test_plot_multisite_read_raster_heatmap_centered_titles(): +def test_plot_two_site_read_raster_wrapper(): import matplotlib matplotlib.use("Agg") @@ -596,13 +738,15 @@ def test_plot_multisite_read_raster_heatmap_centered_titles(): "region_start": 0, "region_end": 4, "region_strand": "+", + "read_length": 8000, }, { "read_name": "r1", "chromosome": "chr1", - "region_start": 6000, - "region_end": 6004, + "region_start": 2000, + "region_end": 2004, "region_strand": "+", + "read_length": 8000, }, ] r = cluster.ReadWindowExtractionResult( @@ -612,26 +756,24 @@ def test_plot_multisite_read_raster_heatmap_centered_titles(): datasets=[], regions_dict=None, ) - fig, _ = cluster.plot_multisite_read_raster( + fig, stats = cluster.plot_two_site_read_raster( r, - n_windows=2, - min_separation_bp=5000, + second_site_offset_bp=2000, + window_width_bp=4, motif_index=0, - render_mode="heatmap", - x_axis_mode="centered", - rotate=False, smoothing=None, ) - titles = [axis.get_title() for axis in fig.axes if axis.get_title()] - assert "Window 1" in titles - assert "Window 2" in titles + assert fig is not None + assert stats["n_windows"] == 2 + assert stats["window_centers_bp"] == [0.0, 2000.0] + assert stats["window_widths_bp"] == [4, 4] -def test_plot_multisite_read_raster_multimotif_nonrotated_uses_effective_window_count(): +def test_plot_multisite_read_raster_supports_symmetric_center_spec(): import matplotlib matplotlib.use("Agg") - motif_a = np.array( + data = np.array( [ [0, 1, 0, 1], [1, 0, 1, 0], @@ -639,15 +781,6 @@ def test_plot_multisite_read_raster_multimotif_nonrotated_uses_effective_window_ ], dtype=float, ) - motif_c = np.array( - [ - [1, 0, 1, 0], - [0, 1, 0, 1], - [1, 1, 0, 0], - ], - dtype=float, - ) - data = np.hstack([motif_a, motif_c]) meta = [ { "read_name": "r1", @@ -655,23 +788,23 @@ def test_plot_multisite_read_raster_multimotif_nonrotated_uses_effective_window_ "region_start": 0, "region_end": 4, "region_strand": "+", - "read_length": 7000, + "read_length": 9000, }, { "read_name": "r1", "chromosome": "chr1", - "region_start": 2500, - "region_end": 2504, + "region_start": 2000, + "region_end": 2004, "region_strand": "+", - "read_length": 7000, + "read_length": 9000, }, { "read_name": "r1", "chromosome": "chr1", - "region_start": 5000, - "region_end": 5004, + "region_start": 4000, + "region_end": 4004, "region_strand": "+", - "read_length": 7000, + "read_length": 9000, }, ] r = cluster.ReadWindowExtractionResult( @@ -684,27 +817,24 @@ def test_plot_multisite_read_raster_multimotif_nonrotated_uses_effective_window_ fig, stats = cluster.plot_multisite_read_raster( r, motif_index=0, - motif_count=2, - plot_all_motifs=True, - motif_labels=["A,0", "CG,0"], - window_center_offsets=[-2500, 0, 2500], - center_tolerance_bp=500, - rotate=False, - render_mode="scatter", - x_axis_mode="relative_to_primary", + symmetric_side_windows=1, + symmetric_max_offset_bp=2000, + window_match_tolerance_bp=200, smoothing=None, ) + assert fig is not None assert stats["n_windows"] == 3 - # 2 motifs x 3 windows + 1 colorbar axis - assert len(fig.axes) == 7 + assert stats["window_centers_bp"] == [-2000.0, 0.0, 2000.0] -def test_plot_multisite_read_raster_rejects_too_small_min_read_length(): +def test_plot_multisite_read_raster_heatmap_window_titles(): + import matplotlib + + matplotlib.use("Agg") data = np.array( [ [0, 1, 0, 1], [1, 0, 1, 0], - [0, 1, 1, 0], ], dtype=float, ) @@ -715,23 +845,61 @@ def test_plot_multisite_read_raster_rejects_too_small_min_read_length(): "region_start": 0, "region_end": 4, "region_strand": "+", - "read_length": 7000, }, { "read_name": "r1", "chromosome": "chr1", - "region_start": 2500, - "region_end": 2504, + "region_start": 6000, + "region_end": 6004, + "region_strand": "+", + }, + ] + r = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=meta, + datasets=[], + regions_dict=None, + ) + fig, _ = cluster.plot_multisite_read_raster( + r, + n_windows=2, + min_separation_bp=5000, + motif_index=0, + render_mode="heatmap", + rotate=False, + smoothing=None, + ) + titles = [axis.get_title() for axis in fig.axes if axis.get_title()] + assert "Window 1" in titles + assert "Window 2" in titles + + +def test_plot_multisite_read_raster_accepts_centered_axis_mode(): + import matplotlib + + matplotlib.use("Agg") + data = np.array( + [ + [0, 1, 0, 1], + [1, 0, 1, 0], + ], + dtype=float, + ) + meta = [ + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, "region_strand": "+", - "read_length": 7000, }, { "read_name": "r1", "chromosome": "chr1", - "region_start": 5000, - "region_end": 5004, + "region_start": 6000, + "region_end": 6004, "region_strand": "+", - "read_length": 7000, }, ] r = cluster.ReadWindowExtractionResult( @@ -741,49 +909,776 @@ def test_plot_multisite_read_raster_rejects_too_small_min_read_length(): datasets=[], regions_dict=None, ) - with pytest.raises(ValueError, match="min_read_length_bp"): - cluster.plot_multisite_read_raster( - r, - motif_index=0, - window_center_offsets=[-2500, 0, 2500], - min_read_length_bp=100, - smoothing=None, - ) - - -def test_cluster_read_windows_kmeans(): - rng = np.random.default_rng(0) - feature_matrix = rng.normal(size=(20, 5)) - result = cluster.cluster_read_windows( - feature_matrix, method="kmeans", n_clusters=3, random_state=0 + fig, stats = cluster.plot_multisite_read_raster( + r, + n_windows=2, + min_separation_bp=5000, + motif_index=0, + x_axis_mode="centered", + smoothing=None, ) - assert isinstance(result.labels_raw, np.ndarray) - assert result.labels_raw.shape[0] == 20 - assert result.labels_size_ordered.shape == result.labels_raw.shape - assert "silhouette" in result.metrics - - -def test_cluster_label_mapping_round_trips_labels(): - labels_raw = np.array([3, 3, 7, 7, 7]) - labels_size_ordered = np.array([1, 1, 0, 0, 0]) - mapping = cluster.cluster_label_mapping(labels_raw, labels_size_ordered) - remapped = cluster.apply_cluster_label_mapping(np.array([7, 3, 9]), mapping) + assert fig is not None + assert stats["x_axis_mode"] == "centered" + data_axes = [ax for ax in fig.axes if ax.lines] + assert len(data_axes) == 2 + assert [float(ax.lines[0].get_xdata()[0]) for ax in data_axes] == [0.0, 0.0] + assert all(ax.get_xlim()[0] < 0 < ax.get_xlim()[1] for ax in data_axes) - assert mapping == {3: 1, 7: 0} - np.testing.assert_array_equal(remapped, np.array([0, 1, -1])) +def test_plot_multisite_read_raster_heatmap_auto_uses_raw_values(): + import matplotlib -def test_extract_read_windows_infers_shortest_region_window(monkeypatch): - dataset_names = [ - "chromosome", - "mod_vector", - "motif", - "read_end", - "read_name", - "read_start", - "strand", - "val_vector", + matplotlib.use("Agg") + data = np.array( + [ + [0, 1, 0, 0], + [0, 0, 1, 0], + ], + dtype=float, + ) + meta = [ + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 6000, + "region_end": 6004, + "region_strand": "+", + }, + ] + r = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=meta, + datasets=[], + regions_dict=None, + ) + fig, stats = cluster.plot_multisite_read_raster( + r, + n_windows=2, + min_separation_bp=5000, + motif_index=0, + render_mode="heatmap", + render_values="auto", + axis_orientation="position_x", + smoothing="gaussian", + rotate=False, + ) + assert fig is not None + assert stats["render_values"] == "raw" + + +def test_plot_multisite_read_raster_heatmap_relative_axis_uses_window_offsets(): + import matplotlib + + matplotlib.use("Agg") + data = np.array( + [ + [0.0, 0.8, 0.0, 0.0], + [0.0, 0.0, 0.7, 0.0], + ], + dtype=float, + ) + meta = [ + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 6000, + "region_end": 6004, + "region_strand": "+", + }, + ] + r = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=meta, + datasets=[], + regions_dict=None, + ) + fig, _ = cluster.plot_multisite_read_raster( + r, + n_windows=2, + min_separation_bp=5000, + motif_index=0, + render_mode="heatmap", + render_values="smoothed", + smoothing="gaussian", + axis_orientation="position_x", + x_axis_mode="relative_to_primary", + rotate=True, + ) + data_axes = [ax for ax in fig.axes if ax.images] + assert len(data_axes) == 2 + center_0 = float(data_axes[0].lines[0].get_xdata()[0]) + center_1 = float(data_axes[1].lines[0].get_xdata()[0]) + assert abs(center_0) < 5 + assert center_1 > 1000 + + +def test_plot_multisite_read_raster_heatmap_relative_axis_rejects_variable_offsets(): + import matplotlib + + matplotlib.use("Agg") + data = np.array( + [ + [0.0, 0.8, 0.0, 0.0], + [0.0, 0.0, 0.7, 0.0], + [0.0, 0.6, 0.0, 0.0], + [0.0, 0.0, 0.5, 0.0], + ], + dtype=float, + ) + meta = [ + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 6000, + "region_end": 6004, + "region_strand": "+", + }, + { + "read_name": "r2", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + }, + { + "read_name": "r2", + "chromosome": "chr1", + "region_start": 7000, + "region_end": 7004, + "region_strand": "+", + }, + ] + r = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=meta, + datasets=[], + regions_dict=None, + ) + + with pytest.raises( + ValueError, + match="render_mode='scatter'.*x_axis_mode='centered'.*fixed/explicit centers", + ): + cluster.plot_multisite_read_raster( + r, + n_windows=2, + min_separation_bp=5000, + motif_index=0, + render_mode="heatmap", + x_axis_mode="relative_to_primary", + smoothing=None, + ) + + +def test_plot_multisite_read_raster_heatmap_smoothing_label_mentions_per_read_axis(): + import matplotlib + + matplotlib.use("Agg") + data = np.array( + [ + [0.0, 0.8, 0.0, 0.0], + [0.0, 0.0, 0.7, 0.0], + ], + dtype=float, + ) + meta = [ + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 6000, + "region_end": 6004, + "region_strand": "+", + }, + ] + r = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=meta, + datasets=[], + regions_dict=None, + ) + fig, _ = cluster.plot_multisite_read_raster( + r, + n_windows=2, + min_separation_bp=5000, + motif_index=0, + render_mode="heatmap", + render_values="smoothed", + smoothing="gaussian", + axis_orientation="position_x", + rotate=True, + ) + colorbar_axes = [ + ax + for ax in fig.axes + if "per-read smoothing along position axis" in ax.get_ylabel() + ] + assert colorbar_axes + + +def test_plot_multisite_read_raster_heatmap_thresholds_still_use_colorbar(): + import matplotlib + + matplotlib.use("Agg") + data = np.array( + [ + [0.0, 0.9, 0.0, 0.0], + [0.0, 0.0, 0.4, 0.0], + ], + dtype=float, + ) + meta = [ + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 6000, + "region_end": 6004, + "region_strand": "+", + }, + ] + r = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=meta, + datasets=[], + regions_dict=None, + ) + fig, stats = cluster.plot_multisite_read_raster( + r, + n_windows=2, + min_separation_bp=5000, + motif_index=0, + render_mode="heatmap", + ml_score_thresholds=[0.5], + smoothing=None, + ) + + assert fig is not None + assert stats["render_mode"] == "heatmap" + assert stats["ml_score_thresholds"] is None + assert any("window signal heatmap" in ax.get_ylabel() for ax in fig.axes) + assert not any( + legend.get_title().get_text() == "Motif thresholds" for legend in fig.legends + ) + + +def test_plot_multisite_read_raster_accepts_axis_orientation_and_sort_modes(): + import matplotlib + + matplotlib.use("Agg") + data = np.array( + [ + [0, 1, 0, 0], + [0, 0, 1, 0], + [1, 0, 0, 0], + [0, 0, 0, 1], + ], + dtype=float, + ) + meta = [ + { + "read_name": "z_read", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + "read_length": 7000, + }, + { + "read_name": "z_read", + "chromosome": "chr1", + "region_start": 3000, + "region_end": 3004, + "region_strand": "+", + "read_length": 7000, + }, + { + "read_name": "a_read", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + "read_length": 6500, + }, + { + "read_name": "a_read", + "chromosome": "chr1", + "region_start": 3000, + "region_end": 3004, + "region_strand": "+", + "read_length": 6500, + }, + ] + r = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=meta, + datasets=[], + regions_dict=None, + ) + fig, stats = cluster.plot_multisite_read_raster( + r, + n_windows=2, + min_separation_bp=2000, + motif_index=0, + render_mode="scatter", + axis_orientation="position_y", + sort_by="read_name", + sort_descending=False, + smoothing=None, + ) + assert fig is not None + assert stats["axis_orientation"] == "position_y" + assert stats["sort_by"] == "read_name" + # At least one data axis should now expose reads on x. + assert any(ax.get_xlabel() == "Reads (sorted)" for ax in fig.axes) + + +def test_plot_multisite_read_raster_default_scatter_uses_ml_score_colorbar(): + import matplotlib + + matplotlib.use("Agg") + data = np.array( + [ + [0.0, 0.9, 0.0, 0.0], + [0.0, 0.0, 0.4, 0.0], + ], + dtype=float, + ) + val = np.array( + [ + [0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 0.0], + ], + dtype=float, + ) + meta = [ + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 6000, + "region_end": 6004, + "region_strand": "+", + }, + ] + r = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=val, + metadata=meta, + datasets=[], + regions_dict=None, + ) + fig, stats = cluster.plot_multisite_read_raster( + r, + n_windows=2, + min_separation_bp=5000, + motif_index=0, + render_mode="scatter", + smoothing=None, + ) + assert fig is not None + assert stats["scatter_color_values"] == "ml_score" + assert any("normalized ML score" in ax.get_ylabel() for ax in fig.axes) + # Ensure ML coloring tracks mod values (0.9 / 0.4), not val-mask (1.0 / 1.0). + scatter_arrays = [ + np.asarray(collection.get_array(), dtype=float) + for axis in fig.axes + for collection in getattr(axis, "collections", []) + if collection.get_array() is not None and len(collection.get_array()) > 0 + ] + assert any(np.isclose(arr, 0.9).any() for arr in scatter_arrays) + assert any(np.isclose(arr, 0.4).any() for arr in scatter_arrays) + + +def test_plot_multisite_read_raster_uniform_downsampling_stats(): + import matplotlib + + matplotlib.use("Agg") + data = np.tile(np.array([[0.0, 0.9, 0.0, 0.0]], dtype=float), (20, 1)) + meta = [] + for idx in range(20): + meta.append( + { + "read_name": f"r{idx}", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + } + ) + meta.append( + { + "read_name": f"r{idx}", + "chromosome": "chr1", + "region_start": 6000, + "region_end": 6004, + "region_strand": "+", + } + ) + r = cluster.ReadWindowExtractionResult( + data_matrix=np.vstack([data, data]), + val_matrix=None, + metadata=meta, + datasets=[], + regions_dict=None, + ) + fig, stats = cluster.plot_multisite_read_raster( + r, + n_windows=2, + min_separation_bp=5000, + motif_index=0, + render_mode="scatter", + max_rows=8, + downsample_method="uniform", + smoothing=None, + ) + assert fig is not None + assert stats["downsampled"] is True + assert stats["downsample_method"] == "uniform" + assert stats["rows_before_downsample"] > stats["rows_after_downsample"] + + +def test_plot_multisite_read_raster_drops_reads_that_do_not_span_display_windows(): + import matplotlib + + matplotlib.use("Agg") + data = np.array( + [ + [0.0, 1.0, 0.0, 0.0], # long read, window 1 + [0.0, 1.0, 0.0, 0.0], # long read, window 2 + [0.0, 1.0, 0.0, 0.0], # short read, window 1 + [0.0, 1.0, 0.0, 0.0], # short read, window 2 (outside read_end) + ], + dtype=float, + ) + meta = [ + { + "read_name": "r_long", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + "read_start": -10, + "read_end": 3000, + }, + { + "read_name": "r_long", + "chromosome": "chr1", + "region_start": 2000, + "region_end": 2004, + "region_strand": "+", + "read_start": -10, + "read_end": 3000, + }, + { + "read_name": "r_short", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + "read_start": -10, + "read_end": 2001, + }, + { + "read_name": "r_short", + "chromosome": "chr1", + "region_start": 2000, + "region_end": 2004, + "region_strand": "+", + "read_start": -10, + "read_end": 2001, + }, + ] + r = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=meta, + datasets=[], + regions_dict=None, + ) + fig, stats = cluster.plot_multisite_read_raster( + r, + n_windows=2, + min_separation_bp=1000, + motif_index=0, + window_widths_bp=4, + enforce_full_window_span=True, + smoothing=None, + ) + assert fig is not None + assert stats["pairs"] == 1 + assert stats["dropped_for_window_span"] >= 1 + + +def test_plot_multisite_read_raster_ml_thresholds_use_motif_colors(): + import matplotlib + + matplotlib.use("Agg") + data = np.hstack( + [ + np.array( + [ + [0, 1, 0, 0], + [0, 0, 1, 0], + ], + dtype=float, + ), + np.array( + [ + [0, 1, 0, 0], + [0, 1, 0, 0], + ], + dtype=float, + ), + ] + ) + meta = [ + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 6000, + "region_end": 6004, + "region_strand": "+", + }, + ] + r = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=meta, + datasets=[], + regions_dict=None, + ) + fig, stats = cluster.plot_multisite_read_raster( + r, + n_windows=2, + min_separation_bp=5000, + motif_index=0, + motif_count=2, + plot_all_motifs=True, + motif_labels=["A,0", "CG,0"], + render_mode="scatter", + ml_score_thresholds=[0.5, 0.75], + motif_colors=["#1f77b4", "#ff7f0e"], + smoothing=None, + ) + assert fig is not None + assert stats["ml_score_thresholds"] == {"A,0": 0.5, "CG,0": 0.75} + assert stats["read_order_consistent"] is True + assert any( + legend.get_title().get_text() == "Motif thresholds" for legend in fig.legends + ) + + +def test_plot_multisite_read_raster_multimotif_nonrotated_uses_effective_window_count(): + import matplotlib + + matplotlib.use("Agg") + motif_a = np.array( + [ + [0, 1, 0, 1], + [1, 0, 1, 0], + [0, 1, 1, 0], + ], + dtype=float, + ) + motif_c = np.array( + [ + [1, 0, 1, 0], + [0, 1, 0, 1], + [1, 1, 0, 0], + ], + dtype=float, + ) + data = np.hstack([motif_a, motif_c]) + meta = [ + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + "read_length": 7000, + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 2500, + "region_end": 2504, + "region_strand": "+", + "read_length": 7000, + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 5000, + "region_end": 5004, + "region_strand": "+", + "read_length": 7000, + }, + ] + r = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=meta, + datasets=[], + regions_dict=None, + ) + fig, stats = cluster.plot_multisite_read_raster( + r, + motif_index=0, + motif_count=2, + plot_all_motifs=True, + motif_labels=["A,0", "CG,0"], + window_center_offsets=[-2500, 0, 2500], + center_tolerance_bp=500, + rotate=False, + render_mode="scatter", + x_axis_mode="relative_to_primary", + smoothing=None, + ) + assert stats["n_windows"] == 3 + # 2 motifs x 3 windows + 1 colorbar axis + assert len(fig.axes) == 7 + + +def test_plot_multisite_read_raster_rejects_too_small_min_read_length(): + data = np.array( + [ + [0, 1, 0, 1], + [1, 0, 1, 0], + [0, 1, 1, 0], + ], + dtype=float, + ) + meta = [ + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + "read_length": 7000, + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 2500, + "region_end": 2504, + "region_strand": "+", + "read_length": 7000, + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 5000, + "region_end": 5004, + "region_strand": "+", + "read_length": 7000, + }, + ] + r = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=None, + metadata=meta, + datasets=[], + regions_dict=None, + ) + with pytest.raises(ValueError, match="min_read_length_bp"): + cluster.plot_multisite_read_raster( + r, + motif_index=0, + window_center_offsets=[-2500, 0, 2500], + min_read_length_bp=100, + smoothing=None, + ) + + +def test_cluster_read_windows_kmeans(): + rng = np.random.default_rng(0) + feature_matrix = rng.normal(size=(20, 5)) + result = cluster.cluster_read_windows( + feature_matrix, method="kmeans", n_clusters=3, random_state=0 + ) + assert isinstance(result.labels_raw, np.ndarray) + assert result.labels_raw.shape[0] == 20 + assert result.labels_size_ordered.shape == result.labels_raw.shape + assert "silhouette" in result.metrics + + +def test_cluster_label_mapping_round_trips_labels(): + labels_raw = np.array([3, 3, 7, 7, 7]) + labels_size_ordered = np.array([1, 1, 0, 0, 0]) + + mapping = cluster.cluster_label_mapping(labels_raw, labels_size_ordered) + remapped = cluster.apply_cluster_label_mapping(np.array([7, 3, 9]), mapping) + + assert mapping == {3: 1, 7: 0} + np.testing.assert_array_equal(remapped, np.array([0, 1, -1])) + + +def test_extract_read_windows_infers_shortest_region_window(monkeypatch): + dataset_names = [ + "chromosome", + "mod_vector", + "motif", + "read_end", + "read_name", + "read_start", + "strand", + "val_vector", "region_start", "region_end", "region_strand", @@ -820,16 +1715,168 @@ def test_extract_read_windows_infers_shortest_region_window(monkeypatch): ), ] monkeypatch.setattr( - cluster.load_processed, "read_vectors_from_hdf5", lambda **kwargs: (records, dataset_names, None) + cluster.load_processed, + "read_vectors_from_hdf5", + lambda **kwargs: (records, dataset_names, None), ) result = cluster.extract_read_windows( hdf5_file="reads.h5", motifs=["A,0"], - config=cluster.ReadWindowExtractionConfig(window_size=None, orientation_aware=False), + config=cluster.ReadWindowExtractionConfig( + window_size=None, + orientation_aware=False, + enforce_thresholded_vectors=False, + ), ) assert result.data_matrix.shape == (2, 6) +def test_extract_read_windows_auto_thresholds_raw_vectors_by_default(monkeypatch): + dataset_names = [ + "chromosome", + "mod_vector", + "motif", + "read_end", + "read_name", + "read_start", + "strand", + "val_vector", + "region_start", + "region_end", + "region_strand", + "read_length", + ] + record = ( + "chr1", + np.array([0.0, 0.3, 0.8, 0.2, 0.9, 0.0], dtype=float), + "A,0", + 106, + "read1", + 100, + "+", + np.ones(6, dtype=float), + 101, + 105, + "+", + 6, + ) + + monkeypatch.setattr( + cluster.load_processed, + "read_vectors_from_hdf5", + lambda **kwargs: ([record], dataset_names, None), + ) + with pytest.warns(RuntimeWarning, match="applying automatic thresholding"): + result = cluster.extract_read_windows( + hdf5_file="reads.h5", + motifs=["A,0"], + config=cluster.ReadWindowExtractionConfig( + window_size=2, orientation_aware=False + ), + ) + + # default 190/255 ~= 0.745 -> [0.3, 0.8, 0.2, 0.9] => [0,1,0,1] + np.testing.assert_allclose(result.data_matrix, np.array([[0.0, 1.0, 0.0, 1.0]])) + + +def test_extract_read_windows_respects_adjustable_auto_threshold(monkeypatch): + dataset_names = [ + "chromosome", + "mod_vector", + "motif", + "read_end", + "read_name", + "read_start", + "strand", + "val_vector", + "region_start", + "region_end", + "region_strand", + "read_length", + ] + record = ( + "chr1", + np.array([0.0, 0.45, 0.8, 0.2, 0.9, 0.0], dtype=float), + "A,0", + 106, + "read1", + 100, + "+", + np.ones(6, dtype=float), + 101, + 105, + "+", + 6, + ) + + monkeypatch.setattr( + cluster.load_processed, + "read_vectors_from_hdf5", + lambda **kwargs: ([record], dataset_names, None), + ) + with pytest.warns(RuntimeWarning): + result = cluster.extract_read_windows( + hdf5_file="reads.h5", + motifs=["A,0"], + config=cluster.ReadWindowExtractionConfig( + window_size=2, + orientation_aware=False, + auto_threshold_if_raw=100, # 100/255 ~= 0.392 + ), + ) + + # threshold 100/255 -> [0.45,0.8,0.2,0.9] => [1,1,0,1] + np.testing.assert_allclose(result.data_matrix, np.array([[1.0, 1.0, 0.0, 1.0]])) + + +def test_extract_read_windows_errors_when_raw_vectors_disallowed(monkeypatch): + dataset_names = [ + "chromosome", + "mod_vector", + "motif", + "read_end", + "read_name", + "read_start", + "strand", + "val_vector", + "region_start", + "region_end", + "region_strand", + "read_length", + ] + record = ( + "chr1", + np.array([0.0, 0.45, 0.8, 0.2, 0.9, 0.0], dtype=float), + "A,0", + 106, + "read1", + 100, + "+", + np.ones(6, dtype=float), + 101, + 105, + "+", + 6, + ) + + monkeypatch.setattr( + cluster.load_processed, + "read_vectors_from_hdf5", + lambda **kwargs: ([record], dataset_names, None), + ) + with pytest.raises(ValueError, match="unthresholded"): + cluster.extract_read_windows( + hdf5_file="reads.h5", + motifs=["A,0"], + config=cluster.ReadWindowExtractionConfig( + window_size=2, + orientation_aware=False, + auto_threshold_if_raw=None, + enforce_thresholded_vectors=True, + ), + ) + + def test_classify_read_features_binary_includes_row_index(): X = np.vstack([np.zeros((8, 3)), np.ones((8, 3))]) labels = np.array(["a"] * 8 + ["b"] * 8) @@ -985,9 +2032,7 @@ def test_plot_cluster_karyotype_handles_non_numeric_cluster_names(tmp_path): matplotlib.use("Agg") bed = tmp_path / "clusters.bed" bed.write_text( - "chr1\t0\t10\talpha\t0\t+\n" - "chr1\t20\t40\tbeta\t0\t+\n" - "chr2\t5\t15\talpha\t0\t+\n" + "chr1\t0\t10\talpha\t0\t+\nchr1\t20\t40\tbeta\t0\t+\nchr2\t5\t15\talpha\t0\t+\n" ) sizes = tmp_path / "chrom.sizes" sizes.write_text("chr1\t100\nchr2\t80\n") @@ -995,6 +2040,78 @@ def test_plot_cluster_karyotype_handles_non_numeric_cluster_names(tmp_path): assert fig is not None +def test_plot_cluster_karyotype_uses_top_bottom_coordinate_labels_and_draws_rare_cluster_on_top( + tmp_path, +): + import matplotlib + + matplotlib.use("Agg") + bed = tmp_path / "clusters_overlap.bed" + bed.write_text( + "chr1\t10\t20\t0\t0\t+\nchr1\t10\t20\t1\t0\t+\nchr2\t5\t15\t0\t0\t+\n" + ) + sizes = tmp_path / "chrom.sizes" + sizes.write_text("chr1\t100\nchr2\t80\n") + + fig = cluster.plot_cluster_karyotype( + bed, + sizes, + chromosome_order="natural", + min_visible_bp=1, + min_visible_fraction=0.0, + ) + assert fig is not None + ax = fig.axes[0] + + text_values = [t.get_text() for t in ax.texts] + # One "0" label per chromosome at the top. + assert text_values.count("0") >= 2 + # Bottom end-index labels should be present. + assert "100" in text_values + assert "80" in text_values + top_zero_labels = [text for text in ax.texts if text.get_text() == "0"] + assert len(top_zero_labels) >= 2 + # Top "0" labels should sit just above chromosome starts and centered on each line. + for text in top_zero_labels: + x_pos, y_pos = text.get_position() + assert x_pos == pytest.approx(round(x_pos)) + assert y_pos < 0 + assert y_pos > -5 + + end_labels = [text for text in ax.texts if text.get_text() in {"80", "100"}] + assert len(end_labels) == 2 + for text in end_labels: + x_pos, y_pos = text.get_position() + end_val = float(text.get_text()) + # End labels should be just below the chromosome end and centered. + assert x_pos == pytest.approx(round(x_pos)) + assert y_pos > end_val + assert y_pos < end_val + 6 + + legend = ax.get_legend() + assert legend is not None + label_to_color = { + text.get_text(): handle.get_color() + for text, handle in zip(legend.get_texts(), legend.legend_handles, strict=False) + } + assert "C0" in label_to_color + assert "C1" in label_to_color + + overlap_lines = [] + for line in ax.lines: + x_vals = np.asarray(line.get_xdata(), dtype=float) + y_vals = np.asarray(line.get_ydata(), dtype=float) + if x_vals.size != 2 or y_vals.size != 2: + continue + if np.allclose(x_vals, [0.0, 0.0]) and np.allclose(y_vals, [10.0, 20.0]): + overlap_lines.append(line) + + assert len(overlap_lines) == 2 + top_line = max(overlap_lines, key=lambda line: line.get_zorder()) + assert tuple(top_line.get_color()) == tuple(label_to_color["C1"]) + assert not ax.yaxis.get_visible() + + def test_infer_shared_window_size(monkeypatch): def fake_regions_dict_from_input(regions, window_size=None): if regions == "a.bed": @@ -1003,7 +2120,9 @@ def fake_regions_dict_from_input(regions, window_size=None): return {"chr1": [(0, 30, "+")], "chr2": [(10, 70, "-")]} raise ValueError("unexpected input") - monkeypatch.setattr(cluster.utils, "regions_dict_from_input", fake_regions_dict_from_input) + monkeypatch.setattr( + cluster.utils, "regions_dict_from_input", fake_regions_dict_from_input + ) shared = cluster._infer_shared_window_size(["a.bed", "b.bed"]) assert shared == 15 diff --git a/tests/test_distribution.py b/tests/test_distribution.py index 7a337df..fd1d8b4 100644 --- a/tests/test_distribution.py +++ b/tests/test_distribution.py @@ -22,7 +22,13 @@ def test_build_cluster_distribution_counts_and_fractions(): result = build_cluster_distribution(assignments) - assert list(result.columns) == ["sample_id", "condition", "cluster", "count", "fraction"] + assert list(result.columns) == [ + "sample_id", + "condition", + "cluster", + "count", + "fraction", + ] s1 = ( result[result["sample_id"] == "s1"] .sort_values("cluster") @@ -137,7 +143,13 @@ def test_prepare_cluster_distribution_bar_data_returns_sorted_frame(): result = prepare_cluster_distribution_bar_data(cluster_distribution) - assert list(result.columns) == ["sample_id", "condition", "cluster", "count", "fraction"] + assert list(result.columns) == [ + "sample_id", + "condition", + "cluster", + "count", + "fraction", + ] assert list(result["sample_id"]) == ["s1", "s2"] assert list(result["cluster"]) == ["C0", "C1"] diff --git a/tests/test_dmr.py b/tests/test_dmr.py index 43348ae..da4dbe5 100644 --- a/tests/test_dmr.py +++ b/tests/test_dmr.py @@ -1,7 +1,5 @@ from __future__ import annotations -from pathlib import Path - import pandas as pd from dimelo import dmr, run_modkit @@ -41,11 +39,15 @@ def fake_run(cmd, check): "chr1\t1\t2\t0.3\t0.001\t0.4\t10\n" "chr1\t3\t4\t0.01\t0.6\t0.01\t3\n" ) - seg.write_text("#chrom\tchrom_start\tchrom_end\tname\tscore\nchr1\t1\t10\tdiff\t0.2\n") + seg.write_text( + "#chrom\tchrom_start\tchrom_end\tname\tscore\nchr1\t1\t10\tdiff\t0.2\n" + ) return None monkeypatch.setattr(dmr.subprocess, "run", fake_run) - monkeypatch.setattr(run_modkit, "_ensure_modkit_available", lambda **_: _fake_capabilities()) + monkeypatch.setattr( + run_modkit, "_ensure_modkit_available", lambda **_: _fake_capabilities() + ) result = dmr.run_dmr_pair( control_bed_methyl=a, @@ -109,7 +111,9 @@ def fake_run(cmd, check): return None monkeypatch.setattr(dmr.subprocess, "run", fake_run) - monkeypatch.setattr(run_modkit, "_ensure_modkit_available", lambda **_: _fake_capabilities()) + monkeypatch.setattr( + run_modkit, "_ensure_modkit_available", lambda **_: _fake_capabilities() + ) result = dmr.run_dmr_multi( samples={"s1": sample_a, "s2": sample_b}, diff --git a/tests/test_export.py b/tests/test_export.py new file mode 100644 index 0000000..864c6ef --- /dev/null +++ b/tests/test_export.py @@ -0,0 +1,337 @@ +from pathlib import Path + +import pytest + +from dimelo import export + + +def _make_bedmethyl_row( + *, + chrom: str, + start: int, + strand: str, + modified: int, + valid: int, +) -> str: + end = start + 1 + other = max(valid - modified, 0) + # modkit-compatible 18-column row + return ( + f"{chrom}\t{start}\t{end}\tY\t{valid}\t{strand}\t{start}\t{end}\t255,0,0\t" + f"{valid}\t0.00\t{modified}\t{other}\t0\t0\t0\t0\t0" + ) + + +def test_pileup_to_bigwig_sorts_and_collapses_duplicate_positions( + monkeypatch, tmp_path +): + rows_chr1 = [ + _make_bedmethyl_row(chrom="chr1", start=100, strand="+", modified=1, valid=2), + _make_bedmethyl_row(chrom="chr1", start=99, strand="+", modified=1, valid=1), + _make_bedmethyl_row(chrom="chr1", start=100, strand="-", modified=2, valid=2), + _make_bedmethyl_row(chrom="chr1", start=101, strand="+", modified=1, valid=2), + ] + + class _FakeTabixFile: + def __init__(self, *_args, **_kwargs): + self.contigs = ["chr1"] + + def fetch(self, contig): + assert contig == "chr1" + return iter(rows_chr1) + + class _FakeFastaFile: + def __init__(self, *_args, **_kwargs): + pass + + def __enter__(self): + return self + + def __exit__(self, *_args): + return False + + def get_reference_length(self, contig): + assert contig == "chr1" + return 1000 + + class _FakeBigWig: + def __init__(self): + self.header = None + self.entries = [] + + def __enter__(self): + return self + + def __exit__(self, *_args): + return False + + def addHeader(self, header): + self.header = header + + def addEntries(self, contigs, starts, *, ends, values): + self.entries.extend(zip(contigs, starts, ends, values, strict=False)) + + fake_bw = _FakeBigWig() + + monkeypatch.setattr( + export.utils, + "sanitize_path_args", + lambda bedmethyl_file, bigwig_file, ref_genome: ( + Path(bedmethyl_file), + Path(bigwig_file) if bigwig_file is not None else None, + Path(ref_genome) if ref_genome is not None else None, + ), + ) + monkeypatch.setattr(export.pysam, "TabixFile", _FakeTabixFile) + monkeypatch.setattr(export.pysam, "FastaFile", _FakeFastaFile) + monkeypatch.setattr(export.pyBigWig, "open", lambda *_args, **_kwargs: fake_bw) + + output_bigwig = tmp_path / "out.bw" + export.pileup_to_bigwig( + bedmethyl_file=tmp_path / "in.bed.gz", + motif="A,0", + bigwig_file=output_bigwig, + ref_genome=tmp_path / "ref.fa", + strand=".", + chunk_size=2, + ) + + assert fake_bw.header == [("chr1", 1000)] + starts = [entry[1] for entry in fake_bw.entries] + assert starts == [99, 100, 101] + values_by_start = {entry[1]: entry[3] for entry in fake_bw.entries} + assert values_by_start[99] == pytest.approx(1.0) + # 100 has two rows merged: (1+2)/(2+2) = 0.75 + assert values_by_start[100] == pytest.approx(0.75) + assert values_by_start[101] == pytest.approx(0.5) + + +def test_pileup_to_bigwig_sorts_rows_buffered_before_late_inversion( + monkeypatch, tmp_path +): + rows_chr1 = [ + _make_bedmethyl_row(chrom="chr1", start=100, strand="+", modified=1, valid=2), + _make_bedmethyl_row(chrom="chr1", start=101, strand="+", modified=1, valid=4), + _make_bedmethyl_row(chrom="chr1", start=99, strand="+", modified=1, valid=1), + _make_bedmethyl_row(chrom="chr1", start=100, strand="-", modified=2, valid=2), + ] + + class _FakeTabixFile: + def __init__(self, *_args, **_kwargs): + self.contigs = ["chr1"] + + def fetch(self, contig): + assert contig == "chr1" + return iter(rows_chr1) + + class _FakeFastaFile: + def __init__(self, *_args, **_kwargs): + pass + + def __enter__(self): + return self + + def __exit__(self, *_args): + return False + + def get_reference_length(self, contig): + assert contig == "chr1" + return 1000 + + class _FakeBigWig: + def __init__(self): + self.header = None + self.entries = [] + + def __enter__(self): + return self + + def __exit__(self, *_args): + return False + + def addHeader(self, header): + self.header = header + + def addEntries(self, contigs, starts, *, ends, values): + self.entries.extend(zip(contigs, starts, ends, values, strict=False)) + + fake_bw = _FakeBigWig() + + monkeypatch.setattr( + export.utils, + "sanitize_path_args", + lambda bedmethyl_file, bigwig_file, ref_genome: ( + Path(bedmethyl_file), + Path(bigwig_file) if bigwig_file is not None else None, + Path(ref_genome) if ref_genome is not None else None, + ), + ) + monkeypatch.setattr(export.pysam, "TabixFile", _FakeTabixFile) + monkeypatch.setattr(export.pysam, "FastaFile", _FakeFastaFile) + monkeypatch.setattr(export.pyBigWig, "open", lambda *_args, **_kwargs: fake_bw) + + output_bigwig = tmp_path / "out.bw" + export.pileup_to_bigwig( + bedmethyl_file=tmp_path / "in.bed.gz", + motif="A,0", + bigwig_file=output_bigwig, + ref_genome=tmp_path / "ref.fa", + strand=".", + chunk_size=1, + ) + + assert fake_bw.header == [("chr1", 1000)] + starts = [entry[1] for entry in fake_bw.entries] + assert starts == [99, 100, 101] + values_by_start = {entry[1]: entry[3] for entry in fake_bw.entries} + assert values_by_start[99] == pytest.approx(1.0) + # 100 has one row written before inversion plus one later row: (1+2)/(2+2) = 0.75 + assert values_by_start[100] == pytest.approx(0.75) + assert values_by_start[101] == pytest.approx(0.25) + + +def test_pileup_to_bigwig_streams_sorted_rows_before_iterator_is_exhausted( + monkeypatch, tmp_path +): + rows_chr1 = [ + _make_bedmethyl_row(chrom="chr1", start=100, strand="+", modified=1, valid=2), + _make_bedmethyl_row(chrom="chr1", start=101, strand="+", modified=1, valid=4), + _make_bedmethyl_row(chrom="chr1", start=102, strand="+", modified=3, valid=4), + ] + + class _FakeTabixFile: + def __init__(self, *_args, **_kwargs): + self.contigs = ["chr1"] + self.write_fetch_exhausted = True + + def fetch(self, contig): + assert contig == "chr1" + self.write_fetch_exhausted = False + try: + yield from rows_chr1 + finally: + self.write_fetch_exhausted = True + + class _FakeFastaFile: + def __init__(self, *_args, **_kwargs): + pass + + def __enter__(self): + return self + + def __exit__(self, *_args): + return False + + def get_reference_length(self, contig): + assert contig == "chr1" + return 1000 + + class _FakeBigWig: + def __init__(self, tabix): + self.header = None + self.entries = [] + self.add_entries_exhausted_states = [] + self.tabix = tabix + + def __enter__(self): + return self + + def __exit__(self, *_args): + return False + + def addHeader(self, header): + self.header = header + + def addEntries(self, contigs, starts, *, ends, values): + self.add_entries_exhausted_states.append(self.tabix.write_fetch_exhausted) + self.entries.extend(zip(contigs, starts, ends, values, strict=False)) + + fake_tabix = _FakeTabixFile() + fake_bw = _FakeBigWig(fake_tabix) + + monkeypatch.setattr( + export.utils, + "sanitize_path_args", + lambda bedmethyl_file, bigwig_file, ref_genome: ( + Path(bedmethyl_file), + Path(bigwig_file) if bigwig_file is not None else None, + Path(ref_genome) if ref_genome is not None else None, + ), + ) + monkeypatch.setattr(export.pysam, "TabixFile", lambda *_args, **_kwargs: fake_tabix) + monkeypatch.setattr(export.pysam, "FastaFile", _FakeFastaFile) + monkeypatch.setattr(export.pyBigWig, "open", lambda *_args, **_kwargs: fake_bw) + + export.pileup_to_bigwig( + bedmethyl_file=tmp_path / "in.bed.gz", + motif="A,0", + bigwig_file=tmp_path / "out.bw", + ref_genome=tmp_path / "ref.fa", + strand=".", + chunk_size=1, + ) + + assert fake_bw.add_entries_exhausted_states + assert fake_bw.add_entries_exhausted_states[0] is False + assert [entry[1] for entry in fake_bw.entries] == [100, 101, 102] + + +def test_pileup_to_bigwig_uses_max_end_for_header_without_reference( + monkeypatch, tmp_path +): + rows_chr1 = [ + _make_bedmethyl_row(chrom="chr1", start=100, strand="+", modified=1, valid=2), + _make_bedmethyl_row(chrom="chr1", start=105, strand="+", modified=1, valid=4), + _make_bedmethyl_row(chrom="chr1", start=99, strand="+", modified=1, valid=1), + ] + + class _FakeTabixFile: + def __init__(self, *_args, **_kwargs): + self.contigs = ["chr1"] + + def fetch(self, contig): + assert contig == "chr1" + return iter(rows_chr1) + + class _FakeBigWig: + def __init__(self): + self.header = None + self.entries = [] + + def __enter__(self): + return self + + def __exit__(self, *_args): + return False + + def addHeader(self, header): + self.header = header + + def addEntries(self, contigs, starts, *, ends, values): + self.entries.extend(zip(contigs, starts, ends, values, strict=False)) + + fake_bw = _FakeBigWig() + + monkeypatch.setattr( + export.utils, + "sanitize_path_args", + lambda bedmethyl_file, bigwig_file, ref_genome: ( + Path(bedmethyl_file), + Path(bigwig_file) if bigwig_file is not None else None, + Path(ref_genome) if ref_genome is not None else None, + ), + ) + monkeypatch.setattr(export.pysam, "TabixFile", _FakeTabixFile) + monkeypatch.setattr(export.pyBigWig, "open", lambda *_args, **_kwargs: fake_bw) + + export.pileup_to_bigwig( + bedmethyl_file=tmp_path / "in.bed.gz", + motif="A,0", + bigwig_file=tmp_path / "out.bw", + ref_genome=None, + strand=".", + chunk_size=2, + ) + + assert fake_bw.header == [("chr1", 106)] + assert [entry[1] for entry in fake_bw.entries] == [99, 100, 105] diff --git a/tests/test_global_analysis.py b/tests/test_global_analysis.py index 107b000..1c66fb5 100644 --- a/tests/test_global_analysis.py +++ b/tests/test_global_analysis.py @@ -316,7 +316,9 @@ def fake_regions_to_list( captured["split_large_regions"] = split_large_regions return [(5, 10), (0, 0)] - monkeypatch.setattr(global_analysis, "tile_genome_windows", fake_tile_genome_windows) + monkeypatch.setattr( + global_analysis, "tile_genome_windows", fake_tile_genome_windows + ) monkeypatch.setattr( global_analysis.load_processed, "regions_to_list", @@ -362,8 +364,12 @@ def test_compute_global_normalization_factors_from_summary(): "reference_fraction", "global_offset", } - assert factors.loc[factors["sample_id"] == "s1", "global_offset"].iloc[0] == pytest.approx(-0.1) - assert factors.loc[factors["sample_id"] == "s2", "global_offset"].iloc[0] == pytest.approx(0.1) + assert factors.loc[factors["sample_id"] == "s1", "global_offset"].iloc[ + 0 + ] == pytest.approx(-0.1) + assert factors.loc[factors["sample_id"] == "s2", "global_offset"].iloc[ + 0 + ] == pytest.approx(0.1) def test_run_global_analysis_returns_result(monkeypatch): @@ -452,12 +458,18 @@ def fake_build_window_summary(**kwargs): } ) - monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) + monkeypatch.setattr( + global_analysis, "build_window_summary", fake_build_window_summary + ) monkeypatch.setattr( global_analysis, "compute_global_normalization_factors", lambda summary: pd.DataFrame( - {"sample_id": ["s1", "s1"], "motif": ["A,0", "CG,0"], "global_offset": [0.0, 0.0]} + { + "sample_id": ["s1", "s1"], + "motif": ["A,0", "CG,0"], + "global_offset": [0.0, 0.0], + } ), ) diff --git a/tests/test_load_processed.py b/tests/test_load_processed.py index 02695da..521f7e8 100644 --- a/tests/test_load_processed.py +++ b/tests/test_load_processed.py @@ -1,5 +1,6 @@ -import numpy as np import h5py +import numpy as np +import pytest from dimelo import load_processed from dimelo import utils as dimelo_utils @@ -26,6 +27,34 @@ def fetch(self, _chromosome, _start, _end): return ["row_a", "row_b"] +def test_process_pileup_row_parses_modkit_18_column_format(): + parsed_motif = dimelo_utils.ParsedMotif("A,0") + row = "chr1\t9167144\t9167145\tY\t12\t+\t9167144\t9167145\t255,0,0\t12\t0.00\t3\t9\t0\t0\t0\t0\t0" + keep, coord, modified, valid = load_processed.process_pileup_row( + row=row, + parsed_motif=parsed_motif, + region_strand="+", + single_strand=False, + ) + assert keep is True + assert coord == 9167144 + assert modified == 3 + assert valid == 12 + + +def test_process_pileup_row_skips_malformed_rows_without_raising(): + parsed_motif = dimelo_utils.ParsedMotif("A,0") + malformed_row = "chr1\t1\t2\tY\tbad\t+\t1\t2\t255,0,0\tbad\t0.00\tbad" + with pytest.warns(RuntimeWarning, match="Skipping malformed bedMethyl row"): + keep, coord, modified, valid = load_processed.process_pileup_row( + row=malformed_row, + parsed_motif=parsed_motif, + region_strand="+", + single_strand=False, + ) + assert (keep, coord, modified, valid) == (False, 0, 0, 0) + + def test_resolve_cores_for_task_count_auto_small_batch_is_single_core(monkeypatch): monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: 8) resolved = load_processed._resolve_cores_for_task_count( @@ -36,7 +65,9 @@ def test_resolve_cores_for_task_count_auto_small_batch_is_single_core(monkeypatc def test_resolve_cores_for_task_count_explicit_cores_are_preserved(monkeypatch): - monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: int(_cores)) + monkeypatch.setattr( + load_processed.utils, "cores_to_run", lambda _cores: int(_cores) + ) resolved = load_processed._resolve_cores_for_task_count( requested_cores=4, task_count=2, @@ -46,9 +77,13 @@ def test_resolve_cores_for_task_count_explicit_cores_are_preserved(monkeypatch): def test_memory_limited_cores_caps_auto_parallelism(monkeypatch): monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: 8) - monkeypatch.setattr(load_processed, "_available_memory_bytes", lambda: 1024 * 1024 * 1024) + monkeypatch.setattr( + load_processed, "_available_memory_bytes", lambda: 1024 * 1024 * 1024 + ) monkeypatch.setattr(load_processed, "AUTO_PARALLEL_MEMORY_FRACTION", 0.5) - monkeypatch.setattr(load_processed, "AUTO_PARALLEL_PROCESS_OVERHEAD_BYTES", 64 * 1024 * 1024) + monkeypatch.setattr( + load_processed, "AUTO_PARALLEL_PROCESS_OVERHEAD_BYTES", 64 * 1024 * 1024 + ) resolved = load_processed._memory_limited_cores( requested_cores=None, @@ -60,8 +95,12 @@ def test_memory_limited_cores_caps_auto_parallelism(monkeypatch): def test_memory_limited_cores_keeps_explicit_override(monkeypatch): - monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: int(_cores)) - monkeypatch.setattr(load_processed, "_available_memory_bytes", lambda: 128 * 1024 * 1024) + monkeypatch.setattr( + load_processed.utils, "cores_to_run", lambda _cores: int(_cores) + ) + monkeypatch.setattr( + load_processed, "_available_memory_bytes", lambda: 128 * 1024 * 1024 + ) resolved = load_processed._memory_limited_cores( requested_cores=6, @@ -141,7 +180,9 @@ def __init__(self, _path): def test_pileup_vectors_from_bedmethyl_single_core_bypasses_process_pool(monkeypatch): def _raise_if_called(*_args, **_kwargs): - raise AssertionError("ProcessPoolExecutor should not be created for single-core execution.") + raise AssertionError( + "ProcessPoolExecutor should not be created for single-core execution." + ) def fake_process_pileup_row(row, **_kwargs): if row == "row_a": @@ -150,10 +191,20 @@ def fake_process_pileup_row(row, **_kwargs): return True, 102, 1, 3 raise AssertionError(f"Unexpected row payload: {row}") - monkeypatch.setattr(load_processed.utils, "regions_dict_from_input", lambda *_args, **_kwargs: {"chr1": [(100, 104, "+")]}) - monkeypatch.setattr(load_processed.utils, "process_chunks_from_regions_dict", lambda *_args, **_kwargs: _single_region_chunks()) + monkeypatch.setattr( + load_processed.utils, + "regions_dict_from_input", + lambda *_args, **_kwargs: {"chr1": [(100, 104, "+")]}, + ) + monkeypatch.setattr( + load_processed.utils, + "process_chunks_from_regions_dict", + lambda *_args, **_kwargs: _single_region_chunks(), + ) monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: 1) - monkeypatch.setattr(load_processed.concurrent.futures, "ProcessPoolExecutor", _raise_if_called) + monkeypatch.setattr( + load_processed.concurrent.futures, "ProcessPoolExecutor", _raise_if_called + ) monkeypatch.setattr(load_processed.pysam, "TabixFile", _FakeTabix) monkeypatch.setattr(load_processed, "process_pileup_row", fake_process_pileup_row) @@ -170,7 +221,9 @@ def fake_process_pileup_row(row, **_kwargs): def test_regions_to_list_single_core_bypasses_process_pool(monkeypatch): def _raise_if_called(*_args, **_kwargs): - raise AssertionError("ProcessPoolExecutor should not be created for single-core execution.") + raise AssertionError( + "ProcessPoolExecutor should not be created for single-core execution." + ) monkeypatch.setattr( load_processed.utils, @@ -178,7 +231,9 @@ def _raise_if_called(*_args, **_kwargs): lambda *_args, **_kwargs: {"chr1": [(100, 110, "+"), (120, 130, "-")]}, ) monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: 1) - monkeypatch.setattr(load_processed.concurrent.futures, "ProcessPoolExecutor", _raise_if_called) + monkeypatch.setattr( + load_processed.concurrent.futures, "ProcessPoolExecutor", _raise_if_called + ) result = load_processed.regions_to_list( function_handle=lambda regions, **_kwargs: f"ok:{regions}", @@ -191,7 +246,9 @@ def _raise_if_called(*_args, **_kwargs): def test_regions_to_list_auto_cores_prefers_single_core_for_small_batches(monkeypatch): def _raise_if_called(*_args, **_kwargs): - raise AssertionError("ProcessPoolExecutor should not be created for small auto-core batches.") + raise AssertionError( + "ProcessPoolExecutor should not be created for small auto-core batches." + ) monkeypatch.setattr( load_processed.utils, @@ -199,7 +256,9 @@ def _raise_if_called(*_args, **_kwargs): lambda *_args, **_kwargs: {"chr1": [(100, 110, "+"), (120, 130, "-")]}, ) monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: 8) - monkeypatch.setattr(load_processed.concurrent.futures, "ProcessPoolExecutor", _raise_if_called) + monkeypatch.setattr( + load_processed.concurrent.futures, "ProcessPoolExecutor", _raise_if_called + ) result = load_processed.regions_to_list( function_handle=lambda regions, **_kwargs: f"ok:{regions}", @@ -232,8 +291,12 @@ def map(self, fn, iterable): "regions_dict_from_input", lambda *_args, **_kwargs: {"chr1": [(100, 110, "+"), (120, 130, "-")]}, ) - monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: int(_cores)) - monkeypatch.setattr(load_processed.concurrent.futures, "ProcessPoolExecutor", _FakeExecutor) + monkeypatch.setattr( + load_processed.utils, "cores_to_run", lambda _cores: int(_cores) + ) + monkeypatch.setattr( + load_processed.concurrent.futures, "ProcessPoolExecutor", _FakeExecutor + ) result = load_processed.regions_to_list( function_handle=lambda regions, **_kwargs: f"ok:{regions}", @@ -270,8 +333,12 @@ def map(self, fn, iterable): "regions_dict_from_input", lambda *_args, **_kwargs: {"chr1": regions}, ) - monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: int(_cores)) - monkeypatch.setattr(load_processed.concurrent.futures, "ProcessPoolExecutor", _FakeExecutor) + monkeypatch.setattr( + load_processed.utils, "cores_to_run", lambda _cores: int(_cores) + ) + monkeypatch.setattr( + load_processed.concurrent.futures, "ProcessPoolExecutor", _FakeExecutor + ) result = load_processed.regions_to_list( function_handle=lambda regions, **_kwargs: f"ok:{regions}", @@ -295,15 +362,21 @@ def map(self, fn, iterable): return map(fn, iterable) def _raise_if_called(*_args, **_kwargs): - raise AssertionError("ProcessPoolExecutor should not be created when external executor is provided.") + raise AssertionError( + "ProcessPoolExecutor should not be created when external executor is provided." + ) monkeypatch.setattr( load_processed.utils, "regions_dict_from_input", lambda *_args, **_kwargs: {"chr1": [(100, 110, "+"), (120, 130, "-")]}, ) - monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: int(_cores)) - monkeypatch.setattr(load_processed.concurrent.futures, "ProcessPoolExecutor", _raise_if_called) + monkeypatch.setattr( + load_processed.utils, "cores_to_run", lambda _cores: int(_cores) + ) + monkeypatch.setattr( + load_processed.concurrent.futures, "ProcessPoolExecutor", _raise_if_called + ) executor = _ExternalExecutor() result = load_processed.regions_to_list( @@ -320,7 +393,9 @@ def _raise_if_called(*_args, **_kwargs): def test_pileup_counts_from_bedmethyl_single_core_bypasses_process_pool(monkeypatch): def _raise_if_called(*_args, **_kwargs): - raise AssertionError("ProcessPoolExecutor should not be created for single-core execution.") + raise AssertionError( + "ProcessPoolExecutor should not be created for single-core execution." + ) def fake_process_pileup_row(row, **_kwargs): if row == "row_a": @@ -329,10 +404,20 @@ def fake_process_pileup_row(row, **_kwargs): return True, 0, 1, 3 raise AssertionError(f"Unexpected row payload: {row}") - monkeypatch.setattr(load_processed.utils, "regions_dict_from_input", lambda *_args, **_kwargs: {"chr1": [(100, 104, "+")]}) - monkeypatch.setattr(load_processed.utils, "process_chunks_from_regions_dict", lambda *_args, **_kwargs: _single_region_chunks()) + monkeypatch.setattr( + load_processed.utils, + "regions_dict_from_input", + lambda *_args, **_kwargs: {"chr1": [(100, 104, "+")]}, + ) + monkeypatch.setattr( + load_processed.utils, + "process_chunks_from_regions_dict", + lambda *_args, **_kwargs: _single_region_chunks(), + ) monkeypatch.setattr(load_processed.utils, "cores_to_run", lambda _cores: 1) - monkeypatch.setattr(load_processed.concurrent.futures, "ProcessPoolExecutor", _raise_if_called) + monkeypatch.setattr( + load_processed.concurrent.futures, "ProcessPoolExecutor", _raise_if_called + ) monkeypatch.setattr(load_processed.pysam, "TabixFile", _FakeTabix) monkeypatch.setattr(load_processed, "process_pileup_row", fake_process_pileup_row) @@ -351,7 +436,9 @@ def test_read_vectors_from_hdf5_mod_fraction_order_and_missing_defaults(tmp_path h5_path = tmp_path / "reads.h5" with h5py.File(h5_path, "w") as h5: h5.create_dataset("read_name", data=np.array(["r1", "r1", "r2"], dtype="S2")) - h5.create_dataset("chromosome", data=np.array(["chr1", "chr1", "chr1"], dtype="S4")) + h5.create_dataset( + "chromosome", data=np.array(["chr1", "chr1", "chr1"], dtype="S4") + ) h5.create_dataset("read_start", data=np.array([0, 0, 10], dtype=np.int32)) h5.create_dataset("read_end", data=np.array([4, 4, 14], dtype=np.int32)) h5.create_dataset("motif", data=np.array(["A,0", "CG,0", "A,0"], dtype="S4")) diff --git a/tests/test_models.py b/tests/test_models.py index 76d1444..d320e3e 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -9,18 +9,18 @@ ChipAtlasEnrichmentResult, CohortSpec, ContrastSpec, + DatasetArtifact, + GlobalAnalysisResult, ModkitDMRMultiResult, ModkitDMRPairResult, - GlobalAnalysisResult, - DatasetArtifact, - SampleSpec, - RegionDiscoveryResult, + RegionContrastResult, RegionDiscoveryClusterContrastResult, RegionDiscoveryClusterResult, - RegionContrastResult, + RegionDiscoveryResult, + SampleSpec, + SharedClusterContrastResult, SharedClusterModel, SharedClusterResult, - SharedClusterContrastResult, ) @@ -45,7 +45,9 @@ def test_dimelo_package_root_exports_region_discovery_cluster_contrast_result(): RegionDiscoveryClusterContrastResult as RootRegionDiscoveryClusterContrastResult, ) - assert RootRegionDiscoveryClusterContrastResult is RegionDiscoveryClusterContrastResult + assert ( + RootRegionDiscoveryClusterContrastResult is RegionDiscoveryClusterContrastResult + ) def test_dimelo_package_root_exports_chip_atlas_enrichment_result(): @@ -502,9 +504,7 @@ def test_region_discovery_cluster_result_supports_wrapped_outputs(): figures={}, metadata={"notes": "ok"}, ) - selected_regions = pd.DataFrame( - [{"chromosome": "chr1", "start": 0, "end": 1000}] - ) + selected_regions = pd.DataFrame([{"chromosome": "chr1", "start": 0, "end": 1000}]) result = RegionDiscoveryClusterResult( discovery=discovery, @@ -663,9 +663,7 @@ def test_region_discovery_cluster_contrast_result_supports_wrapped_outputs(): metadata={"notes": "ok"}, figures={}, ) - selected_regions = pd.DataFrame( - [{"chromosome": "chr1", "start": 0, "end": 1000}] - ) + selected_regions = pd.DataFrame([{"chromosome": "chr1", "start": 0, "end": 1000}]) result = RegionDiscoveryClusterContrastResult( discovery=discovery, diff --git a/tests/test_parse_bam.py b/tests/test_parse_bam.py index cfa3598..522d29e 100644 --- a/tests/test_parse_bam.py +++ b/tests/test_parse_bam.py @@ -1,6 +1,8 @@ -import pytest +import gzip from pathlib import Path +import pytest + from dimelo import parse_bam, run_modkit @@ -28,8 +30,7 @@ def __init__(self, reads): self._reads = reads def fetch(self): - for read in self._reads: - yield read + yield from self._reads def test_check_bam_format_consumes_at_most_the_first_100_reads(monkeypatch): @@ -88,6 +89,21 @@ def test_threads_command_list_uses_requested_cores_when_available(monkeypatch): assert command == ["--threads", "6"] +def test_parse_should_render_live_progress_respects_env_off(monkeypatch): + monkeypatch.setenv("DIMELO_PROGRESS_MODE", "off") + monkeypatch.setattr(parse_bam.sys.stderr, "isatty", lambda: True) + + assert parse_bam._should_render_live_progress() is False + + +def test_parse_should_render_live_progress_auto_disables_notebook(monkeypatch): + monkeypatch.delenv("DIMELO_PROGRESS_MODE", raising=False) + monkeypatch.setenv("JPY_PARENT_PID", "12345") + monkeypatch.setattr(parse_bam.sys.stderr, "isatty", lambda: True) + + assert parse_bam._should_render_live_progress() is False + + def test_create_region_command_list_returns_empty_without_regions(tmp_path): command, bed_path = parse_bam.create_region_command_list( output_path=tmp_path, @@ -302,5 +318,301 @@ def test_build_extract_command_prefix_uses_full_subcommand_for_modkit_0_6(): capabilities=legacy, ) - assert modern_prefix == ["modkit", "extract", "full", Path("input.bam"), Path("out.txt")] + assert modern_prefix == [ + "modkit", + "extract", + "full", + Path("input.bam"), + Path("out.txt"), + ] assert legacy_prefix == ["modkit", "extract", Path("input.bam"), Path("out.txt")] + + +def test_build_extract_command_prefix_uses_version_fallback_for_modkit_0_6(): + stale = run_modkit.ModkitCapabilities( + executable="modkit", + version_raw="modkit 0.6.1", + version="0.6.1", + version_tuple=(0, 6, 1), + supports_mod_threshold=True, + supports_mod_thresholds=False, + supports_modified_bases=True, + supports_force_allow_implicit=False, + # Simulate stale capability detection. + supports_extract_subcommands=False, + extract_supports_reference_long=False, + extract_supports_reference_short=False, + ) + + prefix = parse_bam._build_extract_command_prefix( + input_file=Path("input.bam"), + output_txt=Path("out.txt"), + capabilities=stale, + ) + ref_flags = parse_bam._build_extract_reference_command_list( + ref_genome=Path("ref.fa"), + capabilities=stale, + ) + + assert prefix == ["modkit", "extract", "full", Path("input.bam"), Path("out.txt")] + assert ref_flags == ["--reference", Path("ref.fa")] + + +def test_prep_output_directory_respects_overwrite_flag(tmp_path): + _, (output_file,) = parse_bam.prep_output_directory( + output_directory=tmp_path, + output_name="demo", + input_file=tmp_path, + output_file_names=["result.txt"], + overwrite=True, + ) + output_file.write_text("keep-me") + + parse_bam.prep_output_directory( + output_directory=tmp_path, + output_name="demo", + input_file=tmp_path, + output_file_names=["result.txt"], + overwrite=False, + ) + assert output_file.exists() + + parse_bam.prep_output_directory( + output_directory=tmp_path, + output_name="demo", + input_file=tmp_path, + output_file_names=["result.txt"], + overwrite=True, + ) + assert not output_file.exists() + + +def test_extract_overwrite_false_reuses_existing_outputs(tmp_path, monkeypatch): + output_path = tmp_path / "existing_extract" + output_path.mkdir(parents=True) + output_reads_path = output_path / "reads.combined_basemods.h5" + output_reads_path.write_bytes(b"") + processed_regions_path = output_path / "regions.processed.bed" + processed_regions_path.write_text("chr1\t0\t1\n") + + def _unexpected_modkit(*args, **kwargs): + raise AssertionError("modkit should not be called when outputs are reused") + + monkeypatch.setattr(run_modkit, "_ensure_modkit_available", _unexpected_modkit) + + output_reads, processed_regions = parse_bam.extract( + input_file=tmp_path / "missing.bam", + output_name="existing_extract", + ref_genome=tmp_path / "missing.fa", + output_directory=tmp_path, + regions="chr1:1-2", + overwrite=False, + quiet=True, + ) + + assert output_reads == output_reads_path + assert processed_regions == processed_regions_path + + +def test_extract_overwrite_false_raises_on_partial_existing_outputs( + tmp_path, monkeypatch +): + output_path = tmp_path / "partial_extract" + output_path.mkdir(parents=True) + output_reads_path = output_path / "reads.combined_basemods.h5" + output_reads_path.write_bytes(b"") + + def _unexpected_modkit(*args, **kwargs): + raise AssertionError("modkit should not be called before conflict check") + + monkeypatch.setattr(run_modkit, "_ensure_modkit_available", _unexpected_modkit) + + with pytest.raises(FileExistsError, match="overwrite=False"): + parse_bam.extract( + input_file=tmp_path / "missing.bam", + output_name="partial_extract", + ref_genome=tmp_path / "missing.fa", + output_directory=tmp_path, + regions="chr1:1-2", + overwrite=False, + quiet=True, + ) + + +def test_pileup_overwrite_false_reuses_existing_outputs(tmp_path, monkeypatch): + output_path = tmp_path / "existing_pileup" + output_path.mkdir(parents=True) + output_pileup_path = output_path / "pileup.sorted.bed.gz" + output_pileup_path.write_bytes(b"") + output_pileup_tbi_path = output_path / "pileup.sorted.bed.gz.tbi" + output_pileup_tbi_path.write_bytes(b"") + processed_regions_path = output_path / "regions.processed.bed" + processed_regions_path.write_text("chr1\t0\t1\n") + + def _unexpected_modkit(*args, **kwargs): + raise AssertionError("modkit should not be called when outputs are reused") + + monkeypatch.setattr(run_modkit, "_ensure_modkit_available", _unexpected_modkit) + + output_pileup, processed_regions = parse_bam.pileup( + input_file=tmp_path / "missing.bam", + output_name="existing_pileup", + ref_genome=tmp_path / "missing.fa", + output_directory=tmp_path, + regions="chr1:1-2", + overwrite=False, + quiet=True, + ) + + assert output_pileup == output_pileup_path + assert processed_regions == processed_regions_path + + +def test_pileup_preserves_explicit_threshold_empty_output_without_retry( + tmp_path, monkeypatch +): + calls = [] + + capabilities = run_modkit.ModkitCapabilities( + executable="modkit", + version_raw="modkit 0.6.1", + version="0.6.1", + version_tuple=(0, 6, 1), + supports_mod_threshold=True, + supports_mod_thresholds=False, + supports_modified_bases=True, + supports_force_allow_implicit=False, + supports_extract_subcommands=True, + extract_supports_reference_long=True, + extract_supports_reference_short=True, + ) + + monkeypatch.setattr( + run_modkit, "_ensure_modkit_available", lambda **_: capabilities + ) + monkeypatch.setattr(parse_bam, "verify_inputs", lambda *args, **kwargs: None) + + def _fake_run_with_progress_bars(*, command_list, **kwargs): + calls.append(command_list) + output_bed = Path(command_list[3]) + output_bed.write_text("") + + monkeypatch.setattr( + run_modkit, "run_with_progress_bars", _fake_run_with_progress_bars + ) + + output_pileup, _ = parse_bam.pileup( + input_file=tmp_path / "missing.bam", + output_name="test_out", + ref_genome=tmp_path / "missing.fa", + output_directory=tmp_path, + motifs=["A,0"], + thresh=190, + regions=None, + quiet=True, + overwrite=True, + ) + + assert len(calls) == 1 + assert "--mod-threshold" in calls[0] + + with gzip.open(output_pileup, "rt") as handle: + rows = [line for line in handle if line.strip()] + assert rows == [] + + +def test_group_motifs_for_pileup_splits_multi_context_on_modkit_0_6(): + capabilities = run_modkit.ModkitCapabilities( + executable="modkit", + version_raw="modkit 0.6.1", + version="0.6.1", + version_tuple=(0, 6, 1), + supports_mod_threshold=True, + supports_mod_thresholds=False, + supports_modified_bases=True, + supports_force_allow_implicit=False, + supports_extract_subcommands=True, + extract_supports_reference_long=True, + extract_supports_reference_short=True, + ) + groups = parse_bam._group_motifs_for_pileup(["A,0", "CG,0"], capabilities) + assert groups == [("A,0", ["A,0"]), ("CG,0", ["CG,0"])] + + +def test_group_motifs_for_pileup_keeps_combined_on_legacy_modkit(): + capabilities = run_modkit.ModkitCapabilities( + executable="modkit", + version_raw="modkit 0.2.4", + version="0.2.4", + version_tuple=(0, 2, 4), + supports_mod_threshold=False, + supports_mod_thresholds=True, + supports_modified_bases=False, + supports_force_allow_implicit=True, + supports_extract_subcommands=False, + extract_supports_reference_long=False, + extract_supports_reference_short=True, + ) + groups = parse_bam._group_motifs_for_pileup(["A,0", "CG,0"], capabilities) + assert groups == [("combined", ["A,0", "CG,0"])] + + +def test_pileup_multi_motif_split_merges_outputs_on_modkit_0_6(tmp_path, monkeypatch): + calls = [] + capabilities = run_modkit.ModkitCapabilities( + executable="modkit", + version_raw="modkit 0.6.1", + version="0.6.1", + version_tuple=(0, 6, 1), + supports_mod_threshold=True, + supports_mod_thresholds=False, + supports_modified_bases=True, + supports_force_allow_implicit=False, + supports_extract_subcommands=True, + extract_supports_reference_long=True, + extract_supports_reference_short=True, + ) + + monkeypatch.setattr( + run_modkit, "_ensure_modkit_available", lambda **_: capabilities + ) + monkeypatch.setattr(parse_bam, "verify_inputs", lambda *args, **kwargs: None) + + def _fake_run_with_progress_bars(*, command_list, **kwargs): + calls.append(command_list) + output_bed = Path(command_list[3]) + modified_bases = [] + for i, token in enumerate(command_list): + if token == "--modified-bases": + modified_bases.append(command_list[i + 1]) + if any(base.startswith("A:") for base in modified_bases): + output_bed.write_text( + "chr1\t10\t11\ta\t1\t+\t10\t11\t255,0,0\t1\t0.0\t0\t1\t0\t0\t0\t0\t0\n" + ) + elif any(base.startswith("C:") for base in modified_bases): + output_bed.write_text( + "chr1\t12\t13\tm\t1\t+\t12\t13\t255,0,0\t1\t0.0\t0\t1\t0\t0\t0\t0\t0\n" + ) + else: + output_bed.write_text("") + + monkeypatch.setattr( + run_modkit, "run_with_progress_bars", _fake_run_with_progress_bars + ) + + output_pileup, _ = parse_bam.pileup( + input_file=tmp_path / "missing.bam", + output_name="test_out_multi", + ref_genome=tmp_path / "missing.fa", + output_directory=tmp_path, + motifs=["A,0", "CG,0"], + thresh=None, + regions=None, + quiet=True, + overwrite=True, + ) + + assert len(calls) == 2 + with gzip.open(output_pileup, "rt") as handle: + rows = [line for line in handle if line.strip()] + assert len(rows) == 2 diff --git a/tests/test_parse_bam_vectors.py b/tests/test_parse_bam_vectors.py index 89f921c..d7b2028 100644 --- a/tests/test_parse_bam_vectors.py +++ b/tests/test_parse_bam_vectors.py @@ -183,7 +183,9 @@ def test_read_by_base_txt_to_hdf5_uses_dense_span_vectors(tmp_path): sparse_val_vector = _decode_vector(h5["val_vector"], sparse_index) no_hits_index = 1 - no_hits_span = int(h5["read_end"][no_hits_index] - h5["read_start"][no_hits_index]) + no_hits_span = int( + h5["read_end"][no_hits_index] - h5["read_start"][no_hits_index] + ) no_hits_mod_vector = _decode_vector(h5["mod_vector"], no_hits_index) no_hits_val_vector = _decode_vector(h5["val_vector"], no_hits_index) @@ -267,8 +269,12 @@ def test_read_by_base_txt_to_hdf5_stores_per_motif_threshold_metadata(tmp_path): val_vector_index = datasets.index("val_vector") assert len(read_tuples) == 4 - assert all(read_tuple[mod_vector_index].dtype == np.bool_ for read_tuple in read_tuples) - assert all(read_tuple[val_vector_index].dtype == np.bool_ for read_tuple in read_tuples) + assert all( + read_tuple[mod_vector_index].dtype == np.bool_ for read_tuple in read_tuples + ) + assert all( + read_tuple[val_vector_index].dtype == np.bool_ for read_tuple in read_tuples + ) def test_read_by_base_txt_to_hdf5_rejects_mixed_raw_and_thresholded_motifs(tmp_path): @@ -322,8 +328,12 @@ def test_read_vectors_from_hdf5_loads_thresholded_vectors_as_binary(tmp_path): read_name_index = datasets.index("read_name") assert len(read_tuples) == 2 - assert all(read_tuple[mod_vector_index].dtype == np.bool_ for read_tuple in read_tuples) - assert all(read_tuple[val_vector_index].dtype == np.bool_ for read_tuple in read_tuples) + assert all( + read_tuple[mod_vector_index].dtype == np.bool_ for read_tuple in read_tuples + ) + assert all( + read_tuple[val_vector_index].dtype == np.bool_ for read_tuple in read_tuples + ) reads_by_name = { read_tuple[read_name_index]: read_tuple for read_tuple in read_tuples @@ -562,12 +572,14 @@ def test_readwise_binary_modification_arrays_splits_duplicate_read_names_by_regi quiet=True, ) - _, read_ids, motifs, regions_dict = load_processed.readwise_binary_modification_arrays( - file=output_h5, - motifs=["A,0"], - regions=["chr1:95-105", "chr1:100-110"], - thresh=None, - quiet=True, + _, read_ids, motifs, regions_dict = ( + load_processed.readwise_binary_modification_arrays( + file=output_h5, + motifs=["A,0"], + regions=["chr1:95-105", "chr1:100-110"], + thresh=None, + quiet=True, + ) ) assert set(read_ids.tolist()) == {0, 1} @@ -675,6 +687,97 @@ def test_read_vectors_from_hdf5_accepts_tuple_sort_by(tmp_path): ] +def test_read_vectors_from_hdf5_filters_by_min_read_length(tmp_path): + input_txt = tmp_path / "extract.txt" + output_h5 = tmp_path / "reads_thresholded.h5" + _write_extract_file(input_txt) + + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=0.5, + quiet=True, + ) + + read_tuples, datasets, _ = load_processed.read_vectors_from_hdf5( + file=output_h5, + motifs=["A,0"], + min_read_length_bp=11, + calculate_mod_fractions=False, + quiet=True, + ) + + read_name_index = datasets.index("read_name") + assert [row[read_name_index] for row in read_tuples] == ["read_no_hits"] + + +def test_read_vectors_from_hdf5_supports_global_random_read_sample( + tmp_path, monkeypatch +): + input_txt = tmp_path / "extract.txt" + output_h5 = tmp_path / "reads_thresholded.h5" + _write_extract_file(input_txt) + + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=0.5, + quiet=True, + ) + + def _pick_first(array, n=None, frac=None, replace=False): + assert n == 1 + return np.asarray(array[:1]) + + monkeypatch.setattr(load_processed.utils, "random_sample", _pick_first) + + read_tuples, datasets, _ = load_processed.read_vectors_from_hdf5( + file=output_h5, + motifs=["A,0"], + random_sample_n_reads=1, + calculate_mod_fractions=False, + quiet=True, + ) + + read_name_index = datasets.index("read_name") + sampled_names = {row[read_name_index] for row in read_tuples} + assert len(sampled_names) == 1 + + +def test_read_vectors_from_hdf5_rejects_invalid_random_sample_or_length(tmp_path): + input_txt = tmp_path / "extract.txt" + output_h5 = tmp_path / "reads_thresholded.h5" + _write_extract_file(input_txt) + + parse_bam.read_by_base_txt_to_hdf5( + input_txt=input_txt, + output_h5=output_h5, + motif="A,0", + thresh=0.5, + quiet=True, + ) + + with pytest.raises(ValueError, match="random_sample_n_reads"): + load_processed.read_vectors_from_hdf5( + file=output_h5, + motifs=["A,0"], + random_sample_n_reads=0, + calculate_mod_fractions=False, + quiet=True, + ) + + with pytest.raises(ValueError, match="min_read_length_bp"): + load_processed.read_vectors_from_hdf5( + file=output_h5, + motifs=["A,0"], + min_read_length_bp=-1, + calculate_mod_fractions=False, + quiet=True, + ) + + def test_readwise_binary_modification_arrays_passes_subset_and_quiet(monkeypatch): captured_kwargs = {} @@ -714,12 +817,16 @@ def _fake_read_vectors_from_hdf5(**kwargs): motifs=["A,0"], regions="chr1:100-110", subset_parameters={"n": 1}, + random_sample_n_reads=1, + min_read_length_bp=1000, quiet=False, ) ) assert captured_kwargs["quiet"] is False assert captured_kwargs["subset_parameters"] == {"n": 1} + assert captured_kwargs["random_sample_n_reads"] == 1 + assert captured_kwargs["min_read_length_bp"] == 1000 assert mod_positions.tolist() == [-5] assert read_ids.tolist() == [0] assert motifs.tolist() == ["A,0"] diff --git a/tests/test_plotting.py b/tests/test_plotting.py index ba2549f..e1f41e2 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -2,14 +2,6 @@ import pandas as pd import pytest -from dimelo.models import ( - ContrastSpec, - GlobalAnalysisResult, - RegionContrastResult, - RegionDiscoveryResult, - SharedClusterModel, - SharedClusterResult, -) from dimelo import ( plot_depth_histogram, plot_depth_profile, @@ -18,6 +10,14 @@ plot_reads, plotting, ) +from dimelo.models import ( + ContrastSpec, + GlobalAnalysisResult, + RegionContrastResult, + RegionDiscoveryResult, + SharedClusterModel, + SharedClusterResult, +) @pytest.fixture(autouse=True) @@ -69,7 +69,9 @@ def fake_plot_depth_profile(**kwargs): captured.update(kwargs) return "axes" - monkeypatch.setattr(plot_depth_profile, "plot_depth_profile", fake_plot_depth_profile) + monkeypatch.setattr( + plot_depth_profile, "plot_depth_profile", fake_plot_depth_profile + ) axes = plot_depth_profile.by_regions( mod_file_name="pileup.fake", @@ -231,7 +233,13 @@ def test_prepare_cluster_distribution_bar_data_handles_empty_input_shape(): result = plotting.prepare_cluster_distribution_bar_data(cluster_distribution) - assert list(result.columns) == ["sample_id", "condition", "cluster", "count", "fraction"] + assert list(result.columns) == [ + "sample_id", + "condition", + "cluster", + "count", + "fraction", + ] assert result.empty @@ -541,13 +549,23 @@ def test_prepare_shared_cluster_distribution_data_returns_distribution_payload() "metadata", } assert sample_distribution["sample_id"].tolist() == ["s1", "s1", "s2", "s2"] - assert sample_distribution["condition"].tolist() == ["NS", "NS", "treated", "treated"] + assert sample_distribution["condition"].tolist() == [ + "NS", + "NS", + "treated", + "treated", + ] assert sample_distribution["cluster"].tolist() == ["C0", "C1", "C0", "C1"] assert sample_distribution["count"].tolist() == [2, 1, 1, 3] assert sample_distribution["fraction"].tolist() == pytest.approx( [2 / 3, 1 / 3, 1 / 4, 3 / 4] ) - assert condition_distribution["condition"].tolist() == ["NS", "NS", "treated", "treated"] + assert condition_distribution["condition"].tolist() == [ + "NS", + "NS", + "treated", + "treated", + ] assert condition_distribution["cluster"].tolist() == ["C0", "C1", "C0", "C1"] assert condition_distribution["count"].tolist() == [2, 1, 1, 3] assert condition_distribution["fraction"].tolist() == pytest.approx( @@ -558,8 +576,12 @@ def test_prepare_shared_cluster_distribution_data_returns_distribution_payload() assert distribution_change["cluster"].tolist() == ["C0", "C1"] assert distribution_change["count"].tolist() == [1, 3] assert distribution_change["fraction"].tolist() == pytest.approx([1 / 4, 3 / 4]) - assert distribution_change["reference_fraction"].tolist() == pytest.approx([2 / 3, 1 / 3]) - assert distribution_change["delta_fraction"].tolist() == pytest.approx([-5 / 12, 5 / 12]) + assert distribution_change["reference_fraction"].tolist() == pytest.approx( + [2 / 3, 1 / 3] + ) + assert distribution_change["delta_fraction"].tolist() == pytest.approx( + [-5 / 12, 5 / 12] + ) assert distribution_change["log2_fc"].tolist() == pytest.approx( [-1.415037499278844, 1.1699250014423124] ) @@ -578,6 +600,7 @@ def test_plotting_matplotlib_module_exports_save_figure(): def test_save_figure_writes_png(tmp_path): from matplotlib import pyplot as plt + from dimelo import plotting_matplotlib fig, ax = plt.subplots() @@ -615,7 +638,12 @@ def test_prepare_shared_cluster_distribution_data_handles_missing_change_table() assert sample_distribution["fraction"].tolist() == pytest.approx( [2 / 3, 1 / 3, 1 / 4, 3 / 4] ) - assert condition_distribution["condition"].tolist() == ["NS", "NS", "treated", "treated"] + assert condition_distribution["condition"].tolist() == [ + "NS", + "NS", + "treated", + "treated", + ] assert condition_distribution["cluster"].tolist() == ["C0", "C1", "C0", "C1"] assert condition_distribution["count"].tolist() == [2, 1, 1, 3] assert condition_distribution["fraction"].tolist() == pytest.approx( @@ -630,7 +658,12 @@ def test_plot_shared_cluster_distribution_matplotlib_returns_figure_and_axis(): payload = plotting.prepare_shared_cluster_distribution_data( result=_make_shared_cluster_result_with_explicit_display_order() ) - assert payload["sample_distribution"]["sample_id"].tolist() == ["s1", "s1", "s2", "s2"] + assert payload["sample_distribution"]["sample_id"].tolist() == [ + "s1", + "s1", + "s2", + "s2", + ] assert payload["condition_distribution"]["condition"].tolist() == [ "NS", "NS", @@ -638,25 +671,37 @@ def test_plot_shared_cluster_distribution_matplotlib_returns_figure_and_axis(): "treated", ] - fig, ax = plotting_matplotlib.plot_shared_cluster_distribution_matplotlib(payload, level="sample") + fig, ax = plotting_matplotlib.plot_shared_cluster_distribution_matplotlib( + payload, level="sample" + ) assert fig is not None assert ax is not None assert [text.get_text() for text in ax.get_legend().texts] == ["C1", "C0"] - assert [tick.get_text() for tick in ax.get_xticklabels() if tick.get_text()] == ["s1", "s2"] + assert [tick.get_text() for tick in ax.get_xticklabels() if tick.get_text()] == [ + "s1", + "s2", + ] - fig, ax = plotting_matplotlib.plot_shared_cluster_distribution_matplotlib(payload, level="condition") + fig, ax = plotting_matplotlib.plot_shared_cluster_distribution_matplotlib( + payload, level="condition" + ) assert fig is not None assert ax is not None assert [text.get_text() for text in ax.get_legend().texts] == ["C1", "C0"] - assert [tick.get_text() for tick in ax.get_xticklabels() if tick.get_text()] == ["NS", "treated"] + assert [tick.get_text() for tick in ax.get_xticklabels() if tick.get_text()] == [ + "NS", + "treated", + ] def test_plot_shared_cluster_distribution_matplotlib_rejects_duplicate_x_cluster_rows(): from dimelo import plotting_matplotlib - payload = plotting.prepare_shared_cluster_distribution_data(result=_make_shared_cluster_result()) + payload = plotting.prepare_shared_cluster_distribution_data( + result=_make_shared_cluster_result() + ) duplicate_row = payload["sample_distribution"].iloc[[0]] payload["sample_distribution"] = pd.concat( [payload["sample_distribution"], duplicate_row], @@ -664,7 +709,9 @@ def test_plot_shared_cluster_distribution_matplotlib_rejects_duplicate_x_cluster ) with pytest.raises(ValueError, match="duplicate cluster fractions"): - plotting_matplotlib.plot_shared_cluster_distribution_matplotlib(payload, level="sample") + plotting_matplotlib.plot_shared_cluster_distribution_matplotlib( + payload, level="sample" + ) def test_plot_shared_cluster_change_matplotlib_returns_figure_and_axis(): @@ -698,7 +745,9 @@ def test_plot_shared_cluster_change_matplotlib_returns_figure_and_axis(): def test_plot_shared_cluster_change_matplotlib_rejects_duplicate_condition_cluster_rows(): from dimelo import plotting_matplotlib - payload = plotting.prepare_shared_cluster_distribution_data(result=_make_shared_cluster_result()) + payload = plotting.prepare_shared_cluster_distribution_data( + result=_make_shared_cluster_result() + ) duplicate_row = payload["distribution_change"].iloc[[0]] payload["distribution_change"] = pd.concat( [payload["distribution_change"], duplicate_row], @@ -715,7 +764,9 @@ def test_plot_shared_cluster_change_matplotlib_preserves_sparse_missing_pairs(): payload = plotting.prepare_shared_cluster_distribution_data( result=_make_shared_cluster_result_with_explicit_display_order() ) - payload["distribution_change"] = payload["distribution_change"].iloc[[1, 2]].reset_index(drop=True) + payload["distribution_change"] = ( + payload["distribution_change"].iloc[[1, 2]].reset_index(drop=True) + ) fig, ax = plotting_matplotlib.plot_shared_cluster_change_matplotlib(payload) @@ -739,9 +790,11 @@ def test_plot_shared_cluster_change_matplotlib_preserves_missing_condition_row() payload = plotting.prepare_shared_cluster_distribution_data( result=_make_shared_cluster_result_with_explicit_display_order() ) - payload["distribution_change"] = payload["distribution_change"].loc[ - payload["distribution_change"]["condition"] == "treated" - ].reset_index(drop=True) + payload["distribution_change"] = ( + payload["distribution_change"] + .loc[payload["distribution_change"]["condition"] == "treated"] + .reset_index(drop=True) + ) fig, ax = plotting_matplotlib.plot_shared_cluster_change_matplotlib(payload) @@ -764,9 +817,11 @@ def test_plot_shared_cluster_change_matplotlib_preserves_missing_cluster_column( payload = plotting.prepare_shared_cluster_distribution_data( result=_make_shared_cluster_result_with_explicit_display_order() ) - payload["distribution_change"] = payload["distribution_change"].loc[ - payload["distribution_change"]["cluster"] == "C1" - ].reset_index(drop=True) + payload["distribution_change"] = ( + payload["distribution_change"] + .loc[payload["distribution_change"]["cluster"] == "C1"] + .reset_index(drop=True) + ) fig, ax = plotting_matplotlib.plot_shared_cluster_change_matplotlib(payload) @@ -814,7 +869,9 @@ def _make_shared_cluster_profile_result() -> SharedClusterResult: ) -def _make_shared_cluster_profile_result_with_explicit_display_order() -> SharedClusterResult: +def _make_shared_cluster_profile_result_with_explicit_display_order() -> ( + SharedClusterResult +): return SharedClusterResult( model=SharedClusterModel( mode="region_anchored", @@ -865,7 +922,9 @@ def test_prepare_shared_cluster_profile_data_returns_long_form_profiles(): def test_prepare_shared_cluster_profile_data_respects_feature_subset(): result = _make_shared_cluster_profile_result() - payload = plotting.prepare_shared_cluster_profile_data(result=result, features=["f1"]) + payload = plotting.prepare_shared_cluster_profile_data( + result=result, features=["f1"] + ) profile_table = payload["profile_table"] assert profile_table.to_dict("records") == [ @@ -877,9 +936,13 @@ def test_prepare_shared_cluster_profile_data_respects_feature_subset(): def test_plot_shared_cluster_profile_heatmap_matplotlib_returns_figure_and_axis(): from dimelo import plotting_matplotlib - payload = plotting.prepare_shared_cluster_profile_data(result=_make_shared_cluster_profile_result()) + payload = plotting.prepare_shared_cluster_profile_data( + result=_make_shared_cluster_profile_result() + ) - fig, ax = plotting_matplotlib.plot_shared_cluster_profile_heatmap_matplotlib(payload) + fig, ax = plotting_matplotlib.plot_shared_cluster_profile_heatmap_matplotlib( + payload + ) assert fig is not None assert ax is not None @@ -892,7 +955,9 @@ def test_plot_shared_cluster_profile_heatmap_matplotlib_preserves_payload_order( result=_make_shared_cluster_profile_result_with_explicit_display_order() ) - fig, ax = plotting_matplotlib.plot_shared_cluster_profile_heatmap_matplotlib(payload) + fig, ax = plotting_matplotlib.plot_shared_cluster_profile_heatmap_matplotlib( + payload + ) assert fig is not None assert ax is not None @@ -910,7 +975,9 @@ def test_plot_shared_cluster_profile_heatmap_matplotlib_preserves_payload_order( def test_plot_shared_cluster_profile_heatmap_matplotlib_rejects_duplicate_cluster_feature_rows(): from dimelo import plotting_matplotlib - payload = plotting.prepare_shared_cluster_profile_data(result=_make_shared_cluster_profile_result()) + payload = plotting.prepare_shared_cluster_profile_data( + result=_make_shared_cluster_profile_result() + ) duplicate_row = payload["profile_table"].iloc[[0]] payload["profile_table"] = pd.concat( [payload["profile_table"], duplicate_row], @@ -928,7 +995,9 @@ def test_plot_shared_cluster_profile_heatmap_matplotlib_handles_empty_payload(): result.cluster_profiles = pd.DataFrame(columns=["cluster", "count", "f0", "f1"]) payload = plotting.prepare_shared_cluster_profile_data(result=result) - fig, ax = plotting_matplotlib.plot_shared_cluster_profile_heatmap_matplotlib(payload) + fig, ax = plotting_matplotlib.plot_shared_cluster_profile_heatmap_matplotlib( + payload + ) assert fig is not None assert ax is not None @@ -940,7 +1009,9 @@ def test_plot_shared_cluster_profile_heatmap_matplotlib_handles_empty_payload(): def test_plot_shared_cluster_profile_series_matplotlib_returns_figure_and_axis(): from dimelo import plotting_matplotlib - payload = plotting.prepare_shared_cluster_profile_data(result=_make_shared_cluster_profile_result()) + payload = plotting.prepare_shared_cluster_profile_data( + result=_make_shared_cluster_profile_result() + ) fig, ax = plotting_matplotlib.plot_shared_cluster_profile_series_matplotlib(payload) @@ -970,7 +1041,9 @@ def test_plot_shared_cluster_profile_series_matplotlib_preserves_payload_order() def test_plot_shared_cluster_profile_series_matplotlib_rejects_duplicate_cluster_feature_rows(): from dimelo import plotting_matplotlib - payload = plotting.prepare_shared_cluster_profile_data(result=_make_shared_cluster_profile_result()) + payload = plotting.prepare_shared_cluster_profile_data( + result=_make_shared_cluster_profile_result() + ) duplicate_row = payload["profile_table"].iloc[[0]] payload["profile_table"] = pd.concat( [payload["profile_table"], duplicate_row], @@ -987,9 +1060,11 @@ def test_plot_shared_cluster_profile_series_matplotlib_preserves_missing_cluster payload = plotting.prepare_shared_cluster_profile_data( result=_make_shared_cluster_profile_result_with_explicit_display_order() ) - payload["profile_table"] = payload["profile_table"].loc[ - payload["profile_table"]["cluster"] == "C1" - ].reset_index(drop=True) + payload["profile_table"] = ( + payload["profile_table"] + .loc[payload["profile_table"]["cluster"] == "C1"] + .reset_index(drop=True) + ) fig, ax = plotting_matplotlib.plot_shared_cluster_profile_series_matplotlib(payload) @@ -1183,7 +1258,9 @@ def test_prepare_shared_cluster_region_data_rejects_missing_region_summaries(): def test_plot_shared_cluster_region_matplotlib_defaults_to_condition_level(): from dimelo import plotting_matplotlib - payload = plotting.prepare_shared_cluster_region_data(result=_make_shared_cluster_region_result()) + payload = plotting.prepare_shared_cluster_region_data( + result=_make_shared_cluster_region_result() + ) fig, ax = plotting_matplotlib.plot_shared_cluster_region_matplotlib(payload) @@ -1192,7 +1269,10 @@ def test_plot_shared_cluster_region_matplotlib_defaults_to_condition_level(): image = ax.images[0] assert [tick.get_text() for tick in ax.get_xticklabels()] == ["C0", "C1"] - assert [tick.get_text() for tick in ax.get_yticklabels()] == ["reg1 | NS", "reg1 | treated"] + assert [tick.get_text() for tick in ax.get_yticklabels()] == [ + "reg1 | NS", + "reg1 | treated", + ] assert image.origin == "upper" np.testing.assert_allclose( np.asarray(image.get_array()), @@ -1203,7 +1283,9 @@ def test_plot_shared_cluster_region_matplotlib_defaults_to_condition_level(): def test_plot_shared_cluster_region_matplotlib_supports_sample_level(): from dimelo import plotting_matplotlib - payload = plotting.prepare_shared_cluster_region_data(result=_make_shared_cluster_region_result()) + payload = plotting.prepare_shared_cluster_region_data( + result=_make_shared_cluster_region_result() + ) fig, ax = plotting_matplotlib.plot_shared_cluster_region_matplotlib( payload, @@ -1215,7 +1297,10 @@ def test_plot_shared_cluster_region_matplotlib_supports_sample_level(): image = ax.images[0] assert [tick.get_text() for tick in ax.get_xticklabels()] == ["C0", "C1"] - assert [tick.get_text() for tick in ax.get_yticklabels()] == ["reg1 | s1", "reg1 | s2"] + assert [tick.get_text() for tick in ax.get_yticklabels()] == [ + "reg1 | s1", + "reg1 | s2", + ] assert image.origin == "upper" np.testing.assert_allclose( np.asarray(image.get_array()), @@ -1226,7 +1311,9 @@ def test_plot_shared_cluster_region_matplotlib_supports_sample_level(): def test_plot_shared_cluster_region_matplotlib_rejects_duplicate_row_cluster_values(): from dimelo import plotting_matplotlib - payload = plotting.prepare_shared_cluster_region_data(result=_make_shared_cluster_region_result()) + payload = plotting.prepare_shared_cluster_region_data( + result=_make_shared_cluster_region_result() + ) duplicate_row = payload["condition_region_table"].iloc[[0]] payload["condition_region_table"] = pd.concat( [payload["condition_region_table"], duplicate_row], @@ -1289,18 +1376,39 @@ def test_prepare_read_cluster_region_association_data_accepts_long_form_fraction matrix_table = payload["matrix_table"] top_regions_table = payload["top_regions_table"] - assert list(association_table["region_id"].drop_duplicates()) == ["chr1:10-20:+", "chr1:30-40:-"] + assert list(association_table["region_id"].drop_duplicates()) == [ + "chr1:30-40:-", + "chr1:10-20:+", + ] assert list(matrix_table.columns) == ["region_id", "C0", "C1"] - assert list(matrix_table["region_id"]) == ["chr1:10-20:+", "chr1:30-40:-"] + assert list(matrix_table["region_id"]) == ["chr1:30-40:-", "chr1:10-20:+"] np.testing.assert_allclose( matrix_table.loc[:, ["C0", "C1"]].to_numpy(), - np.array([[0.25, 0.75], [0.60, 0.40]]), + np.array([[0.60, 0.40], [0.25, 0.75]]), ) + assert payload["metadata"]["region_sort"] == "cluster_fraction" assert top_regions_table.iloc[0]["cluster"] == "C0" assert top_regions_table.iloc[0]["region_id"] == "chr1:30-40:-" assert top_regions_table.iloc[0]["value"] == pytest.approx(0.60) +def test_prepare_read_cluster_region_association_data_supports_cluster_fraction_sort(): + table = _make_read_cluster_region_association_table() + + payload = plotting.prepare_read_cluster_region_association_data( + table, + region_sort="cluster_fraction", + ) + + assert payload["metadata"]["region_sort"] == "cluster_fraction" + # Region chr1:30-40:- is dominant in C0 at 0.60; chr1:10-20:+ is dominant in C1 at 0.75. + # Cluster order is C0, C1, so C0-dominant regions appear first. + assert list(payload["matrix_table"]["region_id"]) == [ + "chr1:30-40:-", + "chr1:10-20:+", + ] + + def test_prepare_read_cluster_region_association_data_uses_requested_log2_enrichment_values(): table = _make_read_cluster_region_association_table() @@ -1316,7 +1424,7 @@ def test_prepare_read_cluster_region_association_data_uses_requested_log2_enrich assert list(matrix_table.columns) == ["region_id", "C0", "C1"] np.testing.assert_allclose( matrix_table.loc[:, ["C0", "C1"]].to_numpy(), - np.array([[-1.0, 1.5], [0.25, -0.10]]), + np.array([[0.25, -0.10], [-1.0, 1.5]]), ) assert list(top_regions_table["cluster"]) == ["C0", "C1"] assert list(top_regions_table["region_id"]) == ["chr1:30-40:-", "chr1:10-20:+"] @@ -1332,7 +1440,10 @@ def test_prepare_read_cluster_region_association_data_supports_genomic_sort(): ) assert payload["metadata"]["region_sort"] == "genomic" - assert list(payload["matrix_table"]["region_id"]) == ["chr1:10-20:+", "chr1:30-40:-"] + assert list(payload["matrix_table"]["region_id"]) == [ + "chr1:10-20:+", + "chr1:30-40:-", + ] assert "region_axis_table" in payload @@ -1346,7 +1457,10 @@ def test_prepare_read_cluster_region_association_data_supports_association_stren ) # chr1:10-20:+ has max value 0.75, chr1:30-40:- has max value 0.60 - assert list(payload["matrix_table"]["region_id"]) == ["chr1:10-20:+", "chr1:30-40:-"] + assert list(payload["matrix_table"]["region_id"]) == [ + "chr1:10-20:+", + "chr1:30-40:-", + ] assert payload["metadata"]["association_strength_aggregate"] == "max" @@ -1389,7 +1503,10 @@ def test_prepare_read_cluster_region_association_data_accepts_legacy_wide_region matrix_table = payload["matrix_table"] top_regions_table = payload["top_regions_table"] - assert list(association_table["region_id"].drop_duplicates()) == ["chr1:10-20:+", "chr1:30-40:-"] + assert list(association_table["region_id"].drop_duplicates()) == [ + "chr1:10-20:+", + "chr1:30-40:-", + ] assert list(matrix_table.columns) == ["region_id", 0, 1] np.testing.assert_allclose( matrix_table.loc[:, [0, 1]].to_numpy(), @@ -1401,7 +1518,9 @@ def test_prepare_read_cluster_region_association_data_accepts_legacy_wide_region def test_prepare_read_cluster_region_association_data_rejects_missing_requested_mode(): - table = _make_read_cluster_region_association_table().drop(columns=["log2_enrichment"]) + table = _make_read_cluster_region_association_table().drop( + columns=["log2_enrichment"] + ) with pytest.raises(ValueError, match="log2_enrichment"): plotting.prepare_read_cluster_region_association_data( @@ -1413,19 +1532,61 @@ def test_prepare_read_cluster_region_association_data_rejects_missing_requested_ def test_plot_read_cluster_region_association_heatmap_matplotlib_returns_figure_and_axis(): from dimelo import plotting_matplotlib - payload = plotting.prepare_read_cluster_region_association_data(_make_read_cluster_region_association_table()) + payload = plotting.prepare_read_cluster_region_association_data( + _make_read_cluster_region_association_table() + ) - fig, ax = plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib(payload) + fig, ax = ( + plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib( + payload + ) + ) assert fig is not None assert ax is not None assert [tick.get_text() for tick in ax.get_xticklabels()] == ["C0", "C1"] - assert [tick.get_text() for tick in ax.get_yticklabels()] == ["chr1:10-20:+", "chr1:30-40:-"] + assert [tick.get_text() for tick in ax.get_yticklabels()] == [ + "chr1:30-40:-", + "chr1:10-20:+", + ] np.testing.assert_allclose( np.asarray(ax.images[0].get_array()), - np.array([[0.25, 0.75], [0.60, 0.40]]), + np.array([[0.60, 0.40], [0.25, 0.75]]), + ) + + +def test_plot_read_cluster_region_association_heatmap_matplotlib_accepts_region_sort_override(): + from dimelo import plotting_matplotlib + + table = pd.DataFrame( + [ + {"region_id": "chr1:100-110:+", "cluster": "C0", "fraction": 0.90}, + {"region_id": "chr1:100-110:+", "cluster": "C1", "fraction": 0.10}, + {"region_id": "chr1:10-20:+", "cluster": "C0", "fraction": 0.80}, + {"region_id": "chr1:10-20:+", "cluster": "C1", "fraction": 0.20}, + ] + ) + payload = plotting.prepare_read_cluster_region_association_data( + table, region_sort="genomic" + ) + axis_table = payload["region_axis_table"].copy() + axis_table["source_label"] = ["late", "early"] + payload["region_axis_table"] = axis_table + + fig, ax = ( + plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib( + payload, + region_sort="association_strength", + row_annotation_column="source_label", + ) ) + assert fig is not None + assert ax is not None + # association_strength sort should place chr1:100-110:+ before chr1:10-20:+ + ytick_text = [tick.get_text() for tick in ax.get_yticklabels()] + assert ytick_text[0].startswith("chr1:100-110:+") + def test_plot_read_cluster_region_association_heatmap_matplotlib_supports_row_annotations(): from dimelo import plotting_matplotlib @@ -1438,11 +1599,13 @@ def test_plot_read_cluster_region_association_heatmap_matplotlib_supports_row_an axis_table["source_label"] = ["on_target", "off_target"] payload["region_axis_table"] = axis_table - fig, ax = plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib( - payload, - row_annotation_column="source_label", - row_annotation_title="Source bed", - row_annotation_palette={"on_target": "#D95F02", "off_target": "#1B9E77"}, + fig, ax = ( + plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib( + payload, + row_annotation_column="source_label", + row_annotation_title="Source bed", + row_annotation_palette={"on_target": "#D95F02", "off_target": "#1B9E77"}, + ) ) assert fig is not None @@ -1450,6 +1613,15 @@ def test_plot_read_cluster_region_association_heatmap_matplotlib_supports_row_an ytick_text = [tick.get_text() for tick in ax.get_yticklabels()] assert "on_target" in ytick_text[0] assert "off_target" in ytick_text[1] + main_pos = ax.get_position() + left_side_axes = [ + axis + for axis in fig.axes + if axis is not ax and axis.get_position().x1 <= main_pos.x0 + ] + assert left_side_axes + # The source-bed strip should live fully to the left of the heatmap. + assert max(axis.get_position().x1 for axis in left_side_axes) <= main_pos.x0 def test_plot_read_cluster_region_association_heatmap_matplotlib_grouped_region_labels(): @@ -1467,16 +1639,20 @@ def test_plot_read_cluster_region_association_heatmap_matplotlib_grouped_region_ {"region_id": "chr2:30-40:+", "cluster": 1, "fraction": 0.35}, ] ) - payload = plotting.prepare_read_cluster_region_association_data(table, region_sort="genomic") + payload = plotting.prepare_read_cluster_region_association_data( + table, region_sort="genomic" + ) axis_table = payload["region_axis_table"].copy() axis_table["source_label"] = ["on_target", "on_target", "off_target", "off_target"] payload["region_axis_table"] = axis_table - fig, ax = plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib( - payload, - region_label_mode="genomic", - row_annotation_column="source_label", - group_region_labels=True, + fig, ax = ( + plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib( + payload, + region_label_mode="genomic", + row_annotation_column="source_label", + group_region_labels=True, + ) ) assert fig is not None @@ -1489,10 +1665,30 @@ def test_plot_read_cluster_region_association_heatmap_matplotlib_grouped_region_ def _minimal_region_contrast_result() -> RegionContrastResult: regions = pd.DataFrame( [ - {"region_id": "chr1:90-110,+", "condition": "NS", "fraction": 0.20, "rank": 2}, - {"region_id": "chr1:90-110,+", "condition": "15min", "fraction": 0.55, "rank": 2}, - {"region_id": "chr1:190-210,-", "condition": "NS", "fraction": 0.30, "rank": 1}, - {"region_id": "chr1:190-210,-", "condition": "15min", "fraction": 0.70, "rank": 1}, + { + "region_id": "chr1:90-110,+", + "condition": "NS", + "fraction": 0.20, + "rank": 2, + }, + { + "region_id": "chr1:90-110,+", + "condition": "15min", + "fraction": 0.55, + "rank": 2, + }, + { + "region_id": "chr1:190-210,-", + "condition": "NS", + "fraction": 0.30, + "rank": 1, + }, + { + "region_id": "chr1:190-210,-", + "condition": "15min", + "fraction": 0.70, + "rank": 1, + }, ] ) summary = pd.DataFrame( @@ -1547,9 +1743,24 @@ def _group_vs_group_region_contrast_result() -> RegionContrastResult: return RegionContrastResult( regions=pd.DataFrame( [ - {"region_id": "chr1:90-110,+", "condition": "NS", "fraction": 0.10, "rank": 1}, - {"region_id": "chr1:90-110,+", "condition": "15min", "fraction": 0.50, "rank": 1}, - {"region_id": "chr1:90-110,+", "condition": "30min", "fraction": 0.70, "rank": 1}, + { + "region_id": "chr1:90-110,+", + "condition": "NS", + "fraction": 0.10, + "rank": 1, + }, + { + "region_id": "chr1:90-110,+", + "condition": "15min", + "fraction": 0.50, + "rank": 1, + }, + { + "region_id": "chr1:90-110,+", + "condition": "30min", + "fraction": 0.70, + "rank": 1, + }, ] ), summary=summary, @@ -1569,7 +1780,9 @@ def _group_vs_group_region_contrast_result() -> RegionContrastResult: ) -def _region_contrast_plot_setup(position_rows: list[dict[str, object]]) -> tuple[ +def _region_contrast_plot_setup( + position_rows: list[dict[str, object]], +) -> tuple[ RegionContrastResult, pd.DataFrame, plotting.AxisSpec, @@ -1589,7 +1802,9 @@ def _region_contrast_plot_setup(position_rows: list[dict[str, object]]) -> tuple ) -def _region_contrast_position_rows(*, include_grouping_key: bool = True) -> list[dict[str, object]]: +def _region_contrast_position_rows( + *, include_grouping_key: bool = True +) -> list[dict[str, object]]: base_rows = [ { "region_id": "chr1:90-110,+", @@ -1962,7 +2177,10 @@ def test_prepare_region_discovery_scan_data_rejects_hits_missing_from_filtered_w figures=result.figures, ) - with pytest.raises(ValueError, match="result.hits contains window_id values not present in the filtered windows table"): + with pytest.raises( + ValueError, + match="result.hits contains window_id values not present in the filtered windows table", + ): plotting.prepare_region_discovery_scan_data( result=inconsistent_result, contigs=["chr2"], @@ -1981,8 +2199,14 @@ def test_prepare_region_discovery_hit_context_data_uses_top_ranked_hits(): assert set(payload) == {"context_table", "selected_hits", "metadata"} assert payload["selected_hits"]["window_id"].tolist() == ["chr1:100-200:+"] assert payload["selected_hits"]["rank"].tolist() == [1] - assert payload["context_table"]["selected_hit_id"].tolist() == ["chr1:100-200:+", "chr1:100-200:+"] - assert payload["context_table"]["window_id"].tolist() == ["chr1:0-100:+", "chr1:100-200:+"] + assert payload["context_table"]["selected_hit_id"].tolist() == [ + "chr1:100-200:+", + "chr1:100-200:+", + ] + assert payload["context_table"]["window_id"].tolist() == [ + "chr1:0-100:+", + "chr1:100-200:+", + ] assert payload["context_table"]["selected_hit_rank"].nunique() == 1 assert payload["context_table"]["selected_hit_rank"].iloc[0] == 1 assert payload["context_table"]["is_selected_hit"].sum() == 1 @@ -1997,7 +2221,10 @@ def test_prepare_region_discovery_hit_context_data_adds_relative_window_offsets( padding_windows=1, ) - assert payload["context_table"]["window_id"].tolist() == ["chr1:0-100:+", "chr1:100-200:+"] + assert payload["context_table"]["window_id"].tolist() == [ + "chr1:0-100:+", + "chr1:100-200:+", + ] assert payload["context_table"]["relative_window_offset"].tolist() == [-1, 0] @@ -2008,7 +2235,11 @@ def test_prepare_region_discovery_hit_context_data_returns_empty_payload_for_no_ hits=pd.DataFrame(columns=base_result.hits.columns), contrast=None, plot_data={}, - metadata={"score": "effect_size_only", "contrast_mode": "pairwise", "merge_hits": False}, + metadata={ + "score": "effect_size_only", + "contrast_mode": "pairwise", + "merge_hits": False, + }, ) payload = plotting.prepare_region_discovery_hit_context_data(result=result) @@ -2021,7 +2252,9 @@ def test_prepare_region_discovery_hit_context_data_returns_empty_payload_for_no_ def test_plot_region_discovery_scan_matplotlib_returns_figure_and_axes(): from dimelo import plotting_matplotlib - payload = plotting.prepare_region_discovery_scan_data(result=_make_region_discovery_result()) + payload = plotting.prepare_region_discovery_scan_data( + result=_make_region_discovery_result() + ) fig, axes = plotting_matplotlib.plot_region_discovery_scan_matplotlib(payload) @@ -2037,7 +2270,9 @@ def test_plot_region_discovery_hit_context_matplotlib_returns_figure_and_axes(): top_n=2, ) - fig, axes = plotting_matplotlib.plot_region_discovery_hit_context_matplotlib(payload) + fig, axes = plotting_matplotlib.plot_region_discovery_hit_context_matplotlib( + payload + ) assert fig is not None assert axes is not None @@ -2048,13 +2283,22 @@ def test_prepare_global_analysis_summary_data_returns_expected_tables(): payload = plotting.prepare_global_analysis_summary_data(result=result) - assert set(payload) == {"sample_summary", "condition_summary", "normalization_table", "metadata"} + assert set(payload) == { + "sample_summary", + "condition_summary", + "normalization_table", + "metadata", + } assert payload["sample_summary"]["sample_id"].tolist() == ["s1", "s2", "s3", "s1"] - assert payload["normalization_table"]["sample_id"].tolist() == ["s1", "s2", "s3", "s1"] - assert ( - payload["condition_summary"][["condition", "motif"]].apply(tuple, axis=1).tolist() - == [("NS", "A,0"), ("treated", "A,0"), ("NS", "CG,0")] - ) + assert payload["normalization_table"]["sample_id"].tolist() == [ + "s1", + "s2", + "s3", + "s1", + ] + assert payload["condition_summary"][["condition", "motif"]].apply( + tuple, axis=1 + ).tolist() == [("NS", "A,0"), ("treated", "A,0"), ("NS", "CG,0")] assert payload["condition_summary"]["sample_n"].tolist() == [1, 2, 1] assert payload["metadata"]["motifs"] == ["A,0", "CG,0"] @@ -2065,9 +2309,15 @@ def test_prepare_global_analysis_summary_data_computes_condition_means(): payload = plotting.prepare_global_analysis_summary_data(result=result) condition_summary = payload["condition_summary"].set_index(["condition", "motif"]) - assert condition_summary.loc[("NS", "A,0"), "global_fraction_mean"] == pytest.approx(0.5) - assert condition_summary.loc[("treated", "A,0"), "global_fraction_mean"] == pytest.approx(0.7) - assert condition_summary.loc[("treated", "A,0"), "global_fraction_median"] == pytest.approx(0.7) + assert condition_summary.loc[ + ("NS", "A,0"), "global_fraction_mean" + ] == pytest.approx(0.5) + assert condition_summary.loc[ + ("treated", "A,0"), "global_fraction_mean" + ] == pytest.approx(0.7) + assert condition_summary.loc[ + ("treated", "A,0"), "global_fraction_median" + ] == pytest.approx(0.7) def test_prepare_global_analysis_summary_data_filters_motifs(): @@ -2099,7 +2349,9 @@ def test_prepare_global_analysis_summary_data_skips_condition_aggregation_when_d def test_plot_global_analysis_summary_matplotlib_returns_figure_and_axis(): from dimelo import plotting_matplotlib - payload = plotting.prepare_global_analysis_summary_data(result=_make_global_analysis_result()) + payload = plotting.prepare_global_analysis_summary_data( + result=_make_global_analysis_result() + ) fig, ax = plotting_matplotlib.plot_global_analysis_summary_matplotlib(payload) @@ -2113,8 +2365,18 @@ def test_prepare_global_analysis_window_data_returns_expected_tables(): payload = plotting.prepare_global_analysis_window_data(result=result) assert set(payload) == {"window_table", "condition_window_table", "metadata"} - assert payload["window_table"]["contig"].tolist() == ["chr1", "chr1", "chr1", "chr2"] - assert payload["window_table"]["window_midpoint"].tolist() == [50.0, 50.0, 50.0, 50.0] + assert payload["window_table"]["contig"].tolist() == [ + "chr1", + "chr1", + "chr1", + "chr2", + ] + assert payload["window_table"]["window_midpoint"].tolist() == [ + 50.0, + 50.0, + 50.0, + 50.0, + ] assert payload["condition_window_table"].empty assert payload["metadata"]["contig_order"] == ["chr1", "chr2"] @@ -2122,7 +2384,9 @@ def test_prepare_global_analysis_window_data_returns_expected_tables(): def test_plot_global_analysis_window_matplotlib_returns_figure_and_axes(): from dimelo import plotting_matplotlib - payload = plotting.prepare_global_analysis_window_data(result=_make_global_window_result()) + payload = plotting.prepare_global_analysis_window_data( + result=_make_global_window_result() + ) fig, axes = plotting_matplotlib.plot_global_analysis_window_matplotlib(payload) @@ -2182,9 +2446,9 @@ def test_prepare_global_analysis_window_data_aggregates_per_sample_windows_acros } ] ) - result.windows = pd.concat([result.windows, duplicate_sample_window], ignore_index=True).rename( - columns={"chromosome": "chrom"} - ) + result.windows = pd.concat( + [result.windows, duplicate_sample_window], ignore_index=True + ).rename(columns={"chromosome": "chrom"}) result.plot_data["window_fraction_table"] = result.windows.copy() payload = plotting.prepare_global_analysis_window_data( @@ -2192,10 +2456,14 @@ def test_prepare_global_analysis_window_data_aggregates_per_sample_windows_acros aggregate_conditions=True, ) - treated_chr1 = payload["condition_window_table"].loc[ - (payload["condition_window_table"]["condition"] == "treated") - & (payload["condition_window_table"]["contig"] == "chr1") - ].iloc[0] + treated_chr1 = ( + payload["condition_window_table"] + .loc[ + (payload["condition_window_table"]["condition"] == "treated") + & (payload["condition_window_table"]["contig"] == "chr1") + ] + .iloc[0] + ) assert treated_chr1["window_fraction_mean"] == pytest.approx(0.45) assert treated_chr1["window_fraction_median"] == pytest.approx(0.45) @@ -2261,8 +2529,14 @@ def test_prepare_region_contrast_profile_data_returns_all_value_modes(): plot_table = payload["plot_table"] assert len(plot_table) == 12 - assert set(payload["plot_table"]["value_mode"]) == {"numerator", "denominator", "delta"} - assert plot_table.groupby(["region_id", "position", "value_mode"]).size().to_dict() == { + assert set(payload["plot_table"]["value_mode"]) == { + "numerator", + "denominator", + "delta", + } + assert plot_table.groupby( + ["region_id", "position", "value_mode"] + ).size().to_dict() == { ("chr1:90-110,+", 95, "numerator"): 1, ("chr1:90-110,+", 95, "denominator"): 1, ("chr1:90-110,+", 95, "delta"): 1, @@ -2352,9 +2626,10 @@ def test_prepare_region_contrast_profile_data_returns_all_value_modes(): def test_plot_region_contrast_profile_matplotlib_defaults_to_delta_and_honors_ax_title(): - from dimelo import plotting_matplotlib from matplotlib import pyplot as plt + from dimelo import plotting_matplotlib + result, position_table, axis, aggregation = _region_contrast_plot_setup( _region_contrast_position_rows() ) @@ -2386,8 +2661,12 @@ def test_plot_region_contrast_profile_matplotlib_defaults_to_delta_and_honors_ax assert ax is provided_ax assert ax.get_title() == "Custom region contrast profile" assert len(ax.lines) == 1 - np.testing.assert_allclose(np.asarray(ax.lines[0].get_xdata()), expected[x_column].to_numpy()) - np.testing.assert_allclose(np.asarray(ax.lines[0].get_ydata()), expected["value"].to_numpy()) + np.testing.assert_allclose( + np.asarray(ax.lines[0].get_xdata()), expected[x_column].to_numpy() + ) + np.testing.assert_allclose( + np.asarray(ax.lines[0].get_ydata()), expected["value"].to_numpy() + ) plt.close(fig) @@ -2520,7 +2799,7 @@ def test_prepare_region_contrast_heatmap_data_orders_rows_by_rank(): "reference_fraction": 0.05, "delta_fraction": 0.11, "rank": 8, - } + }, ] ), ], @@ -2535,7 +2814,9 @@ def test_prepare_region_contrast_heatmap_data_orders_rows_by_rank(): value_mode="all", ) - rank_rows = payload["plot_table"].loc[:, ["region_id", "row_order"]].drop_duplicates() + rank_rows = ( + payload["plot_table"].loc[:, ["region_id", "row_order"]].drop_duplicates() + ) assert list(rank_rows.sort_values("row_order")["region_id"]) == [ "chr1:190-210,-", "chr1:90-110,+", @@ -2548,9 +2829,10 @@ def test_prepare_region_contrast_heatmap_data_orders_rows_by_rank(): def test_plot_region_contrast_heatmap_matplotlib_defaults_to_delta_and_honors_ax_title(): - from dimelo import plotting_matplotlib from matplotlib import pyplot as plt + from dimelo import plotting_matplotlib + result, position_table, axis, aggregation = _region_contrast_plot_setup( _region_contrast_position_rows() ) @@ -2566,8 +2848,13 @@ def test_plot_region_contrast_heatmap_matplotlib_defaults_to_delta_and_honors_ax x_column = "plot_x" if "plot_x" in payload["plot_table"].columns else "position" expected = ( payload["plot_table"] - .loc[lambda table: table["value_mode"] == "delta", [x_column, "row_order", "value"]] - .pivot_table(index="row_order", columns=x_column, values="value", aggfunc="mean") + .loc[ + lambda table: table["value_mode"] == "delta", + [x_column, "row_order", "value"], + ] + .pivot_table( + index="row_order", columns=x_column, values="value", aggfunc="mean" + ) .sort_index(axis=0) .sort_index(axis=1) .to_numpy() @@ -2589,9 +2876,10 @@ def test_plot_region_contrast_heatmap_matplotlib_defaults_to_delta_and_honors_ax def test_plot_region_contrast_heatmap_matplotlib_accepts_minimal_payload_without_summary_table(): - from dimelo import plotting_matplotlib from matplotlib import pyplot as plt + from dimelo import plotting_matplotlib + result, position_table, axis, aggregation = _region_contrast_plot_setup( _region_contrast_position_rows() ) @@ -2721,7 +3009,9 @@ def test_prepare_region_contrast_profile_data_requires_grouping_key(): ], ], ) -def test_prepare_region_contrast_profile_data_rejects_ambiguous_grouping_key(position_rows): +def test_prepare_region_contrast_profile_data_rejects_ambiguous_grouping_key( + position_rows, +): result, _, _, _ = _region_contrast_plot_setup(_region_contrast_position_rows()) position_table = pd.DataFrame(position_rows) axis = plotting.AxisSpec( @@ -2859,7 +3149,9 @@ def test_prepare_single_read_plot_data_filters_rows_outside_fixed_window_bounds( @pytest.mark.parametrize("upstream_bp, downstream_bp", [(-1, 10), (10, -1)]) -def test_validate_axis_spec_rejects_negative_fixed_window_bounds(upstream_bp, downstream_bp): +def test_validate_axis_spec_rejects_negative_fixed_window_bounds( + upstream_bp, downstream_bp +): axis = plotting.AxisSpec( orientation="genomic", coordinate_mode="fixed_window", @@ -2906,8 +3198,20 @@ def test_prepare_single_read_plot_data_rejects_invalid_region_strand_in_region_5 def test_prepare_aggregate_plot_data_retains_metadata_for_fixed_window(): table = pd.DataFrame( [ - {"region_id": "reg1", "region_strand": "+", "event_pos": 95, "anchor": 100, "signal": 1.0}, - {"region_id": "reg1", "region_strand": "+", "event_pos": 105, "anchor": 100, "signal": 3.0}, + { + "region_id": "reg1", + "region_strand": "+", + "event_pos": 95, + "anchor": 100, + "signal": 1.0, + }, + { + "region_id": "reg1", + "region_strand": "+", + "event_pos": 105, + "anchor": 100, + "signal": 3.0, + }, ] ) axis = plotting.AxisSpec( @@ -2958,7 +3262,9 @@ def test_legacy_enrichment_profile_routes_regions_5to3prime_through_shared_prep( real_prepare_aggregate_plot_data = plotting.prepare_aggregate_plot_data - def spy_prepare_aggregate_plot_data(table, *, plot_family, axis, aggregation, **kwargs): + def spy_prepare_aggregate_plot_data( + table, *, plot_family, axis, aggregation, **kwargs + ): called["table"] = table called["plot_family"] = plot_family called["axis"] = axis @@ -2971,7 +3277,9 @@ def spy_prepare_aggregate_plot_data(table, *, plot_family, axis, aggregation, ** **kwargs, ) - monkeypatch.setattr(plotting, "prepare_aggregate_plot_data", spy_prepare_aggregate_plot_data) + monkeypatch.setattr( + plotting, "prepare_aggregate_plot_data", spy_prepare_aggregate_plot_data + ) monkeypatch.setattr( "dimelo.plot_enrichment_profile.get_enrichment_profiles", lambda **kwargs: [np.array([0.25, 0.75])], @@ -2982,7 +3290,9 @@ def spy_prepare_aggregate_plot_data(table, *, plot_family, axis, aggregation, ** lambda *args, **kwargs: regions_dict, ) - def fake_make_enrichment_profile_plot(*, trace_vectors, sample_names, offset_center=0, **kwargs): + def fake_make_enrichment_profile_plot( + *, trace_vectors, sample_names, offset_center=0, **kwargs + ): captured["trace_vectors"] = trace_vectors captured["sample_names"] = sample_names captured["offset_center"] = offset_center @@ -3134,7 +3444,9 @@ def set_xlim(self, limits): "dimelo.plot_reads.plotting.prepare_single_read_plot_data", spy_prepare, ) - monkeypatch.setattr("dimelo.plot_reads.sns.scatterplot", lambda **kwargs: FakeAxes()) + monkeypatch.setattr( + "dimelo.plot_reads.sns.scatterplot", lambda **kwargs: FakeAxes() + ) axes = plot_reads.plot_reads( mod_file_name="sample.h5", @@ -3201,7 +3513,9 @@ def set_ylabel(self, label): "dimelo.plot_reads.plotting.prepare_single_read_plot_data", spy_prepare, ) - monkeypatch.setattr("dimelo.plot_reads.sns.scatterplot", lambda **kwargs: FakeAxes()) + monkeypatch.setattr( + "dimelo.plot_reads.sns.scatterplot", lambda **kwargs: FakeAxes() + ) axes = plot_reads.plot_reads( mod_file_name="sample.h5", @@ -3220,8 +3534,18 @@ def set_ylabel(self, label): def test_prepare_aggregate_plot_data_builds_concatenated_segment_axis(): table = pd.DataFrame( [ - {"region_id": "reg1", "segment_id": "upstream", "segment_pos": 0, "signal": 1.0}, - {"region_id": "reg1", "segment_id": "body", "segment_pos": 10, "signal": 2.0}, + { + "region_id": "reg1", + "segment_id": "upstream", + "segment_pos": 0, + "signal": 1.0, + }, + { + "region_id": "reg1", + "segment_id": "body", + "segment_pos": 10, + "signal": 2.0, + }, ] ) axis = plotting.AxisSpec( @@ -3229,7 +3553,15 @@ def test_prepare_aggregate_plot_data_builds_concatenated_segment_axis(): coordinate_mode="segment_map", segments=[ plotting.SegmentSpec("upstream", "Upstream", 0, 100, "raw", bins=20), - plotting.SegmentSpec("body", "Body", 100, 400, "scaled", bins=50, contiguous_with_previous=True), + plotting.SegmentSpec( + "body", + "Body", + 100, + 400, + "scaled", + bins=50, + contiguous_with_previous=True, + ), ], ) aggregation = plotting.AggregationSpec( @@ -3258,7 +3590,14 @@ def test_prepare_aggregate_plot_data_builds_concatenated_segment_axis(): def test_prepare_aggregate_plot_data_rejects_duplicate_segment_ids_in_axis_segments(): table = pd.DataFrame( - [{"region_id": "reg1", "segment_id": "upstream", "segment_pos": 1, "signal": 1.0}] + [ + { + "region_id": "reg1", + "segment_id": "upstream", + "segment_pos": 1, + "signal": 1.0, + } + ] ) axis = plotting.AxisSpec( orientation="region_5to3", @@ -3289,7 +3628,14 @@ def test_prepare_aggregate_plot_data_rejects_duplicate_segment_ids_in_axis_segme def test_prepare_aggregate_plot_data_rejects_unknown_segment_ids(): table = pd.DataFrame( - [{"region_id": "reg1", "segment_id": "unknown", "segment_pos": 1, "signal": 1.0}] + [ + { + "region_id": "reg1", + "segment_id": "unknown", + "segment_pos": 1, + "signal": 1.0, + } + ] ) axis = plotting.AxisSpec( orientation="region_5to3", @@ -3319,7 +3665,14 @@ def test_prepare_aggregate_plot_data_rejects_unknown_segment_ids(): def test_prepare_aggregate_plot_data_rejects_missing_segment_positions(): table = pd.DataFrame( - [{"region_id": "reg1", "segment_id": "upstream", "segment_pos": float("nan"), "signal": 1.0}] + [ + { + "region_id": "reg1", + "segment_id": "upstream", + "segment_pos": float("nan"), + "signal": 1.0, + } + ] ) axis = plotting.AxisSpec( orientation="region_5to3", @@ -3348,9 +3701,18 @@ def test_prepare_aggregate_plot_data_rejects_missing_segment_positions(): @pytest.mark.parametrize("segment_pos", [-1, 20]) -def test_prepare_aggregate_plot_data_rejects_segment_positions_outside_declared_span(segment_pos): +def test_prepare_aggregate_plot_data_rejects_segment_positions_outside_declared_span( + segment_pos, +): table = pd.DataFrame( - [{"region_id": "reg1", "segment_id": "upstream", "segment_pos": segment_pos, "signal": 1.0}] + [ + { + "region_id": "reg1", + "segment_id": "upstream", + "segment_pos": segment_pos, + "signal": 1.0, + } + ] ) axis = plotting.AxisSpec( orientation="region_5to3", @@ -3424,14 +3786,25 @@ def test_prepare_aggregate_plot_data_marks_non_contiguous_segment_breaks(): "segment", [ plotting.SegmentSpec("bad_bins", "Bad bins", 0, 100, "raw", bins=0), - plotting.SegmentSpec("bad_bins_neg", "Bad bins negative", 0, 100, "scaled", bins=-5), + plotting.SegmentSpec( + "bad_bins_neg", "Bad bins negative", 0, 100, "scaled", bins=-5 + ), plotting.SegmentSpec("bad_raw", "Bad raw", 100, 100, "raw"), - plotting.SegmentSpec("bad_raw_reverse", "Bad raw reverse", 200, 100, "raw", bins=20), + plotting.SegmentSpec( + "bad_raw_reverse", "Bad raw reverse", 200, 100, "raw", bins=20 + ), ], ) def test_prepare_aggregate_plot_data_rejects_malformed_segment_spans(segment): table = pd.DataFrame( - [{"region_id": "reg1", "segment_id": "bad_raw", "segment_pos": 1, "signal": 1.0}] + [ + { + "region_id": "reg1", + "segment_id": "bad_raw", + "segment_pos": 1, + "signal": 1.0, + } + ] ) axis = plotting.AxisSpec( orientation="region_5to3", @@ -3459,7 +3832,14 @@ def test_prepare_aggregate_plot_data_rejects_malformed_segment_spans(segment): def test_prepare_aggregate_plot_data_rejects_invalid_segment_mode(): table = pd.DataFrame( - [{"region_id": "reg1", "segment_id": "upstream", "segment_pos": 1, "signal": 1.0}] + [ + { + "region_id": "reg1", + "segment_id": "upstream", + "segment_pos": 1, + "signal": 1.0, + } + ] ) axis = plotting.AxisSpec( orientation="region_5to3", diff --git a/tests/test_region_analysis.py b/tests/test_region_analysis.py index 698bb76..acdbddf 100644 --- a/tests/test_region_analysis.py +++ b/tests/test_region_analysis.py @@ -10,8 +10,18 @@ def _samples() -> list[SampleSpec]: return [ - SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5", metadata={"pileup_path": "s1.bed.gz"}), - SampleSpec(sample_id="s2", condition="TR", extract_h5="s2.h5", metadata={"pileup_path": "s2.bed.gz"}), + SampleSpec( + sample_id="s1", + condition="NS", + extract_h5="s1.h5", + metadata={"pileup_path": "s1.bed.gz"}, + ), + SampleSpec( + sample_id="s2", + condition="TR", + extract_h5="s2.h5", + metadata={"pileup_path": "s2.bed.gz"}, + ), ] @@ -20,7 +30,9 @@ def test_build_region_feature_table_parallelizes_across_samples(monkeypatch): started_lock = threading.Lock() second_started = threading.Event() - def fake_region_feature_matrix_from_pileup(*, bedmethyl_file, motif, regions, cores, **kwargs): + def fake_region_feature_matrix_from_pileup( + *, bedmethyl_file, motif, regions, cores, **kwargs + ): nonlocal started with started_lock: started += 1 @@ -59,7 +71,9 @@ def fake_region_feature_matrix_from_pileup(*, bedmethyl_file, motif, regions, co assert metadata_rows[1]["sample_id"] == "s2" -def test_build_region_feature_table_reuses_regions_executor_in_serial_sample_mode(monkeypatch): +def test_build_region_feature_table_reuses_regions_executor_in_serial_sample_mode( + monkeypatch, +): class _FakeProcessPoolExecutor: instances = [] diff --git a/tests/test_region_contrasts.py b/tests/test_region_contrasts.py index 4da4d20..036e33f 100644 --- a/tests/test_region_contrasts.py +++ b/tests/test_region_contrasts.py @@ -548,7 +548,9 @@ def test_score_regions_single_read_mod_fraction_effect_size_only(): samples=[], regions=None, motifs=[], - contrast=ContrastSpec(mode="group_vs_group", numerator=["treated"], denominator=["NS"]), + contrast=ContrastSpec( + mode="group_vs_group", numerator=["treated"], denominator=["NS"] + ), analysis_unit="single_read", representation="read_mod_fraction", signal_source="extract_reads", @@ -781,7 +783,9 @@ def test_score_regions_single_read_window_features_effect_size_only(): samples=[], regions=None, motifs=[], - contrast=ContrastSpec(mode="group_vs_group", numerator=["treated"], denominator=["NS"]), + contrast=ContrastSpec( + mode="group_vs_group", numerator=["treated"], denominator=["NS"] + ), analysis_unit="single_read", representation="read_window_features", signal_source="extract_features", @@ -981,8 +985,18 @@ def test_score_regions_single_read_matched_pairwise_requires_pairing_key_column( @pytest.mark.parametrize( "representation,table_factory,signal_source,test_name", [ - ("read_mod_fraction", "read_table", "extract_reads", "sample_distribution_shift"), - ("read_window_features", "feature_table", "extract_features", "feature_summary_shift"), + ( + "read_mod_fraction", + "read_table", + "extract_reads", + "sample_distribution_shift", + ), + ( + "read_window_features", + "feature_table", + "extract_features", + "feature_summary_shift", + ), ], ) def test_score_regions_single_read_matched_pairwise_requires_non_null_pairing_keys( @@ -1065,8 +1079,18 @@ def test_score_regions_single_read_matched_pairwise_requires_non_null_pairing_ke @pytest.mark.parametrize( "representation,table_factory,signal_source,test_name", [ - ("read_mod_fraction", "read_table", "extract_reads", "sample_distribution_shift"), - ("read_window_features", "feature_table", "extract_features", "feature_summary_shift"), + ( + "read_mod_fraction", + "read_table", + "extract_reads", + "sample_distribution_shift", + ), + ( + "read_window_features", + "feature_table", + "extract_features", + "feature_summary_shift", + ), ], ) def test_score_regions_single_read_matched_pairwise_rejects_multi_condition_sides( @@ -1167,8 +1191,18 @@ def test_score_regions_single_read_matched_pairwise_rejects_multi_condition_side @pytest.mark.parametrize( "representation,table_factory,signal_source,test_name", [ - ("read_mod_fraction", "read_table", "extract_reads", "sample_distribution_shift"), - ("read_window_features", "feature_table", "extract_features", "feature_summary_shift"), + ( + "read_mod_fraction", + "read_table", + "extract_reads", + "sample_distribution_shift", + ), + ( + "read_window_features", + "feature_table", + "extract_features", + "feature_summary_shift", + ), ], ) def test_score_regions_single_read_matched_pairwise_rejects_multiple_samples_on_one_side( @@ -1252,7 +1286,9 @@ def test_score_regions_single_read_matched_pairwise_rejects_multiple_samples_on_ ) } - with pytest.raises(ValueError, match="exactly one sample per region, pair, and condition"): + with pytest.raises( + ValueError, match="exactly one sample per region, pair, and condition" + ): region_contrasts.score_regions( samples=[], regions=None, @@ -1269,8 +1305,18 @@ def test_score_regions_single_read_matched_pairwise_rejects_multiple_samples_on_ @pytest.mark.parametrize( "representation,table_factory,signal_source,test_name", [ - ("read_mod_fraction", "read_table", "extract_reads", "sample_distribution_shift"), - ("read_window_features", "feature_table", "extract_features", "feature_summary_shift"), + ( + "read_mod_fraction", + "read_table", + "extract_reads", + "sample_distribution_shift", + ), + ( + "read_window_features", + "feature_table", + "extract_features", + "feature_summary_shift", + ), ], ) def test_score_regions_single_read_matched_pairwise_rejects_sample_ids_mapped_to_multiple_pairs( @@ -1403,7 +1449,9 @@ def test_score_regions_single_read_window_features_uses_builtin_loader(monkeypat region_contrasts, "cluster", SimpleNamespace( - extract_read_windows=lambda **kwargs: extracted_by_path[kwargs["hdf5_file"]], + extract_read_windows=lambda **kwargs: extracted_by_path[ + kwargs["hdf5_file"] + ], read_window_feature_matrix=lambda extracted: feature_rows_by_path[ "ns.h5" if extracted is extracted_by_path["ns.h5"] else "treated.h5" ], @@ -1418,7 +1466,9 @@ def test_score_regions_single_read_window_features_uses_builtin_loader(monkeypat ], regions="regions.bed", motifs=["A,0"], - contrast=ContrastSpec(mode="pairwise", numerator=["treated"], denominator=["NS"]), + contrast=ContrastSpec( + mode="pairwise", numerator=["treated"], denominator=["NS"] + ), analysis_unit="single_read", representation="read_window_features", signal_source="extract_features", @@ -1881,7 +1931,9 @@ def test_score_regions_beta_binomial_adds_p_values(monkeypatch): assert "p_value" in table.columns assert "adjusted_p_value" in table.columns assert ((table["p_value"] >= 0) & (table["p_value"] <= 1)).all() - assert ((table["adjusted_p_value"] >= 0) & (table["adjusted_p_value"] <= 1)).all() + assert ( + (table["adjusted_p_value"] >= 0) & (table["adjusted_p_value"] <= 1) + ).all() def test_score_regions_beta_binomial_rejects_unsupported_multiple_testing(monkeypatch): @@ -2098,8 +2150,14 @@ def test_score_regions_beta_binomial_ranks_by_adjusted_p_value(monkeypatch): ) assert result.summary.iloc[0]["region_id"] == "lower_effect_higher_significance" - assert result.summary.iloc[0]["adjusted_p_value"] <= result.summary.iloc[1]["adjusted_p_value"] - assert result.summary.iloc[0]["delta_fraction"] < result.summary.iloc[1]["delta_fraction"] + assert ( + result.summary.iloc[0]["adjusted_p_value"] + <= result.summary.iloc[1]["adjusted_p_value"] + ) + assert ( + result.summary.iloc[0]["delta_fraction"] + < result.summary.iloc[1]["delta_fraction"] + ) assert result.summary.iloc[0]["rank"] == 1 @@ -2430,7 +2488,9 @@ def test_score_regions_modified_count_representation_ranks_by_delta_count(monkey assert result.summary.loc[0, "reference_count"] == 1 assert result.summary.loc[0, "delta_count"] == 10 assert result.summary.loc[1, "delta_count"] == 7 - assert result.summary.loc[0, "log2_fc_count"] == pytest.approx(math.log2((11 + 1e-6) / (1 + 1e-6))) + assert result.summary.loc[0, "log2_fc_count"] == pytest.approx( + math.log2((11 + 1e-6) / (1 + 1e-6)) + ) assert result.metadata["representation"] == "modified_count" @@ -2543,7 +2603,9 @@ def test_score_regions_cluster_occupancy_dominant_cluster_rejects_missing_reques samples=[], regions=None, motifs=[], - contrast=ContrastSpec(mode="pairwise", numerator=["15min"], denominator=["NS"]), + contrast=ContrastSpec( + mode="pairwise", numerator=["15min"], denominator=["NS"] + ), analysis_unit="cluster_occupancy", representation="dominant_cluster", signal_source="cluster_occupancy", @@ -2575,7 +2637,9 @@ def test_score_regions_cluster_occupancy_dominant_cluster_rejects_region_specifi samples=[], regions=None, motifs=[], - contrast=ContrastSpec(mode="pairwise", numerator=["15min"], denominator=["NS"]), + contrast=ContrastSpec( + mode="pairwise", numerator=["15min"], denominator=["NS"] + ), analysis_unit="cluster_occupancy", representation="dominant_cluster", signal_source="cluster_occupancy", @@ -2668,7 +2732,9 @@ def test_score_regions_cluster_occupancy_rejects_fraction_test_for_dominant_clus samples=[], regions=None, motifs=[], - contrast=ContrastSpec(mode="pairwise", numerator=["15min"], denominator=["NS"]), + contrast=ContrastSpec( + mode="pairwise", numerator=["15min"], denominator=["NS"] + ), analysis_unit="cluster_occupancy", representation="dominant_cluster", signal_source="cluster_occupancy", @@ -2836,10 +2902,30 @@ def test_score_regions_cluster_fraction_treats_missing_sample_cluster_rows_as_ze @pytest.mark.parametrize( ("representation", "column", "value", "message"), [ - ("cluster_fraction", "fraction", 1.2, "fraction values must be finite and between 0 and 1"), - ("cluster_fraction", "fraction", float("nan"), "fraction values must be finite and between 0 and 1"), - ("cluster_entropy", "cluster_entropy", float("inf"), "cluster_entropy values must be finite and >= 0"), - ("cluster_entropy", "cluster_entropy", -0.1, "cluster_entropy values must be finite and >= 0"), + ( + "cluster_fraction", + "fraction", + 1.2, + "fraction values must be finite and between 0 and 1", + ), + ( + "cluster_fraction", + "fraction", + float("nan"), + "fraction values must be finite and between 0 and 1", + ), + ( + "cluster_entropy", + "cluster_entropy", + float("inf"), + "cluster_entropy values must be finite and >= 0", + ), + ( + "cluster_entropy", + "cluster_entropy", + -0.1, + "cluster_entropy values must be finite and >= 0", + ), ], ) def test_score_regions_cluster_occupancy_rejects_invalid_numeric_values( @@ -2872,7 +2958,9 @@ def test_score_regions_cluster_occupancy_rejects_invalid_numeric_values( samples=[], regions=None, motifs=[], - contrast=ContrastSpec(mode="pairwise", numerator=["15min"], denominator=["NS"]), + contrast=ContrastSpec( + mode="pairwise", numerator=["15min"], denominator=["NS"] + ), analysis_unit="cluster_occupancy", representation=representation, signal_source="cluster_occupancy", @@ -2887,7 +2975,9 @@ def test_score_regions_cluster_occupancy_rejects_missing_occupancy_columns(): samples=[], regions=None, motifs=[], - contrast=ContrastSpec(mode="pairwise", numerator=["15min"], denominator=["NS"]), + contrast=ContrastSpec( + mode="pairwise", numerator=["15min"], denominator=["NS"] + ), analysis_unit="cluster_occupancy", representation="cluster_fraction", signal_source="cluster_occupancy", diff --git a/tests/test_region_discovery.py b/tests/test_region_discovery.py index 5a1d118..0a32b47 100644 --- a/tests/test_region_discovery.py +++ b/tests/test_region_discovery.py @@ -3,11 +3,9 @@ import pandas as pd import pytest -from dimelo import global_analysis +from dimelo import global_analysis, region_contrasts, region_discovery from dimelo.models import ContrastSpec, RegionDiscoveryResult, SampleSpec -from dimelo import region_contrasts, region_discovery - def _mock_window_summary() -> pd.DataFrame: return pd.DataFrame( @@ -443,7 +441,9 @@ def fake_build_window_summary(**kwargs): captured.update(kwargs) return _mock_window_summary() - monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) + monkeypatch.setattr( + global_analysis, "build_window_summary", fake_build_window_summary + ) result = region_discovery.scan_genome( samples=[ @@ -503,7 +503,11 @@ def fake_build_window_summary(**kwargs): def test_scan_genome_matched_pairwise_uses_only_complete_pairs(monkeypatch): - monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_window_summary()) + monkeypatch.setattr( + global_analysis, + "build_window_summary", + lambda **_: _mock_paired_window_summary(), + ) result = region_discovery.scan_genome( samples=_paired_samplespecs(), @@ -559,8 +563,14 @@ def test_scan_genome_matched_pairwise_ranks_by_mean_abs_delta(monkeypatch): assert result.metadata["rank_by"] == "mean_abs_delta" -def test_scan_genome_matched_pairwise_errors_on_missing_pairs_in_strict_mode(monkeypatch): - monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_window_summary()) +def test_scan_genome_matched_pairwise_errors_on_missing_pairs_in_strict_mode( + monkeypatch, +): + monkeypatch.setattr( + global_analysis, + "build_window_summary", + lambda **_: _mock_paired_window_summary(), + ) with pytest.raises(ValueError, match="incomplete matched units"): region_discovery.scan_genome( @@ -607,95 +617,102 @@ def test_scan_genome_matched_pairwise_applies_min_coverage_filtering(monkeypatch assert pd.isna(result.windows.loc[0, "rank"]) assert pd.isna(result.windows.loc[0, "score_value"]) -def test_scan_genome_matched_pairwise_reranks_surviving_hits_after_coverage_filter(monkeypatch): - monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: pd.DataFrame( - [ - { - "sample_id": "t1", - "condition": "targeting", - "replicate": 1, - "motif": "A,0", - "window_id": "chr1:0-500", - "chromosome": "chr1", - "start": 0, - "end": 500, - "strand": ".", - "modified_count": 9, - "valid_count": 10, - "window_fraction": 0.9, - }, - { - "sample_id": "d1", - "condition": "nontargeting", - "replicate": 1, - "motif": "A,0", - "window_id": "chr1:0-500", - "chromosome": "chr1", - "start": 0, - "end": 500, - "strand": ".", - "modified_count": 1, - "valid_count": 10, - "window_fraction": 0.1, - }, - { - "sample_id": "t2", - "condition": "targeting", - "replicate": 1, - "motif": "A,0", - "window_id": "chr1:500-1000", - "chromosome": "chr1", - "start": 500, - "end": 1000, - "strand": ".", - "modified_count": 12, - "valid_count": 60, - "window_fraction": 0.2, - }, - { - "sample_id": "d2", - "condition": "nontargeting", - "replicate": 1, - "motif": "A,0", - "window_id": "chr1:500-1000", - "chromosome": "chr1", - "start": 500, - "end": 1000, - "strand": ".", - "modified_count": 6, - "valid_count": 60, - "window_fraction": 0.1, - }, - { - "sample_id": "t1", - "condition": "targeting", - "replicate": 1, - "motif": "A,0", - "window_id": "chr1:1000-1500", - "chromosome": "chr1", - "start": 1000, - "end": 1500, - "strand": ".", - "modified_count": 10, - "valid_count": 60, - "window_fraction": 1 / 6, - }, - { - "sample_id": "d1", - "condition": "nontargeting", - "replicate": 1, - "motif": "A,0", - "window_id": "chr1:1000-1500", - "chromosome": "chr1", - "start": 1000, - "end": 1500, - "strand": ".", - "modified_count": 6, - "valid_count": 60, - "window_fraction": 0.1, - }, - ] - )) + +def test_scan_genome_matched_pairwise_reranks_surviving_hits_after_coverage_filter( + monkeypatch, +): + monkeypatch.setattr( + global_analysis, + "build_window_summary", + lambda **_: pd.DataFrame( + [ + { + "sample_id": "t1", + "condition": "targeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 9, + "valid_count": 10, + "window_fraction": 0.9, + }, + { + "sample_id": "d1", + "condition": "nontargeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:0-500", + "chromosome": "chr1", + "start": 0, + "end": 500, + "strand": ".", + "modified_count": 1, + "valid_count": 10, + "window_fraction": 0.1, + }, + { + "sample_id": "t2", + "condition": "targeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 12, + "valid_count": 60, + "window_fraction": 0.2, + }, + { + "sample_id": "d2", + "condition": "nontargeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:500-1000", + "chromosome": "chr1", + "start": 500, + "end": 1000, + "strand": ".", + "modified_count": 6, + "valid_count": 60, + "window_fraction": 0.1, + }, + { + "sample_id": "t1", + "condition": "targeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-1500", + "chromosome": "chr1", + "start": 1000, + "end": 1500, + "strand": ".", + "modified_count": 10, + "valid_count": 60, + "window_fraction": 1 / 6, + }, + { + "sample_id": "d1", + "condition": "nontargeting", + "replicate": 1, + "motif": "A,0", + "window_id": "chr1:1000-1500", + "chromosome": "chr1", + "start": 1000, + "end": 1500, + "strand": ".", + "modified_count": 6, + "valid_count": 60, + "window_fraction": 0.1, + }, + ] + ), + ) result = region_discovery.scan_genome( samples=[ SampleSpec( @@ -767,6 +784,8 @@ def test_scan_genome_rejects_invalid_pairing_policy(monkeypatch): ), score="effect_size_only", ) + + def test_scan_genome_matched_pairwise_rejects_merge_hits(monkeypatch): monkeypatch.setattr( global_analysis, @@ -799,7 +818,9 @@ def test_scan_genome_matched_pairwise_rejects_multi_condition_sides(monkeypatch) lambda **_: _mock_paired_pairwise_window_summary(), ) - with pytest.raises(ValueError, match="exactly one numerator and one denominator condition"): + with pytest.raises( + ValueError, match="exactly one numerator and one denominator condition" + ): region_discovery.scan_genome( samples=_paired_samplespecs(), motifs=["A,0"], @@ -1123,7 +1144,11 @@ def _mock_paired_time_course_window_summary() -> pd.DataFrame: def test_scan_genome_time_course_ranks_by_trajectory_amplitude_mean(monkeypatch): - monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_time_course_window_summary()) + monkeypatch.setattr( + global_analysis, + "build_window_summary", + lambda **_: _mock_paired_time_course_window_summary(), + ) result = region_discovery.scan_genome( samples=_paired_time_course_samplespecs(), @@ -1147,8 +1172,14 @@ def test_scan_genome_time_course_ranks_by_trajectory_amplitude_mean(monkeypatch) assert result.metadata["rank_by"] == "trajectory_amplitude_mean" -def test_scan_genome_time_course_errors_when_time_order_conditions_are_missing(monkeypatch): - monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_time_course_window_summary()) +def test_scan_genome_time_course_errors_when_time_order_conditions_are_missing( + monkeypatch, +): + monkeypatch.setattr( + global_analysis, + "build_window_summary", + lambda **_: _mock_paired_time_course_window_summary(), + ) with pytest.raises(ValueError, match="time_order"): region_discovery.scan_genome( @@ -1165,7 +1196,10 @@ def test_scan_genome_time_course_errors_when_time_order_conditions_are_missing(m score="effect_size_only", ) -def test_scan_genome_time_course_filters_incomplete_trajectories_per_window(monkeypatch): + +def test_scan_genome_time_course_filters_incomplete_trajectories_per_window( + monkeypatch, +): monkeypatch.setattr( global_analysis, "build_window_summary", @@ -1350,7 +1384,9 @@ def test_scan_genome_time_course_filters_incomplete_trajectories_per_window(monk assert second_window["trajectory_amplitude_mean"] == pytest.approx(0.8) -def test_scan_genome_time_course_ignores_extra_conditions_outside_time_order(monkeypatch): +def test_scan_genome_time_course_ignores_extra_conditions_outside_time_order( + monkeypatch, +): monkeypatch.setattr( global_analysis, "build_window_summary", @@ -1537,8 +1573,14 @@ def test_scan_genome_time_course_ignores_extra_conditions_outside_time_order(mon assert result.hits.loc[0, "trajectory_amplitude_mean"] == pytest.approx(0.35) assert result.hits.loc[0, "trajectory_amplitude_sd"] == pytest.approx(0.05) + + def test_scan_genome_time_course_errors_on_missing_pairing_key(monkeypatch): - monkeypatch.setattr(global_analysis, "build_window_summary", lambda **_: _mock_paired_window_summary()) + monkeypatch.setattr( + global_analysis, + "build_window_summary", + lambda **_: _mock_paired_window_summary(), + ) with pytest.raises(ValueError, match="pairing_key"): region_discovery.scan_genome( @@ -1556,17 +1598,35 @@ def test_scan_genome_time_course_errors_on_missing_pairing_key(monkeypatch): def test_merge_adjacent_hits_preserves_rank_order_and_merges_counts(): - merged = region_discovery.merge_adjacent_hits(_merge_helper_hits(), merge_distance=1) + merged = region_discovery.merge_adjacent_hits( + _merge_helper_hits(), merge_distance=1 + ) assert list(merged["window_id"]) == ["chr2:100-200", "chr1:0-200", "chr1:500-600"] assert list(merged["rank"]) == [1, 2, 4] assert list(merged["merged_window_count"]) == [1, 2, 1] - assert list(merged["score_value"]) == [pytest.approx(0.95), pytest.approx(0.3), pytest.approx(0.8)] - assert list(merged["p_value"]) == [pytest.approx(0.01), pytest.approx(0.03), pytest.approx(0.05)] - assert list(merged["adjusted_p_value"]) == [pytest.approx(0.01), pytest.approx(0.06), pytest.approx(0.07)] + assert list(merged["score_value"]) == [ + pytest.approx(0.95), + pytest.approx(0.3), + pytest.approx(0.8), + ] + assert list(merged["p_value"]) == [ + pytest.approx(0.01), + pytest.approx(0.03), + pytest.approx(0.05), + ] + assert list(merged["adjusted_p_value"]) == [ + pytest.approx(0.01), + pytest.approx(0.06), + pytest.approx(0.07), + ] assert list(merged["modified_count"]) == [19, 8, 8] assert list(merged["valid_count"]) == [20, 20, 10] - assert list(merged["window_fraction"]) == [pytest.approx(0.95), pytest.approx(0.4), pytest.approx(0.8)] + assert list(merged["window_fraction"]) == [ + pytest.approx(0.95), + pytest.approx(0.4), + pytest.approx(0.8), + ] assert pd.isna(merged.loc[0, "numerator_modified_count"]) assert merged.loc[1, "numerator_modified_count"] == 6 assert pd.isna(merged.loc[2, "numerator_modified_count"]) @@ -1582,16 +1642,39 @@ def test_merge_adjacent_hits_preserves_rank_order_and_merges_counts(): def test_hits_to_bed_projects_required_columns_in_order(): - merged = region_discovery.merge_adjacent_hits(_merge_helper_hits(), merge_distance=1) + merged = region_discovery.merge_adjacent_hits( + _merge_helper_hits(), merge_distance=1 + ) bed = region_discovery.hits_to_bed(merged) assert list(bed.columns) == ["chrom", "start", "end", "name", "score", "strand"] assert pd.api.types.is_integer_dtype(bed["score"]) assert bed["score"].between(0, 1000).all() assert bed.to_dict(orient="records") == [ - {"chrom": "chr2", "start": 100, "end": 200, "name": "chr2:100-200", "score": 950, "strand": "+"}, - {"chrom": "chr1", "start": 0, "end": 200, "name": "chr1:0-200", "score": 300, "strand": "+"}, - {"chrom": "chr1", "start": 500, "end": 600, "name": "chr1:500-600", "score": 800, "strand": "-"}, + { + "chrom": "chr2", + "start": 100, + "end": 200, + "name": "chr2:100-200", + "score": 950, + "strand": "+", + }, + { + "chrom": "chr1", + "start": 0, + "end": 200, + "name": "chr1:0-200", + "score": 300, + "strand": "+", + }, + { + "chrom": "chr1", + "start": 500, + "end": 600, + "name": "chr1:500-600", + "score": 800, + "strand": "-", + }, ] @@ -1615,7 +1698,9 @@ def fake_regions_to_list( split_large_regions=False, ): pileup_path = function_handle.keywords["bedmethyl_file"] - regions_dict = region_contrasts.utils.regions_dict_from_input(regions, window_size) + regions_dict = region_contrasts.utils.regions_dict_from_input( + regions, window_size + ) n_regions = sum(len(region_list) for region_list in regions_dict.values()) base_counts = counts_by_pileup[pileup_path] if len(base_counts) >= n_regions: @@ -1623,7 +1708,9 @@ def fake_regions_to_list( repeats = (n_regions // len(base_counts)) + 1 return (base_counts * repeats)[:n_regions] - monkeypatch.setattr(region_contrasts.load_processed, "regions_to_list", fake_regions_to_list) + monkeypatch.setattr( + region_contrasts.load_processed, "regions_to_list", fake_regions_to_list + ) samples = [ SampleSpec( @@ -1698,14 +1785,25 @@ def test_paired_discovery_bed_handoff_into_region_contrasts(tmp_path, monkeypatc "d2.bed.gz": [(1, 10), (2, 10)], } - def fake_regions_to_list(function_handle, regions, window_size=None, quiet=True, cores=None, split_large_regions=False): + def fake_regions_to_list( + function_handle, + regions, + window_size=None, + quiet=True, + cores=None, + split_large_regions=False, + ): pileup_path = function_handle.keywords["bedmethyl_file"] - regions_dict = region_contrasts.utils.regions_dict_from_input(regions, window_size) + regions_dict = region_contrasts.utils.regions_dict_from_input( + regions, window_size + ) n_regions = sum(len(region_list) for region_list in regions_dict.values()) base_counts = counts_by_pileup[pileup_path] return (base_counts * ((n_regions // len(base_counts)) + 1))[:n_regions] - monkeypatch.setattr(region_contrasts.load_processed, "regions_to_list", fake_regions_to_list) + monkeypatch.setattr( + region_contrasts.load_processed, "regions_to_list", fake_regions_to_list + ) result = region_contrasts.score_regions( samples=[ @@ -1812,7 +1910,9 @@ def fake_build_window_summary(**kwargs): ] ) - monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) + monkeypatch.setattr( + global_analysis, "build_window_summary", fake_build_window_summary + ) result = region_discovery.scan_genome( samples=[ @@ -1848,9 +1948,11 @@ def fake_build_window_summary(**kwargs): result.windows["window_id"] == "chr1:1000-2000", "score_value" ] assert low_coverage.isna().all() - assert result.windows.loc[ - result.windows["window_id"] == "chr1:1000-2000", "rank" - ].isna().all() + assert ( + result.windows.loc[result.windows["window_id"] == "chr1:1000-2000", "rank"] + .isna() + .all() + ) def test_scan_genome_hands_include_and_exclude_contigs_to_window_builder(monkeypatch): @@ -1875,7 +1977,9 @@ def fake_build_window_summary(**kwargs): ] ) - monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) + monkeypatch.setattr( + global_analysis, "build_window_summary", fake_build_window_summary + ) region_discovery.scan_genome( samples=[], @@ -1955,7 +2059,9 @@ def fake_build_window_summary(**kwargs): ] ) - monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) + monkeypatch.setattr( + global_analysis, "build_window_summary", fake_build_window_summary + ) result = region_discovery.scan_genome( samples=[ @@ -1990,7 +2096,10 @@ def fake_build_window_summary(**kwargs): result.windows.columns ) assert list(result.hits["rank"]) == [1, 2] - assert result.windows.loc[0, "adjusted_p_value"] <= result.windows.loc[1, "adjusted_p_value"] + assert ( + result.windows.loc[0, "adjusted_p_value"] + <= result.windows.loc[1, "adjusted_p_value"] + ) assert result.hits.loc[0, "score_value"] >= result.hits.loc[1, "score_value"] @@ -2096,8 +2205,12 @@ def fake_bh_adjustment(p_values): observed_bh_inputs.append(len(p_values)) return p_values.astype(float) - monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) - monkeypatch.setattr(region_discovery, "_beta_binomial_two_sided_p_value", fake_p_value) + monkeypatch.setattr( + global_analysis, "build_window_summary", fake_build_window_summary + ) + monkeypatch.setattr( + region_discovery, "_beta_binomial_two_sided_p_value", fake_p_value + ) monkeypatch.setattr(region_discovery, "_adjust_p_values_bh", fake_bh_adjustment) result = region_discovery.scan_genome( @@ -2184,7 +2297,9 @@ def fake_build_window_summary(**kwargs): ] ) - monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) + monkeypatch.setattr( + global_analysis, "build_window_summary", fake_build_window_summary + ) result = region_discovery.scan_genome( samples=[], @@ -2227,7 +2342,9 @@ def fake_build_window_summary(**kwargs): ] ) - monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) + monkeypatch.setattr( + global_analysis, "build_window_summary", fake_build_window_summary + ) with pytest.raises(ValueError, match="treated"): region_discovery.scan_genome( @@ -2367,7 +2484,9 @@ def fake_build_window_summary(**kwargs): ] ) - monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) + monkeypatch.setattr( + global_analysis, "build_window_summary", fake_build_window_summary + ) result = region_discovery.scan_genome( samples=[], @@ -2480,7 +2599,9 @@ def fake_build_window_summary(**kwargs): ] ) - monkeypatch.setattr(global_analysis, "build_window_summary", fake_build_window_summary) + monkeypatch.setattr( + global_analysis, "build_window_summary", fake_build_window_summary + ) result = region_discovery.scan_genome( samples=[], diff --git a/tests/test_regulatory_enrichment.py b/tests/test_regulatory_enrichment.py index b5b9c2d..e47cd8f 100644 --- a/tests/test_regulatory_enrichment.py +++ b/tests/test_regulatory_enrichment.py @@ -34,11 +34,15 @@ def test_regulatory_spec_filters_screen_for_non_screen_species(): assert spec.species == "rattus_norvegicus" assert spec.enabled_providers == ("unibind",) assert "screen" in spec.provider_notes - assert "supports only homo_sapiens and mus_musculus" in spec.provider_notes["screen"] + assert ( + "supports only homo_sapiens and mus_musculus" in spec.provider_notes["screen"] + ) def test_regulatory_spec_can_raise_on_filtered_screen_when_strict(): - with pytest.raises(regulatory_enrichment.RegulatoryEnrichmentSpecError, match="SCREEN disabled"): + with pytest.raises( + regulatory_enrichment.RegulatoryEnrichmentSpecError, match="SCREEN disabled" + ): regulatory_enrichment.RegulatoryEnrichmentSpec( species="rattus norvegicus", providers=("screen",), @@ -47,7 +51,9 @@ def test_regulatory_spec_can_raise_on_filtered_screen_when_strict(): def test_regulatory_spec_rejects_species_not_supported_by_unibind(): - with pytest.raises(regulatory_enrichment.RegulatoryEnrichmentSpecError, match="Unsupported species"): + with pytest.raises( + regulatory_enrichment.RegulatoryEnrichmentSpecError, match="Unsupported species" + ): regulatory_enrichment.RegulatoryEnrichmentSpec( species="bos_taurus", providers=("unibind",), @@ -113,30 +119,30 @@ def test_search_unibind_trackhub_tracks_and_resolve_to_cache(monkeypatch, tmp_pa payloads = { hub_url: ( - "hub test\n" - "shortLabel Test\n" - "longLabel Test\n" - "genomesFile genomes.txt\n" - "email test@example.org\n" - ).encode(), + b"hub test\n" + b"shortLabel Test\n" + b"longLabel Test\n" + b"genomesFile genomes.txt\n" + b"email test@example.org\n" + ), genomes_url: ( - "genome hg38\n" - "trackDb hg38/trackDb.txt\n\n" - "genome mm10\n" - "trackDb mm10/trackDb.txt\n" - ).encode(), + b"genome hg38\n" + b"trackDb hg38/trackDb.txt\n\n" + b"genome mm10\n" + b"trackDb mm10/trackDb.txt\n" + ), trackdb_url: ( - "track CTCF_track\n" - "shortLabel CTCF\n" - "longLabel CTCF example\n" - "type bigBed 9 .\n" - "bigDataUrl CTCF_track.bb\n\n" - "track ATAC_track\n" - "shortLabel ATAC\n" - "longLabel ATAC example\n" - "type bigBed 9 .\n" - "bigDataUrl ATAC_track.bb\n" - ).encode(), + b"track CTCF_track\n" + b"shortLabel CTCF\n" + b"longLabel CTCF example\n" + b"type bigBed 9 .\n" + b"bigDataUrl CTCF_track.bb\n\n" + b"track ATAC_track\n" + b"shortLabel ATAC\n" + b"longLabel ATAC example\n" + b"type bigBed 9 .\n" + b"bigDataUrl ATAC_track.bb\n" + ), bigbed_url: b"fake-ctcf-track", other_url: b"fake-atac-track", } @@ -200,7 +206,9 @@ def fake_resolve(**kwargs): captured.update(kwargs) return [Path("/tmp/fake.bb")] - monkeypatch.setattr(regulatory_enrichment, "resolve_unibind_track_paths", fake_resolve) + monkeypatch.setattr( + regulatory_enrichment, "resolve_unibind_track_paths", fake_resolve + ) spec = workflows.resolve_regulatory_enrichment_spec( species="human", target_genome="hg38", @@ -223,7 +231,7 @@ def test_submit_unibind_tfbs_extraction_parses_job_page(monkeypatch): submitted_html = ( "" "" - "" "
Job status:Queued
Results URL:" + '
Results URL:' "https://example.org/TFBS_extraction/jobA/" "
" @@ -255,10 +263,14 @@ def open(self, req, timeout=60.0): # noqa: ARG002 if url == endpoint and data is not None: assert b"performTFBSextraction" in data assert b"collection" in data - return FakeResponse(submitted_html, "https://example.org/TFBS_extraction/jobA/") + return FakeResponse( + submitted_html, "https://example.org/TFBS_extraction/jobA/" + ) raise RuntimeError(f"Unexpected request url={url!r}") - monkeypatch.setattr(regulatory_enrichment.request, "build_opener", lambda *args: FakeOpener()) + monkeypatch.setattr( + regulatory_enrichment.request, "build_opener", lambda *args: FakeOpener() + ) result = regulatory_enrichment.submit_unibind_tfbs_extraction( regions=["chr1:10-20"], @@ -319,7 +331,9 @@ def fake_fetch_text(url: str, timeout_seconds: float = 60.0): # noqa: ARG001 timeout_seconds=1.0, ) assert result.status == "completed" - assert "https://example.org/temp/jobB/extraction_results.bed" in result.download_urls + assert ( + "https://example.org/temp/jobB/extraction_results.bed" in result.download_urls + ) assert len(result.status_history) >= 2 diff --git a/tests/test_run_modkit.py b/tests/test_run_modkit.py index 22ae7c6..aeb5077 100644 --- a/tests/test_run_modkit.py +++ b/tests/test_run_modkit.py @@ -1,3 +1,4 @@ +import subprocess from pathlib import Path import pytest @@ -30,7 +31,9 @@ def fake_get_modkit_capabilities(quiet=False, executable=None): captured["executable"] = executable return capabilities - monkeypatch.setattr(run_modkit, "get_modkit_capabilities", fake_get_modkit_capabilities) + monkeypatch.setattr( + run_modkit, "get_modkit_capabilities", fake_get_modkit_capabilities + ) result = run_modkit._ensure_modkit_available( quiet=True, @@ -46,7 +49,9 @@ def fake_get_modkit_capabilities(quiet=False, executable=None): def test_resolve_modkit_executable_prefers_env_override(monkeypatch): monkeypatch.setenv(run_modkit.MODKIT_EXECUTABLE_ENV, "modkit-0.6") - monkeypatch.setattr(run_modkit.shutil, "which", lambda name: f"/usr/local/bin/{name}") + monkeypatch.setattr( + run_modkit.shutil, "which", lambda name: f"/usr/local/bin/{name}" + ) resolved = run_modkit._resolve_modkit_executable(None) @@ -105,8 +110,12 @@ def fake_cached(*, executable_path, executable_fingerprint, quiet=False): return capabilities monkeypatch.setattr(run_modkit, "_prepare_modkit_path", fake_prepare_modkit_path) - monkeypatch.setattr(run_modkit, "_resolve_modkit_executable", fake_resolve_modkit_executable) - monkeypatch.setattr(run_modkit, "_modkit_cache_fingerprint", fake_modkit_cache_fingerprint) + monkeypatch.setattr( + run_modkit, "_resolve_modkit_executable", fake_resolve_modkit_executable + ) + monkeypatch.setattr( + run_modkit, "_modkit_cache_fingerprint", fake_modkit_cache_fingerprint + ) monkeypatch.setattr(run_modkit, "_get_modkit_capabilities_cached", fake_cached) result = run_modkit.get_modkit_capabilities( @@ -123,3 +132,58 @@ def fake_cached(*, executable_path, executable_fingerprint, quiet=False): "cached_executable_fingerprint": "fingerprint-123", "cached_quiet": True, } + + +def test_should_render_live_progress_respects_env_off(monkeypatch): + monkeypatch.setenv("DIMELO_PROGRESS_MODE", "off") + monkeypatch.setattr(run_modkit.sys.stderr, "isatty", lambda: True) + + assert run_modkit._should_render_live_progress() is False + + +def test_should_render_live_progress_auto_disables_notebook(monkeypatch): + monkeypatch.delenv("DIMELO_PROGRESS_MODE", raising=False) + monkeypatch.setenv("JPY_PARENT_PID", "12345") + monkeypatch.setattr(run_modkit.sys.stderr, "isatty", lambda: True) + + assert run_modkit._should_render_live_progress() is False + + +def test_get_modkit_capabilities_extract_subcommands_fallback_for_modkit_0_6( + monkeypatch, +): + run_modkit._get_modkit_capabilities_cached.cache_clear() + + def fake_run( + cmd, stdout=None, stderr=None, text=None, check=None, capture_output=None + ): + if cmd == ["modkit", "--version"]: + return subprocess.CompletedProcess(cmd, 0, stdout="modkit 0.6.1", stderr="") + if cmd == ["modkit", "pileup", "--help"]: + return subprocess.CompletedProcess( + cmd, + 0, + stdout=" --mod-threshold\n --modified-bases\n", + stderr="", + ) + if cmd == ["modkit", "extract", "--help"]: + # Simulate help text that does not include the exact usage marker. + return subprocess.CompletedProcess( + cmd, 0, stdout="Extract command\n", stderr="" + ) + if cmd == ["modkit", "extract", "full", "--help"]: + return subprocess.CompletedProcess( + cmd, 0, stdout=" --reference\n", stderr="" + ) + raise AssertionError(f"unexpected subprocess command: {cmd}") + + monkeypatch.setattr(run_modkit.subprocess, "run", fake_run) + + caps = run_modkit._get_modkit_capabilities_cached( + executable_path="modkit", + executable_fingerprint="fingerprint-test", + quiet=True, + ) + + assert caps.supports_extract_subcommands is True + assert caps.extract_supports_reference_long is True diff --git a/tests/test_shared_cluster_tests.py b/tests/test_shared_cluster_tests.py index eb91857..2668043 100644 --- a/tests/test_shared_cluster_tests.py +++ b/tests/test_shared_cluster_tests.py @@ -25,22 +25,94 @@ def _make_shared_cluster_test_result() -> SharedClusterResult: ), cluster_distribution=pd.DataFrame( [ - {"sample_id": "s1", "condition": "NS", "cluster": "C0", "count": 80, "fraction": 0.80}, - {"sample_id": "s1", "condition": "NS", "cluster": "C1", "count": 20, "fraction": 0.20}, - {"sample_id": "s2", "condition": "NS", "cluster": "C0", "count": 75, "fraction": 0.75}, - {"sample_id": "s2", "condition": "NS", "cluster": "C1", "count": 25, "fraction": 0.25}, - {"sample_id": "s3", "condition": "treated", "cluster": "C0", "count": 30, "fraction": 0.30}, - {"sample_id": "s3", "condition": "treated", "cluster": "C1", "count": 70, "fraction": 0.70}, - {"sample_id": "s4", "condition": "treated", "cluster": "C0", "count": 25, "fraction": 0.25}, - {"sample_id": "s4", "condition": "treated", "cluster": "C1", "count": 75, "fraction": 0.75}, + { + "sample_id": "s1", + "condition": "NS", + "cluster": "C0", + "count": 80, + "fraction": 0.80, + }, + { + "sample_id": "s1", + "condition": "NS", + "cluster": "C1", + "count": 20, + "fraction": 0.20, + }, + { + "sample_id": "s2", + "condition": "NS", + "cluster": "C0", + "count": 75, + "fraction": 0.75, + }, + { + "sample_id": "s2", + "condition": "NS", + "cluster": "C1", + "count": 25, + "fraction": 0.25, + }, + { + "sample_id": "s3", + "condition": "treated", + "cluster": "C0", + "count": 30, + "fraction": 0.30, + }, + { + "sample_id": "s3", + "condition": "treated", + "cluster": "C1", + "count": 70, + "fraction": 0.70, + }, + { + "sample_id": "s4", + "condition": "treated", + "cluster": "C0", + "count": 25, + "fraction": 0.25, + }, + { + "sample_id": "s4", + "condition": "treated", + "cluster": "C1", + "count": 75, + "fraction": 0.75, + }, ] ), condition_distribution=pd.DataFrame( [ - {"condition": "NS", "cluster": "C0", "count": 155, "fraction": 0.775, "replicate_n": 2}, - {"condition": "NS", "cluster": "C1", "count": 45, "fraction": 0.225, "replicate_n": 2}, - {"condition": "treated", "cluster": "C0", "count": 55, "fraction": 0.275, "replicate_n": 2}, - {"condition": "treated", "cluster": "C1", "count": 145, "fraction": 0.725, "replicate_n": 2}, + { + "condition": "NS", + "cluster": "C0", + "count": 155, + "fraction": 0.775, + "replicate_n": 2, + }, + { + "condition": "NS", + "cluster": "C1", + "count": 45, + "fraction": 0.225, + "replicate_n": 2, + }, + { + "condition": "treated", + "cluster": "C0", + "count": 55, + "fraction": 0.275, + "replicate_n": 2, + }, + { + "condition": "treated", + "cluster": "C1", + "count": 145, + "fraction": 0.725, + "replicate_n": 2, + }, ] ), distribution_change=None, @@ -64,22 +136,94 @@ def _make_shared_cluster_time_course_result() -> SharedClusterResult: ) result.cluster_distribution = pd.DataFrame( [ - {"sample_id": "t0_a", "condition": "t0", "cluster": "C0", "count": 80, "fraction": 0.80}, - {"sample_id": "t0_a", "condition": "t0", "cluster": "C1", "count": 20, "fraction": 0.20}, - {"sample_id": "t1_a", "condition": "t1", "cluster": "C0", "count": 55, "fraction": 0.55}, - {"sample_id": "t1_a", "condition": "t1", "cluster": "C1", "count": 45, "fraction": 0.45}, - {"sample_id": "t2_a", "condition": "t2", "cluster": "C0", "count": 25, "fraction": 0.25}, - {"sample_id": "t2_a", "condition": "t2", "cluster": "C1", "count": 75, "fraction": 0.75}, + { + "sample_id": "t0_a", + "condition": "t0", + "cluster": "C0", + "count": 80, + "fraction": 0.80, + }, + { + "sample_id": "t0_a", + "condition": "t0", + "cluster": "C1", + "count": 20, + "fraction": 0.20, + }, + { + "sample_id": "t1_a", + "condition": "t1", + "cluster": "C0", + "count": 55, + "fraction": 0.55, + }, + { + "sample_id": "t1_a", + "condition": "t1", + "cluster": "C1", + "count": 45, + "fraction": 0.45, + }, + { + "sample_id": "t2_a", + "condition": "t2", + "cluster": "C0", + "count": 25, + "fraction": 0.25, + }, + { + "sample_id": "t2_a", + "condition": "t2", + "cluster": "C1", + "count": 75, + "fraction": 0.75, + }, ] ) result.condition_distribution = pd.DataFrame( [ - {"condition": "t0", "cluster": "C0", "count": 80, "fraction": 0.80, "replicate_n": 1}, - {"condition": "t0", "cluster": "C1", "count": 20, "fraction": 0.20, "replicate_n": 1}, - {"condition": "t1", "cluster": "C0", "count": 55, "fraction": 0.55, "replicate_n": 1}, - {"condition": "t1", "cluster": "C1", "count": 45, "fraction": 0.45, "replicate_n": 1}, - {"condition": "t2", "cluster": "C0", "count": 25, "fraction": 0.25, "replicate_n": 1}, - {"condition": "t2", "cluster": "C1", "count": 75, "fraction": 0.75, "replicate_n": 1}, + { + "condition": "t0", + "cluster": "C0", + "count": 80, + "fraction": 0.80, + "replicate_n": 1, + }, + { + "condition": "t0", + "cluster": "C1", + "count": 20, + "fraction": 0.20, + "replicate_n": 1, + }, + { + "condition": "t1", + "cluster": "C0", + "count": 55, + "fraction": 0.55, + "replicate_n": 1, + }, + { + "condition": "t1", + "cluster": "C1", + "count": 45, + "fraction": 0.45, + "replicate_n": 1, + }, + { + "condition": "t2", + "cluster": "C0", + "count": 25, + "fraction": 0.25, + "replicate_n": 1, + }, + { + "condition": "t2", + "cluster": "C1", + "count": 75, + "fraction": 0.75, + "replicate_n": 1, + }, ] ) return result @@ -114,7 +258,9 @@ def test_shared_cluster_tests_pairwise_returns_summary_details_and_plot_data(): result = shared_cluster_tests.shared_cluster_tests( result=_make_shared_cluster_test_result(), - contrast=ContrastSpec(mode="pairwise", numerator=["treated"], denominator=["NS"]), + contrast=ContrastSpec( + mode="pairwise", numerator=["treated"], denominator=["NS"] + ), test="permutation", n_permutations=50, random_state=7, @@ -163,7 +309,9 @@ def test_shared_cluster_tests_supports_chi_squared_screen(): result = shared_cluster_tests.shared_cluster_tests( result=_make_shared_cluster_test_result(), - contrast=ContrastSpec(mode="pairwise", numerator=["treated"], denominator=["NS"]), + contrast=ContrastSpec( + mode="pairwise", numerator=["treated"], denominator=["NS"] + ), test="chi_squared", ) @@ -177,7 +325,9 @@ def test_shared_cluster_tests_supports_g_test_screen(): result = shared_cluster_tests.shared_cluster_tests( result=_make_shared_cluster_test_result(), - contrast=ContrastSpec(mode="pairwise", numerator=["treated"], denominator=["NS"]), + contrast=ContrastSpec( + mode="pairwise", numerator=["treated"], denominator=["NS"] + ), test="g_test", ) diff --git a/tests/test_workflows.py b/tests/test_workflows.py index d058e80..7b81d1b 100644 --- a/tests/test_workflows.py +++ b/tests/test_workflows.py @@ -5,9 +5,10 @@ import pytest from dimelo import plotting, workflows -from dimelo.models import ContrastSpec, DatasetArtifact from dimelo.models import ( ChipAtlasEnrichmentResult, + ContrastSpec, + DatasetArtifact, RegionContrastResult, RegionDiscoveryResult, SampleSpec, @@ -96,14 +97,31 @@ def _mock_cluster_result(*args, **kwargs): assignments=assignments, cluster_distribution=pd.DataFrame( [ - {"sample_id": "s1", "condition": "NS", "cluster": "C0", "count": 1, "fraction": 1.0}, - {"sample_id": "s2", "condition": "15min", "cluster": "C1", "count": 1, "fraction": 1.0}, + { + "sample_id": "s1", + "condition": "NS", + "cluster": "C0", + "count": 1, + "fraction": 1.0, + }, + { + "sample_id": "s2", + "condition": "15min", + "cluster": "C1", + "count": 1, + "fraction": 1.0, + }, ] ), condition_distribution=pd.DataFrame( [ {"condition": "NS", "cluster": "C0", "fraction": 1.0, "replicate_n": 1}, - {"condition": "15min", "cluster": "C1", "fraction": 1.0, "replicate_n": 1}, + { + "condition": "15min", + "cluster": "C1", + "fraction": 1.0, + "replicate_n": 1, + }, ] ), distribution_change=None, @@ -203,7 +221,9 @@ def _fake_region_anchored_extract(*args, **kwargs): def test_discovery_cluster_workflow_returns_both_results(monkeypatch): - monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr( + workflows.region_discovery, "scan_genome", _mock_discovery_result + ) monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) result = workflows.discovery_cluster_workflow( @@ -216,13 +236,22 @@ def test_discovery_cluster_workflow_returns_both_results(monkeypatch): assert result.discovery.hits.shape[0] == 3 assert result.clustering.model.mode == "region_anchored" - assert list(result.selected_regions.columns) == ["chrom", "start", "end", "name", "score", "strand"] + assert list(result.selected_regions.columns) == [ + "chrom", + "start", + "end", + "name", + "score", + "strand", + ] assert result.metadata["selection"]["mode"] == "top_n" assert result.metadata["selection"]["top_n"] == 250 def test_discovery_cluster_workflow_selects_top_n_hits(monkeypatch): - monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr( + workflows.region_discovery, "scan_genome", _mock_discovery_result + ) monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) result = workflows.discovery_cluster_workflow( @@ -238,7 +267,9 @@ def test_discovery_cluster_workflow_selects_top_n_hits(monkeypatch): def test_discovery_cluster_workflow_selects_all_hits(monkeypatch): - monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr( + workflows.region_discovery, "scan_genome", _mock_discovery_result + ) monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) result = workflows.discovery_cluster_workflow( @@ -258,14 +289,18 @@ def test_discovery_cluster_workflow_selects_all_hits(monkeypatch): assert result.metadata["selection"]["top_n"] is None -def test_discovery_cluster_workflow_passes_selected_regions_into_clustering(monkeypatch): +def test_discovery_cluster_workflow_passes_selected_regions_into_clustering( + monkeypatch, +): captured = {} def fake_cluster(**kwargs): captured["matched_regions"] = kwargs["matched_regions"] return _mock_cluster_result(**kwargs) - monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr( + workflows.region_discovery, "scan_genome", _mock_discovery_result + ) monkeypatch.setattr(workflows, "shared_cluster_distribution", fake_cluster) result = workflows.discovery_cluster_workflow( @@ -278,12 +313,21 @@ def fake_cluster(**kwargs): ) assert captured["matched_regions"] == ["chr1:0-500,+", "chr1:500-1000,-"] - assert list(result.selected_regions.columns) == ["chrom", "start", "end", "name", "score", "strand"] + assert list(result.selected_regions.columns) == [ + "chrom", + "start", + "end", + "name", + "score", + "strand", + ] assert list(result.selected_regions["name"]) == ["chr1:0-500", "chr1:500-1000"] def test_discovery_cluster_workflow_errors_when_no_hits_survive_selection(monkeypatch): - monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr( + workflows.region_discovery, "scan_genome", _mock_discovery_result + ) monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) with pytest.raises(ValueError, match="No discovery hits remained after selection"): @@ -302,7 +346,9 @@ def test_discovery_cluster_workflow_rejects_unknown_selection_mode(monkeypatch): def fake_scan_genome(*args, **kwargs): called["scan_genome"] = True - raise AssertionError("scan_genome should not be called for invalid selection config") + raise AssertionError( + "scan_genome should not be called for invalid selection config" + ) monkeypatch.setattr(workflows.region_discovery, "scan_genome", fake_scan_genome) monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) @@ -319,12 +365,16 @@ def fake_scan_genome(*args, **kwargs): assert called["scan_genome"] is False -def test_discovery_cluster_workflow_rejects_invalid_clustering_config_before_scan(monkeypatch): +def test_discovery_cluster_workflow_rejects_invalid_clustering_config_before_scan( + monkeypatch, +): called = {"scan_genome": False} def fake_scan_genome(*args, **kwargs): called["scan_genome"] = True - raise AssertionError("scan_genome should not be called for invalid clustering config") + raise AssertionError( + "scan_genome should not be called for invalid clustering config" + ) monkeypatch.setattr(workflows.region_discovery, "scan_genome", fake_scan_genome) monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) @@ -335,12 +385,18 @@ def fake_scan_genome(*args, **kwargs): motifs=["A,0"], genome_sizes={"chr1": 1500}, discovery={"window_size": 500, "step_size": 500}, - clustering={"mode": "region_anchored", "clusterer": "agglomerative", "n_clusters": 2}, + clustering={ + "mode": "region_anchored", + "clusterer": "agglomerative", + "n_clusters": 2, + }, ) assert called["scan_genome"] is False -def test_discovery_cluster_workflow_region_anchored_uses_serializable_matched_regions(monkeypatch): +def test_discovery_cluster_workflow_region_anchored_uses_serializable_matched_regions( + monkeypatch, +): captured = {"resolve_params": []} def fake_resolve_artifact(requested_artifact, available_artifacts, artifact_policy): @@ -352,7 +408,9 @@ def fake_region_features(*args, **kwargs): captured["regions"] = regions return _fake_region_anchored_extract(*args, **kwargs) - monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr( + workflows.region_discovery, "scan_genome", _mock_discovery_result + ) monkeypatch.setattr(workflows, "resolve_artifact", fake_resolve_artifact) monkeypatch.setattr( workflows.cluster, @@ -374,10 +432,15 @@ def fake_region_features(*args, **kwargs): ["chr1:0-500,+", "chr1:500-1000,-"], ["chr1:0-500,+", "chr1:500-1000,-"], ] - assert result.clustering.metadata["matched_regions"] == ["chr1:0-500,+", "chr1:500-1000,-"] + assert result.clustering.metadata["matched_regions"] == [ + "chr1:0-500,+", + "chr1:500-1000,-", + ] -def test_discovery_cluster_workflow_artifact_params_keep_matched_regions_json_serializable(monkeypatch): +def test_discovery_cluster_workflow_artifact_params_keep_matched_regions_json_serializable( + monkeypatch, +): captured = {} region_spec = ["chr1:0-500,+", "chr1:500-1000,-"] artifact_samples = [] @@ -403,7 +466,11 @@ def test_discovery_cluster_workflow_artifact_params_keep_matched_regions_json_se "feature_scaling": "robust_zscore", "cluster_basis": "shape_plus_level", }, - provenance={"pipeline": "parse_bam", "source_files": [], "source_fingerprints": []}, + provenance={ + "pipeline": "parse_bam", + "source_files": [], + "source_fingerprints": [], + }, ) ], }, @@ -411,10 +478,14 @@ def test_discovery_cluster_workflow_artifact_params_keep_matched_regions_json_se ) def fake_resolve_artifact(requested_artifact, available_artifacts, artifact_policy): - captured.setdefault("params", []).append(requested_artifact.params["matched_regions"]) + captured.setdefault("params", []).append( + requested_artifact.params["matched_regions"] + ) return available_artifacts[0] - monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr( + workflows.region_discovery, "scan_genome", _mock_discovery_result + ) monkeypatch.setattr(workflows, "resolve_artifact", fake_resolve_artifact) monkeypatch.setattr( workflows.cluster, @@ -432,14 +503,19 @@ def fake_resolve_artifact(requested_artifact, available_artifacts, artifact_poli ) assert captured["params"] == [region_spec, region_spec] - assert result.clustering.metadata["cache_hits"] == {"s1": "s1.bed.gz", "s2": "s2.bed.gz"} + assert result.clustering.metadata["cache_hits"] == { + "s1": "s1.bed.gz", + "s2": "s2.bed.gz", + } def test_discovery_cluster_workflow_materializes_samples_iterable(monkeypatch): captured = {} def fake_discovery(*args, **kwargs): - captured["discovery_sample_ids"] = [sample.sample_id for sample in kwargs["samples"]] + captured["discovery_sample_ids"] = [ + sample.sample_id for sample in kwargs["samples"] + ] return _mock_discovery_result(*args, **kwargs) def fake_cluster(**kwargs): @@ -493,9 +569,13 @@ def fake_cluster(**kwargs): def test_discovery_cluster_contrast_workflow_returns_all_results(monkeypatch): - monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr( + workflows.region_discovery, "scan_genome", _mock_discovery_result + ) monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) - monkeypatch.setattr(workflows.region_contrasts, "score_regions", _mock_region_contrast_result) + monkeypatch.setattr( + workflows.region_contrasts, "score_regions", _mock_region_contrast_result + ) result = workflows.discovery_cluster_contrast_workflow( samples=_workflow_samples(), @@ -517,18 +597,29 @@ def test_discovery_cluster_contrast_workflow_returns_all_results(monkeypatch): assert result.clustering.model.mode == "region_anchored" assert result.contrasts.metadata["test"] == "effect_size_only" assert result.metadata["contrast_scope"] == "selected" - assert list(result.selected_regions.columns) == ["chrom", "start", "end", "name", "score", "strand"] + assert list(result.selected_regions.columns) == [ + "chrom", + "start", + "end", + "name", + "score", + "strand", + ] assert result.metadata["full_scan_windows"].equals(result.discovery.windows) -def test_discovery_cluster_contrast_workflow_scores_selected_regions_by_default(monkeypatch): +def test_discovery_cluster_contrast_workflow_scores_selected_regions_by_default( + monkeypatch, +): captured = {} def fake_score_regions(**kwargs): captured["regions"] = kwargs["regions"] return _mock_region_contrast_result(**kwargs) - monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr( + workflows.region_discovery, "scan_genome", _mock_discovery_result + ) monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) monkeypatch.setattr(workflows.region_contrasts, "score_regions", fake_score_regions) @@ -595,9 +686,13 @@ def fake_cluster(**kwargs): ) return result - monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr( + workflows.region_discovery, "scan_genome", _mock_discovery_result + ) monkeypatch.setattr(workflows, "shared_cluster_distribution", fake_cluster) - monkeypatch.setattr(workflows.region_contrasts, "score_regions", _mock_region_contrast_result) + monkeypatch.setattr( + workflows.region_contrasts, "score_regions", _mock_region_contrast_result + ) result = workflows.discovery_cluster_contrast_workflow( samples=_workflow_samples(), @@ -632,7 +727,9 @@ def fake_score_regions(**kwargs): captured["regions"] = kwargs["regions"] return _mock_region_contrast_result(**kwargs) - monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) + monkeypatch.setattr( + workflows.region_discovery, "scan_genome", _mock_discovery_result + ) monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) monkeypatch.setattr(workflows.region_contrasts, "score_regions", fake_score_regions) @@ -659,10 +756,16 @@ def fake_score_regions(**kwargs): assert result.selected_regions["name"].tolist() == ["chr1:0-500", "chr1:500-1000"] -def test_discovery_cluster_contrast_workflow_preserves_full_scan_windows_context(monkeypatch): - monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) +def test_discovery_cluster_contrast_workflow_preserves_full_scan_windows_context( + monkeypatch, +): + monkeypatch.setattr( + workflows.region_discovery, "scan_genome", _mock_discovery_result + ) monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) - monkeypatch.setattr(workflows.region_contrasts, "score_regions", _mock_region_contrast_result) + monkeypatch.setattr( + workflows.region_contrasts, "score_regions", _mock_region_contrast_result + ) result = workflows.discovery_cluster_contrast_workflow( samples=_workflow_samples(), @@ -682,8 +785,12 @@ def test_discovery_cluster_contrast_workflow_preserves_full_scan_windows_context assert result.metadata["full_scan_windows"].equals(result.discovery.windows) -def test_discovery_cluster_contrast_workflow_rejects_missing_contrast_config(monkeypatch): - monkeypatch.setattr(workflows.region_discovery, "scan_genome", _mock_discovery_result) +def test_discovery_cluster_contrast_workflow_rejects_missing_contrast_config( + monkeypatch, +): + monkeypatch.setattr( + workflows.region_discovery, "scan_genome", _mock_discovery_result + ) monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) with pytest.raises(ValueError, match=r"requires contrasts\['contrast'\]"): @@ -704,7 +811,9 @@ def test_discovery_cluster_contrast_workflow_fast_fails_invalid_contrast_config_ def fake_scan_genome(*args, **kwargs): called["scan_genome"] = True - raise AssertionError("scan_genome should not be called for invalid contrast config") + raise AssertionError( + "scan_genome should not be called for invalid contrast config" + ) monkeypatch.setattr(workflows.region_discovery, "scan_genome", fake_scan_genome) monkeypatch.setattr(workflows, "shared_cluster_distribution", _mock_cluster_result) @@ -742,14 +851,34 @@ class R: if hdf5_file == "s1.h5": data_matrix = np.array([[0.0, 0.0, 0.1, 0.1], [0.0, 0.1, 0.0, 0.1]]) metadata = [ - {"read_name": "s1-r1", "chromosome": "chr1", "region_start": 0, "region_end": 4}, - {"read_name": "s1-r2", "chromosome": "chr1", "region_start": 10, "region_end": 14}, + { + "read_name": "s1-r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + }, + { + "read_name": "s1-r2", + "chromosome": "chr1", + "region_start": 10, + "region_end": 14, + }, ] else: data_matrix = np.array([[1.0, 0.9, 1.0, 0.9], [0.9, 1.0, 0.9, 1.0]]) metadata = [ - {"read_name": "s2-r1", "chromosome": "chr1", "region_start": 20, "region_end": 24}, - {"read_name": "s2-r2", "chromosome": "chr1", "region_start": 30, "region_end": 34}, + { + "read_name": "s2-r1", + "chromosome": "chr1", + "region_start": 20, + "region_end": 24, + }, + { + "read_name": "s2-r2", + "chromosome": "chr1", + "region_start": 30, + "region_end": 34, + }, ] val_matrix = np.ones((2, 4), dtype=float) datasets = [] @@ -853,9 +982,14 @@ class R: ) assert result.region_summaries is not None - assert {"region_id", "sample_id", "condition", "cluster", "count", "fraction"} <= set( - result.region_summaries.columns - ) + assert { + "region_id", + "sample_id", + "condition", + "cluster", + "count", + "fraction", + } <= set(result.region_summaries.columns) assert set(result.region_summaries["sample_id"]) == {"s1", "s2"} assert set(result.region_summaries["condition"]) == {"NS", "15min"} @@ -897,7 +1031,9 @@ class R: assert result.region_summaries is None -def test_shared_cluster_distribution_read_global_prefers_cluster_summarizer(monkeypatch): +def test_shared_cluster_distribution_read_global_prefers_cluster_summarizer( + monkeypatch, +): fake_samples = [ SampleSpec(sample_id="s1", condition="NS", extract_h5="s1.h5"), SampleSpec(sample_id="s2", condition="15min", extract_h5="s2.h5"), @@ -1041,14 +1177,34 @@ class R: if hdf5_file == "s1.h5": data_matrix = np.array([[0.0, 0.0, 0.1, 0.1], [0.0, 0.1, 0.0, 0.1]]) metadata = [ - {"read_name": "s1-r1", "chromosome": "chr1", "region_start": 0, "region_end": 4}, - {"read_name": "s1-r2", "chromosome": "chr1", "region_start": 10, "region_end": 14}, + { + "read_name": "s1-r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + }, + { + "read_name": "s1-r2", + "chromosome": "chr1", + "region_start": 10, + "region_end": 14, + }, ] else: data_matrix = np.array([[1.0, 0.9, 1.0, 0.9], [0.9, 1.0, 0.9, 1.0]]) metadata = [ - {"read_name": "s2-r1", "chromosome": "chr1", "region_start": 20, "region_end": 24}, - {"read_name": "s2-r2", "chromosome": "chr1", "region_start": 30, "region_end": 34}, + { + "read_name": "s2-r1", + "chromosome": "chr1", + "region_start": 20, + "region_end": 24, + }, + { + "read_name": "s2-r2", + "chromosome": "chr1", + "region_start": 30, + "region_end": 34, + }, ] val_matrix = np.ones((2, 4), dtype=float) datasets = [] @@ -1175,7 +1331,9 @@ def fake_region_table(*args, **kwargs): }, ] - monkeypatch.setattr(workflows.region_analysis, "build_region_feature_table", fake_region_table) + monkeypatch.setattr( + workflows.region_analysis, "build_region_feature_table", fake_region_table + ) result = workflows.shared_cluster_distribution( samples=fake_samples, @@ -1275,7 +1433,9 @@ def fake_region_table(*args, **kwargs): }, ] - monkeypatch.setattr(workflows.region_analysis, "build_region_feature_table", fake_region_table) + monkeypatch.setattr( + workflows.region_analysis, "build_region_feature_table", fake_region_table + ) result = workflows.shared_cluster_distribution( samples=fake_samples, @@ -1289,9 +1449,14 @@ def fake_region_table(*args, **kwargs): assert not result.assignments.empty assert "region_id" in result.assignments.columns assert result.region_summaries is not None - assert {"region_id", "sample_id", "condition", "cluster", "count", "fraction"} <= set( - result.region_summaries.columns - ) + assert { + "region_id", + "sample_id", + "condition", + "cluster", + "count", + "fraction", + } <= set(result.region_summaries.columns) def test_shared_cluster_region_data_region_anchored_region_summaries_feed_region_plotting( @@ -1338,7 +1503,9 @@ def fake_region_table(*args, **kwargs): }, ] - monkeypatch.setattr(workflows.region_analysis, "build_region_feature_table", fake_region_table) + monkeypatch.setattr( + workflows.region_analysis, "build_region_feature_table", fake_region_table + ) result = workflows.shared_cluster_distribution( samples=fake_samples, @@ -1380,7 +1547,9 @@ def test_shared_cluster_distribution_region_anchored_requires_matched_regions(): ) -def test_shared_cluster_distribution_region_anchored_accepts_list_matched_regions(monkeypatch): +def test_shared_cluster_distribution_region_anchored_accepts_list_matched_regions( + monkeypatch, +): captured = {} def fake_region_table(*args, **kwargs): @@ -1408,7 +1577,9 @@ def fake_region_table(*args, **kwargs): }, ] - monkeypatch.setattr(workflows.region_analysis, "build_region_feature_table", fake_region_table) + monkeypatch.setattr( + workflows.region_analysis, "build_region_feature_table", fake_region_table + ) result = workflows.shared_cluster_distribution( samples=_workflow_samples(), @@ -1443,8 +1614,18 @@ class R: data_matrix = data val_matrix = np.ones_like(data) metadata = [ - {"read_name": f"{kwargs['hdf5_file']}-r1", "chromosome": "chr1", "region_start": 0, "region_end": 2}, - {"read_name": f"{kwargs['hdf5_file']}-r2", "chromosome": "chr1", "region_start": 2, "region_end": 4}, + { + "read_name": f"{kwargs['hdf5_file']}-r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 2, + }, + { + "read_name": f"{kwargs['hdf5_file']}-r2", + "chromosome": "chr1", + "region_start": 2, + "region_end": 4, + }, ] datasets = [] regions_dict = None @@ -1466,7 +1647,9 @@ class R: training_sample_per_dataset=2, ) - ns_rows = result.condition_distribution[result.condition_distribution["condition"] == "NS"] + ns_rows = result.condition_distribution[ + result.condition_distribution["condition"] == "NS" + ] assert set(ns_rows["replicate_n"]) == {2} @@ -1566,7 +1749,9 @@ def fake_region_table(*args, **kwargs): } ] - monkeypatch.setattr(workflows.region_analysis, "build_region_feature_table", fake_region_table) + monkeypatch.setattr( + workflows.region_analysis, "build_region_feature_table", fake_region_table + ) result = workflows.shared_cluster_distribution( samples=fake_samples, @@ -1621,8 +1806,18 @@ class R: data_matrix = np.array([[0.0, 0.0], [1.0, 1.0]]) val_matrix = np.ones((2, 2), dtype=float) metadata = [ - {"read_name": "r1", "chromosome": "chr1", "region_start": 0, "region_end": 2}, - {"read_name": "r2", "chromosome": "chr1", "region_start": 2, "region_end": 4}, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 2, + }, + { + "read_name": "r2", + "chromosome": "chr1", + "region_start": 2, + "region_end": 4, + }, ] datasets = [] regions_dict = None @@ -1648,7 +1843,9 @@ class R: assert result.metadata["cache_hits"]["s1"] == "cached-s1.h5" -def test_shared_cluster_distribution_rebuilds_when_source_fingerprint_mismatches(monkeypatch): +def test_shared_cluster_distribution_rebuilds_when_source_fingerprint_mismatches( + monkeypatch, +): stale_artifact = DatasetArtifact( sample_id="s1", artifact_type="extract", @@ -1688,8 +1885,18 @@ class R: data_matrix = np.array([[0.0, 0.0], [1.0, 1.0]]) val_matrix = np.ones((2, 2), dtype=float) metadata = [ - {"read_name": "r1", "chromosome": "chr1", "region_start": 0, "region_end": 2}, - {"read_name": "r2", "chromosome": "chr1", "region_start": 2, "region_end": 4}, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 2, + }, + { + "read_name": "r2", + "chromosome": "chr1", + "region_start": 2, + "region_end": 4, + }, ] datasets = [] regions_dict = None @@ -1774,7 +1981,15 @@ def test_chip_atlas_cluster_enrichment_workflow_per_cluster(monkeypatch): ] ), cluster_distribution=pd.DataFrame( - [{"sample_id": "s1", "condition": "NS", "cluster": "C0", "count": 1, "fraction": 1.0}] + [ + { + "sample_id": "s1", + "condition": "NS", + "cluster": "C0", + "count": 1, + "fraction": 1.0, + } + ] ), condition_distribution=pd.DataFrame( [{"condition": "NS", "cluster": "C0", "fraction": 1.0, "replicate_n": 1}] @@ -1795,7 +2010,9 @@ def fake_chip_atlas_workflow(*, regions, **kwargs): results=pd.DataFrame({"target": ["CTCF"]}), ) - monkeypatch.setattr(workflows, "chip_atlas_enrichment_workflow", fake_chip_atlas_workflow) + monkeypatch.setattr( + workflows, "chip_atlas_enrichment_workflow", fake_chip_atlas_workflow + ) results = workflows.chip_atlas_cluster_enrichment_workflow( cluster_result=cluster_result, @@ -1807,7 +2024,9 @@ def fake_chip_atlas_workflow(*, regions, **kwargs): assert set(results.keys()) == {"C0", "C1"} assert len(called) == 2 assert all(frame.shape[0] >= 1 for frame in called) - assert all({"chrom", "start", "end", "strand"}.issubset(frame.columns) for frame in called) + assert all( + {"chrom", "start", "end", "strand"}.issubset(frame.columns) for frame in called + ) def test_chip_atlas_search_peak_datasets_workflow_forwards(monkeypatch): @@ -1815,7 +2034,9 @@ def test_chip_atlas_search_peak_datasets_workflow_forwards(monkeypatch): def fake_search(**kwargs): captured.update(kwargs) - return pd.DataFrame([{"dataset_id": "SRX1", "bed_url": "http://example.org/srx1.bed"}]) + return pd.DataFrame( + [{"dataset_id": "SRX1", "bed_url": "http://example.org/srx1.bed"}] + ) monkeypatch.setattr(workflows.chip_atlas, "search_peak_datasets", fake_search) out = workflows.chip_atlas_search_peak_datasets_workflow( @@ -1837,7 +2058,15 @@ def fake_download(**kwargs): return pd.DataFrame([{"dataset_id": "SRX1", "variant": "top_3000"}]) monkeypatch.setattr(workflows.chip_atlas, "download_peak_datasets", fake_download) - datasets = pd.DataFrame([{"dataset_id": "SRX1", "bed_url": "http://example.org/srx1.bed", "genome_assembly": "hg38"}]) + datasets = pd.DataFrame( + [ + { + "dataset_id": "SRX1", + "bed_url": "http://example.org/srx1.bed", + "genome_assembly": "hg38", + } + ] + ) out = workflows.chip_atlas_download_peak_datasets_workflow( datasets=datasets, dataset_ids=["SRX1"], diff --git a/tutorial.ipynb b/tutorial.ipynb index 554a39a..f859036 100644 --- a/tutorial.ipynb +++ b/tutorial.ipynb @@ -20,21 +20,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "You don't seem to be running on Google Colab so this cell is not going to be useful for you.\n", - "Make sure you are running you notebook in a conda environment set up as per README.md.\n", - "Once you have this notebook running in a correctly configured environment, proceed to the rest of the cells.\n", - " \n" - ] - } - ], + "outputs": [], "source": [ "# Lets Colab access your Google drive\n", "try:\n", @@ -52,12 +40,12 @@ " import condacolab\n", " condacolab.install()\n", " # Install modkit\n", - " !conda install nanoporetech::modkit==0.2.4\n", + " !conda install nanoporetech::modkit==0.6.1\n", " # Clone the repo, change the active path to be inside the repo, and install the package\n", - " !rm -r dimelo\n", - " !git clone https://github.com/streetslab/dimelo\n", + " !rm -rf dimelo-toolkit\n", + " !git clone https://github.com/streetslab/dimelo-toolkit\n", " import os\n", - " os.chdir('dimelo')\n", + " os.chdir('dimelo-toolkit')\n", " !pip install ipywidgets==7.7.1 .\n" ] }, @@ -78,7 +66,7 @@ " from google.colab import drive\n", " drive.mount('/content/drive')\n", " import os\n", - " os.chdir('dimelo') \n", + " os.chdir('dimelo-toolkit') \n", "except:\n", " pass" ] @@ -106,156 +94,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "# packages in environment at /opt/anaconda3/envs/dimelo:\n", - "#\n", - "# Name Version Build Channel\n", - "anyio 4.9.0 pypi_0 pypi\n", - "appnope 0.1.4 pypi_0 pypi\n", - "argon2-cffi 25.1.0 pypi_0 pypi\n", - "argon2-cffi-bindings 21.2.0 pypi_0 pypi\n", - "arrow 1.3.0 pypi_0 pypi\n", - "asttokens 3.0.0 pypi_0 pypi\n", - "async-lru 2.0.5 pypi_0 pypi\n", - "attrs 25.3.0 pypi_0 pypi\n", - "babel 2.17.0 pypi_0 pypi\n", - "beautifulsoup4 4.13.4 pypi_0 pypi\n", - "bleach 6.2.0 pypi_0 pypi\n", - "bzip2 1.0.8 h99b78c6_7 conda-forge\n", - "ca-certificates 2025.4.26 hbd8a1cb_0 conda-forge\n", - "certifi 2025.4.26 pypi_0 pypi\n", - "cffi 1.17.1 pypi_0 pypi\n", - "charset-normalizer 3.4.2 pypi_0 pypi\n", - "comm 0.2.2 pypi_0 pypi\n", - "contourpy 1.3.2 pypi_0 pypi\n", - "cycler 0.12.1 pypi_0 pypi\n", - "debugpy 1.8.14 pypi_0 pypi\n", - "decorator 5.2.1 pypi_0 pypi\n", - "defusedxml 0.7.1 pypi_0 pypi\n", - "dimelo 1.0.0 pypi_0 pypi\n", - "executing 2.2.0 pypi_0 pypi\n", - "fastjsonschema 2.21.1 pypi_0 pypi\n", - "fonttools 4.58.1 pypi_0 pypi\n", - "fqdn 1.5.1 pypi_0 pypi\n", - "h11 0.16.0 pypi_0 pypi\n", - "h5py 3.13.0 pypi_0 pypi\n", - "httpcore 1.0.9 pypi_0 pypi\n", - "httpx 0.28.1 pypi_0 pypi\n", - "idna 3.10 pypi_0 pypi\n", - "ipykernel 6.29.5 pypi_0 pypi\n", - "ipython 9.3.0 pypi_0 pypi\n", - "ipython-pygments-lexers 1.1.1 pypi_0 pypi\n", - "ipywidgets 8.1.7 pypi_0 pypi\n", - "isoduration 20.11.0 pypi_0 pypi\n", - "jedi 0.19.2 pypi_0 pypi\n", - "jinja2 3.1.6 pypi_0 pypi\n", - "json5 0.12.0 pypi_0 pypi\n", - "jsonpointer 3.0.0 pypi_0 pypi\n", - "jsonschema 4.24.0 pypi_0 pypi\n", - "jsonschema-specifications 2025.4.1 pypi_0 pypi\n", - "jupyter-client 8.6.3 pypi_0 pypi\n", - "jupyter-core 5.8.1 pypi_0 pypi\n", - "jupyter-events 0.12.0 pypi_0 pypi\n", - "jupyter-lsp 2.2.5 pypi_0 pypi\n", - "jupyter-server 2.16.0 pypi_0 pypi\n", - "jupyter-server-terminals 0.5.3 pypi_0 pypi\n", - "jupyterlab 4.4.3 pypi_0 pypi\n", - "jupyterlab-pygments 0.3.0 pypi_0 pypi\n", - "jupyterlab-server 2.27.3 pypi_0 pypi\n", - "jupyterlab-widgets 3.0.15 pypi_0 pypi\n", - "kaleido 0.2.1 pypi_0 pypi\n", - "kiwisolver 1.4.8 pypi_0 pypi\n", - "libcxx 20.1.6 ha82da77_0 conda-forge\n", - "libexpat 2.7.0 h286801f_0 conda-forge\n", - "libffi 3.4.6 h1da3d7d_1 conda-forge\n", - "liblzma 5.8.1 h39f12f2_1 conda-forge\n", - "liblzma-devel 5.8.1 h39f12f2_1 conda-forge\n", - "libsqlite 3.46.0 hfb93653_0 conda-forge\n", - "libzlib 1.2.13 hfb2fe0b_6 conda-forge\n", - "markupsafe 3.0.2 pypi_0 pypi\n", - "matplotlib 3.10.3 pypi_0 pypi\n", - "matplotlib-inline 0.1.7 pypi_0 pypi\n", - "mistune 3.1.3 pypi_0 pypi\n", - "modkit 0.2.4 h70deae4_1 nanoporetech\n", - "narwhals 1.41.0 pypi_0 pypi\n", - "nbclient 0.10.2 pypi_0 pypi\n", - "nbconvert 7.16.6 pypi_0 pypi\n", - "nbformat 5.10.4 pypi_0 pypi\n", - "ncurses 6.5 h5e97a16_3 conda-forge\n", - "nest-asyncio 1.6.0 pypi_0 pypi\n", - "notebook 7.4.3 pypi_0 pypi\n", - "notebook-shim 0.2.4 pypi_0 pypi\n", - "numpy 2.2.6 pypi_0 pypi\n", - "openssl 3.5.0 h81ee809_1 conda-forge\n", - "overrides 7.7.0 pypi_0 pypi\n", - "packaging 25.0 pypi_0 pypi\n", - "pandas 2.3.0 pypi_0 pypi\n", - "pandocfilters 1.5.1 pypi_0 pypi\n", - "parso 0.8.4 pypi_0 pypi\n", - "pexpect 4.9.0 pypi_0 pypi\n", - "pillow 11.2.1 pypi_0 pypi\n", - "pip 25.1.1 pyh8b19718_0 conda-forge\n", - "platformdirs 4.3.8 pypi_0 pypi\n", - "plotly 6.1.2 pypi_0 pypi\n", - "prometheus-client 0.22.1 pypi_0 pypi\n", - "prompt-toolkit 3.0.51 pypi_0 pypi\n", - "psutil 7.0.0 pypi_0 pypi\n", - "ptyprocess 0.7.0 pypi_0 pypi\n", - "pure-eval 0.2.3 pypi_0 pypi\n", - "pybigwig 0.3.24 pypi_0 pypi\n", - "pycparser 2.22 pypi_0 pypi\n", - "pygments 2.19.1 pypi_0 pypi\n", - "pyparsing 3.2.3 pypi_0 pypi\n", - "pysam 0.23.1 pypi_0 pypi\n", - "python 3.11.9 h932a869_0_cpython conda-forge\n", - "python-dateutil 2.9.0.post0 pypi_0 pypi\n", - "python-json-logger 3.3.0 pypi_0 pypi\n", - "pytz 2025.2 pypi_0 pypi\n", - "pyyaml 6.0.2 pypi_0 pypi\n", - "pyzmq 26.4.0 pypi_0 pypi\n", - "readline 8.2 h1d1bf99_2 conda-forge\n", - "referencing 0.36.2 pypi_0 pypi\n", - "requests 2.32.3 pypi_0 pypi\n", - "rfc3339-validator 0.1.4 pypi_0 pypi\n", - "rfc3986-validator 0.1.1 pypi_0 pypi\n", - "rpds-py 0.25.1 pypi_0 pypi\n", - "seaborn 0.13.2 pypi_0 pypi\n", - "send2trash 1.8.3 pypi_0 pypi\n", - "setuptools 80.9.0 pyhff2d567_0 conda-forge\n", - "six 1.17.0 pypi_0 pypi\n", - "sniffio 1.3.1 pypi_0 pypi\n", - "soupsieve 2.7 pypi_0 pypi\n", - "stack-data 0.6.3 pypi_0 pypi\n", - "terminado 0.18.1 pypi_0 pypi\n", - "tinycss2 1.4.0 pypi_0 pypi\n", - "tk 8.6.13 h5083fa2_1 conda-forge\n", - "tornado 6.5.1 pypi_0 pypi\n", - "tqdm 4.67.1 pypi_0 pypi\n", - "traitlets 5.14.3 pypi_0 pypi\n", - "types-python-dateutil 2.9.0.20250516 pypi_0 pypi\n", - "typing-extensions 4.14.0 pypi_0 pypi\n", - "tzdata 2025.2 pypi_0 pypi\n", - "uri-template 1.3.0 pypi_0 pypi\n", - "urllib3 2.4.0 pypi_0 pypi\n", - "wcwidth 0.2.13 pypi_0 pypi\n", - "webcolors 24.11.1 pypi_0 pypi\n", - "webencodings 0.5.1 pypi_0 pypi\n", - "websocket-client 1.8.0 pypi_0 pypi\n", - "wheel 0.45.1 pyhd8ed1ab_1 conda-forge\n", - "widgetsnbextension 4.0.14 pypi_0 pypi\n", - "xz 5.8.1 h9a6d368_1 conda-forge\n", - "xz-gpl-tools 5.8.1 h9a6d368_1 conda-forge\n", - "xz-tools 5.8.1 h39f12f2_1 conda-forge\n", - "zlib 1.2.13 hfb2fe0b_6 conda-forge\n" - ] - } - ], + "outputs": [], "source": [ "!conda list" ] From 6c95d9b86bf80d2b3ae7d177a9be21faacbcf843 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 29 Apr 2026 12:15:27 -0700 Subject: [PATCH 270/272] Refactor multisite raster selection --- README.md | 37 +- dimelo/cluster.py | 1036 +++++-- dimelo_test.ipynb | 2750 +++++++++++++++-- .../hdf5_openzl_compression_benchmark.py | 4 +- tests/test_cluster.py | 409 ++- 5 files changed, 3633 insertions(+), 603 deletions(-) diff --git a/README.md b/README.md index a7ffece..4bac90f 100644 --- a/README.md +++ b/README.md @@ -1043,13 +1043,40 @@ cluster.export_region_clusters_to_bed(region_info, labels, "region_clusters.bed" cluster.plot_cluster_karyotype("region_clusters.bed", "ref.fasta.fai") # If pileup_matrix concatenates multiple motifs, pass motif_index to select which slice to visualize. -# Multi-site read raster (paired windows) for exploratory QC +# Strict two-site fixed-offset raster: window 1 is centered at 0 and window 2 +# is centered at the requested distance along the same reads. +# fig, stats = cluster.plot_two_site_read_raster( +# read_windows, +# second_site_offset_bp=2000, +# window_width_bp=2000, +# motif_count=2, +# plot_all_motifs=True, +# max_rows=500, +# downsample_method="auto", +# downsample_seed=42, +# ) + +# Co-occurring multi-site raster: pick one site-set per read from all candidate +# regions on the read. Each panel can use its own local coordinate system. # fig, stats = cluster.plot_multisite_read_raster( # read_windows, -# n_windows=2, -# min_separation_bp=5000, -# motif_index=0, -# smoothing="gaussian", +# site_selection={ +# "mode": "cooccurring", +# "n_windows": 2, +# "min_distance_bp": "window_width", +# "max_distance_bp": None, +# "choose": "first", # or "random", "longest_span", "shortest_span" +# "selection_seed": 42, +# "strand_relation": "any", # or "same", "opposite" +# "orientation": "genomic", # or "anchor_strand" +# }, +# coordinate_mode="local_window", +# window_widths_bp=[2000, 2000], +# motif_count=2, +# plot_all_motifs=True, +# ml_score_thresholds=[0.65, 0.50], +# downsample_method="random", +# downsample_seed=42, # ) # Binary classification of read features across two samples diff --git a/dimelo/cluster.py b/dimelo/cluster.py index 02e1752..e720b72 100644 --- a/dimelo/cluster.py +++ b/dimelo/cluster.py @@ -7,6 +7,7 @@ from collections.abc import Sequence from dataclasses import dataclass from functools import partial +from itertools import combinations from pathlib import Path from typing import Any @@ -80,6 +81,41 @@ class ReadWindowExtractionResult: regions_dict: dict | None +@dataclass(frozen=True) +class _RasterSiteSelection: + mode: str + n_windows: int + min_distance_bp: int + max_distance_bp: int | None + selection_multiplicity: str + choose: str + selection_seed: int | None + anchor: dict[str, Any] + strand_relation: str + exclude: dict[str, Any] | None + orientation: str + window_offsets_bp: tuple[int, ...] | None + primary_window_index: int + + +@dataclass(frozen=True) +class _RasterSiteCandidate: + row_idx: int + center_bp: float + chrom: str | None + start_bp: int | None + end_bp: int | None + strand: str | None + read_key: tuple[Any, Any] + + +@dataclass +class _RasterSiteSelectionResult: + window_indices: list[np.ndarray] + panel_centers: list[np.ndarray] + stats: dict[str, Any] + + @dataclass class ClusterResult: labels_raw: np.ndarray @@ -694,6 +730,450 @@ def _resolve_motif_slices( return n_motifs, slice_width +def _resolve_raster_site_selection( + site_selection: dict[str, Any] | None, + *, + selection_mode: str, + window_offsets_bp: Sequence[int] | None, + n_windows: int, + min_separation_bp: int, + primary_window_index: int, + panel_widths_bp: Sequence[int], +) -> _RasterSiteSelection: + spec = dict(site_selection or {}) + mode_aliases = { + "cooccurring_regions": "cooccurring", + "cooccurring": "cooccurring", + "fixed_offsets": "fixed_offsets", + "anchor_plus_neighbors": "anchor_plus_neighbors", + } + mode_raw = spec.get("mode", selection_mode) + if mode_raw not in mode_aliases: + raise ValueError( + "site_selection mode must be 'cooccurring', 'fixed_offsets', or 'anchor_plus_neighbors'." + ) + mode = mode_aliases[str(mode_raw)] + + offsets_value = spec.get("window_offsets_bp", window_offsets_bp) + offsets = None + if offsets_value is not None: + offsets = tuple(int(value) for value in offsets_value) + if not offsets: + raise ValueError("window_offsets_bp must contain at least one offset.") + + if mode == "fixed_offsets": + if offsets is None: + raise ValueError( + "window_offsets_bp is required for fixed_offsets site selection." + ) + n_windows_effective = len(offsets) + else: + if offsets is not None: + raise ValueError( + "window_offsets_bp is only valid for fixed_offsets site selection." + ) + n_windows_effective = int(spec.get("n_windows", n_windows)) + if n_windows_effective < 1: + raise ValueError("site_selection n_windows must be >= 1.") + + primary_index = int(spec.get("primary_window_index", primary_window_index)) + if primary_index < 0 or primary_index >= n_windows_effective: + raise ValueError( + f"primary_window_index {primary_index} out of range for {n_windows_effective} windows." + ) + + default_min_distance: int | str = ( + "window_width" if site_selection is not None else min_separation_bp + ) + min_distance_value = spec.get("min_distance_bp", default_min_distance) + if min_distance_value == "window_width": + min_distance = int(max(panel_widths_bp)) + else: + min_distance = int(min_distance_value) + if min_distance < 0: + raise ValueError("site_selection min_distance_bp must be >= 0.") + + max_distance_value = spec.get("max_distance_bp") + max_distance = None if max_distance_value is None else int(max_distance_value) + if max_distance is not None and max_distance < min_distance: + raise ValueError("site_selection max_distance_bp must be >= min_distance_bp.") + + multiplicity = str(spec.get("selection_multiplicity", "one_per_read")) + if multiplicity == "all_valid_sets": + raise NotImplementedError( + "site_selection selection_multiplicity='all_valid_sets' is not implemented yet; use 'one_per_read'." + ) + if multiplicity != "one_per_read": + raise ValueError( + "site_selection selection_multiplicity must be 'one_per_read' or 'all_valid_sets'." + ) + + choose = str(spec.get("choose", "first")) + if choose not in {"first", "random", "longest_span", "shortest_span"}: + raise ValueError( + "site_selection choose must be 'first', 'random', 'longest_span', or 'shortest_span'." + ) + + anchor = dict(spec.get("anchor", {"mode": "first"}) or {"mode": "first"}) + anchor_mode = str(anchor.get("mode", "first")) + if anchor_mode not in {"first", "random", "index"}: + raise ValueError("site_selection anchor mode must be 'first', 'random', or 'index'.") + + strand_relation = str(spec.get("strand_relation", "any")) + if strand_relation not in {"any", "same", "opposite"}: + raise ValueError("site_selection strand_relation must be 'any', 'same', or 'opposite'.") + + orientation = str(spec.get("orientation", "genomic")) + if orientation not in {"genomic", "anchor_strand"}: + raise ValueError("site_selection orientation must be 'genomic' or 'anchor_strand'.") + + exclude = spec.get("exclude") + exclude_dict = dict(exclude) if exclude is not None else None + selection_seed = spec.get("selection_seed") + + return _RasterSiteSelection( + mode=mode, + n_windows=n_windows_effective, + min_distance_bp=min_distance, + max_distance_bp=max_distance, + selection_multiplicity=multiplicity, + choose=choose, + selection_seed=None if selection_seed is None else int(selection_seed), + anchor=anchor, + strand_relation=strand_relation, + exclude=exclude_dict, + orientation=orientation, + window_offsets_bp=offsets, + primary_window_index=primary_index, + ) + + +def _metadata_center_bp(meta_row: dict[str, Any], distance_mode: str) -> float: + if distance_mode == "center": + return float((int(meta_row.get("region_start", 0)) + int(meta_row.get("region_end", 0))) // 2) + return float(int(meta_row.get("read_start", 0))) + + +def _metadata_interval(meta_row: dict[str, Any]) -> tuple[str | None, int | None, int | None]: + chrom = meta_row.get("chromosome") + try: + start = int(meta_row.get("region_start")) + end = int(meta_row.get("region_end")) + except Exception: + return chrom, None, None + return chrom, start, end + + +def _interval_overlaps_any( + chrom: str | None, + start: int | None, + end: int | None, + regions_dict: dict[str, list[tuple[int, int, str]]], +) -> bool: + if chrom is None or start is None or end is None: + return False + for region_start, region_end, _ in regions_dict.get(str(chrom), []): + if max(start, int(region_start)) < min(end, int(region_end)): + return True + return False + + +def _build_raster_site_candidates( + meta: Sequence[dict[str, Any]], + *, + original_indices: np.ndarray, + selector: _RasterSiteSelection, + distance_mode: str, +) -> tuple[list[_RasterSiteCandidate], int]: + excluded_original_rows = set() + excluded_regions = None + if selector.exclude: + excluded_original_rows = { + int(value) for value in selector.exclude.get("row_indices", []) or [] + } + regions = selector.exclude.get("regions") + if regions is not None: + excluded_regions = utils.regions_dict_from_input(regions, window_size=None) + + candidates: list[_RasterSiteCandidate] = [] + excluded_count = 0 + for row_idx, meta_row in enumerate(meta): + original_idx = int(original_indices[row_idx]) + chrom, start, end = _metadata_interval(meta_row) + if original_idx in excluded_original_rows or ( + excluded_regions is not None + and _interval_overlaps_any(chrom, start, end, excluded_regions) + ): + excluded_count += 1 + continue + candidates.append( + _RasterSiteCandidate( + row_idx=row_idx, + center_bp=_metadata_center_bp(meta_row, distance_mode), + chrom=str(chrom) if chrom is not None else None, + start_bp=start, + end_bp=end, + strand=_coerce_strand(meta_row.get("region_strand")), + read_key=(meta_row.get("read_name"), meta_row.get("chromosome")), + ) + ) + return candidates, excluded_count + + +def _strand_relation_ok( + selected: Sequence[_RasterSiteCandidate], + selector: _RasterSiteSelection, +) -> bool: + if selector.strand_relation == "any": + return True + strands = [candidate.strand for candidate in selected] + if any(strand not in {"+", "-"} for strand in strands): + raise ValueError( + "site_selection strand_relation requires '+'/'-' region_strand metadata for all selected sites." + ) + if selector.strand_relation == "same": + return len(set(strands)) == 1 + anchor_strand = strands[selector.primary_window_index] + if len(strands) == 2: + return strands[0] != strands[1] + return any(strand != anchor_strand for strand in strands) + + +def _distances_ok( + selected: Sequence[_RasterSiteCandidate], + selector: _RasterSiteSelection, +) -> bool: + centers = [candidate.center_bp for candidate in selected] + if len(centers) < 2: + return True + for left, right in zip(centers, centers[1:], strict=False): + distance = abs(float(right) - float(left)) + if distance < selector.min_distance_bp: + return False + if selector.max_distance_bp is not None and distance > selector.max_distance_bp: + return False + return True + + +def _apply_anchor_orientation( + selected: Sequence[_RasterSiteCandidate], + selector: _RasterSiteSelection, +) -> list[_RasterSiteCandidate]: + ordered = list(selected) + if ( + selector.orientation == "anchor_strand" + and ordered + and ordered[selector.primary_window_index].strand == "-" + ): + ordered = list(reversed(ordered)) + return ordered + + +def _fixed_offset_sets( + items: Sequence[_RasterSiteCandidate], + selector: _RasterSiteSelection, +) -> list[list[_RasterSiteCandidate]]: + assert selector.window_offsets_bp is not None + out: list[list[_RasterSiteCandidate]] = [] + by_center: defaultdict[float, list[_RasterSiteCandidate]] = defaultdict(list) + for item in items: + by_center[item.center_bp].append(item) + for anchor in items: + selected: list[_RasterSiteCandidate] = [] + used: set[int] = set() + for offset in selector.window_offsets_bp: + matches = by_center.get(anchor.center_bp + float(offset), []) + chosen = next((candidate for candidate in matches if candidate.row_idx not in used), None) + if chosen is None: + selected = [] + break + selected.append(chosen) + used.add(chosen.row_idx) + if selected and _strand_relation_ok(selected, selector): + out.append(_apply_anchor_orientation(selected, selector)) + return out + + +def _anchor_position( + items: Sequence[_RasterSiteCandidate], + selector: _RasterSiteSelection, + rng: np.random.Generator, +) -> int: + mode = str(selector.anchor.get("mode", "first")) + if mode == "first": + return 0 + if mode == "random": + return int(rng.integers(0, len(items))) + index = int(selector.anchor.get("index", 0)) + if index < 0 or index >= len(items): + raise ValueError("site_selection anchor index is out of range for a read.") + return index + + +def _cooccurring_sets( + items: Sequence[_RasterSiteCandidate], + selector: _RasterSiteSelection, + rng: np.random.Generator, +) -> list[list[_RasterSiteCandidate]]: + out: list[list[_RasterSiteCandidate]] = [] + ordered_items = list(items) + if selector.mode == "anchor_plus_neighbors": + anchor_pos = _anchor_position(ordered_items, selector, rng) + anchor = ordered_items[anchor_pos] + combos_source = [ + [anchor, *combo] + for combo in combinations( + [item for idx, item in enumerate(ordered_items) if idx != anchor_pos], + max(0, selector.n_windows - 1), + ) + ] + else: + combos_source = combinations(ordered_items, selector.n_windows) + + for combo in combos_source: + selected = sorted(combo, key=lambda candidate: candidate.center_bp) + if not _distances_ok(selected, selector): + continue + if not _strand_relation_ok(selected, selector): + continue + out.append(_apply_anchor_orientation(selected, selector)) + return out + + +def _choose_site_set( + valid_sets: Sequence[list[_RasterSiteCandidate]], + selector: _RasterSiteSelection, + rng: np.random.Generator, +) -> list[_RasterSiteCandidate] | None: + if not valid_sets: + return None + if selector.choose == "first": + return list(valid_sets[0]) + if selector.choose == "random": + return list(valid_sets[int(rng.integers(0, len(valid_sets)))]) + + def span(site_set: Sequence[_RasterSiteCandidate]) -> float: + centers = [candidate.center_bp for candidate in site_set] + return float(max(centers) - min(centers)) + + if selector.choose == "longest_span": + return list(max(valid_sets, key=span)) + return list(min(valid_sets, key=span)) + + +def _summarize_observed_offsets( + observed_offsets: Sequence[Sequence[float]], +) -> list[dict[str, float | int | None]]: + summary: list[dict[str, float | int | None]] = [] + for values in observed_offsets: + arr = np.asarray(values, dtype=float) + if arr.size == 0: + summary.append( + { + "n": 0, + "min": None, + "median": None, + "max": None, + "unique": 0, + } + ) + continue + summary.append( + { + "n": int(arr.size), + "min": float(np.min(arr)), + "median": float(np.median(arr)), + "max": float(np.max(arr)), + "unique": int(np.unique(arr).size), + } + ) + return summary + + +def _select_raster_site_windows( + meta: Sequence[dict[str, Any]], + *, + original_indices: np.ndarray, + selector: _RasterSiteSelection, + distance_mode: str, + selection_spans_all_windows, +) -> _RasterSiteSelectionResult: + candidates, excluded_count = _build_raster_site_candidates( + meta, + original_indices=original_indices, + selector=selector, + distance_mode=distance_mode, + ) + groups: defaultdict[tuple[Any, Any], list[_RasterSiteCandidate]] = defaultdict(list) + for candidate in candidates: + groups[candidate.read_key].append(candidate) + + rng = np.random.default_rng(selector.selection_seed) + per_window_indices: list[list[int]] = [[] for _ in range(selector.n_windows)] + per_window_centers: list[list[float]] = [[] for _ in range(selector.n_windows)] + selected_read_keys: list[tuple[Any, Any]] = [] + dropped_for_window_span = 0 + observed_offsets: list[list[float]] = [[] for _ in range(selector.n_windows)] + + for read_key, items in groups.items(): + if len(items) < selector.n_windows: + continue + ordered_items = sorted(items, key=lambda candidate: candidate.center_bp) + if selector.mode == "fixed_offsets": + valid_sets = _fixed_offset_sets(ordered_items, selector) + else: + valid_sets = _cooccurring_sets(ordered_items, selector, rng) + chosen = _choose_site_set(valid_sets, selector, rng) + if chosen is None: + continue + candidate_for_span = [ + (candidate.row_idx, candidate.center_bp, window_pos) + for window_pos, candidate in enumerate(chosen) + ] + if not selection_spans_all_windows(candidate_for_span): + dropped_for_window_span += 1 + continue + primary_center = chosen[selector.primary_window_index].center_bp + for window_pos, candidate in enumerate(chosen): + per_window_indices[window_pos].append(int(candidate.row_idx)) + per_window_centers[window_pos].append(float(candidate.center_bp)) + observed_offsets[window_pos].append(float(candidate.center_bp - primary_center)) + selected_read_keys.append(read_key) + + if not all(per_window_indices): + raise ValueError("No read sets found meeting site-selection criteria.") + + stats = { + "rows_are": "reads", + "unique_reads": len(set(selected_read_keys)), + "site_sets": len(selected_read_keys), + "orientation_applied": selector.orientation, + "observed_window_center_offsets_bp": observed_offsets, + "observed_window_center_offsets_summary_bp": _summarize_observed_offsets( + observed_offsets + ), + "site_selection": { + "mode": selector.mode, + "n_windows": selector.n_windows, + "min_distance_bp": selector.min_distance_bp, + "max_distance_bp": selector.max_distance_bp, + "selection_multiplicity": selector.selection_multiplicity, + "choose": selector.choose, + "selection_seed": selector.selection_seed, + "anchor": selector.anchor, + "strand_relation": selector.strand_relation, + "orientation": selector.orientation, + "excluded_sites": excluded_count, + }, + "dropped_for_window_span": dropped_for_window_span, + } + return _RasterSiteSelectionResult( + window_indices=[np.asarray(values, dtype=int) for values in per_window_indices], + panel_centers=[np.asarray(values, dtype=float) for values in per_window_centers], + stats=stats, + ) + + def _extract_window_from_record( record: tuple, idx: dict[str, int], @@ -2398,27 +2878,26 @@ def plot_multisite_read_raster( *, n_windows: int = 2, min_separation_bp: int = 5000, + selection_mode: str = "cooccurring", + window_offsets_bp: Sequence[int] | None = None, + primary_window_index: int = 0, + coordinate_mode: str | None = None, + site_selection: dict[str, Any] | None = None, distance_mode: str = "center", # or "bounds" window_size: int | None = None, motif_index: int = 0, motif_count: int | None = None, plot_all_motifs: bool = False, motif_labels: Sequence[str] | None = None, - window_centers_bp: Sequence[int] | None = None, window_widths_bp: int | Sequence[int] | None = None, - window_match_tolerance_bp: int | None = None, - symmetric_side_windows: int | None = None, - symmetric_max_offset_bp: int | None = None, enforce_full_window_span: bool = True, - # Legacy aliases - window_center_offsets: Sequence[int] | None = None, - center_tolerance_bp: int | None = None, min_read_length_bp: int | None = None, smoothing: str | None = "gaussian", # None, "boxcar", "gaussian" smooth_win: int = 21, smooth_sigma_bp: float = 6.0, max_rows: int | None = 500, - downsample_method: str = "bin_mean", # "bin_mean" | "uniform" + downsample_method: str = "auto", # "auto" | "bin_mean" | "uniform" | "random" + downsample_seed: int | None = None, cmap: str = "magma", vmin: float | None = None, vmax: float | None = None, @@ -2430,7 +2909,6 @@ def plot_multisite_read_raster( scatter_color_values: str = "ml_score", # "auto" | "ml_score" | "raw" | "smoothed" ml_score_thresholds: Sequence[float] | None = None, motif_colors: Sequence[str] | None = None, - x_axis_mode: str | None = None, # "relative_to_primary" | "centered" sort_by: str = "mod_fraction", # "mod_fraction" | "cluster" | "window_center" | "read_name" | "region_start" | "read_length" | "none" sort_window_index: int | None = None, sort_descending: bool | None = None, @@ -2443,28 +2921,32 @@ def plot_multisite_read_raster( Args: read_windows: ReadWindowExtractionResult from extract_read_windows / build_multimotif_read_windows - n_windows: number of windows per read to plot when explicit centers are not provided - min_separation_bp: minimum separation between site centers (distance_mode="center") or read starts (bounds) + n_windows: number of windows per read for co-occurring-region mode. + min_separation_bp: minimum separation between selected site centers. + selection_mode: shorthand selector mode. "fixed_offsets" requires exact + window_offsets_bp matches per read; "cooccurring" chooses regions from the + same read separated by min_separation_bp. The legacy alias + "cooccurring_regions" is also accepted. + window_offsets_bp: fixed window offsets relative to the primary window center. + Pass one value per window; the primary window offset should usually be 0. + primary_window_index: window used as the reference coordinate frame and default sort window. + coordinate_mode: "relative_to_primary" preserves offsets along each read; "local_window" + centers every panel on its own selected site. + site_selection: optional rich selector dict. Supports modes "cooccurring", + "fixed_offsets", and "anchor_plus_neighbors"; distance bounds, seeded + random choice, strand filters, exclusions, and orientation by anchor strand. + When provided, it supersedes selection_mode/window_offsets_bp/n_windows + shorthand for site selection. distance_mode: "center" uses region_start/end center; "bounds" uses read_start/read_end window_size: half-window in bp; if provided, per-motif slice width is ``2 * window_size``. motif_index: reference motif slice index for single-motif plotting and ordering motif_count: total motif slices concatenated in data_matrix; inferred when possible plot_all_motifs: when True, render all motif slices in a motif x window panel grid motif_labels: optional motif names aligned to motif slices - window_centers_bp: explicit desired window centers in primary-region coordinates - (for example ``[-2500, 0, 2500]``). When provided, this replaces ``n_windows``. window_widths_bp: per-window display widths in bp (common width when scalar). Defaults to the extracted span for each panel. - window_match_tolerance_bp: matching tolerance for explicit centers. Defaults to half - the extracted span. - symmetric_side_windows: when set with ``symmetric_max_offset_bp``, generate centers as - evenly spaced offsets from ``-symmetric_max_offset_bp`` to ``+symmetric_max_offset_bp`` - with ``2 * symmetric_side_windows + 1`` windows total. - symmetric_max_offset_bp: max absolute offset used for symmetric center generation. enforce_full_window_span: when True (default), drop read-sets that cannot span the full displayed windows based on read_start/read_end (or read_length when available). - window_center_offsets: legacy alias for ``window_centers_bp``. - center_tolerance_bp: legacy alias for ``window_match_tolerance_bp``. min_read_length_bp: optional minimum read length filter. Must be at least the required span implied by requested centers/separation plus plotted window width. smoothing: None, "boxcar", or "gaussian" @@ -2472,8 +2954,10 @@ def plot_multisite_read_raster( smooth_sigma_bp: sigma for gaussian smoothing max_rows: cap rows; when exceeded, downsample according to ``downsample_method``. Pass None to disable downsampling. - downsample_method: "bin_mean" averages adjacent sorted read rows; "uniform" takes - evenly spaced sorted rows. + downsample_method: "auto" uses "uniform" for scatter plots to preserve real reads + and "bin_mean" for heatmaps; "bin_mean" averages adjacent sorted read rows; + "uniform" takes evenly spaced sorted rows; "random" samples sorted rows. + downsample_seed: seed for reproducible random downsampling. cmap: matplotlib colormap vmin/vmax: color scale limits; None auto-scales render_mode: "scatter" or "heatmap" @@ -2495,8 +2979,6 @@ def plot_multisite_read_raster( ml_score_thresholds: optional per-motif ML score thresholds for scatter mode. When provided, only points with ML score >= threshold are plotted in motif-specific colors. motif_colors: optional colors aligned to motifs for thresholded scatter display - x_axis_mode: coordinate mode. ``relative_to_primary`` preserves primary-region offsets; - ``centered`` keeps each panel centered at zero for legacy compatibility. sort_by: ordering strategy for paired reads sort_window_index: optional window index used by window-aware sorting modes sort_descending: descending/ascending order toggle for supported sort modes. @@ -2525,26 +3007,27 @@ def plot_multisite_read_raster( raise ValueError( "scatter_color_values must be 'auto', 'ml_score', 'raw', or 'smoothed'." ) - if x_axis_mode is not None and x_axis_mode not in { + if selection_mode not in {"fixed_offsets", "cooccurring_regions", "cooccurring"}: + raise ValueError( + "selection_mode must be 'fixed_offsets', 'cooccurring_regions', or 'cooccurring'." + ) + if coordinate_mode is not None and coordinate_mode not in { "relative_to_primary", - "centered", + "local_window", }: raise ValueError( - "x_axis_mode must be None, 'relative_to_primary', or 'centered'." + "coordinate_mode must be None, 'relative_to_primary', or 'local_window'." ) - effective_x_axis_mode = x_axis_mode or "relative_to_primary" if distance_mode not in {"center", "bounds"}: raise ValueError("distance_mode must be 'center' or 'bounds'.") if n_windows < 1: raise ValueError("n_windows must be >= 1.") if min_separation_bp < 0: raise ValueError("min_separation_bp must be >= 0.") - if downsample_method not in {"bin_mean", "uniform"}: - raise ValueError("downsample_method must be 'bin_mean' or 'uniform'.") - if center_tolerance_bp is not None and center_tolerance_bp < 0: - raise ValueError("center_tolerance_bp must be >= 0 when provided.") - if window_match_tolerance_bp is not None and window_match_tolerance_bp < 0: - raise ValueError("window_match_tolerance_bp must be >= 0 when provided.") + if downsample_method not in {"auto", "bin_mean", "uniform", "random"}: + raise ValueError( + "downsample_method must be 'auto', 'bin_mean', 'uniform', or 'random'." + ) if max_rows is not None and max_rows <= 0: raise ValueError("max_rows must be > 0 when provided.") if sort_window_index is not None and sort_window_index < 0: @@ -2629,75 +3112,76 @@ def _smooth(M: np.ndarray) -> np.ndarray: [f"motif_{i}" for i in range(len(motif_labels_resolved), n_motifs)] ) X_by_motif = [X_full[:, m * slice_width : (m + 1) * slice_width] for m in motif_ids] - ML_by_motif = [np.clip(matrix.astype(float), 0.0, 1.0) for matrix in X_by_motif] - if ( - window_center_offsets is not None - and window_centers_bp is not None - and list(window_center_offsets) != list(window_centers_bp) - ): - raise ValueError( - "Pass either window_centers_bp or window_center_offsets (legacy alias), not both with different values." - ) - resolved_centers = ( - window_centers_bp if window_centers_bp is not None else window_center_offsets - ) - if ( - center_tolerance_bp is not None - and window_match_tolerance_bp is not None - and int(center_tolerance_bp) != int(window_match_tolerance_bp) - ): - raise ValueError( - "Pass either window_match_tolerance_bp or center_tolerance_bp (legacy alias), not both with different values." - ) - match_tolerance_bp = ( - int(window_match_tolerance_bp) - if window_match_tolerance_bp is not None - else (int(center_tolerance_bp) if center_tolerance_bp is not None else None) - ) + def _normalize_ml_scores(matrix: np.ndarray) -> np.ndarray: + values = np.asarray(matrix, dtype=float) + finite = values[np.isfinite(values)] + if finite.size and float(np.nanmax(finite)) > 1.0: + values = values / 255.0 + return np.clip(values, 0.0, 1.0) - if symmetric_side_windows is not None or symmetric_max_offset_bp is not None: - if resolved_centers is not None: - raise ValueError( - "Do not combine symmetric center spec with explicit window_centers_bp." - ) - if symmetric_side_windows is None or symmetric_max_offset_bp is None: + ML_by_motif = [_normalize_ml_scores(matrix) for matrix in X_by_motif] + + raw_selector_spec = dict(site_selection or {}) + raw_mode = raw_selector_spec.get("mode", selection_mode) + raw_offsets = raw_selector_spec.get("window_offsets_bp", window_offsets_bp) + if raw_mode in {"fixed_offsets"}: + if raw_offsets is None: raise ValueError( - "symmetric_side_windows and symmetric_max_offset_bp must be provided together." - ) - if int(symmetric_side_windows) < 0: - raise ValueError("symmetric_side_windows must be >= 0.") - if int(symmetric_max_offset_bp) < 0: - raise ValueError("symmetric_max_offset_bp must be >= 0.") - n_side = int(symmetric_side_windows) - max_offset = float(symmetric_max_offset_bp) - if n_side == 0: - resolved_centers = [0] - else: - resolved_centers = ( - np.linspace(-max_offset, max_offset, (2 * n_side) + 1) - .round() - .astype(int) - .tolist() + "window_offsets_bp is required when selection_mode='fixed_offsets'." ) + n_windows_effective = len(list(raw_offsets)) + else: + n_windows_effective = int(raw_selector_spec.get("n_windows", n_windows)) - if resolved_centers is None: - n_windows_effective = int(n_windows) - target_offsets = None + if window_widths_bp is None: + default_width_bp = int( + slice_width if window_size is None else max(1, 2 * int(window_size)) + ) + panel_widths_bp = [default_width_bp for _ in range(n_windows_effective)] + elif isinstance(window_widths_bp, (int, np.integer)): + panel_widths_bp = [int(window_widths_bp) for _ in range(n_windows_effective)] else: - offsets = [int(offset) for offset in resolved_centers] - if len(offsets) == 0: + panel_widths_bp = [int(width) for width in window_widths_bp] + if len(panel_widths_bp) != n_windows_effective: raise ValueError( - "window_centers_bp must contain at least one center when provided." + "window_widths_bp must be a scalar or a sequence with one entry per window center." ) - n_windows_effective = len(offsets) - target_offsets = np.asarray(offsets, dtype=float) + if any(width <= 0 for width in panel_widths_bp): + raise ValueError("window_widths_bp values must be > 0.") + if any(width > slice_width for width in panel_widths_bp): + raise ValueError( + "window_widths_bp values cannot exceed extracted window span; increase extract/parse window_size." + ) + panel_half_widths = [0.5 * float(width) for width in panel_widths_bp] + + selector = _resolve_raster_site_selection( + site_selection, + selection_mode=selection_mode, + window_offsets_bp=window_offsets_bp, + n_windows=n_windows, + min_separation_bp=min_separation_bp, + primary_window_index=primary_window_index, + panel_widths_bp=panel_widths_bp, + ) + n_windows_effective = selector.n_windows + primary_window_index = selector.primary_window_index + target_offsets = ( + np.asarray(selector.window_offsets_bp, dtype=float) + if selector.window_offsets_bp is not None + else None + ) + effective_coordinate_mode = ( + coordinate_mode + if coordinate_mode is not None + else ("relative_to_primary" if selector.mode == "fixed_offsets" else "local_window") + ) if target_offsets is None: required_read_length_bp = int( max( slice_width, - ((n_windows_effective - 1) * min_separation_bp) + slice_width, + ((n_windows_effective - 1) * selector.min_distance_bp) + slice_width, ) ) else: @@ -2718,31 +3202,10 @@ def _smooth(M: np.ndarray) -> np.ndarray: ) effective_min_read_length = ( required_read_length_bp - if target_offsets is not None and min_read_length_bp is None + if selector.mode == "fixed_offsets" and min_read_length_bp is None else min_read_length_bp ) - if window_widths_bp is None: - default_width_bp = int( - slice_width if window_size is None else max(1, 2 * int(window_size)) - ) - panel_widths_bp = [default_width_bp for _ in range(n_windows_effective)] - elif isinstance(window_widths_bp, (int, np.integer)): - panel_widths_bp = [int(window_widths_bp) for _ in range(n_windows_effective)] - else: - panel_widths_bp = [int(width) for width in window_widths_bp] - if len(panel_widths_bp) != n_windows_effective: - raise ValueError( - "window_widths_bp must be a scalar or a sequence with one entry per window center." - ) - if any(width <= 0 for width in panel_widths_bp): - raise ValueError("window_widths_bp values must be > 0.") - if any(width > slice_width for width in panel_widths_bp): - raise ValueError( - "window_widths_bp values cannot exceed extracted window span; increase extract/parse window_size." - ) - panel_half_widths = [0.5 * float(width) for width in panel_widths_bp] - def _apply_index_filter(index_vector: np.ndarray) -> None: nonlocal X_by_motif, ML_by_motif, meta, filtered_original_indices X_by_motif = [matrix[index_vector] for matrix in X_by_motif] @@ -2819,7 +3282,6 @@ def _apply_index_filter(index_vector: np.ndarray) -> None: keep_by_length.append(idx) _apply_index_filter(np.asarray(keep_by_length, dtype=int)) - span_check_warning_emitted = False dropped_for_window_span = 0 def _safe_int(value: Any) -> int | None: @@ -2864,7 +3326,6 @@ def _window_is_covered( def _selection_spans_all_windows( selected: Sequence[tuple[int, float, int]], ) -> bool: - nonlocal span_check_warning_emitted if not enforce_full_window_span: return True @@ -2885,137 +3346,22 @@ def _selection_spans_all_windows( if length_value is not None: candidate_lengths.append(int(length_value)) - if unresolved_present: - if candidate_lengths: - required_span = max(right_edges) - min(left_edges) - if max(candidate_lengths) < required_span: - return False - elif not span_check_warning_emitted: - warnings.warn( - "Unable to fully verify window-span coverage for some reads because " - "read_start/read_end/read_length metadata are missing. " - "Re-extract windows with current APIs for strict filtering.", - RuntimeWarning, - stacklevel=2, - ) - span_check_warning_emitted = True + if unresolved_present and candidate_lengths: + required_span = max(right_edges) - min(left_edges) + if max(candidate_lengths) < required_span: + return False return True - # Group by read key - groups = defaultdict(list) - for i, m in zip(range(len(meta)), meta, strict=False): - key = ( - m.get("read_name"), - m.get("chromosome"), - m.get("region_strand"), - ) - if distance_mode == "center": - center = (int(m.get("region_start", 0)) + int(m.get("region_end", 0))) // 2 - else: - center = int(m.get("read_start", 0)) - groups[key].append((i, center)) - - pair_indices_per_window = [[] for _ in range(n_windows_effective)] - panel_centers = [[] for _ in range(n_windows_effective)] - for _, items in groups.items(): - if len(items) < n_windows_effective: - continue - items = sorted(items, key=lambda x: x[1]) - centers_arr = np.asarray([entry[1] for entry in items], dtype=float) - idx_arr = np.asarray([entry[0] for entry in items], dtype=int) - - if target_offsets is None: - # sliding window of n_windows with minimum separation - for j in range(len(items) - n_windows_effective + 1): - centers = [items[j + k][1] for k in range(n_windows_effective)] - if any( - (centers[k + 1] - centers[k]) < min_separation_bp - for k in range(n_windows_effective - 1) - ): - continue - idxs = [items[j + k][0] for k in range(n_windows_effective)] - candidate = [ - (int(idxs[k]), float(centers[k]), int(k)) - for k in range(n_windows_effective) - ] - if not _selection_spans_all_windows(candidate): - dropped_for_window_span += 1 - continue - for k, idx in enumerate(idxs): - pair_indices_per_window[k].append(int(idx)) - panel_centers[k].append(float(centers[k])) - continue - - tolerance = float( - match_tolerance_bp - if match_tolerance_bp is not None - else max(1, slice_width // 2) - ) - best_candidate: tuple[float, list[int]] | None = None - for anchor_pos in range(len(items)): - anchor_center = centers_arr[anchor_pos] - targets = anchor_center + target_offsets - used_positions: set[int] = set() - selected_positions: list[int] = [] - total_error = 0.0 - for target in targets: - distances = np.abs(centers_arr - target) - order = np.argsort(distances) - chosen = None - for candidate_pos in order: - pos = int(candidate_pos) - if pos in used_positions: - continue - if float(distances[pos]) <= tolerance: - candidate_idx = int(idx_arr[pos]) - window_half = float(panel_half_widths[len(selected_positions)]) - covered = _window_is_covered( - meta[candidate_idx], float(centers_arr[pos]), window_half - ) - if covered is False: - continue - chosen = pos - break - if chosen is None: - selected_positions = [] - break - used_positions.add(chosen) - selected_positions.append(chosen) - total_error += float(distances[chosen]) - - if not selected_positions: - continue - if best_candidate is None or total_error < best_candidate[0]: - best_candidate = (total_error, selected_positions) - - if best_candidate is None: - continue - _, selected_positions = best_candidate - candidate = [ - (int(idx_arr[pos]), float(centers_arr[pos]), int(k)) - for k, pos in enumerate(selected_positions) - ] - if not _selection_spans_all_windows(candidate): - dropped_for_window_span += 1 - continue - for k, pos in enumerate(selected_positions): - pair_indices_per_window[k].append(int(idx_arr[pos])) - panel_centers[k].append(float(centers_arr[pos])) - - if not all(len(p) > 0 for p in pair_indices_per_window): - if enforce_full_window_span and dropped_for_window_span > 0: - raise ValueError( - "No read sets found after enforcing full-window span coverage; " - "increase read length, reduce window widths/offsets, or relax constraints." - ) - raise ValueError("No read sets found meeting separation criteria.") - - window_indices = [ - np.asarray(values, dtype=int) for values in pair_indices_per_window - ] - panel_centers = [ - np.asarray(center_values, dtype=float) for center_values in panel_centers - ] + selection_result = _select_raster_site_windows( + meta, + original_indices=filtered_original_indices, + selector=selector, + distance_mode=distance_mode, + selection_spans_all_windows=_selection_spans_all_windows, + ) + window_indices = selection_result.window_indices + panel_centers = selection_result.panel_centers + dropped_for_window_span = int(selection_result.stats["dropped_for_window_span"]) panels_by_motif = [] panels_smooth_by_motif = [] panels_ml_by_motif = [] @@ -3048,7 +3394,7 @@ def _selection_spans_all_windows( reference_panels = panels_render_by_motif[ref_motif_pos] if sort_window_index is None: - sort_window_pos = 0 + sort_window_pos = int(primary_window_index) else: sort_window_pos = int(sort_window_index) if sort_window_pos >= n_windows_effective: @@ -3163,8 +3509,8 @@ def _resolved_read_length(read_meta: dict) -> int: "Inconsistent read ordering across multisite panels; panel row counts diverged." ) centers_sorted = [center_values[order] for center_values in panel_centers] - primary_centers = centers_sorted[0] - if effective_x_axis_mode == "centered": + primary_centers = centers_sorted[int(primary_window_index)] + if effective_coordinate_mode == "local_window": center_offsets = [ np.zeros_like(center_values, dtype=float) for center_values in centers_sorted @@ -3173,15 +3519,15 @@ def _resolved_read_length(read_meta: dict) -> int: center_offsets = [ center_values - primary_centers for center_values in centers_sorted ] - if render_mode == "heatmap" and effective_x_axis_mode == "relative_to_primary": + if render_mode == "heatmap" and effective_coordinate_mode == "relative_to_primary": for offsets in center_offsets: if offsets.size > 1 and not np.allclose( offsets, offsets[0], equal_nan=True ): raise ValueError( - "Heatmap rendering with x_axis_mode='relative_to_primary' requires constant " + "Heatmap rendering with coordinate_mode='relative_to_primary' requires constant " "per-read offsets within each panel because imshow uses one rectangular extent. " - "Use render_mode='scatter', x_axis_mode='centered', or fixed/explicit centers " + "Use render_mode='scatter', coordinate_mode='local_window', or fixed offsets " "producing constant offsets." ) @@ -3204,12 +3550,17 @@ def bin_vector(vector: np.ndarray, k: int) -> np.ndarray: P = panels_sorted_by_motif[0][0].shape[0] rows_before_downsample = int(P) + effective_downsample_method = ( + ("uniform" if render_mode == "scatter" else "bin_mean") + if downsample_method == "auto" + else downsample_method + ) downsampled = False downsample_factor = 1 if max_rows is not None and max_rows < P: step = math.ceil(P / max_rows) downsample_factor = step - if downsample_method == "bin_mean": + if effective_downsample_method == "bin_mean": panels_sorted_by_motif = [ [bin_rows(panel, step) for panel in motif_panels] for motif_panels in panels_sorted_by_motif @@ -3227,6 +3578,26 @@ def bin_vector(vector: np.ndarray, k: int) -> np.ndarray: for motif_panels in panels_ml_sorted_by_motif ] center_offsets = [bin_vector(v, step) for v in center_offsets] + elif effective_downsample_method == "random": + rng = np.random.default_rng(downsample_seed) + keep = np.sort(rng.choice(P, size=max_rows, replace=False)) + panels_sorted_by_motif = [ + [panel[keep] for panel in motif_panels] + for motif_panels in panels_sorted_by_motif + ] + panels_raw_sorted_by_motif = [ + [panel[keep] for panel in motif_panels] + for motif_panels in panels_raw_sorted_by_motif + ] + panels_smooth_sorted_by_motif = [ + [panel[keep] for panel in motif_panels] + for motif_panels in panels_smooth_sorted_by_motif + ] + panels_ml_sorted_by_motif = [ + [panel[keep] for panel in motif_panels] + for motif_panels in panels_ml_sorted_by_motif + ] + center_offsets = [vector[keep] for vector in center_offsets] else: keep = np.unique(np.round(np.linspace(0, P - 1, max_rows)).astype(int)) panels_sorted_by_motif = [ @@ -3403,7 +3774,17 @@ def _axis_for(motif_pos: int, window_pos: int): return axes[motif_pos, window_pos] first_mappable = None + first_mappable_by_motif: dict[int, Any] = {} threshold_legend_entries: dict[str, tuple[str, float]] = {} + if threshold_map is not None: + threshold_legend_entries = { + str(motif_labels_resolved[motif_id]): ( + str(motif_color_map[motif_id]), + float(threshold_map[motif_id]), + ) + for motif_id in motif_ids + if motif_id in threshold_map + } for motif_pos, motif_id in enumerate(motif_ids): motif_panels = panels_sorted_by_motif[motif_pos] motif_raw_panels = panels_raw_sorted_by_motif[motif_pos] @@ -3440,10 +3821,6 @@ def _axis_for(motif_pos: int, window_pos: int): rows = rows[keep] cols = cols[keep] values = panel_ml[rows, cols] - threshold_legend_entries[motif_label] = ( - str(motif_color_map[motif_id]), - threshold_value, - ) if rows.size > 0: x_scatter = x_positions[cols] + row_offsets[rows] in_window = (x_scatter >= window_lo) & (x_scatter <= window_hi) @@ -3471,6 +3848,7 @@ def _axis_for(motif_pos: int, window_pos: int): linewidths=0, rasterized=True, ) + first_mappable_by_motif.setdefault(motif_id, first_mappable) else: ax.scatter( x_scatter, @@ -3502,6 +3880,7 @@ def _axis_for(motif_pos: int, window_pos: int): linewidths=0, rasterized=True, ) + first_mappable_by_motif.setdefault(motif_id, first_mappable) else: ax.scatter( rows, @@ -3565,6 +3944,11 @@ def _axis_for(motif_pos: int, window_pos: int): x_pad = max(1.0, 0.02 * (window_hi - window_lo + 1.0)) ax.set_xlim(window_lo - x_pad, window_hi + x_pad) + if window_pos == primary_window_index: + for spine in ax.spines.values(): + spine.set_linewidth(2.2) + spine.set_edgecolor("black") + if render_mode == "heatmap": heatmap_title = ( f"{motif_label} | Window {window_pos + 1}" @@ -3589,12 +3973,16 @@ def _axis_for(motif_pos: int, window_pos: int): if (not rotate) and len(motif_ids) > 1 and window_pos == 0: ax.set_ylabel(f"{motif_label}\nPosition") + position_label = ( + "Position relative to primary center (bp)" + if effective_coordinate_mode == "relative_to_primary" + else "Distance from window center (bp)" + ) if rotate: bottom_axes = [ _axis_for(motif_pos, n_windows_effective - 1) for motif_pos in range(len(motif_ids)) ] - position_label = "Position relative to primary center (bp)" xlabel = ( position_label if effective_axis_orientation == "position_x" @@ -3619,7 +4007,7 @@ def _axis_for(motif_pos: int, window_pos: int): for window_pos in range(n_windows_effective): if effective_axis_orientation == "position_x": _axis_for(motif_pos, window_pos).set_xlabel( - "Position relative to primary center (bp)" + position_label ) else: _axis_for(motif_pos, window_pos).set_xlabel("Reads (sorted)") @@ -3635,37 +4023,70 @@ def _axis_for(motif_pos: int, window_pos: int): first_mappable = first_axis.scatter( [], [], c=[], cmap=fallback_cmap, vmin=vmin, vmax=vmax ) - cbar = fig.colorbar( - first_mappable, ax=np.ravel(axes).tolist(), shrink=0.6, pad=0.02 - ) sigma_txt = f", σ={smooth_sigma_bp}" if smoothing == "gaussian" else "" - if render_mode == "scatter" and effective_scatter_color_values == "ml_score": - cbar.set_label( - f"normalized ML score (0-1)\\n{'downsampled' if downsampled else 'full'}" - ) - elif render_mode == "scatter": - scale_label = "fraction modified signal" - smoothing_label = ( - f"{smoothing}, win={smooth_win}{sigma_txt}" - if render_value_mode == "smoothed" - else "none" - ) - cbar.set_label( - f"{scale_label} (values={render_value_mode}, smoother={smoothing_label})\\n" - f"{'downsampled' if downsampled else 'full'}" - ) + if ( + render_mode == "scatter" + and effective_scatter_color_values == "ml_score" + and len(motif_ids) > 1 + ): + for motif_id in motif_ids: + motif_pos = motif_ids.index(motif_id) + if motif_id not in first_mappable_by_motif: + first_mappable_by_motif[motif_id] = _axis_for(motif_pos, 0).scatter( + [], + [], + c=[], + cmap=ml_cmap_names[motif_id], + vmin=vmin, + vmax=vmax, + ) + cbar = fig.colorbar( + first_mappable_by_motif[motif_id], + ax=[ + _axis_for(motif_pos, window_pos) + for window_pos in range(n_windows_effective) + ], + shrink=0.6, + pad=0.02, + ) + cbar.set_label( + f"{motif_labels_resolved[motif_id]} normalized ML score (0-1)\\n" + f"{'downsampled' if downsampled else 'full'}" + ) else: - scale_label = "window signal heatmap" - smoothing_label = ( - f"{smoothing}, win={smooth_win}{sigma_txt}" - if render_value_mode == "smoothed" - else "none" - ) - cbar.set_label( - f"{scale_label} (per-read smoothing along position axis; " - f"values={render_value_mode}, smoother={smoothing_label})\\n" - f"{'downsampled' if downsampled else 'full'}" + cbar = fig.colorbar( + first_mappable, ax=np.ravel(axes).tolist(), shrink=0.6, pad=0.02 ) + if ( + render_mode == "scatter" + and effective_scatter_color_values == "ml_score" + ): + cbar.set_label( + f"normalized ML score (0-1)\\n{'downsampled' if downsampled else 'full'}" + ) + elif render_mode == "scatter": + scale_label = "fraction modified signal" + smoothing_label = ( + f"{smoothing}, win={smooth_win}{sigma_txt}" + if render_value_mode == "smoothed" + else "none" + ) + cbar.set_label( + f"{scale_label} (values={render_value_mode}, smoother={smoothing_label})\\n" + f"{'downsampled' if downsampled else 'full'}" + ) + else: + scale_label = "window signal heatmap" + smoothing_label = ( + f"{smoothing}, win={smooth_win}{sigma_txt}" + if render_value_mode == "smoothed" + else "none" + ) + cbar.set_label( + f"{scale_label} (per-read smoothing along position axis; " + f"values={render_value_mode}, smoother={smoothing_label})\\n" + f"{'downsampled' if downsampled else 'full'}" + ) else: from matplotlib.lines import Line2D @@ -3694,8 +4115,9 @@ def _axis_for(motif_pos: int, window_pos: int): return fig, { "pairs": panels_sorted_by_motif[0][0].shape[0], + **selection_result.stats, "downsampled": downsampled, - "downsample_method": (downsample_method if downsampled else "none"), + "downsample_method": (effective_downsample_method if downsampled else "none"), "downsample_factor": int(downsample_factor), "rows_before_downsample": rows_before_downsample, "rows_after_downsample": int(panels_sorted_by_motif[0][0].shape[0]), @@ -3705,23 +4127,18 @@ def _axis_for(motif_pos: int, window_pos: int): "render_values": render_value_mode, "scatter_color_values": effective_scatter_color_values, "axis_orientation": effective_axis_orientation, - "x_axis_mode": effective_x_axis_mode, + "coordinate_mode": effective_coordinate_mode, "sort_by": sort_by, "sort_window_index": sort_window_pos, "sort_descending": effective_sort_descending, "motifs_plotted": [motif_labels_resolved[m] for m in motif_ids], "n_windows": n_windows_effective, - "window_centers_bp": target_offsets.tolist() - if target_offsets is not None - else None, - "window_center_offsets": target_offsets.tolist() - if target_offsets is not None - else None, + "selection_mode": selector.mode, + "primary_window_index": int(primary_window_index), + "window_offsets_bp": target_offsets.tolist() if target_offsets is not None else None, "window_widths_bp": [int(value) for value in panel_widths_bp], "required_read_length_bp": required_read_length_bp, "min_read_length_bp": effective_min_read_length, - "window_match_tolerance_bp": match_tolerance_bp, - "center_tolerance_bp": match_tolerance_bp, "enforce_full_window_span": bool(enforce_full_window_span), "dropped_for_window_span": int(dropped_for_window_span), "read_order_consistent": True, @@ -3750,7 +4167,9 @@ def plot_two_site_read_raster( *, second_site_offset_bp: int, window_width_bp: int | None = None, - window_match_tolerance_bp: int | None = None, + max_rows: int | None = 500, + downsample_method: str = "auto", + downsample_seed: int | None = None, **kwargs, ): """ @@ -3760,23 +4179,36 @@ def plot_two_site_read_raster( read_windows: ReadWindowExtractionResult from extract_read_windows / build_multimotif_read_windows second_site_offset_bp: secondary site center (bp) relative to the primary site at 0 window_width_bp: common width (bp) applied to both windows when provided - window_match_tolerance_bp: tolerance used when matching explicit centers + max_rows: cap displayed reads; pass None to show all rows + downsample_method: "auto" uses uniform read sampling for scatter and bin-mean for heatmap + downsample_seed: seed for reproducible random downsampling **kwargs: forwarded to plot_multisite_read_raster """ - if "window_centers_bp" in kwargs or "window_center_offsets" in kwargs: + if ( + "window_offsets_bp" in kwargs + or "selection_mode" in kwargs + or "site_selection" in kwargs + ): raise ValueError( - "plot_two_site_read_raster manages centers internally; do not pass window_centers_bp." + "plot_two_site_read_raster manages fixed offsets internally; do not pass window_offsets_bp, selection_mode, or site_selection." ) if "n_windows" in kwargs: raise ValueError("plot_two_site_read_raster always uses exactly two windows.") + if "primary_window_index" in kwargs: + raise ValueError("plot_two_site_read_raster always uses window 1 as primary.") forwarded: dict[str, Any] = dict(kwargs) - forwarded["window_centers_bp"] = [0, int(second_site_offset_bp)] + forwarded["max_rows"] = max_rows + forwarded["downsample_method"] = downsample_method + forwarded["downsample_seed"] = downsample_seed + forwarded["site_selection"] = { + "mode": "fixed_offsets", + "window_offsets_bp": [0, int(second_site_offset_bp)], + "primary_window_index": 0, + } if window_width_bp is not None: forwarded["window_widths_bp"] = [int(window_width_bp), int(window_width_bp)] - if window_match_tolerance_bp is not None: - forwarded["window_match_tolerance_bp"] = int(window_match_tolerance_bp) return plot_multisite_read_raster(read_windows, n_windows=2, **forwarded) diff --git a/dimelo_test.ipynb b/dimelo_test.ipynb index 9b9fa2a..0507997 100644 --- a/dimelo_test.ipynb +++ b/dimelo_test.ipynb @@ -10,6 +10,20 @@ "If you launch notebooks outside an activated shell, connect the correct kernel (`dimelo-test` by default) so Python, `dimelo`, and `modkit` resolve from the same environment.\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "metadata": {}, @@ -22,9 +36,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "You don't seem to be running on Google Colab so this cell is not going to be useful for you.\n", + "Make sure you are running your notebook in a conda environment set up as per README.md.\n", + "Once you have this notebook running in a correctly configured environment, proceed to the rest of the cells.\n" + ] + } + ], "source": [ "# Lets Colab access your Google drive\n", "try:\n", @@ -138,7 +162,7 @@ "text": [ "System: Darwin\n", "Release: 25.5.0\n", - "Version: Darwin Kernel Version 25.5.0: Fri Mar 20 18:56:10 PDT 2026; root:xnu-12377.120.72.0.4~13/RELEASE_ARM64_T6020\n", + "Version: Darwin Kernel Version 25.5.0: Thu Apr 23 21:19:59 PDT 2026; root:xnu-12377.121.5~4/RELEASE_ARM64_T6020\n", "Processor: arm\n" ] } @@ -174,7 +198,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "87186168c2ac4f8c12f91385e2ca42688ac6c5c7\n" + "1fda0c7af44d600796e84654ea844fc199a1f62a\n" ] } ], @@ -194,9 +218,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "modkit required: 0.6.1\n", + "modkit active : 0.6.1\n" + ] + } + ], "source": [ "import re\n", "import shutil\n", @@ -274,9 +307,363 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "version", + "rawType": "str", + "type": "string" + }, + { + "name": "runtime_mean_s", + "rawType": "float64", + "type": "float" + }, + { + "name": "runtime_std_s", + "rawType": "float64", + "type": "float" + }, + { + "name": "runtime_min_s", + "rawType": "float64", + "type": "float" + }, + { + "name": "runtime_max_s", + "rawType": "float64", + "type": "float" + } + ], + "ref": "7789f5c4-ac3b-4e26-9826-030eca979504", + "rows": [ + [ + "0", + "0.6.1", + "2.0819532913155854", + "0.2763177122597796", + "1.7662932079983875", + "2.2800389159237966" + ], + [ + "1", + "0.2.4", + "5.246847764006816", + "0.37088222422172723", + "5.00622979097534", + "5.67396429204382" + ] + ], + "shape": { + "columns": 5, + "rows": 2 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
versionruntime_mean_sruntime_std_sruntime_min_sruntime_max_s
00.6.12.0819530.2763181.7662932.280039
10.2.45.2468480.3708825.0062305.673964
\n", + "
" + ], + "text/plain": [ + " version runtime_mean_s runtime_std_s runtime_min_s runtime_max_s\n", + "0 0.6.1 2.081953 0.276318 1.766293 2.280039\n", + "1 0.2.4 5.246848 0.370882 5.006230 5.673964" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compatibility flags\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "version", + "rawType": "str", + "type": "string" + }, + { + "name": "supports_force_allow_implicit", + "rawType": "bool", + "type": "boolean" + }, + { + "name": "supports_modified_bases", + "rawType": "bool", + "type": "boolean" + }, + { + "name": "supports_reference_long_opt", + "rawType": "bool", + "type": "boolean" + }, + { + "name": "supports_reference_short_opt", + "rawType": "bool", + "type": "boolean" + } + ], + "ref": "d060be50-4cd2-47bf-92e7-adb0f0fa071c", + "rows": [ + [ + "0", + "0.2.4", + "True", + "False", + "False", + "True" + ], + [ + "1", + "0.6.1", + "False", + "True", + "True", + "True" + ] + ], + "shape": { + "columns": 5, + "rows": 2 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
versionsupports_force_allow_implicitsupports_modified_basessupports_reference_long_optsupports_reference_short_opt
00.2.4TrueFalseFalseTrue
10.6.1FalseTrueTrueTrue
\n", + "
" + ], + "text/plain": [ + " version supports_force_allow_implicit supports_modified_bases \\\n", + "0 0.2.4 True False \n", + "1 0.6.1 False True \n", + "\n", + " supports_reference_long_opt supports_reference_short_opt \n", + "0 False True \n", + "1 True True " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pileup comparison summary\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "row_delta", + "rawType": "int64", + "type": "integer" + }, + { + "name": "row_delta_pct_vs_024", + "rawType": "float64", + "type": "float" + }, + { + "name": "outputs_identical_sha256", + "rawType": "bool", + "type": "boolean" + } + ], + "ref": "04a5c483-e058-4a54-a9ba-fec9c10e0113", + "rows": [ + [ + "0", + "1603", + "0.3127572979954657", + "False" + ] + ], + "shape": { + "columns": 3, + "rows": 1 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
row_deltarow_delta_pct_vs_024outputs_identical_sha256
016030.312757False
\n", + "
" + ], + "text/plain": [ + " row_delta row_delta_pct_vs_024 outputs_identical_sha256\n", + "0 1603 0.312757 False" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Recommendations\n", + "- Prefer modkit 0.6.1 for pileup runtime in this workflow (~60.3% faster on average).\n", + "- Backend-aware command building is required: use --force-allow-implicit for 0.2.4 only.\n", + "\n", + "Re-checking required modkit binary after comparison...\n", + "modkit required: 0.6.1\n", + "modkit active : 0.6.1\n" + ] + } + ], "source": [ "import json\n", "from pathlib import Path\n", @@ -454,9 +841,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PARSING quiet mode for notebook progress: False\n", + "PARSING overwrite mode: True\n" + ] + } + ], "source": [ "import importlib\n", "import gzip\n", @@ -575,9 +971,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This is expected to fail. Read the error message below:\n", + "\n", + "\n", + "Base modification tags are out of spec (Mm and Ml instead of MM and ML). \n", + "\n", + "Consider using \"modkit update-tags dimelo/test/data/ctcf_demo.sorted.bam new_file.bam\" in the command line with your conda environment active and then trying with the new file. For megalodon basecalling/modcalling, you may also need to pass \"--mode ambiguous.\n", + "Be sure to index the resulting .bam file.\"\n", + "If you are confident that your inputs are ok, pass \"override_checks=True\" to convert to warning and proceed with processing.\n" + ] + } + ], "source": [ "try:\n", " pileup_file, pileup_regions = parse_bam.pileup(\n", @@ -614,9 +1025,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "modkit required: 0.6.1\n", + "modkit active : 0.6.1\n", + "$ modkit update-tags dimelo/test/data/ctcf_demo.sorted.bam dimelo/test/output/ctcf_demo.updated.tmp.bam --mode ambiguous\n", + "Updated BAM ready: dimelo/test/output/ctcf_demo.updated.bam\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[0;32m>\u001b[0m done, 1024 records processed\n" + ] + } + ], "source": [ "import shutil\n", "from pathlib import Path\n", @@ -653,9 +1082,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using updated BAM: dimelo/test/output/ctcf_demo.updated.bam\n" + ] + } + ], "source": [ "print(f'Using updated BAM: {ctcf_bam_file_updated}')" ] @@ -669,9 +1106,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Indexed dimelo/test/output/ctcf_demo.updated.bam -> dimelo/test/output/ctcf_demo.updated.bam.bai\n" + ] + } + ], "source": [ "import pysam\n", "from pathlib import Path\n", @@ -693,17 +1138,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], - "source": [ - "pileup_file, pileup_regions = ensure_pileup_output(\n", - " input_file=ctcf_bam_file_updated,\n", - " output_name='ctcf_demo_pileup_on_target',\n", - " ref_genome=ref_genome_file,\n", - " output_directory=output_dir,\n", - " regions=[ctcf_target_regions,ctcf_off_target_regions],\n", - " motifs=['A,0','CG,0'],\n", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "WARNING: no modified appropriately-coded values found for [] in the first 100 reads. \n", + "Do you expect this file to contain these modifications? parse_bam is looking for ['A,0', 'CG,0'] but for [] found only found [].\n", + "\n", + "Consider passing only the motifs and mod codes (e.g. m,h,a) that you expect to be present in your file. \n", + "You can use modkit adjust-mods --convert [OPTIONS] to update or consolidate mod codes.\n", + "See https://github.com/nanoporetech/modkit/blob/master/book/src/advanced_usage.md\n", + " \n", + "No specified number of cores requested. 10 available on machine, allocating all.\n", + "Detected multiple motif contexts with modkit 0.6.x; running per-motif pileups and merging outputs to avoid mixed-motif empty output behavior.\n", + "Modification threshold of 190.0 assumed to be for range 0-255. 190.0/255=0.7450980392156863 will be sent to modkit.\n" + ] + } + ], + "source": [ + "pileup_file, pileup_regions = ensure_pileup_output(\n", + " input_file=ctcf_bam_file_updated,\n", + " output_name='ctcf_demo_pileup_on_target',\n", + " ref_genome=ref_genome_file,\n", + " output_directory=output_dir,\n", + " regions=[ctcf_target_regions,ctcf_off_target_regions],\n", + " motifs=['A,0','CG,0'],\n", " # parsing can optionally specify mod codes.\n", " # The default is Y or a for adenine and m or Z for cytosine, corresponding to methylation\n", " # motifs=['A,0,Y','CG,0,Z'],\n", @@ -719,9 +1182,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pileup rows: 246104\n" + ] + } + ], "source": [ "import gzip\n", "with gzip.open(pileup_file, \"rt\") as f:\n", @@ -738,9 +1209,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "WARNING: no modified appropriately-coded values found for [] in the first 100 reads. \n", + "Do you expect this file to contain these modifications? parse_bam is looking for ['A,0', 'CG,0'] but for [] found only found [].\n", + "\n", + "Consider passing only the motifs and mod codes (e.g. m,h,a) that you expect to be present in your file. \n", + "You can use modkit adjust-mods --convert [OPTIONS] to update or consolidate mod codes.\n", + "See https://github.com/nanoporetech/modkit/blob/master/book/src/advanced_usage.md\n", + " \n", + "No specified number of cores requested. 10 available on machine, allocating all.\n", + "Modification threshold of 190.0 assumed to be for range 0-255. 190.0/255=0.7450980392156863 will be sent to modkit.\n", + "Threshold provided. The extract text will stay probability-valued and read_by_base_txt_to_hdf5 will binarize at write time.\n" + ] + } + ], "source": [ "extract_file, extract_regions = ensure_extract_output(\n", " input_file=ctcf_bam_file_updated,\n", @@ -778,7 +1267,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -787,13 +1276,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "de000ce1b7a546d08095c12712c22e00", + "model_id": "24e92fdb09d24ffa82d35f1ab4076273", "version_major": 2, "version_minor": 0 }, @@ -807,7 +1296,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3264d0ab25f244b8b10f5b3f44250afb", + "model_id": "69c4c48aff8d4b309d6a8e3306cfeee4", "version_major": 2, "version_minor": 0 }, @@ -824,13 +1313,13 @@ "" ] }, - "execution_count": 20, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -858,13 +1347,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1e0881ac48214764b5773570c1d0c32b", + "model_id": "f4aa883afb0a454c8427c67ca9b5322d", "version_major": 2, "version_minor": 0 }, @@ -878,7 +1367,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7a447d7fcda74dd0af8efb81d200af55", + "model_id": "5791b6bf33e34aa5a1656e339fc1a344", "version_major": 2, "version_minor": 0 }, @@ -895,13 +1384,13 @@ "Text(0, 0.5, 'mA/A')" ] }, - "execution_count": 21, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -933,7 +1422,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -942,13 +1431,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f4a7d074a57c436c9a51880e55111215", + "model_id": "d1aaf21a0a0c4519ac298c982b2f9ad3", "version_major": 2, "version_minor": 0 }, @@ -962,7 +1451,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0b5f5f4d2d114e55845203e3fff82436", + "model_id": "97c1f7973f2643229ad014ec2a70090f", "version_major": 2, "version_minor": 0 }, @@ -979,13 +1468,13 @@ "" ] }, - "execution_count": 23, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1006,13 +1495,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "08c132c9a990451cb5d892639d55b4c3", + "model_id": "0fdc6991c11f46e89a5c9991bb959bb3", "version_major": 2, "version_minor": 0 }, @@ -1026,7 +1515,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8869b7970385442b969344934f163fef", + "model_id": "9ad7ba2314834200afd9dfa99c8bf515", "version_major": 2, "version_minor": 0 }, @@ -1043,13 +1532,13 @@ "Text(0.5, 1.0, 'dimelo/test/data/ctcf_demo_peak.bed')" ] }, - "execution_count": 24, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGzCAYAAADHdKgcAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAN6RJREFUeJzt3Qu8TPX+//HPdt0ot+24JhQnya22yKXoJJRySIXqcCT9uqFExXGJdFTiqKj9U1S6kV9Sp+PI9ZQi5O6cSOUWueUWcp//4/39/df8Zu89mz3aY2bPej0fj2H2mjUz37Vmzcx7vreVFAgEAgYAAOAjeWJdAAAAgHONAAQAAHyHAAQAAHyHAAQAAHyHAAQAAHyHAAQAAHyHAAQAAHyHAAQAAHyHAAQAAHyHAIS49+STT1pSUlLw78qVK9uf//znmJSlWbNm7uJXsdz3sbRjxw679dZbLSUlxR2Lo0eP/k2Pp8fQcY2zo2PwvPPOO+f3jZRf3y+5BQEIOMceffRRq1Gjhru+YMEC90W4b9++qD7nX//6V5s2bVqWt586dcp+97vf2XPPPReV59+2bZvbzhUrVvzmx9q7d6/ly5fP3n///Wzf5+WXX7Y33njjrJ/zkUcesU8//dT69etnb731lrVq1eqsHwtAfCAAIddZt26dvfrqq5Zb/eMf/7DWrVsHA9CQIUNiHoAWL15su3fvDpYrGgFI25kTAUhBRDUoLVq0OGcBaO7cufbHP/7R+vTpY3fddZdVr179rB8LQHwgACHXKViwoOXPn99yox9++MEFuGgFjbM1ffp0q1Spkl122WUW71TWxo0bW/Hixc/Zc+7cufOcPh+A6CMAIa588cUXduWVV1pycrJdfPHF9t///d9nbFfXL3vVCOi+PXv2dE05+rL6r//6Lzt27JirXencubOVKFHCXR577DELBAKZmoDUr0MBQM9dpkwZd381t2Tny7Fbt27uPrpvnTp17M0338yy9qdYsWLWpEkT1yTUt29ft7xKlSpuG3TZuHFjcP23337bUlNTrVChQlayZEnr2LGjbdmyJd1jrl+/3tq3b29ly5Z1z3/BBRe49fbv3+9u12MeOnTIlcl7joz9EkJrpUT7Z9iwYe6xChcubNdee639+9//zrQ9e/bscbUitWrVcv0qihYtajfccIOtXLkyuM6//vUv95pK165dg2XwamTmz59vt912m1144YUu3FasWNE1Of3666+Znk+v04wZMzIFSO2n+vXru7LqNb7mmmts5syZweNFZf/ss8+Czx3aj0vHh55P6+n5tc06XlQj5h1b2h9jx44N3j+7jh496h5bx+T5559vbdq0sR9//DHsulu3brW7777bHUcqh47FCRMmpFtH+1LPr+Y/1ahVqFDBPa76J+n11vM9/PDDVrp0afd6aH9rWagTJ07YU0895d5feh5td//+/TOtl92+eWvXrrXbb7/dvfbqI9WrVy87cuRIpvWzcyxHcixkpNpF7We9tgcPHszWj5GWLVtakSJFrHz58jZ06NCz/lzI7vsF8SVfrAsAeFavXu2aNfQhpg9XfVAPHjzYfehkR48ePVwI0BfDV199ZePGjXNBSM1M+kBVM5BqD0aMGGE1a9Z0X3Iefajpy05fGApRGzZssDFjxtjy5cvtyy+/zLLGSR/M+sD97rvv7KGHHnJBZsqUKS5g6ItVXwah9PzXX3+968Nyyy232Lfffmvvvfee/e1vf7NSpUq5dbT98vTTT9vAgQPdl8s999xju3btspdeesl9uatc2jYFPH2I68vL2359kX7yySfu+RW21GdF91dAuPfee91j68vPs337dvd4+gLwDBo0yH2g33jjje6ybNky99ro+TJ+iahpTV9a2nZ1FlZobdq0qf3nP/9xXyyXXnqpe2w9pp7/6quvdvdt1KiR+1/76/Dhw3b//fe7L1A1x2k7FRR0W6glS5a4/aAyefR663jR4+l5ChQoYIsWLXLNViqzvsC0bxQI/vKXv7j7eMeUvihVnm+++caFjyuuuMIFn48//tg9v/a19t+f/vQn97qFHjPZof2uL/477rjDlU9lClf7p/121VVXuUCh40jHwD//+U8XrA8cOOBCTajhw4e7IPHEE0+4Y0/7S8donjx53Jez9ofeAzqm9bpo34eWSWFYoUn90bSv9HjaBx9++KFFSsenQpQeQ8/54osvujJMnDgxuE52juVIj4WMx4XeB/Xq1bOPPvrI7ZvTOXnypOvHpX2ufm8K1fqs0WdO6Psgu58L2X2/IM4EgDjRtm3bQHJycmDTpk3BZf/5z38CefPm1c+y4LJKlSoFunTpEvz79ddfd7e3bNkycOrUqeDyhg0bBpKSkgL33XdfcNmJEycCF1xwQaBp06bBZfPnz3f3f+edd9KVZ8aMGZmW636h9x09erRb5+233w4uO3bsmHvu8847L3DgwIHg8kOHDrntU3k9I0aMcPffsGFDuufeuHGj2+6nn3463fLVq1cH8uXLF1y+fPlyd/8pU6acdt8WKVIk3T4LNX78+EChQoUChw8fdn/v3LkzUKBAgUDr1q3T7c/+/fu75wp9nCNHjgROnjyZ7vG0LQULFgwMHTo0uGzJkiXuvqHb7vGeN9Tw4cPdaxd6LMjAgQPd6+9Zv359IE+ePIF27dplKkdo2S+77LJ0r5tn0KBBrlxTp07NdFvo/bXOgw8+GIjEihUr3P0eeOCBdMvvuOMOt3zw4MHBZd26dQuUK1cusHv37nTrduzYMVCsWLHgPpo3b567b82aNd1x5unUqZPbXzfccEO6++s4DN1fXpnuueeedOv16dPHLZ87d262t0/l133atGmTbrm2V8tXrlwZ0bEcybGgY1DHtHzxxReBokWLuuNVx+OZ6L4qX48ePdK91rq/jvtdu3ZF9LkQyfsF8YUmMMQF/SJT59a2bdu62hqPag/0yy479Gs5tHmiQYMGrmpayz158+Z1vxJVc+HRL0vVlOgXvn79exdV16vWYN68eVk+p2p0VOvSqVOn4DL9KtSvRdUuqNnFo1//qqlRE9GZTJ061VW/6xdzaJn0XNWqVQuWSeUW7Tv9cj4b2gZV2Xu/mmfPnu1+uarWJHR/ZqyFEDVTqNbBew1//vlnt88uueQS9ys4O0J/raupTtup2hK9dvqlnbGsoTUoqn3SftIvcK8cnuw0VX3wwQeuybJdu3aZboukqSsclVV0LITKuB+1nSrHzTff7K6Hvt469tW0lXFfqiYqtFbSO9ZVixVKy9XMpJqN0DL17t073XqqCfKaQiP14IMPpvtbx03oc2X3WI70WBDdV/vouuuuc8+j4zG7VNPm8WredNzr+I/kcyGS9wviC01giAuqEldzkj4QM9KXqfdhejqhwSk0HKgfQcbloW346kOjLxn1m8iqj09WNm3a5Mqc8ctXwc273aMvF4Wv7DTpqUz60A+3P8T78lPzhr7MRo0aZe+8845rzlE/E41U8rb/dI4fP26zZs1yzReh2yQZn1vNMupfE0pfbC+88IIbZaXmAYUgj5owsmPz5s0uwKjZKWPfCq8fk9dUpyAQ2kTx/fffu33vTSsQKd1f/aeiQftRZQttbvSO54zHvpor1WSrS3aOwUiOdb1G2o96PbwyVa1aNd16CiNqhgo9XrMr43Gi7dVzeH3ZsnssR3IsiPoZKQwrkKhPlJqVs0vlu+iii9It+/3vf+/+Dy13dj4XInm/IL4QgJAwVLuT3eWhnR31BaEPOQWIcLw+Ob+VQpz6EmSHyqRfk+oHEq78oRO5jRw50vU5Ut8HdfxVjYPXH0OdMk9HHcfVxyS0T00k1K9KfTtU86COtercqi8X/frVNpyJApN+Yasz9eOPP+6Gl6tTqvoxaZtCH0P7Qh1RVVuVSLxtVGjt0qVL2HVq16591se6ZOzc+1trt04n42Nn91iO5FgQ1fbouNVxrz48N910U45ux7n6XEDsEIAQF/Rhoupv/erKSMPGo0m/WFWNraHVZ+o8mZGGjq9atcp9WIbWAmlkjHe7rFmzxv26zdgBNqsvIpVJX1qq4fF+mZ6ORmHpMmDAANfpW9uSlpbmOmae7nlUK6XaE3ViDd0m0WsR+itZNRUZf5X/z//8jwsk48ePT7dcNRpep+7TPb86vqsjuDrlhnYwVq1UuLKGNtV5+0n7Xh2u69atm+X+Od1+1msTDdqPKptqmUJrfTIez94IMQWA5s2bR6UsGcuk19arpfQ6Yes18177SOixdJx61Clbz+EdU9k9liM5FrzXVOFE8zOpE74CVnZnaVf51AweWh49t4SWOzufC5G8XxBf6AOEuKBfhmrLV58OBQWPRqaof0s0qW+CvnxUg5GR+k6cbpJC/QJV08zkyZPT3UcjV/TLVqOhvNofNX2pCSyUfuFKxufQCDHtE41wyvjrXX+rr42o9sbr3+FREFIYCx3WrOcJtx0Z+9SIvoTVLKFtCH3ucKd/UBkzlk99J/SrPTvb6dUIhD6GrqtZLVxTXcayqs+YtlXNYhlrCEIfM6vtV/OXhuyHG/2Ucbsi5fX10qioUBn3o/aByqF+QOHCmL5Ic4pX05exDGpClbOZn0rTA4TScRO6/dk9lrN7LITSiD/1/dE0C+pDpVFjoX766Sf3Y0THT0YazRX6PPpbx736E0XyuRDJ+wXxhRogxA19QKoqW/1YHnjggWCQ0BwcqmWJFoUUDXdVs5HmEtHwVX2g6Redvsz1Aawhw+FoWLeGfauKfunSpe7Xo2pFNERWH4D6Ze/VXugLIWNNhPoviIZna14UPa8+yPXrU7U3OvWC+iToi16PpX42+rLW82r+HXWsVudN/QLWr1ntMw3b9r5UQ59Hv2b1Raeh6fo1rup9BcxXXnklU42EHlv7Q80K+tJUB1T9wg6t1RHdrvChpj11VtWveP0qz9i/QtujPiaqldJ2KJCog66aOXSbnk+hSXPJKAhk/OXsNdVl/IJWXxbtO31J6bjRl62aRjQsWtvp9W3S9ms7tU91H237H/7wBzcPk14v7T8142k9NcGoD4rKqg7SZ0s1Uuocr/5R6kui/TNnzhxXQ5LRM8884zrVap90797d1cqpHOrzpNdN13OCtkfNbOprpC9wHfsKDap10TF2Ns2LOibV70zDyhcuXBgc9u/tu+wey9k9FjJS7YymfdDrqfeYBh5omgvRc2rb9FyhtZxqStVnjfaF9rmObb1HNR+S17SV3c+FSN4viDOxHoYGhPrss88CqampbljpRRddFEhLSwsOtz3TMHgNtQ7l3c8b1hpuCG2ocePGuefWkPDzzz8/UKtWrcBjjz0W2LZtW5bD4GXHjh2Brl27BkqVKuXKrfuFDvfet2+fG+77/vvvh32xn3rqqUCFChXccO6MQ+I/+OCDQJMmTVx5dalevbobjr1u3Tp3+w8//BC4++67AxdffLEbYl+yZMnAtddeG5g9e3a651i7dm3gmmuucdvmDc0dM2aMG2J9/PjxTGXSkPIhQ4a4odm6T7NmzQJr1qzJtO817PjRRx8Nrte4cePAwoULw+6njz76KFCjRg23L0KHxGuqg+bNm7tpA7QPu3fv7oZQh66jYdq6b1YmTJgQuPzyy93w+xIlSrjnnjVrVvD27du3u2HKel31uKFl+/nnnwMPPfSQew30+mmaBG1j6JD0sxkGL7/++mugZ8+egZSUFPf63XzzzYEtW7ZkGgbvHUd6jooVKwby588fKFu2bOC6665zx6XHGwafcdqDSN4Der312lapUsU9j56vX79+2RpCHu6x9frdeuutbt9q32tfarszOtOxnN1jIav3sF4vHSPab5oewVsv43vKu+/3338faNGiRaBw4cKBMmXKuO3JOJVCdj8Xsvt+QXxJ0j+xDmFAItMIlTvvvNMNoc3OyKxzRb9U1UwXyUlFY0U1Ivp1Ha2TtSJymmxRtbZqoqOmA7kRTWBAlKnpR/1A4in8iDqMerMyxzPNsdKhQwfXJwMAcgo1QAAQIXV8P1O/lHgLvNmlCTzPdC4t9XtRvytqgJCbUQMEABEqV67caW9X51rvZK+5zfPPP++CzemoUzGQ21EDBAAR8k6XkBWNQDvb2aljTfPjhJ4qJpwmTZq4kVRAbkYAAgAAvsNEiAAAwHfoAxSGZpTdtm2bm6wrmufMAQAAOUcz+/zyyy+uGTrjSaozIgCFofCT8azKAAAgd9iyZcsZTwZNAArDO32BdqCmYwcAAPFPp8xRBYb3PX46BKAwvGYvhR8CEAAAuUt2uq/QCRoAAPgOAQgAAPgOAQgAAPgOAQgAAPgOAQgAAPgOAQgAAPgOAQgAAPgOAQgAAPgOAQgAAPgOAQgAAPgOAQgAAPgOAQgAAPgOAQgAAPgOAQgAAPhOvlgXwM9S+06MdRGAuLN0ROdYFwGAD1ADBAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfIcABAAAfCcuAtDYsWOtcuXKlpycbA0aNLDFixefdv0pU6ZY9erV3fq1atWy6dOnZ7nufffdZ0lJSTZ69OgolBwAAORGMQ9AkydPtt69e9vgwYNt2bJlVqdOHWvZsqXt3Lkz7PoLFiywTp06Wbdu3Wz58uXWtm1bd1mzZk2mdT/88EP76quvrHz58udgSwAAQG4R8wA0atQo6969u3Xt2tVq1KhhaWlpVrhwYZswYULY9V944QVr1aqV9e3b1y699FJ76qmn7IorrrAxY8akW2/r1q3Wo0cPe+eddyx//vznaGsAAEBuENMAdOzYMVu6dKk1b978/wqUJ4/7e+HChWHvo+Wh64tqjELXP3XqlP3pT39yIemyyy47YzmOHj1qBw4cSHcBAACJK6YBaPfu3Xby5EkrU6ZMuuX6e/v27WHvo+VnWv/ZZ5+1fPnyWc+ePbNVjuHDh1uxYsWCl4oVK57V9gAAgNwh5k1gOU01Smome+ONN1zn5+zo16+f7d+/P3jZsmVL1MsJAAB8GoBKlSplefPmtR07dqRbrr/Lli0b9j5afrr158+f7zpQX3jhha4WSJdNmzbZo48+6kaahVOwYEErWrRougsAAEhcMQ1ABQoUsNTUVJszZ066/jv6u2HDhmHvo+Wh68usWbOC66vvz6pVq2zFihXBi0aBqT/Qp59+GuUtAgAAuUG+WBdAQ+C7dOli9erVs/r167v5eg4dOuRGhUnnzp2tQoUKrp+O9OrVy5o2bWojR4601q1b26RJk+zrr7+2cePGudtTUlLcJZRGgamG6JJLLonBFgIAgHgT8wDUoUMH27Vrlw0aNMh1ZK5bt67NmDEj2NF58+bNbmSYp1GjRvbuu+/agAEDrH///latWjWbNm2a1axZM4ZbAQAAcpOkQCAQiHUh4o2GwWs0mDpER7M/UGrfiVF7bCC3Wjqic6yLAMAH398JNwoMAADgTAhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdwhAAADAdyIOQG+++ab94x//CP792GOPWfHixa1Ro0a2adOmnC4fAABA7APQX//6VytUqJC7vnDhQhs7dqw999xzVqpUKXvkkUdyvoQAAAA5LF+kd9iyZYtVrVrVXZ82bZq1b9/e7r33XmvcuLE1a9Ysp8sHAAAQ+xqg8847z37++Wd3febMmXb99de768nJyfbrr7/mfAkBAABiXQOkwHPPPffY5Zdfbt9++63deOONbvm///1vq1y5ck6XDwAAIPY1QOrz07BhQ9u1a5d98MEHlpKS4pYvXbrUOnXqlPMlBAAAiHUNkEZ8jRkzJtPyIUOG5FSZAAAA4m8eoPnz59tdd93lhr5v3brVLXvrrbfsiy++yOnyAQAAxD4AqdmrZcuWbij8smXL7OjRo275/v373RB5AACAhAtAw4YNs7S0NHv11Vctf/78weUaBq9ABAAAkHABaN26dXbNNddkWl6sWDHbt29fTpULAAAgfgJQ2bJl7bvvvsu0XP1/LrroopwqFwAAQPwEoO7du1uvXr1s0aJFlpSUZNu2bbN33nnH+vTpY/fff390SgkAABDLYfBPPPGEnTp1yq677jo7fPiwaw4rWLCgC0A9evTIybIBAADERwBSrc9f/vIX69u3r2sKO3jwoNWoUcOdIgMAACBh5wGSAgUKuOBTvXp1mz17tn3zzTc5WzIAAIB4CUC33357cCZonfz0yiuvdMtq167t5ggCAABIuAD0+eef29VXX+2uf/jhh64/kIa/v/jii26OIAAAgIQLQJrxuWTJku76jBkzrH379la4cGFr3bq1rV+//qwKoROs6kzyycnJ1qBBA1u8ePFp158yZYpretP6tWrVsunTp6e7/cknn3S3FylSxEqUKGHNmzd3o9YAAADOKgBVrFjRFi5caIcOHXIBqEWLFm753r17XSCJ1OTJk6137942ePBgN5N0nTp13Kk2du7cGXb9BQsWuLPOd+vWzZYvX25t27Z1lzVr1gTX+f3vf++a6VavXu3mJ1K4Ujl1BnsAAICkQCAQiGQ3vPzyy24eII36qlSpkgstefLksZdeesmmTp1q8+bNi2ivqsZH/Yi8fkVqUlPI0pB6DbnPqEOHDi58ffLJJ8FlV111ldWtW9edoiOcAwcOuJmq1Vlbw/fPxFtftV1Fixa1aEntOzFqjw3kVktHdI51EQDkUpF8f0dcA/TAAw/YV199ZRMmTHC1Kwo/olmgI+0DdOzYMVu6dKlrogoWKE8e97dqmcLR8tD1RTVGWa2v5xg3bpzbIapdCkcndNVOC70AAIDEFfE8QJKamuouodQHKFK7d++2kydPWpkyZdIt199r164Ne5/t27eHXV/LQ6mGqGPHjm6yxnLlytmsWbOsVKlSYR9z+PDhNmTIkIjLDwAAfBSAfvzxR/v4449t8+bNroYl1KhRoyweXHvttbZixQoXsnTmeg3VV0fo0qVLZ1q3X79+rh+SRzVAaoYDAACJKeIANGfOHGvTpo1r8lItTc2aNW3jxo2mrkRXXHFFRI+lGpm8efPajh070i3X3zrpajhanp31NQKsatWq7qI+QtWqVbPx48e7sJORTuWhCwAA8IeI+wApQOi8XxphpVFfmvxwy5Yt1rRpU7vtttsink1aTWkKVR51gtbfDRs2DHsfLQ9dX9S8ldX6oY+rvj4AAAARByCd8qJz5/8dpZEvXz43G7RGhA0dOtSeffbZiPeomp7URPXmm2+6x9YZ5TXKq2vXru52PVdorY1GoGn4/ciRI10NlOb8+frrr+2hhx5yt+u+/fv3dx21N23a5DpZ33333bZ169aIAxoAAEhMETeBqWnJ6/ejzsXff/+9XXbZZe5v9beJlIa1a36eQYMGuY7MGs6ugON1dFY/I2+kmTRq1MjeffddGzBggAs6atqaNm2aa4oTNakpGClQqTwpKSlumP38+fOD5QQAAP4W8TxAmnRQI766d+/umsI++ugj+/Of/+zmANKsy5prJ7djHiAgdpgHCMC5+P6OuAZIo7wOHjzormvouK5rNmfVxMTLCDAAAIAcDUAa/RXaHJbV7MsAAAAJNQ+QqOOxOi1LjRo1Mk2MCAAAkDABSJMg6mSkX375pRUvXtwt27dvn+ucPGnSJLvggguiUU4AAIDYDYO/55577Pjx4672Z8+ePe6i65pnR7cBAAAkXA3QZ599ZgsWLLBLLrkkuEzXdTb4q6++OqfLBwAAEPsaIJ0jSzVAGemkpuXLl8+pcgEAAMRPABoxYoT16NHDdYL26LpmaH7++edzunwAAACxaQLTBIdJSUnBv3W6iQYNGrhTYciJEyfcdZ1yQhMlAgAA5PoANHr06OiXBAAAIJ4CUJcuXaJfEgAAgHjtAwQAAJDbEYAAAIDvEIAAAIDvEIAAAIDvEIAAAIDvZGsU2C233JLtB5w6depvKQ8AAEB81AAVK1YseClatKjNmTMn3UzQS5cudct0OwAAQELUAL3++uvB648//rjdfvvtlpaWZnnz5g2eB+yBBx5w4QgAACDh+gBNmDDB+vTpEww/ouu9e/d2twEAACRcANJ5v9auXZtpuZadOnUqp8oFAAAQ2yawUF27drVu3brZ999/b/Xr13fLFi1aZM8884y7DQAAIOEC0PPPP29ly5a1kSNH2k8//eSWlStXzvr27WuPPvpoNMoIAAAQ2wCUJ08ee+yxx9zlwIEDbhmdnwEAQMJPhKh+QLNnz7b33nvPkpKS3LJt27bZwYMHc7p8AAAAsa8B2rRpk7Vq1co2b95sR48eteuvv97OP/98e/bZZ93fGh4PAACQUDVAvXr1snr16tnevXutUKFCweXt2rVzkyECAAAkXA3Q/PnzbcGCBVagQIF0yytXrmxbt27NybIBAADERw2Q5vrRzM8Z/fjjj64pDAAAIOECUIsWLWz06NHBv9UJWp2fBw8ebDfeeGNOlw8AACD2TWCa/6dly5ZWo0YNO3LkiN1xxx22fv16K1WqlBsVBgAAkHAB6IILLrCVK1fapEmTbNWqVa72RzND33nnnek6RQMAACRMAHJ3ypfP7rrrrpwvDQAAQLwEoI8//thuuOEGy58/v7t+Om3atMmpsgEAAMQuALVt29a2b99upUuXdtezog7R4UaIAQAA5LoApKHv4a4DAAAk7DD4kiVL2u7du931u+++23755ZdolwsAACC2AejYsWPBM7+/+eabbvg7AABAQjeBNWzY0PX9SU1NtUAgYD179sxyyPuECRNyuowAAADnPgC9/fbb9re//c2+//5719F5//791AIBAIDEDkBlypSxZ555xl2vUqWKvfXWW5aSkhLtsgEAAMTHRIgbNmyITkkAAADiKQC9+OKLdu+991pycrK7fjrqHwQAAJDrA5D6/+hcXwpAup4V9Q8iAAEAgIQIQKHNXjSBAQAAX8wDBAAA4LsaoN69e2f7AUeNGvVbygMAABAfAWj58uXp/l62bJmdOHHCLrnkEvf3t99+a3nz5nUTJQIAACREAJo3b166Gp7zzz/fnRKjRIkSbtnevXuta9eudvXVV0evpAAAALHqAzRy5EgbPnx4MPyIrg8bNszdBgAAkHABSCdF3bVrV6blWsZZ4gEAQEIGoHbt2rnmrqlTp9qPP/7oLh988IF169bNbrnlluiUEgAAIJanwkhLS7M+ffrYHXfcYcePH//fB8mXzwWgESNG5GTZAAAA4iMAFS5c2F5++WUXdnR2eLn44outSJEi0SgfAABA7AOQR4GnZMmSwesAAAAJ2wfo1KlTNnToUCtWrJhVqlTJXYoXL25PPfWUuw0AACDhaoD+8pe/2Pjx4+2ZZ56xxo0bu2VffPGFPfnkk3bkyBF7+umno1FOAACA2AUgTYD42muvWZs2bYLLateubRUqVLAHHniAAAQAABKvCWzPnj1WvXr1TMu1TLcBAAAkXACqU6eOjRkzJtNyLdNtAAAACdcE9txzz1nr1q1t9uzZ1rBhQ7ds4cKFtmXLFps+fXo0yggAABDbGqCmTZu6s79rRuh9+/a5i2aAXrduHSdDBQAAiTsPUPny5ensDAAA/BWANNx91apVtnPnzkxz/4SODgMAAEiIADRjxgzr3Lmz7d69O9NtSUlJdvLkyZwqGwAAQHz0AerRo4fddttt9tNPP7nan9AL4QcAACRkANqxY4f17t3bypQpE50SAQAAxFsAuvXWW+1f//pXdEoDAAAQj32ANOGhmsDmz59vtWrVsvz586e7vWfPnjlZPgAAgNgHoPfee89mzpxpycnJriZIHZ89uk4AAgAACdcEprPBDxkyxPbv328bN260DRs2BC8//PDDWRVi7NixVrlyZReqGjRoYIsXLz7t+lOmTHHnHtP6qoUKnYH6+PHj9vjjj7vlRYoUcXMWadTatm3bzqpsAAAg8UQcgI4dO2YdOnSwPHkivmtYkydPdp2qBw8ebMuWLXPnE2vZsqWbYyicBQsWWKdOnaxbt262fPlya9u2rbusWbPG3X748GH3OAMHDnT/T5061c1SzfxEAADAkxQIBAIWgUceecR+97vfWf/+/S0nqMbnyiuvDJ5gVcPpK1as6IbbP/HEE5nWV/g6dOiQffLJJ8FlV111ldWtW9fS0tLCPseSJUusfv36tmnTJrvwwgsz3X706FF38Rw4cMCVQbVcRYsWtWhJ7Tsxao8N5FZLR3SOdREA5FL6/i5WrFi2vr8j7gOkuX50QtRPP/3UateunakT9KhRoyKqTVq6dKn169cvuEw1S82bN3cnWA1Hy1VjFEo1RtOmTcvyebQj1D+pePHiYW8fPny4a9YDAAD+EHEAWr16tV1++eXuutfs5AntEJ0dmk1agSrjnEL6e+3atWHvs3379rDra3lWp+1QnyA1m2WVBhXAQkOVVwMEAAASU8QBaN68eZZbqEP07bffbmrle+WVV7Jcr2DBgu4CAAD84axOhppTSpUqZXnz5nWzS4fS32XLlg17Hy3Pzvpe+FG/n7lz50a1Lw8AAMhdcmYo11kqUKCApaam2pw5c4LL1Alafzds2DDsfbQ8dH2ZNWtWuvW98LN+/XqbPXu2paSkRHErAABAbhPTGiBR35suXbpYvXr13Eit0aNHu1FeXbt2dbdrDp8KFSq4jsrSq1cva9q0qY0cOdJat25tkyZNsq+//trGjRsXDD86XYeGwGukmPoYef2DSpYs6UIXAADwt5gHIA1r37Vrlw0aNMgFFQ1nnzFjRrCj8+bNm9PNOdSoUSN79913bcCAAW4ofrVq1dwIsJo1a7rbt27dah9//LG7rsfK2H+pWbNm53T7AABAAswD5AeRzCPwWzAPEJAZ8wABiMt5gER9a1Sbotma1WcnlGpyAAAA4lnEAejVV1+1+++/343g0sirjCdDJQABAICEC0DDhg2zp59+2k0uCAAA4Ith8Hv37rXbbrstOqUBAACIxwCk8DNz5szolAYAACAem8CqVq1qAwcOtK+++spq1aqV6WSoPXv2zMnyAQAAxD4AacLB8847zz777DN3CaVO0AQgAACQcAFow4YN0SkJAABAbjgXmOZQZB5FAADgiwA0ceJE1/+nUKFC7lK7dm176623cr50AAAA8dAENmrUKNcJ+qGHHrLGjRu7ZV988YXdd999tnv3bnvkkUeiUU4AAIDYBaCXXnrJXnnlFXeWdk+bNm3ssssusyeffJIABAAAEq8J7KeffnJnZM9Iy3QbAABAwgUgzQP0/vvvZ1o+efJkq1atWk6VCwAAIH6awIYMGWIdOnSwzz//PNgH6Msvv7Q5c+aEDUYAAAC5vgaoffv2tmjRInc2+GnTprmLri9evNjatWsXnVICAADEsgZIUlNT7e23387JcgAAAMRXADpw4IAVLVo0eP10vPUAAABydQAqUaKEG+FVunRpK168uDvnV0aaEVrLT548GY1yAgAAnNsANHfuXCtZsqS7Pm/evJx7dgAAgHgNQE2bNg1er1KlilWsWDFTLZBqgLZs2ZLzJQQAAIj1KDAFoF27dmVavmfPHncbAABAwgUgr69PRgcPHrTk5OScKhcAAEDUZHsYfO/evd3/Cj86GWrhwoWDt6njs+YGqlu3bnRKCQAAEIsAtHz58mAN0OrVq61AgQLB23S9Tp061qdPn5wsGwAAQGwDkDf6q2vXrvbCCy8w3w8AAPBPH6DRo0fbiRMnwnaCPtMkiQAAALkyAHXs2NEmTZqUablOhKrbAAAAEi4AqbPztddem2l5s2bN3G0AAAAJF4COHj0atgns+PHj9uuvv+ZUuQAAAOInANWvX9/GjRuXaXlaWpo7SzwAAEDCjALzDBs2zJo3b24rV6606667zi2bM2eOLVmyxGbOnBmNMgIAAMS2Bqhx48a2cOFCdz4wdXz++9//blWrVrVVq1bZ1VdfnbOlAwAAiIcaINGMz++8807OlwYAACBeA5DnyJEjduzYsXTLihYt+lvLBAAAEF9NYIcPH7aHHnrISpcubUWKFLESJUqkuwAAACRcAOrbt6/NnTvXXnnlFStYsKC99tprNmTIECtfvrxNnDgxOqUEAACIZROYOj0r6GjiQ50XTB2f1Qm6UqVKrl/QnXfemZPlAwAAiH0NkM75ddFFFwX7++hvadKkiX3++ec5X0IAAIBYByCFnw0bNrjr1atXd0PhvZqh4sWL53T5AAAAYh+A1OylSRDliSeesLFjx1pycrI98sgjrn8QAABAwvUBUtDxaEbotWvX2tKlS10/oNq1a+d0+QAAAGJbA6QTnur0F+vXrw8uU+fnW265hfADAAASMwDlz5/fnfICAADAV32A7rrrLhs/fnx0SgMAABCPfYBOnDhhEyZMsNmzZ1tqaqqbDTrUqFGjcrJ8AAAAsQ9Aa9assSuuuMJd//bbb9PdlpSUlHMlAwAAiGUAUr+fmjVrWp48eWzevHnRKgsAAED89AG6/PLLbffu3cGJEH/++edolwsAACC2AUgzPHuzP2/cuNFOnToVvRIBAADEQxNY+/btrWnTplauXDnXz6devXqWN2/esOv+8MMPOV1GAACAcx+Axo0b5yY7/O6776xnz57WvXt3O//883O2JAAAAPE2CqxVq1buf532olevXgQgAADgn2Hwr7/+enRKAgAAEK8zQQMAAOR2BCAAAOA7BCAAAOA7BCAAAOA7BCAAAOA7BCAAAOA7BCAAAOA7BCAAAOA7BCAAAOA7BCAAAOA7BCAAAOA7BCAAAOA7BCAAAOA7BCAAAOA7BCAAAOA7BCAAAOA7MQ9AY8eOtcqVK1tycrI1aNDAFi9efNr1p0yZYtWrV3fr16pVy6ZPn57u9qlTp1qLFi0sJSXFkpKSbMWKFVHeAgAAkNvENABNnjzZevfubYMHD7Zly5ZZnTp1rGXLlrZz586w6y9YsMA6depk3bp1s+XLl1vbtm3dZc2aNcF1Dh06ZE2aNLFnn332HG4JAADITZICgUAgVk+uGp8rr7zSxowZ4/4+deqUVaxY0Xr06GFPPPFEpvU7dOjgAs4nn3wSXHbVVVdZ3bp1LS0tLd26GzdutCpVqrigpNtP5+jRo+7iOXDggCvH/v37rWjRohYtqX0nRu2xgdxq6YjOsS4CgFxK39/FihXL1vd3zGqAjh07ZkuXLrXmzZv/X2Hy5HF/L1y4MOx9tDx0fVGNUVbrZ9fw4cPdDvMuCj8AACBxxSwA7d69206ePGllypRJt1x/b9++Pex9tDyS9bOrX79+Li16ly1btvymxwMAAPEtX6wLEA8KFizoLgAAwB9iVgNUqlQpy5s3r+3YsSPdcv1dtmzZsPfR8kjWBwAAiKsAVKBAAUtNTbU5c+YEl6kTtP5u2LBh2Ptoeej6MmvWrCzXBwAAiLsmMA2B79Kli9WrV8/q169vo0ePdqO8unbt6m7v3LmzVahQwXVSll69elnTpk1t5MiR1rp1a5s0aZJ9/fXXNm7cuOBj7tmzxzZv3mzbtm1zf69bt879r1oiaooAAEDMA5CGte/atcsGDRrkOjJruPqMGTOCHZ0VZDQyzNOoUSN79913bcCAAda/f3+rVq2aTZs2zWrWrBlc5+OPPw4GKOnYsaP7X3MNPfnkk+d0+wAAQHyK6TxAiTCPwG/BPEBAZswDBCCh5wECAACIFQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwHQIQAADwnXyxLgAAJKLNQ2vFughA3Llw0GqLF9QAAQAA3yEAAQAA34mLADR27FirXLmyJScnW4MGDWzx4sWnXX/KlClWvXp1t36tWrVs+vTp6W4PBAI2aNAgK1eunBUqVMiaN29u69evj/JWAACA3CLmAWjy5MnWu3dvGzx4sC1btszq1KljLVu2tJ07d4Zdf8GCBdapUyfr1q2bLV++3Nq2besua9asCa7z3HPP2YsvvmhpaWm2aNEiK1KkiHvMI0eOnMMtAwAA8SrmAWjUqFHWvXt369q1q9WoUcOFlsKFC9uECRPCrv/CCy9Yq1atrG/fvnbppZfaU089ZVdccYWNGTMmWPszevRoGzBggP3xj3+02rVr28SJE23btm02bdq0c7x1AAAgHsV0FNixY8ds6dKl1q9fv+CyPHnyuCarhQsXhr2PlqvGKJRqd7xws2HDBtu+fbt7DE+xYsVc05ru27Fjx0yPefToUXfx7N+/3/1/4MABi6aTR3+N6uMDuVG033fnyi9HTsa6CIDv3t8H/v/jqzIkrgPQ7t277eTJk1amTJl0y/X32rVrw95H4Sbc+lru3e4ty2qdjIYPH25DhgzJtLxixYoRbhGA36rYS/exE4FENbzYOXmaX375xVV+nA7zAJm5GqjQWqVTp07Znj17LCUlxZKSkqL/SiGm9ItBYXfLli1WtGhRXg0ggfD+9pdAIODCT/ny5c+4bkwDUKlSpSxv3ry2Y8eOdMv1d9myZcPeR8tPt773v5ZpFFjoOnXr1g37mAULFnSXUMWLFz/LrUJupfBDAAISE+9v/yh2hpqfuOgEXaBAAUtNTbU5c+akq33R3w0bNgx7Hy0PXV9mzZoVXL9KlSouBIWuo18AGg2W1WMCAAB/iXkTmJqeunTpYvXq1bP69eu7EVyHDh1yo8Kkc+fOVqFCBddPR3r16mVNmza1kSNHWuvWrW3SpEn29ddf27hx49ztarJ6+OGHbdiwYVatWjUXiAYOHOiqwzRcHgAAIOYBqEOHDrZr1y43caE6KauZasaMGcFOzJs3b3YjwzyNGjWyd9991w1z79+/vws5GgFWs2bN4DqPPfaYC1H33nuv7du3z5o0aeIeUxMnAhmp+VPzUGVsBgWQ+/H+RlaSAtkZKwYAAJBAYj4RIgAAwLlGAAIAAL5DAAIAAL5DAAIAAL5DAAIAAL5DAIIv6ES4mnVcc0ediQZGaloGzSReqFAhd2Ld9evXn5NyAsiapkrp0aOHXXTRRW54u05hc/PNN6eb+Hb58uVuehW9f7VOpUqV7KabbrK///3vpz1BJu97/yEAwRfGjx/vPjg///xz27Zt22nXfe655+zFF1+0tLQ0N4N4kSJFrGXLlnbkyJFzVl4A6W3cuNGdOWDu3Lk2YsQIW716tZvf7dprr7UHH3zQrfPRRx/ZVVddZQcPHrQ333zTvvnmG7dOu3bt3Nxx+/fvz3K38r73H+YBQsLTh6F+DWrGcE14WLt2bTeJZla/AjVr+KOPPmp9+vRxy/ShqYk533jjDevYseM5Lj0AufHGG23VqlW2bt0696MklCa8zZ8/v6vtueaaa2zq1KlZvr/DneCa970/UQOEhPf+++9b9erV7ZJLLrG77rrLJkyYkGVV+IYNG1w1u5q9Qk+s16BBA9eMBuDc27Nnj6vJUU1PxvDjnbx65syZ9vPPP7szAWQlXPgR3vf+RACCL5q/FHykVatWrkbns88+C7uuwo94p2Lx6G/vNgDn1nfffed+tOiHTFa+/fZb979+6HiWLFli5513XvDyySefhL0v73t/IgAhoam6fPHixdapUyf3d758+VwHSYUiALnD2Z6xSc3dK1ascBedH/LEiRM5XjbkXgQgJDQFHX3oqV+Pwo8ur7zyin3wwQdhO0SWLVvW/b9jx450y/W3dxuAc0snvVbz1dq1a0+7jvejx6NRYFWrVnWX0+F9708EICQsBZ+JEyfayJEjg78CdVm5cqULRO+9916m+1SpUsV9GIYOqz1w4IAbDdawYcNzvAUApGTJkm4k5tixY11NTkbqBN2iRQu33rPPPhvxTuN970/5Yl0AIFrU3r93717r1q2b68gcqn379q526L777ku3XL8yH374YRs2bJj7RakPxoEDB7rA1LZtW14sIEYUfho3bmz169e3oUOHuuYt/ciZNWuWq9XVkPfXXnvNNXFrvq+ePXu697BGgaoDtWgusHB43/tUAEhQN910U+DGG28Me9uiRYvUqSCwcuXKQKVKlQKDBw8O3nbq1KnAwIEDA2XKlAkULFgwcN111wXWrVt3DksOIJxt27YFHnzwQfeeLVCgQKBChQqBNm3aBObNmxdcZ8mSJYFbb701ULp06UC+fPkCKSkpgZYtWwYmTZrk3tse3vdgHiD42uHDhy0lJcX++c9/WrNmzWJdHADnAO97CH2A4Gvz5s2zP/zhD4QfwEd430OoAQIAAL5DDRAAAPAdAhAAAPAdAhAAAPAdAhAAAPAdAhAAAPAdAhAAAPAdAhAAAPAdAhAAAPAdAhAAADC/+X+6AJnqK20wSAAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -1070,13 +1559,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e1ee52758d5a49cf8e7698b298f634fe", + "model_id": "ee40d8033ae149e8849b672d240d4ed1", "version_major": 2, "version_minor": 0 }, @@ -1090,7 +1579,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c691518c29804e97b70b09312918f827", + "model_id": "ab696faac6c549fe9d7ba8461c2c2fe2", "version_major": 2, "version_minor": 0 }, @@ -1107,13 +1596,13 @@ "Text(0.5, 1.0, 'dimelo/test/data/ctcf_demo_not_peak.bed')" ] }, - "execution_count": 25, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGzCAYAAADHdKgcAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAO/hJREFUeJzt3Qm8TfX+//HPMQ9FhpspGeImOSgyJrqEKJEKDVxJtwllCtcQKUlcFeWqVCqRm6uu68qQRiIz90aUMZmnKIT9f7y/j//av73P2YezOefsc/Z6PR+Pzdlrr7XXd6299tqf9f1+vt+VEAgEAgYAAOAj2WJdAAAAgIxGAAQAAHyHAAgAAPgOARAAAPAdAiAAAOA7BEAAAMB3CIAAAIDvEAABAADfIQACAAC+QwCEdPPUU09ZQkJC8HnZsmXtz3/+c0z2eKNGjdzDr2K572Np9+7ddscdd1iRIkXcsTh27NgLej+9h45rZH1btmxxn+cLL7yQoctG66233nLr0jqRtgiAgFTq1auXVa5c2f29aNEi90N46NChdN1/zz77rM2cOTPF18+cOWN/+MMf7Pnnn0+X9e/cudNt56pVqy74vQ4ePGg5cuSwDz74INXLvPLKK+4H4Hw98cQT9sknn1j//v3tnXfesebNm5/3eyH9PicgFgiAkGE2bNhgr732Wpbd4//+97+tZcuWwQBo6NChMQ+Ali5davv27QuWKz0CIG1nWgRACkR0Jdu0adMM+2H99NNP7bbbbrPevXvbvffea5UqVTrv90LKCICQFREAIcPkzp3bcubMmSX3+I8//ugCuPQKNM7X7NmzrUyZMnb11VdbZqey1q9f3y655JIMW+eePXsydH0Asg4CIKSJr776yq677jrLkyePXXHFFfb3v//9nHkoXtu2lu3evbtrytGP1V/+8hc7efKkq13p2LGjFSpUyD369u1rgUAgWROQ8joUAGjdxYoVc8uruSU1P45dunRxy2jZatWq2dtvv51i7U/BggXt+uuvd01Cffr0cdPLlSvntiFpG/27775rNWrUsLx581rhwoWtffv2tn379rD33Lhxo7Vt29aKFy/u1n/ZZZe5+Q4fPuxe13seO3bMlclbR9I8ntBaKdH+GT58uHuvfPny2Y033mj//e9/k23PgQMHXK1IYmKiXXTRRVagQAG7+eabbfXq1cF5PvvsM/eZSufOnYNl8GpkvvzyS7vzzjvt8ssvd8Ft6dKlXZPTb7/9lmx9+pzmzJmTLIDUfqpVq5Yrqz7jG264webOnRs8XlT2zz//PLju0DwuHR9an+bT+rXNOl5UI+YdW9of48ePDy6fWidOnHDvrWPy4osvtlatWtmOHTsizvvTTz/Z/fff744jlUPH4qRJk8Lm0b7U+tX8pxq1UqVKufdVfpI+b63v8ccft0svvdR9Htrfmhbq1KlT9vTTT7vvl9aj7R4wYECy+VKbm7dp0yZ3POk7p2Nb6/z111+jXue5Pqdz0fyPPfaYvffee3bllVe674K+O1988cV57WudOwYPHuzeQ9uVP39+a9CggS1cuPCcZdHx8uCDD1quXLlsxowZqSr/3/72N3cRou96w4YNbd26dcnmWb9+vfusdS7Q9tWsWdM+/vjjZPNpP/7pT39y76XjWd9lfXeQPnKk0/vCR9auXeuaNfRjoZOrTppDhgxxJ6nU6NatmwsC9MPwzTff2MSJE91JWc1M+nFVM5BqD0aNGmVVqlRxP3IeBTv6sdPJW0HU5s2bbdy4cbZy5Ur7+uuvU6xx0o+0TtL6EdDJV4HM9OnT3Q+Cflh79OgRNr/Wf9NNN7kclttvv92+//57e//9993Jr2jRom4ebb8888wzNmjQILvrrrvsgQcesL1799rLL7/sftxVLm2bTtLNmjVzPyTe9uvkPmvWLLd+nbiVs6LlFSDopCz6IfLs2rXLvd+wYcOC03Ti10mzRYsW7rFixQr32Wh9SWu01LSmAEbbrmRhBa06gf/vf/+zkiVL2lVXXeXeW++p9etHROrVq+f+1/7SD+bDDz/skozVHKftVKCg10J9++23bj+oTB593jpe9H5aj350lixZ4pqtVGYFtto3Cgj++te/umW8Y+ro0aOuPN999537Qbz22mtd4KMfFa1f+1r777777nOfW+gxkxra7wrO7r77blc+lSlS7Z/2W506dYI/4joG/vOf/7jA+siRIy6oCTVixAj349avXz937Gl/6RjNli2bC9q1P/Qd0DGtz0X7PrRMCob1Q6p8NO0rvZ/2wT//+U+Llo5PrUPvoePk9ddfdwHYyJEjo1rn2T6n1FLwNG3aNPcdVmCjJjXla+mY0nc+mn2tv7UtHTp0sK5du9ovv/xib7zxhvu+6f2qV68esQynT592x5LKoW1LTW3v5MmT3fs/+uijdvz4cXvxxRddAKNzorcPFNSo5lNBrz53BWQKhFu3bm0ffvihtWnTJvh91gWLzp/efDoX6nhBOgkAF6h169aBPHnyBLZu3Rqc9r///S+QPXt2VdcEp5UpUybQqVOn4PM333zTvd6sWbPAmTNngtPr1q0bSEhICDz00EPBaadOnQpcdtllgYYNGwanffnll2759957L6w8c+bMSTZdy4UuO3bsWDfPu+++G5x28uRJt+6LLroocOTIkeD0Y8eOue1TeT2jRo1yy2/evDls3Vu2bHHb/cwzz4RNX7t2bSBHjhzB6StXrnTLT58+/az7Nn/+/GH7LNQbb7wRyJs3b+DXX391z/fs2RPIlStXoGXLlmH7c8CAAW5doe9z/PjxwOnTp8PeT9uSO3fuwLBhw4LTvv32W7ds6LZ7vPWGGjFihPvsQo8FGTRokPv8PRs3bgxky5Yt0KZNm2TlCC371VdfHfa5eQYPHuzKNWPGjGSvhS6veR599NFANFatWuWWe+SRR8Km33333W76kCFDgtO6dOkSKFGiRGDfvn1h87Zv3z5QsGDB4D5auHChW7ZKlSruOPN06NDB7a+bb745bHkdh6H7yyvTAw88EDZf79693fRPP/001dun8muZ+++/P2y6PosiRYqc1zpT+pxSQ++lx7Jly4LTdPzoO6cyRbuvda44ceJE2DwHDx4MFCtWLGybdbxrvfou//7774F27dq579Mnn3xyzjJ7y2r+HTt2BKcvWbLETX/iiSeC0xo3bhxITEx037nQY7RevXqBihUrBqc9/vjjblm9h0ffaW1bpHMNLhxNYLggumpScquuZlRb41Htga64UkNXcKHNE7Vr13ZV0ZruyZ49u6s2Vs2FR7UMqinRFb6u/r2Hqr51NXq2Km/V6KjWRVeJHl2J6wpUtQu6IvXo6l81NWoiOhdVm6vKWlfXoWXSuipWrBgsk8ot2ndJmx1SS9ugK0bvCnH+/PmupkdX46H7M2kthOgqW7UO3me4f/9+t8/UBKHagNQIvTJVU522U7Ul+uxUM5W0rKFX1Kp90n5SDYdXDk9qmqp05awmS+/qOdrlz0ZlFR0LoZLuR22nynHrrbe6v0M/bx37atpKui9VExVaK+kd66p5CKXpajJVbUBomXr27Bk2n2plvKbQaD300ENhz1WjpuNANSjptc6U1K1b131vPTqXKHld3w8dn9Hsa50rVJsoOsbU3Kv9qPNHpGNb3xnVhKr2VdscTZK+znuq2fGotlafnbfvtG6dP3Q+UE2RV2btZ5VbzeCq+RUtoxouvYdHtVz33HPPee1TnBtNYLggatZQc5J+3JPSj6l3Ijib0MApNDhQTknS6aG5PTp56MSnavuUcnxSsnXrVlfmpD++Cty81z060evkmZpqfZVJJ+hI+0O8Hz81PeiHZcyYMS73QT8+yjNRTyVv+8/m999/t3nz5rnmiNBtkqTr1klU+TWh9MOg6no1NajZUD8yHjVnpca2bdtcAKNmp6Q5V14ek1e1rx+e0Ka6H374we17b1iBaGl55U+lB+1HlS20udE7npMe+2quVDOFHqk5BqM51vUZaT/q8/DKVKFChbD5FFirSTX0eE2tpGXxjhF9lsoJS491piTS9+WPf/yjuzjQflY5otnXarYbPXq0y73Rd8Wj711S+g7pokfNadGOFZZSub2hHtTMqfOBmsT1SKncCqK0PxU8JZX0uEPaIQBCzOmKLbXTQ5Og9QOh4EcBRCReTs6FUhCnHKPUUJlUA6GTaaTyq5bFoxO0co4++ugjl/irGgedjJUDogTIs1HiuK7UQ3NqoqG8Kp2QVfOgJFclZ+pHRrUcqUm6VMCkmjdd4T755JOue7lyFnQ1q20KfQ/tCyV+qrYqnnjbqKC1U6dOEeepWrXqeR/rkjTp/0Jrt2K9zozY18rd0jGo2hl1VtA5Qtuq75YC56RUE6MEfY2lpQBIx2pal1sdDlKqEU8aYCLjEADhgijIUFOIaj6SUrfx9KQrdDX7KMEw2kRB9dpYs2aNO0GF1gLpitF7XdSjQzUdSRMiU/pRUJn0A6IrTV0Jnot6YekxcOBAl/StbZkwYYJLZD7belQrpdoT9cAJ3SbRZ1G+fPngdF1BJ62h+cc//uECEiWHhtJVtpfUfbb1K8lTieC60g5NMFatVKSyhjbVeftJ+14J1yklpZ5t/Vo+Um+btKD9qLLpxzL06jvp8ez1EFMw2KRJk3QpS9Iy6bP1aim9xGB9Zt5nH6t1XmiQFOn8oeNLvQO9C5nU7msd2zr+1RwdWi51zIhEzU5qDrzllltcU5gSoNXZ4ULK7X0vve+han7PVW7tz1icR/2MHCBcEF1Z6cpGOR0KFDzqJaL2+/SkdnWdEFWDkZTa/M82SKFqTtQ0ox4focuoV45qadQbyqv9UdOXmsBCqbZDkq5DPcS0T9TDKemVtJ6r7V9Ue+Pld3gUCCkYC+1irPVE2o6kOTWiE6xOtNqG0HVHuv2Dypi0fMqp8vIRzrWdXu1B6HvobzWrRWqqS1pWXZ1rW9UslrTGKfQ9U9p+NX+py36k3k9JtytaXq7XSy+9FDY96X7UPlA5lJsSKRhT4JlWvJq+pGVQE6qkx/hU0awzpc8ptRYvXhyWn6P8J9WMKh9H+zmafR3p2FTvNa0jJfruTJ061dUEqedg6DGpY1gXRj///HOy5XTeC/3OqJeZ1uUdQ6p9Uq2SelhGWj603Nrfqv3Ve4S+nlINNy4cNUC4YPqx14lDeSyPPPJIMJDQGB2qZUkvClLUDV5V2xqpWCdLBQC6itKPuX6M1X03EnXr1klJVeXLly93V2y6clTXeZ3wdbXp1V7oZJb0CtdL2FS3X43do/UqQVM1E6q90a0XNC6Qfuj1Xsqz0Y+11qvqcCVGqiuvrjhVU6R9pm7b3ok+dD2q5dKPjrqmq2ZJJ1UFmK+++mpYmXSlrPfW/tDVrE6oSkZWE1RorY7odQUfatpT4rJqdHSiDa05Em2P8j1UK6Xt0A+d8hTU5KXXtD79AChnRD9OSWuavKa6pD/QqvbXvlPwquNGgaMSs9VdXtvp5TZp+7Wd2qdaRtuubsZq2tDnpf2nZjzNp+Y45SOprEqQPl+qkVJyvPKjlIOj/bNgwQKXz5HUc8895xLbtU/U5Vq1ciqHfsz1uenvtKDtUdOP8l8UaOjY1w+lauB0jKVH82I060zpc0otdXXXhVRoN3jv3BLtvtaxrdofJcjruNN3T8eE5leuT0q0TW+++aar0dTx7I1lpuNbNWDaF0lHJde2amwwDQWhCxedO5SzpTHLPBqHSvPoAkfl1ndMtWgKyDRkgzf2lpbxbteiYTi8bvBebTXSQRr0JAMCn3/+eaBGjRquG3b58uUDEyZMCHa3PVc3eHW1DuUtt3fv3rDpWlbdwpOaOHGiW7e6pF588cWuy2nfvn0DO3fuTLEbvOzevTvQuXPnQNGiRV25tVxod+9Dhw65rusffPBBxE/46aefDpQqVcp1507aTfXDDz8MXH/99a68elSqVMl1x96wYYN7/ccff3Rdcq+44grX3bdw4cKBG2+8MTB//vywdaxfvz5www03uG3zurKPGzfOdY1V192k1KV86NChrruwlmnUqFFg3bp1yfa9uuT26tUrOF/9+vUDixcvjrifPvroo0DlypXdvgjtEq+hDpo0aeKGDdA+7Nq1a2D16tVh86jLtJZNyaRJkwLXXHON635fqFAht+558+YFX9+1a5fr1q/PVe8bWrb9+/cHHnvsMfcZ6PPTMAnaxtBu0ufTDV5+++23QPfu3V23cH1+t956a2D79u3JusF7x5HWUbp06UDOnDkDxYsXd12fdVx6vG7wSYc9iOY7oM9bn225cuXcerS+/v37h3WvTo2Uvl9eWUKP49Su82yf07l4n5GGpFC3cB0LOia0z5JKzb5WF/Nnn33WHfPee82aNcsdG6FDC4R2gw/1yiuvuOk6dkPnC/3+hC47evRoVx6tq0GDBu47kNQPP/wQ6Nixoyuvyq1j9pZbbgn84x//CJtvzZo1bt/pnKB5dI7RcBd0g08fCfonPQIrIKtTTw51QVW31dT0zMooqtlRM100NxWNFV1164o8vW7WiqxPtasaSFADmAIZiSYwIAVq+lEeSGYKfkQ5Bd6ozJmZxldp166dy9UCgMyGGiAAvqHE97NRT7XMFvCmlvJbzpbj4uWJpdT9PVb7mhogxAo1QAB8o0SJEmd9PVKia1bxwgsvhCUNR6KE4NChE9JTPO9rxAcCIAC+EWmcolDqgZZVqfeSehudjUZxzmz7mjRUxApNYAAAwHcYCBEAAPgOTWARaBTQnTt3uoHfMsN9cAAAwLmpSfWXX35xTaxJb3adFAFQBAp+kt6dGQAAZA26ncq5bipNABSBdxsE7UANiQ4AADI/3XpHFRje7/jZEABF4DV7KfghAAIAIGtJTfoKSdAAAMB3CIAAAIDvEAABAADfIQACAAC+QwAEAAB8hwAIAAD4DgEQAADwHQIgAADgOwRAAADAdwiAAACA7xAAAQAA3yEAAgAAvkMABAAAfIcACAAA+E6OWBcAAOLRtmGJsS4CkOlcPnitZRbUAAEAAN8hAAIAAL5DAAQAAHyHAAgAAPgOARAAAPAdAiAAAOA7BEAAAMB3CIAAAIDvEAABAADfIQACAAC+QwAEAAB8hwAIAAD4DgEQAADwHQIgAADgOwRAAADAdwiAAACA7xAAAQAA3yEAAgAAvkMABAAAfIcACAAA+A4BEAAA8B0CIAAA4DsEQAAAwHcIgAAAgO8QAAEAAN8hAAIAAL5DAAQAAHyHAAgAAPgOARAAAPAdAiAAAOA7BEAAAMB3CIAAAIDvEAABAADfIQACAAC+QwAEAAB8hwAIAAD4DgEQAADwnUwRAI0fP97Kli1refLksdq1a9vSpUvPOv/06dOtUqVKbv7ExESbPXt22Ot//vOfLSEhIezRvHnzdN4KAACQVcQ8AJo2bZr17NnThgwZYitWrLBq1apZs2bNbM+ePRHnX7RokXXo0MG6dOliK1eutNatW7vHunXrwuZTwPPzzz8HH++//34GbREAAMjsYh4AjRkzxrp27WqdO3e2ypUr24QJEyxfvnw2adKkiPO/+OKLLrjp06ePXXXVVfb000/btddea+PGjQubL3fu3Fa8ePHgo1ChQhm0RQAAILOLaQB08uRJW758uTVp0uT/CpQtm3u+ePHiiMtoeuj8ohqjpPN/9tlndumll9qVV15pDz/8sO3fvz/Fcpw4ccKOHDkS9gAAAPErpgHQvn377PTp01asWLGw6Xq+a9euiMto+rnmVw3R5MmTbcGCBTZy5Ej7/PPP7eabb3brimTEiBFWsGDB4KN06dJpsn0AACBzymFxqH379sG/lSRdtWpVu+KKK1ytUOPGjZPN379/f5eH5FENEEEQAADxK6Y1QEWLFrXs2bPb7t27w6brufJ2ItH0aOaX8uXLu3Vt2rQp4uvKFypQoEDYAwAAxK+YBkC5cuWyGjVquKYqz5kzZ9zzunXrRlxG00Pnl3nz5qU4v+zYscPlAJUoUSINSw8AALKqmPcCU9PTa6+9Zm+//bZ99913LmH52LFjrleYdOzY0TVReXr06GFz5syx0aNH2/r16+2pp56yZcuW2WOPPeZeP3r0qOsh9s0339iWLVtcsHTbbbdZhQoVXLI0AABAzHOA2rVrZ3v37rXBgwe7RObq1au7AMdLdN62bZvrGeapV6+eTZkyxQYOHGgDBgywihUr2syZM61KlSrudTWprVmzxgVUhw4dspIlS1rTpk1dd3k1dQEAACQEAoEAuyGckqDVG+zw4cPkAwE4L9uGJbLngCQuH7zWMsvvd8ybwAAAADIaARAAAPAdAiAAAOA7BEAAAMB3CIAAAIDvEAABAADfIQACAAC+QwAEAAB8hwAIAAD4DgEQAADwHQIgAADgOwRAAADAdwiAAACA7xAAAQAA3yEAAgAAvkMABAAAfIcACAAA+A4BEAAA8B0CIAAA4DsEQAAAwHcIgAAAgO8QAAEAAN8hAAIAAL5DAAQAAHyHAAgAAPgOARAAAPAdAiAAAOA7BEAAAMB3CIAAAIDvEAABAADfIQACAAC+QwAEAAB8hwAIAAD4DgEQAADwHQIgAADgOwRAAADAdwiAAACA7xAAAQAA3yEAAgAAvhN1APT222/bv//97+Dzvn372iWXXGL16tWzrVu3pnX5AAAAYh8APfvss5Y3b1739+LFi238+PH2/PPPW9GiRe2JJ55I+xICAACksRzRLrB9+3arUKGC+3vmzJnWtm1be/DBB61+/frWqFGjtC4fAABA7GuALrroItu/f7/7e+7cuXbTTTe5v/PkyWO//fZb2pcQAAAg1jVACngeeOABu+aaa+z777+3Fi1auOn//e9/rWzZsmldPgAAgNjXACnnp27durZ371778MMPrUiRIm768uXLrUOHDmlfQgAAgFjXAKnH17hx45JNHzp0aFqVCQAAIPONA/Tll1/avffe67q+//TTT27aO++8Y1999VValw8AACD2AZCavZo1a+a6wq9YscJOnDjhph8+fNh1kQcAAIi7AGj48OE2YcIEe+211yxnzpzB6eoGr4AIAAAg7gKgDRs22A033JBsesGCBe3QoUNpVS4AAIDMEwAVL17cNm3alGy68n/Kly+fVuUCAADIPAFQ165drUePHrZkyRJLSEiwnTt32nvvvWe9e/e2hx9++LwKoa71GkNIgynWrl3bli5detb5p0+fbpUqVXLzJyYm2uzZs1Oc96GHHnLlHDt27HmVDQAAxJ+oA6B+/frZ3XffbY0bN7ajR4+65jANjPiXv/zFunXrFnUBpk2bZj179rQhQ4a4HKJq1aq5JOs9e/ZEnH/RokVuvKEuXbrYypUrrXXr1u6xbt26ZPP+85//tG+++cZKliwZdbkAAED8SggEAoHzWfDkyZOuKUxBUOXKld0tMs6Hanyuu+664NhCZ86csdKlS7tgSsFWUu3atbNjx47ZrFmzgtPq1Klj1atXd8nZHnXP13t/8skn1rJlS3v88cfdIzWOHDnicprUs61AgQLntV0A/G3bsMRYFwHIdC4fvDZd3z+a3+/zGgdIcuXK5QIfNUXNnz/fvvvuu/MKojSCdJMmTf6vQNmyuee603wkmh46v6jGKHR+BVH33Xef9enTx66++upzlkNd+bXTQh8AACB+RR0A3XXXXcHaGt38VLU3mla1alU3RlA09u3bZ6dPn7ZixYqFTdfzXbt2RVxG0881/8iRIy1HjhzWvXv3VJVjxIgRLmL0HqqBAgAA8SvqAOiLL76wBg0aBHNsVNui7u8vvfSSGyMo1lSj9OKLL9pbb73lkp9To3///q66zHts37493csJAACyUACkAKFw4cLu7zlz5ljbtm0tX758Ls9m48aNUb1X0aJFLXv27LZ79+6w6Xqu7vaRaPrZ5tdtOpRAffnll7taID22bt1qvXr1SvFu9blz53ZthaEPAAAQv6IOgNQ8pHwbJSIrAGratKmbfvDgQdctPdo8oho1atiCBQuC01SjpOe643wkmh46v8ybNy84v3J/1qxZY6tWrQo+1AtM+UBKiAYAAIj6bvDqSXXPPfe4Xl9lypSxRo0aBZvGNCZPtNQFvlOnTlazZk2rVauWG69HwVXnzp3d6x07drRSpUq5PB3RGEQNGza00aNHu1qnqVOn2rJly2zixInu9SJFirhHKN2yQzVEV155JZ84AACIPgB65JFHXPfybdu22U033eR6bYlGgT6fHCB1a9+7d68NHjzYJTKrO7tqlrxEZ63HW4foDvRTpkyxgQMH2oABA6xixYo2c+ZMq1KlCh8nAABI33GA4hnjAAG4UIwDBGTucYCirgGSHTt22Mcff+xqZzSWT6gxY8acz1sCAABkmKgDICUgt2rVyjV5rV+/3jU9bdmyxVSRdO2116ZPKQEAAGLZC0xj5ujGp2vXrnW9vjT4ocbNUWLynXfemZZlAwAAyBwBkG55oZ5ZojF2NBq0eoQNGzbMjcAMAAAQdwFQ/vz5g3k/JUqUsB9++CHs1hYAAABxlwOkO69/9dVXdtVVV1mLFi3cCMtqDpsxY4Z7DQAAIO4CIPXyOnr0qPt76NCh7u9p06a58XjoAQYAAOIyAFLvr9DmsAkTJqR1mQAAANLVeY0DJLr9hBKipXLlyu6eXgAAAHEZAGkQxA4dOtjXX39tl1xyiZt26NAhd4sK3ZfrsssuS49yAgAAxK4X2AMPPGC///67q/05cOCAe+hv3cVdrwEAAMRdDdDnn39uixYtCruzuv5++eWXrUGDBmldPgAAgNjXAJUuXdrVACV1+vRpK1myZFqVCwAAIPMEQKNGjbJu3bq5JGiP/u7Ro4e98MILaV0+AACA2DSBFSpUyBISEoLPjx07ZrVr13a3wpBTp065v++//35r3bp12pcSAAAgowOgsWPHpuU6AQAAMn8A1KlTp/QvCQAAQGbNAQIAAMjqCIAAAIDvEAABAADfIQACAAC+QwAEAAB8J1W9wG6//fZUv+GMGTMupDwAAACZowaoYMGCwUeBAgVswYIFYSNBL1++3E3T6wAAAHFRA/Tmm28G/37yySftrrvusgkTJlj27NmD9wF75JFHXHAEAAAQdzlAkyZNst69eweDH9HfPXv2dK8BAADEXQCk+36tX78+2XRNO3PmTFqVCwAAILZNYKE6d+5sXbp0sR9++MFq1arlpi1ZssSee+459xoAAEDcBUAvvPCCFS9e3EaPHm0///yzm1aiRAnr06eP9erVKz3KCAAAENsAKFu2bNa3b1/3OHLkiJtG8jMAAIj7gRCVBzR//nx7//33LSEhwU3buXOnHT16NK3LBwAAEPsaoK1bt1rz5s1t27ZtduLECbvpppvs4osvtpEjR7rn6h4PAAAQVzVAPXr0sJo1a9rBgwctb968welt2rRxgyECAADEXQ3Ql19+aYsWLbJcuXKFTS9btqz99NNPaVk2AACAzFEDpLF+NPJzUjt27HBNYQAAAHEXADVt2tTGjh0bfK4kaCU/DxkyxFq0aJHW5QMAAIh9E5jG/2nWrJlVrlzZjh8/bnfffbdt3LjRihYt6nqFAQAAxF0AdNlll9nq1att6tSptmbNGlf7o5Gh77nnnrCkaAAAgLgJgNxCOXLYvffem/alAQAAyCwB0Mcff2w333yz5cyZ0/19Nq1atUqrsgEAAMQuAGrdurXt2rXLLr30Uvd3SpQQHamHGAAAQJYLgNT1PdLfAAAAcdsNvnDhwrZv3z739/3332+//PJLepcLAAAgtgHQyZMng3d+f/vtt133dwAAgLhuAqtbt67L/alRo4YFAgHr3r17il3eJ02alNZlBAAAyPgA6N1337W//e1v9sMPP7hE58OHD1MLBAAA4jsAKlasmD333HPu73Llytk777xjRYoUSe+yAQAAZI6BEDdv3pw+JQEAAMhMAdBLL71kDz74oOXJk8f9fTbKDwIAAMjMEgLKaj4HNXstW7bMNXvp7xTfLCHBfvzxR8vq1OOtYMGCLtepQIECsS4OgCxo27DEWBcByHQuH7w20/x+54i22YsmMAAA4ItxgNLb+PHjrWzZsq6JrXbt2rZ06dKzzj99+nSrVKmSmz8xMdFmz54d9vpTTz3lXs+fP78VKlTImjRpYkuWLEnnrQAAAFlFqmqAevbsmeo3HDNmTFQFmDZtmnv/CRMmuOBn7Nix1qxZM9uwYYO791hSixYtsg4dOtiIESPslltusSlTprgxilasWGFVqlRx8/zxj3+0cePGWfny5e23335zXfibNm1qmzZtsj/84Q9RlQ8AAPg0B+jGG28Me65g49SpU3bllVe6599//71lz57dDZT46aefRlUABT3XXXedC1i8e42VLl3aunXrZv369Us2f7t27ezYsWM2a9as4LQ6depY9erVXRB1tjbB+fPnW+PGjc9ZJnKAAFwocoCAOMgBWrhwYVgNz8UXX+xuiaHmJTl48KB17tzZGjRoEFVBdYuN5cuXW//+/YPTsmXL5pqsFi9eHHEZTU9aI6Uao5kzZ6a4jokTJ7odUq1atYjznDhxwj083m0/AABAfIo6B2j06NGu+ckLfkR/Dx8+3L0WDd1g9fTp026gxVB6vmvXrojLaHpq5lcN0UUXXeTyhNQENm/ePCtatGjE99T2KEDyHqqBAgAA8SvqAEi1I3v37k02XdMy013i1Wy3atUqlzPUvHlzu+uuu2zPnj0R51UNlKrLvMf27dszvLwAACATB0Bt2rRxzV0zZsywHTt2uMeHH35oXbp0sdtvvz2q91KNjHKHdu/eHTZdz4sXLx5xGU1PzfzqAVahQgWXH/TGG29Yjhw53P+R5M6d27UVhj4AAED8ijoAUqLxzTffbHfffbeVKVPGPfS3alleeeWVqN4rV65cLnF6wYIFwWlKgtZz3YE+Ek0PnV/UvJXS/KHvG5rnAwAA/Cvqe4Hly5fPBTqjRo1yd4eXK664wtW4nA8lNHfq1Mlq1qxptWrVct3g1ctLtUzSsWNHK1WqlMvTkR49eljDhg1dvlHLli1t6tSpbpRqJTqLln3mmWesVatWVqJECZdnpHGGfvrpJ7vzzjvPq4wAAMDnAZBHAU/hwoWDf58vdWtX/tDgwYNdIrO6s8+ZMyeY6Lxt2zbXM8xTr149N/bPwIEDbcCAAVaxYkXXA8wbA0hNauvXr3e91BT86PYd6mb/5Zdf2tVXX33e5QQAAD4bByhpU5LX4+vo0aNumrrF9+rVy/7617+GBStZFeMAAbhQjAMExME4QKEU5CiZ+LnnnrP69eu7aV999ZW7/cTx48dd8xMAAEBmFnUApKal119/3eXYeKpWrerydB555BECIAAAkOlF3V514MABd6PRpDRNrwEAAMRdAKTbSXj37QqlaSndagIAACBLN4E9//zzrvu5bizqjb2j+3Np9OTZs2enRxkBAABiWwOkMXh093eNCH3o0CH30AjQGzZsiPpmqAAAAFlmHKCSJUuS7AwAAPwVAKm7+5o1a9zNRTUuUKjQ3mEAAABxEQBplGbdnkKjLCeVkJBgp0+fTquyAQAAZI4coG7durl7av3888+u9if0QfADAADiMgDavXu3u4Gpd68uAACAuA+A7rjjDvvss8/SpzQAAACZMQdIAx6qCUx3V09MTLScOXOGvd69e/e0LB8AAEDsA6D333/f5s6da3ny5HE1QUp89uhvAiAAAJDZndfd4IcOHWr9+vWzbNmibkEDAACIuagjmJMnT1q7du0IfgAAgH8CoE6dOtm0adPSpzQAAACZsQlMY/3ohqiffPKJVa1aNVkS9JgxY9KyfAAAALEPgNauXWvXXHON+3vdunVhr4UmRAMAAMRNALRw4cL0KQkAAEAGoRsXAADwHQIgAADgOwRAAADAdwiAAACA7xAAAQAA34m6F5hs3LjR9Qbbs2ePnTlzJuy1wYMHp1XZAAAAMkcA9Nprr9nDDz9sRYsWteLFiye7GSoBEAAAiLsAaPjw4fbMM8/Yk08+mT4lAgAAyGw5QAcPHrQ777wzfUoDAACQGQMgBT9z585Nn9IAAABkxiawChUq2KBBg+ybb76xxMTEZDdD7d69e1qWDwAAIM0lBAKBQDQLlCtXLuU3S0iwH3/80bK6I0eOWMGCBe3w4cNWoECBWBcHQBa0bVhirIsAZDqXD16baX6/o64B2rx584WUDQAAIGsPhKjKoygrkAAAALJmADR58mSX/5M3b173qFq1qr3zzjtpXzoAAIB0EHUT2JgxY1wS9GOPPWb169d307766it76KGHbN++ffbEE0+kRzkBAABiFwC9/PLL9uqrr1rHjh2D01q1amVXX321PfXUUwRAAAAg/prAfv75Z6tXr16y6Zqm1wAAAOIuANI4QB988EGy6dOmTbOKFSumVbkAAAAyTxPY0KFDrV27dvbFF18Ec4C+/vprW7BgQcTACAAAIMvXALVt29aWLFni7gY/c+ZM99DfS5cutTZt2qRPKQEAAGJZAyQ1atSwd999Ny3LAQAAkLkCIA0t7Q0prb/PhltHAACAuAiAChUq5Hp4XXrppXbJJZe4e34lpRGhNf306dPpUU4AAICMDYA+/fRTK1y4sPt74cKFabd2AACAzBoANWzYMOxu8KVLl05WC6QaoO3bt6d9CQEAAGLdC0wB0N69e5NNP3DggHsNAAAg7gIgL9cnqaNHj1qePHnSqlwAAADpJtXd4Hv27On+V/Cjm6Hmy5cv+JoSnzU2UPXq1dOnlAAAALEIgFauXBmsAVq7dq3lypUr+Jr+rlatmvXu3TstywYAABDbAMjr/dW5c2d78cUXGe8HAAD4Jwdo7NixdurUqYhJ0OcaJDEl48ePt7Jly7ocotq1a7vbapzN9OnTrVKlSm7+xMREmz17dvC133//3Z588kk3PX/+/FayZEnr2LGj7dy587zKBgAA4k/UAVD79u1t6tSpyabrRqh6LVq6i7zyi4YMGWIrVqxwTWnNmjWzPXv2RJx/0aJF1qFDB+vSpYtrlmvdurV7rFu3zr3+66+/uvdRnpL+nzFjhm3YsMFatWoVddkAAEB8SggoqScKGhBRd3+/6qqrwqavX7/e3R1+//79URVANT7XXXedjRs3zj0/c+aMG2eoW7du1q9fv2Tz6070x44ds1mzZgWn1alTxyVgT5gwIeI6vv32W6tVq5Zt3brVLr/88nOWSTVZBQsWtMOHD9PUB+C8bBuWyJ4Dkrh88FpLT9H8fkddA3TixImITWBqevrtt9+ieq+TJ0/a8uXLrUmTJv9XoGzZ3PPFixdHXEbTQ+cX1RilNL9oR6j3mm7jkdI2aaeFPgAAQPyKOgBSTcrEiROTTVfti+4SH419+/a5LvTFihULm67nu3btiriMpkcz//Hjx11OkJrNUooGR4wY4SJG76EaKAAAEL9S3QvMM3z4cFcDs3r1amvcuLGbtmDBAtfMNHfuXMtMVCt11113ua77r776aorz9e/fPzjOkagGiCAIAID4FXUNkPJ81NykAEGJz//617+sQoUKtmbNGmvQoEFU71W0aFHLnj277d69O2y6nhcvXjziMpqemvm94Ed5P/PmzTtrW2Du3Lnd66EPAAAQv6IOgEQJx++9957997//tWXLltmkSZOsYsWKUb+PBlBUs5lqkDxKgtbzunXrRlxG00PnFwU4ofN7wc/GjRtt/vz5VqRIkajLBgAA4lfUTWBJ82uUyBwq2toTNT116tTJatas6fKLNM6QenlpwEXRGD6lSpVyeTrSo0cPd3f60aNHW8uWLV2XfAVhXl6Sgp877rjDdYFXTzHlGHn5QerBFjqCNQAA8KeoAyCNs9O3b1/X/BWpy7sCjmioW7vuLj948GAXqKh2ac6cOcFE523btrmeYZ569erZlClTbODAgTZgwABX8zRz5kyrUqWKe/2nn36yjz/+2P2d9N5kGs26UaNG0W4yAADw+zhAjz76qAsknn76abvvvvvcKM4KOv7+97/bc889Z/fcc49ldYwDBOBCMQ4QkLnHAYq6BkhJz5MnT3Y1KWqmUuKzkqDLlCnj8oLiIQACAADxLeokaN3zq3z58u5vRVd6Ltdff7198cUXaV9CAACAWAdACn42b97s/tYNSZUL5NUMpTTSMgAAQJYOgNTspUEQRffqUg6Q7sr+xBNPWJ8+fdKjjAAAAGkq6hwgBToejQitm6Dqfl7KA6patWralg4AACDWNUAaY0e3v9AAgx4lP99+++0EPwAAID4DoJw5c7pbXgAAAPgqB+jee++1N954I31KAwAAkBlzgE6dOuXu/aV7bOk+Xvnz5w97fcyYMWlZPgAAgNgHQOvWrbNrr73W/f3999+HvZaQkJB2JQMAAIhlAKS8H91rS/fk0m0wAAAA4j4H6JprrrF9+/YFB0KMdBNUAACAuAqANMKzN/rzli1b7MyZM+ldLgAAgNg2gbVt29YaNmxoJUqUcHk+NWvWtOzZs0ec98cff0zrMgIAAGR8ADRx4kQ32OGmTZuse/fu1rVrV7v44ovTtiQAAACZrRdY8+bN3f+67UWPHj0IgAAAgH+6wb/55pvpUxIAAIDMOhI0AABAVkcABAAAfIcACAAA+A4BEAAA8B0CIAAA4DsEQAAAwHcIgAAAgO8QAAEAAN8hAAIAAL5DAAQAAHyHAAgAAPgOARAAAPAdAiAAAOA7BEAAAMB3CIAAAIDvEAABAADfIQACAAC+QwAEAAB8hwAIAAD4DgEQAADwHQIgAADgOwRAAADAdwiAAACA7xAAAQAA3yEAAgAAvkMABAAAfIcACAAA+A4BEAAA8B0CIAAA4DsEQAAAwHcIgAAAgO8QAAEAAN8hAAIAAL5DAAQAAHwn5gHQ+PHjrWzZspYnTx6rXbu2LV269KzzT58+3SpVquTmT0xMtNmzZ4e9PmPGDGvatKkVKVLEEhISbNWqVem8BQAAIKuJaQA0bdo069mzpw0ZMsRWrFhh1apVs2bNmtmePXsizr9o0SLr0KGDdenSxVauXGmtW7d2j3Xr1gXnOXbsmF1//fU2cuTIDNwSAACQlSQEAoFArFauGp/rrrvOxo0b556fOXPGSpcubd26dbN+/folm79du3YuwJk1a1ZwWp06dax69eo2YcKEsHm3bNli5cqVc4GSXo/GkSNHrGDBgnb48GErUKDAeW8fAP/aNiwx1kUAMp3LB69N1/eP5vc7ZjVAJ0+etOXLl1uTJk3+rzDZsrnnixcvjriMpofOL6oxSmn+1Dpx4oTbaaEPAAAQv2IWAO3bt89Onz5txYoVC5uu57t27Yq4jKZHM39qjRgxwkWM3kO1UAAAIH7FPAk6M+jfv7+rLvMe27dvj3WRAABAOsphMVK0aFHLnj277d69O2y6nhcvXjziMpoezfyplTt3bvcAAAD+ELMaoFy5clmNGjVswYIFwWlKgtbzunXrRlxG00Pnl3nz5qU4PwAAQKaqARJ1ge/UqZPVrFnTatWqZWPHjnW9vDp37uxe79ixo5UqVcrl6EiPHj2sYcOGNnr0aGvZsqVNnTrVli1bZhMnTgy+54EDB2zbtm22c+dO93zDhg3uf9USXWhNEQAAiA8xDYDUrX3v3r02ePBgl8is7upz5swJJjorkFHPME+9evVsypQpNnDgQBswYIBVrFjRZs6caVWqVAnO8/HHHwcDKGnfvr37X2MNPfXUUxm6fQAAIHOK6ThAmRXjAAG4UIwDBCTHOEAAAAAxRDd4AADgOwRAAADAdwiAAACA7xAAAQAA3yEAAgAAvkMABAAAfIcACAAA+A4BEAAA8B0CIAAA4DsEQAAAwHcIgAAAgO8QAAEAAN8hAAIAAL5DAAQAAHyHAAgAAPgOARAAAPAdAiAAAOA7BEAAAMB3CIAAAIDvEAABAADfIQACAAC+QwAEAAB8hwAIAAD4DgEQAADwHQIgAADgOwRAAADAdwiAAACA7xAAAQAA38kR6wL4WY0+k2NdBCDTWT6qY6yLAMAHqAECAAC+QwAEAAB8hwAIAAD4DgEQAADwHQIgAADgOwRAAADAdwiAAACA7xAAAQAA3yEAAgAAvkMABAAAfIcACAAA+A4BEAAA8B0CIAAA4DsEQAAAwHcIgAAAgO8QAAEAAN8hAAIAAL5DAAQAAHyHAAgAAPgOARAAAPAdAiAAAOA7mSIAGj9+vJUtW9by5MljtWvXtqVLl551/unTp1ulSpXc/ImJiTZ79uyw1wOBgA0ePNhKlChhefPmtSZNmtjGjRvTeSsAAEBWEfMAaNq0adazZ08bMmSIrVixwqpVq2bNmjWzPXv2RJx/0aJF1qFDB+vSpYutXLnSWrdu7R7r1q0LzvP888/bSy+9ZBMmTLAlS5ZY/vz53XseP348A7cMAABkVjEPgMaMGWNdu3a1zp07W+XKlV3Qki9fPps0aVLE+V988UVr3ry59enTx6666ip7+umn7dprr7Vx48YFa3/Gjh1rAwcOtNtuu82qVq1qkydPtp07d9rMmTMzeOsAAEBmlCOWKz958qQtX77c+vfvH5yWLVs212S1ePHiiMtoumqMQql2xwtuNm/ebLt27XLv4SlYsKBrWtOy7du3T/aeJ06ccA/P4cOH3f9Hjhyx9HT6xG/p+v5AVpTe37uM8svx07EuAuC77/eR///+qgzJ1AHQvn377PTp01asWLGw6Xq+fv36iMsouIk0v6Z7r3vTUponqREjRtjQoUOTTS9dunSUWwTgQhV8+SF2IhCvRhTMkNX88ssvrvIj0wZAmYVqoEJrlc6cOWMHDhywIkWKWEJCQkzLhvSnKwYFu9u3b7cCBQqwy4E4wvfbXwKBgAt+SpYsec55YxoAFS1a1LJnz267d+8Om67nxYsXj7iMpp9tfu9/TVMvsNB5qlevHvE9c+fO7R6hLrnkkvPcKmRVCn4IgID4xPfbPwqeo+YnUyRB58qVy2rUqGELFiwIq33R87p160ZcRtND55d58+YF5y9XrpwLgkLn0RWAeoOl9J4AAMBfYt4EpqanTp06Wc2aNa1WrVquB9exY8dcrzDp2LGjlSpVyuXpSI8ePaxhw4Y2evRoa9mypU2dOtWWLVtmEydOdK+ryerxxx+34cOHW8WKFV1ANGjQIFcdpu7yAAAAMQ+A2rVrZ3v37nUDFypJWc1Uc+bMCSYxb9u2zfUM89SrV8+mTJniurkPGDDABTnqAValSpXgPH379nVB1IMPPmiHDh2y66+/3r2nBk4EklLzp8ahStoMCiDr4/uNlCQEUtNXDAAAII7EfCBEAACAjEYABAAAfIcACAAA+A4BEAAA8B0CIAAA4DsEQPAF3QhXo45r7KhzUcdIDcugkcTz5s3rbqy7cePGDCkngJRpqJRu3bpZ+fLlXfd23cLm1ltvDRv4duXKlW54FX1/NU+ZMmXslltusX/9619nvUEm33v/IQCCL7zxxhvuxPnFF1/Yzp07zzrv888/by+99JJNmDDBjSCeP39+a9asmR0/fjzDygsg3JYtW9ydAz799FMbNWqUrV271o3vduONN9qjjz7q5vnoo4+sTp06dvToUXv77bftu+++c/O0adPGjR13+PDhFHcr33v/YRwgxD2dDHU1qBHDNeBh1apV3SCaKV0FatTwXr16We/evd00nTQ1MOdbb71l7du3z+DSA5AWLVrYmjVrbMOGDe6iJJQGvM2ZM6er7bnhhhtsxowZKX6/I93gmu+9P1EDhLj3wQcfWKVKlezKK6+0e++91yZNmpRiVfjmzZtdNbuavUJvrFe7dm3XjAYg4x04cMDV5KimJ2nw4928eu7cubZ//353J4CURAp+hO+9PxEAwRfNXwp8pHnz5q5G5/PPP484r4If8W7F4tFz7zUAGWvTpk3uokUXMin5/vvv3f+60PF8++23dtFFFwUfs2bNirgs33t/IgBCXFN1+dKlS61Dhw7ueY4cOVyCpIIiAFnD+d6xSc3dq1atcg/dH/LUqVNpXjZkXQRAiGsKdHTSU16Pgh89Xn31Vfvwww8jJkQWL17c/b979+6w6XruvQYgY+mm12q+Wr9+/Vnn8S56POoFVqFCBfc4G773/kQAhLilwGfy5Mk2evTo4FWgHqtXr3YB0fvvv59smXLlyrmTYWi32iNHjrjeYHXr1s3gLQAghQsXdj0xx48f72pyklISdNOmTd18I0eOjHqn8b33pxyxLgCQXtTef/DgQevSpYtLZA7Vtm1bVzv00EMPhU3XVebjjz9uw4cPd1eUOjEOGjTIBUytW7fmwwJiRMFP/fr1rVatWjZs2DDXvKWLnHnz5rlaXXV5f/31110Tt8b76t69u/sOqxeoEqhFY4FFwvfepwJAnLrlllsCLVq0iPjakiVLlFQQWL16daBMmTKBIUOGBF87c+ZMYNCgQYFixYoFcufOHWjcuHFgw4YNGVhyAJHs3Lkz8Oijj7rvbK5cuQKlSpUKtGrVKrBw4cLgPN9++23gjjvuCFx66aWBHDlyBIoUKRJo1qxZYOrUqe677eF7D8YBgq/9+uuvVqRIEfvPf/5jjRo1inVxAGQAvvcQcoDgawsXLrQ//elPBD+Aj/C9h1ADBAAAfIcaIAAA4DsEQAAAwHcIgAAAgO8QAAEAAN8hAAIAAL5DAAQAAHyHAAgAAPgOARAAAPAdAiAAAGB+8/8AWfUosQ05zRMAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -1141,7 +1630,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ @@ -1150,7 +1639,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -1159,13 +1648,13 @@ "Text(0.5, 1.0, \"CTCF target data, 100 known binding locations\\nsort_by=['shuffle'] i.e. default\")" ] }, - "execution_count": 27, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAl4AAAHcCAYAAAAHsaTIAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsfQe4JUWxf19YdknCkpMgIAgCiiCCIEZ4Ig99GBEXAVExYUZA3hPxmUBFfQZMvD9B3SUJgqKIPMRMlihJBRWVIOmSlzT/r4bbY01NVXV1T8+cc+/O7/vuPefMdKjO1VXV1RNFURRuwIABAwYMGDBgQOdYrPssBgwYMGDAgAEDBgyM14ABAwYMGDBgQI8YJF4DBgwYMGDAgAE9YWC8BgwYMGDAgAEDesLAeA0YMGDAgAEDBvSEgfEaMGDAgAEDBgzoCQPjNWDAgAEDBgwY0BMGxmvAgAEDBgwYMKAnDIzXgAEDBgwYMGBATxgYrwEDZihe9KIXlX8D4jExMeHe/e53LxJV9/Of/7ws7/e+971g2De96U1u3XXXzZo/lybQ87GPfcz1jT//+c9l3scee6wbV3TRBgP6xcB4DYjCn/70J/f2t7/drb/++m7JJZd0yy23nHve857nvvSlL7kHH3ywnCxh4gr9YYYAJv5Xv/rVbvXVV3ezZ892q666qnvFK17hTj311MaEyP0997nPVWn+7W9/W9J19913T4vWHjW9DzzwQJk/tEsfuPDCC9273vUu9+xnP9stscQSZZtq+H//7/+5pz/96WX/23DDDd1XvvIVNtzf//53t9tuu7m5c+eW/XTXXXd1N9xwQ0elGDAgH/7xj3+UY/Cyyy4bqnUGYtaoCRgwffCjH/3Ive51r3Nz5sxxe+21l9tss83cww8/7H7961+7Aw44wP3+978vpQQbbLBBFee+++5z73znO92rXvWqkrnyWG211crPQw891H384x8vF1Bg6J7ylKe4O+64w/34xz92r3nNa9z8+fPdvHnzqnhveMMb3L//+7/X6FpllVWCjMx///d/lztFWITHHaOmFxgvyB/Qh8QM2vp///d/3TOf+cySob/++uvFsN/85jfdO97xjrJvfPCDH3S/+tWv3Hvf+96S5oMOOqjW71784he7yclJ95//+Z8lQ/fFL37RvfCFLywXs5VWWqnzcs1EHHXUUe7xxx/vPB/YxM2aNWuRZrxgDIJk61nPetZI2mBAd1h0e/aAKNx4441u9913Lxmjn/3sZ26NNdao3u23337uj3/8Y8mYweIJfx633357yXjBsze+8Y21NEG1AUzXa1/7WrdgwYJycfQARu6ss85yjzzySC3Olltu2UhnFIC75R966CG31FJLjZqUaQ/oH8A0QV0C4y4xXrAY/9d//ZfbZZddKrXYvvvuWy5Cn/jEJ9zb3vY2t8IKK5TPv/a1r7k//OEPpTTtOc95Tvls5513LjcLn//8592nP/3pHks4c4DHaJcAaeaA0bbBgO4wqBoHmPDZz362lCKAmgczXR4g5Xrf+94XVZuHHHKIW3HFFd3RRx/NTiY77bSTe/nLX96qhUBcD0wcYL311qvUk6C6BBxzzDHuJS95SaneBEneJpts4r7+9a830oGdJ9ACzOBWW21VMgkgfQH85S9/cf/xH//hlllmmTKdD3zgA2U4yIeq6y644AL3spe9zC2//PJu6aWXLiUwv/nNb8z0SvjWt77lnvrUp5Z0bb311qUkiAKkkx/96EdLlR7kD/Q+//nPd+eee24VBvLxEkTYcfv8vb3NFVdcUUrivKoZ1MNvfvObSyllKkD6aWFggU7IB9SSGMD433///SXj7wGMGTBcnukCbLzxxm6HHXZwJ510UhKdn/zkJ91iiy1WqTa9bRSk96lPfco9+clPLusE8oCNCMXJJ59c1j2UdeWVVy43EKAO9fjBD35Qpgd17HHKKaeUz7C0GACq1te//vUNm7TTTjutZC6hL2+66abuJz/5ibl8jz32WCkdhDaFvgF9+qabblLti7wJwBFHHFH1Qcgb6v2iiy5q5OHpg3qCz+9///ssLdTGy5swQL16STD04X322aeUdlIGHaSgUMdPetKTynJAPbexG4PNJowVqBfIG9TW11xzTSMc5POWt7zFrbnmmmU9wBiGjQWMPcCdd97pPvShD7lnPOMZbtllly1V4LAhuPzyy6s0oF/5fgvl82PQ251xNl7Q//fff3+39tprl/lutNFGZZvABpHWq6Wf3Hvvve79739/mQ+EgXnt3/7t39zvfve7pPobUMcg8Rpgwg9/+MNysd1uu+2y1BhII6699tpy0YbJ0QqYZEGKhgETsLQLhAULJCjHH398qWqCyRjgmQtgsmDigckZVBtQTljYQYoCCzrGddddV6o6QSUKkhaY3GDCA8bt5ptvLhlPWLRAeoeZGTx5wyQLiy+oWGER94wfMErAMIXo5QDMMNAEbQOTJdgxQXmAqYWJ2OOee+4pVXpQBqAfJleICwwuSIZApQH5QJ1Q9bCXYp599tll+rAgQFlBvQwLLnyef/75QfusNrj00kvLT2B8MaA+oS7hPTAz0HbAvEDfooA6/ulPf1qWPabffeQjHymlZMBsQ91hHH744WX+sKCCahM2KXvssUfJZHvAogl1BgvqYYcd5m699dbSLhKYbqAbFvPtt9++rL9f/vKXVX1Dv4C0QZ3v8c9//rMcO9T4H8KAXST0Xyjbl7/85VIl+9e//tWkWgXmEfIH6eNtt93m/ud//sftuOOOpWo2xBhDn4c6hX4IaUAdQN+BvuLHJtQ70AObG6gDYKKhToBhtQJs9oCZgfjABEB/BqbgM5/5TBUGGBNghvfcc8/S/vMXv/hFKSVNxf/93/+V4xbmP2DcgLED5htsW4EGzwSBehD6F9hmgvQVGH1gxGATAPMW2K9CfQDTAyYbUA7oB9CnYAN29dVXlwwbMNWgCYBNEqQDDB9AmnuBuYLxDnMOMH0wjmHjBxs4yB/mkdh+Aup8oBv6GLQXtBXEA2YTtA4DWqIYMCCAyclJ2DYVu+66a3Rd/fOf/yzjHnroobXnp59+evn8i1/8oimdG2+8sQzP/Z177rlq3M997nNlOEiD4oEHHmg822mnnYr111+/9uwpT3lKmcZPfvKT2vPPf/7z5fPTTjutevbggw8WG2+8cY22xx9/vNhwww3LtOE7zn+99dYr/u3f/s1EL8XDDz9crLrqqsWznvWsYuHChdXzb33rW2UaL3zhC6tnjz76aC0M4K677ipWW2214s1vfnOwzaT6Ov7448vwv/zlL4u22G+//cq0pHeLL744+26VVVYpdt999xr9H//4xxvhjjzyyPLdtddeq9IBYSA/wP77718stthixbHHHlsLA20L4Z7+9KfX6vVLX/pS+fzKK6+stdFmm21W9g2PM844owz30Y9+tHq26aabFrvttlv1e8sttyxe97rXleGuueaa8tmpp55a/r788str9M6ePbv44x//WD2D9/D8K1/5ilpWX4611lqruOeee6rnJ510UvkcyuOx9957l2OBjsuVVlqpuPPOOxvj+4c//GH1DProGmusUdx9993Vs5/+9KdlOJymLw/uf/AdnuF+CnjVq15V5u1xySWXlOHe//7318K96U1vEvs0hi/PMcccU6Mb2u+OO+6o1S30ib322qt6Bt/h2UUXXdRI14/5hx56qHjssccaec6ZM6fWXyENSofUBjD3QNhPfvKTtXCvfe1ri4mJiVqfsPaT5Zdfvur/A/JjUDUOCAIkJYAYCUFXacIOEKQu+G/zzTdPpgPv5EFaAdI02H3CzhR+Y8AOFaRDGCCiX2uttcodpweoUahUBKQGIOWDgwKwe4R84A8kZqCaAilHisHsxRdfXEonYIcKO2q86wdJIMbiiy9ehYG8QO3x6KOPlhIkqwoB1xfYuEEZ/KnSrtUQIGnAZcSAOof3PhwAVCRcOBxGA6xTsOMHydR3v/tdt/fee7PhQGqD6fISCn+C0rcRSBiw7RJIYUAqglWkENeriUGCBCoo6PMg+fTP4RMkZKAqwgDpFKj6PEBqBqos60lOODCDxyPYXoJZARx+CAHUnt6+jqsDkAjDGIA6xP0S1FcgUbEC+jkG5APjyc8nXmVG1dHvec97XAo83TCeQIKM6xZo93UD4wkkWXAam0pkAV4SDH0SJJhetQu0g8oRpOep4wdogLEN6lUMUD1CHz7zzDOj+wn0L5DYghRvQH4MqsYBQcCg9AvBqNOE048wceQCqHpA7Xfeeec1bEWA8cKLBDBeFGDfBZMYVbHhk50AYLoA0uLt88OLlwWQv68XDFDvgGqE4rjjjiuNy0FVhQ8ucGXjAMwa2H6dcMIJJTNB6e8SwPR5WxkKfNDBfy5cuJANh8No+Pa3v13aNYLqFdSzEtZZZ53ab9+Gd911V62NYHGlAMYLqxGBkfjGN75R2jKB6xboV9tuu23FkAFDD5+g5vILuESHp8XTEQLtQ5A39OOQfWFMHdA8ADFMh5YPzCmQD9QL7c90PFqhtR2oBEGlB5sn6CfA/FFmmAIYNGDk4fAHHFgC5ssj9aQt0AgqSrqJBfpwGWL6CaiKYa4CUwVQ5cNJcmDMuTllQDwGxmtAEDChwcC+6qqrstUWLDiAK6+8cmQtAAsbSJuAli984QvlJAOSC9hBgl0ElUC1OcHo0/rc5z7XOB7uATvfLgFSG9i5v/KVryztP8A2BnbKYC8DdWG1sQF3FxAfygE0Q9ngwEDXR9xB+gILFTB8QLsHMGMgOYA+CgDJBEgWQFpB4Z/5sBqAuQFpx1e/+tWy3FjigQF1yIEaNlsAdl4AkICCBALsafwhCLDFgQUebMLAHqtLOmLRV96jLGMOgJ0gHCoC+0M4iQt9ChhFsM3sy0WEpQ6hv0Ofg8MPYJsH8xbY0YFtGNi7DWiHgfEaYAKc6AMjapAMwQ68LZ72tKeVu8jTTz+93AF2yXRIBt9gSA9SEThNhneBnGG8BHCvAUaxMGnhfOipNi/aByY2JLGLMVCH/L1EDYz0PUCaBTtqrIYFY1nYscLkifMAiZ8lf9gRn3POOaXECwx/qTSva3iGFVR32Jcb/IZFy7+HhQxOjcFzClCfQB1YVNwgJYGdP/gyA8YSyp6ibvdtBIczcBv5Z/49APoh/IFUCxgvr7J7wQteUPotg5ORwHzC79yg7Qh9Gvoxdg+TCtxPKaAOcgHygb4AfR9L17hTptb0JBpBagwqYGCMYVMGYzu0OYUxCP7l4FALBhjk+4M0KXMAHACgB0aAPlyGlI0OqGzhDzY7sAkAhn9gvNpjsPEaYMKBBx5YTjBvfetby5M4FCAxAQYqBrCAg6QC0gRbIwrYaZ1xxhmtWwjoBlBP8H7nh3d6oC6Dk4ZWgM0XnBwC5g2rs8DJIQaI64H5giPeILWggJNqIXo5gD0JnEQE9RRWw8EpOkt5gREBZhoD3Fxw+XPxAXD6rQ8A0wISAuruA34DzfjkGtgngTsDzHzB4gknS+FEmRXAdIAEFE5zgf2OxTaMayOQ0EEbYfUn2N5AuvTEHTBbQCecNPWMFzCVsKjCCUpY5KE/5QaoVrHqH5gEkBDmWGhhEYcygKobq6TBRhM2LrngbTBBlYch3W4QQzceD8BgwfzkNwDA7IMkGTZzHMPvxwyMITp+gJnGbkVi5wCgAZhxkMxigNQeGLjY9oO0qNkA9F+QEnPq+wHxGCReA0wApgGOjIMRLdgOYM/1oHqCyQPUWDGAtEDVCLsoUJ+AHY33XA9GsiBhgDzbwi9S4HwTnMCC/RMsoi996UtL1SJ8h2PwwBABwwSTDKem4gDxYMID2sGdBEzU4G3fG1H7nStMzHD0HSZBcF8BBtlglA8TLkjYYLcMk7ZGr5+MMeAd+JcCOoAxgTqF3T4wj9QeA6SWIO0CNxGw2EM4YAbAuBkzg7Cww7MTTzyxlEwCswNtDX8gaQEpEEjUgH5YfCAdDlB2OKgQunoIbFC+853vlN/9ogVlAkB/ALcAni5Qz4CbD2CeYJEFyRCoUKEPYVUg7NKhLaGc4OYB6gnUyeAzDIyOYwCHB0AyCwscMHRgRB3jxBLCgpoG2hzqA/qKdycBrgjA7xsGMFvQh6D+vOoRFmxwJwA2RSCBkw4ZtAHUH+QHdAJ9wFCD1I8eFEkFqLShPSAPULWBvSAwRDAeuM1ICmDsgGsEoB3mEe9OwjvlTXF3Amo2GLcg6Qd3Dd6dBNh/Yr9goEaE8QBtDAciYJ6EeQTmRrDjA4N1GIPgKgLqGNoT5j9oazpWYb6F8DA+geGGsb/NNtuwtpgwN4AUDeYLsMcDKTfQAX0WVJjYkN4CYL7BxQf0dUgLtBEgUYONDNiHDsiADk5KDpjBuP7664t99923WHfddctjyU960pOK5z3veeVRZDgqTaG5JvA455xzSlcVcGR71qxZpWuAV7ziFeWRdHrMG1wtpOATn/hEeVwejntjVw0/+MEPimc+85nFkksuWZbpM5/5THH00Uc33DnA8e1ddtmFTfuGG24o3y211FIl7eB+4JRTTinTOP/882thL7300uLVr351eQQejpBDuuA+AOrAQq+Er33ta6VbCkhzq622Kl07gCsJ7E4CjrR/+tOfLvOEcFtssUXp0oAeTwf89re/LZ797GeXbYzb729/+1t5hH/u3LnlkXNwdfCPf/yj0cb33ntv+cy7eLC4M+D+MP3YVcZGG21U0vbUpz61dEmCXXR43HTTTeWR+uWWW65Ydtlli5e//OXFH/7wh8IC7E7CA/oj9M/Xv/71pUsAT/fJJ58cdEkAOPHEE8s6h7pfccUViz322KOsT4rf//73lZsKDHAXAM8POeQQE70AaFdoXw2+HOAW5OCDDy7HIfRl6NN/+ctfamEldxLcuOTGPYwLKBfUwSabbFK6xuD6n+ROAuYTDKhjOj7uv//+si6gjqHdX/nKVxbXXXddGe7www9X60Jqu//7v/8r5zmoF+hPMD9dffXVjfhQX+BWAuYBKCO4pQFavLsRmCNhfgC3GpAWpHneeec1xqrvb1BH0OcwTVx9wXj7wAc+UKy55prFEkssUbqugTah48LST4DWAw44oNh8883L+X2ZZZYpv8McMyAPJuBfDgZuwIAB/wLsuEGS8be//a2UDC1qAPUc7O7BHQLYWw0YMErAIYktttiilI6Cc9sBA0aJwcZrwICWoHY/YOMF3qjBuHdRZLoAoD4FNenAdA3oG5wdHmyEQN3fxaGEAQNiMdh4DRjQEnA1CpxEAyNcMEqFXTWcKALbjUUVYBczYMAoADaIl1xySWn3BNeAwSEG+AO7K3yF1oABo8KgahwwoCVgNw2G82DYCieCwDAdToHiS4wHDBjQD+CkJJyYhtOSYLQPmyI4oAHG58CIDRgwagyM14ABAwYMGDBgQE8YbLwGDBgwYMCAAQN6wsB4DRgwYMCAAQMG9ISB8RowYIYDnHSCa4dRAxx/ggNL+MtBD6QXupQ4BeDMFe7vBMen4MQSHxgAR5fgzNRfTwR1G+s4WLMV9PUDf7fffrsaHvKF/McFYOMIdMOtCSmA64TAqTE4JoV0wFFtF4B+A38DBowKA+M1YMA0AHjw7+tqni4BDA0wNuBNHqPNgp0TcBoVGBrw9g2e7+F+UgB4AocDE3BxNtwKAF7K24KWGe6DhLqBmwUWRey9997VTRZQD3DVUh/4xz/+UXqgB19fAwb0geGIx4AB04Txgvvh4AqQ6Qy4sueNb3yjG1fA9UZwyTJc5wPX5XjA3YngBwouN+7iuh7PlMIfXOj8/e9/PxgeGEOgdab43oI7Q+Hk4bvf/e5e8wbGC05BgvTQSzIHDOgSg8RrwIAxxv333z9qEhYp3HbbbeUnVjH653BXZFdMVwpAFTpnzhw3E+Aviaf1PmDATMTAeA0Y0AJwoSxIoWC3DIsgXLD9b//2b+53v/tdLRxclAsX+MLivfLKK5dSH7ggGwNUXHAh7Z/+9KfyQma4HBeuNwF7lB/96EflZdLe/ifFtgfUZbCjhwu8wdcYXJjtccMNN5TpfvGLX2zEg0vQ4d3xxx/vxq1eAeCvCZxlLr300uVNAeBAEwPUeUA/2CBR6RY895d4Q16HHnpo+X2VVVYp34EKCj5BvQhMsK9/TS169913l7SDs06gHSRncEl2bulUjI0XOBCFy7fhsmXoV3BZ9e9///vkvKGMkD/YYwGzBGpCeCapb+HCZbiEG/oeqBB/8IMfVO+hjuEydMABBxxQ69/Q5+HC84022qgcOyuttFJ5QTptS99OFFLbe0DbP+c5zym/w8XVlvYdMKAtBlXjgAEt8I53vMN973vfK9UjwMzccccd7te//rW75ppr3JZbblmGgUkcJnWY4A877DB36623lqqs3/zmN+7SSy+t7fIfffRRt9NOO7ntt9/eHXHEESUzsfrqq5ce8eHeR88YAYMWa7gMDl2BXlgkgZGABewnP/lJydCA0TjYL4G3fbhjEgOewWK96667lr8feeSRkh4LYLEFFV0X9Qq46667StsouD1gt912K+McdNBB5VVFO++8c1SeYEP37W9/u1Tzff3rXy/r+JnPfGbJOIGt14UXXlg6ygVst912bBoPPPCAe+ELX1gy1W9/+9tL553AuB588MHu5ptvHomdHthLQZtDvwIGEGiE8kEfg/4Xy8TD9b7QF6A9oJ2e/vSnl3UGeVAAcwf9ChjiD3/4wyXjd9JJJ7lXvvKV7pRTTint2aDtYAxAv3vDG95Qbjp8/77ooovK+oPrp5785CeXDBTQDpsRYLhhfLQB0P7xj3/cffSjHy092wNzqrXvgAFZkOmy7QEDFkksv/zyxX777Se+f/jhh4tVV1212GyzzYoHH3ywen7GGWfA5fTFRz/60erZ3nvvXT778Ic/3Ehnl112KZ7ylKck0QjxIN1TTjmlejY5OVmsscYaxRZbbFE9++Y3v1mGu+aaa2r0r7zyyiVtHueee24ZzvJ34403VvFe+MIXln856tWnB3l8+9vfrp4tXLiwWH311YvXvOY11bNjjjmmQQsuB3x6HHrooeWzf/7zn7WwUP5lllmGrVtcN5/4xCfKcNdff30tHLTp4osvXvz1r38Nll2igQLyDfWJe++9t5g7d26x77771p7fcsstZR3T5xacdtppJX2f/exnq2ePPvpo8fznP798DvXtscMOOxTPeMYzioceeqh69vjjjxfbbbddseGGG1bPoG0g7uc+97laXg888EAj//POO6/R7r7OKLi2p/3woosuatA9YECXGFSNAwa0AOzUL7jggtJAl8PFF19c2geBugTULB6g6gFDalAhUrzzne/M3iZrrrlm7bTccsst5/baa69S4nHLLbeUz0BiBDTiOybPOuus0q0BNojffPPNy2tZLH8greuiXj1AMoJpAxusrbfeulSdjgKgUgapyQorrFDWm//bcccdy+ukfvnLX/ZKD7QBqABBkoTpAZcY22yzTXmZeSx+/OMfl1fv4H4K6b3nPe+phbvzzjvLQwnQr0B17PMG6SVI30AKS9XtFKBe9ABJK8QFCST0D07tPGDAdMCgahwwoAXAnghULGDPAzZcoCYBhgZUd95GBQA2KhTAeIG6pjYgZ80qVSq5AYsVtYF52tOeVn6C+gYYJFjMXvGKV5QnKD/xiU+U74AJAzXRS17ykioeMBXASIyyXj2grmi5gL4rrrjCjQLATEDeYCOmGe/3SQ8Atx8GMOCxgD69xhprNNTdtI/D6UxQSx5yyCHln1Qf0L+0046gngfVODBpkJ6HVd09YMC4YWC8BgxoAdjNg4QDbFzAeB2cbIIdDRiux9oYAcAYO8UmKheAuQGpDdjVgJ0UGEGDtA7T9PDDD5fSDAuAAQFpSFf1KqWNF2jO6BoAEqjcAAN6sJkDn18cPLPbF7xBP9h5cdLHLi+N9nmDzzaQcHHALjs4gBQNmC44rLDttttWzlXB5gsfVuizjQcMaIuB8RowoCVg9w/MCfzBDh6Mv8EJJDAI/rTWdddd15A6wDP/PgRpYbHCSx9wOtdff335iY2rwVAdmCWQdIEqCgyx99xzz1pawJTBKUILbrzxxmTv6lq9xgAkYAB66s5LI3MCHK/ed999nUsEY+gBwKnQXDRBnz3nnHPKcmKpF/RnDC+dBLcXqXnDYQmQfH7+85+vnj300EONtsRtjA+rWNq47dgaMCAWg43XgAGJgN00VXfAAgf2VAsXLix/w9F5ePaNb3yjeuaP98MJPbD1sgBOg7VRrYCtFHbKec8995Qn+MC9BJaEgAQE7IHg5BmcxgSpF5zsw+jaxstSrynMB7avgjy8V/qcAEkdOAIF2zgKYArg1GqXAFck8OcBkiZQJ4KnfbCRkvxnAaDOwfVDqJ+B2hfKAacLcX1+5StfabQZnD785je/WZ7o1PKWABJNLL0EQD5UksW1Mbj/OO6440xjCyC5wxgwIDcGideAAYkAg2GwMQIfRcCMwO7///7v/8oj8H6HDrt9UJGBOwlwMwBMjXcnAZIg6rpBAtg5nXjiie6DH/xg6ZYC8gJ7LCtAxfWWt7ylpA28xx999NElHaDG4dSNX/7yl0vDa6CdomsbL0u9xmDTTTd1z33uc0uXDqAiBRcXJ5xwQidMEPihAvUs3EUJfq6g3YABgKtwQHoD9nTgx60r7LDDDuWn91sFTBcwSCC1BIkhqOhAovnXv/61PNgBrh6++tWvlmGBMYd+Cn1Cu38S+h3EA/cQkI/3CccxbEceeWTptgIY+H333beUgkG/A+YU3KNcfvnlanmgHkFNCipGyAfiQV8Af14YcMcjuO6APg5tAAwb9HFfVg3AtIGUDDZH4DYFGDGQ9q633npqvAEDktHpmckBA2YwwHXBAQccUGy++ebFk570pNKNAHz/2te+1gh74oknlq4b5syZU6y44orFHnvsUfztb38zuSwA3HfffcW8efNK1wAwbGNcS0BYcEdx1llnFc985jNLGjbeeOPi5JNPFuNsuummxWKLLdagsQ2s7iSs9QppAZ0WNwt/+tOfih133LEs+2qrrVb853/+Z3H22WdndyfhXTgcfPDBxQYbbFDMnj27dMcB7hOOOOKI0j1Hl+4k4DfXN6CMO+20U+lCYskllyye+tSnFm9605uKiy++uOF6weJW4Y477ij23HPPYrnllivThO+XXnopGx/qfq+99irdfCyxxBLFWmutVbz85S8vvve97wXdSdx1113FPvvsU9bhsssuW5bh2muvZev9kksuKbbZZpuyztdZZ53iC1/4gsmdBOD0008vNtlkk2LWrFmDa4kBnWMC/qWzbQMGDJiJ2GKLLUrJENjy5AKonUDddfrpp5duH1JO1M1kgO0S2E3BiU44TACquC6lYwMGDBgNBhuvAQMGNHyPXXbZZaXKMTfAMB/UP/PmzRtqnQBUXVA3wHQNGDBg5mKQeA0YME0BEhHtuDxIlUBqZcVVV13lLrnkktKOChxdghNS7PS1LSBtuOIHAAwG2G8N+Bduuumm2slAsAkEG8EBAwbMLAyM14AB0xRgnK8dl4eF218AbQFcNAz31oEjTJC+QPwBAwYMGJAXA+M1YMA0BVyyDZ69JcDpQzhVN2DAgAEDxgcD4zVgwIABAwYMGNATBuP6AQMGDBgwYMCAnjA4UM0EuDcMvIODA77hCooBAwYMGDBgeqAoitJxM9yO0cdduQPjlQnAdK299tq5khswYMCAAQMG9Ag4WQy3ZnSNgfHKBJB0+YYbHEMOGDBgwIAB0wP33HNPKTjx63jXGBivTPDqRWC6BsZrwIABAwYMmF6YmFrHu8ZgXD9gwIABAwYMGNATBsZrwIABAwYMGDCgJwyM14ABAwYMGDBgQE8YGK8BAwYMGDBgwICeMDBeAwYMGDBgwIABPWFgvAYMGDBgwIABA3rCwHgNGDBgwIABAwb0hIHxGjBgwIABAwYM6AkD4zVgwIABAwYMGNATBsZrwIABAwYMGDCgJwyM14ABAwYMGDBgQE8YGK8BAwYMGDBgwICeMDBeAwYMGDBgwIABPWFgvMYVCyb47wPC9TUT6my60z8DMTGxaJVrppZ3wIBRY2C8+l5M/V8I8wr+uxHipOnzpp8auLBaOUJpMkxlcJLX0oR3uI7o754AZaDl4J6ZQOnvgBGLoSsU1pczubxGGtqk7eOmplEUPC207FpdaHXUdf2FylXmi/oZLq+1PnujnRkPsXnXwi+Y6LXeq7wiNti0fRrPE+eIqs9pa4I1bS2ulP6C+LrnxpX0Lkgj/D5pedcnJooiNLwGWHDPPfe45Zdf3k1OTrrllluuWdET4YmMxYiYiC7gBwTUQ6g+cFj8rIo7n6+X5HpW6ODSy5kPToubNKT8tfda+tbwXFiuXVLi4bBcObi0QuXQ3kt00/rmaNL6AAWNr6XTR9/KPVaHeWxmo9a+flO8R8H3W2CYyLuZun7nxiDx6gnJnXOGMF2+Dnw9hOoDh62eAbPl4wr1kmUSMOz6G89DO07yDks2cFq+3PhPyl9j1vCOmqYvxaFhuLxDNFnj4bD0ncSMcUyTVo80PY0uqW9qkimuLnBe+E9iBDkJlw+fIi3jnjd+K33R/5bqw9J/xmEeoxLJUavwRyXNjEWtP88rWKYLv8/OdC2QpWIStDrV6rz2vGeJ18B4dQWp46Dn4z4Ic8FUzlj1a07QvLV8JDohjhaPvNMYmBi1gZRO9SyBQbWoFdu8D0FiaChDpjFs9JllgZDSb2wAGCaSMpJcelwamDHjGDApTnQ/wL9Rn6jqZ2pTw0q0mL4YlADi+S4nsxNSzU3lJ27ycswhCeWptZ1FlafVH/fbUs8xbTEVDku/vKZBHUshFTClYYEyn+J3ie1W1vlU3+beqTR0iEHV2LGoUlO/iPAdIaazeZVkTtWkFyX7jpuabiJNlkUzRuXWJp9QfE2FxKnVPKgKR5J+SLRZ39F+GKsyimkLjmnS8uTakFP3aaDxNCkTTQ//1vJPYd6455Tu2DbUwoRos5ZFZALxWGbGddux1AVC/ZKGoWMx1OdTxlOI3pTx3jdUWgJz/kSEyUMfGFSNMwzsrguBivhN0hMOPnxOqZAXJVN6GFUFBRVJR4PsWqVdUlDyEdgtSotzjKiblSowv6mUA+/E/E7YP8eSEG2XXMuLhPHxcBml/igyNowEQasHjtbQGODakD7jJFBaPC4/Lq4vO65vKX8LaLrae7rIcyo/TW0Wy+TQsrCqOEJno92xtGyPJtNl6SdWNOhKPLks0aT1G2tZYvuHld6UdzVESHHUsa+gMfdgaZayXgAa8wSO66VtgqRKRKx0FYcdjOunJxoccwdG8dE7gFQaMtBu2amPgi4LQvSO066Toqud97iVuYs2kiRi/pmUh0WyaJHEce9DUq4YCWn2NswoZZfKPDZ9MCDpGwtY6epIO9JXnUzg8YIPWbVY7+55+WSvxvWDqrFPUWULlVsfYuxRIOWEorbgjRRT7ZtD/ZmDDgxNOpKFXiFPKrWznoKy0suF0VSKXBocY8RBYq7os5Q4EkPWJxMdokOSjHUKZc4M1d+oEKq/HDRyaanph8xXWp5QbFv3E4HNSNd9aVA1zmSkGgjGilw7hCiWTkQ5Ie1RZ1Zq74QTV/g9pY3G6QyKUX5NTdG38WZkP5MmNrUep1SYVA3WUF8Jpyol4DQwo0AnYlYNRt7jNLiFkFM10f7F5cOlSeP477QsWjo5F2T6zNIGEh2N+kCq8FSapHCNsMIGgqOXnQ8MYw/3VWt4nHZo3mn0jZT5gNDWqP+QOYBkvoIYMonxqYUTfqvMnuF5QebKxriLaUcJCtM5qBoXQVVjNTkLkp9UtNmFBHdPPfnQEmkYAcaBnt5pCLS11uYcA5WiApN2w1K60ntNosTF8bBIUzipEMd4hSQVVimulE7bftGF9KgziRTpm1EqSqxukxwW51DbhdKRVJgBCVWjTFw+I1KJauMcUOQgaUpC10gvpt0AU2H7lngNqsZMSG24qMkoky0FoPOB0eNkYKlDTeUUU17LQpoDFlG7lXYrjRbmwqczKia0TZm1xTimbJzqKHd9cGq0nOmnMjYWGnKNNSndtkxcFZdjmoi5gLWvceVk0xAYhi7bV62rWAZTiWNqkxxrwoL8Agrn7nHODQ5UFxnEiOvxKSKLOo0Lo4mjY9QHPn0VnJpg6lkuVSCe5LQ0OZWRf86lKaVF06C/c5VLopeGkfLkVHMaOOmPRJM1TY6WXO+k93gBoxIo+t5SR5waiYbzdUfrD8fx36Uy0fcaw2IZ+xrM8a2+5xi1E6cmastU0P5HEVSPoXRC17OZ+rdQLnWMTKn0uPZtmJRkMlFQyyEwUGq4Ni5EuPz24NPjrhOK7ffWvj456XrF4EC1T1idxzHvQgs+By4M7cTl74BDP6nzsgwPORKs0YbTtgwOiYbSvgE79jOWx8pcafTQ+mTrm3FhITEEnlZ1ESFlsTCeGv2UbomR1CZArU45BojLi6YlMTganTgvrm005ii0wGsMNtcXuDRDmx52QRZsz1Ih1YNUliBC0odE6USIKQ/1Ryy5Ypn0qQU/mZFV7M+CQPNk1Za0nlJPpONPa/gWNsVWBtUav8C/ie1Z+d3CLBJbsXGzoR5UjZmQXUeccnzZYBfgoTFkdFKuxPIobS0tDcHdUW6njFo9hn4L9NcYvESRe2r9pcJCkyWNqInWYH/D0Rh6n0pbbPyYOuMYLe65fyflR+NbaU2hORhe6d8+/9ixmaMfzhiEThpa4ndpw9VGBajFXRCXbqPPpNrTKRhsvKYp+m64tohe3CIMP6cbQgteK8av40Wnj4XMwhABJMYqKzOQSKMWXgO3CZHixqYXkuiF8szBeLWJF1PXUtnpdxyuhLDhU+coZKfF9gmcZsCNgkRf63EXYBKS0s90IKCx4WZs3rR6weGmC+4ZLsleBNCDe4HYBYU+bwD7p0rxrN+2zAb1IRfOIv6X1EDiIkfE+aLaCrlcoG4VUmFuL0N8qW6kPEJqMokm3Nc0FZ0kBQq1IVXDsWonQ9tzf1wZpU+sGqRpYJWhRgsuM41Pn2lpxELr+xSYPmvaUv+Q6riEZwwkNy2SrRCy06J5VOE8I0fsizjaad5V2VvMaTH5+vmjBi5v65wccJ7K1TF+JqnR2bjCvD3BlUkK3+ea0hMGVWNPHHNoZyepJPpAm11KSNoRyieUd0h6wu2eLZKZWLVOKFwqLOWhtFikSbESoBQ6MS2W/hvTz0ISoZi+ZGG+fbyYeqN9I/TbGl8rt0aLtZ37lIq1iZeSDyDUflklV0Z6rO9yj9tRImcZJiJPXMfkC+EnJ/vVWA3G9V2BGEiLOzvGYVxoV5sCv0ul0pnYxbCieepPm9y0nRHON2YHr/2m0oHgzmzKIF+TAuVqD2nxt5SHo18KQ5+HmHsrtHw1SQ9HP0cHbS8pPk2Le8+lRdteiofLw4GOG44uKV+uPFx4i1RTC9OmnS0SLknCKz3PufiGILUxDWMJ1xZif+ecnfp1YMrQu3xnlMhY6kWUMCUgZiMTk+aEQRocBLcmRRr394GB8eoK5DSGFq5TCJ6AU5i8KpwX/xORPv7uGZtgWhnBLbYqCP25d2gYYrrcaUXmZFKOxTQkAeDy0Zik1MWLMglUhZaTQeTec0w/HQ/SQhBa0KX6k+oxtgySmg8zhFGbKIGZpOmJY5xpM2tbxrYzzCeNdkEb3Kr+LWo5PMY0dViIVrQJrdGG0my0hzfbwDS0uDuRG0+0jGXdBNSbFBzDKPbjFqcoAVGbW9RmjbE8Jk5kQxhUjSMwzqtNjpIHXiGedXJmw2leko0ekrOKwA0GpqPYkTTqr+3gZRxR0oUpuYzaycqImxAoTda+SBkZa1rWPHz6beurSkM4NUvzCdGJ42BodMZIqWi9hsrdpp5j4qh1FDGX9YEYJjTU7tZ+l3V+jMGYMBgjK3/LOhtONU5TcA2XW4JimQiSJ82OaExJm1240SDRFsrUvEJpxdR3TD3ElkFjQnItsirTprj78ODSw+9imC6ahkVqJzJE5LQbl4/0TKMT08UxS9J7a9ks+dM8Lf3PWqdtxpiFIbSMvRgpXrZNzQjQak4LXXRtZM6mY721ravhVOMMQs6OS9OSRLMhVUhM+FjnfByNKeDUGvRkU9DxnSL6xuofU1qR9R1TDxVDEKpnYgPC0ZRS3yLTgU+xonfcxO3p0OoIv7PQKfV3rAKjKjIchuZZhhM8ZONPjVHg1CwhqRWlgaujGo0GlSTH0OHP2P7H5UnpSoWUt9ZvVUZeUHf5cDRdWrfRZbGoLTOh9UYSmbew5cQaDqUc0jjOghGeJARUfcBqCtQRBhuvntBm8opKt8uO7QduzyJtaTGChZQunhUYqQzdydUGHpKmhdoKv+cWRZEmCYx/NMoo0KPybUGZjdBCTFVrqf1ZYyKkdGmelMngFlxuocVMWYjZoLRwixFm1GJcWlC6QgtuiJHKscGR7JXaLsJcWfEnfc7ShTG1YFoYVAxtY9CANof6sZkyznH6nMd4jrYY2ynNrgynJbkDkvIi9lQa88ulUQtLHVZL6Ggdw5uzUWKw8coEi6hSnGDHRD8/kl3agEZ9akxCiholto0k9RtHF8eohFReFnpiVGZS3h4ajZyEQKpzK63WuJy6LdTmOcdajvRC/bDLPKq0FRvKICLmXsuY0/p4TJ/i0qNxuyqnFdz4H8VaMNHS3Qq8G9xJzBQwImrrIonjlL9HKZ7lTt0xYZLE+NZ828QNpRPxPiRdVHeBxvJwKjlJqqP2J7L7ZXfoQj1x6XKTPbcgaCokGh8/45glKmELLe4S00XTkMpH6z5Ux5xUCC/ONG9OAkfpDLW5NsZyjL/YNEJ1VKnGU8YzOZEdkqKIjFFAgmVF7T5YKYyiTq/alJg1VHO8Qf3Hji9L3fpTkz68xXmp9hutZ7V6b+sUNXC6W+ofIXCbr5pLpJOWd31iUDV2Be7CU6nDM/ZL/nn5uwtpmNV2QbiVvjbYpui0MgJJiBFLx9RXxAW/jYmFxBXLb/H0n5u5RupLSbJTa0+kto1V4dBwEpPEMSj0uZS+RXqAmSBugdKkhW1UR5Z4wfGRaPuG8+UYM07Np6XFLlApoEw9VadbwNgZavWpjj8LjHah5nqRGAdSF9Ucz9lPxlzgHFm3wXlT+83Ni9KGV1MvLjAyWVx/pnMWt76GVLpcPfSAQdWYCTlORcSoj2Y8ElxNsAv+uKhxR0AHp8rKkSZd5CXVSogmml6IzlB5NJUsfm5VkVjLx6mDKCSGU1MlhejLDalOg+0xwjE2KvVWiRblTlE7dgWLurh8j046j3qunQiYOZjqFLuT+N8Jt/y+oHIcPNcvkmAXDGrcOGqEDCi558gg06Q+DQzgmthfEzmPA9PVAx2cZMOi9rPu4KkKjftuQUhKoaqthPJUKj8kHaBqQE71R9Oi9cGVj6srTj1IJW+chA8zXZykzlInElLmCo55NLWH0UUB7aPanGGSPgrzYpRUSsi/DSySY7a9M0leNCknB6mfNt5LmhkPzc2MsWwT0qlloiblNk5RcxFlEnebdH1iUDV2iBR7icZ330GojZjQkU15ErslOskF02C8A4dURfj4bkh9apo4idg7drLR8m5M6gZbrpQ8uXKmLhpWJovGKf8M6owud+V+wbcsWBo45520X9BFJsSIafRINGt5hqQKVuakq/aqJFgMbTVEqIR8urSPanNGVV9TfZOlQTBxqPp0wDaolq5k45hgH8bVYSNdLT1OZSdtdjmXM8xcYGWCRJs8A+NE+2tDpWeIW0ibF3yiPvUgxRhtyAdVYybkdsCmqT8kdYllYucgqWxGLQIPTuaJntlN5Uw47YTTCtYhkz63WI1LW2j9EUD7ZCzdqRMoHg8WyY1FJREztizlTCkbl641HS2cNH/E0KX1y6h2z6WaQukkL8SGdo55HpMnV4dSG3F9k0pPfRksfV1ti9j2GRezjgT6FikHqo899pg75JBD3HrrreeWWmop99SnPtV94hOfcAXqIfD9ox/9qFtjjTXKMDvuuKP7wx/+UEvnzjvvdHvssUdZYXPnznVvectb3H333VcLc8UVV7jnP//5bskll3Rrr722++xnP9ug5+STT3Ybb7xxGeYZz3iG+/GPfxxfqEynI0ISJHaXF1AL1P6mVHWSaqPrhZ7baapAF8tyou8Qostp2KHRdKw7ein9Rvki20JkrluoMCQGgO5QaZjYPpTCmODFhKs3/Bzvxjl6aZlqag4Shn6nTJ1VItpQp5D64Ma4BaF5ICYtS9q0Lmr1TX0+KYdTkhHYwHDgwuA6lxh3Lo6UttYfKukUI23W2ojtE0jjUJUBzZecVB1/L39zbRHbPiFDdcs8tABJKkMnJGPnNSpRxJ89n2oExmZk+NSnPlWstNJKxRlnnFHceOONxcknn1wsu+yyxZe+9KUqzOGHH14sv/zyxWmnnVZcfvnlxX/8x38U6623XvHggw9WYV72spcVm2++eXH++ecXv/rVr4oNNtigeMMb3lC9n5ycLFZbbbVijz32KK666qri+OOPL5Zaaqnim9/8ZhXmN7/5TbH44osXn/3sZ4urr766+MhHPlIsscQSxZVXXmkqC+QB1QmfsRhtKyDMd3nDjQss9AbCZG0jnBd8p3n73zQcpaXDdogtb0x4vzzkShenF5tuDC00PykuTRuHSYkTS1tseI4+jQYpTI4xEtuPcqeZCq6+yt9TYzS2f0ppqmlo80HkHIhpT4GFbpeQfKhfWp7Xfk/Nv5NHueT1OwUjXUF32WWX4s1vfnPt2atf/eqSQQI8/vjjxeqrr1587nOfq97ffffdxZw5c0rmCQBMElTYRRddVIU588wzi4mJieLvf/97+ftrX/tascIKKxQLFy6swhx00EHFRhttVP3ebbfdSnowttlmm+Ltb39754yXR20yGyFzk23Q9FSGkTKuHZRRWviC7TIfJo9w2tb8reG5ePQZTVMKl0oDl3aovqT6DdHMpU/jxDIlFkZH+05pCOWllV+iKXV+0uqtDYLpSTRymxhDXlrYRv9g8mjDUNO8WBAmL0Snny9M7ZK4eW27iXA9ze051u8YjFTVuN1227lzzjnHXX/99eXvyy+/3P361792O++8c/n7xhtvdLfcckupXvQAPew222zjzjvvvPI3fIJ6cauttqrCQPjFFlvMXXDBBVWYF7zgBW727NlVmJ122sldd9117q677qrC4Hx8GJ8PxcKFC0u9MP5rq97BU1unfp8Cccv8A8/K3y1PJlpoYcOROBwtVJyO4zZUO1LaltOksTYQ3HfmWakKJmqIYLso9481bD+8SF8wAvbpSOnRdCVQVkRqF/w+h12bZtNH1ZScCrI2FoU6welLrBd+z9GglddCJy0vzZeDtW3LtJi7Qf38ZFXpafXWBo30JN9hFKHTeUJeWthG/+DuljW0TbTROsZUnrRf4O81GsjhhFq6Ql2qanSqavTqTqpOXWCb81Prq5FHKL8R+PEaKeP14Q9/2O2+++6lXdUSSyzhtthiC/f+97+/tNcCANMFWG211Wrx4Ld/B5+rrrpq7f2sWbPciiuuWAvDpYHzkML49xSHHXZYyQT6P7Abs0Ky64jpOPTC3yh0ZFuhQSyrlIbi3I8re+VMj7GdqE1EUzfS1yZrrPtnnATmWigkB4Rsfganq5rtBkWDCfDpJ9jHcOmGDLpjbGZCTAtHq2fa6KKjjTXKjFrD0zCc3ZfGYFEmiTKlkj0atxC1ZWZqdehPAlI7LGFTY8lTarsU+qRnNTslT6uxXwfn4TGAhQGRysCNIxOkE5uKTVojHjqJWKNvXq4JtcVcS8Iuv/wixHiddNJJbv78+W7BggXud7/7nTvuuOPcEUccUX6OOw4++ODyBIT/u+mmm+L8UIUGU6DjUOkBRZeTScpkFb0wKPUnSX5qO03tqPcUGkalsRPCCHZKGNIinIoQ86TGm5qQG/WLjHz9e67vSgwKBo0n7ezpO/qcMjsaI8ExUly+nGSqIWEI0K0xWaIEl6E1BpjmcvMCm5rAQhmaezA9qdJLLV6jPrFPP4HhCvWH3OibmSvLEHIBgaT9LH1EG1CTZFmguamQpGkZ0YaJnpxchBivAw44oJJ6wSnCPffc033gAx8opUmA1Vdfvfy89dZba/Hgt38Hn7fddlvt/aOPPlqedMRhuDRwHlIY/55izpw55SlK/AeoOGdrJ2yBkOg7BZaO29Vk1QWsUqAkpO7ckApT3dHTE2Ekfm5Y+hOl2TMXXuLYYCTQIk7fcQyJqPow0EjDcAwfpoNKniijRNVkUno0XY7+kMSK0pXSb9W6MZgXhOrenBdJMwWhDUCtD3oJuOI7aySMkECTijb+GQ1X/jT6IZFulu/8JorzhabNedb5cF43iwcdu+MsyRwp4/XAAw+UtlgYiy++uHv88cfL7+BmAhgfsAPzAFsqsN3adttty9/weffdd7tLLrmkCvOzn/2sTANswXyYX/7yl+6RRx6pwpx99tluo402ciussEIVBufjw/h8YtCQpKDneFE1pZPwLhacymY6SX405GQQxXpJPNYsLUx4987S32LiajshUZolxkRTC3K/KQMiqepCEjEpffwc93GpPjSJk5SWBI1mTeIllS0JQp9pSNKmVI01OtuOb6szTsN9fTXGEJsVBHxIBesvlkYpjIVREWwrsbNsmp562XhM+0ibOY5m6X5Nq8uI1H6zIJC+Id1qDFnacRQoRoi99967WGuttSp3Eqeeemqx8sorFwceeGDNncTcuXOL008/vbjiiiuKXXfdlXUnscUWWxQXXHBB8etf/7rYcMMNa+4k4CQkuJPYc889S3cSJ5xwQrH00ks33EnMmjWrOOKII4prrrmmOPTQQ9u5k0g8UZPaIlW8lFN26DSM5ZQcVdhI6TVoS6UvkL4aRnLVoMRr1KWhLTmoddQzuDajdI0LraH6w/RL5Qr9ltLiaIilV3qm1X1sXp0j1PcLuS67QChtqZ47heEUcSyy9AvSdqY2MsypqfWaMoZc6glYpRxa2fs+1TjSoX7PPfcU73vf+4p11lmnWHLJJYv111+/+K//+q+a2wdwKXHIIYeUjBO4kdhhhx2K6667rpbOHXfcUTJa4ANsueWWK/bZZ5/i3nvvrYUBH2Dbb799mQYwe8DQUZx00knF0572tGL27NnFpptuWvzoRz8yl0VtuFH6vTIOqOmIviZYax6tJ41YGiKP9GsMFw2nMdy5oaVLadaYmxCjpTFqEi1aXWllsTKD1nRzwNL+MXEtbdH5XKgwiGq52tBhZEZTGY5GPM7XXyJi+9y4bcZSEKR/UfPjNZOQxDG3dXhnBLcA1d4p/l/8+6idWJtyZXB22ghjpSd212fwm5OEyLbPzeBpTJd1Is45YcekJTED+NP6vE1eUthxXsTYBb/r/hrLMHH5Ei2CFl8q46gY4c7ylJw0x64rPTlpdtaxlIHB5vrAIuXHa5GEUUedlK4A6Grcp//OXS5cu3AV2xpJl8liGxHt6gjD0d4guDvF6G/raUVjOGw4XZXb6m7CYlch0WRAMH8DqGE4Zz+F/yw04XDWU3CWtCx5c7/Lvi7Yc2m0hOyyWINvxn0ETUMKH4Octp4NGq0ua4wXILMuCXDcqXGiXdpeS0s4wczOS+gdPbHJnT61XBzf8PPHjPPQIQk83nKMY3Fe41w74FOM5OJwWseSnWIbW8CCOXwivWfLRS8F52wENXdFOFzPVwYNl2RngnjJJvUT1cI4Ouvg7PhCU2mxSX3WJl8ujIeFaQoZJksLd8zz6Q5qaN5HGXFeUj/y0Ojhwlni4jKnlJ3Sz8Wl5YrtP330t9Z5hOYivJnjPgO0NRZnmkbbE8qSAb10cTeNYyzHKOYNNd8Wa8hEy0vaLfUeQ+cidUn2jAY3oA1OMRvxXSSTYIVw6jIXOFqrAaOF8xe+cheZWhF5dD4FfmcupcGVqypbx1LSURylxlKl2DLG0kulj5jxoQwTlSpwJya5/mDtI3gBoflwNNN4oXqjEprYujWHl06uGU+QRQGnHbN4B3z0SbSxEraAQ2bzeGMW+bK9EFPHzXtV3j5sYBywddz1aVNpvrK0W2DOKpRbLDRQbUMjz9TLvgeJ1/RE3xyzBTNVujJT0UV7cVIV/5sLJ73XaMTPcpRBkiBpUi0axqI6ldLhJGkWiZqFXu05ly5HqxYnlO44zAeadK8LqV+ISYhJrxY2UbqShJR0LXH6prdrrc+CtPIMEq8B2RAzYUe/z73bsuabm46OkCJ16mJRpFKc6pPYdFglVZxUh8sjCL8jViQBdLHFnzg/i5pP27nTuFQSVYtPbBy5sGqeEoR0JcaRxuPaL4WB6wOidE+QILeqV0AuxoJKgDTpSmZb3qQr4pT7FWkYFgr97Pxmsa0KaX0WhLUVtbAxDl7HSOI1qBq7gnXQSQ7xrI7oQvmQ95w6hkJaVNmB1REDRiU0mK7ac21XpTxn08qEGEaGxtN+p4JljFC9YTUdZWRCaSbXoXBXJEcvpw6U8qV9l1M9YhroghYsD1ELSTTQT/wd13f1LnDpNMeEYnq4/HNIHntVWSeYP1TvmTHP1X9M2o2wU21kimc0K5E2FBRt2jI5bsAhbWNtYA5KNKC0UzTjROo4ZrNeCzuCzfvAeHUF6eSdhUOnCwLTuaqOE7IPUAzDJcZGHKwcs5W6wzDYa3A73YYEgBs00gROmI3a5CEwqL0sPEhqUeaHvFVXNBg8Vku0WsrC2TiFEJLKaPRY0ua+4/4pSfM4taPWt6nUysp4Uhoow02ZRi5NTWKm5d3mvafVkg8tn3UxNb8PbDDV/LEEipkjuT4hvaeQysrNGbEbJi5ti3TXkhdl8i2MnTqXaiDrQK1cmsQLkFMaGLvRgFP60snanjAwXl0jURQaUploi0coXW7RoO9UGKVMXTEtNRpb1mcF5kh6itTKlJeSdxkXMaUVDdzlv4Fj9G3KYpqomXys9KTmH8Oc0IWXYxDpMzqJ47CW/qwxeRYmqyEJs6LFUX5rumIfSnURI82NgtF3lT9l1oja2m9YpHxqaVCVN0oDL85iuRkD9AaNTJ+r9QPhwBHn0kIdY/RCeqS61dobz6W1fqcdCJgKj39Hbd7mkTkvFqRfauOFfUf75G4935Ldi7ewRQBmB2xWZ3ZdervnrtGxXq1jdYDalYdqy7uWebOjoo0zydS6nAaYTjMIptUvE/R7TDo0DS4cfd7c+jTTo3RayhMDiaYcaZXoylkncuRcfmb05t4oBy1DyFmy0RFzVD1PlZfrJ+M0Lqu2mPqT+hPX70zI6AC7Ftb3pxF4rh/8eGWCPxXh3KQrivqpRq9uyHGKpJZWn8B0CydTctmWjBojq+NpWBdYnUclRdz3rukKqXA4lY4ESj8Xn5OM4fhSHCoBwfVHv3OflrqwgpMAcuXj2rkvWMtI51ow2WjEI3Nwcv1pc3niiUKtv2hS0kpyFlOumLXI4j4icl2bEPrdKDCcapzmmJySWNbUDRn1yckdtIVOvSzLHv8SQ5f2Z8gYmCtrw76AMWwX85oKr9qUdGgQGVXHsfYtueiO9YZvgMQ8VO9wniR/TQWSY1KlKj/KvOC8ONUiZ+tCVT5cXI1+GoZjiLjf2O6L5s995z4lOlKAaaE00jxouCi06PvWMtbC4Rs3MDQVveFgjpSO6Z1mHyupLQW1Iw1jNT2o5W81EUlVJysoBBMIOta7MlmpMBjXzxzUJqgIA/cK1lONVrRg+KRFiVu0sN1DLRxj2K7l1QiXWgexjE/MxGuhidY7c+VFKtidfOSpVvxcmwB9G+JJnjI3Xe5aJSaAAy0j7buUEdMkZ5K9lVSHlD6ufjS6Rw2ORo0hFxHLqIwaoXki17iN8W2Va87T0gqcKm7E1zZ8jK0cm/cCnb6KySTrSFsXNWL+UAeDA9XpCbOosqWq0ZquVUQNiF4wpYkiIzpRaQTqPifzkJsR6YqxCTEeYp4d9WNJ5dZG7SQtFPRdrEpPo0/Lqy9mtc3YSlEDdaEGleii7dBrnaK+z6mbLUxpqQKdn0F9R01ALOmljF1DPr335wXM1UuAWPXpggl3zwPOLb+v680B+mDjNU464haLWdnppwZy0B6AG/BdMYQCYiZL8X3PNOfAqGxkJLRlbkbdV0y2L4G0LQt5iEGlaWjhfNhkpjcBmkSzq3Zm07eOWYlJEOyiGvl0iY43HW3LkqVfKWWcLpvKmPLd878TA+M1ExivcVq4LOCkA0nMUEZ6VBo6ZLpiyyYt3vRZSj6xjIUkldEWfW7Xjmm3qCFDzEoMcx1iBmP7aEgCxZXBQgcXRqKNSvIkCRhHo7SIhiTaUpzU9zMVucrdZ/01xhbaTE/3dp5IlWC2WBMG4/rpjildMTYyr6D5Rclt4Jfo1wfbwrDpCMaYVRmMTj1xPE0VJMJy7QSlx1gnQckF43eHk5iEJgxuwa3VZcAeiHtHn+H2xDThcPQ7pd2aD6UrlIYlPQ/K0Gj1q/U5mgdXJ74N8DvcV0Nl52iLqXv8XGKiufeW8sZuHLTxOe0gODzNxYT0ycw0+lDILxbxe5WMxHWKzmsaYuaNGgRJqJZnJ2uvAYMD1dzwjtimOkHZcfyAh9OAhCmoJnLhhEksqs4W8hBMjSA140vmJA67C4eTj1OnH2u0kImcvqPSh2oHJ5QPLwbcwKm8/tNrOzJIyIJ2GQkTG3XUWJtIhXZR8xCY3xATrKHxnhq+BhjFGEiMnu8nHDOgSa8k5pOLKzHNGkMVA45OrX00hi8XNMZaYnDZzUJGtEovYEg+cmlPVwu9li5nCxVDh7QBj9jMWua1VgcGBEe0Ynr+FOlgXD99ESuqjFUzjVI8LKlEYqUxmspq5JNhz2jbnjn6Q041VY64nKqPkwpqfcvSxzR6LKrCVFjHhXXcW2mKbTurKlcyGq9tUKbUP6Me+5a8QnVd22TE2KkxaYy7ui83emvrBXaVKw4zqBpnMLQJjdvhJYtcQzD4btHE8Y1dsHGnoUkyrLCoLmORc7fO1SP3jC60ktQDi8stKsgY+mJUdW3Ueqm0auo6iQZOKhZi5mhYbmxa+iknjWMltIRuSnPMuLfUbez4kqR7QXBXXCmHfdT2TJHKeDAmD6E5K7RIp/hipBewdzafR6rXQvHFMa2lGXDjYO1PE+TKLMucXnvPqFxzS2NzYDjVmAkxHHNoJy/tDqSw9HvMjlXbhWtgaY00bgyVs/XkJHmuFmiJkaSk7Fj7kjD5+IA+d9U5pXiUKQltVCz9XAorMZoSPaH0cXwcR5PKjUoqYun3gHGRzljqMDXN1Pe55yVuTs0lcW6kMw1PhsfCMlf0LfEaGK9MyNVwbQcYgE6YVqahT/G3WazfIy3jtshQWNQ1MeL1USPErMT0YS5sqF0tC66UplQGmo9UHu1djn4Yw0zEfudo75LW1PgpTGzusZEj33EZrxbE9IuJMZpvB1XjDAc3UWPxcNUJE0TFXpxLOzTt2FJHxyqPEP1txbeqWJ97l6pyiKAlWr2S4doeGl8Tr0vqGiktCTFljC0fDm+RmuI//AzTSRdQylDRPGl8S3/n/jhaKB1SHeA0aHm533Ts0vRwX5bylvINlZ3S5NPinku055ZAcONCOpkY2ozQ71K/iQEbV6NNOmktlMH6LpfRPten8DNtXsLhY/pFkaLObmlCI4YdPNdPT4Q4ZklaYZFEjVok3OWOq0+VQVf5tgEnSbFIVUKSmFgacJo5wsYurjnKIjGr3EIcGo8xEggLg8lJu6jkC4dNkVaF6NbSw/n3NfZi40j09TqHMAbzEl2jmLNzSpGkMULTH6XkaqJN24/Qc/3gTqIjsAsPuUuK20U2dhVkp9uGltrODO/OAjslcdEM+UcxQGU0LeD80xh8d0nShaj8Q0es6S5X2elq0gX/TJIQSXFMNJO0AdrOloaTwKUZChMC3XVzEiqaPv7E6XCfOE1Kt6Ws2nNL3fr3dFHTmNi2TBem09KuWhoh0AU6yOCgT62fNJ5H+u+LYjyZi6jFOBa/UgFJWIo/xqg+EDCIp2sRHDKgrn6CeeZwHRE6yGWNw7hGGoVAY7Dx6lDiNS5SlZyQdjc5ylqlwe0UDc/Gob4tNCTtENHurAS+TgUZ4Ean21I60UY6FStd4xgi3F8k5o6WA6cnIcQwShIr7j1XlhBCbZld8pAonUmVsLHt2CbfgBsBKc/WtEQc4MkCqZ0yGOG3ldC17QujRN9XBg0Sr66A7bXI89qn9H5Moe3uc6Rdghv8hmdqffcEdvdN6IjelcIE5R3TYqew5DMl3RCsEjWOQZEYG+tkiyUxHHOD+4tPk6sDnJ8kLeKkidxzqT6s7yVQqRsNr5bfmIeKwOXx0vMUKRlXvyI0STGVXjCaBI6ZktpJokUt25QLjWikzkuBGztMEiBr2hEuPWqb5ggUVklZwFmqCqsT8R4xMF5dQRogoR0F2rWlqhY92savoU3HT0SOOhj5UelM4uzURZXWX2ydiuHJIicxRxzaqMMkGkP04ufa4hqqG2v9UTUojWdVH2rPohA5Xrl+Q9PDC21uhr/Kj94+gd8TKWflNwstqFk3hEbTjBoN0jvrfBDwj1WBpme9Us2SpuFWFXHDqeUfAloLk8onhcVaA//pb5zpCQPj1TdIo0v2XNLOPQYNUXyIphwTQWB3EbPwm5kNK1PYhlkM0G95Ftt+ORhnTSpiYTLENmCu/jD3twygqjvMAFJphiQJo+GrOIHTUXQhpr+phM0iMaN50PRCYUMMsqSKbS2V6mhjExr3ksQqhilOpqtNmQXjfEpfbZ2w5hcbTgrPjd1caRvTmmA2SuZ2k2zrpPxHIPEabLx69AMSspOR7EKs0oQqPHNTPVULNBaP+WGnflL8HLBII0IqhHEGW+ctJFhaP5KeYXUAbWsrPX3bZFjqzWo/xU3kXNqWMobGcmy82DApdHlQxntUY2jU9j2pbShKrhQ7K61v1dR0THxuHbD001HXr4YJgw1jp7STthv8eM1ghFQv3IQo7ZyldPyOjHZsTZXh42g7xpAqxCJ50nbuoXJp4TUVzqhBJSBtFztaTyHJB9tujF2KlelqgxSJX4hOVSrH5CsttFTVSNWD2m5bCsulqTFFXByORg2hucEiyaJ50fJo9Kl00hNpsEFk7Hga8S02OsJco9Wpj8uOGSHPWrrkSqBafAGS1BWr9Lg+r0l0Y/JKGY/W9oxBERiznTOMIzZBGVSNfSDF4BBPJgmqvTYLO0ZtUgocd64MwP1zzfjd24aQo8khurjwJqaQo5+ZdKNhsH2gO1UxjcBkT7/T9EKMuQSNIaYLUpsJMTauthumYShza2G28HuuD0kLHk1DYw4tUjTaP7i82tZ9DEMnMWihzRsXrpY2Z6eDn6FDIo1wIbUWkTz5OVRjVPCGU8yTYxal9lAWc27uU8vU5TqTMvdym+pR289OZxQDsmBychJ6YeEcfCoB5zv+O4Ef2tr7VJRxfd6IBmuazWm2+U5MUymz+J4+i/nNpCeWU4o39b1Rb6GyBGCq7/nQpyLjtqQrJq/qHcmTxgn2ixw0oO84P6mf0nehMSflbRkPOD9LmbpCzBgfMHPqJUS3uV+iubA2HxrzoemYYQkfWE81TB4F86wr1/E+MNh4ZULfOmIJUbpxerojFNbgM2uc7QpCsKgBU1WFqn1Rpt1jzrpPTWvUdkMaJPsYzaZGSsdavq7HycjaPKLPqn1fCWdJi3tPxxXXvjhMWz9cWKoZor9TxM4jQnipHBbpbW5MdGRPTNMcbLwGJKspo21owEaBGodKsPjMYuzU+oBqx2E9jm1U51hVPtTepYwHBximTixpTFdq3aUygylpSfY8fUzIFrsrHI777hcQzi4rVq0n0SMxdJL9FEdPCDnrW2Nm8KfllKRFldvF+Ku9E1SXtTkqYNtqgU8vtt9kR8wpRSW8VA5czlramr8tBRNd9m/FfGMcNoWDjVdHYCfOHE7tFMQO/EZYgQnTFgfuPTWS5exKJEQvPgE7jnKBoP59egBWMmFayt+MXQuN6xFTd6H3SYuLYLTMlk9hvkN9QWSclX5A60ljtHAculDSskhMpZamRC9XLp9XTHvk7Acp+QEozWYGqCf/gVL7SLAwg20g0mOch9Q2j5nLFKlWMB9D2rVDBhFS0KJLBkhwa9GnQEDDwHh1hPJOK6vxpXEy4eLVFgiDp1/MGKlAtEoLFLeA+bh4ceF2nFK5uIVRK79loGO6ckzYWWDcJUq7dWv4NmnFSDpDjJGFBolRo0wRF5+Tqoj9UwHXz5MkrYG+zDGwUnhpDIXKYQW3oEtMSUPa0QUskndBkoHr1YPOkVZpYhJ9hB5Km5eyNegKxG/8TjFNEHzusfkENAUcA86WxXL4a0GgPlv2M+tmoU8MjFdunLR8fBzraRgmHmV4xDSx2N1yeWsiuAtUKWoLSeRJnBoCu5lGuQx5VZOOQgenKopmtPACIjj0y8kEtpGE5VAJWFVIHFPPhdPQFfMsScq4Z9byUrqtDGwKLNLj2mcIMd7Xtd/ac+1Eo2cOEJMgMfsSU54EhfnTUOU7RW+DDq6eYuZHOm/EqgBxGHxSlKGLmyfZudPSR+bxmpZkuzUCtq1puJR1uwUG4/oZZlxvReei3szoa9eSVC/UiJca7KLf3I48F21dtCmXJn4Wm6clvJY+9zvE4OMwtB9ZVJialI9Kda3tK6XLpcWBkybH5G0JZ4UkZWrb30N5WutYmjtY2mIOHHUJz3BIjIfgvDVLnkqaanui8GXdI0fepvza1IeCxkafiT9ckj0TkWh8mD1vl0FlENoVS2Ul8cRFhbEt8/T6v0ZcbUet+MZqSBi0u900H2b0ChDqoBT9jtltU/pyqpeskCQIbdPTbLIkhkijh5MWcaoeLQ+ubSxllaQpuI9x5eEktJwKiJOmSepHK71aHWParNLORv16f1dgcjE/8/xnvIORqz+O7hq0uyENzzTE2k7VPqX3ORlFw32IZZ1J/r+o426JYfSIobnFnbc1eiWahrsaZyACxtSdqktiRb0a8G7BMiHgy1VJPIvzPmmBYCdL7TemH6dN7fCM94tV9JCTXa1UYIKIPJXJCalD8cIqqmgD6XN5WONSBiUkZQoxYprqTpN64PhaPtw7Lg7HsGjtqNWjVA8Sw5oTtF44UDrEsMz8V8YlmywzhBOVoXbgwL5nDpQ0vOwnbEAs80M0vS1tvUzPKQ1TjrLpphUQHLcJds5tDwJpdaTdQNAlBhuvMUXUoO5Limb194XDKgwaHry1QcJMcOykxE3cmo2BcSerPff0cN/p7yDDiOnF5Y61tRFo1JgtyrBQ6SJlpCijRpmJEHNBacPPQ7+t0gZKL2XcOZppeiFJkJQfTZOT0NI6pZIYTrJFoZXBCo6p0+o4JGFmma7A+KcSkTZMDMdgWxhHUXLGzEGSJCwJgoS+0ebMPNBg9mNtt6Tyac8J2P6ptTOlYYGQdwjEni+URpl3wL6QPQTXAwYbr75svFKMBFsMdDoBaWG4cNUuz7BjECUKCXp5defcAlV5AmUBZMlfMpo31EOndRCZble05KBBkghRVRzHVFmkDzidGCkcTt8qEQ3VMy2DRIulzGxaiiNRjbbauwi1F9cOHF3j0P9Giha2Tcl5Sb/HBQvy09W3jfbAePXUcKGJ2zrJ0AVF+y69l+iJzXOkaMnEdF2O0AJvXswy0JG7nJaFf9Sw9H2NmeGYKqkf4fehcWYdS1J9RjFBOSU02Gg6Yo7KES4rtHoZV0YjBKMRvFjfIyz3hOGmgUY4qSxCPYjxUPjBc/0MhaY2MInFmXRC3zWVhLRwhhacriQxVnVSBeNEIdmSWRaPGgwieLoIa3mkvosFJ3mx1H0ozVA/we9j028LTtqFEWK6aFj/R1WZNG3M0HESpxDTxakhOXpM7RIhYaZlaZSNqgQDY0Erl//doDfCxkmaK7j2KCV5QlkaZQ+o2ti8ra4yugTj9qHsP9S1j2IUj+NX5RQOOlGo4yKmr8x74gfb7wU3RbV1K8anI8pvFBhsvBZ1EKNIblEVJ0PtpJ8RfgGKWmTIBMHSJ6k9Aqcca/UReQIHL7opzAaOa2X8rPmEGAuNHi4f2k80xr4LiRs30UtSIkmdRTcoXHk4ZggzTfhTYuLo2OLGVxtmhOYVw5xQGnFZREwxKDF9L7RJlOYBWhcxc4U3LWjMadimKuKADZu3dLAnFwPWJp1Y2jCDjc0ywBZOsYXC79j6zFEX83iGmRMyNMZxKP8RMMuDqjETUkWVMeJ2vKMeF5WOBdKCJk2yMeqVmDBt4ku05co/Jr8ctMSG0cJbFvMY4H6O05EYPRpeC6OlT99pYy2F4dXyldJvO0Zi+zVnCxlqe7aeiNrH2pe0PENp0GfmPDVVqkENFzv2qzoP+blKgKW9zRJfUi8+fN+Y6MHmdVA1zhC0lURoYS1xtPxDu2gq/ZF2z9YrOMw7VDrh4eeBI9CiryDjbkbaMVlO19BduUQHradQnVmlVBrDoaVvnuwCfpM8PfiPoysGkuSISqK4PLD0ie6M/Xual1SHXFm4RYiWnWs/S5pceKkOQmG151KY8js6cRxa9MQ5iTthFkuTMnZp++J0pfYRgSU7TDnwXCjSGoGqDTkXNW0wRX9oXqGSQzzOayAq5mqO7ViaN8FIOdW4AXpwP5E2b31jkHhlQoNjVnZKdCeGwe3KpQnFshtP7lwC/cHdR4YTjJJ0wiLhCUkKuHcWo8ycSEk7VaJhTTNmp2xph+kGTtIF4BYyqxSKvgv1a00CF4VEY+kqL0FaFSOxU2mR6EPG1eb0tfzIjRFR6VnqkErKGAmWaS5Laa8cBvFMfXcyho1roQVByaWHkh+AntgfTjUuAoyXRcxtEaWzaQEyiK9jVQOWdFRkPlmjTW4WJgPQtXg75X1KXo3ykAm39q5DujSmmJPgRS/yCqMj5cXFpflpzBOlk0LL35KfBaNmeHvNv4N5AtAl/X3koakG1U0TYVSlU4W9YoF9TZTixWJgvKYpUhquqw7OLWTjLImwSFOmC8ZFlD3OiGnvlA1AavrSe42Bsqp1QmlbGDIL3dYyh9IPIUr6FZB4VPFz+/sLSO01ht+ElhK6oORrDN1bhKS7sXXXheYlZR0ZbLwWIZglQS3T7UR0bKXLoIv3k26bRYDLl3sOz+hz/Nu/p+G4ZxygDP5PpM2IWtwMJ0iDeSjv/HdrPUjp0UUfp8sB94kQA8Olzz3H8TSVtE+jsTgytjLcH0uz4IWcOy6vjYea9JJ7TkFdDbS4jioasScFDdD6QvXHXAVD+xvX3uJ7wQZKLEOMKwWOwRCuRkpxYdEYtz6ONq8wNqxcWRvqO8u8N6+pkrWEw3RI9FdMvBUQ9qTlXZ8YbLwyITvHnGh3FLsT6F3KlHEX14p2zo6Feurv4ERTCsZREhizy++Cfk3NRyUxHK2ami+FVmkBD9EeK43x8TSm0TrGg22YMFa7auu+x1hKnmqbEPcMVJUmfY4CkiSWCyOGG4W0bkHYlkySoA+qxmmKnA2XKrrurCPHDiLG1sC68OF3dPfZeuHscDLoc+KxMNASY8L9pvFz97/QIhJS+Vj6CoVV4sgxZiGmJ0SntoBKdU/piWWeONqsajSu7TVa+oaV9pmKXGUMSXhD/T80z8bQOZHBbjhHvfg0BlXjgLxqAE2kLIX1ndKL6hkmyoeX1Dz+vaTW4J5Li0jD43IgXY7GMm2NEWqptmvky0grcflqon+L6gC1Iydml+oXf6dMRq2OyXerJIv7ThFKS6Mdv9cYdPqnvad5cHVD20vqp/43x+hKUhRMHw5DPzkmCOdF04upU0ozjSfV+SjAtSl+R59z7aP9zgV2DswAUxsY5i+pnzTGm6D2lvqMdXMVosVah7hvNtqdWZO49Brl6FnVOHiuHyW0wWJkBIID3TMAFumL4nun9hudnuQWsmgGh/GeT+mqPYuRJE3FHfUCwjETmj8fliEDtJSicXXBMYTWtLjvKeCYCi4vOvlrUiArUyI9l5gQjdnHzBD3XCoXx1hpDCTN18oo07Q45j+W6e7T87fWdlXZmKtxROYr1hZIeRY9z6C4uO3VuhX8B1oR3CwJJi5q+ST7XG6zSJ5LG2orGmNAWpOUeCV2m3R9YmC8MmP55QNG5QZfI8F3WgdKMLw0wUo3DmtlEjg/P1o5YqR3xNmpGJe7TiMUJ3UCVMpSW1RxvXB1abA/83loEy5egFOkXTnAMStSnpxESmNY6KLGMZfWHTlHN6bfmh5XVo1h49KMhUSj72sx6cduhGIkUtZ3Ik2GDWSwfa2bHskfmQXEcWuj/QWDe/ZOw8j1QpJQgZYjeixIeXObflymeUzZLIhc00a96WZRDMiCyclJaN7ys8R8oWql50V96I0dFLo5jGUZYsqqlTdUF/S9oe56qy9PS0R7Tre2tNCLw9Dw3Dv66b/TP+05jSelL8WJKV/XYGmY6lNc+VrB2ldjxl3kfBaVryV9P8fgcIZ0pPosn+P0LGUPzXNGmkR6IsK3bjetLIYyNtbvjjGcauzLgeoY+mRRMd3oHRNINhAx8UPqs74h2TrRMFZJWYxEje7QOVsqUYrD5Kvlz9lkeeC4khSKUyVKtGhxQuXR2kOyK+PeUVTvkcf31nNFjPTbcJiHtj/Xpo1yhuiLkbQoHvej0xshuD6cNLYtdRJBE0Ca/4J9t8Xdl8OpxmmKvhuuC1gXxXFDMlMS4c2ey88jywIVCBuzgFqg2VDh31LcUP4hBieUR6geavY8yNt2bD2FwocWAwyJGQzlz4W3MBhaeWL7iFT2Nu2cAjNzqDDnXdO4qIOtT4Mrh1FgwthHhlONMxWMvVBuO5m2YAeTweBasrVJBZuGYmdVCrYZg9pQHvQSWC6/MhxjhwX5NfIN2R4QBkKqJ0wbtzCnTGIck4D/6HMNeBKTyqClEcqjlq5yBQq1SZHsiCQbr5Ddkc9HkmRxdIfS49Ln0pHaWxprtJ9Qmjn6cT3QPCSpHi2HhTGLmQ9i+jbXd2PTHLc5OAajop2da9HF6o3wmZiuidDBAya89nuUGIzr+4LvmGihME8IRmYthelR4wiemfFkz0383CQuLUTWBY16oa7iM8+jvEZjw3PmAIFoeExUIpSRC0FjPvDElmPSootoLBMhvZP6RSidmAmRMly4v4UYOEnyw9GNn1k2Ehwji9PWmCWOTu23xOjgfNSNg9CPQrTSPKW20BDFZBvAtRFOS/vNPU8dX6E2lcKkMAPq5kaZ58xzq3JQhfsduomgKwanIG3P3UxAw9MxMi6Sz4Hx6upUo7JQBRsfpDh4V6FJZhBSOpYaRzjVV3VkL/WhadAj1lPh8LvGc4UmjsZGvpYTMswkVbNlkfyVSfVubJdoZPTsb1nYOYT6GZeX1JYSk2L5TVUEmpSOTrI+DkcbrRtO+kPTDfULiSGRxhjHTHJMgcRcYZq5jUGb+YBjxrpaxFLS4eYbaz+nc5GVuZbSDuajtGHMWGTpEeYsaTxyaYfmW2tbhzYBFBNWrQZDL83HuuGm+Y9KCjYwXpkxOZlhYqGuDTRXCgZxa3Lnosd+ubvKAq4WavFpWvTwgQZB6hda1ENuMKQFMck9RcDxad+I7XehfmLZ2Ut0dKlykuiQmHX6Hf8WFw9B2oSZOws9HDOF04kpt8SI5gJlRMe2j9J5JNKdA7sBbHF3bCcI0MMydNJ8ROevjL7M2GdC+xRUZWk9gMHkJ27AFXQ1boyZD8iB2nHUXMeYLcd9Q/Fz0KGlkfNYNk1b+22N2xV9UtoRx527Gn1+SlmUQcvfZFPqz63ppOYf856jqQsaTUgZP1aXJbFjvOVYbtSTZfzGuF9B7jRSaGo9bnO6beDCtF1PuLqcn7nzpvQ9cCdxlPvX+t0DRj49/+1vfyv22GOPYsUVVyyWXHLJYrPNNisuuuii6v3jjz9eHHLIIcXqq69evt9hhx2K66+/vpbGHXfcUcybN6940pOeVCy//PLFm9/85uLee++thbn88suL7bffvpgzZ07x5Cc/ufjMZz7ToOWkk04qNtpoozIM0PGjH/3IXA6THxDDRBM78KwLiDVMKB8t/1Q/Ua3pmQ+DhqGBhI+dEK3huXCUHpqepd1GzTz1mX9K21AGir7n0pYYMu19LE0xSM0vNuzIMNX38W/2e8s82mJa1KWh/NJc5MOJ5TRuotV6SvF/ON/J40ijNwXKetu3H6+Rdrc777yzeMpTnlK86U1vKi644ILihhtuKM4666zij3/8YxXm8MMPL5mp0047rWSe/uM//qNYb731igcffLAK87KXvazYfPPNi/PPP7/41a9+VWywwQbFG97whuo9VOZqq61WMnhXXXVVcfzxxxdLLbVU8c1vfrMK85vf/KZYfPHFi89+9rPF1VdfXXzkIx8pllhiieLKK680lUVtOMNkozENXcLSsVM6f1dMYB8TZK48NOagBjTBjHoBGEdpGSetooyrVZKVylBr6Wl5hJjAUbZ76vjTNhHjRGNIwtxVnQf7SYwD0y4dzSZoEbLMD/Pbb85zS4AXKcbroIMOKqVQEkDaBZKuz33uc9Wzu+++u5RIAfMEACYJKgxLyc4888xiYmKi+Pvf/17+/trXvlassMIKxcKFC2t5g3TLY7fddit22WWXWv7bbLNN8fa3vz254cSdtLJDkSYNFYEBbJ5wqKg818BIEMFLaYjvpXBC3fSy0NF29gxWhl2/RdKjxQv+lhatxLbsc5MgMgJCmbh6s9alxgRq9Gh5aoyaREcuaPRK+bbNP0d8ru7GAVYGwcrUq+jgRg0rxrHuYxjJvhmvkRrX/+AHP3BbbbWVe93rXudWXXVVt8UWW7ijjjqqen/jjTe6W265xe24447VM3BSus0227jzzjuv/A2fc+fOLdPxgPCLLbaYu+CCC6owL3jBC9zs2bOrMDvttJO77rrr3F133VWFwfn4MD4fM9At59Ck3HftNJzvCrEXQYeO+DZ+Cyf8asa0wv1tFlcQXHkpHSFIJzulU0y1cNhjtjUujmeFFh4dPvBt2mhbYzsHDxFoxqLIZQbbF7jfzMXd+DmXT+whjtjwWv+RTt75d5y7D3hPjcclVxkSPTQ//J2m7Z9xJyo5uqgLAo5O+rwCMp4uwxr7NVd/mCYaVsw/Ari8KQeBKOsVSod9H3kajvsu0VYLK4xFri/UnlnoC80l3MnvTId+LONFw0TCqcRY2qt2RzcklHTDOoPW7T4wUsbrhhtucF//+tfdhhtu6M466yz3zne+0733ve91xx13XPkemC7AaqutVosHv/07+ASmDWPWrFluxRVXrIXh0sB5SGH8e4qFCxeW3m7xX6+3nLcZMIKXYe50j7bAS4uv5XRc8ISc5uXdwqxoJzEt8awIXG2ipSf50OHSkSY1y2QXdf2Lkcmzxk1FqI9IzApHB6Xf4j6AawfVtxHj50pj6LRxpbnOoGUS6xudSDZv5NCJt1q6aPPQpY8mtqyGeY49Pao4VGbziTwNx3230FW1hyFtGk9F7OlEj9BVT/R7iHlNXJcK314xJ90p4yjlj10YcXU5giueRsp4Pf74427LLbd0n/70p0tp19ve9ja37777um984xtu3HHYYYeV0jf/t/baa4cjCR3YGlby36ItJOyCITie426mt4Du4kNe5EN+v8RBxSHCW3wQsc4ISXhc36oUQnEAamF8YxGzOLDhDUfrU90haO80ZlNiAjTJniZpoBITLk38mzI+nHQLP7cuttQ9Bf40tZVAswleOkyZA6O/OkprqB7NNCl5iTSNwX2JraTqVgYmhdmxSs+UtNl53sLEaflRSL4YNVdF1nTo874EJuPAeK2xxhpuk002qT17+tOf7v7617+W31dfffXy89Zbb62Fgd/+HXzedttttfePPvqou/POO2thuDRwHlIY/57i4IMPLu9l9H833XTTEy8UkWWD4eEWtJhLZY07aLoghBa0GNCFhVPpBBEjwTL45qrB4PdMlE4hdU1VL0LeVEpRS5cJH9w1U6lDLIzxTVIMQeVM00lBUPJJnomqGNJ/8eJPJVESY4zf0bBWKYdEq1QuSZ3IfUYxtaErtKRxoDi7DPaBqTylOakxhqxMA/GFV7VfwEdeSJqsxU2S3Fh9+lniW+c1xCybITFVnHZAS5ubL0OMT1vV5rzIso4rihECTh5S4/r3v//9xbbbblszrj/iiCOq92D8xhnXX3zxxVUYOBnJGdc//PDDVZiDDz64YVz/8pe/vEYL0NHGuD4ZGU+70BaOavHQ6RPJaN3qNoMYn3vauO+xPZXGY+mi9IwThFNEXHty73OVh6ZtaQuuHa15cXHatL9EW2ze0jspr1Ac7Vlqn5dosdBrTSumTrV0Y6HRYU5POZknjZtQXVrzt7SLBTnqmp0bE8drX3BKOXJgkTrVeOGFFxazZs0qPvWpTxV/+MMfivnz5xdLL7108d3vfrfmTmLu3LnF6aefXlxxxRXFrrvuyrqT2GKLLUqXFL/+9a+LDTfcsOZOAk5CgjuJPffcs3QnccIJJ5T5UHcSQAsweddcc01x6KGH5nMngUF8k7CTLGW8ND8t0imzkA8U5FuqCpdyKibkHiOUVosTh9EDr+NTPZSmUP2bnrWkycIkhRbT6LJlBMdYdjEJcwxWqLw0TgrDNAqGP4WJSWJ0OkZt3mo7D2Wkp/YZoCt6jugZ0fOr0UmqG2XRGBoXKcYL8MMf/rB0VgpSrI033rj41re+VXvvHagC4wRhwIHqdddd13CgCozWsssuWyy33HLFPvvsozpQXWuttUqGjnOg+rSnPa2YPXt2semmm+Z3oJq502nphJipLmjIuQPJhp4mrz4n+D76TtdtGZIsxUiMcHyalhQGpxWKK9EU2kBJUgWuLBLDlwpLfAuT1Sb9ZP9SJB+RSenTSTOH3H6oOixPY2M/9Vnrt8rG1LTZ6coLfReaIhKub8ZrAv6NWt05EwCnGsHIHuy9lltuuZq+WzS2FqCFj02rLwSNXduC2A90np+Qb26ETi1WNAA6psPa5zjjci6upa+27c/SCczQyUyLzVroZCSXp4+nPePih8ohheHqP6VOG3Ey9HuJ9pT2pocOLP3PUpZW/Q/sKCNPDKv0MM9r9mzW9kDuEqLjWBEIP5J1akH6PNlYvzvGcEl2V7CcBFJOjKjvBJiMSSPooGlr8HQFjXql9GJOJ3r/K1N/FgP65DozDOJgPSuG7lUZtPThUMaUgXvIYDtEi3TaLIbRx781+i0Tb9vJudYPDO+osT0N5/84RokyDxwjxZ1ulE4jUuaMPuPyoeG4slvrtFYe6YQaMcL2Bvih05b0UILWThaw5UXzQAXOaFzzcWicr1gEXENo8Si4Q0llHc6fqusAk8Ol40+ps3MtbVOJJgtzo11anQsLjCcjGTdCVTm4ww+Z/JjFYpB4ZUKnHHPL3WfbXV2tM+faQUm7sojdWnS5OpZe9Q1JmtJrnoIkEoexSIBy0obpkCAxRDHvcZ6SNIqT9oQkhlx9SeWU0Eef0KR5XeQdSjdJswCMF3M6OVaawqW1SEKbYzNL1Ry3dgAS1qhB4jVTkNsDeoIfHFYM3+aYdKxzOy09ZndXi2cYPNGT+zSfFCV1VKrqJgWNPBlv8Bpd9F0MHSHpJMfk0PywRIt7ztFIpWFSeThpFK0HTiLGMW64rFKZLYxhTnD00LwkRjEHQmUS8zXMrT682C8tt4O0nV8Cjkqleqw9j5XkpIaLWUdiXPrEMFDchl1S4XK/E9fVHBgkXpmQnWMeN+kMlXwBxom+lmB3umPWBrEqwVCcUF7aYqap0CySCS5tC02WOJIUCdOYi6bUNKRFPofkaCT2NeMIiy1VbinMKGGlrQ8bsOmABYPEa9FAzC6hg04u2WP4dw3EeghW0lV3FSPSs2OwC1Umx38huywrWMZQehd4HqJBs8eRpDzBxX7KNkgKq/VNi+0apY/SzOXr027DnHKSOE5SIYXjaGvDPOVkusZt3Fr6AnVY3YhD5zIKo4QsBSUdIYlPKkJaBs32Db/nyp9Q7uCa0gNYSRpn19bzXY2DxKsPidcM2y3klq60tZdItcvQ0jJJL4ztGisJsYY1IdPpNIukTaM9yf6mhT1PjC2ZZIvmIdlwUTqsfUdaZEP2YBxdUrq5xictS0waYj3kmg8T0pHataJxKs1GW3J3CeZECy1CjnbNnb7pNOh8+VRo31Lbvm28BsZrDBouRYXUJs22TMQo1BgxdRS7OKTEjV3QAW1oEuMb1CYxtLZ5T2lsqxq0Mi4SY6KlqalMJSaMa0vKtNGwWlpc+UN5cfRZ6qwNasxHYv+y5JHC3IXoCD3rYz7rai7ODumgU8RmucZI9VWOBe3zGYzrZxgsImRtUFrUN0nxKAwnCC3p1sT6xrvJkutoKj591+aIuLXeLOGoSq4GpW4a5dHUeIraJEaNVoZB6gaNgaHpYxpDUhcpb67MofBSPPyclkP7zZUB00IXbKxCxG3NPQvVE40fqheuflKZlRAqOoQ5IsiQG9RLeMxmYYSEuYE+62MTGbPhaqjA+gTNN4IO3z9q464v4/V5CfU1YvOWwY9XV1AGPhcuGRkHKR4g6sLrF2jBf0sV1ngqJXnyUy5vtQ52Me8peyQxHcUewpR3j5Mrx2zUnmE1R0SbaIyBVgcxEzGl1f/GTA8NhxnOED0cA8fFo8wRx/xRRlSii77naJJozY1czJpWv6a+nnk8ePsu0daUju8e/DqpeXmfZMCACu9b08f5tuoItfE0v/t8J7TNPjdHYx9n8L5nG6+B8eoJjQ4n6PRjO2aMdEllJIidgzoh+wWacVbXKaR8ppjAxsIWIVHjUBOZByZ2ztCdW3Cr+Mo7Lgz3jqbBpaVJhURkaE+rFFeim2N4NCZFkhpZwps3HAI4WnF8TULXB7TyhcLj3yzTSJypsqAbNfzJMRdcfI5Gko4myaLSRz9+G7ZbqXOaYQOmbkg5Nzq5N2cWp95tINUZl++CxA2rALFuBTVkbTzC+90mXZ8YbLwyQdMRU3UPVVnETvKS2ofmEUrTqj6Mgmd2pownS6TajnGDZga6sujKFsLXaQozkZuGNvEBsWngsnPSqxx5aHlKkPLOkX/n7TVlFD0utLZyl4DCmK79yWRLSeNzcRqbx9xzQ4o7ib7Wjx7A0T3YeM1AVJMxo36M3Qlb1RCWNLG9Cae6wbtZM0DN5yeyKamY1Y6ES4t9hidAbWeaKLnp3CYh4MQxJJn04Wh4icFqJXFpKf2yMP6h+NJGg/sL5cNJI7k8LGnRdDT6pXJIUjpLH5Dos0hTJZql9sJSolD+pjCWfqWEUfPx12sp6sbqHb72R5vvFAbFoj6W4kl9gt2ESgioIRtaEaOT6tq4wtoDRbofNV8syDR/B8JZtAB9Y5B4ZULfHLMFdMGJlj50eSpFkmb1LMnS6iTLji7DrhJLUSTJaS60lTCF0gnu8COkujiuRxf1Iy2sIWliSMLGxekTYp8a86tvGu06LqcA+46fO33hVGOtvsfUNdKEcIWZChR2kHjNYFh30bHvJdCddrT0IecVGHRXptk59IiQPVCIKZNQvW9ZJonp4n7H7hQtZWAloRydU2rlUJqaKi7E9IXUeFz4WOD0ffk5yTAntabxcTycpnUcpkq9aDrSe46+SlIdkU+sVK0tKKNokcSZYbEz0+awGImPV/e1qWctvtWLvW8n4VRjxdAEaG7TXx2p35DGheaVpJYd4ZVBg3F9X1AM1mPtQjQkdaKAMT2nyuFUXbX86SAYw11SAxbVquW0Kq1P7mBDxATdYABDKgVjXYtqjikmqsG0ByZ5zFRI6juO8bCoQTXmkzI+Uj8Npe3Ts6gNOamXpGqSpH5cmSWGLhYWMwNJ4hWbT2jz0gUoU+yfheK0OSkdDBN6l3DCsGqj+cIcLdnARpoIsGnjNAJua3waye09r56+3wBoa2bjXeIaMwqJczTjdeyxx7LPH330UXfwwQfnoGlmgC7igU6Rq/GlSTRkE6GmOTXo6aLgP2sLdMigXjs11NKeyMo0cc/9jq8mUucQezR+igFtSBe8YW/KLjHCqSGXdoiRFneC1E8PSVP7DQgtkpSB5xgijpGikiga1j/nyu8Xby5djSHR6MHvuLw0WiS0kiZEMt44T0oDR1ef0Bb5nBvYzoHsrEyMq/WGjByn5JF0S9xYExrxhru1BHRBQqdCkrvUDe5YM17vfe973ete9zp31113Vc+uu+46t80227jjjz8+N33TF8yAyjlJhRYuAMcoxaRXIUF8awG3sLeBRSpTA5pgcu2ePCiDVaMR5WHaJdIyCWWUpEFcOI2RltID1KQkhA4trtY3Q/Rq6XMSNIlmHD60kaDxuEWdk7ZxGxL8jDKWUr4hqRkuD10ULUyaFkaTLtK8rNKmXLBI8iikTcZMQ81xNOePj5s3yEbYS5pizVVMaw2nWVmg0CSkIc6z3BwiqEZrDKZzbvnlx5zxuvTSS93f/vY394xnPMOdffbZ7sgjj3Rbbrml23jjjd3ll1/eDZUzBEmTlNBpUhYuC20acu3IuZ2ZNZ9Q3lH2HhnUnxKtdPBz9SNKnGgetEwG24QUiVQs8CXEXNr4s5UaQsqfMEbaoqDt2rU2lBYUTlLFMU70XcxmTGJWpXL7clrqOlRfXP40DxxGi8OVqwSS+FIpRe0Z44+vIdVQNlwa08rmGTptFzF2W4HUT4hR7s2cQzttiucqGi6DXe8EmQu1fq7VC2UwJ/t14wUExOOxxx4r3vOe9xSLLbZYscQSSxQLFiwoFnVMTk5CK5afJeY7/ZOCPpfCFf/ag2hp4L2KlEYIOIyWVhSUcpneI4TKiNMLhSvfReSN07bQx+WdrU6N6DOvWJjah/mO43L1bf0eQ2dMnlr6oedS/5GeafG18ohpk/mkM2jjCN6hMSy9q6UTMZc20oiFIc/O6k6qF4aGnDDNWx3lHbWGIoTobazfHSOpdn7wgx8Uq6yySvG85z2v/Nxhhx2Kv//978WiDK7h2A6aMNDZNCIhpaExHNwCV8ufTIrREwyZNGMXwgY9Srhsk5+x7qUFrUtYFliODivDw6VnSSMVGnNk2VhIjBAX38KwScwz9z2mfBJt44xR0VjLU2K6yBiN6e9taePmWZUxit2Qt4XPM3UN4eLhMlrWkvkJQgUhrrThCIHSO/aM19ve9rZizpw5xRFHHFE8/vjjxc0331zsvPPOxYorrliceOKJxaIK33DOwacxUmgnpiC025XCanmZJghMmzAIG++63P1w6TODk500cux0pQU0pvzcZNJnnWntaH3eckFruxjGMAJWJjTEXNJ0NEbPQquUXtdIYvzabLgywUIjG6brsRXKIzF/bZNgSTemj3ZVZ9Gb6h4AeY0947XpppsWl112WeP5V7/61WKZZZYpFlVka7jQDigzxn1nnYSe6k7DuEstzPS1lM7GMkQ0nnUnnUuSx6VrCT/2GIMx0RkS50xrHwjmK/2ORWgD3DZtKzPYxaY5Vv3btRSQpNE34xXtuX7hwoVuzpw57Ds43bjRRhu5RRHU861kAO+fS6eWLKe0YhCbXu782wLXl1afXeQLGGVb9J2XdOowlFbotGJM/qH4uF24U4eUbgl4vNHnXNvTfGl+oXFNy6j1a64cobRDdWEBVx5L2Jh3fYzN0JwxXdFVneee62L6kZWOrtty7D3XA9P1pz/9yX3kIx9xb3jDG9xtt91WPj/zzDNLX16LOvyxVG4yxc+pUsEjd+eKTa8Mn8n3ScxJR5UehS52AWV8urCnBZUj5rRdWmHqlBTn3T1ElxSGA3fCLhQeA/dH6TQdrk9t89Cm3aUTY9oYkpguboxx+XDp0jytiznNU6Idf9JwEiMllYc+5xi1RptEuANR08nIfFvA9VFMA1e3HGg/zXIqUTkRaUlfGzu18tC2w64kIpEy11k2NbF0FQod2vi1nPwM0dw3ohmvX/ziF6UriQsuuMCdeuqp7r777iufgyuJQw891C3qkI6ljuPOS+yI0hHfyAtQy4EkDTzj5FT7rRw9lnzYaIwbjtN5+6DLvUMLHKW1UYeKHy+O4aeLi//TyizRVWNOGA/3Eh0x4OqHYzg0CR1+hstLF22NMQuNFcr0S3Uq0cylTxk2LU4IHHM2XT19J5XP0H7sWGyz8Zwa5+zGxMCEmMcOd71PiO6Ei8lNTKAUn7v7MYUmwSN/Y27A3v2ZK54ajGuil/8siNVNPve5zy0+//nPl9+XXXbZ4k9/+lP5/YILLijWWmutYlGFqiNO0Un3aZweosGQv9ST8HP/3Q+VHIhKJ7dNRkxeGcGWWTm+jus7pr7athHNN1ebx+QrveNoC73DaUhpae+tdZCjrnLUdagOs9DT1gg90v1MkB7j6WATRjRv9zXOVEgHnIo8c5MEUxrMujZ5lOvVxita4nXllVe6V73qVY3nq666qrv99ttz8YMzCxGXqVY7DHo3lvFur66utQh5T7eIiL2kwbxjDl3xo0kTJI/I0v1joTxjkcvzPQO2/oi3aRq+JvkzgkpeLLRp+fYlKbFIjLDki5PWaRI8rky0bFQah8NxapGQ1IxTuarlM0pJNWhjGtKPUdOJbd/y3kNwqCmqmZBEg9YVboda2MAYEe9MjAEnaTE4bbWmG6QvRdJjlIRJbWeRVhcZ5gd2HAYcuY5CBRnNeM2dO9fdfPPNrEf7tdZayy3qABsvbqFqNK4wqVgmqFAHbWNjIy6yws31sYgaXIY7A2naVdkZZrF6bsizVZ0ar/ihE2CfdjKpjIxnDNraceVAiDnVGKuQLZykrsTvreWniz2mw7/nFp/Q4qQuWHTstLzfkwPuBzH91WrrZKGRyhM1b+dVGI7JMtwGIYXjmDccVkwDeWEvvxs2giJ9VK1HUKMX55s4jlvNTwsEJrcDlV+ZfqAdyjC7TY4347X77ru7gw46yN1yyy1uYmLCPf744+43v/mN+9CHPuT22msvt6gDbLwaEgdO99yhXrk2CbW8pZ5OVClg7R0ipCmxUho6maako6ZLEZpwQxeGZ6AvtGNuyyRhG6lYei0Gr5L0RGN2OKZIMrSV4kqMEc1blKwy6XMKRvqOGxOUbkoPR0sIGmPJ1Q9lCGkciZmJ6V8W+lWpU0h6Si55boQX7jGMYSDZcWDdjDKSKZEBoXOEZCcWsPGq5UVsW9tu8lRmUKNngZFRjc1Xg0BT33c1RruTePjhh91+++3njj32WPfYY4+5WbNmlZ/z5s0rny2++OJuUQR3HDV2J5gLKTtQU3iYnPbgpU00HZpmKA8al6JNPWp500XOKgHpHKSuufr09Gi0YQmVpsIKtSn3qYn3Y+O0hbXPUFq4PpdCW5syWscf11Ypc0zWeUmStCgSmBz5t0mjzVjw77W5LoWOUa0VQQQkadHhxgkL/kXz2LuTmD17tjvqqKNKlxJnnHGG++53v+uuvfZa953vfGeRZbok5JAIWOPg3TKVBHA7WywhwDsgKjGo5QMqvinbDvY9npzIzix0oodTB3Hv2HpQLtsNxcd5aTt3VZUhSEmCYKSfVXkIg8tJIn1bSLThviAxtWK5iASA+6Rxaf/DNGA6LVIYrm9pz6W0aZo0Dn6euvvnmLlQOpRBU8edghR6Q+Mpig6jNNeavxVt0pDihtqNzhVSetZ+S9NIkuC0hJSnn4fMpyV9e3codS+Ron2R4oyQUYyWeA2Ik3gBarsaz4BE2FzgNGhHt0iSaPyKjoBNgJguHpCa6wkjjUk0GPPKvpMkZbZKwmLCcVIiq0QqBqOWPEhpSdJPi3SAW9wkKRSXTkx9hqR+lAZJYmlJLwZc3m3T5PIYRXq1cJQxSFlIEyR2HE2AkGQ5ur4Mdlut2oBz9xCaswNzvqYRaYsJg8RXG2faOOhb4mVivD74wQ+aE/zCF77gFkVkb7gE0e3Yiqszlr+LRaTvhQPQCGtkVGPbWGMuLPHa1re2EOF0rQxzGyYeQ2J4uHfSgsqVgcK6CaDMJseA5u7z4zBfxPQvC4NjzTOaqVDS6KUeO1blRZeBSrms6kiPeYGNewoM6TWEDlNx7vnfCbf8vm68GK8Xv/jFtd+/+93vSi/1/nqg66+/vlQzPvvZz3Y/+9nP3KKIBuPFiV+76Gx9DjAhPYB1Ic+BGGYiholpIz3qErmZEBwfECMhpAyZR476CjEfUhwKKjGkDKRUBi4djj7pUyoLpTPEYGk0aHnEvk8Nm5JOTql3SKox9kwQF7+N1C6Wri7XoGlq63XPyyfHz8br3HPPrf5e8YpXuBe+8IXub3/7W8mAwd9NN91UMme77LJL5wRPSyCv5aPulNGTElGrVQuDvwbHaBcj7jATECPB0WzLaBz/O3nitrqRCIURfKTlZna4tguliesI/7WFpWwhRonSRz/xd7xYc38+v1qfF2jTGHscxhIvpl5zMV00Hldu/z2WWbXQGotaWqEbMiQs6C58qI6wOwd2jVDSUdPW1hZ86jnkTT4En5bkKzEHFoTpkuqH9ltT3z1p+fG28QJfXT/96U/dpptuWnt+1VVXuZe+9KXuH//4h1sU0beOeNrtNGLpI6q35MmbsztIqasO6xeLvzWVm1QPIdugHOpJazyJhtj8LKpBC8PTpyQk1A40rFWSR6VzMRLKGGRV4yfYeDbyZ8acRqMk1dTUtmaVoUEiFaOet7Z/r+rMALT5h7uyLSrN+YIUMMRM4vxSpYYg8XrA9apqXCyFwfjnP//ZeA7P7r333lx0TX+08AoscevSDryEcnQ79ExNl3HumYTYwUAcxoYWZi2dxoRlUJ1W9ZFBBSDW7RRK+jjfQoHTnmw6xufaLrDNBJ8SV5P8cO+5vkDLw8VJleJwkPJsJQEW3qsS3QhVoiYN8Glpdet/m0AdPlMv7T4t4kyzlj8z5mphyKlgrs/4vOnmRev3lK6KlgATwElXQ2Hxs0ZddHiXbKP8htOIbN2T+SvWUW/h0+TiWZxd0xteUuZpiNOzA9VoiRc4Sf3Vr37lPv/5z7utt966fAYXZh9wwAHu+c9/vjvuuOPcoohUidcodjJanlnpMUqJcteBxS4kNu/c9jLRZW4pcbPSBFB3/crpUTVuIjSJhERDLAMjSZdiJI00Pyp94eJ3iXGQkEzLcnQg2TaXwZJ3plOYIcZQlT6NkXZlItM8NJanGjEeeOCB0kv90Ucf7R555JHyGThRfctb3uI+97nPuWWWWcYtipAariHqthraZ+jcnJi9kX6bI8AZT162mmCVY9G5oIrEpbBGVYJ1sggxHqMEx7xoKrIu6QipobjnHhKzxcXn1Fk0LSkel6eVTm1ToaVNka3/jNFCnNIf+mSM1Tm5o7zaxOuCzolMm92ctI094+Vx//33l05UAU996lMXWYarTcOpOvOW0gnTZOJF/gzjFTs4uIWhE8lP4qJgYlq69EOjuMdIbf/sDKwRufLoklaOGaGLLO27Uv+QmEopXxyWPg8xcjQuR6PWl2MX9r7GH/sstGFqITFvVf4Mpw659s5Vz63TCtwq4BGdB1NHZqZ2QbyNl4V5tpZn2jBeA/iGc27SFUW7hsuh1kpl3sZJipKKlB1bH4yMVSyuLbLjBssCY2FcYqR5VoliqF7pd1oOmoeWr6SupGizoRr3vjDAjti2bNP2I+k3I5KCTtCyGukY+yuDQNJ1yCGHuO22285tsMEGbv3116/9LeqAS7LbHj+2MgpaWEsaEIaGk1QWUv5tw4TipV7Ayi6soUtbleeQRtvyxKje/LuQaiwaiS48NEYC0ygxVDgcV26pH1rypDTS/sPRTunh8qdtb6GJ9r1QuSntNF+aR0z7h/qsNS3TeExEzLjCYdvQwcaNHBehOqHPUub4NuGluL4OpfprVcfUQWrPmODoHVMV+KzYCG9961vdL37xC7fnnnu6NdZYw03kHokzDQaOmx1UgXixA7GNFI1j8jRphGWhscYT01C82lNUCxmoEefZaeLSaBs3hsFoSwevbnvigaRyC7V77O7Z0k8s7zWGVduEhKRTUljaHyVVofSM0hWqMwvtnNoxlKa2wIYkA5hpxt9zIpgeoouOo6oMjDmBuZ/69Il6zNReU3G5esTv2XIKZg1s2zLXlLHlTF1rUD54fnjiVCX6TcpE0Zhfe5Z6FQGpuzYXVQKTnhCtapw7d6770Y9+5J73vOd1R9VM81wfsG+IXYRSYckHwC3CXdM27ZB4Z+N0hcSc0ffW56nhrOE5JkUrA8+kxqVP42oMnkQfF7crpjgW0cyMFaFDRh4hGyAUVrXVRLatgD7m3k4PBKWcaEzwsxZM0/jcBezlTHNpLqbOXxk07qrGFVZYwa244ordUDOTIHUKwTeNhuRBIXhAF/OZP+VfhvMz05K2VmJr/1vymCz91jwstwVpRyoNYMX5jE+0WpgO6OTUbrHqKsoMSKo7Drn7EaVNKh+WVkkSWC6+9p6jFzNcUr1okiJJcuF9OGlSP45Bs/gGlCC+Q36ypLRr9bjHE9InM7QF1EujLH6ekC8ptT9NpZcqibSOV7UO6KYNMUFcn1bBMZ8CbVV/897zlbne2obBsW/1ibZg6jYUvw5pkA4/xLQJFoL07LkeRItR+M53vlO89rWvLe6///7YqDMak5OT0BPKzyyYH900NcS3bH4aspYlkEatvPNBPp6QtxYWp5mSRos68Mus9DylrWmcUBpt+lOWvqikbU1fCldnj+rh/Hf8nL7n6lJKJ0QbzY/mG5Nma0z12WA+pG83wgfGlSmcId9cMNdrzFi3lpO+azN/heK2qG8/J3NtbZmvC2vfCtCR3H9IvMmjXN71O4BoVeMWW2xRupGAaOuuu65bYoklau/h7sZFEX2IKkPqnnFydsqpRqy/YyQqFlhoHjeVqSZuD4nic5TXmoanow91eUgtF8pfCqPZTlnaAdMRSl8KZ7Ehw2lJeUiwqCotkOKN0/iR+mXbcdHGnMCqyh5FPbYdPzMB9/zvxHhfGfTKV77S7b///qUT1de+9rVu1113rf0NcLrI06pOYq7Y4NQPSWo8jo7QxalU3TD1TFOxYNWatnCV78n1GPSvjRrOooJp0MfUP/u+CzWmoEqKids2TDANckG6Kb2WdUXz476H4uI+h/suXRjxQhOz2HDpc8wWbVdKX63vk3BS+bh08XuqKg7F0fKJgTV9NRzpO2xY4eogSR2tqfljVPKWcLjetD4l1u/UXMvlF2s+QNOl9JjV0dimjvR7+j6ULiC5DJFg8+n5yqCuhdWLDJJUjSDu9H/cOymOJV0BnLokq8jepzVVLrWHdaHKtOQboINTH1kRo2ZqXTeGdjblFaEestRLX7MK105c/Wt0aWlY86d50rZnx5xCEzcntK3TNuMhNp8yL2UMZu0f0vwZQadGE227Wt8geVvm1OxjI6faUliPkmnOPL87WveBPMWxxXwfe1XjgICq8Si45bwwXS2T5f4rQ7xU9WArujpERafglZ6Gy6YeSTg9JKqXAt6jc4zKSpIY8P5c5ZXgnZvbKbdR52hpxfRjipCUGEt/Uuve0t9CKrBY1ZhGRypGogrLPc+M4d2CwbrLcA9jb+iSpgXk5H/bvAzxx/JUI5xivP3222unGqW/RR67ged64+JFb1afAhWNYzGzpiLU1AwWNBgDSiOBJO6PESmL5WLSbdCJfeQQ1R+1keFUXZV6U1Ml4u9TTJ5vE/+OKw9VwTXaQDjFxIZ1aaoFSz+sMTZw0iliguOYIqraCcXjgNOi8bi0aX3QuFx+VJWH1YISTZKKh2vzkOrGl4XmGaKbo4vmocWr0cyoy7m659RyrLoOvQ/l3YibcOcrq/Yi81YZZmrcWum05NlGLcb1oxKMH7XaCcRQfAsCJ73NaUkMopYvWs9UoNOptU/DCXV2bdH6VkemIiGYJF7HHXec23333d2cOXPK7xr23ntvt6hfGeTccq13nLmkBtquOzY9MzRJlFFCR2lsSGYSdkCSBIhKKqq8AxK1Bl2B320lGCHJnhlC/QXTR/UBCJWbhmkLTmIkSZm0BUQLI0msYphJ2o+k35zki6bFpYefh+JK4NLMNe/EQut3mL6UNLWxI7XDdEDMfJirbF3W0UTP9U/zG+5qnAGqxuXeGuCwQxx4YLFPguKZuu2AbzwDeBGx/56Sfo4BOY5i+p7BLdCAviY6K/MZ29ah8NJiqzFUoXca08kx8DiepGKUGP82THvbcRNi6jRac+QfS2Pqu2ybGRLXo7M6iDV7sJi+SHHR3O4d01o2X23pDkEbb1o4Thhwz8snh0uypyPacMx9cfttdrSWRawPxEqfAKPYyYby1t5r5RhlmTRYJE5d9J9QPXL5W5gEjVnVmDfLcynPULlimUS8UNJ8NWZPykOkL3IxtUhrUupHeh/D+GtppvaPzkEYolQJISA074TCJJd7QcCeqwtbZpTmWNp4DegWbGfpQPds6ZRSGOzugXUt0SFgoFgmxdCEGsojCgF7A6AlRGtDSojeYbp8WE0Vhf+s9FdhGbs4nDbNg+bL0eRpxn8UXDk4cOXC+Ur1QfPxzyWGRWOUaBvg+tDKx8Xz77Ryhcofqm/OgzsuO/3E76U6xbTUvIsnMl1lmkJcjgmkdp4asy0xWtWCS8JraUp50Hg1dz/a7RrKd6k/hMa1z1NjxoP1ied4Uh++vaV+V9EQgQk8p1B7LhqW2LlxoPSL4RL6bW4MjNeo/HhZDQwzQlo0TSAHAdS4mZlGunhRsM+9fxp6/YTRj1ctTS4Oc+2FNtGpjBE2HlXosizwISYE58lNQNICz6XP/c4FbUGkTAB+TpkLjtHA8ekCrUnqOCZLq2/KnOH8KUPNSQ5q34mfO41Jjt5UGRjjRp0qh0OsNIQY4AZNkRIPkZFC6ViZf4xQumWdUEaBnrCkZhhTzznGhqOzNlcozKv2W7q2iEWbeySFZ4XAzHFQy9+SrrLsPV8ZNLiTyIQYUSW36865aPWCtu4vuPgd2mOZ6jg2/zZG/orqo4v+oElz2qSHmYCaJGMM1aFa3UrtoJUjJIWizJy1PrqsvyrtKZsf6Td+FkSuY/+RaDuPmuLHlElzYYF+i3ROqQzHcSz1vkYt6KEvDarGGQ5OlcS5R9Di9nzstRzwVhcPmlidQhMpd3js1zRpxOZvOVJtkGJp780I1I8kEdOgSTOoNMkkaWiZJxeWxpPiS8yhtrBJ5aBxJImc/x6qDwsDh8tohtD3sMRK+o2fabSWCKiJzPQx9HKSMFwW7beUDg3P9oHQwSBtPuCYBvSO9hWsbqtJ6Bmv8mqZYuZh+t4wf5hgnacXZNL4xJZZSmMcJV6vfvWrzQmeeuqpblGEWeJFT/21cLvQajeCdqmSAa6Wl7fzSL3fMST1SSoL8zvXTq1KJ8NOjFNr0UUAP8PPsfpJSm/Uu2MPa93X+lRL2rm0rFKuUB37d1w+ljHT5nnOuql9Z8Z/Sp5dhaVzZEz70vxiaTRtijOf0Et9P3YSptwuLhYYHeIqLm80jKU7iX322af6DsG///3vl0RutdVW5bNLLrnE3X333SWDdswxx7hFEVGMV6LH8lGqJMdZHTrOtKVAY8jaLpBSXpaFni52FBpT2JZOSq+EkLoP08nRzqUh0UEZAZwO125aGKle22xYxmVcjAsdA2Zum0xo5VE2F6NyJ2Eyrgdmyv+tttpqbrfddnM33nhjKd2CvxtuuKF0sLryyit3TvC0B2fXNPUZGgitxb2pYtgxkqJwGGfaUoDVPXixllRQSeUnBq4cDTQv/Ix+x2o3H16LQ9OOUqGR9KS6wflzailNjaNBY+I0KRYOH6oXibYYBjFaotACWvuJp83oyWADDWJfCXhNT+lfQaR6f1cMzrlnWnqpqufO5kyDenOig7aQNi6VCpfTKCX4mRyZcf0qq6zifv3rX7uNNtqo9vy6665z2223nbvjjjvcooiGxMsqup2uDj4jO61VfRkj5fHIpaYK0WmJx0k4uN/+mSXPlLJ2JSFrCwtjwoWVpEj4t4fUDlq/klSJsWXTyiCFl2gJ0dgFLOpPS1vEShDHFVJbSGHLMC3n9OR6S/SJ1ggrmJCo/bvtOrYgrD6kdJS0UFoT6Rh7P16PPvqou/baaxvP4dnjjz+ei67pD6tRZpcXjWYK53eZtQUOu1Mw7Fq1ga9JLqR4NZ85jGFsaFdFy8MtIBZJDI1HpT9YcoV/WyRB+D0nVbLEkd55urUycvVj7TdqXCYcpbchRZr/r/sBufrDz7Q2wXF8WCnNEHAfwWngOsW/NTViqK9x72gdhcJYykPp52itFlpFklj73vPBoCjJv/FQCqCqE2WO8xKWkATOmmcOsNIegY4yrHBoSJ2f265j8wrzu9p4lw4xRKK87a9PFJH4wAc+UKy00krF5z//+eJXv/pV+XfEEUcUK6+8cvluUcXk5CS0ePlZYr4ru4aK+U8EwF1JCjMtQWjnyiiVXasT+pwLq6U7IA6+zkZVdzHtGKJR62fiGIzIg9YV7ZMx0MporRNt/MTQk1JPI5lv6HxJ5lj/PZgOQRnHMqdbaAzklYJWdEk0oPKy/RjH83XPlE/tp/OdTANNP7UchjCN9btjRKsaQap1xBFHuC996Uvu5ptvLp+tscYa7n3ve5/bf//93eKLL+4WRaSIKvEOU2qFNqovABeXS9OaTx9qKkl1pOUr1aVFdZJKY856oKpKDEu5uec+ria9iKGNpivRHaInNU8pfdr2Uh1a1IlJqqUA7VLdaWUIhR8HWFXefdIfqjNtfHHtlqpyjulvXD9npVTaVTqB03ya+pobO5Y5VCq3Sq8Qz2NUfX3sVY2LLbaYO/DAA93f//738iQj/MF3eNaG6Tr88MPdxMSEe//73189e+ihh9x+++3nVlppJbfsssu617zmNe7WW2+txfvrX//qdtllF7f00ku7VVdd1R1wwAGlOhTj5z//udtyyy3dnDlz3AYbbOCOPfbYRv5HHnmkW3fddd2SSy7pttlmG3fhhRe6nAgtqDEqARVIBSB1Yu65tcObwimidEs56d66kS9Jn2O2JLULVgtxNFnUbhU9CcbBEnx6nGwhFE/qW7jurOmJtDHp4neh9GPzlvKU2hm3KZeXxiRR1aBEq3WMUto5dapGO12IOLUw7eOS2jFW1RgDS3vmXkhDY9U6Zrh2Ds2LtTpXxrrUD2tMCZO+2vekK3OwDzWqDqRXApEDO5RWKT57OEJSUyYYrBdSubnDBYYDBxKt2dbYUV8ZBJxhDu7woosuct/85jfdM5/5zNrzD3zgA+6HP/yhO/nkk90vfvEL949//KPmU+yxxx4rma6HH37Y/fa3v3XHHXdcyVR99KMfrcLA6UsI8+IXv9hddtllJWP31re+1Z111llVmBNPPNF98IMfdIceeqj73e9+5zbffHO30047udtuu83lgjbpSwuFj2ftMJV9waih0GBhkGLT1yYvetUKV9ehybf2nF7VwVylFGurI5WLxpPixixuyXVuSDdHGB8uZGdkiS8x8ByTxY0zTAfHuPk4HKNDmTn6nPZDjpHCkghML/7OSSg0RpUrH/dOCkfrpe++wY3V0EZLiq/lLTFh1fPEGysscWm/s9BL09XWgmhmONbZNXclj4KJwPsavZLfSwNi1tLOkaKfPPnkk4vXve51xTbbbFNsscUWtb9Y3HvvvcWGG25YnH322cULX/jC4n3ve1/5/O677y6WWGKJMi+Pa665Bqq7OO+888rfP/7xj4vFFlusuOWWW6owX//614vllluuWLhwYfn7wAMPLDbddNNanq9//euLnXbaqfq99dZbF/vtt1/1+7HHHivWXHPN4rDDDjOXI0ZHXKt1rwPPYT/QBUJ6c/TeT00S1PcjtGUL0RyTTiO8YsOAw3bZ9pa0JVqa7Ek9DP3sC1rdWfsg/rSUI7WMXL8IjZWu27oKx/RPLg01XWXsZisnYy/K0cz1VWqrNPJ5NmTPhJ8p9ldJ+SKbN/xJv0uw1p9pHM1PWPMS5lFLHn3beEVLvL785S+XDlXBn9ell17qtt5661IVCL68dt5552jGD1SJIJHacccda8/BKesjjzxSe77xxhu7ddZZx5133nnlb/h8xjOeUdLiAZIq0Nf+/ve/r8LQtCGMTwOkZZAXDgPqVPjtw3BYuHBhmQ/+s3L8rMSF8zUyDkAe4GvwajZ84WzgQmpOjE3zaYPU3YwmFVDbRCuf4TqVoKRNUmP6ujeeLLSUQaKFY71wGCqV6RJUisTRi2nycXB8/J7bAUvlCEnDYtV7nMSLpivRoaUfkgLRMFz/lKQ9EqgajKqyKqkzYyJgVtVzUm6GZq6v4rlV8lvH0e7HWEPFKJwKNM8/VgkSlaiHQGht0IPSq8YAahvJ3xodd6JfNhReq+OCaReuLCxC8yhDmzq3jujEbTTj9bWvfc1961vfcl/5ylfc7NmzS9uus88+2733ve8tDdNicMIJJ5SqvcMOO6zx7pZbbinTnzt3bu05MFnwzofBTJd/799pYYBRevDBB93tt99eqiy5MD4NDkAzGOP5v7XXXrseQJvIqLqKe54bVqd9U+BUI+wglsrC/ba+42Com5JGrM9PcHBoZiCwUWsqAnfTUTVm7XvkpNyYjH097aGrR61MRDagxY7LR2OS6XOOudLUDTH9QlvofR4WBopj/FgGnrwPwRKOMmkpqkNJBVsLJ2w+KPNkvX6M+57LzU+tLFNjjDJxok8pZdNJn1vUb2oYgVHjNkcSHbX6nyqXpna1qkqzzAfzwmYbUjxzuCmP9qNQP0YzXmDMDo5SAUsttZS79957y+977rmnO/74483p3HTTTeVJyPnz55cG7dMNBx98cMlo+j8oD4XYcYQOLg3oLIjU09OFJSpdAbEDqRZeqBvKUPjdt59UOEkFLY/FvoXdPRK6otGxlA9PmI0yo3oKLfRa3lz9cnSZ255hKE2SG/KcvqPMGMeQmSUhRskappHLD4ePXazazg+SVNOSp1S3OBwrUYyw+7HSHQLdQHLva5K/mFs/NImNNLaZm0ssmwwrosYZgxDDb9nQ5lq7CmMdhOZv8d3UNUKj0DRFM16rr766u/POO8vvoPY7//zzKyP2GM8UoN4D43U4bThr1qzyDwzoQZUJ30HiBGpAODWJAacagQZPCz3l6H+HwsChAGAc4ZojOI3JhfFpcIATkv5wgXTIQBPLmnajFnFoLimZJZ2WedU6uaFsbHhh8m3s8rgdLBKn4wkkJBaPWZTMUNQuwbQir/7Q6stCG/ccL8JUFaFJQbg0QuW1Sm6455w0ioPEPNCySXljJkOSgFFGjetbFmlcSIom/eae0+9SnrisobEhjhdBC2AZO6n1QjeQVOLbUD1aGSaP2FPNdM7JbGKSxEhIZgvSyUUl71CYnJjgxiVj/iFhFAwXyjwOb3nLW4qPfexj5fevfvWrxVJLLVXsuOOOxdy5c4s3v/nN5nTuueee4sorr6z9bbXVVsUb3/jG8rs3rv/e975Xxbn22mtZ4/pbb721CvPNb36zNK5/6KGHKuP6zTbbrJb3G97whoZx/bvf/e6acf1aa63VmXF9ENio0mpEaQ0fY5SJ02xj/D4dncBqxsaSY79AOf20aM0zGF6iLzFMmzRq7xLb20qjFI6rryb7Jbdn2zpS8zCEDcWL6RM5QfOUvo8DSnqmjLajaUt1bppxfuNoHlkdG+uDpa+nOd8F5p1g3U3F6du4Prp2gCl55JFHqt/HH3988Z73vKf48pe/XJ0kTAU+1Qh4xzveUayzzjrFz372s+Liiy8utt122/LP49FHHy2Zqpe+9KXFZZddVvzkJz8pVlllleLggw+uwtxwww3F0ksvXRxwwAHlqcgjjzyyWHzxxcuwHieccEIxZ86c4thjjy2uvvrq4m1ve1vJSOLTkiGoDTcdGY8BInqbCAlTV+Uby5Qb8ggt6uOwwGqLv7RgUaZGY3JimCYujiVN+l1LW3rWhvmy1BMNJ9KcuFHg4naCNic1+0SoLqynIDPS0Snm/2v+im2DrsKPPePVJSjj9eCDDxbvete7ihVWWKFknl71qlcVN998cy3On//852LnnXcuJW9wbdH+++9fYwwB5557bvGsZz2rmD17drH++usXxxxzTCPvr3zlKyWTB2FAAnb++edH0U4bLjTBjSu03W2WARyzizRcZUERZE6kSS71eHaLsEkL1QiY+HHvs7GwMG2p6YTGTxd1qTFJ48xI58JMKktfErVUBprr317KaKZ5vsxIWiS+rTUwTDnH/sogwK9+9avS4emf/vQn973vfc+ttdZa7jvf+Y5bb7313Pbbb+8WRTSuHGh7WzsD8QRNhnTL9DLQnGIoHJs+ICqPULnQ+1odgz1YwKlpazqmTtbU8gt4f6b5Yvsh+rxMt0inD6eppUfDSXla31GbKOm7B1du/JyzQQuFiykzzVeKQ+Nz4aQ64mhLGWu0v3QyZumpX2y8nulQidZXrGnEhLeMkdbpK4hpp1DY3LSZkdD+E13RWpv3wR3UGF8ZdMopp5R+sMAwHfx4gT8rABD86U9/ugsaB0wB8+k5UaUX6TMm1vgyB6LLLwz0muExMfqt8sh5bFqacPARcHK025qv/809j6KROTmK46cyEhytoXe4TNx3HI5jQrm0q3SmDlhw4yn0WysLlXthmqT4LK3z5bFFaTMf6mAOZEj9JitiXMxEQOorsQddosse8CNFn4vpRx6cimWO8aEueqCgRlvoQIAwz3OnG9ucpqwhxv9j6gEwMh9HesJqjWiJ1xZbbFFe5bPXXnu5Jz3pSe7yyy9366+/fsmEgQNVzffVTEbfl2wO0AeSJoEx7aCmJFHVBIauqig/sXRKYOxSF7QuJBCqRKqFFMIqEcPhKWKlVZa4NLwWVyuDpS1iJdGhMlh+0zytdPYu4RgjOmrjNgciL4KuMQ9GqZn1vUSfd5kQk4YmCeXKMQ79akLT2hjaaewvyb7uuuvcC17wgsZzIJq6fhgQyYH3AHFXkpp/pGNWkSZhV2U+Ru+9Zwc8sfvfwYnCH/Mm0rCGlCzgdJBFoH6kuDE7eSlNdpJEZZBcEITStdYrlQppUiOJ9lBc7pkW17+X1JqWOuCkXJqki9Lm/3BZaZtwbSdJrbj4MYtjm74WQsoiXZsj8Cdx58DWO5oT6DzBeqePkd4QqRQnXfJ51+KR8CHppda+4jPiqqLGMCnzrSYJbbhHUjzexzhJnjC6QpHmzorWlHslR4BoiRdIt8BzPVypgyVe3/72t93hhx/urr76arcoImjj1YFtA/e7S3SZV3TaioSrVbpM3NBOWdsZ5qiznDYkuCySpCYmXVWSZojDPa/Rheo9tEjFSN5wOBq37fiy1IkknctJR1tI/dpjJFIOg2Q7RnpkldJmK6tVQs7YneaioW156DhMZaSLUUk9mXE19hKvfffdt/Q4f8EFF7iJiQn3j3/8o/Q+/6EPfci9853v7IbK6YiQbUOihInbnXPAu2TpfQjRO8AIcAtPVHx0Pxy3YNP6iZXkVFdq+DQibK7wszZMn5a+fx6bPi6LJjkK0cb1P2lXbm1rKgniJI5cGPyc6wNU+sPRYRlP3G+pjNIzqbz4U1uUuPy4skl5xkDq11hSZ86HczRquG+0AeaKNVofXLtyUkO1zRUnxWx9W50fWz3GI2layjiXwJXfGk8ah1pYCYUiJYueqxVoc8+omL8kxuvDH/6wmzdvntthhx3cfffdV6od3/rWt7q3v/3t7j3veU83VM5EZBR/cpNxY1EVJinr9Q/mwc9cIsuJkLnJ0YSp9PHA5SYBjpkon1mNMy2McsTCUat3yds1qrdWE0ImA1RpIQ/2BaRGoGFzM/AcOIYyVJ+YkaCLtDZBc4wfx0hRGqSFC+cpMRNS2ThJYJcLC86vkQ/tY1hK5e/HA6krc1eexszWvgc2EJgujmHk4oj9E411TjqJaQnCOm+0vQsW58cwGqb5EIcN5eHnZksdzNM3shbaGm2V6Gl/FEhyJwGA63z++Mc/lszXJpts4pZddtny0mk47bgoYqYa11vF9zV0ZDyqqW3YiZ8zfk9R+SaqiaN3VB24IBHpChwOyJ5fxh07BmV4uLxiVTUxqiiOOeKkrRbJAMc40XcSoxaiJ3VsdQFLG1nq0FrPbWmbCeitXBnnk4ke22LsVY0es2fPLhmurbfe2i2xxBLuC1/4QunHa0CE0XmL3Ywk5s8tUdBEyib/PSSdUD4pYTiDT/ES65RJIRAnqFIztDPeNXeNkq4pGy+qsm0DjWlIjUvfWZh32h5Y0oGfh1SBlndU2sXRGWKMtHKFpIuiZFcJQ2mJWeA46bUksbLSzNFtkViyYSLmVI7GmDHbNSyaCauEkEpRRQl8WwiXjcfOLROczVsipLxzqjQ7Y7zAX9fBBx/sttpqK7fddtu50047rXx+zDHHlAzXF7/4xdLNxAAFDBOQyjRJk1L2HUKqDUafJ0k68hVkhabqqNHD+e5hTmHmmgglVaFHcIGOpKNN35OkGdLiqC3UmgqJqpusk68mjbIyWvQd/q2pv6S4moqOYwalMDHQGD1LGTiazCAnCFkYxn6t/MQcovqc2pDUmBMh/2gGhmNKGPWjtX2k+Udrq1p4gVmKBi4DaYcGQ7ugfqqRIomJFlS4qZuasVA1HnTQQaW3ejjN+Nvf/tb985//dPvss487//zz3X/+53+6173udW7xxRd3iyr6FlWmqlTECTfR/0kbYAmFdXcePVBwGToqD6fuiVV/aHVgUXflULFoecSkE6OWC8Xpo89Reqw0hcJwEgecN8egSSrJruvHosb0z1LGaep8ZYFVImpNi7bVKFWPUl/pgyYxb3LSODTXpcyHuWi2jtHJyTFVNZ588smlywi4IuinP/2pe+yxx9yjjz5aupPYfffdF2mmKwopJ3mMXLyFgxelGl71hHd+BgPzGHWNRpNFpSINajZPZueF1WqNcPR7BKgYn5V+GHx3UWmM1Zg9Rk1kUZm1gaUNg5K2gMSLCytJ9+g7uuOn0hrchlQqxtHEqW+o5IdbNC11gMNrZaffY+pOyl/KN2mcCgbXZVhsJpB4gMUyf1iAy0w/WSTM42qbMKYoMX0ltyqtljeWzJOTxiG6UuZDihjJtIUmKfzYSbzApuvGG28s72UEgBH9hRde6J7xjGd0TeMiI/Ea9e5KQ5bdaU/G4wPaI9gXjX7UtDhWOkKMASdx9HG4HTD9bZEmhKRUnHSLgkpQOKlKSPIVoiFGSmORUATfGdq0ptaLPHTTmxQE31TBlaeLuct68Ec6aW1Nt2X7WdNOrqMFo18Xxta4HiRcwHx5zJo1qzzJOEBBjzYynSHFl4y0s4sYXJy0QqOvzc6ua1S0Ce41ess/wtCULu4NySaRHlKpH4uE9uekUpQ+SZriP7WwEpPE5cfFxYwODoN/0+ccjVo+Fhqk9GibcHVIJXYaGrThgzQJXsUbTAD32RImKQhzUwV9ryKFVs02FacXuLsVUGu3GJ+Dws0bIjQ6lHeaRNqlMl1jcACic4nXYostVt7FOGfOnPL3D3/4Q/eSl7zELbPMMrVwp556qlsU4Tlm5+C2zeXYHVXobj9ul67qx4l3Y9it+bu5uB149Yk8l0s7ZG0HH1oIubJZpArTcaeUDIPtWQ4pY+s0YnfbYwytH3YteYlJP0riFJFO9jIKEixAKB+VNqNdZuflk6CM17ZjNTV+zrLjNSKUlyVfi9S6D2j59W6jbWW8wJDeAjjluCgipuE41YIHp4bwz1WROWHCaHoxyDXxh1RTlD6NudPo4aAykoZJRWNG1fJPlTNUT5Y26nJiMjMhEaokidnvE1K/imFWtD4YUvfR/KR30vjOyWRzbayVoy1ytbc2J+LfXecvbp4j8hrFGOBoAIya3pg5vwi0cYg5HHs/nMB4DWiPyclJ6AHlZypCrWFpLS9YT81PehbVU+a7+mcfkPKKoQGHlb7TZ8w7tq7mO3N9a2Gi28ICVIbUtHPSZC3jv5RItrDSM1q/sfE5WrjP2LGZMo5HOqNzYyZm7IR+9wWJ5ti5JIH+6PZLqSMtTps6t5Z5PtP+Wj+JQHDcCGnmWL9jkOy5fsDoOOYs4nxjPrFqDSmOKIkgak8x/wxqRU7akEP9kxLOii4kE1z6HjnVFTnT09LmpJ6aRNkqkeKeS7TQtDkpIE5Pi2+hM5dkI5cEexQIllczVmfmnKxjN0Ud2VaFmcFQXsxrDNpbgjY2rc/H1rh+QPeADiGpzjBKnt5wySjtXDUmxrW754rG8WGlOH4v0khfueNMpZfSYDC0pDSq5ZPcTDAGwFW7xdyxGHFHGreAtwK+V22qH3Htk9o/relp+YTypQwR/aN04Ofce/wbp0nzk8op9S0uT1weLr7UP3GZcX3EtAtHP47PpcPmpajqafiugMdGow4UJgbfD8nGFcocVRbDZdiNPKboimkPmmcMjZx7HXFz0YLp6rIPhMYmRbUujtgwf5B4ZUIbjrl3OwDBFQCnb+foi91hdI1xsKOIhVWCMg4SBCp5iZW0Wt9ZwoYkUZIESkqTSpgwJMmVVWolpRUCJ+ni8s2N6TCup+NYp5iOZZiONMdgkHjNRAjctSSZyrqT4PImdynS3bY0+YZE+9yuXtux4TBtdkUp9WfZmeegTUpLkoDE1qUUX6NDei61vUXyI4Xn8rCCqwNJQsWNJYlpktqaSpq4ZxLTRhklTQrG5c3RyJW3awlSzPM2sPTZUF8cN1jbZlQbqtjwUp/UpIMDbBhUjV2B+mERVHltBqEYl7szi+aPn1Pv0MydYSytgbsHQY2lTZ7+fVQ9cPQKNIhhBRWTFCbHRKmlJamarHTE0JhrcQ1NtpLUJxWh8tPPUNtSBolKpPAzH55rF4nGBoMt+JuLZXg7X7SNKhiNgRfTRePSzw+qGj9EEx3nkShpTc2T+a6Zf0ShAz9mKeGt8xBb7hDtCwz1G4KlzTKZqWRHLyb8iwCyn4oQTnz4ro9/i/FS85Peh06e5D5hQ8LVypojr5hTjFy8UZ26yln/XSDxRBdG7MxkDY+XDy5+6NOSLo5Df+coR85Zm5tPpDryY3DcVg0zPeMyPgg9Up9pVdc9ljVLf5jf8jRlSwynGme6jtjiHJC7SgIQeUVLyDanfOZ3Kz1fkB1yKJuSVs1w0lqv0qmeCLpCKlgrLPZIVKKC89Xsl2LySXGmSm2lpDwtdoQhuyatvnE+XHpSupztGA5rbQuJLimcNEa5coTKSdPQ4mh0jgqpZhcxc6HUzqF5EofJQX9umyk6/vz3nHnNZDuve4ZTjTMceNESvD6zV0mQZ8EBQE7YceLg8r10HUXinXpYbKuqo3z6Uh0g1UwjHaRaKN8xJyOreFTly9GAUKVhvP5CVBUliK8tqiz8PRQeP+Ns2iQ7G1GNBKeuAifCpMmZqvAoXdxCKNEuqeZoPlr+NF2pPrk+JdUPly7HRNJ21MZJqJwxCyNXBzkxKlsfS1m0fsG1h7W/WTcJnCmGGi4SJY30hLKQl89Pok3LIzsWoFPhiDYpbCcYgapxsPEaBUJ3milhzDAwGal5cIO2WnTgiLIf8LE2D55ZRNImyU5MdEMxFbeafDhJXkvQiZoFsuvTFmvO5idmErYstP57beEV3EhoizdmmijDSRmqGPotDCVlamIMfDFzwy2qGgPK9XNKD33P0UQZTEmyxS5AymbG1BeFuEGQfE2LozE9DrF9J5VZEfPxLlakjRRjExSiudEfDG4mOp3zUX6NPKW7Ipl2i2KOtHafh+ZqRBsbr4M7HbU26RKDO4k+RZUjckJH73HkaMomnjaqo5LS5VS0MXWaWv+kjgBURevrWFMHj0pUH50vVt1Kqug26UeoRXGbceo1SeIQo37ifkvfpTQ4Zs5vIry/JE6qF1UXieDqTSqXpLLK0XeT5hjFHxdNy2NajLHENHG/GrVDU27O6xwLAk5mp8YbN9a0NhpUjTME7C46UweN3el5yU9IchSzexbhVZeBk4ShMjQkG4jxqdRdlslHUzVaQeqIk6SJz5TfvSDGqSsnTRRU0bGSOYqQyodz8kilRTgelx5V91GpF5V2cRInyoBxEidJnViGR0wXTo8yNlpdSNI9a/1z9cb9xnlT2lgphEUSQqRDFdNgHQ+KhMjSD7LBcHIyt6pVap8GlNPbUZBOCVo0NL78sRKvTKhoIesc7hPSJmMUGFSNHSF1EvCdV1KN+LR76TTCEXgM8V2AyQmK6JGrCRpHYn6CMEwAUSJ0Lf/YyQa1uacjRp1GgRnWUFxJfaflrU1ouSDtULl6wvRLTEOj/xBGg0qvpMWd5k0XfcqISUyWxtBx5aDxrPVu3eTQPLSNWuM7oU2TfFvGrbiIt0StrCEVVAQ6ZfqcoR0kW93UNK0SNb/JbutOY4GRYZNsgn14SzqU8YffJy3v+sSgaswETlQZK1oflSpKQ0jlwtKsDVpGdRQNIk7m6ASwvxnVD0sfWjjEMnoo16eE6o6j0yNKJRPIvw0sjL8myrc819RrVikTTjOkeuLypmlLDBOnspPyoTRJkiwpPWs9c2lb6kGjd4AdoT4wyvrNnZ/U13KlF0JKfqExO6gaZwowV42MNvE7imwO+BiIO2oiadEgLQQ0Pc0mA79TBw8Vc5M6o3WF67YyyOeMYIkxZ2O3j09bKvdIWnaZnHTDqi6hUhgLtLbh3lvT5CQslFYuP4kO7jknTZLyolIm3IacdIiT6FGmlkubo0vKg5OE4fS5cmnp0/wpfVpd4t+0jSxou4hapMZtpLmh8GpaiqpUlbIFVKxR9SvN81Rik6o+pHOltu5Y0+fmUnKIirZ9zLoSA3WdNKpFY8dEbgwSr0zwHLNzk8655eqNahDbStKxkNRkkdm1hnybtTE2tdqKtTDMV79zcQAdGK2G1Hfj0mfa9N+ud/gDusW0mOes84HBd2AnNKXSh5+lHmKypK0hNi+OXgW8xPge51zaXcspGGy8MmNyEkm5AMbOQN0mSFIGK7JNRpLBZU/gJGXVb3zSEBvfUxJDNFttGayQ1JAB+5iU/FJsUaTnWp+x5JMiUesCkvQJ/9YkLrgfcSo7Gi+UHhee+03zpc+09HO2jya1ouUVw4bGnPK+1TxncOFiCsdJwzCsh3okFw94fTAY7ZvmNHqoKSIPlkZmvtL6qJgOQ+MElS6G1suASwoxP6bsWGLnaYd1u08MEq9MyKkjTpI+tOL20xi1rtMKhbHYr+SwB4jJz5Iebt9UCVSqJNRKr5R3bN/UaEvp51Kf88B1GqoXSTUrMVvSe0lKzb3HNGrg4nO0S30g9F4Kx4FL29p32TCMHWXtuYFGa59PGhsdSaUa/Qm5YrDMOWWczGRZx6BlHGOI6WFXNUU/6xubFoT1dsILJtw9L5/Mtn5bMDBeY8R49aFe6Uo0n5MJs6Q9XVGb6MbAF08sU6ktEF0sCiF1ewzDHsOIWcLFML4cM9LlmIlhWPsYWxoTytEY22bjND+kMhWN/hepQuPyr76HDhV1gJHM2wvS5tTBuH4RhBfbWnY8bdFKnaQYZ3LpmgZdwFcMm06MGiNWVSqJv42oRPCKkWdVHqtXfYMqIkccTxv3LrTAceo9q/pLCmdVt1ulR6H+6MsvSVUxrZSBwO+5P6481jHDqXeCkNQrKM2QejknaF5c3lw7W9tsLKDMhVy4ClPMVaP/kdsvxPhencbkj9Oq0g6pHrWDTVxcYb6t1UOLQwMTBlMBUZVroLPE4E5ieqLimI9ybrm3KiNPMVgcx91bECOQ2ki74RhJRLTakLQb9Y6cogbhykRpw/T1sYO01GGfUhnpvUVtx5VB6jMx0qiQKk1KkwvD5SnNA0EVXgI4Wrm8rWmFpKFZpPpdzTmpRt0zAdYDPYFwXWhtJmL6T4pB/6BqnBmnGotiuWyTzTig7WACtCp/RxNiX22Ukg9dhAFtmLlc6FPVyOWBITHdkjQvRi0ZeiepxaT8tM2CJb9Q2JhySGFzbfxy9IXpPmfmmKc6ZzQT6WLbh4mTxCRFwEKD+hzhnv+dcMvvC0b2w6nGaQl/OiKkHml7SlBTOUSpJBANIcmBSRXGqDhalz92cEoGuor6hS6cWL1Dn5kwdWKGTg6qqgy1A16kOQbD0sZdLFxSmprUJxa4bFRVZ1VB4fASw8P9+bA0f60drbRoDKHPy/quTf1KNOD6DaZPbteg6Ykn6ozzXarEjdLIIpKepLpuY+4wBY3pqtFkXUOsdBB7Mx9Wko76ODRNtg3pie8FBpWngEb6iUxXid16PtZYDMiCyclJaN3yE1DV7HxX+8Q17qe6cUKNHk/7dAdpAwsa7TLquojMP9SvuPd1VqUlXQn1JeVJn2u0ceOL+8Pvue9aGjQ/KR0tXIhm7r1Eo0SrlI+1fVPnps7nNGVOzZ4H/Z4Svy/QPMnvUN+j8cR6jZhPyzSU9FxqNUGa1rkH/ZbKS9fvrjGcauzTxiuDyFiyc4lRU1nseLqGxU5Go3m6qijGjb5c6qW+oe6+DbD2rZAqUErXol6WbLukdAbIqNUTmmdjVPu43nNhbNqPuvAAtHUILVzfFhW/K1jzqU6UDg5UpzewyJI7vWKFcioOf+c6PFbHcGHoM6peyQZG3M6pjazMpVWlE4Mc5Y5JI4Y+a5pt1FChdqDqpFx9pG06uI/7T+07946mhdWK9F0Dito6Rh0s2X5p+afWnTke4zxUbX9mrqIq3JrKkXOgGUFP4zm9oNlwLRlV71f9QjG7UOsB0YjDSP2i+kT50f6SquLk5gPvSgJfdWZtg4ZKkTBvtToOqTO1U4dtzG9o/VvzmQo3OFCdpmj4AcnE2cfsmOjOOWWnZc4POaFLzSsHgmUN2EiMxW4UwSIpGRU91vAAjplIqXNOOiulHzs2uO9cXhhceTRYpS1am3fRV0PScu5ZqL60vEbZj0edvwjFIL38RA5Wo9Pi/Ha1XZOodIvJs+adHjkobWV/5SLGgCVNJkzffrwGVWMmBBtuDI8eh3bbWZFh0HOTFEClvct6j0l7DNtfgraohhbmUaisOaZAYl4oQgyFVLYQ48IxjBrTRvOQGE4tTy4fDqkMcW6mWosXKn+bTaYWJ6UPW+uc5jm2DGFQLTe68d4VhlONMxWjWHSNp0IagydB1BtURRkvCRfBxDepH7FoPPEEqRg3pk3btn8b2iPzoOo5rAIJqbYxYlUllvBU3RNifDhgejlmh6aF49A0OPUTR5cmRaN5cs9i20RTWeH6iWFcqMpWehcqE2WiPD1amWrpTzkbrT6nnkngyi/FY58zqlf8PbbuGnlJiHQySlWXQcQ6Mt1jiumaUuuy9PcxTzGgatpo9HyqcZB4ZULvokqD0a91N47jcPFyQlssud/aO0t4Cz1t1SXjqrYcN0htGWrjkPQoJ10hVaREl1V1Z5UWxIwJKY703kKT2qcZg+o2EqjYcuBwwbwSfPppcSzl1CSuFuZUCyP105g5UnsWyrctktNa0J3GAGianOx3/V6s8xwGhEEMLD0su3bpXUgyIe0oxXTxTipypxSiW9sJRu8SY4Cu6bCEk2BJA0sYaBtzEpNRgEodUuJqkNoy1Ma0fmPqWnon0YwlMCFGR9scSHUhLciSxIdbsKXysxspZGzdiDf1TpJgaNKkmjE7nVvIOwppjtOYV06SA/lUTBAn1dZsi2h5cDCF6cLhaRv59sOMmX+uSdlo/o2+I4S3jp/as5CfLdJ3tHApSE5r3pTmooU2hn63zO1dYZB4TTeJl8FQUdsRY4QkXqFdHZdOCOMsHbLsxixSBY/YcLklOVZYdsz4eVs6Y+JbJUk4bKrkwBI2RdKUezykSHUpM8D9ltLPQWOffcaHt7ZrjvxiYJmfc+adUpZRzUW93wowFfael08OEq+ZiGgpguJVOPRc2llhqZZF4qXtXIMSMpw/2WXhhUySDtSeMUekG3k4Q3htx2Tc+YTCVPUCdcd478YLQlUXlp2ltKMPhTeAtkdoomo7IcdKrCQJgpQu1y81CVRImhmim5N2aZJMTnISI22MrX9aL5h5luYC+ltjYDiaNcauDwTnJoDi3oIy5mLcWEzNM1KdmeiOpCc6PTIXNvptSzuuibYSfclmF8+x3GlLrU6GS7JnuMQrYD8AmNY7jRFLowBUQmGR3PVd56NclDhY6gqHDYXpEpJExirN4cJJkjyurFr+Wh1KjKTGJEoMAKU3p0TIIq2S6kVKMxcsUsfpJK2ZTrRmt7NaEH+hdYq0HFCLw7jBGCReMx1Kp0re7Wi7zxGdMsm9E6pJ8RTnspyEQqvXtnWeuoNT81WkW7U2zti2EuOBgfPGUppoJ4wtd72atJaWQwvLMUKaBFZjnHB7UikWR7vU/hZpng+HP1OkYBYJnpS2JCnrmokI0TyujAyV2HqMglZKS0jSXb1rezKdYh6TXiAPsxRTkyDSPOYVbvnlXa8YjOtnEBoTPvK7YoW0QFrTsKpLuDxMk5D3vJwx/7aQVE2pIv2qfLicU99rE0nmUz4Ss6IxGFY6QhKU2AXLmpeUlg9HGTCOeZcm8BCzhsNJUjKOecFqQK5cGk0hUFql/kpVpdyGTlPDmRjykJfzUHgGNcZUCK9uXKgRf4wrGnoACT3DG8fGJrKF2lL9HRpD6HBRQyJEDjDU4k+1L03LlKdCZxYkXoM0eVS/nNdgXD9Cz/UWCQPAMrmKEzvxfhxSrYyzo1CLmkGNO184Bs95iO6oHNY27WtXnEtCYFHJpaZjicMxRZZn0nstrEX1FhvfinGV6HQGzjv6NHFELMGquo2GwQ2GNXwvfXFBPrWiD+8hrRPSu77dQQ0Sr64gdSjDcV783trxRLE/oYNTx1C6GqD3c2m7NHSyEqO1FEoxfrfUka8LVoqAaBbF6oFdmlX9V2tTww4VSzBjVARWtJk4tYlOW1ws6cVAUutxNFqlU20Qit+mznMyXaH64t5xfbARP9VhMRPeO+2s3me475bNRzgQQQ3wTX1YmB+1uFT6KsVLkQDngGXcREvv5hnVisZDRF46Z10nam3cs3H9wHiNEF0PnNBAryE0oVG1F8Ng4cFZph/BZHJQGaEUxDBFWnhGxO/L6+9HM4nXBeaOU+lRkb9V1aSpkKRycQssB0kVxr2rnikLkqbSk5hPmj5W6+FPjk6aHqdG5eqLpkklZTS+RC9Xxj6A64hCotuH5/pgIz6nKrdAuJ2i9t6wWanCGE6A43yq8uCTh6gslvFWlV8pS2MDEJgnpXHVGE8B++EGItpHU31X3wNmIA0ssDFUapqMOYYGXGe18gye66cnLKJKs7i3rXg9c/hUFYwqKiYDqxcVSkK9UtWs/07DpKiDg/QZaUpR51kZtpiyWtNNqSvKTFE6KSzSNtqnJQaL+8RpcmMj1G8kBi0UntLFpSWhTdtp9IbytISzQqvjNuMgVnorpZeaRi/zX0uk9LlRY0IYt5TuQdU4g1Hz7eQUCQnd2WXYOWrwNLDqAoMko/YOSU1UD9Z+d4SMxoN0BiQ14m+cp/abQUPyJOxIaZ2Z6AnRZ6QpFpY4tKzcwitJabC6hv5pCz8nnaM0S/XPPeekWfhPkmbh9zQ9bteP06HSO/xdkq5RaRJX9zWJDMOgWdtUMoTGY1WSLNJ5QKpzScIoIUbSJ9FgYRrpd3UsC3lqNNM2Skkj5n1bxKavtX+yxHZBt4Xk+kcWultiUDX2CSqKBfG1dOGoZRFWFvpgZ6KMFf2dqNrzTByXBl2Q8TMahoM4uWoMVczAbjEJ0PJyjHQXu0OOuekCHMNBJ186yXHMDqWdpqflSeNSSRVlmiiTKJUJp4HDWphuyjTVykZUt7UwBptBKtGh44bL09QHGLtP1gEz+R1Mn7mCy8JwRI0LRh1epSeosSk9FulnCNymhP7W2sFSB6Z6SZmzvKqNbowZhrzW3ug97QeWq6JYzFMKmWIjGBnHumnJjeFUYyaIokrk0sGqZsohdh53UXBu0XpvonxGHahNoqn55uoDsWnQOJo6hutjEkPQhg6tL1PmBIdLYeI51YSVRkoDJ12h4fB7qe65tKX8uTpp2/8kKdEo5phKOufnVO5EcmBuxWhNu2QeoJmQjMPJTEJDUj/RyhFTL2OAvlWNA+PVUcPVOnLfnS2UH5kApIldgnmQRpQ7lPdYMpIGptpaV5oKJJqpVOiSFuuuGdwumFMtf46JwflqfV7qaxIjRMvFvdeYII3Z5X5r5R4HWJjX1DJ1XU6ujbvKL6WdxwEawz8d6QdMTg7uJGYEamJXxbdKUC2QgpBLB3LqiFWnKCLboOSO0GGBqK5R3kcjxgbLIrI22KdZafbl01QOVL0iMqNGuzkpXUuc2Pe4fH5B83/WOqKqj1SJFn7P0RNKkzJs+Dl+zzFzFloxPVpZuDRibhLg/qipgtofhHxq9RFQ/0l1zs1d+BmlN0irkrZIe8aNHldOa//oZI1Q8rLOBbQMo2K6JgRVs0Q/pXkUdA82Xl3BYrhNDFrxZw7bI25Ct6CkwdNP/XeFwMXD6aK02EUCTfq9DYiEqyu6niAlaQrHJMfkKzF2HFNhoqtF3wxNenSxonE0iZS1DJj542iSxiVl2DhmUktXQ6oksopnuK2C0lWjD/m7U9uHHMqhtPgwXHtwjCtHHw3HbhIjDugEw1n99SWMu9AGrfbe6ooncvxJNFf1jNzWaJsoE6yHnhiEmD9248bZLvZszG/FoGrsU0c8Qv02p/aIHUwWVQlVs2iSh3ERS48TLdMRkkoI0FhMItx3xOYZSiMmbRyOjh3tWUo/4lQflE5L2n31Y8pYRuU/gpsteoNQtq7oikrXan5iSWPqNH4j7wQbtolMddN2sz64k5jJSJ1whNMm/l1ohw+gah5up8tJAmoLATm1QsXSeBAFd3g+rYBDxNxSJE7qJjGTvaPFCaUuwKqhyDvptCZ1+JriviMUTlMlUIYA93muHNoY4iRWdDz5Zz5NK7j+x43JtnWi5R8LSSJiKv+UNI4Loz1vQ68kbcuFKj2hf8dIOmOlaOY4EQ6yRSmTv0WA3ADSKH+kiUnfGMncTmkoimGvnwOeY3Zu0jm3HDsR5pL+dL2za5P+yHediXSMgm7Lotq2HDgPTjIZm6aWflvacyOGVim8Vq6QFLnKC/nrk/IPtZuF7j7re7rNEan9HT8DjMPc1hajHpe5ILWTeS5CkrlFSuJ12GGHuec85znuSU96klt11VXdK1/5SnfdddfVwjz00ENuv/32cyuttJJbdtll3Wte8xp366231sL89a9/dbvssotbeumly3QOOOAA9+ijj9bC/PznP3dbbrmlmzNnjttggw3cscce26DnyCOPdOuuu65bcskl3TbbbOMuvPDC6DJNTvK2CFWj43vMuKsLJLS8fkdNl0hN/GIRg+wTU4x9AHeFz5REzbq7SZEWpNYzlQ7Wwkx94jCxu2D6m5VICb6rKGp0onql6XNptO0LGk3SnxQW08NJUDgJK1dHUpuEpDyadBnT5t9xc4iGUFtKEuTUPp80XhLnuxTpF60HSq8Y1yDB7WyeCM25idLtqHFpsXGLPMyQExOoH3PtIZWNfT5KtxbFCLHTTjsVxxxzTHHVVVcVl112WfHv//7vxTrrrFPcd999VZh3vOMdxdprr12cc845xcUXX1w897nPLbbbbrvq/aOPPlpsttlmxY477lhceumlxY9//ONi5ZVXLg4++OAqzA033FAsvfTSxQc/+MHi6quvLr7yla8Uiy++ePGTn/ykCnPCCScUs2fPLo4++uji97//fbHvvvsWc+fOLW699VZTWSYnJ6EVy08V8yOqHMIaw0e3pJIuTstP+7FpBPOd76p0a3lY0kzJN4I2Wt5G+VEZgrTgsB1AbB9Uvz4c/qTPrfng/Lh+EnrfqkwJNHO/JTpDeVrrk6sLLX1KCzsulPJxcaS20dJp/O5qnBloGHmaPZbdVI4u6RmjslJIc1sWoHTM63cmjFWN33bbbWXhf/GLX5S/77777mKJJZYoTj755CrMNddcU4Y577zzyt/AaC222GLFLbfcUoX5+te/Xiy33HLFwoULy98HHnhgsemmm9byev3rX18yfh5bb711sd9++1W/H3vssWLNNdcsDjvsMBPtXMNZJ14NMQtWG3SZx2jZ+3hoDEPodyi9nLTR59ICmyN/jkmxlDuGebDQamUiNMZD+s2lQ9OQ0rbSqs0HEh0xzBhHq0Q7/t2mj8QwdI2wwmbHlFfipibEqMamqdUvS7cViIa260Bs3K7nkYKULRdS19i+Ga+xcicB+lXAiiuuWH5ecskl7pFHHnE77rhjFWbjjTd266yzjjvvvPPK3/D5jGc8w6222mpVmJ122qnU2f7+97+vwuA0fBifxsMPP1zmhcMstthi5W8fJgW+++LfgJAxr5ZGV2jkkdFom6bdhYg61jC1AeVuStxu+L1VvZql/aZUldK1HJT1suSfosLEn5Zyh8Lh9CT1gf+NVXA4TU6lxLWRf0fpp+9CkPpH7BxA6afzA46Py8WFC+VP24/SU3see+2K0ifpuGrUVRtXEIIxt7VO2Hw9vdQXYuA6GjE9jm4JNH1yjVObeUSMq/hiE+eRWBdDXBrzdJvHJCReywZxSvPsHjE2jNfjjz/u3v/+97vnPe95brPNNiuf3XLLLW727Nlu7ty5tbDAZME7HwYzXf69f6eFAebswQcfdLfffrt77LHH2DA+DYqFCxeW8fGfFZYFKRW5mI/g0eOQDQa9U81oo0bja+FMtgvGiYHzScSlzy26oTrHtMYw3TU6yKXiEp0xtMT0P0p3LlshDFq3lKEK0UttsEI0arZeVuZVokGKY7E3w/1Ks1+R6oTbLEQh1vZFCz8Cf3ix82qtHr07BP/OcP8gZTCTwV0xlBPYvpjmGZMXuW+4im+5KzHkxHoBsh9jngXXh5D/SBp2KvzkUf1yXrPcmAAM6K+66ir361//2k0HwMGA//7v/26+OGl5597K78ByMVpaeq3ysE6SzA6zseNr7GRlhoHbzUu72NDOPbVMbepSkyhxzFrNYL1F+tx7KgniJD8ao8Yt2FQqRdOlCz2lN7a8Ei0SI0P7BFfuGg3lZPuEwTvbdxmw6ZB3lBHnmCyJuZTqyFIHHB00flf+s1LbVkOonYN3Dlrub4xlLCLcMWSrv4x39+L0+Lm1cG4PRfKZq/xSuHn150/QgeidGrNqOkJ9ifMRYbIXOYnXu9/9bnfGGWe4c8891z35yU+unq+++uqlGvDuu++uhYdTjfDOh6GnHP3vUBg4NrrUUku5lVde2S2++OJsGJ8GxcEHH1yqRv3fTTfd9MSL3SaDkpJcXr+zoU3nixDvNupF2k0ieqrFhPiFCkmOulJnxiBF7aDl0UX+ktqFSmXxp8boWenV2k2SrIWeU+aSqiarMMrGgeYTYqxwHqG+yOVBmVb8x0m9uH5P6WPz7+gElybVs9CsxQvlIy7Ygk+qLuaEmD7N0WOR4lrztoTlwtCxXmFKwi7dUNAJ5hXJ6x7dFGrpNPLb7Qkzp0WC8QK7NmC6vv/977uf/exnbr311qu9f/azn+2WWGIJd84551TPwN0EuI/Ydttty9/weeWVV7rbbrutCnP22WeXTNUmm2xShcFp+DA+DVBnQl44DKg+4bcPQwFuKSAP/PevchkrgFkArAOolZhVsSWIhnIPJQU3sFlpA7ryRJKAlYOQc9Ip5ZUBXaRpzaPtrlddlIVdYQqjxzFlMdJEjuGjfzRtylxxtEhlkSR8nESPk7pq5dXyl+iNLX/1PfVuVQFtmRSuPjGdwT7BqcW43wFoko/gHa0GdRYnGeZoYNst4ESaxtXg58MQndr8UvsecHckzQ9iv7G224K4+g/WQYiuUaEYId75zncWyy+/fPHzn/+8uPnmm6u/Bx54oOZOAlxM/OxnPyvdSWy77bblH3Un8dKXvrR0SQEuIlZZZRXWncQBBxxQnoo88sgjWXcSc+bMKY499tjS5cTb3va20p0EPi2pwXIqYrS1XSTRxb0b13JYQekPlUd6H1sPPjyO56fW6dgvcHlomdqknRrH8p6re+kvlI7lL0Sf1CdSypeKmDE+zv11FDSm9P0uIfXvUNjQs1Aa06FfaFik3ElMKW0bf+Dby+PBBx8s3vWudxUrrLBCyTy96lWvKpkzjD//+c/FzjvvXCy11FKlD6/999+/eOSRR2phzj333OJZz3pW6atr/fXXr+XhAf69gMmDMOBe4vzzz09vuNAx6VhfJGPsa6U1bTQ+d0y8w/LHLthR6OjYdG5YmYK+8vbPNQaPC8vF0/IMMUkSI8U91/KNXfysdWKJ0xZafrH5jtMYqNHOzC9jyUxMp3UgJ63zuy335FGuV8ZruDIoE1KvHMA2TPQIs0XEnBNWdZblapTKczx3mWoH4Ox0pHwb74yGx10YEovo6UL1UJm6KjO1x/LfY+Jr7culF+ojlCbuU8qDqpwkuy4prdR6iIVF5dRZ/rRPU+Ntqc+Hni9ozjW4HGqZY/PUEBMnZ76pcVvkZRoXXPo9zWsqGBr6vjJoYLwywdJwvS7cHS2+QYaGMJBc2E7qYYrpi2G+ANzkoUFacK0May7mIhZRjCh5bukfqXVgYpjxAktPsBns1jRGDMPKlHk6ohglw4Kj0cOF45g+7jkduyb7Sy1PVP6oeC0QYlpriN1IGe7SjKWzr3glhHEhphmonyxtxjHZORiuBZkZt6n0Fqm7Ghc1mCfoMaMLv9fClu8MjvE6YT6Rob7VmNKHT2W6aDrW/BogRrDW0zkxoHXDSWhCBuha2m3qIGigLByD15gIC2NM6ZbqpJEHYjpwPj4c/qy+7/EvRo2G1foqTTPUjy2MKFYSNsou+EyqhVecnnJ9S6InBtJYrRhBDlN3nmpplu+ZuzRVtD3IwMS3zg12VwyMVJ87qCAcYqjiontjo4zoKXOUi1mal3nxGJH0bWC8+kbI+WiLjhCaxCV6THHIJc84v6R8EayLT0x6fhKlC4pHrOTJx5GYLkxjdH0wHqo1RonSFcqLk4hIl13TZymIoSfELEjxqcSS1hFtMxqGrROm/PQPv5Po5MJxEmOOXhxPWuy4/sExgBZmAtOH558aUzklDbIsvtxJ41z9SoSyyMdsKpPzi91Ax8zxXtKb6JW9lo7i+wqrbGv5IKYUQ6SlZ0ZmYtxOKxoxMF59wotJhc7Z2KFEIjTJsosOsSsTJ1dEN7fDlvLlmDQNmFHCkh9pYa2AmMLGwtdSimiZ8CwSFlwmqR6qd6GrVgISO7oANzAltUmRwoSQY7GzMAuUyZYkYKF0af+K6qfC5K8xgZgOjrmTxhelnWvfGOkjjkPToe85CSw7Lvv0+RRCiAlA0h5tPGbNO2Uu6krKwzGsEfSFxkDQXYdHi/nZ0tfHkTkbGK8+YRxADcmX1jHJO6tKgj5XRfkBOrQFT1RvoEmPzZ/stCSJQwWq/qCGu9ykQqSPOQaouvCFVBq+LmI8bxvuWgtJeaj0yMrEaPlLi5kmdbJIVLT4GlNAJUIhSVmILm68aN8l6bBW5hBdlAHlGEZt42NlNkL1rI7LzLCO0RDzXJtjiZkCzqcL6VzSPNNSE2Jmcrg7Kpl43FwipZX0LCNCbTgKxmxgvDoClVrEoCGlCdyFhjuOpgKp0RYDSW+PED1BkV2XZUFISl97RqSPIWmhVSJipp86C7ReT4JhCEsXaO6973PRi6hyBQjH3EhMfkiySRdCysByDBlmIKX8pd84XcqEcmMsRsqnSZgszJuUPmWCKINolYZJEsVohJygJkhXrBuC0OahUR6yCbPc0ZgCrj816OC+J+bVKKtxQ1/1cS/B5BxYF/2vjV0wTF1vFjgMjFdHKAeX77QJE03M4stNEqzkh77TQBg/URJAJgqRgQp4oE7eNad4RE4AK31jyhSjoqq1cQ+2EazEEdMVeeouJk+pTTmGSntOw1CGissLP6eSJ4sETlu8aX+nzBjOQ2IEOWaTy5tjrDTplCTF4SAxdRyTae4HflNF1Y+MXVEoTXZ+MDAp4lxC+z/QyPR/qV5SF32N6W5sRLXxaJjPgvOoQRWreoJvI1iYZ1QDS3lLzLMVIzjEhjG4k8gE9jhqxNFXvDvFcRvPxxyUXo7+kBh/upVZQq5yWOoLg0prQun6OFw+fbWFpd/gdx5c3+IkfNY6oelQCYUmURbzwP7tBNVuqFwWeqV4mtQO0+gZoYbvPWEuMqXbF4S5lrZjnxD74pQpQWhc9wKDawmtTzWeGc0kJjpyKZTqG23w4zVN0XfDxYBO7tpElMIoTSdkH/CZHCHmoCsqDYU+idmw5NVl/4lhmnx+ElNqiZtKi5WJ1OqK0tsV42Bl6qXySO+1NGNoy1VmCyPfJb1dM6d9zh8xm6Sc9OUYi/g5wL8b/HjNFHQsyoxRG3Bieqmjcs/ZsIJbjFQRvAVt0uYkFpr6JKRmstg4BUEOGLRBaIIJ0YdVYjgexxhgxgyH5577NKySN46eNu0eypsLz9FkYeCkOrOMNVx/mGatHSTE1Feofrj3WNUnvc+xyKZK/WLTyk0vN3fQds0N0/gKrEnS3EjTwe1P46XQ1xbcBgu/k55jupdf3vWKwcZrmkHazXMLg7R4cQOrFs7CNApuMTodYIy9ATvgDHZtdBKUFpdOpXwpxvQCYhhpKRz3J4XjvgMw85CDdi4PjVGktNC0LBsWSj8n4bEwhhpDSZ/RhUCig6YbYpatTJg2l4hlUiSmuUHrm8uja4m8tVzSZiUlrRyo6DHOM9rYtzhujcFEC1sxs8TWwHBOHtUv5zUwXl0BOb4LOU6t3mu/pyAxC5JUi1tEtV1s+ckY09fChwZKJmlfjQZBNcYaf6Ye2ZaQwR9NnxNta1CjZaPLDU5SkwPSIisxZTiM5RlNk+atjS36DNNb/mZ8t0ljL1ZSJdHMhbOmh6WWqellZ4CQZK38805aA3Mqx6hh6Y9flKvF2SgRorRpNAelhiQNXO+PPfaYe+jkp7iHHnrIPfS9dZ/41P5QmHXXNcTx7yPTNv0J4Uu6HvrX34MPPuQeevWD8elN/S7jK/F8+lCXtG/UsNuk6xODcf2YGNenuHDoDRG0hFRe2s6ETv7jYHuVKy4nkfHPK+YxcMdlSp6s9EcwgM2VbxcI9R8pvIcmweKYLS5eKq2hesXMDmZ6JMmdJc1QXq3DkrHA9bWqn9FxEzOOWo5XfKhBTT/DHJdKa5O5L9wtt9zi7r777urZX/7yxOdTnqIkdP9fnFtGCxAIH/odysMSH5XnKRGk5sDcuXPd6quv7ibI5AA/JyeHS7KnJVTjvIQBqTEwURNum4mrTb7GNAGjXuyzlS1U15naogtkW5B7oIEyKpZwVqbfQgsnFeLo4X5bpUyUEePeSzRl3cDkBDodyW0CGgzbFMQyJTBNahqxzCE+7Uk2T21w8803l0zXqkvf75ZedVM3cffvnVthM9cXrrrKuc02+9cnfu5Bn+PfJtx1VT9luusqV8zd1D3wwAPutttuK5mvNddc418S06n26v1wXDEgCyYnJ6EFi8mjMlXpfMd/18Llhk9byoN7bn2WSov/rtFkpbfruusy/Y5BZwb/e5xmDI0W7h1+5hVAoXRC6eNPazpSWGoc0DVy5GNKwzoO6HxjiRcIk422FCSk/eijjxZXX311cfvtt4thLrqoKIrbL2o+48J5kPAaIB6XXkwaIkJp3B5HZ1TWt99e1u2jC5Zu9DPnptbvycmiDwyqxkXAnYRFWhClHmmjBs0p9cmtNqTlUtQpEtqqqUQaJXozS9As0pU+IRmMh/oujaOl7cNqKj1OWhWyybKkQd9L5QpJ00LllFSYmkRQKnOb/pBLImdRx3J5doVceYBd0o033ujWXXddt9RSS5XPLr7Yua22cv3hjoudW2mr7uP0jAcffND9+c9/duutt55bcsklRyrxGozrpyHwJIONRtmFgHjNxwafGNQAVJ1ElIu+G3kyHqKpoSulWywLR4cxTuO9dKUQUntQj9ua6gmHoYsBNfClcSS6cV31dccZ7R/cIhZqG668ofhSmrRf+mc4HVzfkl0bRxPXVhw9OE0fh0uH/tF0pPFlGZPcOyss+YaYlVyMS840aVpcOXLkY5mLNJVyWp7/SqRXpguAGShgqEaBO/LnS227Rmn2MTBeHSI4AMl1GbXwylUa1snT7LIgp88xeucgYY4ozVL56OIayrO2IDJXiYj1IyAmvDTZV+WcOoWlLoAhmjlmFn22mew1pge/94txiAENLYLS85gycPXJSVIoTRy9/r1EO2V+KCPGbX406RlXfhqX/tEwXBk4hCRBUniJ0TSPIcs1acbTshykOrSgEc5ynZl06rHN3JkSV2JIYhiVQBo///nPSybl7hvONUux3vTuj7lXvvKV7DuQ2Gm/cd6Q72mnndbM11K+mLqhdX9Sz468elFoLko2Xl5HjPT7sbWshu/KhioVpX5cplkrixhvKk36LEQH+2mBNW1jW2YJY7QR0+renF9EXVnzawMpD2u+PhxOh6apfZf+YumQ0pRotcTpov6Txuh0x5jaXz744IOlHRJ8cnZMe++9d7nOvP3tb2/Efde73lW+gzBtcO6555bp3HXXXWo4TNvdd99dC2+2v7q9HhDy/f73v1/0Ubfq+t0xBolXV0CSntqOKdZfDN055lI5Wf2LhdKY98S9bpr0SoImpWs8D5WRSvZi6sSadkY/RsEwIXUuSqd1fga/Z5rkyII20iz8XFNjaulwUiyLjRb+k1SbHqHfVCqHw9FPSm/b+tfGeE2qiuaDKk/homQfplZOJH3V1OlmSV1Laa6I1Euac/gwjJhzt1rv4obUZu2113YnnHBCabOEbcMWLFjg1llnnWCalcTpjovr0if6+85Ly9/4D9OCVaBgH/XHP85l36k0rLRVUyJ17x/1yLHSPf83RhgYr9xAIsuGTRH+AwiDj7VFijgqbYKgDoxC5F2E0TA4R2ydx4jRZRksdmRWNRTHbGh2a1L6MaoxLR1KD/4LqUIxE6Op8Sg9oXTxb041Jz3nGDJO5dcKgt82aY6qMX+KLWVDNYs2TZy6VvpNwaXH0Z8DbDqpV4FZ5sSYOXelrZ5gem78Fyez5ZZburXXXNmdeuqp1TP4DkzXFltsUYu+cOFC9973vtetuuqqpUH59ttv74rioiptYJB+/OMfu6c97WluqSc/3x1wwItLA/QSK25Rvsd/Ph7Fm970JvfJT76yeveiF72ozPfAAw90K664Yuk/62Mf+1iNAfrDH/7gXvCCF7gl19rebbLJJu7ss89+4sWTNqjC3HTTTW633XYr3UBAOrvuuqv7870rl++uvfZat/TSS5cMp8dJJ51UHkq4+uqr/0Wr/0P+0EaNgfHKjSkPuKFJvPyNjLctE7wFalwLoxcBaXEOvbOmXTMuJzZQlfdqFL5NvWmSipi42m/Oboei9QLL0MbZPIUgMWJUisTlF5Ou9F5jhEILuhSXY9qoRIzrU5Yycf2dS5uWj2PAOOlcKjTmOEVSnSxxA4RspCIl714S14oBk+5JbWn3GrsxZN8h6RGVIL153/3cMcccU/3+n/852u2zzz6N+MD4nHLKKe64445zv/vd79wGG2zgdtppJ3fnnXeW74GxefWrX+1e8YpXuMsuu8y99a1vdfvv/2GXCiwxgzyXWWYZd8EFF7h3vvOz7uMf/7g7++cXlO+2fMqFbuedX+0eemh2+f4b3/iGO+igg2ppPfLIIyWtT3rSk9yvfvUr95vf/MYtu+yy7mX/9iL38MMPu/vu29i95z1HuHe9613ur3/9q/vb3/7m3vGOd7jPfOYzJSPn6cE0VU5bOVvZPtGLQnMRgKQjHjcbiZA9R0p6qfYvUryk+mrjoyvR3kMqO0d/+YzJRyw3YzuH09fyktJv8z5nH+bGROi3FM+aHg5H61F6ZikH/S61UWicaPFjYKV7nOaknPNP7vCpoG1t7e+aHRLYTYH91q677lrcdu1Pizlz5hR//vOfix/84M/FnDlLFv/85z/Ld97G67777iuWWGKJYv78+VUaDz/8cLHmmmsWn/3sZ8vfBx98cLHJJpvUbLL22usg1sZLs9vydHm8cLsti+2f+6xamOc85znFQQcdVNp1nXXWWcWsWbOKv//979X7L33pzJqN13e+851io402Kh5//PHKFmzhwoXFUkvNKeN77LLLLsXzn//8Yocddihe+uLnPhGeAdTpmWcONl6LBMohhW0kWl4ImiKNsUrTUnaybXbnUjxTGrQeqegee7SW4jBxOXsbLW6DbrSDbqi/ApeK16QPyHauRgeJRyU0WvpcOYISqPlP2NiEwln7JFZhSf1Sk3SFpEtUFUqfWSRMOFxIcs19p7RKUiJNJemfSZITSZIltRMn6ZKgSWpi1MuxsIz7GCl7ZxI7wxzO9TPpPfebA5Z6rbLyCm6XXXZxxx57rLvkkmPcy1++i1t5YkpFOIU//elPpdToec97XvVsiSWWcFs/62nummuuKX/D5zbbbFNL+9Wv3jaYP2czVd5w5J8v8ST3zC23q71fY401Su/xPl+wVVtzzTWdx9571/O9/PLL3R//+MdS4rXsU15USrtA3fjQQw+XZfM4+uij3RVXXFFK9I6df2rlNoI7PQkSr403diPHoGrsCnhw4gW3he8QbrHFaEw8yM0CF1ZaVMrnylFvlfnrS2xr8eHFMWMoDgVVPeHPENPE5SEt6hrNeLGVFktpsTEtKLH9zxjeuphxjKbESHFlw+o/TnWrMVMhWinDQ8PSZxIjmKLi5VSPlIHDYUILt8ag0PeUQdXSruXtNxk9qmpSN44xGwMRKQd32kAxCAebrze/+c0l43XUUceV3zXXDyUT4tObPbcVWWVaTF5z5z5Bl2d47rxziX+FL+t2wj3++ONV3IULBdcSU7jvvvvcs5/97FIFiv+uv/56N2/evBqDdv/995d/N19zTo1RpOmDjde117qRY2C8uoJ0QXOfE48yQUgLU/XcGLcxUdH7zhJgWaQ4moL5oudS2aXwHA1WCaREr2VRDuUjLfyhdGNgZaq0uqDMfCh9jgHQJF34vcS0BqV7hLm1SnYkRqjGLE7ZJHIMIpc3TVN6ptHEQZL8SeVQ0TcjIsBCM5WI0jGlMcq1sEa/ZBZwedSkMQojBUzFy172stLWaWLiCVsoALpX2z31qU91s2fPLm2jytORK21VSsAuuuii0gYKmJKnP/3p7sILL6wxeeeff34tr8ZpRn/SkuLhu5+wR5t6v9pq/6KV4ulPf7q77bab3Fpr3SzmC4cIwAAfDgZssMLdpX2a/4NTlEAP2KqBYf9//dd/uTftvovbY79P1U57iqcrW9gW5sDAePUI6gm98T5SjZgVluPmxndVORInZDY/hWlSGU5J8miBgfm0LujB91PH5rFEg/uLST+GYdKeSQwNl59Ki1VqqDDGVOpH64vG5RZXq+rOIkGhn5Q2WnZJWqnRIpWDixOaPyTGQspHej+yeaolpDFFpZcNphcYZ3J5dwPSFWQKLZSuGGnM4osvXqrs4AQffPdSJw8wbH/nO9/pDjjgAPeTi24vw+27777lhdFvectbSqYEjNGBuTng8BPdddddV54QBCkaRuM0I8cQLry9fnXQI/eqkrsdd9yxPEm59957lxKrX51xlPuvgz5QC7PHy57uVl555fIk46+ufrC8Sgmcu+6++3vdj370tzIfoB9Ulh/5yEfcFz7xAffYY4+5D717L7HOKuN6qoXq2YHqwHiNEagYPyeCUpGMu9bonbMFPbi8SEWuhSi13mLzDqmhrBIRjRnQaLMyPhLtIcaEpkGlV5qkUcpXaxtLvlwYTqKHGQJcJkndxzHqWjlwGtpzTF9I8pYCiXmMjZcV0glHxQWE2od6mHvgXkHtbsHDDz/cveY1r3F77rlnKUECm6mzzjrLrbDCCuV7cEFxyjGHl97iN9988/J04af/c99GOqAmpAxZDXNWfkKFyTFl/tnDU+K4Oy52iy22mPv+979fSqe23npr99b9j3Cf+swXa9GWXnt798tf/rKkEU5egpQMGMbllnvIPf/5y7lvf/vbpSuM73znO27WrFlumXWe77773e+6o75zujvzzDNtFdjGj2UbyOcUBsQgyfOtdpoOvxuRl+WqdwS807NxDOHUsEqeUb1Wq8cW9SrRheusbXpRMOZnbUdrWrkgpYXppd/xMymcFIamEVsmLj8aV6LHEqcvcHXXd/59pxcMw8wZZRwyxrLMTwTaqUar9/dc4f0pxhtuuKE8gXj99dfrafq/XDTdLqQlpY3zj/Vcf5Tr1XP9BPzrn92beWjcbo7vLBwHxNKTSr8hXkiNkztehZZtQqUPNXpI2q1pNdKTmgcnSdGep+SrSXVC4a2qPi6MVjYvSaKSO04FKKWN08CfGJKUzZqn9F5KC+ep0U3TCsXDN2ZUYYRxROsiVAcSXcl9T7vdA4UBkw9LHzTlaaTPmgZ4oAeV2nrrrVc6PB0HHHnkkaWaEj6nAy6+mLft0uq2sX53jEHV2BUMC3yMekaLaxK9d3SaDdOD42nlMk1ijPi3xuRYQW28lMvHLWlTtUstbSFcbvi21xaPkEqGqotw22jMjA+j0UbDaXRY0/VhQ3RqaVFGgPuuqTCp+o3+lmiS6lmqqxCTpJXXEo/KADl6KiBP9rVnARq8Cx3ugvgQXaY5INUj/JSblqpdkW1llX7MJdkx9E0hde7JBXzSr3EdEBN2m232CzNd9LqhQNguLwQPXVfEomcbr0HilQmxHHPM7p6Lk4Ku8pEWCnUn3SK/mYw+JWUpeVmkRW0kBjH5AqR+R8Notltt6AkxRpJExzL+27RTX+iKthx9k74DjGs9alKZUoIzdSrRhDs6ChubjpD2xVQi5RmpHHQIgDw322yQeM14WCQOPlyJDLspLU+6UFhoC6aruAegO3ANdLcvwSTZsxwkaJF2KF4oD02iAhClTQm7YUkq2mYxl9Rf9H1DihCJUHv4PmaRGofUdLiOJGkh104S00XLbu2PoTxC48MaxkILl6bW3jlostQbTcvUz4g/w9SxTumg37X+owKNbc65Z8mkWJgSgYGh7iBqmApb8/OVItHSjOpDEqmV/nWXYldIkoJ1iEHV2BEkVY4YLoM9mCrS96J/btEli7p5gmWOyNfSM15yjdUrJvWRUR1oYWos73BatbphTkGF8uDCa4uMD1O7tzKEqfqxqHhiFwlaDxzzE2pL2u4h+rjfOJylXTWVFq5/i7pQoiPEnITqhOsLdBMTYh5C9SFBYvgxXanSImtcrl20MJY5oyszgEr9OAVaT1F5ePoWTDTcSZjVdxZGx1+4fbHO3HFhwDHquDEvrTCKk4wIA+PVE0Yu4iYe1aV33PsY2mthFSey0oLChdUgMg2S1/4AMyiBnVAzu+DQnkVN5pH+smLbl6sL7ruVEQkynURq12DcSJ+S0rMwc5jZ4OiWpFw4f6kOrFJAa3vESnZjGew2zFYniLzuSnWkjDeHxkW4UX9TNqOx80wMopgdKrHCv7kLt5EUi37ifCtVZyi/WDrvSIyP6IpiTAH3/4WfIwcbrxlq45XplGNI3eGf47Cc5I3u8v07LS4N06YMKWnkyDuUrqSS0xZcjrbctFoW7K7qpyuE6OXq1CO2nF3125B0GPefUFmlNHLRquWrSRRbwzr3ZTx5rc1tUdBoyn1yfcGEe+jVD3Z7qtFg0yWdCrSmY4qfCoM9mHaq8ec/v9G94x3ruT9/eqla2w2nGmcI2N0RB+VORA5U2kAlECG1iUnSZFG5CDtFSTrBphGJ3EyFtOhwkouGpIeoU6nqIURrqK2xJAefDqNhqMSHph1SJbaxd5GkOVyenE2MtNh7SH1X2nBo9Pk4MX8SPdp7SVrM9QdNpYjz0epSgrX/aXOE2N+E3yIM7mUs4dh0BbMGC/2ciYVp3ra4rTCO62BemroxJDFKlChxTEslXZIYH3iOpGpBWu5IlHYZ7ME0pg881197xMbNvjNIvKYnOI65lRQkZjdFJgKL5EqCJhGLidugD9kxdOXfrLVUo8WOe9ylTbFtmTtfLW9OKqTVpxSOpsP1Zfw7l4SSk4pKEmUuf415ydFebNlo3+Wuw5kKozHKtXQjx0+ojX3602FsVRuvltKxNn68UjdRprq1nn704XD4qe+VJOqOTCcpI6Vrgx+vRQSNnSRMblabghgGgPivwfmKUi3DTrERl9ItxaXh6L1YuUEkPslptPB1FtxdGyHuyLk+M+WDyIIYSVEqNCmR1jahxZd75uuXY3Bo/w9J2CgTJOUrSXu4fDlGF7cB1xYNqaqhPpJB+y7p+2Ve6PAMVw7THanKfEfryyr5bFsPyfE57QR+NnUAxiQ58/USawvGSYqQtCkLuPSQYT7nBwyHq30isEzXHfpJyhCwvdq0Qi/+8RcBxFwZNHa1HnGVTpD20NU1wvsq3cC1HFL+OFz5ab2yJ0SPFrbNVU6xcZWrSzTQ+ouBFpeyCTQ8Fzf0rPW4QHXEpSXlbQkbystarpgyhsIm0Z0p75iw2ea7QL+PHRu9wNMjXV1G6H3w5Kf861qbyOt3mqy77U+EdjVPIM5vz/x/xWKLLVb8+47Pa8a5vR7/8ccfLw455JBi9dVXL5Zccslihxc8h7+eKJRvoJ7YK4Om6j/pyr8WGByoZkKKcZ6mivC/x1XEPgrapDxTVKt906/RPi4qFWv+lnaITZMLb6kbLoxFvUnj47CaGlDrZyF1pkS35XkqYttEq7uYehXzY67W8unFlN3Sr6Sy4zxi+rwUz6JiltqAvlt33YfcmWfKqkZOteYlTs95jkuCtS25E48SbW9961vdsssu6/7f//t/7rrrrnNrrrmmGOeccz7jDjvsMHfccceV5T7kkEPclVdeWV5TlPOAgVc17rzzeu7Pf66nOzFxj3NuuDJoWiNW/aP9HrVPkpD4P1WllgKpPujz2m9BnN83g9OgiRjNNxanjpDDnkgLJzEqVkjjwdr2uB7pwojVQLHqSS49nCdHk8SU4bJpqk0aj5ZD+87lSenj8tPqWyuPGYzrmlgmTqv/EF2NOXa+oK5nDs9I7e/f43e0D3HtX7MNm0LNjxejPuOYHnD1kPsUIadOrLmiUHDfffe5E0880b3zne90u+yyizv22GPFsM9+duH+53/+x33kIx9xu+66q3vmM5/pvv3tb7t//OMf7rTTTlPpinmHQX2lASYnXa8Y/Hh1ADqYKCwTbc2GAN0vSCfaEox9hjYJc5O6WpbA+5gdYw0ag5HIfHhHsY07Gq00tcy/lnaoDyinINl2DrzTyuPjaItHKJ0Qk52yiGrPOEbJmr+0gcFKFi5fC8OlxafMCV18aVmqtEhf0BgfWk7uu5YORa3sjFNgSkNsO0dvcpRxw+UvtZUm1cNzJxvOzxmCT7wQo07z59aE6n1bu9cMhuqUaanssbzvL8aPlxTnpJNOchtvvLHbaKON3Bvf+EZ39NFHgz6PzffG353ubrnlFrfGGjtWz0BztMkm27jzziWM1x1PMJgSgyWephxD+6+B8eoB4uLILLyNhQMZztNJR5MCaFIgPwkkSVhCYSWjfc8QYWgTjvZOM/JXJkwalq2/FkfFMcq0GZWKT7t6z+Uz9R63M13EQwwGS48AKjGRNg6xC64FkgQK58eVV2NquI0HjYs/cRo0bVrnmrRFo42Wp5EGcwuExgBr7zVo9UL7bN+o6iZy7HPtzTG6XUJjgCsY6/Yvf/mXt3jq2JR+zwWWacEMnWQsD8CMzUpbuS996f+VDBfgZS97mbvjjkn3i1/8gs33loWrlp8veclqtbQ22GA1d8vdpL6maIiS7lmvI+rZncTAeHUFyylD40C0ThzShMq+TzxpCCd3VEiMD3eqR6ItdqGJYeBCZc208ITaIha5mR5ul671zRh1jrUtQ9ITi3RLYmo4JkhjOCg9HJOF49A8U9oG5xsqo8QsSpAYjhqtEX7nQulqDGn0pk2DMJ41KSFluLX2bdCTKvnWvOYrdervarzqqnoYzGxgaVTnMOQDDKIH2HNdffWF7g1veEP5e9asWW6PPV5f2nqZ0l4pwCTlKjdth9361TUOjFdHyLnLYqVFCXmHJtccqscaOHcIgkTJIq3JJprvAWo9kXqp6t1wxyVFaIGTpDpaepJUhKorJVq49zSuJpH14S1SOqlMIYaGYyQ5NSB+T8siSdjoYi+lI5Wbq/uQZDMUhy1DaBPFoEo3cH1PksRHc1YaoMkyb1KGU5V4e3qw/8EYSGXVVJdTdzWCk8/NNgvYVHV8qXTDUSpz/ZAHphEYrEcffbQ0pgemC/6+/vWvu1NOOaU8eFbDSlu51Vdfvfx666231l7Bb/+OxkkqC2XYRryGDIxXR5DUNdE2ThH+paRFzQRi26GJ6E07RYqQCtCQR6zaILeKIUbqo4JIGytGANWRVU0iLXCaxEOLq0lwLIxQnxI7n6+26EvhrJIrTWIiSdlofI0hxelyNEvltj6XkCppTF64pE2Ytjnz+YSkR1PpNMZMgPkpw1FaJEYrVF5ms0PHYEhSCIwwSLxKVeNdROQlMRC5JV+SZ/qA2hEADBcYxn/+8593l112WfV3+eWXl4zY8ccf38hnvfXWcyuttLo79thzKhUqeAi44IIL3LbbbtukKwVY3ejvahyxqnHMnJ5MX6h+QMbNt0zP0HpZqAf20UP9MtRV2loeePluhcg+1le9cnlJeeN6oN/b5B963jYfmpb2h8NY6LTQZKkrLv9Q+hzdKua7ZrromRSHo1HKj3tvLUco3WA5GR+Dject53rW1xTCRRel9z2tT8b4C5Pw/e9/v5g9e3Zx7rl3N94deOCBxVZbbcXGO/zww4u5c+cWp59+enHFFVcUL3zhrsWaa65XPPi3XyfRIdVRo25RW/Xtx2uQePUBf+1GbnuBcUVADWF9V5NSKLYR6g7dqKowSwwC3vu5tPEnjcPdwZjU3gYJhGQILoXRVJ+WurdKYDkVHSdJijEqD6kaJTotUsaQnRMtgyRN49KhbWTplyGpGxdGCs+pTENpcxKmKiw5KNIAiYPDcXEa74mkKWjXpti+BvsrOSyDy8iFaTt3c0b0nV0+zUGSMgnPQc244wue4170ouUbYV7zmte4iy++2F1xxRVu3XXXdR/72MeqdwceeKB7z3ve4972tre55zxnKzdr1n3u3HN/4pZcck4S2TF1VPWX4a7G6Ym+bzefieAWy5Capi+EbI5iw3UNCx0ptKaWz2IbhpkfC0NO7bysdGl2V23KZu2rlFaOIZbCxqTbJWLLnDPfzvLLcY9s4FR0qI3G4q5G5p5FMwLhH3jgAbfSSiu5M888073oRS+qha8ctILrilhbLiFf7NSVq1vfHn2v34PEa5yQw3dUHwjdIZiYprTD7WVSN5Qj++GDBLs1KyQGlobh7FBYqRfDsIRsAKmhuiQls0pWaNl8HI0uKT9OymaJL72TGAJLGFou6VnIRiiGQWtzCg/n1dv4dMb82pxEzGFwLbmImULbupJcSWR1MWGw5wrFleg599xz3Ute8pInmC6SfnWYIMWAnjsEoEm/ctzv2wLDlUGZMFMlXqOU4FikJDlpG1VZOQlMl3SkSro0ZgDTb5HaxJYzV/hQOSQGjXvHxYtpR6kdUpipUQAz1F3311C/s9LV1fjipJgabV1IvJIQK9HSri+ypHXHxaX7iWipVgs6LXU7SLwGmGCRONSAvN+LYRiEFobGjh7vOK27T+xSweJGA6RjnG2UENaEQDitvmgdxEqxKNNikVa1gSTh0fKR7JRi7XJ8fiHJBa1DHJ7rf/RPy5fLg5ZBkr5JdFDaLbSGFmaLalaDJVybvmWVUIbykcaLJJXEedJxF6KrlYQu4FFf+80958pcnWqMBTnxaJaAacyMT0+w6WowXUpYnN9WnFRrKl5JN0qrKkfX7jN6xiDxygSNY267y7LuKGN3njHh+9jVagsNt4Ot1Sswb3ug6z+m7DVMdc/ZdtCj5ZonfOYdm2+MDQkK27kkjrm4OEc/ykF3KA1Lv7H2I0kVKaVLGUPutyYJ1OjS4sbQpm2c2kgP2bqdT8agEHYU8xeOA0jpl5oUNbWPjlzixUC7iFtS3/k4oYu0R4mH0CXZf/nLkrU2GSReMwVeijNlu1RjCPAnQkitEYKmGmmTbmxYFcZyc5IBvBBhqQnnDBJ+a5KPGjjfPcpJpZoUYypfSeXE5tPi5oMYmPtChDNbDpbdfSqq9hVsreh7Kr2TmKGQ5MkiGaFSQO43Dqulw4WXFnqNNkqLRrcVmsSp9lu49zBm/pJQtaPmbd/ggLiNxEuKK9IhvedobGkrm9PGCzNNlOGq3ZWIpFs+juki7TviTkvmLjc4qe10I2vAYFzfFfB9fOR59ckN0JYDsJcOZbjuR1z0DZfO4meWRZ0LK8WX0izpjXRUi79TppCGUyFNwiHnkhF0TidwjBSASoBCassaYy54peckVRIdOD9Nzaj9heJQ+qkqjWMopfRoOOm7lEbM865RtT3aUDWYsQgnzZ2WwzKPxF5lFmAyzBImrNIzADNUjbwEdWHMFUM1GNWJFunbuGNgvLpCyr1j0rNxA2Ea2+xyU9BF2rnS5JiA4CTPTcJE1Rjr+T8VlFaRduFaoui8iO0hZZo1aQtlrCRpExeH0o7TouBokRg6mjeNxzFS2nsuLZw/B60eaH1IDCFXR2y8yNOQXJoxYOtA8p2lSb4ir2Fj09fyCNxKQutOrA9GqiTCwvjgi6ZDkifmPTA1/i+Vhq1aqiHF+FN2bqXhPoJEq9p/O8bAeHWFXP5gpr5bFsDOQVRxrXaNzIKbE2y6mcX7VsRKvvBiItqHdER7SKVU1atBFRqSsGCJsLTQh/Lw72JVeVyeHAOlMSiclNWH1eJy6ceWiStPCBxzx9FpUZtXz5RrebSxnXOjw+Wt0obeNRhI44a5MQ4irxii2hCtPmoG5wwjkWyADuGxATv33mMqf2Bqyj8uK4MEjDJuF3fhBoPQITFqrEaqJwzG9ZmQ3TgvhzO/nHkZwohMQig+NYyPgU83or5UOmPzNRhOA6r3mds1pSzRcRSao9WqiTTG0GxtDxyOfvdhaDz8nKMRI6TGpGnRMBrtlrK2hUSTpG4N0Z67PbnnXfVHDTnboJVxfUv/ZdhA3jMrrLG84GCVM8pvhJ/CxVLYDjG4k1gUoEisuB1wY3eYYXE2S5OEU3m1+G3pCew+pYnVrKaLoC91kqzRQ3eriqPJWn6ZmekQgxErPWIROLUZs4BawUmnQvZKVD0n2Udxki5JZYnzlyRcoTBaelqZKVLitIHUtliCKJVPiqOCSp0CTi5Z2qxuZjIiJT+p/1ZgLsnu2napYc8FajtqLO+ZKOYybVF9yUjitkJ5iLBeCB5Sb+a+SDwDBlVjVyCn4vDC4ScqbaLPgVqakbuh2AWVLnLcd8yASvYx+B1HgxavT/uSBrqQTlqN65lnknrNo62KV2KUtfQt/UlSd9H4khQGp4GlWvgvNO4wDVL/tH5a+zuXr2njYYUwJrhNoAVt6OKY4/K7P5lMNlMhhruWtk9D8SGI56JQOYIbZA4G2y2uL9f64gqbNeL0JiFimKqQOo/GueWWW8r7F9dff303Z84ct/baa7vnP/8V7pxzzqmiXHrppe717/qcW2ONNdycObPdGms8xb385S93P/zhD+H26qY3+qnf8O6jH/1oGW+ppZZ0O77+w+4Pf/iDXJ4x9AE2MF49gKo3oqUFCYxEFxI0CXRhozti/x2rE6ltCSclCOXnvzfAnBil8duI50MTcLbFkjDvnNuMRjgFmtQnN0KMmRbPMi64suD0tf5BGTAfV5MmSd8tDCK34eLojZEgSXmLEPpISIonzS1tNoqWeqXh6Rwq0Vo9m7q6hxurfi6S0tBoNZU7gysYDGrM3pnkizJcnKTIIKH6wQ/+7J797Ge7n539I/e5z33OXXnlle4nP/mJ22qrF7v99tuvDHP66ae75z73ue6+++5zxx13nLvmtye5n/3sJ+5Vr3qV+8hHPlKa7EiM02c/+1n35S9/2X3jG99wF1xwoVtmmWXcTjvtVKoSx1G6xWGw8VpUrgwK2Ral2B552yw4IUSNTDHzk+OgQYwRKxfeaAcWXFQ6sNFSFxdUtyVtuK4D6UoMCS0j99uH5X5bysKla6EXf2KapbJx+WNITFJoAefSCJVHq0epPCl11Bah9mybT046U9MJ9RFuHKTkHUtjqO6pHVKULVTOOyojruihNP77v/+7u+KKK9x1111XMkUYd999t7vyyiXcq171FPeCF7zAnXrqqWxeINWaYAY0PF9zzTXd/vvv7z70oQ+Vz2DNXW211dyxxx7rdt99d5HOWt2eulRtjZjYAxi94ZLsRQox4u5khBbrgJRIilNOINTZKFYVpDIpmjNT/CfQFfUcITiJGpker86ogVEXYpuUakdNne5aaRPCcpJILV1OCsIxcRic6o4yHBZ6LRIGiVGSpEasxGMiLEHTpEGSKlB6RuHDUQmYVr9aejGwSJTbpp/idy7a5YNyNZkmPav1NU4tODX+GnlJKv2IstbqPhRvysbKfx8plPyxbdedd95ZSrdAskWZLsDcuXPd7bf/1N1xxx3uwAMPfOIhw+A1mK6p9IFxAjXmjjvuWDF9IPDYZptt3HnnnWcvD1lTJo9a3vWJQdVIcOSRR7p111233G1AY1544YXta5kOWuMkYX3fmq5YyZTx/sWsiLxzsVoYQaWQU80amCzZHa2vY+4ggFUK6cuFHEhyhzYoLdyiblJNM+nQtDCDKTFZVpUmpY1jckII2dNQyZXGVGlSMBxfkpxx5gTa9xDDxTHOUr3EMmYWZo8+D+abw++cJM3m8ohQt0t51NSUHC2hDV1qWaV4ghF7L8yV4bJrTvX5xz/+sZRKzZq1cS04DnP99deXnxtttFH17KKLLnLLLrts9XfGGWfU80O2YwCQcAE8Ywq//bsk7IZUmz1gYLwQTjzxRPfBD37QHXrooe53v/ud23zzzUvd8W233RZfs3SCwHfhMXY6dOHhFkluAeQg7cYb76eYkppBqqVMKZ6ZQxBUiFUZiN8dsXzIL1T5B7vmFCZQYqyoATABK2Xx7a95pOfyZBi0GkNAToNKkiuO0cA0aowGZTK4P8lehiKFmaLloPThdClDwo0dSgenRvR5STRKKiytPDhNqQwW6R59x/U3TX0mpcOFs0iNLLRmkdhnQmebWAna3KNpGfypRisDlEMipvnhou/oacYpJrE0infObbDaH2vBQ+rSZz7zme4737nMXXbZZe7+++93jz76qMuCUUsKBQyMF8IXvvAFt++++7p99tnHbbLJJqXx3tJLL+2OPvroqEotJxqF8dAmLekz9I6mhRcrTtXC/mZOEdV+t5QccYsOq5ILiPapKqkRDyNV3SkxVlPqD03SVNEmXQsiSbx8/XMG9CR9C6oFlKhspH4kMTMhRj+khpTiSH1bkqZQ6ZLGGHFSIU3FxuVLGVeaHlYXSmlS+mmZQ1LI0CaKy8saxo89rtzWfEsENjYN1VoLhMYGnTdE+hM97qu0CRtBVUKIJdo4b3yqUWMepFOGsTC6gfDe4dk4K23lNtxww1JNeO3fBcbpjovLMACwAfNpwMnHV71qA7fBBhuo9K0+5wkhyK233lp7Db9XX311liYRysnXrjEwXlN4+OGH3SWXXFLpjsvKWWyx8neU7hjp/dmBSBraouLBv2MWXW6yl5436Fd+S/lVUHxa0TJVDArHpAj+vYK7SA1tBxoneQrY/L6aad0AABXfSURBVFBYF9G2kgJVdSKE5+gPMfqN/CKhbQw45ob2YU0qHKOe0yRh3Lih4RuSQEaiSBktythJTLDGkHLPLH3Hjz2pbqQ5orHpsG5sMqn8pbKV9IMqHqnjRemkxMBJ1w8ZECUh9HZkjBbhL39x7qqr6h7pO79/0Mq4QTjC7GHaVlxxxVJLBCY7ILmiuHvxDdxLX/rSMtxnPvOZ8t5Gkxf7qbzW23LXksHCbingYNsFF1zgtt122zgGtI0NcksMjNcUbr/9dvfYY49VumMPSXe8cOHCssHxXw2EabBIjUTJCfpthaYOiEknaccdkPZZJnSafw2Rg6UWv8VA0yQ+UrmkNlDrM+A4koaLoTWEWKbbmk9IDSeF58aAJjmSmB+aF5VaSTRihsjCENLvEkPHxaHpcv2JG48hhsnSRhpTyUn4NMaGo8ssPYugkaarjcPYObCiG9tU5oQi/X7KU5zbbDP7acY+L4Xm7mmkdALTBWvp1ltv7U455ZTSx9Y111xTuoAA5mjZZZd1//u//+vOOONH7tBDd3F33HGWu+GGG9wf/nCFe+97P1umccMNi7N5gjTt/e9/v/vkJz/pfvCDH5SuKvbaa6/ypOMrX/nK6PJ00rYGzBpNttMfhx12mPvv//5vc3iLdClVYtAl+qRJYlK6SHeU6QTTyiBB6KvdrPnE0pMrfKhPpdZT23QlKWKIYbA8yx1GkvDFpNnVOO6qn1ulvH1BY8L6vHrHkhc4TQUb6U996lOl24ebb77ZrbLKKqVvr69//etlGPDXdd55vy2lXsA4wWlIOJ241VZbuRNOOMHtttvLq/Re+9p13Zve9Ca31VYfK3/DaUiQpr3tbW8r3VNsv/325UnK6CuWRti+gx8vpGoEe67vfe97Nc557733LhsXHL5RiRf8eYDEC7zzjq0frwEDBgwYMNYY5V2N44gHHnjArbTSSu7MM890L3rRi1qlNdzVOIaYPXt2yZFj3fHjjz9e/i51xwRgDAgMFv4bMGDAgAEDBuTBueee617ykpe0ZrrGDYOqEQFcSYCEC8SdoJ/+n//5n1KkCaccBwwYMGDAgLHFGEuuUrHLLrv8//buAziK6o8D+AtJCCAltEBAehNpAelVht5Rhi4ISpUIDIjAKFXpCDoMMOoIqCAISBuMMoD0DtJ7bwKhC0ML8P7z/fm/nd3LJVySy2Xv8v3MHORu3+3tu7flt6+dwsPfMPAyad++vbp586b8ACc61EdEREjbsXOHeyIiIqLEYODlJDIyUh5EREREnsbpJIiIiIi8hIEXERGRjTh+eof88ztl4EVERGQDwcHBxjQK5FmO79TxHack9vEiIiKygcDAQBUaGqqio//7TULMLYnZ2ilpNV0IuvCd4rvFd5zSGHgRERHZhPzYs1JG8EWegaDL8d2mNAZeRERENoEarvDwcBUWFqZiYmJSenP8QnBwsC1quhwYeBEREdkMAgU7BQvkOexcT0REROQlDLyIiIiIvISBFxEREZGXsI+Xhydn+/fffz21SiIiIkpmjuu2tyZZZeDlIbdv35b/8+XL56lVEhERkRev41myZEn2z2Hg5SHZsmWT/y9duuSVgrPTnQKCzcuXL6vMmTOr1IL5ZnmnBtzPuZ+nBvfv31f58+c3ruPJjYGXh6RJ8193OQRdqSkAcUCeme/Ug+WdurC8U5fUWt5p/n8dT/bP8cqnEBEREREDLyIiIiJvYY2Xh4SEhKhRo0bJ/6kJ883yTg24n3M/Tw24n4d45XsO0N4aP0lERESUyrHGi4iIiMhLGHgREREReQkDLyIiIiIvYeD1CuPGjVPVq1dXGTJkUKGhoS7TYNLUZs2aSZqwsDA1ZMgQ9fz5c0uajRs3qgoVKkjnxaJFi6p58+bFWs/MmTNVwYIFVbp06VSVKlXU7t27lV1g+wMCAlw+9uzZI2kuXLjgcvnOnTst61qyZIl64403JJ9lypRRUVFRys5QJs55mjhxoiXNoUOHVK1atSRPmFB28uTJsdbjS/lGWX744YeqUKFCKn369KpIkSIyeOTZs2eWNP5Y3q7Y+dhMqAkTJqhKlSqpTJkyyfmqdevW6uTJk5Y0b7/9dqxy7dOnT4LPe3YyevToWHnCfunw5MkT1a9fP5U9e3aVMWNG1aZNG3Xjxg2fznNc5y88kFd/KuvNmzerFi1aqDx58kgeVqxYYVmO7uwjR45U4eHhck6rX7++On36tCXNnTt3VOfOnWUOM1zvcQ58+PBhgs/1r4TO9RS3kSNH6mnTpulBgwbpLFmyxFr+/PlzXbp0aV2/fn29f/9+HRUVpXPkyKGHDx9upDl37pzOkCGDrOPYsWN6xowZOjAwUP/5559GmkWLFum0adPqOXPm6KNHj+qePXvq0NBQfePGDVsUz9OnT/W1a9csjx49euhChQrply9fSprz589joIZet26dJd2zZ8+M9Wzbtk3yPnnyZPkuPv/8cx0cHKwPHz6s7apAgQJ67Nixljw9fPjQWH7//n2dK1cu3blzZ33kyBG9cOFCnT59ev3tt9/6bL7/+OMP3a1bN71mzRp99uxZvXLlSh0WFqYHDx5spPHX8nZm92MzoRo1aqTnzp0r++qBAwd006ZNdf78+S37dJ06dSSf5nLFfp6Q857djBo1SpcqVcqSp5s3bxrL+/Tpo/Ply6fXr1+v9+7dq6tWraqrV6/u03mG6OhoS57Xrl0rx+2GDRv8qqyjoqL0Z599ppctWyb5W758uWX5xIkT5Rq+YsUKffDgQd2yZUu5fj1+/NhI07hxY12uXDm9c+dOvWXLFl20aFHdsWPHBJ3r3cHAy004UbkKvFDYadKk0devXzdemz17ts6cObMEK/Dpp5/KAW/Wvn17OQE6VK5cWffr1894/uLFC50nTx49YcIEbUe4uObMmVMCEucLMQ7OuLRr1043a9bM8lqVKlV07969tZ0Dr+nTp8e5fNasWTpr1qxGecPQoUN1iRIlfDrfzhA84UTl7+XtzNeOzcRcmFGOmzZtMl7DxXjAgAFxvsed854dAy9cVF25d++e3BAsWbLEeO348ePyvezYscNn8+wKyrVIkSLGDbM/lrVyCryQ19y5c+spU6ZYyjwkJESCJ8CNId63Z88eyw1oQECAvnr1qtvnenewqTGJduzYIc0nuXLlMl5r1KiR/MbZ0aNHjTSo1jRDGrwOaL7Zt2+fJQ1+ugDPHWnsZtWqVfKDot27d4+1rGXLllIdXbNmTUln9qrvwq7QtIgmiPLly6spU6ZYqtmx7bVr11Zp06a15AnNN3fv3vXpfDv/npmr3zLzx/J28MVjMzHlCs5lu2DBApUjRw5VunRpNXz4cPXo0aMEnffsCE1LaIoqXLiwNCmhCQ1QxjExMZZyRjMkfr/PUc6+mmfn/Xn+/Pnqgw8+kOY4fy5rs/Pnz6vr169byhc/74duA+byRfNixYoVjTRIj+N9165dbp/r3cHfakwiFKZ5hwTHcyyLLw123MePH0uBvXjxwmWaEydOKDv64YcfZId7/fXXjdfQL+Krr75SNWrUkJ31t99+k/4jaGvHxTm+78LxXdlR//79pX8eLkzbt2+XE9O1a9fUtGnTZDm2HX2h4toHsmbN6pP5Njtz5oyaMWOGmjp1qt+Xt9mtW7d87thMiJcvX6qBAwdKGeKi69CpUydVoEABCVLQp2Xo0KFycVm2bJnb5z27wUUWfWtLlCghx++YMWOkr86RI0dkm3Exde7Ha95XfTHPznBs3rt3T3Xr1s2vy9qZYzvjOxfhf9xAmgUFBcl535zmVed6d6TKwGvYsGFq0qRJ8aY5fvy4peOlv0rMd3HlyhW1Zs0atXjxYks63DENGjTIeI4OvP/884/UEDkuxL6Yb3OeypYtKyfo3r17SydlX/ulgsSU99WrV1Xjxo1V27ZtVc+ePX2yvMk1dLBG4LF161bL67169TL+Rm0HOiTXq1dPnT17VgZa+KImTZpYjmMEYgg4cB5DZ+vUADfM+B4QZPlzWdtdqgy8Bg8ebIn4XUFVtDty584da4STYyQMljn+dx4dg+cYOYEDPjAwUB6u0jjWYafvYu7cudLs5s7FFSe3tWvXGs/j+i6SO5+e3AeQJzQ1YlQf7p7jypM7+4Dd841Aqm7dujKy97vvvvPZ8k4sBJcpdWwmt8jISLV69WoZDWauuY6rXB01n7gYu3PeszvUbhUvXlzy1KBBA2mGQ22QudbLXM6+nueLFy+qdevWGTVZqamsc/9/O7HdCCwd8DwiIsJIEx0dbXkfzvMY6fiq87j5M9ySpB5sqcirOtebRzhhhAM6Hj558sToXI9RIWYYKeHcuT4yMtLSgTdv3ry268CLToroYG0e3RYfjHwsX768pbN18+bNLWmqVavmU52t58+fL2V+584dS4dL82g+jPhx7lzva/m+cuWKLlasmO7QoYOMbEqt5e0rx2ZCjmEMFsAAgVOnTrn1nq1bt0rHY4wGc/e8Z3cPHjyQ4/abb74xOtcvXbrUWH7ixAmXnet9Nc8YXIAO5jExMX5f1iqOzvVTp061jFB01bkeI1odMKrbVef6+M71bm1fknKXCly8eFFGbY0ZM0ZnzJhR/sYDB615qG3Dhg1laDamiMBoP1fTSQwZMkRGysycOdPldBLYCebNmyc7QK9evWTIunkkiR1g6gDsnMiHM2z7L7/8IsvwGDdunBywGIZvnl4gKChIDgCkwcnAztMLbN++XUY0omwxrQKCLpRv165djTQ4aWOIcZcuXWSIMcoS5e08nYQv5RtBF4ZS16tXT/42DzX35/J2xVeOTXf17dtXbiI3btxoKddHjx7J8jNnzshoZVyAMHIVU4kULlxY165d21iHO+c9u8HNIvKMPGG/xPQImBYBozod00lgWo2//vpL8o4bBDx8Oc/mmwXkDSPwzPyprB88eGBcn3GNwjRQ+BvXcMd0EjhukcdDhw7pVq1auZxOAjeOu3btkgAUN57m6STcOde7g4HXK7z//vtSiM4PxxwocOHCBd2kSROZzwMHMg5w57sKpI+IiJD5gLBjowbNGeb3wsGBNLjLxlwidoOd0Dy3jRkuTCVLlpQdEXdDyIN5eLbD4sWLdfHixSWfmGbj999/13a1b98+mf4AF6p06dJJ/saPHx/rTg93hzVr1pQLNGpDcJD7cr6xf7ra782V5P5Y3nHxhWPTXXGVq+OcdOnSJbnwZsuWTfZnBOC4aTTP7eTuec9OMIVPeHi4lCGOUTxH4OGAC/BHH30kNRrYp9955x3LjYYv5tlcc4MyPnnypOV1fyrrDRs2uNyvcQ131HqNGDFCAifkFTeVzt/H7du35RqHShac07p3725UsiTkXP8qAfgn8S2nREREROQuzuNFRERE5CUMvIiIiIi8hIEXERERkZcw8CIiIiLyEgZeRERERF7CwIuIiIjISxh4EREREXkJAy8iIiIiL2HgRUR+a+PGjSogIEB+/Dg+BQsWVF9//bVXtqlLly5q/PjxHv3sW7duqbCwMHXlyhUPbCERJScGXkSUorp16ybBER5p06ZVRYsWVWPHjlXPnz9P8rqrV6+url27prJkySLP582bp0JDQ2Ol27Nnj+rVq5dKbgcPHlRRUVGqf//+Hl1vjhw5VNeuXdWoUaM8ul4i8jwGXkSU4ho3biwB0unTp9XgwYPV6NGj1ZQpU5K8XgRyuXPnlqAuPjlz5lQZMmRQyW3GjBmqbdu2KmPGjB5fd/fu3dWCBQvUnTt3PL5uIvIcBl5ElOJCQkIkQCpQoIDq27evql+/vlq1apUsu3v3rtTmZM2aVYKjJk2aSIDmcPHiRdWiRQtZ/tprr6lSpUpJrZJzUyP+RnBy//59o4YNAZ6r5r5Lly6pVq1aSYCUOXNm1a5dO3Xjxg1jOd4XERGhfv75Z3kvatQ6dOigHjx4EGceX7x4oZYuXSrb6gzv69ixo2x/3rx51cyZMy3Lsa2zZ8+WvKdPn14VLlxY1mWGfOfJk0ctX748ESVARN7CwIuIbAfBxbNnz4ymyL1790ogtmPHDqW1Vk2bNlUxMTGyvF+/furp06dq8+bN6vDhw2rSpEkua5TQ7IjgCoEUatfw+OSTT2Kle/nypQRdqDnatGmTWrt2rTp37pxq3769Jd3Zs2fVihUr1OrVq+WBtBMnTowzT4cOHZKgr2LFirGWoXavXLlyav/+/WrYsGFqwIAB8rlmI0aMUG3atJHmys6dO0ugd/z4cUuaypUrqy1btrzy+yWilBOUgp9NRGSBoGr9+vVqzZo16uOPP5aaLQRc27Ztk8AJ0JyWL18+CXrQbIfaKQQkZcqUkeWoDYqr2RE1U6g9Qu1aXPD5CODOnz8vnwM//fST1CihL1ilSpWMAA19xjJlymR0msd7x40b53K9qJkLDAyUTvDOatSoIQEXFC9eXPI7ffp01aBBAyMN8tqjRw/5+4svvpDADE2Xs2bNMtKgxgvBGxHZF2u8iCjFocYItVTp0qWT5jTULqE5DzU6QUFBqkqVKkba7NmzqxIlShi1Peio/uWXX0rwgs7lqFlKCqwXAZcj6II333xTOuWba5jQxOgIuiA8PFxFR0fHud7Hjx9Lk6qr/mbVqlWL9dy5NsudNKgpfPTokVv5JKKUwcCLiFJc3bp11YEDB6SGCwHKjz/+KP2d3IFaIDQFosYJNVVoykNNUHILDg62PEdAhVqw+EYeIihyNKEmBzSPYqAAEdkXAy8iSnEIsjCNRP78+aWGy6FkyZIyrcSuXbuM127fvq1OnjwptVAOqJ3q06ePWrZsmYyK/P777+NsbkQn9/jgMy9fviwPh2PHjkkHffNnJhQ64zvW5Wznzp2xnmM7EprmyJEjqnz58oneRiJKfgy8iMi2ihUrJh3de/bsqbZu3Sody9977z0Z+YfXYeDAgdInDH2y/v77b7Vhw4ZYAYm5efDhw4fSFwuTjrpqlsOISvQXQwd2rG/37t0yqrJOnTouO8a7CzVRFSpUkHw4Q5+uyZMnq1OnTsmIxiVLlkgHezO8NmfOHEmDJlVsV2RkpLEcedm3b59q2LBhoreRiJIfAy8isrW5c+eqt956SzVv3lz6NaEDPqaLcDT1oQYLIxsRbGE+MHRON3c4N0MHfdSMoQ8ZAiEEO87QZLhy5UqZnqJ27doSiKHD/q+//prkvKBZFIMDnKGWDiM3UVuF/mrTpk1TjRo1sqQZM2aMWrRokSpbtqx09l+4cKGlBg7bjBrDWrVqJXk7iSj5BGicxYiIKNmh/xoGBiCIc+4sHx8Eg5ifq3Xr1nGmqVq1qgw06NSpk4e2loiSA2u8iIi8BKMOUVuFZk5PwvreffddmYSViOyNNV5ERDbnTo0XEfkGTqBKRGRz7BFC5D/Y1EhERETkJQy8iIiIiLyEgRcRERGRlzDwIiIiIvISBl5EREREXsLAi4iIiMhLGHgREREReQkDLyIiIiIvYeBFREREpLzjf7pTF/nldRGUAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -1202,7 +1691,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -1211,9 +1700,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This is expected to fail. Read the error message below:\n", + "\n", + "\n", + "A threshold has been applied to this .h5 single read data. plot_read_browser must be used with an .h5 file extracted using thresh=None.\n" + ] + } + ], "source": [ "try:\n", " plot_read_browser.plot_read_browser(\n", @@ -1233,9 +1733,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "WARNING: no modified appropriately-coded values found for [] in the first 100 reads. \n", + "Do you expect this file to contain these modifications? parse_bam is looking for ['A,0', 'CG,0'] but for [] found only found [].\n", + "\n", + "Consider passing only the motifs and mod codes (e.g. m,h,a) that you expect to be present in your file. \n", + "You can use modkit adjust-mods --convert [OPTIONS] to update or consolidate mod codes.\n", + "See https://github.com/nanoporetech/modkit/blob/master/book/src/advanced_usage.md\n", + " \n", + "No specified number of cores requested. 10 available on machine, allocating all.\n", + "No valid base modification threshold provided. Raw probabilities will be saved.\n" + ] + } + ], "source": [ "extract_file_no_thresh, _ = ensure_extract_output(\n", " input_file=ctcf_bam_file_updated,\n", @@ -1256,9 +1773,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from IPython.display import Image, display\n", "from plotly.io import to_image\n", @@ -1301,12 +1829,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "" ] @@ -1347,7 +1875,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -1356,13 +1884,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4c8bb6352d604b3d80565a23de728287", + "model_id": "5f78cc63164645da952774ce8cca04c9", "version_major": 2, "version_minor": 0 }, @@ -1376,7 +1904,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3ef0b8d5246e4e888e6ea435aede6099", + "model_id": "5a10462480a04f1880c70ed08823c828", "version_major": 2, "version_minor": 0 }, @@ -1393,13 +1921,13 @@ "" ] }, - "execution_count": 34, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAADvCAYAAADhLuMKAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAUFVJREFUeJztnQncDdX7wI99aUEqW4iQJQmRJVspSVIUpSRpEUqb4ie8JEuUSvi37yrKUtpDWZOE7FpspWxJdpX5f77n7Vxz573LzL33vdv7fD+fed97586dmXtm5jznWc7z5LIsy1KCIAiCEIbc4TYQBEEQBBEYgiAIgmtEwxAEQRBcIQJDEARBcIUIDEEQBMEVIjAEQRAEV4jAEARBEFwhAkMQBEFwhQgMQRAEwRUiMISE8eWXX6pcuXLp/+lO8+bN9ZLs3HzzzerMM89UqQD3TkZGRkreexkZGfr4u3btUqmECIwk4JVXXtE3T6ClX79+iT69lGDSpEnqySefTPRpCIIfw4cPV9OnT1fpQt5En4BwnKFDh6oKFSr4Nck555wjTeRSYKxatUrdc8890l5CUgmMa665Rl111VUqHRCBkUS0bt1anX/++THf74EDB9QJJ5yg4g15LQ8fPqwKFSqkkgnOKX/+/Cp3blGw0/1aC7FFnpgUYvbs2apJkya68y9atKhq166dWrt2bUDb6Jo1a1Tnzp1VsWLF1IUXXqjef/99vf7777/3bfvee+/pde3bt/fbR7Vq1VSnTp18719++WV10UUXqdNPP10VKFBAVa9eXU2cODHL+WH7vuKKK9Snn36qBR+dx7PPPqs/++WXX/Qoi3NnP/fee686cuSIq9+9b98+rTmwf47P9y+55BL13Xff6c/xDXz44Ydq8+bNPlOescMbW/Xbb7+tHn74YVWmTBlVuHBh9ddff6k//vhDPfDAA6pmzZrqxBNPVCeffLIW2itWrPA7vtnH5MmT1aOPPqrOOOMMVbBgQXXxxRerH3/8Mcv5Pvfcc+qss87Sv79+/fpq3rx5yi0cp3fv3mrKlCm6ndlHw4YN1cqVK/XntGelSpX08fndmzZtyrIPvlu3bl393VNPPVXdeOON6tdff82yHaYSNFj2xf9p06a5Ps9Q1/rPP//U16ts2bL6enG+o0aNUseOHfPbx5gxY1SjRo1U8eLF9fc553fffTfLsbhPuF9OO+00ddJJJ6krr7xS309u8XLvLV68WF122WWqSJEi+j5p1qyZWrBgQcBnbN26dapjx476vuE39OnTRwtNA9swWHv11Vd99yU+Iju0Fet4njlmt27d1MGDB1WyIhpGErF3794sTjAeePjiiy90Z1axYkV9wx46dEiNGzdONW7cWHecTkfltddeqypXrqxVYkZ/CA1u2Llz56pzzz1Xb0NHxih7/vz5vu/t3LlTPwh0WgaEQ40aNfSDmjdvXvXBBx+onj176g6gV69efsddv369uv7669Udd9yhbrvtNnX22Wfrc6Vz3bJli7r77rtV6dKl1euvv64FoBt69OihOxLOiU509+7d+pwRlnXq1FEDBgzQbUfHMHbsWP0dBICdRx55RGsVCAg6C14jVOk0aStMgdu3b9edHp0En3GedkaOHKnbi31wvMcee0zdcMMNupMxvPjii/q30xHSaf7888+63U455RTdgbqB64KAN207YsQI3Tk/+OCDasKECbrt9+zZo49/yy23+LUj/jA6nXr16unv8Zueeuop3ektW7ZMd0zw2WefqQ4dOuj2ZDvalO8hDN0S6FrT2dF+CCjWlytXTi1cuFD1799f/fbbb35+Js6LtqENjx49qoU612LmzJmqTZs2vu1uvfVW9cYbb+gBEO3K77V/Hgov9x7reMYQXIMHD9bX2gyWuCb169f32x5hwXNH+3399dfq6aef1tfltdde059zHM6d791+++16HQMJ5z6499gHz/ELL7yghRoCNimhHoaQWF5++WVqkgRcDOedd551+umnW7t37/atW7FihZU7d27rpptu8q0bPHiw/t7111+f5Tg1atSwOnbs6Htfp04d69prr9Xbr127Vq+bOnWqfs++DQcPHsyyr1atWlkVK1b0W1e+fHn93U8++cRv/ZNPPqnXT5482bfuwIEDVqVKlfT6OXPmhGyfIkWKWL169Qq5TZs2bfTxnbBvjsG5On/H4cOHrX///ddv3caNG60CBQpYQ4cOzbKPatWqWUeOHPGtf+qpp/T6lStX6vdHjx7V14hrZd/uueee09s1a9bMCgfbcXzOw/Dss8/q9SVLlrT++usv3/r+/fvr9WZbc/xzzjnHOnTokG+7mTNn6u0GDRrkW8c5lipVyvrzzz996z777DO9XaB2dBLsWj/yyCPWCSecYG3YsMFvfb9+/aw8efJYW7Zs8a1zXg/On3O/6KKLfOuWL1+uj9OzZ0+/bTt37qzXc7+Hwu29d+zYMaty5cr6vua1/RwrVKhgXXLJJVmesSuvvNLvWJyj89mhLbp27ZrlvMw+brnlFr/1V199tVW8eHErWRGTVBIxfvx49fnnn/stwMhs+fLlWnVlpGpAU8A089FHHwUclTvBnGXMI5h5ML0w8kGLMev5zyjU7my326WNFsQoktEz7+0wWmrVqpXfOs6vVKlS2vlnQN03o65wcD6M4rdt26YipWvXrlns65hLjB/j33//1aNsNBNGysbcZYcROJqJvT2BdoBvv/1W7dixQ7e9fTuuG+YGtzAitmuMF1xwgf6PRoBJxrneeXw0EMxMBkbjVatW1WY7+/1Em9jPi3sJjcMtga415jDaBVMo94lZWrZsqdsYDddgvx6MzLmX+K697c29jXZgx21wg9t7j/b44YcftBbDfWDOG5MS14PzPuYwqTm167vuusvvnN3gfE75/Rwfk2kyIiapJALVNZDTG9s80JE5wd+AHdnp2HZGW5mb8f/+7/+03f2nn37SJirs40aQYFbgP2Yuu0MYcwYq+qJFi7LYV3nI7Z1OoONy/tixOZ6dQL8nEJhe6Nww6WAuuPzyy9VNN92kzXNuCXRedACYRTDzbNy4UXdoBmzSTjCv2KFTNJ2d/TphCrSTL18+T+fqPI5pX6dJy6x3Hj9QuyIwjOkx2Hma7wYSlm7blE4XPxn+hkAg0AyYnoYNG6Y7a7tPwX6fcK7ci05Tjtt7x+29x3kD91kw9u7d67vmgdqPc+RcA/mVghHqnsI3kmyIwEhTAkWr4McARkuMSrH/I2QQGNhf9+/fr+3cOHYNCBZGWHQ4TzzxhO60GD0zisJf4Bx1ZUeUDHZezhGnLLb30aNHaxvv1KlTtc3ZDYHOC//OwIEDtR8AHwfaGw88o1fn74I8efIE3HesqxwHO068ju+WQG1Ku6Gp4G8JRJUqVfR/Bib4L5o2baoFNloAghWfASHS8cZcb+6t8847L+A2Jzr8Yk6cQskNyXZNwyECIwUoX768z8noBAc1JiU3YbOMZlh4WBEYxqTCQ3vfffdpcwKjbN4bcHAz+sMJax8NzZkzx9P5M0eCh8D+UAX6PcGgQ8HUwsIoFWGHYDMCI5KHFUd6ixYttKPaGbligg0iuU6MVnGUGv7++2+twdSqVcvzPiM5Pu1qP75ZZz63n6cTL9ckEIyyGXhgggoFEXqYzdCOMQ0aEBh2OFc6cwYudq3A7Xm6vfeMBsOoPty5G2g/u5aF5s652s2JkdyXyYz4MFIAOktGPYTn0ZkZeBAYcWOicQtCgmiQb775xicw2De2caKATHijcwRkH/Ggmjsf7FBwfvgf7CGTmLYIPw0HAszpJyGKhGgXuxkDgencLhz8NudIDqEZKATVDZgTMcVg9iPqxx65ZL9u2QXHp204vr1tPv74Yx1RZiKL7PeTvc3wmREdFq02iOkSQeCENvjnn398bU9najcDYspxzoo2AwI0YDtuZ/W7vfe45xEahPoi8JwQPRjI52iHqEWwa73cl/G49vFCNIwUAVWZGxGfQ/fu3X1htdixveTTQUi8+eab+mE1JioeXsIVeciJ7bc7bC+99FL9vm3btjpMkofp+eef1x0TzlM34Bt55plntN9h6dKlusMi5BDnYzhwzhPqidOSETpmAUKMlyxZoh5//HG/B/6dd97RmhIhpWzHOYeCUFVm1+PM5vcz14G28eJvsINJBZs87cQIn7ksaBYI10j36fX4mOr4PQQlEPJqwmoZ9TL/wEAYJwKEewCTHHNSuJ8Inw7UYbqlb9++WhulbXH2c13wr9G2dNoIBbQ3jo2JkzkPOJrRGumA8TfY5woh2PgdmK0QblynWbNmBZz/Es29hymSkFaeMdqANmTODoMHtGk0jw8++MDvO1xbzGr8BoSkCf21a5L8fu5XfiuDHDQSE6yQkiQ6TEs4Hla7ZMmSkM3xxRdfWI0bN7YKFSpknXzyyVbbtm2tNWvWBAzX27lzZ8B9rF692hciamfYsGF6/cCBA7N85/3337fOPfdcq2DBgtaZZ55pjRo1ynrppZf8QjpNqCXhrYHYvHmzDkMsXLiwdeqpp1p9+vTRIZnhwmoJT+3bt69Vq1Yt66STTtJhiryeMGGC33b79+/XoZZFixb1Cw01IbFTpkzJsm/Cau+//34dXkqb0raLFi3S4a/2ENhg++C3s57rZ4dzIxST8Njzzz/fmjt3bpZ9BoP9OUOIzXFGjx7ttz7Yeb3zzjtW7dq19fFPOeUU64YbbrB++eWXLMd677339H3AdtWrV9ch1YSAug2rDXat9+3bp0N+CV3Nnz+/vt6NGjWyxowZo0NnDS+++KIOZeX4VatW1e1o7l87hAjffffdOtyU6899v3XrVldhtV7vvWXLllnt27fXx+K8+J2Eos+aNcu3jTlHnr1rrrlG35fFihWzevfu7RfODOvWrbOaNm2q7y++Y0Jsgz2npi+wP1fJRC7+JFpoCYIgpAoZGRlqyJAh2kwVia8rlREfhiAIguAKERiCIAiCK0RgCIIgCK5IiA+DmGrC4kymVdIRkOnROZtTEARByMEaBqGbCAjmAZALiYU8QYSymdxJgiAIQvIRdw2jdu3aOmEZk8TsUIqUSWhu89gIgiAIaS4wSAfAJB5n4q4NGzZobcNegCQZYKo/M0WZCZ1u0/wFQciZWJalJ8UymdBL5cm4z/QmdQLZKZ0Cg3XMHk42EBZuC98IgiCkElu3bvVUNCvuAoOp+uSiJ/kd0/xN+mxSGpDWIdkw9Qdo2GRMNywIguAV6m0wELbXV0lKkxSHI0KKPECmIA5qETloKJKSbGYfGpZ8TeSxEYEhCEI6EGm/FpcoKZKRkeIZEAgkQaP+MidrajETVutVWJBAjURzSEnMWRR6D5T2mMRgJIMjcySNQ/pukvcJgiAIKrkExtVXX+1L8UtmVFN1i47eq0pk56uvvtJlEinATkguQonsqmTHtAsLskmynlBespz27t3bk6NHEARBiJNJqmTJkjolNumm6ahJuRyshGM0kAwMTQNBYooANWjQQFcAo6JaPFU3qmHaqlEGhVordeocf79yJYVZlCJYDIsdWbHr1aM8Z+bnW7cqtWTJ8e3z5lWK/Ge//65SFhRLMq2bWwJldPZspWxyPyyMO1q0yGwPJ7QplWUpc0GZClv2dh8Uj6PiKVmz7YXVGFfgalu27Pj5/PFH5mvq+XBMIsEpJBegqqsPSjRTc4rCbtya9m05J/ZBDSyufenSpPXObANKq1O3iu9x3WvWpCZ11n3zPe6jn36iqBalPpXavl3FHM6FKsKcD2Xgd+9WSQ/tSj2pVatISa6SijJlMu9Lt9Du5lpT8uS/8iLq4osz799sN7XHIyUuqXxz5cpl5c6dO+wSDT/88INODbxy5Ur9fvv27fr9008/bTVs2NA6/fTTdarhefPmBd0HKa/37t3rW0waZV574dJLEcTulvXrM79DBuo8ebJ+Xrp05ufHjllWmTLu95tKS8OGx9tu1KjI9vHMM1mvw4oV2Xve9esf/x+KDh2Of6dpU//PHn00cHvwv0iRzOs+Y0bm+969s+67XLnMz95917J4hLL7WvF4caxE3zNelm7dEn8OKhsX7nMv0J9F0q/ljVc64Ouuu04XPaHgCAVlihYtGvP5EtRibty4sTqHYZlSOhLLHJ9KWhRjee2113SNaqrVOUN7jV+E1MXRUqNG+BEyo1ZGvlu2ZI5QGRlSgIwRJOsNaBqMLBh5m9FIgwZUMMv8DlDlkpFfqsHvpB0YGRtM0Te0L0Zg4di0KbNdAo0eZ80K/J3GjY+/5rvsw2COSzE6RqX20TXXxrQ5fPON//9goBkafvnF/7NAtYAWLcr8zzlwTxjXHPeKE7OOInL2UuRoTXbtNVqWL8+8p/kt5hqVKpWpBScrmzdntjcaP3D9atdO9FkprVXaLQX161MAK/z3Fizwf1+1aqa26qIWWWyw4kxGRoZ14MCBmO+3R48eutgJGoFhwYIFWopSzMVOzZo1rX79+mWrhuGGOnUyRwcffZT5/o03Mt+3aJF1BEHdmV27jr//+2/Lmj79+PsqVayU5OefM8+/cOHj61q3zlz34ovu9jFgQPDR99ixgUdkdp5+2v+zp57KXD9/vv/6kSP92zzUPp2cf/7x7c480/+za68NPXo8fPj4bwxUs8hs17Kl//dq1bJiSr16mft9//3MtuY155XMDBqUeZ5nnOFOE4wXv//uf61273b3Pee9wbWIhKTWMOwMHjw45vvEiT1z5kw1d+5cv0kolGMEclfZqVatmtoSaKimR+oF/IrSZydmRPFfAJkyFU//O20/sFUajYXTw1Zv99sHssunAibmAU2DkTQlxI3vx+08zoIFM//bylj7cBN4Z75vMO3qHPGxXaSxEvaRv/01hKuIyrU3ZaGNzTrcMSDWEer/lXfX18nrNUoUpg1MAgnntU4U+fIFbluvxPu5j3uoEA7vLl266LkXefPm1VFT9sULCFyExbRp09Ts2bN1vVw71DHmOM5QW9KQlC9fXiXLTYN6Gk5g8JAagYETD9JBYNgdzOb37dzprTMy8j2QwPDy/XACg+0SITC49pimzOtQ29mJdSCgXWB4vUbJIjDiNBZMW4ERdw2DwvCM7gcOHKg1gGgm6hFSO2nSJDVjxgwdnvv7f6FCeP8LFSqk982EQLQaCrPjw3j11VfVunXrdEH6RONFw+AhNR2L6WTtHUKyPAheMdoSI+d9+zI1DjN6dRtIZ357oDRkbm6veAgMe2ceicBwo2Fkt8AwEWh2DSMbgh1zpMDIG2FPHO/fE3eBMX/+fDVv3jzdeUfLxIkT9f/mzZv7rcepjmACHOEkNGSy4B9//KEFB3M2kqH2hhkdOAVGyZI5R8PggUYA0iHScbKYhzvRGoazTWOlYTg7di8ahheTVHZqGKlmkjLtlqwCI49oGIEhf0mspn643Q+p01mSDaeGYeZS5CSTFNgFhjF1EPVhfmd2+zBSwSRlNIxQJql4+TC4X838i1QRGIZk8WHkyZOaAiPuPgzySNF5b7LHMeZQYmmSSmWBYRzfmKQiMXVEq2HEw+kdyiQVLvzarYYRLx8G18j8hlCTFZNRYCSLhuEk0muV9j6MTp06qYMHD2qTUOHChVU+x1OJ2SgnCgxSW5lOISdqGIBAZNay15FrKvgwgmkYKMnZpWFkl8AwAxuERaS293iRKgIjUtJeYKBhCFmjpMxDyCg20BT/cAIjlR8EIzDQMMyExUgERjxMUs5O2Q6fBeukgwkMhFyofZoBBW3jVcPILpOUuVeT3RyVEwRGgXR3enft2jXeh0xa7E5v47/A4R3oQQ9kkrLbPdPBJMXv27XLu0kq1j4M066BnN4mBDoQdObBrkMwk1Q47QLQLoy7Lhmc3kZgJHuEVE4QGPnTUcMg0ZVJcMXrUOSkmhN2k1Qo/0VOMklFEn0TTw0jVIcdSmAE0zDcCAx7gr9kMkmlooaRLE7vWJGWAqNYsWLqt99+05lkySEVaO4FEU+s/zfUE5FmiMDI6vSOZEJYKB9GrJ3eocqouB39RyMwkkHDMNpwKgoM0TBSQGAwC/uUU07Rr+eQ41nwLDDoKNI1SiqQhhHPKKlgGgb/WUxHHM7pbaLdYm2SsseBJIMPwwRniEkq8SS9hkGlOrQBIpxg8+bNOjUH+ZooUhSIZs2aBXyd07ELjD17gk/ay0lO70hMUqF8GG4UVmfb2TtarpHZbziBEQ8NIxlMUgbRMBJPpPM3IsXzLdWuXTudIhyoonfBBRfo+tysNzOvhcijpHKiD8Pu9I7GJJUdAsMplGMtMNwUiXKrYWS3wHCG0IrAiI5Ya4DxwPMt9d1336kmTZro1+RjKlGihNYyECJPP/10dpxjjoiSciMw0t0kFYuJe87J/6E6WOf3w3XC4SbuuTUXZZeGES+TlCEVTVLJ5PTOnYJVoj2fMpPuTB3uzz77TLVv316XXaUUKoJDcI84vf0FBoVuTKcbicAAZ9irGw0jVMdq79xjpWGYagbZ7cMQk1RyO73zxNmclBCBUalSJTV9+nS1detW9emnn/r8Fjt27MhRIbGxFBhE95iRtRsNI918GMYk9V+BRMVt5GUkaP/tTrOUGw0jFPaOngc8FgIDvAiMUFFSdo1KBEZWnNcrmZ6T3DlBwxg0aJB64IEHdK0J/BcNGzb0aRu1k6H2YQoKDEqE8uBzAwUbWdt9GOlqkjKOf6+mjlACI9oobS9+AS+jf/Peq4YRbD9ezzXaETGvixVTSU8yaxi5U1BgeI6Suuaaa9SFF16o51WQKtxAneyrr7464HcQJG7rXuAjyWkCwxT/w4kYTE3NCU7vSJ2ptANtiS8o1gLD6ROJlYZh3kerYYQSGNnpwzj11NTo8MSHkQTzMEqWLKkXO/WpYh6Eq666yvea2hQTJkzQYbhGO/n666/V6tWrVc+ePVVOwikwgpmjcorTO5roG0aOCAzn5L1oTVJOIp2HESuBkSwaRipESIFoGAkQGDi23TJ16tSQdbxvvfVWdffdd6tHHnkkyzb4RXISppM3nVoogWEy2qajhhErgUHnG2sNw0msTFJeBIZzP2g9piMUgREaERixxdUYhJKnZsGxPWvWLPXtt9/6Pl+6dKlex+fhmDJlirrpppuyrL/xxhvVe++9p3ISztQTwSbtgclWms5O72jCNYNN3ounhhGJScrNPAwndiER7HV2axipEFKb7AIjT5401TAoeWp46KGHVMeOHdX//d//qTz//WLyP2FOchMlRa3tBQsWqMqVK/utZ13BZAqSToDACKVhmHQMPACFCmW+Fg0j/OS9SDSMUIUcQ/kFggkMexhttBqG+U32+trOfbo510gQk1RsScWJe559GC+99JKuy22EBfD6vvvuU40aNVKjR48O+X1qbN95553auW38HosXL9b7HThwoMpJeBEYJskv2oW50dJFYND5MVbwWsvbTQLCZNAwAtW7iEZgcBzze+3HdB4/O2d6p6oPI5nGpLlTIGggaoHxzz//qHXr1qmzzz7bbz3rjoWrBPNffe2KFSuqp556Sr3xxht6XbVq1bQWg+aSk4hEw7DXuU6XehjGj2E6+0jMHbHUMEKN/CLRMLwIDK5jqJobzuPYf5/T6S4mqeQ2SeXOCQKjW7duqnv37uqnn37y0xBGjhypP3MDgiGnCYdAODt5NxqG3UGcLhqG+V2meFIko9d4+TCyW2CEK9IUym/hPL6YpERgJFxgjBkzRofUknCQuRhQqlQp1bdvX3X//fe73g+O8rVr1+rXNWrUyJGT/rw4ve0mKUO6OL2dju9oTFKRahiYW9wIl0gERqBzCCUw7AEOBtyD5h4IpmE4kbDa5BYYedLV6W2HvFEPPvigXkz1PC8pQUghct1116kvv/xSF1MyWW9btGih3n77bXVaqoRfJIFJyt4hOPeVatg1p+LFY+fDcCswaL9oBUaweRheNYxA8KiwLd8LFRllR0xS/teL18n0nOROQZNUVKeMoPCaP+quu+5S+/bt0xP1/vjjD72sWrVKCx/mZ+Qk7DcvHUIoh1w4k1QyPQiRYH4XdbYi+S3BNAy3Jim3Jr1YmqTo7J0CLpTAME5n0TDcY79etG0yRSblzikCg7Tm+CDIUFunTh2/JRyffPKJnumNo9vArO/x48erjz/+2NN5jBgxQtWrV09nz6X8KzPK169fH3Bbij61bt1apygheWIyYO8YQ2kXbkxSzloFqWqSijT6JpgPw62GkZ0Cw34O5pohMALNwQh2HkxxMiYMtwIju3wYnGOq5Bl1CoxkIndOEBjUvMC5TR2MZcuWacd38eLF1c8//6w75HAQSZUvwBCSdW6irOx89dVXqlevXjq1yOeff67+/vtvnT33QIAn8cknn3SdzyoZBUY4k1SqCwyjYURqkYxWw3DbmUSrYZjrxLpAIbXBzgOBEWjuRSJMUlyjJHuUgiICI7Z4vqXQDp577jk1btw4lT9/fu3LoLPGnLTX9GohuOiii1SfPn3Utm3bfOt+/fVXde+99+oEhl5AW7n55pu105xEiK+88orasmWLdqjbWb58uXbSM9cjmbCPJkM5vMGkP7ebpOyTwVLdJBWthmE6WnJXkp1m0aLM9omnhrFmjXuBwXmaHGJuzgOTlOmwX3ghs3YIrFgRf4GRKnMwQARGbPF8S9EhM0HPzNrGHwFdunRRb731VtjvP/PMM9pfQXr0s846Sy8VKlTQ6xBC0WAE1ikYwm0Fnzp37qxNXs6EiYE4cuSIPhf7kl2YGdtQurS7FNd2U4D9YUimCUmRYLLKlCgR2feN5jVpklIdOijFLbpggXsNw25NtWe4MbfSGWeE10TGjFFq+/as643Q4nqZTpf0bP/l3vSLlnGjYYwapVTZsplVGm+8Mfj5xFoLMOcW6TVKBMn8jFT2T3bhCvvA0DEVLi54NmTQ6eKoLl++vCpXrpw2BzG637hxo/YThKNs2bJ6lvcXX3yhJ/sB/oyWLVuqaMCcxSzyxo0bq3POOce3Hs0FAUfNcbd+kSFDhqh4wEPfp49SuF26d/f/DDfLlCmZHQKT5zG1MArv2tW/E8nIyHxtk5EpSZcuSm3YoNQdd0T2/VtuYfJopl+AkT61NX780V/DoEAT7XX55Vm/P3IkvjmlKlQgVf/x9V9+qRR5MocOzXz/X2BfUDgHZ4dqNAxG/IFG/ezTZKQNZlqks3N+ZlPS46Jh0G7XXUcCUZUyJLOG8dxz9E9K9erl/jtLlih17bWZAyT6h7hjeaR79+5WRkaGfv3MM89YhQoVslq2bGkVLVrUuuWWW6xE0aNHD6t8+fLW1q1bfetmzJhhVapUydq3b59vHT952rRpQfdz+PBha+/evb6F/fEdXgupQceOmdmbnn7aslq1ynz96qux23+LFiY7VNblq6+ybs8tyWf58llWsWJZv3PWWcdft2wZeL/9+llWmTL+6xYvDn4eLL16xe43pyqvvXa8PerWTfTZJA/0Z5H0a541DPwXxjmNwxmH98KFC9WVV16p7nA5PFyyZImaM2eOnpPhdHQ/8cQTXk9J9e7dW82cOVPNnTtXnWFsB0qp2bNn6xnpZr6HoUOHDqpJkyZ6LoiTAgUK6EVIfX8I1kSjYcRrklQgM5D9HAKN+u0msGBaAaYIp4YRzj+TilE4OUnDSEUimrjHYmASHotbhg8frh5++GGdi4pIK3vkktcoJhQG5nVMmzZNd/74Qpx5q6i/YadmzZpq7Nixqm3btp6OJaQOxs+De834MGIpMLz6BtyYpOzbmuqBdljn/A3h/DOpEsmUU30YqUhEwZjz5s1Tzz77rB69MyejTJky6vXXX9cdNuVbQ0HSQaKViG6KFjScSZMmqRkzZui5GL///rteT10OHPKBKgMCvhencBHSW8OIV9hxoE46nMCwaxjBBAbRU6JhRHc9RMOIHs9KK0WOWrVqpTtk5mEQVWQilNAewh4wd27tmI4FEydO1Mdt3ry5zmdllnfeeScm+xdSX8PIDpOU12y2XkxSRmC4MUmF0zDEJJVe+dZSUmAMGzZMF096/vnn/SbgIQSIfgoHUUuEuMYCTFKBllDaC5/ba4wL6ath2E1SiZzYGE7DsCdeDCUwnEIvnA9DTFKiYcQaz48RqTeaNm2aZT1mIJIIhuOBBx5Qbdq00fMvSAninPUdqCa4IESiYWSX09urhhFOYNgnY7JtoMl7omFEhpikEqxh4BP4kQB3B1ThozBSOJgRToRUlSpVdISVvV64m5rggpDMGkYkJim7wGDbWGkYYpISp3es8fwY3XbbbTq1B45roppI8bFo0SKtObgpsfrqq69qPwhahiBkt9PbjNaTJUoq0Hk4NQy3PgwRGN6ulfgwEiAwCFVl7gR5n0i7gXmKeQsIDEJcw0HaDsxRghAPp7dRWpM5SsqZHyyQwAgUJSVhtd6uhwiMOJuk/v33Xx1SSzirqWNBapCdO3eqR8if4IKMjAw1ePBgLWwEIRUn7sU6SsqthiEmqeiulQiM6PE07sqTJ49OH05pVWZP47SOJD068zeYtEcCQqfT202klSC40TDIK2XqYydyprdXp7eE1WbP9RCBET2eFXUS+1H7ItKJbxLSKmQ39jBVk3E/liap7IySQhspXDjrNuLDiAyZ6R1b8kYyDwN/BSaounXrqhPsFX1c1PfGHCUI2QkjSQQENn4T6Z3MuaTsj5AXk5T4MLxdD9EwEiAwLv8vNzTJBu25n5gQx3v8HIKQSLgtGbeYGiLx1DACEQuTlKQGiQwRGLHF82PEHApBSAWzlF1gpIMPw6uGIfMwRGAkXGA0a9Ys5ichCLHGaRlNpA8jVlFSXudhSGoQ8WHEGsmYL6S94zueGkYg7BpGoKKUbn0YMnHPO2KSii0iMIS0JJk0DLvA+C+5c9BzE5NUbBGBEVviMv/1vvvuc71tJBX3BCFZNIxwJilmn4fCS/JBSQ3i7XpIlFSKCAzqZjgn5/3zzz+66h5s2LBBTwokTFcQkl1gRBMldeiQ/2fOTixUlJSE1XpHBEYKCgx7ZBUaBNXxSEJYrFgxvW7Pnj2qW7duus62ICS7SSoU4UxShw/7f1aoUNZtxYeRPddDSrRGj6vHqHbt2q7rbYdL7fH444+rzz77zCcsgNdMCCTtyP333+/qOIKQjBpGOJNULAWGhNV6u1ZikoqTwLCn8zh8+LCaMGGCziPVsGFDvY4EhKtXr1Y9e/YMu6+//vpLJyt0wrp94Qy8gpDkGoZXk5Rz1CsV92KLCIzY4uoxsqfzuPXWW3URJGd2WrbZunVr2H1dffXV2vyEplG/fn29bvHixapv376qffv23n+BICS5hmEXGE68CAxxentHBEZs8TzumjJlivr222+zrL/xxhvV+eefrwsrhYJ64OSi6ty5s/r7778zTyJvXtW9e3c1evRor6cjCK4ERiJTg4RKse40SbGtlGiNHeLDiC2eH6NChQqpBQsWqMqVK/utZ11BF16lwoULa5MWwoE050BBJWcSQ0GIpUkqWVKDOPHiw5B6GNFdD/FhJEBg3HPPPerOO+/Uzm27SQnNwk2JVgMC4txzz/V6eEFIK5OUU2AEq7jHfqXinnfsbS4CI0ElWitWrKieeuop9cYbb+h11apVUy+//LLq2LFj2O8fOHBAjRw5Us2aNUvt2LFDl3u1Q60NQYilhkFnm8hEfMYkFY2GAaJheEc0jNgSkWUXweBGOAQCp/lXX32lunTpokqVKuU6XFcQItUwYm2OilTDcOPDCCUwJKzWO+Z60HaSvTd6InYFHj16NKCGUK5cuZDf+/jjj9WHH36oGjdurKJlxIgRaurUqWrdunXat9KoUSM1atQo3wxy6o4TvcW8jy1btqjTTjtNhwgT4VWkSJGojy+khoYRz44iUHJBLyYptBG3AkNSg7gXGDJpL0EC44cfflC33HKLWrhwod96twWUmKR3yimnqFiAptKrVy9Vr149nWrkf//7n578t2bNGu0j2bZtm17GjBmj541s3rxZ9ejRQ6979913Y3IOQvJrGKaud6KjpNyapAJFSYGkBon8Won/IkEC4+abb9ZhsDNnzozIpMToftCgQTo1CBFT0fDJJ5/4vX/llVfU6aefrpYuXaqaNm2q64+/9957vs+Jxnr00Ud1CDACht8hpCfxHFHSwduFElHnW7YoVamSUsR1rFwZ3CTldh4GOG/Xr78OfV5ighGBEWs895jLly/XHXLVqlUjOiAT9ginLVGihDrzzDNVPsfTES61SCj27t2r/4fSYNiGuuPBhMWRI0f0Yp+ZLqQe2ekaK1vW//2ppyq1bVvm6++/V6pz5+PngCI+blzwDrx8ef/3Vaq4d3pv2BD6PEVgHG/LKMemQqQCA9POrl27VKTY04zEEnwphPziG0GzCATnjYZz++23h/SLDBkyJFvOUUgPhg5Fuz3eYdeqdVxg2IP88GcsXuzfgc+blylAGjRg8KXUnXdmfrZ0qVIjRyo1fHjma0ObNkp16nT8+16QeBKl6tRRqls3pVq0iPBiC/5YHpk1a5bVsGFDa86cOdauXbusvXv3+i2JokePHlb58uWtrVu3Bvycc6tfv7512WWXWUePHg26n8OHD/v9HvZHMyXytwmRkdllZy6xZsmS4/tu186yTjst8/X//ud/3OHDj7/u1MndvidPPv6d7duPrx8/3n/fZmnbNvD6t96K/e8W0gP6s0j6Nc8aRsuWLfX/iy++OCKnd3bQu3dv7VOZO3euOuOMM7J8TlLDyy67TKdVnzZtWhYzmJ0CBQroRRDcjt7tt5MzueDBg8dfu9UQgm0XTGMIdjuLSUqINXmjqW0RCQiUsWPHqsmTJ+tQV8Jz7RAK6xaE1F133aWFwJdffqkqVKiQZRt8EK1atdJC4P3333eVvkQQvAoM894uIJzv3Xbg9n0Hex1MYLCNCe0VgSEkXGA0a9YsqgPiH3jhhRd03YuHH35YDRgwQG3atElNnz5dR095gZDaSZMmqRkzZmjt4ffff9frmWPBvAyEBWG2Bw8e1LPSeW+c2MzJoMqfIMRSw3AKDLvG4fZ2i0bD4LUZg4kPQ4g1EceV0gkH0hDC5Yd688031fPPP6/atGmjMjIy1PXXX6/DXfkedTVIne6WiRMn6v/Nmzf3W0+aEsJ/ibgizxVUIsbRxsaNG3WUliAkm0kqGg1DBIaQVAKDQkfUs2DGdiDC+TDQAmrWrKlfn3jiib5Q2CuuuMJT8kLQfs0QIEjCbSMIyWaS8qph2Cf6Oc1TghBLPCdNIHT1zz//1CN3zD5MnmMSHunO8RGEA6f0b7/9pl+jWZC2A5YsWSLOZiFlsHfG9g47lIbh1iTlRqsIpWF4+a4gZKuGMXv2bO0zoFhS7ty5Vfny5dUll1yiJ8MxhwFTU7iKe2SqveCCC7TDmlnXL774ojZv3XvvvV5PRxBSxocRrYYRTFm2H1+SFwhJJTBIT076DZMXChNVlSpVtJnJzSxtUpsbOnXqpAUOeanQUNq2bev1dAQhrU1S9uM48nz6HT/Qa9EwhIQLDDLBrl+/XjuMa9WqpZ599ln9mtKr5JbySoMGDfQiCOnu9I42SiqYwBAfhpC0AqNPnz4+HwSpw5kQR+RT/vz5dfI/QcgJuDVJxTJKyo1JSjQMIakEBj4HQ926dXXKcOpRUAfjVLKwCUIOwK1JKpY+jGAaht1vESKJgSDEN0rq77//1pFNa9eu9a0jRXmdOnVEWAg5ikRESQXTMOzHtwsP8WEICRUY5GA6fPiw54M8/fTTvu8RDSVzI4R0NUnZMuNrxOktpBOe52GQjoMyqBQgcst9993nS8lBviciqwQhHU1STuwCJBIfhh2JkhJSzofBBDvmUTDhjlBaSqHaoca2k9KlS+vKd5dffrnWLn755Zegmkq4muCCkMwahoEcl85bPJIoqWic3oKQcIFRtGhR1aFDB0/fIckgk/RIQ04KdGpwO0lkenRBiLXAYBzlFBjZpWGID0NIWoFBYj+vUOGOJINEVJFk8IsvvlDFixf3vB9BiITscP6GM0khMHbv9l8X7cQ9CasVUk5gXHTRRdrshKZhBx8F5VdJHRII0o9TOhWBQxlVKVIkxIvsqAsRTsMIVEM6kiipaHwYgpBwgUGhImdKc8AnMY+CxWHo2rWr10MKQlJrGHaTkMHh2tOIhiHkGIHx/fff+16vWbPGV6wI8DuQtbZMmTIBv3vKKaeoDRs26Lka5J/CVxEMLxX3BCFZNIxAJqlIz0OipISUFxjnnXee7uhZMEs5IdX5uHHjAn6XkqyYpMzrUAJDEFLRh2GHyXOBTEPRRkm5MUnJxD0hKQQGFeqIZKpYsaL65ptvdIlTA3mkyGAbrOSp3QxFJTxBSGcfBv6LQMeMVsOIV1gtFgOyOgipTf78+XUJioQIDNKQw7FgwxyXIFRIXmhSpBt2796t10lYrZDqUVKFCgU+ZrTJB7M7Wy0DQkzNFEgTUp/cuXPridIIjoQ5vamuhy/CFEp68MEH1XPPPaeqV6+u3nrrLZ9gCUawtCBHjhyJ6Q8ThOwUGPbO3zmqR2AEEg7RpjfPbg3DCAsGbuSIE9Nx6nLs2DG1bds2PThnMnSsrqVngTF8+HA1ceJE/XrRokXqmWeeUU8++aSaOXOmrpgXaKa3yScFnPgLL7yg63kb0Crmzp2rqlatGvkvEYQEmaQY5zg1jGhMUtHMw4i04h7PoBEWMkcqPTjttNO00CCNE3kAY4Hn22vr1q2qUqVK+vX06dPVNddcoyfmMbeiefPmQb+Hs9toGBRbsvs70CxMESZBSHWnNz6MaExSXtObx8LpbXwWaBZCepD/P4sNg4GECQw0A/wNqDnkkyKxIBQsWFAdcuZ2djjNoUWLFloLIbxWENJRYERrkoqmgFK0UVJihkofcmXDje9ZYFxyySXq1ltvVbVr19ZzK0goCKtXr9ZaQjjmzJmTxZ8hN6mQnaSa0zsRGoYguMGzdXf8+PGqYcOGOkU5GWiNvXPp0qU6X5QbXnvtNZ3plrkbLOSXev31172eiiCkfVitVw3DrRaTTpB9gkGnl+guwvtJZRQtuXLl0qb5nILnR4kcUji6Z8yYoet5G4YMGaIGDBgQ9vtPPPGEuvPOO7VmMnnyZL2wnx49evj8HG4ZMWKEznzLpECcddwA69evz5KyhBoeCDbMaWTa3b59u6fjCKlNdo+0nY7mWGoYqT5xj46ZTpXn2wnPJZ8lYm7WU089pV555ZW4HzfVyYaxV2iYDU6UFUWYrrzySr089thjasKECb5IKrd89dVX+qb7+uuv1eeff64dd5deeqk6cOCAbxsitz744AM1ZcoUvT1RA+3bt8+GXybkJA3DXj+MTtpNlFS0yQeDaRj2/dpfJ4PAgLJly6q3337bz8fJQG7SpEkJq39TpEiRLAlUhSQUGMQFN2rUKMt61vGZF8hfxeikRo0aqlatWnrEQAlYzGOwd+9e9eKLL2qthnQmdevW1dlyFy5cqIWMkDPIjo7TLjACOb1jpWHYhUQwDcN+rGQUGHXq1NFCwx5yz2uEBb5Q53ysu+++W1sMCKS58MILddE2Ox999JGqUqWKNmcTRLNp0ybP5+Q0SRHhyXGZV0buu5IlS6qMjAy/7/zwww+qadOm+ryYd8YgNVAUaceOHbUwYj/t2rXznd+6det0FBqC0oCFhd9Bfr5UIO4Cg5BcGsnJO++8oypXrhzVvhEQwIUCBAdaR8uWLX3bMNeDG5U5JIHghiVVu30RUpsqVWK/z1CT5aL1YSBwAlGiRPhzsc99tU11Sji33HKLXy2dl156SXXr1i3LdnTY+EaZIPzdd9/p/qJVq1a+pKR0yFgI2rZtq5YvX64DcPr16xeTc+SYVBBdvHixtnoMHTrUJxSYCNe+fXsdqsrnTAF46KGH/L5PX8O5YiInc/eCBQu0GRyTOxm+6XvGjBmjevbsqQe2VB7FVIe1BQGUElgeOHbsmLV582br0KFDVqS8++67Vp48eaxWrVpZQ4cO1Quv8+bNa02dOjXi/f77779WmzZtrMaNG/vWvfnmm1b+/PmzbFuvXj3rwQcfDLifwYMHM6bLsuzduzficxMSw6JFltWxo2Vt3pw9+x8wwLIefTTzdYUK6AKZy8CBltWp0/H3Zpk0yf2+H37YsoYN81938KBldeliWXXr+u/XnMuVV1rWli2WNXasZd17L8+r++PxTK9ZsyaqZzsQXbt2tdq1a2ft2LHDKlCggLVp0ya9FCxY0Nq5c6f+jG1g//79Vr58+fRzazh69KhVunRp67HHHtPv+/fvb1WvXt3vGA899JB+Rvfs2eP5vAzNmjWzLrzwwiz9BPuGTz/9VPdRv/76q+/zjz/+WB932rRp+v3rr79unX322bqfNBw5csQqVKiQ/r6BfqpJkybWxRdfbF166aV+28eSUNeU/iySfs1TWC1hsEh8Qmgj1QZwOiOhcXCb6IJq1arphIZO9dQL+DJWrVql5s+fr6Khf//+vrklgIaBOi2kHg0aoLlm3/6HDQu8PtqZ3vDII4H3+9prma/PO0+pFSsCn8s996iknHVMOiHMxvQjvCbFkJ2ffvpJj9KZBGxgwln9+vXV2rVr9Xv+X3DBBX7fI2ozFhCtaadUqVJqx44dvuOWLVtWlS5dOuhxV6xYoX788UdfZm67v4bfZteuMKmR64m+NJWmFXgSGPxABAUT96IxH+FLeOONN1SsoFY4qUlIL3LGGWf41mOHRBUk3M7u4CJKis8CQSVAqQYoREO0Jik3/PuvSjkwS/GsmvD8ZMM5G5qO3Euy1f379+u+7c0338zymT27N4KFwBz6U/y2CKZUwfMtPHLkSNW3b189mo8GJDf7oDCTffECIxVuwGnTpunSsGRmtMPF4yaYNWuWbx1ht9gPYzUqEQRwM3EvlnMkUlFgGFu+sfU7Oeuss7SPANu/gW1xehsbv7FG2IlHAAvH3bp1q19gjvO4OPdxjOOwxxJjX4jKAnwxONyZgsD/G264IWSGjGTD80zvm266SR08eFBHJXFx8fB7qZiHI5r6GKh4zsy1SHQv6c0xQxFxwJwQ1EBTBZCLw3nxv3v37trEhCP85JNPVnfddZcWFg2wVwhCNhALk1Q6CgzyxxnTUqDaOTicmaPFgJTnleAUnM/0NzzHgJP48ccf19vg8KY/icd8CgJnqlSpovuu0aNHa1O1c94ZnT+fERmFwxxrx+bNm3VEGM583nP+mLYefvhhHWCDGf6BBx5ISo0rJgKDzLTRqqU0POGuJUqUiMp+Z7LmOpMeEo1hJgPhK0H1w3fCBWJkw5wPQcguog2rTVeBAQzawlkwMAN16dJF7du3T51//vnq008/9eWeQ4gQRcX8KuZ04d8ggzb9ih36FXs/EC30IdOmTdOCi2OSBol5Y/bJy4TMYhYneoqIKs6fstUXX3yx/t1kuCAkeNmyZSpv3rx6wTRP6PAVV1yhWrdurZKdXHi+43lANAEazGS8TXYYSaCpELIb7mYXci7czsav+eGHSr37LgMX/21mzlTqvzIyUYP11Uw/iMUTjGOWBKGYdZlnkMrwOxiUMrch2lD9VOZwiGsaab8W0ZgHjz8qFbmjTBTBxx9/rD3+4UDa4vQRhHRFNIzEwiiekgs5WVgkjUmK9BqoToS+oX49+uij2smDEMDM9C5DqxBQPAk7IA7vc845J0tkAqlCBCGVER9GYsG3KSSJwGBW5bBhw7Qj2R5vTOoNkhKGgxnWREGgkTjx6vQWhGTB7rMIVkApp0dJCamPZ5PUypUr1dVXX51lPVrGrl27wn6fKKUbb7xRh6fh3LIvIiyEdEA0DCFdiSi9eaAkgTiyiQgIB5P+iHAgQkoQ0pF4+DA8zCcThJjh+Ra+7rrrdNgYcx7MTEhMTMQSM0cjHISb2avuCUI6EMv05m4Qk5SQEj4MYp5xKjH5BBMSMzD537lzZx05FQ7C3cjXRM4nqu45nd6kGBaEVEZSgwjpimeBwezu559/Xg0cOFBHOpE/hdmKbkPYiJIi5S/RVix20FhEYAipDiHvMnFPSEc8CwwDMy5NFlcvs7WZSCII6YZ5BIywEJOUkI5E5IZjvgVzKJg9yMJrNAdByOlgjgLRMHIGzZs3V/fEKZ88A3NTEiJlBMagQYNUnz59dMUr6mSz8JrIJz4ThJyMycUpyQfjC/O7SGhInQ03kBGJ/orU4iQqJbkgmWaTgYyMDHUeBU+SkNyRJPzDhzFixAg9K5uF188995wk9RNyLEajMAIjuzUMIavVgzleZJ/Ytm1b2OYhCy7JAym1SkE3MuWSmJT8S0JwPN/C5Kcng6QTak/8888/XncnCDlGw0ihwmo6oeGBA4lZvCZTJPDmnXfe0anRTVW/0L/N0lm3ieokFTmV9sgki6AJZfI5cOCAnjpA0A6aCWnWnZARmykGzElDCFEd8Msvv/R9zrkxl43jECiESR9BRa0N8/mQIUN0qiVMUCz238PkaCZOkxmX77///vsqqQUGaYdNWnE7aBjkgxeEnEy8fBjZzcGDSp14YmIWju2FyZMnq6pVq6qzzz5bZ5GgBGqoJNwE3jCPDDOUgcytdO6YtoLRt29fHdlJ/Z3PPvtMC4LvvvvObxsKurGPt99+WxeEu/baa3UKdLu5i/oe5OBDSDGHjYqgzG+DTp06qfvvv1/VqFFDT5BmYZ0BYdKxY0e978svv1z3ueFqECU8Sgr1jwYzRYhQ6ahih/S118N+4oknAn6fBqJqFplunSUQ3Uz+E4RkN0lltw9D8O+PEBRA50zKbjp2Z50cgym05sw2wXvzWSAt5sUXX9T1K8i4Da+++qpfSWj6QGpw8N/U/kbb+OSTT/R65rAZKw1590xtcvZjKglSawMNhloZgcpIU9+DLOHA/jCr8T17XY6kEhjMvaAUIZjC5hRzZ7GXbQ0WavvBBx9oqcgFIA+7fTtei8AQUpl08WGgKe3fn7hju4WSy3SYFDcCOlpG5HTuwQRGJNDXHT161NfJA1UB0WrsefaYxMzkZKeZqnjx4r73nGO9evV879GOMFNRjRCBEQrMZwZMXvShpsREUgqMaNN6oG5RHQvpiB1OENIJc0unuoaBwDvhBJX0IBjwnZoRPWCOKlCggB7Fm1radszIffv27doXYeB9NNFJ+/fv15FalI11lqBFa4gFzswYJj1TvIj7Lfzrr7/q2dwiLIScFiWVSk7vVABBgR8A5/Py5ct9Cw5jBMhbb70V8HtUoENozJo1y68CHab1hg0bBvzOWWedpTtrtjHs2bNHbdiwwfeejBdoGIz4qShqX+zmJc7722+/9dOSMNNjljLZNJI1c3fEM70jhYgAGqtixYrxPrQgZDviw4gfM2fO1J02dbadmkSHDh209tGjR48s32NUzmQ76voQaYQAIdURQuaqq64KeCw0hO7du2vHN+YlyjkMGDBA1/o2YIrC3I5ZHSGGANm5c6cWTJiSzBwRBA8hwPgfME/hKMcfbMxR1AvHMY/ww0dC3SE0phwjMOyhXzQajU693UDJB6XinpBOTm+e8yNH/NcJsQGBQKRTILMTAoO5FkQT0VnTCeMwZlIcPPjggzpMllKujO4vvPBC7ZwOVc989OjR2uzERGU6cczrONjt4NxGEPEZ1hR8uwiDK664wrcN1hUyfpOwlW2aNGmif4v93KdOnapatGihz419cu5JgRUHcuXK5WrJnTu3lWzs3buX+Dz9XxCCUb06cZyW1a9f5vshQzLfFy2a+Z9l48bYtZ/ZZ6ye4EOHDllr1qzR/9ONAwcOWAULFrTmzJmT6FOxXn75ZatIkSJxOVaoaxppvxYXDSOeThlBSCRODYP3f/6Z+Vp8GImBQB1KSMcyaiqnEnclGScVYWZOCFnjM0FIJ6e33fQsJqnEgBn8ww8/TNDR04u4C4xu3bplsfvBvn379GeCkE5htSIwBDv4IvBLpCpxFxiYXwNN6vvll18COq9CQaIxHFBENwRK/YuDiggEIg3ISEl1QJKNCUJ2IRqGkM7ELayWEDOTTIup9YSTGYg5JozM6/R2ohxq1aqlJwJSK9wJaUpmz56tp/MTJUE6k549e2oBI9FYQryipJzbJDOhcjAJqUV2XMu4CQwT30xsMXMx7DMfmahCh044mRdat26tl2AsXLhQde3a1efsIoTu2Wef1akERGAI8dAw8ufPXh9GrPZpwttJjIc2LqQ+R48e1f+ds85TQmAMHjxY/0cwkOslVLxzrGjUqJGeA4IGglZBdklmZo4dOzbod3DI253yzAAVhHAYhdmMg4ygKFr0+DbZMfeqevXY7IdOhXxGJi8RcwW8lF4WkgsiU5k0yHW0W3NSbqY3I/54MW7cOK1V4MOg0ZiVSfGnpk2bBv0OxaBIISwIXujfXykCcZo0yXyPhXThQqWo3kn5GDQBjy66kCxdqtSoUWQsjd0+TfqKeCazE7IP+rty5crFVPDnYjKGymbI6sjInlmPxYoVC/kDIs3tzj7JWGmf2j9mzBgtIPhfvnx57STv37+/3s6eCz+chlG2bFkd2UVmSEFId/ApkoJbSG3y58/vl7rEDv0aQUZe+7W4aBiYgJhKb17HQ9U9dOiQ+t///qeFg8nhQooAfCgIkGACg5wtyZK3RRASAeapWNq9hfQhb7zNUPHKicIIicUpYXkQZOa5IAhCCvgwyORIUi38CKQMjgbmWfz444++9ybDIyYwbHfNmjXTiQ6J+sAkRRUuZpMHqwQoCIIgJNiHYefWW2/VvgQ6egql06kT9sp/Ug17gagnhE8gjYbC6ZRbxGfB/At8IwgNnOD33nuva7NYpLY+QRCEZCXSfi3uAsNAWl8EB6N+FpziVL9ixncyQYMSbrh161YRGIIgpAUmmIc0JV4ybMTdJGUgWopCJPynQybs9bTTTlPJBjmugMYVBEFIJ+jfvAiMuGsYRC5hSlq2bJkuSWhMUvg0EB7JBg7ybdu26SgvL9FdRoKLZiJtI/dM9MjzFNt2odtHWDChOVjobVIIDE4OTQI/AvmfKGuYjojvQ9pG7hl5ntKtn4m7SQrNAp8FWgZ1b5lcYrQMlnQVIIIgCKlO3AUG2WVZ7r77bv1+xYoVejJfr169tPmHWaaCIAhC8hF3gYEFDC0DDYNl/vz5Wq1iFjaaRrrAbHESLsqscWkbuWfkeUqXfibuPgwc20y4Q8swpqgmTZroSClBEAQheYm7wKC2LgJCJsEJgiCkFgmbuCcIgiCkFnGv6S0IgiCkJiIwBEEQBFeIwPDIo48+qku/UvowmKN+y5YtugYH25x++uk6Y+4///zjtw0RYnXq1NHRDZUqVdLJEp2MHz9el7SlnO0FF1yga5GnEpw7s+Pty8iRI/22+f7777VPi9/IjNXHHnssy36mTJmiqlatqrepWbOm+uijj1Q6kurX2ysZGRlZ7g+us+Hw4cM63J4UQieeeKLq0KGD2r59u+dnLdmZO3euatu2rZ51TRtMnz7d73O8BoMGDdK59si8TS2fH374wW8bkqvecMMN2jdMv9S9e3cdXOT1WQsLPgzBPYMGDbKeeOIJ67777rOKFCmS5fN//vnHOuecc6yWLVtay5Ytsz766CPr1FNPtfr37+/b5ueff7YKFy6s97FmzRpr3LhxVp48eaxPPvnEt83bb79t5c+f33rppZes1atXW7fddptVtGhRa/v27SlzucqXL28NHTrU+u2333zL/v37fZ/v3bvXKlGihHXDDTdYq1atst566y2rUKFC1rPPPuvbZsGCBbptHnvsMd1WDz/8sJUvXz5r5cqVVjqRDtfbK4MHD7Zq1Kjhd3/s3LnT93mPHj2ssmXLWrNmzbK+/fZbq0GDBlajRo08PWupwEcffWQNGDDAmjp1Kv5ka9q0aX6fjxw5Uvc106dPt1asWGFdeeWVVoUKFaxDhw75trnsssusWrVqWV9//bU1b948q1KlStb111/v6VlzgwiMCHn55ZcDCgwufu7cua3ff//dt27ixInWySefbB05ckS/f/DBB/WDYqdTp05Wq1atfO/r169v9erVy/f+33//tUqXLm2NGDHCSiWBMXbs2KCfT5gwwSpWrJivXeChhx6yzj77bN/7jh07Wm3atPH73gUXXGDdcccdVjqRDtc7EoFBJxeIP//8Uw8MpkyZ4lu3du1a3aEuWrTI9bOWaiiHwDh27JhVsmRJa/To0X5tU6BAAd3pAwMpvrdkyRLfNh9//LGVK1cu69dff3X9rLlBTFIxZtGiRdpsUqJECd+6Vq1a6cmJq1ev9m3jLBHLNqyHo0ePqqVLl/ptQw4u3pttUgVMUJgUateurUaPHu1nLuC3kHSS9DD2dli/fr3as2ePq7ZKB9LpensF0wqmmIoVK2qTCiYmoD2omGlvE8xVFEYzbeLmWUt1Nm7cqOv62NuB3FGYLO3tgBnq/PPP923D9txDixcvdv2sJXV683SFi2u/gcG857NQ23CjU4ucC0iKlEDbrFu3TqUKpH/BT0MFxIULF+piVr/99puv4iHtUKFChaBtxSTPYG1l2jId2LVrV1pcb6/Q6eG7O/vss/V9MWTIEG1jX7Vqlb6+dG5OP6H92rt51lKd3//7HaGeAf7jv7FDuQieO/s24Z41N4jAUEr169dPjRo1KmRDrV271s8hl1Px0lb33Xefbx2pX+gA7rjjDjVixAhJmSKo1q1b+90fCBCqYk6ePFk7d4XkQwSGUur+++9XN998c8iGQmV2Q8mSJbNEt5jIDj4z/53RHrwnwoEHJU+ePHoJtI3ZRyq2FR0CJqlNmzbpUWWwdnDTVoluh1hy6qmnJu31jidoE2SrpnzzJZdcok11VISzaxn2NnHzrKU6Jf/7HfwuoqQMvD/vvPN82+zYscPvezxnRE6Fe47sx3CD+DCU0vU5GBGHWuy2v1A0bNhQrVy50u8Cfv7551oYVK9e3bfNrFmz/L7HNqwHjlW3bl2/bcjky3uzTSq21fLly7Vd1ajP/BZCCrFV29sBYWJU5HBtlQ4k8/WOJ4SB/vTTT7pjpD3y5cvn1ybY2/FxmDZx86ylOhUqVNAdur0dMF3jm7C3A4IVv49h9uzZ+h5ikOb2WXNFVC79HMjmzZt1CN+QIUOsE088Ub9m2bdvn1+o36WXXmotX75ch8qedtppAcNq+/btqyM/xo8fHzCslkiIV155RUdB3H777TrM0h4RkswsXLhQR0jRBj/99JP1xhtv6Ha46aab/KI9CPXr0qWLDvXjN9MuzrDavHnzWmPGjNFtRWRNuobVpvL1joT777/f+vLLL62NGzfq60x4LGGxO3bs8IXVlitXzpo9e7YOq23YsKFeDG6etVRg3759vn6ELpmwfV7T15iwWu6FGTNmWN9//73Vrl27gGG1tWvXthYvXmzNnz/fqly5sl9YrZtnzQ0iMDzStWtXfVGdy5w5c3zbbNq0yWrdurWOc+YB4MH4+++//fbD9uedd56Ova9YsaIO03XC/AweGLYh7JIY61Rh6dKlOvyV0OOCBQta1apVs4YPH24dPnzYbzviyi+88ELdWZYpU0Y/HE4mT55sValSRbcD4cgffvihlY6k8vWOBELJS5UqpX8v1573P/74o+9zOsSePXvqcFA6t6uvvlrP1bDj5llLdubMmROwT6GvMaG1AwcO1B0+z8nFF19srV+/3m8fu3fv1gKCQSxhxd26dfMNYr08a+GQ5IOCIAiCK8SHIQiCILhCBIYgCILgChEYgiAIgitEYAiCIAiuEIEhCIIguEIEhiAIguAKERiCIAiCK0RgCIIgCK4QgSEIUUK5XUprks8nFJRfffLJJ+PS3l26dFHDhw+P6bFJw04esF9++SUGZyikIiIwhBwBGXZN3WiS/VFHfejQoTGp/0yNd+o5UNgGqPEQqN77kiVL1O23366ymxUrVui659QjiXVW3ZtuukkNHjw4pvsVUgcRGEKO4bLLLtMdO1XeSNOekZGhqwBGCwKIjKIIo3CZfgsXLqyym3Hjxqlrr71WnXjiiTHfd7du3dSbb76pU2cLOQ8RGEKOoUCBArpjp0jPnXfeqctYvv/++/ozqhwyeibVM506xX0QLIbNmzertm3b6s9POOEEVaNGDT2Kd5qkeE2nunfvXp9Gg2AKZBYiVXe7du10x05K7o4dO/rVLOB71Dx4/fXX9XfRYK677jq1b9++oL+Ryn3vvvuuPlcnfO/666/X51+mTBk1fvx4v88514kTJ+rfTl0W6pqwLzv8bkqqTps2LYIrIKQ6IjCEHAudIkV6jMnq22+/1QKE+sdkcr788st99QN69eqljhw5omsKUIOBqoOBRvCYpxAKCAC0GZYHHnggy3bUKkBYMFL/6quvdG2Cn3/+WXXq1MlvO+pDTJ8+Xc2cOVMvbEud9GB8//33WljZ6zsb0KZq1aqlli1bpisn9unTRx/XzsCBA1WHDh20WYsa2wgoKijaqV+/vpo3b17Y9hXSkCgz8wpCSkCqaOoImHTRn3/+uU7z/MADD1gbNmzQ6aSpyWDYtWuXTplNanWoWbOmlZGRETI99Z49e/R7UtWT1t1J+fLldY0Q+Oyzz3QNlC1btvg+X716td7PN998o99T+4O03n/99ZdvG2qokDY+GNOmTdP75Tc6j03NBDukEyc1uIFjU4PCDse68847/dbde++9VvPmzYOeg5C+iIYh5BgYoaMVFCxYUJtdGM1j9mEEnTdvXl91MihevLiuRmZG1ziQhw0bpho3bqydvozko4H9li1bVi8GqsThLLeP6DFFnXTSSb73VKNzluO0c+jQIW16C+RPcVbv471Te3CzDZrZwYMHXf1OIb0QgSHkGFq0aKHLxOKboGN99dVXtT3fDbfeeqs2GRGuikkKkw/O5eyGMqV2EASYs0JFMtGZG1NbdoAZDQe+kPMQgSHkGBAOhNOWK1dOaxSGatWq6fBa6iQbdu/erWtI22tDow306NFDTZ06VUdZPf/880GjpnA+h4Jjbt26VS+GNWvWaMd5NPWocZKbfTn5+uuvs7znPLxus2rVKlW7du2Iz1FIXURgCDmeypUrawf0bbfdpubPn68dvjfeeKOOJGI93HPPPerTTz9VGzduVN99952aM2dOlo7Ubkbav3+/mjVrlp7sFsh8Q4RWzZo1tWOZ/X3zzTc6SqtZs2YBHdZuYeRfp04d/TucLFiwQD322GNqw4YNOkJqypQp2vFth3UvvfSS3gbTG+fVu3dv3+f8lqVLl6pLL700x983ORERGIKglHr55ZdV3bp11RVXXKHt9viACZs1JiE0BiKlEBLM56hSpYqaMGFCwLYjUgpNBB8JHTidtBNMSzNmzNBhuk2bNtUChDDWd955J+rrgfmMuRJO0IqIBEM7wB/zxBNPqFatWvltM2TIEPX222+rc889V7322mvqrbfe8tN4OGc0tCZNmsh9kwORmt6CkGbgn8Fhj/BxOrFDgRBjfsVVV10VdJsGDRroAIDOnTvH6GyFVEI0DEFIM4hiQjvAHBZL2F/79u315D8hZyIahiAIrjUMIWdzPFREEIQcTebcPUEIjpikBEEQBFeIwBAEQRBcIQJDEARBcIUIDEEQBMEVIjAEQRAEV4jAEARBEFwhAkMQBEFwhQgMQRAEQbnh/wGsd9IHi//nxgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -1409,7 +1937,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1458,13 +1986,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3b7e7ffd4a884a54a596532568730024", + "model_id": "6bee107d362748fe828eec0b3b9ca28b", "version_major": 2, "version_minor": 0 }, @@ -1478,7 +2006,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b98ad4c48e2642e7afcab84ef874831b", + "model_id": "4b0e656284834f0da0884e46af9c1b30", "version_major": 2, "version_minor": 0 }, @@ -1492,7 +2020,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f23c4dcbf58c44d59b40aef58ebccc3e", + "model_id": "aa30fd07df2348baae3a09ede7a28600", "version_major": 2, "version_minor": 0 }, @@ -1506,7 +2034,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5c39ecaf77be4d55894be5d252bccee6", + "model_id": "354cd2b985414b62a190a00f1f7b2b23", "version_major": 2, "version_minor": 0 }, @@ -1519,7 +2047,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvwAAAGJCAYAAAD2X+dgAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQe4E9XWhhecw6F3pCkdpPcmiiCogGJvqCgWrt6r2Ou1997b1d+C2EUsqKjYBRUREelFkN57r6f8z7cnK9nZ2ZNMctLPep8nJyfJJJlMJjPfXnutb5UqKioqIkEQBEEQBEEQspLSqV4BQRAEQRAEQRAShwh+QRAEQRAEQchiRPALgiAIgiAIQhYjgl8QBEEQBEEQshgR/IIgCIIgCIKQxYjgFwRBEARBEIQsRgS/IAiCIAiCIGQxIvgFQRAEQRAEIYsRwS8IgiAIgiAIWYwIfkEQ0oJRo0ZRqVKlaOnSpUH3P/bYY9S0aVPKycmhTp06UTrTuHFjuvDCC2N6Lj43Pj+2Qyq3/9SpU1Py/oL3feTxxx+XzSUIQlSI4BcEIUT04fLLL7+EbJmioiJq0KCBevyEE06Iacs9+OCDNHbsWE/LfvPNN3TTTTfREUccQa+//rp6rlA8/ve//6VsUCEIgiCkBhH8giCEUK5cOXr33XdD7p8wYQKtXLmSypYtG/NWcxP8559/Pu3Zs4caNWrkv++HH36g0qVL02uvvUbDhg2j448/Xr6tYiKCXxAEoeQhgl8QhBAgrMeMGUP5+flB92MQ0LVrV6pbt27ctxpSdjDQwOwBs379eipfvjzl5eXF9Jq7d++O4xoKqWTXrl3yBQiCIMSICH5BEEI455xzaNOmTfTtt9/679u/fz99+OGHdO6557oKsuuvv16l/GAGoGXLlirXGGlADMQ8lnvjjTf8qUOc827m8ON/pPFgeV42XCrKUUcdRe3ataM///yT+vTpQxUqVKBbb71VPbZv3z666667qHnz5mrdsI5IFcL9Oni//v37U+3atdVybdq0oRdffDHkvfCZ7r//fjrkkEPU+/Tr14/mzJnjeU/aunWr+txVq1alatWq0QUXXKDuszF//nw644wzqEaNGmpA1K1bN/rss8+CluFtN3HiRPr3v/9NNWvWpCpVqqhZkS1btgTVGGA9MVPD2xTbTQfb5LrrrqODDjqIKlasSKeeeipt2LAh4meaOXOm+kyot8B6YlB48cUXq/3IZNWqVTR8+HCqX7++2s5NmjShyy67TO1j+ufBel5++eXq+8C21mcp2rZtq56L1xgxYkTI9lu4cCGdfvrpaj2wPnj+2WefTdu2bfMvg/27d+/e6juoVKmS2md5nwkH1u2KK66gd955Rz0Hr4+BMLa/7bNiO9SpU0etL9Z75MiRQcvgc995553qNbBPYLsfeeSR9OOPP0ZcF+yLl156qRoUf/zxx+q+AwcO0D333EMtWrRQ64b9AZ9T/z0LglCyyE31CgiCkH5AGPbq1Yvee+89Ou6449R9X331lRJLEE3PPvtsiOg46aSTlECBkENx7ddff0033nijEjxPPfWUWu6tt96if/3rX9SjRw8lUkCzZs2s64BlX375ZZoyZQq9+uqr6r7DDz887HpDXGJ9sY7nnXeeElmFhYVq3VCTgPds3bo1zZo1S63T33//HZReBHEPQYblc3Nz6fPPP1eCE68BUclAnEHwYyYEl2nTptGAAQP8gjUc2FYnn3yyWp///Oc/an0++eQTJfpNIM5Rv3DwwQfTf//7XyUEP/jgAzrllFPoo48+UmJcByIU4vXuu++mBQsWqM+zbNky+umnn5RIffrpp+nKK69U4va2225Tz8E20sHj1atXVwMkDL7wHLzu6NGjw34uiMnFixfTRRddpEQ21h3fH64nT57sn7lZvXq1+v4h0PF9tGrVSu0jGExiRkafzcG2x8AD25sj/PhsELPHHHOMGiTw5/zjjz/o119/pTJlyqjvYeDAgWrwgs+D9cF7jBs3Tr0vRDXWC3UoHTp0oHvvvVeJ8UWLFqnX8AIGI9gmV111lXouBiGDBg1S+ysGnmDdunV02GGH+QcI+Cz4HeE3sn37drrmmmvUcvgf+zgG2pdccgnt2LFDpbHhM+D13IrVCwoK1GAC64F9aPDgwf5t9NBDD/l/a3h9FGNjPz322GM9fT5BELKMIkEQBB+vv/46wvFFf/zxR9Hzzz9fVLly5aLdu3erx84888yifv36qf8bNWpUNHjwYP92Gzt2rHre/fffH7QtzzjjjKJSpUoVLVq0yH9fxYoViy644ALX916yZIn/PiyH5b3Qt29f9fyXXnop6P633nqrqHTp0kU///xz0P1YDsv/+uuv/vv4s+oMHDiwqGnTpv7b69evL8rLy1Ofv7Cw0H//rbfeql7P9tl0eFs9+uij/vvy8/OLjjzySHU/tgNz9NFHF7Vv375o7969/vvwnocffnhRixYtQrZd165di/bv3++/H++B+z/99FP/fW3btlXbyoRf45hjjgn6XNdee21RTk5O0datW8N+Ltu2e++999RrTpw40X/fsGHD1PeBfcyE35fXpXfv3mrbmNt+wIABRQUFBf77sa9i+ZEjR6rbf/31l7o9ZswY1/V96qmn1DIbNmwoihY8D5epU6f671u2bFlRuXLlik499VT/fcOHDy+qV69e0caNG4Oef/bZZxdVrVrVv83wGfft2xe0zJYtW4rq1KlTdPHFF/vvw28D7/vYY48VHThwoGjIkCFF5cuXL/r666+DntuxY8eg36cgCIKk9AiCYOWss85SRbSIiiLiiGu3dJ4vv/xS5eAj2qmDFB/oI0Q1kwEirYgw66AWAVF0RJI3btzovyB1B+hpE6gXYDCbgeX69u2rItecCvLdd9+pCDIix3q9AUdrI4FthdkDRKcZbDu8ns7mzZtV0TK+B2x/Xm/MYiDyi5QVRK11EDFHhJvBe+C98J5ewWvonwupJYgkY6YgHPq227t3r1pXRLcBIssAMyWYUTnxxBNVapKJ/r4A0W5sG4a3PbY1irn15ZDC9MUXX6jbiOADzDK51XFgJgR8+umnar2iBTNgSMFhGjZsqGZu8J7YXtjvMQuDz4r/9X0P3x/2J94u+Iw8s4F1wXeP+hlsI15GB9vgzDPPVL9JfLeYXTI/G2YwsI8IgiAAEfyCIFhB+gHSJlCoi9xgiBjkktuAGEQudeXKlYPuh9Dmx5MBUl/MAl+IHogffB79cuihh/oLgxmkc+AzI3UGognLcU43C37+LMiP1sGySIWJBJ5fr149lVajg1xwHaSXQCjecccdIeuOdBtz3W3rhPfAe5m9DcIB4arDn0mvBbABkXr11VerFCGIf6wncvP1bYdaAKSXcMpLJPj5DG97c1vhO0ftAD+O56EOAWkytWrVUgL7hRdeCMrfHzJkiEqXQtoL1hlpYEiX8ir+zW0NsE9hgIHPiQvSh5DWZH5/PCjVvz/UtSC9iHPusRwGMPo6M0jXwcAJaVBmDQZAihLeG+vTvn17lVqHGgtBEEouksMvCIIriOgjerp27VqVG89R0XRFjzIzEHAQPU8++aT1OSjgBf/88w8dffTRaiYAy+J+CElEUJHvH0sUuDjw+91www1KsNpAEXK80SPqOnrxtQ3MREyaNEmJS+ScY7CBz4C89li3ne379MoTTzyhiogRwUc/B8w+QSijngAFvHhtFNlihgfCevz48SoXHjM/WN5tO3iFPzNqSWz1GQACH7z99ttqXVGbge2HImW8P9YX+6UJ9ges76OPPqoEPwYJOihax/P4s2Pgg334pZdeUgMcQRBKHiL4BUFwBUWhcH2BSApXtAnvfKRbIPVEj/LDYYYfd0vbSDQoCp4xY4YS8+HeGwW6KPKEA44e5TadUvizYOYAUWUGEd1IUXB+/vfff087d+4MivKj+FSHXxspOph18ALWCY5BDN5jzZo1Qf0LErH98bnxmVBMiwJbfX10ELVG6s3s2bNjeh/e9thW+rZHisuSJUtCthMGerjcfvvtajCCiD5ELwquAdKCsF/ggkEeekSgmBnfeaRtbkuXQRE4XJvwOQF+C5gZi/RaiNTj82AmTf9+eCbHBKlSKPhG0TFSe1Cwi9QtHbg6YSYBF+wHGASgmFcEvyCUTCSlRxAEVyBI4YACoYBcZDcgKCFsnn/++aD7EVWEgGGnH4B0GTcLykSAyDNy3V955ZWQx1CjwO4vHNHVI9lIp4BVpw7EG0T4c889F7Qs3Gy8gG2F/Gzd7hPbDq+ngygvorf/93//p0S7ic0qE+kjsGRk8B54r0Rvf9u2s20TCGxEsTG4gmtMtLMI2PaYdYFLlL4sHG3wXbFLDdKGzB4SEP54f7ZiRQqSCbvhmHatNn777beg/PoVK1aoiDry6bE9cIEtKPL4bQMc/fuzbb/ff/9dvUe4bfH++++rSD+a1umzKKYVKn7HmA3y8rkEQchOJMIvCEJY3NIRdDAYQGQZ0VHki3fs2FGlEkAAocBSt95EoSNmAxBRRd4/8q179uyZsG8BYgi52YiIInKLKC8ENmYfcD+KLFEcCaEGMYnPglkNREUxSIDw1gU3ordIs0G6BSKsEPB//fWXKkxGvriXbYV1gM0mthW8/hHZteVqI+8c/ukQq0itQhQYVo8Qguh4jJkLHUS6Ea3GIAdRcFhF4vmwGdW3PwYCiHJDBOLzcQFzrCBqjwgyUkww4EAtBb5/RN1NEEXHYyiGZptUbF8UV8OqNFzaGLb9LbfcomYSkCqEz8Wfs3v37ip9BqDYGTaYiH4jjx3iHzavLMI5zx0pPRgkYOYA+fR4HaT7YJtFAnUISK3RbTkB1o15+OGH1T6H/RvfH75rDDQwUMBvgAcd2I+wD2BGDeuD7YaZCCyP/dANDJ4wIEW/BXwHGBwCPA+DRXzXiPRjcIVZBGwTQRBKKGJUJAiCzZYzHKYtJ9ixY4eycKxfv35RmTJllG0k7AN1i0cwf/78oj59+ig7Qd3GMh62nLCctAGrykceeUQ9XrZs2aLq1asrC8t77rmnaNu2bf7lPvvss6IOHTooe8XGjRur58Dq0VwvWELiubBcxOc46qijimbPnq22SyRbTrBp06ai888/v6hKlSrKnhH/s5WkbssJ/vnnH2VlWbduXbVdDz744KITTjih6MMPP/Qvw9tuwoQJRZdeeqn6fJUqVSoaOnSoei+dtWvXqu8Olqt4Dlt0un33P/74o7of1+FYuXKlsqSsVq2a+kywcV29erV67l133RW0LCws8ZkOOugg9X3A9nTEiBF+a8pI+yFsOFu1aqW2B6wrL7vsMmVjySxevFjZWTZr1kx9lzVq1FCWst99951/me+//77o5JNPVvsrrD5xfc455xT9/fffRZHAumF93377bbWf4zN07tzZuo3WrVunlm3QoIFaX3yPsFt9+eWX/cvgN/Lggw+q/Ydfa9y4cWpfwn02W06d//3vf+r+G264Qd2GPW6PHj3Ud4H9E9vqgQceCLJsFQShZFEKf1I96BAEQRBiB51pkauN5lM2u0shviBNDY3YzBQ2QRCEdEVy+AVBEARBEAQhixHBLwiCIAiCIAhZjAh+QRAEQRAEQchiJIdfEARBEARBELIYifALgiAIgiAIQhYjgl8QBEEQBEEQshhpvOUBNG1BY506deqoTo2CIAiCIAhCeoGO02hO2LlzZ8rNFYmrI1vDAxD7PXr08LKoIAiCIAiCkEKmTJmium8LAUTwewCRfd6B6tWr5+UpgiAIgiAIQhJZs2aNCtCybhMCiOD3AKfxQOwfcsghXp4iCIIgCIIgpABJvw4lpQnpEydOpBNPPJHq16+vWpWPHTvWddn//Oc/apmnn3466P7NmzfT0KFDqUqVKlStWjUaPnw47dy5M2iZmTNn0pFHHknlypWjBg0a0KOPPpqwzyQIgiAIgiAI6URKBf+uXbuoY8eO9MILL4Rd7pNPPqHJkyergYEJxP6cOXPo22+/pXHjxqlBxKWXXup/fPv27TRgwABq1KgR/fnnn/TYY4/R3XffTS+//HJCPpMgCIIgCIIgpBMpTek57rjj1CUcq1atoiuvvJK+/vprGjx4cNBj8+bNo/Hjx9Mff/xB3bp1U/c999xzdPzxx9Pjjz+uBgjvvPMO7d+/n0aOHEl5eXnUtm1bmj59Oj355JNBAwNBEARBEARByEZy091e6fzzz6cbb7xRCXWT3377TaXxsNgHxxxzjMrd+v333+nUU09Vy/Tp00eJfWbgwIH0yCOP0JYtW6h69eohr7tv3z51YXbs2BFxXYuKipR9Z0FBQYyfVshEcnJylPUX0s0EQRAEQRDSkbQW/BDlEFNXXXWV9fG1a9dS7dq1g+7D8jVq1FCP8TJNmjQJWoart/GYTfA/9NBDdM8993heT8wgoDJ89+7dnp8jZA8VKlRQBd36oFIQBEEQBCFdSFvBj3z7Z555hqZNm5b06Oktt9xC1113XVBaUZs2bVxnIZYsWaIivUghguiTaG/JALM6GOxt2LBB7QMtWrQQZwBBEARBENKOtBX8P//8M61fv54aNmzovw/pMtdff71y6lm6dCnVrVtXLaODtBo49+AxgGt0XdPh27yMSdmyZdVFL/x1A4IPoh/uP4j0CiWL8uXLU5kyZWjZsmVqX4ATlCAIgiAIQjqRUpeecCB3H3aaKLDlCyLoyOdHAS/o1asXbd26Vc0GMD/88IMS4D179vQvA+eeAwcO+JeBo0/Lli2t6TyxIp6vJRf57gVBEARBSGdSGuGHX/6iRYv8t5EWAWGPHHxE9mvWrBm0PCKpiMpDrIPWrVvToEGD6JJLLqGXXnpJiforrriCzj77bL+F57nnnqvy8eHPf/PNN9Ps2bNVqtBTTz2V5E8rCIIgCIIgCCVM8E+dOpX69evnv8158xdccAGNGjXK02vAdhMi/+ijj1aR1tNPP52effZZ/+NVq1alb775hkaMGEFdu3alWrVq0Z133imWnIKgsWsXESbBqlWTzSIIgiDEidVfExXsITrocKJywSYrQgkS/EcddZQqfPQK8vZNMBvw7rvvhn1ehw4dVE2AkF7g++/UqVNI9+REgEJqNHA75ZRTEv5emcg77zjXw4YRSRmCIAiCEBem30y0dQbRUeOJ6g+UjZpC0jaHX0ge6FUAlyGzsZkbGKRhlgRWlChaRe+DhQsXUjqALsoYRAjeKSwM/L91q2w5QRAEIU4c8JmelKkimzTFiOAX6LXXXlPdjFHcvHr16ohb5NFHH1VpU6ibQIOzihUrqmZme/fula2ZgWj17BTFhJsgCIIghCff17i0TGXZUilGBH+CyM9PzSWWwunRo0fTZZddpiL8kWonEN1HCs7tt99OJ598skqXevPNN9VAYezYsa7P27VrFw0bNowqVaqkZgaeeOKJkGXQ3fiGG26ggw8+WA0i4LT0008/+R/HuqGzMt4HnvewwMRAY8WKFf7HUaA9Y8YMlcKDi/55Nm7cqLovwz4Vz//ss8+i32BZLvilUbQgCIIQvxOMCP50IW19+DMZCO+RI1Pz3hdfjG7D3pf/4IMPqFWrVsr56LzzzqNrrrlGNR5zax4GJyV0KEYaj14YDXGO1CA4JNmAneqECRPo008/Vd2Rb731VtVUTU+/QfH13Llz6f3331cuS8i5hwvTrFmzlEAH6Gb8wAMPqEEGmpxdfvnl6j1//fVXGjJkiHJhGj9+PH333Xf+dWMwGMDsxGOPPUbPPfccDR06VPnnow6kJKMLfv1/QRAEQYiZgv1Ehfuc/yWlJ+VIhL+Eg3QeCH0Acb1t2zYlzN2A2Ad16tQJuh+3+THbLALe5/HHH1duSu3bt6c33nhDNUljli9fTq+//jqNGTOGjjzySGrWrJmK9vfu3Vvdz8B69fnnn1f9FeC6hNeZNGkSTZkyRdUTYAYhNzdX2bfigvuYCy+8kM455xxq3rw5Pfjgg2q98LySji7y9/mOzdkE+ubJQEYQBCFF6TwgN71Tel544QVq3LixyhxAADOcNpgzZ45yhMTyCI66GY9E85rJQCL8idiouU6kPRVEE91fsGCB2gERSXeem6ui5BDncNCJF//884/qQsvN0ACi6txPASCKj07Khx56aEiaj96PAevYvXt3/23MTiDNZ968edSjR4+w64H0IwYpQ1WqVAnp1FwS0cVwmKbSfvbsQYdhyghQhDxmDBF2odNOS/XaCIIgxAbqq1wm3tOX/F3Odek8otLpKzdHjx6tbOFRlwidAgGPdGFoJGQkmCDToGnTpnTmmWfStddeG5fXTAbp+w1kONEI71QBYY8oOzcp4xz9smXLqii6ng7DIGoO1q1bp3LxGdwujjsOou1wCkLXZFzrIGofD9C4TQcjc3RlLulEI/jnzSOCw23v3vhenNt9+6avlSdq0HGi3LiRCDXl6bqegiAI4QIXKJFr356oa9cM2k4Fvinj0mUpnXnyySdVA9eLLrpI3YZI/+KLL2jkyJH03//+N2R5BB058Gh7PJbXTAaS0lNCgdBHHjyKZ9HdmC8oeMUA4L333rM+r0mTJkr0f//99/77tm/frtx6kGZjA+k5ENtYhtmyZQv9/fff/tudO3dWEX5E3JFyo194kMHrjYZtDEbLW7duVV2XAfL68TqCd/bvD/wfKfWF21n88gvR+PFEy5YRTZ6cHZ9NEAQhHcGpE8eyP/+kzILz93OSL/h37NihtAlf9rnkqyL7AIFGvS4RTVxxG3WJsZCI14wHIvhLKOPGjVOie/jw4dSuXbugC3LTEP23gag4Cnvvv/9+5XKDVBy472CQ4NbUChF6vA8Kd3/44QdVWIt8evwAGKTyoIgWr/Xxxx+r4mCkGz300ENqVMxg4AALUQwe8IPC6xx22GH+dB7ky+G5GLzAlcftRy7Ez6XHSxpQKjsIMzIOFAQhE8nY01hh6iL8bdq0UVkKfHnooYesy0EnIEgYTV1iJBLxmvFABH8JBYIeo01b2g4EP6LoM2fO9ItoNLRibrrpJiW6L730UjWthXQcOOOgMMUNOOOgGPfEE09U74tiXBTd6qA4F4L/+uuvV/n9GED88ccf1LBhQ/8ysNS8+eab6dxzz6UjjjhCDSaQK6evO4qP+/XrRwcddJDrTIVgF/zhrF3dBHM6Z0WJ4BcEIdPJy8vQmUpO6clJfi4lHP9gQsKXW265hUo6GZBpLiSCzz//3PUxRMuRy8/FKcjP14t4EeW/99571cUrEOZvvfWWujCI+Osgeg/rTFzCcdppp6mLDdQffPjhhyH38+fRQSqQ4F3w796tb+dA1CmdI+c7dwb+T+f1FARBcEObDFfHXaMcLX1JYUpP5cqVlTFHJGrVqqXqBqFzdHBbTyeOhkS8ZjyQCL8Qlh9//JH69+8fV9eeRAJRhxSTWJqQJZPly4lWrqS0QBfC4USx/phelJ7ODZb1qfBYBD8GOfpAR8h+MGMF97w1a1K9JoIQeuzKqPSeDCjazcvLU9kGel0izDxw260uMRWvGQ9E8AthQfddPYc+3dm2zTkgpnPwHgIZBa9ffpke6TD6ySTcQEl/TH8O0mZQVJZuufyYudixI3bBj+8GGWFvv+1YkQolA3gJTJ+OWdBUr4kghB674DyWMaQwhz8arrvuOnrllVdUXx9YfF922WW0a9cuv8MOUo31lCAU5bLRCf5ftWqV+n/RokWeXzMVSEqPkDGgQBcXLwdGSwZP2qBHjCGi9fzMdI7w64LfjOrPmOFYdEb4epKK6WgRreDHZ+TnIBMN/ekqVIjf+gnpX/eBfT4TLJaF7EY/9sLkpXnz0F4oOP4igwQ2yWnj1+/P4U9vwT9kyBDasGED3XnnnaqoFhbjqEvkols0BtVNRlavXq2cBRk0FcWlb9++9NNPP3l6zVQghzIhq0/cFStS2qFPySZa8CNKDRdTnByaNHG8823L6FFxtwYvkQSzboGZDphmCNEK/h9/DL6NGvbDDiv+egnpje49ANvZZs0oq8BvHDOhtWqlek0Er5jHLtQmmYKfLZMbNXKO9WnBPz63vwNpNv1r4YorrlAXGyziGRiZ2OoCo3nNVCApPULWkq6512aEPxnpCYgKvfuutwj/5s325dK9LsLEPB5HK/hXrQq+bdRfRQQDqQUL3LenkHqQq4/0On3Qqw92Mypf2iNffUX08cdES5dSRgOB+9dfVCIwj13hUkETtc8igKKbIHhijy//aOeSRKySECUi+AUhiUybRqTV8XgS0bNnE33ySWzFsWYtgy0oYZ5M3BppZZrLje5sEY8ZiGjTxCBGJkxwLkJ6gsEwCuj1vGj9N5lus1bRzE79+qs92MAzX9984wQEMhEMopHC8scf6VEHlWjM80Q4a85EpPNs2kT02WfuQSNXyvscadoHbL2F1CGCXxCSiNYk2LPgnzSJaMMGJ0++uKxYEXqfOZBAZNsWybGtq3lywUk4XVx7qlULvl3cwttoBzxIBwH47oT0QxfzumjU9/NZs5K3PhhQjhtHNHFi8V4Hg/yFC4nmzAkVwxjg6BiZChlJygrq5z9F9GENoo1TEr5fmANP81ic6H02ZseqQt+Kl68Xz9URYkQEvyAkkEiCPpo0mVgi7GZUGukL5vvbGv/Z1ssWVTr7bKKzzgqeZv/2W0oLeH3RMwBEOxAxc2QjfVcbNzpRfRZZ6Vw4LgQLRf271f9PppjEwBAzDfPnF2/f0cWhuc9mSzRc/xxRp5nEi2nXEe3fQvRNz4S+DeotohH8mP2I98xUzLO7+b4fUI5xMBVSggh+ISuAuDNzpc2UjmSDE9GoUUQ//OC+TDRdE3Ny4n+gxsnEhk3c2sQPRLHZrDkV/uUQ86ZdHW/bypUDy0RDjRrRbUvkRSPF4NVXs0tcZSt6rrO+b6SDSEaEPlb0Y4q5z8ZyDElH9M+Vkhm0QlNxa9ZOCXSN8r+d8fbr1ye2fi1mwV/gO2nkiuBPB0TwCxkBGn9dc801YYWreVCKNZcRnYTHjh1LxWXuXEcsaNa8IUQqBNXFBnL5oyWSWHE7kNsGIqg/MIGAwHZO9eAKYhvpEHohIn8GbrYYbbTW3HbRFi3rUdpMzQXPZvTvU+8hYX7Pb7wRXHeTKPTfIlJtYhVtpgtYOMHPg+Fs+e6SRoERPdhlyZWME/x96t+dGbzg9MFkCP6oxD8LfonwpwUi+Es48Ie98sorqWnTplS2bFlq0KABnXjiiUEd4sBff/2lfGXr1aunlmvUqBGdcMIJ9Pnnn4e1p8Jj8KHF88qXL0/HHHMMLSxO+Mr1fbzdp3P33Xcrb9xE4WXAoTeG8tIp1i0i74bt4OylKNEU/G7bkj9jqqPZPK2v71r82VjwRxvhN7ddcVyKErDLC8VE32f14nZbgeQ//yReWJq/uVhFm/6b/uij4M9pDsxTPVDP2M6z3FBKT+9JEHzcatCAqE2bgLuUTpkyyRP8Zh1I+CeK4E8nMvTnLsSDpUuXqvbPP/zwAz322GM0a9Ys1RiiX79+NGLECP9yn376KR122GG0c+dOf9c4LHfqqafS7bffTtvCqNBHH32Unn32WXrppZfo999/p4oVK9LAgQNpr0f1hcXgEJCJ+dC64HcTxJEOzObJzBQjEJLI+XXD9r56pNvtZGkOBPTlDj3UEQoJHCvFzJIloYMAjmJiW0ezH/G269IlesGP99FPkhLhtwNHKLNBWqo7TLt9z++/Hyq04kmkPG2vmAP6LVtC92nu/ZHqgXo8vruUmAQseC749pqvEvZWfOxFLZKeZqgfy9AjJJGCX9+n8Hv1nEYlgj+tEMGfyBy/VFyi4PLLL1fpK1OmTKHTTz+dDj30UGrbtq1qCT3Z582IVtDDhw+nwYMH0xdffEEDBgxQswGtW7dW98+YMYOqmkncWnT/6aefVoOCk08+mTp06EBvvvmm6lIXLmUG74lW1pUqVaJGjerR888/EXLy27dvH91www108MEHq0HEoEE96ddfA5YT778/ipo2rabep0WLFlSuXDk10FixYoU6yY0aNYruuecetf7YBrjgPmbjxo1qQFOhQgX1/M/gSVYMcOLVD9D9+0dOM0EKT7husfgcsN+Dq4dpv2lb3naC5JNJ48bBy5iFvPpz0MkR3cF79HBf92QKCdtnRN4rCyg0GEK3VHzWaDzx+XUPOsg+dY7PCE9z7MqmBSKeG/M0eAkB3xGECvbxVGwfXbS4iX8TRDdxKIi2J4MXQo9xsb1OuNRG3n+52Wem7pfhun4nnO0LiWbfE3p/YRQFWTF8VkTx9SZwfIy1fYc4fcNEIF6Y+yJifKgb+OWXCPupCP60QjrtJgII78UjKSU0vZiodOSvdfPmzSpK/8ADDyjBbFLN52n4zTff0KZNm+imm25yfS2IZRtLlixRKUNI42EwOOjZsyf99ttvdDYsXizceOONNGHCBPr440+pbNna9OCDt9LMmdOoe/dASBnd6+bOnUtvvfU+VapUn7788hM6++xBNGHCLGratIVaZs+e3erzYZCRl5enBjhDhpxNn376Kw0ePISuv3622gbfffedf90YDAYwO4GZj+eee46GDh1Ky5YtoxpmJacLOAjrNpo4KPKBG5uLO966Fe3ifthxmuA1jz3Wef333gvcj4OvaUOpnxSQ1sIpCfogg0UxO9m4nUT5Nl4H6x+p+A8nhOrVKeFgvWx+45gVYhDhx/bGoCiaSDtvO33bfP010XnnEVWo4BQJs82pWTSH95EIf3j0ATDESTI7zuO99ZoUCHh835i5ihRZx2D400+JLr7YGUjGi3CzatFgrj/2Q3w+zE5wtJ/XOxMj/EiD1LtgR2N8UFzQU6NWwUpqa3tw32ai8vHfifk4gmOuvr/hftynH2fq1w+YF6Cu6dJL47MO5r6IcwibUWC/5QBW6DSn78QhOfxpgUT4SyiLFi1SEfhWrVqFXe5vX2eWli1b+u/7448/VPSdL+NQLWkBYh/UMc7kuM2PmSBt6LXXXqPHH3+cjjjiaGrTpj0999wbVFAQOIstX76cXn/9dRozZgwdeeSR1KRJMxox4gbq0aM3vffe6/7lDhw4QM8//zz16tVLpS4hHem33ybRtGmYly+v1j03N5fq1q2rLqgxYC688EI655xzqHnz5vTggw+q9cJMiFcQnTenndF1FdStGxCRbhE2N9HBKSsQSPq0rdtJD02FQNeugUg1nscHcL7mKX7GXC8W/OXKkScgiJIhJmADivxqE/29sc48QIkmoqmfaHUQ1TLfwwTpRCnPM05z9O3ncghJGLaoMKfG8W/P/E2YjBzprLett0UsmL/heKT0AOyH+D3q7lkcKcZ2SKZgjgcYdOska/0xI4Rj+IolLj6gRYmN8EPs6zUXtgh/kybJ+b2gczvjOtul1zmIS09aIBH+RIAIOyLtqcBDdB+EK7SNBFJzpvsqd5Dukl+cakaDf/75h/bv369mAfhAXr16DWrWLDDgQK1BQUGBSkEC/FH2799HNWrU9C8HMd+tW3f/bQxuqlatRn//PY+6dOkRdKLAayAqzffhMzKYAalSpQqtN8O4YTAPghB8nFN+8MGRBWikTWqKUAj7tkbYSU9fwfJIbcFJCylAEMqnnx6cH3r88URffhmY+kc0kKP00Qp+RH1GjyY65xyKCowv0fgLaUNeCgptJxucCPl7xLYGsQh+PqGa6xGp0BqYGWuSwx9KcVOeMIuDdCCkltlmt8JhE4lcisSPIWoJ16dwNTKIpuISj0iquU5etwl+pxic8EStWVJlex19MIPgROfOlDGYaXlIDcO2MwtX483Klc51uVJGrkxuRceWk5tMeQTpbDge9+sX/ljH5wJ2RMMF5ytT8OM1bNsAy+I1irN9bNagEYMZnM6jVl5sOdMBEfwpFt6pAkIdqTjzw53NfMuBBQsWqMJdAJceRL4jgag5WLdunXLpYXBbd8fBAQsHJXN63MwU4gMcou05OTn0559/UkFBTpAAq1Onkt+VhZ/jln5iNqjRT7g5OcFHR2yrwihC1hDKukUkBDMfmHHgLa7gN1fFFmU0BZWeuYXtjci4ntJzyCGOyOGp2jFjAmkL0Qp+gO9FHzR4gTt/ohgZux5OhuGwZZNh2+l5r6C4EX596pxfK5oxswh+9+0bLdgXsR8iZQHfAYS/bWCJ/Q8D244dAwM/LIvvwha9x76E/YZT35C917AhUaNGoVFlE04HihXMusVStAvx++GHzv+9ejn7u37c8SL4s2H2Cc3+ELBIJOixAfJKGXZNpcpEzOHH5DBEs34885XJqeMc9jMvEX4+/uA+/l752i29DEEcBFGOOsoxXIgW7Nvhas1cj23cdKtUDlHpBI/GBE9ISk8JBbnoKGJ94YUXVJGsyVZfFSiKdLHsI488EvV7NGnSRIl+3eJz+/btyq0HaTZ88sZJC8IQB65mzZpRmTJl1DIsqLZu3UKLF//tP7B17txZRfgRcW/WrDk1bepcWrZsTo0b11Xi1Tl559OUKVP9741By7ZtW+nQQ1ur28jrx+vYKK4rkDnI0A/QLCD5YGp7r0gney9iSX9dDGa4boDBAECP8ANTtLAFGx/UI6U5mBSnC2asVpbYNjx400+S/JgJ9kHUQ/AJWH8d3iZ9+gTu59eKZmJLBL/9e2KaNvW2HfEdvfmmc837t23GhWtcEJX94ovAvgybys8/t9fH4JiB/RWvi/2cfy8ungRBFEc0Y+Lw7bdDZxK8/MYXLw5Os8DsnYntdXRxmOjIeDLg6Hui0AMsZUjb4VpcRpTDlkd25Yv9Cfsejmc8O6EHlzBAQ8qVm9kdB3P4O+NjtC3Cb55L8BjEvlsfFS+wPMDrn3lmFE+Ugt20QwR/CQZiH4K3R48e9NFHHyl/fFhuwkaTBTny3F999VXl0HP88YPp44+/phkzFtO0aTNVUStAtN0GouJolnX//fcrlxuk4sB9p379+nTKKaeEnKwhivB+cP9B4e7EiT/QvHmz6aqrLqRSpQK7KlJ5UESL1/rkk49p2bIlNH36FPrf/x5S6xmY3ixD11xzpRo8YDYAefldux6m0nlAgwaNVWEx0pM2bdqonH/iJfht3Tr1FBF9k0XyyrfhRQzoy9gEP9bHzOE3BT+XWkSKIrkBF5twnYYTIYoxc8HinaO1NsGPz488bAhI7IemtR1/X/oATX+taHKHEVnOxALJRGJ+F17g78j8rkxY5Oivr5fg2LpBQ/Dz70GfyUK6kO6OEovgR/wEaV5cU6PjK5Pyw4NvLwNKL70+bMcKvRDdLNgXwuewlynli2Lk1SDq9kLECL/+PfJ5RY+xYaCH1ETbYA2DATN44Sb4cVzSytAU+rEXx7hYjkFsigCjAk+ztUvfI5pwEtEe348sJ4ppYSGhiOAvwcBec9q0acp3//rrr6d27drRscceqyLyL774on852FNOmjSJcnMr0L//PYy6dWtJxx7bX/n3v//++6oBF9O4cWPV0IqBuw8ae1166aXUvXt3lY4DZxzYZJqimg9scMZBMe4555xIZ5xxjCrG7dixa9CyKNqF4P/vf6+nww9vScOGnUJTp/5BDX1zo87BrwJdc83NdO6559IRRxxBFStWoldeGe1/jRNOOJ2OPnqQ+vz16h1En3zyXtwEv9mcRLdpNAWkeULGQRpRyHB46Sqs2w7CdlNPdeITUaQIP5+s9ChStKDTsO6aE00hZSwnKD16y4XNNsGP6KibqMK40W2Axv+7DVDMk66ZEiCEfhfxHgyZPuTz5nl7nlsR+9FHe3ueG7DyRCQfqScm5m+KZxS8CP5wx6lws1oY0PAxg3PCEw3PnngFIth2TIDwBObxLGmCnyP8h47wtRkPH+G3BQZsxw7bZ9VtgE3Bb6b04PtGcy63viTY9tE2j8PyPEjl2VrbuUZ/H5p0LtGqz4n+fta3YpK/ny6kVPBPnDhRdXVFxBfRYN2bHQ4rN998M7Vv314VTWIZCDx4uJv2koj2oqgSVpKIDkNU6sycOVMJSIhMdJLlyLRAKrceTjZowoUI98qVK1WjraOQ8KfRrVs3eu21MTR37jpavfoAzZ+/UQl3dN9lW87du3er/Hz9uXjs3nvvVa48aLYFC0wutjVP8jjB4aAHYf7WW2/RihW7aM6ctXTttTfS2LE/0cMPP+1fFtF7WGfOm7eEVq3aTwsWrKaPP/5Y7S86J554mioExnuPH/8tHXJIQ/8BC7UIr776IW3ZsoX27y+is8++UN2/fn0RnXiiMwOhpzhhhsAGDqSI2IQTdKbg10/yZq49BLJJt276ugSewxEXrIN+Mp01KxDlxokRIsKM8Ot5wyz4zckazt2MFOFHkS0egxuQ2+ePRCwzHZEinJyKYxM/bv7deE89Qmxa37Ggd+t9oJ/g9VQV3aa1pIP9DrM/XvcPbGtbVN4NM0vRZt0KtNIi/3q5Rb3N3080+ynva1yvZHtPhguQvXgEhHtfXl/bYATHH943sW2QUpJIcEx7992Aw1UkcJrHOtkCHzwYw2km3HcST/TftD/Cn+vr6Fc6fITfrBXzkmZlu4+PO3o6qH7NRb16+mG0KZb4nf31V2A99TQjdnk78sjQ5/kHsmzDqf737Xgi+NOGlAp+5I537NhRpZaYQDwi+nzHHXeoa4g55GCfdNJJQctB7M+ZM4e+/fZbZQ+JQQSiyXrOOPLQGzVqpNI6ED1GBPrll19OymfMBnRHgHD8+OOP1L9//5DBQrjX1cFBENOOfILix1kc26JDfJ8p/GzP0Zc1I3i2dTHBQRCRarOACScDbB9EjPXUHfP1TNcXPph7cSvhluoAeaC8nP459PfVbdP09dUdUuHOYU4Xm9uRU64iRfjh2opmXBD8qO3m7rQMxvK//x4cvUPnUr3AMBbBH4maNYNPkrqFp+2zYHuY74nl9O2CfQX2fDYBijp1zcE2aYIk04Co0Ikk+FFAHmnWK5b0MIgoLmTUZ7xstSrh6lei2U/Noloz6soRfi+Nk8KllcGTHRgxMoXZSwODC7fPgPSp4ubIc2qJl5kWDA644aDeJZi/V921hsVtPHp+IECCWgpbl1p9/yxTyndQLMOC33uEnwdWtv3dVkuhf0ecZmam9LCI52XhtO1WBBypSdkHHziBKw5e6QMEbqcT1sl774ZQ4xIR/GlDSq1kjjvuOHWxgSZIEPE6iEQj3xw+7EjdQL45oszwhUcEGqBJ0vHHH6983DEr8M477yibx5EjR6oiTXSSRc72k08+GTQwEOzgoAKB6WUqFt14cfGK22tyV1o3W0Qvr2ETwbrgx4ke7+Pm4GMT7Tj44X5cu6VtoDDL5oXMzW8AvyeiiDh5IYqC5lBu78sHe7iFYIoXooQFqH6S4EYsPO3NJy79hAMBqltZ8vux4Hfbnm6e9Dq8TnA0xeuaRWKIcPfs6YgLPvF9803A0tD22SPlyUf6/jlSy4MeM3fWxBYNxWfGtmcg9rmngglcOLBvzJkTSKWKlG9eEjFFbqSAQqTvGb9JFKHzPhiNANdTaHj/sPQiDFu/4jZYxW/QTD0xAwZmsSaOHyy48LnxmfA6EM2tWwfXE4T7nBBmENi2ugHbcRXHQ/MzooaHZwpjPV1GU+uCwZBZ84PvBN8HBgL6Y/hd8vHPbftz1NsL/DvFYPSII8IIfl9KT2FOJfp5AlH3vWVIZRkVHlADI6yrPgAxP7/u2GZLVdLRvw8W/OZsJc8E6R3B3dKdwgl+/TjFtVt8PEQQg89RNvwzYvs1z9R9vjxOEfxpQ0bl8G/btk2liHAXWHRrxf8s9gG6upYuXVoVavIyffr0UWKfgTsNZguQymEDqS2YGeDLDi/G21kKi+9E4Pa6umd9pAg/Yx7UL7jgQlq0aGvQc/QBhLm8eVB2i9JHAoJffy0+iJue+IDzLfX0EfM9cMA/44zA/wBi09YcSF9n/eRx+OGB//Xos044q0m8rhfBr+M2SIPINj3qE1m8zOvhc5cN2l62CKoeQWRUmm5pZ+YiEjjZ43s691zne/M50woU/vcVq0Ung3QRzQzMs8iE+ObfFb53Pu7YBD8Gb4zZJNy2n2I/xyyWXktj/jbwe9MHAIjM6mKNBRcKjhGpx2fEYBKvC4EWzh8dAtAUkfj9skWp+RtFnYH5erpAjLXOwhYxN8Hxcfx4+wwAn6bNgYBeC6Vvf34tFOTbaiYiYdumwRF+ZydZs6GyOhbv2O0cVLZv268sMDEb5fZcgOfY9nfbPqvXWZhpl/yZeTZL70VhzizyDHE4wW+6lOnrHum4z/uUX+Tr/0vTrbQhYwQ/crCR04/up8jXB8gLr127dtByaLYEG0nu5IprW6dXfszGQw89pGYY+NJGz6dIE3CiwMkg0c4f4aIjxbFcBF7XndchmpQe23P4wGiecG0nJdu6eRn44KCtH7gRkQP6lDgfqHm31IWneSJAuwP4gevvj4gOH7gRTTaneM3IkC7y4bV/8smh623mhepgu+l5ol4x86OBzYmCsaXIRCqG9BrJZeETaZ+zCf5wgxjc5zO0CloGJ1z+3nTEqce+n4fbLl4DDrpFpf5/OCC2OUqM363NpYfBzBVqVTCQMyOotqJ0HuSbs0H6fqQfK4YOhQ2y8zgPTHl99OMTcu4xQwKBZkvX0THX84ILAn715m8Zr8k59vx++gxipHQQN7x0UUa6FmYibP1E3Dzg9Qg/1hcDLMyMoC8Bz2qY6VOxpoPp3y9H+FesdVR1ITkrsX5N4MvUvy+z1gfrxDUlOEby7KFN8PPvpF077f19n5lnanl99e/KFPy8P0f7HXoV/P7fmx7h5/8lwp82ZITgRwHvWWedpbrD6u4xieKWW25Rswl8mTt3LqUbODjjkujJh3An23DNOLzgdcDgJYffxBT8PECyPe4W1fbyXjjY6p9D94DHQdfsCql/Hk4l0NMbzAiXLtz1AlA+oeiCXxdRfBKAu4iZG6pP/fL6mHUF+v9m3qxXvGZ38bpODbRM8OMWwcT3g5O6V8Fvq5ewgX3E7TVt+wSm7lEnDqOqs86yP09vtiN+/I7oMHPCw32P0Ub/cbjm78rsIIuajoEDA7fRfVqP8IcTOPiNYPBsG8ihSD7c+ugzS7qw42MS1gGzCvw7ZIHGv/NIOfR6CgmOOzyoN1MP8T587LMNYNmeFrnsOBbp2z6W4z2CGfpv2K0OItzAHt+lbZYA3xEGNDyYRyDErA2JF1xToEf49+Y7OS6FRc4BdtuWwEgB6YyoF0KpoF5PxUKdtyXOKRwUsgl+23GXU3jYCY6fp29b8xjP+xNinLbjmFtthVfBn0s7ae/8d4nmaoYoktKTdpTOFLG/bNkyldPP0X2Apk5ovqSDZktw7uEur7iGc4wO3+ZlTODegvfhS+VwyWspAD9wFg6JFhCJfH2vkTs3wY8DF0csIkX4zeJdswgz0rq5RSDNXGS9yytOrra8X57+ZMGPkyxHgUwnF/35vDxOcHzCcIvw8/+2vFA3m0mOOKGIEekrfAKJNcKP90FENBKInukFvV4EP7YTpu0jvT/jtdMuOqoitcGGbVvy+qFAUp9S10E6EX+P0eQzZyu27y3cdnH77dnSbszCbHwnepT7xBOdiCoGZ4jYY3bGq+A3MQvTvR5HbYLfFMK8L9kCBja6dw/8jwEozx6G89h3E/yc2oEuxbYgAmoOIKxj2Zdtp1IvdVi2wBbn57v97hIFF+2u38wRfufLK8g/EDTI01PMgJFo4LzG+uAZJhNb9N4cHPPz9GWwndk7A52mWfBjf/rxx9D3wXdtw+33gDRRnHu4MLxj3qNUbtpQos2aVV2huPSkG6UzQeyjIRTsHGuy5YYPNIeCXSLcdxh4wxcWFlJPVAf6loFzD16LwcChZcuWVD0epf0pIJlRQjPyYka3ipPfzweoSOMpt5QeXWy7CX5+nv7cSGLf9hxzm/OB0Hw+Dsb6AVg/EZv+1zhg8i7tUk4SJPh10aq/h03MRhIuusDQ3wPrhhMFxJAu+KPN4be9thuILrlZVuqfSd/WXBTrlrqAojs94m7bRl4aDumzFMjhNlvTe93/dVFZ0rHZTbod0yD2zKJnzFqddppTJ2FD/16Rwqb/3nmfhkjEoBa/Qf27iWZgi9Ixc39gwg0szWaD5jrr+3O4HH0dfC7k/+P4gjRAJpzhgZtLldvn4FkMdCtG6owt59vEPC7bZglsxfM6+E50C1eGvzfbQDza32i4ZczfbBlyIvwHqHJQSk9BhBEQ9jVzcIL7wgl+Luh2K8LFtrENCgD2TThJQwrpKWoYECP9yYvzktvMLlKMzj+fqIfqYVlIjXLCWGhJSk/akFLBD798OObgArjrKVx4INDPOOMMmjp1qnLaQUdY5NzjAtcd0Lp1axo0aBBdcsklNGXKFPr111/piiuuoLPPPls59AA0XULBLvz5Yd85evRoeuaZZ+i6666jTEU/UHtxIEAUHIKyuIVxth9+pIOpHjXzmn+vg4O5m+APd3wNJ+rxmFfRHy6qYos8YuqZI5g4AGN6XZ9WN4UNRyndcsf171pP3dF98W2dX3mg5nbC59kCL4MCvG4iBX+41C7exohMjRrlTGOjCNKc4sdJjXNhMchq2zb4JBnOAtVt/8Pr+IvRfK+hF0ADjw60YU/qJQm3Bmx6YbgOIqWm2xOK3ZGKg+/NbDSkH2/w3bi5adm+GwQQuMDW637OUX5zP4e9oRt6Ea/Z+I7h26aBgRt4f+T/YxCkf2b998+5+wwGQ5HQj0mcD8/3md2MbZjHSPxu9RmYSOlQAN+nedzU0xAjfcdeBtlugQUz3aU07aecUs7KHChiwe8cKAvzw0fisE+ZATM95ZKPDdgPuaaBB4f6sax//+BzO89y2+pO+BhuziBh0P3dd5G3R6QBMEoou1T6H9XKMTpN6uRGGJEJJcOWE2IeXU4ZFuEXXHCB8sr/zDe33qlTpxC/d/Z6x2AAIv/oo49W7jynn346Pfvss0H2nt988w2NGDGCunbtSrVq1aI777wzayw53X6IiAzhQIBJDD5o4GAbbXYSDqqxFtRhkMEHW0Q2zAiELvghjG0nNv050bj0sKjnSL3+XH0QAdw+Hw56bulEejTQDV53fZbEfI5enKd3iA2XlmK65mDQgG3HIhgTXnyCdNs/IPi5Zt0tepSsCH+4QjLeXihywwkRbiU2IJBw8oSYsmXq6dsOF2xX/kwolkQqj+mmEsmL/fTTAzM0kRDB7xDOohT7mSnebIXcZkG6Xuipp5/xbydSUIQLHPXBmNeO0rw/8PGAnxeutkqP2rul9LDgh9j04l2PbaKLYEb/7KbA99IjIlyQKFohzSDVha1Fccxya2DH2I6z+mex+dfr4HuNtIzb50TBtZ6D7++yqyL8lYJy+MsW4QCCE0Up1/fQZyPOPNM5P/NxG/suZjtwgSDHvm8T7JjBwTphtgSBED7W2wR/uGOZPojC47YGYV5qtzqWusP52KDtbUR71xH982pggTJJzrkS0lPwQ7SjENeNcI8xcOR5F55sYejQoQP97JaklqZw91Yc+N2Ecjj4IFLcwtpYU3bMBkb43+2gy774wBT9tnx72wnc7T5T8Jv560A/4eAAzOk1OGlzREaPdHATLf09bQdEFibhBgZ8YsfB1tZh103w6wdiniXgbacXmLkJF11YuTVS4ZMEtkOsgl//zpEmZBN84U74ZjdJN3Cyw/a2OQOZ643Pgiga7xNuXt1u+yui/Ph9eRX70ab0ILKH/S4bm3aFO55A/EaK1iKVwDbrxdgGp5HEHgcA9HXzup/rQgrvHU50MTgm4zeF4Au77HhJL4tlYB1usBNpu0TaX/EbiCSmI80q24IcJvjtm4JU/51H+q68zKrpKZX6Ok+YELxc/z47iaYR5ReVoyKffCrwRfi7lb2LqpWeRz/se891/9Yj/LzdOM0T+5/pYmbLzwcIaixZEjzLEm4fivRdY1/UZ9/4tbykuJUpChzAt+U3oqqtLwgW/Hki+NOFtM7hL8ngYIoTg00M2brHuj2upz64HfzRqyAnJydi0yycGDEIe/jhO6ldu3rUsGF5GjDgGFVjEW4dIq2nntNu5jjaupzaBGC4QYBb/r4J3svMZzffV/dA5m2LA7ZNqHg5oeoRftvJ1ZbDD/jkh8dZZLg1jbKhr69bhJ8HEqhxj0eE39xObrm3KKREoZn+PUcSDpEEE9ab1wUiS0+5wGO2/dPt+4PodHJXveM1wo/IHlLCIsQwMhY3a1Mvfu0YAJkpVebv2Sb4MRmMfVx3SzJfw4yARtNvgvc9Xn+3fVUv8oV1JDtNAXPm1eYEZHLOOcHrES1ejk/6Z7ENKiIJ9ki/23BFybpdpZnSow+sIg2i2QIzHHqhPr+eLcjQoO6OoOi+nsMPmpd53/U9EJDR9zPe/vju3ArQ+bhkbnuktAHOw9drw2yE6xKtf2ZuOMb1cdG6s02bUZb2FxoHYxH8aYMI/jTFa769Tai4nTjdDgivvfYaXXnllaq4ebVm7KxHxnECwkHp0Ucfpddee5Yee+wl+uqr36lcuYqqkRn6JIRbr3A2l/p66f/jIIaDon4fDpoQtmYucCTB72WmgpfnE7gtnchmgWlr5KU/n5s+AbNOnA+kZhEq+7jrBXg2wa97UdvEpJcIv9uJn6NomGmKh+DHdtVPPG4uJ3AZ4XXyGuGPJPjx/XA+PtJ3GKyPW3TUiyDyiq1BkAl+QnpTsuLOzqUjunBDexMUVnMKVqQCVZtoMX/XuuDnfR+/OTTK0n+HJuY+EI2ANpvruR279W7N+K3i++btYWSt+t1Pwu1PGCRg4InBsdtsULjPoR+z9OOMjj7jagtquHWcZvh3C4cavcCZt5HpcqavNwcibAX9+m8z0iAaojjc8R+Rch1et7//DtzXI++/1LP87UT5voLdIl3wB++YXTvZcxTx+fX9TP8MtmON/p2aj/PsIp8HI80seU1p4oEHb9Nw9QE2sC0mTTZ+qJLSkzakNKUnW8HBxUt3wXDg+fxjMyOhOAizGMBBW/8xYlm3A6BNlKJwGoXMf/wxVRVEjxo1im699Vb/59APwIjuP/3003T77bfTCSecrA4Szz77JrVtW4fGjh2riqW9RPi5u2QkwW87wUDs2yLZthNbtBF+fszWddYU/JHeWz/I9u7tOGjgezNPrG5ik5/j9j565CWc4PcS4Xc7GfB+V5wcfjNypb8XR6lsJznTajSc4Nej9+GAsFy2LPg+jqzaBEGkqFg0hGtsxph+3fEosk83+LeLqDsLQN4XYRdoinJ9htMmOsx9N1YL2VjSJvV9CCkh6AQLYev2vuY+yr9hvLeX/de2vuZAIVrwfHjl4/uwpRTqDjq2/TFSCpZ+3MB7oGAX9+H8hueavwesDwrz4aAUbgCoHwttxxHberhtY7MbL38vnOZTjjZQp7xHnBt7ujmvR4EPzjn8TN1qsKEKHLyHDHGEOY7nekO4SOYbfDzXeydE8tmPFbNzO74X/AaiFfwFRWVpxfKypE2AENXx4M0sJAWJ8CcAHMwgXIpzQXS1SRPnYj4G4cKPwSpQfyzcQMN2Env33Q+oefNWVLNmSzrnnPNo5MiR/toJ3cUEF7goYVBwzDHH+E84VapUpa5de6q0oHDvpUf2cBDRD+ZuItyLA1G4ZXXBbxbyhXsN22u5Ta3qy5vilpfFtkKRGiJx5jJun9FtPc33x23+LiK5/LhFxN0EPy+DgUq4AU84dPFjChvbNDafyMzBmpc6iEjYPme4iHsku79oMG1Bbb9Fo11IVnbl5eOTHr3UC1zNz6znVtsGYIiEcwFocQan5u8qmufqBaRms6pw7+GWn20Dxw6f03RUv8NIqUGYIYB7j5fXs+2PuO+bb4gsWZ0Kc7aFf1PYD8zoPmb84IwFgWzWapjox01zkIgZQhM9Wh+t+G2Q+2XgwT2r/MKW4Rx+pkzhhqBjEwwS0DQR37/bAMl2HuDBse05uE//bmMV/Pz98LX+G9P73HgW/FRWXfzUH0yUl5n259mICP4SzquvvkZnnHGe+v+oowapzsITfJVKuvUjgNgHderUCTp51a5dx/+Y28lBd5YxRZZbhD8avKb0hDuJ8AnYNjMQLmrIr3nsscH3ezmRu0US3QSH2bxFF/y2CJ3b6+gH8EiC33y/aEHuNKK5OOnpAz+boIbNW7QRfq8nI9u6J0vw66lg8NZ+443g4mp9mWyO8LPg1wd7+j4aruOqDfxW4c7EM2cQdjyAiGZwau4bum1tJPT9T7fMxefSByPmb1Fv0BcJ2Myi6J3x+tnw/hgonHRS5GXPOCP8IMG2P+L7gl2nrZkT4AxR/owsXhHwMU4ZKsiF75O3vfkZjzzS/Zyh19TYnOh++YU8Y573+pW7MPDgbscSShe1eg4/KNoTaDRh9orA4JAbG+qEO++Z1rO22isvx0Db8Yx/bzbB/9ZbgeNuNCk9hbrgLxXllLCQUCSlJwHgh+XFOzkcetoORz3xo8R9ehSLD9B8MsF7c7OOSOJy/vwF9NdfU2jUqE/U7TJlcmnIkCEqpx8OSuEiZZFOUjYhixMcDuLhRJbbgQ8CIdwUr9cIfzQDChwMsQ309bVZiPKJyRTIXgS/Tcia0RvzIM/ODHh9HIj178dM63ETBvgMEAJs52fDdpCPpTgQETiOwunrZ/suODpnCv5w4tfrIMS27lwEimJxpDZEWj4eEX5Yi+I3DMHftWvwd6KnsGSb4Ncbxun7ln6s0J16zN+GF9tBXUTGmtKDhlqxgvfk4wXWF7ah7DvvFuEPl9YHoYp9xMzR97pv4jfGBfCRwDEH0XWcQ15/3f79hXPUwuP6NkcPBY6sY7AP+Ls1PeAxa206bJnHMqTEYN0waDQDH0gFwnZG6gxmvfHekew+TfD+sMIMtqQ0TmS7V4Xk7Zs5/OVytrueA7ixYTS49QfVfw9eZjnRrA49D/SaCHaW4t+a6ToVrmO824m+iLSdQAR/WiGCPwHgR+1Wde8VHOz0aVC8Jqa3cZ954sPjONDyAdJrc5+XX36N8vPzqUOHQIUY0nnKli1Lzz//PJUu7YRaeD3q+qrr1q1bR3XrBo7OuN29eyf/QRLTgG5iBaJdF9DmdCVvOxxH9JMHlvPadVJ/rXARfog820lBF6KmiwRbiOLAiMdwrS+PpijI5Y216BOCF9Eft4GJ/t1zJAsnOEYv+nSz22S8CAGcqDnvFOtUXBEcLlKPIk5+fVPwhxuoeU3psb0G0uJY+OP78uJ5XlzB79ZV1vzNZFtKj5vjCyLXLNT1CL++nSBGwwlx2+84mhkam3uKV/S+D8g/ZzGK19F/L+Fy+N1+D7iYEWIUoSLlJRFwdB3HOLNoHPtjuGMwil/1GiU9qs4Fy7bvBIEH27HI1psAZWLYj2y/+VNOcc59OEaeeqqzruEaoOnfC74LHAPQRRhglggFyblkfOAD20NSekqVDv4Cq1YpUOcB03EuHDgOccAB5gK63aZbGpC+Lb0EB7A8tnXr1o4rEQZOZvCQA0D6sSesC1JhsNjYXug7oDKlRWKmE5LSk+aRML4d7oeHHyd+vIjsh2v4Etw5Np/efvtNuueeJ+iHH6b7Lz/+OIPq1KlPo0a95z/58gmpSZMmSvR///33SjxBxOzYsZ2mTfudesFL0Xfi5VkIhp/Pxbr6gczmLoEDk9dcdxzc3Q6skVx6oi1A1V8Tz4VTgmlpqZ/8vXT5NNcLkapw4lZ/TRb/umDwF5qVI+rTh4qN/tqxbC+TcCcm/XNHI/gjDWy8gO2FlIFI7iixYmuaZmIK/GyL8OuiXBfCGLCyGLZ1i4bwQ7pJOAFva7YWjbe9fryJVvDjGKY78HBzOHOWzhwsR5PDz6CbLtJzkOKTSCCsbWlNtkZoDAc6bEEn/oy2Y6Kbe5I52OFIs9v3it+YfkzEeUH/XvlYi9oBiGteR31GRi/kxSxuxVI+30sm3znB1qqdpwIzF19MlGOOTIoK1MAnbDGxceDH94kZnWHDQt3L3MwD9EBPND1BcM7i3xLPYuvbMKqgTmFghP7Fnm9oR5GWw1acRj5CQpDhVxoSbaRPdwXykgOLA93o0eNo27YtNHTocFV4q3PCCafTqFGv0bnn/kcJLT5YlypViq655hq6//77qUWLFnTIIU3ottvuUAOEk08+xb8u5sGF18mMDsWar6+faMOJapvg91Iv4NWdxXZgxDoNHOjMcpjTzjZMgRlpkOB1GtfLYCMVgh8nQUQobdte3891wQ+R4RZZvOii+Npn4qQL4dK5MyUswq9Hevm3i26xZuQ/2wS/Pvtkfv8Qx+hB8KWvPhJiilM8vHy/GChjud9/j23ddGEYS52KnjfOg26IKqRjYl/mwAaiyOxdj7STaN8Py9oGN/EG2xLpPWPGBBdO4zvygs1KE9hmvt2+XxzrMMBBUbAXJx4bJ58c6GmB8x4CYhzFR73QiSfa14MHp41zNYN+9SKO4C9Xoay/piKnTB6Rft4tinDC3rmY6OueRLV6EeWUJ8opR3mHjaI2bUpZB4pu5yNsk+OOc2aadctTL+hd1HnAw/bSelpatVJzqX2tb4gKLsfIJvSFCgMHrdUF/UMfPxBlXpWQUETwZwD4Udp+9HrXVy/oEY633nqN+vQ5JkTss+B//vlHac6cmTRs2El08cUX0t13360eu+mmm2jXrl106aWX0tatW6lHj940evR4yssrZ/UNZ4efeKQo6N0wcXCKJGoj2XKGc8gx8/Q5l9LLIEWP9kXCy6DATfCH256xiJZIrxMPwd+3r5O7botQ6jNYuuC3dedl4in2AaKCyHWNN/x5MBDkZjkADcAxfW+bmcuWlB69kNXr4Hny5EB6iJfvGPsp0kKwb3npZhyLa1U4bN8VW+ZeeGHg8+EzseBnV6Z4/VYTAdJkcL744w+nSRjvuzhu4XhvOu1wHr/elkUX67ZZg3CfH1Fs9IOMJoKtg+M4nzcg+HXPfQxe9H0F64EAFT4Tzrd4rGypzdYIP5UOnJC3765Ceto6Ivxh2fQH0b6NRKs+D9zX+QmicrX8+yJStmbPjhyAQkGvW1FvOPg1YbvK3w9/D/px/qyKbYlwXl9UmqjlVa6Cv7CodFDu/q/7nqNeFf5LpdvdGf3KCQkjjQ81JRc3D3sW+IAj77jtddZMtzh8++3AwcZsW96lSw9av76Idu/eTRs2rFMFvAyi/Pfee6+6ABRJcZqCrVDZq7VatHgRQ7aBRrj31E9G5nJmF95U4eauYw5Q4iWE9feLh+BHhM8t1chN8Lv1PjCn/OM5EIs3vO24gNPmc26SLRH+778PHuTYsO1b7DoVze/OLHyO1T42WmzHYN5v9fW3fZZ4D1rjCdYNYtv8DeJ+Wy0KZnMxs6H/lvXUE5uDTqTzADfMixWc37BeEPzmDAMPTLg+CelFGDTyjHmI4Ed0HuQERoj7CqtGJ/gLLI25di/3C36gp6nGsx8Iw8EyBBt4G/BvwGrtvdmwFDMFv+7Mg0aSB66ghr0uowa1xaUnnZAc/gwS/HpBI6b9bBFsHTPlwyaS2XXGxq+//khHHtk/SPDbnh+uY6KXRldeiXZ5XTRGKmTGQTXcgTWeFo3FQT9h6lZ0KFLTv8d4DU70Bi/xdK1h9Gi6LhJ43+WaEJPhwwMOO17BNrnkkuKnksVCNKKO90ObzWqmwbaNkaLu4QaT0Qw0jznGSXk54QSKikiiPBK2Y7BtP8s0wc+Yv0F8J7bfJadv6oMBPd0kFcdR3r5YJ/M8wKmC/L2Y54CDqmy2F6mu+8l/V+lyRiFXRMFv2XA+u09GnyEpblMtG3qRNGZvbL+zUlQQvlvunAeJfr8kqBeBbkP766QcevllZxbTzahASC4i+DNI8PM1hB3n29mW11uT42DBBzHbcqYbjs6xxw6md9/9Iuy6sgh0G3TEM8Kvv4eXk6TufR7pPSPNkqTLSRlC+MwzHX9nXeAjYsOOM/EU/HpEzM3utTjo0/029yac+Ey/7uL2a+ApcFu0MVHEq6Yi07CJwmhFfTSpTQiEoKg12uJr/fcSr5QerzOvmTCTYxP8tgAJfquYacQgj1P49OOU+T0Xt1OwF3g9IfZNwc+zom6Cv9QBn+AvUyU0Iu+jQ9eqxRf8E08hmvuo/yYfy+HKlIhAi242wb0SzP0+h7RRx9/Phr7IjNuI1vraFJfOU+sJ7w62YOUgIJzPYq2tEeKLCP40xDxRcA4sCyKzI2y46BJEDYs2vIZb8aNbdDvSSSvSwSie0VR9XbzYnobz5g/32jYScdBlODXFq9sMaglsszLFFS02onE6KS668LFFAnEy4a7FxQETVrB4jDYKXByiiVKz5aJXe910xquYDbd9Evnbs71/vCL8XgcqiRhIxxs94szfie17wfnF17fR9byC4xwEJ2ob9FnKRMHHQpvg54GMm+AvU+QT/OWMSun+gUYC1Q82cgUjFe3aBD+YfnPgNasTDR1KNGgQJQ3+7FwUXpqMsHxQJ8rgDZlXvqz6PnHcts1I6DajQuoQwZ+GQGTplmI4aep+8KZoNQ/G5jL6/9b8PI9evzZSldfuRQTYxL2bEA6ZzjSem8g0EKSm4MAOj+TikAjBn4j8Ubd9D9Es/Tdgfsc4EZ13ntNZtTjghATru2RG+KPJQ+YTZjZMg3stoE1UrU+ycvjNplHhgghmwXq0qWmpAJF6LxF+nKs2bAh/fkAND2w/k3FsiZTSw5FnXs+Q5olFPoui8toXXPYgorraQah8HdrVZzrllz/UW4Q/39u0F87/pUsVEe31aI0Up+2EHgIgp9Q+d8cdY9BSqnSefxvaBH+2GBBkOiL40xB2d3CLepkR/nDLeBXHbsI9Uv6gl4N2vNIZeHtgXWMpILWdyDGwwmc0I+YhU7sJFB34ftBFsrjR9GhnQLyQDLGFPH6IANMKE/nYOvje0yW1Klqwv3otMubvLhsEfzwi/MnYB/XfTixBDHTUNUud3AS/2UAsmgZNqQIpJrCx1L8vvfieu8Hi+9aPnelgdBAupcfc/4KP+0VUvnB5aIS/UpPQ3+whHSm3To/YU3rcmPMA0cd1iJa8TcmCg3whEf5dK9wHLZprkU0zZELaWklABH8G4kXw6yLfywkTy3MjKT3yGWmw4EV4c/e+4oITIy5urcZNvHxuCEh8XnP9UlHYWVz02ZtYrNrcgBc2TgJofpQIIHAxzW/uSyE5pRlu+OA1ysW/v2xI6bFF+BHdNdG/22TOrjHhOuJ6AeuI4lR9n3UT/MmKbMcbfbYX3xfqJWDbid4VnGZnCv50+M3qEX63QbQtpefgnEDaDlXQph/zDKN8plSOR8HvMs1uY+YdzvUUpzg2npjnPN0cBAGog2qYgn8Z0e5V9kFL6bJhBT9Sp0T0px4R/GlMpLzyeDjg6Cco/NARZcYPFgdz3Qko3PtE6yKA98Tzoj3xYf2iifAWVyjweyXCJSHRgtJs3lIcYKuHVJp4vqYXzMLLdIgWJhoMqmxdZ7NJ8JvdqU1hqDtDJSuHH8Xj8MgvbhEpCoYjHb9xXOL0tTAGaGmH/vvj2UhE/TFzxd8finb1Y3QsPRGSmcNvfjY92FWn9G++F6gWLPgbD40g+GPM4Td3mgI9pSb+o159xsbseIwU0wFHGyk9P59GNPYQopWfWwR/+Ah/pC7N6cALL7xAjRs3pnLlylHPnj1pCrfMdmHMmDHUqlUrtXz79u3pS+4a6GPnzp10xRVX0CGHHELly5enNm3a0EsvvUSpRAR/GuMmiFnIhhO/5o/O9loc3baBA7jX6Iwe+XHL+ec0BawX/O5t3s6JJtoBBs92uNmWphtIicEMyBFHUFagC6NsEPzcDRZNi9yEHgZV/LvLhrxXr1E9/VhmDgiSNduG3OXiFpHqDaLCBWyQrobBXbQdUlOJ/vtzE3Xoyqv3QYi2sWAij/vTp7uLTp4d1fe1iqV9zSNaXUtURnPiyXU5IZRiy7owO/2WmUSLR7k/vmpc4P9NmrVNoSG+44BZCxWyL2pddBVFvtHb38+HCn6tC68tnRTOPensVDZ69Gi67rrr6K677qJp06ZRx44daeDAgbTepbX0pEmT6JxzzqHhw4fTX3/9Raeccoq6zOZuaUTq9caPH09vv/02zZs3j6655ho1APjsM6N7cxIRwZ/GQBDbDqx8UGLrTdvj5mDAFPZ4HOIwHlOu+kESr8frrOek4z68H3c+THbKDN4v2gMOb/9MSe/Bd3zWWfYutpmKvu0zXfDjt3rBBUQnn2wXescf71zzbzIbpsDNCK9bBF0f/CMKq6ePZcrvj+GZMO4U7CZCkz1jlogIP6NHztmLf9iw9ErpCVeErKf6cAPGShV8d+bA21oT/GUqxZ7S83X38Cs78SSijb/7CnV1eRb/HwGEedgOxqbgZyq3CJvSY6tJweAi1m7JyeDJJ5+kSy65hC666CJ/JL5ChQo0cuRI6/LPPPMMDRo0iG688UZq3bo13XfffdSlSxd6/vnngwYFF1xwgepjhJmDSy+9VA0kIs0cJBIR/BmIfgL0WuiJE2pxree8rA+AqDdrAfRUnlQAsZ9pwkEIjhAme0YoEeifoV+/4Ol1ns3Qe1twlBjin4VUJmH6t7tFtIMyGQqCxXAy3ZTiAfLahwwJ2BtmC/q+a0Zxzdx4BErSJRXSNrOLmgPdBln/bMcdR9S+PVHd2vsD6Sq6D39u5dgFvy6iuzxF1GJE6DLfHEb0RRuifM1Du3oXSgQY+OCzWwfibrMKZWv4G27ZUnqiscNOJDt27KDt27f7L/tcDqD79++nP//8k47RXCJKly6tbv/2my+tywD368sDzAjoyx9++OEqmr9q1SoqKiqiH3/8kf7++28agKK4FJEFp9DsxpwWto2ebRaGNtw6sa5du5auvPJKatq0KZUtW5YaNGhAJ554In3//ff+ZTBtNWTIEKpXr55aplGjRnTCCSfQ559/rtwMzB831gnX2NHvvPNO9TzkseFHsnDhQsraL0s/SHvtvCOE7QiJkxFEVLaBnNlLL3VcivRzgD4w5yj/mDFEb7xht+BNZ7ixEeMmAvX0JY6MDxzouMOYrjbpDo6tHCXOJnRRb+Z/m+ln6eQ8ZEb4MZjEd6S7DOmHagSrVM+P0prg11168qoXr2iXqdCAqJqv6YbJvk1EBbtic/aJsnbFtR+CW4S/VBmi7fNcBX+6pHIhUl+1alX/5aGHHrIut3HjRiooKKA6xkrjNrSRDdwfafnnnntOrQNy+PPy8tSMAOoE+ug7XpLJ8Eny7MfUjLbpSU7r0f2PvaZHLF26lI444giqVq0aPfbYY6r45MCBA/T111/TiBEjaP78+fTpp5/SWWedpcT6G2+8Qc2bN1ejZUxZ3X777XTkkUfiEG99z0cffZSeffZZ9bwmTZrQHXfcoUbCc+fOVcUuyYju4ESVjGhTmSlDidZ8QXT8bOdg+eMAona3E7W4LPFvnqVA/CajOU8q0bsNm4KfhRR3rURXTO5kmQnMn+9cI5qKqKrb71Cf7ufiwUaNnIuQfulZZoAJg/K5czND8Huu5WLBm1OWqGpboh7/R7Rvs5PSUpyiXSanvJMu5AZccRIs+MPO9hf4Pn/ZWkT7NgbuL7REHbCNNFq3Jlq3LriRYLKBxjhYa4BSNpldJH2Cf/LkySrKjwDpxIkTlaaqX79+yOxAshDBnyiVHo31VhjyShPt1wMG4VwPsFzpClSqdKmIgwcWFZdffjmVKlVK5ZVV1OZp27ZtSxdffDHt2rVLFaYMHjyYPv7446DXQ+4aHkMUH4VaOCHoB1Pc//TTT6tBwclIXCaiN998U42Ex44dS2fb/PniDAZD+NyJTgfJyd9KOas+CRRbLR5JtGc10R+Xi+AXokLfVxHh13+36eB64pWVvppHgHSlcM3H4ASFwBcceiT1Lj0Jt+9h9rhDB6KZM53bttqyVGHWEdgEv3UylgU/otfYKZtfGv6NvBTtYlDAj+eWJzoQRoTu9SnmBAt+V7jRFgY4uuDX18slwo/UPaTiYSCfKhvaypUrUxUPO2KtWrUoJyeH1vEIxQdu13XJy8P94Zbfs2cP3XrrrfTJJ58o7QQ6dOhA06dPp8cff1wEf1YBsf9BfKxdUGfqtdYUbnYb+u8kyqnoGunAIBcjehy/Nm/erKrIH3jggSCxzyDqjx1206ZNdNNNN7m+LwYMiOiYwnrJkiVqiksfzWJqDZZXyHVLhuBPVoFwTv6mwA2k9Ug6j1AM8DtCdB+Cf/HiwP2ZVMi7UdMIXk76ek61kH5EqvvSZ2/SJX8fmMd/275o3T91we/pjXICAZ85DxK1uiHIvUZRsRHRTt8PumAvUekwVnv7fV1+QX58AohRscdnaVSxCdHG38Kvi2Ub2bpPpyN5eXnUtWtXlcIMpx1QWFiobsNVx0avXr3U43DeYb799lt1P0CWBC6oBdDBwAKvnSokh78EgQMfBrxsnblo0SIVhYeXrBsoMgEt0UrSxx9//EGVKlXyX8aNG6de24yicz5bNLlxmUpO/pbgyEi4qVpBiLQ/adacWilNRgl+36Ejo5tNCQGQWof8d9PhxouLTyox9z19MILaGTRyhCVr6Cz9vtgE//oJRDNuI1r8uvsyoHYf9zx5gPShVEb4MUMNyhvK3Za94HUbpSnXXXcdvfLKKyr1GBaal112mcpugGsPGDZsGN1yyy3+5a+++moVLH3iiSdU2vPdd99NU6dO9Q8QMLPQt29f5eLz008/qeDnqFGjVIbDqaeemrLPKSk9iSCnAtFZRrVaMdixbT8VrPuVStU6jKrWcI/379gBsVnB6oNrA2I/FnhqCrRo0YLyMynPIEHk6oJ//zYR/EKxBT+sDk2Bn67NuFBbAA923RJW92OXCa/MB2k74bptp6vgNxu56YIfqWS4BLHjH6Lv+gQEb7SCn9n5T+gyhb4f8IDJRLkVnSi/G/s3BzvmoDaA04aSwYHtAVceHWuEP42+8BgYMmQIbdiwQRmMIBjZqVMnJeg5WLl8+fKgaD0ceN59912VrozUHeggpCm30woW3n//fTVIGDp0qMqmQB4/sin+85//UKoQwZ8IEO7GjzlOVFp+P5Wa9zAVNb6A6HD3ph2V0BCw0Lv3MXZSpONghBpuGbBgwQI67LDD/MUvKNyNBOezIbcNLj0MbuMHlbURfhyoJcIvFAM+t5iNgmbNcjqbppOgAuN8/YIQLTU7JNsKk4XsQxf86TajA6enqVM9phv9fnFA7Ecj+Peas9aliOY+QtT0YqJyB9nThHTry4FTiCaeHEil0VN6AAYHuS6dLRMBD0ZKl3OCmBzZt0b4M19KXnHFFa4pPIjSm5x55pnqEk7/vP66ZZYnhUhKTwYAsa+ul74RfrlS0TU6qVGjhnLMgVUUpq9Mtm7dqjxjsdwjjzwS9XrDlQc7vW7vCT/c33//3Z/rlpWCf9fSjI94COkhnn75Jfh+2HL+8EPsr7ttW2KtPdlNyCQdGjAJiSVdI/zmurl1g/djRt29Cv4dht30opeJpv+X6Iu2oRF+zt0/qHfgsZrdiQbPtUf4U5HHz9sBDjwnzCeq0sp9PfhzCWmNCP5MAKNr5kD8UoUAxD48aHv06EEfffSR8shHDhusNCHKkaP/6quv0hdffKGqzWHXuXjxYpo5c6ay3FSr53I2x+wBilruv/9+ZU01a9YslQsHWyoujslKwY+iLD3Cv+ablKyTkLmEi5CuWBG7J/7o0XDKinm1BMET6Sz4IzZyg11mLIIf3vk2l5t9ml82R+35Nau1Jxo0lehUX1Q/rxpRtQ7By6Yij3/vRqIVHzn/41xWsQFRgzOCI/x6epFhyymkJyL4MwFU9rtFEYoJmm1NmzaN+vXrR9dff73KQTv22GNVVP7FF19Uy6DIBJ77aDUNwY4C3v79+9MPP/yg8tTQgItBC2kUsDBw90FTL7SV7t69O+3cuVPlxiXDgz9lOfw4MJfX8hpWf5mSdRIyl0SkRBgucnFh4kSiTz8N3BZLzZKLbj5i6xeTLkQW/MYUgNf0TDOHX2f3Kqc2oMhX76a789ToSlRes3/kwQDn0KdC8H+HmYeiQEqP/vny94R2/5UZ7Ywg8xOvspU965x23vDq1dt669GCOIH8+ueff15d3OjWrRuNQbvPMOzevVvl5x911FFBUf57771XXbKZoAg/8jT1g/8BVFMLQnwFP+w6keOP7DgvfSbiWTj73Xdo2hfaYVUouej7QroN/PQ0toi/LZxzdcpEGiH4OOx1ovFd7Y+NPYToEKcXTcRZA7fH4tTbxxPbF4QOePictnt5aFS/8qHJWzchMyP86Dx24oknqhQPCENUOZsuMqiahiAtX7688nNHyokOqp9RBQ0bJPjGoxEUosg6SD9BN1hElRs0aOBPRUlbdq8m+qQu0RetQ3P5ln9A6cqPP/6oIv+64C8pBAv+A8HdFvNF8AvxF/wQ3XPmBPv0e6U4xlpwA8N72sT+qlVEOETrg4tBg2J/LyFzQFdk2D5rDs5pQ1RF42aEP9djT50aWsTbxspPvc0GuKXHcGQ92bDgL50TmsLU93Oi1jcSNR6aklUTMkjwo1C0Y8eOKo/cBoQ5cslfeuklVeiJ5lAoMt2rDdch9ufMmaOaHsAPHoMIpI/oRaIoPIUl0p9//kmPPfaYSjl5+eWXKW1Z83Vwa21d8G+dQ+kKcvyR618Syc3XLdT2B3dblAi/ECXlI3Tbmzcv8L/XIlxdoBdH8IfrBbBoEQb+jk1npjXgEYoH0njQS9HNpz+VNGxIdOyxzvpFxBTjXgV/NJQL7k0TNsJfKjd1Xvy2CD+zfT7RwScQdX40dDAgpCUpTek57rjj1MUGovtPP/208jk9+WRnKgxNC+CLipkAdGlFcSnywdEICikn4LnnnqPjjz9etS/GzME777xD+/fvp5EjR6qOam3btlUe8k8++WTQwEBn37596sLsUAb3SaRQO4MjUqwX72zXzvRC2pBTsNVwLJAIvxA7sLc0Oekkos8+c/7/+WfvHVBtIh9+/rGW0XhJ49HdhcShR0gHmjTxuKAerAGJsMIMl/Nk1gxUOMRxfktmSo91fYz4cOPzUrE2QjYW7aIzGRogII2HqVq1KvXs2ZN++81p84xrpPGw2AdYHg0SMCPAy/Tp00eJfQazBPCV34JOMRYeeugh9V58aQPj62SiT90d2BacHoLbk+SHllbk76bShXuMlB6J8AvxjfD72lqE4FVQ6027EhXh1+0/eTDipb5AENIG/XwL4t3sqm5A01jRZxQg9is1c/7ft5FS8vnLHmSP8LcNdJ4VMoO0PRRD7APudMbgNj+G69q1awc9npubq3zj9WVsr6G/hwm6o23bts1/mTtX88aNc9daK/rU3Z61oVZhS98hWhfaCEJIESEH4qLglul6cxVB8IDXqD1ACs2ePckT/NEU6nrt+i0IaYMZ4Y+GdndGXqbH/4V/PFcrEj70CqKqPh//yRdRUsg3rL95wKEL/rrHElVNciBUyF7Bn0rQSRZFwHypHMbHq4zPfwwONXFDb/wx4xZ7/t6GX+P3fkKx2Lt9lbou0iMz+ndYoIl/QYhB8GvOt1bMBl02tupZZ4WxR/eX+UqLBCHrBf9BR0b33A73EHV8IPi+ah2Db5cNDlKGUKZScAExPPCZ9RMp4ez3Tc+B3h8E8vN1wd/ymsSvh1BybDnRoRXA5hEuPQxud+rUyb/M+vXrg56Xn5+vnHv4+bjGc3T4Ni9THNB0CmlFvB7wqofjULFocjmVm3N/SGV/Ubm6VMrXvvvAgb1UkMiWmYKnWR0M9HZuWEbVcDwsV9vpbmQKfonwC8UQ/MhGrK+1dbDhMlmp7avBbj6xTkiiWHj6dO/Lw7VFEDIL32j44JOIesXQpe7gE4lm3Ba4XbEh0dYZ7o29TPTAEeoHCrS4LBt5JBKkDYOytYganhm4Xy/MzbMUGQlpT9oK/iZNmihBjgZQLPDhuIPc/Msuu0zdRifYrVu3Kvedrl0d/1s0gyosLFS5/rzMbbfdRgcOHPBH4+Hog+ZR1W2VcTHAAwdz8FEcWpYqR6WLggX9sgZPUOOFjv3V9o3Laf2SJXF7PyF26pQrDBwg0WUXFGhpPHp6jyBEKfi95OhHSunR03mKE+GfPdv9sUMOIVq5Mvgz9Eb/HkHIxAj/wYOJ8qpG/3x0z0VaDtsx60221O0c7yk9yiK0lHt+fSIFfxnjs+sR/li2i1CyBT/88hfBx00r1IWDDnLwGzZsSNdccw3df//91KJFCzUAuOOOO5TzzimnnKKWb926NQ0aNIguueQSZd0JUX/FFVcoBx8sB84991y65557lD//zTffTLNnz6ZnnnmGnnrqqbh9DkT0MQuBegKsQ1xec04Fov0BwX+g7b1Ut+VpdCDvXioz506qWr6IKnq2HRASBQaROcumBKIeKPDCQXmVz04FiOAXiiH4a9Tw9hyYibllH0Yr+PG4rdjWrYMqmn81aIBgChF7IcACsUICDE4EIaEUFkT2yo/EUV8QfdeHqOnF0bvr5GG+WIvwB80Qx7FW0I39W+2CX88AD3lMyARSKvinTp1K/fr189++7rrr1PUFF1xAo0aNoptuukl59cM+E5H83r17KxtONNBiYLsJkX/00Ucrd57TTz9defczcNn55ptvaMSIEWoWoFatWqqZl5slZ3HTe3CJC/m7gm6WaXoulcHnruB0EMld/hbl9niGaNt8p1137ShzDYXEHCDhoYx0Ho6SmNF+QYhS8LdoESy43WIKyNGPh+D/+280RXR8y9FMSceWrYjIfvv2zv+nn06EhtxYfxH7QmZSWHzBj/PxqWuJyh1E9NuFgfvbe+g4z644/gj/Fu8R/kW+/kLNY9A3eO15TxBNv8neK0BPUxXBn5GkVPCjI2s4dxtEzu+99151cQOzAe+++27Y9+nQoQP9rBtXZwKYTlzxcWj3vdKaR++vQ4nWfOX8f+Z27y3AhfjC4h6RmVIIgRq1FaoRV1H69ZsX0hYIe2QKQqg3bRpcvPvJJ/bnfPUVbImDl2f27/cu+H/yGYB9/TWRl7iIfgjHrMCZZ8quLmRD0W4xPU3K1wlN6fGSCoPUULemX4j24we37D2iah2IqrULPHZgJ9GUfzv/H3KqM9iIhjkPEc28PXT9mV1aCnGu2G9lIuLSk67UPCz4dumyoU05WOxbZgSEJEb3N08NRD2sg64iZxZGEKIAjbZOOy042m+m1AwaRNSqVeD2d9/ZX2uj4RzrpWiXJyv/+IPoyy+dQcIuy2HGHMdC9MvYVsh4wV+cCL+OLvi9RMYrNQ78X6Nz8I/1wHYnXXTSUKIvfdNqjN6gc0cgVdoT6B2ji31QQXMHAg2H+K7Pkh94hpK2RbslHn2Ur0f4zS58TLwOTkJ0fNUlEPnAwbxcXaI9q0OXg9tSwzNk6wpRYQrnqoZewACgkhEEtGG2EvFStMuC/6+/nOvJk4OLg7k5GPL3BSFr4LSZRAh+PV3HjfL1iI6Z6NSE4Xyv23SiL8/2+fbnHdB8d3evwC/T+zru+Cf0vhaXB9+u1cNJUypb0/vrCmmFCP50pZbxY0VueDjBX5xmIULs6NOcSvAb06DML2cSnZuEgiuhRA0AIPgj5cpD3HMhLWwyt2/3Jvgxs6AvZzr0YAbCHIAIQvZE+OOUAKGfs72m2eg1eYc4JiUKBJP0gQjy6vn1df/8aAuF928Kvj1gMlF5i225meYjZBSS0pOuVG0VfKAoSYIfBzH4GC95q3hOC5v/JCpMYioN8jPLRDAeT+b6CFnJ4MHBA4BIgh9tR5AVAD9/FuheUnqQmqO3+tBde/r2FbEvZCnxTumpr3XNQ6+WWGYIeo8J+PDrrj3rJgT+X/Z+7Cm+Wr8fRS3H1lzILkTwpzO6OORoA+fym2RTjvjSd4nmPEj02zDHhSgW0KF4fDeiaY7zU1LIqxk+KoRp049qEU33dU8WhBjQm3Ahwq+ZloXN38fzWLTbIvzw0H/vveD7vv8+8L/+HHEEFrI/pSdO8qhOX6JuLzgdeCsatldeqdLSud6+wEnrYX4aZI/qRyv48bpM33GxraOQ9ojgT2fa/Df0vlK52R/h37U08P/6H2N7jXmPOdd/P0cJ92vWcy9R/GQD7dVn3+s4+sx9OHHrJGQ9iOrDzRi580jRiST42ZITOffhBD889OHlz6Bp9Jo19tfEbIEgZCXxjvCDQy8nantr7M+vDG/eUk6e/taZ9vOQ3u8lP9qUHl/OX8+RjkOgkJWI4E9n0HTDpOiAN/GZyei5iLstBbDpQlBDFJ/gb3e7zzuZ4aTrwuR0SRRKBPDmZ+/7stqkn61ZFgt+zAZwDYBN8HtJ8wFdukS/voJQogV/cUEqbyVfo838ncGPFewKFfx8n1f2bQx1CBKyDhH86UyQcAxzX7ZF+PWmVdyePFrcZkLiSYFmWcIODNU7Ep25NbQzYv6e+E0RC4K+25V1PPs3bCC65BJH1C9ZEojWs+BHEW64CL8Xt59olhOEjCTeKT3xoqKLGOf0naAIf4yC33QHFLKKNNujhSAaneVc1+4TuK96J6LWvk544QR/JkeTV34S7Dscr9mReGMK/tI5gSKrVtc7/3d+3Lcsplil8ZaQGAYOJJqpzfQ/8EAgH1+P8LPgt0Xz94VpCL1tG9E//zgNvCSdR8hq0jHCb7P0zK0caLgFCjTBv/BFop2ag1w4oBXYpUcEf1Yjgj+dQYoIOuj2/yFwH8J3nR8JL/gXPEc0phrRximUkYXKusg/EGOEP8dnEp5IELV3o8vjRGduI6p/fGBwoEeMxK1HiDPjxwf+37o1IOKXLQsV/GaEH248use+Dl7jzjuJHn2U6MorA68tCFkHxC9HytNN8OuWns0uCfjzc4qPHuEHnzX1luqL5pEcIITxhJC1iOBPd9C5lSPH4dBdev68ykmFQTe+TMOMmuenseDXXRHgwmACi06eaYjX5xIECw8+6PjrM+y7/8YbTlQe1KjhLvjdxD6YPz/YnvMrrcG3IGQV3/cn2j4vPVN69Ag/ml/lVgoYU2yaSrROs9RilrxpL9CddR/RzsXB6Tw4X+VINX42k2Z7tBAzthx+s5lGJlBg5BWYBUpeScbUJK9bpeaOC0O4gQd6Cyx+XXtuGIUlCFEA8X7vvcH32aLwtWsHinbNlB6zoZfOnDnBtxdoDn6CkDUg73295mufdhH+2sFNHlnw47zydXf7czZMDL3vr5uIZt1J9FVn5/Y+n06Q6H7WI4I/UzmotwfB7wvzZRKFWijRNgDwSqVmgf/3baaEwLmTeutzrzMNZsRfEGJksS9QBy680F3wI7rvFuG3FfFOm0b0ySdEq1Y5t9u1c645RUgQsordK4Nvs6BOxwg/ovHcjDMctpSeTb8715w6KwW7JYYkWJkICQF+uctHE82+z8ndyxaXHkTCw932it6RGN7FZWtQ3OG0nNxYBH+UPsmC4MKMGc51164Bq05O6THxIvh37yZ65RWiuXODlznzTKLZs4kmTnS699apI1+JkEWs+yn4droVsOo5/Ijwe2HPKsvr1COiWYHbIvhLDBLhz1SqtHA839mbVxf86RaZSIXg112KYn0Nryk94bZ3aZcxdbSNUQQhguDv2JGoZcuAq44u4vl+L4L/zz9DxT7Sga73GU+BH2PshycIaYvebTYdBb8Z4ffi+rb+p9AZbjP4JYK/xCCCP9PhPEO3CH+mNeQyxbnZ3Mor+vZIlODnlJ5YBlgS4RfiBKfYHHooUaNGTj4+BDx8+Js3Jzr2WKK+fZ1l3BpvFfh+LtWqETVsGPoep5xCVLEi0bnnOrfh8y8IWYV5rkmGtXOsOfxe1w2BL7MzrznrLIK/xBBTSs/333+vLuvXr6dC48wxcuTIeK2bEE2DKd3mUY9uq868aVZ8FM1BN2axnoQIP9cb6OlDXpGiXSFObPYF8GrVIqpShahqVSeHPyeHqF+/4IJcNx9+PozjcVv+/2GHOdcYQAAR/ELWweeeKi2Juj5LaUde9cD/pgVnOLb8RVTnqMBt/XwF734W/OXSbEZDSH2E/5577qEBAwYowb9x40basmVL0EVIgwh/UHQ7xgh5qmBxzgeleET4Y30Nr+/h1c0B3snlD3b+lwi/EGfBD9vN6tWJdvomnl57LdR9J1JKDx7ndJ0hQwKPd/YZejTxZRCK4BeyDj5X4jhdbwClHbAJrdLaua7Vy7Hm9MK064Jvl9YE/5RLiRaPTM8UJiH1Ef6XXnqJRo0aReeff37810YovuBHCo8ucKOJBKQD7F6DoiSIfzgJIBwZzjcwVTn8PKvilqfPdHqYaPVXRF2fdryPUUiVad+LkBGCv3Jlonzfbmnm4XsR/PiZLV3q/H/rrU73XjzGDj2NGzvXvIwgZA18nihdltKW46Y758i8qkQd7yda/UXw43WPIVr7nf1cZTtPLXkj8L/YcqYdb775Jg0ZMoTKlg3eJ/fv30/vv/8+DRs2LLERfrzR4YcfHu3ThGQJfjjS6GSasNy/zbkup1mAzH0o+tdJhuD3GuFvczPRMT85eZelyzj3FSLVShCKBxpm/fOP8z/n3l97beBxvRmXl5QevB434WrRgmj6dMeZJzc3OMKPugHO+xeErIADZbGkaCYLNMaC2AfVOxGduobo1NXOQOCs3UT9vg4sq5+X9HOg3qRTp8qhiVprIUYuuugi2gYHBoMdO3aox6IlasH/r3/9i959992o30hIkuA3K/IzTvD7moBw6guYcZt92eVjiDZMSl3Rrl/wRzFRxt7Jmfa9CGnJl18SHThA1KBBIPqOJlz16zv/f/aZ8zhiNDg/RCra5axMpAaVL0+UlxcQ++CQQ4jKlHFec6VhWy4IWZHSk5PGEX6T8nWJytcjqt6RKLe8k+5z5MdEVdsQDfzD3vfFzeAD6UJCWlFUVESlLNkNK1eupKoo1ooST0rluusCOWAo0n355Zfpu+++ow4dOlAZHP01nnzyyahXQigG+zY410vfIWpwKtH+DBf8PGCpaLEK0dk2n+iXs5z/zzXClSER/gQ1ueJISTQdGSXCL8SR0aOd66FDA2K+UiWis84ievppom+/JWrThui335wLB4XcUno4Pehgbbytg0JguAGh+y4ucAUShKyK8KdzSo8XoANw4QATNECkCH/LayKnpgpJo3Pnzkro43L00UdTrhZ1KSgooCVLltCgQYOifl1P3/Bff/0VdLtTp07qejbmeoX06A7I19w9L1OLdveuca5RkFR3ANHab4jqn2BZbl34/EQ9irHfYjuSsgh/mcwciAlpyaJFznVvo/F2z57ONdJ9vtNSehcuLJ7gB8jnh9ifNYvo+OOL+wkEIU3IxAh/JGDBiXPNsveJ2tzoHuGv6JseFNKCU+CDTEipnE4DBw6kSoji+MjLy6PGjRvT6aefHvXrelIqP0qXlfSl23NEv/8rEGXO3xX8eCYJSzSjWvaB83+NbkQVGjiCn0Wyjmo84mP/luAuhIrC8N0G4wEfOEvnxJDSIzn8QjF2vSKin35CMMYu0Fv7Zud//dW5MOvXE9WsGSr4d/kOG1wP0KqV+3ujmy9mFiD4BSFryJYIv+18M/0mokZDnJlzNpuo1Jxo56JQy08h5dx1113qGsIeRbvlysWnriTqHP6LL75YFQyY7Nq1Sz0mJJkqvjPz3rXB3V8Z3N70R2iVXrp2OkTRMQ5S9QcHp7+EW/99vrx/HT2KsWd1Yl16YknpUf0RBCE2PviAqH//wG3k8JuiHL78Jmt9hwkz/57rwlascK579XJ/b7w2kAleIavg4BiL5GyAa+L08yCn9FRs4N59V0gLLrjgAiX2YZaDvP3ly5cHXRIu+N944w3awzYOGrgPFkJCkmErLUS5bYJ//pNEX/cgmnpl+n813ACk8qGOG0Epnzhe8xXRR7WIln9kz0M06xbU41oIE9OZB0IHqSkt2kXDE0GIEV8ASNGnjxO1D9rNSjv3m+hCn+07wf79gRkAYOu2y7BF57x5oTMFgpCx8DnFNqOcqejnQa6P4/NWpaaBx3IrJ3nFBC8sXLiQjjzySCpfvjw1atSImjRpoi6I/OM6Wjwrle3bt6uKYVwQ4denGFBE8OWXX1Lt2lrrZyE5lKkULPRNwb/qc+d64QtE3Z9P72/FbPHtj4YXOKL+lzOIzil0qhP1CH6kCD9Y8RFR0wtTX7TLgxiJ8AvFAC48CxY4/7/xhsvuqU2KnXsuEczV9C66H39MNGAAUbVqjksPxPu6dfYZAx08hgEFBgkYINStK1+lkAVwmmU0AZxMguveeGa6WsfAY7r4F9KGCy+8UBXsjhs3jurVq2d17IkGz3t2tWrV/FXDh8KmwQD3owuvkGRyKwUOVogamzn8mcSkc4OnF22Rlu/7OZ72fNAypy1tkY1oRXlSinYlpUeIHc65f/XVgB2nLfXmk0+c/y+5xBH8f/8d6GMH8Y+C3jPOcAQ/0npwDSeeevXc3xvGbBhwYLYAs8oi+IWswGsjxUyi3iCiNeOd/w9sM2rP8ohOXOQE2vT0HiFtQNHun3/+Sa3CFVUlIqUHhbvff/+9ivB/+OGH9MMPP/gvv/zyi8onuu02F790IXHkVgz8j+i+GeHXQRfedAKi95/XiXYtDw5H7lrmLvjXT3A+hx7Bn3xRqMA3I/zc0CttinYlpUeIHc65b9bMfZn//pfo9tsdR50ePRyRD5HOgwWwe7dzDaG/yTduhpiH6A8Hp/zEkEYqCOlJNqb09Pb59gLVtb4weGa6cjOiWj5LrxLOCy+8oFJlkL3Ss2dPmjJlStjlx4wZo4Q4lm/fvr3KcjGZN28enXTSScozv2LFitS9e/eocu/btGlDGzf6Mh+SKfj79u1LRx11lPL/PPnkk9VtvvTq1Yvqc6cXIbng4MSuAhD7B8II/lWfUVox7zGi3y8m+qqTIYBLBae/mBTsCvUS3hJsHesfAJSr6z4LELeiXYnwC6kR/OF6r6Bx1n33OT78FSoEingtngtK8GNgALp0ifz+LPh1ByBByGiyMaUHbnatb3D+n3UX0Rdtifaszb6ZjGIyevRo1W8K7jjTpk2jjh07KjvM9VzUZDBp0iQ655xzaPjw4cq2HjaauOhW9f/88w/17t1bDQp++uknmjlzJt1xxx1ROe488sgjdNNNN6nnb9q0SaXW65doifobR+HAli1b6LXXXlOjFx6FoM1vjRpS6Z2yPP59+5zC1HAR/u3zKa1Y+Xmg4FgX/BwFd4u0IG3JjOBvnUNUo2vgNj8OP384GCUywh9T4y2J8AuJFfwmdeoQbdhAtFM7RPDEGgQ/O/gcdVTk10LHXYDmXkgJOuII7+shCGmJP/KdZUJYL8jVNUAi0lwzlCeffJIuueQSpWPBSy+9RF988QWNHDmS/oupUoNnnnlGNb668Uant8F9991H3377LT3//PPquQAZL8cffzw9+uij/uc1Czcla+GYY45R12i+ZevAi/rZhLr0TJw4UU17PPvss0r444L/UTGMx+IJPgxGRHhtVCljY2HD4sMy+P/OO+9UBQ1YBhsIlc06mzdvpqFDh1KVKlVULQJGZTv1s162OPXsWx/I4a/dN3S5nUsordBFb5DgLxNB8O8OzuG3NRxjH/4yPkWUnwiXnhiKdrnmIhGuQUKJYMsWuKI5/0fjkwDBDzh1ByBOgDx/DCD4fi/mD7orkNn0SxAykmzM4Td71ui4zaBnCTCX0aPh+3CwswDLS+TJs7gGpUuXVrd/Q3tyC7hfXx5gRoCXLywsVAMG1LvifhjaIE1o7NixUX0GpNLjoqfQ48L3RUvUgn/EiBGqEQBSez7++GN1Wbx4MZ199tnqsXiC6YwXX3xRjZowm4DbGC0999xz/mVwGwMOjKp+//13lSeFDbx3b6CVNMT+nDlz1AgM1c4YmFx66aWUNaBBFVjwbCDCX+uw0OUwIEgndJGvdwQuVTr6CH++Ifj58bxqznW62HJixgEsHy3WnEJMLF4cEPBaA0bPgt+cCUbUX7/fS3amefjU6wIEISNh57RsyuEH1TU3Hp3yvgNCloLME+TO8+Whhx6yLocceQSX6/AB0gdur+VpTwPcH255pAIhqPzwww+rmYBvvvmGTj31VDrttNNowoQJnj+DnjpvuyRc8C9atIiuv/56ytGquvA/8p/wWDxBnhTqBQYPHqxmFc444wwaMGCAv5gC0f2nn36abr/9drVchw4dVC+A1atX+0dSGCiMHz+eXn31VTXCQk4VBgzvv/++Wi4rqNzCuV45lmj38oCXvQl79ad7hJ9ncEqFE/xGhN9M2SlKRoQ/hqLdPC3tbdl78V8nIevhbrhRzg773XRsqZ/4yfGk50Fm02oLyN7UX8eX3SkIiQU76uZpRPmhvYBSUpOVCdhm+0G5MFZcWcDcuXNp27Zt/sstt9yStPdGhB9Al1577bXUqVMnlRp0wgkn+FN+vPLzzz/TeeedR4cffjitWrVK3ffWW28ps5yEC/4uXbr4c/d1cB8KHeIJPiCcgf6GlxwRzZgxQ33I4447Tt3GLANGVPrUCkZyEPY8tYJrpPF069bNvwyWx5QNZgRsYOpHnwqydRZOK9rdEdytlqP+ZsdAbryRDuxeTbTD+V6D2pqDSj6fwYqN7M/dOCk0wm+m9HABFgvsdT+EpgGl4gSRUzZ9U6yEjIrwN43SOtstwg/gqX/A95Oxdei1UblyoCPv0qXRrYsgxASCJOO7Ev18avwHEtmaw88z5iaVom/clElUrlxZpXHzpWxZ7dyrUatWLRW0XsdNSHzgdl0Xz2HcH255vCb88zHLoNO6deuoXHo++ugjlbGCdHUUE3NaEgYwDz74ICVc8F911VV09dVX0+OPP67ENy74H6MYXFCJzJfighERUoVQ5VymTBnq3LkzXXPNNSpFB/D0SbipFVybDcHwRaDA2G26BlM/+lSQ+aWlHRXqE9UfHJornlc9fSP8M28Pvq1H+Ds9FphybHBG6HP/uiG03wB7DPtf70BwCk3BXqIZt6W+aPcgrf1ptk0dC0mBzxdu/vtuHHywc60332I4uo9zYkXN6TcSjXxj8mU+J11BSCjznnCu13wd39fVA0jZeFwuZxT7DJ4bHHwqweTl5VHXrl1VcFmP0OM2HCht4H59eYCUcV4erwkLzgXcHdEHgtcwvvHK/fffr2YEXnnlFaWBmSOOOEINAKIl6qEsrIgArIJsj6FyONYKYpMPPviA3nnnHXr33Xepbdu2qgkBBD8sQC+44AJKFJj6QYoSg2mUtBf95g+6jE/wc3c9gG616YIZoeccfsxMlNNCjB3vJ1rxYejzZ98XPsLP0Rq9gyC6DXd+pJgrbnmPqCL8eUTN/0206P9Ct4EgeGDNGuc6XHMsG9w9F0W/boIf0f1omjnyIMIldiII8WVL9CLHE3qKaLYV7YLyhxDt1Wr4Kvp8dQUF9B40JTJBevTooVLFd+3a5XftGTZsGB188MH+OgAEvZFD/8QTT6iUc6SIT506lV5++WXnBYmUgw/qXfv06UP9+vVTqeWff/65stj0CgYMeL4JAtFbbZGbCES9ZyONJllgg3GUH6C5wbJly9RGx5fD0yeYSoFLD4PbyJkCWMb0Us3Pz1fOPW7TNZj60ad/YvE7Tbngt0X4C/Y4wjodRvamc8DyMc61mYZUySVReacvkTlShL9y8+JMaIUH2xPkePfVDZoREMEvJFHw8/Js6ekm+KOB8/1d7KoFITPQO59nW0oP6Pky0fhAWjPlVEjl2qQdQ4YMoQ0bNijHR2R+QD9CoHP2CNJwkAaup5sjEI360VtvvZVatGih6kbbtWvnXwZFuojOQ68iM6Zly5YqRQd1pF6BRkVtLGpYdZBZ0zTanM5YffiTxe7du4M2MkCuFRdEwK4TGwRTKyzwIc6Rm3/ZZZep25hiwUgItkuYtgGwM8JrINc/a9CLQd0EP6f1lLcPdJKKeVCd96hd8CPacuTHRD+fZn8dLI90oJAI/4HAwKLB6UQrPiLKi8K03At7ffYmZWvFKPjjXFMglAhiFfws5pEGmp+P1MbAY1ym5KVgV4ezJdnpRxASRiJTUoMi/FmY0oMeNcf9RfRVZ6cZZTTTeCWEK664Ql1s2KLyZ555prqE4+KLL1aXWEFvAMwmoB8AsmZgNIO61BtuuEFZ1kdLTENZVAhj5IJoP94cgwBMgUCAoyo5Xpx44on0wAMPUMOGDVVKDzqaoUECb0BsAKT4IM8JIyy8PzYCUn7Q9YyLJGCLhA2HdT5w4ID6UjFrkFXdgc2IOQS/3nBDT+tJB8GvR1R0ci2Rh5zy4Qc6aKwVUrSrpdt0f9ER/LtXEu3dGJwyFCt4/e2+4vVyB8U22JEIvxBDbSGnz0Qr+NGkC/ETxEtgo6k37SpuhF8Ev5Bw2JDCNqNdXHSXt2xtSFW9k5O7z1bVQtqDDBcEp9F4CwFwpPcg+wSC/8orr4z69aLOcYAvPvKd0EEMkXPO04cTDkR/PIF9Jqw4L7/8ciXc8SH//e9/q+ZbDGoJ8MHhq48iCXifYipGb1+MOgAU/mKjYb0xpaLnWmUF5hQd0kyQx2+SLoW7HIE30XPuveRUctTe7DDMAwpEayDI2fFHdwYqDuu1ET8iJtHANp4i+IUYCnbhqAMMr4LIu11px04TmH0HJaVHSHvgtMbo+ejxYOqVkV1tsoGqrYnKZ7cdZzZRqlQp1bEXKeizZ8+myZMnq9QjXQMnNMIPEY6KYUTQ0VSAQbEDBHm8bZUwiAg3kMAGuffee9XFDTjyIN8qq9GnJE/f6EzZ5VjsNtLFmtMtwl/RYhUWLqeSBzrm65lNVHgGpGA3xYXdjh9ubBF+n+AvlKJdIToeeMC5btuWSItpeAYdcjduDBX83DhLIvxC2oLZWZ2NU4hq9YjPa68eF5/XEYQEANefeBjHxFS0C3tME0wzoKpZSBG6rSVbUVoj/Gkm+CHIdbHO6+5V8HOdgv759dfn5l2cFlTchi3IqcBgat8m53ajc6N/DSnaFWKE3Y5jNSmDoIdTnJ4ONHGic+HHY8nh37PHGTREY+kpCFFhNk/cuSh+gh+NKjH72/sD+VKEtGHv3r0qyP7jjz8q8xmuX2WiteaMWvAjTx72mGbxLtJokHYjpAj41cOfXvd5Rx6/yeQLiZomztI06hmJTo8Szb43kGpkKzSu1t5JyUE0n/PmGU7VMTv1+rvg5gbPBPw2jKjTw0Qt/h39Ov96jpNHOmAy0b6N7gOUSIjgF2IAhbbczPzoo2PbhIjwA26UjgLed94JPB6ttz8EPmYa9u51nHqaZHcvHyGVmHVaf15F1DiGgIsNThGq2jY+rycIcWD48OH0zTffqNR22IUio6U4RC34kb8/YsQINfKA3/6UKVPovffeU9ZDr776arFWRigGKEQ9bX2wRaStaDdd8Ef484jq9HeKat0EP/L0T0J70VJE47sQbZkeKvgh8JEig/x4m+MCFwMf2Er0x3+Iml8avVPBsved67XfBU4+ZWJw/hGXHiEGRo8m2rTJEe2xxlZY8MOLH2L9H8PdtrnuYusB/IRQuLtihVO4K4JfSBh8zEXwBqmZmGXdNp+oaiuitd87XXi7PBlqYBEJBIjyt7uffwQhRYwbN46+/PJL1WgrHkQt+P/1r3+pNr/wH0XV8Lnnnqvcbp555hm/X76QIkyHmzpHBf5vczPR3EeIKjRMv5QefSbCzUGAC6lM204W/P68/RzDU5lTeoxtg4Zk0bgV4aTA7N+k1QgY65MtEf51PzkDp7rHpHpNBB+TJjnX6AVTPoxxlVfBf8ghjlBnDj3UuUSLLvgFIeEpPRDle3y1WAW+NOIffMepvJrRN1dEP5WiQvdZcUFIEWj2hVrWeBFTOfrQoUNp4cKFyhEHTQpWrlypph6ENKNqm9Cv2pwWTRWrPgsI/jLaDl02gt3aIacG366o5SCw0Ld1TTStPXctjW599ZQhFD7zbXTOzTbBX7Cf6Pt+RD8cmz6uTiWcdeuI/vc/5/8WLWJ/Hc7Rx+s9/jjRxx87t9ER/p57YrPn5v6F3B9AEBLCAZ/gr9VLu884n8XiwsavC3KlCEVIH9DJ9+abb1YNZ1Mm+Ddu3KjaCM+bN081whLSFN1ejCPh6EjL0YxUoVuqQaTraUiRLMNaX09Ud4A9ws8i3BbhNw/kiPCj6/DS94IP+G4U7NXeZ68jimOO8BfTh3/FWKJ1Eyhh6F2L421/J8SEni1ZnFIpjvCPGUO0cGHg/lhdfwBmCsAqzbhKEOJOvi+af+gVwf75OB4Wp0suWzrjHJHNlpxCxgH3S6TPo6suIv1wnNQv0RLVr2POnDmqg+2vv/4adH/fvn2VPz9aBwtpRr9viDZOImpyvpO7TkWOwI1319lo0MUzXIN0wR2pCBYzAvWOJVr7jXO7QgMnYq5y+E3BXyrgeV+xQfDr7FlL9PslREvfIjr0KqJuz4R/38J92v/5gZQeHlAkK8IPK7qffbMc52ppRvFk/9b0s3EtwaDR1u23O/83a0YURWf2ENxy7BGl17PWYhH8Zj2AICRE8OPcVW8Q0Zrxzvnjdy27YMWHRPm77Q0cIwr+NK55E0ok55xzDq1atYoefPBBqlOnTvKKdpG6A2F/0EEHqW63aGSFot25c+cqX/4jjzxSNQaozT5tQnoAcYwLR6MhihHBTaXg//v5wP8ovNKbZnmJsKC7rp6yg0FAgSb42WtfP+ib/v7ozguxr9bn2ciCXx+kIOczHik93A04Gr7pSQkHhc3MPknMTjU//xz4H2k9xTnm9+sXel/16sgVjV3wH3aYc/2D1hdJEBIm+JFnz7VeuthnVn9F1PD06AMcemqpIKQBkyZNot9++406duwYl9fzLPifeuopZcWJ6L7exXbQoEEq6o/utVgGbj1CmoKDJFI0cICrmMLi3XmPBf6vfZQTfUeRaLvbvD2/8XlEW2c6UR4eyBRoaTZ+Bx3NraFsrdAIfzQg/Uc/8RQrpSfGCL+pyNiVKFYws7JtnhMpa3A6UbW2oSk96VLzUYJZuTLw/7G+sXusoNsuJmjZ9OHCC4lwLsH9uTFkQ4Du3QMpPTt2oGFi8dZREOxOOlrqTRkXcwewaXJ0gn+37wdWwTdVJQhpAgLre9DkJE54Tlj79ttvVfGALvYZuPbceOON9PXXX8dtxYQEwAfJbXOJJl/keMqnmvrHOT77p64kanGZt+cgqt71aaL6muAH065xTgw2wW9atW2fH/jfixUb8vYZzCBwhD+WlJ7SMQp+s7kYpxXFAtKexrV2Zgxm3UX0ZbvAgOKANuPCsyU8UBSSzmI40hLRzTcXL7rPHH6472dygOj114kq+CbCjNYqnqlWLVAMzH0CBCGuqBnWooDgt7m5dfK582ydEyzm13wb/rV3Lw+khwpCGvHwww/T9ddfTz/99BNt2rSJtm/fHnSJFs8xncWLF1OXLl3CFhdgGSGNYc/434Y6hbuL3yA6N8UFvPFQMJwas/pLog2/OoVcIFcX/EbYcYveoa5U9BF+FtvJdOlBKpHOyk+JGg2hmEBu/h6jyhL5sKih0AcSyIddPZ7op+OIKjUlOnFRfL4zwTOcG4/8/XjCEf0TT3Si8x06xP5acA7auNEpBLY0YhcEdzD6XPstUfUuTj+ZcOk8IAcRfktKao2uzvVuzdHks6ZOcOOo8UT1B9pfm53Iyh4k35KQViCDBhxtdFpEOj3y+QuQypwIwb9jxw6qUsW9oQUqiGHTKaQxFQ4m2vyH5tKToKLPcGzXrEHiRfUOROsnOv+v+ZqoSivnf71OwYzw66kqen6+G/oyekpPMot2TcH/69mxC35ztoCtSiH4dZejadcG/t+52FnnWJwwhJjhOErTponZiPXqOZfiAMH/22/Bzj+CEJGdS4k+89VXNTqb6Ij37MtxOg8c3TBDas7KVusYSMnhFB3Ax7I1muBHAOPv54ja3UlUq6cT1ADRFPoKQhL48ccf4/p6UZ25IfptKT0A0wsYdQhpDA6KKzULs2SzaznROK2zT8MYxaqJHsnftYSoQv1QkR/OgQFCestMp3lLu9uJWl4VPsKEiFBhPGw584sn+IuDTfBzXYMu+E3UOovgTxZI31ywIDER/njCvQFE8AtBxxOkjdbp675R5j0a3MncVfDvCrZXLlcn+PGjvgzM4iKYg+V1K2b9eDf5AidFcc9qouP+CjTvEg9+Ic2AUU488Xzmhpg/NEwbRp5iENIYFsI6iPYny3sY7c+ZxucT9RoVn9fVC1chxt1y+Gt0d2Y4Qigimn2P40jz59VELUaEFsPqTkI4WfgbeiUxpQfRsHih24wyXKwbVvCnabOwLOXTT51r5Miz/WU6IoJfCOHz5o7w7vc1UT2td4rZD0UHxx64roVz6AFml3R1u1TAohlpnUGCf19ob5Et032vvdvejV0Q0oCtW7fSlClTaP369VRYGJyCPWzYsMQI/nhPLQgpAG3HbQfSZNmR6d1u2/43jgON0nbBr0f+MRgd+LsztfvT8aEvscLXchRsn+sUErtF+DEw4H4BMaX05EZvy4mT0g/BeXxxj/BP+TdR1bbhZx5isRIVYmbmTOf6tNNid9FJBhwLkgi/EHLMRAqNm+Dn4IdeW1TeiN4jcwDGAoBFvN5hXb1O6UBgx38O0AJc/7xG1FPrXhdu9kAQ0oTPP/+chg4dqtLlkVKvB9Xxf8IEf7ynFoQUYGtqhQNjsgQ/C0lYcVZtE7/X1SNCONhz0a7ZawA/Fr2rL55ni2ZvnBwq+Hnal3sH8Ovor+eV3PLBtQBeZgl2x7mNKdcg4MRZsyfR8tHOLMZXnYi6Phu87EG9iTb84vwvEf6kwq43xemumwyaN3euN2wg2raNqGoK23wIaUa4mX8umGX2bQwV/Ku/cAI1XLBri/AzKOZVgh8d5T2mGLMTmUT4hTQDDj0XX3yxarxVge3UioH0kS5JVPadlXV2r0je+7NY1CP98aDD/cEDGFtKD6MXnNbpb3+9bZqtm/919YL0okBhWCxRIX4O0os+bRDcadiNaPP9I8FT3KhBME+e+iAI7hbHTEzceghhWb68eJaZyQLe++jWCyTKLwQTTvBvM25vCj4OIY1x85+B+8r4UnpAm/8GatP8j/uO+RD84VIT/e+3NXBsl6JdIc1Al92rrroqLmIfiOAvSdgai2zW7SkTDItFzn+PF1VaEB0/MyBkd/p8DMvVCy/43cS6bRA0/0n7srEIfo5ScT4p7DWTWbAL9KJj0+KObTmbXug4WyBCx1PmEuFPieBvmMI+eV6RPH7Bj98JLkKEX+9vwrOnYNcKovfzHAefWXcHHq+iTXW1uZmo50ii/prPvr9wd0fwa+tBJn1G+Lu+TvEuKOcyayAIKWLgwIE0derUuL1eGmeFCklB76qaaDj/28zbjAc8HYs0mY2TnP9rdgtdTn9vCG9E+df9ELwMTjYmZWsQ7bV05y1OhJ/57XyixkPDnxi5sMwE09axFMvrgt9sYsORMb0+AQOlov2Sw59E9u0jWrMmswT/zz9LhF8wj1elItsdI+iAc9GiV5yu6EvfsS9fWTMOwXGr2UXBj7NrGo5h+VqQRA9UYBk+xqFjO5PK7vOC4OOzzz7jf2nw4MGqqe3cuXOpffv2VKZMcM3gSSedRNEggr+k0edTohm3OgdLNKlyE5KJgA+6ifBxzylrnECqEFX2eQXq6LMLEN7dXyRa8AzRwv+555UCTrvR89nV+8Yw1WYbJMBOFI2tIuWZmsTqi8+NxLDdzAg/D8z0bRWrs5AQMyt84044IXMn23RGIvyCHz04Eu6YwcehfN/xdc1XzqXmYfblI9VMcZACs5T6rCgCHIUFjvuam/FAudryBQop55RTTgm579577w25L5bGW5LSU9I45CSiwbMd4Wq6z2RqSo96TeNEAPs2mwuQmdJT5dDQIlXbrAfXBdTsYbxPnAQ//KrDwQOzMtWIztSahi18keKe0gOLUluEH0gOf9KY6CudaN8+M5obi+BPEbuWBRoPpgt6qujOJe7LcdqNngIEtvosM00izQ5zug4i+GYaJIImmBG1WRI3PDN59tSCEAZYb3q5RCv2gSfldRo84Tzy8ceavaGQvnBk2i1ynHEpPb4IP3PIqfblzAi/ui8nvODHSYIjULp7D/JCYzlJ2AQ/clfX/UR00JGh6wP45FWjS3CU68+riA69InpFGJTSY3SttOW6SoQ/6Xz1lXN9wgmUEYjgTxGf+iwq0USqeidKC/Rj6MpPnCZcNmcdjvD3eJloyqWh98dT8CO45Raw0DuvC0KW4kmtVK1a1X+BF+j3338fVEjw559/qvvwuJAhcGRaT0/J5JSe0obgd5tFcCvaPW0d0XEzAmKYU4MAThwcgdIFv5n77hVbGtCcB4i+7+cIeBt88oLYN7dfpJOVbQpbF/zVNZeLoGUOhG5P8eFPGkt8gdGuXSkjYGvOzZuJ1lrKXYQEs8V3/EoH9OMnmH1v+OVCfPo1S029mDbS7HCkCD/PpJY/mKjsQcFd4AUhzYBDz7PPGhkIRPT888/TNddckxjB//rrr/svderUobPOOouWLFmiovm4LF68mM4++2yqlQmJpkLA75gtKJHbmAyKEhjhN7sztrreZTkXwY/8zWrt7CLab5tZKtglIlwxWth1tXz+7fOda72WwCa+MbAxo/l7wnj0z3mI6IOKRCs+MV5Py+FHf4Z2vsY2Ovs3B/6XCH/S2ej7iR6k6ZJ0Bs5xrVo5/7/xRqrXpoSwd0Pgf7eZulRgps2YHXWBnl6D2dI+Y0OX6fwY0Wm+ynUvwSJOQ1RBGzPCvzvgwIZ6qUrNAo91ey786wpCCvjoo4/oiCOOCLn/8MMPpw8//DDq14s6H2HkyJF0ww03UE5OQLTg/+uuu049JmQIuZXDF6kmAlsxaLwwRXDFBi7LhbHlRHoOC1s9ku3v3FspOGffi39+vNAj8iabDNsuRKs2/k60bb5ToI3nmoK/wHi9DneH1idU8ak3IDn8KRP8NS398tKV665zrkXwJ4npNwf+j3d/k3hG+NHcL1y3bwQyDjmZqKnhuuPvrNskfO8U/+toRbu6Sw+n9KCTL7uuHTmGqNlwosPeIKobxy7mghAnNm3aZM2cQabNRj5BJFLw5+fn0/z5vmikBu5DIYGQISDv24z2Z3JKj1ci+fDrJwx1XUQ0+z57Iy/TQzpe8Ekp6L0Mgd77g8BjW7QCN6zv9/2JvjmM6At9NqIw8gCi19vBy7S5KfC/RPiTyp49RLt89fSZNHF61lnO9bx5TmqPkGC2zg78n04F9abgtzn16IYRXJekB6L049MJc4lOt3ThjTalh2ct82o4fWl6vkrUdJinjyQIyaZ58+Y0fryvy7TGV199RU2bhnH1cyFq5XXRRRfR8OHD6Z9//qEePZyI4O+//04PP/ywekzIEPKqElVqTrRzEdFfNxI1OMWJdmRqSo9X9NkFHPStU8J7NZ/mWURL3wpOnUGHx3mPEfX+KDHr+FFNov7fE9XtbxHoZQKuEnAXQs7/bl/+6eJRRFOvsDsvmTMDeqddvYGZW5qU5PAnlU2+/kO5uYjmUMaAYFS9ek7/gMWLiWpYfmJCnEC/EHTrZrx0lk1VSg+vGwYCU/7jFBdX6+DcV7FRwHRB76Sr12ZhQBDJktP04TcNKXBc1AW/IKQ5yJy54ooraMOGDdS/v6MHUC/7xBNP0NNPP514wf/4449T3bp11Ruu8XWFqVevnmoOcP31LnnTQnqCBicQ/KvHOZcGp8deiJoOEX54N2+aHH4Z/b3LWaJFprC1zX50fJCo9Y3OtHCsIH3ItKLT+fVsotPXh4/IV/JNc6/4yLHn/ONy99czo13+1yvrcX3Fhz+Z8GwtovuZYMmpg8ATTg3//EPUzdL7TogTk4YG307nCP+su4jqHEW07keiJW84l8Nedx7T66KQNqljS2H0GuFf4gvU6Dn8nIZpztYKQhpy8cUX0759++iBBx6g++5zMg0aN25ML774Ig0bNizxKT2lS5emm266iVatWkVbt25VF/yP+/S8fiFDBL/O5j8z14ffZs1pQ3/v8vUip/Tk7wxdBgqsOGJfvU+EdTWjWTbBX0fLOw0n9sMKfuOEyjm0tfu6CP40EhUlRPBnGs18tZAXX5zqNclyNvwcfDtdIvxIM7IFSr7rS7Tys9DaKF18u6X0eEU/fpsd1BHh5+Oel3OFIKQBl112Ga1cuZLWrVtH27dvVyY5sYh9UCzlhcIBIYPZ8Xfw7URbkyXSh9+rSwVOLojQ48QAdxpXl4f8UMF/ZBx7TMAVCA1zXB+vaz+Z52gnwNzyROXrE+1ZbX+NxucR1T2GaPKFoR2V/Z12jRNqtxeIqndxUrx0/EW70mk3GWRiwS5T17fr7t7tpPXEkGoq2Ng6xwlYVGlpNwxIB8G/+E2iyRcEHzf0IMEWrSGXLdpupvREK8z5+L1Xmx2t3ploy19OL5Vw5geCkMYcFAe7tpgEP+yAPvjgA1q+fDnt369V2hPRtGnaD1pIb8wTBFuWZWpKT5eniLbPI2oZwZ+27S3uj/lTejjC78uHP/gkogYuzbxiodebRL8NI+ryNNHPpwai+jwVXqtX8PJuJ6q+44jGd7EPGA5/i2j5h6ERfhT2YjvZXg+DiJZaQTdjcy8SEp7Dn4kR/ttvJ3r00UC0f9Uqovr1U71WGQ6i4V91csTzGVvtnbnTYfZt5m3Bt8tUdneB87ufVY5/Ss/Oxc41gjpwH4Pg379VBL+Q9nTp0kXl6VevXp06d+5MpcLkdEart6NO6UETABTnwo//r7/+UoW7NWvWVNMMxx13HMUbpAudd9556j3Kly9P7du3D2r6VVRURHfeeaeqI8DjxxxzDC1cuDDoNTZv3kxDhw5VMxLVqlVTRcc7d1pSNUoafT8Nvs3Fn4nuvpioCH+lxkQnzCdq8Z/YX6OUkdIz/8lQT/p4ULsP0clLgyPp8IVuc3No6hFO7ov+z34CrNE5uBkYs3dtsFUfC36cfN8rTbTm6+gi9hxpS5aFawknk1N6KlcmuuGGwO0uXQIDGCFGts0LCHo0S+RIOY4jCEZwxHzG7Y4lr+7TD6GbLPRmVrYUHR1bSk+ZqsUT/GZDyQoNAq8pgl/IAE4++WQqW9Y5355yyinqttslWqIOtf7vf/+jl19+mc455xwaNWqUyt2HPRBEN4R1PNmyZYtqOtCvXz9lQ4QpDYh5jHyYRx99VA1C3njjDWrSpAndcccdNHDgQJo7dy6VK+fkQUPso8D422+/pQMHDqgBy6WXXkrvvvsulWggFI/6kmjuw0TrJzquD4lkyZv2JlnphL/oKz+4IdbuMM2t4lVs3OxfgaloXYiPaxX+BGjz3657rF3wc8Tf1rgnHAcdSbRpCtGyd4kan+3tOULMrF+fuSk94LHHnOvHHydat47o2muJ3vT9/IUY2Olruwz2bSJa843zP6LXHM2eebsjotG1+4zNjsMY8ubhxnbCvMTVToVLq0SE34196wOOcQw79zBenHl0ghoj+gQ/G1Ec2Braf0QQ0oy77nKaYBYUFCjt26FDBxWojgdRR/iRxoMuXwAR9R07nDy8888/n9577z2KJ4888gg1aNBAdfjFTAIE/YABA6iZryoM0X1YE91+++1qtIMN8+abb9Lq1atp7Fina9+8efOUj+mrr75KPXv2pN69e9Nzzz1H77//vlquxFP/OKJ2dyY+pQcHWo7s1zosfTc7nxQR4ddddLqFtreOG/2+Iur3NdGhV2rFsS4OPrbBUo7WDIwtO3u9ESz4UUSHjsosDkCNrkSttVBsOJqc71yv+pxoQQK3haAyrj7yOb42b565G0SP8r9lGKYIxbC5xGwjR8eRn776y9Du4JMvJprvs+2DE9smLeqfSMzjlq3XiTmIgR8+A599XeSHe74NszEXLD9Z8GO7SQ6/kCHABAd6F4HveBG14IclJ0fyGzZsSJMnOzaIS5YsUQI8nnz22WfUrVs3OvPMM6l27doqn+mVV17xP473XLt2rUrjYdCVDML+t99+U7dxjdERXofB8nAbQv8AG7BBQjU0X3hQk7UgCsIpPXH+Dv3sWuJErZGjGalbYirxF+0eCJ4Krzsgce+JE1K9AUSlcxy7znCpNrbIlN79F7S9LeBAhJx8gJmDH44m2uFLd0PtwKCpRFUO9baO1Ts6BcCA04uEhDBnjhMVB717Z+5GrlMn2JZzWZgadSECen4+0uq4tgiDfdMCE6wcS7RS666d6NlbNzew7YYxhE3wl9cEvynyoxX8KPrVo/y1DneMDcDu1SL4hYyiXbt2Kl0+ZYIf5v8Q4gCpMddeey0de+yxNGTIEDr11FPjW/C/eLHyG23RogV9/fXXyp7oqquuUuk7AGIfoJ5AB7f5MVxjsKCTm5tLNWrU8C9j8tBDD6mBA1/atGlDWQ1HWHASwbRnIti/LdDwJJ2NxXUffo6YqaYvSZoCjuR3b5viNiP8ut2q/tj6CQHBX9losuWFrs8519vmEi0U0Z8oOBqOJlYtYvia0ok//ggMWsaNS/XaZInBAgruud+IOdh3g2t6isOKT5wmjabjl47Z7Cqc3z2fa8zuubplcU6Ugt8cJOA4x+e33csCVqaS0iNkAPfffz/dcMMNNG7cOJWWrgeicYmWqJP6kL9fWOhM240YMUIV006aNIlOOukk+ve//03xBO+DyPyDDz6obiPCP3v2bHrppZfoggs06684c8stt6gOZ3rhcFaLfpw0IBKR9oFIkBd7y2gp2BVbxCbZ6D7OsHGLVHgWb/wR/kK7k5ItX1+/D8/XG4qZy+9d596DIBKwA2TWjCdqEd/fu+DwpK9OvHHj7NgiAwcS/fILZltxzkj12mQoujvW8jGB/70eT/l3Hys7FhH9fJrzf7l6RK0D58cg8o0If8cHiP64zN7PhAnpeqsFhGI5X+izISq6Xxhq1SmCX8gAjj/+eHUNfa279SCbBreR559QwY9UGFyYs88+W10SAZx3TKHdunVr+siX4Ir0IoCGBFiWwe1OnTr5l1nPFXA+8vPzVVoSP98EFdJcJQ1iGUllZFoPBD/y+KsbhVPxgKegTdu1dE7pmXZd8rsymhF+nhkJF+HXi94wUNCL80zBz97XsRRO44DT/N9OSk8sAwYhIvn5zgXceGN2bDDfoZhmzUr1mmQwbpabmMFrcTnRwv/ZHz/kVCe1x5b2Ew1bZwb+/+t6ooZnEFVs6LwuUoz4eGBG+BFhP2uH0/djtOXYhQBFuONrtEW7YMv04H4ntsFGsmZsBaEY/PjjjxRPok7pAT///LOyyuzVq5eKfoO33nqLfkEYJ47AoWfBgmC/4b///psaNWqk/kcRL0Q7PEt1cY7cfKwbwDW6Af/5Z6CL7A8//KBmD5DrL/jgPMc9axKzSQ7szJAIv08soxBu7XeRnSbijd+ytNA+FW+L8Iez1uQcfoZPyLH2QsBJXq1ecP8NIT7Mnx+wtjznnOzYqlx4vHRp4kqEsgrkmi99n+ijWkQLngvfVAuzs4da+mYw3FywuB79ZpPABc841z+dQPRJfccMAKYAehRdF+yw9bUd+0uXC8xq2o5nxU3/xPHcFmSSCL+QAfTt2zfsJVqiPusjug5HHlhdwocfBa5g27ZtKvXmyy99jgFxAPUBcATC65511lk0ZcoUlVKEC8CUxjXXXKPynJDnz7ac9evXV/6lPCMwaNAguuSSS1QqEGw5r7jiCjUrgeUE3hMq2SM0cU/pSfcIv+8nsfOfwH2pSOnBydM2ALNFvKqESTezDRCK0wuB82vZ3k6IK9xiBN712kRqRuOLzxAmSuHHn4m9BZIGfvdjDw7c/vMqR9CHi/CHE/N+wV/MDtkh9r2lnNHbOl+wbcnbRM0uDl0X/XiPdeWZXj+WEaDuNhQLnR9zag36+PrM2OxIkzlrKwjFAAFraF9kqnA6PTNs2LDECn6IawhnvBGsLfVoPB6LJ927d6dPPvlE5dTfe++9StDDhhODDQZ9AHbt2qV89bFhYLsJG0724AfvvPOOEvlHH320Skc6/fTTlXe/oMHFX+EKsooD0oUyIcLPghtT0G7NYJIV4d86JzDLEE7AN7+EaO5DRHtWBxp3+V+vtGO9Oe/x4Ptj9eTmyJhE+BPCr7861127UtZQvrwT5V+0iAjGaIMHp3qN0pjtc0Pvm3WP+wAdKSvhmgKy4C5Oh2wch3B80cH6LH49OMefZwEQNIHzWM2eRJWaRgg+lLLPShYn8ITjXfNLw4v6ylo9kiCkKZ9//rnSu2gUi8axeh4//o9W8EcdQ0KKTZ8+fULuh5sNBHe8OeGEE2jWrFm0d+9e5amPSL0OPjQGA3DcwTLfffcdHXposNUgHHnQZAv2mpiJGDlyJFWqlOaR5mTDbi6mrVo8QCRo+n8DtmnpDJ9Y0dzGliOfcHw/yaXvEH3Zjmjeox6KdssSnbKS6MSFRB2dAveQiFdFowK0VHEFvzYgEuICcvc/8Tkp+mq1sgZ2Th6j1ZsKFnZZup3PfyJMhL9s6Kxfm1uIjp1EdE5B4HdenJSeCZYRGgIGvw8P3EZDPjT6AgcdQXTaOqK+nwWn5DS9KPR1bCk7vd52rrk/TCyEE/udHpEcfiGEF154gRo3bqyCxUj3RlQ9HGPGjKFWrVqp5du3bx82u+U///mP0qoIWEfD9ddfTxdffLES/NDX8OTnSyyNbmPy4V+EUI0B8vfRcVfIUDjXOxEpPex2w/mpmSD4ES1nWiexejJSqo1bERtOnJWbh+bDMrpzj5f3cUMi/Alh506YFDgpL2iqGEN6ZlrTr59z/Y+WKSdYsB1/UXQaLhCDPHgduKwd1Ms5Fug2w/HK31fraQz4kTI0dUSg2RXe2zwWtb+TqPeHRIdeFdoDRqf+IKLTNhC1v5sSQpubEvO6QsYyevRo5cyILrfTpk2jjh070sCBA0MMXxg4U55zzjk0fPhwldqOFHJc4CJpgiwV9KuKJYUcNbKwoq9QwaP9brwFPyLsV199tSqMxYgF3WqRMgOvUPjkCxke4U9ESo/ewKqtL9Kfrvhz6PcFokxoOpXs93fDFO7RFmUzktKTVvzwA9HGjYH8/dwYJ2DSlYYNA4JfCnfDwMffSkaL5X9eC1128JxAsKbecYH7ubMsiEeEv2q70PtszffYShiC3+3Y1vB0om7PEHV73hH7nYwZTKZcrfj2azl1tXPsNFMehawFGR26Z/0+X72pjSeffFJpW/SWgjMk0tYhspENYuOZZ55RtaE33nijqhO97777qEuXLvT888+HCPYrr7xSaeQyZaJ3xsOgYyoXdsWBqE8r//3vf1XhAPLhd+/erdJ7YGEJwY8PJmR4Dn9BggV/7dB0sLTCjHxXa5fa93crwovVXcfr+7iBFAIgOfxxBQ42zC23UNYBd2UEqdascQqTu3dP9RqlKRudDvFUpRXRTm0m3czTr3M0UVWtWP+I94g+rBbauCoegr/CwUTbZgfScpC7r1tdNhsePCBxE/w6h45wLskCtqGnrknvpo9CXDEt3e+66y66++7QWaP9+/crF0fUijKo9TzmmGPoNzQPsYD79V5NLM7Hjh3rvw2dDIMbDAratm0b02cYPHiwev7cuXNV2pA5aIA/f0IFP6L6t912m1oJpPYgtwgbFjnxe/bsofKo0BIyj0RG+LmjYuXg2or0xIiwm5G2ROMmxKt1JGp7a+yve1DvgJVePHL4xaUnriz0NUC+4YZAvns2UaUKEUq/xo8nuu8+Il+zdkEHvymOnO/4m+jIT4h+PtVbjnrQ7aLQmbxYXXo2/UG0fqLzf8/XfC47WrEuqGqIGX22IZ0QsV+igEg++OCA41VZrbeSzsaNG1UDqzp1gmfPcXs++yQboGbUtjzuZx555BHKzc1VKTmxwjWrqFM1iaXxVszGb3l5eUro9+jRQ406MCUCFx0hQ0mkSw/brGWCFZopuCslud2pntLDjkZoktVvPFGjs2J/3UpN4pzSs09yM+IItwnhJlXZyIknOteffx74vILGnpWB/9EAscEp9kE+foOtrnEXs7qrWKli5PCja+7XPQL1A5hd5POEf13KEuVps45D9hJVELtrIfVUrlxZOdvwpayL4E8EmDFA2s+oUaOCnHWiBbMEbpdoxX5Ugh/5T5jy6Natm/LG56mL119/XQn9p556SvnmCxkKu78kwqWH0z84HSSTBD/PfKTi/dEl8/hZRMfPJipv7wrtmXL14lu0u+Uvog+rE62KX9+NkuzO89dfzv/ZnOpy+eWB2YsJE1K9NmmIPmvGx2HTlavD/URnbrOnRnZ9jqjxeUQH+0ZWQZ27YxD8W6aFFgeb64Njer0BgRncTDjGC4JGrVq1KCcnh9atW6ffrW7DpMYG7g+3PJrTouC3YcOGKsqPy7Jly5TrDpyAInH88ccrR0nm4YcfDnLB3LRpU0jKUlwF/5133kkvvviiWtmlS5fSmWeeqbzvIfQR3cd9N98sBTGZb8uZgAg/d4ksFX3RStIxi2YRXU/V+6PDL2oIqsQhFQp+3UHvU8wIPziwzT3lQPDM8uVEe/cG/OqzmSOOcK7nWuzmSzx6XUzLa+yuXDgeuTl1tbyC6PC3iEprg/niuPQseTP4Nt43ZH3ynGDEKSuIBv1R4r9CIfPIy8ujrl270vfffx8UWcftXr16WZ+D+/XlwbfffutfHrn7M2fOpOnTp/svcOlBKvzXX38dcZ2wjF5kjOazug1nfn6+ssiPFs9nfXiOvvnmm6pIANZDHTp0UG86Y8aMYk1ZCCUgpYdPZMkWz7GgR74hiiO55iTy/ePZpAwnfhTT+ZvjFLNol5Hi3WLDaZ+w5cyW7rputG7tXIvgt6D/ljo9bLfc1AtyveBWtIs+I79dSNTkfPdUwd2rgm9D7O/fYryOz1qqwiHRrZcgpBHXXXcdXXDBBSqDBWnq8MtHQ1e49gA0uEI9wEMPOQ3o4FTZt29feuKJJ1RhLZrQwk3n5ZdfVo/XrFlTXXSQ+o4ZgJYtIzd9KzKszMzbseJZ8K9cuVKNgkC7du1UPhRSeETsZwnJiPDr0eF0RRf4KVlfPYc/zk3KytbSBH+Mg3Rzm+TVKP56lXBY8LvMHmel4I8hOFVyBD+MAnhgzf1R9N9wNLgV7f79P6LV45yLq+BfESr49c65gpAlDBkyhDZs2KAyWVB426lTJxo/fry/MHf58uXKuYdBWjuaud5+++106623UosWLVSaO7RxOuNZ8KNAAFMf/ifm5kq32mwioRH+A5kZ4U9FPmrpBEX41WvH4fOYgj8TCrHTnMWLnetDSkCQlNNXMTu9fbvj3iOYtU7ab8yM8Edry+sW4S+A246PAzvtHdD3rAnt5VGtA1GvN4kmX1w8q09BSDOuuOIKdbHx008/hdyHtHZcvIK0d68gkG4G0+MRXPcs+DGlcOGFF/ornffu3avaBVesGCxKPv7442KvlJDKol1J6UlphD9RKT3xGsCY2wQdiTHdKGl9MTNrlnOd5sGhuACBX6OGI/iXLCHqmMSedmmPP/UxL9gDvzgRfj6emDn8HIQB+zaECn78pk3vf7w3fudIA6p9FNGXHYganR3d+giCUGy9Ha6JWFwEP/KbdM4777yY3lBI98ZbiXDpydCi3VSn9OTEO8JfLg6vkRcqUiAMYm0IJqiiXZDtBbsMBjYTJxJNn15CBT/E9OoviGp0dRpChRP86J9RsyfRpt+d6LrpeR9rhH+v5jDywwCik3yNIPSCfE4DqtKaqO4xwYP6ig2ITl8fe/G/IAjF0tuoK4gWz79W2G8KJSGHf6/TIj2exapFB0KnqtMVPcKeCsGvGtv4qNkj/SL8ttfA1L8I/phZ5auNrF9C7Mu7dHEE/7RpOLFRyWP9BKIJPuvMs/MDaXw2wY8c/AHo9lkU2zHZzaVnT6BBkOroi8f13hwo6uXzwgkulkqZkKIpCBnI6wnS21nuCSF4Rm+oEu8o/9L3MifCr/8kUiH4a/d2cu0bnUtUtVV8XzseRcC2bbJzSfFft4RSWBgQ/FpTyKzG5/2gBH+JZLfWYGvv2lAffvM3hsh6rAEYf2ds45iuvy/YsSj4Ngt+GcgLQtYggl9w0BuqxLNwd9dyoq0znP8zIc87yMM6BYIf1plnbnX8tONN/eOd64N8ZuixYNsmE08imvJvol+GEK3/JfbXLoGsXEm0ezdMEIgaNaISE+EHaDYWQ7PIzEfPn9fFvy3CX1zYVWfH30QHdlgEv++YvGsp0c7FRL//i2jTVKL9IvgFIduQBDzBAREkRJYL98W3cHd/oDscbZ+f/ls71Sk9wK2xTnFBgV3VNkRVIvsAu+K2TRY5/sMqn7//t7G/fgl16GnSBD7NVCKADXWFCkS7dhHNmBEYAJQYcIxl9qwKvT+ex50KDZwoPSL2S98havEfZ8DBEXxVHzCZ6NchTodeLPPPa+5OPYIgZCwS4Rfs1px6FCpezWR2Gb7OaYnR6TabwAxL9Y7FG1DoA6IGp4U+rkcRhYhs9PUt8tk9lwhycoh6+MpT7ruPSh4F++zNrbZMj38TK/zma/dz/v/jMqJFrxDtXe97LCeQNnhguyP2TfJ3xm9dBEFIKSL4hdDC3YmnEH1ycCAKVBxQBMzkb0//ra0LWvhOC8b2KeW4i2BGqOU1RJ2fcP++hYhs2OBc14rSbTHTefxxR/iPHUv0999UciP8858MTn8E1TvF9/3yqgf+n3JpIJ2nXJ3gGVgb/b+L77oIgpAyRPALoRF+5HvCm3lxMSrFuRV0oSYAeyUgLz3e6MVxumWeEODYSUSnrCaqfSRRq2uITl1DdPRPoWJG8BzhL2mCH4W7HOX/4w8qWeiDYohvnk1l68x4pxKaM5XzfIOMcnWJWl3n/rzeHxDVOiy+6yIIQsoQwS+ERviZWCP8f91M9El9J/+TT26ICtc/LsMi/CL4rcBetXydwACpfN2AXaeeriB4FvwHHZTijbV/W/zS+Dxy+OHO9RdfUMlCHxTj+LhlRmI7kpvuXMve9b1PrjNobzbc/ryG3ruICoKQ/ojgF+xOPQDNXmJh3qNO5GruYwHBH++usYlCUnpig+sC9BkdITMi/Pu3EC0fTbR8TFLfdvBg5/o32MyXJMxB8dfdnRnRogQJfrdaJG6sVfnQ0Mfq9I/vOgiCkHJE8At2L36wbV7xts6CpwKCHw5AmYCk9MQGf78S4c88wc+540ku0OzkS1VfupRo82YqOdjS3tBwL1EdyfUcfp3KLZxrs4i/3qDMSL8UBCEqRPALYVJ61od2aIyWbbMTazUZbyTCHxuc0iM5/FHxzz/Ode3alDr0iDK6bCeJ6tUdO1Iw3WdQUyLgQXGzSwL3HdBSquId4UdvDxudHgkNxrS4nKjfV0QVxLBAELINEfyCe4QfJ//dvuhftMW6Zgv3TBH8iLQxksPvndLltEhlMQeJJYQ1axzBX7p0IJ89JZTKTVyX7Qh07hxowlVi4EFx5eaB6HsiBX+N7kTljBHlsb8QVWwYPFgHZUtY9bgglCBE8Avugh/s8IUgvQJ3Hx1uLGMWjmXCNsiUuoN0QBcNNj9vIYSFC53rxo2JqlRJ4QZidxj1f3Jb33bv7lx/910JjPAjsl6mqvP/14cFOpLHW/DnVSU60bezMXq3bT3CL4JfELIWEfyCtjdY8uzROTUaFo+y5wfnZkgTq6bDiVqMcCzpBO+wcOFopRCR+b7G0y18qdQpQ3fnMWfoEsxpvt5tX3/tzHiUqAg/Bsn8u8nfYZ9xiRdltBFl65uCH9NnXys1jf97C4KQFojgF+yRPrRcjzbihyLf6TcH3wdPf1AmQyL85WoRdX9eLOmiBRZ/h5zi/C+Fu57gNBYuXk2L3z0lV/AfeqiT1oNxxu23U8mL8NsEdrwj/MyA34haXk3UztjQuu+/zbFHEISsQAS/EKDxUOe6attA5CkawT/j1sD/Znv4TInwC7FToWHA5lEIS2Eh0ahRwXns6RHhT17RLnP22c71zJlU8iL8VQ5NnuBHE62uT4fadO7zWUWBSo0T896CIKQcEfxCgDr9nCjQ0T8E3Gq8Cn4IhV3LArcPN/K4MyWHX4idvGrOtQj+iEyZQrTX51h7WKqbmRamLsIPBg50rpcsSXpGUWoFPyL8NS1ffrxtOSOB4uFEDzYEQUg5IviF0CgQHB2iEfwQ+5OGEm3hHIVHiGp0C16mXKpbiQrJs+bcLxvbY/5+y5ZEjVxcE5MGN3xKUYS/Ocxq8og2bSJasICylwPbifJ3B1J68Hs55GSibs8HL5ds0V3rcKLeY4gGz03u+wqCkFRE8Asue0YUgh+5+8veD9zGlDHcbnRf/5o9ZEtnOxyZDMoJF2wsWuRc9+uXBtsnxRH+ihWJuvniA7NmUXayZx3Rp02crrr7twYi/KVKER06IljkJ1vwYx0ankFUtXVy31cQhKSSUYL/4YcfplKlStE111zjv2/v3r00YsQIqlmzJlWqVIlOP/10WrduXdDzli9fToMHD6YKFSpQ7dq16cYbb6T8fBElYeEIvxdPdd1hAuT6HCFyywfuKy+NXLIeFip6TrhghS05U+7QkwY5/GxNyl13s5LVXziOZ9vmEu1cFGplq38HklYjCEJJFvx//PEH/d///R916NAh6P5rr72WPv/8cxozZgxNmDCBVq9eTaex1xsMEQoKlNjfv38/TZo0id544w0aNWoU3XnnnSn4FBkEW8N5ifCbrizl64S6P+gnNyE7EcHvCcQafvjB+b9NG0o9KXTpYZo1c67nZmtWyb5N3myQ9eJ3QRCEkib4d+7cSUOHDqVXXnmFqqMfu49t27bRa6+9Rk8++ST179+funbtSq+//roS9pMnT1bLfPPNNzR37lx6++23qVOnTnTcccfRfffdRy+88IIaBAgu6Dn8qKSznbDMIjTQ7F9EtY9KnJ+0kP6CX88JF0J46CGijRudVJZjjkmDDRTUeCs1gr+HL+Nv6lTKTmwdjHVvfAbHTqTYCIIglETBj5QdROmPMc6Of/75Jx04cCDo/latWlHDhg3pt99+U7dx3b59e6pTp47mCjGQtm/fTnPmzLG+3759+9TjfNmxw0hZKWmCf84DRB/VIlo1LnyEHy3ce77ieLKr212StLJCWsADPEnpcQV6micXd+0iyk2HMXHQ95WalB748XNKT1Y69dgEf0VLJL9sjaSsjiAIJY+0F/zvv/8+TZs2jR5CWMxg7dq1lJeXR9Wq+ewAfUDc4zFeRhf7/Dg/ZgPvVbVqVf+lTVrMu6dQ8M+8w/l/won2ZdmVxUzbaXmN4+nfZ2wi11RIu5QeqY9xY7PWuPr++yk9SIMc/gYNnOudO4O3UdZQ4PNg1cmtaLlP+pUIglACBf+KFSvo6quvpnfeeYfKldPafyeYW265RaUL8QUpQSVX8OeHuk3ozHmY6JczQnP2QZ2jiAbPdqznhBLk0iMpPW7MmBH4/1atT11CwMBr6yyi/dvSPoe/fHmiJk2c///4g7KPBU87121vJepwP9HRP9mXM5tiCYIglATBj5Sd9evXU5cuXSg3N1ddUJj77LPPqv8RqUce/tatPpszH3DpqVu3rvof16ZrD9/mZUzKli1LVapU8V8qVy6BB2FOyyksICpbK3D/54atyIxbtOcYgl8oWUjRbkQmTnSuzz03Canau5YSbfyNaPlo92XQJE3vm5DCfJqjj3auP/qIMg+476z83L79ti8I3t7tbiOq0zd4mYOOdK6bDU/wigqCUFJJa8F/9NFH06xZs2j69On+S7du3VQBL/9fpkwZ+v777/3PWbBggbLh7NWrl7qNa7wGBg7Mt99+q4R8iUzViSWlJ39nsAUnoobqsSL3Fu1CyUMEf0Q+/9y57tMn4d9GwO8d7FljX2atzy7IT2pSenTBn5HNt345i2jiSUSLR4Y+tt3XZS1cF+r+3xGdsoqoeqfEraMgCCWadCgZcwWR9Xbt2gXdV7FiReW5z/cPHz6crrvuOqpRo4YS8VdeeaUS+Yf5+tUPGDBACfvzzz+fHn30UZW3f/vtt6tCYETyhQiC/8DW0PzTLzsQdXyIqOXVwffDZ1oouUjRbliQmz5tmvP/qacm4wvRBuSrvwxEj/dtDhSImsWkKYzwN/TVsK5cSZnHNp8BBIwNzCi9LvJtufwgJ4+ogvQqEQShhEb4vfDUU0/RCSecoBpu9enTR6XpfPzxx/7Hc3JyaNy4ceoaA4HzzjuPhg0bRvfee29K1ztjBD9HBlFg1vDM4FSeXcuCn5O/K4krKKSvLacU7dpYssS5RiZh7dpJ+D70VJ28mr77CohWfOhckOOfZ7jCpKhoV2++tXw50fbtlDlgm5qOZbhv8zTn9opPAo93uC/56ycIgpDuEX4bP/0UXOyEYl546uPiRqNGjejLL79MwtploeBf96NzXeEQoiqtgpeZ90jw7VbXJWnlhLREUnrCwqkqTZsm5dsIFvxcX6NH9FWHbFPgpy7CX7++I/phzQk//v79U7YqjmAv7TsGRiJfG50U7HauZ95GNPcRovonEK322Rk3vZioWvCMtSAIQrLI+Ai/kCA4PWPfBue64dlE5Y0p58WjnOuyBxEdN4Oo9Q3ydZRkRPCHZcIE57pLlxTYbRbuDRX8B3aEdtJOYYQfNG/uXK9YkcKV+P1fRGMPJtrrO/ZFUyuxa7lzvfxD55rFPqjeMZ5rKQiCEBUi+IXwEX6mZg+iBqcTNTwrdFncV70DUSnZnUo0bMupR5YFv7/8u+86/59ySpI2it4PoWB/qOBHugkLfv/vPbWCn/34Uyr4/3mNaO+6gJVmJLbODPy/awnRr0Ptncmb/yd+6ygIghAlotAEb4I/rxpRuYOIeo92HCWCHqsqW1Egyq0QnNYg+EErD4h+5O8nLVVFr6Xg3gj6fcqS03e7tM/AwIz4l0TBz8x5kGitcayzsUUT/GDZu47ZgU7VNk5hriAIQooQwS94E/xlNFFfvl7wYykWCUKawJ1DpXg7BBSicv5+wv33bb9LTu/RU3a2Tic64GvKleNrbLj5L0olaSX4wfynIi/jxY44t1JcVkcQBCFWRPALHiP8muBH8a7eZGunz35EKNmw4EfaSIpzwdONX38NdqJJfoQ/3/lOQmw3i4J/78j13506X8xGjZzrxYspPVgb6PFSLMHv1gdBEAQhSYjgF1z2DF8+NlOmSuB/5OpXaha43UJyUwVN8IN8SethNmwg+r//c/4///wU2UX6o/yFkWcD9EZRSaZtW+d60SKivS6W9UmlTGWiBc8TTR4euj0jCf686vb/BUEQUoAIfsGOfoKq048ot3LoiVB/XBByyge2wfSbZXv4QCPwPXuI2rcnGjgwiZvF7IcAwW+beUGxNaf0gN2rKFXUq0dUA/3ACojmp2LcYc6AwIHszyudDrrv5xItfsOb4G9yAVFV3+gFdH8pASsrCILgHRH8gp26vj735WoTHf1DaOJxje6y5YRgdJemhf+TrQMtuI/onHOcTYHm30nL37cJflW4W2SfmdEHAoX7grvDJhFsH26uPmtWClbArEfaPi/49uQLQ9NzbIK/+4tEPf6PqPNjRKeuJjqoVwJWVhAEwTsi+AU7lZsTHT+b6Ljp9sc73kdU9xiinq/KFhSCI6JMSL54yePxxwP/Dx+exDfeszZgj8r5+bDmdKutMAvx2U8+BWAmBBg9FpMDBjuRgGWnDvcq0UGNE5x50JvE3LaCIAgpQAS/4E61tu4nK6T89P+WqFkyVYyQ9py0OLpixiznhx+c68GDiXr2TOIbr/4i1GELEX4W/HoNDqL+1TsT1eoV6Ka96XdKFX36ONdvv020KtnZRXoPiSM/si+j16fAthNF6qbJgdcuvYIgCElCBL8gCPGjTCWicnWc/1Po9pIu/POPc33LLcl+Zy13aP9m53rTlEDRri5QMRNTOpeoWnuiyi0C9+9NzYDtzDOdKP/+/US//JLkN+cGZdh+h5xKVP7gwGPYPmoZTfAvH+NcY5/nXgaCIAhpiAh+QRDiS4VDnOvd6WKmnhoWLCBatoyodGmili2T/Obl6jrXVX0J8TzjwmlWbl2xebAGUpjHf8QRzv9//pmiCD9SclTBhZYClWPpM7FrmXPd4jJ7fYQgCBnBCy+8QI0bN6Zy5cpRz549acoUBEjcGTNmDLVq1Uot3759e/ryyy/9jx04cIBuvvlmdX/FihWpfv36NGzYMFq9ejWlEhH8giDElwq+7kklXPDDnQf060dUq1aS3xxpJvxdIFUHqN4ZhZZDvyZUMRCo7Bud5O+gVNG1a4oEPzci467ReooP3zfzrsDsB89i1US+lgh+QchERo8eTddddx3dddddNG3aNOrYsSMNHDiQ1q9fb11+0qRJdM4559Dw4cPpr7/+olNOOUVdZs+erR7fvXu3ep077rhDXX/88ce0YMECOumkkyiViOAXBCFBgr9kp/T89ptz3bt3Ct68YG/AKrVi44ADjTXCX2S33D2QesE/bVqSa7+5B0HlQ53rKm1C+0xsnUE077HgQS32ee5mLAhCRvHkk0/SJZdcQhdddBG1adOGXnrpJapQoQKNHDnSuvwzzzxDgwYNohtvvJFat25N9913H3Xp0oWef/559XjVqlXp22+/pbPOOotatmxJhx12mHrszz//pOXcdj0FiOAXBCG+SEqPEqkTJjibo1eyHRn3byUq8KWdwF+fm+gpwV8QmuNvKmruuZHCCD8acOXlEW3dSvT33wl6k3UTiD45mOiXs4k+bUr0WTOiNeODi5p7jSJqcDrRgMlEeTUCz921hGj3aqID2wP7fMOztPQeQRBSyY4dO2j79u3+yz54JFvYv3+/EuLHHHOM/77SpUur279x1MYA9+vLA8wIuC0Ptm3bRqVKlaJq1apRqhDBLwhCfJEIv/KQX7GCqHz5gOtM0lj+QeB/CP5SuYHbHIVGhL+M78RTWXfs0VJXeJYgBUDsd+jg/H/CCU7jsrjz+8VEe1YTLR/tCPidiwONtcr6xH2lpkRHfkhUqydRu9sDz923iWisr6C3fH2nWB2++33HEXXWvFgFQUgJiNQj0s6Xhx56yLrcxo0bqaCggOrU0eqX0E+0Th1au3at9Tm4P5rl9+7dq3L6kQZUpUoVShUi+AVBiC8VfEIIYqqE8oXPFbN/f0f0x8T+bUTb5hcvpwXuO7ojj9+bvzTRwSc6+f3VOhjPKROav57CHgaLFhF98kkC6xxszcr0TuN6bxKIerDO57eqd9HNq0Z08ODAgEkQhJQxd+5cFVXnyy3Jt0rzF/AitaeoqIhefPFFSiUi+AVBiC9lfBGM/J1U0gU/otMxs+Zrog0TiVZGoXYLje66AG4zHOX3i/hSRLnlHatJU6Cq4l5D8MN7ftU4oo2TKVn07Ut0ww3O/6+9FucX37sh0DFXtyJl9PQdHXbqYVpcTnTIiXFeOUEQikvlypVVNJ0vZcvabXNr1apFOTk5tG5dcEM93K5b1+d2ZoD7vSzPYn/ZsmUqpz+V0X0ggl8QhPjCouhAyRT8e/cS/e7rWzVoUDFe6MDWgJ2mV4vM9RPt95uC382WM0jw+9J/CguIlr7tzNhsnRl5XfC8FZ8QbZpKxWXECKKcHKeBWVxz+dd8E/gf+flHvB/8eLna9uchdUenzlFxXClBEJJNXl4ede3alb5nWzUcwgoL1e1eLgVYuF9fHkDQ68uz2F+4cCF99913VLNmTUo1IvgFQYgvLIpQOJpUi5X0AM2i8vOJcHxv1ChOh+e9dnu4IFBEunNR4HZOheDUnmgFP9x70Ihqx4LgxyMJ/h0LifZtINoyjYpL48ZERx/t/P/hhxQ/ePap5mFOvj4KbvU0niqt7c8zm2vV6BbHlRIEIRVcd9119Morr9Abb7xB8+bNo8suu4x27dqlXHsAPPT1lKCrr76axo8fT0888QTNnz+f7r77bpo6dSpdccUVfrF/xhlnqPveeecdVSOA/H5cUCScKkTwC4IQX9i+sKgwpYWfqeINX93naaf5ejfF3PFVa/q0foKzPd1AEenqccH3NTgtNMLP34ee12/CgwMA15oNRrvb3avCr7vfCQjWFPOouJxxhnP96qsUP7h5FopyAb4o3l5oVla1rf15KN7VYctTQRAyliFDhtDjjz9Od955J3Xq1ImmT5+uBD0X5sJKc80aXwogER1++OH07rvv0ssvv6w8+z/88EMaO3YstWvnNDpctWoVffbZZ7Ry5Ur1evXq1fNf4OGfKrQjuyAIQhzQ85z/up6o+/9KzGZFZH+cT3cPG1aMF2JbzaD79jl59zb2BueTKnLDRfjDCH6AaDci+XstrhO4Hx79W/5yBDPbsNrY8DNRVZdouUfQq+bf/yZasoTo44+dgVTcBD8PTkHPV4k6P+H0IXCbAcF2qTfIGQjVPbYYIzpBENKJK664wh+hN/npp59C7jvzzDPVxQY69qJIN92QCL8gCHE+quQEUh8WvhiXKG9x2bGDCD1ULr2UqEEDojlzEvM+ixc73vEVKhTTfx9Fsl5cZRgz+n+IoYo5ws8uNJEO/XDwMand17nGIGDZe06TqnU/hi4X5wZUCLLV9qXU/2h5u2INqHTBD/Kqhk93Al2eJGp/D1HvMXFaGUEQhMQjgl8QhPije5F/4ZIekUSuvZZo+HCiV14hWrmSCDOv6ID75JPxfZ+//nKumzVzik2LHYEuXS5wn1t6FBptmV2NIVx1dC9+dTvCysG/X09XgWtNuWDfaesgZM9aoq2zQpt4FZMnnnCujTq52ECtw9xH7ILfC5ixaH9n6DYWBEFIY0TwC4IQf1peQdR4qO9GEdHejSnbyjNm2G0df/2V6Prr0TUxfu/FndiPOKKYL1Tgi/BXbEhU9iDn/+1zQ5dDsyg02tq93O6l77+dGzoLE4lczZEGMzb6bbeI/qrPiAq1jpb6/8UA9qalSxPNm0ekpdLGxi/aNLzbZxIEQcgyRPALgpAYuj4b+P+feFZcRse77zrX6Gi+fDmRaYX8gdaYtjigs+533zn/s398sSP8cNphn3gzig+2L/T2emaE38uhXxfDOWWdQUOTC0OdaXhdbT0AUDMQh1zWqlWJWrYMnkWJmY1a0RwaZQmCIJQARPALgpAYYHfIXVy3JShp3gX0REHaDmoqH300kBaC/H2YJBx3HKzYnPufftrxy3fpih6VO09hodMwCik9xYJz+JFywhaREM9mbn/+Dm+vZ0b8I6X0cOdYs0YgJ4+oRheig08KFfxrfaOdBOX0d+kSJ8GvMW9Ne5qcvF5igiAIKUMEvyAIiaO1L9Rtc3vxArqhrv6K6MB2z0/ZvZvo5JODC3NbtID1mvN/27ZEX35J9PDDRP37O/d9/TVRvXpE27ZRzEzz2c7jvePqIoP0m5zyodtxw69E+zeHPtfWObZ8/egFf4UGwRH+oNerS1T+kEDEHClbelpRje5as6/4pPV0800sTJgQYcEIMwq7clup63+/9hK1aeMUV599trPfCIIgZCsi+AVBSBxlawW6xcbCqs+Jdq8g2ugtDLt9O1GTJoFOt8znnxNVNOozy5Qh+uwzoj59Avfdf39sqwlnHk7n6WlYtRcrh5+tNVnEIoqOzrdusyb1jgu46ehUbkZURovYR3KiUcuUIqrR1SkcxrXbdwubzpUfB+7HQKBG50ADL9iJxgFuwPXtt04uv5WNU4iWvOnYhlrYtYtoywan+HnG8o7++0ePJrrqKqIxY4gWLAhscnynSAOLCnxeL43SBEEQkogIfkEQ0lPws7BVz98U1nLzyCOJmjZ1cr3X+7TWqFFEaI6IyDvnf5tgEICI8X33Obcff5xok/tbufLII856tG5NdNhhVHw4dYe75RZqDj3oYmtSqbnjC1+xgbuYRwFwSDfdCEDoNx1GVMYofABVLDMJoP6g4FkB9v4vJu3bEw32pdy//rrLQlunOzMK2ywFzkR099046TkDkIHHlVOpV5df7jyGwu6zziJq1Ypo/nxnpubYY51uyUj78szKT4lWjiVa+n5Un08QBCGRiOAXBCFxlK8XKDideBrRXotYdeOAnl8Tmqaxd68TuX/zTaJffnEaMzF33UV0wQVEDz5I1Llz5LdCdJeJ1j8fqUJID2LhDzeZYqEi4pwzX95uhannxZepSlS3P1GlJuFfF2k2aJSFTrKoryguaEJlUqd/YMDBvRjilNID/vUv5/qll4gKtPFgSNGwZUCDdC106y1Xxhk83XNfOVq0iOj5550Bow4Gbti3dFtXzz0ADmx1rvO3h3engj3oqi+jSlcTBEGIFRH8giAkDnRhhcAEKz8h+rg20a5lUQn+OQurU7+zj6LOnYtUzv3//R9alxPdeKPThRXNER855yb68qbjqHrFzTR0KNGdd0a3mnDuee455/+FC4kmTvT2PIhAdvlBKg/sI8MCG81t891nNJAew972EK02+0yIfd3/3tYkywZeq+4xRAcdTnGjWqfg25Wba+8X35QecOKJROXKObMpaHIWhD6TYJnl+OILJ/WqXN6+oBkIZC6hhuOBB+zF1ij+BhgYRA1EvxurxxHtWWlvXiYIglCSBP9DDz1E3bt3p8qVK1Pt2rXplFNOoQWcYOlj7969NGLECKpZsyZVqlSJTj/9dFoHiw6N5cuX0+DBg6lChQrqdW688UbKz7dYyAmCEH+O+oKo0TmB23MejErwPz2qHf30e32aPr2UEtj/+Q/RIYcEBFiFsrvophMeo+M6jqfvXvtApfLEEmXHwAEDCACnHfj3hwNuMccfH7iNegCIR1d2r3Jy8DdMJNrsq/DVWT7GuexYGJzOQxZhe2BnILrPef6poFaPwP85RpGEP6UnfoIfzcx4xgYDP1fBb0kjGvvmAvrtnsOoQh6nSwWampUvT3Trrc5gb+BA5z5E+JHHjxkk8NVXRHvCNDu24mVGa2/w+SorsVm2CoKQVNJa8E+YMEGJ+cmTJ9O3335LBw4coAEDBtAuVF75uPbaa+nzzz+nMWPGqOVXr15Np50WaCtfUFCgxP7+/ftp0qRJ9MYbb9CoUaPozmhDgIIgxAZyx3u8HLi9aaqnp939UC0q1eJSevUDny2lC34BB+vG5vMp17Scj4Krrw78z7ndbrz9tpNWhKJfFAvXrh3hxbdrwYqtM4MfQ40CR4O3+HwndSFf+6jgCD/bccapk21cMFN8OKXHa4R//zZPy952WyDnPihuo4tKQ/BjxubijlfTYc21am5N8DMYsGHghu+TZ2s6dXLsXCH2kbIVloL9oS5TNra5VR2nKagpQeF8LOlH6BWxeCTRjkWJWDNBELJB8I8fP54uvPBCatu2LXXs2FEJdUTr//zzT/X4tm3b6LXXXqMnn3yS+vfvT127dqXXX39dCXsMEsA333xDc+fOpbfffps6depExx13HN133330wgsvqEGAjX379tH27dv9lx2YPxYEIXbKVCLq/aHz/+7IKT3I0b7nMZ/to4/Vi1bShg1OOg9zzz1EX36mhV0XPEP0binn8n3/UMGlFwJbQMoQ8roxQwC/fth3usH+7cOHE1X2orv18L/pqb9nbfhmWVUOJaraPvBcdqEpkwaCv9bhTpOu2r2D7+dC3/9v7zzAoyjeP/6mF0JCDzX0IlWkV1G6KGJFRZoIdvAPSlEURREVLD8VC2BHFFFARRTpolSRLqD03kkgoaTt//nO7NzObvYul9BS3s/zHOTu9vZ253ZnvvPOWy74kbEmOZ5o7zSiPd9kag1GzYSiRaV7jq1KssPCD5cf+Oaj2bFiU7Wko0iZl8lSaKj998Tn8Z3qesNzPJDRJwPO1Qy3tKng2NLcZQE/+rucpCIgOcufNV2Wjiy85IfFMEweEfxOIPBBkSIy4AzCH1b/du3aebapUaMGxcXF0XJzJMD/derUodjYWM82HTt2FEJ+s56o2+FKFBMT43nURLJmhmGyDyyDSbssa7YPCyfyoetBtAUiU2j34qlUqvhZKlaMqHRpog0bZKAuFuoaXadlsNGBb/QP5S3RD//5nZ8SHdMqrboAP+4nn5R/jx7tntYdtgLT7uB/kK+zAJXuymELUDYp7PCPR9ErtZ/UxIzVcK8WhWoTVbgvYyaf8JLyf8QlZIbaBoI5k2JicOtRAhx++R4Mq33TU5JF7QVcIyAkKJkqFN9tbVv7eVk52E+GD8/4GjL6nHKemlqhQCpTcUypRGlerk+dS5TJCBmpunXLZryBG5iUIvBYpRlF7Ahb6hkmV5JrBH96ejo9+eST1KJFC6ptRlEdPnyYQkNDqVChQvZEEbGx4j21jS721fvqPTdGjBghJhfqgRUChmEuUjjoFlUf1j740qekEBUulExb506jvUumUvkyiTZRhBSNLZqlyImEHsDqBOJ4zSDNlSidKGFTpoc7dKgMDkU+/19/dfffv3BBWpqraHGqPlHCT1nuYdUG8ZszHlNoUVncSicgRFsdSMw5Fn5fqzqerEK+V1Zsojg1c0d5lZ4T7jeYkOHx1jsR1PzurlSt/d308LAaouoxqFCBaOiATRQUmC6zHt2bTlT3xSydClK+YsUAkw2djyebX+K08MMdS4l+VUQtO4If982pDZmuACBjEbJFNWhA9MMPRE88QfTOO3IVxBdoN0xe8XmsbOGatt5MJ9r3vayxoKeFZUs9w+RKco3ghy//pk2b6JtvLn9u47CwMIqOjvY8EDTMMMxFAEEDPwhkiQFerITHjxN99ZX8e9IrK6l6pQQqUiw0oyiCeP/rcaLtEzMGwDb7kug+g6iumVwfgbBYUVAiWQlM+BZ7EVKwCSCtp57zffVqWbEXExLl342c+z4DdXWUC09oEbvIPf5nxm1RYdeJynqDSYxy6ckJFn5vCB/5QEv0Q7genOve5vqkTRUd8wEs/JiQoQAX3K/69iUa/EwJWr62JP23uxBNmlpebPfAAzJd68t9JlkVh739YAiwda7CaKCgG1YUkM3nnTE7xGtPDw0UNR6+/NIh+BG/oH5D3XUrq4L/yGKiEyukDzwEuAsQ6Q89ZGWL0uNRUD364EHrNbghod0QkIwA+GrVMN6RiHvBtR0ZKd2kMOEWx+1rMs0wTK4iVwj+xx9/nGbPnk2LFi2iskjPYVKyZEnhhx/vMGMgSw/eU9s4s/ao52obhmEy599/ZYBqVJS0ImYJJWjCzcjWUxlT4OA2njhRWhwbXJdGd7SH20+AVTBK7QNmyUUdpdhf+zTRygfsO1IW9BpDrNd+rimzA6mgykNzpW+xCpB1QVXghUiCRmzcWFpBJ0yQExPQofFmPwVdmuWqotpAt5o6ccu8Exiiub0k5XzBb5ukJEvhiviN+PW+BS8mZueOEO38XFbOdaFwYTnxUnz+ecZtwsMNUWhL7tNs+xgv7plH/5BpY4+ZPkBeQAafZ4YlU/9bF1OV8gme+6JXL6IBAzBf0FJ+egR/Ni38uGaQttMt6NsEqw5wQUMAM4B3K65RBYLKO3SQ7YNrGG5ImCAgG5WKV7F9ZTpR8+ZEtWoRpZz3cl37W7QtJ4IJXeJuubp2cu0lTRnLMDmdHC34DcMQYn/mzJm0cOFCqggTiwaCdENCQmjBggWe15C2E4G9zUzHWvy/ceNGOqrKb4rS7POE5Z598xkmcyAaEJgKS+bSpURIkgU/YfjR+40SNGGm2IXYPmzdt0ixCBGHDCyVSuyg5x772xK0CGjFQ+0D/u7egiELVCAqY5rfgx1FqxJ3EB1dbJ6UaQTwEUuASqu+CAgw6Il7/yTaPSVz4ZCM8r2GFEu6hd+L1dbjDuImtM7DFdH83NVMyZklwX/Bno3HiW5ZR5VcBLXiM6ic6wUUV7vrLut5bLGzdHrtp5S2bSJNGb+QlvwWL7Lr2Co1l70t444unCQ6bbptIiVqZj73KfEUHpZGv3z8Cz1wp1VTYdIkotady2kWfvO3SXMIfr0YF1YcQKJWNU5xyrFypVzATJA2FmIfQeyw2k+dirFNvoa6ArDeA4Sq9enj+5TatiV6801ZjwIgPemDD0XQqQQXcY/70Nt164q/S2BXAMT1HP6NaO+3RCdXy8xDDJNPCMzpbjzIrjN16lThVgOfezzOmcmQEVDbr18/Gjx4sLD+I4i3b9++QuQ3NevbI40nhH3Pnj1p/fr1NHfuXBo5cqTYN1x3GIZxZ8YMGSCLHOWffJLx/WHDMk4MbD7AOkqs69Vgd3/lMdi/8YZ8KSAgnXa8VYVuDW8sM4OsG0H0x51E/7wuLaUQ1t+5VHhVdN1h+Y6DCj3s78MnWQUgiuM67x6Vi7lDAemrj6qrcHWAaEKWIFTVhQvJsZVfWN4hmRVPOmf6VUSUsSYiOBdvvtkuhaNs5+Vru5yECjRWLkgAQl5/7hT8sPB7m9BpYKUJbizwPz/4zybaOPs7KhiVQoFBQdTj1u3U+FptH0rwhxXNPA/+aS+F0RSmm0uV8qfp47G/C6Gv+HNlFC1cXtpu4Xfm4odPvKKgqcpPbyE65ZjcxG/0uQqgpwhFjYB7tVIXsOqjZI0z/gRBzHi0aEFi9ePvPw+Tse8nmv/TEVFNGNe3mkR98XVBKtKwDy37O9ZrG/hFTrpGk7TAbf2+ZJh8QA66EzPywQcfiKDZNm3aUKlSpTyPadOmebZ566236OabbxYFt1q3bi3cdGZAqZgEBQUJdyD8j4nA/fffT7169aLRSL/BMPmYEydkFVGIVogHVd4C8+nBg4nuuIPokJbV8p57pNuNSkcJMQHLokpTiIlBXJz0mc6AsoDDrxsZXcDOT6nPTYuEDzYsiqDn3fH2CYFK4Qkrafwmov8+tO830rSoxt5A1HF1RnHR8D2iJh8TNTDL6IINjhocPiy6yMGOmH20DXz5kSUIEx1MgIoW1mY3Z/faPwh/dbgcwQdbt85CcCrrvbDwa4I/7m7fIsmZ5z43oAKNdev02X1Ee74mOquJLb0dMstt7wDXT6lip6l40fPSnauAOanEBBGTuS1vSmsuCCuecQfOyUdmLjiO9x/omy7cvFSV3g+m1pTXuSqchmtDnavzXArIWAPBCYf7krPwmpaFaMEvCfT11/Lvv/4iaqOVaXC6IGG4hHsagngh9PGA6McKSf241UTnDxEdnONJSYpJ1LSvUyg6Sh5r536d6fQZ83fMrL6AGwFapHOWVgYuMW6Ta5daDAyTV8nxLj1uD+TmV4SHh4uc+idPnhQFuSD2nb755cuXpzlz5tDZs2fp2LFjNH78eAq+mOo8jN/AH3vsWJkHG4GO8IdW2TNyCsj2CsGZ5SqauQy0u26Bf+kludyv0g7CZWfrVqKePTGRtn92SL/19PUXpykmhqhJE5mPHDgt+vCcQ8XSDEZz3Tqp8skj6LWUNXmHkP58ommJdWPdUKK/zXyZAFl/ao+URb1uXEBUtGHGz4QWIqr8AFEps3yqwHFwx/Vk7n6ii1WnXzNEDfzVwZl/pdDw5M2P0SrQaoIfwhjHqgh3sao6ffaR/z6no9pFFRXTOb7Mmmz5CJb1J4jXs58iDa3vhECGT/5aLZajkHXtZUiJqgS2r2MR2yfaTzH5iCjSNnOmfD5rfgU6eKSAvY6CqkWgF1zD++pacNu3WiFQv7k5Wfhtbjq1uylG/F3/2jSRmccX8NtfskRm7skAxL5qK00Q333rSVo85Sfx9+nEUJq9yIyjUSDFrTfgfqevoukyIysThUsNJppOWPAz+YgcLfiZ3AUsvshs8vLLUjzDpxRzLwhAVLpEhgsMPkipiLSHyLWOJeSrBap01qtHhKyu8HeF28Ztt8kJgJtYhv86lr0hTDPk3/aFLviuAhDf48ZJ67Rukf/f/+zbwRcY7ivff2+9tuinPZT+70QaP3ylTYw895zcziyJIejQSlbEQiItZAHx6sMfVoS2JMpq2AXCkqhsmTRRaAvXjc2VA6L3mqeIol0q7RauT1RLJUc33ANBbd9/gahiT+v5XwOJVj0ks/0kZqMCqNMNRFWVBc5qpGf3a0G2BSyRgTbx5G0Ptqz8yGQUWSZzwY/89zkdFWjsJhDxW6tCTkpkF22ccTt/gl6V4EfbeoKbU+y/U7k73d2iVEBvWDH7sXj9LsfxmO5C6NdaNjpBqamB9L+Pitvd13B86Ad0v/y4O+X/xVtZr+2Zal0TRprlBiZieFNEvzN0qJXidMI4Lag3q4hZueZff0GLLUhJoPq1TtCgPjK24ffVpewTUbdVMUx08Tsf+JFo/yxrG3Ue/tZkcP72e6YRnTBXaC4G2ySEYfIfLPiZi+btt6WA7NyZ6IsvpBiEeO7Rw10Yw0UCAvTdd4lKlJABoJs2ybSHWmy1LaAT+/ekvrtEIP2jM/B01ixp6cZ5YDyEXzpcBpB/G8viONfXX5dCF8fsF4d+lS4MSS4WpqyCQfXAHMtVRAev7fg0Q9VWrKpgguX2WxQqZFBKsiFWODAZAGhruK/g/Ns0P2H5qWuWVrx2++1EJ46nk/HfRPGY+8nP9H99ZYOqyZzH0q8G/5ha1KrHnfTu9LbiaUToOdq48oBIKygW3WARB9E1iOqOlkGWtZ6xH3TsjUSV+1kCTblD7P5GigO3nO+w4hbTKmSpINIdk7IXVOgsDoXnSDkJnP7nCBJUFm6Rnz3M+k6VKlRZg2Hlj6rk/XtLXE8UHE1U3EwhlNPJLKMLfhdMJJW7ClxuQgplQ/Cby3PIs68Lfv2zLb728tlku0U9M8Gv3JN01yyTx3vJ6/f1twvRmrXBREWbWMenuzVBOKtCZRGlHPs3b1S1+hMUTsnJgVS3fRvR76zfECKK0Z1Y/Tk1uy7zWAevnDtgX+3S28p0Ubups7yXJk+vIX35C1bNuK0C6XEPz9f2fzCju5Y/Rch00GfiGkE2rYRMYisywxH0fCkLnmUVZFeCW+D+i5ivMUxWYcHPZBtYvSGCYfX2BgLJIJoh/FBB1Q2keIR1DGkPkf8c4jTR1EFIG/fww/JvpL67/36XwFCkWXMGxmUC8kwjn7YCKxDKBxdZW7FSgef430tMpzjm+vVlZhkcL44rw7Z4QQ18+nL+xQxaSNUHYawPYChWhNeMFEo9uU0cD74aA4vygINbFXz1GzdKExlmRjyxm46vmEzBZ9aK4lEoMjV+vFz+93jN6cF5buknE+zVql8cuEZk+tizR07mxG+HYxPigmjt5sL0x6oidC5ZBq62abibCkVpbgwq+BWuGQDiLdJKxStSbZbvbok6HYhqiAPlTqMDqzt8id0EKAR6Vn2LVXGoQvWs1xBvgMmYLnqcwG0EsyW1IqBWfvxNdRgaQ1ThHqKYGpQrcPudnEDg6jEeF2vhV5MnXJsr+lgrJ94q6ypBqgS/5iufcdt0a0KnVmFgtTcnF7fduJmKFZbXRsOGRLfeX5nueKw9ff51EUq7cMY+cVM4z9lpGQ+KoM9mVKPN/0o3HnB3551UpBCCn12WI1Ulssw46Ijo1TMpmatU7ToVpDYtz1BaWiC16H4rdbi9Ip1JDHGfFDlX2fC7CpFuZF/w6+5cx37P2mdt+0m24oFsr1+4oqk5EUiNVVSMLch8hixSGO/8+bkY5mJhwc9kG3RUcHNRfPCBFPUPPig7MqSGgxVdJUNCUCc6tjNnpEBGBhRP2jwNWP9R6wy6CMVgdLA/WKLLlyeaM4co/mgCnf5vkcyhffCXjL7VMDydlIGmEPmYfMD/HJ+HVRvfgU64VSs5uYDFBcIYIPhUL2aD93H8ylcXrFtH9Mor8nhxXAh6g3hG3IJAH5AzsxxmdQB0BkIS0Xtf1qKQsteL48HKBAYWuFfBdQkuV/jNVv68itL/nUSvDPyNgoIMopOoQEtUty7RkCGyLVxFvpvwUtlPTJAlBftQIK/+7BknRbsdPRFOfR6WPkBK8BeLOSOX/xffQjSzrAjkFSh3CAhhuO8ACHanb3vxlhmDWSH0zsjCSFZbmb+DXu1X8d9HctCH+Pajqqkth76z0q2eNx3++jo4FyU6lchT7kROX+68gj6RidQCVHVwjyghiImQ7gKSHQu/ChIV6UtNklzEntPK648PP1xLPK42pey+6Wd2UGhoOv042Sqk9uOcKJrxW0Xq83/1qGTlcrR8bQnZDnq8RgbBb95z5vds2BJNT46xx2v07GauhKkVMXWvwkVtx8dyVTEznBMgW7VjeQyBoQVoxpf7KDhYTojnLYyg97+q6R5k7Zw0Q/AjTkPHV+0JcjHkmH2T9R2ZKGPcu27bJGy0Z0YKN+P8UuKJdn1uVuG+9OzeLd1YEVTdqJGsHYE4Ked4p2dYYpjLBQt+JuucP0YjH9vgSaUIEQlrP6y5EPVIU7d3r0wN51bUEun0kPIQGVCwHTpFiGa49Lz/vvtX/vmnDCZV4HNduhAVjo2hmOv6UkDVAdSwY0Pas3oxffaZtL5jewh4uOigLAPEOI4P6ehU9hkkdFL5qkGZMkSLF8uc1Cquu8l18XT2TLJnBQAuSHAz0j+nxwXs2CHjFhAUa6CAkB64d1SbISnL075ZRDs/k/nAvYAsMWIc08UPXEWUO0LySSH2nxjdIsNn8RsgnkK57GRp0M2sAqpTHAUECZeuv/8m6t5dvnRL9zIUWG0AxTbtRRs2yC7npbGRlmBZ/yzRwdmeVQBBVFVLDMGq3WwKUc3h8m+Vu1z5tCs3A50jC+xCRLng1Bohs7iU6kx0zVBr0Mf3w+0KqwNHFsqJDCYAcDdxBGnKtjjvfQKhKNrIR3GpJLvfdG4uZuSvhR8WcZW1R+cCVufSrd+7YJWsCX6R1z5dCn0I/nAzE89Z7XqC65TbRE5Yw5WFPzJzNw/diq1fd0ipaVrFm11fSPQPTo6fCKbBrzQTkzv0E7YVT+X6A9T1Zh7vh58WpXPng6n5dUeEseT0f4vphqaHMt6DcKkRMQLp0gCQmb+8cinyVENWKwuGtmISIepj7FxouUN9OqM6pSSnuS1n2p/CIOGcGGiTCiQMQAE7ZAzCmKGyhCmSdi6kOx9vR32GXk+JSWZnfMylKrUC/SfE++6pGQwRHuMIamDEtrGvsLjVPLgIYARCATT0uygdBJdKrJoim9J8c/EP4xwynqkUqMikhHZgmMsJC/78BgaRLCyrQjDD9QUCW3ByLa377Xca835d8fSxx6SbiLdq9Rlwsb7A2j5ihFwCf+QRotOnpUCFwIZIx8oBqj/Crx7+/97KJ6zZVJwqtLlP5EiHf/2UKXIFQVVFVRQvLrPSwOoP8S6WnR2Fb+CmhHNe+8P3tGLatxRxwe6Og6qaWBnA6ezbJy3ZOD7dUvP880TtbylBaWla4yDftpaaL/ngcjLOH6Wt/0XQ4h+3iaxGIpPgFplVY+H8VGrb4qiYJNWta9B/21Jdc4av/iuQBr5kWQFbNrVGzx9/JKqpFxjNyhK2zaUnyQ/BHyKuBbg6IQ7AbVKEwa5qdUdRLJ1G71vBlcr6CWuqqrhbsoO1LQSeR7g4UMJJCDFDunrUGEzU6S+i5lOIKvU2zyHZLo6Qqxv5+jEBQIGevdNk5Ve388b3eyMyjqjcHZZPfrT2IzjdRvKq4NfjLJBCFdmSIsoSlbnFikNQmVvUCghWdBDIqt6HKwZSnOLh5setAnMxEQzEKlAJoqJN7Xnt4+7KGGgNdEGamYVfX+0KRXrVEMulC6sJqnhXcJToH3AfH9p3VgS9z/9cpr1csS6W3ppUgUJCrDoPgsL1rOB0FRRspNHWHTH0wWQ5qRzafx1FFUingmEOX/S938tJ7RlHJd7MEgWofkhdnyqeRLj2qAlYhHB1KlcqiY6v+pyKFTNo285CVKDeA3Rwv/Ped6wY6LEsanUn7YJYFW7fXqYERl+MFUW0F4w0/ftLN8SEk8nU7O5b6fu5lejzmdWpSrt76MSpMHNyKPtmxFJt3OgQ7VgVQfs53epU31XkOu/322lttSSbYPUXfZ9WC1RQoYL1951d4+mRfqdExjMtw7gYkxjmcsK5KfMosLhDPM6eLYMn4ZONLCjz55yhOlWPUkpYRQoODRXp5LyldYMrCNxb0AGPHEl0922n6brKyfTyB7eI9yMjUmjcOD98dNVgiYqkoPRNdr9sB3BHgXAW4hkd9fGVRElVhOCD/yPccnB+OLcKEUvp4L4z9PL719Gfa+zpWHVgWYFAh/hHgChiBTyiUPmGVnrAtsxdqhRRqZon3DOvaJQtKwcqgFUFTFbg0gMr/4KlhSm4hnxz+jvz6M7Ouyj9/AkaMRr1JODrDkuT3dqECY2KU3jvPRyPrE67aVMA9X28LC2dIidY584H0W8/BlGDtkQ9Hq1JhhFArRoeoiVTf6IACIhiTaSQRQn5lIaWMM5K0ZzMfPiVcIW4RaCfJqCwmrJwIVGHGxKoaMxZ+vILg8pfY1rnjzqEMoRTqQ7yGKs8JINv9cBI3eqKYk4Fq8sVBwhKbwJNCJcoK74D26LhwopYln2xnS+fbfN8DvxAVKwFUaFa9te9+YUXvk6+h7z7JdrIVQVUAVYg8FZPVZlX0wNGlJTWa7VSg0dkaftvqoSmuj7RbjHXuFfkhYVdj1+AaD3+p/3zO78g+usxa7+4njBhhNVXz34EQewRhgFa9iQv1wOq8CpKd7Z/p5dJTsmykUS7Iqlt8/10e8c9NGNueRr8nHUd3HCDtG4LS294CTrw7x4qmJZK0bFyBeD6HrKvDQlJo9aNDsljc/ZFuI5Ob/PuCgUjD1bScI/qWYo8mbOKSdcytV91z8O9ChMoTNRK3EBFyxWlt98OEHFUKSlBVCYuSIwRYuUQEw7t3kff9PmMahQYaFCluCRq2OE6Orwjntr17kgHXOZdyoVy8mT5IIIgt4qkHTkeSSWa9qRHemynucule6Ve/A+rsWOGl6eneu4UrowZYhtUWwSZcRr4rREcrvoAgCrc0S4WCj9B5WMkMlB0abOHurbdQw8+01ocE+LEdq3bQr06LyWCAa1CDwoILiCMU5j8YBV77CsGjXj6jHVdwdCA3we/A8NcJCz48xDofJH5RnWCsCLBbx089hhqGMDSXJhWrbN8npEp4PBhTQBrwNcdYl/x7cxo+paspefv3p1PERHmwJcZhzWTB4q8wOLmTyGho39ICx8CXyve73kZHWjXrjD1HKG6FU9Sp9b7hY/4+Mn1qE71k9SzVzD97+tWNOG9VHp7XBK1bRsjysdnQLcCHvyZqHQXS8Rl5ssNQQILmKomqgE3p107U2nSZOsWu2tge+rffQtNmubIyuHAGZSMIMAubfbS1z9XpT9XxVDvoW3ojeErqETTXtpWUVS8yDn69N1dcrVFud/snW5tUvJGu3CHyFYuClj1cYpOZLvRhbYvlx64YSjBD9OmueRTpnQ6bZ6DY0gnKm8W3AL6wFr2VjkJ9FgCA+xBmMp6i/0r/+zY6zO3jmOyg+3VcTvFmbLO4xy0Y/YKhGVUBRncqa4NWDVhtYblWQUFwkdYrwmA66mg6Q+mQOpNveKqMzNNXgKTTzf0VKZubYDJAcSOni7SKWr1dJ8qvgNuHUrsg+jq8n+4a+G6KtaYKOEfmaPfcywh2nUE8QoXIccC+ImV1t/K/Qf7RsyIx5odQBSurWqoazdxO40ftoyWri5Bx05ak12kAIaPNwwEE96rTPsPyGOdP8+gxO2l6egJ+T0fjv6TCscgjetZyyUPWadUDQln0S6ANsB1vetLOTFHek/cA1hJwDHqgh9A8COGxRNXYh4n2iFaui8h89qev9fQs29KKxHcffbtTqZiEVYF2w2ne1Lj5qF04YJTpJo+fkjWFSMzoiEdL9wtkQ4ZhcDgjqnT67Z/6bEem6nVfd1EpqIJX7oLcrhIDXu5KsUfT6RBvTdRbLFzcjKIvhltoKfFFecUIMcg/M47P7Z2BDcwbylxdcQEJ83jsobf8T6te/t36e9UtaS5GpWGGKRIat06iFqXXmqPUShUi2rVImrZUrr0PPNsAPVp8wOVqtVAXo9wL8QKDPqLSw36MNw/MIy41ae4lKjfgrmqsODPA5yOT6URw1Np0ifhHoEP8Dd80hEgm5AgxUybJgeFMEQgGTIvKCsT/OexxKyAu4sq3f7OG6cpKvlv2rCtKP2+uiQlnQuh+27eTp1aZyHNpNMqdWw5UZmb/PicaanBQId9OEWb5p5Uouh5en2YOShfKEaDHjtHg7pgVcEg2m4WKnLmLlfL8ABL/hg4i5uuMbpowCB44BxRmS7yOVJfIt80rLawTDtAGs+J/ztMdzTfQE+/3pw2bpViZtI0K6d8RIRBLw1aQQePFqAbmx6g6xsfoel/96GE4wl05mwENWkWSqmHl1PrelsoqkAqXVP9Ag1/tS59OauaeOjEFLxA374znypXjyM6Ybrt6BZSJcyFf645+MXUkpZBCAhMAiCuseKBQDtMBtTgqICYx371AFOPa0ukfTvlqy1+P4inELt1EW4XbX4l2vedfbCBaBapMsku+HGsEB6qsq43P3G4gyCFH8BgCa9FpPh0bif2rYQX/LjTiMJiiUq0khNSb37cuEaEpT7d2ieqpeIBlxPxmh8DGwQXXHzU9Qdxm99wtpObtTymtrS8KnBPwvVCTRh1n/ooc1KV4MiXq1/H8euICpSzi301cdNXaw78JIWxPjHFNQzhrK/U4Jos241o5yfyecn2Gc/BFPwVy52hPUu+pmmrelGlKsEiixVWLAFcGvXhuF179NeyWNyggen0wN275SWn4hJgqcZ9c2a7dHNRGXbgLoUVFPRjCVusewEgRgYPuBViNVNdw1iFUvetnuFKve7gmcf/IcNIp5FvNRKrrfffk0AFw4MpPb09paSF0k8LfLi5Icah/mGau6SkWMnVKwTDBXDYoztoxcJ9FFMwWSQUgIUcwnzh/HRq2dqaQIwZfY76DYgQ8V8wWiGZA2IAxn5Yn97+rA6t/+k7qloeRoxQc4xIt0/UxG+HgiRBRFFVrEkO2i3yNs391Mgw8YNBJmnn75Rw5Cj9tLYrfTgpXLhgAqRNxVhaKQIbmR+AayCo3F9eZ2olBL+FuWL4yy+YBBmUnh5Are/rSt+8vYAa1D6eeZGz7IKYBrgrKjBxrDLgkn/Nn4vP0LPPpFLrhvvokaerUqlyvq8N5vLCgj+Xczo+hdrfkESr1tmtY+gA4+JkZgC49Pw5dw9dV345Va1gCe9l+7tTyxtjRGcFH3H4VhctKgcfZdlH5pYnev9LdMqLfyOCTSv2lp0nLAYiBWWADK4q0dJy3YEw0o1z/hZg0V1K4GfvtBY64xEgCBGwhgAuITa1mAEIWawqKAuOs8w90P18dcGvOmjxGeTC/9Hy9/ZG6lnq2Go/deywjFKirqXxL+2nCVNqUtL5MPp2egi1b3mE6MBGOXibIrzvrWuITq6Ry++lO8mIZpivsHz94BoKCAikYWOtScujPTZT/x6HqGShQ1Qy1iAKrWu1iz7Yq0FLF08Y/CDeIfghGPD7ofCPOi8IGbFdlBT22AYTL1fBr60OYD9KXKvf2W01p3RHmY1HPyYbAdZ3YUnbW6EpXTjCdQM+4Z4MLSgvbLr0OANGbcecIq9VTEQq9SHajkmH4T5QRqS6+y2jaBQs/YXM3yAzdPHhnFzlB5yZifTMNW6FxpyuFxBkyk8dQht9EIoriQJLAUTXviaDNNFn6EGZbtVe0c/gHsG1hMke+gE8lOAXFv8AeUnAXUsHEwXElcDKj4mfEy2bT0RMIerzgHXNwKiCFVnEKrVueYGigw8KY4wiOiqZRjwTSnQOqTDPW1lv1D7FCoiWklifoPgKzvf0m9o95sQZPK0ICKJnH11LBcvUoEFPFaS5ixEkXdzeJIEGjRu2gto2O0C7z3eg0a9GU1zZZPrixa+oYHQQUUF9ddKiRoUjVOOOf+2T8tDC1KIV0flNk+nU6TAqWRyGl1uEz2Bs8RRqUnYeTRieQh3ua0iLVpQRAc4vvNOAvmpxTk4i9ZUZ56oNQAAvxgq0o1pBBHD3wrUSdycdOBIpCjQiABcxYkTaTMUEtRHmz9hFlUI2EaV4qQWix4wgcxT6ncAQMf4u+XYR3T6gGW3fE0M3PdiJtvw6XaZeBW4rTjCAoT9SsU1ZwS1FNFINB2dfkCOeApM2uNpWqiSz9BHJ+JMlywvTNfUO0L39/Fg9YS4bLPhzKRjr3nrtFA0ZASElB8o3n1lOvbr9S0Vr3mDrBOBj3r3bMaJTdit784Ynac6cGFEwC8Cf38l772nWeVhZ0fHAQqTA4IgMKOhYYVHVBTAspcpqoNwq0LkeXWJZXHyBzkzPDY2lc4gp5XohXFOwnwA5OCEVY7GmRPsOS0ucEuU66GSV4Ff+myJYMFQKfH3wVLnWdXAezhR/zuVK+IzrriTBkRQSU5pGjE6nEQ9PJSOkMAWUv4voTJKV2lGUtk+WYh/AfSV+o73Ak5FCQx9YRre22Uw//92JujVbRJXKaJXKytxpWaaREQgPhXpdWYvg/oABRFj1kRbxglUvwHP+Z+3FjJKRujLRLt49vuwhlvUKYhviWXzGh+AXxyHjE1zRVw18oQsWVPJ1TgLVMTgt/J4CWLDwp9jTaCLYFr8zxCLcAfbNkNci2kitGOCzum9t4Wvlw1/0CYe/55qXUPEZviz8bpVxbZNNsx/BBBkcX2Fl0Kn5tLUt7seTZrVWZ6pHgWEdg82FyBRaqA+BewjH7HYtw9WLNMu/N9ckuHs5XP8gIOEaE5yWSKm75tParWVp8uwb6JtpgfTRmJUUG9uKaK/j2tUNKTrIGuWP64TnnvAi9nGeWC1ww5zkDnw0kVatLSiMSzoIPh37YjzRvq3i/qlXJJpuRYxCSjLRHvRzDjGM57iP0NbO1RmNsLB0KfZ1QxBWKM/tF0Jm3mdzaMT4xjRucj2a+lNVKjUsgf5YhfoibahwTFP6a8ZMquQ2h8F3I73v/plkJJ8mI+kwBR75zTNh+uSD4zTg/+JEnECGGjAm7Zrvp2n/WyAFurecCGqiietHFZtD34KJrpFOLettp61z91HLe7rSlh2FqWTz+2nkI2vp8Z6bqciOyTIQHSuRyEKF318Ea6dkGhPnijPAGmAcyETwI8U1YgNhGARIjIEHskchAN20TYmU1zrNGp2lbvex2L/asODPgSD4B0WQsOR78CDRd9/J/L3IKKNqqiA7zsSJcuBBEaW3nllOg/ps8h5gqlu4VLBS6lnq1Ilo9dLj1LN3EG3daQ1kCGx96imZU572HLfEFAIedcHv+b4Ad2s3OvH9P2r+osWtDhuCys0iplCDN8SQKGyTKK13EbF2KwUGudgbZFCl8Nn0EYSpZ65Q+8dgjKwgyMYC1HG5uXVABDsDwpApp3Bd633UBNCzsigxZwrKAGHpcfiV4nPO71P+uTg/TfhXr5RA1VtDfFYkOnHUbg11VoBVKAu+8oFWmW7UgA+R7rSmqokNjg8DBESCcGkx3Wr0QD3hA41VnFSiw/PMgL8Qa5XEm+B35qr3luHFFxBk5e+Rf+P3d7ajfoy2z5mBmrgWNzwvLfQbphJVGyhdblRwLyZkiDPAEjhcuTxBjX4GrHsDvrnw48X+vQX/5mWcgYhuvzeuSayA4TfEPa7yy6sVJ487TpD9nnamXSxSX6786bn53cC9pgt+CK2ytxMlmnUd4IKRnQBKxAbBmOAizJCpRmCEUHCwQY3qHKJGHU7SR8NnW3ENTvcnlVkng1tUQfvKEUCAOyb/+qqqWslUn9fdy0DZrt7PU1nBjTSRTvnQzgNUJe40DRuwjraf7UztuxQiCihMVFmYwi30GAllJEEfc2iedKVzSxqoW9yLNLImbcoYo+X5hwvQq68G0Fezz9PBw+H0xrtW33IqIZwqt71XBM7a6oyoI2ya+jIAADHKSURBVAoqSANfbEETpkgXm+5dWtD2PdEi85siLc2y5E9/Zz5VKneaypVKFN1IRLiLRd+JanME7IvVKTkGC8EvVqVITBgmjfmdWt93iwiMHvVOQ/EY2GsjjRm8Wrh2en5/Nc4JI5Z2XaFfRj8FlyxvqzeqZoJyUyNY5A36e4ssbgkBf+AA0ba/99CcX4Jo+/4SlJoeKgKrfYFMe4HpSRQdformLytLfW7fRh+PXSLSMjNXn3w4yuR8fvtNWn50FpkFSENCDEpJkRbuwMB0uu+WHTR++AoZpKRw5iDWJwCwBsDKi84GQYgFK1PDyn/Tlrm7acv2QpSSGkh1b77T6hSOrbAs4Zj9oxOB9RPCEdlf4HON/8+7LJMDdDy6pVm34sHtxyn44ZOKlQIEb5qdoPBVxTnBzxKTCiX4PWkiTeucsmxhGV9PCad8gWE9Sjbb5ux+a/DH9sIKV0IeK7JxwDVICQpY5fD9+CxeU5MGTF4wiGNfSvDrLkGeDj7SEi+qgxXVRdUKQAGiMOSKP+1dFEPU6hMNkRKwjn25WohdLyIUA6xqLxyDsuTANQCrCbBchzuCifG6+n6cg8jkoWW10IOasU/daiQmGBccFlAXMFrGtvVY6mxkxa9dv66wgqNnVFG4CfQiDaQ/N0T8fFMkHv1drkwl7ZX3CibLECux7YkKlLH8v50W6qyCyYY/cSx5GQhNZJCJu9Pd3QKvxd2hVdE17x8IJbWSo0QhVvj+fc+7OwqsuIgZ0RF9xSnLDctZSA0cNTtfEJPN4EYIr8yssMowgMkN6kKIv9Nc6hnEWRNEm+DHip15X8NHH5MUTKLQZ6MooS741Uqf6jOxMqoEP/pBN/cqz9eY352aRHGhC2nBF6b/e3RNqlTC1+e0c0AygYo9pNjHBECs+rqgAq7VpA19GI4T96uLYSswuhIt+G4zNexQl5LOhohkFKicrkAWnTVrpLurskSjLsvUqbiXzQxcyIv/sz3I/v8eT6Tb746kTUtW0c3X76CypfwoBgcQ74F+G22viqSJFd1UU/Cb+1GGkfBS1KL7LfRbkVQa+WwyrVgt+5h3vqgjYugWfDFbZiHS/frFync9azUMk161UoKxC5NfZ0ICc0w2ireiOT+eodHjytCqDXK1FdnlLHwY5BxgpefeO09TwN5v3CenzFWHBX8OBPnnYXlH9hxYFbZvN+jcOXnDKrEPZr3/G93SViXIdxFqCr1jRKYGvUIrhJEp3K6pYr6OwRQC78hiK5hJFzgqmEuJLG9iH6iBy+bv2k76R6KTg3hWgyxEn+r49TLoMTWl/z6OBasLsMSiA1OdJZ47Cx4dEg6EljUbIhAdo/jORLsVT1VyhT85OkJ0phATyuIIoQFRDsEPca8KRIntj9mFuJ71R00u9MwQcKU5Z042PC4zkfK7kryYT2AdR4adXV9o7RgqxZBqS0xoxHc4bmm0DQLRIL6V9V93k0CgIyYNmNColHUKZclGakXh+qJVrIW48lxn8H0O8m7xxnXjLVc+QAYbPOA2o/8u2XVzgbATKxLx9mvT7fjaLiL6qap9dQrXoJsAwbVa/QnNOnqRFn5Gxvkg24wvq7nN9SmCKDVFTpZhMMCkDIGsK/rYP+O2cuhcwYrrLl+DqFbC162QmhLKuFcuZ6YR9I1aPI9A3bP6taZbbfXYD0x8lLDDvnSx7FwJ0N0Z1fb6fnyh3nfeI/gtfX5OE504R6xuuYG+DK5xEMiqNoFCGU/w++sTGFGML1C0R43akbThp+8oOCqW4hrfKNK0JiWmUtP7etGmzcEiSQVW0FEcC6vpOmViE+m2DrvpZHwYzfuzLNWsckpk/cFrSK3bspTZR6t+1xcwWiGhwwGMgdqxoi9UxhD1W6uxwPw927YPFo9N8xdQnfYyvdzilaUpun5fWvLVT1ZAr6kJ1s/5ndYfv0mkQT6xrxydSapE8adD6c1nVlDH+05Zq5XiO5NFYcQpPzSlid9WpqQk39nJHu+5iWJLGDRtbh2RGQ8pqFGcEj8nMhNhAgJXp0j8NAkOow1wjivMVYMFfw4EVgg9ny+dWk+rF+2i/YcLiMfK9SXosfs3U7P6R907Hwi1g7/KoE9Y39UyKHwycZeiE1VLoRAxzuAuCG9YU3SxD5xWH19WIF9gxq+s6chgEHe3tCK7iSwMyBjslGCEuwYsGMWbZegkbYM9RKY6LwhW7EMFuOF71SQIFl5l7daLKMHirQSn8vEXbbPFbmmDmMagrNxl9BgAN+EaoQT/EburCSySIquMOaBC5CvxC8ugED2BWraJAlZbImhaiQCn4IcFU7WbKkSlCx/hrgP/2TRrxUO4BiU6/OJN8S/qIqywB30pseDmFwqUu01m6P7EaDNMqLID2hMuAkgxaBP8LmINxw7BqQt+bIfVG4gLXJewfsJyDKvZxpdktV58Tk3omIsjKy4y+E2wEobCaJtedi+mhXSLKs2rjlOse1aQguwrUZgA4x5A36BXbPZVZO1SIVzMNMEfXjLjRETvT/SJtK/Ab291HvR7ThkH9ImCG97u86yCSuFu4PvxO7vFw6jfAC49yq1HJThQhBWjSnFniAJNl5f0ZCoQmU7ffJVM1zUOFgkpPG5UCNcpJ9NSj378D+rc4h+tIm9Ron2awUoZZDC2+ONuWNLMA60b2MTnQy0RjPbGvlR/63DHql0vgoz/JtLzbzeglyY0EKsWDW+7naIKJFNqahAVLXSODhxxxrlYmcw6PXATFR6STk2byroyxYoR/fhDIG3dpgsMosZ1j9JD92yhvk/Woq27i4mU3lWKrifj+EpznhZII8eZmdJI1vXREWJftNE+y7CoDGP50V0xh8K/RG4g7QI1qntMPMATtNn+PkQf3DF0cQPrKzpEJfaBmuVjgEWKSoh+PUgKnSmEHVLdOYszlb45442r8l57jqOKFJbOFQaF7leL1Jf7Z8m/4SKh5+CGyFJWcyVY9aX2hI1S8KuB0emzqgYNnAfEqhrssA8IcuGHf9ryp/RmAVQCGANsoGMJF4MM2lNl9VCBr27ox6faDAVV1GCtBtBC18q0gSIdYHUpasTnC2gD8gp7xVZxfNqg7fyNPD7yhuXmpIsH9ObYBu8pqxOOEblc5Q5NVwrTCoRJlDPDg3I7cMtjX+F+/62imOSoQaLCfe4uHlnB6b/qTaioawzUGU1U57mM2yDrEzIYYbKGySCC4rGSwFxZYGRA8OPaYe51IW47ZK5IeUEVPPPmZoB7DRMGXCvOWB23fuZS44w/QdyCmvSrFKR6PAxWWxFEjpU3XfQ6wSomVknh4gGXGPU9+iQYAht9jze/7ytRFRpjhJd0oDbBj/FJGXSckxlliBLphs95jCS16oSKzDG9esnq6ApMABCQS4cQV6Z9D/p3ZH9CTJIO+m237FE6yCKk+mKn6yX6Dr0NkdzCc36Oawy/bcImGjZgvajJ8MeaWNr8XxFKTJKfd4r9ggXTqV71I1SzcjxNNFNAnzoVKNJ+Wsjjat3kON1yZzG6755UKn3eHItTy9I116BGQxrRTiX2RWOaQb1RZrIC3X0ThitDGlrUmImxSsWy+UrMwFxRWPDndOB7reea9iZW4PJx9qAcsJQbjdPVRrmuALcOq0hDomNL3bMluAVdOt00YtvImx/fG7/Z8slGpyWqbWoDCToBZB2AgIWAUhli0NHCH1FVvxVLteZAjP0gQFZZmpXQdFsyxOCFc0S2DqdLEgYLZXXRzwH+7HoxG93qkhJq75TV4BpaVJ4v4g2cAkHf3tNm5mCEyYoSEMrCCVckWBjxm+rp29Qgh7SUyNDgnGjpOEWyWCExJyXqN3VmPsGKiB7zIAT/Dm0FICDjCoOOpxhSgN0yiU4/KyJJuF2Zx3ixYt/N4ulNqChLIs6x+uPu2zT/kuiQ6QeNtJAFKsnfHG5ImOhW8HMVg7k4IOAgJJTYr/wgUa1nif6bQFRzuG+xqPpJBDn6KjSkjAt6DMqVyqSkfycmy+r+wf0kqkqnZnRXKtE68/1iP6pwIT6PytFu90RmYh8gvklf/YWhQgXyXwzoqzNbXfAI/vPWiqVT8Av3J7Ov8iQxgNthsMj7v2ePrLyOfPmPPGKKfTVRUILfs4JaUcbzqBobajtn/1TiBivWA2OClopVZLdDn47+TX0OvwHGVGd6amd/iUlHTG0qEBNAH359jbD2fzGzKs2aX4GWra8ogryfGbibujZfRuVqVJCWdaychJWgV16Ipz6Plqb4szEUEBJFS/+QJzro4RN09w1/UNMWERRYBskbgomOVJMuVFjRUkYgT5ubbmaYMKJgHdoXq/LYDoYz9IGYICONs7p+cW5Y2cUqta/EHMwVhQV/Tkf360amB9xgEOUie0WEXHb2CGJT3KpCInp12wo9HL6fzsErUAYYCcHvqDALAeiWrkuf5eMGF2keQ+UNDss6goJhjUYhGDfQEeqFXpR7kl7aXncbgkVVCX4EoXkErYtLAM7VLGpinbN5DrAQQjDAlUX3bUQHBiEANwE9KAqTAlschHY+ODcxwdlgCX6RfUX7vH58asCCSFYuScryLHz8lTUkWLaPftxoX30g8Qd8NyYZeuC0009Zt3DjWPTnumgW7hSO2gQ6WDXCgIFJU3ZyQ+O6EQW/MrGe+YszqNabz33lfkQx18iB2ls2IbQ9hNX+H6TvOB46iDNRgdvM5eHIEqLFmhUb94KaJNcf598+cH/5a3F0uvBcCZceGEFg7EBfp/fRuI/L2d0wso1+jWdWXdoNjDN6IDMqF/uLMvK4vY57KDNUX4hVGhVk7NZfCCPHec3VNd12yu3by4cNXeTqfSDAyody51SZ5hDTAcMI3KJ0UesUuBgnnRMiHETZ24h2T7Gv6ri5ZalCkPhYZGnqfft/1LtXOlFJuDwGEJ1OITqaJGPUlItWcAEqWqoQ/TTRjGVDsHv5eygpyaACx8yV47B67ueONsMERrxeSLqbIpUtEmpg3IR9BysW6Kv3qADdZKuGC8YXnHNgtO/YLeaKw4I/p6Ms0bDuiPzxZWSHAyHszTfO0wEa3jsS53NYf0Rn4bDi6v7hvtBFuth/ROblwEWgp5ZGEQVtMIir7DxAt9jpVhVlkdarXmaG6sTVsiM6OTcRCIsVrBloPwy8aGtd8OuCAVYp5M7XrfuY5OC70Eki3ae3c1bWJ2+uJsVb0CUBkxpd8DsFj80POMoh8qPsFk4l+GNvlNck8pMXMQsRIZVl+e4Xd6zFmtAlw2nt9SbYMPj609Y1npKuWAh0x7lD4MMdDRPIjS8QtZgq7wPhApaN1I2MdxDgufBG6zmuP6xIXk6c1u8rURwNFm5Mli+n+5DuYudtgnu5wD2jJsaHF1orBTBu+HPPuK2yuPWfqqCgLwOFE+EKplngdRAThN8FrlMwDgD07TgeFDtDmyLTEyza/kxcAMZvWMoh+n2dn+042kgjoO7WqU9OVPptXKs4BxjwADJbHfyZCuixB6oejTh3h1FOTW6weqKMbnqGNhi4PFnyHLBFP8fCgj+no4QkcikrIKx8kSGItYL7Nshbjw4RLg1K1OtWXHQCmYl95QKD/7MDvhuBSxCWqiPFhAarFOhonOfi9KnMbAlfB8udqtAS8GZJRvtW6W9/Te8o9b8hlvXMGhAJsPrjgQHAbVIm6gokW8eRWVaMi0VkvNghO31MqpypB/XnKiORAtlz3ASzSGVaiKicWYY+JwIhX7GPzN0u/GYvsrtDFpKOy+1VLxd1loIfbibTtPZp8I7M6MNcGtaPsHKH37xNXn/wfS56GUW/0/p9JcQxvvNKxAqoysCOQmB+o6zb+riUVXRji78TZLd72C0eA32VboSBEScz0JdjFQXXmVtKYAhZfTiCyEcsmQLB/VkFv7VeXyCz3x7umE53NCHItXFN7KeA3JdKjgHweytDGSZJeppYJJPQt1WpvWEE1OPrdJTbp6pur8hqETDmisGCP7dY+LOSk1wfmLC8BlcLN5wuL0rwKcGvXE58gc4Hg4Y/qwBuuFUnxaAHX1s31HKqAp2Nv6CDFgHBZpuq3NtZ6ZjRNk4fepH3/d+Mg483gSkGI81acqmzGCjfUDWhwUDmLIJjOx7d9QXBV8EyNz5cu3RrjS6AfBXMykngN0cRoUuJvtJUqqNVDEpnzUApihDX4tnedHnLTyCWB1ZPuENlx31EZRJTrgMNJ0iLKqjUi64YEEjZPf6ciK/KwP4G18KA4lbvwF/Q7yN2S7ku+gtWdlS1ZByH2z0Fo4xeZM3fCti6i+eVAn0sLPMYV7KT6hf9denO9uBfZbRBrNmxZRkz7rllsSrTRRrf4BqkinphLMmsrxe1XDTBn1W3U+aKwYI/pweoKWHo9Cn0hbBAm645yPLgqzy9W5Cwm3XXF9kV+9kB54JO/vS/0rqXVWsYlm1Vm3qLLfAGUpW6gRUUJfj9yWDhPOZLleZOgZUbBL9mZ9VFWVHdfnsETYvCZ2XYZUVRfZCcJCGmpGJPOWCq4k9LumRsQ6xIwU1u15dylQcrVi2/zRtiEtVDEcAnshiVJ9r5iYx5AHCZqtxfrgYid75IvRil+TPfKuOR4DKBoHr0YRAyyHw1PdoSHwigvJKoRAHOyr35Hfw2MTUubh9YWcyOCyBcCDFJgKD35j4Cw4sn8UQOn2hjkoFCaRfTB8CqDvdTVRRQpXOFMQfGM6ONrBqtcBs3MdnApAOCX29HrL7AlQjJCgDaHpNwvTBjpX7Srx9BzlyfJMfCgj+ngmwMCHoFKie4v6BzQ+VKrA74SlHn/sVZWwa9GkAsZJbNwRvIHAMRcTGWKSe6/6M/4v1yBwMql6KsgEkLxLyvVQ+4xZTpmjU3qrwOBuka/ycfAKIfqyPb3pb1CpyZXrBUvvVN6zkqv+6Z5l+WH6y4wdKNexuZZhBEB2sahDACzRFLgn4Dx4SVB1+ZaLIKvmvdcCnmIexVPwMXMcT/II3fwrbefaadgc7IeKSz6SV5XSlXAgiNVjMtAQNqP3flc3rDTxsre25JC5irB4xMvnzF9ZXg3CBAL8WEH+5ViDXDuTuNfFhl1NNdextznC60asVDuESGyb4GHgPI1uMR/NFyUqAFF+dGJkyYQOPGjaPDhw9TvXr16N1336XGjb0HpE+fPp2ee+452r17N1WtWpVee+01uukma+XEMAwaNWoUTZo0ieLj46lFixb0wQcfiG2vFiz4cyqwFKpML1kJTNX9+rJTGAsrCWrQzouBh7B4lGp/ifcZKoOokK1HxSH4Qp+8YYKQE6xPCILEBDGz+JAsTyDzIeW6yQdWy5Tgh3vUXwOJ4jdK9zwMnioWZdm98oE0dsgYpPxx/xknrcvOuhYrsU0mrH1aWsxRL6LcHfI7keXLTVgg0FgEqatqrYHyf0wikI4QkwtnLnLF0d/l5MY5AVZpdkG1gTLzDCz7CGjECpEKHEf7qJSHSuwD9H2/aFlEgJpUXUmETz2L/VwHxi64mmLlVU9HnZcR9XV8xBHgvlSC39skyCn4lTsixk2kiRV9Q4Ajji2bBThzENOmTaPBgwfThx9+SE2aNKG3336bOnbsSNu2baMSJTJm9Vq2bBnde++9NHbsWLr55ptp6tSp1K1bN/r777+pdm1Z9f7111+nd955hz7//HOqWLGimBxgn//88w+Fh3sphHeZCTAwDWF8sn//fipXrhzt27ePypa9AgEpEAq7PrOeoxDMlcqmgNzGSJsWU0cG8jCXHlQyVlWF0XFeqnR7TO7i1HqiXxtodQyyCKz7otib2YXD4hlT2571wwlc/ETwOj4TIAvRHTJT9/kDUvFhUoLv2vst0dGlWuG1IHO140kp7iHgscqQmVUe1cDXPiXjTgrXI6o9iuj3brL+CIQJ0qW2mmEPkGQYJmtg9Q8TdGgJb+6pYPc3Mu0p8OVCh0QQWJXLjmExh+m1Jk2aUKNGjei996Q7Znp6utjHE088QcOHD8+wfffu3SkpKYlmz7YqMTdt2pSuvfZaMWmArC5dujQNGTKEnnrqKfF+QkICxcbG0meffUb33HN16rawhT8nolx5AAbwK5k6DUuBmaXTZC4OfbkZLkZM/gTi9u5EmdoU7i6wouuB8rCmYfkc28HSj+J1WCnA0j0C7r2liWz8IdGpdUR7v5NuPio1H8B3eUPVZxACPl3+D5/e4q2JytwsrYfw0VX4CoaGC4C/tRggPtpqNUNA57Xy/7wQ28AwOQFMvL0lw9BB5jW40mWWXtPfGL+rxJkzZ+j0aSuddlhYmHg4SU5OpjVr1tCIESM8rwUGBlK7du1o+XKzCKcDvI4VAR1Y72fNkhWLd+3aJVyDsA9FTEyMmFjgsyz4GQv4jCJ4DUE4mblYMLkP+EWKgmmBnMIsv4OlcmTYwKPey5dmn5gIIEhW1RZQK4Zw24GbDlLzIe0tVgjgegNrPCx5l9rV7WJgoc8wVy8+omTbXN/6NWva6yGMGjWKXnjhhQzbHT9+nNLS0oT1XQfPt241C306gJh32x6vq/fVa962uRqwhT8nAis7fICZvIuqkMwwlxvEiFzp7DYMwzBXEfjKlyljFRcLc7Hu5ze0hNIMwzAMwzAMk7spWLAgRUdHex5hXgR/sWLFKCgoiI4cOWJ7Hc9LlnRPUoHXfW2v/s/KPq8ELPgZhmEYhmGYfEdoaCg1aNCAFiyw4ogQtIvnzZq5JwrA6/r2YN68eZ7tkZUHwl7fBvEEK1eu9LrPKwG79DAMwzAMwzD5ksGDB1Pv3r2pYcOGIvc+0nIiC0/fvrJCfa9evYR7ENJwgkGDBtH1119Pb7zxBnXp0oW++eYb+uuvv2jiRJliOCAggJ588kl6+eWXRd59lZYTmXuQvvNqka8s/CisUKFCBZEDFdHSq1atutqHxDAMwzAMw1wlunfvTuPHj6fnn39epNZct24d/frrr56g271799KhQ4c82zdv3lzk3ofAR5Gu7777TmToUTn4wdChQ0VazwEDBoiUn4mJiWKfVysHf77Kw4/CCpil6YUVUCnNW2GFq5qHn2EYhmEYhskSrNe8k28s/G+++Sb1799fLNEgXROEf2RkJH3yySdX+9AYhmEYhmEY5rKRLwS/KqygF0HwVVjhwoULIsBCPVDAgWEYhmEYhmFyI/lC8PsqrOBWBAGBGaiKph7OAg4MwzAMwzAMk1vIF4I/q6DEckJCgueBAg4MwzAMwzAMkxvJF2k5s1pYAQUa9CINcOthGIZhGIZhmNxIvrDwZ6ewAsMwDMMwDMPkBfKFhd+fwgq+wOQA6HlYGYZhGIZhmJyD0mlKtzH5UPCjsMKxY8dEYQUE6qK4gl5YwRfKFQgTBYZhGIZhGCbnAt0WFxd3tQ8jR5FvCm9dDKmpqbR27VoxOUA6zysBUoEiOxAChgsWLHhFvjM3wO3CbcPXDN9P3M9wH5zT4LEpZ7QNLPsQ+/Xr16fg4Hxj0/YLFvw5FAQKIyUosgRFR0df7cPJMXC7cNvwNcP3E/cz3AfnNHhs4rbJ6eSLoF2GYRiGYRiGya+w4GcYhmEYhmGYPAwL/hwK6gCMGjXKVg+A4Xbha4bvJe5nuP+9mvDYxO3C10zuhH34GYZhGIZhGCYPwxZ+hmEYhmEYhsnDsOBnGIZhGIZhmDwMC36GYRiGYRiGycOw4GcYhmEYhmGYPAwL/ivMmDFjqHnz5hQZGUmFChVy3Wbv3r3UpUsXsU2JEiXo6aefFtV+dRYvXkzXXXedyJhQpUoV+uyzzzLsZ8KECVShQgUKDw+nJk2a0KpVqyi3gPMLCAhwfaxevVpss3v3btf3V6xYYdvX9OnTqUaNGqId6tSpQ3PmzKHcDH5T5zm/+uqrtm02bNhArVq1Eudcrlw5ev311zPsJ6+1C66Hfv36UcWKFSkiIoIqV64sMl0lJyfbtsmP14wbubl/yA5jx46lRo0aiUqf6Fe7detG27Zts23Tpk2bDNfGww8/nOX+OTfxwgsvZDhnXPuK8+fP02OPPUZFixalqKgouuOOO0Ql07zcJr76WjzQHvntevn999/plltuodKlS4vznDVrlu19wzDo+eefp1KlSon+t127dvTff//Ztjl58iT16NFDFBOF/kF/nZiYmOWxi8kmBnNFef75540333zTGDx4sBETE5Ph/dTUVKN27dpGu3btjLVr1xpz5swxihUrZowYMcKzzc6dO43IyEixj3/++cd49913jaCgIOPXX3/1bPPNN98YoaGhxieffGJs3rzZ6N+/v1GoUCHjyJEjRm7gwoULxqFDh2yPBx980KhYsaKRnp4uttm1a5eBS3j+/Pm27ZKTkz37+fPPP0XbvP7666KtRo4caYSEhBgbN240civly5c3Ro8ebTvnxMREz/sJCQlGbGys0aNHD2PTpk3G119/bURERBgfffRRnm6XX375xejTp48xd+5cY8eOHcYPP/xglChRwhgyZIhnm/x6zTjJ7f1DdujYsaPx6aefinti3bp1xk033WTExcXZ7p3rr79etIV+beB+ykr/nNsYNWqUUatWLds5Hzt2zPP+ww8/bJQrV85YsGCB8ddffxlNmzY1mjdvnqfbRHH06FFbu8ybN0/0H4sWLcp31wuO/dlnnzVmzJgh2mDmzJm291999VWhaWbNmmWsX7/e6Nq1qxivz50759mmU6dORr169YwVK1YYS5cuNapUqWLce++9WRq7mOzDgv8qgYHHTfDjpgoMDDQOHz7see2DDz4woqOjhQgGQ4cOFR20Tvfu3cWApmjcuLHx2GOPeZ6npaUZpUuXNsaOHWvkRiDIihcvLoSuU7yhI/XG3XffbXTp0sX2WpMmTYyHHnrIyM2C/6233vL6/vvvv28ULlzYc72AYcOGGdWrV8/T7eIGRDsGnfx+zTjJa/1DdsUcroUlS5Z4XoOAGzRokNfP+NM/5zYg+CHC3IiPjxeT3enTp3te27Jli2i35cuX59k28QaujcqVK3uMTvnxegFOwY/2KFmypDFu3DjbtRMWFiZEO4DxBJ9bvXq1zUgTEBBgHDhwwO+xi8k+7NKTw1i+fLlwIYiNjfW81rFjRzp9+jRt3rzZsw2Wy3SwDV4HcGFYs2aNbZvAwEDxXG2T2/jxxx/pxIkT1Ldv3wzvde3aVSyVtmzZUmynk1lb5VbgwoMl9vr169O4ceNsS8Q4t9atW1NoaKjtnOG+cOrUqTzdLk4SEhKoSJEiGV7Pj9eMIi/2D9m9NoDz+vjqq6+oWLFiVLt2bRoxYgSdPXs2S/1zbgSuF3DVqFSpknC5gBsKwHWSkpJiu1bg7hMXF+e5VvJqm7jdN1OmTKEHHnhAuLTk5+vFya5du+jw4cO26yQmJka4CurXCdx4GjZs6NkG26PvWblypd9jF5N9gi/is8xlADeN3jkA9Rzv+doGnci5c+fEjZGWlua6zdatW3Pl7/bxxx+LG79s2bKe1+BP+sYbb1CLFi1Ep/H9998Lv1z4FkLQ+Wor1Za5kYEDB4r4DQiVZcuWiUHm0KFD9Oabb4r3cW7wY/d2DRUuXDhPtouT7du307vvvkvjx4+n/H7N6Bw/fjzP9Q9ZJT09nZ588klxHUCoKe677z4qX768EL/wJR42bJgQGzNmzPC7f85tQJQhBqx69eqiH3nxxReFD/WmTZvEOUF8OePN9PshL7aJG+gj4uPjqU+fPvn6enFDnYuvfhP/w8iiExwcLMYxfZvMxi4m+7DgvwQMHz6cXnvtNZ/bbNmyxRYIlV/JTlvt37+f5s6dS99++61tO1hVBg8e7HmOgLyDBw8Ki7cSb3mxXfRzrlu3rhiQH3roIRGUiCDuvEZ2rpkDBw5Qp06d6K677qL+/fvnyWuGyT4IuoSg/eOPP2yvDxgwwPM3LLMIQGzbti3t2LFDBIHnRTp37mzrTzABgIhFf4vgS8YyOqGtIO7z8/XC5F5Y8F8ChgwZYpv1u4GlUn8oWbJkhmwZKiMC3lP/O7Mk4Dki39FBBwUFiYfbNmofuamtPv30U+G+4o8gw2A1b948z3NvbXW12+FSXkM4Z7j0IAMNrHTeztmfayintUt22gYC/oYbbhDZsCZOnJhnr5nsgklPTu0frgSPP/44zZ49W2Qd0VcMvV0barUIAs6f/jm3A2t+tWrVxDm3b99euLLAsq1b+fVrJT+0yZ49e2j+/Pkey7038uP1op8Lzg2THgWeX3vttZ5tjh49avscxi1k7slsXNK/g8k+7MN/CShevLiwLvp66D5pvmjWrBlt3LjRdmNAjEDM16xZ07PNggULbJ/DNngd4LsaNGhg2wZL2HiutsktbYX4IAj+Xr16UUhISKb7X7duna3Dyayt8sI1hHOGe4paLsW5QczA91Y/Z0wG1JJobmmXrLYNLPtIlYfrH9cN2iWvXjPZJSf3D5cT9CUQ+zNnzqSFCxdmcB3wdm0AdX340z/ndpAmERZqnDOuE/S7+rUClxX4+KtrJT+0CfoS9K9Ir+mL/Hi9ANxLEOT6dQIXY/jm69cJJo6IC1HgPkTfoyZK/oxdzEVwEQG/TDbYs2ePyBDy4osvGlFRUeJvPM6cOWNL49WhQweROg6pNpGdxi0t59NPPy0yJkyYMME1LSci5D/77DMRHT9gwACRdk/PFpAbQPpEXKY4Tyc4t6lTp4r38BgzZozIiIBUg3qKxeDgYGP8+PFiG2SkyM0pFpctWyYy9ODaQOrJKVOmiOujV69etuwISG3Ws2dPkdoM1wKuF2dazrzULmD//v0izVvbtm3F33qqvPx8zbiRV/qHrPDII4+IzGiLFy+2XRtnz54V72/fvl1kAUPqSWRzQlrXSpUqGa1bt/bsw5/+ObeBtLVoE5wzrn2kkETqSGQxUmk5kb504cKFom2aNWsmHnm5TXSQwQrnj2wxOvnteoFGUXoFYzLSi+NvaBqVlhN9CNphw4YNxq233uqalrN+/frGypUrjT/++MOoWrWqLS2nP2MXk31Y8F9hevfuLW4W50Pl9QW7d+82OnfuLPLPouNFh5ySkmLbD7a/9tprRS5tdDJI8+kE+fnRUWEbpOFD7tvcBjoDPeezDsTKNddcIzoEpDnDOerp4xTffvutUa1aNdEOSGf6888/G7mVNWvWiBSREC7h4eHi/F955RXj/Pnztu2QB7lly5ZC1JUpU0Z0xnm5XQDuAbd7S7dr5Mdrxht5oX/ICt6uDdV37t27V4i1IkWKiPsGk0cYVfS86v72z7kJpHQuVaqUuA7QV+A5xKwCgu3RRx8V6RJx39x22222SXRebBMd1PXAdbJt2zbb6/nteoHmcLt/oGlUas7nnntOCHa0BwwvzjY7ceKEGNNh7ET/27dvX4+xMytjF5M9AvDPxawQMAzDMAzDMAyTc2EffoZhGIZhGIbJw7DgZxiGYRiGYZg8DAt+hmEYhmEYhsnDsOBnGIZhGIZhmDwMC36GYRiGYRiGycOw4GcYhmEYhmGYPAwLfoZhGIZhGIbJw7DgZxiGYRiGYZg8DAt+hmHyLIsXL6aAgACKj4/PEfvJD+T0tqpQoQK9/fbbPrd54YUX6Nprr71ix8QwDHO5YcHPMEyOpE+fPkI44hESEkIVK1akoUOH0vnz5y/r97Zp04aefPJJ22vNmzenQ4cOUUxMDF1uvv/+e7rxxhupcOHCFBERQdWrV6cHHniA1q5dS7mBi20rNWFQj9jYWLrjjjto586dl+T4Vq9eTQMGDPA8x3fMmjXLts1TTz1FCxYsuCTfxzAMkxNgwc8wTI6lU6dOQjxC7L311lv00Ucf0ahRo674cYSGhlLJkiWFOLycDBs2jLp37y6syz/++CNt27aNpk6dSpUqVaIRI0ZQbuBStRXO/eDBgzR9+nTavHkz3XLLLZSWlnbRx1e8eHGKjIz0uU1UVBQVLVr0or+LYRgmp8CCn2GYHEtYWJgQj+XKlaNu3bpRu3btaN68eZ7309PTaezYscL6D2t4vXr16LvvvvO6vxMnTtC9995LZcqUEaKvTp069PXXX9tWFZYsWUL/+9//PBbm3bt329xUTp8+Lb7rl19+se175syZVLBgQTp79qx4vm/fPrr77rupUKFCVKRIEbr11lvFvryxYsUKev311+nNN98Uj1atWlFcXBw1aNCARo4cmeH7fvjhB7ruuusoPDxcTAhefPFFSk1N9byP4508eTLddttt4lyrVq0qJhE6ONfGjRuLdi5VqhQNHz7ctg+sdjzxxBNixQMrDrC2T5o0iZKSkqhv377ifKtUqWI7NjeXnj///FPsC8eB/XTs2JFOnTpFvihRooQ4ptatW9Pzzz9P//zzD23fvl2898EHH1DlypXF5AIrIF9++aXnc4ZhCJcctB3Oq3Tp0jRw4EBXlx78DdBGOGb13OnSg+ts9OjRVLZsWbFPvPfrr7963sfvis/PmDGDbrjhBnGeuBaXL1/u8xwZhmGuFCz4GYbJFWzatImWLVsmRJ4CYv+LL76gDz/8UFiB/+///o/uv/9+IWTdgDsQBPTPP/8s9gfXjp49e9KqVavE+xD6zZo1o/79+4uVBTww2dCJjo6mm2++WVjedb766isxKYHYS0lJEaIWgnjp0qVC8MJqjBWL5ORk12PDxAPbPProo67v6xZz7LNXr140aNAgIYSx8vHZZ5/RmDFjbJ/BJACTjg0bNtBNN91EPXr0oJMnT4r3Dhw4IF5r1KgRrV+/Xojojz/+mF5++WXbPj7//HMqVqyYaCOI/0ceeYTuuusu4brz999/U4cOHUQbqomOk3Xr1lHbtm2pZs2aQgD/8ccfWbbWY4IF0HaYWOG8hwwZIn7Dhx56SEw+Fi1a5HGJUqtB//33n3DXwcTOm3sP+PTTT8VvrZ47wXXxxhtv0Pjx40Vb4rft2rWr2L/Os88+K9yBcM7VqlUTk0t9AsUwDHPVMBiGYXIgvXv3NoKCgowCBQoYYWFhBrqrwMBA47vvvhPvnz9/3oiMjDSWLVtm+1y/fv2Me++9V/y9aNEi8blTp055/Z4uXboYQ4YM8Ty//vrrjUGDBtm2ce5n5syZRlRUlJGUlCSeJyQkGOHh4cYvv/winn/55ZdG9erVjfT0dM8+Lly4YERERBhz5851PY5OnToZdevWtb32xhtviPNXj/j4ePF627ZtjVdeecW2Lb6zVKlSnuc43pEjR3qeJyYmitfUMT7zzDMZjnHChAnivNLS0jxt0bJlS8/7qamp4jh69uzpee3QoUNiv8uXL3dtK/wWLVq0MPzF+fmDBw8azZs3N8qUKSPaEH/379/f9pm77rrLuOmmmzxtVq1aNSM5Odl1/+XLlzfeeustWzvh99QZNWqUUa9ePc/z0qVLG2PGjLFt06hRI+PRRx8Vf+/atUvsZ/LkyZ73N2/eLF7bsmWL3+fOMAxzuWALP8MwORa4R8BaunLlSurdu7ew5CKAE8C9A1bl9u3bC8u4esDiv2PHDtf9war80ksvCYsv3Gyw/dy5c2nv3r1ZOi5YxhFIrFxkYFWG5R8uRwAWcxwfLPzquPB9WGHwdmxuIFgX5w9rNdxopD6V+4eLiX7ealVCt7TXrVvX83eBAgXEMR49elQ837Jli1jN0FcOWrRoQYmJibR//37XfQQFBQnfdt1iDjcfoPbrzcKfVeA+g2OGSw7OHW2M1R0cN45TB8/xOsDqw7lz54SbE9oEKwIXY2WHCxdiCXx9p1tbwR3JV7swDMNcSYKv6LcxDMNkAQg++IiDTz75RPhFw+2kX79+QpgCuOfAJ18HftZujBs3TrhnwIcbohX7h3+6Nzcbb0B43nnnncKt55577hH/I9g2OFh2qTg2uA7BzcctaNQN+NjD3QXuQJhMAPj/46ELcLV/uOvcfvvtGfYDn36F2o8C4h7+6FnBbR/6a2rC4G2/yh0nq8BtCRMU+PJj4uQvcMFCwO/8+fNFvAdcpPC7w83LeS6Xmqy0C8MwzJWELfwMw+QKAgMD6ZlnnhEBrLDgwiccwh7WeUwK9IfT714BX3oEz8LPH5MHWIH//fffDGLeH/9y+MMjcBOxAwsXLhTPFQimhX83xKrz2Lylq4S/N4T8+++/n+l3Y/8Qtc5944F28odrrrlG+NSrVQPVPhDXsK5fKmD1zk6KSwRiIzDXKfZx3DhOHTzH9aBPMhAn8M4774ggYpznxo0bvYp0X783Jh1YZcjsOxmGYXIyLPgZhsk1wF0DbiUTJkwQQhABkgjURWApXGUQRPruu++K596s6LD6IvgX7hgI+Dxy5IhtG2RqgQsRMq8cP37cq4UW2WOQQQhCH+K0SZMmnvfwGgJdMbmApXrXrl1CeCJbjNNar4B7DQJR8Rg8eLCw9u/Zs0dk78GqBizGSswjaw1cl2Dlx4QD5/LNN9+IyZC/wPKNTEIIxN26davI+oOUp/hufycN/oB0ogiGxfch4BXfhQBhtG12ePrpp0WAMvaBSRUyGiE7Dq4FgPfQXgjoRTrXKVOmiAlA+fLlXfeH3xsTksOHD3vNHITvfO2112jatGliooVsRnBVQvAwwzBMboAFP8MwuQa4zDz++OMifSX8uuGP/9xzz4lsPbD8IgsOXHwgwN2AIIZ1HFlWkCYSgh2ZdXQgHDGpgPUW7jfe/PshwGGVhz+9bt0HyNTz+++/i9SQcLvBscENCT78sBh7A1lg4B6EIlvIBIQJCiY5mHTASq0+i+OfPXs2/fbbbyLLTtOmTUVmGm+i1g24Qc2ZM0dk38Fqx8MPPyyOMSuTBn9AthocJ9oJKUAxscHkQrk/ZRX8XnDLQlvVqlVLxDcgyw5+TwAXKKQOhY89Vhfg2vPTTz95zauP7DuYBGJVqH79+q7bYKKGiRAmY3AFw8oO4jfw+zAMw+QGAhC5e7UPgmEYhmEYhmGYywNb+BmGYRiGYRgmD8OCn2EYhmEYhmHyMCz4GYZhGIZhGCYPw4KfYRiGYRiGYfIwLPgZhmEYhmEYJg/Dgp9hGIZhGIZh8jAs+BmGYRiGYRgmD8OCn2EYhmEYhmHyMCz4GYZhGIZhGCYPw4KfYRiGYRiGYfIwLPgZhmEYhmEYhvIu/w9vKATstWzeBgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -1587,7 +2115,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ @@ -1596,13 +2124,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1c07a0a5a1ee45798283d09e70f7106c", + "model_id": "57d61141a4d84208a62c31f35557089c", "version_major": 2, "version_minor": 0 }, @@ -1619,13 +2147,13 @@ "" ] }, - "execution_count": 37, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1646,13 +2174,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ee33e9942d7a48e6bef1781e7c0c2917", + "model_id": "ed3971d1c88e483fa5447ab398ebf7cb", "version_major": 2, "version_minor": 0 }, @@ -1669,13 +2197,13 @@ "" ] }, - "execution_count": 38, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1773,7 +2301,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 40, "metadata": {}, "outputs": [ { @@ -2132,14 +2660,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/cluster.py:1592: UserWarning: *c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n", + "/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/cluster.py:2235: UserWarning: *c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n", " ax_left.scatter(\n" ] }, @@ -2259,14 +2787,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'test': {'accuracy': 0.8356164383561644, 'roc_auc': 0.8820826559425002, 'confusion_matrix': [[707, 99], [105, 330]]}, 'train': {'accuracy': 0.8369609028617493, 'roc_auc': 0.8732761088441978, 'confusion_matrix': [[2875, 349], [460, 1278]]}}\n" + "{'test': {'accuracy': 0.8356164383561644, 'roc_auc': 0.8820826559425002, 'confusion_matrix': [[707, 99], [105, 330]]}, 'train': {'accuracy': 0.8369609028617493, 'roc_auc': 0.8728129898888372, 'confusion_matrix': [[2875, 349], [460, 1278]]}}\n" ] }, { @@ -2276,7 +2804,7 @@ "
" ] }, - "execution_count": 41, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" }, @@ -2347,21 +2875,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 43, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'test': {'accuracy': 0.8356164383561644, 'roc_auc': 0.9029776674937966, 'confusion_matrix': [[705, 101], [103, 332]]}, 'train': {'accuracy': 0.8405884723901652, 'roc_auc': 0.9012457275268627, 'confusion_matrix': [[2865, 359], [432, 1306]]}}\n" + "{'test': {'accuracy': 0.8356164383561644, 'roc_auc': 0.9029833718376543, 'confusion_matrix': [[705, 101], [103, 332]]}, 'train': {'accuracy': 0.8405884723901652, 'roc_auc': 0.9012326995177138, 'confusion_matrix': [[2865, 359], [432, 1306]]}}\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/cluster.py:1592: UserWarning: *c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n", + "/Users/ngamarra/Documents/GitHub/dimelo-toolkit/dimelo/cluster.py:2235: UserWarning: *c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n", " ax_left.scatter(\n" ] }, @@ -2372,7 +2900,7 @@ "
" ] }, - "execution_count": 42, + "execution_count": 43, "metadata": {}, "output_type": "execute_result" }, @@ -2447,9 +2975,388 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 44, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Association payload metadata\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "plot_family", + "rawType": "str", + "type": "string" + }, + { + "name": "value_mode", + "rawType": "str", + "type": "string" + }, + { + "name": "source_format", + "rawType": "str", + "type": "string" + }, + { + "name": "region_order", + "rawType": "object", + "type": "unknown" + }, + { + "name": "cluster_order", + "rawType": "object", + "type": "unknown" + }, + { + "name": "top_n_regions_per_cluster", + "rawType": "int64", + "type": "integer" + }, + { + "name": "has_top_regions_table", + "rawType": "bool", + "type": "boolean" + }, + { + "name": "region_sort", + "rawType": "str", + "type": "string" + }, + { + "name": "association_strength_aggregate", + "rawType": "str", + "type": "string" + }, + { + "name": "chromosome_blocks", + "rawType": "object", + "type": "unknown" + } + ], + "ref": "cf932a3c-cdf8-492e-a5aa-7f447904f627", + "rows": [ + [ + "0", + "read_cluster_region_association_heatmap", + "fraction", + "legacy_wide", + "['chr1:9168068-9168218:+', 'chr1:9168135-9168218:+', 'chr1:9168136-9168218:-', 'chr1:9169918-9170236:+', 'chr1:9169985-9170303:+', 'chr1:9169986-9170302:-', 'chr1:9172003-9172086:+', 'chr1:9172003-9172152:-', 'chr1:9172003-9172153:+', 'chr1:114356586-114356736:+', 'chr1:114356587-114356736:-', 'chr1:114358436-114358754:+', 'chr1:114358437-114358753:-', 'chr1:114360454-114360603:-', 'chr1:114360454-114360604:+', 'chr1:150101499-150101649:+', 'chr1:150101534-150101649:-', 'chr1:150101535-150101649:+', 'chr1:150103349-150103667:+', 'chr1:150103384-150103702:-', 'chr1:150103385-150103701:+', 'chr1:150105402-150105517:+', 'chr1:150105402-150105551:+', 'chr1:150105402-150105552:-', 'chr1:224661531-224661681:-', 'chr1:224661583-224661681:+', 'chr1:224661584-224661681:-', 'chr1:224663381-224663697:-', 'chr1:224663433-224663751:+', 'chr1:224663434-224663750:-', 'chr1:224665451-224665547:-', 'chr1:224665451-224665600:-', 'chr1:224665451-224665601:+', 'chr2:44482827-44482977:+', 'chr2:44484677-44484995:+', 'chr2:44486695-44486845:+', 'chr3:48462628-48462778:-', 'chr3:48462688-48462778:-', 'chr3:48462689-48462778:+', 'chr3:48464478-48464796:-', 'chr3:48464538-48464856:-', 'chr3:48464539-48464855:+', 'chr3:48466556-48466646:-', 'chr3:48466556-48466705:+', 'chr3:48466556-48466706:-', 'chr5:111666908-111667058:+', 'chr5:111668758-111669076:+', 'chr5:111670776-111670926:+', 'chr5:138876711-138876861:+', 'chr5:138878561-138878879:+', 'chr5:138880579-138880729:+', 'chr6:15561907-15562057:+', 'chr6:15561908-15562057:-', 'chr6:15561985-15562057:+', 'chr6:15561986-15562057:-', 'chr6:15563757-15564075:+', 'chr6:15563758-15564074:-', 'chr6:15563835-15564153:+', 'chr6:15563836-15564152:-', 'chr6:15565853-15565924:-', 'chr6:15565853-15565925:+', 'chr6:15565853-15566002:-', 'chr6:15565853-15566003:+', 'chr6:41196591-41196741:-', 'chr6:41196592-41196741:+', 'chr6:41196657-41196741:+', 'chr6:41196658-41196741:-', 'chr6:41198441-41198759:-', 'chr6:41198442-41198758:+', 'chr6:41198507-41198825:+', 'chr6:41198508-41198824:-', 'chr6:41200525-41200608:+', 'chr6:41200525-41200609:-', 'chr6:41200525-41200674:-', 'chr6:41200525-41200675:+', 'chr6:53009844-53009994:+', 'chr6:53011694-53012012:+', 'chr6:53013712-53013862:+', 'chr6:73588139-73588289:-', 'chr6:73588200-73588289:+', 'chr6:73589989-73590307:-', 'chr6:73590050-73590368:+', 'chr6:73592068-73592157:-', 'chr6:73592068-73592218:+', 'chr6:155875926-155876076:-', 'chr6:155876024-155876076:+', 'chr6:155876025-155876076:-', 'chr6:155877776-155878092:-', 'chr6:155877874-155878192:+', 'chr6:155877875-155878191:-', 'chr6:155879892-155879942:-', 'chr6:155879892-155880041:-', 'chr6:155879892-155880042:+', 'chr7:152343785-152343935:-', 'chr7:152343786-152343935:+', 'chr7:152343847-152343935:-', 'chr7:152343848-152343935:+', 'chr7:152345635-152345953:-', 'chr7:152345636-152345952:+', 'chr7:152345697-152346015:-', 'chr7:152345698-152346014:+', 'chr7:152347715-152347802:+', 'chr7:152347715-152347803:-', 'chr7:152347715-152347864:+', 'chr7:152347715-152347865:-', 'chr8:22846344-22846494:+', 'chr8:22846345-22846494:-', 'chr8:22846428-22846494:+', 'chr8:22848194-22848512:+', 'chr8:22848195-22848511:-', 'chr8:22848278-22848596:+', 'chr8:22850296-22850361:-', 'chr8:22850296-22850362:+', 'chr8:22850296-22850446:+', 'chr9:145234660-145234810:+', 'chr9:145234661-145234810:-', 'chr9:145234697-145234810:-', 'chr9:145236510-145236828:+', 'chr9:145236511-145236827:-', 'chr9:145236547-145236865:-', 'chr9:145238565-145238677:-', 'chr9:145238565-145238678:+', 'chr9:145238565-145238715:-', 'chr12:57871837-57871987:-', 'chr12:57871885-57871987:-', 'chr12:57873687-57874005:-', 'chr12:57873735-57874053:-', 'chr12:57875753-57875855:-', 'chr12:57875753-57875903:-', 'chr14:17377273-17377423:+', 'chr14:17377274-17377423:-', 'chr14:17377341-17377423:+', 'chr14:17379123-17379441:+', 'chr14:17379124-17379440:-', 'chr14:17379191-17379509:+', 'chr14:17381209-17381290:-', 'chr14:17381209-17381291:+', 'chr14:17381209-17381359:+', 'chr14:44123158-44123308:+', 'chr14:44123159-44123308:-', 'chr14:44125008-44125326:+', 'chr14:44125009-44125325:-', 'chr14:44127026-44127175:-', 'chr14:44127026-44127176:+', 'chr15:38664850-38665000:-', 'chr15:38664851-38665000:+', 'chr15:38664892-38665000:-', 'chr15:38664893-38665000:+', 'chr15:38666700-38667018:-', 'chr15:38666701-38667017:+', 'chr15:38666742-38667060:-', 'chr15:38666743-38667059:+', 'chr15:38668760-38668867:+', 'chr15:38668760-38668868:-', 'chr15:38668760-38668909:+', 'chr15:38668760-38668910:-', 'chr15:54632158-54632308:+', 'chr15:54632159-54632308:-', 'chr15:54632192-54632308:-', 'chr15:54632193-54632308:+', 'chr15:54634008-54634326:+', 'chr15:54634009-54634325:-', 'chr15:54634042-54634360:-', 'chr15:54634043-54634359:+', 'chr15:54636060-54636175:-', 'chr15:54636060-54636176:+', 'chr15:54636060-54636209:+', 'chr15:54636060-54636210:-', 'chr16:4279474-4279624:+', 'chr16:4279536-4279624:+', 'chr16:4279537-4279624:-', 'chr16:4281324-4281640:+', 'chr16:4281386-4281704:+', 'chr16:4281387-4281703:-', 'chr16:4283404-4283490:+', 'chr16:4283404-4283553:-', 'chr16:4283404-4283554:+', 'chr16:61261359-61261509:+', 'chr16:61261360-61261509:-', 'chr16:61261438-61261509:+', 'chr16:61261439-61261509:-', 'chr16:61263209-61263527:+', 'chr16:61263210-61263526:-', 'chr16:61263288-61263606:+', 'chr16:61263289-61263605:-', 'chr16:61265306-61265376:-', 'chr16:61265306-61265377:+', 'chr16:61265306-61265455:-', 'chr16:61265306-61265456:+', 'chr16:63442391-63442541:-', 'chr16:63442392-63442541:+', 'chr16:63442436-63442541:-', 'chr16:63444241-63444559:-', 'chr16:63444242-63444558:+', 'chr16:63444286-63444602:-', 'chr16:63446302-63446408:+', 'chr16:63446302-63446409:-', 'chr16:63446302-63446452:-', 'chr17:42517551-42517701:-', 'chr17:42517552-42517701:+', 'chr17:42517613-42517701:-', 'chr17:42519401-42519719:-', 'chr17:42519402-42519718:+', 'chr17:42519463-42519781:-', 'chr17:42521481-42521568:+', 'chr17:42521481-42521569:-', 'chr17:42521481-42521631:-', 'chr17:44334563-44334713:+', 'chr17:44334564-44334713:-', 'chr17:44336413-44336731:+', 'chr17:44336414-44336730:-', 'chr17:44338431-44338580:-', 'chr17:44338431-44338581:+', 'chr17:45987586-45987736:+', 'chr17:45987587-45987736:-', 'chr17:45987626-45987736:+', 'chr17:45987627-45987736:-', 'chr17:45989436-45989754:+', 'chr17:45989437-45989753:-', 'chr17:45989476-45989794:+', 'chr17:45989477-45989793:-', 'chr17:45991494-45991603:-', 'chr17:45991494-45991604:+', 'chr17:45991494-45991643:-', 'chr17:45991494-45991644:+', 'chr17:82008550-82008700:-', 'chr17:82008681-82008700:-', 'chr17:82008682-82008700:+', 'chr17:82010400-82010718:-', 'chr17:82010531-82010849:-', 'chr17:82010532-82010848:+', 'chr17:82012549-82012568:-', 'chr17:82012549-82012698:+', 'chr17:82012549-82012699:-', 'chr19:41732348-41732498:-', 'chr19:41732349-41732498:+', 'chr19:41734198-41734516:-', 'chr19:41734199-41734515:+', 'chr19:41736216-41736365:+', 'chr19:41736216-41736366:-', 'chr19:43453207-43453357:-', 'chr19:43453252-43453357:-', 'chr19:43453253-43453357:+', 'chr19:43455057-43455375:-', 'chr19:43455102-43455420:-', 'chr19:43455103-43455419:+', 'chr19:43457120-43457225:-', 'chr19:43457120-43457269:+', 'chr19:43457120-43457270:-', 'chr19:44926036-44926186:+', 'chr19:44926037-44926186:-', 'chr19:44927886-44928204:+', 'chr19:44927887-44928203:-', 'chr19:44929904-44930053:-', 'chr19:44929904-44930054:+', 'chr20:33335198-33335348:-', 'chr20:33335199-33335348:+', 'chr20:33335286-33335348:-', 'chr20:33337048-33337366:-', 'chr20:33337049-33337365:+', 'chr20:33337136-33337454:-', 'chr20:33339154-33339215:+', 'chr20:33339154-33339216:-', 'chr20:33339154-33339304:-', 'chr20:36033923-36034073:+', 'chr20:36033924-36034073:-', 'chr20:36035773-36036091:+', 'chr20:36035774-36036090:-', 'chr20:36037791-36037940:-', 'chr20:36037791-36037941:+', 'chr20:40161013-40161163:-', 'chr20:40161014-40161163:+', 'chr20:40162863-40163181:-', 'chr20:40162864-40163180:+', 'chr20:40164881-40165030:+', 'chr20:40164881-40165031:-', 'chr20:59988985-59989135:-', 'chr20:59989037-59989135:-', 'chr20:59989038-59989135:+', 'chr20:59990835-59991153:-', 'chr20:59990887-59991205:-', 'chr20:59990888-59991204:+', 'chr20:59992905-59993003:-', 'chr20:59992905-59993054:+', 'chr20:59992905-59993055:-', 'chr21:24894312-24894462:-', 'chr21:24894313-24894462:+', 'chr21:24896162-24896480:-', 'chr21:24896163-24896479:+', 'chr21:24898180-24898329:+', 'chr21:24898180-24898330:-', 'chrX:9700334-9700484:-', 'chrX:9702184-9702502:-', 'chrX:9704202-9704352:-', 'chrX:99209453-99209603:-', 'chrX:99209454-99209603:+', 'chrX:99211303-99211621:-', 'chrX:99211304-99211620:+', 'chrX:99213321-99213470:+', 'chrX:99213321-99213471:-']", + "[0, 1]", + "8", + "True", + "source_bed_then_genomic", + "max", + "[{'chrom': 'chr1', 'start_index': 0, 'end_index': 32, 'n_regions': 33}, {'chrom': 'chr2', 'start_index': 33, 'end_index': 35, 'n_regions': 3}, {'chrom': 'chr3', 'start_index': 36, 'end_index': 44, 'n_regions': 9}, {'chrom': 'chr5', 'start_index': 45, 'end_index': 50, 'n_regions': 6}, {'chrom': 'chr6', 'start_index': 51, 'end_index': 92, 'n_regions': 42}, {'chrom': 'chr7', 'start_index': 93, 'end_index': 104, 'n_regions': 12}, {'chrom': 'chr8', 'start_index': 105, 'end_index': 113, 'n_regions': 9}, {'chrom': 'chr9', 'start_index': 114, 'end_index': 122, 'n_regions': 9}, {'chrom': 'chr12', 'start_index': 123, 'end_index': 128, 'n_regions': 6}, {'chrom': 'chr14', 'start_index': 129, 'end_index': 143, 'n_regions': 15}, {'chrom': 'chr15', 'start_index': 144, 'end_index': 167, 'n_regions': 24}, {'chrom': 'chr16', 'start_index': 168, 'end_index': 197, 'n_regions': 30}, {'chrom': 'chr17', 'start_index': 198, 'end_index': 233, 'n_regions': 36}, {'chrom': 'chr19', 'start_index': 234, 'end_index': 254, 'n_regions': 21}, {'chrom': 'chr20', 'start_index': 255, 'end_index': 284, 'n_regions': 30}, {'chrom': 'chr21', 'start_index': 285, 'end_index': 290, 'n_regions': 6}, {'chrom': 'chrX', 'start_index': 291, 'end_index': 299, 'n_regions': 9}]" + ] + ], + "shape": { + "columns": 10, + "rows": 1 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
plot_familyvalue_modesource_formatregion_ordercluster_ordertop_n_regions_per_clusterhas_top_regions_tableregion_sortassociation_strength_aggregatechromosome_blocks
0read_cluster_region_association_heatmapfractionlegacy_wide[chr1:9168068-9168218:+, chr1:9168135-9168218:...[0, 1]8Truesource_bed_then_genomicmax[{'chrom': 'chr1', 'start_index': 0, 'end_inde...
\n", + "
" + ], + "text/plain": [ + " plot_family value_mode source_format \\\n", + "0 read_cluster_region_association_heatmap fraction legacy_wide \n", + "\n", + " region_order cluster_order \\\n", + "0 [chr1:9168068-9168218:+, chr1:9168135-9168218:... [0, 1] \n", + "\n", + " top_n_regions_per_cluster has_top_regions_table region_sort \\\n", + "0 8 True source_bed_then_genomic \n", + "\n", + " association_strength_aggregate \\\n", + "0 max \n", + "\n", + " chromosome_blocks \n", + "0 [{'chrom': 'chr1', 'start_index': 0, 'end_inde... " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Region axis preview (sorted)\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "region_id", + "rawType": "str", + "type": "string" + }, + { + "name": "chrom", + "rawType": "str", + "type": "string" + }, + { + "name": "start", + "rawType": "int64", + "type": "integer" + }, + { + "name": "end", + "rawType": "int64", + "type": "integer" + }, + { + "name": "source_label", + "rawType": "str", + "type": "string" + } + ], + "ref": "b53eba3f-e11d-43e3-a34a-48da3b07a78f", + "rows": [ + [ + "0", + "chr1:9169918-9170236:+", + "chr1", + "9169918", + "9170236", + "on_target" + ], + [ + "1", + "chr1:9169985-9170303:+", + "chr1", + "9169985", + "9170303", + "on_target" + ], + [ + "2", + "chr1:9169986-9170302:-", + "chr1", + "9169986", + "9170302", + "on_target" + ], + [ + "3", + "chr1:114358436-114358754:+", + "chr1", + "114358436", + "114358754", + "on_target" + ], + [ + "4", + "chr1:114358437-114358753:-", + "chr1", + "114358437", + "114358753", + "on_target" + ] + ], + "shape": { + "columns": 5, + "rows": 5 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
region_idchromstartendsource_label
0chr1:9169918-9170236:+chr191699189170236on_target
1chr1:9169985-9170303:+chr191699859170303on_target
2chr1:9169986-9170302:-chr191699869170302on_target
3chr1:114358436-114358754:+chr1114358436114358754on_target
4chr1:114358437-114358753:-chr1114358437114358753on_target
\n", + "
" + ], + "text/plain": [ + " region_id chrom start end source_label\n", + "0 chr1:9169918-9170236:+ chr1 9169918 9170236 on_target\n", + "1 chr1:9169985-9170303:+ chr1 9169985 9170303 on_target\n", + "2 chr1:9169986-9170302:- chr1 9169986 9170302 on_target\n", + "3 chr1:114358436-114358754:+ chr1 114358436 114358754 on_target\n", + "4 chr1:114358437-114358753:- chr1 114358437 114358753 on_target" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Source label counts\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "source_label", + "rawType": "str", + "type": "string" + }, + { + "name": "n_regions", + "rawType": "int64", + "type": "integer" + } + ], + "ref": "51c5e854-8771-4e07-9536-78c8fb2aab7a", + "rows": [ + [ + "off_target", + "200" + ], + [ + "on_target", + "100" + ] + ], + "shape": { + "columns": 1, + "rows": 2 + } + }, + "text/plain": [ + "source_label\n", + "off_target 200\n", + "on_target 100\n", + "Name: n_regions, dtype: int64" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from dimelo import plotting, plotting_matplotlib\n", "import pandas as pd\n", @@ -2563,11 +3470,222 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 45, "metadata": {}, "outputs": [ { "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "region_id", + "rawType": "str", + "type": "string" + }, + { + "name": "chrom", + "rawType": "str", + "type": "string" + }, + { + "name": "start", + "rawType": "int64", + "type": "integer" + }, + { + "name": "end", + "rawType": "int64", + "type": "integer" + }, + { + "name": "strand", + "rawType": "str", + "type": "string" + }, + { + "name": "cluster", + "rawType": "object", + "type": "unknown" + }, + { + "name": "count", + "rawType": "int64", + "type": "integer" + }, + { + "name": "fraction", + "rawType": "float64", + "type": "float" + }, + { + "name": "total_reads", + "rawType": "int64", + "type": "integer" + }, + { + "name": "value", + "rawType": "float64", + "type": "float" + }, + { + "name": "rank", + "rawType": "int64", + "type": "integer" + } + ], + "ref": "32df251f-c65f-462c-9d39-e02425cdc7e0", + "rows": [ + [ + "0", + "chr12:57871837-57871987:-", + "chr12", + "57871837", + "57871987", + "-", + "0", + "24", + "1.0", + "24", + "1.0", + "1" + ], + [ + "1", + "chr12:57871885-57871987:-", + "chr12", + "57871885", + "57871987", + "-", + "0", + "24", + "1.0", + "24", + "1.0", + "2" + ], + [ + "2", + "chr12:57875753-57875855:-", + "chr12", + "57875753", + "57875855", + "-", + "0", + "25", + "1.0", + "25", + "1.0", + "3" + ], + [ + "3", + "chr12:57875753-57875903:-", + "chr12", + "57875753", + "57875903", + "-", + "0", + "25", + "1.0", + "25", + "1.0", + "4" + ], + [ + "4", + "chr14:17377273-17377423:+", + "chr14", + "17377273", + "17377423", + "+", + "0", + "23", + "1.0", + "23", + "1.0", + "5" + ], + [ + "5", + "chr14:17377341-17377423:+", + "chr14", + "17377341", + "17377423", + "+", + "0", + "23", + "1.0", + "23", + "1.0", + "6" + ], + [ + "6", + "chr14:17381209-17381291:+", + "chr14", + "17381209", + "17381291", + "+", + "0", + "19", + "1.0", + "19", + "1.0", + "7" + ], + [ + "7", + "chr15:38664850-38665000:-", + "chr15", + "38664850", + "38665000", + "-", + "0", + "22", + "1.0", + "22", + "1.0", + "8" + ], + [ + "8", + "chr9:145236510-145236828:+", + "chr9", + "145236510", + "145236828", + "+", + "1", + "19", + "0.9047619047619048", + "21", + "0.9047619047619048", + "1" + ], + [ + "9", + "chr9:145236511-145236827:-", + "chr9", + "145236511", + "145236827", + "-", + "1", + "19", + "0.9047619047619048", + "21", + "0.9047619047619048", + "2" + ] + ], + "shape": { + "columns": 11, + "rows": 10 + } + }, "text/html": [ "
\n", "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
plot_familyvalue_modesource_formatregion_ordercluster_ordertop_n_regions_per_clusterhas_top_regions_tableregion_sortassociation_strength_aggregatechromosome_blocks
0read_cluster_region_association_heatmapfractionlegacy_wide[chr1:9168068-9168218:+, chr1:9168135-9168218:...[0, 1]8Truesource_bed_then_genomicmax[{'chrom': 'chr1', 'start_index': 0, 'end_inde...
\n", - "
" - ], "text/plain": [ - " plot_family value_mode source_format \\\n", - "0 read_cluster_region_association_heatmap fraction legacy_wide \n", - "\n", - " region_order cluster_order \\\n", - "0 [chr1:9168068-9168218:+, chr1:9168135-9168218:... [0, 1] \n", - "\n", - " top_n_regions_per_cluster has_top_regions_table region_sort \\\n", - "0 8 True source_bed_then_genomic \n", - "\n", - " association_strength_aggregate \\\n", - "0 max \n", - "\n", - " chromosome_blocks \n", - "0 [{'chrom': 'chr1', 'start_index': 0, 'end_inde... " + "Indexing chr2.: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Region axis preview (sorted)\n" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cce5d02fbe1b4421b690794174581903", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Indexing chr20.: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { "data": { - "application/vnd.microsoft.datawrangler.viewer.v0+json": { - "columns": [ - { - "name": "index", - "rawType": "int64", - "type": "integer" - }, - { - "name": "region_id", - "rawType": "str", - "type": "string" - }, - { - "name": "chrom", - "rawType": "str", - "type": "string" - }, - { - "name": "start", - "rawType": "int64", - "type": "integer" - }, - { - "name": "end", - "rawType": "int64", - "type": "integer" - }, - { - "name": "source_label", - "rawType": "str", - "type": "string" - } - ], - "ref": "b53eba3f-e11d-43e3-a34a-48da3b07a78f", - "rows": [ - [ - "0", - "chr1:9169918-9170236:+", - "chr1", - "9169918", - "9170236", - "on_target" - ], - [ - "1", - "chr1:9169985-9170303:+", - "chr1", - "9169985", - "9170303", - "on_target" - ], - [ - "2", - "chr1:9169986-9170302:-", - "chr1", - "9169986", - "9170302", - "on_target" - ], - [ - "3", - "chr1:114358436-114358754:+", - "chr1", - "114358436", - "114358754", - "on_target" - ], - [ - "4", - "chr1:114358437-114358753:-", - "chr1", - "114358437", - "114358753", - "on_target" - ] - ], - "shape": { - "columns": 5, - "rows": 5 - } + "application/vnd.jupyter.widget-view+json": { + "model_id": "05c9857c65814f0785c1656a90311ecf", + "version_major": 2, + "version_minor": 0 }, - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
region_idchromstartendsource_label
0chr1:9169918-9170236:+chr191699189170236on_target
1chr1:9169985-9170303:+chr191699859170303on_target
2chr1:9169986-9170302:-chr191699869170302on_target
3chr1:114358436-114358754:+chr1114358436114358754on_target
4chr1:114358437-114358753:-chr1114358437114358753on_target
\n", - "
" - ], "text/plain": [ - " region_id chrom start end source_label\n", - "0 chr1:9169918-9170236:+ chr1 9169918 9170236 on_target\n", - "1 chr1:9169985-9170303:+ chr1 9169985 9170303 on_target\n", - "2 chr1:9169986-9170302:- chr1 9169986 9170302 on_target\n", - "3 chr1:114358436-114358754:+ chr1 114358436 114358754 on_target\n", - "4 chr1:114358437-114358753:- chr1 114358437 114358753 on_target" + "Indexing chr21.: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Source label counts\n" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a1c7b00d82aa44d0a375a27e1b3d2398", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Indexing chr3.: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { "data": { - "application/vnd.microsoft.datawrangler.viewer.v0+json": { - "columns": [ - { - "name": "source_label", - "rawType": "str", - "type": "string" - }, - { - "name": "n_regions", - "rawType": "int64", - "type": "integer" - } - ], - "ref": "51c5e854-8771-4e07-9536-78c8fb2aab7a", - "rows": [ - [ - "off_target", - "200" - ], - [ - "on_target", - "100" - ] - ], - "shape": { - "columns": 1, - "rows": 2 - } + "application/vnd.jupyter.widget-view+json": { + "model_id": "a6101dc20a0847f397711efc08f78550", + "version_major": 2, + "version_minor": 0 }, "text/plain": [ - "source_label\n", - "off_target 200\n", - "on_target 100\n", - "Name: n_regions, dtype: int64" + "Indexing chr5.: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" - } - ], - "source": [ - "from dimelo import plotting, plotting_matplotlib\n", - "import pandas as pd\n", - "\n", - "region_sort_mode = \"genomic\" # initial sort before source-label refinement\n", - "association_strength_aggregate = \"max\" # used when region_sort_mode=\"association_strength\"\n", - "top_regions_per_cluster = 8\n", - "\n", - "association_summary_A = cluster.summarize_read_clusters_by_region(\n", - " metadata=rw_multi.metadata,\n", - " labels=clust_multi.labels_size_ordered,\n", - " include_strand=True,\n", - ")\n", - "association_payload_A = plotting.prepare_read_cluster_region_association_data(\n", - " association_summary_A,\n", - " value_mode=\"fraction\",\n", - " top_n_regions_per_cluster=top_regions_per_cluster,\n", - " region_sort=region_sort_mode,\n", - " association_strength_aggregate=association_strength_aggregate,\n", - ")\n", - "\n", - "axis_table = association_payload_A[\"region_axis_table\"].copy()\n", - "\n", - "# Primary source labeling from read metadata (most frequent source per region_id).\n", - "meta_df = pd.DataFrame(rw_multi.metadata).copy()\n", - "if not meta_df.empty and {\"chromosome\", \"region_start\", \"region_end\"}.issubset(meta_df.columns):\n", - " if \"region_strand\" not in meta_df.columns:\n", - " meta_df[\"region_strand\"] = \".\"\n", - " meta_df[\"region_id\"] = meta_df.apply(\n", - " lambda row: f\"{row['chromosome']}:{int(row['region_start'])}-{int(row['region_end'])}:{row.get('region_strand', '.')}\",\n", - " axis=1,\n", - " )\n", - " if \"source_label\" not in meta_df.columns:\n", - " meta_df[\"source_label\"] = \"unknown\"\n", - " source_by_region = (\n", - " meta_df.groupby([\"region_id\", \"source_label\"], dropna=False)\n", - " .size()\n", - " .reset_index(name=\"n\")\n", - " .sort_values([\"region_id\", \"n\"], ascending=[True, False])\n", - " .drop_duplicates(subset=[\"region_id\"], keep=\"first\")\n", - " .loc[:, [\"region_id\", \"source_label\"]]\n", - " )\n", - " axis_table = axis_table.merge(source_by_region, on=\"region_id\", how=\"left\")\n", - "\n", - "if \"source_label\" not in axis_table.columns:\n", - " axis_table[\"source_label\"] = \"unknown\"\n", - "axis_table[\"source_label\"] = axis_table[\"source_label\"].fillna(\"unknown\")\n", - "\n", - "# Optional fallback from region overlap for unresolved labels.\n", - "if (\n", - " {\"chrom\", \"start\", \"end\"}.issubset(axis_table.columns)\n", - " and \"ctcf_target_regions\" in globals()\n", - " and \"ctcf_off_target_regions\" in globals()\n", - " and \"_label_regions_from_targets\" in globals()\n", - "):\n", - " unresolved = axis_table[\"source_label\"].isin([\"unknown\", \"unlabeled\"])\n", - " if unresolved.any():\n", - " region_info = [\n", - " (str(row.chrom), int(row.start), int(row.end), str(getattr(row, \"strand\", \".\")))\n", - " for row in axis_table.loc[unresolved].itertuples(index=False)\n", - " ]\n", - " inferred = _label_regions_from_targets(\n", - " region_info,\n", - " on_bed=ctcf_target_regions,\n", - " off_bed=ctcf_off_target_regions,\n", - " mode=\"overlap_any\",\n", - " min_overlap_bp=1,\n", - " )\n", - " axis_table.loc[unresolved, \"source_label\"] = inferred\n", - "\n", - "source_priority = {\"on_target\": 0, \"off_target\": 1, \"unlabeled\": 2, \"unknown\": 3}\n", - "axis_table[\"_source_rank\"] = (\n", - " axis_table[\"source_label\"].map(source_priority).fillna(99).astype(int)\n", - ")\n", - "\n", - "# Final ordering for this tutorial: source bed first, then genomic coordinates.\n", - "axis_sorted = axis_table.sort_values(\n", - " [\"_source_rank\", \"chrom\", \"start\", \"end\"],\n", - " ascending=[True, True, True, True],\n", - ").drop(columns=[\"_source_rank\"]).reset_index(drop=True)\n", - "region_order = axis_sorted[\"region_id\"].tolist()\n", - "\n", - "matrix_table = association_payload_A[\"matrix_table\"].copy()\n", - "matrix_sorted = (\n", - " matrix_table.set_index(\"region_id\")\n", - " .loc[region_order]\n", - " .reset_index()\n", - ")\n", - "\n", - "association_payload_A[\"region_axis_table\"] = axis_sorted\n", - "association_payload_A[\"matrix_table\"] = matrix_sorted\n", - "association_payload_A[\"metadata\"] = {\n", - " **association_payload_A.get(\"metadata\", {}),\n", - " \"region_sort\": \"source_bed_then_genomic\",\n", - "}\n", - "\n", - "print(\"Association payload metadata\")\n", - "display(pd.DataFrame([association_payload_A[\"metadata\"]]))\n", - "print(\"Region axis preview (sorted)\")\n", - "display(axis_sorted[[\"region_id\", \"chrom\", \"start\", \"end\", \"source_label\"]].head())\n", - "print(\"Source label counts\")\n", - "display(axis_sorted[\"source_label\"].value_counts(dropna=False).rename(\"n_regions\"))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Top regions per cluster\n" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ + }, { "data": { - "application/vnd.microsoft.datawrangler.viewer.v0+json": { - "columns": [ - { - "name": "index", - "rawType": "int64", - "type": "integer" - }, - { - "name": "region_id", - "rawType": "str", - "type": "string" - }, - { - "name": "chrom", - "rawType": "str", - "type": "string" - }, - { - "name": "start", - "rawType": "int64", - "type": "integer" - }, - { - "name": "end", - "rawType": "int64", - "type": "integer" - }, - { - "name": "strand", - "rawType": "str", - "type": "string" - }, - { - "name": "cluster", - "rawType": "object", - "type": "unknown" - }, - { - "name": "count", - "rawType": "int64", - "type": "integer" - }, - { - "name": "fraction", - "rawType": "float64", - "type": "float" - }, - { - "name": "total_reads", - "rawType": "int64", - "type": "integer" - }, - { - "name": "value", - "rawType": "float64", - "type": "float" - }, - { - "name": "rank", - "rawType": "int64", - "type": "integer" - } - ], - "ref": "32df251f-c65f-462c-9d39-e02425cdc7e0", - "rows": [ - [ - "0", - "chr12:57871837-57871987:-", - "chr12", - "57871837", - "57871987", - "-", - "0", - "24", - "1.0", - "24", - "1.0", - "1" - ], - [ - "1", - "chr12:57871885-57871987:-", - "chr12", - "57871885", - "57871987", - "-", - "0", - "24", - "1.0", - "24", - "1.0", - "2" - ], - [ - "2", - "chr12:57875753-57875855:-", - "chr12", - "57875753", - "57875855", - "-", - "0", - "25", - "1.0", - "25", - "1.0", - "3" - ], - [ - "3", - "chr12:57875753-57875903:-", - "chr12", - "57875753", - "57875903", - "-", - "0", - "25", - "1.0", - "25", - "1.0", - "4" - ], - [ - "4", - "chr14:17377273-17377423:+", - "chr14", - "17377273", - "17377423", - "+", - "0", - "23", - "1.0", - "23", - "1.0", - "5" - ], - [ - "5", - "chr14:17377341-17377423:+", - "chr14", - "17377341", - "17377423", - "+", - "0", - "23", - "1.0", - "23", - "1.0", - "6" - ], - [ - "6", - "chr14:17381209-17381291:+", - "chr14", - "17381209", - "17381291", - "+", - "0", - "19", - "1.0", - "19", - "1.0", - "7" - ], - [ - "7", - "chr15:38664850-38665000:-", - "chr15", - "38664850", - "38665000", - "-", - "0", - "22", - "1.0", - "22", - "1.0", - "8" - ], - [ - "8", - "chr9:145236510-145236828:+", - "chr9", - "145236510", - "145236828", - "+", - "1", - "19", - "0.9047619047619048", - "21", - "0.9047619047619048", - "1" - ], - [ - "9", - "chr9:145236511-145236827:-", - "chr9", - "145236511", - "145236827", - "-", - "1", - "19", - "0.9047619047619048", - "21", - "0.9047619047619048", - "2" - ] - ], - "shape": { - "columns": 11, - "rows": 10 - } + "application/vnd.jupyter.widget-view+json": { + "model_id": "cbf5ef3837874a3b99f7c47f76b746bf", + "version_major": 2, + "version_minor": 0 }, - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
region_idchromstartendstrandclustercountfractiontotal_readsvaluerank
0chr12:57871837-57871987:-chr125787183757871987-0241.000000241.0000001
1chr12:57871885-57871987:-chr125787188557871987-0241.000000241.0000002
2chr12:57875753-57875855:-chr125787575357875855-0251.000000251.0000003
3chr12:57875753-57875903:-chr125787575357875903-0251.000000251.0000004
4chr14:17377273-17377423:+chr141737727317377423+0231.000000231.0000005
5chr14:17377341-17377423:+chr141737734117377423+0231.000000231.0000006
6chr14:17381209-17381291:+chr141738120917381291+0191.000000191.0000007
7chr15:38664850-38665000:-chr153866485038665000-0221.000000221.0000008
8chr9:145236510-145236828:+chr9145236510145236828+1190.904762210.9047621
9chr9:145236511-145236827:-chr9145236511145236827-1190.904762210.9047622
\n", - "
" - ], "text/plain": [ - " region_id chrom start end strand cluster \\\n", - "0 chr12:57871837-57871987:- chr12 57871837 57871987 - 0 \n", - "1 chr12:57871885-57871987:- chr12 57871885 57871987 - 0 \n", - "2 chr12:57875753-57875855:- chr12 57875753 57875855 - 0 \n", - "3 chr12:57875753-57875903:- chr12 57875753 57875903 - 0 \n", - "4 chr14:17377273-17377423:+ chr14 17377273 17377423 + 0 \n", - "5 chr14:17377341-17377423:+ chr14 17377341 17377423 + 0 \n", - "6 chr14:17381209-17381291:+ chr14 17381209 17381291 + 0 \n", - "7 chr15:38664850-38665000:- chr15 38664850 38665000 - 0 \n", - "8 chr9:145236510-145236828:+ chr9 145236510 145236828 + 1 \n", - "9 chr9:145236511-145236827:- chr9 145236511 145236827 - 1 \n", - "\n", - " count fraction total_reads value rank \n", - "0 24 1.000000 24 1.000000 1 \n", - "1 24 1.000000 24 1.000000 2 \n", - "2 25 1.000000 25 1.000000 3 \n", - "3 25 1.000000 25 1.000000 4 \n", - "4 23 1.000000 23 1.000000 5 \n", - "5 23 1.000000 23 1.000000 6 \n", - "6 19 1.000000 19 1.000000 7 \n", - "7 22 1.000000 22 1.000000 8 \n", - "8 19 0.904762 21 0.904762 1 \n", - "9 19 0.904762 21 0.904762 2 " + "Indexing chr6.: 0it [00:00, ?it/s]" ] }, - "execution_count": 45, "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "association_payload_A[\"top_regions_table\"].head(10)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Karyotype view of top associated regions\n", - "\n", - "This adds a genome-level view under **Top regions per cluster**:\n", - "- each chromosome is vertical and proportional to true chromosome length,\n", - "- coordinate increases downward (0 near the top, chromosome length near the bottom),\n", - "- loci are colored by cluster assignment, and\n", - "- optional haplotype-aware backbone shading is enabled when maternal/paternal naming is detected.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Wrote karyotype BED to artifacts/notebook/association_regions_by_dominant_cluster.bed\n", - "Using chromosome sizes from dimelo/test/output/chm13.draft_v1.0.fasta.fai\n", - "chr9: 9 plotted region(s)\n", - "chr12: 6 plotted region(s)\n", - "chr20: 30 plotted region(s)\n" - ] + "output_type": "display_data" }, { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "e8e3ea883c1749cc89117883d1273fe6", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "
" + "Indexing chr7.: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" - } - ], - "source": [ - "from pathlib import Path\n", - "import pandas as pd\n", - "\n", - "from dimelo import cluster\n", - "\n", - "karyotype_chromosome_order = \"natural\" # \"length_desc\" | \"length_asc\" | \"natural\" | custom list\n", - "karyotype_min_visible_bp = 20_000\n", - "karyotype_detect_haplotype_shading = True\n", - "\n", - "matrix_table = association_payload_A[\"matrix_table\"].copy()\n", - "axis_table = association_payload_A[\"region_axis_table\"].copy()\n", - "cluster_columns = [c for c in matrix_table.columns if c != \"region_id\"]\n", - "\n", - "if matrix_table.empty or axis_table.empty or not cluster_columns:\n", - " print(\"No region-association rows available for karyotype plot.\")\n", - "else:\n", - " dominant_cluster = matrix_table.loc[:, cluster_columns].astype(float).idxmax(axis=1).astype(str)\n", - " dominant_by_region = pd.DataFrame({\n", - " \"region_id\": matrix_table[\"region_id\"].astype(str),\n", - " \"cluster\": dominant_cluster,\n", - " })\n", - "\n", - " karyo_table = axis_table.merge(dominant_by_region, on=\"region_id\", how=\"inner\")\n", - " karyo_table[\"name\"] = karyo_table[\"cluster\"].astype(str)\n", - " karyo_table[\"score\"] = 0\n", - " if \"strand\" not in karyo_table.columns:\n", - " karyo_table[\"strand\"] = \".\"\n", - " karyo_table[\"strand\"] = karyo_table[\"strand\"].fillna(\".\")\n", - "\n", - " artifacts_dir = Path(\"artifacts/notebook\")\n", - " artifacts_dir.mkdir(parents=True, exist_ok=True)\n", - "\n", - " karyotype_bed = artifacts_dir / \"association_regions_by_dominant_cluster.bed\"\n", - " karyo_table.loc[:, [\"chrom\", \"start\", \"end\", \"name\", \"score\", \"strand\"]].to_csv(\n", - " karyotype_bed,\n", - " sep=\"\t\",\n", - " header=False,\n", - " index=False,\n", - " )\n", - "\n", - " chrom_sizes_path = None\n", - " if \"ref_genome_file\" in globals():\n", - " ref_path = Path(str(ref_genome_file))\n", - " candidate = ref_path.with_suffix(ref_path.suffix + \".fai\")\n", - " if candidate.exists():\n", - " chrom_sizes_path = candidate\n", - "\n", - " if chrom_sizes_path is None:\n", - " inferred_sizes = (\n", - " karyo_table.groupby(\"chrom\", as_index=False)[\"end\"]\n", - " .max()\n", - " .rename(columns={\"chrom\": \"Chromosome\", \"end\": \"Length\"})\n", - " )\n", - " inferred_sizes[\"Length\"] = (inferred_sizes[\"Length\"] * 1.05).astype(int)\n", - " chrom_sizes_path = artifacts_dir / \"inferred.chrom.sizes\"\n", - " inferred_sizes.to_csv(chrom_sizes_path, sep=\"\t\", header=False, index=False)\n", - "\n", - " fig = cluster.plot_cluster_karyotype(\n", - " region_bed=karyotype_bed,\n", - " chrom_sizes=chrom_sizes_path,\n", - " chromosome_order=karyotype_chromosome_order,\n", - " invert_position_axis=True,\n", - " detect_haplotype_backbone_shading=karyotype_detect_haplotype_shading,\n", - " min_visible_bp=karyotype_min_visible_bp,\n", - " )\n", - "\n", - " print(f\"Wrote karyotype BED to {karyotype_bed}\")\n", - " print(f\"Using chromosome sizes from {chrom_sizes_path}\")\n", - " for chrom in [\"chr9\", \"chr12\", \"chr20\"]:\n", - " n = int((karyo_table[\"chrom\"].astype(str) == chrom).sum())\n", - " print(f\"{chrom}: {n} plotted region(s)\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Association heatmap\n" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ + }, { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "ea066d6aa0ea45feb7cf22eabb607ef8", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "
" + "Indexing chr8.: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "fig, ax = plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib(\n", - " association_payload_A,\n", - " title=\"Read-cluster association by region (sorted: source bed -> genomic)\",\n", - " region_label_mode=\"chromosome\",\n", - " max_region_labels=24,\n", - " row_annotation_column=\"source_label\",\n", - " row_annotation_title=\"Source bed\",\n", - " row_annotation_palette={\n", - " \"on_target\": \"#D95F02\",\n", - " \"off_target\": \"#1B9E77\",\n", - " \"unlabeled\": \"#7570B3\",\n", - " \"unknown\": \"#999999\",\n", - " },\n", - " group_region_labels=True,\n", - " group_label_columns=[\"source_label\", \"chrom\"],\n", - ")\n", - "plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Export" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For some use cases, such as loading pileup information into a genome browser, it can be desireable to create files with less information content than the full bedmethyls. The `export` module contains functions to do these sorts of exports. " - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "pileup_file: dimelo/test/output/ctcf_demo_pileup_on_target/pileup.sorted.bed.gz\n", - "ref_genome_file: dimelo/test/output/chm13.draft_v1.0.fasta\n", - "bigwig_out_no_ref: dimelo/test/output/ctcf_demo_pileup_on_target/pileup.fractions.no_ref.bigwig\n", - "bigwig_out_with_ref: dimelo/test/output/ctcf_demo_pileup_on_target/pileup.fractions.with_ref.bigwig\n" - ] - } - ], - "source": [ - "from pathlib import Path\n", - "\n", - "pileup_file = Path(pileup_file)\n", - "ref_genome_file = Path(ref_genome_file)\n", - "\n", - "if not pileup_file.exists():\n", - " raise FileNotFoundError(\n", - " f\"Expected pileup file not found: {pileup_file}. Run parsing cells above first.\"\n", - " )\n", - "\n", - "bigwig_out_no_ref = pileup_file.parent / 'pileup.fractions.no_ref.bigwig'\n", - "bigwig_out_with_ref = pileup_file.parent / 'pileup.fractions.with_ref.bigwig'\n", - "\n", - "for p in [bigwig_out_no_ref, bigwig_out_with_ref]:\n", - " p.unlink(missing_ok=True)\n", - "\n", - "print('pileup_file:', pileup_file)\n", - "print('ref_genome_file:', ref_genome_file)\n", - "print('bigwig_out_no_ref:', bigwig_out_no_ref)\n", - "print('bigwig_out_with_ref:', bigwig_out_with_ref)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [ + }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a52c15b37e994fd89cd5040b3b14c6c5", + "model_id": "22e12fe22bd0458289c06573a72baa33", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Step 1: Indexing contigs in pileup.sorted.bed.gz to set up bigwig header for pileup.fractions.no_ref.bigwig: …" + "Indexing chr9.: 0it [00:00, ?it/s]" ] }, "metadata": {}, @@ -4137,12 +2509,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e22eaacdd0044a0a836b21d4916cde7d", + "model_id": "ffc3c5d9bd3b4959a3934a74bc19c684", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Indexing chr1.: 0it [00:00, ?it/s]" + "Indexing chrX.: 0it [00:00, ?it/s]" ] }, "metadata": {}, @@ -4151,12 +2523,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ce8147f44e724889930df0dffcaa6e06", + "model_id": "cbe7f81faafe4a1988f884d5c69a1f3b", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Indexing chr12.: 0it [00:00, ?it/s]" + "Step 2: Writing pileup.sorted.bed.gz contents to pileup.fractions.no_ref.bigwig: 0%| | 0/17 [00:00<\u2026" ] }, "metadata": {}, @@ -4165,12 +2537,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6b8adc997f7342a2853f1fc2d4ae2a6f", + "model_id": "3d13a9476fa749168b8a11df882ce7aa", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Indexing chr14.: 0it [00:00, ?it/s]" + "Writing chr1.: 0%| | 0/24430 [00:00" + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from dimelo import plot_enrichment_profile\n", + "plot_enrichment_profile.by_modification(\n", + " mod_file_name=pileup_file_coded,\n", + " regions=ctcf_target_regions,\n", + " window_size=1000,\n", + " motifs=['A,0,a','CG,0,m'], # We know from above that these mod codes aren't present in our file!\n", + " single_strand=False, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", + " regions_5to3prime=False, # if set to True, regions on the reverse (-) strand will be flipped so everything is 5 prime to 3 prime\n", + " smooth_window=50,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `modkit` command below will make the bam file work for the to-spec mod codes m and a. However, you must use this command with caution: `modkit` can and will adjust any mod code to any other mod code; you need to verify yourself that they are actually equivalent and thus that the operation is in fact valid." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "modkit required: 0.6.1\n", + "modkit active : 0.6.1\n", + "$ modkit adjust-mods dimelo/test/output/ctcf_demo.updated.bam dimelo/test/output/ctcf_demo.recoded.bam --convert Y a --convert Z m\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[0;32m>\u001b[0m Converting Z to m\n", + "\u001b[0;32m>\u001b[0m Converting Y to a\n", + "[modkit-core/src/modbam_util/subcommands.rs:774:9] &self.cpg = false\n", + "\u001b[0;32m>\u001b[0m done, 1024 records processed\n" + ] + } + ], + "source": [ + "run_modkit_checked([\n", + " \"adjust-mods\",\n", + " \"dimelo/test/output/ctcf_demo.updated.bam\",\n", + " \"dimelo/test/output/ctcf_demo.recoded.bam\",\n", + " \"--convert\",\n", + " \"Y\",\n", + " \"a\",\n", + " \"--convert\",\n", + " \"Z\",\n", + " \"m\",\n", + "])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "''" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ctcf_bam_file_recoded = output_dir / 'ctcf_demo.recoded.bam'\n", + "pysam.index(str(ctcf_bam_file_recoded))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "WARNING: no modified appropriately-coded values found for [] in the first 100 reads. \n", + "Do you expect this file to contain these modifications? parse_bam is looking for ['A,0,a', 'CG,0,m'] but for [] found only found [].\n", + "\n", + "Consider passing only the motifs and mod codes (e.g. m,h,a) that you expect to be present in your file. \n", + "You can use modkit adjust-mods --convert [OPTIONS] to update or consolidate mod codes.\n", + "See https://github.com/nanoporetech/modkit/blob/master/book/src/advanced_usage.md\n", + " \n", + "No specified number of cores requested. 10 available on machine, allocating all.\n", + "Detected multiple motif contexts with modkit 0.6.x; running per-motif pileups and merging outputs to avoid mixed-motif empty output behavior.\n", + "Modification threshold of 128.0 assumed to be for range 0-255. 128.0/255=0.5019607843137255 will be sent to modkit.\n" + ] + } + ], + "source": [ + "pileup_file_recoded, pileup_regions = ensure_pileup_output(\n", + " input_file=ctcf_bam_file_recoded,\n", + " output_name='ctcf_demo_pileup_on_target_mod_code_specified_adjusted',\n", + " ref_genome=ref_genome_file,\n", + " output_directory=output_dir,\n", + " regions=[ctcf_target_regions,ctcf_off_target_regions],\n", + " motifs=['A,0,a','CG,0,m'],\n", + " thresh=128,\n", + " window_size=1000,\n", + " # cores=1,\n", + " # cleanup=False,\n", + " # log=True,\n", + " quiet=PARSE_QUIET,\n", + " modkit_executable=MODKIT_BINARY,\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a41b60014d6443a69d635f36af2fc4e5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading data: 0%| | 0/50 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from dimelo import plot_enrichment_profile\n", + "plot_enrichment_profile.by_modification(\n", + " mod_file_name=pileup_file_recoded,\n", + " regions=ctcf_target_regions,\n", + " window_size=1000,\n", + " motifs=['A,0,a','CG,0,m'],\n", + " single_strand=False, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", + " regions_5to3prime=False, # if set to True, regions on the reverse (-) strand will be flipped so everything is 5 prime to 3 prime\n", + " smooth_window=50,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Advanced Use Cases" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Clustering and Classification\n", + "\n", + "This section shows how to work with processed files (`pileup.sorted.bed.gz` and `extract.h5`) to discover structure in your data.\n", + "\n", + "The key idea is to turn each read or region into a feature vector that makes the biological pattern you care about more salient for the current window, motif set, and comparison. A feature is not a result by itself; it is a lens. Good lenses emphasize structure that is plausible for the question (for example center enrichment, flank depletion, periodicity, or motif-specific density) while minimizing nuisance variation such as read depth, missing motif coverage, or arbitrary row order.\n", + "\n", + "- **Read clustering**: build fixed-length windows per read, compute features (PCA, autocorrelation, density, summary stats), and cluster molecules. Supports single motifs or combined multi-motif windows.\n", + "- **Read classification**: train a binary classifier on read features to quantify separability between two samples; includes train/test metrics, confusion matrices, and per-read profile plots.\n", + "- **Region clustering**: cluster loci on their pileup profiles (single motif or concatenated multi-motif features), and visualize mean profiles plus genome distribution.\n", + "- **Region classification**: treat each locus feature vector as a sample for downstream classifiers.\n", + "\n", + "Optional clustering deps: `scikit-learn`, `scipy`, `hdbscan`, `umap-learn`, `pyranges`, `xgboost` (install via `pip install dimelo[clustering]`).\n", + "Make sure earlier parsing steps have produced the processed files before running these examples." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Read analysis and feature-engineering tips\n", + "\n", + "- Use `span_full_window=True` and `orientation_aware=True` when extracting to keep windows comparable across reads.\n", + "- For multi-motif windows, set `require_all_motifs=True` to drop reads missing motifs instead of zero-filling.\n", + "- `read_window_feature_matrix` currently computes features from the row matrix it receives. For multi-motif windows, that row is a concatenation of motif windows, so PCA, autocorrelation, densities, and summary statistics are computed over the combined representation unless you explicitly build/slice motif-specific matrices.\n", + "- Treat feature choices as part of the analysis design. Decide whether the question is about whole-read signal, a centered window, motif-specific signal, cross-motif relationships, or long-range structure before interpreting clusters.\n", + "- Drop low-information reads by setting `require_nonzero_valid=True` and `min_valid_fraction` in `read_window_feature_matrix`.\n", + "- Inspect feature behavior before trusting a clustering/classifier: check matrix shape, feature names, missing/zero-heavy rows, feature variance, and whether known labels or regions dominate the result.\n", + "- Validate rigorously with held-out labels, shuffled labels, sensitivity to window width/motif choice, and visual inspection of representative reads. A clean cluster is only useful if it is stable and biologically interpretable under reasonable parameter changes.\n", + "- Inspect cluster/classifier QC: profile plots for clusters, confusion matrices and per-read profile plots for classifiers.\n", + "- Check locus homogeneity with `summarize_read_clusters_by_region` (dominant_fraction/entropy) to see if clusters are locus-driven.\n", + "- Beware class imbalance in classifiers; look at both accuracy and ROC-AUC, and at confusion matrices to spot overfitting." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Read Clustering" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Single motif (merged on-target vs off-target reads)\n", + "\n", + "This example uses the notebook test data directly: extract read windows separately from `ctcf_target_regions`\n", + "and `ctcf_off_target_regions`, merge them, and run unsupervised clustering to see whether clusters enrich for one group.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Motif semantics*: extract output stores one row per motif per read. For multi-motif analyses, use\n", + "`build_multimotif_read_windows` and either:\n", + "- `motif_profile_mode=\"single_axis\"` to overlay motif profiles on a shared y-axis, or\n", + "- `motif_profile_mode=\"separate_axes\"` to keep each motif on its own y-scale.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Sampling for speed**: Use `cluster.sample_rows` to downsample reads or loci before clustering/classification. Example:\n", + "\n", + "```python\n", + "sampled_feat, sampled_labels, idx = cluster.sample_rows(feature_matrix, labels, frac=0.2, stratify=True)\n", + "```\n", + "\n", + "Run heavy algorithms (e.g., spectral/DBSCAN/UMAP) on the sample, then apply insights back to the full set." + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reads used: on_target=2173, off_target=4030, total=6203\n", + "Feature matrix: 6203 reads x 31 features\n", + "K-means input: feature matrix scaled inside read_window_feature_matrix(scale_features=True, family_weighting='equal_family')\n", + "Cluster purity vs on/off labels: 0.803\n", + "Feature families\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "family", + "rawType": "str", + "type": "string" + }, + { + "name": "n_features", + "rawType": "int64", + "type": "integer" + } + ], + "ref": "ec9290ff-b978-49c7-851d-1562312ca1fa", + "rows": [ + [ + "1", + "density", + "13" + ], + [ + "3", + "summary", + "7" + ], + [ + "2", + "pca", + "6" + ], + [ + "0", + "autocorr", + "5" + ] + ], + "shape": { + "columns": 2, + "rows": 4 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
familyn_features
1density13
3summary7
2pca6
0autocorr5
\n", + "
" + ], + "text/plain": [ + " family n_features\n", + "1 density 13\n", + "3 summary 7\n", + "2 pca 6\n", + "0 autocorr 5" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Most variable default features\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "feature_name", + "rawType": "str", + "type": "string" + }, + { + "name": "variance", + "rawType": "float64", + "type": "float" + }, + { + "name": "missing_fraction", + "rawType": "float64", + "type": "float" + } + ], + "ref": "9d860709-80e3-4f7e-b0f0-57b002a32e41", + "rows": [ + [ + "0", + "density_minus240", + "1.0000000000002067", + "0.0" + ], + [ + "1", + "density_minus150", + "1.0000000000001972", + "0.0" + ], + [ + "2", + "density_pm300", + "1.000000000000195", + "0.0" + ], + [ + "3", + "density_minus320", + "1.000000000000117", + "0.0" + ], + [ + "4", + "density_pm500", + "1.0000000000001081", + "0.0" + ], + [ + "5", + "pca_2", + "1.0000000000000788", + "0.0" + ], + [ + "6", + "global_mod_fraction", + "1.0000000000000608", + "0.0" + ], + [ + "7", + "density_minus800", + "1.0000000000000524", + "0.0" + ] + ], + "shape": { + "columns": 3, + "rows": 8 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
feature_namevariancemissing_fraction
0density_minus2401.00.0
1density_minus1501.00.0
2density_pm3001.00.0
3density_minus3201.00.0
4density_pm5001.00.0
5pca_21.00.0
6global_mod_fraction1.00.0
7density_minus8001.00.0
\n", + "
" + ], + "text/plain": [ + " feature_name variance missing_fraction\n", + "0 density_minus240 1.0 0.0\n", + "1 density_minus150 1.0 0.0\n", + "2 density_pm300 1.0 0.0\n", + "3 density_minus320 1.0 0.0\n", + "4 density_pm500 1.0 0.0\n", + "5 pca_2 1.0 0.0\n", + "6 global_mod_fraction 1.0 0.0\n", + "7 density_minus800 1.0 0.0" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Feature scaling preview\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "feature_name", + "rawType": "str", + "type": "string" + }, + { + "name": "scaling_method", + "rawType": "str", + "type": "string" + }, + { + "name": "family", + "rawType": "str", + "type": "string" + }, + { + "name": "family_weight", + "rawType": "float64", + "type": "float" + }, + { + "name": "scaled", + "rawType": "bool", + "type": "boolean" + }, + { + "name": "center", + "rawType": "float64", + "type": "float" + }, + { + "name": "scale", + "rawType": "float64", + "type": "float" + }, + { + "name": "raw_mean", + "rawType": "float64", + "type": "float" + }, + { + "name": "raw_std", + "rawType": "float64", + "type": "float" + }, + { + "name": "scaled_mean", + "rawType": "float64", + "type": "float" + }, + { + "name": "scaled_std", + "rawType": "float64", + "type": "float" + } + ], + "ref": "ed14f839-e17c-4773-a96d-bfb116989d36", + "rows": [ + [ + "0", + "pca_0", + "standard", + "pca", + "1.0", + "True", + "2.7491577717624383e-17", + "0.25804970135868555", + "-1.806711563812547e-15", + "0.2580497013586851", + "1.492091957002131e-14", + "1.0000000000000024" + ], + [ + "1", + "pca_1", + "standard", + "pca", + "1.0", + "True", + "1.1368912868642584e-16", + "0.18175693772912851", + "1.674037518490596e-16", + "0.1817569377291284", + "3.191510859842573e-16", + "0.9999999999999521" + ], + [ + "2", + "pca_2", + "standard", + "pca", + "1.0", + "True", + "7.588820932469231e-17", + "0.18011870418727277", + "6.48992968202537e-17", + "0.18011870418728018", + "-1.3273724820854936e-16", + "1.0000000000000393" + ], + [ + "3", + "pca_3", + "standard", + "pca", + "1.0", + "True", + "-4.975689196288788e-17", + "0.1778403661994923", + "-6.90645348423718e-17", + "0.17784036619948876", + "8.182592475947218e-17", + "0.9999999999999918" + ], + [ + "4", + "pca_4", + "standard", + "pca", + "1.0", + "True", + "1.4461715361875326e-16", + "0.17127270439983974", + "7.534678990675082e-17", + "0.17127270439984799", + "-6.260419306035583e-16", + "0.9999999999999944" + ], + [ + "5", + "pca_5", + "standard", + "pca", + "1.0", + "True", + "4.3886294637770176e-17", + "0.1706551436413648", + "5.1269286700608755e-17", + "0.17065514364135828", + "-2.866927681516324e-16", + "0.9999999999999446" + ], + [ + "6", + "autocorr_20", + "standard", + "autocorr", + "1.0", + "True", + "0.006838371543611701", + "0.03218155896626967", + "0.00683837154361214", + "0.03218155896626913", + "6.913702240080694e-16", + "1.000000000000013" + ], + [ + "7", + "autocorr_75", + "standard", + "autocorr", + "1.0", + "True", + "0.0010282527368907757", + "0.01892136162649048", + "0.0010282527368908104", + "0.01892136162648973", + "-1.265489584976974e-15", + "1.0000000000000135" + ] + ], + "shape": { + "columns": 11, + "rows": 8 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
feature_namescaling_methodfamilyfamily_weightscaledcenterscaleraw_meanraw_stdscaled_meanscaled_std
0pca_0standardpca1.0True2.749158e-170.258050-1.806712e-150.2580501.492092e-141.0
1pca_1standardpca1.0True1.136891e-160.1817571.674038e-160.1817573.191511e-161.0
2pca_2standardpca1.0True7.588821e-170.1801196.489930e-170.180119-1.327372e-161.0
3pca_3standardpca1.0True-4.975689e-170.177840-6.906453e-170.1778408.182592e-171.0
4pca_4standardpca1.0True1.446172e-160.1712737.534679e-170.171273-6.260419e-161.0
5pca_5standardpca1.0True4.388629e-170.1706555.126929e-170.170655-2.866928e-161.0
6autocorr_20standardautocorr1.0True6.838372e-030.0321826.838372e-030.0321826.913702e-161.0
7autocorr_75standardautocorr1.0True1.028253e-030.0189211.028253e-030.018921-1.265490e-151.0
\n", + "
" + ], + "text/plain": [ + " feature_name scaling_method family family_weight scaled center \\\n", + "0 pca_0 standard pca 1.0 True 2.749158e-17 \n", + "1 pca_1 standard pca 1.0 True 1.136891e-16 \n", + "2 pca_2 standard pca 1.0 True 7.588821e-17 \n", + "3 pca_3 standard pca 1.0 True -4.975689e-17 \n", + "4 pca_4 standard pca 1.0 True 1.446172e-16 \n", + "5 pca_5 standard pca 1.0 True 4.388629e-17 \n", + "6 autocorr_20 standard autocorr 1.0 True 6.838372e-03 \n", + "7 autocorr_75 standard autocorr 1.0 True 1.028253e-03 \n", + "\n", + " scale raw_mean raw_std scaled_mean scaled_std \n", + "0 0.258050 -1.806712e-15 0.258050 1.492092e-14 1.0 \n", + "1 0.181757 1.674038e-16 0.181757 3.191511e-16 1.0 \n", + "2 0.180119 6.489930e-17 0.180119 -1.327372e-16 1.0 \n", + "3 0.177840 -6.906453e-17 0.177840 8.182592e-17 1.0 \n", + "4 0.171273 7.534679e-17 0.171273 -6.260419e-16 1.0 \n", + "5 0.170655 5.126929e-17 0.170655 -2.866928e-16 1.0 \n", + "6 0.032182 6.838372e-03 0.032182 6.913702e-16 1.0 \n", + "7 0.018921 1.028253e-03 0.018921 -1.265490e-15 1.0 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Counts by cluster and region set:\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "cluster", + "rawType": "int64", + "type": "integer" + }, + { + "name": "off_target", + "rawType": "int64", + "type": "integer" + }, + { + "name": "on_target", + "rawType": "int64", + "type": "integer" + } + ], + "ref": "32009461-a166-45a7-8f70-c4f05c296546", + "rows": [ + [ + "0", + "3758", + "952" + ], + [ + "1", + "272", + "1221" + ] + ], + "shape": { + "columns": 2, + "rows": 2 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
region_setoff_targeton_target
cluster
03758952
12721221
\n", + "
" + ], + "text/plain": [ + "region_set off_target on_target\n", + "cluster \n", + "0 3758 952\n", + "1 272 1221" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Within-cluster fractions:\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "cluster", + "rawType": "int64", + "type": "integer" + }, + { + "name": "off_target", + "rawType": "float64", + "type": "float" + }, + { + "name": "on_target", + "rawType": "float64", + "type": "float" + } + ], + "ref": "fb52a39f-8fd8-45b7-a9dc-bfe0f5a7762d", + "rows": [ + [ + "0", + "0.798", + "0.202" + ], + [ + "1", + "0.182", + "0.818" + ] + ], + "shape": { + "columns": 2, + "rows": 2 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
region_setoff_targeton_target
cluster
00.7980.202
10.1820.818
\n", + "
" + ], + "text/plain": [ + "region_set off_target on_target\n", + "cluster \n", + "0 0.798 0.202\n", + "1 0.182 0.818" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from dimelo import cluster\n", + "import importlib\n", + "import inspect\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "# # If this notebook kernel already imported dimelo before local edits, reload the module.\n", + "# cluster = importlib.reload(cluster)\n", + "# required_kwargs = {\"return_feature_table\", \"scale_features\", \"return_scale_table\"}\n", + "# observed_kwargs = set(inspect.signature(cluster.read_window_feature_matrix).parameters)\n", + "# if not required_kwargs.issubset(observed_kwargs):\n", + "# raise RuntimeError(\n", + "# \"This notebook is using an older dimelo.cluster module. \"\n", + "# f\"Imported from: {cluster.__file__}. \"\n", + "# \"Restart the kernel or install this repo in editable mode with `python -m pip install -e .`.\"\n", + "# )\n", + "\n", + "# Fixed window sizes for tutorial reproducibility.\n", + "shared_window = 1000\n", + "region_window_size = 1000\n", + "\n", + "# Exposed plotting handles for tuning.\n", + "plot_point_size = 1.2\n", + "plot_point_alpha = 0.015\n", + "profile_smoothing = \"gaussian\" # None | \"gaussian\" | \"boxcar\"\n", + "show_unsmoothed_overlay = True\n", + "\n", + "rw_on = cluster.extract_read_windows(\n", + " hdf5_file=extract_file,\n", + " motifs=[\"A,0\"],\n", + " regions=ctcf_target_regions,\n", + " config=cluster.ReadWindowExtractionConfig(\n", + " window_size=shared_window,\n", + " orientation_aware=True,\n", + " ),\n", + " span_full_window=False,\n", + ")\n", + "\n", + "rw_off = cluster.extract_read_windows(\n", + " hdf5_file=extract_file,\n", + " motifs=[\"A,0\"],\n", + " regions=ctcf_off_target_regions,\n", + " config=cluster.ReadWindowExtractionConfig(\n", + " window_size=shared_window,\n", + " orientation_aware=True,\n", + " ),\n", + " span_full_window=False,\n", + ")\n", + "\n", + "rw_single = cluster.merge_read_window_results(\n", + " [rw_on, rw_off],\n", + " source_labels=[\"on_target\", \"off_target\"],\n", + " align=\"error\",\n", + ")\n", + "\n", + "feat_single_scaled, feat_single_names, feat_single_table, feat_single_scale_table = cluster.read_window_feature_matrix(\n", + " rw_single,\n", + " n_pca=6,\n", + " use_peak_features=False,\n", + " scale_features=True,\n", + " scaling_method=\"standard\",\n", + " family_weighting=None,\n", + " return_feature_table=True,\n", + " return_scale_table=True,\n", + ")\n", + "feat_single = feat_single_scaled\n", + "\n", + "clust_single = cluster.cluster_read_windows(\n", + " feat_single_scaled,\n", + " method=\"kmeans\",\n", + " n_clusters=2,\n", + " random_state=42,\n", + ")\n", + "\n", + "cluster.plot_cluster_profiles(\n", + " data_matrix=rw_single.data_matrix,\n", + " labels=clust_single.labels_size_ordered,\n", + " val_matrix=rw_single.val_matrix,\n", + " metadata=rw_single.metadata,\n", + " window_size=shared_window,\n", + " point_size=plot_point_size,\n", + " point_alpha=plot_point_alpha,\n", + " smoothing=profile_smoothing,\n", + " show_unsmoothed_overlay=show_unsmoothed_overlay,\n", + ")\n", + "\n", + "sample_labels_single = np.array([m.get(\"source_label\", \"unknown\") for m in rw_single.metadata])\n", + "feature_summary_single = cluster.summarize_feature_matrix(\n", + " feat_single,\n", + " feat_single_names,\n", + " feature_table=feat_single_table,\n", + " labels=sample_labels_single,\n", + ")\n", + "cluster_vs_group = pd.crosstab(\n", + " clust_single.labels_size_ordered,\n", + " sample_labels_single,\n", + " rownames=[\"cluster\"],\n", + " colnames=[\"region_set\"],\n", + ")\n", + "cluster_vs_group_frac = cluster_vs_group.div(cluster_vs_group.sum(axis=1), axis=0)\n", + "purity = cluster_vs_group.max(axis=1).sum() / cluster_vs_group.values.sum()\n", + "\n", + "print(f\"Reads used: on_target={rw_on.data_matrix.shape[0]}, off_target={rw_off.data_matrix.shape[0]}, total={rw_single.data_matrix.shape[0]}\")\n", + "print(f\"Feature matrix: {feature_summary_single['n_reads']} reads x {feature_summary_single['n_features']} features\")\n", + "print(\"K-means input: feature matrix scaled inside read_window_feature_matrix(scale_features=True, family_weighting='equal_family')\")\n", + "print(f\"Cluster purity vs on/off labels: {purity:.3f}\")\n", + "print(\"Feature families\")\n", + "display(feature_summary_single[\"feature_counts_by_family\"])\n", + "print(\"Most variable default features\")\n", + "display(feature_summary_single[\"top_variable_features\"].head(8))\n", + "print(\"Feature scaling preview\")\n", + "display(feat_single_scale_table.head(8))\n", + "print(\"Counts by cluster and region set:\")\n", + "display(cluster_vs_group)\n", + "print(\"Within-cluster fractions:\")\n", + "display(cluster_vs_group_frac.round(3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Multiple motif (merged on-target vs off-target reads)\n", + "\n", + "This example plots both motifs with motif-matched colors. You can switch between:\n", + "- `motif_profile_mode=\"single_axis\"` (shared y-axis) and\n", + "- `motif_profile_mode=\"separate_axes\"` (one y-axis per motif).\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Multi-motif reads used: on_target=2173, off_target=4030, total=6203\n", + "Default feature matrix: 6203 reads x 31 features\n", + "Rich feature matrix: 6203 reads x 108 features\n", + "K-means input: default feature matrix scaled inside read_window_feature_matrix(scale_features=True, family_weighting='equal_family')\n", + "Multi-motif cluster purity vs on/off labels: 0.730\n", + "Default feature families\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "family", + "rawType": "str", + "type": "string" + }, + { + "name": "n_features", + "rawType": "int64", + "type": "integer" + } + ], + "ref": "aa3bc707-96fd-448e-bd0e-45b4efec9cf6", + "rows": [ + [ + "1", + "density", + "13" + ], + [ + "3", + "summary", + "7" + ], + [ + "2", + "pca", + "6" + ], + [ + "0", + "autocorr", + "5" + ] + ], + "shape": { + "columns": 2, + "rows": 4 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
familyn_features
1density13
3summary7
2pca6
0autocorr5
\n", + "
" + ], + "text/plain": [ + " family n_features\n", + "1 density 13\n", + "3 summary 7\n", + "2 pca 6\n", + "0 autocorr 5" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rich feature families\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "family", + "rawType": "str", + "type": "string" + }, + { + "name": "n_features", + "rawType": "int64", + "type": "integer" + } + ], + "ref": "7b661996-a430-4d50-95c1-b78f2e5bfd16", + "rows": [ + [ + "3", + "density", + "39" + ], + [ + "6", + "summary", + "21" + ], + [ + "4", + "fft", + "15" + ], + [ + "1", + "autocorr", + "12" + ], + [ + "0", + "asymmetry", + "9" + ], + [ + "2", + "center_edge", + "6" + ], + [ + "5", + "pca", + "6" + ] + ], + "shape": { + "columns": 2, + "rows": 7 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
familyn_features
3density39
6summary21
4fft15
1autocorr12
0asymmetry9
2center_edge6
5pca6
\n", + "
" + ], + "text/plain": [ + " family n_features\n", + "3 density 39\n", + "6 summary 21\n", + "4 fft 15\n", + "1 autocorr 12\n", + "0 asymmetry 9\n", + "2 center_edge 6\n", + "5 pca 6" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rich features by motif\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "motif", + "rawType": "str", + "type": "string" + }, + { + "name": "n_features", + "rawType": "int64", + "type": "integer" + } + ], + "ref": "dcac67dd-a3b8-4cf1-bb7c-063a36691699", + "rows": [ + [ + "2", + "pooled", + "40" + ], + [ + "0", + "A,0", + "34" + ], + [ + "1", + "CG,0", + "34" + ] + ], + "shape": { + "columns": 2, + "rows": 3 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
motifn_features
2pooled40
0A,034
1CG,034
\n", + "
" + ], + "text/plain": [ + " motif n_features\n", + "2 pooled 40\n", + "0 A,0 34\n", + "1 CG,0 34" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Default feature scaling preview\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "feature_name", + "rawType": "str", + "type": "string" + }, + { + "name": "scaling_method", + "rawType": "str", + "type": "string" + }, + { + "name": "family", + "rawType": "str", + "type": "string" + }, + { + "name": "family_weight", + "rawType": "float64", + "type": "float" + }, + { + "name": "scaled", + "rawType": "bool", + "type": "boolean" + }, + { + "name": "center", + "rawType": "float64", + "type": "float" + }, + { + "name": "scale", + "rawType": "float64", + "type": "float" + }, + { + "name": "raw_mean", + "rawType": "float64", + "type": "float" + }, + { + "name": "raw_std", + "rawType": "float64", + "type": "float" + }, + { + "name": "scaled_mean", + "rawType": "float64", + "type": "float" + }, + { + "name": "scaled_std", + "rawType": "float64", + "type": "float" + } + ], + "ref": "ac71e39c-51e6-48b7-b9ba-21c7573b5f22", + "rows": [ + [ + "0", + "pca_0", + "standard", + "pca", + "0.4082482904638631", + "True", + "8.247473315287315e-17", + "0.26355477077539524", + "2.9535324156837427e-16", + "0.26355477077539485", + "-1.1638067674739491e-15", + "0.4082482904638646" + ], + [ + "1", + "pca_1", + "standard", + "pca", + "0.4082482904638631", + "True", + "-8.820214517737823e-17", + "0.18811959268629744", + "-5.0144359216791774e-17", + "0.18811959268629783", + "-1.3920407807449935e-16", + "0.40824829046386346" + ], + [ + "2", + "pca_2", + "standard", + "pca", + "0.4082482904638631", + "True", + "-5.097396701809521e-17", + "0.18474617797555246", + "-5.361170872781845e-17", + "0.1847461779755514", + "-6.316709027338923e-17", + "0.40824829046386096" + ], + [ + "3", + "pca_3", + "standard", + "pca", + "0.4082482904638631", + "True", + "2.2451455136059913e-16", + "0.18337894839163327", + "2.2429306159871397e-16", + "0.1833789483916325", + "-1.6392479649823717e-17", + "0.40824829046386174" + ], + [ + "4", + "pca_4", + "standard", + "pca", + "0.4082482904638631", + "True", + "-5.4983155435248767e-17", + "0.18173755904387098", + "-6.391657583128344e-17", + "0.18173755904387007", + "-3.460162280117014e-17", + "0.4082482904638644" + ], + [ + "5", + "pca_5", + "standard", + "pca", + "0.4082482904638631", + "True", + "-1.0252067523864093e-16", + "0.17671025733181234", + "-1.0386527470220638e-16", + "0.17671025733181248", + "1.0676253976929e-17", + "0.4082482904638619" + ], + [ + "6", + "autocorr_20", + "standard", + "autocorr", + "0.4472135954999579", + "True", + "0.00872424766826622", + "0.03266366933767494", + "0.008724247668266407", + "0.0326636693376748", + "3.266056706974022e-16", + "0.44721359549996526" + ], + [ + "7", + "autocorr_75", + "standard", + "autocorr", + "0.4472135954999579", + "True", + "0.0034970248304790263", + "0.0229627213372743", + "0.0034970248304791625", + "0.02296272133727445", + "-2.815380973295778e-17", + "0.4472135954999559" + ] + ], + "shape": { + "columns": 11, + "rows": 8 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
feature_namescaling_methodfamilyfamily_weightscaledcenterscaleraw_meanraw_stdscaled_meanscaled_std
0pca_0standardpca0.408248True8.247473e-170.2635552.953532e-160.263555-1.163807e-150.408248
1pca_1standardpca0.408248True-8.820215e-170.188120-5.014436e-170.188120-1.392041e-160.408248
2pca_2standardpca0.408248True-5.097397e-170.184746-5.361171e-170.184746-6.316709e-170.408248
3pca_3standardpca0.408248True2.245146e-160.1833792.242931e-160.183379-1.639248e-170.408248
4pca_4standardpca0.408248True-5.498316e-170.181738-6.391658e-170.181738-3.460162e-170.408248
5pca_5standardpca0.408248True-1.025207e-160.176710-1.038653e-160.1767101.067625e-170.408248
6autocorr_20standardautocorr0.447214True8.724248e-030.0326648.724248e-030.0326643.266057e-160.447214
7autocorr_75standardautocorr0.447214True3.497025e-030.0229633.497025e-030.022963-2.815381e-170.447214
\n", + "
" + ], + "text/plain": [ + " feature_name scaling_method family family_weight scaled center \\\n", + "0 pca_0 standard pca 0.408248 True 8.247473e-17 \n", + "1 pca_1 standard pca 0.408248 True -8.820215e-17 \n", + "2 pca_2 standard pca 0.408248 True -5.097397e-17 \n", + "3 pca_3 standard pca 0.408248 True 2.245146e-16 \n", + "4 pca_4 standard pca 0.408248 True -5.498316e-17 \n", + "5 pca_5 standard pca 0.408248 True -1.025207e-16 \n", + "6 autocorr_20 standard autocorr 0.447214 True 8.724248e-03 \n", + "7 autocorr_75 standard autocorr 0.447214 True 3.497025e-03 \n", + "\n", + " scale raw_mean raw_std scaled_mean scaled_std \n", + "0 0.263555 2.953532e-16 0.263555 -1.163807e-15 0.408248 \n", + "1 0.188120 -5.014436e-17 0.188120 -1.392041e-16 0.408248 \n", + "2 0.184746 -5.361171e-17 0.184746 -6.316709e-17 0.408248 \n", + "3 0.183379 2.242931e-16 0.183379 -1.639248e-17 0.408248 \n", + "4 0.181738 -6.391658e-17 0.181738 -3.460162e-17 0.408248 \n", + "5 0.176710 -1.038653e-16 0.176710 1.067625e-17 0.408248 \n", + "6 0.032664 8.724248e-03 0.032664 3.266057e-16 0.447214 \n", + "7 0.022963 3.497025e-03 0.022963 -2.815381e-17 0.447214 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rich feature scaling preview\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "feature_name", + "rawType": "str", + "type": "string" + }, + { + "name": "scaling_method", + "rawType": "str", + "type": "string" + }, + { + "name": "family", + "rawType": "str", + "type": "string" + }, + { + "name": "family_weight", + "rawType": "float64", + "type": "float" + }, + { + "name": "scaled", + "rawType": "bool", + "type": "boolean" + }, + { + "name": "center", + "rawType": "float64", + "type": "float" + }, + { + "name": "scale", + "rawType": "float64", + "type": "float" + }, + { + "name": "raw_mean", + "rawType": "float64", + "type": "float" + }, + { + "name": "raw_std", + "rawType": "float64", + "type": "float" + }, + { + "name": "scaled_mean", + "rawType": "float64", + "type": "float" + }, + { + "name": "scaled_std", + "rawType": "float64", + "type": "float" + } + ], + "ref": "11ef1ccc-4dbe-408e-adac-bc88a12287be", + "rows": [ + [ + "0", + "pooled__pca_0", + "standard", + "pca", + "0.4082482904638631", + "True", + "8.247473315287315e-17", + "0.26355477077539524", + "2.9535324156837427e-16", + "0.26355477077539485", + "-1.1638067674739491e-15", + "0.4082482904638646" + ], + [ + "1", + "pooled__pca_1", + "standard", + "pca", + "0.4082482904638631", + "True", + "-8.820214517737823e-17", + "0.18811959268629744", + "-5.0144359216791774e-17", + "0.18811959268629783", + "-1.3920407807449935e-16", + "0.40824829046386346" + ], + [ + "2", + "pooled__pca_2", + "standard", + "pca", + "0.4082482904638631", + "True", + "-5.097396701809521e-17", + "0.18474617797555246", + "-5.361170872781845e-17", + "0.1847461779755514", + "-6.316709027338923e-17", + "0.40824829046386096" + ], + [ + "3", + "pooled__pca_3", + "standard", + "pca", + "0.4082482904638631", + "True", + "2.2451455136059913e-16", + "0.18337894839163327", + "2.2429306159871397e-16", + "0.1833789483916325", + "-1.6392479649823717e-17", + "0.40824829046386174" + ], + [ + "4", + "pooled__pca_4", + "standard", + "pca", + "0.4082482904638631", + "True", + "-5.4983155435248767e-17", + "0.18173755904387098", + "-6.391657583128344e-17", + "0.18173755904387007", + "-3.460162280117014e-17", + "0.4082482904638644" + ], + [ + "5", + "pooled__pca_5", + "standard", + "pca", + "0.4082482904638631", + "True", + "-1.0252067523864093e-16", + "0.17671025733181234", + "-1.0386527470220638e-16", + "0.17671025733181248", + "1.0676253976929e-17", + "0.4082482904638619" + ], + [ + "6", + "A,0__mean", + "standard", + "summary", + "0.2182178902359924", + "True", + "0.0035774625181363862", + "0.004131523596149701", + "0.003577462518136417", + "0.004131523596149662", + "3.846315137706692e-17", + "0.21821789023599472" + ], + [ + "7", + "A,0__var", + "standard", + "summary", + "0.2182178902359924", + "True", + "0.0035475947928421737", + "0.0040760002537805875", + "0.003547594792842113", + "0.0040760002537806", + "-1.5568269263172284e-15", + "0.21821789023599458" + ] + ], + "shape": { + "columns": 11, + "rows": 8 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
feature_namescaling_methodfamilyfamily_weightscaledcenterscaleraw_meanraw_stdscaled_meanscaled_std
0pooled__pca_0standardpca0.408248True8.247473e-170.2635552.953532e-160.263555-1.163807e-150.408248
1pooled__pca_1standardpca0.408248True-8.820215e-170.188120-5.014436e-170.188120-1.392041e-160.408248
2pooled__pca_2standardpca0.408248True-5.097397e-170.184746-5.361171e-170.184746-6.316709e-170.408248
3pooled__pca_3standardpca0.408248True2.245146e-160.1833792.242931e-160.183379-1.639248e-170.408248
4pooled__pca_4standardpca0.408248True-5.498316e-170.181738-6.391658e-170.181738-3.460162e-170.408248
5pooled__pca_5standardpca0.408248True-1.025207e-160.176710-1.038653e-160.1767101.067625e-170.408248
6A,0__meanstandardsummary0.218218True3.577463e-030.0041323.577463e-030.0041323.846315e-170.218218
7A,0__varstandardsummary0.218218True3.547595e-030.0040763.547595e-030.004076-1.556827e-150.218218
\n", + "
" + ], + "text/plain": [ + " feature_name scaling_method family family_weight scaled center \\\n", + "0 pooled__pca_0 standard pca 0.408248 True 8.247473e-17 \n", + "1 pooled__pca_1 standard pca 0.408248 True -8.820215e-17 \n", + "2 pooled__pca_2 standard pca 0.408248 True -5.097397e-17 \n", + "3 pooled__pca_3 standard pca 0.408248 True 2.245146e-16 \n", + "4 pooled__pca_4 standard pca 0.408248 True -5.498316e-17 \n", + "5 pooled__pca_5 standard pca 0.408248 True -1.025207e-16 \n", + "6 A,0__mean standard summary 0.218218 True 3.577463e-03 \n", + "7 A,0__var standard summary 0.218218 True 3.547595e-03 \n", + "\n", + " scale raw_mean raw_std scaled_mean scaled_std \n", + "0 0.263555 2.953532e-16 0.263555 -1.163807e-15 0.408248 \n", + "1 0.188120 -5.014436e-17 0.188120 -1.392041e-16 0.408248 \n", + "2 0.184746 -5.361171e-17 0.184746 -6.316709e-17 0.408248 \n", + "3 0.183379 2.242931e-16 0.183379 -1.639248e-17 0.408248 \n", + "4 0.181738 -6.391658e-17 0.181738 -3.460162e-17 0.408248 \n", + "5 0.176710 -1.038653e-16 0.176710 1.067625e-17 0.408248 \n", + "6 0.004132 3.577463e-03 0.004132 3.846315e-17 0.218218 \n", + "7 0.004076 3.547595e-03 0.004076 -1.556827e-15 0.218218 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rich features most associated with on/off labels (QC, not proof)\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "feature_name", + "rawType": "str", + "type": "string" + }, + { + "name": "effect_score", + "rawType": "float64", + "type": "float" + }, + { + "name": "min_group_mean", + "rawType": "float64", + "type": "float" + }, + { + "name": "max_group_mean", + "rawType": "float64", + "type": "float" + }, + { + "name": "overall_std", + "rawType": "float64", + "type": "float" + } + ], + "ref": "cb79bb5a-733b-4c71-a78a-53e2668c24ee", + "rows": [ + [ + "0", + "pooled__pca_0", + "1.355536849758361", + "-0.1938624282161216", + "0.3595331733598573", + "0.4082482904638646" + ], + [ + "1", + "A,0__density_pm300", + "1.2870861023455598", + "-0.0721993424973482", + "0.13389937886070555", + "0.16012815380507683" + ], + [ + "2", + "A,0__density_pm100", + "1.2814577673492937", + "-0.071883619963065", + "0.13331384650306113", + "0.1601281538050976" + ], + [ + "3", + "A,0__center_minus_edge", + "1.2151217395298082", + "-0.17378092749409654", + "0.32229044537561385", + "0.408248290463843" + ], + [ + "4", + "A,0__density_pm500", + "1.2149432990479243", + "-0.0681524780688479", + "0.12639414938677265", + "0.16012815380508683" + ], + [ + "5", + "A,0__density_pm75", + "1.2080158234620955", + "-0.06776387999327602", + "0.12567346358624126", + "0.1601281538050804" + ], + [ + "6", + "A,0__density_pm50", + "1.0840493559065434", + "-0.06080995714933015", + "0.11277686484666381", + "0.1601281538050883" + ], + [ + "7", + "A,0__var", + "1.042807624434637", + "-0.07971728435388671", + "0.14784199537329196", + "0.21821789023599458" + ], + [ + "8", + "A,0__mean", + "1.0407913617734987", + "-0.07956315143413832", + "0.14755614370896333", + "0.21821789023599472" + ], + [ + "9", + "A,0__mod_fraction", + "1.0220006283904153", + "-0.07812669642439393", + "0.14489212452384143", + "0.2182178902359909" + ], + [ + "10", + "A,0__density_minus150", + "0.9166853081717443", + "-0.051421638697189846", + "0.09536548732152554", + "0.16012815380509796" + ], + [ + "11", + "A,0__density_plus150", + "0.8740970250519107", + "-0.04903264076322191", + "0.0909349021057452", + "0.16012815380510037" + ] + ], + "shape": { + "columns": 5, + "rows": 12 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
feature_nameeffect_scoremin_group_meanmax_group_meanoverall_std
0pooled__pca_01.355537-0.1938620.3595330.408248
1A,0__density_pm3001.287086-0.0721990.1338990.160128
2A,0__density_pm1001.281458-0.0718840.1333140.160128
3A,0__center_minus_edge1.215122-0.1737810.3222900.408248
4A,0__density_pm5001.214943-0.0681520.1263940.160128
5A,0__density_pm751.208016-0.0677640.1256730.160128
6A,0__density_pm501.084049-0.0608100.1127770.160128
7A,0__var1.042808-0.0797170.1478420.218218
8A,0__mean1.040791-0.0795630.1475560.218218
9A,0__mod_fraction1.022001-0.0781270.1448920.218218
10A,0__density_minus1500.916685-0.0514220.0953650.160128
11A,0__density_plus1500.874097-0.0490330.0909350.160128
\n", + "
" + ], + "text/plain": [ + " feature_name effect_score min_group_mean max_group_mean \\\n", + "0 pooled__pca_0 1.355537 -0.193862 0.359533 \n", + "1 A,0__density_pm300 1.287086 -0.072199 0.133899 \n", + "2 A,0__density_pm100 1.281458 -0.071884 0.133314 \n", + "3 A,0__center_minus_edge 1.215122 -0.173781 0.322290 \n", + "4 A,0__density_pm500 1.214943 -0.068152 0.126394 \n", + "5 A,0__density_pm75 1.208016 -0.067764 0.125673 \n", + "6 A,0__density_pm50 1.084049 -0.060810 0.112777 \n", + "7 A,0__var 1.042808 -0.079717 0.147842 \n", + "8 A,0__mean 1.040791 -0.079563 0.147556 \n", + "9 A,0__mod_fraction 1.022001 -0.078127 0.144892 \n", + "10 A,0__density_minus150 0.916685 -0.051422 0.095365 \n", + "11 A,0__density_plus150 0.874097 -0.049033 0.090935 \n", + "\n", + " overall_std \n", + "0 0.408248 \n", + "1 0.160128 \n", + "2 0.160128 \n", + "3 0.408248 \n", + "4 0.160128 \n", + "5 0.160128 \n", + "6 0.160128 \n", + "7 0.218218 \n", + "8 0.218218 \n", + "9 0.218218 \n", + "10 0.160128 \n", + "11 0.160128 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cluster counts by source\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "row_0", + "rawType": "int64", + "type": "integer" + }, + { + "name": "off_target", + "rawType": "int64", + "type": "integer" + }, + { + "name": "on_target", + "rawType": "int64", + "type": "integer" + } + ], + "ref": "6234c25b-65ec-4f24-9338-506ad502dc65", + "rows": [ + [ + "0", + "3419", + "1062" + ], + [ + "1", + "611", + "1111" + ] + ], + "shape": { + "columns": 2, + "rows": 2 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
col_0off_targeton_target
row_0
034191062
16111111
\n", + "
" + ], + "text/plain": [ + "col_0 off_target on_target\n", + "row_0 \n", + "0 3419 1062\n", + "1 611 1111" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from dimelo import cluster\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "if \"shared_window\" not in globals():\n", + " shared_window = 1000\n", + "\n", + "motif_labels = [\"A,0\", \"CG,0\"]\n", + "\n", + "rw_on_multi = cluster.build_multimotif_read_windows(\n", + " hdf5_file=extract_file,\n", + " motifs=motif_labels,\n", + " regions=ctcf_target_regions,\n", + " window_size=shared_window,\n", + " orientation_aware=True,\n", + " span_full_window=False,\n", + " require_all_motifs=True,\n", + ")\n", + "\n", + "rw_off_multi = cluster.build_multimotif_read_windows(\n", + " hdf5_file=extract_file,\n", + " motifs=motif_labels,\n", + " regions=ctcf_off_target_regions,\n", + " window_size=shared_window,\n", + " orientation_aware=True,\n", + " span_full_window=False,\n", + " require_all_motifs=True,\n", + ")\n", + "\n", + "rw_multi = cluster.merge_read_window_results(\n", + " [rw_on_multi, rw_off_multi],\n", + " source_labels=[\"on_target\", \"off_target\"],\n", + " align=\"error\",\n", + ")\n", + "\n", + "# Default pooled feature scheme. Keep the raw legacy matrix for clustering so the\n", + "# read-cluster association heatmap matches the original tutorial behavior.\n", + "feat_multi, feat_multi_names, feat_multi_table = cluster.read_window_feature_matrix(\n", + " rw_multi,\n", + " n_pca=6,\n", + " use_peak_features=False,\n", + " return_feature_table=True,\n", + ")\n", + "feat_multi_scaled, feat_multi_scale_table = cluster.scale_feature_matrix(\n", + " feat_multi,\n", + " feat_multi_names,\n", + " feature_table=feat_multi_table,\n", + " method=\"standard\",\n", + " family_weighting=\"equal_family\",\n", + ")\n", + "\n", + "# Rich explicit feature scheme used for inspection and feature-salience QC.\n", + "rich_feature_spec = {\n", + " \"motif_mode\": \"per_motif\",\n", + " \"motif_count\": len(motif_labels),\n", + " \"motif_labels\": motif_labels,\n", + " \"pooled\": True,\n", + " \"pca\": {\"enabled\": True, \"n_components\": 6, \"scope\": \"pooled\"},\n", + " \"densities\": {\"enabled\": True},\n", + " \"asymmetry\": {\"enabled\": True, \"spans\": [100, 300, 500]},\n", + " \"center_edge\": {\"enabled\": True, \"center_bp\": 100, \"edge_bp\": 200},\n", + " \"autocorr\": {\"enabled\": True, \"lags\": [20, 75, 150, 250]},\n", + " \"fft\": {\"enabled\": True, \"periods_bp\": [10, 50, 100, 150, 200]},\n", + " \"cross_motif\": {\"enabled\": False},\n", + " \"peaks\": {\"enabled\": False},\n", + "}\n", + "feat_multi_rich_scaled, feat_multi_rich_names, feat_multi_rich_table, feat_multi_rich_scale_table = cluster.read_window_feature_matrix(\n", + " rw_multi,\n", + " feature_spec=rich_feature_spec,\n", + " scale_features=True,\n", + " scaling_method=\"standard\",\n", + " family_weighting=\"equal_family\",\n", + " return_feature_table=True,\n", + " return_scale_table=True,\n", + ")\n", + "feat_multi_rich = feat_multi_rich_scaled\n", + "\n", + "sample_labels_multi = np.array([m.get(\"source_label\", \"unknown\") for m in rw_multi.metadata])\n", + "\n", + "summary_default = cluster.summarize_feature_matrix(\n", + " feat_multi,\n", + " feat_multi_names,\n", + " feature_table=feat_multi_table,\n", + " labels=sample_labels_multi,\n", + ")\n", + "summary_rich = cluster.summarize_feature_matrix(\n", + " feat_multi_rich,\n", + " feat_multi_rich_names,\n", + " feature_table=feat_multi_rich_table,\n", + " labels=sample_labels_multi,\n", + ")\n", + "ranked_rich_features = cluster.rank_read_features_by_group_difference(\n", + " feat_multi_rich,\n", + " feat_multi_rich_names,\n", + " sample_labels_multi,\n", + " top_n=12,\n", + ")\n", + "\n", + "clust_multi = cluster.cluster_read_windows(\n", + " feat_multi,\n", + " method=\"kmeans\",\n", + " n_clusters=2,\n", + " random_state=42,\n", + ")\n", + "\n", + "cluster.plot_cluster_profiles(\n", + " data_matrix=rw_multi.data_matrix,\n", + " labels=clust_multi.labels_size_ordered,\n", + " val_matrix=rw_multi.val_matrix,\n", + " metadata=rw_multi.metadata,\n", + " window_size=shared_window,\n", + " motif_count=len(motif_labels),\n", + " motif_labels=motif_labels,\n", + " plot_all_motifs=True,\n", + " color_points_by=\"motif\",\n", + " motif_profile_mode=\"single_axis\",\n", + " point_size=plot_point_size,\n", + " point_alpha=plot_point_alpha,\n", + " smoothing=profile_smoothing,\n", + " show_unsmoothed_overlay=show_unsmoothed_overlay,\n", + ")\n", + "\n", + "table_multi = pd.crosstab(clust_multi.labels_size_ordered, sample_labels_multi)\n", + "purity_multi = table_multi.max(axis=1).sum() / table_multi.values.sum()\n", + "\n", + "print(f\"Multi-motif reads used: on_target={rw_on_multi.data_matrix.shape[0]}, off_target={rw_off_multi.data_matrix.shape[0]}, total={rw_multi.data_matrix.shape[0]}\")\n", + "print(f\"Default feature matrix: {summary_default['n_reads']} reads x {summary_default['n_features']} features\")\n", + "print(f\"Rich feature matrix: {summary_rich['n_reads']} reads x {summary_rich['n_features']} features\")\n", + "print(\"K-means input for cluster labels: raw default feature matrix (legacy tutorial behavior)\")\n", + "print(\"Scaled default features are still computed for classifier/QC examples below.\")\n", + "print(f\"Multi-motif cluster purity vs on/off labels: {purity_multi:.3f}\")\n", + "print(\"Default feature families\")\n", + "display(summary_default[\"feature_counts_by_family\"])\n", + "print(\"Rich feature families\")\n", + "display(summary_rich[\"feature_counts_by_family\"])\n", + "print(\"Rich features by motif\")\n", + "display(summary_rich[\"feature_counts_by_motif\"])\n", + "print(\"Default feature scaling preview\")\n", + "display(feat_multi_scale_table.head(8))\n", + "print(\"Rich feature scaling preview\")\n", + "display(feat_multi_rich_scale_table.head(8))\n", + "print(\"Rich features most associated with on/off labels (QC, not proof)\")\n", + "display(ranked_rich_features)\n", + "print(\"Cluster counts by source\")\n", + "display(table_multi)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Read Classification\n", + "\n", + "The next cells ask a supervised question: given the engineered read-feature matrix, can a classifier distinguish reads from the on-target and off-target region sets? This is not meant to replace visual inspection or clustering. It is a QC layer that checks whether the feature representation carries separable signal, reports held-out train/test metrics, plots confusion matrices, and then shows the read profiles behind true/false positives and negatives. The examples use the same scaled feature matrices used for k-means so distance- and model-based steps see comparable feature weighting." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Single Motif" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'test': {'accuracy': 0.8364222401289283, 'roc_auc': 0.8979606970708195, 'confusion_matrix': [[710, 96], [107, 328]]}, 'train': {'accuracy': 0.8409915356711004, 'roc_auc': 0.891370139660258, 'confusion_matrix': [[2878, 346], [443, 1295]]}}\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sample_labels_single = np.array([m.get(\"source_label\", \"unknown\") for m in rw_single.metadata])\n", + "\n", + "clf_single = cluster.classify_read_features_binary(\n", + " feat_single_scaled,\n", + " sample_labels=sample_labels_single,\n", + " classifier=\"logreg\",\n", + " random_state=42,\n", + ")\n", + "print(clf_single[\"metrics\"])\n", + "cluster.plot_confusion_matrices(clf_single[\"predictions\"])\n", + "\n", + "cluster.plot_classification_profiles(\n", + " data_matrix=rw_single.data_matrix,\n", + " predictions=clf_single[\"predictions\"],\n", + " val_matrix=rw_single.val_matrix,\n", + " metadata=rw_single.metadata,\n", + " split=\"test\",\n", + " group_by=\"confusion\",\n", + " window_size=shared_window,\n", + " point_size=plot_point_size,\n", + " point_alpha=plot_point_alpha,\n", + " smoothing=profile_smoothing,\n", + " show_unsmoothed_overlay=show_unsmoothed_overlay,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Tip*: For concatenated motif windows, use `motif_index` in plotting helpers to choose which motif slice to visualize (e.g., 0 for the first motif, 1 for the second)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Multiple motifs" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'test': {'accuracy': 0.8436744560838034, 'roc_auc': 0.9122101480277229, 'confusion_matrix': [[709, 97], [97, 338]]}, 'train': {'accuracy': 0.847037484885127, 'roc_auc': 0.9066018454799589, 'confusion_matrix': [[2868, 356], [403, 1335]]}}\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sample_labels_multi = np.array([m.get(\"source_label\", \"unknown\") for m in rw_multi.metadata])\n", + "\n", + "clf_multi = cluster.classify_read_features_binary(\n", + " feat_multi_scaled,\n", + " sample_labels=sample_labels_multi,\n", + " classifier=\"logreg\",\n", + " random_state=42,\n", + ")\n", + "print(clf_multi[\"metrics\"])\n", + "cluster.plot_confusion_matrices(clf_multi[\"predictions\"])\n", + "\n", + "cluster.plot_classification_profiles(\n", + " data_matrix=rw_multi.data_matrix,\n", + " predictions=clf_multi[\"predictions\"],\n", + " val_matrix=rw_multi.val_matrix,\n", + " metadata=rw_multi.metadata,\n", + " split=\"test\",\n", + " group_by=\"confusion\",\n", + " window_size=shared_window,\n", + " motif_count=len(motif_labels),\n", + " motif_labels=motif_labels,\n", + " plot_all_motifs=True,\n", + " color_points_by=\"motif\",\n", + " motif_profile_mode=\"single_axis\",\n", + " point_size=plot_point_size,\n", + " point_alpha=plot_point_alpha,\n", + " smoothing=profile_smoothing,\n", + " show_unsmoothed_overlay=show_unsmoothed_overlay,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Read-Cluster to Region Association\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Read-level clustering stays the primary inference step. Here we aggregate those cluster labels back onto regions, then plot the region-by-cluster association matrix. The cluster labels in this section intentionally use the raw default feature matrix to preserve the original tutorial grouping; the richer/scaled feature matrices above are kept as QC tools for exploring alternative feature salience.\n", + "\n", + "Sorting controls:\n", + "- `region_sort_mode` controls row order before the tutorial's final source-bed grouping. It can be one key or a list of keys applied hierarchically. Options are `cluster_fraction`, `input`, `genomic`, and `association_strength`; for example, `[\"cluster_fraction\", \"genomic\"]` groups by dominant cluster/fraction and then uses genomic coordinates as the next tie-breaker.\n", + "- `association_strength_aggregate` only matters when `region_sort_mode=\"association_strength\"`. It defines each region's scalar sorting score from its per-cluster values: `max` uses the strongest cluster association for that region, while `mean` uses the average association across clusters.\n", + "- `cluster_sort_mode` controls heatmap column order. Use `natural` for cluster labels in lexical/numeric-looking order, `input` for the order produced by the association table, `total_association` for columns with the largest summed values first, or `max_association` for columns with the strongest single-region association first. You can also pass `cluster_order=[...]` directly to `plot_read_cluster_region_association_heatmap_matplotlib`.\n", + "- `row_annotation_columns` can plot any number of categorical region labels as separate bars to the left of the heatmap. Here we show source BED and strand so the row grouping remains visible without crowding the y-axis labels." + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Association payload metadata\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "plot_family", + "rawType": "str", + "type": "string" + }, + { + "name": "value_mode", + "rawType": "str", + "type": "string" + }, + { + "name": "source_format", + "rawType": "str", + "type": "string" + }, + { + "name": "region_order", + "rawType": "object", + "type": "unknown" + }, + { + "name": "cluster_order", + "rawType": "object", + "type": "unknown" + }, + { + "name": "top_n_regions_per_cluster", + "rawType": "int64", + "type": "integer" + }, + { + "name": "has_top_regions_table", + "rawType": "bool", + "type": "boolean" + }, + { + "name": "region_sort", + "rawType": "str", + "type": "string" + }, + { + "name": "association_strength_aggregate", + "rawType": "str", + "type": "string" + }, + { + "name": "chromosome_blocks", + "rawType": "object", + "type": "unknown" + } + ], + "ref": "43b0901f-29f2-4f7a-ae75-a25adb36634a", + "rows": [ + [ + "0", + "read_cluster_region_association_heatmap", + "fraction", + "legacy_wide", + "['chr1:9168068-9168218:+', 'chr1:9168135-9168218:+', 'chr1:9168136-9168218:-', 'chr1:9169918-9170236:+', 'chr1:9169985-9170303:+', 'chr1:9169986-9170302:-', 'chr1:9172003-9172086:+', 'chr1:9172003-9172152:-', 'chr1:9172003-9172153:+', 'chr1:114356586-114356736:+', 'chr1:114356587-114356736:-', 'chr1:114358436-114358754:+', 'chr1:114358437-114358753:-', 'chr1:114360454-114360603:-', 'chr1:114360454-114360604:+', 'chr1:150101499-150101649:+', 'chr1:150101534-150101649:-', 'chr1:150101535-150101649:+', 'chr1:150103349-150103667:+', 'chr1:150103384-150103702:-', 'chr1:150103385-150103701:+', 'chr1:150105402-150105517:+', 'chr1:150105402-150105551:+', 'chr1:150105402-150105552:-', 'chr1:224661531-224661681:-', 'chr1:224661583-224661681:+', 'chr1:224661584-224661681:-', 'chr1:224663381-224663697:-', 'chr1:224663433-224663751:+', 'chr1:224663434-224663750:-', 'chr1:224665451-224665547:-', 'chr1:224665451-224665600:-', 'chr1:224665451-224665601:+', 'chr2:44482827-44482977:+', 'chr2:44484677-44484995:+', 'chr2:44486695-44486845:+', 'chr3:48462628-48462778:-', 'chr3:48462688-48462778:-', 'chr3:48462689-48462778:+', 'chr3:48464478-48464796:-', 'chr3:48464538-48464856:-', 'chr3:48464539-48464855:+', 'chr3:48466556-48466646:-', 'chr3:48466556-48466705:+', 'chr3:48466556-48466706:-', 'chr5:111666908-111667058:+', 'chr5:111668758-111669076:+', 'chr5:111670776-111670926:+', 'chr5:138876711-138876861:+', 'chr5:138878561-138878879:+', 'chr5:138880579-138880729:+', 'chr6:15561907-15562057:+', 'chr6:15561908-15562057:-', 'chr6:15561985-15562057:+', 'chr6:15561986-15562057:-', 'chr6:15563757-15564075:+', 'chr6:15563758-15564074:-', 'chr6:15563835-15564153:+', 'chr6:15563836-15564152:-', 'chr6:15565853-15565924:-', 'chr6:15565853-15565925:+', 'chr6:15565853-15566002:-', 'chr6:15565853-15566003:+', 'chr6:41196591-41196741:-', 'chr6:41196592-41196741:+', 'chr6:41196657-41196741:+', 'chr6:41196658-41196741:-', 'chr6:41198441-41198759:-', 'chr6:41198442-41198758:+', 'chr6:41198507-41198825:+', 'chr6:41198508-41198824:-', 'chr6:41200525-41200608:+', 'chr6:41200525-41200609:-', 'chr6:41200525-41200674:-', 'chr6:41200525-41200675:+', 'chr6:53009844-53009994:+', 'chr6:53011694-53012012:+', 'chr6:53013712-53013862:+', 'chr6:73588139-73588289:-', 'chr6:73588200-73588289:+', 'chr6:73589989-73590307:-', 'chr6:73590050-73590368:+', 'chr6:73592068-73592157:-', 'chr6:73592068-73592218:+', 'chr6:155875926-155876076:-', 'chr6:155876024-155876076:+', 'chr6:155876025-155876076:-', 'chr6:155877776-155878092:-', 'chr6:155877874-155878192:+', 'chr6:155877875-155878191:-', 'chr6:155879892-155879942:-', 'chr6:155879892-155880041:-', 'chr6:155879892-155880042:+', 'chr7:152343785-152343935:-', 'chr7:152343786-152343935:+', 'chr7:152343847-152343935:-', 'chr7:152343848-152343935:+', 'chr7:152345635-152345953:-', 'chr7:152345636-152345952:+', 'chr7:152345697-152346015:-', 'chr7:152345698-152346014:+', 'chr7:152347715-152347802:+', 'chr7:152347715-152347803:-', 'chr7:152347715-152347864:+', 'chr7:152347715-152347865:-', 'chr8:22846344-22846494:+', 'chr8:22846345-22846494:-', 'chr8:22846428-22846494:+', 'chr8:22848194-22848512:+', 'chr8:22848195-22848511:-', 'chr8:22848278-22848596:+', 'chr8:22850296-22850361:-', 'chr8:22850296-22850362:+', 'chr8:22850296-22850446:+', 'chr9:145234660-145234810:+', 'chr9:145234661-145234810:-', 'chr9:145234697-145234810:-', 'chr9:145236510-145236828:+', 'chr9:145236511-145236827:-', 'chr9:145236547-145236865:-', 'chr9:145238565-145238677:-', 'chr9:145238565-145238678:+', 'chr9:145238565-145238715:-', 'chr12:57871837-57871987:-', 'chr12:57871885-57871987:-', 'chr12:57873687-57874005:-', 'chr12:57873735-57874053:-', 'chr12:57875753-57875855:-', 'chr12:57875753-57875903:-', 'chr14:17377273-17377423:+', 'chr14:17377274-17377423:-', 'chr14:17377341-17377423:+', 'chr14:17379123-17379441:+', 'chr14:17379124-17379440:-', 'chr14:17379191-17379509:+', 'chr14:17381209-17381290:-', 'chr14:17381209-17381291:+', 'chr14:17381209-17381359:+', 'chr14:44123158-44123308:+', 'chr14:44123159-44123308:-', 'chr14:44125008-44125326:+', 'chr14:44125009-44125325:-', 'chr14:44127026-44127175:-', 'chr14:44127026-44127176:+', 'chr15:38664850-38665000:-', 'chr15:38664851-38665000:+', 'chr15:38664892-38665000:-', 'chr15:38664893-38665000:+', 'chr15:38666700-38667018:-', 'chr15:38666701-38667017:+', 'chr15:38666742-38667060:-', 'chr15:38666743-38667059:+', 'chr15:38668760-38668867:+', 'chr15:38668760-38668868:-', 'chr15:38668760-38668909:+', 'chr15:38668760-38668910:-', 'chr15:54632158-54632308:+', 'chr15:54632159-54632308:-', 'chr15:54632192-54632308:-', 'chr15:54632193-54632308:+', 'chr15:54634008-54634326:+', 'chr15:54634009-54634325:-', 'chr15:54634042-54634360:-', 'chr15:54634043-54634359:+', 'chr15:54636060-54636175:-', 'chr15:54636060-54636176:+', 'chr15:54636060-54636209:+', 'chr15:54636060-54636210:-', 'chr16:4279474-4279624:+', 'chr16:4279536-4279624:+', 'chr16:4279537-4279624:-', 'chr16:4281324-4281640:+', 'chr16:4281386-4281704:+', 'chr16:4281387-4281703:-', 'chr16:4283404-4283490:+', 'chr16:4283404-4283553:-', 'chr16:4283404-4283554:+', 'chr16:61261359-61261509:+', 'chr16:61261360-61261509:-', 'chr16:61261438-61261509:+', 'chr16:61261439-61261509:-', 'chr16:61263209-61263527:+', 'chr16:61263210-61263526:-', 'chr16:61263288-61263606:+', 'chr16:61263289-61263605:-', 'chr16:61265306-61265376:-', 'chr16:61265306-61265377:+', 'chr16:61265306-61265455:-', 'chr16:61265306-61265456:+', 'chr16:63442391-63442541:-', 'chr16:63442392-63442541:+', 'chr16:63442436-63442541:-', 'chr16:63444241-63444559:-', 'chr16:63444242-63444558:+', 'chr16:63444286-63444602:-', 'chr16:63446302-63446408:+', 'chr16:63446302-63446409:-', 'chr16:63446302-63446452:-', 'chr17:42517551-42517701:-', 'chr17:42517552-42517701:+', 'chr17:42517613-42517701:-', 'chr17:42519401-42519719:-', 'chr17:42519402-42519718:+', 'chr17:42519463-42519781:-', 'chr17:42521481-42521568:+', 'chr17:42521481-42521569:-', 'chr17:42521481-42521631:-', 'chr17:44334563-44334713:+', 'chr17:44334564-44334713:-', 'chr17:44336413-44336731:+', 'chr17:44336414-44336730:-', 'chr17:44338431-44338580:-', 'chr17:44338431-44338581:+', 'chr17:45987586-45987736:+', 'chr17:45987587-45987736:-', 'chr17:45987626-45987736:+', 'chr17:45987627-45987736:-', 'chr17:45989436-45989754:+', 'chr17:45989437-45989753:-', 'chr17:45989476-45989794:+', 'chr17:45989477-45989793:-', 'chr17:45991494-45991603:-', 'chr17:45991494-45991604:+', 'chr17:45991494-45991643:-', 'chr17:45991494-45991644:+', 'chr17:82008550-82008700:-', 'chr17:82008681-82008700:-', 'chr17:82008682-82008700:+', 'chr17:82010400-82010718:-', 'chr17:82010531-82010849:-', 'chr17:82010532-82010848:+', 'chr17:82012549-82012568:-', 'chr17:82012549-82012698:+', 'chr17:82012549-82012699:-', 'chr19:41732348-41732498:-', 'chr19:41732349-41732498:+', 'chr19:41734198-41734516:-', 'chr19:41734199-41734515:+', 'chr19:41736216-41736365:+', 'chr19:41736216-41736366:-', 'chr19:43453207-43453357:-', 'chr19:43453252-43453357:-', 'chr19:43453253-43453357:+', 'chr19:43455057-43455375:-', 'chr19:43455102-43455420:-', 'chr19:43455103-43455419:+', 'chr19:43457120-43457225:-', 'chr19:43457120-43457269:+', 'chr19:43457120-43457270:-', 'chr19:44926036-44926186:+', 'chr19:44926037-44926186:-', 'chr19:44927886-44928204:+', 'chr19:44927887-44928203:-', 'chr19:44929904-44930053:-', 'chr19:44929904-44930054:+', 'chr20:33335198-33335348:-', 'chr20:33335199-33335348:+', 'chr20:33335286-33335348:-', 'chr20:33337048-33337366:-', 'chr20:33337049-33337365:+', 'chr20:33337136-33337454:-', 'chr20:33339154-33339215:+', 'chr20:33339154-33339216:-', 'chr20:33339154-33339304:-', 'chr20:36033923-36034073:+', 'chr20:36033924-36034073:-', 'chr20:36035773-36036091:+', 'chr20:36035774-36036090:-', 'chr20:36037791-36037940:-', 'chr20:36037791-36037941:+', 'chr20:40161013-40161163:-', 'chr20:40161014-40161163:+', 'chr20:40162863-40163181:-', 'chr20:40162864-40163180:+', 'chr20:40164881-40165030:+', 'chr20:40164881-40165031:-', 'chr20:59988985-59989135:-', 'chr20:59989037-59989135:-', 'chr20:59989038-59989135:+', 'chr20:59990835-59991153:-', 'chr20:59990887-59991205:-', 'chr20:59990888-59991204:+', 'chr20:59992905-59993003:-', 'chr20:59992905-59993054:+', 'chr20:59992905-59993055:-', 'chr21:24894312-24894462:-', 'chr21:24894313-24894462:+', 'chr21:24896162-24896480:-', 'chr21:24896163-24896479:+', 'chr21:24898180-24898329:+', 'chr21:24898180-24898330:-', 'chrX:9700334-9700484:-', 'chrX:9702184-9702502:-', 'chrX:9704202-9704352:-', 'chrX:99209453-99209603:-', 'chrX:99209454-99209603:+', 'chrX:99211303-99211621:-', 'chrX:99211304-99211620:+', 'chrX:99213321-99213470:+', 'chrX:99213321-99213471:-']", + "[0, 1]", + "8", + "True", + "source_bed_then_genomic", + "max", + "[{'chrom': 'chr1', 'start_index': 0, 'end_index': 32, 'n_regions': 33}, {'chrom': 'chr2', 'start_index': 33, 'end_index': 35, 'n_regions': 3}, {'chrom': 'chr3', 'start_index': 36, 'end_index': 44, 'n_regions': 9}, {'chrom': 'chr5', 'start_index': 45, 'end_index': 50, 'n_regions': 6}, {'chrom': 'chr6', 'start_index': 51, 'end_index': 92, 'n_regions': 42}, {'chrom': 'chr7', 'start_index': 93, 'end_index': 104, 'n_regions': 12}, {'chrom': 'chr8', 'start_index': 105, 'end_index': 113, 'n_regions': 9}, {'chrom': 'chr9', 'start_index': 114, 'end_index': 122, 'n_regions': 9}, {'chrom': 'chr12', 'start_index': 123, 'end_index': 128, 'n_regions': 6}, {'chrom': 'chr14', 'start_index': 129, 'end_index': 143, 'n_regions': 15}, {'chrom': 'chr15', 'start_index': 144, 'end_index': 167, 'n_regions': 24}, {'chrom': 'chr16', 'start_index': 168, 'end_index': 197, 'n_regions': 30}, {'chrom': 'chr17', 'start_index': 198, 'end_index': 233, 'n_regions': 36}, {'chrom': 'chr19', 'start_index': 234, 'end_index': 254, 'n_regions': 21}, {'chrom': 'chr20', 'start_index': 255, 'end_index': 284, 'n_regions': 30}, {'chrom': 'chr21', 'start_index': 285, 'end_index': 290, 'n_regions': 6}, {'chrom': 'chrX', 'start_index': 291, 'end_index': 299, 'n_regions': 9}]" + ] + ], + "shape": { + "columns": 10, + "rows": 1 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
plot_familyvalue_modesource_formatregion_ordercluster_ordertop_n_regions_per_clusterhas_top_regions_tableregion_sortassociation_strength_aggregatechromosome_blocks
0read_cluster_region_association_heatmapfractionlegacy_wide[chr1:9168068-9168218:+, chr1:9168135-9168218:...[0, 1]8Truesource_bed_then_genomicmax[{'chrom': 'chr1', 'start_index': 0, 'end_inde...
\n", + "
" + ], + "text/plain": [ + " plot_family value_mode source_format \\\n", + "0 read_cluster_region_association_heatmap fraction legacy_wide \n", + "\n", + " region_order cluster_order \\\n", + "0 [chr1:9168068-9168218:+, chr1:9168135-9168218:... [0, 1] \n", + "\n", + " top_n_regions_per_cluster has_top_regions_table region_sort \\\n", + "0 8 True source_bed_then_genomic \n", + "\n", + " association_strength_aggregate \\\n", + "0 max \n", + "\n", + " chromosome_blocks \n", + "0 [{'chrom': 'chr1', 'start_index': 0, 'end_inde... " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Region axis preview (sorted)\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "region_id", + "rawType": "str", + "type": "string" + }, + { + "name": "chrom", + "rawType": "str", + "type": "string" + }, + { + "name": "start", + "rawType": "int64", + "type": "integer" + }, + { + "name": "end", + "rawType": "int64", + "type": "integer" + }, + { + "name": "source_label", + "rawType": "str", + "type": "string" + } + ], + "ref": "80e653e8-84e8-456c-8355-64c2731f9543", + "rows": [ + [ + "0", + "chr1:9169918-9170236:+", + "chr1", + "9169918", + "9170236", + "on_target" + ], + [ + "1", + "chr1:9169985-9170303:+", + "chr1", + "9169985", + "9170303", + "on_target" + ], + [ + "2", + "chr1:9169986-9170302:-", + "chr1", + "9169986", + "9170302", + "on_target" + ], + [ + "3", + "chr1:114358436-114358754:+", + "chr1", + "114358436", + "114358754", + "on_target" + ], + [ + "4", + "chr1:114358437-114358753:-", + "chr1", + "114358437", + "114358753", + "on_target" + ] + ], + "shape": { + "columns": 5, + "rows": 5 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
region_idchromstartendsource_label
0chr1:9169918-9170236:+chr191699189170236on_target
1chr1:9169985-9170303:+chr191699859170303on_target
2chr1:9169986-9170302:-chr191699869170302on_target
3chr1:114358436-114358754:+chr1114358436114358754on_target
4chr1:114358437-114358753:-chr1114358437114358753on_target
\n", + "
" + ], + "text/plain": [ + " region_id chrom start end source_label\n", + "0 chr1:9169918-9170236:+ chr1 9169918 9170236 on_target\n", + "1 chr1:9169985-9170303:+ chr1 9169985 9170303 on_target\n", + "2 chr1:9169986-9170302:- chr1 9169986 9170302 on_target\n", + "3 chr1:114358436-114358754:+ chr1 114358436 114358754 on_target\n", + "4 chr1:114358437-114358753:- chr1 114358437 114358753 on_target" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Source label counts\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "source_label", + "rawType": "str", + "type": "string" + }, + { + "name": "n_regions", + "rawType": "int64", + "type": "integer" + } + ], + "ref": "55e26722-aa74-4038-baba-5476528d51a8", + "rows": [ + [ + "off_target", + "200" + ], + [ + "on_target", + "100" + ] + ], + "shape": { + "columns": 1, + "rows": 2 + } + }, + "text/plain": [ + "source_label\n", + "off_target 200\n", + "on_target 100\n", + "Name: n_regions, dtype: int64" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from dimelo import plotting, plotting_matplotlib\n", + "import importlib\n", + "import inspect\n", + "import pandas as pd\n", + "\n", + "# Reload plotting modules in case this kernel imported dimelo before local edits.\n", + "plotting = importlib.reload(plotting)\n", + "plotting_matplotlib = importlib.reload(plotting_matplotlib)\n", + "required_plotting_kwargs = {\"cluster_sort\", \"cluster_order\"}\n", + "observed_plotting_kwargs = set(\n", + " inspect.signature(plotting.prepare_read_cluster_region_association_data).parameters\n", + ")\n", + "observed_matplotlib_kwargs = set(\n", + " inspect.signature(\n", + " plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib\n", + " ).parameters\n", + ")\n", + "if (\n", + " not required_plotting_kwargs.issubset(observed_plotting_kwargs)\n", + " or \"row_annotation_columns\" not in observed_matplotlib_kwargs\n", + "):\n", + " raise RuntimeError(\n", + " \"This notebook is using an older dimelo.plotting module. \"\n", + " f\"Imported from: {plotting.__file__}. \"\n", + " \"Restart the kernel or install this repo in editable mode with `python -m pip install -e .`.\"\n", + " )\n", + "\n", + "region_sort_mode = [\"genomic\"] # string or list, e.g. [\"cluster_fraction\", \"genomic\"]\n", + "cluster_sort_mode = \"natural\" # \"input\" | \"natural\" | \"total_association\" | \"max_association\"\n", + "association_strength_aggregate = \"max\" # only used when region_sort=\"association_strength\"\n", + "top_regions_per_cluster = 8\n", + "\n", + "association_summary_A = cluster.summarize_read_clusters_by_region(\n", + " metadata=rw_multi.metadata,\n", + " labels=clust_multi.labels_size_ordered,\n", + " include_strand=True,\n", + ")\n", + "association_payload_A = plotting.prepare_read_cluster_region_association_data(\n", + " association_summary_A,\n", + " value_mode=\"fraction\",\n", + " top_n_regions_per_cluster=top_regions_per_cluster,\n", + " region_sort=region_sort_mode,\n", + " association_strength_aggregate=association_strength_aggregate,\n", + " cluster_sort=cluster_sort_mode,\n", + ")\n", + "\n", + "axis_table = cluster.infer_region_source_labels(\n", + " association_payload_A[\"region_axis_table\"],\n", + " rw_multi.metadata,\n", + ")\n", + "source_priority = {\"on_target\": 0, \"off_target\": 1, \"unlabeled\": 2, \"unknown\": 3}\n", + "axis_table[\"strand_label\"] = axis_table.get(\"strand\", pd.Series(\"unknown\", index=axis_table.index)).fillna(\"unknown\").astype(str)\n", + "axis_table[\"_source_rank\"] = axis_table[\"source_label\"].map(source_priority).fillna(99).astype(int)\n", + "axis_sorted = axis_table.sort_values(\n", + " [\"_source_rank\", \"chrom\", \"start\", \"end\"],\n", + " ascending=[True, True, True, True],\n", + ").drop(columns=[\"_source_rank\"]).reset_index(drop=True)\n", + "region_order = axis_sorted[\"region_id\"].tolist()\n", + "\n", + "matrix_sorted = (\n", + " association_payload_A[\"matrix_table\"].copy()\n", + " .set_index(\"region_id\")\n", + " .loc[region_order]\n", + " .reset_index()\n", + ")\n", + "\n", + "association_payload_A[\"region_axis_table\"] = axis_sorted\n", + "association_payload_A[\"matrix_table\"] = matrix_sorted\n", + "association_payload_A[\"metadata\"] = {\n", + " **association_payload_A.get(\"metadata\", {}),\n", + " \"region_sort\": \"source_bed_then_genomic\",\n", + " \"cluster_sort\": cluster_sort_mode,\n", + "}\n", + "\n", + "print(\"Association payload metadata\")\n", + "display(pd.DataFrame([association_payload_A[\"metadata\"]]))\n", + "print(\"Region axis preview (sorted)\")\n", + "display(axis_sorted[[\"region_id\", \"chrom\", \"start\", \"end\", \"source_label\", \"strand_label\"]].head())\n", + "print(\"Source label counts\")\n", + "display(axis_sorted[\"source_label\"].value_counts(dropna=False).rename(\"n_regions\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Top regions per cluster\n" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "region_id", + "rawType": "str", + "type": "string" + }, + { + "name": "chrom", + "rawType": "str", + "type": "string" + }, + { + "name": "start", + "rawType": "int64", + "type": "integer" + }, + { + "name": "end", + "rawType": "int64", + "type": "integer" + }, + { + "name": "strand", + "rawType": "str", + "type": "string" + }, + { + "name": "cluster", + "rawType": "object", + "type": "unknown" + }, + { + "name": "count", + "rawType": "int64", + "type": "integer" + }, + { + "name": "fraction", + "rawType": "float64", + "type": "float" + }, + { + "name": "total_reads", + "rawType": "int64", + "type": "integer" + }, + { + "name": "value", + "rawType": "float64", + "type": "float" + }, + { + "name": "rank", + "rawType": "int64", + "type": "integer" + } + ], + "ref": "fead3234-1b1f-4e19-8989-6d81a7b7e496", + "rows": [ + [ + "0", + "chr14:17377273-17377423:+", + "chr14", + "17377273", + "17377423", + "+", + "0", + "23", + "1.0", + "23", + "1.0", + "1" + ], + [ + "1", + "chr14:17377341-17377423:+", + "chr14", + "17377341", + "17377423", + "+", + "0", + "23", + "1.0", + "23", + "1.0", + "2" + ], + [ + "2", + "chr15:38668760-38668867:+", + "chr15", + "38668760", + "38668867", + "+", + "0", + "19", + "1.0", + "19", + "1.0", + "3" + ], + [ + "3", + "chr15:38668760-38668909:+", + "chr15", + "38668760", + "38668909", + "+", + "0", + "19", + "1.0", + "19", + "1.0", + "4" + ], + [ + "4", + "chr16:61261359-61261509:+", + "chr16", + "61261359", + "61261509", + "+", + "0", + "18", + "1.0", + "18", + "1.0", + "5" + ], + [ + "5", + "chr16:61261438-61261509:+", + "chr16", + "61261438", + "61261509", + "+", + "0", + "18", + "1.0", + "18", + "1.0", + "6" + ], + [ + "6", + "chr16:61261439-61261509:-", + "chr16", + "61261439", + "61261509", + "-", + "0", + "18", + "1.0", + "18", + "1.0", + "7" + ], + [ + "7", + "chr17:44334564-44334713:-", + "chr17", + "44334564", + "44334713", + "-", + "0", + "10", + "1.0", + "10", + "1.0", + "8" + ], + [ + "8", + "chr17:45989477-45989793:-", + "chr17", + "45989477", + "45989793", + "-", + "1", + "17", + "0.9444444444444444", + "18", + "0.9444444444444444", + "1" + ], + [ + "9", + "chr16:4281324-4281640:+", + "chr16", + "4281324", + "4281640", + "+", + "1", + "22", + "0.9166666666666666", + "24", + "0.9166666666666666", + "2" + ] + ], + "shape": { + "columns": 11, + "rows": 10 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
region_idchromstartendstrandclustercountfractiontotal_readsvaluerank
0chr14:17377273-17377423:+chr141737727317377423+0231.000000231.0000001
1chr14:17377341-17377423:+chr141737734117377423+0231.000000231.0000002
2chr15:38668760-38668867:+chr153866876038668867+0191.000000191.0000003
3chr15:38668760-38668909:+chr153866876038668909+0191.000000191.0000004
4chr16:61261359-61261509:+chr166126135961261509+0181.000000181.0000005
5chr16:61261438-61261509:+chr166126143861261509+0181.000000181.0000006
6chr16:61261439-61261509:-chr166126143961261509-0181.000000181.0000007
7chr17:44334564-44334713:-chr174433456444334713-0101.000000101.0000008
8chr17:45989477-45989793:-chr174598947745989793-1170.944444180.9444441
9chr16:4281324-4281640:+chr1642813244281640+1220.916667240.9166672
\n", + "
" + ], + "text/plain": [ + " region_id chrom start end strand cluster count \\\n", + "0 chr14:17377273-17377423:+ chr14 17377273 17377423 + 0 23 \n", + "1 chr14:17377341-17377423:+ chr14 17377341 17377423 + 0 23 \n", + "2 chr15:38668760-38668867:+ chr15 38668760 38668867 + 0 19 \n", + "3 chr15:38668760-38668909:+ chr15 38668760 38668909 + 0 19 \n", + "4 chr16:61261359-61261509:+ chr16 61261359 61261509 + 0 18 \n", + "5 chr16:61261438-61261509:+ chr16 61261438 61261509 + 0 18 \n", + "6 chr16:61261439-61261509:- chr16 61261439 61261509 - 0 18 \n", + "7 chr17:44334564-44334713:- chr17 44334564 44334713 - 0 10 \n", + "8 chr17:45989477-45989793:- chr17 45989477 45989793 - 1 17 \n", + "9 chr16:4281324-4281640:+ chr16 4281324 4281640 + 1 22 \n", + "\n", + " fraction total_reads value rank \n", + "0 1.000000 23 1.000000 1 \n", + "1 1.000000 23 1.000000 2 \n", + "2 1.000000 19 1.000000 3 \n", + "3 1.000000 19 1.000000 4 \n", + "4 1.000000 18 1.000000 5 \n", + "5 1.000000 18 1.000000 6 \n", + "6 1.000000 18 1.000000 7 \n", + "7 1.000000 10 1.000000 8 \n", + "8 0.944444 18 0.944444 1 \n", + "9 0.916667 24 0.916667 2 " ] }, - "execution_count": 62, + "execution_count": 56, "metadata": {}, "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "from dimelo import plot_enrichment_profile\n", - "plot_enrichment_profile.by_modification(\n", - " mod_file_name=pileup_file_coded,\n", - " regions=ctcf_target_regions,\n", - " window_size=1000,\n", - " motifs=['A,0,a','CG,0,m'], # We know from above that these mod codes aren't present in our file!\n", - " single_strand=False, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", - " regions_5to3prime=False, # if set to True, regions on the reverse (-) strand will be flipped so everything is 5 prime to 3 prime\n", - " smooth_window=50,\n", - ")" + "association_payload_A[\"top_regions_table\"].head(10)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The `modkit` command below will make the bam file work for the to-spec mod codes m and a. However, you must use this command with caution: `modkit` can and will adjust any mod code to any other mod code; you need to verify yourself that they are actually equivalent and thus that the operation is in fact valid." + "#### Karyotype view of top associated regions\n", + "\n", + "This adds a genome-level view under **Top regions per cluster**:\n", + "- each chromosome is vertical and proportional to true chromosome length,\n", + "- coordinate increases downward (0 near the top, chromosome length near the bottom),\n", + "- loci are colored by cluster assignment, and\n", + "- optional haplotype-aware backbone shading is enabled when maternal/paternal naming is detected.\n" ] }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 57, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "modkit required: 0.6.1\n", - "modkit active : 0.6.1\n", - "$ modkit adjust-mods dimelo/test/output/ctcf_demo.updated.bam dimelo/test/output/ctcf_demo.recoded.bam --convert Y a --convert Z m\n" + "Wrote karyotype BED to artifacts/notebook/association_regions_by_dominant_cluster.bed\n", + "Using chromosome sizes from dimelo/test/output/chm13.draft_v1.0.fasta.fai\n", + "chr9: 9 plotted region(s)\n", + "chr12: 6 plotted region(s)\n", + "chr20: 30 plotted region(s)\n" ] }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[0;32m>\u001b[0m Converting Z to m\n", - "\u001b[0;32m>\u001b[0m Converting Y to a\n", - "[modkit-core/src/modbam_util/subcommands.rs:774:9] &self.cpg = false\n", - "\u001b[0;32m>\u001b[0m done, 1024 records processed\n" - ] - } - ], - "source": [ - "run_modkit_checked([\n", - " \"adjust-mods\",\n", - " \"dimelo/test/output/ctcf_demo.updated.bam\",\n", - " \"dimelo/test/output/ctcf_demo.recoded.bam\",\n", - " \"--convert\",\n", - " \"Y\",\n", - " \"a\",\n", - " \"--convert\",\n", - " \"Z\",\n", - " \"m\",\n", - "])\n" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": {}, - "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "''" + "
" ] }, - "execution_count": 64, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "ctcf_bam_file_recoded = output_dir / 'ctcf_demo.recoded.bam'\n", - "pysam.index(str(ctcf_bam_file_recoded))" + "from pathlib import Path\n", + "import pandas as pd\n", + "\n", + "from dimelo import cluster\n", + "\n", + "karyotype_chromosome_order = \"natural\" # \"length_desc\" | \"length_asc\" | \"natural\" | custom list\n", + "karyotype_min_visible_bp = 20_000\n", + "karyotype_detect_haplotype_shading = True\n", + "\n", + "matrix_table = association_payload_A[\"matrix_table\"].copy()\n", + "axis_table = association_payload_A[\"region_axis_table\"].copy()\n", + "cluster_columns = [c for c in matrix_table.columns if c != \"region_id\"]\n", + "\n", + "if matrix_table.empty or axis_table.empty or not cluster_columns:\n", + " print(\"No region-association rows available for karyotype plot.\")\n", + "else:\n", + " dominant_cluster = matrix_table.loc[:, cluster_columns].astype(float).idxmax(axis=1).astype(str)\n", + " dominant_by_region = pd.DataFrame({\n", + " \"region_id\": matrix_table[\"region_id\"].astype(str),\n", + " \"cluster\": dominant_cluster,\n", + " })\n", + "\n", + " karyo_table = axis_table.merge(dominant_by_region, on=\"region_id\", how=\"inner\")\n", + " karyo_table[\"name\"] = karyo_table[\"cluster\"].astype(str)\n", + " karyo_table[\"score\"] = 0\n", + " if \"strand\" not in karyo_table.columns:\n", + " karyo_table[\"strand\"] = \".\"\n", + " karyo_table[\"strand\"] = karyo_table[\"strand\"].fillna(\".\")\n", + "\n", + " artifacts_dir = Path(\"artifacts/notebook\")\n", + " artifacts_dir.mkdir(parents=True, exist_ok=True)\n", + "\n", + " karyotype_bed = artifacts_dir / \"association_regions_by_dominant_cluster.bed\"\n", + " karyo_table.loc[:, [\"chrom\", \"start\", \"end\", \"name\", \"score\", \"strand\"]].to_csv(\n", + " karyotype_bed,\n", + " sep=\"\t\",\n", + " header=False,\n", + " index=False,\n", + " )\n", + "\n", + " chrom_sizes_path = None\n", + " if \"ref_genome_file\" in globals():\n", + " ref_path = Path(str(ref_genome_file))\n", + " candidate = ref_path.with_suffix(ref_path.suffix + \".fai\")\n", + " if candidate.exists():\n", + " chrom_sizes_path = candidate\n", + "\n", + " if chrom_sizes_path is None:\n", + " inferred_sizes = (\n", + " karyo_table.groupby(\"chrom\", as_index=False)[\"end\"]\n", + " .max()\n", + " .rename(columns={\"chrom\": \"Chromosome\", \"end\": \"Length\"})\n", + " )\n", + " inferred_sizes[\"Length\"] = (inferred_sizes[\"Length\"] * 1.05).astype(int)\n", + " chrom_sizes_path = artifacts_dir / \"inferred.chrom.sizes\"\n", + " inferred_sizes.to_csv(chrom_sizes_path, sep=\"\t\", header=False, index=False)\n", + "\n", + " fig = cluster.plot_cluster_karyotype(\n", + " region_bed=karyotype_bed,\n", + " chrom_sizes=chrom_sizes_path,\n", + " chromosome_order=karyotype_chromosome_order,\n", + " invert_position_axis=True,\n", + " detect_haplotype_backbone_shading=karyotype_detect_haplotype_shading,\n", + " min_visible_bp=karyotype_min_visible_bp,\n", + " )\n", + "\n", + " print(f\"Wrote karyotype BED to {karyotype_bed}\")\n", + " print(f\"Using chromosome sizes from {chrom_sizes_path}\")\n", + " for chrom in [\"chr9\", \"chr12\", \"chr20\"]:\n", + " n = int((karyo_table[\"chrom\"].astype(str) == chrom).sum())\n", + " print(f\"{chrom}: {n} plotted region(s)\")\n" ] }, { - "cell_type": "code", - "execution_count": 65, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "WARNING: no modified appropriately-coded values found for [] in the first 100 reads. \n", - "Do you expect this file to contain these modifications? parse_bam is looking for ['A,0,a', 'CG,0,m'] but for [] found only found [].\n", - "\n", - "Consider passing only the motifs and mod codes (e.g. m,h,a) that you expect to be present in your file. \n", - "You can use modkit adjust-mods --convert [OPTIONS] to update or consolidate mod codes.\n", - "See https://github.com/nanoporetech/modkit/blob/master/book/src/advanced_usage.md\n", - " \n", - "No specified number of cores requested. 10 available on machine, allocating all.\n", - "Detected multiple motif contexts with modkit 0.6.x; running per-motif pileups and merging outputs to avoid mixed-motif empty output behavior.\n", - "Modification threshold of 128.0 assumed to be for range 0-255. 128.0/255=0.5019607843137255 will be sent to modkit.\n" - ] - } - ], "source": [ - "pileup_file_recoded, pileup_regions = ensure_pileup_output(\n", - " input_file=ctcf_bam_file_recoded,\n", - " output_name='ctcf_demo_pileup_on_target_mod_code_specified_adjusted',\n", - " ref_genome=ref_genome_file,\n", - " output_directory=output_dir,\n", - " regions=[ctcf_target_regions,ctcf_off_target_regions],\n", - " motifs=['A,0,a','CG,0,m'],\n", - " thresh=128,\n", - " window_size=1000,\n", - " # cores=1,\n", - " # cleanup=False,\n", - " # log=True,\n", - " quiet=PARSE_QUIET,\n", - " modkit_executable=MODKIT_BINARY,\n", - ")\n" + "#### Association heatmap\n" ] }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 62, "metadata": {}, "outputs": [ { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a41b60014d6443a69d635f36af2fc4e5", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Loading data: 0%| | 0/50 [00:00" - ] - }, - "execution_count": 66, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -5724,51 +7898,71 @@ } ], "source": [ - "from dimelo import plot_enrichment_profile\n", - "plot_enrichment_profile.by_modification(\n", - " mod_file_name=pileup_file_recoded,\n", - " regions=ctcf_target_regions,\n", - " window_size=1000,\n", - " motifs=['A,0,a','CG,0,m'],\n", - " single_strand=False, # if set to True, regions that specify the strand will only pull from reads on the strand (as opposed to both strands)\n", - " regions_5to3prime=False, # if set to True, regions on the reverse (-) strand will be flipped so everything is 5 prime to 3 prime\n", - " smooth_window=50,\n", - ")" + "import matplotlib.pyplot as plt\n", + "\n", + "fig, ax = plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib(\n", + " association_payload_A,\n", + " region_label_mode=\"chromosome\",\n", + " max_region_labels=24,\n", + " row_annotation_columns=[\"source_label\", \"strand_label\"],\n", + " row_annotation_titles={\n", + " \"source_label\": \"Source bed\",\n", + " \"strand_label\": \"Strand\",\n", + " },\n", + " row_annotation_palettes={\n", + " \"source_label\": {\n", + " \"on_target\": \"#D95F02\",\n", + " \"off_target\": \"#1B9E77\",\n", + " \"unlabeled\": \"#7570B3\",\n", + " \"unknown\": \"#999999\",\n", + " },\n", + " \"strand_label\": {\"+\": \"#4C78A8\", \"-\": \"#F58518\", \".\": \"#999999\", \"unknown\": \"#999999\"},\n", + " },\n", + " cluster_sort=cluster_sort_mode,\n", + " group_region_labels=True,\n", + " group_label_columns=[\"source_label\", \"chrom\"]\n", + ")\n", + "plt.show()\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Two-window raster demo\n", + "# Two-site raster demo\n", "## What it does:\n", - " - selects two windows from the same read at a strict fixed offset,\n", + " - selects two sites from the same read at a strict fixed offset and displays a window around each site,\n", " - keeps row sorting matched across motifs,\n", " - shows either read-coordinate spacing or local window-centered coordinates,\n", " - supports uniform, random, and heatmap bin-mean downsampling.\n", "\n", - "The default two-site view keeps window 1 centered at 0 and window 2 at the requested offset in read coordinates. Use `coordinate_mode=\"local_window\"` when you want each panel centered on its own selected site.\n" + "The default two-site view keeps Site 1 centered at 0 and Site 2 at the requested offset in read coordinates. Use `coordinate_mode=\"local_window\"` when you want each panel centered on its own selected site.\n" ] }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Two-window fixed-offset raster stats: {'pairs': 56, 'rows_are': 'reads', 'unique_reads': 56, 'site_sets': 56, 'rows_before_downsample': 56, 'rows_after_downsample': 56, 'downsampled': False, 'downsample_method': 'none', 'coordinate_mode': 'relative_to_primary', 'selection_mode': 'fixed_offsets', 'window_offsets_bp': [0.0, 2000.0], 'window_widths_bp': [2000, 2000], 'ml_score_thresholds': None, 'observed_offsets_bp': [{'n': 56, 'min': 0.0, 'median': 0.0, 'max': 0.0, 'unique': 1}, {'n': 56, 'min': 2000.0, 'median': 2000.0, 'max': 2000.0, 'unique': 1}], 'site_selection': {'mode': 'fixed_offsets', 'n_windows': 2, 'min_distance_bp': 2000, 'max_distance_bp': None, 'selection_multiplicity': 'one_per_read', 'choose': 'first', 'selection_seed': None, 'anchor': {'mode': 'first'}, 'strand_relation': 'any', 'orientation': 'genomic', 'excluded_sites': 0}}\n", + "Two-site fixed-offset raster stats: {'pairs': 56, 'rows_are': 'reads', 'unique_reads': 56, 'site_sets': 56, 'rows_before_downsample': 56, 'rows_after_downsample': 56, 'downsampled': False, 'downsample_method': 'none', 'coordinate_mode': 'relative_to_primary', 'selection_mode': 'fixed_offsets', 'window_offsets_bp': [0.0, 2000.0], 'window_widths_bp': [2000, 2000], 'ml_score_thresholds': None, 'observed_offsets_bp': [{'n': 56, 'min': 0.0, 'median': 0.0, 'max': 0.0, 'unique': 1}, {'n': 56, 'min': 2000.0, 'median': 2000.0, 'max': 2000.0, 'unique': 1}], 'site_selection': {'mode': 'fixed_offsets', 'n_windows': 2, 'min_distance_bp': 2000, 'max_distance_bp': None, 'selection_multiplicity': 'one_per_read', 'choose': 'first', 'selection_seed': None, 'anchor': {'mode': 'first'}, 'strand_relation': 'any', 'orientation': 'genomic', 'excluded_sites': 0}}\n", "Vertical-axis scatter stats: {'pairs': 56, 'rows_are': 'reads', 'unique_reads': 56, 'site_sets': 56, 'rows_before_downsample': 56, 'rows_after_downsample': 56, 'downsampled': False, 'downsample_method': 'none', 'coordinate_mode': 'relative_to_primary', 'selection_mode': 'fixed_offsets', 'window_offsets_bp': [0.0, 2000.0], 'window_widths_bp': [2000, 2000], 'ml_score_thresholds': None, 'observed_offsets_bp': [{'n': 56, 'min': 0.0, 'median': 0.0, 'max': 0.0, 'unique': 1}, {'n': 56, 'min': 2000.0, 'median': 2000.0, 'max': 2000.0, 'unique': 1}], 'site_selection': {'mode': 'fixed_offsets', 'n_windows': 2, 'min_distance_bp': 2000, 'max_distance_bp': None, 'selection_multiplicity': 'one_per_read', 'choose': 'first', 'selection_seed': None, 'anchor': {'mode': 'first'}, 'strand_relation': 'any', 'orientation': 'genomic', 'excluded_sites': 0}}\n", "Heatmap stats: {'pairs': 56, 'rows_are': 'reads', 'unique_reads': 56, 'site_sets': 56, 'rows_before_downsample': 56, 'rows_after_downsample': 56, 'downsampled': False, 'downsample_method': 'none', 'coordinate_mode': 'relative_to_primary', 'selection_mode': 'fixed_offsets', 'window_offsets_bp': [0.0, 2000.0], 'window_widths_bp': [2000, 2000], 'ml_score_thresholds': None, 'observed_offsets_bp': [{'n': 56, 'min': 0.0, 'median': 0.0, 'max': 0.0, 'unique': 1}, {'n': 56, 'min': 2000.0, 'median': 2000.0, 'max': 2000.0, 'unique': 1}], 'site_selection': {'mode': 'fixed_offsets', 'n_windows': 2, 'min_distance_bp': 2000, 'max_distance_bp': None, 'selection_multiplicity': 'one_per_read', 'choose': 'first', 'selection_seed': None, 'anchor': {'mode': 'first'}, 'strand_relation': 'any', 'orientation': 'genomic', 'excluded_sites': 0}}\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -5776,9 +7970,9 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -5786,9 +7980,9 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -5812,7 +8006,7 @@ "raster_ml_thresholds = None # example: [0.70, 0.80]\n", "raster_motif_colors = [\"#1f77b4\", \"#ff7f0e\"]\n", "\n", - "# Sorting controls. Window 1 is the primary window for the two-site wrapper.\n", + "# Sorting controls. Site 1 is the primary site for the two-site wrapper.\n", "raster_sort_by = \"mod_fraction\" # \"mod_fraction\" | \"cluster\" | \"window_center\" | \"read_name\" | \"region_start\" | \"read_length\" | \"none\"\n", "raster_sort_window_index = 0\n", "raster_sort_descending = True\n", @@ -5821,27 +8015,6 @@ "show_heatmap_variant = True\n", "\n", "\n", - "def _raster_stats_brief(stats):\n", - " keys = [\n", - " \"pairs\",\n", - " \"rows_are\",\n", - " \"unique_reads\",\n", - " \"site_sets\",\n", - " \"rows_before_downsample\",\n", - " \"rows_after_downsample\",\n", - " \"downsampled\",\n", - " \"downsample_method\",\n", - " \"coordinate_mode\",\n", - " \"selection_mode\",\n", - " \"window_offsets_bp\",\n", - " \"window_widths_bp\",\n", - " \"ml_score_thresholds\",\n", - " ]\n", - " brief = {key: stats.get(key) for key in keys if key in stats}\n", - " brief[\"observed_offsets_bp\"] = stats.get(\"observed_window_center_offsets_summary_bp\")\n", - " brief[\"site_selection\"] = stats.get(\"site_selection\")\n", - " return brief\n", - "\n", "fig, stats = cluster.plot_two_site_read_raster(\n", " read_windows=rw_multi,\n", " second_site_offset_bp=raster_second_site_offset_bp,\n", @@ -5867,7 +8040,7 @@ " downsample_method=raster_downsample_method,\n", " downsample_seed=raster_downsample_seed,\n", ")\n", - "print(\"Two-window fixed-offset raster stats:\", _raster_stats_brief(stats))\n", + "print(\"Two-site fixed-offset raster stats:\", cluster.raster_stats_brief(stats))\n", "\n", "if show_vertical_axis_variant:\n", " fig_vert, stats_vert = cluster.plot_two_site_read_raster(\n", @@ -5895,7 +8068,7 @@ " downsample_method=raster_downsample_method,\n", " downsample_seed=raster_downsample_seed,\n", " )\n", - " print(\"Vertical-axis scatter stats:\", _raster_stats_brief(stats_vert))\n", + " print(\"Vertical-axis scatter stats:\", cluster.raster_stats_brief(stats_vert))\n", "\n", "if show_heatmap_variant:\n", " fig_hm, stats_hm = cluster.plot_two_site_read_raster(\n", @@ -5920,21 +8093,21 @@ " downsample_method=\"bin_mean\",\n", " downsample_seed=raster_downsample_seed,\n", " )\n", - " print(\"Heatmap stats:\", _raster_stats_brief(stats_hm))\n" + " print(\"Heatmap stats:\", cluster.raster_stats_brief(stats_hm))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Co-occurring-region raster demo (two windows)\n", + "### Co-occurring-region raster demo (two sites)\n", "\n", - "This uses the full `plot_multisite_read_raster` selector. It finds reads with two regions separated by at least the requested distance and plots each selected region in its own local coordinate system. The same mode supports arbitrary numbers of windows by increasing `n_windows`.\n" + "This uses the full `plot_multisite_read_raster` selector. It finds reads with two regions separated by at least the requested distance and plots each selected site in its own local coordinate system. The same selector supports arbitrary numbers of sites by increasing `n_windows`.\n" ] }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 37, "metadata": {}, "outputs": [ { @@ -5946,9 +8119,9 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6YAAAJVCAYAAADN8+joAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQeYJEX5xr/N8XYv35GzZMkZDAgigigmzATlL4oJFBADCiYEBQwoJsCAoihgAEFBUTJKlCiS0x1c2tsc+/+81fPN1tRWh0k7szvv73n25ma6p7u6urqn3v5SXRAEgRBCCCGEEEIIIRWivlI7JoQQQgghhBBCAIUpIYQQQgghhJCKQmFKCCGEEEIIIaSiUJgSQgghhBBCCKkoFKaEEEIIIYQQQioKhSkhhBBCCCGEkIpCYUoIIYQQQgghpKJQmBJCCCGEEEIIqSgUpoQQQgghhBBCKgqFqYgcfPDB8r3vfU9qmVe96lVyww03lHSbnZ2d8p///EdmIk8//bRpf09Pj1QbRx11lHziE5+Q2Xq9XXzxxbLjjjum3t4Xv/hFedOb3lRwe+rq6uSee+6JXD537tzIa6PYfacB5xrnvNqv90r1wZNPPmnO4Zo1a2QmkPZ8vvTSS7L//vtLV1eXvO1tb5uWth133HFyyimnzLht33jjjbL++utLpXnd614nV199dcHfv+SSS2TvvfeWagHtefe73x27Dq6/jTfeuGT380Ip9b34q1/9qrzzne+sqvt2pUhzfW277bbypz/9SaqJmfY7R0IoTEXkz3/+s3z4wx+WmUDSJLqa6Ovrk+23316q+bzvvvvu0t3dLfPmzZPddtstO6nYcMMNTfuxrFRi8POf/7zpj8bGxhktLEt5veFHA8KPzF4wOTjvvPMq3YwZxw9+8ANpaGgwgvuyyy6blon8BRdcIF//+tdLvq9SbPvnP/+5uX9CqC9YsED23Xdf+de//mWW7bfffvLss8+WdMz93//9n2y55ZZSX1+falt///vfzcOE17/+9QXvEyLwlltukWoBwuyOO+6Qu+++W2qNz3zmM/KrX/2q0s2oCtJcXw888IAceuihFWjdzAb3YcwJYQjRv1//+tc565x++umyZMkSc+/DPQJz03yW+3jZy14WeV3jXONhKOZm+DvooINylj/44IPmszlz5sj8+fPl/e9//5RtBEFg7tGFPDSuKWE6NjY2pePGx8entQ2jo6PTur9K7L8Sx5jvPh977DFz4eHHZ9WqVfLCCy/IN77xDXOhlYvNN99czjrrLDnssMPKtg8ys+9PuCfNlvtNJe6vs4knnnjCWCEgjKrxt2S6LTYf+9jH5Pvf/77xYoFHC+7dLS0tZdvnDjvsYDw78PAyDeeff74cffTRBe9vus9nmvsNxh4murXuUUZmP+X4/U0LBD3EpP4dccQR2WUXXXSR/OQnPzH3QNz3Vq5cae6FaZf7ePjhh2VoaEh22mmnKcv6+/vl1a9+tbn/PfPMM7JixQr58pe/nF3+/PPPG0+et7/97fLiiy+aufPxxx8/ZTu4ZxR6f85LmK5du1Y+8pGPyEYbbWSUOSxMaDhYvny5aeiiRYuMtemzn/1sjhD8y1/+YjoBFqidd95ZrrvuuuyyiYkJ+fa3vy1bbbWVEQZbbLGFXHPNNYnL3Kc2sCRCnStYfvLJJ8trX/ta6ejoMJYauJx87Wtfkz333FPa29uN8re3oxacH//4x7LBBhuYJ7PYhs13vvOd7LLPfe5zxk0F7ipxbixf+MIXZOnSpfKOd7zDDLw3vvGNsnjxYtMfr3jFK+Tee+/Nfueuu+4y7UMfL1y4UN7whjeYz/UHEq4+eKoCVxMVWVgHfY9zg0GEfovafyGgX7/1rW+ZJ8joH1w46uaqrnS4QCC+1OXDtu7iqRAuvg9+8IPmmDfZZBPT11deeaX5DiyWGDMKLrADDzzQHBOWHXLIIWY/CiyYeEqDMYd+OvPMM6W1tdVM5hRcePju7bffPuV48KQIT5hgMYBVAt995StfaZ4M2seEJz0Yf3BpwoWGfsdkUScSp512mmy22WZmLEBw4qKN4sgjjzRurGhvEsPDw3LMMceY84/+2m677bLWAb154FzimsA5sd1Vent7zdP+ddZZx/zBhQ7rgw996EPy6U9/2vwfN2H0rz0mdtllF/nd735n/o9rBUIaYxH7Qf/o9e4CS4i7HXxPectb3iLf/OY3zf/1esMNFP2BcaRPCnFzVb70pS+ZawTnKcligXsNxgP6FveIK664IrsM5+nUU0819yUcL8YuLBs+cN3Aso19rrvuumaymUQx+8YY++53v2vOL+5RuDf885//NJYh9Meb3/xmcz5tyn29Y1zA5RLfxzHhyaq6aGEZziPGPJ6UwnXx8ccfz37Xvb/i+sQ5xfZwPDjfAMeJ3xL0C87x+973vhy3+aQ+8AGrIvaPaxEW+ZGREfM5fnfc+zPaHWW902PA7xvOCdqMh1fYJu59OMe2VSvueiv0WPDQ7Gc/+1n2noOJRyG/JQBWH0wycC4xXrAd3Hfx+4HzqteezzPk3//+t+yzzz7muLfZZpscCxLu6RiHOI9YjnPpPum3sbet91dYQXH/x/exPEqc4R6OeYM+gcd5gWXy5S9/+RTPi09+8pMFjTkXTLZe85rXmN+GJNBuzEswYVP0fEFAY0xiv7bA099E3JNxLeG+7Lq95jsWf/GLX5h7Ce7X2B/uZfZk273f4LcN92ObSy+91JxrBX3wxz/+UUpF0lzxzjvvNP2IPsE6H/3oR83nacZ6EhhHuEYVjJWmpqashQlzO51vuR4F6DtY/dF3uJbwe5/PPSvqWsKx43xBLAD0Nfal81yEQ+E7aR7y6XWA48Bx4j6B+4U9BjBGtt56a7MerifMNxXMczCm0J711lvP/Abb2427vjBWcV9Jsx+MOfwuqtUN13ZS2Bf6aa+99jJzbvca1d+/fPH9/pbiPOEaPfzww838E59hPvTUU08V1MYLL7zQCE38DmNbOCdo0+DgYKrlPtB2HecuuAdh3ol+xvHCmov7j3Luueea6xNznra2NiM+cf5sME8855xzzPyxIII8OPzww4ODDjooeO6554Lx8fHgrrvuCl566SWzbP/99w/e9a53Bb29vcGTTz4ZbLPNNsFXvvIVs+zRRx8NWltbg9/97nfB6OhocNlllwVtbW3B448/bpZ/61vfCjbZZJPg3//+dzAxMRE89dRTwYMPPpi47JWvfGVw7rnnZtt399134+rLvsfyRYsWBbfffrv57sDAQLDRRhsFL3vZy4KHH344GBsbC4aHh3O28/e//z2or68PTjjhhGBwcNDsq7293XwOrrvuumDu3Llmm/ju5z//+aCxsTG46KKLvH2GzxsaGoIzzjjDrN/f3x/09PQEl156adDX12f28bGPfcy0CW0Ee+21V/DlL3/Z9PHQ0FDwj3/8I7s9HB+OU8H2cExoP7aP/tl2222DH//4x5H794E+0GP0gf3usssu5tyvXr06OPDAA4OjjjrKLHviiSfM8je96U1mme7DbusXvvCFoKmpyYwB9Dv6bb311jPbQD888MADQUtLS3DnnXdmt3n11Veb/kF/vfWtbw0OOOCAbHuOPPJIM4auueYa00/Y51ve8hazH+WXv/ylGYc+MPYwJo877rjgz3/+c7By5cqc5XpMOB7d38c//vGcdU466SQz7p9//nnTt5/85CeD/fbbL7IP7ba723L5wQ9+EOy8885m/xgXjzzySPD0009nvz9nzhxzvtCXX/rSl8wYUI4++ujg1a9+dbBixQpzfeLcHnvssWbZr3/962D33Xc3/7/nnnuCTTfdNFi6dKl5v2rVKjOWtS+wze233970Fc7DwQcfbPbtA9fDkiVLstvB/+fPnx+sXbvWtB//x/0CuNdbd3d3zrYwZtGOb3zjG8HIyIhZB+//97//efeNc44xfsEFF5j7yx/+8AczlnT9008/Pdhuu+3MtYH70xFHHGHGr2KP05/85CfB+uuvHzz00ENmTGF84n4QdW2UYt+43nFd4VrHOUN/2Ntrbm7O9vt0XO/XXnut6QO0CWAfGH/gpz/9abDuuusG9913nxkTJ554ornG0FaQdH9V3va2twXvfOc7zfjG9f+Od7wjeM973pMdP3F94KLXKsYntod277DDDsEXv/hFs/w73/mOaYPy7LPPmu3huvWBY8D3cb2tWbPG9O8WW2yRvXeddtpp5rpIc73leyxx94lCfkuwP1x7119/vblPLl++PHsdYuy+8Y1vjNwn+nLBggXBt7/9bXMd3nDDDUFHR0dw00035dzTcU9Bv2BsdHZ2mms+6Xj0nGEMYH2cM4y5qN/Rm2++2ezr05/+dPC3v/1tyj7c+0i+Yy4O37Zc8PtVV1dn+sE9X5/5zGfM+brlllvMfVt/z/XegfUwNnA+8X+MvULHIn4zca3i/OOetnjx4uAXv/hF7P0Gv4M6FwOvfe1rg7POOiv7Huvge1HXC86l/fvj4h5T3FwR12ZXV1dw/vnnm/GMPvnnP/9pliWNdd94dkE/4xzoHHLHHXcMNttsM9NvAHOYc845x7s99AGuc1xDGEM77bRTdr6RdJ0nXUu4d33ve98z///EJz5h2nTyySeb9+edd15w2GGHBWnQ+St+t9B3+B3DdXXxxReb5Rh7uEbxinZgXGOOjLGFfsXvrI5PtPmOO+5IfX1hDFxxxRWJ+9HvY/6HOQj6C/dL+x4dBcbpvHnzTHuuvPJKs82ocZl2XmtfD5j7lOI8nXrqqcGhhx5qzgGuU1yL7hxTwRjCmMR9Gtf2Zz7zGTO+FVwPf/3rX7Pv0S60G32XZrmPfffd18ydfeA+ifn26173OtPXmIdeddVV2eW77babOV977723aTO2ddttt+Vs45BDDgl+9rOfTZlHpyW1MF22bJnZASYpLriZYBnWUS655BLTyQAiCwdpg8mZ3oy22mor86PmI25ZGmHqCgCd1EVtB4MYPzD2hA6CCJNkcMwxxwTHH398ziDABRsnTHHyMCmIAicN7UY/gle84hXmxD/zzDNT1nWF6W9+8xtzc7X54Q9/aG7+afef9gLGBETBQMSNF9vVwWe3y20rLr4999wz54ccyzGBtQf8j370I+/+sR1M+PU4cMN3f4Tw44KHGPpDhR/Ys88+O/KYIIIxMcENEjdznOfHHnsslTDFPnDDsi9+3EywHRWQxQjTCy+80Fw/mMy45w7fh8Bxrz9MILAuzot9o8CkTvsOP6r48cGPPH6AIa4hnHA+Lr/88pyxhGvl+9//fvY9JjhY1wduvrhB6nZwc8ONGTc0TIQxBvW8pBGmKpaVzTffPPjtb3/r3TfG1tZbb53zGe43EOz6XUxoFPwIob9UeNnjFNfN17/+9Sn3vThhWuy+9ccc4Gbu255OcKbjesfEf+HChcFf/vIXc3+zwTVy5plnZt/jxxw/qhhjae6v4MUXXzTXCSZzyn//+18jPDCOkvrARa9VPBxR0OeYNADsx34Q+tWvftX8cEaBY8AEU8E14t678BsBsZF0veV7LEnCNN/fEuwLD0d8JAlTXO/4/bXB75KKbnx/jz32yC7D9Y2+wEPkpOPRc4aJs/KBD3wg+MhHPhJ5bBDXePiIySjGCv6PsZRm4pw05ooVppi44vfABucL90T7GsKD0Pe///3Z/rMFm37HFaZpx6IP9Df6VXHvN+Dtb397VmBh3GDsvvDCC1MmuthXscI0aa6IewvEXxrcsZ5GmILXv/71RvhCKOB3BnM79CuuK0zE9TfdJ0zxEFvBvBa/cSDpOk+6lvAgAL+Z4OUvf7nZHuZDAGIHoicNuA7QTvzOK+jT17zmNeb/GAsYgzYQ9zgHEKa4T2K8YX7gbjcfYRq3H/3+KaecknP9QMimAQYHzNkgIP/4xz8WPa+1r4dSnSc8MILgjROHyv3332/m+hh///nPf8y1gocuCu5b//rXv3K+A2PZjTfemGq5C+aJMK7ht9sHxgq2iX7BtY9XjAsYGAF+V3GucM5w38GDX8wX9N6K86PjrVBhmtqVF2ZomGzheuELlIW7C9zflE033TQbLI1XN2ubvRzbhvtA1H6jlqXB117fZzZw04AbmgITv7plwFUTbrwK3EBs1xAfcImw44RgYocrDvoE+9K+gS+3mubhhgrzP1yY4WoQBVyi7r///myQMv7garFs2bLI/RcK3MDs/8NVznZLTOpXe3xo/7qfqUsNtvuud73L9DX6CG47cG+13WPc/cEtBG36xz/+Ic8995x5fe973xvZHrgfwJUM4/C///2vcXd5z3vek6ovcK7grod2ab/Dbaa5uTnS3TUf0G64tsEtEG4V+L+OD4B92eMToG/Qb+gD+3rDtYa+w/fhBgXXX7ji/O1vfzOxBHCFQeIOvLdd0Xz7iXJDhDs03KB1O+524bpju9knYY+LpH27Y1PfYwz47j9w0cW9zE7moOD6treFdiTFSRS7b3scu/t3tz8d1zvOHZIpwA0QYw9u2Ooi7x4PjgXHFHU8PnAMcL2CO78eA1yF0GYcR1IfpL0/6TmAOxVcAH/605+a93iFm3wc7n3JfY97xcDAQOL1VuixlOq3pJjfz6Tfbff+gOsbrl1pXJV930+6xnFv+u1vf2vimhDWAJf2j3/846n2kzTmigVjDOPBdbfEtYE5gm9cprlW8hmL4NprrzWhPhoCAtdT+3fDt09cC3Abx3bwitAn+7wghEuPsViS5opx4zVprOdzf8PvEv7w+62/UwjvwXhQ9/B8xmvSdZ50LaFNcJfF/UTnPhizq1evNi7C7u9yHOhf/M6n+T0CuCbwOY4HLp6///3vzbwL7rfol0KI209UX6ZJ2APgIovrDNdWKZIt2ddDqc7TSSedZOZDcFnHceI+FeVai9AwhL9h7MGl+Ktf/WpOSIRbHQIuxbjeNR9K0nIXJPjEmI+a12B7uIfAjR33LrxCiyAcU5fjM7g7Y76L8AiMuVtvvdW4MCMkAbkAiiH17AWDGz+2vkk3OhVCCrEDCk6Wxhri1Y4PdJdj2//73/8i9xu1DB2kN2SAINwpB+iZoBUzacPFYPcBBoFvv3H7Q4wW4ihuuukmc9PXvtE4AMRv4QcCP5iIdf3Upz5l1gfu5B43EAwaxELqH7aJDGmlOF4b20ceMaAYlIgBKfV+AOIPcG4Rl4DjwUUP7FgJd394DwEHH3n0H4SqK3CiQJ/j5hEV5+DuCzFDmBQgZsXue9x8SpHuH379iE1CDM1DDz1k+htiIQmcD5wX+3rD/3ETwmRFb65//etfzY0EN0/cTG1BWSj6g68CN812yzE2AfoLk3jf/QfXFe5lvvT3uL7tbWESjHXLuW+7D9z96/am+3rHBPC2224z+8bY0WQK7vFAlGFSFnU8vvc4BnyG79nHgd8Q9FtSH6S9P+k5AIiHwT0B8XiIbY6Kr8mXpOut0GMp1W9J3O9n0jhJ+t2uJIiZhaBKe79OGnPFAjGF34NHHnkk53Psz46bdcdlKX8zcS0ithF5HCBEMFnFg003oYu7T+RywDwGD3Lx0MZN4IQ8HPgdTXoAn4akuWLceE0a62lRcXH99deb3yiMJZwX5AbI9wGqknSdJ11LiIPH+YMRArkc8KAXwhC5FSAOIFjSgv7F71aa3yO3HRAsEC4Q+4hzhwDxxW9W8t6B+TBiP/E7iljaYrGPpVTnCdoEOQxwP8A8C2MtbQKxeqdv8aDErsSB/+P3BTGlaZa7/OEPf4hNwInrIY645ffdd5+55yEWGL9/GnuK+TUeKqYl9V0RNyY8dcaNDkIMgxVPmPAjj0GPix0DBlYkXAhf+cpXTLIXgIQfuBHgSQxugJdffrkRGpqYAzdSTLrRobjJ4PuYjCctw0FjW7gB40IsONA2z/Tpv/zlL02ANH5wkHjETnSRBtxU8YQBTyDxlAgCxAYTKNy4cYPEk10MVFwAeh7wpFjBEyOsi0GPGxKeJOFiKEftprPPPjv7w46kPzh/pfxhdfsIP/Q4foyxNKIMYLKCMYFkIXFWEVgM0WearAiC4Uc/+lGkqES/I8mL/gjiuHEtwFqlDyrQzrjkHxgveo7wh/9HJfuAmMOYx/WCp4kYLxCrSaBdeIqHhBJ4eoU2YXzBAqvnCtcqElXhxoUbKG6wuHHCaownyIWC7eKpGq5HWGWRCAJPGjHhiXrii37FU2f7h7QQ0HacP/TXVVddZfpPM9vBCo6nkDhPuN5OPPFEOeCAA8xkwnd9I+ERriE8ZMADkqQxXqp9AyT5wqTS3d50Xu+wRkHA4QcYFjCMPx17OB78KGOyiokBEiTg/h+XudS9Z+EJMiY8eNKq1g5cf5o0KqkPojjjjDPMvQnXNBLG2PUXMeHCtQvBjWOwrVjFkHS9FXospfotwe8nktbhGsRvNq4zLRGA84LJtJutXkFyIayPsYZ1cM9EchQkDZpukFQF3i3qoQMLflzNz3zHnA+Mf1xj6DccP/4f1VcYT3gQ6lqYMDdAMhJsCw8x09QFLRRcj2gjHppiYor9Ya6SBMYpxCgSU2EMu1YojFeM41KQNFdE36A8DSy9OB48nNaEeEljPS0QFziPOBdoC+ZZeEALkZOPZdIm6TpPupYwv8NvLwSOPsRFW/DeFcuw6EUl29Tzid8t/H7htwG/ZzrmcO/Dfm+++WbTDhwz7lloH35XcD3g9xj3e1ilo+Yc7vXlErefYoCo+s1vfmMSKyHBD35/IIZKRanOE5LKYV6Aewf6EfeHqL5En6NvAM7XZz7zGeOlpODaRJKyRx991MytMPfGbw5+m9Mst8F9CIln484DjhUGIRwD2o9XvNeSMccee6zRcri/YP6h1yruxRCkuDdj7oo/Lb+Ifszn3OelKvA0DU8ed911VyMYMDFX8zRugPg/nnjBxIsLVbPZIusexAKygyHTGiYQOBkwkQM8jUdmOpi9YX7GxE2fNsUtO+GEE8xTPLQJg8NOsVwusH8cB37k8GOHwYsJfj5pkTE5xQDHxY0nLDiZNhg4eCoB0YCHARCEmqkPP3LoE9yckYkW62B9CAvNSIlBWQr3JN/NBhcjzjHOBSY85QJCFE9OcZwYT5r5LQmMKYxP3FzjfkyxXbg9wfqEiTcecuAzdfdz+cAHPmB+eDB+1dUHk1+cO4w99Ift7uADFzRuFripYnKP/+MzH/iRgEjCdQYXGLhlYdylAecFYwFPFeEmgusPGdIU3EDRP/ojjG1jDKP9aTIGR4ExipuvZnnETRqiF31jZ3m0gYCFNQvLcax4Gl4IyLIKCx/ODyzf6GN1CdPsfzhX6Bc8DMByH3iYgXGOiQrGEiYxSSWESrVvgG3gpo9zqNnB7YnsdFzvmABCwGHbuMdB6Om1jh8tZMnE5BXLYNGH+1fcQxNMeNFmHI9OejGxUndKjDn0t3qFJPVBFLhXYgzinrrHHnvkTFwxFvEDjvYWU9Ij3+ut0GMp1W8JfqfQFmSvxHWO/lYrIywi6HtYfX21hHE/RCZ7jFeMBWQehosWLATTDfoRwhR9jGsA9xgci2b6LnbM+YBLK+7RmFTBNQ//t8smuKCPXcGAc4I5AuYpb33rW40IK8YrJQ7cpyBCcJ5wfNhX2jkRrglM8N2HNpiYYmLuKwdRKHFzRVimcG/DOhjTuK7U0pI01tMC4QZxgf5SqxIeXOG+V6gwTbrO01xLGBd2G3xt0hABO+O9C44L90H8fuE4cc9W4Y/fY4hE/OaiHcjAjHahzTjXaD/m07hXYCyh730PZn3Xl03cfgoFv0PYHkLdcD1hzobMyZgnxWWgzYdSnSfMXTEv0LkPxip0TFQ2ecyDNOv2QQcdZEoX2nMSXJ+4VnB9oA/tuXfSchs8oMS1o95zPtS6iWsS9xGIf1RqwOcAfYFzC8MU9gVDGh7E4P/QQWiD/qm7Nh7E2+GRieQVkUqmgOBfDQSeyaQJEneTG1UryJKJDLmEkMKu99kIkughszgh5QIJ9zTDq5vIqJpBskckb0LyFRskq0EG3TiSkh+R0oEsscgmHYUvmWAtU4u/c3EguZydcbtaSfYNJFOA9RdPNvCECU8T8GTFrvNDKgfcS/C0J+5JOCGktoDrH9ydop5aE1IK4IUz08BzZ1hA4B3ixjLCGwN/pDqAJRJ/hBQCwqvSeh9WkvIECM5y4FIEVwKYp+F7Db93JMCYySBpkJuNbKaBeCq4sKDwczGZnAmZ7cyG6z2f+zXc/xDfpi5t1QBcJOGW6vsrJkESIWlBjBjc9RAnVmhoDlz44NpZLcD1Ouq60nhVUp3gvhd17nC/zJda+p1LA1yT7aoi1UodzKaVbgQhhBBCCCGEkNqFFlNCCCGEEEIIIRWFwpQQQgghhBBCSEWhMCWEEEIIIYQQUlEoTAkhhBBCCCGEVBQKU0IIIYQQQgghFYXClBBCCCGEEEJIRaEwJYQQQgghhBBSUShMCSGEEEIIIYRUFApTQgghhBBCCCEVhcKUEEIIIYQQQkhFoTAlhBBCCCGEEFJRKEwJIYQQQgghhFQUClNCCCGEEEIIIRWFwpQQQgghhBBCSEWhMCWEEEIIIYQQUlEoTAkhhBBCCCGEVBQKU0IIIYQQQgghFYXClBBCCCGEEEJIRaEwJYQQQgghhBBSUShMCSGEEEIIIYRUFApTQgghhBBCCCEVhcKUEEIIIYQQQkhFoTAlhBBCCCGEEFJRKEwJIYQQQgghhFQUClNCCCGEEEIIIRWFwpQQQgghhBBCSEWhMCWEEEIIIYQQUlEoTAkhhBBCCCGEVBQKU0IIIYQQQgghFYXClBBCCCGEEEJIRaEwJYQQQgghhBBSUShMCSGEEEIIIYRUFApTQgghhBBCCCEVhcKUEEIIIYQQQkhFoTAlhBBCCCGEEFJRKEwJIYQQQgghhFQUClNCCCGEEEIIIRWFwpQQQgghhBBCSEWhMCWEEEIIIYQQUlEoTAkhhBBCCCGEVBQKU0IIIYQQQgghFYXClBBCCCGEEEJIRaEwJYQQQgghhBBSUShMCSGEEEIIIYRUFApTQgghhBBCCCEVhcKUEEIIIYQQQkhFoTAlhBBCCCGEEFJRKEwJIYQQQgghhFQUClNCCCGEEEIIIRWFwpQQQgghhBBCSEWhMCWEEEIIIYQQUlEoTAkhhBBCCCGEVBQKU0IIIYQQQgghFYXClBBCCCGEEEJIRaEwJYQQQgghhBBSUShMCSGEEEIIIYRUFApTQgghhBBCCCEVhcKUEEIIIYQQQkhFoTAlhBBCCCGEEFJRKEwJIYQQQgghhFQUClNCCCGEEEIIIRWFwpQQQgghhBBCSEWhMCWEEEIIIYQQUlEoTAkhhBBCCCGEVBQKU0IIIYQQQgghFYXClBBCCCGEEEJIRaEwJYQQQgghhBBSUShMCSGEEEIIIYRUFApTQgghhBBCCCEVhcKUEEIIIYQQQkhFoTAlhBBCCCGEEFJRKEwJIYQQQgghhFQUClNCCCGEEEIIIRWFwpQQQgghhBBCSEWhMCWEEEIIIYQQUlEoTAkhhMwqXvWqV8knPvGJ7PuBgQF5y1veIl1dXVJXVydr1qxJvS2sf+WVV8p08uSTT5r93nPPPUVtZ+ONN5bzzjuv6o6PEEII8UFhSgghZFo46qijjBA67rjjpiw7/vjjzTKsk5YbbrjBKzQvv/xy+dKXvpR9/9Of/lRuvPFGueWWW+SFF16Q7u7uKdv64he/KDvuuGPex0QIIYSQ0kBhSgghZNrYYIMN5NJLL5XBwcHsZ0NDQ/LLX/5SNtxww5LsY/78+TJnzpzs+8cee0y23npr2W677WTp0qVGzJaLIAhkbGysbNsnhBBCZisUpoQQQqaNnXfe2YhTWDUV/B+idKeddspZd3h4WD72sY/J4sWLpbW1Vfbdd1/517/+lXV3ffWrX23+P2/evBxrq+3Ki/9/85vflH/+859mHbx3ufjii+X000+Xe++916yDP3ymrFixQg4//HBpb2+XLbbYQv7whz9Msdr++c9/ll122UVaWlrkpptukomJCfna174mm2yyibS1tckOO+wgv/3tb7PfW716tbz73e+WRYsWmeXY7kUXXZTTrscff9wcI/aL79966605y3/3u9/Jtttua/YJt10cZxyPPvqovOIVrzB9uc0228hf//rXnOUjIyPykY98RNZZZx2zzkYbbWSOgRBCCJkOKEwJIYRMK8ccc0yOCLvwwgvl6KOPnrLeySefbMQXXHHvuusu2XzzzeWggw6SVatWGXGLZeCRRx4xLrrf+ta3pmwDovfYY4+Vvfbay6xjC2LliCOOkE9+8pNG5GEd/OEzBaL17W9/u9x3333y+te/3ghKtMHm05/+tJx55pny0EMPyctf/nIj6H72s5/JBRdcIA888ICccMIJ8p73vEf+8Y9/mPU///nPy4MPPmgELb7z/e9/XxYuXJizzc9+9rPyqU99ysSavuxlL5N3vvOdWWvsnXfeadr0jne8Q/7zn/8YV2Rs0xbUNhDKb37zm6W5uVluv/12065TTjklZ51vf/vbRnT/5je/MX16ySWXGMFLCCGETAeN07IXQgghJAME2qmnnipPPfWUeX/zzTcb915YH5X+/n4j1iC0Dj74YPPZj370I2Pl+8lPfiInnXSScdkFsKjOnTvX279YBxZHCDK48fqAxbKzs1MaGxu968ASC1EIvvrVrxoBd8cdd8jrXve67DpnnHGGHHjggVlLL9a77rrrjCAGm266qbGk/uAHP5BXvvKV8vTTTxsL8a677mqW+wQgROkhhxySFccQzv/73/9kq622knPOOUde85rXGDEKIFwhdM8++2xvnC7a8vDDD8u1114r6667bvZYtG8B2gTLLSzTsALDYkoIIYRMF7SYEkIImVbgvgrBBdEJyyn+71oLERc6Ojoq++yzT/azpqYm2X333Y2FcTqBBVTp6Ogw2X1ffPHFnHVUYAKIR2QChlCF4NU/WFBxXOBDH/qQEeNIuATLMBIzxe0X7rVA94s+sPsG4D3cdcfHx6dsC+vDyqyiFKhoViBoYZ3dcsstjQv1X/7ylzx6iRBCCCkOWkwJIYRUxJ0X8Yzg/PPPr+ozAEFsA2siXGNtIFiVvr4+83rVVVfJeuutl7Me4kEBLJWwGF999dXGCgzrJzITf+Mb3/DuVxM2ufstdfzvE088YdyLYWGFq/ABBxyQExtLCCGElAtaTAkhhEw7cINFsh1YRRE36rLZZpsZ91u4+SpYF8mPkLgHYDnwWQjzBdsqxXYA2gcBCtdYxMXaf7Ba2pbjI488Un7xi1+YeqM//OEPU+8DWYbtvgF4D5fehoYG7/rPPPOMiZ9VbrvttinrwRqM+Fq4Tf/61782cbxuPC0hhBBSDmgxJYQQMu1APKlLrk9IwQIJd1eNJUXW3rPOOsu4yL7//e836yAGEpbEP/3pTyYpkcaKFgJiPGEthCvr+uuvb8rNqHUzX/BdxIci4REsnIjZ7OnpMcIRwg9i9LTTTjNZfBE3iphUHAPEY1qQrGm33XYz9VohJJGx97vf/a5873vf864PyydEK/aNONS1a9ea5Eo2iFuFyzBiX+vr6+Wyyy4zMbdR8buEEEJIKaHFlBBCSEWASMNfFMhy+5a3vEXe+973GjdTxG4ieQ/KwwC4ySIpEDLiLlmyJOsaXAjYD6y4KM8CS+avfvUrKQYIRiQmQnZeCE5sG669KB+jFlokgEIcKUq4QJwj5jQt6A9kz8V3UJ8VQhcJmHyJjwCE5hVXXGHqxyJO9wMf+IB85StfmSKoIf4RLwvRi5I8cDXGdwkhhJByUxegGjghhBBCCCGEEFIh+BiUEEIIIYQQQkhFoTAlhBBCCCGEEFJRKEwJIYQQQgghhFQUClNCCCGEEEIIIRWFwpQQQgghhBBCSEWhMCWEEEIIIYQQUlEoTAkhhBBCCCGEVBQKU0IIIYQQQgghFYXClBBCCCGEEEJIRaEwJYSQKmHlypWyePFiefLJJyvdlFnHO97xDvnmN79Z6WaQAuB1UT723HNP+d3vflfGPRBCSHooTAkhM4rxiUBGxyfM63Rx6623SkNDgxxyyCGp1g+CQE477TRZZ511pK2tTQ444AB59NFHE7/3la98Rd74xjfKxhtvbN5DoNbV1Zl9P/fccznrvvDCC9LY2GiWq5DV9e+55x6pVm644QbZeeedpaWlRTbffHO5+OKLU/XnN77xDXnZy15mvrfeeuuZvrK3ieN2/5YtW5Zd53Of+5z5Tk9Pj8wYJsZFxkfD12kA/fXRj35UNt10U9PPG2ywgbzhDW+Q66+/Pme9u+++W4444ggzvrHeRhttJIceeqj88Y9/NOcqCl4Xpbsu9Fp3/2677bac9S677DLZaqutpLW1Vbbffnu5+uqrc5bjuvj0pz8tExMTsfsjhJDpgMKUEDIjGBufkL6hUVkzOCI9g+Er3uPzcvOTn/zETNj/+c9/yvPPP5+4/llnnSXf/va35YILLpDbb79dOjo65KCDDpKhoaHI7wwMDJj9vP/975+yDELsZz/7Wc5nP/3pT83nxfL000/LdPHEE08Ycf/qV7/aiOdPfOIT8oEPfECuvfba2O99/OMflx//+MdGnD788MPyhz/8QXbfffcp6z3yyCNGsOsfrM/KdtttJ5tttpn84he/kKpnfExkqFdkcM3kH97j8zIBobPLLrvI3/72Nzn77LPlP//5j1xzzTXmXB1//PHZ9X7/+98bK1tfX58Zgw899JBZ7/DDDzciJ07487oo7XUBrrvuupwxj3Oo3HLLLfLOd77T3FPwMOFNb3qT+bv//vuz6xx88MHS29srf/7zn1OPFUIIKRsBIYRUOaNj48Gq/uHgpd6hYM3ASLB2cMS84j0+x/Jy0dvbG3R2dgYPP/xwcMQRRwRf+cpXYtefmJgIli5dGpx99tnZz9asWRO0tLQEv/rVryK/d9lllwWLFi3K+eyJJ56A+Sn43Oc+F2yxxRY5y172spcFn//8581yrGevf/fdd6c+vo033jjYY489gu9973vBqlWrgnJy8sknB9tuu23OZ+jTgw46KPI7Dz74YNDY2Gj6P4q///3v5rhXr14du//TTz892HfffYOqZmw0CPpXBkHv8iAYWB0Egz3hK97jcywvAwcffHCw3nrrBX19fVOWab9i2YIFC4LDDz88dvxHfc7ronTXRZpr/e1vf3twyCGH5HyGa/2DH/xgzmdHH3108J73vCdyO4QQMl3QYkoIqXqGRseN625rU4M01Icua3jFe3yO5eXiN7/5jXGF23LLLeU973mPXHjhhbHuirB+wCUS7rtKd3e37LHHHsYlOIobb7wxx9phc9hhh8nq1avlpptuMu/xivdwsywWWIGxfVh44Zr59re/Xa666ioZHx/3trGzszP275JLLoncF47f7hcAS3Jcv8A9FK6lf/rTn2STTTYxbs6wJq1atWrKujvuuKM5hgMPPFBuvvnmKcthZb3jjjtkeHhYqpbRQZGJMZGmNpH6BpG6uvAV7/E5lpcY9CWsnrCMwrrvMnfuXPP6l7/8xcR7nnzyyZHbwrXpg9dFaa8LBdcuPAP23Xdf40lQyHZxXeDaJoSQSkNhSgipaiA8h8cnpKnBf7vC58NljDmFey0EKXjd615nXBX/8Y9/RK6vcY1LlizJ+Rzv7ZhHl6eeekrWXXdd77KmpqasKAZ4xXt8XiyII/zMZz5jXDIhUjHJPeqoo2T99deXT33qUzluf7vuuqtxNYz7w0Q5Chy/r1/Wrl0rg4N+wfX444+bvkGsHNyZEXt35513ylvf+tbsOhCjcJtGEhf84Zhe9apXyV133ZWzLfTvyMhI7HmofEzpiEhDs385PsfyEsec/u9//zMPW/AAJo7//ve/5hUPaZR//etfOQ8m8ADBB6+L0l4X6Gsk88J1gQdJEKZw07XFadR23fGP6+KZZ55hnCkhpOI0VroBhBASx0QQCAyU9X5DjPkcy7Feg0SsVCCIWYSF7YorrjDvkWwISV8gViF8SgkmoEhQEsUxxxwje++9t3z1q181k1FYPcbGShtzCMsJ/s455xw59dRTzSti2DSZEhI5ITHLdIKkLLBwQpQi+RFA/8O6jPMDkaR/Cvrpsccek3PPPVd+/vOfZz9H+zWetyoJJsK/uogHDnX1IsFYuI40lG63MR4ASbz85S/Pjo8tttii5GOS14WfhQsXyoknnph9v9tuu5n4d8QHxz0c8oHrQq8zvUYIIaQS0GJKCKlq6k22SQhP/3J8brwdI1wIiwECCBNtWBQgSvH3/e9/31jlopK8LF261LwuX74853O812VRE02450aBjJqwaCGZydZbb22S+ZQaCD0ksIEAhFX22GOPlR/+8Iclc+XF8fv6paurK3JCDGso+l1FKcDxJyVugsCGJdBG3X8XLVokVQmEpxGfEQm9jGitC9cpIRCUcMFFYqmk9XScKJpFNumBBa+L0l4XPhAuYI/5qO269yFcF3DhpiglhFQaWkwJIVUNYklbGuplaGxCGhBr54DSMa2N9Wa9UgJBCisd3OVe+9rX5iyDy9yvfvUrOe6446Z8D3GQmPihxAZiHgFc8pCd90Mf+lDk/nbaaafEjLGwmn74wx824rhUrFixQi699FJjWYSLLOIzzzzzTHOMrgVXXXnjcF0Hbfbaa68p5Sr++te/ms+j2Geffcy5gAUUWXVtl1KUKYkC7YSotYFbMlyU8RCgKsH4hrvu2KBIvUeQwI23MRN7WkLmz59vYg/PP/98+djHPjYlznTNmjUmzhTXAdb9+te/nvUiSAuvi9JeF2nGPL6P+xCy/MZtF9cF7j+EEFJxpi3NEiGEzKCsvFdccUXQ3NxsMur6smjuuuuukd8988wzg7lz5wa///3vg/vuuy944xvfGGyyySbB4OBg5HewHrLP2plx3cybo6OjwUsvvWReAT73ZeW99NJLzTL7b2RkxLvfTTfdNNhmm22Cr3/968Hzzz8flJPHH388aG9vD0466aTgoYceCs4///ygoaEhuOaaa7LrfOc73wn233//7Pvx8fFg5513Dl7xilcEd911V/Dvf//bZBY98MADs+uce+65wZVXXhk8+uijwX/+85/g4x//eFBfXx9cd911Ofs/8sgjg2OOOSaoaiqUlfexxx4zWXMxFn77298G//3vf01G5G9961vBVlttlV3v8ssvD5qamoLXv/715rzhe/fee68ZPxh7f/jDHyL3weuidNfFxRdfHPzyl7806+MP2cIx5i+88MLsOjfffLO5p3zjG98w63zhC18w5w7XiM0rX/nK4Iwzzihw5BBCSOmgMCWEzAggPnsHR4IVfUNGkOIV78tVKubQQw81k28ft99+u5mEY0IONtpoIzPps0tjoJTLkiVLTJmY17zmNcEjjzySuM/dd989uOCCC1KXhIgSpr6/Z555xrsNTFinE5R22XHHHY3ohyi+6KKLcpajH9GfNs8991zw5je/2ZTtQZ8eddRRwcqVK7PLIYo222yzoLW1NZg/f37wqle9Kvjb3/6Wsw08FOju7g5uvfXWoOqB+BxcGwR9K4Kg96XwFe/LJEoVPJg4/vjjTf/j/KB8zGGHHWbOmc2//vWv4K1vfWuwePFiI3xQQgalTfBAxC4Xw+uifNcFhOnWW29tBG1XV5e5d6DklMtvfvMbU1oK20VJmquuuipn+bPPPmvEatT9gRBCppM6/FNpqy0hhKQF2XeR6AgxpaV23y0EJNJZsGCBKVBfbEIkZNc86aSTjGtdfT1TAJQSuD/D/RQlT2YMyL5r4krrS+6+W254XcwMTjnlFBPbbseSE0JIpWCMKSFkRgExWursu8Xw97//Xfbff/+SZOk95JBD5NFHH5XnnnvOlDwhpQOldb7zne/MrC41YnRmCVKF18XMAOWh7Oy+hBBSSWgxJYQQQgghhBBSUegrRgghhBBCCCGkolCYEkIIIYQQQgipKBSmhBBCCCGEEEIqCoUpIYQQQgghhJCKQmFKCCGEEEIIIaSiUJgSQgghhBBCCKkoFKaEEEIIIYQQQioKhSkhhBBCCCGEkIpCYUoIIYQQQgghpKJQmBJCCCGEEEIIqSgUpoQQQgghhBBCKgqFKSGEEEIIIYSQikJhSgghhBBCCCGkolCYEkIIIYQQQgipKBSmhBBCCCGEEEIqCoUpIYQQQgghhJCKQmFKCCGEEEIIIaSiUJgSQgghhBBCCKkoFKaEEEIIIYQQQioKhSkhhBBCCCGEkIpCYUoIIYQQQgghpKJQmBJCCCGEEEIIqSgUpoQQQgghhBBCKgqFKSGEEEIIIYSQikJhSgghhBBCCCGkolCYEkIIIYQQQgipKBSmhBBCCCGEEEIqCoUpIYQQQgghhJCKQmFKCCGEEEIIIaSiUJgSQirK9773Pamrq5M99tgjr+8999xz8va3v13mzp0rXV1d8sY3vlEef/zxsrWTEEJIyGOPPSYf/OAHZdNNN5XW1lZzD95nn33kW9/6lgwODma7aWJiQn72s5/JgQceKAsXLpSmpiZZvHixvPa1r5Uf/vCHMjw8nKpLeb8npDaoC4IgqHQjCCG1CyYzzz//vDz55JPy6KOPyuabb574nb6+Ptl5552lp6dHPvnJT5rJzrnnniu4nd1zzz2yYMGCaWk7IYTUGldddZW87W1vk5aWFnnf+94n2223nYyMjMhNN90kv/vd7+Soo44yohMC9fDDD5drr71W9t57b3nDG94gS5YskVWrVsk//vEPufrqq+XII4+Un/zkJ7H74/2ekBoCwpQQQirB448/jgdjweWXXx4sWrQo+OIXv5jqe1//+tfN9+64447sZw899FDQ0NAQnHrqqWVsMSGE1PY9u7OzM9hqq62C559/fsryRx99NDjvvPPM/z/4wQ+a+7S+d/nvf/8bnH/++Yn75P2ekNqBFlNCSMX48pe/LOecc44sW7ZMPvGJT8h1110n//3vfxO/t/vuu5vXO+64I+fzgw46yLiY/e9//ytbmwkhpFb50Ic+JBdccIHcfPPNxgoaxTPPPCObbLKJceH985//XNQ+eb8npHZgjCkhpGJccskl8uY3v1mam5vlne98p3Hl/de//hX7HcQs3XfffbLrrrt6JzAQpr29vWVsNSGE1CZ//OMfTVxpnCgFEKPj4+Pynve8p6j98X5PSG1BYUoIqQh33nmnPPzww/KOd7zDvN93331l/fXXN2I1DsQnIWHGOuusM2WZfoaYVUIIIaVj7dq1JgnR9ttvn7gu7u0A8ac2iEVdsWJF9m/lypWx2+H9npDagsKUEFIRIECRCOPVr361eY/MvEcccYRceuml5kl7FJrxEYk3XJAd0l6HEEJI6YQpmDNnTup1Ozs7cz5HwqNFixZl/zbaaKPY7fB+T0htQWFKCJl2IDwhQCFKn3jiCRMTij+UjFm+fLlcf/31kd9ta2szr74yA0NDQznrEEIIKQ0oCQPShEqoeEVGXTcL+1//+lfzh5IxSfB+T0htQWFKCJl2/va3v8kLL7xgxOkWW2yR/UNdUhDnzjt//nxjLcX3XfSzddddt4ytJ4SQ2hSmuLfef//9ietutdVW5tVdF1bSAw44wPz5wjFceL8npLZorHQDCCG1B4Qniqyff/75U5ZdfvnlcsUVV5jMjz7LZ319vYlx+ve//z1l2e23324Sc6RxNSOEEJIfhx56qKlReuutt8pee+0Vud7BBx8sDQ0N5l7/7ne/u+Bu5v2ekNqCFlNCyLSCmCGIT0xw3vrWt075+8hHPmJcxf7whz9EbgPrIXuvLU4feeQRY4lF4XdCCCGl5+STT5aOjg75wAc+YMIuXJAV/Vvf+pZsuOGGcswxx5jsvN/97ne92woClDlNhvd7QmoH1jElhEwrv/71r00m3iuvvFLe+MY3essDLF26VPbcc08jTo866ij56U9/amJRN954Y7MOhOtOO+1kXj/1qU9JU1OTqYeK2NV77rnHuIsRQggpPbgvI1EdPFre9773mcy7yLZ7yy23yGWXXWbu2T/4wQ9kYGDA3ONRnxqxpW94wxuMpwyy8aIOKkrPbLnllvLggw9mt837PSG1DYUpIWRaOeyww0ziC5QJaG9v965z9NFHGxcwxIx+8IMfNJkcUQJm7ty52XWeffZZOeGEE+Qvf/mLEbOvetWr5Nxzz5XNN998Go+GEEJqD9ScPvvss829HPdmxP2//OUvNw8djz322GzWdDws/PnPf27+8NAQ2XpxH99hhx2Md8uRRx6Zzaau1lHe7wmpXShMCSFVDUrK4Kk8JkGEEEJmL7zfE1LbUJgSQqqWBx54wCTYePzxx2XhwoWVbg4hhJAywfs9IYTClBBCCCGEEEJIRWFWXkIIIYQQQgghFYXClBBCCCGEEEJIRaEwJYQQQgghhBBSURoru3tSy6DER19fX/Z9c3Oz1NXVVbRNhJCZSRAEppai0tnZKfX1fPY6XfB+TggpFbyf1y4UpqRiQJR2d3fzDBBCSk5PT490dXWxZ6cJ3s8JIeWC9/PagY+TCSGEEEIIIYRUFApTQgghhBBCCCEVha68pGIgptR11WhpaalYe0j1MjQ0JE8//bRsuOGG0traWunmkCpkeHg4JzTAvb+QGXY/73leZGxQpLFNpHvdqcsH14iMDYs0toi0zZ38fHxUZHxEpKFZpKEpv/10Lgq/27dSZKhHpKldZP6G4Xb6XhKZGBOpbwzXU0b6RYIJkbp6keaOqduPWu62M992R5F2O6XaXyXu53bb9RziPcaBfW4KBdvH+cZ5a+nMHV9pwfdH+kSaO/1tKtf5x3gb7hMZHQq3U98w9RophnzamXRtxMD7ee1CYUoqhpvoCJMYClMSNZF56qmnzESGY4QUcn8hM+x+ju8Gg+GrbzsTLSINmMU4y0fGwgkz2tPckt9+6sZEZFSkfkykrVWkoVGkMbOduvnhRBsTbHu7jfXxE/XI5U7bfO0uRKykPv6WGXw/d74zMS8jAiPGSiHbx3aKEYqjGDOjMW1yP0tod9qxgPGGP+kKvwNh6F4jRZHHdurGM9dMa7prMW5TvJ/XDBSmhBBCCCk/IwOhpRMTa1hw4ibYze2T1h4XTLgBlrmWGEzcbWtaEr79tGYs70YENE+uhz8XHEPccbjLowSGr914D2FhPk8pjvI9/jRMl3W10P1gXVi3o75TyHaTzmuxbcq3XWnHgrYb62bfNxd2rWYfxHjGfZpjMdtA5YW6qdvAMliVASzKafZBagIKU0IIIYSUH0x04TY7PhxORGOFaUdmeV34PXvCiwkwxCRcBN1tJAkKdwKt+9HJu/4/X0GR2oU2QmD42u2KzDT7iDv+QoUfvgO36b4Vkw8VooQE9oHzlXMO89hPvkLc3k+UACt0u8X0W1KbstfDsEhdg0hz2+T2XVFo9p95GAPrI8C56H9JpGORSOfC3HbimhkdnjwPSecsqm1wXTftaE/vQoxrEkLTHEd/pg2w4C6cuv5Ib+b/EQ99SE1CYUoIIYSQ8oOJNibPaaw4KrAwAccEtnnO5AS8GKugigGNu3OFXJTQtN9HTcJ9Ma9TjstnGbUEBV4hTIAREx2li3sc7BEZXB2KFggciBojfBJiHc0xZ8SSZCxxKiR88Z5rXwi/O2+jyXOWhkLPa6LVukgrckGW6xQWV/Td6IDI+IRIMD45dsyYXyvS3BXGOOv+J8Ynv/vsXSKrnwr7eKvX5rYT49KMo97QQ0HHSj7iD+NOxXFacCwqNLNCeMK/XyO650z+n5AMFKaEkKqnqalJ1ltvPfNKCJmhRLnDxk3cYRWC4PNZXQpBxQAm7/mIEfs9mEAsaubzfN1O3fVV1EJ4wBI8tCYUKSNNk/1lLEx9ky7MrhU51bGPhNbqvmUirRlR0LBO9HFmhWnG4gZxiu/nuCY7/YLlYxAobZOfxd3PXSGcxu3ZJ+gliF4vSiRGWXenuLHCAjnkF1BR1nMIQrymslQGuW+x/4FV4RRdraVDfSL19ZPtWvucyMBKkZYO66FBph9sa21DS66gTdu3+V6rpq86J12IgR6774EAPp+/Ufrtk5qBwpQQUvW0t7fLTjvtVOlmEEKmE0ycG1szk+320rhmpon981nZ7Pf2RDsbg5rCdTNN2/DXqhYuRwih3eq+XMjxq+VsAkJoItMPMcfptg3Zkd1l7vpt88KHCHiP9kOg6bFk2ppzP9fMrb5jiTvPGqPY1BYmeoKgx2c4RhWcSfGR2C4s33jIYPfPFDfWQKQpMw5923DbaKyVfeHn9sOFqLHYXJ8r4ODWK/PDV3VbRyIuvOr2F2wWfrZgi8n2jo2IdMwP26miEOdDEyCl7dtCwDY0q3WOWzwfJpP8oDAlhFQ94+PjJpMjSgs0NGR+nAkhsxtMcNshdOblijRbDEUlaYmyCKUVkD4XX/u960pbzCQ8x8KVsU7GrWOOrwDXVLWC2QIi6ThtvHGwzmfYtpZHUZdnZ73c+3nmXI6PhW7AeN/WPXmsUceJbUOQjg6G+8N7CDd1hU4TH4ntQujD8h3nxhrXDt8yI8o7wzEY56bqnne7D03cZWa5lsJRqzBYsrXIws1zxXSbPriwzmvkg4YyJMmiECUlgMKUEFL19PX1yY033ij77bdfTq1KQsgsRkVa1mXTigFNStISl2RIl/u2V4n6nmkm9FGxsIUkZopzbc0nqZM+FDDLGv2ZhtVSZ4RQuK2+viG58ZZbJ+/nJpb4JSsxVlt8O4EKPvuBBNoCgQuCjIhTi60RYI67r1r51J1X459dN9ZCxHqa2qVR2/Xt38XdvivA7X254rjYMV7BGrhk9kNhSgghhJDqJS7eMypJiyYpkvFJwRG1vbh9zZRJu+4Xr2o5tEV4mmOKckvN6XsnCRQeCgz1iLTMmUzeY69jW3/VbVddZ32JsUwCqExcZdxDgykxkBl3W8SC4lWXQfBCQJtanp1Tk1OpOIwcD3mez7j1k85D1HejYmkL3VfaRF1RuN+nUCUlhMKUEEIIIdVLbLxnRAyfTsZN4iTH9TYf18x8LYbFTvoLJVt6JBODGhcHGkWUW2pOf3geCiBO0ibSWp3Zlus6C1RoFhpzqts2Dygsl1dYUJE0CPGXnpK4if2T7/n0int9aDBmtTHld+02IJsyjkWzQce1rRyuulGUOl6V1DQUpoQQQggpL8XUt8wnDrKQ7U1p54BIc91U66zP8oQYx/4VInOWZD4bFBlaLdI6L1rIlNPCZIS6az3O7MOXKdaO0fW1ZUrfex4KuCVj4hIomb+xmPbnGc8Z1U4FCZvchwdpv5tEVGkdt432GIpKouR+1952tqwMsus2TGaDjsswneQGnSbOOooptX+nUQSTWQ+FKSGEEELKC2po9r84mRG3HJYVVygUMgF3a0jGTbqNxXAgdGNFSQ47GVN9S3ksTFHJnpKOFftCfVGcB4i1hZtNPd7OBcntSpMAqZjzm288ZxL5lj2Z8v2YfvWdR2//RFhzXezv4iGCWkPt7L22AG4YTZdhOm4/hZB0vunaS4qAwpQQUvUgQcahhx5a6WYQQgoFE3NYdhCTWC7LCvaBybyWDcknyU+WIFM3sieMT7QFrgs+QwbZHAHTGJYwwau3jZn4SfMdWM/yxAiWwUzG1/b0QgDLTJ3UjFurfbz6Ok2Wr+7Odjn0ta+eXgtbWrEUZdl3k2VhjEHkI+7TlHXxxMSWSghGZe8tRYmiNODhBeoJdywKx3tcP6IfcN1AsCOmN5s12HmgUowHBZnVUJgSQgghpLyoUFQ3UzMpdZK55CskpmQ5bRZZu0xkaE3oXtu1jn/Sa8fmmaQ71jYQuzfcK9L7gsiap8KaonM3DK2JU5LSZGpMalynW+rDh73vpMm46yKrcYqm9mZGQCe5Gyv4fMGmocCAlU2/65YmceMiy+FuXIk43LRWaoiwNU+HDxfmbRi2z9deWJ8HVoX/71wYnhe8evddQF+6YjSNm3Wc2ItNlOQsc98vf1Bk7fMibfPDawqZk7vWE+leJ/rhEB6e2LVT0V89z4X9unTbUKiufiq8/udtHN13pObwOKYTQkj1lYu56aabzCshZIYxxVqSEQmw/kFk6WQ6SkhE4a6jIg3Csm+5yOBq/7bjtoH2wYjY+5LI8v+K9L0oMrDS3xatg2lbrLROaJT7aDZe0JOZNq5t2ZqggUhrVxirmD1upx0qUNx9wNoFYdE6J/d4fe1N0/8F0tc/IDfd9aB5nTZ858pH/8pw7PS8EH+OhnrDcQGhj76OG2eF9GWcpT4KtAFjHuPE3pdaMQcirge3fTrWdF085FnzbChOzUOfleGrl7rQMm+8Bppy+6t3WWhl1v4a7gmvBXym2ZNJzUOLKSGk6kFB9jVr1phXQsgMw601qi6jsDJhgutLFJTGrdSXQReJYZrnZCbalttslDXKCMWhXAsnRF/bHJG6iVAEts/3i5pCXDQ1XjDN99xkOKbt1nezyWecdpQiW2sZ3XrH61tkTW+/eY1eKaF0Sr6W3LRxkKbUzByRFquffS6zcFMNFohMOLVUvdRNHWNuG8z7Ii3USLwF8VnfHI5ZV3hqmR6fp4F7HcGVvSHjUYAHFxMjIu0LQg8CjN/WqHrigUjH/FCc2seL/sJDEd0m6FwqUockY43+WsSkJqlZYXr33XfLv/71L1m1apXMmzdPdt55Z9l1112lDhcJIYQQQkqDW2s0m521RyRo8WcpTSP6poiNkXBSrHGfmIwnuUD6MqUiOZC6NELYYXulcmfNJy7QbmdUnGG+xPXrFMFSprg/O/42mzE3ZWmYOJfcJNGak+nWsRJqnVA910ZsOuPVBmPErBuT7detseqOc7cNbnvyPteBSGNzpi3WvvAewhCo67ruS63rtnVWj1fr4S7eWqRj4dQYUx/Zz+tyPRm0v1TEmz7Wh1RWG0jNU1PCdGRkRL773e+av6eegm97Luutt5589KMflY997GPS0hLzJI8QQgghxWVGNfF7nvImaa1iJgHNmnA9FQnAtUDlaxlEW+dvVJ6zm0YY+mJv8xGKOtm3J/0gyTV0uutRwoIXaP9HZLKdYqWOseQmtT9nuW2NznwOqybEGM5/0sOItNl+NUmSjtG4Y/GJ5nzOg1rHzbhpdpJ0OZZz3ReuH9daaV+PWKezY1KQusujHmi49Wjd/rLHsy4npNYspltttZURpEEQyCabbCLbbrutdHV1ydq1a+XBBx+Uxx9/XE455RS54IIL5LHHHqt0cwkhhJDZS9TkPu3E3LisIkPtcJgZ1Z2Mp3KXTZG5V9tUjLUyLsGMbt+4IjeEAkljSNPsb4qQD8LtGGtkU+jWG3espXDfLcTFFm7XUXGfaRP+5NN+e7nP2q6WfY1/1oRdxYDt1emDhqapDwpyRGDTVCHrKw/ky3Crx6XJmtJmCdYSR23tyUI2rp6v6zrO2qakQGpKmA4MDMjpp58u73nPe2TjjTeeshyi9ec//7mxqBJCqoe2tjbZcccdzSshZJYTNan11SlVyyCsjBATEGRmG3lkvE2yrgG3DE3a7SiaUAZCzGTCdbLzYl8Ay+PqXfr25woDFRsoC4PENYg5hIDBZ6bMTEz5m0L7LQ8rX/Z+3jlHpLnAGFbXuuyzMvsseUnHjVcdR6WwHLtu7Jq11t2vWw5IQcIhxGva5YHckkF230PUuuWE4oAbMtzfMe5i18vzoUU5XcHJrKYugPmwRhgaGpLW1taSrUeKY3h4OKef0e90oSaE8H4y85iW+7las7LizVmGCT8m8T5LlytS4rblrg9UrGiJGbdN2G9cDCi+jwy/oHNx+BpVsibfPjBCxbFYof09z1tlO2BBhTDOiAwkr8muq26dPZP1KlG+A0IW2VJNmzOZe+39Y2N2fKJ7DKUoORO1DT3m0WGRppbJV7sP8jnHpUiwlPZ44lyrcc5MQrBMbHPvi+E5NOdk0eR5hZdAWyZpmL09nC/9PuI6k/BZZPM9/jL0F+eHtUtNWUztH81LLrlE3vzmN3stMNUsSnGx3n777ca6CwvwokWLZKeddjKuyYTMVjDuX3jhBVlnnXX48IKQWiXOamPHlybGF3oykcbuN+PaGBfzKOPh9tV91m2Hmfh3TlpG09SpTNsHbkIlFQoaw2ssqP0i9fUiQ2tFmiCEX5rcp4pa1G7VDMpGmKKsR2+4jql1mklWY4TQeChq4KaK97Ygjksw1NAsw2MT6e/niZZYta0E0dlwNZbS7iufFbuQeN588bnJ2qCP9QEIslbjgYedtRr9gHI/E+2TY9KupWt/P5V49CRmcvs8SXj6+ssneAlJQc3WMX3ve99rborHHHOM/P3vf5dq5+abb5a3v/3tMnfuXNl///3lE5/4hHzpS18ybsmbb765bLHFFnL22WdLb2/mRyRPzjzzTJORGNu1n3gff/zxsmDBAuns7JS3vOUtsnz58pzvPf3003LIIYdIe3u7LF68WE466SQZGxsr+ngJscFYvP/++80rIaRGUffdqMmxu0wtfnh161jGbctXyzGpTfjD9lGyA5ZRWB/d9SB+2udN7tfef1Tt0bjj1ONz3XNVWMBNE1YziEyz7wUi8zfNWBY9YREtXeE28JoVdiMidbBh1E3uSzO2GhfkINc62bdi8vi1zyGwYOUbxvGN5Hc/d8+bguNFplm8aikWvFfhbPoxI7rUfRZ/dn3PbAKmifS1NO0xlYZ819fjwDhadn9oGTVZf62Y0KzLNkTjmEj/qvDV7Zc049nu36w1ty63z9NeC/YYtktEEZIHNStMYWVE0qOLL75YDjjgABNz+rnPfU4efvhhqTYOO+wwOeKII0wb//KXvxjxuXLlSnn22WeN1fTRRx81bb/++uvlZS97mfz1r3/Na/som/ODH/xAXv7yl+d8fsIJJ8gf//hHueyyy+Qf//iHPP/888bKrKCmJEQpsh3fcsst8tOf/tT052mnnVayYyeEEEK8JIk5I5KWh69JQtS37dFMTGaayblaLOFGCZHjWy+uDWkn/zawAg6vnbQGxok5WK0gTiFS520kMmfxpKBWIQMRu3irSRdQiKmm5rBuJUSeCg3dvpbSMRa3THwshJ+xtGYsxxpjCXdUtDXfxEq+PptilR2bTF6EdtqZd9WNF2LOxPM6lma4wxoh2O/vy7R9Xqr19Xh7l4mMrBVZu3xqgiTX6hsUIQDt7amAjyrhk3TN2ZZWbLO+kSVgSN7UrDC988475cknn5RzzjlH9t13XyPyvva1r5lMvXvuuaf86le/kmoB4u+JJ56Qs846S/bbb78p7sebbrqpHHnkkXLNNdcYcVoPd52U9PX1ybvf/W750Y9+ZOq5Kj09PfKTn/zE9A8stLvssotcdNFFRoDedtttZh2IZGQz/sUvfmESGRx88MHGinv++ecbsUoIIYSUTXjqRBqTfu86cW6eCWBSbgSZpLNkansaW8NaktPhvog2qgun+3mcCLeXR/3f7T8IlTEn8ZSKcRV/Wbdk5/jxGUQh4lpL4SLrS0zlE+VZa3bG7dWNPVa3Wv3c3k7kvscy420s/ThNs12XoE5kDHV05yePJfNAI/MQxe0bJcqSaoM+g/VZxanvu3EPULTvNREV+pVuvCRPalaYgg033NC4rn7+85+X17zmNaaMDP7uuOMO4yL7qU99SqqBD37wg9LUlO5mvs0225hjSQtcdSF8YTV2hfvo6GjO5yi3gz679dZbzXu8br/99rJkyZLsOgcddJCxRD/wwAORsYJYrn+EEEJmJmW/nydaKZvDGDwtjeKKA2MhXBK+5kvWNTSTMde4uKaY2MNVt2vd+DjCuP3Fbd8F+0AipXz3lZac/vPEIvosboh/1KQ85WqnLT4hfOCirAIoX8u44m4nct+NGSFrpWiJEoP5bNelY57Igk3D16R2t3ZZ5YUiXJ/T9IvGqOb7oMNdz7ZaE5InNStM1f11o402MmIK7q+oaQqhhv/vvvvu8uMf/1hmM5deeqncddddxlLssmzZMmlubjYxrTYQoVim69iiVJfrMh/YV3d3t/lDTCohaWhoaDCJvvBKCKkOpv1+7lqm1OKliV7cybC6rxZitXFjR/X/SRN7n2Uu7hjc/eXzvUJFWFry7T83/jGinUXfz+3tFSLofaTdDo4NMbi2yI4Sg/ls18X3UMU3Bmx3ZNeaXQhJ7U1reY3qD0ISqKmsvDZbbrmlSfYDCyncVI877jh55zvfaZL4gHvvvbdqLKZwsUVb07Bq1apU6z3zzDPy8Y9/3Ijw6cxCfOqpp8qJJ56YfdpOcUrSgORbe+yxBzuLkCqirPdznXzb5Vncep02ZhIcUfuzGEqdodXEn/aKNM8J4z3L/b1S4Wb+LaKvSno/L9X5SdqOnWVWxSI+g1uvikF9KOKKcl/GWrcMjws+cz/3jf+kLL+l6gc7rjdJZJczqzGZ9dSsMO3o6DBCFG6yEKYuxx57rMlCWw2cd9552f8j6dGXv/xlY+Xda6+9si611157rXFJTgtcdV988UXZeeedc5IZ/fOf/5Tvfve7ZnuIE12zZk2O1RRZeZcuXWr+j1e4Pdto1l5dxwWp4TU9PCYyhKQBD5CQ7bmxsTH1QxpCSHkp6/3cLYMRt15crcpqI87tMw51VTaObhUQpiUUGzPyfm7qpg5mMiBbscfms8zYz7rTNiVva+1z4blU99lqJ+6hECElpCaFKWIn3/a2txlB6hOlYM6cOeavGkBiIwVi+YwzzpCPfOQj2c8+9rGPGTF53XXXmUy6aUAc6n/+85+cz44++mgTR3rKKafIBhtsYOJakUxJBfojjzxiysOoIMbrV77yFSNw9Um5ukQj1pWQUoH4tRtvvNEk/4LbICFklpOmXmfUetWM1hZVEZ1UI1Ix4mViZoiYUtzPq6UOprYDyY7chyTGSjqaG1uZti4uBB7CdfMR+2ms1oTMcGpSmEJwoQTKdLqwlgpYMr/+9a9P+fx1r3udfPrTn069HYju7bbbbooVGTVL9fP3v//9xk1r/vz5Rmx+9KMfNWIUWYvBa1/7WiNAURMWGYMRV4q4XcTpJhbNJoQQQvKx0KX9rJpxXTRtC2rccWiG01oRJT4LZSXQepwm6dGCqSV4CmmbHYObj5W/kmOdophMEzWb/Ojwww83pU/gvjqTgHD8/e9/P+VzfIZlpeTcc8+VQw891FhMX/GKVxj33Msvvzy7HIkL/vSnP5lXCFZkMn7f+95nLLqEEEKIAeICMXU9z4cWqDg0/i5qvaTlhW67nPuNI22imHInOqo2okrhxJFUtiXtOjZaj9M8GChR/xsr+WiylTypveUakz5ia/BOYzvIrKcmLaZgaGhI7r//ftliiy2MqFILH+IdUL+zWjn99NPlAx/4gNxwww3Z5AG33367qWGKWqTFgG3awKKMmqT4iwJZja+++uqi9ksIIWQWg4n12ucRXBi+j7My9a0QGVkr0twlMn/D/JdHucfis9VPi4wNhbUh3e+ufUFkYJVI+3yRhZtN3d7qp8IYO99340hy1S21FSyta3C1ENXeQizEcQmidD+Da0XGh5KTSNntKqTcUBorLKzCtvuvrx/iYjsLsSqnHR9J69nL9XiM6/XMdzUnlaVmhelvf/tb8/rkk0+aP6XahelRRx0lW2+9tXz729/OWi/x/qabbmLWUkIIIdVJfZPIRCYeLxatkxkUuDxCoJjkQQOhKEF5DXeCbaw9EyJjnqRExt02CNsft99ik8ZoWxDPiNdC4ivxPewPxxNXtqZY0ggXCCe8qsjMLhubfNVatbCOqgDMbjcjekC2Vqq1X2Avj0sspcuwfn1dfPIpbTuSb4FC+zCqj9BWbbfdXp9LN7YxOhD2jw8zttrStUWvAVOPNuG4klzM7eV6PDMh+RipempWmH7hC1+QmQospZdcckmlm0HItIGY6AMPPNDEhxNCZhhaYsNYdjriJ+5Yb6Q9epIbtzwrMvsnJ81ZsTcq0jEP6edzy33ABbGpTaRjgci4U59SUavZCOo3tk0mvCm5mMtM9iGKGjOiLF9hasTcQCiq0mSILbT9aYTLSF9GDOZmnp3T3iwHvnIvaWpqFgnGQ8GPBxeuQFPhZVuWXfFpL3cTS7n9gu+YcZgRU0kZoSfG87PYZsffYHju8N3Wzql9pLGprsj2JfHC95ra/X2MbaCdWsc3zQML9F2a40pKKmYvnymZhcmMoC5A3m4yo3jsscfkoosukscff9yUkkFG3D//+c+y4YYbyrbbbiszBZQXsBNQwb2aSZMIIbyfzDwS7+fG7dCxHBq33BLW5tTtSUMoII0lB1lVe0UaWsPPbOsbROnoYGgN7V43WcSp4M2nNI1PzOn3XaGa1mKaj5tlKYWpHj+EjXk/GFqQ1TLrHkuUxTSq/mc2U7HHIqp1aqUu1/3VtaimJa6PCu0/jL/B1eG4as9Y5TsWFpdZuFTtVItpVF9Fub+Xso/y+A7nh7VLzVpMAcql/O1vfzPlTlSfw5UXJVCqlX/84x9y8MEHyz777GNqjqKmKYTpvffea1yQ1UWZkNlEf3+/PPjggyYLNLJHE0JmAT7XS9/k1S4dAkxsXt2k+MxOpDPbg/hV90LEFBovSIiZplwrn24vragppDSNG0PqWsjs9qSNN01yDy5X9lY9fhmftMjall37WDRZj4pWtSA2NEn/wIA8+NDjss1mG0gHvucegxtrqiIX8zTUPVUxi+25300dQxlj8S20/+BC3vuCSF3mu63dGbfZIuw/cW3Jp51qUc5nTMX1kXvt5tPnZiw0zZw4aDKt1Kww/eUvf2niNX1ZeatZmKIkDMQoyrjYdVb3339/U8uUkNkIirEvX75cXvayl1W6KYSQUpWb8NX09MX22clVABK+YBJdn8naquvZ27PLfGTXqcvNgGuS62QsfT73XFfkFCv43O9XogZrMdbUrDttZhvaz22ZJEWupdNOiGMJnLGJOlm+co28bNON0x27utYO9Yq0zgm3CcGXJJjiji9N3+txulbaqP7DWGvpEqlrEOlaZ9LKW8z5zSdZUaHW43z6yO4TvZaiBOeU68d6sJHmHJGapGaFKepuTkxMGGsjLKZbbbWV/O9//zOWyGq38kJUu+A4VqxYUZE2EUIIIbH4RJ2vpqcvtk/jJo0Aykx4G9tD605cXUlMlDu7J915MZmekq01wSpUbCKhOGHh9oltGY5z/XTjdPNyYU0p3OKw293UMlnWxZfgJ5u0yBI4EHAAIjOtpRp0qvXREYruumnEfpqHDNpXEMQay+la3W0Qv6rnzTxcCYpPCJT2fOlYjTu2uLHoe3Dk205U5mOf4IzyCHBjawmxqFlh+sgjj5hapuuvv77JcPvAAw/Iq1/9atlvv/2kmpk7d6688MILsskmm+R8fvfdd8t6661XsXYRQgghRZEVLs7EGUKmY34mNtMRn1HY6xk30IhsrXFCphSJhPIRgmnLbugEvxCBWUorbdy23PNUSktzqdZNfXyZvk57zKUUXqmFdvNkEiR3XTspE5JN+VzA0/abbR0daZv6AMl+YBDV9nK5mpNZQUT+6dkPYkmXLl2ajVeDtRHC7nvf+55UM+94xzvklFNOkWXLlpljgNX35ptvlk996lPyvve9r9LNI4QQQgpD4z6nWBabc11w8wWTcLhYRsVjRrk+alyea5l13Sc1ntJHPm1HO+ob01nZCu2TuOPNl1Juq5rBMbZ0Th5r0jGXu499407Hqs+y74vl9pFmPOu1ZLtn6/bVQqz7r5XxQUpKzVpM4fq6cuVK2X777U3io1133dVYIjs7O6Wa+epXvyrHH3+8bLDBBiY+Fslg8Pqud71LPve5z1W6eYSUBWT7xFi3s34SQmYQUW6EUZ+rW6v5HFOVuslJc9blMGOdiZr42tvWEjH5Emfd8SWAKaYGaVprsO3yOwMn/dNyP4/LCpx6G04W5XJTisRNPtRyaR7MxMS8ptluPqVu0lKuLNJkRlKz5WKOPvpoefLJJ+U3v/mNSajS09NjPofo+853viPVzjPPPGPiTfv6+mSnnXaSLbbYQmYaTAdOCOH9pIbLxbglWGzXP5TcGO4N33evJzI6JDI+HE5ike0U6yMBTpxoyLe8iy+BTNqSGTqp718VZqrF1KqtO1wHrsClEDe6P8T5ITstrKuFCu7ZDs5jz3MZQTY/LAdUzYLJTvylWaWnu135lp/xlZcp5GGA5zrl/LB2qVmLKeqAKnfeeaf86U9/Mq69b3vb26SaOeOMM4zbLiym+FMGBwfl7LPPltNOO62i7SOkHIyMjBh3+4ULF0pzMxMmEDLjwGR1dCCcfNrYYtS22MDyuPYFkaaOUJTqNhCBlHWttTOleibK+cZTYoLc92ImSZKWKsmjrIhapTTL73CflRioBPctLemBvjH1Q9tnpMVpWu7npi805rIESZ6SsvUW2++a+AtjHcm/sI84F/NynOd8tuu7Lkwca18mBrUpvTCtRHZqUrXUrMV0ptLQ0GBcjuGKbAO3ZHzmK39TrfCJGEkLPBpuvPFGk5ysu7ubHUd4P5lp93NYQDFpbe6MtvLZAgvrQyTCMjhvo3B5XO1O1+pSiFiDtccIU2RYXTxZQ7MQK1JSrdFCUKszhAsy2uqx5msZrpX7ealKqLhjQPsbIjLJap+0PWC7qAPNrqtxrWm3WepyMdNlMfXA+WHtUrMWU2Th/chHPmKspf39/TlJkVAzsVrBcwS00eXee++V+fPnV6RNhBBCSCyYvDZlyr3EraPLVcxh4quT8zjLo2t1KaQsCvYDQar/d9uUhL1PX/mNYskKDstSZwRCJllNc4ljNn3la2aKdTZr1cyUbimmPI77kEHHmhkjBdQpdWOTc8q8uFlu89hmUrmYUuLbB97TtZwUSc0KU2SwRYmVmcK8efOMIMUfYmJtcQorKWJNjzvuuIq2kRBCCPGSr1DzJQJKK2oLdQ/UzKaFYu+zHOLAt02IJo1hLcX+bOEJV+qBVSLt80UWbhYugyUbogrWvFJZgt39pn4QEPMdrbfZ0CrS1lXcAwLXDb3Yc+uOTbvMi45BW1inTXAUVS6GkBlEzQrThx9+WLbddlv52te+JnPmzJFq57zzzjPW0mOOOUZOP/30HPcXxGhsvPHGstdee1W0jYQQQoiX6a5dWIlaiUkxieWwMhYTn+drF4SuxsYO9YqMol5l66QohasmsiRDmJaSQizcce7Sps4mrL1V6N7sjhOfwM87826RD1XypRxxtoTUsjA94IADjKXx0EMPlZnAkUceaVyMYSndf//9cxIfETLbqa+vl66uLvNKCKlB0mbHrcbJcSGiazoEeFS7JpBJuCljgZsj0to1uS5EKeKEixB7U+7n5XBHNtb2icmYUNvFO18xlcYNvdT4HjhU0zjX8aBxtuUY26QmqdnkR88//7xst912sv7668vWW29tkgoBCL9LLrlEqpX29nZ56KGHZKONMskgZjAMbieE8H4yOyj7/TwuwU8+yX+KndwnWYqiSs4UkpgmTVt97TGfp6mHGZHARtuK/6NftXxJvseQtq/jEle5x5LvMrtcDygkaVE5BWE+244b58W0sRg3ah13hYy/GDg/rF1q1mL6mc98RtasWWP+7r///uzn1S5Md999dxMbOxuEKSGEEFK0y2o+7qyaJAaJfezkNfm6j44OizS1THUj9SWh0T/bOunLzOqKPrutJumOJR7dEjtwu9UamCBNRuAoa6sdC2wLjHxdRdNaiqMSV2m2WhyXtstepu3UbLAQRzgndvIpn1i1z3uUKNPETyq43IcMmkU3TqTb4i0bL2qVObKPJ6fsivVwQL9r9hNhRcW6g2vxJiyRgwRESW3KeRgRc56i+scdO3pdoN/Q5mC8tBmpSc1Qs8L0sssuM9bHAw88UObOnTkXzoc//GH55Cc/Kc8++6zssssu0tGR+9Ts5S9/ecXaRkg5ywvcfPPNss8++7BcDCEznULi0+JcVvNxZzWlXAZCsYPJdKFuiKb94/66rL4kNK6osOMjweDq0H02ezxYry5MPlTXkCsM7e8aC2NG9NgJeoZ6QpGSb+kQX2bhQol4YDDlfh6VuAr9i/OE8ji6DXuZthPnc2IMZQtEmtucfne37Uke5RNl+BzbhOBFv5t41fbJhwXoa3XvjRSBlrsrXs1no7ljzis2rYcb+G5jpvyQT3DquuOofzoWjqG48ewToXEPdvJ5uKDXFdqsDxNytlVFrsikaqlZYbrpppsa6+NPfvITmUm84x3vMK8f+9jHcqy8WkZmJtUxJSQfJiYyP+yEkJlNJePTsllPPe6vaVCxBgFoYi49JTN8VqIk8QxBYbubqthsbA1jPuOORy15YxkBq58XUialmGRKUW3L935uH5MrZHzLmuumlrUp9njVdblj0aTFVNfHAwHNghzXT3ZZGZ/F1D4e93v6wALnP2vljdiHsUzOz2w3ZZvixHua/om7rtBm33VVzlhrMmuoWWH63ve+V84880zZaaedZJtttpHGxsmueMUrXiHVyhNPPCG1wOj4hPlTmhrqzR8hpLbRewPvCTOYYutA5osrcNyJuLpD5mO5tSfsqWMpBzJZbS0X0ByB4rjPAs1+awuTrFvpWJgp1wgya3vGzRQurbD49YQC3BVsxv21J9wXBIUujxIpcbGd5SJNW3SdNILUV5dVRS7Oi/25r1yRrp+1XGfOZ5QgtkW0G3+p/a+WWNtVOx+36XxdrH19Gjd+8/JGSFi3lA89yKylZoXppz/9aWNh/PjHP57zOT5D9ttqpVZiSzHxnAhEhkbHpLWpMTsRrVRbOBGuHXi+q//8DI9NyMDImHS3NfOB1UwiRxgUUcIjX5dA21Kj79PG2KXZf5Q7qItxwR0UGR/OCB+rD3wumti+io5sHGVGmOIPohTum66bJ77bOkekH27Aak20hJNuC3+IBcT77nXj4xLNuoFI3UC8NXY6BGyhljd1z3X7w/d5mjEWtb249gL1Fhjpy8SSToTf98UQ5xMr6i5Pm6yqFJbMpERa2QcnTdEPCQiB80gt9wLcX92/meAu+Nhjj8lHP/pRU/IGf3DrxWezCYjQ+jqR9uZG86qiFJPRFX1D5nW6RbJtwSWzl5lyvtE+XAfV3s5Sg3vB+MSENNTX19yxz3jsiXyx20GtzbTbwWTZuF42T8bkQWhpiRJ7eRpcoRH1fTtRDsAkvLEtLLcSty93+/oZ2m3iCUcmt1ffOFXka3sgan3L8X0IS7Ne46Q7dawohZganIwdNG7HdbnH57bd19c5286MBd+yONBuxJ2qxdL080Ao1PHq9rsS1V/u53rMdl/7iNqer706PvT/RpDNyfw54yGp36LGiLvcHS9p2lcoacdsqe8FZNZRsxbTmSBAfVx77bVy2GGHyY477mgSBwAkEdh2223lj3/8o0nmNBuIctPDRBxzUbxCtBZq/crHKoblOgHGfmeaC+FssAB2dnbKK1/5SpOwrNzo+a72vrIFdLW3tZTgWGEprbXjnhVo3F4x1tI44qx1bsZV2+KXj7uizyUx0uXUsURFuYcmbT8qqVKcu2mSSyXonjPZzihRoiIWP4GwytrJqnyW4ilJnpy+tu/njUFxlmoVPaYtA6FwNhmMu/0WXT0HPnfVHIvlyNSkSz7c/k+bwdZ22dVkTW7yJ0+/pa5zajL5jqaLg/VRSJKitGN2uu4FZMZSs3VMZyqIiT3ooINMfKzrmvyXv/xF7rrrLpkpFFKnCsJQRWkaYYp1MXlX62vS54Vsq9oF4kxtN5ld56Xc7WXdu8oyrf0fWeLDqvMIylHzsRTtnEnEHUOxLqf59o99fo14s9xEsS1YTGH9hRhSQRY1PuwxEVdHNV9X4bT1dJPWL6QNur1867S67Yhq1zSOZ97Pa5fqn82UkIaGBlNqRf/v+7OTIFUjDz30kLz//e+f8vkxxxwjDz74oMwG4lwUIawWdramFljqEuxOhKM+j2sP8H0nrUtlpVxE8znWanVtHRgYkHvvvde81rIbqw3OJ66DmSBKq2UckVmCnTwoyWXSZy2K+v50tbMcRLmv+tbT+FLXBdb+P8i+H0x/fG47POtk7+fDo/n1T875zST90aRBsFwiThbJouxkUFHfT/N5ElOONeV29ByYMjcRVlk7wVZaV2fbTTjt8Rh36J6wLq9dksfrmp7gPuweYyFu2qTmmRkzmhKhcaT2/2dajOmiRYvknnvumfI5Plu8eLHMBko5gY2avOczqdf2AN930ra3WIGYDyrcVLwVY6WajnYnCc3R0VF55plnzKuuT5Ezs5jO8U9qFBVB2URBdVMTsbgT5dkygU4rGty4PzvWz43702RNI73pxEjKdrj389hzYQtpECdkkx4ERD7QcD5HGwZWh6I8blxMiTVO+SBCz4GWG4q0NuchBO39a2KttFZoJMjSUjNxx5GPgM+37YRkqG7zYBlKrXR1dWX/PxM59thj5f/+7//k8ccfl7333jsbY/r1r39dTjzxRJkNVCrGL8rVMKk9adtbTpdLt+2lzGo8Ha6i+cZL+vp8prm2znbc88HzUuNMp1urN8tqRObRctRWrIQLb+p6k07cn10DFNj/V5GvFuhStsOH71yoiDPbzjMWuJhzhNqxqC0bNy4KPda42MtSbD8f8on1tPs/Lp7bLNOEX5Pu/bPKxZ2UjZoSplpqBU/p3vzmN8urXvUq+eY3vykzic9//vMyZ84c0+5TTz3VfLbuuuvKF7/4RZOddzZQqQlslDhKak8p21uouHLbrsJNXZ6rXailFfcQ2u0R/VOryYCqlVKeDz50mAUUKgALmcT6JttRk/xyTP7LIXaTSCva3LqX6garuP/Pt5RHMeIx3wQ65TpH7rgp9bG656DU28+HQs5xVAkc7UtNHqXJl+K+S2FKalmYKk1NTfL8889Lb2+vzDRQZ/WEE04wf9p+CFUyO7KxFjqZx7omY3FmG9NpnS0FabcV1zfVcP7SUgtCq5Tngw8dZgN1YVKWfLJwqhunyU466k9oY6+rosY32Y6a5Jdj8j8dlq7ZiO9cpBVxpTxH5drnTCSq3qjbfzlZqhPGP68PEsPsnBGlANbFP/3pT/Loo4/KTGJwcDCbAAaCdNWqVXLeeeeZjLxkkkKS4xSbTKYUCXkKjcNTgTMdtR0rEd/Z3Nwsm2y6qbS2tMS6VM+UZEDT0YfFjsdiv1/K88H41NlAEGYKxWta7LIdZhMJdRvziWkrVWypbztpEteUMrZ1hsXJ4n6+2WabmdeKtT+fxFTlbF/Stt3lxbYl3+9H1Ru1+8/ty0JjfQmp5XIxm2yyiQm+B0uWLMmmtYdF8rHHHpNq5bWvfa1xQz7uuONkzZo1suWWW5qb+4oVK+Scc86RD33oQzJTKGc68GJLpBRi+VKxUe59pmlLuRMVVYu1bzrbUsp9TUe7i70GpusaKhUsL1Dl/V+IS25cHFvcuvmWHimmlmLaEiTl2n+pt1UJqr395Wyfb9v2WNYHLqYEUp3I2udF6hsnMxKX+ljc6yjKYlpmeD+vXap/tlEmnnrqqez/X3jhhez/IUyrGdQpPffcc83/f/vb38rSpUvl7rvvlt/97ndy2mmnzShhWkk3wlIJA9fFsJKupGmOpRTHXQlBOjY2Zh7EzJ07N6ekU74unsUcfyndSaejD+3xWMhxV3o8k1lGPi6zOW65drxfzPfzdclN604YJY7V8mQ+D0TGhyYTBRmrcF18BlN7/7oPfEetrGp1NdlSE8R2KV0jpyExzZT7ua8v0jyMKAXu/tQymNP3EefKd25si6RaBn3HYW/HHSf4/nBf+DnEpy6HWzusl/gePk9RmmfKcSaNSzf+s5AYVCY3IkVQs8L073//u8xE4MarMaVw34X1tL6+Xvbcc88csV3rJE3ASyUy7Ml7NVgQZ2usXn9/v9x2222y3377SXd3d2rxpCVzYPHDXzHHXyqhVm5rqXvM+lm+x13JJGTVYpEn04jPSqRuuVGT+mIES1ohG5XkxdSgDOtbm4l7tgTLaOiynGRds/evVizE4JrXAZGm9sltRSWJiRLwvuVprcyR2YtLJ1in3M99feFLqhNF2rYlHS/QDMA4v3AjR+IlrZXqnissx3r2cs0irOdQP9d9qJiEQKyvD93U7e+7WYFV/Gq7W7omz7e9L6D7i0s4lDguC3zIEXX90l2X5EnNCtNXvvKV5nX58uXGpXeDDTYwLr3Vzuabby5XXnmlHH744XLttdeaJEjgxRdfzJbCqXV0Yqv4JrilEhkzbfI826xgSf1vEkJNhK8a75h0/D5hl2ZfaQWWimPsoxwPNNxjnmnnfaY+PCFFkjOZtSbHppbm8KRAcNfV9z7LVSmEVFSSF7vMCrafkzk2Iyby3YeKDdRTh2BBqQ3buuUeU5IAcJe7bpne70ckqUorNrLCK6HmaFqLXk7fR5zT1G3zrOdaQ9HvZvv14bpx5wrHaRJzOdvDWNCMtO5xqNUTUXQIncY+sB3bLdfNCmxfA93rhp/jXA72hP3V3JlZuS63VIvdV1GC0+3TQpOBRV2/hORJzQpTJA068sgj5eqrr85+9vrXv14uvvhiWbBggVQrcNd917veZQTpa17zGtlrr72y1tOddtqp0s2rCtwanioAlJli3SyVBckVWjPluEsBjtcVaEnH7xN2pS4/hM8wJymHAHOPWfdZzizN2J/uuxQPe5L6hFbVWYg9mU2aHOeIicyE2LjVWll7S2W1cduSk+DFcnEsRRZX3SZefdYt95jyzX7q1nf1fj8iSVWUu63bt2rF0+NJLUwz3/NZEO3EOyoE9TsqxqJqZsb1h9tGLGudMymMfX1rr6/jzN2ebyzod+xSRnZfuesmjSdsA6FnGm+K98bKW++3NidZUou+TvK4fgmJoWaFKZIHXXXVVTmfQaQiRvM3v/mNVCtvfetbZd999zVxsTvssEP2c4hUWFFriajJqU5sdWKuAkCFajFxd6Vua9rvFiNgSiW0Skkp+j7KsmkTtywfYVdKgaXHbPdBKSnkmIsBxzA8NmEirpoapscLgVbVGUiSBTNqMpvN/BkhJsy2MREfz0+05dv2QqyAqbfvWoAjhJZ7TL4+c9tqC1u3vqu3PEuKfosTM3bdUdwV1G1Vjy3KjdRYBjPus7pdLRcE8aZWaVs0qkutuk4nnRdbgNrvCxVXhQgwO2ZzXAVjXF9nxgKO3T2XfSugUMP+DTLjXy2+epz2tqdY3Ef9Y60QbwOKUVIiqmOWWgFgYVxvvfXksssuk2222UYeeOABedvb3jYjyq4g4RH+bHbffXepNeIsUq7rpC1Uddl0Tm4rGdtYKqFVSpGZb38gKRkyfo4HQdY6t7JvOJOsrLTHFifs3CzMccI4qT9mktU+DhzDxMSEDI6MS3Pj9BzPTHJNJgW4gsa5FkYtd5PYlJJCrYBpcS3AEGc+oZVj3Ytxa41qq22RjWxLGstayhqgbuxsZrnez3OSTer3XLdp7QsVZu6xGrGmcZgpHiDEiupptvSl2Z87HnLiitsmkyHhvLp95LNm28dui3ug383XiupLCDUdiavIrKRmf9XnzZsnBx98sEkahNhMuMTifTW68cK6++yzz6Za99e//rVccsklUgukrfmJ5SoebFfDtN+fzrZGfbcYF0l8d2Fna8mFqQozO7FOufqjraNT9n7Fq6ShpT0bn9nS1CAjY+E+p6umqi2obUt00nd6BkdkRd+QeZ3O+q/TAc5hI8ZoS9O0HVux1wSpAJigxmUDVSAsBlaL9L3kr7XoWhez23cykkatV0hNR7UC4q8cwtdue5p+si2JU/ohpq1p+iSyjVa73L5O+g7WtdqEOdcBBxwwNS+Gu109ls5FU917dV1jgbQEVTYJ1Uhx47BacNtrn0Mct106xpdEKW5beIWFFduz+yzfPrLd6bNJnooYa6SmqVmL6Ze+9CX53Oc+J/fdd59svfXWxmJ63XXXydlnny3VxqJFi2TbbbeVffbZR97whjfIrrvuKuuuu6554rh69Wp58MEH5aabbpJLL73UfP7DH/5QagHb4pQm4ZFr2SvWYpWPpbBQF95qzU6qYquhPhSY+YruuGPyHbcKQmDX1WxprDdtmC7rmW2pS2uJVlfXwZExaTPrlifpUSUpt1We1BiakTTKVdRYxcYnS3J4LalFuqTmG/OXD3GukvlY0Wy3zTRtLca9uRBrom3Njit7E9Uf+e7TdiOOjLstNLlPGcvo5DUerORU+ZZy8VnQNT7VvI9xEY9ts5UQymcxJSQP6oIAqcFqD5RYSapZiuWot1UNIHvwj3/8YyM+IURtUD4GTx8/8IEPyOte9zqZKZSygLJa7TSO1BYv7jq+ZcXss1Tbm+7tF9s2iK3xiQnpbmsueVZZ+7gh7F5atVruv+cu2XW33WT+3LkVF+/57Fetq7Z4VkE/3ee1XP3lxsv6/l/u88OC7JUlsf/VmpJUriLKHdNXjsIIs6bJWEYt7xG3fXdflXA3TNsXlW63m8XXZIJdE+63LVPmpYDjXbt2rdxxxx0mBMlYTYvtj6R2K0k1SJMs1PmOr9TtzeP4S91XhVLmdvB+XrtU12x3mknS5NWk2VHK5rOf/az5g5X06aeflsHBQVm4cKFsttlmiSJ7toNJr7pUQizVZ97bE+J849Liyn2odbacrsDVHEc32aeld6d0jxv/x+geGR6WBmecV8rqmE+MLJZDvNvfrdR5LXVctbpyA00sBmzXbpZ+IYnWOldo+Sx+vhhHTXikNSV9FsQ4iokpjM1M66uX6bEw+Up3qGuxbfWNjZnMbHc8k23XxB62J38vzXG5WXxN2ZJBkfHhML4xdWKc3OPF3AoPLrJzLLc/ChWQitvu7LE5CZPs7L5TYnWdByE6vuyETmmswG7iJ2/iL8/xR8XKZsdERGKpqGOIOs5CYUkYUiZqVpg+8cQTMpPjY/FHJsEkeO3gqLQ2NWQn3O6EOF8REzWJ18/LbfGqZlfPcrbNl2UZfV1NFPPQoBLnVQVkMS7Evgc1PYOjMjw6Lg31dTkxn1HW06T2ubVmq3X8kwKIE4FpXGp9GVN14m27EE6X5bPnBZH+F0U6FovM39Bv0bWPx40NtNupFj4jLntD4dQ+P6xnOgRLXWNYv9JOKqR1LbEdbHftC+F3mzrD7ZvvNYXxmUZEpnSjtbftZvE1JU5GJ8V1qR4ATElw5RGQeSXMymT4bXPcXH0up1Fjz30QYn8/Tdvs9azET35h2pRfAis9T0nbd+M8S1EWJqrNhJSImhWmG220UaWbQIosBeKuX19XJ0Oj4zK3vTl2QpzWndGeIEdNnGcKaY453z6fLtBeWOOqiZkmmjRRk0joel0Ivgc1TQ11MjJWJ23NDVPqpvr+n9Q+HX/ufqo53prI9FhfkrLzJn0ehW99n8uqu95QTxgLi9c0WWvjjhEiY3RQZLAntMxBiMJFUi3C2E9U2xV8B0LUPMQLMqIF24RAzVwzPsuuuqj6lueUNsnEiULolluQRMUsRuGKy4ZGkY75mT6014MlcmBqGR3feYkrHaNtU6u9HevsO4Zsgq26lLG1aWJlre3bSYtysOJRNTkUYz5JlVNTv/Cf+MQn5LnnnotdB9lvsR6pLGkzniqYzLY01cuCzpbs5DUqa6c9wfbFASr2Nuz2zMSMoL5jLrbP3e27/VdKEDusr6XeV7nbDpAo6plV/eZ1uvZpg/GK4VrMAwdfJmWI3EVzWgoWu772uftBPy3rGZT+4enrLzLNxGV5jcqcG5X1MykbqLs9/H+4b9J1EkCsrX1OZOVjoVg0n/WI9L0YvuK7rV0izZ0iXevEZ61NU8JExYVaKTsXh4IQFlL8v2vdcLvIVNzzfCg4WjrDbUFU4hUW1e71ROZtFIpHfK9jgUjrnEkXZxWi2Ab+cCxjIyK9y0NrrbYF23bjBn39VC58GXdj1/dkm/VllbVdfN19+ZIOxX2uZXe07mrsMbSH5wEiG+iYQB1SHVM2Wl/UdQW3xy2+s/rpjGU4k5FXj1HXQbtG+kTWPh9+VqoavGmzWRNSADWV/AgJjxoaGuQVr3iF7L///qZ+aXd3twnER0Kh66+/Xv75z3+amnzj44glIOUkLri9nNY7n/UlKdFQpa2JUcllComXjaq/WcwxFpOoCWINbthdbU2RsZiregfMdYpEGa0tzaZMDGpmFiuIim17WiBKR8cDY2HcYH5HVSe2qjZQZmd4FA9WAlna3RY55pkso7KUrf+jkqwUajF1t6dlVyAKdXIPAbjq8fDZPcQeRB+EHOIrG9tCK2qpk9XY7VD3XPs7Rsi8GH7e0hWKz6Rj9bnpQlwOrMyUb2kL10HsflNbuM007Ss0Q3GmPWNBvazp7Ze5c+dKY+M03v+ikiJFkW//Ru3Ddx6M+/Xy8EcA5wFjTMH4g4CGFVzPiTuOlj8Uxvo2tIgs2dq/jnnA8nz4vn1B/PnNh2lIwMT7ee1SUzOiq666Sj71qU/J3//+d7nhhhumLIdG32qrreSb3/xmRdpHJimnAPQJuiT3XLs9lXArdC2e+SaUyY0LHMlxmyxFnxfj3gxRCtGGV1eY6nHOaW+VhsawfXhfyqdp5XDNdscIRLeK73Ltc7rJ9zpwH66s7BuSwZFxmd85aXH1bTMck5Nu9KTGiHKBTRuvl7Q9u36oAuE1f9NQUKgIM2U1mvJ3i0ybJMZth88VGBZatXzFHasthGzhoC6irdYxATuONG37CiFjzW6sE5O4cdrJt7xKUuyzr/99iZemxIlmxoR5uKAuy3Y7ndhe+zva/x2LRPpfCl+j1sH3sdweM6WAiY9IGampX/mDDz7Y1Cu99tpr5YMf/KDstttusvnmm5u6oP/3f/8nf/7zn43lFOtVK8jEOzAwkH3/1FNPyXnnnSd/+ctf8trO1772NXP8KDWzePFiedOb3iSPPPJIzjp44n388cfLggULpLOzU97ylreYsjU2yA58yCGHSHt7u9nOSSedVLYSO1o7E39q3SuVa18+7rlp3GLtde12FurCabs3+lwqp9ut09e+QoUDxBosiSra7G3qcdaNj8pLzzxhXrGfzpbSPbgoh2u2O0YgvGApVQFW6D7TjB8sh5WxEJfsYo4xqm3aHly3uj7+1gyMyuBomLQsapsA/bSwszXnwdB0ukETmV7XP3fdODffQnC359s+/g/RACuWyXCbia+EkFMXzrRtSruuvV6aNqUVVG6mX9u9VPelQtt3fuLOXdJ5nXIuQxdbXPcPPfSQmc9M+zjLZyxGuQTHgf6FpTONEIzqe5wbk7SqPdoVvHOhyMLNw8RW9rUCN29YSmG5TTNmCnHLLfU1SUitWkyVAw880PzNRN74xjfKm9/8ZjnuuONkzZo1sscee0hTU5OsWLFCzjnnHPnQhz6Uajv/+Mc/jOiEOIWQ/MxnPiOvfe1rjTDv6AhvqCeccIKxMl922WXG5fkjH/mI2ffNN99slsPdGaJ06dKlcsstt8gLL7wg73vf+0x7vvrVr5b82DERRe3Musz/tTxFvpl27e/o5D0fkZCPtctNGFNouQ5fptpCqbbkRhBrPpfcXFfrEXnsscdk3XXXlba2aHfOaqFcFtGk8YPPV/YNZ8pH5VrEi8F1854Uh4F0Zx4oRLVNY5eDYELqmyfH7tz2JmMxtR9I2P0WV66JJWhmGGmy7ip2Vlhv2ZgCa3i638unJIm6wEKklDP5T5p41FTbGJi09rp972Z8BVEZYDUmFRFfSKRk4iQz67mJk8z6znlBHCQyBTfPCYVUZvsjgz059/PIc5FYdsdjrUxyN85nLBaSeTaNVTafjL2+Y9I+GBkUCcZzl0WWyolyfff0R74uz4SUkOqe3ZEp3HXXXbLffvuZ///2t7819U1hNf3Zz34m3/72t1P32DXXXCNHHXWUbLvttrLDDjvIxRdfbKyfd955p1ne09MjP/nJT4zYRTzuLrvsIhdddJERoLfddptZB1ZaCNlf/OIXsuOOOxpL85e+9CU5//zzZWQkIvFEEWBy2tJYb2ILMTlOYzV0rUf2pFaFLuIV46wvroUmH2uXa90s1tqZhlqxKKWxDJbKYp0vUWOk2P0njR/TF0FgxnSSKM3HsuomxtLrqNGq4xPVNrXQd7U1Z/sEf0u722WTRXNyHkrY/RblmTAd1xApMYVYnqJISm6U9nv6XuPlkraHzLiF7DffNkKEQARD9KW1RLrbQDuNYAz8iYFMfGnLZNkX+727LWwHohSlUew6sXZtT7fsituWpD6LOhfFbHM6xmKhaBsg/KL6Po64PvBZbPUhAsZWTl9mkiy59X99SaLixiCTIZESUj1mE5IKuPHC/VaFISyYSOq05557GoFaKBCiYP78+eYVAnV0dFQOOOCA7DqIv91www3l1ltvNfvD6/bbb2/EsXLQQQcZqy1cpnfaaaeSnlVMRPNNduOWoXAtWZjgwupTrJXKtuzoe7vdtjD1iZVSxqxWq0Wp1MfpiiXU1IRLMMaInSSqFBbrUlHs/tP0XUtzo3RlHt7kc23EgeX2evqQSP8f17ZCLfRRVmeWjJmB5GN50hqU2cykbmKjjBhrnky0lHq7vpqUaUqSuLF+5UJFIoSCZnuNq5HpW+6WGvHVwXStiVHWRT3WztapVmW7H7PWTCcu1o7LTTpu37nIt+xOmjjYaqi/mdOG9uQYYfeYtA/MeXPGrs9i6z5EcD83Qr0pPsZ1ShvLWCOV1DQUpjMMxMReeeWVcvjhh5tYWbjbghdffNFkLC0EZCFGiZx99tlHtttuO/PZsmXLpLm52WTNs4EIxTJdxxalulyXRWVaw5/+vxAxE5XF1QcmxBAsDVLnzWqL5bCaYh185rNyJbllRokflDZJ426cRqzkI+qqNbFOqUWhLZbwOjw6bmpqtjfbdTZz+6LSfVPI/vM59+H4Tbd9V2yW+yFRIfuotjFMCryf5+V+i3TVDf6JbtREOg3ZeD51l61LL1Q0ps5noUrrhprGTVdFo+4rqYalloBxt1to1lxfe6L6xid43XXzTTaUZptp25R2zBXqGl5O3Jq4xbp6+x4i6HvfOEtz3tzv6jWA9lVTX5IZB3/1ZxinnXaaySy88cYbm/jSvfbaK2s9LdRCiVjT+++/Xy699FIpN0i6hHhV/CFZUhI+dz47i2vUd9RdEpNuxMCpQHS3iYnv+MSEycgc5dKb5Lob5a6b1t04jWtiPgmXypHMpxQU44KJuOUNNtjAvPqS4oR1bBuko6VhSiyu3Rel7pt8Ew0Vsv9izr2dMMz9vptUKO46KqbGbRxJCZPKncCJTNP9fIobbYwrapxrKSa+iMtTUVlQcqU8XXijjiFuez7XSSwfXB266SbtMym5jL1c3X9dN80qZsr9vFj3XB/2efHWwc2MmaRxkHZsldSd1RrnOYmsYs517DWVZ63WNLjJuoynQ/+MGoekOqmumStJ5K1vfauJBf33v/9t4kSV17zmNXLuuefm3YNIaPSnP/3JlNBZf/31s58joRHiRJFgyQZZebFM13Gz9Op7Xcfl1FNPNW7D+IOVtxAxE5XFNWoiHxfnqZafjpZGE7sKoibycW30iR/9SxKcaWIgpyuuzt0/+gE1OPFaLMWIQmR9Riw0Xr3Lmxtlne42I7SmU5CXS7CV6tynjaNOuo6KzeQcNa51H26W7enoV1I8qe/nblxfnBBRix/+pkyYgzDW0SR+sSbhUVlo49qCSXU+sYZRsYm+7UW5TtY3hZ/ZLsnFEivkSyik4F6N+pp4LZIp93O7b/PNrBu1vm4T+MaGjhngnlccI+rW9q0IEzjhYYJ+L6ptmiBLLZpJxxHbn5lx7sYIu+fadzzFCuxCUVEKQV3J+F0y46Err8XXv/514x77t7/9TaoZiD5X+O2+++55bQMWwo9+9KNyxRVXmJqum2yySc5yJDvC08zrr7/elIkBKCcDUaxWWrx+5StfMRMSfVr+17/+1bgUb7PNNt79ouC6Fl1P48rrc+eLyuJqf8d133StaO573Z5xCc1k/k3rElmqTMPYH/C5u06XW6MtRiBGH3iuR1qb6mVwpKXksX75uKgiA/Ta3j5pbGmV1uamrNCpdIbhKFfxUlJsP8NVv7GAbdjXkT5UKLUbt+5j3DPuUee0qzX/zNtk+kh9P4+q45jvBFa/hxFju/rmuLYWUHsy1b4LqJtquzRmLZyj8fGjhbSrENdd26KofRjXHl+2V9sNVreZIoMu7ufIlwFh2tDQkNuHtgUzqj1p4htt123v2NC41taI7L6DIuPDIg0tk5mH88nom7RuVPZc03ZrPLvjyz7XOX2VcE2laXuxbs34jhHNTdXvLk2qFgpTi4cfftiUUak2kOAoLZdffnlq991f/vKX8vvf/94kU9KYULhkIX07Xt///vfLiSeeaBIiQWxCyEKMIvERQHkZCND3vve9ctZZZ5ltfO5znzPb1slKJShmIq/WqaSESKXCl0SmkIm4CkmU32hrbshJAJRve3T/q/pGpKWhTlb2jcjizhYjwOa0NqWOnS1lzGlfX5/cfNONsssee0lDd3deiXvKie7bPg64oKLv5nc2GwtuuZI/uURtv7O1uSCLaynbmZTIyG670t7cJONBQGE6G3HjPfOdsJrJt50kxy1zUoDoLSVxsZGumKsUUSI/Cl9CnCSBGCGGcD+/8cYbTYUBzDW87RofCy2KdsmSrPvt4GRdWXVnVguiK4DcuFNY9GwXVP1cYyTVslrXaO3bGmtpEy8lCUWsD3dv3X9SbK2POAEbt24U+QjvpOOPfCBAYUriqTlheswxx0Quu+mmm6QasW/csHTCyonPdt1112wGXbjc5iNgv//975vXV73qVTmfoyQMysgAuAYj4y8spngajoy73/ve97Lr4kkn3ICRhReCFfVPjzzySDnjjDNkurFdBeNcRtOKg9YmqzZbGfElkSnUZXNgeFz6R8ZMyTk7AVC+7dHvQViBpd2t0tzUJEMjY+ZPKTb5TSGJgFRgFZO4Jw2+cRI1dtzjgCgdGZ8wr64whYBVt2gdo4XU0k0r9Cud7ElJut7c5eiLsXFYenNjhqdL5JNpIt8Jq66vrrPVmHU1yTpUyvYVY4lKI5RzssN6EuIkJsApwDKu7YIonWKhzcRYjg+JNKlgzMfaarnIxtUVhYW0rds/xopJBmWjgjeuvaUcS1rftrku3sJf6EMT+2GEvqa15hJSy8IU9TrD4vNTgeiLWlZJIBaVU045Rd7+9rfLBRdcELrAZNxiPvzhD+eVlRfHmkRra6upSYq/KDbaaCO5+uqrpdKoS+yQsRhGu+GmKf3SUB8mRGpqmDmXhxFrLQ2C4QuLaSkm6xBV+FNrrEiD9A6OSUtTroW3mDbnuw1YakvhWpqEb5xEfeYKJAh6tZja66iwhuCqqwsFqbGw9g6badLcdo0zDkzCLhyfPnBJI1x9ItRup/2+2rFFu13qSal02R9SIvKdsGqCFVj5XCtTEtPlThgntkvdBt++SrmPfN2i8X9bHNqJdfK1FPsstBpjWQf330Z/vG/abMa+z+3My9MhotzsylNcoUtoaYxzHS7VQ5MoMVrph0VkRjFzZt4lAmIOYmq33Xabsuz2228vqhbodHDhhRcay66KUoD/w+V27733lrPPPltmOvZEPq2AUZdYO6mRTzQkWZAm16u+rLZxoK22da5QovoM1lEIBPRvICjJMrtvHVEiz/3MJ5BU0OtyiHo87MD41H5TsZUVrBIK1pGxwLivIrmXLo+LebbPF7bpK6NUrSIuqexT3LFXiyWYFEm+E1Zdv5DJ+nS5E8aJo7wtxEkWM8++CrVC+9YvyOIZ8Z2cBFUZzxt99WFbaN0yKbq9KftOcmdNEyecR3mbYkmy9pbS0pimNmmxUIySEjC7Z5cett12W5k3b5786le/mrIMLqw///nPpZoZGxszsbBbbrllzuf4DElOZgM6kc4nltHnEouJus+1Ufdhv7e3435mW23yEWQz0d1QxQDiSdubG6ZmG57mrLc2cCufLtxzltaNN40F3nY1Nw8U5kxuC+MM1tbVfcPZ9dwYZHf7OsbtMkr2tZCmjcWMU/v7+SSlimqv3e6oY59J1xQpMcUmTiqXJSzH7bWjNG0oJJFTIVboqPULsXRFij9rPxO9Ug/3nomUGWLVhVe3D6YzZrHklm5fLKzHG2CKe2ymDBHWhatxPm3Jt6ZsXFujoGWUlICajDFFqRUfCMSvRldem6OPPtokJXrssceymXhh6T3zzDPNstmATnB1YptGKOZjHc3XglRoop1qtVTFoeJI67qqparUx5KvGEJM9etf//qy7yduO4VkS/ZZ4N0yLLYow3sksLIFW9oM1LA8qgXSXSeujXZ7gOs6nNSHdskX7D+8h/qvFXtbbnvVggpXdN13sXHMZAYTNSEuNHFSuSfNaSyVeVuIi4jRLNf6hWLtp3veAnn9ga/KTzzDhVf/D3JiW8vspq2lUNCGQjIgpxkrUd4A9rqIEdVswc1t0yTKmbiITC91QZpgQ1I1wCr6jW98Q771rW/JCy+8YD5bZ5115OMf/7h88pOfzHHxrXaQUAlxrMrQ0FA2m2/cZBhZT1f3j0jv0KisM7ddFna2ZCfHcDVNEo9R2476vNwW02qyrEYlkSp1G9WaneZ8RX0/6py4Fjzdjy3i8j0G7ZdBiHapy8aAJn3Ht78kF9ak5aXG7a++4THjPovavppkKu5c6ffV2j48Oi4LOlu862o5JliQ3czRqJcLQQ6X5nXntXv3FzcO4+4npPwU3f+uuFDXRlML1FPORJfHJULKh3zFjbt+KcSRXWsS27DdVr2CLJNsyJc11tcGCBuTCbYuFDYmpjKzT81AW4rjwH7sbRbaD8COU40C9UZHekWa54h0LszdTtSx5LMP9Fk+wtR3HnPGbqZ/TLsaJ8+hvsLF2Y7RtZNK4bualRpoe+zt6ViIa0Na0o6HEj8c4P28dqk5i+lMB+6MJ598svlbu3at+SyfpEczhSgLlVp11g6NyfDomDy5ot9MZBGTh1qNaSbySZafJKtgWpFmL4/7TjVZVtX1VEWpUmrRnG+MYG9vr9x9992y0047mfJGcVZstz9dkVpIP+vxrxkLJAgmZCATA1roGG5ubMiJo7ZJspKWGvfcuu6zSedKvx+uMyHz2idrAut31AqL9xClGGN2bGy4buit0tXWbNZBbdM0Mb1kluBaZpLKmZTaNbfY2My0lse4Cfxgj8jqp0RGB0TmbpDrtqoiQ2tq6ufIJItMs+ruCQEFoQYgCrWkil2fE+sgNMI8ABjITYpjH5dP/KY5Rk20Y0TwVNHcOzCUcz/3fn9wdaZ8y2juMfgeCGA/wVhYczTuHMW5B8clj3JLoSSh28Z5RPbgKWMjkx0Y5w7nQc+hPmSxMxJ3Lpp8UIN1VOj3vSgyliltg+XwVMG57JifOxYi25CS1OOallVSGihMZzCzUZAqcW64iDtdb26rPLc6MJPo3sFRWTAH2WPDmof6fZ8gdLN82sui9umKoEImx77vaNtAIXUmy0G+grGY/eSzD3gK4EGMxlFHlYvJ6VOrFEvc+QVhbOeQsYba1j53/HS0QFAiOdFkVt04webbX7lL3RSDz3026mGKz4JsC1HbPXgyiVG4fbtf9PrCgyWUJnK/b1vsq+laISXGFZq2y643k2qeE+0oQWjXsIQwiK3zaG/Dl3gohdUobgIP8dG3PCyH0jpPpHu9ye9AoEOUGguyJfSMVdUSfxC3Pc+K9K8SmbNYZPGWk1Y1tZA2tofWPxMPm7HEqXU2J1Nspq1DveG+01oMNdEO8NQ5nRgeCO/nwwMiEKa+fqtvEhnGfhvDbdmWQdt6ifdoW2DtN5sJNi5+1uMeHHV+CnHBNtmDM+I/LgswGu6ew6iMxDnH0iCy5nmRpiaRtoWTFnB7DKMNo8NhPzZayRHL4frMkjCkRFTfzIgk8tvf/lZ+85vfyNNPPy0jI7mZ6e66665Z0YNRE36dpC7obDWWFRUeoEHqEkt8uCLTXha1T1dIaBtAkjixQTInFbb4Q4KhkbFx4zIZl1E3ym21HC7GaY6lEq7HsIrbr1HHrBZfiBdgZ3WNK7eCfuwdglvgRDbG0RcPqufJl1jLJW48lbvUTbnPj7rt9gyE5YNcC7ItJiFeQZuV8Mlul0+ou6I+H1d9MkNJlTG1CKIEoX6exiXY3obPNTJVnGmMWII1rLVbJOgUaZ2TK4y8CXOa/NvATa9uYmrWW28t0qbcz9z+1mPBcU3pjwiBo/uxRX+2DEuDyACsobiwB/39pn0LYeXbr++YjcgMRIb7JkVr3NjB5z6RXYzAsvsD284ef55j2s1I7EuqBSHa0hqKdCSR6lhv6hjWNkyoO3AZrZtMfERKBB87zzC+/e1vmyRHS5YsMa4wSIC0YMECefzxx+Xggw+W2Y4d96hCQf9giXGtKfi//Rm+g//qNtJYX3Q/tjDV/9tWoSgw6V7ZNywaza2T7CGTZKguK7bivq9iOs3nCvaDeNwXegZz1nGT3eRLId/H/tEWtx0az5q0v77hMHvj2MSE97h0+1hmlwyCRb25MVmg4Xy2NtVJQ93UrLu+MZJ27FSCYs9vGrRvu9sbpaVpUsjby/UhDGq2qpt9lFC3ry/7+7Y7cbX2N5lG7Ni9fMHE3mcRjfo8n23ks624eD8IiUUvE1mweejCmfZ7Nlhn3iYiC7GdTYuLv9V9ol0tnVO35br9Rn0fghFWTdP2QKQx0z9Nbf5+i9sv/m9/5r4vlqLiMT1u0HH9EzWu7fc5ZXasz9HG9sUinUtEutaZOu7s5GCwOmfjlUczYtWyvKc+vph2+t4TUgB89DzD+N73vic//OEP5Z3vfKdcfPHFJtZ00003ldNOO01WrVoltUySBVAn6u4E2Xb/zcfalNbt1SR8GR2Xl3qHZN25bcbSi0n2/EzSJnwfCW+Az6oX5fqZ5BKKbfcPj5sMu7ZFq1h33bjvq9h0j8UXE5pPTK+WimnMxCbiuGBtNvHF3ZOWcJEwqY6SNlYTbVrS3Za1yiW5sVZLsqo058e1rEdZ2vMd+2liYXV/ruuzvS/dt2+ZLUyrsa/JNFOMpacUFlk7U6qZfFtxl1OSNzkJgKJqcbpJi4yVK3N8+SRYspdB1JpyInEuxY6LdJxrZ2TfpbQuuuupNRAxk7Hb95XDcUqo2OskxYKWO5HPFHf0lP3jjuuc9x7XarXYL9oseZtIhoSxYH+OhwTqZpwPse30vCekAGr6l/7Pf/6zHHLIIaYm6HPPPSdnnHGG3HHHHVLNwH137733Nv9va2szSWHAe9/7Xm9t1lojzgrnsyS5n+VjbXKtOlGoy3B7U6Nxf9TPMKmHpQjfx+coz+Lbr8+iFPe53T7ERLoWrbTtLgRjuewdlpd6h3Oso7al2m5HkhVMRQrG+g477iRzOsMJXUMdkhCJOTZ1s7W377PQxo0T3U9Yb7S+4hbJYnDPr2tZj7K0pzku3/UVuqWPmD8Vvbpcxyja4l5n/cNj8uyqfvO3ZiD8btp2kFlKksXFtqzlY52JW1eT5+AvyfKj68J9UrMCq0jVz1Uw2QmATDbVTGykroNYUCSwwWuOVSzi/2b/7vsIyxo+g0srtq3HpkJZj8nEs74YJlvCemkse4VaF+31GpqkrWu+7Lzzzua+XhBRlsik9mi/6AOCKNKu544Td/9J7ck+rHDim+1xnpMILEUcdNK1ko+HQNw207wnpABq1mJ6xRVXyFvf+lZjTULdPbjGnn/++XL//feb+M1qZenSpcYyutFGG8mGG24ot912m+ywww7yxBNPmGOpdeKscD5Ln/tZOZL/YHK+/vx2WTs4YlwaXUuWukXa+8cfkvGs7B+VBR1NMj8zubctTFEWJ/vY4mJX7e3Y30myHPvEvLtefYq4yrTxrCZLcGuLLOwKE4GMjYzJ3I5WaWwYMZZo41KasYKjP0OBNG4KuEdZlN1xYsemlspSXoh1tdC44Thcy3qUpT3NcfmuL403rbOSk9keAG6iMd3X0Oi4EciIvUbf59MOMsPQMiXGItgdk2E1weJiW8dsYehb1952PtlZAdqq2W/deEtNQGQnrLE/17Ie9uRc4yTtZDvjlhhs6PZbL93/uxY417JmxMeQyOBakQkcU51ISyZWVTP64lxobCViPHFBBzg3SKDj+b1Ia6W125ogVJubm2XdddeVGZNoJzJxVpEWwqj4Zl+cb5o46Gw5II1TzYhi+1rxxkZ7rP3IDAxgfVcLt9uupPeEFEDN/vJ/9atflXnz5sk+++xj3jc2Npr/33777VLN7L///vKHP/zB/B+xpieccIIceOCBcsQRR8jhhx8utW4ZjbPC+b5jW5ewbHnPgIkHdS0/xYJ9LO1GzdVQYNqWK9SsdF0ZMVd4bs2QDI+Nm9c4S2+ShSmNFdnNohq3TbuP3fWMhWxOiyyY469jmS+6r4mxURNHjdpm+hmwy66oQILlGaVHXAtt1DEoEEilFpr5Wv+S4oYLwbWsR1na01jS3XOv7dRYXnwfy+FibR+HL2YU2Y+ROMnUS22ZtOrrtpf1DGYFLpnhaJkS1JqMSsJS6nhPV7RFrasZVDVLrS0yffGomljHnvjbn0OsqgulmdR3hOVANHmNTtxN/GTXZJIey6Lo/b/Zv/vetaxpkiIIZExsMiVI0DZ8D8eEY1OB0rFIpKllMtGSV+DHxEn6rLtqHY6xZOM+rvfzvFDLtJ15Nx/i4lHVqghRBrTP8HnP8+EfLMs57RjIfRiRb2xl2vGedj29zoYc630+14puB9eq+YuwGjOelJSJmrWYPvzww/Kud71L2tvb5ZZbbjGfwWr60kuZp0RVCuJLtWTG8ccfbxIfof2HHXaYfPCDH5RaQF0H1criWgmjYgKRBTfOimZnZgXzOiZjQMuBWq7qJMiJv1SRvKC9UXqGJ2TJHH9SJ5/FNB8r8qRgRfmTumzWYN/2bdw+di1hhdTgjLLc6l/PYL88+OCDZrx3d7dk94dzimzM2ga1PKcRWO5yjCdbECZZi9OMC18/YuziYURXpsSKLXSruZSM2yf6MANj03fOk+KfAfoA/Y6xh35RC2v4sCYwr9NZ05WUCZ3ga5mVyJi8POM9oyyvhrpQENoiL9/srL74xjSxkDnWvEzNSrxC2GCy3zxHpHPh1Ay5+TLFYqUCeX7GmusRtnY/mVhUjWmNSegUtdxnwY2qO2sxNDSUvZ+3tDi1R+NwrdulijPWbbulcbAuBOjACpHhjGs2LP5aZxUlbbT2q13CphTtKWS9bDmgtskHLWm+PyUGGHHRmfqyUSIeFtXx4bB2rNZaJaQEVOfsZxrADfGRRx4xBZ7B6OioEXhwla1mkARGE8GAd7zjHeZvthHn0qhul2E8YGNqEQvxBaImy/h8TuuYjIyH62L7LSkEgu5DBZ5uK0lc+JLR2JP/pfM6Zd2I8hiuW6+vTbbgMZY4R0SqyGrMmB/hgunbfhxx6+VjXdS2QKCgHWmEn/YdYhWBZmbOF20nXEtbmxrMNqPaoEITqBVaY1yTzpNiiy479lKFaalFKdqpbuRRmXELpXcIx1A35TiTjkPPN1ALK7L36nUAwarincwCfGVKSun653WptARh7HcdUVtsm3xiMetSXGAsZz77jhNGUcmEYkWLVU/WtVT6XDlzXKiLrJc55dxkLH/GMllX2pqc2fPkKY0DoWcEX+vkuYMotWM4pxO7DI8Z31Y5nkJEom8MqEeA77rV6w2u4OgH+7orR41UUlPUrDCFS+xPf/pTue+++8z7LbbYQp555hk56qijpNq58cYb5Qc/+IE89thjpqbpeuutJz//+c9lk002kX333VdmA7CEIX4wFHuTVid7AgxRmjZGESIzaVJuJtPzO3MsQWndNTX7be/ghHS3h/VV0wqMqPjLfOIY4+q3qvXQXceNbbVf4/aFPwidVX0jMqetSZZ2t0W6Tqe1Lurx2uI8DRA0vpI76H/E6AZSZ1xG4+q/6hhpb9b9RveFLfRxbBBPcCd2z7dPlOtnqJMqI+NGdE1HPCXaNjQaSN3YpEW+VDTU15kkVPkegx53vSX0J4JA5jSHE5k0GX8JibXq5QjCmMmyJiWKsnYVO9G2J/3Y/oiWUJH891WqSX8h20kbT5kmDljrq7p1VpP2aSzA7RnhGBQf5+l9KGElGlIh3r2uyHhG8LlWf1824IL6N4/vZIXhUPjwBa8qpkvxsEcTd5ms0r4HSs2hS7Rale3+YGZeUiQ1HWO6wQYbyJo1a4ygQLZbBOMjM28187vf/U4OOuggk80OdUw1RqOnp8cc02wBVhgkpcKrG6eXJhZuSr1FjygtJE41eh91po1dbVOzzxaCe4xxcaK+9rqf+daxxZOdpCZuf3oulq8dloHRcROPGxU/6e5Ttwnr8rKegWzdUft43XYkgdI7na0N5tVu47KeIXm+Z0hWW9leo+I4tZ32/tPGWoauqFPPt1pyffVjse4G8zuyY7JcGZLdGq1wY8cDhVLFr+q1hdhSEJet1/5cx4COBzzUCR8MhPHCuixuzBOSgy0ofBlS4+Ikkyjmuy6Y5NvJZPLdV6naknY7vmyu+cRTRsU2Tozmvubz/SmfZVy21YKa5ng0Q7EtnH21V1UA44GCuj3bVnWN13Vdpgs5T2m+42bxxT711Y6TLhZsz659GmWZt/sku4yZeUlx1KzFFC67iHG4/PLLjShdf/315c1vfrN0dnZKNfPlL39ZLrjgAnnf+94nl156afZzJG7CstkCJu3tzeliKItxNfVZ9NK6sdrrhwIptLKmEaV2Rl7sf3Bk3FjSVKxoHCI+Cy10oZup7i/pGN3PfOv4aou6feOWfNH2LulqyVpMo/rKF4uqVkbsNx8LHpKTIQYcr1HWZu1Ts369SEt9vbQ2hkl1XBHuc53OhzTfcR0Ip8M66kP7CA8Cos53Whdsd5laNe3kWb5svU0NuXVV0Y7BkVHpbG2S+roxY3UG9vogn3heMstx64DmWOBGozPpJsVJJtW+nM4MsEn7KlVbCqmv6cvwmmSZi7DeNTa3yZJFC8xrrKUwleuxx2U7Kluwa2kEcUmxShV7m4Y034nNzltkvHIa1/ui43jp5kuSqWlX3re97W3yoQ99KPvZlVdeKf/85z/lnHPOkWoFcbGveMUrpnze3d1trL+zBZ+wKhZ3Ul1KoZDvtuzJuRGAw5jYB1mhpnGIg30jMrejWeAv6cbUQryu6gst5q1GfIQiNkk02f0gMuk+6/YP/j+eEQtwlcX78IFBYzbLcCF9BCvj4MiYNDaE7U1DR0eH7Lbbbqn6NAhCd2r8qShFhlcIe5MB1hLYerwahwnaUlpt4wRc+H1/aSI7yU+pSWpTGhfzOBdsFZvYju2F4Bv/Pldxux3qytzZEmaqDi2jk1Zs3Z/bBgjsF3uGYt3IySwkLvFNNnHNgJgnhC5JyY90G/b7NN8tNWnjPYud6KdOuuNxh8ajI5OJdjxjSc2/bzq6umW3PfYK3+QjdJPaGGV9zGYOHhPpf0mkvtmxqKeIn81n3MSdJ/2O7/+FHGs+D3AqjevmS6FKPNTsL/oNN9wgjz76aM5nf//73+Vb3/qWVLul93//+9+Uz2+66SbZdNNNK9KmasTnRliMS7B+X61y9p9tiUu7LayLVTE572hpkM7WRiOa9Pv4HGKwXiZMFuamRn8SnYHRCXlx7ZCJx8X7NKVJtB+wPbtsiCtIVDxBXMCtGu6WxbhV2qK5zdpnGoZHx+Slnj5Z3T/p/hvdp2F8ol3bFG6sSG5kCx67rzQOc83AqCk3k6Zd7jbcY/WNh3KUg0nbpqgyMS5xruz4DA9I3LHgO161qOrDAduF1/5cr1NgnzfdJtaBGNU+g6U+yY2czELcsi7uMliRUPbEtZylcTst1EW2VCUz4rYTu8wu11KCtrjb8LlDa7ZfdWMtAPymIQzJVBgo1vXTdaOdUkbH+j/aWwefjHEnq3Oh59/zPa0BqmVn3PXS/D+fY3XPmz7AscvFVAvuuS6lmzyZNdScxdSOIb3tttuy73GDRH3Q1lbP09Yq4thjj5WPf/zjcuGFFxqx8Pzzz8utt94qn/rUp+Tzn/+8zEZ0UgvcOMg4l0PXjbAQC6mbMdfOHJtPBlm3bSAuGROWGYslfrczMYyuFUvFa3tTq7Q0wWW1wYgGN/uu7nOlmdzDYpnr/hpnQZ4UF7aVtXBsd15f0qAo1vT0yL9uu1W223l3aWma721HVAZnUF9fJ/NiLHx4DYJR83AAMZO222lUEqVCxlO5y8GUwgsgyeJu91k+5xzXC15tV11co0PGjT3X3dcGArRveFQ6W5qkfX6jzO9sNuM+zo2czEJ0Uu6bxOoyjb/LO2FPgiUqyrJTqkQvcduJW2Yn6vG5MmssZVR21Xza4SsNU6CY7O3tNUkc99tvP+PtlXeCIM1GG2Up9mULzqdsUVprtO97vsRBcX3ndTnOJxGS68aeeYCj/09iOq2WcRmrCalVYfrFL37RCDr83X777eZPQRIkn5tsNfHpT3/aiOjXvOY1MjAwYNqLOmAQph/96EdltqCiM8wAO2oyfyLecnR8JMzEKnWypn9I+kYmZGlXq0kmY+NzIywkltC2cKlYVFGRbwZZ+9jSxM7ZIsYnOHyZS32xfrrPNQNYhs/rjOXMXTeuf+KW6XlKs67tzmv3ZdR2XcuiLRh1W1HCUdfD2IFod0WlK8AXdbVNiRG2a9u2JWwjrm9sC6BPPPsesMQ9eIkizXkq5DqwtwFraVwiLXfbep7U+qmfAVyjui1fm7D+EKzZIxPSWBd6J2Ds4o/UILFC0BNrmHbim+S2GbXf6Yj5jF2WaTdEEIQJXGyTRFLB7YgQe9OJGyOa7wOBfMoWpXU7NZ+PTloy9QGJHQMatX1sy10vNpuxpw14b597TUyUlkpm0Z1ON3kyY6g5YYqkQRClKBWz9dZby+67724+b2hokA033FD+7//+T6oZtP2zn/2snHTSScalt6+vT7bZZhuTtGlwcNBk650N2JY1uGGOjI9Lc2MYm9g7NC79w6OyZnDUJLmBKyvEll2nUS19xeKKw1JYaGyRGWUN1veuEMpn2+7nnS310jMUhOVKPOsWKlxsi5hakPW4fMeQj6VNrd4KkuXgc7jbjk0Esrp/2LiBIskREkjBitbd1pSzz4Qqht6+cGvbBpIrSkv5ECJqnbQPMErZlkL7SbetLrn2efcJ7qgx72tzd0eLBDIi3R3hgyFtQ7Eim8xA8hVwhUx8fZN/XwkROzurL0Yxadv6HbVmxsXAJiYZyhyzu3+fSIqLRax2oaDnQbPmlsvSpmITNGcegqmLLKzQmonWF/ecJnFQkhiMGue+70Wd+7RMp9WSMaUkBTUnTC+++GLz+uSTT5rkRx/+8IdlJtLc3GwEKUCsBhI2nXXWWbJs2TKZDbiWtXkdYUwaPh8cGZQ5rU3SihCXugZpqQ9y6jRGiaJCSLuNfCbK9jpopy9zaSEkWa3md7bKXGSBzyg9n2DwCRe37qfveGzrJ95DoKTJAGujyZzwgEET46jVe2w0fO0bGpWRkbAm6/hEIOPjgfSPjJvf6nqpk/FMLTfbqp2mX6POm9a2dUkrrtK41rrraH+HCacC0xc2YazmqHkYk1Sb1wUPD5LOh2aExn7dhztR/aTHgDbX1YVxvVH78bnZRxE+UGk0f/Z+VvQNGw8XuF6z3ikpKd7Jv2WZ9FqyUlqd7PUgcNJYM9NM5o3IHBBprrMsaQlxq3D/hKhyBXaafU2X66fLdAlntUKaeEhLAKKP7RIx+brNps74G3GcpXr4kmZf5aCS1lkyY6gpYYqyMF1dXTJ37lxjMdXPXGA5rTYgPuGG/Ne//tWI0pNPPlne9KY3yUUXXWQsqLD4nnDCCTJbiBMK68/vyEzkO3IyqmqW10JEUaWsUT6XYx9J4jBNG5JEUtTyuLIy+j2fpTHf/l/ZNyJrBkbMMSCDrlq9jbtufyg4R+DGnXH97Gipk8GGOmlubA9jaAeGZW4dhNqkjTWtRU2T8EAIpslunFZc5fugwu7vtYNjJrMwSgU1NUzGApuHGaPjMjJWl1NSKQ2waCehGaHxGiX63Icg7sMWt0SP6zYdNeZVdA8jW7XUy4LOyQRW+gAA/x8chufEqNR3t1KYziaSRI9vYqvfGRkUCcZDoeC6MuYjpgpxq03tMmytBxGp1syorK120qG4ybzPZdf0SV/43ZGMJc8nvIywsmqT2sJrOsRFoUK3FAI5ahtGhPbnZh5WF1ntJ5PcKIhORhTXNq9rb5qY1iq3aCfBmFKSgroAj51rBIi3T3ziE/LNb37T/D/KVXZsrDwZM4vhlFNOkR/84AdywAEHyC233CIvvfSSHH300SaB02c+8xlj/Y06pmoFYttONjU0NGTiZYtxKbX/fJPmtCIvTrz0woU4Y9UL9xUtZgrdl7tflDvB2GxtCjPpRtVETRJUhWAfgy1e0+4jbR8s6xmQFb0j0tJYJ4u723KECKyjI6OjZozDhRef67ZwTp5e0S+N9XWmbM4mizrzPn7s46Xe0ArXgERJHS2xNWmTLKbFuJra9VhtQantKdRimrZNyICLzLdIMhQVy6nxyXF9lGYd3757h8Yy5WDgRt1kXM81CRjag2N4dlW/+ayztSFbtijqfkKmh5L0v1okvXUaIybv+p2h3lBU+YRp0nYrjd0+YLc1jWDxJTlSqyhe0R85wtTZpu7fxCk2ld1iivss5lmoS103OlDYuSnFOY3bRtQy/VzjXPP5brmPZxbB+3ntUlMWU9wMVYdH6fFq1emXXXaZ/OxnP5PDDjtM7r//fnn5y19ubuz33nuvESyziUKsjyoakZgF1hhM2O3kPrpOaFEdNRanUFDmJ0z7h8dNSZHW5rBd2D7GjIoEV4glWRvTYERKEMjIeCDzUdPUs3xodMLEWEbVdUwrSuz19D3+rwIlKrlS3LZ6MnHCSX2woLPVlHrxWdhQb7WrPWyDexympurcNukbGpMl3a2TQl4C477ss975hCXK9qAPcS6R3bglRb3PsYg+LSae0xbw6g0wJGHyLXd5vm7FQC3Dbiyuvf+GrrAsjJZ38cUKJ8V7pnFj9olxWMuXdDUbi6m6dNtjB++XdLdNq0cEmSYKcXHU7xgxGhF3WIylJi4uNG2W2KRto76mxk6qlTQbO5jCSqYxqmZbloWvc1F+2VERT5loUS7eaoc5S1NTU3HnphTWt2Ks43FxrmnrjdoCv5DvVBNu22xXck0KlZTIiZBaE6amZpbn/zOBZ599VnbZZRfz/+222848iYbr7mwTpWknvVHZQjGZbmrIjUfT10mhUGfcIMfHx42FJq01U8XLxESTx2Kam8lVxSi+MzgSxuvFtT3qGPE5Ej4h62x7c12ke/PgyLApGeMTAjjG51YPytz2Jlk0pzVWuGoWWy2ZAndVCEvNausTG1Ht1z5X19o09TN1+3YSHfMwYW2vPPTgA7LxFlvJvO6unDbgdW57c/bYcLwoLyJBvbQ2T7qV2kLRxCn2Dht3UIicdbrbcjIVR9XxtI+tfxh9haRbUwVSPqIsDrQHMZu6zWLcirVfewbGjPVxoKEu0jUb+8X1FFXWx35woddeMYm09JrBqjgXIrlJ3Hz9m0/dYFKlTJmcR4ieuIyobgKfqO8VaoVy40JHB8PX7nXDfSNOE5ZG1FDN173V3rZmFC5U+BXjYjvNLqJI2vjAAw/ItttuaxI3Fpa0pwRtjttGZJxnmmRUdo3UlKWG0my3mmM0p2QxziSGgkW8KfPgpJC4bFJz1JQwnclARCG2VIELjLmhz0LceDWfOPJ9J3ydXO4TShq3iNg8WKLysWaq5TCpVIUbX6luoVHEWddUKMJ9dU5TkzfrqXntFFneMyhr+keM1VCta9gmROnoGCy9IuvODeMxfSIC4gIWwPr6yf4L9x+YLLgQPW7/25Zq+zzoNoHP3TTOvdcntFb2DkrP6lWyomdAuuZ0GmumfRx20iuzjTEsG5ex8UYjVGEJhUuo9osR3aPj5sEOypGkFZT2cSHxjqkja7XF3k4h1jy3X5JidXW/cSVX7HVDj4IwrCFqm3qNmO3GlPXRcQt85WPSZCO2+2wiCGROs3+C4rN4lzJjMakQhSQNcie3mPxqFlXNlqpAOA73he6RsB4mTvx9mWrduNCByVIlCtYziXKaK5dldgbF72E+g3AkvM4K4qx/pSw1VM3n2G2bJobSBFKFxmWTmqPmhOkNN9wgDz74oLznPe8xiZB++ctfyoknnij9/f1y4IEHyo9//GOZP3++VBsQB0cddVQ2ZgfxO8cdd5x0dOQ+Bb788stlNmDHTcIKaosj4HM3jRMCfvfQeFEal500DltsuSIwqm1x6zTAOtsYuigjIY6d9VTFGBLk9I9AoOQmrcHyOS0N8tLouKzf1ZIVm7aLsy0u4Epr95e6RNt9FmWpRl5cu76or96lEufibKyRQ3CXnrTQjoyOZ8WLthvfxZiA04D2Bd6v7kecaqN0teG7gQyPjWdd9O2HFuvNb8+eX/tcJIk7tajaDyi0T+2SOfkIpii35yRrvvazb/y7Ilfb09ndnti2NJZOPTdDmVrD9nUSN6btOHC0XfusvTnXMmpfO64QLZVFmlQY3+Q0rlyLb3KLyS8sllFJeyaQ0KcpfU1It/yHvQyPy9q6J/edkx3VV99yGpPZzPTEOLP1AUvk2C3gfFXzOZ7iHp5QT7Waj4VUlJoTpqeffrr897//NWViVq5caeqWDgwgu5rI73//e1lnnXXk/PPPl2rjyCOPzHkPYT2bUeGC2EJXHNmTVLNG5v9huZH4pC02SZN+ZIldPTAkL/YOy9brdHnFZpK7cdoJftQ6drkTn5hW6yLMqp3NdTIhDVOEVld7s8zrbM3JhOoK+5YYSzT6H1bHR5etNXVCEceqghjLsV1YqlUowg1YhWKUa6dtCXQFlLHQtTQZt04V0p2ZY0IdU4gZTUKlZWNGWsP9Do2Om/aMjI0b12a4Ea/uG5aB0QmTOMpOEoXjyrfUiLYHYkwtifY4sOMg05bHgQCHN0AoMNO5PdvtiRJorvhP61abFt3eyr7hKVl87T6x+9y1tIYPNMQb06vrIV4Y51rHnr19MsPxZieNKdfi+75J7NPhn/zb7rtpa0LCwmNKrNRNXddOeGO3rZgSMtMd9zdFjDPWr/i+jYtVnYUCjGOGlJGaE6YPP/yw7Lfffub/11xzjRGlG2+8sZx77rny0Y9+VK666qqqFKYoC1NL2LGZKiJsfBZTiFKUE8FrkjBNEwPX3lwvL66F8B2VR5f3ysYLO7Iujm68YqncCt12+Sb49rGpMJTGelnoxI9ifbj3wo11XmeLqQXpc+N1RYOvX9CnAyhRMj4hCzpbsqIH7rLdbbYLZyB9Q8My0IzPm3K2a/eR/VAAotcWUK77arh+mHF6YWdL1nKM2EfEeUJwjo2jpmW9tHeG313U3DopepvGpbExyFhPw3503YvTxkTqcmxHLfj2ecoHLY9TPzgqS7tbpa05rMmZz3bs/rXfF1qypxBwjbqWZ0UfVuCBga6r7Qr7PMiWBvI91ME65gGESCYxFcXorKcgF8cE4Zp2PyZJS3soKOFam8blttgSMtMd9zel3E4VCOiZiN1vvvjm2Ug2WZdTViitUKWgJSmoOWG6evVqWbx4sfn/zTffbGLMjjnmGHnjG99ohOrFF19c6SaSzKTUjc20XQDVOmVnL4V2GZ2oMxbTJNKISWSJRZKjp1f2S1N9XdYi5Fqp9L22oxhrjrZLt6NMuq3WGXFm7zvK6ofvIIPwhAQyJ9Nenxuv/j8qkY2K9Jf6xqW7MyznM5RJyAQLH8ShbSVFGCziN+3kOj4rrS1SbddkYAs0vM6d02mSfjU0h6IY56WxARbUyUy9uq4r3NtbGrIlfaKOL+3DhXxiOpNAn67uExkYHZWgq7Xg7fna7uvHtOI7DZO1g5Mtz5jeQ1zCMmxfQ2rptxOW2Wg7cT0vXzssXZ0193M1e0hKUjRdFia3Xqivjdksos7DTWNF9bS/mCQ5023J84rx6RfQKCuE+7ldXigVScLGVzan2G36xq7GNJvP8jyG2SDGAdznx4cm+yGp/q39fT4EITHU3C894kfvvPNO6enpkeuuu858tu+++5rXNWvWzNqEQjMJtQ5CTED42FYfTMDdTKHqztrR2iyLu9Nn2E0T+wmRg1fbIuRO7PV9PqVUktrVB1E5BgEU1tREkh1YjKDTB6wkPnGgH5CJV/sRlknbume7PmNdbbvtkpoVqw0NsvniLuNea46vsTHramsEhiOS3UzFbp/5LKhx1mfEVsOzAceA0jiIGdXSOOh3uMQiwRNc7HA8doxtlDjT/+P7Kpwg+uNwYzrVhVz7O+m827HTsJDCkt1Q15KtzZq0b5+w9I3lKLFaKss+YmHhYjswPG6yIa8/v90bKwxg4V7c3ZpNQKVu+WrpT+o3xD13tjbHJhAjVY4vdrOcxNX1xARa8WUR9bVxuttfVEmbGEuer+2lOh5X9MeUCmmpGzceSFI3niv8zHdjyu4kCRtsZ2Isc+7TClOfFdlqE3DPPdbFOLJduotlOqyJ+Twg8mGXFcJ2RvrC+G3EeeOaA3j1lYexvz/FrZ7u5KSGhSnceFETVBMczZs3LytM7777bjP5JZVFJ9CN9XVmMqsiVN1otUyLbY2z4yfTkI/VKBQRobth0nppJ/2+rLSumy1KkdTVBdmkRIGM5lVnF9vdZNGcHHdZjdkF6FtYvPCqfYt9a4bduJIvuXGLudbjNPG9dl/5XKPdPuwfHJLly1+UrvkLTJZiLY2Dv2dXDRgLbf/ImHQ0NxoLrv0gw7Vu6//1QQLEOfoB4hS1T9USbK/rulXbYg+W7CChVEsonsN4ZYwlJGea09poslI2NTca9+gky2aUsPS5e7tW/NCSHVqa842r9Z8/lFsSWTUwLP0joZsuxKnrFq4JsOwav5o8Km078rmuSJWiSYr0/+XGJ1BUTMDSo23wZRH1tdFehseDZnJfYO3SuJqPui/N+KsxsklxoTniqkIuxHYbQEypkJH+HnlxxUpZvHCBNHd0TQo/HJdmPPZaoROODf2lDySKSsBlPYjAeXfHRTn6eDqsicU+YHG/A1Gq4tzEYA+IjA9HlIcpIHMxqUlqTpieffbZ8uijj8o999xjrKM/+tGPTOmVG2+80SRF+uQnP1npJtY8ttCEi6ibZMZFLXU6MQe22PNN8HXdMG6tzlgkIUggEIAb75imrExasYt9L+uBUMytgWoLDwhRrY8Z5Q7r2659/EnxhnZsoC0mkCVV/+/2of75alrmg++c2Nt36evvlwfvv0922m1Pk01bjxWxphA5DfV1sv68NnMO7YcIcf2Fz1f0DcvwyKiMNjZKR1OdDI0GMjwaWk+RJRbft7Ps+qyVGKNR/aBjDRbG3qEJGR5Fe+tkXnuYqAlJnlqacvszToD63KH1D6CtsODC1RpjC+O6rr5eJiYC6cYB5Xm+okQyrreNF4mMjI+JBGHJHd9DgKRjcPe1sm9IBkYQxzxp9S6F6zGpMEkZOkuNT6DYosJOXJSmjfYybNdOhFTIZDqq5qNZNjrpLqnbTYoLtYVSKSyg+ViwdF0IdbtkTkypkMHxernnkSdlv3mLpFlFP+4lEPp4cBDlHht3bMalNJhaMigJrxXZehDhtfyVwWo+HQ8UfA9fCrVW2uWUlEzNbW95mEIyF5OapOaE6YYbbih33XWXiTWdM2eOEaVgr732kt7e3vxjHkjJsV1C88Gtfwl8E3yd+KulbFX/iDQ3wC1nwogaEJeMp1iwf2gZ6D+1ROpx2yLA3p9tYY0Tpm79T8VnmcV7u5+1XyDWIfTUsgWxA7Hqi83MJw7R93Ag7bYaLSuutmNkLJDRsTHjVrzxoklXUuwX4iwp6zL2DeHW0QZrZfhQAu1taWqeYjHV7bqCN+qhiOs+i+3Naa2X1qZ2k13W/g7Wh0Vb3ap1Gf7wuV3uRccIjg8lgpA4qG8odG0PggmpbxZzTBDBQ2OjMm6SQjVJW1Odcb22+wgWXH0YY/eTXSYJ+4sSycbNfb3QzR3XjVsayCco40Qm9rFmAAIX5WfqIu8BcQ9gyCwnLobQnmBjmbu8VGKiFLVHo2o+2sv0/yAuLrQcbpBR7q2+/ei6ECX2g4C4BxEQ9Pqqol8Ff6HusaW0uuXzIKWQ/veWRJoGF3HfcRXab257k/qr1jIXk4KpOWGqwIXXBgJVRSqpPPZEPY1raJRLr0/86OQe24YIW9IVxnAG0mAl8Akn2xo/mG+21KR2wnrV3Z5bFiRq0o5J+JMr+ky9zrntk7VI3Yl5WpfmqPhDE9s6NJpJSANrdbg+LLuuSHZjUV23ZP0MFsi6samC2m4DSIp9hLgFEGIQQNje2PiINDU0GPdbt7+SLNzafvMgYmQ8my02av2opFF2//keCuhY0wRBet6AvT+4I2tG6Um313FjXYW1Vbel2zPuw5nEQZOu7WGscOgJMCIDw6NSX19vrO+Lu3NjQE1c7RAmgWEf2MsgNLX8i5YGijovhZTciQL7mNuO9ofHFEXcAxgyy4mLIYybYMe6EeYpLPKZREdt293GFMHgEdVRbVBBV0o3yCj3Vt9+SmXtKnY71eDCnLYETzW5rk5Xv1F8kpRQiZGqJKr0S5RrYZSlNcr117VI2mDSjoRDvUOjZnLf2FCX2W+YRCiNSLXdK+19RrUzDrSnXuBmGroduxNz2/KWZrs+d8rJpD51Ul+PGMiwvYjXhEBRq5oKNHyGDMGDI8NGNPoEVCgeJ6SxYWp8rtsGdT8dyByDfUz4U/fisYxIDkVlKGLgSmuLUG0nsC2O7vnBceBz34MPd5z53Gj1/2oZBmhTlNUQ60UJKjwk0Qcx2jYIbtQIxcOTIGiTue3huFP3Yc2E7BuL8zvbZGQ8MALPFZ7GXTsjXpFUyO0b18U7zsIZNcbVwq/4zoEbZ43vYiyNjYcPPuKYmMC4ootvzREXQxg3wY4VrWUUCW7cZTmS25RDWES5t3rL4pTKEl3kdiolfPIR8XHfqRQUjKTKoDAlVYk9UbeJir9Lg+sOGydww2V1mQREYQzq8CgsVSiBklxSBEILSXogJjtbJ7P5FoLJrtuBiXhLVnjCagihrMfVNzQmz6zsC5PqZMSILb5dC2vUMcO6ZrcV7YfodPtNxQtcfpHAR4z4DN1/tV/jLJC+NoxN1JnyNjiuMOkVlof7HZkQ6ZjTbV5tId3VNilG7f5S99goy2lcrKNu3z4Wn+jS/sD/6+qQNCo+oY9t0XbddCGOVSDbgg99PBYE8lLvsBGmuh21vmKc+WJf8d8FHc2mv9Q93T42DB2I187WXNGajxVU+wgPDew43DBWdNhcNwNIRNXSaB5gNHXnlrLxxVmnrUWsWXppLa0xfC66aSbYsW6E5Uhk44m71DhSuCPnGwdZDcKihPtBlve5c+ea1xlPPiI+7juEEAOFKalKdKLuZhrVia87sU+Dunhi0qxuoR0tk+LCFRta3kIteMiKq7GHcdZbFU1wi0X2WK3TmCY2zrdN3zFiGWIK1Z0WE3m4zQ6MDpvPYPGFttBY2yTXxyjLGCylrvVR19NlDfWNWQur6eOEpEO+4wUjY+PGItqMttTDozgULGZbLW2yZIvtpX90Qh58fo3UBYFJUITzAyulnl/7WNzYYHtftkXOdw51nOl2XWGKkjUQW9IZxnRqwp44bEv5M6v6pW94VDpbmqR9/tRziz9YYTtR+3N4VOa1N3nbgSbC7RznW9uriZtRigaCEePPjY9FTCosssXETWsf2cm5dPsY98iUrO7ymkUZqJj1xVlHPZDy7ZeitMbJxwU3VrSWQSRExV1ClKap9zjLQeJJrYZQNZQyVpfCk5CCoTAlVY1aZdxJ+fKeoWw21LSTaxUqmJDDwgVroFqh3LjEnoExk3FU3QV9rr/aNreOpdZgtV0h9fMkgZiPRVgjK7FflOqAe+aK/jGZ31Yn7S2hxVS3ERd7GuceHWV9tEt+uFbFfCzaerxgXke4LWy3rTmM+dR+g9CHla9ncFz6hkPhMjIBa1xouYUwsy13um37mGwLH+pvonwKrHkq6nwuuOq6PGX8rR2SzubQ9RRtQ2KjfISSiYsN4KAdRCfIaqiXBV2tslCQlAn7z00YpeMZ48y2HqqVG4J5vCEsEzPRNDl2Q5dt9JG/MKid/CjJAhz1kKMT/ZpxPdbxFcZuh9eUnlvEWWs/28Id14/7UMGXsZfUMNUUp+fis5hpHGm1uHCSmTOeCKkhKExJVSc/gqsm3EthhVPBY2Iu6zCBhiBpNhPplX3IrCsypy2MmfNNmO0Mu8bVEDZQy+3Utpi2mCsD//dP3oFOuk1Jjrp60x6sj2yxall1kxslJSdKaw0K25krUmAh6zTxr3VT3CAnJ/yhm/HkNqbWEY3aX5QbtM/SmFak2Va30JI3NW4S/x8Z6JOn7r5N1n3ZDtIKF9SWBuOyjNVUmLlldfAQYHXfsAyNTch689qyIhrroWYpBBrGQJxLKD5f1jMoL64dkoVzWmTRnLBfu1sbZWwitPaFwmrcjKlVMmTc07ozDyXQ1xBZeG+PhfmdrdLaHJ+cCSIbz03Q77Dsj00EOdZ9HV+uJ4EmQ8JnL/YMyor+EVnQ0SKbLOrMbhtjdvXAiKzuG5ENFnSYJEfaBxCliK9GtuqNF+bWcE2qv+uOCXuZujzreFJs8b+qb1ieWzOYeahTl7OPNBl7ySzAZ7myPzPvPeVJqokoi5mdsCiqFEkUdq3TfL5XhZbHnp4eU6IPdeW7u7ulKqimuE9CahgKU1KVaKwZLEVLu9tzJriYrMI9sCtjkYEggBVs7WAgLU25gs1FrWmasMeeZNuT5SWZfcYJLNetEs6REDv1dWPGVdL9rm0RSrPNKGyLlq8uKcQWXEVdixfaiLg+uMxq1lPdV1K8ni3qIdQQVwoR7EtUpCLJtTKmOV48kPjv8l7pbm0w58BdjqoxzY2hCA/dXUdFjMvyVJGMhwBrBkeNy/PytZnyJpnl801pmFEjbpNKymj5HMS/rjs3zG7rJsIaHR+S4dHArDO3XWQgI6r6h5G4KMi+d/szbr/2eNdYWxW7rguv/YAhNwYVngChENVj19enVg4IHNRx/cAtW8Ujzm3v0Jgs7GjOWqNtcenG7cY92AgF5YiJgcZDJpSnwXVir6ttx8Mn9Fd9XVh/1X2okyZjL5kFeLOcOkmEfG6yMwW7ZmleGX4L/N50M1Mtj9XcpzOBcpQtIjUJhSmpStxYM1t0mP93T07cQwtRIO1NE8aNEWVVogSRWtI0Yc+cZv8NNElQuUJZLX5mgj0RCibbbTHfWL4491q7nIctPDVpDUSpb3koKnDscGUOLcHqkpumffg+ypr0DyP7br3U1YfiJF+xEgfOOQTX6BjK+Ux+t284jB9d1T8qi9vC9RBfahIl9Y1I67zJ5DtAxdl6c1tlRd+oEbo2WA7BhWNPwozBvvBVz4fbXypWF3aGiT1URHa0hG3M9/y7490VtT4XXtdajdel3S2ysr/eeBM88VJv6B6cybC82eJOebFnyIhz/Q5EKoQkAlWbER89Pi6PLFsrC9obZb35neZ76m2giZeAtkO9EYCKXYhSs+3+TNbmujC5lSboAr2DOO/j0lCHPmyTJd2tU4QpHlCRGsDrBut8NpMtW27N0nJ/b7ZaHmeKEJop7azVBxKk6qAwJVWJnaXU5z7oTtxhjYEAgKBBjUdXENklPWC16WhtNha1NILBFYmYkCPGtbO1MVvCw24TxFvv8IiMjYtsvLBzShkVG/fY7Hg8WF/t49DPIQrgaon6q/bnCib8EGsTmQRRatVTSzOSPqmraZSVyyeK0U702dBonXS1TiaOcpMM6bHGJUKy9xG6F4du0O3N9dI7XC9z20IhqVZXxCyaY2uA4B6Rdbth/US5Glh/GyMtvrC62gLXbl9a0WyPxSiiHj6krcEbhxvzGbUvn1v1+vM7ZX7nmMnqu6p/yLgHa/kY33FhbGG4tjbVGRELd148KFg+NiGdbSPme+ptoFmZl60ZlNbmBlnc1Wpcnp9bPSjd7WFmaGwfIhPXy5r+IVN6KQjqZXFDg0nShOcmeJjUNzQhQ2NjMr+jJXtN+cY+0Bhu1z2azBK8WU49dT9nKlNqlpb5e7PV8pgkhCAIB9eEr+i3qGzOSe7SxQrLfARb1L5mgrilKzQpEfxVJ1WPzyLnW47kP8j+CWugTwCu7h+V/pFR6WhqkJbmpilZVOOy7NrWP+M+Cive0Fg25tAG1ql6aZDulsDEQMJ1Mcp66B6bnQzIFVu6DMIaMYETcBE1k/RQxGryH9NHnWjfuKlDqtY7/Vy3H2UVXtE3LGsHRoyr9DrdbdnPte8XdU21ZvmyBuMvzsXTjhlGXw6NjUtHc6NsuqgzG4ur62jJnblzOqSuucU8WIDRd9157bEWX9fd2nU5ds+FZvaFKylo86ybNjlQqYiykKcBffdiz4A81zMkbY2hwI8Tc4h9BRCkT6/ok9bGOiNC57WHDzXw0GfF2iFTwmZ+e5M8v2ZEnl3ZJ20tTWZcjo5iLGKQhoPs2VV95nOI1KVdbdIzNGragYzEc1qbpLkRf2Gsb+t4s3nYAdxxYyeuinKPJlVM0sR6Jky8k9pczDG4MbQqjnSy78aVpo3DLaQtyBystWLTiLlqFUI4hjVPi4yNiIyPiczfsDB36WItgfkItqh9zQRrJF2hSYngrzqpajAhheCEG6C6Y6oQUqsKgEhD3KAv1lC/A9GBe3s/3AhbwgQx9n4gyBB/iYm4ZtTVZaFr7rix6Kn3J1w7NZmQbcVa3N0unW1TraA+EYjlpp7j+Hj2uLA9ExOYjV+ctBZBhGlyGxW8+rltTcb/sY3RcQibyWRHeixa29LXV+jvMYiAjEiz2xr1YMC1aOu2td12wiXtU9CS+Q6SETXX15kyMVpeR9fDdlo6O2XPffeTkaBe6uvx8EGkbxDiqV/mtDbK4oyAzo3LnNwP2gdrnsaMQqC7x68PCXoGRkyMMESQZrC1+8gWimot1mOLssD6MtOqJTsJjR22Yyt1W1rWKEokmxjPwXEj9FH7c4P50TF52lewMiOW04ytujrZccPQSoN9QRQi9rupsUF6hsalpaFOWpqapBk1XFsbpLGjyTzQwEMfbK93aEJGJ8alsa7OlPfZbPGcbP/Beqpt1lhl+5p0rb+auCpsa3Glbsg0k2jdmgET76Q2F3MMbgytiiOITXzuTvzTxuEW0hYIuomxjDhtL1u5mFe/+tXS2lqgR4lPyHtFOH6tcSPzZz+PdJeGkDX7GM0VloU8fMhHsEWJWFojSQ3BX3ZS1WAy2j88IQPDYcymrB2WtqYGWW9+e7bOqWYvjZuoGsFSF0jvxIQs7mwxllV7fSyHFWZoBGU6UPezIaceKTLtIrZyfKJJWpoQnxiKCp811xXOrhVW4/Ag/DBZH0RcrElCMyLdi8IfJM3yG4qP0P3WdT3WbUPc+SySEKaIyYTLY2PDpEUWogtiBkYtuFHaggfrQOA3OkLI3bZ9THYf2C6Y9vKegdFseRa3hiz+lnS3GQGtgi17zqx+Wzh3Mnuj6cPeERkcG5e64TppHQxrxg6Z2MXJ+q2TVrYxRMWavuxuDxMDaWkZ3b6KTDxwQN+1QnBl6rNGCUU9NoisuLhktfjhe+irurFJS3Yh6PYQa4s+i7KmYvsLO5tkZT+OL9p9WR+wYLybrNeCTNN1Jptxrvt8mBEbDxLgyo51kK0Y43gyEVQomNGHSDyFcT63rdk8QNCYcFdo28fks4DbfUtBOgNJmliXYuI93VZXt83FHIP7XTuWVIVmXMyt77NC2wJLqVpMywTi8Ds6ith+GhGO9s/dYNKVNx93aRy/btO2VNufl2OMxWVznikPbAgpEgpTUjTnn3++nH322bJs2TLZYYcd5Dvf+Y7svvvuJelZTEaRpRMiArFudVIvI+PjWVfLtLGCpqajNEhXa73J6OrG1oWJahqztVFtUWXcg2VMuttbjJsuhIBdQ9R1McZ7uDyqqEGyJXymE3f8H1lPezIZXOuDCamrh1DOFUjYK74LBWlbEe02Rx13uI8JmZiA++WkCLcT50AcaKxgeIyhoNM4xihLr+vabPeBL+kR/v9S75ARHMiS29UaxgMjllBFjMYr2v1u99vo8JA88sgjsuWWW0p7e5itt6OlXvqH62VsbExe6pkwVmBTd9YSkyqQJiYC6UBMcEOd9A+F8azGEuskFXKFtQ9NMgUg5iBKfe7jeuzmXAwiy3QoDsOn93WxMcb2/m0LrfaNorHVOHa3DJAbZxqXjEofwmgG39aWZmlpRhzn5MQW39Njd2OEw4ctQ+EDD6kzDx6wDImV8CAAngiwcuv50PrA7njOjTueLLVjW9+Txj6pQnwTa1dIFhS/l9kGrieIhvpMkjPbvRWfG8tXU2nLrPjiXgvdtvvdHCHVPr1xuLCSltmFd2BgIOd+njdpRDiOv3NRYQ2k5ZKQikFhSori17/+tZx44olywQUXyB577CHnnXeeHHTQQeZHZ/HixUX3Liaf683vyE5oYSHCHASxf7rcTdCzqm/ITGjNpDgjBlEL1VhwxB+XppNum6zVR8JEMLCkYjuuGLaFgLrKQpgiAUxWZFqJjPBZW9OojLXUS2sTJu/h03FbPMJ6iCQyEHEQ0tqe0BUUbr+hsIlyCcU25rSOSWdrm8mOiu/d9cQKGRqfMDGcWjrFxHcOjsidz62S4ZEJ2W69bll3fmfo9hygNMvUfvEdv6+mpYL3CztbjCid12wqhxpBZQtQJK0KcvpwxLhvI47RHPPQsDz33HOyeN0NpKklbDtq1qI80NOrBkw7Vw2OynpzQ5deW5gN18ONNXzwENbSDGQ8CGuCuv0GMbSqd8iUooCIhEsrLKhqnXdFo28sqVBTcHyw+sPSjvPV1lyfTdCFP1+Msd2HroUW60PomazCGU8Bcx6Hx7IPF9z+xzUB11skzIoa/+Fr2AZY9PGwIkrI2n2g5WueWzOUqQuLa6zVWOZxXrANeBgAtLFnAA976qXH2ZbrVeDGkqr1Gw+p7FJEFKgzlFK47+o2RodCUTqBbOvNU2MGRwdEmtppeaoSRkdHzf180003LWwD5U6GRcslIRWDwpQUxTnnnCPHHnusHH300eY9BOpVV10lF154oXz6058uSe/aNTTr68MYzzg3WVgKh8ZGpb4+nNCqGGyfnwksjMHeZihi6k0ioHDfqL8YmMRDOrnH57aQCC1Pk5Y/FbxhwpzJWES4ri7qajNWxNBdGaIztIjhb/naYSOeBkYnZL3mRjOhh5hZ3R+6biI5DbYLl1D9ztrMPiCksAyJbHTZ4y/1yaMv9hlrM0QySm/oMTz2Yp+8uHZUGhoCea5nWJbO6zSCHH3tI04M2NYuXQ+unBClCzqajJjUPtD14aJc3x5axfCH70LIwdr7Qs+YDMMVt39oyvkJ3wdSPzEuL65FTBbqiDbI0u5Ja7hu3429bWyYWmcWYFn/COIfx2T1AM6lyGqUTzElTcIxBUuvinVtszsGIEYxTiHMsP/u9rCGp4pP2+IOl227tqcrBm0LrVpYfaVi7ON0x3TfcJjN2cTXesa6iulsYiirHFMcOFcv9QzKRF29dLfUS99IIPDW1gdHrss3rNUjo0hCJjKvHe694YMHn/XULrWjbdRxg6MopBwRqSJK4b6r2zBup8FUN16NGUTNUyM2qrjMCiEzkbQu9DMxwRmpCBSmpGBGRkbkzjvvlFNPPTX7GcTMAQccILfeeqv3O8PDw+YPDA0NTVkWB8qfICkBJvUTY4GZbGNyOmzFpDUE49JcNyp19YE0yrjZZt/AoIlvxKTcruPoogmQYKXR+EeIomBsROrHA+kfHJM5TSLPrUTSm0n3WJ0cDwfjpo3YL6yraIseE17R/NVjo9LQ2WrWU9fEtRkhBgtdX334+VB/vwyMiyxZ1CETY6MyOhK6NbbUoyTOmMxtqROZCEUqtj1WXy/PvNRrRPHI8LA0zG/P6ZtgbFjqx0elPhiXNhk138F+lvUMStPEqMxpnDDCZmlHvQwMDsowLKaQVs0N8uLwsOm/UFhN1gO1RZEtDlb3DWWtenDpfOKlPhNfODQcyKKO8AcJx5QpTSoNwYSsGRiS1X0jJp53YGxcIN2QMKepvk76++slGBswT9l7+wdlvK5Hnl7VL+PBhHQ2NxsLXUMQWnjrJ8bMMdpjqTXTNOwTrZ+XSaJlt0Ez7cIS3dUcWsnrG8bliZUDsrijWZatDGu/wtUVJWuGkXnWGpfuGNBx2tAQjqPW1oYwM3RvvxG/avWGUEdr6ibqzTjFucL71b2DsqpvOBO7OZmoy1jCkSEKW8e+xsbNdWALtL6BMGs0CN2IR2UcDxoaGqSlviHbNzhmdTlXyy2WYXya82L6aNz0kZ2YyCQ1yrgmI0YZ4JppaG6QAKK7rk6eebHHiHgcKzwXJjJxvdjm0EjYz8tWDUtzfeg6jn5zmdNUJz1jo/L8ysFsiRsVqHY8sn7XvX+gTaS8FHM/D2nEiiLjvdHZbRMntNa9HKEPmjhIqW8L/3zLCy3P4SsrkoZKTM6j3JkrKBTM789o+DsUOU6KLtNSwPdL1SflGj/ViMbd1g3HxyWnXS8D7+e1C4UpKZgVK1aYbLJLlizJ+RzvH374Ye93vva1r8npp5/uXdbdPZnchhBCin1wVnDWT5IK3s8JIdMB7+e1A32gyLQC62pPT4/5e+aZZ9j7hBAyQ+H9nBBCSCmhxZQUzMKFC03a9+XLl+d8jvdLly71fqelpcX8EUIImdnwfk4IIaSUUJiSgmlubpZddtlFrr/+ennTm95kPpuYmDDvP/KRj6Qqsg3Lqb09xPGtXbvWZPR98cUXpaurq6bPEPuC/cDxkO66QEwp3L3s+wuZPqLu51HnqxZhP7AfOB7SXRu8n9cuFKakKFAq5sgjj5Rdd93V1C5FuZj+/v5slt44kCjJN0lRiyqfxrMvOCZ4bfiIukcwprRyRN3PAe/p7AeOB14XcfjuEbyf1yYUpqQojjjiCHnppZfktNNOk2XLlsmOO+4o11xzzZSESIQQQgghhBASBYUpKRq47aZx3U0LnpZ94QtfYCwq+4JjgtcG7xGzAN7T2Q8cD7wueI8gaagLWOyNEEIIIYQQQkgFYbkYQgghhBBCCCEVhcKUEEIIIYQQQkhFoTAlhBBCCCGEEFJRKEzJtPGVr3xF9t57b2lvb5e5c+d613n66aflkEMOMeugptVJJ50kY2NjOevccMMNsvPOO5uEGptvvrlcfPHFU7Zz/vnny8Ybb2zSje+xxx5yxx13SDWDtqLmn/135pln5qxz3333yX777WeOaYMNNpCzzjprynYuu+wy2Wqrrcw622+/vVx99dUy05lp5zJfvvjFL0459ziHytDQkBx//PGyYMECUyvyLW95iyxfvjzv66ba+Oc//ylveMMbZN111zXHfOWVV+YsR/oDZPteZ511pK2tTQ444AB59NFHc9ZZtWqVvPvd7zZlSnBPef/73y99fX15XzekMHhP98P7ee3e02v1fg54TyclAcmPCJkOTjvttOCcc84JTjzxxKC7u3vK8rGxsWC77bYLDjjggODuu+8Orr766mDhwoXBqaeeml3n8ccfD9rb2802HnzwweA73/lO0NDQEFxzzTXZdS699NKgubk5uPDCC4MHHnggOPbYY4O5c+cGy5cvr9oTvdFGGwVnnHFG8MILL2T/+vr6sst7enqCJUuWBO9+97uD+++/P/jVr34VtLW1BT/4wQ+y69x8882mL8466yzTN5/73OeCpqam4D//+U8wU5mJ5zJfvvCFLwTbbrttzrl/6aWXssuPO+64YIMNNgiuv/764N///new5557BnvvvXde1001gnZ+9rOfDS6//PIAP0VXXHFFzvIzzzzT3CeuvPLK4N577w0OO+ywYJNNNgkGBwez67zuda8Ldthhh+C2224LbrzxxmDzzTcP3vnOd+Z13ZDC4T3dD+/ntXtPr9X7OeA9nZQCClMy7Vx00UVeYYqbWn19fbBs2bLsZ9///veDrq6uYHh42Lw/+eSTzU3f5ogj/r+994CTrCrTxt/K1dVppicyAzOABMEACIqguLsCouuucVddE7J+iooZUfmrCAZEUfTTNa9h3XVVMH5mXQwLElQEBASUIHnyTHdXd+W6/99zbr1Vp06fmyp0V3W/z+9XU11V9554753znOcNz3dOO+205ufHPe5xzllnndX8XKvVnE2bNjkf+MAHnEEFFjIf/ehHPX//1Kc+5axevbo5DsDb3vY25/DDD29+ft7znuc8/elPbzvv+OOPd84880xnWDGMc9nJQgbkyoZ9+/apzYXLLrus+d2tt96qiNzVV18d+r4ZdJjEtF6vOxs3bnQuvvjitrHIZDKKXALYfMF5v/vd75rH/PjHP3ZisZjzwAMPhL5vBN1DnuntkOf5yn2my/PchTzTBZ1CTHkFA4Orr75amZ9u2LCh+d1pp51GMzMzdMsttzSPgUmfDhyD74FyuUzXXXdd2zHxeFx95mMGFTDdhXnPMcccQxdffHGb6Q7a/qQnPYnS6XRbv2+//Xbau3dvqLEZNgzzXEYFTFRh0nrwwQcr01SYcgHof6VSaRsDmIVt2bKlOQZh7pthw913303btm1r6/fk5KQy+9P7DfPd4447rnkMjsc1cu2114a+bwT9w0p+psvzfCGGdS6jQp7nCyHPdEFYJEMfKRD0GViI6gsYgD/jN79jsNApFApqsVmr1azH3HbbbQM7h69//euV3+zU1BRdddVVdO6559JDDz1El1xySbPfBx10kOfYrF692nNseOyGDbt27RrKuYwKkC34SR9++OFqzi+44ALlE3nzzTeruQOpMn2y9XkNc98MG7jdftcz3uF/pSOZTKp7SD8m6L4R9HceV+IzXZ7nK/eZLs9zO+SZLggLIaaCrvD2t7+dPvjBD/oec+utt7Y5/68URBmbN7/5zc3vHv3oRysycuaZZ9IHPvABFeRJsHzxtKc9rW3usbDZunUrXXrppSroj0CwmJBnevfjIs/zlQt5ngsE3UGIqaArnH322fSyl73M9xiYJ4bBxo0bF0Tn42h1+I3fzQh2+IyonFjEJxIJ9bIdw2UMw9iAnMCU969//atS0rz6HWZsFrvfvcLatWsHZi4XE1BHDzvsMLrjjjvo1FNPVeZv+/bta1NN9TEIc98MG7jd6Aei8jLw+eijj24es2PHjrbzcM8gUm/QPaHXIWiHPNPtkOd591iJz3R5nruQZ7ogLMTHVNAV1q1bp3aI/V66f5cfTjjhBLrpppvaFps///nPFek88sgjm8dcfvnlbefhGHwPoK5jjz227Zh6va4+8zHDMDY33HCD8r1hU0W0HaHY4W+o9xuklc0Rg8Zm2DBIc7mYQLqTO++8UxEy9D+VSrWNAfwj4YPKYxDmvhk2wPwWCxm93zDthO+o3m8QdvisMX7xi1+oawQbO2HvG0E75JluhzzPu8dKfKbL89yFPNMFodFx2CSBICLuueceFf78ggsucMbGxtTfeM3OzraFSX/KU57i3HDDDSoFzLp166zpYs455xwVnfSTn/ykNV0Mond++ctfVpE7X/nKV6pw9HrU0kHCVVddpSLyos933nmn81//9V+q3y996UvbIpIi7cVLXvISlfYCfcQ4mOliksmk8+EPf1iNDaIDLod0McM0l53g7LPPdn71q185d999t5pDpAlAeoAdO3Y00wts2bLF+cUvfqHSC5xwwgnqxQhz3wwicN/zMwD/FSGVFP7Gc4LTxWCuv/e97zl//OMfnWc+85nWdDHHHHOMc+211zpXXnmlc+ihh7aliwlz3wg6hzzTF0Ke5yv7mb5Sn+eAPNMFvYAQU8Gi4fTTT1cLUPP1y1/+snnMX//6V+dpT3uayjWIhzke8pVKpa0cHH/00UerXGgHH3ywSlVgAvlN8fDHMQhPjzyHg4rrrrtOpXVBCp1sNuscccQRzoUXXugUi8W245DL8YlPfKL6T33z5s1q4W7i0ksvdQ477DDVb6TV+eEPf+gMO4ZpLjsB0h3tt99+qn+YV3y+4447mr+DiL3mNa9RaU9Aqp797Ger3Hg6wtw3gwbcx7bnAZ4TnDLmXe96lyKWuOZPPvlk5/bbb28rY/fu3YqIYqML6XHOOOOM5kZXlPtG0Bnkmb4Q8jxf2c/0lfo8B+SZLugFYvgnvL4qEAgEAoFAIBAIBAJBbyE+pgKBQCAQCAQCgUAgWFIIMRUIBAKBQCAQCAQCwZJCiKlAIBAIBAKBQCAQCJYUQkwFAoFAIBAIBAKBQLCkEGIqEAgEAoFAIBAIBIIlhRBTgUAgEAgEAoFAIBAsKYSYCgQCgUAgEAgEAoFgSSHEVCAQCAQCgUAgEAgESwohpgKBQCAQCAQCgUAgWFIIMRUIBAKBQCAQCAQCwZJCiKlAIBAIBAKBQCAQCJYUQkwFAoFAIBAIBAKBQLCkEGIqEAgEAoFAIBAIBIIlhRBTgUAgEAgEAoFAIBAsKYSYCgQCgUAgEAgEAoFgSSHEVCAQCAQCgUAgEAgESwohpgKBQCAQCAQCgUAgWFIIMRUIBAKBQCAQCAQCwZJCiKlAIBAIBAKBQCAQCJYUQkwFAoFAIBAIBAKBQLCkEGIqEAgEAoFAIBAIBIIlhRBTgUAgEAgEAoFAIBAsKYSYCgQCgUAgEAgEAoFgSSHEVCAQCAQCgUAgEAgESwohpgKBQCAQCAQCgUAgWFIIMRUIBAKBQCAQCAQCwZJCiKlAIBAIBAKBQCAQCJYUQkwFAoFAIBAIBAKBQLCkEGIqEAgEAoFAIBAIBIIlhRBTgUAgEAgEAoFAIBAsKYSYCgQCgUAgEAgEAoFgSSHEVCAQCAQCgUAgEAgESwohpgKBQCAQCAQCgUAgWFIIMRUIBAKBQCAQCAQCwZJCiKlAIBAIBAKBQCAQCJYUQkwFAoFAIBAIBAKBQLCkEGIqEAgEAoFAIBAIBIIlhRBTgUAgEAgEAoFAIBAsKYSYCgQCgUAgEAgEAoFgSSHEVCAQCAQCgUAgEAgESwohpgKBQCAQCAQCgUAgWFIIMRUIBAKBQCAQCAQCwZJCiKlAIBAIBAKBQCAQCJYUQkwFAoFAIBAIBAKBQLCkSC5t9YKVjnq9Tg8++CCNj49TLBZb6uYIBIIhhuM4NDs7S5s2baJ4XPZdFxvyPBcIBL2CPM9XJoSYCpYUIKUHHHCAzIJAIOgZ7rvvPtp///1lRBcZ8jwXCAS9hjzPVxaEmAqWFFBK+cEzMTGx7GajUqvTTKFMlZpDEyMpyqUX55abL1ep7hDFY9S3OlFHoVylkXRy0foF7M4XqVYnSsSJ1oxl+zoW9++Zo0rdoVQ8RvtPjYZqj1d9izEng3j945VKxNWr35iZmVEbXfxcESwult3zvFYhqpWJEmmiRGpx6ivPuX+nRxenzmEaw0EtK2o9i31dDTo8xkOe5ysTK2N1JBhYsPkuFjHLYiFjAGQkXy9R2nEomU3SRAgi1QuMLAIhKOeLlMP/I3Hqe7+KxSLdc889tHXrVtqwNqfGFeQuDMHrZiw2p7I0U6ioTYWJkbT1mGS2vT1e9S3GnAwaMC6ZiGS8F2RW3AKWBsvueQ6S6KSJYnGXKC5Gfcmq+3cmuzh1LsEY6s/zbDbC/x2FfUTVOFEyQTQyMThz60c0bfXkdxE5RaJUimish/cJt4NwHzrDQ3wD5kKe5ysLK2N1JBB4LJp35YvqvV/Awno0k6BMKrGoKhnqRX39JEAoH8UvRr9KpRL95S9/Ue+ob+1YNnS93YzF5EiaDpgaVe9eMNvjVd9izMmgAX0FKY3SZ5DSuVKVtk0X+npvCgSBSDQWy3hfzPrqtQa5WJ5jqD/PB6ldHQNk0Kk3SKGpfscW1mM7vhfgchXR82gP3gcOMaJKcflc84KuIIqpYMUBi13XDLVG6WSiqXb1Q8XBsSAtyxFhFUvB8JjFThfKSiEeSbsbKd3W1cn5OL5YqVE8Fgt1bwqGGFFMGpfC/BH1hKmrPO8u+qH2pHOdtx/f43yQCihendbVT0Sdh7BjGAZs3twLMtnLdqE9PCYmSbSpgCOriMqp3ivi3A5VrmNvD5NV2xxGnVtci1CxcfzIZPTx5Prwnsp6X/OCFYWVs3UvGEpgIY7FKd57BZSH4mLkhFb8UD/8A3vZjkEfJxtQxx3b9tGN9+1VavNi1dtvgJDdt2dOvQ8qFuMaBCmFP/SefHnJrncQU5hO1x1nAaldLteboAPlqF8qUy8AolivtvxDu2l/kJIXpq5+YinnQRH3LnxvF1M19JtHbCiAnIKI8UZDL9rE44PyzXHS2+M1h1HnFu2uFojKs51dD1wfsJiWCYKBhhBTwUCjH4txNkGdGsuGNgntxCRxWMbJNGn2W/zj+535Ks0Wy4q84DPMLsOYXA4yqWBChvdBxWJcgyCEqUSMpsbSS3a94xrBPGRTCSsxHeQNIkEfzSkX26w2CkAC4kl/BSxs+4PIV5i6eg2d0A3yPATBk5Bp/fMiryCQ+Z3ue5hyg+YRdZTyruK4GERfbw/PIUxn9b5GnVuUlxwhSo93dj3gHGW2TsPjDyvoO8RGSjDQwMKUzRcZULV2TBcokUjQxsnwvobdmKAOesAac5zYXJnNMf1MQFlB5uP1xb95PH5fN5akuUpCkRccsztfUmaX7EPpBb9yA/uXStHmzZvVe78IGQc5GlSz3MW4BuFL6+dPG7XdLsksUzIRV+WGPQfXE8x5VyG6VsDzQDAksJkJRjGn7KXpZa+hFKrc4rQ/TF09j2CrEa8eRAvu9/M8ksmt2T+MW7VElMw0VE2LUm2Ov1e5odqUikYGezGvfC3qvqj8na1MrzrDXotB7dDbIFjxEGIqGGjYFsAgEDOlGsWpShMjLsnUidhK9Ekzx8kkm36EEL9PFyqUoFjzGL9jD9nY+s/aNX2NKXVN9wdkdZTP4fZ1SipyuRwdc8wxtFSErNfohqQvJaK2G9dAseJQrNraJAmCew3Zjx/0DSKBD/TFv98CVFJpLO54h0E3xGsJnuee8CJeev+8TGpByNm3N2y5ftDVyyjnLsW89rLOTtsgWDFYeSt4wdADqlaxXFWKKRMhk4itdDBZNxVTr2MBJhxRIseqiLTjUE6dtnFHOaVqXcXYSyVaCltQuV6KXK1WUykGkFoA8x7WZHipIuFyPxhcv963bkjpUmzEmOpnGKBt1VqdkomFZrnY1NiTL1FWRTXONH9fqZtLyx6DsAjuFMNIlnu54O+xWh3leb4o0PvnFWCpW3XQr85Bn9dO6wwb8GtY7inBokD+9xcMHWzqlk7EVjJ0YqdHAw4iQJ0SJb+ow/U6CIk/GeX2Kt/V6QLtmC2p1DprRtO0fnKkSSrz+TxdccUVdNJJJ1FubNzXnNRNN1JTJMr1mWw/bjGi27KyWKxUKZtyzaM7Jf+2smE+7eZ2W7xrHnMUU35J4X1P/UgmLB/mK3UqV8s02ZgnwTJGvxfB/SSVg0iWgzDAC379eT45OUkDhQEet761L+ge6bTOMPfNMG76CPqKlb2KFywbDJvK0q3ixWk9QLxA0pls4ZWIRyeZ/SBpY1n/ADpoI/qB9iKQ0o58me7ZM0+5dEIFjR/NptQx5iYExq1crVM66bbZHEd8V6pUaWauSPOlKo1mkn01o3WJIoJH1WnNmLtpwkRfbxMfC3D0304IKsoAeS9VapGvnU6uO/bp3jlToIoTo61TrQ0Dk/Cb5tt+deLahZoKxbRTJV2wDNHrhXcvSKWYGwqWM/q18RLmvhnGTR9BXzE8K3mBQAMWulCNSuUKZdIpWtMwBTTNJ70WsUthCqkv3OfL3eVp1KPIMjEF2QKg0mHB3yKrjlKk3Hq763NYghBGgWUSXavXVSClfKFMGyYyNAIVdjStiFdBmeQ6FK+0R/3lbGc2E27UiTycqVSakglnQQTXXgfQQVn75qtUd+o0U3CDQJkBf/Rx25Uv0b27ZimeSNBBa0cj57lFGWOZJK3OhQsmpKMTk/f79xbo3p2ztLdQoS1rcjRdrNHaiYXE3ma+7VenbvnAmxReZH1YfXIFA4BuSaWp6CyGwiMqkmAx0a+NlzCbTLLpIzAgxFQwlMAiN1+q0L65Kq0aJUVEOMiPbj7pR0wX2ye1feGOf8PlUA0TRZbJT0YFMiork0v8jvFwHIfmEwhs5FC+WKGZQpUOmMotIExhFvw2gmCWEYW8uu8uEQFJ0RU3qJAInAN/Yp26uZGDy4q0gvzZctFOjKQVOXcotuA3PxNgV4muUjrhphMKm0poVQ6m5HU1H7aAP/q4oT9FkO1qRbUxKrpRDTsxeY87dUpnErQ6TjSeTavNA5sSjs+Z5EJT3zB1epFavWwhpYIlUWBNRacThScq0RQVSdAN/K63bqNjdwuz/kE3nRYsOoSYCoYSWOSOZVKUipFSTHUCoCtnXiRpMX1SkSMUpqqIIDzSqK9bH0Ocu3FyRCN3rf5x30CSWDHl7+p1Ili26tF3QZh0tcpvTGwEwSSrYdUtc06YnOrkMpmoUiqRouJcK8cbn8P+jjbFUfVjaizkiLb7pmK+UvF4W3AtP7hz0QqKgXE2A/7o4zY1llG/o3z0sZ8mq2Z5najlm6ZGaWwk3TQb94I5f4wwdXqRWr0fZjAvMe0VLApMRacThScq0RQVSdAN8ruICnuJRlYTTe7X/hsiC9vS4SwWlrp+wcBDiKlgKOESj4WXr7moVWTMQpIW04QXpLRcg5lntY3AdIog4ufVN53smIQJRAlEL4is2wiTSVZ7pW7p/ZgcWUP/8A//0NeNBbR3NJNQZrIJlZc11nW79bJ5PPxS0/TD/7Xb8hYjlY4Xqe0k165gyKArKPibU3L0MgJqNzAVnbAKT3ne7YsisA3ng3R2ifxsByvADAIe6c/zyOCxjXqdLNU4eNXL1zvQg/ywzXGZ200Uq7fK7qRtenmDdD8Klj2EmAqWNQbBBBD+kyCneO8Fuomg67X4h5LLZqZ/3jaj2hrW99GmfPZ7vPuxsYA2o8/ss7sU10yvr9dBuP57AXMjYrn0a8VBXwSrz2X3u3jCXQDPPOSqKSNTRFNbOitPX2AH/d5v1ao843LSsXVEsUYfbSTEy49VGbc73be5H6bBNtJSmCYq7HOVsJE+RtvFdTK/hyg3RbT2YeHOwZiibbjWgH5cA17z5qUSYrxmHiSKJ4kmN7X/1gmJ1q+57KRdkTTT4aAN5Vmi9Lg7Z3qdPM6ZcaLVB3R2HS4w3W1sQEneUoEHhJgKBh7dmO3ZIod2awIY1acSZCdqgBs/9JL4sW8fAhCBkIFAgwDM7q4uWQ5Qr/QCN9xwAx199NE0NjbWl2BWtnkFFrP/pslqt1iMTYLFgDmvy6VfKw76Ah2LVEWWsHCtuL87DlG9ooU366Q8jXzphEyVvwjRP3khDuJWKRA5MaLKPCnJH9ds3OJX5+XHWpx13+G2AHLbacqNfpgGY+zr1QY5ZWK6j6hebpDTyY6f54GoYj7rjfeQQP9BSuu1/pEivh5RR3Y8+FpTGzNl9zrhe6CbVCtcVnY10dRW+zl+155JoNU13Jjn3Oro5re2zYC2e1JUWMFCCDEVDDx6abbXi7I69akcRKC9IEKcYgZKaWFvjcZTMZWSxRaIZimAhOz79u1T7zZCWijXKJ1MtJl6Rt2A0OcR6Mec2sgv/Hs5crIbOKlOhXKJUpNCvgTLGE2ylGoRBpCv2qrwi18sfEH6QNygBJnkSydk6tiie1w/wYv7RJIovRYPL6JUjqi8l6g0TxRPu0pfG2LtbeN2A6UZouRI67PVJDSAxHiZBndq2qpvJOjjiXljxdRHXfV6nocG1MVCLhpJ0n2E+62Yo3xck1ynqVIy0H51/SYWtqmTVCvYDEgkiNIRyL4ioCm3jZgjvp+A0TVuedhc6QT6ZgCucZRfBgkvtuoQCAwIMRUMPHpptteLsvrlU7kUYPNebj+bsnJ03EHvE/sexshpi87byWaBOY/9mFPbpgYCLnHkZLQfpBR5Sof1mhIIQpnzMVni3+B/GZUw4HiQPq/onvp3qCOVDVZjYQ45t5NodB3R2NrOJxMkQSmJDbNOEE/CczXhkjfVZzbpddrbpo8NK6ZMVGwEtFNFNIoqp5un8liif7rvIfpsU0pt6mo3MOsJY/rcj+ivpjmzTkDD+CXjnNVb7XPXSaoVkEyUGeU60OdQzWvjfgKwUaTGWRtXRhgzeTNgGK41da1rdQgEBoSYCgYeUc32/Mw69bJYveq0HvM8NsO01dFp2VHO77Quv+i4tj55oRtz2k4VTvjEzhSrtH6i3VzaRjJ5rh/ck6ft+QptnRqh/bXIvbZx6DVsmxoIuMSRk5UJ72TrGB5/oJdm1b2MauvXRnw/XaiojQP4MesbB4txTwgGBLwoZWWzV4TBS4laUL9mLhwUgAiktFZy3zshpl7kZCxGVNDIplJVmVB7EEtbWboCbKbdiAqzXpuCis9oK8yKYZ5qOy/MmDCB60vQLM30GQrdYkV8NQl3J/PQzfXfaWCusPeTX3lhzORtZsNqXpyWgjogAbkEgwMhpoJlh7A5Slm9CpP31HZeUNoUv2PDIsr5/TApjlJmN7lhO2k7jq05IEOpUL7FPNf37ytRuVajB/bF2ojpYsBGfk3/Y/0YjCVMqvHfeC/NqnttHu/VRrS/VKkp82SYi+N3YLHuCcGAAItPFfin1gh8kuoukmlUQmb6ovoBSikrpp20z08dw0uPxGojAH790z+jjCg+s2HyVzIJhRIIAsEkBZ+hkLJ/ZlQChGOZuPUKbWqvZhaO75S5aKVFhP0iy7IfJN5ZcfStV1dnLebM+jFLQbq6qTvKvC7Y1AjYqDDLNq9fiQAsaECIqWDZIWwqEV29AmEJS6a8THdt33dr5hvl/H6YFEcps5sULkH1jIyMqEAZeNfPGc0kVaqbsHON4/ZflVGK6eZVvQtI1S+g3Wmf/J6DYh7v1UbX39ehbMo9phdm0sNsOr9iwYvSSETKw8y0HxFmdUAltSmltkAznbRD+QL6qHlhy42qWoYpl0koVEc+jttrixoclvwYddue55Gh999UnhFplpVMAH+DfNrMfDkatNPwdw0iprzJUSkRpTILzZmXMlcn5iW/0x3rzNji1d2RUmxcv5ifKm8oSFCklQwhpoKhgpe5qG7eF9aUlJUpDv4TFl4mhPqiWz/Oy8y3m7q8jjXr7xZm/QjUM1OoqByfSa1/UcbdyyST6+E6YP7pUIwmRlLKtHj//fdvnrsrX2ym4NFzw/pFTOa2HbJxFR3S9ci0xuPO7TNKEdyyJkfZdJJmC67J4Hij3d36M/cyh6htPLqFXxv9cup2U5+Q0iGEvhANo454Ea+O/CkbwYWS2c5VJZPYhQpO00E9tnK5nFqDbDFZ1JW6XkTmNUmo/n03mwNG3el0+/O8I/j6FDfMRHXFFPBqM9K1wAwjErkKETma1fF+Kqc2k2YV2boP5avPfA83yDcCN6VHovfRZg0AE3ox613xEGI6ZCiVSnTttdfSPffcQ/Pz87Ru3To65phj6KCDDqKVAC9z0W7M+/wUmKj+bH5mvnMlRFyt0ZqxTE9IAZPd+XJNkbiJRhAjmFVCneoloWGAMEIB2zNXpo2TI1QoV2j1aCayCS6/OBqwfu79ews0PVdSpG/9ZFZF3E06NXrgwQdp86ZNNJoboQf2Fmi2WKZCpdYWvEkff7x250uUTSWUstoPMrM7X6Z7dxeI4g4lEnHab3KE9s5XKBZzKB53gxkNEokaBDNY8RFdodAXoiqtSEAwHC8VxvZ9ECnDb0kt0m0naqdJ7MKoREH1+AXt4bYCnHJDpY+pugt40zS2k8i8Qea9Vp9Tw183DPk26sY65qGHHqL99tuPMpkM9Rymiskm1F5+vIjyy38Durl187vGueyHidyePEfYaNHnj49hf+JeqftePsC6STOUUr3dXdfp4Uva9num+z52ErhJsCwxOCsmgS9+85vf0POe9zxatWoVPfnJT6Y3vvGN9N73vpde/OIX0yGHHEKHHnooXXzxxTQ7O9vRSF500UUUi8VUuYxisUhnnXUWrVmzRuUae+5zn0vbt29vO+/ee++lpz/96ZTL5Wj9+vV0zjnnULXqBkLpFVoErKrMNkHwdHUQ36tAOJXw9XKaDrwALwJhphAJAsqIx1pkl9vmmgvXKB6LNQPFdAvOQTozX6ZixWmW67ePC6Xxz9tm1HsngHoJtXTDREZFwcVn7m+UdmNMAdu5cadOTixG8USM4pSgdIIoPz9Pf77tVvUOjKZilIgl1LtJtrhMjAfGG+PeLxKWS8dp3USKxjMpZRqcyyRodS5Fq0bSC8gw2oNx53nSr49ewq9cNlvfky/Stun55j2AdvHL7/o0+9Bp+6LcU4JlCCyaoVL1a/EcVB8Wv3o6jzDQCUfoc7R6mOzo+Sq53bq/ndmfpulo0V28I3VMgglhRSNRseh9wnmlvGv6CvKLF6vZXC7/bn6nyJhl7PE9zEn59wV1zlNxz0N08803qzVGuHYaZdrGMgi6yq2fxyox+9Sijr33EM082BoT9H9+L9H0gy0FlDcGsGHAc8S+qnyt4BV1TqJe5/o1ZvalF+DycX2hb5z6BWBT5U76aM5hJ/eXYFlCFNMhwDOe8Qz6wx/+QC984QvpZz/7GR133HFtvhl33XUXXXHFFfS1r32NLrnkEvrKV75Cp556aujyf/e739FnP/tZevSjH932/Zve9Cb64Q9/SJdddhlNTk7Sa1/7WnrOc56jSDKAHGQgpRs3bqSrrrpK7YC+9KUvpVQqRRdeeGHP+s8L2dlihSpV11/NFlwIAYyikjoQXfxtmlyapDLTyI3p5sysKhNT5J30i/qLY7ltOA5KaRgfzLCKkmpXMk4TubRSTJlc+wXJgflruVZX72bQnTDAOHWrxDJpx5ja2rlpapTGlLnwqDIXVilU8u6GS7Jhcr1paoxWjbljqSve+pi549w6ph9YM5ZVSrVer9e4mmp/LwJj6f1GuTONnKhjWfc/d7sftEN75itKWd+0aoRqdUflgN2VL9FouhUhOEwf+uEjKorqCoDNL68bBJmpmvV1G720U5XY9Dusse9jrBVwyMxrikA+yGWaXd1Kk8JElhf2HIlWV/zCmBBzHlhoFCrfJEhCwvWdRHl8zPwON/jRyGp361PPrWoGtkK6nfIMUXqCaGqLRyTbWnfRbzv17w1zHteFuUlUW0p1BWOOB1gjrZFOdDnqsO6b24/rzHad9/ta5vK5f4qkOq2/O72P++0rLhhaCDEdAoD8fetb31KEz4aDDz5YvU4//XT605/+pAhiWOTzeXrRi15En//85+l973tf8/vp6Wn6whe+QP/93/+tFFrgS1/6Eh1xxBF0zTXX0OMf/3hFklHf//zP/9CGDRtUMAOouG9729vo/PPPV34kvUBrIRsjx4kpZZcXtd0EMAKpw6LcZk7aHmm0tfAHmZ2er1ImFW/mnQxud4sohWlfWMLCvn2TRvwIv3Pgk8m+mUuFIMJtI7+VxvEgqraxtJXXSdqafvo7msGhug3iY14nKBvKea1eo1o9QamE3Qcb91GcYpRLxtW9NDHikmSoz6UKNnjifQlwFXbMBsHcWDBkWCyi2WuwiTHIKft2Kuh5TZ0GSXQWEhSQQZUmBaS2odz55Ts1gd+QUxJEEcQ4kWivB4SLiS/MhxUJyxFlJtpVOj2wVfN8x0e9nosWfdlMN2MSNFZ52SRa9y3VVVKlyCUD1D1sEhSIUiNEqVGXlIKkojusXMOMl8dPJ6GRfZ+H6DrXx1xtaDQ2TnpRnkCgQYjpEODMM88MfeyRRx6pXmEBU10Q31NOOaWNmF533XVUqVTU94yHP/zhtGXLFrr66qsVMcX7ox71KEVKGaeddhq9+tWvpltuuUX5vpqAbwlejJmZmcA26kqYaULI38Mc0Ylocgvyk0u3FuxBkUaZzE7mkkoxDRMJtpOFdTeEJSiXKNS8TpRSQfewkelugwCZGx+wAEgmXGJvbrQw2dN/09VkvGPjBabQXoG6FovsCykdDnTyPFcYltQQvUz7Ycu5yoRLpabRCJW+aAdhLXPaFi2QTjM6bsUlsSC3QXlGzf7ovpCcDka1oeEvqcpKtZTSZgoZI7eqXt/YOqJyzpu0YL5zq7U2WUg0p3ABIeZx0lPtNMnqfMP8uECUTBHN7XJ/K067hDvWUKKp7tah+jIZMFHoZ4N4N32TQWphQp10x0mZWGtjpBPobrGUqWb80OZ7XNY2TnpQnkCgQYjpCsbXv/51ZSIMU14T27ZtU4onfFp1gITiNz5GJ6X8O/9mwwc+8AG64IILOmovL5S91JROHpFe5MAWabSlUPZ3h68bwtILU8tBRCKRUIG+8C6wXyd+pNE0d7Zdwy5JrS+5YilRd4cHHT/PTdPMQV3Ie5GmTuqzLcS9TJpNJQ7H2PKWsk8hyFmYPKMLIgvrBNfSJzbfBFHTSZctGi6Xz+Q0zPM85rQHUtLbqUyLG/3xaj9fR8q0NOkquTC5jWn9GGmY/up5Tf3AKrGeFkj1p9FWLtcWEKgnAY4imLh2c+2bAZ6i+k6L2inoE5bPynUZY/Xq1crkLgz27NkT6rj77ruP3vCGN9DPf/5zymYXT0E799xz6c1vfnPbDvsBBxzQtZrCi+qVbvrXC1PLQQSCbx1//PFL3YyhRRiyx8foZr8CQV+e56ZpZjeI6qsWZTFvTd2yRL5xnulzLHlGOynDGsk3AgGJMC7N5zmTbWUWrKcOYbXW6I/ZHr6OxibbFVX+rZP5CeP/7JVCpReIMubd5EtFHQhixallopwvaqegj1heq9dlio997GPNv3fv3q1MbmEye8IJJ6jvYFL705/+lN71rneFLhOmujt27KDHPOYxze8QzOh///d/6d/+7d9UeeVymfbt29emmiIqL4IdAXj/7W9/21YuR+3lY0wgNHw34eH9FE5ZSC+OqWUn6DagjeM4KtpzMplUmzSDECBnENrQDyy3/gj6h46f570MfhRVvYlCLG0L8KVSi/zIQFiiEJVQRDk+wrg0n+fxFMVAjEITZeN7W1CrqAStE5jt6GmAo8UKzNWIthsXc1rBYGHwVrCCBUBQIwZStrznPe9REXIZr3/96xWZRBAiRNINg5NPPpluuummtu/OOOMM5UeK4EXY9Uawpcsvv1zVCdx+++0qPQwTYry///3vVwQXqWIAKLATExOR/FwF4cBRVxEAyPQhHHR0ax4KJQaRp0866SQVIXqpzU2BQWiDQLAs0I1JIpuiwpzV9Fm15unskliKWtT1uJjP875jUP02u4XNbzkscB5MlMUkVzBgEGI6ZICS+cEPfnDB90996lPp7W9/e+hyxsfH6ZGPfGTbd6OjoypnKX//8pe/XJlpTU1NKbL5ute9TpFRBD4CnvKUpygC+pKXvIQ+9KEPKb/Sd77znSqgUl+SZi8iOIiQHnhpsciHlxLHUVdj1f6mQBmGgDZLHSDH3CQYBFXW71huL4Ijwb8rl050dV1z6iT+e2++pMrdOJltC1LGpuUzhYrKeYux0tuJd3Mcg/q7XJXqFY1uTBL9fFZt6qgQy5WH5ZqapNtrOez53RL75boxIOgLhJgOGUAcv/e979HZZ5/d9j2+w2+9xEc/+lGKx+NKMUXkRZgPf+pTn2r+joXoD37wAxWFF4QVxBbqLhTdYSoCNnsAAKZlSURBVAcHESqUK7R6NLOoJMhLiWtFXXVJxSBDjw7sko8KjTTIEKAT66BIwjbwuRyFudfjEdQm/BZT+dx6X3enqqzfsbypsW++TKtyaXUd2a7rsKSP8wDD833vXJlmSzWKU1WlnsF48W/w+8bcIzcq3pmYcjvNzRYgqL+iVAtC+6yaKS5UsJpGShHbIjlstOAoC+2wfo9efouDtJD360sn5KNSIKrlFh7fcyLTyAtrRjYOc01EgV4e55jFRkuQit9NXTY/V78+FaaJ5na6UYuhmNrawNGOAW4752jl8hEJGX1E/2yRjvV7Ce3w2hgQ0iowIMR0yIAIiP/n//wf+tWvftUMBnPttdfST37yE5WLtBugTB0IivTJT35SvbywdetW+tGPfkTLDaz0QOVB+ozFJIJ+AZ68iJsfoWACUChXVZqbyZFU3/1Q79g+Qw/sK9LmVVnKppI0WypTMp6gsUySZosV2jA5Qvs1ErD+dVeeHtxbULlVH77fJD2wZ452zpZoy5oc7T815lnHtukC7c6XaM1Yhg6Y6kEQlQjRjXsRZCoMCYyiDPsdy5saa8fSTcXUdl1HyaGL1EkA5i1GTqPcZNtv+Bv3ECumZjttmy1h6hbz6SGEbQFqfmfmpfQjiG15LkNEt83vIirP4kui7JhbB6c/YahjZojSE0RTW+xt1FOZcJRWP5KBc6EGm+0xy9ZVvZ5Heu0VGfLrSweqpCdZ6bHCyeWBlKUyLWWevwdpRVRjRVoD5tNvbFn5R1ChmQfdVAGrt7aupU765nXf7L2nkWpovZvKhi0OcIzeJ7Oe3XcR7fyLOw6bjiaa3LSwHbi+C3uISnNuzlakC0JkZr2Pu+50AyeV1jQCTxlt1O+lyf3aCbtOoJt5cpeZmi3oGEJMhwwve9nL6IgjjqCPf/zj9O1vf1t9h89XXnmlRC1dJkGEOjFRtBEK5HYFIYCZZCIeo+n5KmVScZruop4w7cBr51yJqrUa7S2UaWs2SXFK0GgqRqVKTQUvKmr5aGcLFSpWajRbLCuy98C+ApVrjiK2JjEFiWETa5xXrTvqvdcIIp69uD7CkMAoc+R3bNj2hiV9ZsoZMzeu/puZYklvJ5NTs+ygugfdYkAQNvVK4ztYH+hqZ5h0MpEX+FpdSENiXQw77e9mPk1OH4LPWPgDKp+jTwAcLMJBGPhvLxNmlaZEU72UMllrT1HSKXpF9Pz60onvrorGm+4yGnCDuNUa14tKr9NQ6Vg15JQ0ihzV3Hr1eprH16KPk7mhAFR5c6GRyqbTvvndN8jVWpptkMEkUWW+dR+xqq3y0hpZF3BfOWX8x0NUK9n7yuTcmXE3cJAVYmxt+3ExbWzNe8TtfOudNzH0lEfqp7r/dSBYkRBiOoSAUvrVr351qZshGCDYCAWbUFZrVZoay9BkLqkU01Qi1regPUy2tq4aod3zVaWYTo1laWyk3ayX1TNg69pRSiXjtDqXVsdsXjWiFFOcq/tEn3rqqVRxWm1fP5mlPfmyUux6jW6IJ9qGTQGMvZ863anyZ/o/6+V1O59C+gR9g82sVicTOiHDYhhmntkJ9282SQSaykzEBT4UsnKDtDDBNM+FaWM51yLJtnya/I7FNBbWZq7NBf0OGSnWFum1V6qhOVamCgclce+9rgI2vrHRXpCOaou4YYPAqy9s+onyQvjcjyfrdOqxhyhT/659J5tq6D6XCIJs8YYBq4ZcHs+Zl7+xaR4bdWx5PJPZ1oaKntO1E+Xadp3j78ykm7s1O+mWBdNc7g9euG7NNDzA1EHub3HM1Wp7X9n8OD1GVNzn9oevQ75/1h7aundtOWfNe8nWF3VtNeZHIGhAiOkQ4s4776QvfelLdNddd6lUMoiI++Mf/5i2bNlCj3jEI5a6eYIlgI1QwKdzz94C5VLub5OT7n+UIE1750rqd69zu2kHSNOqsSytm3TVMF0VcwlVe7qXjZM59WIcunGSDjWyDcHXGQG14tp5UOlMpW4QgPbNlWoqJcJ8IuZLTDshpTCTrtUdGs2kaNPqHBUrVWUu3cuNBj240bAF2hIMKHQSwMqJ8sMrtasoylS03lA0S65JIJtf6mQtap5Ktag2Fu8mFqQfseTT5HN7YR7rF1XVmkM1ZJ0230mdILBJLpszg9TldxKV8y3lC+9Q5Jr+uz4+t0r5hb9oyTUrDRiPeGmGMgQ/xX1EtQax8oOfaTePk9p4MBTT5jur2g3l1Ct/bi+DCdn8LjtRrm1twuepre3Xh34d+W3aQPnEK0ydbCbPZeq/qTFc621qjHE3TeVtmy8CgQFZbQwZfv3rX9OjHvUo5Vf6rW99i/L5vPr+xhtvpHe/+91L3TzBAAGEAoFuUslEk2Qw6UgnE1Qo15rqY6/AZAvllqsuidTBwW7mStVI9c7NzdHvfvc7KhcLA0+U0LbRTIIyKdfnsue+rzWiYrVG2FeAnyjq6LUfNAc3ss2hQNCzHIpKbUm5aotazMYaZq1j7jEqx6JjOS/tHZinabZpfjZMLkF2FBmb92lnY3HOvnBhfws9DpoCFeY3m9moDXycaTrZLDvdbs4MAgFlMTXqKmkATEMx/lDlvIgcA78nR4jS46HUxjknQ7+7aw/NOblw6iQ2J/Lb3XevcQIRhL8klDq1wdAgsTyGbDbN5/QKYefEvH7N6zMq9OvDvFb0z0H3RVAdKriRQTC92sFlQ4GHny3X000/BSsOopgOGZAS5n3ve59K4wLzRsaTn/xklctUMNjoJAJtNwF1QJBgUqrXFSawUzcpOczgNzo6jSyMZOzbt2+nww47LFJbzDQpfqa1vZobVnN1sL8vp0zpFGjXuok0OZRRQZ/65QftN4cCQVfQFRbcC3oAFFZZdL9KRVy06KJ+QYZ0Ncr8bKpIQX6sTXNjn+AsPQ/SE6CIhjVfNn0ndfNpLpuD/7CauvHIlr8rUE2ET9/jFXzKA9XkCG3fm6fDlClpmHEzfH8HCX5zsiC4l8VqoN9Bf4Lui37Vxcp7t6mgBCsOQkyHDDfddBP993//94LvYc67a5dlN1EwUAiK9tot9IA6KN9m6hqGeHWTksMMjBO17l7CTJPiZ1rrNzdepq1hCbyZMiUqdGLrF6m4G5h96Wd+Vlt9ghUCffFqKi0c7IcXtiqYS64zgrDgs0FqvVLMmO3sVZCeMAgiDWFNTW3HmUTINh5t5qAeJsZLAZu/Yi/NprtBlM2StvPSvQ1w1el90Y+62Ee52UeBIDyEmA4ZVq1aRQ899BAddNBBbd9ff/31tHnz5iVr17AhrDqmL55d9a071asXaUb80KtUGsslJcfCNCnJjuZGz9uJgB06MQ1D4M2UKVHRLbENg8XODyr5SFcorMFcGov75iK+g8WzzX/Nb7EfpPI1VUef4Czd+iR61dlP0uBVdlj/v059a3W/VwS2ClO2njfVz5w0DMLMVa9zavqN+YJrvk+Ke9T7ohvYyu7XhoBg2UKI6ZDhBS94Ab3tbW+jyy67TKXdqNfr9Jvf/Ibe8pa30Etf+tKlbt6yUy71xXMvyEGnuUjDIuy5QcTcr5ygdkbpRy/6jH5MFyoqqBLmRS+H1U0V8ClfUq/VYxlaO5aJlCfWy7Q1LIE3U6ZERbfEdhA3I5bL5oegB4tXtaDmwDTZ8GTBFuTHDEykjtPO9wqko5Mg3XfP1oZeExi/sRm0sjs1BeXzECmXleigsjlIU6/az6lN8K7mOGkE7THr73KebdeQfq0qkl5spAqy/W5cu4Dt+g1jdm4bC1vQoqD7KeqGhTlv/bp3BMsGQkyHDBdeeCGdddZZdMABB1CtVqMjjzxSvb/whS+kd77znbQc0Q+Tv7DKpb547jc52JUv0Z58kUbSKTpgKregr70ch25Mik2ly2xXFCXMdiz+3p0v0ny5TmvGXEKXzWbpkMMOp51zFdpemFEpYnD83nyRHpgu0UjK9evMpRfWyVFyd+XLVKe6yukKX9MoY8iRhc1AQL0g52E3EA6Y6sKMLQQW26RWTHgFTeimu175Dv18PDktiM2PDtAj0Oq+pXwsFuIqaEuDtIytb49c2is/PRv5jQo/QtGPxf4CP8kOVV3N7zXrlOjIhx+unuuBZqdeeVM76gsiAecbc1chGp1qn0NbOpNeKZq2a7WZB9fx/t2s3+Yb3WxnY4MnjMmzrW9h7qdOzJY7OU6wYiHEdMiQTqfp85//PJ133nnK3xRReY855hg69NBDabmiHyZ/YX0d9cVzt6pXEIrwh6w6RE7F2lcQFERJTSe79//zIuZMhPTjdHKuk08vc9YoShibSNca5fC5++arVHegUrsqKFLFrN10AN23u0B1pBmAWftomrbPlMlxalQoO5TL2AMqcRAomPNC8Z5ApGLtuLAkMoiQ+x07qD7JAsFAIMgPztMc0hLkx3Y+SCkrSbpvqb4Qx+94TzJZtdTDBBbvXn6nfuiFAuhHKPod0MbmmxoW2nmZdI4OHl/te0zzcy8D5qhAT2Mt8mbO4YL6IwQ2ClO37Vo1r3O/3718o5vtbOQU9QoS1dZmj/yoYe4nv/6FDcwlpr0CD8hKZ8jwnve8R5ntQjHFi1EoFOjiiy9WhHW5YaWY/E2NuTvDWZ90KL2KSehFzJkITc+XaRLBghqEyCSefuasUZQwPb2MXv6qHIhzvalOl8tlyu/ZRRPpEarF0k3FdMNEmuYqKdowkfHMaRqU8zQsiQwi5H7Hdop++yQPWlRpwQpFkB9cVB9P83s9Ai2+N00geSG+eov22VIeK7kqKFMHFgy9UAD9CEUnZfYqEnAE4HmOYI1r165Vm+2LBvQPgZSijInXPEeNNut3rdr+9vrO5hvNZZsm7GECj4VtYxD5Drth0U9zdcGyQMxBFnjB0AABXBD8CFF4dezevVt9B7PeYcLMzAxNTk7S9PQ0TUxMLHVzBgY2NW4xopiGUUxtbeTPfAynaWkd69BIGulaWmol18XlI0jRxEjaGhF3z9699LtrrqYTTnwCjYyN93QMOh3XlRhVdle+qDYu0F0vor+UkOeJjH9fsRz947ol2x0A/99fccUVdNJJJ6n//4dyTGD2HURMB+V68fIdHXDI83xlQra8hwzYR0DQIxM33ngjTU1NLUmbViL6TUpsatxiECC/YEh+bQT09nKalmKlSjGKUd1x1EtPtcLqLJF7fizmnmcjpigbqNbd6Lg4zkZyO1HyOh3XlURIB1XBFQwhwi7WF3tRH6a+5aT2wLwZ5ApQfU620pZwgB3+3hwTk+h4ER6uA9+PTIYfOz3AD/s41qotpQ+KoVcQKxOFabcNII84jv2I+bMNukrsVU+zbVWi6QfdMVBjlWpv9wKz6w6ua/RhbidRqtEGXfHM7ySqzBONrnPH2AZuRz83H/R+ob0zDxGlckRja7z9qQeFuAsGCrK6GBKsXr1aEVK8DjvssDZyCpUUvqavetWrlrSNKwn9TnVh870cNNhMW/lvTtOSTaXaFFMzYq5OcrwID86JNy73ZDxOtToCGLXXLb6Yi4OlMuFdier0sgQWolhIY6GP/8MmNi0kB2EjjHKEVRAHLHx5Ud6pMqSTCA5SZIvc6xXttx8IEyyp04BKIA7TDzQI2qir/o2sJprcr6EGFrATTpSbagWOUvVpc1Ocdd9LeaI4SM94e9Ao1LH3XncM1zyMKD3iY2aqjS3Om9/j1j26xm0byB+C/qRG3O/xO5uvspk1jwEAcoTvdt1JVC0STexHtOYgon33ElXLbsqaiY3eQaS4nOmHiMozROkJoqktCzcpcD1jrEpzjbYkiSY2u+NgM4NW7ZpdOFZ+2H0X0d67idKTRKs2N/ygQa4niYr73HFR5HvSI4I0rpFCg9AWWpsEvSSG+v0z+xDR7HaiGtICPZwIqbdtqrIEQhJYIMR0SPCxj31MqaX/+q//ShdccEGb+Qt8NA488EA64YQTlrSNKw07ZwpUKNdU+pFcOqEWzr1auNt8LwcNNl9Tho1s4m+TvOpj5ZeqJZtyf0siOu5IesGYiJK3vCE5T5cJeCFamtGCuOTsvnscodfPXw4RVhUhqbukB7BFFY0abdaLjJjRfvW/vRb43Sz+VaTgvURxPe2ImT7EOCasMgVSCYKkAuYgn2Yj0qs6vkF0kqMuwVAWKw1FsG1uGnk4QfRSHCBKb/88UWmWqIaoyHNEqczCY2xji7bN73bbBWIKgFyiHJBAzHUFRDBJlBl3zwE5rldayioURpRX3O22A7/FG0QykXXbHCaIVK1BYnGODZzqBeUV9hDFEkRZ+DRP2ued68B4lBtEPSidCq7zud1uHZOb2u+N1BhRabpFpJv3T8IdJ5SH+uZ3uWNYbKjg7HcdJWiW3yaIfv8kUW8jLRDm0svUWQIhCSwQYjokOP3006larSql9MlPfnJb4KPliEFUSJALk9PFoE2lqkPFao1m5stUrSUpnUx0ZeZo9jlKAB2bKetSB6rRVUygm+iy8Xhc+SDj3XZN6H3kdDMzhSqNj6TacpbaUtt0c53pfrJ6Wwblml0uWCkB0JY9sBDNjLkLa8DPrJBNIv3KAlmIFd13r8imXsTQN9osh94wQnB4RQv2W+B3qwqBTHH0WK+y9GNssJ2HeXDWE2VXuwGB2NxV9bNBXJQPBavIOLfx7G6aqzbalGxsApjzBVIJM1MQFWxANNoYj9ebz3Pr2Kq2rXHfmQBBXQcZjTeIT26NWy/KxTkoG+PAfcXfINOrH0Y0t8MtC+fzeU2CFxBESqmLIHmQ/SzgYER4QWEGAWZzW9tcqZRFjc9MUJlksvkviCWUVVXuKFFmlWsSm13rqqzcZxXMaQ3R6OrWPdU2541AW/UaUSLjzoUaF6O/UFOxGYO6lNJr5EzVTbYdLY6J3m79/lFK8GHupgTGfSWYxgt6BiGmQ4RkMkmvfvWr6dZbb6XljkFUSEBKYZKK942TIypyLExMQX50xbRT2NKuhO27zZR1qc1bw5rqhsH4+Dg96UlPCnUsxm96vkr5ckVZGeg5S20pX7q5zniMC+UKZVMJ9V93KjE41+xywSBtUAm6AKf/8ItiymTSi2TpPn8jE0TZBtHlBa5plolFN5RBLM5102E/tQZErdwgBWb7bcTTTB/jlZbDambpo6YyKWszN7WkD2FfR5BLm8+lra8gZop0NRQ0fOY6mDzxeeyT2SQgRl+8NhAwjtxPrV3j46n257k5Dty2Zv9BwGKtOVHEzzgHdfFc4J1JLcAm36z66v6lrALqBEsHHxsUlRh1od38t22u1G8NEtv0060ZGyQNv1aVezfvEmLlp5lxyaVuUm2b26aS2SCT6YbSi+9yq9s3fLivc/e6qjDKwT2lq/FNM+FVLvHWr6223L7G9YBcwCNafeJPKggJIaZDhsc97nF0/fXX09atW2k5YxAVEiilumK6cTJHGy2xBjpV4XQFD9FPdXLKPqdeCiiTQORC/fO2GZVOBd9NFyqUoNiijaXed5upLlTn+/bMqTFE8CJbn7pVMXHOZC6pXNiwaRCU2qabseFxh/8sNi1SidhAXbMCwcDBZg7Y5rvptMxwy7aAOo3FMt4VgUJZtZavoc1HFYtuEEfddNhPrbGl5LD2paGKKUXKo27d5JGjvTYX8wFqqtlGW5t1X0ceF690IrY+mm0K6r9XX7yOVUoiAtz5JIBAWTDFxRyBYFrrb1wXXI7v2Bjn+qWIiToHQZsu5nd+xy+49rVy1H3SMMMFyW5uImhpi2xpX7za6xk5uNwwh666RJJz9TLBxN8IrKRIrrbpYfO31hXgtut+3r0+4R8MEVdUUoEPhJgOGV7zmtfQ2WefTffffz8de+yxNDravlP56Ec/mpYDBlEhAZHCKwidqnDcZ07JARVu9WimLdKtlwLKxA6ktIz0Kvkyrd3o7pQupvIc1HdddWZiavbJVgbSC/zmN7+hJzzhCYHpBfw2DWx+sd2MC4872o82Q0Hv5zgPoom7QBAJbKrYtjjXyUHariQxmr6pmppmI3sAiA4rfaza9RQx158VABFl31au21TLTHWrlz52+riY8FOrOm2D33leinED1uc5+4B6EsTe51Pta7mh6/fYbGDVPsifs+v6066SOr7BTnr9NijMNim/2fnWPaBvYmCnGBtEqEsg8IEQ0yHDC17wAvX++te/vvkd/E45jcyw5TFdjgv2XqlwUBV1ohMmwM/ESJK2z5RoYiy5JMpzUH266uzVJ68y6vXGYnMAsVjj3MmmxyDdGwKBGxyl4ftmI2heShLDVNO8yB5MGHUFsC9oqHhQTJupOBrmk50qoJ3CT+X0UwU7bYPfeXp9HpGC257nOpn2Ilv98kccVD9HmwLbjzbbCGZHGxWa3yw2aKDCmvMbJWq0YMVCiOmQ4e67717qJix7n1SUwQF7OglkYxIA01zVRhTMY2zkM0wQo4mRNI1l0830KjYy0s+gSEHkx1SdbW0IKoPnZ75coxg5qs9B/fDqc7dzHdTmqOXj2JkCgmnVKZFIKP9Y08QZyJerdP+eeWWyjfH0CvbUyb3hRWT17/GOdiJKsp5PNgi9uvb0QGRhrBgEAwImm/oC1UvN8yU+phlhIyWGrqL6ld0r2EjwIGKxVcGo9fmRMMHiolvSi3Ox8dRm5RDSNF4gWKnE9N///d/pyiuvVGavCCY0MtIIM09ET3/60+mHP/whDSqWu2/pIChWKKdUravQAb0IZGOaq1pNVQsVKlVqysy1mwV7mHHoVV1LBZ4fREPOpJKUTAQHVfIyg+71XHu1NWz5yk+44tC++TKtyqVpPhFrI6bI34pNh+2FatNkG7/vmwfhWxjsqZN7w4vI6t9zO2NVdzy7CdLVCUyTcMGQwCsdR9Sotfo5gGka7FffSlDblrqdwzIuvcJyCeyjBxZjs3ivPtnyCAcFLjPHSa9PiKuggRVn13XRRRfR+9//flqzZg197Wtfo8c+9rH00EMPNX+/4ooraNBx55130ute9zo65ZRT1AtmvfhuJYOD7fSCWKCMTDJO6WRvTB/RLhTDC3GUafoiImgOTLHx3u9x6LYuJias3i02eH4mcmnKplrELaiN0/NlFRwKPrysYvZ6rr3aGrZ89AV9WjuWpkwq0TR13jY9rxTKWt0li1BK0413fEaE6LFMSo2JWU/QNaGiGBfK6sVk1OYrq3/P7RzNRLvnzHuhU7gByGJNk3DBkIDTepgpOprpUCpukJTpBxtRVEOUw6bBSqVplIHFLt6bPqDdPVcFgkgbJcMIvvfgB6ruHz3fKt9PtjzCjXy4qu9GgKqgcdIDmQkEDcQcbLGvIDzsYQ+jH/3oR3T44Yerz+94xzvo0ksvpV/+8pe0//77q7QUs7OzNKj46U9/Ss94xjPo6KOPVoEDAAQRuPHGG+n73/8+nXrqqTRMmJmZUcEPEAwBec2WEkvpi7eYdfcidycH+umH4qq3zzVtrdBoOk4pp0q5XE6ZuAYBJKtcrStCCEWNA0qBnE7m0ooccfAlQCduvTLv9esXfw4zB2h7vlijWMyhdePZjsac6+aXme82X6qqpTuIZqdzutR5cwftebIS0fX4Y4Ga39GIRDrhH03Vrwycz3kd+e+eBz7qoapmi1QcdE4n9XTTbk4/YuZw7aAOxMKYn58P/Tzv2RiHbXPUY21z18u2d9q2KODIyNjIaab50SJMm/eQTTFV3weorBEUU3mer0wMnx1fl9i5cycddthhzc9QTzlHIsgplKRBxtvf/nZ605vepJRf8/u3ve1tQ0dMlxLmYh3IplxTWy/fum589PzAxzIp6gdBBVnbPl2kdIJo/WTO0yfSz/+V2whkPJTKbgm2bjLKJptz5TodMDUe6ly8CuUqlasICOZ+z8ojFEaUhxQ6+Kyb2eqEFPXr5rdB/QrTb71fXIfftcaf8Xc2VadkItH2vVd9tt+4boxnOploM6VlVZf/jtIn3d8T44qNgEK5RKnJzubfq+08N4VyTfxKlzNUioqxziLo6kqpSlfRiAxq83UMQwT1c3tC8HzMitGWwl43Km2bj2yXZs69bDdHHGa1q4s6QEax7uo5/PoeZVyiHsvErZvxDltnv8zTcZ0jLU1uqlWuXxAyjhy8oJwQKXIY4nsqsGDFEdNNmzbR7bffTg9/+MPbSB0AclouD7Ypxq233qoUXhP/+q//Sh/72MdoJaFbEmQu1h2nTvH0QhPGToLHdBqIqdsgTn5jgn7OlsoUpwSNjdh9/Gz1m36B8HOESSkTrG4C7digB9fZOV2gRDJBG0fjyirg0EMPJUqm6YE9c1So1GjT6hytHcu2kaS5UpXqdYdGsy1fS51Us68m+qATMpyLLuE6GNFIm1+/9I0NlOnXb9PX03asjbzimMnJnBp/tBGYLVQoHo8pP1TTx9LWVq4bpq+smOrtsvlphp1LJqVQQZxETJkgd3P9mnXyd/CnRbAl8StdBvALeNSJSuqVhob/DnusaWrYSwIQFBAIpBTkBvkkYVKpCLNxThh1rteBjpoBnhoRh03S3gGglv7lL39Rz3Oopj2DX9+jjEu/ju1FOc10Slq+0Z5cnx5+wXrKl+amj0TXFfQPK87HFGaw8C01AXJ61llnDTwxXbduHd1www0Lvsd369evp5UEcxEfFewzh8U61sAc3dXPty5KuZ0szLs5N2hM0M/xTJpW51zfxbD1636B/Dtgq6fb9nMZqAtRZtPpJI2kEpRNEN13331UqVQUQds1V6KZQk2RFR2IZus4rv/smGGWymMDsBkyRwnmOuuOo8gP/6YTO1u/zDL9fXtbvp5efp96PWadvEGAPrt5bu2poew+zK0+gciHMbUNO5fs77l+coQ2To6oce9mU8LWdnzn+tOKX+my9slj80C8TJ+2IJi+pp0ca/qu2nKRdgq/BT2+R35HkHKMCfvdmeewsgqTSy9/Rj6Hj7eNo64u28acf4epJZMlpW5pUY/NvrT59voDz3H1PJ+fiT7PXjCVPW5/J4SqX8f2opzm/Dre91CYeQhzr/Ex2CjBNQefUmzo6HX61Yfxx7nqOgp/fQhWNlacYvqhD33I87e3vvWt6jXIeMUrXkGvfOUr6a677qITTzyx6WP6wQ9+kN785jfTcoCXjx/Uoh1Q0BIJWjPWWizYTErDKopBC2jdjJWDxHj50PGxphksouBiQR0mrUa3JrymKqeDSZiu8tmIkfmdacJrpryx1e83Tn7QywURAQnDO9Ua6kaj/rWjGaWYqt80YHOBo/Ta0tCgbL5eTMWXj7ephF7zopfZC9Nrsx5zg4DNkUHAk4lWKhm/Mrq598LMn5kCKEzderoXvp687kmdyAuWCbxUHy8ls9cpR7yOteUZXQzo9YJ0sN+dn7LqR5g5kI3y1R1b2NegqMY2812/sWACkhohQoraIP9CxoIIzYaSHsV/06Z2h23/MEbX1RVWvd0YL8wnNl387ocw9xof0/TTHmscmw5vos6bLNjY6GeEbMGygfxPP2R417vepXwzPvKRj9C5557bNE8+//zzVXTe5QCvFBtYyM6UahQnkL8YrR7NRFbnopqa6masgF+qCz62UK6otvEiH6lZylVEj7XX2Qu/TATIeXDPvCIsYyNp2jCZ9UyjgTbB3LVWd5rEwK9eHL87X6JsKrEgCqttEyFMShCTxPOL2wZfb+TjZDPd6el2YnroRjfQglJP88W2/K9eJsr6GHMAJxsB9bo2zDJ6MW9RoPdN94tejHsv7LkcCVlXhG3XiJ7uBZ97lYNYMCTghTAHKuLFKiuZ6pg+pAHyIh62AD9LtXj287trKpZBAXIaZKFeCWc2ao65l/muFzCPcOhHRFcov35t0tU2k2CbJCfKRsUCs+cI7feqf5Chj4d+H4U+P8S9plsWdGI6rm+y6OlnBAIfCDEdMmDBjuBHeHH04L4EEVhCeAVjAYlCug8opvi7E5NRP+JhA6tUegRTL7LFx+ptc9UgRxFpmxloWP/EIEBZnClVafdskfaPE40UEr75HV2fwLqKXBtEQNCneCxGxUpN+TRy20EmihWX4OlExhwzrzJNEt/yKXRUgCY/gshEZ75cU21rfXbfXUXR9Z3kOdfJj9d14EcyTTNpqH6YNz5vMdELX94o914UUlss1wiXnh44yiS7uEdYMY16TwqWEcxFbRTVsxN4EY+oCuFSIayKzIFsAJvyapZjjnlUtZrr8FM12+bafU4rhbVNoTavhwgbFb1Qu71UyEG8Frzaze0NM15B91rYY7zGx9xkGfRxFAwEhJgOGQqFAiHDDwIGgJDec8899IUvfIGOPPJIespTnkLLAVig2kiVaTLYadlRFsCmAudHtrzMR73OieKfGASYd4K055I5GsukffM76qpbmPFwj2+Pymsz6+VXGBNQ/A4VFgFzQG45dQui6WaSMRV8SG9XOp1WqZ7wzkRHRd6t1CibTqpybnlgmiazCYrFXR/adNJti42IdqJy6mXoAZRSicV/jPaLzHnde1FIre4jq3/Pf3dq/itYRtAX/YuZxsVL3YmqEOoIIjBLQXD6TfBNhImuqhEY/XnudcyS9MNUIaHWwkwZbYg6d1HnvVfXSdRNhUHAMG0CCPoOIaZDhmc+85n0nOc8h171qlfRvn376HGPe5x6uO/atYsuueQSevWrX00rCaavo1/+yX7kWeymzE79E22mkTB51aPT9pJ8mH1jUqbnMfUyjfUrcz4N1dTNYYdzoEDGYvFmjlEdIyMjdMQRRzTrB9GZKzqUy6Qok4rTA3txrkM7Zsv08P0mlJmybnbcjbmt7g9ptguktKX0Lp5pb9g6bCbMfO0AnfoBY0ygbE82TMH9rqtuyK5XPwRDjrB+cL2GX+TRBelFQqaOCepLN321BfTpVYqbgBySVhNnL1Nn9gUtTBNV5omyq4jG1nq2WX+eLyjD7J9tLMw0Jn4bAmabw5Ig5a857yrpCAAUlZx6qvNe5uR+qW6C+jpgJshhrq1Bbr9gSbGi/4ffu3cvffWrX20GRHrwwQfp/vvvp0HGH/7wBzrppJPU39/85jdp48aNSjX9yle+Qh//+MdppUE3aWQlDeapNv87019ULwN+ig9NFxb8FgQENsoX3QBHQX53vVpocz/3zZdp23RBkQROJYJ+6H3wqp+B37ZNz6vz+Nj79+Tpvj1z1rHgdrtK4cLIqUF9wbmo766deWVuiyi4/D1HxeXPOqrVqtp8wTsTnfGRlPJHBTZMZGhyJENHbppQ5u4csbYbEtMcj70F2jFbUO88xi4xq/c0SrQf2JeW59qvDn3O8cIY8XWybbpIO2eLdM/ueSpWWhscUeCWWVO+052c3wnMseXxWKz6BT2EivQ5TVScJioXWoSGo3f2pHyfKLNhI4Pqi2W/KMIccbQfMNsAgrsgKmqIdtqgB6bxG0elGjZ8GL18Gblt87uISjNExb2t9iCaKyIJa/Xoz/MFZZj9M9vCvwX1lX832xx2jFithR8s8pRG8d9U53tEdfaq3y8KdFCbexlBOsy9EhRh17y2UNb0g0T5Xa1I0Pr5vY6ALRhqrFhievXVV6scWp/+9Kfpve99bzNHKFLGDDKQ/4t9Sn/2s58p9TQej9PjH/94RVBXGnRCxCaD6aSd7OlpT6IutM3FfivIS0wRIbz7kUiTyASRGD9Cyf1Erk74V0LN43ysJvH2q8clofO0d66iyAvXOVusU77kpmWxtQtqqS16bFAQJVbaduUrynyXFbdsyjUHdtOZtD7rmJubo2uuuUa965hs+LxunMzRUQespv2nxhQpxdlmKpmo4LGLI78tJdQ75nK+VFPjhb/1dnqR816QKN5U4bn2mk8mr7p6PVusUr5YUcSaHIfKFYcm0nHXJaADywGUOZpJqHylrML2g4ybddpS5wgxHUJgcY2FvlJGGikvQDr8SFLU8k2C40VS/BAmdQzKgU8qB4exAd/D37MTk2WzDb1McYP2xJPe7eJ5qtfcY1RU1sa7zRQa7cqtJcpMEGVXt7cHkYSDnud+6X70tuj+p3595d/NNkcZIyanYVIQ2c61Kb9e9fuliwnsaw9zi4a5V4KIsnltKasBbELN2jdQJDeqQMOKNeV94xvfSP/+7/9Oz3rWs2j1ajeK3AknnEAvfvGLaZBxyCGH0He/+1169rOfTT/96U9VECRgx44dNDExQSsNJkHyMxn0MlvkhTaIUpA/KC/A+W/U5xVtl8vG4tkMbhTkI+gX3IYVQy6bF+0wNWWCpx/bHlioRXh3zBQVYUHb1k1kmuRyPFslh+y5TrvxbWRSO5aOUZ3cAFY2309b+VBX9XfAK8hSW5qZDtpoBkjaNDXa1ibO42oj57ZxCROlOAi2wFpe9Tgg0ulWeyZGkrSrWqdcgmgkk6CJXCrURoIX2HSc69Sv036Yy3OdelvDBNgSDCj0wDxqoe24i/+mj2cPyl8QMAcRY4vRSUlQMB2d7HgG/enC5y8oSFHYdnbiFxqmb3qdaJutfZybtZtgPLa2BJlf6783zXpDzIfNpDjoeNPM1s/0tpPrYTH9RsP4W3NaGqq1csT6XVsoSx3X2KwAJEKvwAMr9n/1P//5z4qUAlC8AAQUKpVaaSkGEeeddx698IUvVIT05JNPVmSa1dNjjjlmqZs3dGAiEpRj1EbweLEcdB7nDg1DYrzqsyHM4t+sR4+cWqmg/AStG083iYY6fjLnWXc3Pn583uapsQVj4ddevKDgAogMHNT/KP62NkUXpuDwUR1BaOBGPXr+16iErhckKmxAKbee9IIAV2vH3cXAPiiqpTptXuWdTigKzOu0FyQ8DHpNfAWLCBsBUQv5ZG8W31aC47jKJitoC+r2IBE6SWESHUSOlkvwGM/clhHr6gWxCzvOQVGXw/gwRklR41X2YvlMRiXFYRCmz3xM2D7aNkEG4b4RDCRW7P/sW7ZsoRtvvJGOOuqoNv/Ngw46iAYZ//RP/0RPfOIT6aGHHmprO0gqVNTlgsUKdhI27YZNHQuLTiPA9qPfeuTUdDJLDsWU+axJznqZBkWP2Ls3XyS4f0LNNPNcMtnQVTcA81Pl8MV9BCu6+WJZjc/dO2dpPJuiteNZyk0l1bjAhBdBlcIQX/0a7oQo94Ks6abXwB1zUMtrtH0mpsyfu4UomYKewLq47yHZ8ksDYpoVmr8xScF5naaS6XfU0cUMHtPrunpF7Nh3EUhnw+faNBElRY1n2TGi4mwrbUuY4EeLNXbw94TpPNqYHvEPNOWb17dhheBpCt7wJUc5HDhKIu8KQmDFEtNzzz2X/vEf/5HOOeccqlQq9LnPfY4uvvhiuuiii2jQgYBHeOlAdN7lhDCE0WZ2GZXM2pTQbsuMGs10MREUIbUfaVB4LuEfuXce/p+u6pld7fqSmiqb/pmVyvFsmjKZDI1k+jdmPL8bJrO0fbpIqXicitUaxVQ0SteMWPmXFsOZqobd9PA7n82ukQoIhH7NWMuEm4m9LRI1X7eAbvq7cSJNu+erKlhUp+0BdNNr/o3NgzmFkBtQy/ta1zcgdF9VLgf3Cptk83XAkOi8ywy2xX0vCZCZBkQvt420GnUuICkRU8nY+sKfe6puRiBeA1AXrNSy2axrrWYrr5M62A9VmWp3YT4bNUWNtWwEJ0h0r94G1t3B2LG/JzZcsAFtNYkOk9e3YYXQ+P9xAXAOfEqVvyp8YHMSeVcQCiuWmL7gBS9QPpmf+tSnaOvWrfSd73yHPvrRj9I//MM/0KABqWHe+c530v777x947De+8Q0V6e5FL3oRDTPCmLKaC3+1kJ0tqv+Y9p/KLUhxslsFoKkrnzs9v6Wu2jEx08ucni+rQEOVukPVap3WT2ZpomH66+XrZ/Oz4yBLCDozn4j5+rOai3D+Xq+zH6pyi3Ake1om2gn/SOQbLdcSimwwYTJNXfXP3LfcmtV06qmn9qQ9fu3UCVcOAYIoRlNj7sIUcz5TQJ7VhNVU1ZyPbvxxTbNrBKhKJRHoCjleE03irq7R+QolE7EF1wai7+6eLdG6iSxtnBxRvx24boI2awp22LbxpgqIOfLHFqt1WpVL0aqcex+YBNzvWuf7A6Sz5tQpEYurPiEgM85DXwD8Xq7V1bsbsRmm3NVmcKx+WlIIFhm2xXG/yJZZrlm3+Vsv0tn4kd9eYFF9ELuvC2uvU045pb3MbutYTHLejeray3Za75uAsWN/z2TOO6hTWD9Tv37g+/R4qxxdMRUIfLBiiSnSwvz93/+9epnfhyGAi4l169bRIx7xCHrCE56gVN7jjjuONm3apHYckfLmT3/6E1155ZX09a9/XX0P9XfYEYZsmQt/KFpzZYeSiXZTUADH7ZtHoJa6Oo7VOn0hzdaiusKEYyESzZUqNFOsUToZI2emRGPZhX6jDDNiKFLJIGov2hMUZElvi74IB2yL/24UOVu9NqIbNqANFDJT4TL9cFmtRXm7866J3JqxjDJ1BfFBmhqQFD8/Tt00mMcmD9/QGshj0lU2y3VVDso2r4Mwyps6ZyxLO6bnVeRiqKhoOzY89GtLHzOeDzNPaDc+uWx2HY+lGv1zAxdxG5jIwSfWnL998xVF7DDOGIcw1w3KnSmUKakF2GpX0itqg6ZUqdK+OTdXLLAnX1LjjfMRFRl/e13rfH9ABU4lk+o6RznlGu4vl+SC/GIusRGA64nHV8+ZKhgimOaLYfIc9ots+ZW7WHXKAr3/Y7yYptSRAjktsV9yUNCrqH6mfr8jl60eeIrNfhd7PgRDhRVLTI888kiamZlZ8P2jH/1o2rNnDw0SkM7mta99rYoiDIUXRFQH0sdg9xGE9KlPfSotFwQpgub3ULRASqBymYthHLcql2wqpmZkU174ZgwigTKB8Wyccpmqq5hOZHxzduqKH96RhqZcddsUxtfQaxFuMznWSVEvTI1t5Be5L2HaG0SobQqXH3nPl6qKlIDIgPDB1Bd1FPJltXHAiiBehbk8/fa3v1Um68lsrmkanE4mlKINdQ4mwoVKTZmHPbBnnkZScVX2QetawZZ25Uu0J19USiTmFqqf15xgQ+Hu3XOKEAJuBOaFKrjeT7zjcJQP3S+V6Hxe/MyuzeBGptKP1+bVI7Rjuqjyvdquda95KVYcilVbijWfA2yYHGmonfFmuhiUFYvFVZ9BJEFqMWgHTNl9j/i+2DTFiyO3j6tHXQLKPs4g5bofrJDRIYapEup5Ds1FcphFaygfuKhtXKTF8lITE4a+OWD6/0UdC6+NBluEWyK19uLnuTWbgK1+rkN9lySqVVtqnI1o6deIMt92iGLz7Sqgl29llGBCUceqk+sM+T/ndhKNrnPPgY+oioI8Ge78burupGyedx7rpQoOJRhKrFhiChMzE8VisRmhd9CwYcMGesc73qFeUEnvvfdeKhQKtHbtWnrYwx42sO3uBlEVQUUaphppCAzgfL9gL37KWVRf0IXkxVGKaRS/Vy8i3iqzRUTMVDQ6opj72giLUuTiRJUqfve/xvQ0LV7kh1VVmMmOZZI0i4BCTpm2TbumsxgrNvMFweP5x/2K+xPvumkw3nF8OgFSjBQ0KLNCOaSkcRyVOoXHAGRob75E+VKN9s67quBYJuEzHjHlZxpz6tQI0GsFyLVuduwqsu2+mN3Cyz9Zr9Mcb6/oxH7XAsrF5k4y4ZJO2zl6lGKum88ZzUDtrDXnxnbtBd1TtijWgiHHguBDFaLKPFF2lbuAZZLBaSiwaEVKGZvqpIKq7GvltQwTkCgU2Y0SudUMoBTw2e88C3HrGFGIh7k5oPc9KnHw2mjwiHCrP8/t/bDU36xjnmh0yr0Gko3rxUpMNT9JXCsIRpQdd4/3umY6CSYUdazCHq9fG7MPETk1l5ymckT1coOcRiWmfSSEetmYI74eRvgeL7p9UmQ1IHCSYEVjxRFTpFQBicND8TGPeUzbb4h0+6QnPYkGHci7yrlXlzPCKoFRcyfqQVy6MbVcyrQWYU0bg8i9jTywqSt/N5lLEzh9UD9MImSrj1VVKhMdtnFCBRaaLdaV7+lYFr677Wpgk/wYbTbNZfV614zVafVYpmlSCsCcFfc9yC8ee2PpBI1kUk1F3IsgPXzTZJMMegHm1mGVTh2m4g0TWhC8hCKFsQXEE6pwuVpTx6Qmw+VQjXqfhL1eF/rj2oMbQUXF2Lumwe1BkPrhIy0YUJjBh0AUMuMtNaVJMuYbhFO/4z0WwMV5d9EbJi9pmAV5FN8/s7ygz37nRUlNEgQV2Kbk+g4G+caCFNgU0078IPWyTLUySoRbhlk/R9sFkeU5D8p9a/pJqv8jnHaVPajeMGMRdazCHo/xzO9ojOGIe0+YimlUBNXdjaKql52OGddWtUWquVzc50oBHxALAsHAYMUR0ze+8Y1ql+7Vr341veENb2h+H4/HlSr55Cc/eUnbJ2gh7ILVL3eibTHOQWXw31Ol4fug+0L2Y5EchhREVTd1Igk1jYmY7hsYRO5tpqj657AkKyx0VdX9nKVsutqmPNr6aJvv+/fOKxPjbDJOW9eOtamWrtmt2wdFYh2HyjVHqeb6mPiNM34zFUc3UmyJsqqumFJgQSQ3TraOQ33sV+yXH1cfazah3TdfVgGFZgt1tSFQKFdoNWRIIuWzCV9SmNB2oiguVo5RBo8954U1gyB5bZro3/PYSN7SZQRbpFsmGSNQvhoqmh/hADGB+gWTzjCqSxgyEClyqxlAKeCz33mdELd++BrqfY9KFsyymIAzgeyFTy5UTlVPSJWtowBKHQQTilpP5HaBVK9rH8eoSmnYuq2KcUO5xTtHqraZQutl4928HnAtQEXl6xybULwpxelkBIKVSExPP/109X700Uerl2A44EfszKiuQYtxpT4VK4pcQLGDfxwTgDAL/k6UnjCkIKzpsqn4KmI6X6EH9s1TPBanDePug58JE48PSJWezoOVURBCqHA6mdhXKNMD5ZryT4SqyMdyWUzO1hpBdfRxsY2Tqapye2Diixyh/J0fuA3pmEMzMPOtOYr86P6c+lgC8B2eSLaUvU43H+DXOl9BQKyyUmArdaIkTKw0tPsVe8+lTpDZhHbtWFrN21jWbSdMYmHWzL7PkyPRoumGvU/6AX1Tw+af7LVpwtcgRnW+XKN4LLao7Rb0Gd1GuuXzI6lUPVZlzPKCPvsd14uovwxWqJY68mmvI+QOUsTdKOhGgcRcjq1v/b2UaZugwsP0HopnJ/l8mXjq5ur4jk3ym8qpBEMSrDBi+qMf/agZhRc+mnjZ8IxnPGORWybohtgFmSbaIvTmMinCejiXTqnfmQCEWfB3Eg3XzctYUSSKCaLXgrzYIJ66iaRJ+HbNlmi2WFHBaEAOVTTTOiIS12kHSGMqSXFyI5uauUGZmKIP6DMAco7fQBpRB/wwYTpac0iZYeJYDuajkzOYZ9rIoK6WoW1Bqqsb/RjRXlsKtj5Go6Oj9PjHP169lxtBdddNjtBo2fX/RB2m6qZykSbcdC9Q7ECmGegD5jyqGgxFWvmwZlPNv0HQAX3OwvgV28xhcW2gbTFy1djZUpU2rRpRyrJ5TlQEqY5eGy7dmNzaVOcwvtR44VrC9cZtFwiaEPO/wR6XgHboz/NelDew6Mans9ebFh0rxg1Vn/PDdpLP1xYJWN9gAtmVYEiCBlbU//Zvfetbm8RUN+PVARVEiOngoVO1J0hh7cREMIrvK/wG3SjBSIGSUCbEprqnl4sX564EZ+KFuWleC0VO+UorMjSi8lRC/Z0u1mg0FVPECMqbLTeo2Qfbb4hWCzdHKKZMZPk3EDqVcscg1+a44G+YF4eJy+WqsiU372Wp1fc238vUKM1V6vTA3nkV0ReE5+B19mBXKiBP3VEBkDg4D+YBpM/93aHd+XKb+XYYAoax2LJ2TBF63bcV48dz1I3ZKUcm3jNXpj1zRarWMKtFWjWa7TogEFsdeJmte5nQAr1MSxTG55vnw88UWiBY0TCj1JpqU2HaVaRU1NqRcJFm+Rwz4muPo7kmk0kVuLFn6LZ9/YpWO6xK72IRZCbC+vgLVjxWFDG9+eabm3/ffffdNIxAJF4s3nM5d/fpnnvuoe985zsq/c1TnvKU0OV84AMfoG9/+9t022230cjICJ144on0wQ9+kA4//PDmMQgQdfbZZ6v8qKVSiU477TSVrga+uAyozvDX/eUvf0ljY2PKVBpl4z+eXqKXPmbdlhXF9xV+g6VKhRLxjEp/AUIJpTMWc01s/XJX2gISMbHY3Eivwrkj8d34SJricSijDq0ecwkln2/22S94DT7DF3OjxY2Fycn+U6OexJqPcyO1tr5DO5EXFOlXkBdUNylG3koojIjsymWx6qn8EwvzVJneSev325/2zFXovr1FVRbq4ByjZlvgV1rndo3Emyqpqq8RGZjzjnJ9HOEYL6SVAZnl3KE6YTLNlwH4u8L8FGbJHJk2qiKLc9DODRMZijmOMqmGaTZfD92ol6yae5mt632DcssKe7+j5Oo+37xh040yLFjG6JRAhD0vSrqQfpEZv3L138wotaYqB4KJ6K1zMMHcP1ykWT7HjPiqH8+fu+g31jF//etf6cAt+9NIvGaPShxlfLuNNtuvaLX9VHqDrku/VEpho0Gbx6nvepg6Z9gVcUFfIP/zE9G+ffvo+uuvVw/LQcczn/lM+spXvtJs9/HHH08f+chH1Pef/vSnQ5fz61//ms466yy65ppr6Oc//zlVKhVFbOfmGg8hInrTm95E3//+9+myyy5Txz/44IP0nOc8p/k7Iqk+/elPp3K5TFdddRX9x3/8B335y1+m8847r8e9Hk6AeGVTMZrIpRXZZPIHM1sQFz+/PChxrBbpxJGVK/yGPJF6vlAAalulocryd50qWLbzWVUDcQEB06Pj6sDv8BkFWeO2q3Qt8zWaLbnmqlwW/lYEvtpSG12ltKLGDRsxaarTrgfvJadeoVwyQWPpGOWLNbp/z5wirzaMZpO0Kuf6wPJ4cS7STatzLpFvqLloB8AEEJFk79s7T7tmi6odumKoE37uA88diC2CO2EeWJ2NAm4nNgYO2ThBjzlwLa2fzDXrNH1nowBloNleZut63/hY/XO/iCJvxpjm2ALBApgEqdfnYRFeyrcW437n+pWpB4yJCr9y9faBKMQbwZ+QekMREQ1QueJpN5JrpeSqoSCxegApU6Hic0yFTD++0znQu1Eu05133knlQiOKMF5RxrftOE4/VGr9HRVe4xFmXruZ6yB4lc0pk3jcMK/TD7r5TtVrB9HMQwuvZf1c/GYbdx04t7DXPVaZ3BopYfI7W9eUKrv7a0MgWFGKKXDxxRfTwQcfTM997nPV5//5n/+hZz/72YqQrVmzhn784x/TcccdR4OKP/zhD/TRj35U/f3Nb35TqZcg1d/61rcUIYR6GQY/+clP2j6DUK5fv56uu+46lTJnenqavvCFL9B///d/NyMVf+lLX6IjjjhCkVn4h/zsZz+jP/3pT2oM0Q4Ek3rve99Lb3vb2+j888+ndHrxzDIGMfWETZllRQzvUWEzIda/08lSN+Pg50PL9UGpZL9Um/KrTG/jbtoTXbVdnUs08o2mmmXhbyimnDuT1ToYsYJcrpvI0s7d7n90yXiMHrZxgsZG0rR9b56SqaRnjtFUIkHxmOPZBw4oxNcOfwZQdzbhT+TM8eexQ8RhVkw7ha7Eol1e9XVzPWLuHtiTbyrYurobZFXgFYxM39QIS2h548AsHybcbpoZMecVdGka2Y1JZdgIuz3zLQzZVvbb47yvHM2YAcWTVU8QCPhUcM5PL4VKPycoSm7UsdSVvEpDBIinEMSg1W/bOOD4psmyRx5RFUAHUV4bG76sKLNqqMyZc+FMSoPqiprntBv4pR3iPL5oqyKpBbft2KRIptzd1oxHmTgXRBy+o0HziDnSSTvPvVLXjdy15pyVG23i4Ee8oeI3F4IVj8FYwS8iQK5g9qqnjznzzDNpZmaGXvva19I73/lOGmTMz8/T+Djyv5EihlAwkeoGRBFmvZ0CRBSYmppS7yCoUFFPOeWU5jEPf/jDacuWLXT11Verz3h/1KMe1WbaC3NfjOUtt9xCi4kwSpKfErhY0JW7qNCVU9vi36a2dgKc50fEUB98QllRM4F2gVBkUvBHbSc7B66bUPlLuX34Dn9DIeTAS6zWIeAPvsPnZNxtC95xPMo49mHr6dCN40pRNIFz4Ce7plGmrQ+mKTN/5tQ7k6NpOmRDq606WbSVxX+jzWHnmFP94KWXzWbF5gZDL9VLU8GOei6b+pr9gfINP+FuVHs2g4fqvpT3q2DAYEb27PV5OCYz1h4F1etcvzLDKHBMgthXlFUxv3Kt7QtRl66uLtUcMMlqEmmUlWz4s1rShXA9nOvWS4Vr9l87n82ckTuTyZNv23gu5kLWlY6utnYCr7I5IBGPGz6rCIUIfrDazXuKFDMgrqaKzOdyChq/ecT4ozwcy+Sd5952TZlzpsa/YRreND0PmAvBiseKU0xhjgqCxf6Rt99+O1155ZXKPxLBkbZu3UqDjEMOOYS++93vKpX3pz/9qTK3BXbs2EETExMdlVmv1xVBf8ITnkCPfOQj1Xfbtm1TiueqVe0mPSCh+I2P0Ukp/86/2QBfVbwYILG9gJ+SpAdzQX7uMFFiB1nN7SQqsK5yQc2EqSn7QJrtC9NOm1LGZeAd5sq5tH80VdtGQZT+6CSN84uCEMPvVvcH5WNtKhxHwdX9QfEZgaOg9upRkYPGnMeAX2F8mW3+ldxeva4weXCjwlSwo55rU8u9fKQjk1J1rzo0lm1FfRYMHiI/z73838L6VQb6GhrHBpWr52dsplqJ6IPaqc8cEzUoXFHTb0Sti/NKtpG3BiHmfoM8oH9MVnRVlP/mMdNVL90PEfOKY/n3tvFKt34rzkQY0xhRcbZRdmUhKW7OM+Yx7f7O5qpIb6L+0x/196vkuVDVGUTQbF+3qmiU69lWn+18EPyJDS4R1QEFGea6UMw5B2yUPvgda4u02zyvMdcwI7cppgKBD1bc//ipVEr5NwDXXnutIqlMvjKZjAr4M8iAue5b3vIWOvDAA5V/6QknnNBUT4855piOyoSvKQJDIchRv4HASJOTk83XAQcc0JNy/ZQkJhVuZNbFRzd+gVEVzTAq1/aZUpsPZJT2oQybb6lJ3MK0T1fXoIzNNVQ2tMtU45KpFK3buImKtRjdt2euqTBynZzCBuQUOV13zpZo23RRlc8E+P4987R3rtKmwiEyL4JR4Z3hmhm7QY8YYfqk+8za1MQo/pXm9eylUHYDU8GOei6r2Tp6odqrYFTJpNpAAPTr0uv6EywNIj/PTdVMD6bj6a9pBt7x8emzBenxKxeL9nIIXzuv8hf83iBE8PNjoudJhqFy1VyCOLu9Zfbo56vo639q8fnzO09XsJTPIMaB26Ad3+ZXaFG9dD9E3bzTrJfJfzpHqdyEulawHgv2S0ReswRRreg9T6gvxpsdDRIOk2QEhcK7IsmN+TbLYFKLuVDt8yCtnnMe0a8yiu+s1b+00Q/9+mJllduO8QI4zQvqC3uNh22P333Icz22lmhqa2sOoLyKGa8gACuOmILIXXjhhfTAAw/Q5z73OXrqU5/a/O0vf/mL8rMcZPzTP/2TUnp///vft/mJnnzyyU3f0yiA+fIPfvADFVV3//33b36/ceNGReARYEnH9u3b1W98DD6bv/NvNpx77rnKbJhf9913X+i2stnjtul5RU6wQG0F/amr7+/amVfHMPD3PTtn6Z7dc2qhO5ZpKU66Ysd/86uX5oOdEsmo6iv6yqTNBjaRncwmFBkD+QrTPt3cFLlYbQRJL0M3ObaZqernqKBQmQSNZpI0mkkoggZCaJoJT02O08Mf8UgqOQllZgsiiTIRXAnl4BxEsYVPKSwAlAIZdyPlslrKgZRQV8vvFe1Ge+O+5tY6UTSVXh4flzy6PrNeZs62MUA9QSROD0bkNz/LweyV+wo/X/Na6wdBF3SOyM9zJmNYzLIKphBbGMCnqXDFFvq4eRFV0/TRz8ySTRrTY+F87fTyatV2EshtQIChmQeJdt/ZIA4+AX2aahQc6hs+eUGExa8/fqaStvN0U0ylNGIcRlqf+Xj9by+TYPZDVMGTtN892ousAkcddZSbXSDIFLY5T+Pe82Q1K7VcCzjfLIN9Lr3UwTDti2LKGzrQkgeB5XtIkfXGb22Kv0ZSMR8gg5mQ17h+Ly0gotqmkm72zH8HBX/iTRudUPczcJRgaLHiTHk//OEPq0iyCNIDtfSrX/1q87f/+q//UoF/Bh0gfSbxe9zjHhepDCzQX/e616lUM7/61a/ooIMOavv92GOPVbuZl19+eTNQFMyeQYpZpcX7+9//fmVGzIQeEX5hUqz78eqAKo1XJ2CFbXoeOSPdHJU6Wdinvod6Fmszy5yvOhQnLGQzC8xPdaUQZeeLFcqmEioHJvKO2vwToxLMTk0abfkdeQwQNRaA2SqTGs6BaebnZOhmoCP4P6rxk272yqTWjDzbMjeNKWKIiMx8HJdhkiacBwUUKrVX3tawSl2cHCoV5mgim6T5CubGjYALMox6ZkHK6g5NjmQom4I5byt/q942BFLS2wkf1ImRaCbRpjrcPj4Lx6EXGw+m2TKbH+MzrgWMc7Kx0dCtmbp53fF3vTJF5/K8yuTrVDdf7jafsaA/iPw858U/KzpNGxbHNWfVbVp4IcyLbFtwIF7scnk2M08vU0S//Ixe5pZcHkipHvilTWGstshrUMAkJoRsohpEWHxNK0e9TSVt55mmmCAw5jnm36xGmvUyIQJqyfbjLe3F/x+IlwFimggyLQ2TR9NmVmqWq5fTFuQoINhUGHPafqRG8Qy61eiHV5v9+h0Ekwy3baJwYKNau9kzfw4yRWelV29jPwNHCYYWK+5/98MOO0wpo7t371ZReHUgZ+diRpINCz1FSxCQmzSs+S4i7n7ve99TwZTYJxTmWMhriveXv/zl9OY3v1kFRALZBJEFGUWgJQDpZUBAX/KSl9CHPvQhVQaCR6HsTsmnH1hhm8whnYjT9CXk31blsGh1FSsG/oa/GnwGbWaHph9fJpWgYqVGiXisGbwF/pLFSlW99zOfY9j8jmgn2oaXTs454i/Io58/pNfi3otI8rjzuURlyhdJmcQCXuOCz1BA+e9ukM/n6bdX/YYe+/gT6KB1q5vtBUDM9mJTol6jaQR7dFphejnXK5uX8nmmX2tU31a9v/r4dLoB4aqdiCAcWzCe+HtXvkTzJVetLlRqNJJKqOOB6fkizZRqdMCqXF+uO6A9JdHCKNBe3/HfgC3Njt/9ZPOn7aWPrWCJwMoV/83v5kLbb2HOi1iQCz06aa8QtGA2SSC3temfqflqerWdP5uEsFP/RD+fv14giKwDuurrQzTwPL/iiivopJNOUmuNrsH+sqptyWBfZX1+bYGcgvxAF4NQBW2q9KNe855r20TRIher7xMtP3EmrOyv3c19L1jxWLH/w5ukFDAD/QwK9Ac3lE6onPiO09oggi5MbqMQWM55+rd/+7cLoha/7GUvU3/DNBgRf6GYIsAFIu5+6lOfah4LsgczYKSoAWEdHR2l008/nd7znvdQr2Auetns0QR+Q2RXE17H2xbTHAgI5r560BxTGex1MCMvsHksExD+jvsD5VIn59xXvX02eC3uvYikqWziXPjrIr2LPi628nodZAqkTSeEvJkwkqxSNjeizD+r9Rjtm69QjGILlHWdFHW62eClZuom4YDp8+x13eA7+Nfi3o5RXKURbPpaNq43/Aa/WRVUKZmgCuYqgX5gA4VoDdTTRq5cc/6jXqsm0cb5GCsu2ySUft/hvHLVoUqt1gwIpSv0fm3qR8AnwQDApuDYFtqhgvpoC9ywC/UwwWea6UY8FtsmCdTb6kUObfV6tUX/Xn22ECq/4E5hA+wEtQnQTTtVkKbGeNjKDhq3fqFpxjzv+pXaCGPb2AUQoiDiuVwJlW3jxOsY3oTgiMhBRD3sfS9Y8ZD/7YcAIIsM5Ah93vOeR5/5zGcUMWSzmNe85jWRovJioRuEbDZLn/zkJ9XLC4hi/KMf/Yj6hU4j0HZSbtDiHYvk7dPzSpVdPZpu81XsdkGNduzOF2mmUKXxkRStHcs0CQ/aqQPfs/rH55omuHq7wrYnLJEM0y/TDJPJWr5QXpA3M6h9+G3ffMmzzdhIWJ1Lt0XezSKohhqbdmWdz2GSxJ+7hU7EVNR+i/my17WMv+Ffy5GSWdHWj8W1NplNUqkKH9kErZ8cUb+XKlXamskRKO1kw7RXPxeIev+Y1wFbDehjZxtPrzGu1mBanlCbGdyWMClvdH9Sk3AvltWCYMDRycI2jNrF5fZSFbPV69UWT5NKi6IVdH6QeaVfmwCYX1bmXT9SpUzHvcvux7iFASvYIzl/n+Kw5redmPd2E313MQHyDvN3tAtBiayKsEfE6rDqqheibM4IViyEmA4ZvvjFL6r0NkxKAfwNk9sTTzyRLr74YlpOCKOshIFpvglEDUiEBfJssU7VOnIsJmhVLm0lVeaCOmz74CM7X66oTQMmGWH6z4obVCnAJJedtCeorfrLRijNIDX4e3q+rNpZpxqNFFzzWjdoVVEFDQIxM32AcT58ZqtV+0aKnx+tzVSWx9V2bjfQiZiptpvH2L7XNxrMY5kopta5pFP3Nx7L2PO02hTTbvvGbbHV5/cdn6//FgamyXm/NqkEA4BO08V0tKhtBFoyfTEXpBPpsSoWyVzZY9G/QNEKeX43beLIrkxQ9PaELbNb6KltbIp0GDPmKJsYOknXP0fBoPpPYhwRfblWIkqPeJsqI8pyacZNuWMzTfdTV/m+hJ+1bi7N/uBNNb0R9It9xAdpnARLBiGmQ4ZqtUq33XYbHX744W3f4ztEI11u6BV50BUtBM0BETIjoQYpMlggj2er5FCG1jQUTRAek/TZfDj9TDx1H1mQ5fEQ5EkPgIPy0J9aDSaTC6+BXgSM0ceGxxL1p5MJFanXbKtZJ/6eGktTOlFu5s1sKr2O4/qrOg7NN75H2YiinIzHCFalFZi5qnQALfCmgJcSazOVnW/kJu2G4NiukzDXaVRzWvNYk3R7lWUzNe4GYdoddO/Y/EyDYOuvkNJlCr9FfKe/ecISaMkWnMWmEvU6t6kXWQpjUhnl/G7aZAucE7WfFsBNKDT0iMPd+tGGNnPukFjquXqjROuN2r5Oy+Scrhz4yW/zBpGOMe4cATi0uXxj7EBEkw3zbpyL+0sFM8u1cvjivThPZGzOClYuhJgOGc444wwVlOjOO+9sRuJFPtaLLrpI/bYc0QtfM13RUkTKcVRAGQSb4XI56AvqsqXvUMdNjS0ot1B2A+ywT6Duc4iUNlw3fO1Qn1eEWvjIbgwZB4Ij8OLdXezHKBG3L/p74aNnqlV4Z3Lp1FxiCf9UJoVmnfy3rgxivLBJgHQx4JwgufgOvrPoW7UGMpuhdDJN+61aT4dvebpVlbUpsTp0U1ldbeyUsEVV7laCCarfmNiCeEUtm8sVX9NlANvC26ayhVngd6LO+amMZnCWYVLGOiE03fqohimHVWg1pm6wHMTI+Pu///vwfQOZAsnhMrtqU8j5agb1aah6ocfCI5p0WHiaZ2v3QzPoUMVulmsqzGawp0By77i+upzblesL3YdqY75iRFUEBcu1csyq1D+jrbagndnxhRtFghULIaZDmO4GqWI+8pGP0EMPPaS+22+//eicc85RUYWXE5CX9IF9RYpTndZN4MHWueqnkwJFdEtuQJfJhjluK8hLTaWLCUs6cMzq0UzTt1D362NFEcR1LJuieAzkbWEKmk7AEXiZHGZSrmrKPoZ+JIj9MOHzBzNwzmfqR2BtZE5PXwLioSNIIeYyAZij8vF8rNu3VuAq/IZ69DayKmtTYk1TVnOjwWtsdLNfldKgXFfl64Taj9jq/dbrBwFfzmqf35h0E7UYc7F9ukhj2aQyned6ljvRX3bQCQpgKjA2lS3MAr+5ENdMcPlcLyLhpzJGSR/TrTLWa3RCkLv1UQ1TDqvQzeBJHRB4RaSc3rQptJmzEeQnbL3dmjJ7nc/9Qf5f3D8geBhTm1muqTBHbVMnQcV0qDFzraBofIOWE1cLmqXf+8sxkJSgYwgxHTLA/OWtb32res3MzKjvogQ9GiZsnynRXMn1uVw77qpdvViU4rwsLFqSUBldgsPkIZeObnJpC6SjK4qcb9LmDxgFJtlj0tbyabRHTTWBMooVh/bNl9Vif7ZQbxJ0P2KqE3u9DpdMLgz0E0UlM0mxqXru3jtNf7n1Zjr0iEdSbsOaBeeYSmynwX90s9/tM0UVdGhPvtz0h/Xys7T1Ww8aFNWfedjgNybsI8uIcg9jgwLIF6u0btydY06XpCv0ggGHTlCaPosd+D8Glc2L3V4pmE1fucpCMq189Upuf8LmiewrPHxn/dCtj2pkFdpV3mZnZ+n666+nY445RqWr66qOKD7CnajKkceiy0iz+vlt7eV2NIJLAV5muQvSGfUp16rf+SDL+r3erdm5YMVAiOkQY7kSUsaGiQxV6w6tySVp4+RIUw3sNgCKTqR0IqmUxwg+cIDX4rofJMSL7JltCBobTveydiytFFOoUfx9J+qYV/CbIJUsiklsOkE0n59V71HbFzUiLZv9bl6VbSqmYdtq63fUa2q5I8q8c05i3txhiNHXkEEnKH6+m6YJYliFyjTB7VaBYUJQmCGqFd3obciPyQRUmVBOu4vvETevct+xgHgZ5KVc0KLp5roL8tMrIuOhQtfr82pjPVJcDK86+JpRJrd59/PYeqKxtQuP99pMYJNYDvLjlQposaPKmia4ivBVieZ2YhCJxkaJJje1b6Dwey8IX6d94zGUSLuCDiDEdAjxzW9+ky699FK69957qVxu/IfSwB/+8AdaLnB9Ltv/g+1FABQvIjXo5CEM2QvTj7A+p17KVpg6TJXM6xhzLr38iVl55Pegcrn9Uf0SbRFyuaww152t380gTxGD/3QCTjsEQr1mbGFe237VrQfj6mTevWDLQ2xT6AUDDpOgeOXp1E0QdRO/oGA7tvyIXljgf2cjGw1CoCKGQomcJ8qsbRE4vKtIoouo9pjKsNnWZpt8SKxXud0qzEuZ8oOvGZiNgrQhqBLPk9k2Lyhin2/MeconF22ElD+9gFX1LZMKyqA2TDifbbk9mBCuV0TT7Zacdto3rpevQyGoggiQ/9mHDB//+MdVkKMNGzYoUxgEQFqzZg3ddddd9LSnPY2WI9iEtd10dOVdukx6bIGZ+q1s9QO2uTTTzES5Nsy/e9n2bq47VrphftqvsTTTDsHnmc1g+z2PZjCuIHR7D6/kZ8Cygb7gNVUhRALl4Ch6Ps1eQSe/ZlsYWEjDBHFsHVFmgmhiv1a7+PfMmKuWhjWd1XNDev0O1S6/s6Xe2ZRhvMz0Liq/qBZYBmruzIONcgLGj/valcLcw7nyGiev7/maweYE1MPcGmMTxLi+MG/mnKlotWNEyRH/+bSNVS/Gz7M+S3RofFbtHG/3BWVfbHUNjC28Tjqqv8u+9eseFixriGI6ZPjUpz5Fn/vc5+hf/uVf6Mtf/rLyNT344IPpvPPOoz179tByBC+smawUykjZEmvmpNQjxbaOcXN6xsihPXNlGkklaPPUqDrujm3TdOfOPE2MJOnQjatobSP1i5cvJ39nM/01Pz+0J0+7C1WaSCeUmSxSnsAUNCyZ5HK8YFO9oipiYY/vVp3WAwlhrmz5RfUX11N3HBpP++/O6kQUG+UIWrV3rqSuE9SDKMl4deOD6BXAKSiwk9kfHFuq1FR7uiVTfnPHv41l4lSuxZtmsDgO8wDzbW5zr6EH49Jx/568CmAGs+j9jYjWghUMvzydrFaFUbo6wQL/O1suzwClyS9QUqfqEyuiXmqXV518HNRSEFSl/s25hAIEPGyQn27QbcAffa6jBmQyc5iaaqfeNj+TY2xCBMF2fr98JL1Ub1vO1rY2dJlOx7PcTs7XIhtzVGW+78Iq+oIVByGmQwaY75544onq75GRERVEAHjJS15Cj3/84+nf/u3faDnAzNOJBTeoJpSnXfmyIqf3OkRTuRSlUwmKx2KKjMLCpVxzXFOAGNGOmSLtyReoUieaLbkBVG5+cIbu3pVXZHVqbESRJn1hj3pBdkAkEAnYDYgDclFv5sk0VSiOwvvQTIXmSmXa5RCtG88of9BMKrzCw+VC8YLZqv6O4Ey78yUqNoi5rS3sh+uXXidquhNWIaOmnTHzh+pEl/82oxcjwjECUJn14Fp/zGMeo95bZVdp5wwitqYoX6xQoVKn+VKFaqgj6ZrjdhPFFedA5YQ/o246avr68hgBetohzu9aUWU4ker3mkPbXCPCsvubQ4l4jMYN81euMxZzj+8HMbWZ3AIgpdg0wLsQU0ETNtJlol8LfnNhv1jBV4LIGyuiSqFqRC+NWjb+lwR54z4u1qI/4hiaz/N20tmjgEwdtq2n6CYdj5fp9jBBj2xsBigb9r4J+gYhpkMGpIqBMrp161basmULXXPNNXTUUUfR3XffrQjAcgGbBu7Olyk1qUdCrdJoOkH75soUi2PxH6NxB6QnpnxM6k6MJrMJRdyA2kiC9s3HKebUqFRBNM8ajaURIRe+cAlVlkmSQHLLtRqlk+7DEoRw33xFEVn8zuqnqZiCRO83kaLdhVibYorIrp1G+TVTo5QbxDydijVzdjKZZrVKN4e1kRCdrCHPKpMfHA/iC5V5quFnqRNHPa2OTi5N0ofj9uSLTdUa48Df62lT+HyOXow53DlTaFMW+dh0Ok2bNm1q6wMIDyKzog/FUoVmK3UazyQol05QMu7mp/XKwRpWMUb5/DdDkeJihbJaTlQzKJUi89U6zRbKNFeuWv1W/eA1h+Z1xxGWp+dLzU2M9NTCHXOe38XOAwqllBVTwQpGqIV4D/Jw+pXRyzyfnQBl5Xe5f0Od08mx7vfq5YsbpODq/UcZA7zYN5/noVXNYfNb7CYdT6d5dXtNlnFtqlypDcU+ypibKZXUZ2ziOp1twAhWBISYDhme/OQn0//7f/9PhVmHr+mb3vQmFQzp97//PT3nOc+h5QI2DQRZYVLBKVLYVHOmUKVSuUK78wWlks2Wqyqf5yM2TTaDJq0Zy9DoSIZmCy6RAME6dMM4bZoaI6dWpZmimx8T5brEK9ZQI0fa0tNsXj2iiJZuHmkGBAImN0+p905VOr/jm6audShwsWZbUA/6xeqtFwkxTVCZ/LCyh/d8qULkIJ1OtUl6mTjyeLBZNZMkM0cnfpst1mm2VKHJbIrG0glFmJBnVU+bovcV5PKe3fMUjzk0kU3TSIP08dzXqxW69777aNXaDZTOQFVNqrndNl2kSqVOFYdoIoPrIkmxeFxdH3oKH3MTwaYY66bHfrld1VhkUirVUDPyrkZg2Rd4tjBHe+fLNIq+JKMFYbLNoe2a4gjLBXWfJCnRUKZt5S02KQWgkrJSGiVAkmCZIcxCvJNAK+Y5fmX0ovxuADJVdi2cqGyotmbeyU7rHxL1qVQq0QMPPECbN2+mTCYTrd3WAESLGHwpSl3dqL+dmIvb2rfgc0SyrNROzpUaMlK2Wabyf821AjQhny37zwoEBoSYDhngX8oh1s866ywV+Oiqq66iZzzjGXTmmWfScgGbBtqioeJvN2Iv0Z+3zVCpTvRgfk6llnEcqIdV9RuAxThI5rqJEUWKsNgHictUa7Q7j8V+TeWphKKFchPZtDpOJzVRI7t2Yi4bJWKsqb6ZJMbPhFdX9vi8BLnkH2QMSjKoOZsee/kxQgvFObYcnTh3PAvfz2RDVYypY/zSpmAOwAWni1VaP5FbQCjn83N0+2230SMeM0FjiVSz/Yg8i//s9s5XaDybolq9Rsl4vOlPyeWY149tXnTTY7/cruZ42yLx4juQY8wVfGZBoqNcB16E2Lym+LiJkbQy6U1GuFYXI1qvV4AkIaYrDKEW4hFMNU0lRp1baQXGSVsU+k5MQbv1ndTbq8rzWJCbfq+2/pnl8e+N3KCRTUXDEBr2A9RykAaWF6LuYrFIf/rTn9T6RRHTKG32ilQbhcDr48eBeQKjF+tpeWrh8tcGqb/98EUN2qyJSpabuVI7UDdtvuTqGm9cSwKBBUJMhwzxeFy9GC94wQvUa7kiaNGMwEIgIQetGaWZUpWSCfiNLiQJekRfkAqoNiBg00U3OJF5XC/a3UtS6gebH6IX4cCmBsgL/8Zmp1AzQRbWjgWnQ9HNYW1kU7VnaiwS8eE52H8qp0iW3j4d6YZ5rU7MUqtydMCaVl+CTFZ15VT/rOcw9cvtGlZ9RD+YKPZCrfS7pjqpI8rmSdi59DvOK0CSYAUgzEK8E9UMpK0ZWAU7ZJqPZtjy/QiRX5uikD8cB5WI/T6D/F7blCbteD1PJYIdsfoUpH6ZKXK82mgSGvYDRH22esKUExZhzzPnhDckYCKKXLNMoqx1WMYPddrK9Wsfp+XRy1wK02KO5KyIaWOnGO1Av7yCe+n9NNtuM39HuTA97+Q+CONLLhAYEGI6hLjiiivos5/9LN15553KjBfmMP/5n/9JBx10ED3xiU+klQSbgmiCTVh58c4LeBCx/bXjoihHfmaJi61ERSEcYw1FWCdnMMU1Vc8ghOlblP6HmUcAgY7MwD6mWhs2R6se6VmHLYJwJ+i1+WzY8bRdf7bvomyemCbcZlvMKMnYPDDvC68ASQJBJF9Rc7GNhTnMYKtQvpzo5oH9JlJme33LDFBKOYgMk28v9cmsD+dVCi5BRUqVoDG1+jiGVLk6DlLU4XlMFJlshjEXB5j0s2IaGL240T6lkmpj0Utz76ho9r3qbhwoOI2/nRCbKyEiRffDBF8g8IEkghsyfOtb36LTTjtNRbNDHlP4agDT09N04YUX0koFL4pZBdNhy42pH493+DiGzZ0ZlLfRjNjbKUB+79szp97NNvsBhMFGNG3f83dAmLKXAmgTAvtEAfqybXpezautT3q/Occo5jJKDtVuEXTd2eZb7xf+xrWBv13f2Lrn9Wf7ji0IwhBTHANVHdGwMV7mmLKZ+GzjvhAIIkFf3No+m2BSxu8qx2iufUHe71yNUc7T2+uHJnFqEGzPwDiN8rwi75r14W/sGLHqGdTGZsCbtEvEzHrwO/Kt4t2vHFb0bHlZg84zc5byd6z+8rtO4qEUNgIfLjheKalavk8eP/QvTFAfrzHvZx7TIPDmgcrf2sipG+m6DDg2TFm2Y/yuD4EgAEJMhwzve9/76DOf+Qx9/vOfp1Sq9SB9whOeQH/4wx9opcAkHn5kEItvrL290m7YiGsQoJTCd9JmluhFDKPCJL96mzmi7kPThQXt9iIctu91/9lekOmoMMmXjYzh73giRWvXraNk0g3A5Eei8f39e+bp3j3ztHu21DZeN927m35zxw66f89cs+8IXIQ0Q26gLde/djEQdN3ZrmmOwotUOfgbPrG7Zku0c7ZE2xrXgt8GRKfXJCukCC4Ggmq7tvD9aDZF6WQrInJUhN18ESwzmIvbKItrEAWYGoJcdEQwQ5LGMOfZCFWkMgP6jfoyYwvNe4PqxBiBvOBcW9lmGXowJhuCfm+W2zAHxksjxHiOb9iwQb17nmduTPB3qFN/b5L4ZPvGhHk8K3q9TqHTjzKj1q2T5SjtCTo2TFm2Y8JeHwKBBWLKO2S4/fbb6UlPetKC7ycnJ2nfvkYC4xUAXqDHqq6JblT/O5vfqS3YjJdJrs0skc17Od0JR7IN8snjhbhJHE2fPL3NZo5Qk3Tr0XfDKmJm5NrFMEc2zY5tZsjK93M0R8ce91j1N8YZCieCXYFM2nxsMS4xB2porZm6Zl+xSg/uzVMiBpIWb0Ze5ojMqFcPfMUIygvbKYJSuNiuaY7CC19q9++yekc0ZaQzQnkcyMssK8w8+vW1NR/2TQ8OVhZkQuwH2/xjQ+HBPfPKX3d9I3fvUpjIC3oAL19HP783hv49K3FK0Zv093/TA8P0PWJrSLPGwLQ2FW8ltNNow1FMOr2CMXF7zd8967SnPBkdHaXHPvaxPifG2v0k+Xw9eI5pxmwzRV7sYDtL7W/qd994BcriY8IEugrbv7DXh0BggRDTIcxjescdd9CBBx7Y9v2VV15JBx98MK0U6At0r0A5fjB97byi2EaJrMsKZyFfplWj6ba8ll5A2SBZ8+Ua5dLtx5vk1+wjB+oxSRmI23ypRrPFstp933/1SKBvn81nUO+7SboBfUNAHyMvou1Vr05KcS5IJNfD3+eLZUrHiSZyWfX53t15enBvgQ5cN0r7rcotyPU5mUtRKol4ww5V6zGVCicZi9HqXFrlVd040R4l129jIygvrBe8SJn+vZ9fre2aNgkjtxv95Y2QbuDX16B7zPZ72HuIx4Rfet2I2IzAZsgLm065QUeEnA4pvNKi6AiTzgIEt5nCYsQ7DYYewKeXkVC79iX16WPU9vYicrBZhlcwpiZxNX6PmPIEQfgqlYqy+tKDObZg+ElyWVGI92LMt4ml9jc1zeF5XvU0Lba2hQ10FbZ/Ya8PgcACIaZDhle84hX0hje8gb74xS9SLBajBx98kK6++mp6y1veQu9617topUBfoDOh6bW6FyU4TLvC2VJ0wgQISjdNSaMFt7EtzjmYUa1eoUIZ+U07S89h9n13vqz8PJH3FeQOaXYAVsl0k1P4GhYVuQwm5nqfWbV0Gi+uH9/nZ/P0p+t/SyeddBKl0iM0U6xRIhWnPXMVetj6hQQKcwDOhzZjA2PjZFYR0sNHJq3kzW/sg5RNL3iRMtv3naqyfu3uRPXutK9+7Qsb9ZfHBDlvzYjNxXKVkrm4Mrs28+YKhgh+SkpQ4B9dRcNvuGCQFsZLMePvYo2AOOx72E/Fq1sy6aEw9qTObsoIQ34jjN3s7KwK4ojnOay9OqrPVrefKthhWyOd04tNgk6vQb3uNgIZQjn2CnS1IGqvR/+WUikWLDsIMR0yvP3tb1e7jSeffDLNz88rs17kAQMxfd3rXkcrEVGVzbCISnQ7iTrKJpBRAOIAldUW+ZTbCzNVqI7z5XpH6TnMvufScSpX4zSWgRksTGhb4fJ11RTBcdTxmZbiGaVOEA/2hdSV2TmtGHw+cE2O9syVafNq1xzXVpYXefeLqGxDpya8XqTM9r2uVOq/m4p0lPGMcl/oxDhMdGTbeX6EP2jzSDd958+2iM2mOi8YMvgpKV4pUmwqGvwJJza0p4bxJFcW9c3T7HGRFC+vtnoojEuOMORX9+lkEtPpGHrVFzRvfqqgra1R5jnMOb3YJOj0GjTr9ksDE/a60/15eU6tm0phovcGma8LsRW4EGI6ZIBK+o53vIPOOeccZdKbz+fpyCOPpLGxMSoUCipa73JFy9SzqqJ/OhRr5r+E+WetVlNELJtOKoUMi1yQkD35kvpu7Vi7+aZXHWFIQFg/ThzDPo5oA8jQbKFM22dKNJ5NqbydpvLrVaZu6ugVd9IkdL3CmrEsTYy0+6DqqjBe8AWMxaBouWQiKrxIOvqxKtfYzW1gaiyjXn7+mV5zogeV6mf6EtPXUp9bs926UhnG7zZs/WHP8TLhtRFP/R4Ja+Ycpg+uCThM09s3Pcw+CSldpghSm8zfw5rMIp1GvdZ+rNdCuheK10oFjx3Vuif3UTcOovqTdjLPi3Vt9MQ0u0dmzGHnNJSi7kNeJeWMQIMQ0yFFOp1WhBRAyphLLrmEPvShD9G2bdtouQILV6RPeWgaSbGdJimFPydMP6cLNZorV2ikWqOJEXchDfIxX4EfZ1nlp4xiUhhETGGyGuRHijbPFuu0r1CiVWikMout0M5ZpPio0nhDzWTfSkRbhdIJmL6z3Dbz+yjoVH0zj7ed260ZqF8gKK+xrzT8acwAWCjnzm0zlC9XactUjtZPtlQaBEwCAXIV5d6bgHdyvXgRP8beuYb/z5g79thwweYMAgKt8SDoYc18MQZ78yXX93ayXZmEb248FmubV/0eCTvnQSRZD+YF0+vVoxlRRgW9MZnl9zAEtJd+iStNBeKx0/vdKaJuHCyK//Ai+axaA1wt0bUUdk5DqbI+5FU2hAQahJgOCUA+zz//fPr5z3+uSOlb3/pWetaznkVf+tKXlIKKReWb3vQmWu4oluuUUVdtjMYzaUVOsdiF+Wc8lqJUIaaUSV4oQ6HEQhffhSEfYVUmNjvlv72Adoxnq5SMZ5qKKQLyzJVTNKbaFGuqTiAa6WSC6lj1a+lbdGUSnzMh+2IDkwrOjdrLSLNczgyCL5WrkQPUMHkL8k/Vxx7qOVRaJkc8ZtiQQLqYnbMF2jtfocckEorswOd0LJumiYZhgS3AU1gT3ygIe73w7+Yxru+t0+wnSNy++Qpl03FFTr3OY7g5TyvqejP9gtFnPD84wnH7Jojrl2cLuMT1hbl+gsg/fmsF80qo+xlt3p0v9WU+BAMIr+AteiAja8Agn0W7n8lsoGmqlkIlSgoOW3/6Hg04JHFZDILTE5/XPhPQYVPoOrn2e4l++zEvRaAqwcBCiOmQ4LzzzqPPfvazdMopp9BVV11F//zP/0xnnHEGXXPNNUotxWcsLpczsADef2qE5ssZWjMWzp8zqt9n0AKaTRt11dIMYKN/r4jf1FibQoX2bJjMLYhGi1QY3E8bQQ5jXhykhnK5yvS57iyI6ttp2brCVmqk8eHj9uaLNFdxaMNEps3EF30GiQWxYhNWla7F8E/F98lsjk4+5VTKZtLKnJ3nFMeAvJTKFZpNJJQCjd9AZiZGkzRbTlMuE1ebAXoqGJtJsp+Jr6licqAnc2z9xt0sM8g/Uzfdni+WFcHeb5XrUwsSV6+n1Ni5+Vfb+2LOF+opVWpUroJ8tq47vJtpifh8fIeymfiG6acfmPhzmdxvfRy4rW79rulz0HyIae+QwlRhOIcmAhrZSKpXUCSOKIpIvfCTC/JN5HNsaTX01DJcbmWeKJWLvnheTBUoLNEaEEI2MTFBp512mnce034TlWFT6DyDDg3GfAoEvYQQ0yHBZZddRl/5ylfoGc94Bt1888306Ec/mqrVKt14441qob4SgAXoRs0kcykAEoSckciFuWl1i1wCrHwWypUFpoh+JsJ+gWPCgtWlbCpBoxlvRbVJVNJVpbqxIhYEs/3wJ0UaDwRFghIMIJqq8vMttUyUoYBunykT9kz25GMLiCnnouXzbQqc61MbIyeeWHCtK2KTrlK+WKOKU6Nxcs21QWQef/B65d+Lc7k9JiFlggbYCJqt/wD+ni1WKBmPUbFSU+NuC0bF55r1ufNVVucQuaTMpmrumy/TztmSG602nVBBr7wCAvGY2vxSUT7mC21OxBy1McLjbNu8wXlQ76fnyzSZc/O8druBwcQfQas2TmKDqdVv3U8VfYTNAK4tHB80H0JMhxQm+YQvqB7MyIwwqvxEPfzbQEpxvtcC3awrVKqWRqTSeqNujuobVqXqlFwFlW/7PSzRGhBChuc4UsUsGYZNofNU/ns8n4ttMrzSzN0FoSDEdEhw//3307HHHqv+fuQjH6ki8cJ0d6WQ0l4hbNAiL0B5IwcpXmA63E4eeZGNhbT5m6mA9nphjXrhCwiStAoJUQMAIsLKWRiY7QfJKdfqtHdfmQ5cO0aOU6c41nHweRzPqgBILpGp0oaJtFJM2SfYlovWpmTqBGd6Zpb+cvutdOjhRxClMgtIPcylHWqV0/xtaqw5PiaxNP/WCZpp1mubP1YqcU14BaPiY81gRiDsqbhrnsttdol6jSqaqpkvVikVj1Gt6igTZN0n2VTt9T6a7UUd8Kmt1uuUL9VpKuC642uZ5yysubffdc3EH8p56/po903GOS5Zx/etcTd9gcOa3AsGGH7BjGwRRr0CsHBE0W4DJ5kpM/RIpSCsqg253qpUtoV5UPm230P73AYcF4Yo9IBMIGjjLbfcQo94xCNU4EbBgBDsxVZgRfEVWCDEdEgAJQq+pQyYwMgDnSKb93GQFT0Pp820lL83lS6og4mEowIp2SKrho0S2+uFNZNAnWz7jUdUE0jzeBAWkNNVq5iEptsIFrfDz5Tab7zMADsgcbt37aJNW0uUTWTalDwoh6mGaTReUHNtZcO/1GYmbZsH06zXNn9NtdV1em5+NsfcrI/9TTNJd8x08og6QXj5/A2TWdWGzVO55jjaCCiTbD3Vjo0YuqbbwXPfyxQ5+n0FpVRvM8+vXpdNvbX5WwspHXLwwpfNZ5sRQBu/6QRI5T+d986BGrRAtwVxsfmjsgmvb7t7qFJZSWbE6MTWcg2z5KC++7VHH3ek+vE7RpWd9DeZbqxndu7cqd77jk5zlurjp77rMNVJlPpt87aYCLq2eq1wDoiCLxgsCDEdEkBZednLXqaUUqBYLNKrXvUqGh1t/0/629/+Nq1UhFEh8T3ycELnwoKfv8PiGSlccBZ8HHmhbBIAmJtCkOw2YFCQr2bUhbeNSPB4sNoUVHcU6KakQe3wguljafOLrBn+nDCZRdNNJQ8KJ8gqm8LWnZjKcaoHYMLccf9df9iyZ3v9zHr9xtEkjbbjbP6mXmNnI/Ze6rvuQ9urPLtR4TUmO2ZLakPowLWjtN/kSCSLAVFHlzF081ksevUclAsIkCUfaSf1RVUjmSB4qbm9XpiHJdl+WGCWbBvPkO0BUapXG+Q0F3DMPNHoVCtoFMyruQ2LibZNDCd64CBz/ICwqU64XGX67bTGIYwKaZu3xUSgot5jRXXYTKoFiwIhpkOC008/ve3zi1/8YlrJCKNM2Y7DCzk5QUrgy4YXq6gJctRiWffRNAlGVJXTVGGDzu3UxJfzpcKfktOHcHtB7lAmFEOQM1NpC0NUbX6SGEMocDb12GY2zd+1EU/Nt3CBSpqIt5ncMngcmdgCMAnGn3XUWY1ROhFTqXd0RZIVU5xz/555zWQ06UvivMZJVyoB/g1+nOy7y7/7mY3r6qFNQbRdw6YiCfUaZN3Wl6jXYJQATX7Q212p1imTiFGxMV/mveRXj6ijyxim+ayeg9IkQD3J79iBGtnPxXO/yl4wriHHz9YepVZrSrXfMSM5108Y/+vY8scuFnQy7WXm7UeybOMXNtUJl1spNjZSyB60ywZbvYuJIEV0QV87UHjFr1QQACGmQwKkhRH4++0xSTFNBRPxhaaUWKAzsUJ6itEMNYLXtJOsbpVGPcBPGJ/WsOTXpi4iXyrF6sqXkOvSx8LmxxmWBNvGm/NOzmtpRvzMpnWiib/NHJg2k9dmfY0y9fNxLvLB7s2XaSQZo7ITo3ScqFKp0myVaCzb3iZWTHEeTGnh5xk2oI/NdJa/3ztXViouggXhWkrEYyqvLqunnLvU9JXU5wfHQaFFGRyVdg+CWSmihjK9rwtEWAbpxLv3tVGjeh2Eud1M3WbS7BJZVy1WGxva5kEUcL9Q5iEbxtsUaBu5NusJUtQFywC6H6ftN9OXtJ8pK3pVx6COa6d9g0qKV5Rjlpp86GS6k8BBXuMX6jptlMtqLaJMhx0Dv/thMRCkiNp8v6MqvOJXKgiAEFPBUMJmzgiiwSQAaKQDXRCIiM/nvJf4vV8mjnqAnzCL6bCLbpMseQUAYri5ResqzQ6TDwB9B8zgMrZ2maSxlXfSJQ27G5F6XTLlEiX8PpZtBey5b1ee4omEMul0AzC1bwKYGwEANhDmy0RbHnYYFetxyjVUSIzrHdtnKZlM0GzRoQPWjNJssUrxRJKq1RrF2YzMaD/XuS6kCuhlOgvU6m4Qo7lyndKN3/V8payY4m/0wxa1mY9jIog2IcLyfAUqMMyNR9quYZOgmWbHtmsDOXLjWmoGVrxBeBl6XlP2r4X63gkptY05Rxq2XWvmJgXgp6gLMRX0BV6EKirRWmpittQIICnZbFYFccR7T2COtxeZtqUoUnlqG2o9m992Om+6GW/TXzrdn2sjTAokr/O8VM6mn3escUzAeERVeHm81fGJcHUIVhyEmAqGEjYSoxMCAAvYjI9KuRi+a50GkQmC2XY9Aq0JHLdvHuodSIcbWEf3SbT5Rdrq8xsnrmNfoUwj1RrNFuM0nkXqFqJVOTeFy7bpAs1XHYpVKtbclLppLvcJUMpsLEHZ1Rsp1yA3bp0OrRlN0f17C7Q6l6Z8sUKZmEO7SzUaTydUTCKdSDM5ZCUy7LzbrjW+tvjzSKZFwLzK9YrabBvbykhdEW9bO02CZvqO2q6N/adGF5BrkFJFrBGsRFNMdaLbzfVr7ZcHubTVE6SoC4YMZhAdv8U1L569jo0SMdb8jstWhKQR8Ii/L+xb6Bfp973XAh/fQ0nCoj1IAbO1GWOFOlXgp1zDV7FhmsqqWpTouvrYs7+pOR62foRtbxho5yFWxoEHHhhcdti2hVXhzLRBpn9zcdad5zDz5lc+zHjxzmAfZT9fX9v9YY6JLY0S3nFMKe+aTo9M+o8V6ijsJYqnvK0ScAzK9hoPMzBZUMAw8z5SZNZpN3lerEjAgoGHEFPBsgAv0HW/P9OE1eaT2s0id7FNC3VStbbhRxoGaNuqHBb5rirnZzIbFrop77QiEQmC5WwmCbPoFE2MJGmmUKV0ouVnCRPjqZEk1WMu+THBCpkecRdzCmW2UCxTLb+bnMxaymVH1PEoYzSbof1WQT1164a57tYcUSaVoA2NCLA6QLhYiYTZdifzZs53WLVdJ1/oG4g6olKOGf6sJtk0Nw6C5ktvn36N2kzUQUr164D747VpEJaoet0bUa41sy4x4R1ymEF0bESB/8Yi3e/YKARlQXCahvlhZZ4olWsPDmTzi/T7vheBaqxRbkFsC0S1UivoExb1TtX9TgUh8lF0zTJRXqXgjiuIix6MJ2o/OjXF1M4r1xzasWMHrV+/vpVtwLYBwG1jpc2LkHeax3WBf3OqnVBGhW7Gq5M1fby82sr3B8ZAVxC97hG9HIxNvTFGGK/mNe2xiQBS6uf32izbYzw82xSwKWDeR7rJs0TmFTQgxFQwsDBJpq6isKLjqmBusBkmphzoR/fvA6KaAaIeLtv0z3QX6jUVJVb/Pmrf9PJ0AqH7MvKCvFNSheM2TrabNZlkIWr7dVNejA/UN0WwRrNKhcNcJBOu6SraDdNV9OuIzasj5c5EPYj+O10r0Y233UJHHPNYqjoxmk4k1BgcumGc7tjmqCBWCHg0mUuqAFBe44NrxkuJ7Dd0cof3fKlCxbJDsXhLFbRdo7aNhDBtx0bG9umi8n9FjlvkW60Tgn+5xDNK/20+oF4+qlw3/GyRZlmvS8jlCoYZRMcvv2g6Fnxs6OBFliBKICRqYa5H29XeTfNGr++9zBjNSL5+sLVZEZtKu2IKUsaKaVAgH7NMTrdjC8YTZI5pkptOg1Bp5xXy83TDDTfQSSedpBFTjbjopqRoG77zi2yrE7Fm2poA0mz1IzVMWaOadOubIWaaHr1MW8ojvj8Av7lsmwstcjS3T78+bJsI+rUZ5DfrNdf4rNraIJlhgjvZ7iNRSAUWCDEVDCR0HzgQHZ1k6j5wUOFKlRqVqyCPreA07JMG2BbOYYBFOJcNcERbAP6sWHnrppBR+6dHnEV5xXKNXKHK9cFD/Vjcu0GZ0ktKqkwwYeS+cD92zhRpPNuK/At/SsyRzc/XRBg1br5Uo53FgvJ9BCFGGw7ZOBFazfNLmWILGtRpRNow5G4sk6KRZM0zCjSjUzLH6ZB25cu0ZjRDu/Klhpmuu4kTBTYfUPMa5tRE/D3uHfgXi/mtQMHm92czJeT3oIA7NtgUP1sdNjNNzyA5Pt+HDdwUtc1ePpJQO61lmOTbKBNlTW6yk6qggDsLSG+H6nDQeWb0YNQJwoO2sQIZRH6sirlGJv3U3jDHBZVvU6tN81gvcs1zbpruet0j5thar+kuo0wH3RNKTXXsRDtsWQKBASGmgoGE7gNnkkzdB84loq5qxwt404yRzwPRfXDvPI2kErR5ajSQbLj1OlbFVPmzJv19Cv1gqmAoTydvWNiDhMa14DQ4HqlI8L2uCHJAGVNxXSzoRA4kq1p3mvVDKbXl19yVL9IDewuUS8Wbc4HzEfQH4JQ3JmA6nEvGFWHncnCcLadqVJj+jzaVsBvzbp3cuT7BC8vs5byxufQEUjjgYR/PKMXULzerF7zSuJiKKbQOFVCpjkBbrgqz1JsogmUCiebZ3aK/Y0LZgzQ9oeqxRHz1ImdR2srXDauRACLl+l5fPkqhV/lBprqLNY5RlGQvv9ZQZUfsTxgfWiGuAiGmgkFGsVJrEk59UWyqXl6kwSQaiBg7U6wq38jVSnHT0pE0yJ2+APdSypjsdgM/P0UmNxPadyDV9+yeV4Q8m3TbD3CwIGW+3FBcoSp3QgaipufgMQNa51QoY/FdZdIJc9KpsSxtnynR3bvzVEadlTptmMjQ7rkKlatVIidGD+4r0EgyTpumcm2kUymluVFFdhH1NwZbUeosaqwJW9CgqBFpTRVRHz/dv5TL74XPstd5NnWYLREemi545p8N0x7bb+3m58GbI2wqj2tipHH9CIkVeGIpFvYCb1LYT0LRrSrL/qrqu3R7blU24fa7vqKo50FqddQ+9WMDxjPgksXvu19z5FWXbDgJDIhiKhhYcD7IMKaANrNLTn3BChF8F+F7CsXUTD8RRR0zU9P0ejFtEgG0CT6U4+k41WpxFYGWSRPa7DjIXZpsKq6dtidqeg5zHEw/SZ1ogAzBp5KcOGXTVZrMJigBZTWVoGKpQtPzCUog2Q2IZoxoXplrJyibLytimkgkaNWqVTSaTVM602hbyjUX7VXUY3PsOjHhNTc7zPHz89VkK4FOAlFFyUcblH+WAdPfmfkyTeTStN/kSKg6o1x/bo7fGpUrbr/7cS8JlhHEFDAaMeyEOHpFTlZRjKtEcFvRI/uyEhnks2hOZeN5jvdAhO0Hk1H2zXVqmll4w2fXa2MjTDRnv3oxbvCL7sU89GMDxqtMm993v9LVeNUlG04CA0JMBQMJW/oXP+gL/pYCWqN0MtFUr0BwdPXNjFjqRUqZuBbg80lYzCcitS2o3UF+jKgDfqYbVuXooPXtqpJ7bntEVzZxrTZU17DkCsdBwUpQrI1ccT1MOnQTaXMcvKKusk8l1DHOaXncwxKUL7h5T6GMc9AiILtnnopaIKSxsTF64hOf2CzPraOu6ndztLoRfHmuWu10PJXBqIqgCZBtPa0K8rhyrlgzEnQYX03AyxcX5+zJF9UYmWbO+pywabPftaTnn/UDxr+qlPhWCh+zzqjXv37tqM/VOtXrtTbzb8Eyx1KY7ukBaNoinhrfD0JORVvKFNt4LYg2HODrGAZ69F74pPpFMW4GCqpFrsd8nvuPR4RUMOV8K4psU5ULCDrkVUfYeoNUx6jz0I8NGK8yvXyZw8AWmddvk8KrLtlwEhgQYioYSGCRGiVAi77g54U+qA6URi+fOtMM0c8kGMrg9HyVMql4WwRg8zj9uzDqUSd+jHr5rEqCJOnlzJUQOClGyUT4cr0UTzNdCY8vSJQ5R159tvlUKhXOUOIYh22cCOw7XiBixYpDsWor2i3GAUGX0EY/ZdBPaQyjQupBuHCMniuWI9HaCLqXr6Zfzl30a7aIYCBQx13F3zYWQdeSHrQqaJNkaixDSc3iwCyHx0n/HAQeV/hKJ+O4PuNUc+p07+45lToHn/Hi8Vtq/2lBH7AUpntcp5kz0fy+1zkVOyHhCwinx3jZorWG8XX0gx69Vy9HRTFOuIqpabLqp0T2AmH7oYjnWCutDJOgoKBDXnWErTdIdVyuiqDt+utgk0IgMCHEVLAsYJrw4gXz1rG4G1SoF+otpyJhAqRSlDQi5nK9nKqGI/gGLaLD+DF6mQ7r5Ekvx1XFkkox7cYU1eu7KGpZp36TJqanp+mKK65Q6QUmJ1uRKdE/9DOZSLQp3yBTrJj6kTSvfoTpoxmES88Vq/ddBa1C+hSL2sl1hblOxrNQ7Ftm6Oa4duIT67dJ4hfBmPsXZOqtt9FN81RWxBObOzg3l47TztkqJWJED+wr0oaJkeYmA8+BHrFazH2XAZYkCEzanjPR/N6WUzGsgtkrEr7AZ9EjhcmCaK0hfR39YEbvDRO1t4N6vJ7nXZWPY8bWWb4Pk2YoRDRnLwSpjstVEbRFC+73JoVgRUCIqWDZwTQ57VZhYfVWX6SrPI2W45gk8ucghPFj9DJr1smTqfh2GqXWRpLM76KQzCj+j53AHD8/5duEXz/C9NG8Jsxcsdx3kNe8h9oZFq7iPNb8bKrYzWO68LeNSmyDyLs59yg7poKQuGPH3ycbgclAUpOJWHOTgevQI1aLWjqkWOCP1vDLY/8/9V0EfzXfsj1Mc/386MxFNtoGf0UmqnpU16aiqOWMjKLEBUFvC/t3Mmy5PPX+6/ksg8i0F8FeEB03wJdwEKKqmr6x+rgpn1jOu6nl8VwMRPXDNM8ZNkK7XEm4YFEhxFSwbNHPhayr6HQe+KUXZs3DsFD3Iy+66TO/20w18Vu+6ObkhDo6LOC+Q0GFWTmrnb0suxfzr2/gRNnQCLr+9M2hbdPzau4Q7GQ8nWo71/T9NsuImnNVMIAw/dFMn0XA9FfzUxm9ck7yuWFNc8NEK4VayGaKaDeOr9cQnS+EiWiqcxLCwXxQJ35T5rSIKJsO5x9Zgr/oroaK6ITzobQGP2r4mOI3EH0EFUJbWEUdhKiqpp8ntxngNumfF9uEPOx1bZ4jJE+wAiHEVCDoAMNACgd9nHTTZ9cn2G6qiePKDUJarfsTU/hZQn1D0CQvsqMHLeon6dH73mk9XsGxenn99UPV1tuNcpUfcIxoKiBFjWCZoqlY1TSfxUbaDlNNMv8OXLxbfN1M01zTDDZKtFLdlxJA220qbyewksoGWcU7pzfhOoPSnOjfgZTiptPJdZAPpS2Qj5q7ebctIPp4D6p/sWH6efI1xn8D5ufFgO3aDKw/5o5zJ5Fy+4lIJuxDrPoKlhyyQhAMLXrlv8hl6fkluy3PjNiq+xtye3Vf0cUkumEiAS8GdNNnPWiUHgGYj0s3/k7GW2OEc7ZPz9N0sabSzyC675078lSp1ahQqVmJKYjrLQ9M01jWXVwNuhrXTXCssPdJL9VXr3brfsC9bLtgSMDkTkVMdew+i7pqV5h2F7UjDf9Dc5EbRIYWmOZaAuDo5p5hyIrpa8lEtZuFuK0fzSi4RUskXq8Ivfi+0k6YmYyGJTjcH+Ro08/hfqMsBEBqbgboEY0jAqln+N0rYrLeX/M3U9lVJuGNd1aalal4Y1zVcQ3yqm84LIUfZiAcV+Vf4CxkwPda6AMpNNVfvzrMDRebEi8QeECIqWBooJt+uoFUqsqaqlTBwjWmonrOVRyaGk3TxskRtZAFQdyTLynSsnbM3THV03rogYvC5iYNs1jenS8rJRDBd1KT8aavIdLXIGLs6tFMsy+mWuVVfrfpTXpJdvwQti22320RgDFfBUrRcSc8kVZNjqvv3Hkt04P75imTSlC+GKMNE1naVyxTOhan0ZR9sYRzMokY5Ys1OmR9tP+09c0FpA7i6LF6ihpz06Hbses2oFEYRbQfpE9vdzcbIP32URYsIsIqa1jAVgtEtRJRuhG12ySV+oJfJ522Y73qNs09vUx5vRbSnZhphgq601AoQU5gMoxy2ZzXVo/NbBXHIIIuE3srMbdE/0WdtmA+3E6UozYHndb5HUQyHhtJ0d894XGUzVoiI9vaaP5mM93V5wJpY/Ab1Ga01zTnbfYpSrTkRVIB/e4Tmwm7maKlX6bAeruC6jD74HU/ibIqsECIqWAgYSM3uunnXKlG9XqdZos1FRhlruQosoLgKUgRguinOA9kcL5Sp3K1rPJZooz79xZU3kSAialXgKFOF8sI5FKuQunTU2rEFMnKpeJUq7vpQbg8k4Dayu82vUnUSMCdKsjdkAlTvcPfbhoWhyqplPJRLJXd+S9VapRNxiiVTNCG8bTabDhwVY5i8ThtmrIvJjkvKt6jqqV6MCNMqS1FDW84dENM9bHrlaqNe4bbuhhqea/K74eaK1gihI5yOtoILJQOZwIZxlzSiwB6mXcGpQAJW28n0BVKbJUy2fKqB3+DgCnFM9YibrViS0UNkw7FSt4NMuZlNg0ize0NoYgl0iM0mkjYza9NNRZ9M6Ml20x3dVPxBEzFQWZH3Tk2zXlRPkiq7isbhMXy/fS7T2wm7GaKlk5Nq4NI4oKgWBEsFrzuJ/GnFVggxFTQNT75yU/SxRdfTNu2baOjjjqKPvGJT9DjHve4rsq0kRsz6m0lGadVo2kqlGvKVHA8E28qpnwOTGnxGxRTPn8kGadiFeW0By7S1VPTnDTqYnnNWJYmRlxyjbQyxUpNfZ9LpygWcxaYqur9ZiLLxDVMvVEW8GFIQxQFuZu22M41A0ohDcu+mTl68K47aU32CEplsjSaSVA8lqb9Vo80c16GIV1+gXbC9gvXlKuYLkxRw9FjB42IIX1Rt2p5FFXejIjtt8nhN29iwrsCYC6IvRS7nppLBqRBCUoB0k29YdvWLC9gLHjM2Eyazy1BNcy7x+iBivTy/aLxmoGPUIbtHDaJZn/WEMR0vlSh22//Mx1++OGUy2kBsBis8DZJacD8LDAVnyTKjreCRfH1xePAQaUioUPfz16qgnpfdN/nMEQ0qB1RSGLUAFJe99Mg+CcLBg5CTAVd4Rvf+Aa9+c1vps985jN0/PHH08c+9jE67bTT6Pbbb6f169f3dIGuL1LNBSz7dK6bbA9ooxbCky3zSnzef437H4vXwjxMfsbt0wVFeNdPusTIrx/bp4s0VypTIhan1WMZlV/Va2GPfsyVqioPqXmM3yLdy+wXC/7ZQkWlKZnQ1OEgIqcryIAfUQ9qSzdAOUjDMkIVuuPGh6hy6CFqIWMjl/1WAb2CGfF11SlMwsemylH74xXUSb+XujENjqKE87Goy92cwWZMrLnJoSvy82VYPcT6ZlouGHCIatI9bOqnMmNNdZ9TlQMfeZ3HJsARSFulUqEHHniADj744HD9CdtWm4Jt63czqFUUQhTS91MH+7uq8QuRXiiIQFqVf4uSaZvnqOa3i4HFjJAsGBrIKkDQFS655BJ6xSteQWeccYb6DIL6wx/+kL74xS/S29/+9o7LjUpusCCHPyfe9UW5vkBmBJmm2sxJdeKAsvYVylQo1ZWZ8KEbFhITrhcKGpTZuVKCMqmYMjH2W3yD7DpOzJoWxfWrhbmyq+4G+cGifvhUwmwZ6ifOg3Km55XU1TOzfB5HW87MfqGTYDedBsjpl1krky6oqsrHOBFrbkbY0uLgWKjqEBzw/XSh0hFR87oHTHXedq2G9Qm2XQM2QszHwk4gEUce0qryr9bvqZYi7/oDL6apsWCAIKpJD8bQomQiTYyXqa5XXlM91yfAn21pavT5y4wRZcYbvqcNAhYm+FFxlmjMoph2Qlj8FOwFZsydlG8S34BcsUxKVXoh9SBsT+HjpSwrH+uSG2gKPta9CKjl933UMelUAV7sYE2CoYX8zy/oGOVyma677jo699xzm9/F43E65ZRT6Oqrr7aeUyqV1IsxMzMTqi5ePIM4IejRxEhSKYC8mMaimBfHNv86DjaIhTvK8SN2NvXR9PtbhaA3lSKNpROKSPB5AKtESnVMJ2lqLKvIHl68kPciyOhTMmEnJChXpd1o+DaGIRHwpWTFlMvUVWed/HiVH8W8VCdlqNehmJor9J3JhhmxWDfzDKPK2RRGnKOPaxhS068gUEy6phu+sSCcIGfcTpeGtSvQ2IOvNX4HUYN5OnKfslIdjjjGaM9cmTZMZCK31ww4ZavPq34bIeZyOEgUTNvNsliR1681RE3uZ2AuQW8R6XnutQDtVjUZ1IVtN+3qRZ/8THXZlNXMRwrz33ojOi+ODZP7Uw+MFFaRrRQa7/NL67PJCBM1NkiZtH2GUgpS2jQhng5v8qzKy3QeUIs3GnSz327HWVeAuS79Nz+izoSbrzkzLVK/rwPB0ED+5xd0jF27dqlIuBs2bGj7Hp9vu+026zkf+MAH6IILLljwfRBBZdXu7p2zlIjHaOcehw5aN95QJJNqsT+Jq7lSoxmYFBnnIdgQUARpTCWpWgxvfqkv1HEesAbP1klE2C1Sca5ITjmp2gLAFBd/5jJJilXcOnL4oo5+zjd/L2TsBApL+2qxTDOtbihU0faGolmIV5tt8UO60VYQoWrRJYD4t2CpK6h8/TwvYLzRv31zZdo7V6ZUKkY743HaMDFCs3HX9/aBPXNUqTs0OxOjqbFM23joJEyvH9fH/Py8ekcqmJYa3UrFM1soUywWb9YTBPQXxAlq5ky94XvVK2JarlK8WqVazVEBuYrzlTbFtNhUEl2SVm98n68UG30vK4K2vTiv2qf31wuFuSKNxvBeoZlYNVJ79THneyaovlYBZSoWKpTC5tCM60sNINAX+gDOma5nF1w7HDcZ+zqFHs0JP0cQAE3Qf0R6ngf5DXaKfpW7lO3qd58KM7jZiJJIS9N4zoIg5Bv1VmYaAWsaxLSaJCq27m0rdCIScOzM7Kz7PM/PUWy0GFx2v5Hf5UaNjUPBXRvuHLO/fp/rjSdcPdMIFFUjqnusefCb+v8gTlTJhxrPRbuGmFxiPQU/Xr1dZn3mZ/Oa498ReZpNnI1+yvN8ZSLmyP/ggg7x4IMP0ubNm+mqq66iE044ofn9W9/6Vvr1r39N1157beAOO/xMjjzySJkDgUDQM9x33320//77y4j2GfI8FwgE/YY8z1cWRDEVdIy1a9eq9B3bt29v+x6fN27caD0nk8moF2NsbEw9dMbHxykGE5fGLtkBBxygvp+YmFjRMyRjIeMg10P4+wL7rLOzs7Rp06ZFu0dXMsI8zwF5jsk46JDrQcYhzDUhz/OVCSGmgo6RTqfp2GOPpcsvv5ye9axnqe+QWxSfX/va14YqAz6pXsoGHk4rnZgyZCxkHOR6CHdfTE5OLso9KYj2PAfkOSbjINeD3Bd+MJ8R8jxfeRBiKugKSBVz+umn03HHHadylyJdzNzcXDNKr0AgEAgEAoFAIBAEQYipoCs8//nPp507d9J5551H27Zto6OPPpp+8pOfLAiIJBAIBAKBQCAQCAReEGIq6Bow2w1ruhsG8Fl697vf3ea7tFIhYyHjINeD3BfDDnmOyTjI9SD3hTwjBGEgUXkFAoFAIBAIBAKBQLCkCE6EKBAIBAKBQCAQCAQCQR8hxFQgEAgEAoFAIBAIBEsKIaYCgUAgEAgEAoFAIFhSCDEVLBre//7304knnki5XI5WrVplPebee++lpz/96eqY9evX0znnnEPVarXtmF/96lf0mMc8RgXUOOSQQ+jLX/7ygnI++clP0oEHHkjZbJaOP/54+u1vf0uDDLQVCen110UXXdR2zB//+Ec66aSTVJ+QiPpDH/rQgnIuu+wyevjDH66OedSjHkU/+tGPaNgxbHMZFeeff/6CucccMorFIp111lm0Zs0aGhsbo+c+97m0ffv2yPfNoOF///d/6R//8R9p06ZNqs/f/e53235HcnVE+95vv/1oZGSETjnlFPrLX/7SdsyePXvoRS96kcp7h2fKy1/+csrn85HvG0FnkGe6HfI8X7nP9JX6PAfkmS7oCRyBYJFw3nnnOZdcconz5je/2ZmcnFzwe7VadR75yEc6p5xyinP99dc7P/rRj5y1a9c65557bvOYu+66y8nlcqqMP/3pT84nPvEJJ5FIOD/5yU+ax3z961930um088UvftG55ZZbnFe84hXOqlWrnO3btw/sXG/dutV5z3ve4zz00EPNVz6fb/4+PT3tbNiwwXnRi17k3Hzzzc7XvvY1Z2RkxPnsZz/bPOY3v/mNGosPfehDamze+c53OqlUyrnpppucYcUwzmVUvPvd73Ye8YhHtM39zp07m7+/6lWvcg444ADn8ssvd37/+987j3/8450TTzwx0n0ziEA73/GOdzjf/va3HfxX9J3vfKft94suukg9J7773e86N954o/OMZzzDOeigg5xCodA85qlPfapz1FFHOddcc41zxRVXOIcccojzL//yL5HuG0HnkGe6HfI8X7nP9JX6PAfkmS7oBYSYChYdX/rSl6zEFA+1eDzubNu2rfndpz/9aWdiYsIplUrq81vf+lb10Nfx/Oc/3znttNOanx/3uMc5Z511VvNzrVZzNm3a5HzgAx9wBhVYyHz0ox/1/P1Tn/qUs3r16uY4AG9729ucww8/vPn5ec97nvP0pz+97bzjjz/eOfPMM51hxTDOZScLGZArG/bt26c2Fy677LLmd7feeqsicldffXXo+2bQYRLTer3ubNy40bn44ovbxiKTyShyCWDzBef97ne/ax7z4x//2InFYs4DDzwQ+r4RdA95prdDnucr95kuz3MX8kwXdAox5RUMDK6++mplfrphw4bmd6eddhrNzMzQLbfc0jwGJn06cAy+B8rlMl133XVtx8TjcfWZjxlUwHQX5j3HHHMMXXzxxW2mO2j7k570JEqn0239vv3222nv3r2hxmbYMMxzGRUwUYVJ68EHH6xMU2HKBaD/lUqlbQxgFrZly5bmGIS5b4YNd999N23btq2t35OTk8rsT+83zHePO+645jE4HtfItddeG/q+EfQPK/mZLs/zhRjWuYwKeZ4vhDzTBWGRDH2kQNBnYCGqL2AA/ozf/I7BQqdQKKjFZq1Wsx5z2223Dewcvv71r1d+s1NTU3TVVVfRueeeSw899BBdcsklzX4fdNBBnmOzevVqz7HhsRs27Nq1ayjnMipAtuAnffjhh6s5v+CCC5RP5M0336zmDqTK9MnW5zXMfTNs4Hb7Xc94h/+VjmQyqe4h/Zig+0bQ33lcic90eZ6v3Ge6PM/tkGe6ICyEmAq6wtvf/nb64Ac/6HvMrbfe2ub8v1IQZWze/OY3N7979KMfrcjImWeeSR/4wAdUkCfB8sXTnva0trnHwmbr1q106aWXqqA/AsFiQp7p3Y+LPM9XLuR5LhB0ByGmgq5w9tln08te9jLfY2CeGAYbN25cEJ2Po9XhN343I9jhM6JyYhGfSCTUy3YMlzEMYwNyAlPev/71r0pJ8+p3mLFZ7H73CmvXrh2YuVxMQB097LDD6I477qBTTz1Vmb/t27evTTXVxyDMfTNs4HajH4jKy8Dno48+unnMjh072s7DPYNIvUH3hF6HoB3yTLdDnufdYyU+0+V57kKe6YKwEB9TQVdYt26d2iH2e+n+XX444YQT6KabbmpbbP785z9XpPPII49sHnP55Ze3nYdj8D2Auo499ti2Y+r1uvrMxwzD2Nxwww3K94ZNFdF2hGKHv6Heb5BWNkcMGpthwyDN5WIC6U7uvPNORcjQ/1Qq1TYG8I+EDyqPQZj7ZtgA81ssZPR+w7QTvqN6v0HY4bPG+MUvfqGuEWzshL1vBO2QZ7od8jzvHivxmS7PcxfyTBeERsdhkwSCiLjnnntU+PMLLrjAGRsbU3/jNTs72xYm/SlPeYpzww03qBQw69ats6aLOeecc1R00k9+8pPWdDGI3vnlL39ZRe585StfqcLR61FLBwlXXXWVisiLPt95553Of/3Xf6l+v/SlL22LSIq0Fy95yUtU2gv0EeNgpotJJpPOhz/8YTU2iA64HNLFDNNcdoKzzz7b+dWvfuXcfffdag6RJgDpAXbs2NFML7BlyxbnF7/4hUovcMIJJ6gXI8x9M4jAfc/PAPxXhFRS+BvPCU4Xg7n+3ve+5/zxj390nvnMZ1rTxRxzzDHOtdde61x55ZXOoYce2pYuJsx9I+gc8kxfCHmer+xn+kp9ngPyTBf0AkJMBYuG008/XS1Azdcvf/nL5jF//etfnac97Wkq1yAe5njIVyqVtnJw/NFHH61yoR188MEqVYEJ5DfFwx/HIDw98hwOKq677jqV1gUpdLLZrHPEEUc4F154oVMsFtuOQy7HJz7xieo/9c2bN6uFu4lLL73UOeyww1S/kVbnhz/8oTPsGKa57ARId7Tffvup/mFe8fmOO+5o/g4i9prXvEalPQGpevazn61y4+kIc98MGnAf254HeE5wyph3vetdiljimj/55JOd22+/va2M3bt3KyKKjS6kxznjjDOaG11R7htBZ5Bn+kLI83xlP9NX6vMckGe6oBeI4Z/w+qpAIBAIBAKBQCAQCAS9hfiYCgQCgUAgEAgEAoFgSSHEVCAQCAQCgUAgEAgESwohpgKBQCAQCAQCgUAgWFIIMRUIBAKBQCAQCAQCwZJCiKlAIBAIBAKBQCAQCJYUQkwFAoFAIBAIBAKBQLCkEGIqEAgEAoFAIBAIBIIlhRBTgUAgEAgEAoFAIBAsKYSYClY0YrEYffe736XliPPPP582bNgwlH388pe/TKtWreq6nL/927+lN77xjT1p00pCuVymQw45hK666ir1+a9//au6jm644Yauyv3JT35CRx99NNXr9R61VCBoxzA+78JCnunyTO8U8kwXDAuEmAqWHV72spepxQleqVRKkbNTTz2VvvjFLy5YED/00EP0tKc9bdkteG699Va64IIL6LOf/WykPg4Knv/859Of//znpW7GQGIxyPZnPvMZOuigg+jEE0/sablPfepT1T351a9+taflCpY35Jkuz/TlDHmmCwQtCDEVLEtgAQxCBqXnxz/+Mf3d3/0dveENb6B/+Id/oGq12jxu48aNlMlkaLnhzjvvVO/PfOYzPfuIHdRBxcjICK1fv36pm7Gs4TX/juPQv/3bv9HLX/7yvpGMj3/8430pW7B8Ic90eaYL/CHPdMGygCMQLDOcfvrpzjOf+cwF319++eUOLvnPf/7zze/w+Tvf+Y76u1QqOWeddZazceNGJ5PJOFu2bHEuvPBC9dvWrVvVsfzCZ+COO+5wnvGMZzjr1693RkdHneOOO875+c9/3lYvjn3/+9/vnHHGGc7Y2JhzwAEHOJ/97GfbjrnvvvucF7zgBc7q1audXC7nHHvssc4111zT/P273/2uc8wxx6h2HXTQQc7555/vVCoVa//f/e53t7WVb3Mel/e9733Ofvvt5xx44IHq+z/+8Y/O3/3d3znZbNaZmppyXvGKVzizs7MLxhN9QD8nJyedCy64QNX/lre8RbV58+bNzhe/+EXPOfn+97+vzqtWq+rz9ddfr9r1tre9rXnMy1/+cudFL3qR+vtLX/qSOl7v01FHHeV85StfUeM5MTHhPP/5z3dmZmaax+TzeeclL3mJmgfM4Yc//GHnb/7mb5w3vOENzWP27Nmjjlm1apUzMjLiPPWpT3X+/Oc/q9/q9bqzdu1a57LLLmsejzpRFuOKK65w0um0Mzc359nXL3zhC86RRx6pjsO5uKYYe/fuVf1EPePj42rcb7jhhtD9xFyYc3v33Xer32666SbVH/Qf8/TiF7/Y2blzZ7NsjAXagvFYs2aN87d/+7fW9v/ud79z4vF429iiDtT1ta99zTnhhBPUdfiIRzzC+dWvftU85pe//KU65gc/+IHzqEc9Sh1z/PHHq3bpuOeee9RxuHcEgjCQZ7o80+WZLs90wcqAKKaCFYMnP/nJdNRRR9G3v/1t6+9Qcf7f//t/dOmll9Ltt9+uzA0PPPBA9dvvfvc79f6lL31JKbH8OZ/P09///d/T5ZdfTtdff73a1f/Hf/xHuvfee9vK/shHPkLHHXecOuY1r3kNvfrVr1Z1cBl/8zd/Qw888ICq/8Ybb6S3vvWtTbPjK664gl760pcqxfdPf/qTMs+FD+b73/9+az/e8pa3qHYCaCteDLQT9f785z+nH/zgBzQ3N0ennXYarV69WvXpsssuo//5n/+h1772tW1l/uIXv6AHH3yQ/vd//5cuueQSeve7363UZ5x37bXX0qte9So688wz6f7777e26aSTTqLZ2VnVf+DXv/41rV27ln71q181j8F3MGnyU4FhSo1244XjL7rooubv55xzjvrue9/7Hv3sZz9TZf/hD39YoNb9/ve/V+N89dVXK3UQ81epVJSp9pOe9KRmm/bu3atMoguFAt12223NNj72sY+lXC5nbeOnP/1pOuuss+iVr3wl3XTTTaoe+Goy/vmf/5l27NihVPzrrruOHvOYx9DJJ59Me/bsCdXP//t//y+dcMIJ9IpXvKI5twcccADt27dPXd/HHHOM6h98Obdv307Pe97z2tr3H//xH5ROp+k3v/mNMte1AdfbYYcdRuPj4wt+wxifffbZah7RDlzru3fvXnAMrndcT+vWrVPHYHwZW7ZsUeb1qEcg6AbyTJdnujzT5ZkuWGZYamYsECzW7joA9emII46wKqave93rnCc/+clKObNBP9YPUJI+8YlPND9D+YJ6xUD5ULQ+/elPq89QT6Ge7d6921reySef3FRuGf/5n/+pVE8voJ3m7Y1x2bBhg1KGGZ/73OeU4gm1kfHDH/5QKWbbtm1rnoc+1Gq15jGHH364c9JJJzU/QwmFUgdFzQuPecxjnIsvvlj9/axnPUspsFAVoc7ef//9qr2sXtoUUyjJuop3zjnnKEUOQBko69JLL23+jvGEKsqKKcpGHb/5zW+ax+zatUsdw+d9/OMfV/PHKjXKx7XEc3XKKac4/9//9/959nHTpk3OO97xDutvUFuhgBaLxbbvH/awhzUV9KB+AqYKDLz3ve91nvKUpyxQ4dHf22+/vXkeVPcgoGzcBzpYMb3oooua30Ex33///Z0PfvCDbYrp17/+9QVz8I1vfKOtPLQDqr9AEAbyTJdnuv48kWe6PNMFyxeimApWFMAvoYzZgJ1XRB09/PDD6fWvf71S3YIAtRMK5RFHHKGiyI6NjSmVzVRMH/3oRzf/Rv3w+4RyBqBOKF1TU1PWOqCgvuc971Fl84sVs/n5+Uj9f9SjHqUUMwbaChV5dHS0+d0TnvAEpdayogs84hGPoHi89biA4oWyGIlEgtasWdPskw1QhaFGYg6glj3nOc9R43bllVcqVXDTpk106KGHep4P9VpX8fbbb79mfVAZ4V9z/PHHN3/HeGIu9b4mk8m2Y9BmHIPfuI1QpXfu3NlUcPFCu6H6IUqtl6qLtkBVhgLqNY+4XlCnPpd333130yc4qJ9eQNm//OUv28p9+MMf3hwbxrHHHktBgEKczWatv0ElZWAsYQXAY2c7hufAPAY+xFGvXYHABnmmyzNdnun+kGe6YJiQXOoGCASLCSyQEW3UBphVgiTAzBLmrDCDPOWUU+ib3/ymZ3kgpTCL/fCHP6xMNrHg/qd/+qcFQQgQiVQHyCmb6uIcP4DMIMIuiJwJLwLhBZ2ARoGt/X59sgGEDpGRQaJwLogTkz6YzYIURm1Dr9OOgGyDTIGU4gVzaWwifPCDH1SmqSCnXpFqw8wjSKZuvszQU+N00k+UDZNZtNME6owy/zCxhhlyPwHTZZj5CgTdQp7p8kz3gzzT5ZkuGC6IYipYMYCfJBbcz33ucz2PmZiYUKlKPv/5z9M3vvEN+ta3vtX0/wNhqNVqbcfDVw9K67Of/Wz1HyBIDCIBRwHUVKimup+hSZihXoL4mi9dxewEUCxBFOFrqvcJ5epqYy/AfqYf/ehHmySUiSlefv6lQXjYwx6m5gf+rgyQXT3lDPqKiMz6MfCPxNgeeeSRTRKIdsJP9ZZbbqEnPvGJan5KpZLy7YVC6EXuoHJC7YQfr9c8btu2TSmN5jyCDIYFFG/zOkTZaC/qN8uOuhkB9R4+ta71ejuuueaa5t8YS/jJYly9juE50I8pFotKxUU9AkE3kGf6QsgzXZ7pJuSZLhgmCDEVLEuASIAEIKAQAuBceOGFKnUKAvYgkJANCOrzta99TS3KsZhGICAQTVazmHSgXCy4AZieIpgSiCUI3gtf+MLIKt6//Mu/qHqe9axnKVJ41113KUKM4DzAeeedR1/5yleUagryAYXg61//Or3zne/sepxe9KIXKdX19NNPp5tvvlmZg77uda+jl7zkJcpct5dAoCSQPASVYhKKYEOYH4x3kGLqB5iuIr0JAu9gsYq+YMNAJ+6YK1wDMIOG+TDm68UvfjFt3rxZfc9A23AdHH300apclIF2ot1BbTz//PNV4B8E0vrLX/6i+vaJT3xC/Qb1HWaumGeYiWMDA6bB73jHO1TAorDAdQhyjfN37dqlrjcEXMLGBq4lKLsgfj/96U/pjDPOWEBig4DUSlBgca2Z+OQnP0nf+c531D2COnEf/Ou//mvbMTA7x33CcwDSjT7rxBXpi3STX4EgCPJMDwd5psszXZ7pgmGGEFPBsgSiksKEEYt4RMoF4QJZgBIGf0gvxetDH/qQUsUQeRUL/x/96EdNcgPCAbNdREFltQdkFoQL5p0wpUSEW6hXUQAFDEQFeTsRIRbKK6KwcjtRJqKz4hi06/GPf7xSHbdu3dr1OCG6LAgMSA3KhhkyfCSRx7IfALEDUWJiCrNZqJUg5t0qtBdffLFSOzEPIIFQO02fSkQrxnfYoAAxgiqIOdbNZ802Avjb/M4GEPyPfexj9KlPfUr55aIeEFRWY1EXSC4IIyLfvuAFL6B77rkn0iYAzMdxbWDcYA4Lf2b452JTA218ylOeoq6hN77xjWpTJaqqDh9YWACAiJvAdYkX/JJB7hF12FR78TsiSGOcsYnz/e9/v82vGaQfi2evyMYCgQ3yTA8HeabLM12e6YJhRgwRkJa6EQKBQCAYHPzxj3+kU089VSmvUI3DAObYUFuhouo+szqg8GIDAgqxl6+3QCAQCHoLeaYLhgWimAoEAoGgDTC5RiAlBAPrJWCFADVZSKlAIBAsHuSZLhgWiGIqEAgEgq4RRjEVCAQCwXBAnumCpYAQU4FAIBAIBAKBQCAQLCnElFcgEAgEAoFAIBAIBEsKIaYCgUAgEAgEAoFAIFhSCDEVCAQCgUAgEAgEAsGSQoipQCAQCAQCgUAgEAiWFEJMBQKBQCAQCAQCgUCwpBBiKhAIBAKBQCAQCASCJYUQU4FAIBAIBAKBQCAQLCmEmAoEAoFAIBAIBAKBYEkhxFQgEAgEAoFAIBAIBLSU+P8B2Ieuny5/X+UAAAAASUVORK5CYII=", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -6002,7 +8175,7 @@ " downsample_method=\"random\",\n", " downsample_seed=raster_downsample_seed,\n", ")\n", - "print(\"Co-occurring-region raster stats:\", _raster_stats_brief(stats_co))\n" + "print(\"Co-occurring-region raster stats:\", cluster.raster_stats_brief(stats_co))\n" ] }, { @@ -6034,4 +8207,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} +} \ No newline at end of file diff --git a/tests/test_cluster.py b/tests/test_cluster.py index 1435d54..334a6bb 100644 --- a/tests/test_cluster.py +++ b/tests/test_cluster.py @@ -496,6 +496,152 @@ def test_read_window_feature_matrix_filters(): assert features.shape[0] == 1 +def test_read_window_feature_matrix_rich_spec_tracks_motifs(): + data = np.array( + [ + [0, 1, 1, 0, 1, 1, 0, 0], + [1, 1, 0, 0, 0, 0, 1, 1], + [0, 0, 1, 1, 1, 0, 1, 0], + ], + dtype=float, + ) + val = np.ones_like(data) + result = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=val, + metadata=[], + datasets=[], + regions_dict=None, + ) + + features, names, feature_table = cluster.read_window_feature_matrix( + result, + feature_spec={ + "motif_mode": "per_motif", + "motif_count": 2, + "motif_labels": ["A,0", "CG,0"], + "pooled": False, + "pca": {"enabled": False}, + "densities": {"enabled": True, "windows": [("center", -1, 1)]}, + "autocorr": {"enabled": False}, + "fft": {"enabled": True, "periods_bp": [2]}, + "asymmetry": {"enabled": True, "spans": [2]}, + "center_edge": {"enabled": True, "center_bp": 1, "edge_bp": 1}, + "cross_motif": {"enabled": True}, + }, + return_feature_table=True, + ) + + assert features.shape[0] == 3 + assert "A,0__center" in names + assert "CG,0__fft_power_period_2bp" in names + assert "A,0_minus_CG,0__mean" in names + assert {"A,0", "CG,0", "A,0|CG,0"}.issubset(set(feature_table["motif"])) + assert {"density", "fft", "cross_motif"}.issubset(set(feature_table["family"])) + + +def test_summarize_and_rank_feature_matrix(): + features = np.array([[0.0, 0.1], [0.2, 0.1], [1.0, 0.1], [1.2, 0.1]]) + names = ["signal", "constant"] + feature_table = pd.DataFrame( + { + "feature_name": names, + "family": ["density", "summary"], + "motif": ["A,0", "pooled"], + } + ) + + summary = cluster.summarize_feature_matrix( + features, + names, + feature_table=feature_table, + labels=["off", "off", "on", "on"], + ) + ranked = cluster.rank_read_features_by_group_difference( + features, + names, + ["off", "off", "on", "on"], + ) + + assert summary["n_reads"] == 4 + assert summary["zero_variance_features"] == 1 + assert summary["feature_counts_by_family"]["n_features"].sum() == 2 + assert ranked.iloc[0]["feature_name"] == "signal" + + +def test_scale_feature_matrix_standardizes_columns(): + features = np.array([[0.0, 10.0], [1.0, 10.0], [2.0, 10.0]]) + scaled, scale_table = cluster.scale_feature_matrix(features, ["a", "constant"]) + + np.testing.assert_allclose(scaled[:, 0].mean(), 0.0, atol=1e-12) + np.testing.assert_allclose(scaled[:, 0].std(), 1.0, atol=1e-12) + np.testing.assert_allclose(scaled[:, 1], np.zeros(3)) + assert scale_table.loc[0, "scaling_method"] == "standard" + assert scale_table.loc[1, "scale"] == 1.0 + + +def test_scale_feature_matrix_can_balance_and_skip_families(): + features = np.array([[0.0, 1.0, 10.0], [1.0, 2.0, 20.0], [2.0, 3.0, 30.0]]) + names = ["density_a", "density_b", "raw_count"] + feature_table = pd.DataFrame( + { + "feature_name": names, + "family": ["density", "density", "count"], + } + ) + + scaled, scale_table = cluster.scale_feature_matrix( + features, + names, + feature_table=feature_table, + family_weighting="equal_family", + unscaled_families=["count"], + ) + + np.testing.assert_allclose(scale_table.loc[:1, "family_weight"], [1 / np.sqrt(2)] * 2) + assert scale_table.loc[2, "scaled"] == np.False_ + np.testing.assert_allclose(scaled[:, 2], features[:, 2]) + + +def test_read_window_feature_matrix_inline_scaling_uses_feature_families_without_return_table(): + data = np.array( + [ + [0, 0, 1, 1], + [0, 1, 1, 1], + [1, 1, 0, 0], + ], + dtype=float, + ) + result = cluster.ReadWindowExtractionResult( + data_matrix=data, + val_matrix=np.ones_like(data), + metadata=[], + datasets=[], + regions_dict=None, + ) + + scaled, names = cluster.read_window_feature_matrix( + result, + n_pca=0, + autocorr_lags=(), + density_windows=(("left", -2, 0), ("right", 0, 2)), + scale_features=True, + unscaled_families=["density"], + ) + unscaled, unscaled_names, feature_table = cluster.read_window_feature_matrix( + result, + n_pca=0, + autocorr_lags=(), + density_windows=(("left", -2, 0), ("right", 0, 2)), + return_feature_table=True, + ) + + assert names == unscaled_names + density_cols = feature_table.index[feature_table["family"] == "density"].tolist() + assert density_cols + np.testing.assert_allclose(scaled[:, density_cols], unscaled[:, density_cols]) + + def test_plot_multisite_read_raster_smoke(monkeypatch): # Build a minimal ReadWindowExtractionResult with two motifs, two reads data = np.hstack( @@ -783,12 +929,64 @@ def test_plot_two_site_read_raster_wrapper(): assert stats["window_widths_bp"] == [4, 4] assert stats["coordinate_mode"] == "relative_to_primary" assert stats["downsample_method"] == "none" - data_axes = [ax for ax in fig.axes if ax.get_ylabel().endswith("Reads")] + data_axes = [ax for ax in fig.axes if ax.get_ylabel() == "Reads (sorted)"] assert data_axes assert data_axes[0].get_xlim()[0] <= -2 and data_axes[0].get_xlim()[1] >= 2 assert data_axes[1].get_xlim()[0] <= 1998 and data_axes[1].get_xlim()[1] >= 2002 +def test_plot_two_site_read_raster_position_y_keeps_site_limits_independent(): + import matplotlib + + matplotlib.use("Agg") + data = np.array( + [ + [0, 1, 0, 1], + [1, 0, 1, 0], + ], + dtype=float, + ) + meta = [ + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 0, + "region_end": 4, + "region_strand": "+", + "read_length": 8000, + }, + { + "read_name": "r1", + "chromosome": "chr1", + "region_start": 2000, + "region_end": 2004, + "region_strand": "+", + "read_length": 8000, + }, + ] + r = cluster.ReadWindowExtractionResult(data, None, meta, [], None) + + fig, stats = cluster.plot_two_site_read_raster( + r, + second_site_offset_bp=2000, + window_width_bp=4, + motif_index=0, + smoothing=None, + axis_orientation="position_y", + ) + + assert stats["window_plot_order"] == [1, 0] + data_axes = [ax for ax in fig.axes if ax.get_ylabel() == "Position (bp)"] + assert len(data_axes) == 2 + assert data_axes[0].get_ylim()[0] <= 1998 and data_axes[0].get_ylim()[1] >= 2002 + assert data_axes[1].get_ylim()[0] <= -2 and data_axes[1].get_ylim()[1] >= 2 + point_counts = [ + sum(len(collection.get_offsets()) for collection in ax.collections) + for ax in data_axes + ] + assert point_counts == [2, 2] + + def test_plot_multisite_read_raster_supports_fixed_offsets_with_primary_highlight(): import matplotlib @@ -845,7 +1043,7 @@ def test_plot_multisite_read_raster_supports_fixed_offsets_with_primary_highligh assert fig is not None assert stats["n_windows"] == 3 assert stats["window_offsets_bp"] == [0.0, 2000.0, 4000.0] - data_axes = [ax for ax in fig.axes if ax.get_ylabel().endswith("Reads")] + data_axes = [ax for ax in fig.axes if ax.get_ylabel() == "Reads (sorted)"] assert data_axes[1].spines["left"].get_linewidth() > data_axes[0].spines["left"].get_linewidth() @@ -893,8 +1091,8 @@ def test_plot_multisite_read_raster_heatmap_window_titles(): smoothing=None, ) titles = [axis.get_title() for axis in fig.axes if axis.get_title()] - assert "Window 1" in titles - assert "Window 2" in titles + assert "Site 1 (primary)" in titles + assert "Site 2" in titles def test_plot_multisite_read_raster_accepts_local_window_coordinate_mode(): @@ -1437,7 +1635,9 @@ def test_plot_multisite_read_raster_heatmap_smoothing_label_mentions_per_read_ax colorbar_axes = [ ax for ax in fig.axes - if "per-read smoothing along position axis" in ax.get_ylabel() + if "Signal heatmap" in ax.get_ylabel() + and "smoothed" in ax.get_ylabel() + and "gaussian" in ax.get_ylabel() ] assert colorbar_axes @@ -1489,7 +1689,7 @@ def test_plot_multisite_read_raster_heatmap_thresholds_still_use_colorbar(): assert fig is not None assert stats["render_mode"] == "heatmap" assert stats["ml_score_thresholds"] is None - assert any("window signal heatmap" in ax.get_ylabel() for ax in fig.axes) + assert any("Signal heatmap" in ax.get_ylabel() for ax in fig.axes) assert not any( legend.get_title().get_text() == "Motif thresholds" for legend in fig.legends ) @@ -1623,7 +1823,7 @@ def test_plot_multisite_read_raster_default_scatter_uses_ml_score_colorbar(): scatter_arrays = [ np.asarray(collection.get_array(), dtype=float) for axis in fig.axes - if axis.get_ylabel().endswith("Reads") + if axis.get_ylabel() == "Reads (sorted)" for collection in getattr(axis, "collections", []) if collection.get_array() is not None and len(collection.get_array()) > 0 ] @@ -1688,7 +1888,7 @@ def test_plot_multisite_read_raster_scatter_auto_downsamples_uniformly(): scatter_arrays = [ np.asarray(collection.get_array(), dtype=float) for axis in fig.axes - if axis.get_ylabel().endswith("Reads") + if axis.get_ylabel() == "Reads (sorted)" for collection in getattr(axis, "collections", []) if collection.get_array() is not None and len(collection.get_array()) > 0 ] diff --git a/tests/test_parse_bam.py b/tests/test_parse_bam.py index 522d29e..c0a2bd0 100644 --- a/tests/test_parse_bam.py +++ b/tests/test_parse_bam.py @@ -65,6 +65,30 @@ def test_check_bam_format_raises_on_malformed_tags_after_motifs_are_found(monkey parse_bam.check_bam_format("dummy.bam", motifs=["A,0", "CG,0"]) +def test_check_bam_format_warns_only_when_requested_motifs_missing(monkeypatch, capsys): + found_reads = [_FakeRead(["MM:Z:A+a?;C+m?"])] * parse_bam.NUM_READS_TO_CHECK + monkeypatch.setattr( + parse_bam.pysam, + "AlignmentFile", + lambda *args, **kwargs: _TagSequenceAlignmentFile(found_reads), + ) + + parse_bam.check_bam_format("dummy.bam", motifs=["A,0,a", "CG,0,m"]) + assert "no modified appropriately-coded" not in capsys.readouterr().out + + missing_reads = [_FakeRead(["MM:Z:A+a?"])] * parse_bam.NUM_READS_TO_CHECK + monkeypatch.setattr( + parse_bam.pysam, + "AlignmentFile", + lambda *args, **kwargs: _TagSequenceAlignmentFile(missing_reads), + ) + + parse_bam.check_bam_format("dummy.bam", motifs=["A,0,a", "CG,0,m"]) + out = capsys.readouterr().out + assert "no modified appropriately-coded values found for ['C']" in out + assert "parse_bam is looking for ['A,0,a', 'CG,0,m']" in out + + def test_threads_command_list_defaults_to_all_available_cores(monkeypatch): monkeypatch.setattr(parse_bam.multiprocessing, "cpu_count", lambda: 12) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index e1f41e2..6399486 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -9,6 +9,7 @@ plot_enrichment_profile, plot_reads, plotting, + plotting_matplotlib, ) from dimelo.models import ( ContrastSpec, @@ -1464,6 +1465,111 @@ def test_prepare_read_cluster_region_association_data_supports_association_stren assert payload["metadata"]["association_strength_aggregate"] == "max" +def test_prepare_read_cluster_region_association_data_cluster_sort_arbitrary_labels(): + table = pd.DataFrame( + { + "region_id": ["r1", "r1", "r1", "r2", "r2", "r2"], + "cluster": ["10", "alpha", 2, "10", "alpha", 2], + "fraction": [0.1, 0.8, 0.3, 0.9, 0.1, 0.4], + "count": [1, 8, 3, 9, 1, 4], + "total_reads": [10, 10, 10, 10, 10, 10], + } + ) + + natural = plotting.prepare_read_cluster_region_association_data( + table, + cluster_sort="natural", + ) + total = plotting.prepare_read_cluster_region_association_data( + table, + cluster_sort="total_association", + ) + explicit = plotting.prepare_read_cluster_region_association_data( + table, + cluster_order=["alpha"], + ) + + assert natural["metadata"]["cluster_order"] == ["10", 2, "alpha"] + assert total["metadata"]["cluster_order"] == ["10", "alpha", 2] + assert explicit["metadata"]["cluster_order"] == ["alpha", "10", 2] + assert natural["matrix_table"].columns.tolist() == ["region_id", "10", 2, "alpha"] + + +def test_plot_read_cluster_region_association_heatmap_cluster_order_override(): + table = pd.DataFrame( + { + "region_id": ["r1", "r1", "r2", "r2"], + "cluster": ["b", "a", "b", "a"], + "fraction": [0.7, 0.3, 0.2, 0.8], + "count": [7, 3, 2, 8], + "total_reads": [10, 10, 10, 10], + } + ) + payload = plotting.prepare_read_cluster_region_association_data(table) + + _fig, ax = plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib( + payload, + cluster_order=["a", "b"], + ) + + assert [tick.get_text() for tick in ax.get_xticklabels()] == ["a", "b"] + + +def test_prepare_read_cluster_region_association_data_supports_hierarchical_region_sort(): + table = pd.DataFrame( + { + "region_id": [ + "chr2:10-20:+", "chr2:10-20:+", + "chr1:10-20:+", "chr1:10-20:+", + "chr1:30-40:+", "chr1:30-40:+", + ], + "cluster": ["A", "B", "A", "B", "A", "B"], + "fraction": [0.9, 0.1, 0.2, 0.8, 0.7, 0.3], + "count": [9, 1, 2, 8, 7, 3], + "total_reads": [10, 10, 10, 10, 10, 10], + } + ) + + payload = plotting.prepare_read_cluster_region_association_data( + table, + region_sort=["cluster_fraction", "genomic"], + cluster_order=["A", "B"], + ) + + assert payload["metadata"]["region_sort"] == ["cluster_fraction", "genomic"] + assert payload["matrix_table"]["region_id"].tolist() == [ + "chr2:10-20:+", + "chr1:30-40:+", + "chr1:10-20:+", + ] + + +def test_plot_read_cluster_region_association_heatmap_region_sort_list_override(): + table = pd.DataFrame( + { + "region_id": ["chr2:10-20:+", "chr1:10-20:+"], + "cluster": ["A", "A"], + "fraction": [0.9, 0.2], + "count": [9, 2], + "total_reads": [10, 10], + } + ) + payload = plotting.prepare_read_cluster_region_association_data( + table, region_sort="input" + ) + + _fig, ax = plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib( + payload, + region_sort=["genomic"], + region_label_mode="region_id", + ) + + assert [tick.get_text() for tick in ax.get_yticklabels()] == [ + "chr1:10-20:+", + "chr2:10-20:+", + ] + + def test_prepare_read_cluster_region_association_data_accepts_legacy_wide_region_summary(): legacy_summary = pd.DataFrame( [ @@ -1588,6 +1694,41 @@ def test_plot_read_cluster_region_association_heatmap_matplotlib_accepts_region_ assert ytick_text[0].startswith("chr1:100-110:+") +def test_plot_read_cluster_region_association_heatmap_title_reflects_effective_flags(): + table = pd.DataFrame( + { + "region_id": ["chr1:10-20:+", "chr1:10-20:+", "chr2:10-20:+", "chr2:10-20:+"], + "cluster": ["b", "a", "b", "a"], + "fraction": [0.7, 0.3, 0.2, 0.8], + "count": [7, 3, 2, 8], + "total_reads": [10, 10, 10, 10], + } + ) + payload = plotting.prepare_read_cluster_region_association_data( + table, + region_sort="input", + cluster_sort="input", + ) + + _fig, ax = plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib( + payload, + region_sort=["association_strength", "genomic"], + association_strength_aggregate="mean", + cluster_sort="natural", + row_annotation_column="source_label", + region_label_mode="chromosome", + group_region_labels=True, + ) + + title = ax.get_title() + assert "Read-cluster association (fraction)" in title + assert "regions: association_strength > genomic" in title + assert "clusters: natural" in title + assert "strength: mean" in title + assert "annotated by source_label" in title + assert "grouped labels" in title + + def test_plot_read_cluster_region_association_heatmap_matplotlib_supports_row_annotations(): from dimelo import plotting_matplotlib @@ -1610,6 +1751,7 @@ def test_plot_read_cluster_region_association_heatmap_matplotlib_supports_row_an assert fig is not None assert ax is not None + assert ax.get_ylabel() == "" ytick_text = [tick.get_text() for tick in ax.get_yticklabels()] assert "on_target" in ytick_text[0] assert "off_target" in ytick_text[1] @@ -1622,6 +1764,96 @@ def test_plot_read_cluster_region_association_heatmap_matplotlib_supports_row_an assert left_side_axes # The source-bed strip should live fully to the left of the heatmap. assert max(axis.get_position().x1 for axis in left_side_axes) <= main_pos.x0 + fig.canvas.draw() + renderer = fig.canvas.get_renderer() + tick_left = min( + tick.get_window_extent(renderer).transformed(fig.transFigure.inverted()).x0 + for tick in ax.get_yticklabels() + if tick.get_text() + ) + assert max(axis.get_position().x1 for axis in left_side_axes) < tick_left - 0.01 + + +def test_plot_read_cluster_region_association_heatmap_matplotlib_supports_multiple_row_annotations(): + from dimelo import plotting_matplotlib + + payload = plotting.prepare_read_cluster_region_association_data( + _make_read_cluster_region_association_table(), + region_sort="genomic", + ) + axis_table = payload["region_axis_table"].copy() + axis_table["source_label"] = ["on_target", "off_target"] + axis_table["strand_group"] = ["plus", "minus"] + payload["region_axis_table"] = axis_table + + fig, ax = ( + plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib( + payload, + row_annotation_columns=["source_label", "strand_group"], + row_annotation_titles={ + "source_label": "Source bed", + "strand_group": "Strand", + }, + row_annotation_palettes={ + "source_label": { + "on_target": "#D95F02", + "off_target": "#1B9E77", + }, + "strand_group": {"plus": "#4C78A8", "minus": "#F58518"}, + }, + ) + ) + + assert fig is not None + assert ax is not None + assert "annotated by source_label, strand_group" in ax.get_title() + main_pos = ax.get_position() + left_side_axes = [ + axis + for axis in fig.axes + if axis is not ax and axis.get_position().x1 <= main_pos.x0 + ] + assert len(left_side_axes) == 2 + assert sorted(axis.get_title() for axis in left_side_axes) == [ + "Source bed", + "Strand", + ] + assert max(axis.get_position().x1 for axis in left_side_axes) <= main_pos.x0 + + +def test_plot_read_cluster_region_association_heatmap_preserves_annotations_with_cluster_sort_override(): + from dimelo import plotting_matplotlib + + table = pd.DataFrame( + { + "region_id": ["r1", "r1", "r2", "r2"], + "cluster": ["b", "a", "b", "a"], + "fraction": [0.7, 0.3, 0.2, 0.8], + "count": [7, 3, 2, 8], + "total_reads": [10, 10, 10, 10], + } + ) + payload = plotting.prepare_read_cluster_region_association_data(table) + axis_table = payload["region_axis_table"].copy() + axis_table["source_label"] = ["on_target", "off_target"] + axis_table["strand_group"] = ["plus", "minus"] + payload["region_axis_table"] = axis_table + + fig, ax = ( + plotting_matplotlib.plot_read_cluster_region_association_heatmap_matplotlib( + payload, + cluster_sort="natural", + row_annotation_columns=["source_label", "strand_group"], + ) + ) + + main_pos = ax.get_position() + left_side_axes = [ + axis + for axis in fig.axes + if axis is not ax and axis.get_position().x1 <= main_pos.x0 + ] + assert len(left_side_axes) == 2 def test_plot_read_cluster_region_association_heatmap_matplotlib_grouped_region_labels(): From 2b9f366ec84b2656144ab309ea280f920fd38078 Mon Sep 17 00:00:00 2001 From: ngamarra <53231126+ngamarra@users.noreply.github.com> Date: Wed, 29 Apr 2026 21:49:25 -0700 Subject: [PATCH 272/272] Align association legends and title spacing --- dimelo/plotting_matplotlib.py | 45 +- dimelo_test.ipynb | 860 ++++++++++++++++++---------------- tests/test_plotting.py | 11 +- 3 files changed, 478 insertions(+), 438 deletions(-) diff --git a/dimelo/plotting_matplotlib.py b/dimelo/plotting_matplotlib.py index 2ed35c4..9b95c40 100644 --- a/dimelo/plotting_matplotlib.py +++ b/dimelo/plotting_matplotlib.py @@ -1013,7 +1013,7 @@ def plot_read_cluster_region_association_heatmap_matplotlib( origin="upper", interpolation="nearest", ) - ax.figure.colorbar( + colorbar = ax.figure.colorbar( image, ax=ax, label=value_mode.replace("_", " ").title(), @@ -1146,7 +1146,8 @@ def plot_read_cluster_region_association_heatmap_matplotlib( row_annotation_columns=annotation_columns, group_region_labels=group_region_labels, region_label_mode=region_label_mode, - ) + ), + pad=14, ) if annotation_values_by_column and n_regions > 0: @@ -1241,19 +1242,16 @@ def plot_read_cluster_region_association_heatmap_matplotlib( ) strip_ax.set_xticks([]) strip_ax.set_yticks([]) - strip_ax.set_title( - _row_annotation_title( - annotation_column, - row_annotation_title=row_annotation_title, - row_annotation_titles=row_annotation_titles, - n_columns=len(annotation_values_by_column), - ), - fontsize=7, - pad=3, - rotation=90, - x=0.5, - y=1.01, + strip_title = _row_annotation_title( + annotation_column, + row_annotation_title=row_annotation_title, + row_annotation_titles=row_annotation_titles, + n_columns=len(annotation_values_by_column), ) + strip_ax.set_xlabel(strip_title, fontsize=7, labelpad=8) + strip_ax.xaxis.label.set_rotation(90) + strip_ax.xaxis.label.set_verticalalignment("top") + strip_ax.xaxis.label.set_horizontalalignment("center") legend_handles = [ Patch( @@ -1264,19 +1262,20 @@ def plot_read_cluster_region_association_heatmap_matplotlib( for value in ordered_annotations ] if legend_handles: - legend = ax.legend( + fig.canvas.draw() + legend_x = max( + colorbar.ax.get_position().x1 + 0.055, + ax.get_position().x1 + 0.12, + ) + legend = fig.legend( handles=legend_handles, - title=_row_annotation_title( - annotation_column, - row_annotation_title=row_annotation_title, - row_annotation_titles=row_annotation_titles, - n_columns=len(annotation_values_by_column), - ), + title=strip_title, loc="upper left", - bbox_to_anchor=(1.18, 1.0 - (0.18 * strip_idx)), + bbox_to_anchor=(legend_x, ax.get_position().y1 - (0.16 * strip_idx)), + bbox_transform=fig.transFigure, frameon=False, ) - ax.add_artist(legend) + fig.add_artist(legend) return fig, ax diff --git a/dimelo_test.ipynb b/dimelo_test.ipynb index 9275208..87f8686 100644 --- a/dimelo_test.ipynb +++ b/dimelo_test.ipynb @@ -153,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -172,7 +172,7 @@ "print('System:',platform.system())\n", "print('Release:',platform.release())\n", "print('Version:',platform.version())\n", - "print('Processor:',platform.processor())" + "print('Processor:',platform.processor())\n" ] }, { @@ -191,14 +191,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "1fda0c7af44d600796e84654ea844fc199a1f62a\n" + "48d55c3d37523f09a7aead10b19b0afe426f2930\n" ] } ], @@ -218,7 +218,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -307,7 +307,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -345,7 +345,7 @@ "type": "float" } ], - "ref": "7789f5c4-ac3b-4e26-9826-030eca979504", + "ref": "9b72b298-84e1-4344-bdfd-2b213cc094ad", "rows": [ [ "0", @@ -477,7 +477,7 @@ "type": "boolean" } ], - "ref": "d060be50-4cd2-47bf-92e7-adb0f0fa071c", + "ref": "be7427c9-cb8b-4f54-bc76-a1521287ea3b", "rows": [ [ "0", @@ -593,7 +593,7 @@ "type": "boolean" } ], - "ref": "04a5c483-e058-4a54-a9ba-fec9c10e0113", + "ref": "f7677d08-9e7d-4538-949e-05d164428e89", "rows": [ [ "0", @@ -724,7 +724,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -735,7 +735,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -760,7 +760,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -786,7 +786,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -818,30 +818,9 @@ "# !gunzip ./test/output/chm13.draft_v1.0.fasta.gz" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Basic Use Overview" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For details on parameters and functionality breakdown, please read the README sections on **Basic Use**, especially **Parameters and what they mean**." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Parsing" - ] - }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -951,6 +930,27 @@ " return parse_bam.extract(output_name=output_name, overwrite=overwrite, **extract_kwargs)\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Basic Use Overview" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For details on parameters and functionality breakdown, please read the README sections on **Basic Use**, especially **Parameters and what they mean**." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Parsing" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -971,7 +971,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -981,7 +981,11 @@ "This is expected to fail. Read the error message below:\n", "\n", "\n", - "name 'MODKIT_BINARY' is not defined\n" + "Base modification tags are out of spec (Mm and Ml instead of MM and ML). \n", + "\n", + "Consider using \"modkit update-tags dimelo/test/data/ctcf_demo.sorted.bam new_file.bam\" in the command line with your conda environment active and then trying with the new file. For megalodon basecalling/modcalling, you may also need to pass \"--mode ambiguous.\n", + "Be sure to index the resulting .bam file.\"\n", + "If you are confident that your inputs are ok, pass \"override_checks=True\" to convert to warning and proceed with processing.\n" ] } ], @@ -1021,7 +1025,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -1078,7 +1082,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -1102,7 +1106,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -1134,25 +1138,32 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\n", - "WARNING: no modified appropriately-coded values found for [] in the first 100 reads. \n", - "Do you expect this file to contain these modifications? parse_bam is looking for ['A,0', 'CG,0'] but for [] found only found [].\n", - "\n", - "Consider passing only the motifs and mod codes (e.g. m,h,a) that you expect to be present in your file. \n", - "You can use modkit adjust-mods --convert [OPTIONS] to update or consolidate mod codes.\n", - "See https://github.com/nanoporetech/modkit/blob/master/book/src/advanced_usage.md\n", - " \n", "No specified number of cores requested. 10 available on machine, allocating all.\n", "Detected multiple motif contexts with modkit 0.6.x; running per-motif pileups and merging outputs to avoid mixed-motif empty output behavior.\n", "Modification threshold of 190.0 assumed to be for range 0-255. 190.0/255=0.7450980392156863 will be sent to modkit.\n" ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mKeyboardInterrupt\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[14]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m pileup_file, pileup_regions = \u001b[43mensure_pileup_output\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 2\u001b[39m \u001b[43m \u001b[49m\u001b[43minput_file\u001b[49m\u001b[43m=\u001b[49m\u001b[43mctcf_bam_file_updated\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 3\u001b[39m \u001b[43m \u001b[49m\u001b[43moutput_name\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mctcf_demo_pileup_on_target\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 4\u001b[39m \u001b[43m \u001b[49m\u001b[43mref_genome\u001b[49m\u001b[43m=\u001b[49m\u001b[43mref_genome_file\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 5\u001b[39m \u001b[43m \u001b[49m\u001b[43moutput_directory\u001b[49m\u001b[43m=\u001b[49m\u001b[43moutput_dir\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 6\u001b[39m \u001b[43m \u001b[49m\u001b[43mregions\u001b[49m\u001b[43m=\u001b[49m\u001b[43m[\u001b[49m\u001b[43mctcf_target_regions\u001b[49m\u001b[43m,\u001b[49m\u001b[43mctcf_off_target_regions\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 7\u001b[39m \u001b[43m \u001b[49m\u001b[43mmotifs\u001b[49m\u001b[43m=\u001b[49m\u001b[43m[\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mA,0\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mCG,0\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 8\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m# parsing can optionally specify mod codes.\u001b[39;49;00m\n\u001b[32m 9\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m# The default is Y or a for adenine and m or Z for cytosine, corresponding to methylation\u001b[39;49;00m\n\u001b[32m 10\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m# motifs=['A,0,Y','CG,0,Z'],\u001b[39;49;00m\n\u001b[32m 11\u001b[39m \u001b[43m \u001b[49m\u001b[43mthresh\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m190\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 12\u001b[39m \u001b[43m \u001b[49m\u001b[43mwindow_size\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m1000\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 13\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m# cores=1, # uncomment to reduce memory usage\u001b[39;49;00m\n\u001b[32m 14\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m# cleanup=False,\u001b[39;49;00m\n\u001b[32m 15\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m# log=True,\u001b[39;49;00m\n\u001b[32m 16\u001b[39m \u001b[43m \u001b[49m\u001b[43mquiet\u001b[49m\u001b[43m=\u001b[49m\u001b[43mPARSE_QUIET\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 17\u001b[39m \u001b[43m \u001b[49m\u001b[43mmodkit_executable\u001b[49m\u001b[43m=\u001b[49m\u001b[43mMODKIT_BINARY\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 18\u001b[39m \u001b[43m)\u001b[49m\n", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[13]\u001b[39m\u001b[32m, line 71\u001b[39m, in \u001b[36mensure_pileup_output\u001b[39m\u001b[34m(output_name, overwrite, **pileup_kwargs)\u001b[39m\n\u001b[32m 68\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mDetected empty/invalid pileup output at \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mpileup_out\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m; regenerating.\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 69\u001b[39m overwrite = \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m71\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mparse_bam\u001b[49m\u001b[43m.\u001b[49m\u001b[43mpileup\u001b[49m\u001b[43m(\u001b[49m\u001b[43moutput_name\u001b[49m\u001b[43m=\u001b[49m\u001b[43moutput_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moverwrite\u001b[49m\u001b[43m=\u001b[49m\u001b[43moverwrite\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mpileup_kwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/Documents/GitHub/dimelo-toolkit/dimelo/parse_bam.py:637\u001b[39m, in \u001b[36mpileup\u001b[39m\u001b[34m(input_file, output_name, ref_genome, output_directory, regions, motifs, thresh, window_size, cores, log, cleanup, overwrite, quiet, override_checks, modkit_executable)\u001b[39m\n\u001b[32m 614\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m_run_pileup_command\u001b[39m(\n\u001b[32m 615\u001b[39m extra_args: \u001b[38;5;28mlist\u001b[39m[\u001b[38;5;28mstr\u001b[39m],\n\u001b[32m 616\u001b[39m *,\n\u001b[32m 617\u001b[39m base_command: \u001b[38;5;28mlist\u001b[39m[\u001b[38;5;28mstr\u001b[39m] = base_pileup_command,\n\u001b[32m 618\u001b[39m motifs_for_progress: \u001b[38;5;28mlist\u001b[39m[\u001b[38;5;28mtuple\u001b[39m[\u001b[38;5;28mstr\u001b[39m, \u001b[38;5;28mint\u001b[39m, \u001b[38;5;28mstr\u001b[39m]] = group_motifs,\n\u001b[32m 619\u001b[39m ) -> \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 620\u001b[39m run_modkit.run_with_progress_bars(\n\u001b[32m 621\u001b[39m command_list=base_command + extra_args,\n\u001b[32m 622\u001b[39m input_file=input_file,\n\u001b[32m (...)\u001b[39m\u001b[32m 634\u001b[39m quiet=quiet,\n\u001b[32m 635\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m637\u001b[39m \u001b[43m_run_pileup_command\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgroup_mod_thresh_command_list\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 639\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m split_pileup_runs:\n\u001b[32m 640\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mopen\u001b[39m(output_bedmethyl, \u001b[33m\"\u001b[39m\u001b[33mw\u001b[39m\u001b[33m\"\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m merged_file:\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/Documents/GitHub/dimelo-toolkit/dimelo/parse_bam.py:620\u001b[39m, in \u001b[36mpileup.._run_pileup_command\u001b[39m\u001b[34m(extra_args, base_command, motifs_for_progress)\u001b[39m\n\u001b[32m 614\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m_run_pileup_command\u001b[39m(\n\u001b[32m 615\u001b[39m extra_args: \u001b[38;5;28mlist\u001b[39m[\u001b[38;5;28mstr\u001b[39m],\n\u001b[32m 616\u001b[39m *,\n\u001b[32m 617\u001b[39m base_command: \u001b[38;5;28mlist\u001b[39m[\u001b[38;5;28mstr\u001b[39m] = base_pileup_command,\n\u001b[32m 618\u001b[39m motifs_for_progress: \u001b[38;5;28mlist\u001b[39m[\u001b[38;5;28mtuple\u001b[39m[\u001b[38;5;28mstr\u001b[39m, \u001b[38;5;28mint\u001b[39m, \u001b[38;5;28mstr\u001b[39m]] = group_motifs,\n\u001b[32m 619\u001b[39m ) -> \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m620\u001b[39m \u001b[43mrun_modkit\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrun_with_progress_bars\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 621\u001b[39m \u001b[43m \u001b[49m\u001b[43mcommand_list\u001b[49m\u001b[43m=\u001b[49m\u001b[43mbase_command\u001b[49m\u001b[43m \u001b[49m\u001b[43m+\u001b[49m\u001b[43m \u001b[49m\u001b[43mextra_args\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 622\u001b[39m \u001b[43m \u001b[49m\u001b[43minput_file\u001b[49m\u001b[43m=\u001b[49m\u001b[43minput_file\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 623\u001b[39m \u001b[43m \u001b[49m\u001b[43mref_genome\u001b[49m\u001b[43m=\u001b[49m\u001b[43mref_genome\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 624\u001b[39m \u001b[43m \u001b[49m\u001b[43mmotifs\u001b[49m\u001b[43m=\u001b[49m\u001b[43mmotifs_for_progress\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 625\u001b[39m \u001b[43m \u001b[49m\u001b[43mload_fasta_regex\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43mr\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43ms+\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43m[.*?\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43m]\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43ms+(\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43md+)\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43ms+Reading\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 626\u001b[39m \u001b[43m \u001b[49m\u001b[43mfind_motifs_regex\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43mr\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43ms+(\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43md+)/(\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43md+)\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43ms+finding\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43ms+([A-Za-z0-9,]+)\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43ms+motifs\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 627\u001b[39m \u001b[43m \u001b[49m\u001b[43mcontigs_progress_regex\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43mr\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43ms+(\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43md+)/(\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43md+)\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43ms+contigs\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 628\u001b[39m \u001b[43m \u001b[49m\u001b[43msingle_contig_regex\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43mr\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43ms+(\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43md+)/(\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43md+)\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43ms+processing\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43ms+([\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43mw]+)[^\u001b[39;49m\u001b[33;43m\\\u001b[39;49m\u001b[33;43mw]\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 629\u001b[39m \u001b[43m \u001b[49m\u001b[43mbuffer_size\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m50\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 630\u001b[39m \u001b[43m \u001b[49m\u001b[43mprogress_granularity\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m25\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 631\u001b[39m \u001b[43m \u001b[49m\u001b[43mdone_str\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mDone\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 632\u001b[39m \u001b[43m \u001b[49m\u001b[43merr_str\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mError\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 633\u001b[39m \u001b[43m \u001b[49m\u001b[43mexpect_done\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[32m 634\u001b[39m \u001b[43m \u001b[49m\u001b[43mquiet\u001b[49m\u001b[43m=\u001b[49m\u001b[43mquiet\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 635\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/Documents/GitHub/dimelo-toolkit/dimelo/run_modkit.py:393\u001b[39m, in \u001b[36mrun_with_progress_bars\u001b[39m\u001b[34m(command_list, input_file, ref_genome, motifs, load_fasta_regex, find_motifs_regex, contigs_progress_regex, single_contig_regex, buffer_size, progress_granularity, done_str, err_str, expect_done, quiet)\u001b[39m\n\u001b[32m 390\u001b[39m \u001b[38;5;66;03m# Grab output bytes for as long as they're coming\u001b[39;00m\n\u001b[32m 391\u001b[39m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[32m 392\u001b[39m \u001b[38;5;66;03m# Wait for the process to be ready to provide bytes\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m393\u001b[39m ready, _, _ = select.select([master_fd], [], [], \u001b[32m0.1\u001b[39m)\n\u001b[32m 394\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m ready:\n\u001b[32m 395\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m 396\u001b[39m \u001b[38;5;66;03m# Read a single byte\u001b[39;00m\n", + "\u001b[31mKeyboardInterrupt\u001b[39m: " + ] } ], "source": [ @@ -1205,7 +1216,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -1270,7 +1281,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "24e92fdb09d24ffa82d35f1ab4076273", + "model_id": "3224e68446bd487c9f0afbac2866253c", "version_major": 2, "version_minor": 0 }, @@ -1284,7 +1295,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "69c4c48aff8d4b309d6a8e3306cfeee4", + "model_id": "8324aeda6c6b48cd875e7cb382b349fe", "version_major": 2, "version_minor": 0 }, @@ -1341,7 +1352,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f4aa883afb0a454c8427c67ca9b5322d", + "model_id": "450d66b42aa24f10b41558c594692e95", "version_major": 2, "version_minor": 0 }, @@ -1355,7 +1366,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5791b6bf33e34aa5a1656e339fc1a344", + "model_id": "621cba3c7f75482b8bcf72b7bfd2d51a", "version_major": 2, "version_minor": 0 }, @@ -1425,7 +1436,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d1aaf21a0a0c4519ac298c982b2f9ad3", + "model_id": "a5bed285765d43a9b7ef1cd90fd0f87a", "version_major": 2, "version_minor": 0 }, @@ -1439,7 +1450,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "97c1f7973f2643229ad014ec2a70090f", + "model_id": "64efa19eb4974453ab71235a131e45ee", "version_major": 2, "version_minor": 0 }, @@ -1489,7 +1500,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0fdc6991c11f46e89a5c9991bb959bb3", + "model_id": "35635fc4a5364f339106d27b14ffb878", "version_major": 2, "version_minor": 0 }, @@ -1503,7 +1514,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9ad7ba2314834200afd9dfa99c8bf515", + "model_id": "d3393ade59f047bab1ed7032bb48ebc9", "version_major": 2, "version_minor": 0 }, @@ -1553,7 +1564,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ee40d8033ae149e8849b672d240d4ed1", + "model_id": "787fb81945da4a4dbb1343ca73885187", "version_major": 2, "version_minor": 0 }, @@ -1567,7 +1578,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ab696faac6c549fe9d7ba8461c2c2fe2", + "model_id": "17e72d76a70144529d6fb9e12a3861c4", "version_major": 2, "version_minor": 0 }, @@ -1642,7 +1653,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1728,14 +1739,6 @@ "name": "stdout", "output_type": "stream", "text": [ - "\n", - "WARNING: no modified appropriately-coded values found for [] in the first 100 reads. \n", - "Do you expect this file to contain these modifications? parse_bam is looking for ['A,0', 'CG,0'] but for [] found only found [].\n", - "\n", - "Consider passing only the motifs and mod codes (e.g. m,h,a) that you expect to be present in your file. \n", - "You can use modkit adjust-mods --convert [OPTIONS] to update or consolidate mod codes.\n", - "See https://github.com/nanoporetech/modkit/blob/master/book/src/advanced_usage.md\n", - " \n", "No specified number of cores requested. 10 available on machine, allocating all.\n", "No valid base modification threshold provided. Raw probabilities will be saved.\n" ] @@ -1822,7 +1825,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "" ] @@ -1878,7 +1881,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5f78cc63164645da952774ce8cca04c9", + "model_id": "e2a84e17ab154cf5864bacd00fd93286", "version_major": 2, "version_minor": 0 }, @@ -1892,7 +1895,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5a10462480a04f1880c70ed08823c828", + "model_id": "f44f48f6e36b479395a33f044aa36c60", "version_major": 2, "version_minor": 0 }, @@ -1980,7 +1983,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6bee107d362748fe828eec0b3b9ca28b", + "model_id": "8cf6434f7cd84e668099f45cad69f56e", "version_major": 2, "version_minor": 0 }, @@ -1994,7 +1997,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4b0e656284834f0da0884e46af9c1b30", + "model_id": "1dca410b0d60474f820b343705bcf7a9", "version_major": 2, "version_minor": 0 }, @@ -2008,7 +2011,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "aa30fd07df2348baae3a09ede7a28600", + "model_id": "d83f512aa999484d9ed5e1302988533a", "version_major": 2, "version_minor": 0 }, @@ -2022,7 +2025,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "354cd2b985414b62a190a00f1f7b2b23", + "model_id": "9af2ece247e94d09a6412d6fae079acf", "version_major": 2, "version_minor": 0 }, @@ -2118,7 +2121,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "57d61141a4d84208a62c31f35557089c", + "model_id": "cc93553616114765a9c51a018150cbb6", "version_major": 2, "version_minor": 0 }, @@ -2168,7 +2171,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ed3971d1c88e483fa5447ab398ebf7cb", + "model_id": "1b2b4fd395cc4172afcc350552b0c69b", "version_major": 2, "version_minor": 0 }, @@ -2226,7 +2229,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 40, "metadata": {}, "outputs": [ { @@ -2265,18 +2268,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a52c15b37e994fd89cd5040b3b14c6c5", + "model_id": "d85fe1c0ce174e12a42636a6e5356622", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Step 1: Indexing contigs in pileup.sorted.bed.gz to set up bigwig header for pileup.fractions.no_ref.bigwig: \u2026" + "Step 1: Indexing contigs in pileup.sorted.bed.gz to set up bigwig header for pileup.fractions.no_ref.bigwig: …" ] }, "metadata": {}, @@ -2285,7 +2288,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e22eaacdd0044a0a836b21d4916cde7d", + "model_id": "041a0993dd78416e8bc59891a1e6470b", "version_major": 2, "version_minor": 0 }, @@ -2299,7 +2302,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ce8147f44e724889930df0dffcaa6e06", + "model_id": "ade839abde114d0a9020f772156a3048", "version_major": 2, "version_minor": 0 }, @@ -2313,7 +2316,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6b8adc997f7342a2853f1fc2d4ae2a6f", + "model_id": "31870c31134645e48e02feebba50bb51", "version_major": 2, "version_minor": 0 }, @@ -2327,7 +2330,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e9ea4839f51e40119595c18082764f32", + "model_id": "4c18dcda64604bee96b1ca2c8e62ea58", "version_major": 2, "version_minor": 0 }, @@ -2341,7 +2344,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "23276601e5524448964ad054d5fab11d", + "model_id": "07b335ee5a184393baf57254a2d204f4", "version_major": 2, "version_minor": 0 }, @@ -2355,7 +2358,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3b9bf95719314ea491ab0958ea0467ec", + "model_id": "5595c3201c8e4f4aa39b9c8d984536b4", "version_major": 2, "version_minor": 0 }, @@ -2369,7 +2372,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4bd2bc98030a401b90cd52954dc7795c", + "model_id": "fca642ab9bfd47678c9ed89ba7fac6d0", "version_major": 2, "version_minor": 0 }, @@ -2383,7 +2386,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "033bac47ee174864ac86608fac8980c8", + "model_id": "5e1dc0dfdcc34568bddd9c94ff8fa8f8", "version_major": 2, "version_minor": 0 }, @@ -2397,7 +2400,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "cce5d02fbe1b4421b690794174581903", + "model_id": "e92141a5266e4e2b90749880910ababc", "version_major": 2, "version_minor": 0 }, @@ -2411,7 +2414,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "05c9857c65814f0785c1656a90311ecf", + "model_id": "dd77f4cb094b4e9bb7f63090eb2b612e", "version_major": 2, "version_minor": 0 }, @@ -2425,7 +2428,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a1c7b00d82aa44d0a375a27e1b3d2398", + "model_id": "6ceacd6482ff40b2a36e302b28f9c265", "version_major": 2, "version_minor": 0 }, @@ -2439,7 +2442,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a6101dc20a0847f397711efc08f78550", + "model_id": "34332d129bf34f0e958f9df8a81bb862", "version_major": 2, "version_minor": 0 }, @@ -2453,7 +2456,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "cbf5ef3837874a3b99f7c47f76b746bf", + "model_id": "b22bf705ff974f60a60a5f37d267f549", "version_major": 2, "version_minor": 0 }, @@ -2467,7 +2470,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e8e3ea883c1749cc89117883d1273fe6", + "model_id": "45d8469786f8484ba2bbabc99e78c266", "version_major": 2, "version_minor": 0 }, @@ -2481,7 +2484,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ea066d6aa0ea45feb7cf22eabb607ef8", + "model_id": "9b761bf45f1a473fbd69abee1b20dacb", "version_major": 2, "version_minor": 0 }, @@ -2495,7 +2498,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "22e12fe22bd0458289c06573a72baa33", + "model_id": "4d669163ff1c44df924d25d288bd351b", "version_major": 2, "version_minor": 0 }, @@ -2509,7 +2512,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ffc3c5d9bd3b4959a3934a74bc19c684", + "model_id": "4867073420c14455b3fa7bed8ec19b5b", "version_major": 2, "version_minor": 0 }, @@ -2523,12 +2526,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "cbe7f81faafe4a1988f884d5c69a1f3b", + "model_id": "d4d1f972f5f047cba0647a67ae110df8", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Step 2: Writing pileup.sorted.bed.gz contents to pileup.fractions.no_ref.bigwig: 0%| | 0/17 [00:00<\u2026" + "Step 2: Writing pileup.sorted.bed.gz contents to pileup.fractions.no_ref.bigwig: 0%| | 0/17 [00:00<…" ] }, "metadata": {}, @@ -2537,7 +2540,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3d13a9476fa749168b8a11df882ce7aa", + "model_id": "2abdf2fcdd5c40b8b8b456c6293ed45f", "version_major": 2, "version_minor": 0 }, @@ -2551,7 +2554,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3976673f6e7f47ab923e88c7a25acb7c", + "model_id": "665e36b163fd43cabea799dff58c82d5", "version_major": 2, "version_minor": 0 }, @@ -2565,7 +2568,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0acc1060ad974e41a4289e2e39fabc83", + "model_id": "278792daecd64608b80bd74253530fe0", "version_major": 2, "version_minor": 0 }, @@ -2579,7 +2582,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "82471069fe9c42198ead8369f7586da2", + "model_id": "9b3e4b0778d14c2e9e4ad26e6c2152c4", "version_major": 2, "version_minor": 0 }, @@ -2593,7 +2596,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1efb7e51fe6a49d39000f13930249bcc", + "model_id": "850b17eb27a649fb98ae1a27918559ad", "version_major": 2, "version_minor": 0 }, @@ -2607,7 +2610,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "971cb0a576754378b8570bde03ef9753", + "model_id": "e622deef5cdd47a59770d2cdfcce8c55", "version_major": 2, "version_minor": 0 }, @@ -2621,7 +2624,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1810a7b506804665827dc47ad3d28f7d", + "model_id": "7e1c426cf4c84397bc29058e9641dfdd", "version_major": 2, "version_minor": 0 }, @@ -2635,7 +2638,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "35c7fd86590148d49b48deb1d9eda435", + "model_id": "4273550ea05f450aa687109114836a60", "version_major": 2, "version_minor": 0 }, @@ -2649,7 +2652,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "702050a82d48462282738e590e7b6b03", + "model_id": "2df2e46e922c478fa83c7855f14a7c85", "version_major": 2, "version_minor": 0 }, @@ -2663,7 +2666,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "206aa7fa744340faa9fcb61b87fea201", + "model_id": "6214b85dd3be4d0e99de2855aaa17a8b", "version_major": 2, "version_minor": 0 }, @@ -2677,7 +2680,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "75288e60fb174f9cae70447b874ed4b8", + "model_id": "acdf685fa2754a12a295ed228b35d1be", "version_major": 2, "version_minor": 0 }, @@ -2691,7 +2694,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "77ebad9ec35947858ce03e37068952d3", + "model_id": "0736a7afe005402689e09b36b95af2e8", "version_major": 2, "version_minor": 0 }, @@ -2705,7 +2708,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3060f5b1fe8c40a69761a0fbea9b9672", + "model_id": "dc8f53b4d43348cb9414b7c5741370b3", "version_major": 2, "version_minor": 0 }, @@ -2719,7 +2722,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "56155c067f8d4f63bfa5fa39f636d45e", + "model_id": "5af35175f6a745ab8a9b4cbc81d432b0", "version_major": 2, "version_minor": 0 }, @@ -2733,7 +2736,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a48bdb3e42e14933b4353f50ffd89927", + "model_id": "c1152a86d5af48409e9819644a487119", "version_major": 2, "version_minor": 0 }, @@ -2747,7 +2750,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "67ec9acb00fa4a62a2084350bbda3d4f", + "model_id": "bd025141df864f70ba4f99bedc250842", "version_major": 2, "version_minor": 0 }, @@ -2761,7 +2764,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "99673ee5f3964be7bb091820b031f96b", + "model_id": "50b9cd9d6a12428a859c3c19cf4c67a0", "version_major": 2, "version_minor": 0 }, @@ -2802,18 +2805,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 42, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1a6c359defe345a48dad4bfa297ff45a", + "model_id": "2ff7b947781741cbb175beb650dda270", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Step 1: Indexing contigs in chm13.draft_v1.0.fasta to set up bigwig header for pileup.fractions.with_ref.bigwi\u2026" + "Step 1: Indexing contigs in chm13.draft_v1.0.fasta to set up bigwig header for pileup.fractions.with_ref.bigwi…" ] }, "metadata": {}, @@ -2822,12 +2825,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5cb9dee1d33f4d8bb4707dd94eb3395b", + "model_id": "5813c497f87e45049a2bfbc573d8e06b", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Step 2: Writing pileup.sorted.bed.gz contents to pileup.fractions.with_ref.bigwig: 0%| | 0/17 [00:0\u2026" + "Step 2: Writing pileup.sorted.bed.gz contents to pileup.fractions.with_ref.bigwig: 0%| | 0/17 [00:0…" ] }, "metadata": {}, @@ -2836,7 +2839,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6bc90847103e4f03b6b1efebafd336b3", + "model_id": "b4109f9bd7f247e18e05b5b52172dc2b", "version_major": 2, "version_minor": 0 }, @@ -2850,7 +2853,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "376e831962714480b1bc1aed353c7590", + "model_id": "4d9738818337491984be8a229df716b2", "version_major": 2, "version_minor": 0 }, @@ -2864,7 +2867,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "339e79f4a14543beb911ae852237d377", + "model_id": "57879af586394f99904427f69b0ff400", "version_major": 2, "version_minor": 0 }, @@ -2878,7 +2881,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5a4a35812bcd44a1acdfefa99c55b7f1", + "model_id": "ef9ae6e6910e48fc92751ae895ce4a28", "version_major": 2, "version_minor": 0 }, @@ -2892,7 +2895,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "640fa756b3324cac8e3e0e7685f0a875", + "model_id": "84b65fb271f94091a4270eff2b57327c", "version_major": 2, "version_minor": 0 }, @@ -2906,7 +2909,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "810e1b22851648d9b924fe525bc2ac76", + "model_id": "755c448e997a40c0b2c24e3766c5d4b7", "version_major": 2, "version_minor": 0 }, @@ -2920,7 +2923,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e4865783c03b4ac19ce94a1dff99d9e3", + "model_id": "69117e5eb6e74e6fa9453d24f2a64287", "version_major": 2, "version_minor": 0 }, @@ -2934,7 +2937,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c3d37cf1276243ffadfcdfbe9500f126", + "model_id": "74f899fde77f4ee385f2823d9a974cce", "version_major": 2, "version_minor": 0 }, @@ -2948,7 +2951,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3ef31c349b1543d6ada41768b1ae8a2f", + "model_id": "94f16917e1e34411bae40034b5a7defc", "version_major": 2, "version_minor": 0 }, @@ -2962,7 +2965,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "140d04227919415582a67c3166b8a7a6", + "model_id": "f7f4b82b285a442eab00b044eac4a77c", "version_major": 2, "version_minor": 0 }, @@ -2976,7 +2979,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a052de744eee44f39b6dfeb2ca159d8a", + "model_id": "b21c50c5160e49de9e11fa3dbb56db3c", "version_major": 2, "version_minor": 0 }, @@ -2990,7 +2993,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c543251923ca492380b4075e42cd5439", + "model_id": "936bd63d909e4b10ab84b4484353db72", "version_major": 2, "version_minor": 0 }, @@ -3004,7 +3007,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a0e1467def7a449e955c14be66e59133", + "model_id": "099af23186fa483f9d483abb4e5af755", "version_major": 2, "version_minor": 0 }, @@ -3018,7 +3021,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "489b5040c4254bbebf2bd1defe2ee5f6", + "model_id": "586cf993a45f4da8a64721823b8e298b", "version_major": 2, "version_minor": 0 }, @@ -3032,7 +3035,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a1f3683f36f149e2afa3e7db216d155d", + "model_id": "6c9ee87974764de2935e6761b6622bfb", "version_major": 2, "version_minor": 0 }, @@ -3046,7 +3049,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9758166db71642c9a73d48b0818316fc", + "model_id": "312abbd495ab4161afdf0d459f6543f2", "version_major": 2, "version_minor": 0 }, @@ -3060,7 +3063,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "45a1246d3d984662bea49206e82c1927", + "model_id": "e9fde8e9045c4cf6905a70baf5c5f918", "version_major": 2, "version_minor": 0 }, @@ -3107,7 +3110,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 43, "metadata": {}, "outputs": [ { @@ -3136,7 +3139,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 44, "metadata": {}, "outputs": [ { @@ -3145,12 +3148,13 @@ "Text(0, 0.5, 'reads')" ] }, + "execution_count": 44, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmcAAAHcCAYAAACTVw06AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsfQe4XkXR/15aaBKaVCEEqdKL8EeKBQQUBeRTkEQpKlhQQRQQpSiiIIgoShH8VNCE9ikqVRFQUBAIvUaQiAgCCiT0UHL+z2zunrtn35nZmT17zvve5Pye503uOWfLbJudnZndHSqKojAdOnTo0KFDhw4dBgLz9JuADh06dOjQoUOHDiPohLMOHTp06NChQ4cBQiecdejQoUOHDh06DBA64axDhw4dOnTo0GGA0AlnHTp06NChQ4cOA4ROOOvQoUOHDh06dBggdMJZhw4dOnTo0KHDAKETzjp06NChQ4cOHQYInXDWoUOHDh06dOgwQOiEsw4d5mK84x3vsL8OegwNDZnPfvazc0XV/fGPf7Tl/b//+79o2H322cesssoqWfPH0gR6vva1r5m28Y9//MPm/bOf/cwMKppogw7tohPOOmTH3//+d/PJT37SrLrqqmbBBRc0iy22mNlyyy3N97//ffPSSy9ZhgrMLfbzhQaYHHbbbTez3HLLmQUWWMAss8wy5v3vf7/51a9+1cM0sd//+3//j6X5+uuvt3RNnz59VPSIftP74osv2vyhXdrATTfdZD7zmc+YTTbZxMw///y2TTn87//+r1l77bVt/1t99dXND37wAzTco48+anbffXez+OKL2366yy67mIceeqihUnTokA+PPfaYHYO33357V61zIObrNwEd5ixceuml5kMf+pAZM2aM2Wuvvcy6665rXnnlFfPnP//ZHHLIIeaee+6x2obVVlutjPP888+bT3/60+YDH/iAFcAcll12Wfv/0UcfbY455hg7yYLQN27cOPPUU0+Zyy67zPzP//yPmTRpkpkwYUIZb8899zTvfe97K3S98Y1vjAo7X//61+2KEybqQUe/6QXhDPIHtKF5g7b+8Y9/bNZff30r9P/tb38jw/7oRz8yn/rUp2zfOPjgg811111nPv/5z1uaDzvssEq/e+c732lmzJhhvvKVr1ih7+STTzZvf/vb7YS31FJLNV6uORFnnXWWmTVrVuP5wEJvvvnmm6uFMxiDoCHbcMMN+9IGHZrD3NuzO2THtGnTzIc//GErPF199dVm+eWXL78dcMAB5sEHH7TCG0yw8HP473//a4UzePeRj3ykkiaYUUAw++AHP2gmT55sJ1AHEPZ+97vfmVdffbUSZ+ONN+5Jpx8oisK8/PLLZqGFFuo3KaMe0D9AsIK6BOGeEs5gwv7qV79qdtppp9IEt99++9mJ6hvf+IbZf//9zRJLLGHfn3baaeaBBx6wWrm3vvWt9t173vMeu6A46aSTzLe+9a0WSzjnwB+jTQK0oh362wYdmkNn1uyQDSeccILVRoBJyRfMHEBbduCBB6rSPPLII82SSy5pfvKTn6AMZ4cddjDve9/7atENpgEQ9ADjx48vTaFgJgX89Kc/Ne9617usKRU0gm95y1vM6aef3pMOrGCBFhAYN910UytIgBYH8PDDD5udd97ZLLLIIjadL3zhCzYc5BOaBm+88Uaz4447mrFjx5qFF17YanL+8pe/iOmlcOaZZ5o3v/nNlq7NNtvMapRCgJbzqKOOsuZDyB/o3Xrrrc0111xThoF8nCYSVu4uf+f/c+edd1qNnjNrgyn6Yx/7mNV2pgK0qBIhF+iEfMAE6gMWBy+88IJdHDiA8AZCmRPMAGuttZbZdtttzQUXXJBE57HHHmvmmWee0ozqfLUgvW9+85vmTW96k60TyAMWKyEuvPBCW/dQ1qWXXtouMsD06vDb3/7Wpgd17PDLX/7SvvO1zgAw6+6xxx49PnK//vWvrQAKfXmdddYxV1xxhbh8r7/+utUyQptC34A+/cgjj7D+Ts7d4Dvf+U7ZByFvqPebb765Jw9HH9QT/H/RRRehtIQ+Z85dAurVaZShD++7775WaxoK8aBNhTp+wxveYMsB9VzHjw0WpDBWoF4gbzCR33fffT3hIJ+Pf/zjZoUVVrD1AGMYFh8w9gBPP/20+dKXvmTWW289s+iii1pzOywa7rjjjjIN6Feu30L53Bh0fnCYzxn0/y9+8YtmpZVWsvmuueaatk1gERnWq6SfPPfcc+aggw6y+UAY4Gvvfve7za233ppUfx2q6DRnHbLh4osvthPy2972tizpgVbj/vvvtxM7MFApgBGDNs4HMGlqNQmTGmhizj33XGvWAoYNcAIICGLAnICBgxkFygmTP2hjYNL3MXXqVGtWBfMraGyAAQJTBOHu3//+txVOYWIDLaAv8PgMHhgxTNBgzoWJ3gmHIEyBUBWjFwMIzEATtA0wVPCrgvKA4AvM2uHZZ5+15kMoA9APDBjighAMGiYwn0A+UCehKdppQ6+88kqbPkwaUFYwZcOkDP//9a9/jfqL1cFtt91m/wfh2AfUJ9QlfAeBB9oOBBzoWyGgjn//+9/bsmv63RFHHGG1bSCQQ935OP74423+MOmCGRUWMhMnTrSCuANMrFBnMOked9xx5oknnrB+miCYA90w4W+11Va2/q699tqyvqFfQNrgOuDwn//8x46dcMMChAE/Tei/ULZTTjnFmn//+c9/isy4IGBC/qDFfPLJJ833vvc9s91221kzcEx4hj4PdQr9ENKAOoC+A33FjU2od6AHFkBQByBoQ52AUCsF+BCCwAPxQVCA/gyCw7e//e0yDAgvIDB/9KMftf6of/rTn6y2NRV/+MMf7LgF/gfCHQh/IKCDry3Q4AQlMEVC/wJfUdDiwmIAhDVYKADfAn9aqA8QjMA9BMoB/QD6FCzS7r33XivUgeANFgVYSEE6IBQCKN4LAhiMd+A5IBjCOIbFISzyIH/gI9p+Aq4DQDf0MWgvaCuIBwIpWC861ETRoUMGzJgxA5ZfxS677KKO+5///MfGPfrooyvvf/Ob39j3J598siidadOm2fDY75prrmHjnnjiiTYcpBHixRdf7Hm3ww47FKuuumrl3bhx42waV1xxReX9SSedZN//+te/Lt+99NJLxVprrVWhbdasWcXqq69u04a//fzHjx9fvPvd7xbRG+KVV14plllmmWLDDTcsZs6cWb4/88wzbRpvf/vby3evvfZaJQzgmWeeKZZddtniYx/7WLTNqPo699xzbfhrr722qIsDDjjApkV9m3feedFvb3zjG4sPf/jDFfqPOeaYnnCnnnqq/Xb//fezdEAYyA/wxS9+sZhnnnmKn/3sZ5Uw0LYQbu21167U6/e//337/q677qq00brrrmv7hsMll1xiwx111FHlu3XWWafYfffdy+eNN964+NCHPmTD3Xffffbdr371K/t8xx13VOhdYIEFigcffLB8B9/h/Q9+8AO2rK4cK664YvHss8+W7y+44AL7HsrjsPfee9uxEI7LpZZaqnj66ad7xvfFF19cvoM+uvzyyxfTp08v3/3+97+34fw0XXn8/gd/wzu/nwI+8IEP2LwdbrnlFhvuoIMOqoTbZ599yD7tw5Xnpz/9aYVuaL+nnnqqUrfQJ/baa6/yHfwN726++eaedN2Yf/nll4vXX3+9J88xY8ZU+iukEdJBtQHwHgh77LHHVsJ98IMfLIaGhip9QtpPxo4dW/b/DvnRmTU7ZAFoXAAaTUNTacJKErQ3/m+DDTZIpsPXCIDWA7RysIqFFS48+4CVLmiZfIA5YMUVV7QrVwcw2YTaFdA+gLYQNjfAKhTygR9o3sAMBtqSFCffKVOmWC0HrHRhZe5rD0Cj6GPeeectw0BeYGJ57bXXrCZKaq7w6wt87qAMbrds0yYP0Fj4ZfQBdQ7fXTgAmGOwcH4YDjCXgeYANFy/+MUvzN57742GA+2PT5fTdLidoa6NQFPh+1KBNge0K745FuI6kzRoosDcBX0eNKjuPfwPmjYwS/kALReYFR1A+wZmM+kOVdjk449H8AUFFwbYsBEDmFidvx9WB6BZhjEAdej3SzCVgWZGCujnPiAfGE+OnzjzXGj6/tznPmdS4OiG8QSaaL9ugXZXNzCeQCMGu8xDzS7AaZShT4Im1JmRgXYwb4IWPnX8AA0wtsGU6wPMnNCHL7/8cnU/gf4Fml/QBnbIj86s2SELYOC6yaLfacKuTmAuuQBmJTAx3nDDDT2+KyCc+RMJCGchwN8MGF1ozvN3rAJAMANQE7zLz5/gJID8Xb34AFMSmGFCnH322dYhHsxi/mYLrGwYQKADX7TzzjvPChwh/U0CBEPnuxPC35zh/p85cyYazg/D4ZxzzrF+lmDmBVMwhZVXXrny7NrwmWeeqbQRTMAhQDjzTZYgbJxxxhnWtwqOrYF+tcUWW5RCGwj98D+Y1NwkT9HhaHF0xBD2Icgb+nHM31FTB2EeAI1gwuUDPAXygXoJ+3M4HqXg2g7Mj2A+hAUW9BMQEEOBOQQIcSDsw4YV2GQFAppD6g5ioBHMoeFCF+jzy6DpJ2CWBl4FbhHgNgA75EF4x3hKBz064axDFgDTg8F/9913Z6tRmJQAd911l+kXYPIDrRXQ8t3vftcyItCAwEoU/DRCTVadnZkurRNPPLFna7wDrKCbBGh/QAOw6667Wn8U8NWBFTf470BdSH1+4KgPiA/lAJqhbLDJoent/aDFgckMhEKg3QEENtBAQB8FgIYDNBSg9Qjh3rmwHEAAAq3JD3/4Q1tuX3PiA+oQQ+iMLQH4nQFAkwqaDPDvcRs3wDcIhADwUQP/sCbp0KKtvPtZxhwAv0XYCAX+kLDDGPoUCJPgK9rW8RiSOoT+Dn0ONmyAryDwLfDrA1818L/rUA+dcNYhG2CnIjh+g4YJVvJ1scYaa9jV6G9+8xu7kmxSMKGc1MH5H7QrsEvOX01izvwU4GgRcOQFxubnE+7Wc2YEEHRjmj+NUz3k7zRzsLHAAbRisDL3Tb7g4AsrX2Cwfh6gOZTkDyvrq666ymrOwFk51Ao2DSfUgpnQP+sOnmFic99hsoPdcPA+BJhqoA4k5nTQtoAGAc56A+ETyp5i2ndtBBtK/DZy79x3APRD+IF2DIQzZx7cZptt7LlusOMTBFR4zo2wHaFPQz/2j8ZJhd9PQ0Ad5ALkA30B+r6vpcN2z0rTo2gE7TOYm0F4hoUbjO3YAhbGIJy/BxtxfMAmArf5J4UHwKaFcJML0OeXIWUxBOZh+MGCCBYKsCjohLP66HzOOmTDoYceapnQJz7xCbvDKARoXkDI0gAmedB4QJrg+xQCVmyXXHKJqQugGxCeuO9WkP6KEUxzsINSCvBBgx1RIOD5pjM4KNIHmAZAQIPt7aD9CAE78GL0YgD/FthhCaYw3+QHuwMl5QVhBQRuH3DEB5Y/Fh8Au/raAAg2oGkIjzqBZ6DZ35EH/lJwlIMvoMEECztmYaecFCCYgCYVdqmBP5HEVw1rI9D0QRv5plbwBYJ0w52EIJABnbCD1glnIHjCxAs7Q0EQgP6UG2DG9d0MQJAATWOOyRgmeigDmNV98zf4jMLiJhecTyiYDX1Qt0ho6PbHAwhhwJ/cIgEWBKCRhgUftihwYwbGUDh+QOD2j1TR8gCgAQR20PD6AO0/CHna9oO0QhcF6L+gbcZcBTro0WnOOmQDCBawXR4cf8GXwb8hAMxcwGDAZKYBpAVmTViNgakG/HrcDQHg2AuaCsizLtxEBgeYwkG64I8FE+32229vzZjwNxwBAEITCFXAiDCTGAaIB0wRaIejNICZw60GzvHbrYCBecO2f2CUcHQHOJHDRgJgyqCpg1U3MHaOXsewfcA3OH8L6ADhBeoUtAYgYIb+IaD9BK0ZHJEBAgGEA4EBHLJ9gREmf3h3/vnnWw0nCETQ1vADjQ1ok0AzB/TDBAXpYICyw+aK2DVQ4BPz85//3P7tJjYoEwD6AxyJ4OgCUxAccQICFkzEoGECcy30Id/sCKt9aEsoJxxxAfUEpms4Uw0cpTWADQ+g4YVJEIQ+cPzWHAQKYcEkBG0O9QF9xR2lAccwwLl4PkAggz4E9efMnDCpw1EK4OMEmjxqY0QdQP1BfkAn0AdCN2gPw80tqQDzObQH5AFmPfBfBKEJxgO2YEkBjB04FgJoBz7ijtJwBxunHPUCJj0Yt2AxgKMq3FEa4I/qn5sGJksYD9DGsIkD+CTwEeCN4FcITvYwBuGYDKhjaE/gf9DW4VgFfgvhYXyCUA5jf/PNN0d9Q4E3gDYO+AX4B4K2HOiAPgvmUt/5XwIQ0OF4E+jrkBZYNUAzB4sd8FftkAEN7ADtMJfjb3/7W7HffvsVq6yyit2S/YY3vKHYcsst7TZs2CYegjuWweGqq66yx3TAdvX55pvPHovw/ve/327HD7e4wzETKfjGN75hjwqAre7+MRW//e1vi/XXX79YcMEFbZm+/e1vFz/5yU96jrKAres77bQTmvZDDz1kvy200EKWdjh64Ze//KVN469//Wsl7G233Vbstttudvs/bJ+HdOHoBKgDCb0UTjvtNHskB6S56aab2mMt4BgN/ygN2M7/rW99y+YJ4TbaaCN7nEO4NR9w/fXXF5tssoltY7/9/vWvf9njCxZffHG73R6OeXjsscd62vi5556z79zxFpKjHLCfT79/TMiaa65paXvzm99sj2PxjydxeOSRR+xxAosttlix6KKLFu973/uKBx54oJDAP0rDAfoj9M899tjDHofg6L7wwgujxzEAzj//fFvnUPdLLrlkMXHiRFufIe65557yiA4fcFQCvD/yyCNF9AKgXaF9ObhywJEohx9+uB2H0JehTz/88MOVsNRRGti4xMY9jAsoF9TBW97yFnssCNb/qKM0gJ/4gDoOx8cLL7xg6wLqGNp91113LaZOnWrDHX/88WxdUG33hz/8wfI5qBfoT8Cf7r333p74UF9wpAbwASgjHMkDtLijVoBHAn+AI0UgLUjzhhtu6Bmrrr9BHUGf82nC6gvG2xe+8IVihRVWKOaff357bA+0STguJP0EaD3kkEOKDTbYwPL3RRZZxP4NPKZDHgzBPzmEvA4dOugAK3fQiPzrX/+yGqa5DWAKBC0BHAUB/l8dOvQTsLFjo402slpWOCC4Q4d+ovM569ChBYR+SOBzBqd+g0Py3CiYAcBUCybZTjDr0DYwv0BYLIFrQRMbKTp00KLzOevQoQXANTWwww4ch8GRFlbnsFMKfEnmVoCfTocO/QD4RN5yyy3WDwuuZIONF/ADPzD/OrMOHfqFzqzZoUMLgFU5OPuDMy7sdAJnetjd6l9M3aFDh3YAO0BhJzjsAoWNBrBwgk0l4DAPwlqHDv1GJ5x16NChQ4cOHToMEDqfsw4dOnTo0KFDhwFCJ5x16NChQ4cOHToMEDrhrEOHFgEHisLxEf0GHFIKh23CLwc9cNsApIWdfN6hgxRwGDH0o9ihxB1GAAceu7HcjcE5B51w1qGDEnAjQVvXETUJuMwdTt2H0/F9AIMHYavD6IQTlFMAG1Y64UgGOO0fBKMmADeqwM0C2NVMsMDzbx2Aq79gHMNO0w5zDjrhrEOHuVQ4g2uKPvKRj1gtWocOgwA4YwzOIBsNZ401LZzBblLJvZlwjRKMY7g6qsOcg04469BBiBdeeKGrqwYAl5SkXBbeYc4bC3AILNw5C//Pjeh4TAeHuXMEdJgjAZfxwiW+oPYfM2aMvZz83e9+t7n11lsr4eCSYbj8GC7JXnrppe2qEy4X9wEXtMNlvn//+9/tZdZwsTBc6QJapksvvdRexO18PCA/LeDSYTiQFiYiOPMMLht3eOihh2y6J598Mrqihm/nnnuuaRNQP3Ch8worrGDrFi5X/vSnP20vtfcxc+ZMc/DBB5s3vvGN9iJmuED9P//5D+p3Bxd0g0kG2gFuS3BlhwvL4YLthRde2F5KDfWN+SVdcMEFVrsANyxA+8AlzHDAL9AA/QDaH9oQLpCGdz5ee+01e0E6XPgM5QGavvKVr/SEAx86uDwd+gnQCeWGC7nDCRUuSofDSyGtNddc03znO9+xQqcPoPmzn/2s7X/Q5pAeaDvgYmsA1AFcIg59AvoZmBhD3HjjjWbHHXe0F2pD/cAF2n/5y19Mk6DGAmDWrFlWiwwXkwPdoI395Cc/aZ555plKGhAOTHHQf4BuOPwVzhiDeof0Yz5nmjEL73fddVf7N/RDMNvD2YIaPPDAA/Zy9OWWW86WC7RTcJsF9C8A0AjtfvbZZ5d8wJUDeMNnPvMZ2w+A3qWWWsr26bA9nfkZLl2H8NBfIR+op0MOOcSGgf7m0sf6Q4c5F91pex3mGHzqU58y//d//2cnQJj8nnrqKfPnP//Z3HfffWbjjTcuGSJM1m9961vNcccdZ5544gnz/e9/305wt912m1l88cUrEzhMzFtttZWdbGFSAWYNDBruw3TCE0wCWsYPh88CvXvvvbf56U9/apn3FVdcYYXJVVdd1Wy55Zb29gC4e9MHvIPJcZdddrHPr776ajlhxAACT4pG4rHHHjObbbaZNbGAXwv4qsEECHX94osvmgUWWKAM+7nPfc4sscQS5uijj7aTCUzc0B7nn39+Jc2pU6eaPffc007k++23n53IoC3e9ra32TQ///nP20kNJr+dd97Z5gWCng9oP5j8vvzlL5sHH3zQ/OAHPzDzzz+/LSMIBzDJ/fWvf7VtDpPcUUcdVcb9xCc+YdMGgQ4EKxB6ID3oKxdddJEN8+STT5rtt9/eTvCQB/QNKJMvSIMABvTBVVQgvILADUInTK5QR6GAfd1115nf/va35oADDijLAIIqHEh82mmn2UkaaIcT7EEIvPrqq8u48Pd73vMeK6RA/UI5oe+8613vsulCGzUFbCwAoP3cmII2mzZtmvnhD39oxxKMKWgPwOGHH27L9P73v9+mA/epwv9wjVkMmjELQhiku/nmm1s6//CHP5iTTjrJCuGwmJAAFhyQBgjq0J9hzENbXnLJJXYMgGAMPl7Qh6DOna8X5AG4+eab7SIKhDkQtqDPnH766VbgBoHU1Z0DtDn0MeifIPBBG//tb3+zCzDoPyCMAiBMh7kImS5Q79Ch7xg7dmxxwAEHkN9feeWVYplllinWXXfd4qWXXirfX3LJJaDiKI466qjy3d57723fffnLX+5JZ6eddirGjRuXRCPEg3R/+ctflu9mzJhRLL/88sVGG21UvvvRj35kw913330V+pdeemlLm8M111xjw0l+06ZNK+O9/e1vtz8J9tprr2KeeeYpbr755p5vs2bNsv//9Kc/tXlst9125TvAF77whWLeeectpk+f3lMHV1xxRSWtgw46yL6/7rrrynfPPfdcMX78+GKVVVYpXn/99UqZoR2hThz23HPPYmhoqHjPe95TSXeLLbaotNftt99u43/iE5+ohPvSl75k31999dX2+aKLLrLPWLkdfv3rX9swxx57bOX9Bz/4QUvLgw8+WL6DcGPGjKm0g2vn5ZZbrnj22WfL94cffnilzaBOV1999WKHHXao1O+LL75o6+fd73530RSosQDtBO8nTZpUeQ/t6r9//PHHi/nmm6/YddddK+G+9rWv2XBYf4b/U8fsMcccU8kHxtUmm2wiLu9tt91m07nwwgvZcIssskiFdr9NQtxwww02zXPOOad858bMVlttVbz22muV8CeeeGLPmI3Bpcf11w6jB51Zs8McA1hBgwYEND0YwEQF2hBYqYKpwmGnnXay2qDQfAaQrrY1ANOOrwVabLHFzF577WW1AI8//rh9t/vuu1sa/bs3QSPz3//+15p0HDbYYAN7FY3kBxoALcAcBU7PoPEAE2SIcFcgaBH8d1tvvbXVZoCpxwdoskA74eOyyy6zmgjQzjiAVhLSBO0DaB18QJ05zQwAtCUgA4VmR3j/yCOPWO2PywcA5lcfoEEDuH7gNDKgMQENJQZIa95557VaozAtoAXua/Sx7bbbVszgQBsATGigEQ3fg5kXcPvtt1uN64QJE6xGGPoB/EDTAmlee+21tq2aRDgWwNQIWiTQ9jp64AeaPWg30CYCrrrqKlv3MO58gFYqhpQxCxppH9AHXT1KAGVy4w20uFqANtcB+g20F5iroT+FLhYA0BxDH+rQwUdn1uwwxwDMJmAmBN8fmCDAPwYmcDATApyAACa0EMDowQTqA+7YA7NEbgCjDoWaNdZYw/4PQggIUcDIQSCCnaHgGwUAQQ38q8CM5QAmxO222840BfAXe/bZZ826664rCg93FPoA+gChDxIIZyGgfZxQ4mPttdcuv/t0hHm5STW8uBreg+AC5l8wlUI6YBKEdvDh6t31E/DnAqEJ/NrAvARmKfBlAgEJfMscTSBs+4JVSDNXPxzNfr2BYAaA/k0ByufqOzewsQA0QZ7gK4UBhCq/DsL6BjN7jF7tmAUBLjT/QR5h/+MAfRME9+9+97t2zIFwB6ZrWBS5duEAm1vA/AomZzCH+r6HmAsCNhY6dOiEsw5zDEDbBIwUfIbA4f7EE0803/72t62PEPhxaAETcD93jYFgCdoJ8F9Zb731rK8SaBB8msA/5umnnxalB5NW0yt0Kv3QOd7XLuTOS0pD7Cww+A6+buC3dvHFF1tNCmjlwIcJ3ml9DevQ7LRi0KfBrw1DCj11xgLQBIKZr9310Q8fqVz9G9oYHPx/85vfWF4CmlEQuKDdYws20AiCYAabUmDDBwh00JfABw3TbuYYCx3mPHTCWYc5Cssvv7wVYOAHK3fYCPDNb37TCmfjxo0rndF97ZN7577HkHrApwM4r8Ok66cDDsAA3+QFu/JggoPJDzRKYGL56Ec/WkkLBDfY+SYBOGtrd5ZC/mB2vfvuu03TgPqHdghx//33l99z5QOTJGh+nIYLAI7m4PAd5gM7RuEH/Qg0mbBT8bzzzrMO4RAWnM5hp7CvPctNs3M2h7ZoUlOqpQnKDptXOAHD1QH0e19LBOa+mEYr15hNASyI4HfEEUfYcQblPOOMM8yxxx7L8gEQ6EHDCQKeA2x8kJxZlovHdBj96HzOOswRAL+m0GQAq3owObnjEcBnCt4Bg/WPTAC/INilB34sEsAREdIdkhjAJ87tCASA2fCcc86xGhHfLwxMSbCjEY6MgB1rMFGsv/76lbSa9jkDbQmY8kBzhF3NFGqj6gDM0DfddJO54YYbynfgU3XmmWdaoRJ24ObKBxAeJAxmLIDrByA4hOVzWivXfyAt6HuwQ9EHmEFhgk3R2GIAMz0IQ7AD8fnnn+/5Hh5X0pamGsruzO4+wMfMCSPgEwd9GXYs+gjrDEOuMasBjEfnn+gAYw/Ggk8D8AFM4ALtXdhvYCex5jgPSBugEeg6zFnoNGcd5giA5gLMDXA0AggsYOKBVT1sa3crWHAeBzMnbMsHfyIQfNy2fJj8w2MruIkSjoYAvxTY3g95gX+YFOBfBscuAG1wLtRPfvITSweYQjDT5imnnGKdq4H2EE37nLmT0MG0A3UGzvmgbfr3v/9tTa7g8+MfZVAHcFwFHB8AAg2YkcAnCY67AI3fL3/5y2wmZugfoNkAoQ8mPygXCIWQFwiiThMJz3C8BWzeAMEI+thZZ51ltVdOwIN2h/Bf/epXrb8gpA11BeYwMGs5jVddQNl//OMf27qBM8WgD4P/Ifg0Qd8AmkCAjh1HAX3MP1esDqDe4CgNMPfBhgU4dgTGGGgkoW/AuILxCH38wAMPtOMQfLdAIwxHaYCABcdEcFqiXGNWAziyBI5/geNtYKyCoAZHZ4DQBT6IPh8AHgNCPSwCQSsIGm44GgXCgzkTFhSw2IBw4O8oBaQNgH4F5lCoB+hrTmjrMBeg39tFO3TIgZkzZxaHHHJIscEGGxRveMMb7DZ3+Pu0007rCXv++efb7fVwrMGSSy5ZTJw4sfjXv/5VCQNb5CENDM8//3wxYcKEYvHFF7db1zXHakBYOIrjd7/7XbH++utbGtZaay122/4666xjj7IIaawDzVEagIcfftgeqfHGN77R0rzqqqvaY0ug3rlt/OHRCH4dYPj73/9uj6GAul1wwQWLzTbbzB6bgKUZ1hlFw9FHH23f/+c//ynfvfrqq8XXv/51ewzF/PPPX6y00kr2+IqXX365DHPrrbfa4zlWXnllW2Y40uF973tfMWXKlEr6cNwHHBmywgor2LTgyAs4CsE/8gIANIRHvcBRCfAewkvKCMc87LbbbsVSSy1laYK63H333Yurrrqq4PCDH/wAPb5EAm4sAM4880x7VMVCCy1kx956661XHHroocVjjz1WhoGjIo488kh7ZAiEe9e73mWPiYFyfOpTn2L7S90x69pfioceeqj42Mc+Vrz5zW+2fRDye+c731n84Q9/qIS7//77i2222caWxz8S5Jlnnin23Xdfe+zNoosuao8/gbDQVv7RG7GjL77xjW8UK664oh37kmM1uqM05iwMwT/9FhA7dOhAY6ONNrJaJDiSIBdg5yFs8wcNDxwiC5qXDnMuwAQJmj3QEA4KQGsJml/w4QINUYc0wKYgMMWCHyRsRgCNPHbsTYfRhc6s2aHDAAP8vMBkBGap3AAnZ3D4B78dOMurw5wJWH/DdUi/+MUv+kYDHC8RbhpwPn+wUOiQDjhrL7w9o8PoR6c569AhA8Ahm3P4Be0UaL+kgN2Rt9xyi/XTgYM94RBN/xDOuoC03U45ENDAV6pDh6YAiwv4ga8e+GiCryL4F4KfGhxR0hbg2JnwPlgf4Fc22q5JAt4DPnwO4PcWnrvXYfShE846dMgAcE4ODxz1Ac7M4WXOHOBeyGOOOcYevgk71SB+hw6jFXAyPtwfClpgMMHBJgFwrgeTZpPns4UALR1cNE4BjuboLhjvMAjohLMOHTIALmEG0w0F8K1xO7A6dOjQH/gaYwxgeoXzzDp06Dc64axDhw4dOnTo0GGA0B1C26FDhw4dOnToMEDodmu2CLgyBk6HB2fN7nqODh06dOjQYfTsen7uuefsgcNt3LncCWctAgSzlVZaqc0sO3To0KFDhw6Z8Mgjj9jbaJpGJ5y1CLe9GRq3O/SzQ4cOHTp0GB149tlnrXKlrWNKOuGsRThTJghmnXDWoUOHDh06jC4MMXfB5kS3IaBDhw4dOnTo0GGA0AlnHTp06NChQ4cOA4ROOOvQoUOHDh06dBggdD5nHTp06NChwygE3Of76quv9puMOQLzzz+/vVt1UNAJZx06dOjQocMoO3Pr8ccfN9OnT+83KXMUFl98cbPccssNxDmknXDWoUOHDh06jCI4wWyZZZYxCy+88EAIE6Nd2H3xxRfNk08+aZ+XX375fpPUCWcdOnTo0KHDaDJlOsFsqaWW6jc5cwwWWmgh+z8IaFC3/TZxdhsCOnTo0KFDh1EC52MGGrMOeeHqdBD8+DrhrEOHDh06dBhl6EyZc3addsJZhw4dOnTo0KHDAKETzjp06NChQ4cOIvzxj3+0GibNTtF99tnH7LrrrrVreGhoyPz61782cwP6Kpxde+215v3vf79ZYYUVopX+qU99yob53ve+V3n/9NNPm4kTJ9q7KmEb7Mc//nHz/PPPV8LceeedZuuttzYLLrigvbj0hBNO6En/wgsvNGuttZYNs95665nLLrusZzfHUUcdZXdxgOPgdtttZx544IHaddChQ4cOHTrkAAhBME/CfBnigAMOsN8gTNv4/ve/b372s5+1nu9oRl+FsxdeeMFssMEG5tRTT2XDXXTRReavf/2rFeJCgGB2zz33mCuvvNJccsklVuDbf//9KzfJb7/99mbcuHHmlltuMSeeeKL52te+Zs4888wyzPXXX2/23HNPK9jddtttVsKH3913312GAYHulFNOMWeccYa58cYbzSKLLGJ22GEH8/LLL2erjw4dOnTo0KEOQAFx3nnnmZdeeql8B/PU5MmTzcorr9yXyh07dqxVnnRQoBgQACkXXXRRz/t//etfxYorrljcfffdxbhx44qTTz65/HbvvffaeDfffHP57vLLLy+GhoaKRx991D6fdtppxRJLLFHMnDmzDHPYYYcVa665Zvm8++67FzvttFMl380337z45Cc/af+eNWtWsdxyyxUnnnhi+X369OnFmDFjinPPPVdcxhkzZlh64f9ikhn5Afy/BxjQYyS9RhqubpzRAqxsA1ter286+ig6XRn8X086A1LHdeobKydV1vA7Fp5Mh8lT+z2lfJrwfh9pux+T7UG0g7qfpvZdph9g9If5oGUJ6HjppZeKe2++vHjpsZF5DwDT4E477V3ssssuxbrrrlv84he/GCFr0qRi/fXXt9/23nvv8v1f/vJysccenyuWWOKNxQILjCm23HLL4qabbqqke+mllxarr756seCCCxbveMc7ip/+9Kd2Hrv66mdsnhTgm/tBnpC3w9vftnHxuf32KD760UPs/LzssssWRx99dCX+3/72t2Lrrbe28+zaa69d/P73v++REy6++J/Fdtt9qBg7dqxNZ+eddy6mTZtmv913333FQgstZMvucP7559ty3HPPPQStL1m5Auo4rPvK/N0CBtrnbNasWeajH/2oOeSQQ8w666zT8/2GG26w0vimm25avgNz4zzzzGO1Wy7MNttsYxZYYIEyDGi8pk6dap555pkyDMTzAWHgPWDatGn20D8/DKwENt988zIMhpkzZ1rNnf/D4G8Qgb/9X7+A5T9AG1lE6HcdchhUupqoV6xPh+8k6XHpaGiM0aApX2yMYM8cXbnGfmo6VBuFYai4mvQ5erG8c4/nXOlRtIZhcuYZw8c+9jHz05/+tHz+yU9+Yvbdd9+ecKeccqi5+upfmqOPPtv8/Oe3mtVWW83OfeAuBHjkkUfMbrvtZt2Pbr/9dvOJT3zCfPGLX66kMWXK7B+H//63Gh5w9nmXmIUWWsTO1WCZOuaYY8ypp15pv8+aNcu85z27mZdfXsD85Cc3WovVYYcdZuM9+ODsNP7611fN5z+/g1l44TeYM864zvzlL38xiy66qNlxxx3NK6+8Yt2UvvOd75jPfOYz5p///Kf517/+Zc293/72t81b3vIWM+gY6BsCoBLnm28+8/nPfx79DgITHBbnA8IvueSS9psLM378+EqYZZddtvy2xBJL2P/dOz+Mn4YfDwuD4bjjjjNf//rX8Y8TCmMmj4zSoYkglA8gHI1A7zBgXeczGKv3zIC66TiaetKBMnj0+/Ue1n0ZdziM+xam2VP+IDxKB4Ji0pAxk6v1G9Y55OXq3E+zUt4IvRr4aRQTmHCRSbqYpO/XZBsmpOGApSUVJOT5NTd+Xdv7/cD/5miI1R33PUxXAqxtsTS4+rf9f/ZflbAUjTF6S5om8rT78cv+7vd1fzwqoObjQT4hXeQ4WGScMUtU5zUfH/nIR8zhhx9uHn74YXPnncb8+c9/saZOcOb33Yp+9avTrS/YGmu8x7771KfOMpdddqX5+tf/13z0o4eYU0893bz5zW82J510khWI1lxzTfO+991lzjnn2z15OqHL05WQeO7lN5hV37yR2W+/o83qqxuz+uqrmx/+8IfmppuuMptv/m7zhz/8wfzjH/ebH/zgd+aNb5ztzrTPPt8yt902m07A739/vhXijjjix9aXbu21jRVIQWED5QR3JhDMwH8c6gMUNGuu+VazxRafqwiTQK+j+eV/322mPQqSZG/djh1rWsXAas7AP8w5EQ7S2SMawOCYMWNG+YNVCAanyI69kwLTCFCrUOmKzk0MEiaeutpN0aZwsPSWzL8ewroKv4loKXS0YXlK60aiEeK+c32vpxxcWK+MVFhfwOAQGqZCWqO0CMZTKABrAeVN6XN1NHV1tHU+/PrDFgJcOnUXVrbeEtOQ9ke/74TP2OKLqltM+M/Jw6n0YgABY+mlZ//9xje+0ey00052/rz44p+aLbfcySztPg7j73//uz1sdcsttyyFk/nmm9+ss85mZtq0++zzP/5xn7UQ+Vh//S3QvLF3vuADmztBKHLPq622vv3fCUqw2W7eeZ+03++77z6z8sormfe8Z4WefFdbbXYazz13h/nXvx4073znG8w73rGo1ZqBYgb866BsvtYQNgXeeuut5uije+UJp/nzBba11jJ9x8Bqzq677jp7jYLvwAjXVnzxi1+0Ozb/8Y9/2AtK3V1YDq+99ppVycI3APz/xBNPVMK451gY/7t759+5Bc8bbrghWYYxY8bYn2bVlLIKrWiCIiu+HKvjlLSxSV9EC6K5iwoQfhysPpC0etKbIFuB19J8Em0VphUTiJM0N7aOZHGofhgV6BO1waH20tcg+nn79IUTtP/NjycVBFNRajsUmhvuXZ24WFlzabnrCrwjz8VI+0xIz5tOPw2hRpJLL1a/HJ114ParUZoqMG1+9rOftX/HNt356YDf/hJLzH72ffjd90cfnf3/Rhvh3zGAXOgfovCGNxiz4orzV8KA0ASaMIquGTOq7+FUhk022cRMmjSpJw4Ipw533HGH1RKCu9Myy/zbbLzxyBwemmPvfnRd89//TkP5M+TfpvZsYDVn4GsG0i7Yud0PdmuC/9nvfvc7G2aLLbawZ62Als3h6quvtg3spH0IAzs4/esYYGcnqGfBpOnCXHXVVZX8IQy8B4BZFAQ0Pwz4j4Gt3IVR4YKMLRyY6ChoV3aYpif8RmpCamirYmnn1lpo8orVXx3aKZo0WiGuLVF6h7UVmCahLu1YWbBwOfOuA3VfY1zNtelJyi3R+lD9T1u3XJrSPh7jHdryo3xPyPvqoJ99MoZ11+UFIud7BXMf+JGFAHMlmPrAV8sBwt58882lT9baa69tbrrppko8ODkhBSDIhfT6mjUfa6+9trU0/fvf/ybz3Xjjje1xVuDaBL5y/g98wgGgqIGjQ7761a/a/+F0B38Xq6/dgx/U6bhxxtx/v+k7+iqcgeTrBC/neA9/g/MeXOi67rrrVn7zzz+/FZJAsHINCB1wv/32sx0IOhmsFD784Q+Xx25MmDDBdkA4JgOO3Dj//POtufTggw8u6TjwwAPNFVdcYe3q999/vz1qY8qUKeWqAyT6gw46yBx77LHmt7/9rbnrrrvMXnvtZfOoe7AeZ2rSMEMfXLzYZEmlJSkHJihRdITaDI1g1S+GiWlgctMTM+tKhbQ6wk6YN9Z2WP/EvtVG4OsYE0RCSIRD+FFaOSzvmOsApa3zwZmXsbCY+TlV+5fDZQBLj2qHXHQPAiQLjUEBXNwN5sF7770XvcQbjoP69Kc/bRUeMP9BOJhLX3zxRTtfAsCBHgQgCAOb6OA4jjbOK9tuu+3MGmusYfbee2+r+QJLGghYPkDQAlPtLrvsYr+D/AC+ZuCjDs7/jn44WuSII44w3/3ud6317Utf+lI0fzBr9r2vFn3ENddcA9255+dv9fURHqUBeOqpp4o999yzWHTRRYvFFlus2HfffYvnnnuuEuaOO+4ottpqK7slF47lOP7443vSvuCCC4o11lijWGCBBYp11lnHbh/2AcdpHHnkkXbLL6Sz7bbbFlOnTlWVF9uK64Z1+BxrmTJMcORBNHyRJxwVr4yLbAHn1uBkOTRb2hs4uiGmO9CkkZJf3XAkgmMQNOWjvqXGI78TbZlabj8ONe7C9Ov+MJqb/MXqi4rDPWvyTk0j1l5NIkZL7bGWEZD/uHHecQ/BURDuKA0K4VEakMbnPve5Yumll7bzGnaUxsUXX1ysttpq9jscbfGTn/zEzmPPPDP7KA34wTMcsUEB6Hr723cpj97YeOO3Fx/+8IHlM/wP333a/u//phYbbriVnZNXXnmN4pRTrrD5nHjiyFEa//73v4u99tqrpH/VVVct9ttvPzvHnn322cUiiyxij+RwuPHGG4v555+/uOyyy3po9I/SgDoO27ztozSG4J8+yoZzFcAUCupW2BwANxrUgdgfLQgfa21puFRwK5FB74naOvfj+OFytYXEl4hLQ+rfJMmT8nfi8nNhJHE1+cTiQhzqbyyPOvDT1+QRxquTX1N55U4n1i45IPF95fq8/53jBxqfQA0gjXHjXjaXXz7NutvcffeCbHjJzsk6AJ+tRx+dZj74wTWs5g12XYbfNfDpneLt/gzTqVsubGfp7Hcvm0UWmV23Cy20YKWtcs7fo3pDwBwN8DlbODhOg3LkD78PP2tl6krwyUOos/Zs06ILo9xOLiyHo7tkks6Umbh13YeEmccmYi5uE5N3ifAoDFsvhZpGH5JJmYtTHvNRjVUJGx6FEKbjt29Yf3Un8jpx2loIhGUcRJOeM0nWpW1QypYq1GHjO+wzkg0COUHV6cMPw1EYZiDwl79cZm/lCQWzGDChy9/NGb7DwuYUQCEduPBn2vB+gH6jE876iRYcWptEdSKnv2OMrHw3uRm6MKGvH5MHW/a6aQsFW01+VSGeyHPCyA47sfAfnjWXiHACjQqYzPdQIGlz0pVqtDCkxsut7aPKINEsOeTQJjU9HqnvXBvyPA9f0KQiFFxqCStPDSe0lDyR3Xc/gMzTva/QN949bIp+9+NOmdIMzZI66rclpxPORhuQCS6FwblJNnibbmIbPkKAnDiC4xB68pzIq/8lk7H0AEetBoWb7OtO6CMapqBdJlNtFKcRo5VzeCfpp/qa11blUQgTg3r1ysHRFdLGIYeZKxTGuO9NIpYPp83ihB+sr0rrOyb4UgKH1CysbV+JK0Asr9zaQF97pomfYn6n4jntDpytvuCCcWGDMgmmaJ6ow1uxfEKUYZ8aCY/t3gyfpwyfQWa/OUHM6CVQqrwh3YssYgYCnXDWD+w+wwyNXazK3ILJrQRzvlcyg2AEvBjza1q7UJeZcgxdMzlomCrn4yP1n+oRJpGzvXqeBYJbqlktxYeshNOsWSFuJCKcY5VL+JGYn3Mhl0+WFrny5Ma2xgUgpKkpvzCMBv85l1m/b2DGbdM0xwSxKdNmB9h0KXmaUr+yUsBaalO1L1oJF9c3PUY0ZhLTKYawr7d9Q0AnnM0BSJo8KB+xBPOTZZb23CH7pKap7iq3bVNIE5N1DlNUP/LNlUeuMNo0uHaU5tcv4W2QTTIkf+i5pqyIuHvUN9lLFxbkws4300/2/HIFfHIQxmVpRgyEGOpUf1GaiBbLN0PaPIfz6xHEnppiNh1fpYfLd1OX17DGDdWaJZg2Bx2dcNYnUAwjphEIVeoSrZB4dezf9RkxI8J7X6gqzXKIoKX1PSH9NRAGH9MmpvpbxUwqPel6fiQpjJUzO/rfqWcOMTNYqplRGobzX9JqQUizuvA7Ba7fSjWubSFVoAzHbZieRBPm1xPFr0JegglYjmeEPozhWYcxv0qpCwTJg4hFas+CDDHT5zaz+/Snps2ZKrHdj9JwUuGtKrT1pjVba9Wr/YoKhUt5gpxCqxem7ejx6fK/+xsCwr7X9g0BnXA2YEg1rYXxHXSTX5pgEaMhF9iLgFsA2x41TMVNI9UUJOl/OXzuNKZgKg3q3SD35ybQtNsBlh/GryobQobN2z3jALmk3B/jlXqn3D4IekLa6pgYKzvjEd9ZqXnY0aLtT2Edwwn2l18uiztbCMmnTaoKa9V0RwSeTWuZPkNsSviISfzsombcIBxcifXf/87258uxgakOOuGsX/BWluXgJ464kDJcdtCHO0Mjd0dW8gtWl+iq0k8z/Mbcjehr/qTaDZ8ezOSYG3XNrtzdp1zaPVoFiSYgACn0+DRVnPYTKhAxhcfqTDpJ5fRRGzQhK0aTlGZJOrH40rBUntSisOk619RRDFqNcVOuDXV4WGzXZCycNi9U6ALNWcS8yO3STEnPJJgzxbtB+4ROOBsw+MIMxgBEjEOxy09iBnImy1C4ijL90ESBmGU1DHHE9MHQmtmkmDJx9YSfHBdme/JBjlmRTgZ166OXhgJt09jF5lITWfiOMyNTJn33njL/DpppUpInJ9hi75ooQ8xtIEZb2DaYACJdfPjxNWVN1VTFgPYpxEyq6f+xcPC3b3pT7cR8aooZWjpNKoN8cRNlEHDYpOm+xUyoYTyndZvi+64ZvWAp1bZpdpu2jU446xf8A2gRs6J0kulheMGkjqrmg29R7YszNUwk4hHHZIRmC80Kvpd+hB4FpBNATpB138B5X2GeUSAaOaxdbf+aUH034hg91IrGSxqOyzOVnrY1bhLhAxNSYsKO5FsdxLS2owFUW8fcE1JcBkYbKMEl2/lqNTFFeEyGJM6goBPO+gnhbp/KoOZ2U8ZO6U9AXSaec3KjJqAcgprEXEP6RiH1rtGKOCGnvB2gCIWg3jbltH0V+gLaUrRv+LdeE7dU2CdpFcRpQqgYlZNmzUN9R7TQuCaU0mDmbA9sYaE17UmFQk54pVwKUM1wjMdiu9+58DURasbcjka7G3L2XyPfcufHmBd9p30qzg033GC22mors+O7tjCXXvlnQtjbtFzgHn300eass84y06dPN1tuuaU5/fTTzYwZvddFSc5Do24bWHfd7oaAuRqw4yNkfr7JLxQ4eoQADynaKKnJKTRBSn2aMH8yKoyfDiUssbQLmZ/GPFl3MrJlCZh7UwKA1OxN+rTZb0XluihJ3Bg0kzYlALchOKWaFpuCyH+qbDf5mMlJU0q71HE34NJIMW9yWkefp8jdNuKFK9tKcUzIIIE0B9Y4wuJ///d/zef229387y9+ax577DGzwgor9ISZMpz8VVedYE455RRz5JFnmxVWGG/OO+9Is8MOO5if//xeM2bMgr0C2niZb9ugas0AneZsNAETQBhnczGaWt0R94LOhsxfyQdq0p0kqA9t+bzwWp+4kvFHTK+Vb8M+aWh4gmapZoO7agmEsko+xOaQ+Nl27l1R23+K0lo2jTqCYF2hgdXgoFVaKMJGtMyu/WBzTXBIsJSuihYO87XCzjjrGQPeQiGDtl4FbyNWRWsdA6HNrtAS8qc2dgC2edZXYl7PP3ytOf+8c82UW241j08vzM9+9jPzla98pSr0PQV/bGr5yve+9z1zxBFHmLe/fRf7+ZxzzjHLLruseeSRX5vVVvswepiuL3hJbiKAPF9+Bp4WMWutNfv+0n5q1zvhrE/AVr3Uiq4JPxFJWqlhRpgyE6/Ghed+vcSEIFSAwyA87wgNFwhAXJ3gjuu0bx6nPZCu3DntKPXck69ik4kWGuaX20yOt0daGqmQ+sqJBXINhOeHYd/Q/jdsbq2a7WV0kH2duYuSu0O3p3/7muLU+tOOAaRcuRaD1NEW6DlgNQW2nMdXAC74zR/MWquPM2uuuab5yEc+Yg466CBz+OGHmyGksh59dJp5/PHHzXbbbWc23NDlNda85S2bW9MoJpzV0Yg5oazfmKffBMzNcGZD2x/t6rIGl29Ka4bQVaG7QV+78EeFkcKnuxb9QXqabzBBcI70JSL9QcTwqfjet5R6KONAO2I+NsFGF99UT7Vp+DcVDpvAtROtHyclfr8QahXDfoz1b8xNAsVwu2WpiwQ+xgolSD+TlEnSt91Y5NKr8GguLaLfSvsYRivKsy5Zy5gXBkCCsNqtNF+2/z3/KvORfT5p/95xxx3NjBkzzJ/+9KeqMLnUbO3XMss8bl+BpszHUksta4U2TEPmdpO6nw/sHQW/DeEQ2jbRac4GECoG2eeD8ljmGtIW3LmY4pcU05JVVtcTZUc++GEqOxObqG/kfDmJ+cj5sfnmofCy+WrYemSSdHsYyRcxWwfaDpEvVcQMzGknuTrEkEv71pS5Q6uRk2rfXNqSsDFNvut/I2NmpB9UFiA9Vzb1jslUoZAbtz2aPXdEkWe+5TTvKW1L8qnIIrgsh8KPDTuRvymTZuUKJSIPqbZq6tSp5qabbjIXXXSRfZ5vvvnMHnvsYX3Q3vGOd4j82Dbd1JgllsDzpq6rolA5PPfll824cdPM/ffPvlS+oiV+0bSKTnPWB4AEXnfFTmmBqL+Twaxam9I45NJspdCq9RWiVsdUnpgmiYsT89WqW0eYZgrTdCVp/zIjpEeqJZLWqYaOnOG4+HU0g9pFnu93xfVLLT21tLMRUO1NaVvDdLFwWBisv8f4lKbcdkxFFicunAOcZj/owLRXIIS99tprdgMACGbwg52Xv/zlL60GLcRyyy1n/3/iiScq7+HZfcsN8DlrauElRac56zNGBmSfNGCZNG8pE0it8IrDHjXpW4YqPUetyW3yqB+bPJ9KGUI662739zQQ2PsKAg2hr1loi/lFTVuj9TgNBHU0itkWW4imrC/wx1CgyVVry7RjPLzUXbqZK5IPjOtx4142Z5wxzSy9dMsbAMJ8tPk+NcW8NnZD68x/0kknme23377yeddddzXnnnuu+dSnPlV5P378eCuEXXXVVWbDlV6z756dfw1z4403mk9/+tM0ncKdpIO6Y7MTzvqBC8Ya8wn5YKf8rSoY3hHl75gbRF8akibmSqbG81aGaZoGaVjqew4hNRc4LVYOzZLkG2cODd+jZilGeK2jRevJK5IPZV6U0JK9XX3zW0S4xzaT9GqiEsycgkUFdksJGVbY5lxamqM4JMDGi7shwN7/OOAIj9y45JJLzDPPPGM+/vGPm7HBLeL/8z//Y7VqoXA2NDRkNwwce+yxZvVljRk/bkVz5EnHWs0bCHRiuFsIwjPgQrzwsLn/O+8xC77SX7++Tjibm6DRkDR8eGKHFjGXt2FOgThnuLra40FcfPUA8TvtMPcChC/YdRkKZk44O+GEE8ydd95pdt55Z7PPPvuYr33ta/bboYceal544QWz/xe/ZabPeN5stdXW5oorrjALgmPYHIpOOBtgYKt4UgsQ2RIvWRVW0vYdygkn3p50ibypMqT4rmDxxH4dkfwqzp8NTiQcvZhWJMckLN9Q0RsO09DE3mGanjqI1YfWV1BSvyNheq9Vo8qXah61aShumAhp8OmI+SlioLRwdJsWvZtwgnPyYvVKjWNxf2HG58hYjofVps3lN5wrq930+5V7V6GZacewbtq6PsmdvK+5f7Jyr+awturooy+upOnCATbbbDPbr1588UXrT2Y3B3jas2OOOcYcc+DOs+NO29Q8+2w1HT9flH6BphH8+BYxg4FuQ0A/sHuv02OqAzy2KQBNj7hIe7T42vTQiR3jIEhjtJSXRBM+PExdpu5+lDhJY39TG12wNHJuHJHmiZWvX/2qTp4SZ/ac+XE0SN9T36g+hfXtWJ/rB3LlO2gXd1ew1KZWoJLgmmuuMe9617sqwllKOql4+L/jzFpfur+3DyHzdpMYKrhjvTtkxbPPPmvVuTPOMmaxhYOG8E+olpoYvZOtHdBVGHLIIRZHgtwaHW2+Eq0JpaVTrcw1Ny8kmIAl2g1S6wn5NG12jmlLke8SDS/VHhJtIpZ2GC7V8V2iHZSkS42vWFoabWAOraREE8mVJ0wnhY6Y5pH10/P82Lh+xGnn6vJCLN1KOswYjdHJhXv55ZfNtGnTrKO8M+uRB8AmXK/U1oXgg3jx+MvDdfue94w3Dz+8YMUf9NkXjRm7H5y2MMMstthijdPSmTUHBKkOsNTJ7ZSQV1cWb9rkl9t3J6cDek7EmHcZJhWZhLeyfylvUCgvaw+u7qHaI5dfWGqdYe2RkpZok0bCfbCabxLE4rvv0nC5aKi0A3YjQOV7bzoaenPyg7r+g3XDZRFwnMN8S9JS9myeSr/nM4Q756yf6ISzDiRSVsUp/i6DXq6cvlOjBjFH7rnEsZvT5OTSXknixzSRFI1NQqJ54rRjybS20PdyatWicNrwOUwLRfrE+UKU9zdahqd6wzqz5qCVNTc64WxA4MwIdcJSppkcp8WHDrY+DRJmi4UPwaXXxERGmTicc7bE78bGnUif+s8ihSETmzh68ktIm0orVvfVOvECTQwdx+XgTHdSU1uYTl2HfIl/lmxzgKxtNP5g3DeNw7kfJ9UloA7dsfRzLpSwduu335mkXHBA6hlnGPPCC6ZHSOGEtFQBLownccBn0xkv85eb4jnxixz6CY0ZtWliUAVah87nrB8+Z57NWuzDFfj4pPjN+PZz0YGHjPCiEc6kk0IO4Uzif4blK5nQKZ8W1Srbr3ukHWL5xgQVKmyKz16qX4wkrbaEM01+sTyk6eTwVUtJR5NfDuFMIpTG2kWzwNOEyymctaGNlC5wASOH0IK0siAqNFECR4pAUlc4ozYqxNKbgsQL85LQphHOpkx52fz3v9PMO94x4s/nMDQE20Or83eT6DRn/YR3inQOHwTShyMDwnRS/TzCZ4wp5ShH6ZsS+DtRAkfMl470wbH3CMru72wdFd+coteEgvj2pNS9VHjSTnzUNw09EqFH3beG+0oTbU6NA6mgxgl13DjU0BLLS+qXquEh2nCpaVXeMb5vuSFazHn+UH/84+y/sUu/OaRoicI42jRi4anvmyKCVAoq5lTvblDJfaE+4GYp5Hi2xtAJZ32+IYBy6B8EtLFizJ2HVpCoGy41vCgdb3LQCCojGtLgHXEMByZw2vfOHO4JuBKkClVZIHDql9DBa7HzlzNXv03NPxVRbT92vVqLQs+cBP+GgHHjiBsCMjrF9wUE/ZsKBDgunBTrrjv79oVBQCecDShCk0KK3xhlisDS0qzMY3k16UBPmR8l5gCtv0ybk1y/nfor5Z40OupF5wsnNPlL4PwRJ+riasyUMfNzrjaQmoglZksxGlyMxuq4kb6b4SgdSX903196SU9iacL7W5qtfMoaRcV0uOn4XlWWf/7YqHHqX6rfBNDohLMBQltCjf8uNS+tP4y2bCkTQI9vG2F2Qn1NUk1UGU4ed+3QU0dS53+B75lKQB2+NL0Sx9vsIHawF0zuWBxpHmFYG1/YHmH6MT89CT05fcQkpleNz1idRYo0T+mp/Ln4XF3z9CAtFrCwVDqwIeDyy03r0JoWww0AUqd+G2/acFzkVoK2nfr7tkmkO4S2/Q0BxswwRbFY48KZZHKRMO7UCTaWRoxuLE3Jt5h/U5OOwJJNB76J0d/gIXXAbkI4y+3U36ZwhsWvmwaloaXitMHANeWTCmcap/4ULVs/hLNsTv2RzTsUPbnGGDXOYUPA5ZdPM+MXf8EsuIBS+zM5XXOm8Qnjrnpy8R5//HHzzW9+0/zqV5ea//znUbPsssuYVVbZ0Oy550Fms822tWHmnfc2c/zXDzXX3nCbeXr6c2a55ZYz6623nvnkJz9p3ve+99lrnXponQJ1V5iLLz7anHXWWWb69Olmyy23NJ/5zOlm5ZVXn631I+qsPOD3nuGLzyu79rsNAXM8wLFQ7G/kM4MaB4vW8WmJ+e1ImG0TfjiS8Og757A8+ykpryZQh4ZY2bXtX+F5kXOYOL/JnD5fnPCd0leaEKhQOpjbFurQFeMXIS1UW+QSZqRxysVJzJcxLFMgLFEaOjHtmW/Z0LYHmoZgYxL4nLXtF5Xi1M/F+cc//mEFpsUXX9wceOCJ5s1vXs+stdar5sc//p054YQDzD/+cb/5zW9+Y3bffXez3TZvNWef+jWz2sbvNTNnzjTXX3+9OeKII8zWW29t42M455wTzM9/foo5++yz7U0KRx55pPnSl3Yw9173c2PMGDMa0Jk152CoGGyDgl/O9MhvGU53z4E6Qm5q2CZQnWiY/Ju465OARtiUhNG0VZ20NGE04XKhr3RprknrMMfgM5/5jNV63XTTTWaRRUauGj/55HXM0Ud/zLzwwgvm4x//uNlpp53Mr876yuyPS61q/1t77bXtN+q2m002Kcz73/89K8Dtsssu9t0555xjll12WfPry/5kPrzb9nJC3a063vVNbaETzgYVNRlVLkfeET8SXsVfdSjvDRv6MUno0Jr25GWhv2XRzDR472VfHJ6Vflwas1nMlJnbxI+lmapBk5vv8IAaV4KoSYzwT2TjROk2WVFtg0AbhrURt6FlDhLkqrwTf+/zJdipCYfQjveURuFZXqRJsSat+Nlggny9zQQzZjxtrrjiCvPpT3/T3HffImW8kfiLm0ceucg89dRT5tBDDyXzvuWWIVRDB2ZJMJlut9125TtwJ9p8883NDVPutMJZNb8B2JiAYJ5+EzA3AtzO+uVk6ANoKH8TC5HZxac7dVOANmzdunJlLKGcyNA0EsO03q4Z6ElNh3K6T03bD4v9jf2arB9pfpo8w+8pNGr6s7SepHRq2sLnO9INOVSamvJU+ECwwCTTmDBMJ9P/wvBJt3Qo6uLuR9et7JAcLfjXvx60wvkqq6xFhvnb3/5m/3/xxTXLd/fcc7PZZptFzaKLLmoWXnhRc911l6BxQTADgKbMBzw//gQcatYLENLqnKXWBDrN2SAhouIvncdN1ccHW+nWMYv56Y3E8RhThHk4LRkXNtVMRMYL6yvm80H5dFitX1HrQGERU05c+Uucnmv7U2k0f0qfGqDL9StKO9mEgJszbS6tFK2Tq5O5ATnNv7XuqxTcuNIv7Zw/jrFvq6wiPO/rqSnZhbeYb1lFG4U43sP311+fXbDVVhuJy2mupgyXYfXVZ5pJk243660Hf69uXn/9tWSNVyVfrJ7e59187vjh7jOM2W/s3KE5u/baa8373/9+s8IKK1j7869//evy26uvvmoOO+wwuzMDbNIQZq+99jKPPfZYJY2nn37aTJw40V6nAM6BYIt+/vnnK2HuvPNO6zwI1zGstNJK5oQTTuih5cILLzRrrbWWDQN5XnbZZZXvIOkfddRRZvnllzcLLbSQVZk+8MADyRsCUkwrdlKrOLN77wv9qjyM78JUhbLecP4PSyMWJ2ZSSdGkcIjVD9Sp+6XS7afTBnpog3ytk/Xs/DGapdqO8HuZhpc+BT8NjQDOaTvC71Ktqt+nc2o18cVLPDz3rhZ9QbvE+m6sX2PhKTr9PiIdJyHqxgnbo7zBgdHY1aWDGuuURlcDLA6XlkTrA0JIW6Y7EMrQc9CG6Xz++dXtfH8/XHVA0Ln66qvb54UXnlq+e9vbxpgPfGA1sxpIdcPCHQbY0Ql44oknKnk/8a8HzXLLLkXTPGBKyL4KZ+D0t8EGG5hTTz2159uLL75obr31VrvLAv7/1a9+ZaZOnWp23nnnSjgQzO655x5z5ZVXmksuucQKfPvvv3/l+Irtt9/ejBs3ztxyyy3mxBNPNF/72tfMmWeeWYaB3R977rmnFexuu+02s+uuu9rf3XffXYYBge6UU04xZ5xxhrnxxhutwLjDDjvYrbe5IFJnJ6rLB9Ecl8ukkpJvLqCmEmnYyAQiFUIqQEy2WJ5N1xclpMn9tOrl3zS4/llbc5nCNwTtHhPWw/hhOEmZwnASgYcS+GJxctRZKOSFi1OsH/fUq2BR1i8e6wtJOcx2TsDiflR4h7Fjl7Rz5/e+d6q57rrh29s9wNEXSy+9vQ13+OHfJtOhALszQUC76qqrPIHwWXPjrfeYLTZdX1ROOEuuX202cOecgSR90UUXWaGIws0332w222wz8/DDD5uVV17Z3HfffeYtb3mLfb/psNgLjobvfe97zb/+9S+rbTv99NPNV7/6VWuHXmABOBTGmC9/+ctWS+ck9z322MMKiiDcOfy///f/zIYbbmiFMagiSOuLX/yi+dKXvmS/w+WnYMP+2c9+Zj784Q/rLj4/y5jFFmYmconKvQHH3dzp1clP8g2bDCWOzmE4TbkpRh1OyLEyUSY9Lp+UdpHSJ9VAavLE4sXqgPvOvY/R2yaTbVs4C/OOCblcmDAslYd2LEmEbgldku8UtGMOe5dCW4wvSNLAzjl74YXZF587YJqf0Fk/9YYAN1fl8stacsmHzGabbWkWW2xJc+KJx5j111/fvPbaa1bJAnP2z39+n7nmmovMV76yh9l++3ebHXf8vFlppdXNSy89bx555AprVfvtb39rLW8Yvv3tb5vjjz/eHHHE2WbFFcebM8440vzzn3ean//8XjNmzMhl8ZUbDOCcs0XWtRsK3vOe8ebhh0fqFtqinL+7i897AZUCQpw72+SGG26wfzvBDADmxnnmmcdqtz7wgQ/YMNtss00pmAFAaofGe+aZZ8wSSyxhwxx88MGVvCCMM7Oyuz9uuIEUzuBMFvg5QOMO8pbzJKGsoSM4Yt9KBhbxEYsxZP9dCtMnwzqfl0j9UPErpkRix58V2PwV+3AemNmtTtmcYCiZvNzfnOlIkuegIyb41RXQcgl4qUK9T4dLB3vv54O9L8O7fuqdbebKONKH/QM/4zT1QDjWNPWKmXxFfqfSOD3xbQw5gYRvV/kts6mOSk+y69EX7FZddVVz11232kNoQenx73//27zxjW80m2yyiRXONrWmzA+Yd77zejtXH3vsXtaFCeZdmO/PO+88ewitwyqrrGL22WcfaxUDwC5PULiceOL+VhO31ebrmyvOPdE8O++IwIXimbvNww8vYi+Xdy5n/cKo2RAA5kOQlsH8CP5lABCYlllmmUq4+eabzyy55JLljg34H9ScPtwuDvgGwhn8j+7s8NLw42FhMBx33HHm61//enKZudVZip9GHWhXf5o0JdouVKgKfMTCOFR6Ma0RmyfC4HsEF8QvC9MIaSa4prWamDCg1ShSkx/WdyT9SfIepdGb5GJ1nQpO68d9S01f22bcu5jAphW4tQiFfQmdOfmPtr+F9LELx0lDlV2dKbT6wiqWPwgOcAgtXNK94Au4KgvTcFnBafYmyL4gFNzAf/uHP/yh/YU0TymFvU2tPzgn/IEL1OOPP2GWX/4d5TtQ4hxzzDH2V73fM51+e7lPixgVwhlsDoCTgkF7AFL1aMHhhx9e0ciB5gw2JMCuj6Gxi1XuK6wMYmzlF2hFUgY/5zvBTV78xDb8cWIezUlv+jQ9/q7QtiCaoLDzmLz6UaFyfQhCD1IHWq1GzKeGQyiUSCe48F1WgTS4mJzKty00kXfdfq8VxGub6wj+Jdr9zfCDKN+MxJMK77J+PTwWJyb25VDzPYGmZ9Au7q6roatjLr3mmmvMppu+y2yyyYhwpqon/9vLL5tx41q+fmG0CmdOMAM/s6uvvrrUmgHA6e/JJ5+shAe7Nag/3Y4N+N/ftQFwz7Ew/nf3DqR9Pwz4pVEYM2aM/eVAzBenHwei1kVbghWnrapDD7XCrYAxS2qhMrFkzCc1PqVd5N5RoASB3Bqx3H1qkKDlHVLXgSbQSJ0SZkd13Nh1Zr5LQuyKqsygDoQthaeAFkoj1erhrFartSmd31Ow+5MWsOAWAfiFcdzxGHVMseEpC21qz+YZDYIZHFnxhz/8wSy1VFUnucUWW1h7MuzCdAABbtasWdYfzIWBHZyQlgM4Ha655prWpOnCwM4OHxAG3oe7P3wtGPi1uTBaOLOk1Dzph9PEo9KIpYMJAhTN2PvyeIrgGzB86ifJS2LW5SbvyrEDgqMhsLR78ibMmNIVvx9WakrFgOXJ5ed+VB1jwhRFH/atp08U1X6Rilj/0SCVjormJ3JETQ5hN4ewwmk2XbtQ/SE8nsIPJ6bN3odZdUXQ8D6MB2oR9j1Jnw55WgrCfLh+i4X1v0kRnuJPmTqps8vaPFpCdJTFU1Mqzvu1EElnEHZr9lVzBueRPfjgg+UzON7ffvvt1mcMNFQf/OAH7TEasIvy9ddfL/274Ds4+MMdWzvuuKPZb7/97K5KEMA++9nPWgd92F0JmDBhgvX7gmMywGcNjsf4/ve/b04++eQy3wMPPNC8/e1vNyeddJKVwMHZcMqUKeVxG2C/Puigg8yxxx5rz19xF6lCHtzu0pzaMW5Qch3IXQcS02LE8uDy0poAYmlTjEmTRh2ITTi+w3/NvKTfU+uam5hZs2lNk6PUbET5IcXok4TjNEZNM98m+iMlVEu169I2s2EZYcTvGxotYhMaYE3+g6bxxMZYKo3YYbS5dliSfmwCLVQuTdyUaZuaTZeKpx9qzbD8QSB04fyyeVd9it01GkHRR1xzzTVQ5J7f3nvvXUybNg39Bj+I5/DUU08Ve+65Z7HooosWiy22WLHvvvsWzz33XCWfO+64o9hqq62KMWPGFCuuuGJx/PHH99BywQUXFGussUaxwAILFOuss05x6aWXVr7PmjWrOPLII4tll13WprPtttsWU6dOVZV3xowZln74H4Njt/7f/jtp2NiPiiNBSl6a+Fw5NfRpEMbB0qBoTKlDDb2xdpOkJSkP108kdDfRT3P9+pE3Vs+5yyFt35TxU4cmbZ5Y/lw6HA0p6WrqKVbX0vix9uG+v/TSS8Vll91b3Hzzi0VbuPlm/Bd+7xduZujB6MXiAF588cXi3nvvLVZe+aWe+o/N37kxMOeczQ0gz0mR+IUFYahVsmvNVFU4mmeMNuFuxMolx94ZbhytaFpKPzoJPbHrsCgac6/C+7mq58qN9SvsPdf+Ui1SmEYT2i2qbXOnnyNtjlZ2vCUiVvexds3dd2P9iaoDinbOihDr50nw+BWn3fXz7Xl2GswJhbUiwd2TcFJB6Ooj8juroS2TpiHVpFFhpmT0hYul5X+Dy9bBj33TTdcwL744b/kd2qM756yDCD6ziDEtjVqWY/TSSUCSF0Y/53tVNbU0W4bYZMg9U/G09MSYuBQx4cr/5vcXLB2Ofuw5zFtDuzRsqpCV01SBCTE5Bb4Yrf0wC0qE5hTBTkIDRqt0/KD5eYJP06jkJRXaAteJeeed157v6TbDLbzwwtb1JkR4eU2dy2zg2A6Xhrs4x73jgIX3Lt6p0BW+B1AmWU1ZfNrD9y7PKVOgol8006c/ac49d3HzwguzBbN++px1mrMW0ZbkLdJiReJqtQA5hb+6TJxcfWaoD0meTQ9ozWSsEc6o72FYbZiUyZYLE/u7H2iaFkqzkgsh7ZQGvm65Usa1dDyn0DZoGmr3nnoeWegU1gcbNsSFePjh2f+PG9cE9b3pu2cqT/+7jzAsFU4SJ5ZW7DvU6yuvGPPb3y5ufvrT5cysWbMrvNqn4BD59m4I6ISzARLOBsFRta5w1pSJI2WFbTF59qGQ/gGR7u9cq2XJBBYzEcXMhVQ8KW0p7VDHpKXpB1oTfFNmyFzppppzOVooYSkFEhO9pj/G6k5i6pYK5lgZ6qIxfku4X1Dl4YQ1TMsG78HE6Z9E4HYaAnruFb9k+MP7ei8c16BM/zuz/1jrSyPpIXeZl+F9YOFSyrCWl7YfNswzTAeLt9RS81tTJq04aFc4G/hzzjqkMSQpEwyZgMZ8UodBcqvhaN7ENScik2XiVvgQXF4YM42ZWbTCm9TMKAlD5ZNirmtKe5RbgxOmI02vDQ1dmxpAyoQteUd9kyzmNNBqdrV5N6VN5/JxPIES0KTuEmDihJ+Pf/yDIOCVYXVRjXuJyjIAH31lOL9vLVTyuYUW6qXdaak0QvDDFKlBGaCsjiY/7D++xS++wzrS9vk20GnOBkBzxq0MU1eLKYIUtzqX0tiUcEbFlaz2m4DGVJrD3CLNL1U4o2iQ9pum674J4SyHyTYWJregEuZTF02ZXyV9tq5QlEKbVPsv1fT68WLg6kMzpql8pXwolcdieSdbNGq6m+QGN+eNoF3N2UAfQjung9KoVN55B6U6zVb4c8De+d8wcHFiSI2XEpfTPvlp1omPgjio1qefK0vqhOLo9emWCNx1DsqUQmra9L8n138LwNovV3vmLrdkvErqG/uee2LsGSPQLxPPBeQEFI7naXlMLL8wz1x1ljMtTR4Ynwm/jyYMCcZbGMbnr9w8CTcEtIlOOBsAaAUqCWyHCwSLkqH4k/dwmHDlUJnkIwzV7+zl34LT96MDKUEwopiP/yymo+YBsxpIGL5kwq2bv/9c+e71GQnzo+qwSUEtdYGBod8reZt3IGTnEsg0WnT396AIJBI6ylsAQv7h80JqAeMf95Mo5JbpBH2/pDnkKxE+E1uU96SvoZPJUxrOn1fYhSExH8VoT0bCDTCDhE446yNig4wTJDDGEVv9VLQwSg2Lf70LNcilgx+jOzY4JYPXpZs60Ml6nUj7jcWYHsVYw1+YDjY5Yt+oCYRKl6Ip1NBV6hLpJxLtTRnWu8YrDBP2Tern59uzkAjGC1rHRH8P80nVPIZtIg1L5SehlRMeXB5+/Ybfscme+runnjIIa5oxJcmH66tUfWP1n3K9mFZjU/cKs1jeGiE8Ng9phXNsvpHQHevTQwS/wGjmgPHTWPkBbd6rCeh8zgb4KA1s9S4dcFinjU1yUnqw8BRdlJApoVMy+VNpSGim0uQQK09IW0r6mvCxtKQaoFiZtPE4WrC0U9PB0uDeaes0rMO6bRLSR9EUyytWn366aD+QHuQ8HM7tci7z8nY+120bSVgtKml4O7ZjoOrdpVNi+JwyrA5SDvHWQtpnengSCKLhtXOOtlifCL8j4dk+p2yjQtCfufTZMgR0R8PbDQ+dz9kcD4kETq3iKamfWgFjWgWXfphfbEXOrrIidEq/YeBWYJiGJgdSVowUpKtYbdiciJVPqrGRpkeF18aJ0VoX4coeoyGkQyLQSuuQyw/LG9Nu5fBFrIyDTD6NoUCG8ahcbelrb11dxPqbpC9W0q3BH9z/sb8pOqm+gqIhU184ViT1y81lIaj5Ldf8EUPbPmfdURoDjHIlMVE/AZBpKseleIUyoTDFBPxTbOUUhuHC+4MzFMw09HJaByxebBXIxfHD5BK8pO0v1XxJ2iiWPiXI+G3mf/Pbk4qHLSK4PGI01tWQYWVoot012iNRXwi1BIjWAC9/0Zv+sOalcm5g0MZhmjHac40LVEPnaJyAP3O8tfJNUIcoamjNtBpt9r2v6Ro0X6wWbmeoO+46s+ZcYNY0ZoYpisVUZh5MlZtiKsDySzH1+PFiwozEfCFJS0szRqc0Hkd/rN4l6Wro5sKE0JqEYhrVHIjVZ0gLFi9X/nXCpNBUtwyxsZELnFBMjVnsOZaulAYfVF7cOEwda7H+SNHM1RmVPpcPx6+l6Q4SRhudODqz5twB4Q4dafgYQpWxdkWePKiYnUkoHeHuquEVemmWybTio+pBooGp0MLQ02P+GS4LlS5FY5PImQfZt7BdaxEzW1jXZdoNHxOSAznbjDPHSM3MmIksfNcU/P6Qy7wkza8pYOXAnnOYZDmhF0030w7FZLqV+WvraSin2wdzEkA498GvM2vORSidM2MrDXfO2XB410GxgZvCmFAhcJguTkDDtC0V84Z3PlslbYwG5aSrKWdYBukkQZlqxPRMju8eY+MzlyUPDVXNTZqVqUQjUEcTgpmbNZq+WBnCcSMpeyx/SlMh1Tj7YUN6JBpWTrvox03ViHJ5+zSEf4e8RrOYofJ06Um1Q9S3aD8RlD2s05Q6luZHaUH9usbqWTOmi0m9+Wu0eFi6OYRdKa9qcqHQU65JPC2asdMEut2afTJrGrMYK9xITYaDAI3pYhAgHWhU3UvahGojzWQvpRdj+prJGZsoswlnRX1TWgypgiklIEihjS8NLwlXl3YqHc1ETtVlCm11BAgJOHqw8ZcjXJg3JZz54WK8gEpPSwtHg4RWCSieJEXBxKP4Wg7Bmq7j7m7NuQYShqH9Jt4iLwGydTp0AC7/Du+75FTbDTt/pjAVlNGhZZituVQxrBptUkeQ5MKK+h6y7Rxta8VRDDkvnO+ht0O0nmJjI+zbksUFloYWuQWBusgtSIfhQ+1hTIBJLR8VD9f0Q+CRD3UWoU3UGcqbGD5CCbExrWQ/tGQYukNo+4Swg7hfP+CYxaB0SimtIc3aMuT0Xwrbzz33rNA8XysqTkzFzsFn/LEJ2A8TPksnYb/Ow7y12q/UcYD1Cern5xGbWGJ0aMdLrF38PGPhsJV/7EelG8snbGeun0vTjtVtSCfWz+ryNa6vc5oVbuxo+3wlD4ELBFcWCQ3R74rjiDDe67dR+I3SClJ91Qf1XsI3wjqj2jvsK2H7tu1z1pk1+7hbc1AgVgtzqxXqgMIQNTUmlIo7pvpuVMMY0BZOKrF3GrW8VMUvWRHGmBmn5cLSyr26l8ZrUjPiwtbNT5qWhi4qbUndcu1XB3X6AYeYpleq5dKMIUlaKWOabHt3HJB3GGssHwpNtIGfbj/7xpCQj2naRjJ/aA+Rr4vunLM+oG0J3Ae1+hWBE2RSzwBCIBnAMYYcE06KIIAvkGCmWywNLoyEIXP0x4S6cGUao8l/L2WwUA9+HKkmJxaWoktEU6ZJRzPJ+KvzugIM1YYaumJxNRq3VoAthIJ3dds1d9tg78N3WJ4UDdUFzwh/qYQf3uzVkw+zcYzKJ/ZdMq5jfTWGHn4TmE0xmsM4heDMwZG0e+swJnRj5c8t0KaiM2sOACiVPWZSUKOBrdUcXbVoTqRVIgxwquxYPK2GJRUck+SEMSx8LJ9+MKDafTlArjLkrgtpepoFkt9mGk2rpK1D801dqNKpwZvq0qtpJ+nRLyFtIu29BN7OdwndbY1xqk7Cvl32Md9s2ueLyYsUBUWL6DRnoxAaYcRtrW6yE0omW9HK2DmdEzcNxOJLmRZJW8Bo1KZSJr9UgUSqgo/FdfGlWsnYu9hqW7uCl37HVtZcfA6uPupqCDTAyoMJrGFbxTQy1Ls6WgFKM0HBlSOkN+RBFL2SttT0F1QLhfh5+n/7ZajEGy6DfU8cZyMaU8HxOqFWDK3zCDQaWE1/6CkbccNApQyazUJIPlhbF5KkqDrUlhGBo6nzOZuDQdmstZoZjGnHVPFSphxTCWN5pqq865oyJPWAhfWf69AZU8dTYcM4GI1ceIlmLBYul5Ceoy+EkJgyNPXcJD1Np1U3b6kw6yNlXIZjQard0whe0jAYDeG3MB7HWzlw2kzp4s4XBrm6z9HnB1FD5EOjFW4LI8JZ53M210E6sXHfw9UelmaqJgX7jq04c4JjmhRNHLILI57viP/e5RUVHK1KP+6bJ6nbnPVfV2BuC9zkhYVrUzs22kG2PabJKbUoRWP9S6oRjy1GNMJWo5BsRgrq2t8kEH63h6kGmwhIYTlsQ89HCy07cpxOdLOXZOMYEV+0uJ6M0BSmL33vvjFt4Wh6Fo45axGdz9kAAVO5UyYmlcpXofp2aUtVwVg8yY8rXyhQaoRW7cTL0ReN610rJEFZFo+5lM/umiqkbqT9IsU/xdHE1XMYhguL1aGmjlx+XN/Q0OObqcL6lLS7VDCQxtH2T5/2lHEXhovllVK/2FgQj6GMxwhx/AUzcXL9DEtblLd3xZy0/jU8X5KGhu45FUOR45Z6+vOgXQTf+ZyNDsQ0LuVqAtHE+LsP/bRY9bH2AFnJMRrMTi0VIqscUf5Y2LDefIZZ+ojMXtmhQi1Rz7OFLmTlmwEhU3f5ceGiaXplTUY5ORUj/VKwws+B3GmGGulUOrBnl7423dGCVGF3UFDV0tBanQokPC3H8T0Ir0X5gf9M8PW+tInTuAb+axQKqWk84t84mtBtCBhAhBMk1vl6TJTMnWrYVuxBZpI9wqgmvI0jmHBrHEA7e6Lt3bzAbXmv0ugJKDY+3RicOQ5tQyXj702jN75Wi1qtZ1qIlfgE+X+nmiYpGusKcZTQjgl0Us11mXakjDl94MTpIX2L6r+StsLGebiIkfCpynjGaNQIiT03WozkEYuPuWKUZ5cFmweiCI+EoDZJIUeRkL5p2AJxYgI/ifEY6ZFL7m/hOYoj74sovb31Rb332prZiNYPdMJZP9HAQaho+tz7cOWCDR4urVzAdgIptV0otHWLpV0nn4avqsoCrj+4dyZtYgnPjKsjVHCaASpc3THHCp+JTF1K+yAsoFghsWn+lYpBpatDIyik432U9YtOOOsD7CUBEW1XTOtSmRDCbc0hmu6MCZO3OqxGOEQEjN46rjdYY9oY0vypzKrtyRrTdkk2JEjece+ltEnACYJ+2WKmRz8NiXAZ8z3zNWux/DiozNSJ/S2k1f3NaYz8NKL91jN3VxzCjX5MVk7Wn1hP29UbXi6Au/as+rIxGpuItivUxobv/LL7h2pTbiqVcR1z1k9wHaG0nqgzf2ThXxT40Rx+mqVmMhS8Inw9HPO+djOkvZ/ohLN+AjkR2r13wAZiTweMXf4KDKtQnOavVGX3MJYUYTCiqeJO7Y+mpwnTr1WV4sT0nm+Uz5+0LEGelbquozFl6ODK1yR8bZdGMEr1PWNpGWo+Xo4FApm20I8Sa+sRs+FQdj5ax7+zCd/QZCh2wdbPZw7BZFrrr27bPmvaut2afQAcZlf6g/XxwvNUULu3uF1ddfPT0EGFCVddsTJgYSrvhndZ+un57en+xnZykeVTnJpN7URKRUgv9w0LR+2Q0tDMxXV1iO2SxegovyGnu2u1cH4crp78/LH6SB3v3An12jSxOsa0HFxbS8JQbVvmkdgmWPpc/+TqB+tHXHiqbSXti4V176kLx8O+HlskNMWDJaDGY0qfH2L4LtV/SLjd8IL+jOXv8nYWr7bQXXzeIlIuTk1Z+WripJis0JVwxDTLgdKixMoh0b7EzFZUnpSpAdNkUisyyrzA+WFxjs0YDRy0E3YYV9umnFAlDRNtU0bDSKYdaScOmj4To8OnJ6eGButHueLH+IZ07GnylY7xRrWvhNaEpFVgEsTGk7gMsAj0+AY1NjHBD0NSnSH8i8ovtU24OuL4skMouNn7gYPxX4lH8BM/3Mg7OOisu/h8joYvgccmLqyDxlZPUkiYuZ8XpWmi3mFMRMo8QqCrSsHE4OfJaXMk73rSi0ywPWUNwqP5ujDeLippfUkEA01cP0+uz8XylEzSYXth/c4+IyZ/bAWczcxF9I1GBAKlUOjTw8WLpavpM1Rc7SInpCkF0kWqZmERC1uZ9JV0S8NT7R470kdaz9h4ds/SPufHweiuu4AsCMGMi0Pyd9dWAU9NnS/aQqc564PmzJgZxpjFxCscUmhDVnfiwRWsxDgaKGgnAo3wgK4OE5w+6wgslbyZ9GP51dVsaNOQCq1SxDSIdSFeDTMCQPjcNGOV0iJJgxrfmokyBRqtinayFQlnGp8ewdivo8WRhtVqkzXxtFqu1PJS41mrJcbS0EKrxdLyJK1AzPOOdjVnnc9ZH33O/I7T9EocA+XnYL9FbPJUeCwO9l5EnyRu4PPlfhzdlBYubI/wnZ82FR77VoYh/KUkwMpVB9iqW5JHHTqovpGKlDbIhZR6wCYYjTY3F3zNiYQPpU66PRpMga9narmxfBwdGnql4ZrsW34eEp6bmn74TpI39130TcIDEzcoFEJ/Qey9i4+Vw/3avvi8263ZB4DyDFvtiJhD5AT3cKVKMilkdeLDZ97+u54wykMWU1abaBzhydKkiaAFYbhnMiZMlnXST9GE9QMaQT8WFyDRKmm10Vz+OYSoVK2xeydNP2e/kGoAtSat2fwlTtxIWv7Yae/Q0Fz1mJM3UjRRc4NEK9QE//D9Z0sauBP8A55eMGbYGL05yhPWVdvCWWfW7JNZsygWEw9+rbqWGozYyp0DJehx4VMhUVNzK6IwXCoTSjVbSKA1SXImYUy4r0tXrH7DPDG6OZqpOKn0tiWctQmujv3vsTDafiExHUvz05pA/Xw04MZKDKm8pU6cXPyE45V1NJ8p9HELAk09hMKXjyYWoBKTcK9wpt/QN2rNmtdee615//vfb1ZYYQUzNDRkfv3rX1e+w8rqqKOOMssvv7xZaKGFzHbbbWceeOCBSpinn37aTJw40VbW4osvbj7+8Y+b559/vhLmzjvvNFtvvbVZcMEFzUorrWROOOGEHlouvPBCs9Zaa9kw6623nrnsssvUtEjhS+ASjVkdVXrqiq3nnXcxt1RFXddUoS0zddxAXS1NDsQ0pJQpoHYdhUdzKI7qCLega9CWZtKnDTNtY3U6qIKZj9Txnjs//71Ic6EwSaWYhSleWIdHSvIclYiM31id1XKlyHV22uQa6The5/8U0Gjq5jjh7IUXXjAbbLCBOfXUU9HvIESdcsop5owzzjA33nijWWSRRcwOO+xgXn755TIMCGb33HOPufLKK80ll1xiBb7999+/oq3afvvtzbhx48wtt9xiTjzxRPO1r33NnHnmmWWY66+/3uy5555WsLvtttvMrrvuan933323ipZckNrGKYQDTiMQpITJgdz5hIxHk/4gMeSY0BYKJDGfHuzZ5UHFj6WNATNFhLRz8bh3aqE9s7mdip8iXIeICZjYN0xoSe3Dmv4T/l33vlr/b0xwSBUUsPFBpc2NJ63PaFiOWsIO4ivov8PK2kMPQ39q//fp8MtZ5ic4b46qe843um5d5pwjG0MxIABSLrroovJ51qxZxXLLLVeceOKJ5bvp06cXY8aMKc4991z7fO+999p4N998cxnm8ssvL4aGhopHH33UPp922mnFEkssUcycObMMc9hhhxVrrrlm+bz77rsXO+20U4WezTffvPjkJz8ppkWCGTNmWHqNmVHprtV6qL6n/q6D1HQompsAPu1Uv2nTaorGtuNK6ykWxg+XGl+STuw5Vi+xsJJ0Y+WRllPSL5sIL6n7WPkkkLRLXTo1bR/ml1KOnG1SB1wakrRz9A0snbqg2peq0zBOnTIAJOXQtiVeptnzN8zjbWBgd2tOmzbNPP7449Z86AD23s0339zccMMN9hn+B1PmpptuWoaB8PPMM4/Vbrkw22yzjVlggQXKMKDxmjp1qnnmmWfKMH4+LozLR0JLbkBXwN5h73NCuiKJaThSVza5VpdNgtNCUWG12idpeKxPYM9cv+HSb6IuOVqo8mj7PacFpNKuM7a09ZSzXiVjTuN3FNYDpTGj4mveY3lTbaRpH65d/ecwba7/1eW9VBqattGESaE3hX/WrRtqrqMgtSCNdgyscAbCEGDZZZetvIdn9w3+X2aZZSrf55tvPrPkkktWwmBp+HlQYfzvMVowzJw505pV/R9gxlkjp9CGV/qEHZ3t+IgdPcnPi0knO5Arj/xnCdoQUkkE9ZSbKUmAqv4FE4joO3NN0CAvNMK6oL5x8erS1XS/lKYd6ggc6i6c0LwE/aWkIfSBIvhOG0htq8YXfxHfqJieSQNRHIyekH8z5lOMZmneRQPjSVpXjheWl8b34SiNgRXO5gQcd9xxVsPmfrAZQcrUNFooqZagzJvYTYP5YoTxOGaADb7czEy6cqd8lHLQ47cb5e8hyYdr3xSmy+Vb8Z0h/Hhi2kBq4RDWuZTuVC2itF6l77X0SOJLx5D/Hvubik89U3Eoen2665Sf4il++tRzSE9IUw4MspYltxBSZ5EWi1v278TzGmM0ifMvqnH9b2H4cF5rw7oyR59zttxyy9n/n3jiCbtD0gGeN9xwwzLMk08+WYn32muv2R2cLj78D3F8uOdYGP97jBYMhx9+uDn44IPLZ9CcWQFt9xnG5NiK650fw8Hv0GgHRq63yc3MRmjAzigqsp391TiEdY4hrP86GppBLB8HTpuVqvXKBemipi0a3GSSy3yTmo6oHiKn+/vl6Lm+LOEKpLbKH07k/qKzUZpq3HiSg7YeupDbZ6h2C3k8m24GDBGLTZ42Tdrt9M9RpzkbP368FYquuuqqinADvmRbbLGFfYb/p0+fbndhOlx99dVm1qxZ1h/MhYEdnK+++moZBnZ2rrnmmmaJJZYow/j5uDAuHwktGMaMGWOP+PB/ADjqDB1ghEqbWxmEYWLvsO/cikWzgpVoW2LgVnTaNJzJ1P/VWe1VVmHEkR3lL1Dtx+jNOQFL80zJo0eoqlm34Yo51BhjtHITFEd7WwjHVRN0xDTXkvc5UGehQtGv0aKk8CdJPKm2LyfqaIWp+JL6kdTDoGiaCqaPU+GbuBN7jtecwXlkDz74YPkMjve333679RlbeeWVzUEHHWSOPfZYs/rqq1sB6cgjj7RnosExF4C1117b7Ljjjma//fazR1yAAPbZz37WfPjDH7bhABMmTDBf//rX7TEZhx12mD0e4/vf/745+eSTy3wPPPBA8/a3v92cdNJJZqeddjLnnXeemTJlSnncBpzBFqOlDkZUxfq4bOcr7eVFs6srQViMLmqViKZrz1ljVuqae/pS4tvvkbQhTBjf0W3/hn/yz5ISxkkxNInA37YmLUQ/J4ZUQZCLV9EUehdpu/zKNLwT33NoXEPkFtianCDraF7q9OOU9m8CVBlCrVGufGKoaKhKhQKtaWpicVAgZY+Zc/3/uTj91JgNhOYMBKCNNtrI/gBgAoS/4bBXwKGHHmo+97nP2XPL3vrWt1ph7oorrrAHxTpMmjTJHh677bbbmve+971mq622qpxhBr5ev//9763gt8kmm5gvfvGLNn3/LLS3ve1tZvLkyTYenLv2f//3f/ZA3HXXXbcMI6FFe7emZoXQL5t5TKuGheXSiuUjgaT8dVbdVPojV1WNPPtaMgly+2pwzEqyYvbjYszLCQmVM4sIrSDn86Hts5R5oqRRoZmkIGm3SlsTYZvUkGFp1R3/FG/B+It0spVqpHIC07BR2rFQsxzTzIXjgQtbp7w+fRIhkqKdMvGFZeHSTBmj/RZchwTaQs34pMrUj3J21zf1+fqmFFCMExUoGvIdY9NHtFCieEoaNMJcGF6yAuUE0mStYQLdHH2xMFx+XBgp7bF21bQ7FpaKT9WBFiBwYT6XPeEEvj7ZNReTq7RJ2runfpUaZUkbhO/JMKEw62ioq+XuFz8MXU6G74KsaD3DsiHPVH8L61RMA/bdv8+yBp/00+ToxtLRflNjclD3ijzQxR+R3kiacNrCXHJ909yKcEtuTIOTU0NVF7FVp08rt4rWaKwoGqRpYLSG5ZDWv0Tr5a+EpSt1rpwSwcz/xsWNhcG+afqanwclFHN9JMyTooMLI9aMeMKDpE25b7lW1j31QewM9p+p+uTGHUezpO6oOOUzpZH0hAuOhjoauHD8cXTnQB0Nbk9/H9bQ5hL0UUGLOKojlT9xqNOOmroPNZCpc2RoHfHDd0dpdFCh6c4fyyNb/uH9jwMGW74BoqstYSGVcfcDmr5ow00sejRTORBLR6zJCOhrClJhLQxPLhyU5+Sl9tVQqNekq+VbFO+LAjRbw1osG37CbL8sv+4qdEwYafNc4zhM36JBXkYJR1LBSYshaTsnlrnp+XXUHaUxx8NTP1fU4Z7DeDh4cXUzPrmIOj/WWSckOL0TTvvV4zIC5o2kQTF1igH7DtPluxorWKwMKYNSq2JPMQur0sPCU6YlgcmJmxC14NLImY+fH9Um0rbGtJY+cmk9JOlR/aLUqjnhbmKvQNAUuCMyfLMR8Adf+xfyL0wzSI37NuDT7tdvpayZTLUkYuZKpekY0xCF72FDGRUuhkb724Sax/4QcxlZtgva3a7ZCWejGRNGzgdrUqsRPQFc6gxfEULbQzgZSxhNDwMcEK1Z1cxVJdw387VKE2ParITxfFf8yThJgBXQEb7H6EoRADkNUy4Bj4ojpQVDaDouF30947cg42F/a/J2cTnawzYh69vRHUywPYs4wgwbo9MPh6VJCY9YHpL+Je2LqLYyeOfv/JeWVZInJUzH0qPCSvt0IeHRXL6O9ySMd8e7nn3RtIpuQ0AfNgTMOMuYxT6B9I5gtUMxqVDz1ISGIURM21A3bzYdbhWo0PRQiDGIQTDnSSa3ftMpmaSibeELn4Rzbm76XB51V/fSNCTaBCotiYAUFWqU9enzHY2ZNdZPMY1YxcwcHDOCpSGCYgOChM9pBHCOlhztQwlnnIUiDCcae8imALVwNlkwtokNE0WKcMZYIEhhMRT4vTTK+bulDQGd5mwOhVRokgoh3Mon1EhIB5LUjyPl/LdQS8DRQcWRMuEU4a9u/cfCW4T3FgZMr0foV0ymWlqxbz3pRbSTUmEm/DvMGwvXpk+JpL/EtEpYHMk7LC2NVsOf8CXm4dRFzuz+oI/n5yme0DPsHq27gKC0gMm0MGOJrQNJ2tQ3ancuFZY655IRyn3ENILYvFHRGA/AoptDJ5wNCoJdTFZAQA6hnN2hCDV+ZYARPS+yLdqHiLFih7NGhAIMrDDEMSy3Ah32qZHkM3vHUvyqlFzQqOn7yTA0+buwUgEbQ09eYXsorvSiBAKOHqk2RKLpct9zaOBiEJnLEgWOsB4rQhfnS5YghPWGK3r8VOtgpH1HeISeprT3dSHVwDbhf5frWq26/KygBDisb1PzGuO369NXEWj9dJv2IWTQCWd9wNj9ZpjiE/i3SufSdIxAIIqptCthyRUUs/LxOrPGnMNpp3KuHiVn12D0ASRai9gEKZ3IsyA2EQdOxJwgQwGNL7k1oQbC+uE0oHXLx0GTRpOCGbfq7zHLNJS/BD2TXvBNrG1J5ANhn4i2iTKfWuOWdECvP46q5Rzmed6mC5cXqjGPbYCS1FFkA5NoZ3Qm3l8w44DUzCVsjmoS3Tlng4LhLdcUQvNcXWAnrGOMU5qvC0eZV7iVp9bHwjejciaU1InKL0tqnZfxw9P1g/oOT54PTcS54OfNtVOFdsbMGdYtliZW5rr1GiKsrxShV6rZxCApS6wesH6B0RGWM6WfhOOHeud/w+ij3Aao/AYBYZ+m6gD7xZAST1qvGA+JCb0aYMKbpi6wb1g6/jcqDS3dQ0Ppcw1W94PSVwHdhoAW4TsUjh27WFTr0obK3NeAiR2wIysKjP5cZZIwPClN0jw0cWJhKUEgJc8mV3dUPXPCvCSsuv2J8jVuOlQ4v0s1xylpYAJyqIHWIJVOTlCn3mMTMqbhTOUJFB+jtEBSXyYMKeNaEo9Kg6o/af6SsSeJg6Fi4UBuseDywMJwNHKIlatO3WNoe0NApzkbADQtsVOrGk6QqbOK5PKOpZGSN7YiDvNMobUupPUWrpZjK0ut9oNKh6I1pIXSonHan5iQLKE5pXw5kKJx5bRiEsSEnjC9VO0j1WaYJp3S6oT0SdoE1QhF+jrV/lIekgquX0vjUHRLy4M9h+Nfkj+WRjjOqfJIysZZYShegpUhpT8XRHqUZpHje9rx2gY6zVmfNWcUJJMbt7rCVqhc2lz4VBo57YNGAyOlQ1LOGKQrPSoeV65Y3WLt2ZOGQKMjqdtQcyEpd6ydYtqQWNk1Rw3E2lranzVpUfEwQYqKJ4VEsxT7zqENITe3FipHvloekVrHOcpALYi4caGlietnXP+W9k2Kvjp9t05+4TcNHd1RGnMpwkGXs/NKJguJ1iMEKhi6E/YJgUJTnpSVlAQSZke91zB3iWAghQ0bbvpg2rVfky/HgDVCi1vN5qBD+12jCWoSrv9ItKEuPEZbzoVQk5DQpl0wxOJL6ZGMY2qhjMXXLIKbEFh8LZz/XpIWpeXjtK5hOJJPJLppFBGBMecCvi10Zs0+AVP1cqpVTA3s/++H8dW0WJ4a1DURcBfKYiplSh1Nqf+19EvjY3RyQhBVt1QbU7Rw9RDtE4pLk6mFANcHuf7jCxJcO3HvMaZPpRWjFRsL/i/8ngLpeOLqzP6CTSFNAesrFToibd9DN7HJgYtL0YVNmlj6GB9EeV1Qp/6YC/sV9ZwTsfrFwmJxw3A+wjJg4PhY+EuZLzBQm5609TwUcXfB2jh8lsyvdeecXOjMmi2ijlqUWxVwK6S6wPKVrnSoFT31jMXTli22wsUE3JTBx67UMt9PGdLcFLNgaSFO7m4LKYsKLi71PbUv+HGxZ0k/5mjWrvi5fq7tcy6OND4XF4tP1U2sLVLqKEobouWnxp+m/SogzuRK4dmSuqP6d6yOuXFRfkvQdFF5xvrYkFJ7GaZJpSsdq51Zs4MaqYKYhNlqVsLYipaLx2kUYmEoaAe1ZNKQ0KmFRshuIn8pyjpQ3NIQE3pzLjCo9iMXE0KzDEdLrFwYTeHEQ2mLQs2HH5/LG6NFK9DFwvp0cxN+jGdQZeNokZQ7DIdpRbk28s9tpGjn6M3Bq7TQ0iItizQ9EozQpp1vNDRIeDj2rs6c0xS6Q2j7gLHB5fZaoSA3UvOzzK/m1Uo5QaVbZ0Uq1RJUJt8adSJBm0JZbDNCdGIVHCysWdlqw4XfJFpXSvDgBEgqXz9NrcYplm5MI5aq2akj1GnNVFgenPBHCbcSjUicjmGNmeKWgjRtZDUfTpvV9FiXCr10HKosw5Emyua4OmUeUmhM6yz42kZn1mwRTi1qzAxjTNWsGZPsm0BMWxGjI6Yir8Mwc6ryqXgSE0WsPih1uHTyk2gFOJW9BnXNWth7DR0xDRaXloYeDtL61qbbD3D9IiZocu+5ftZUvWDCmcT8FcbXaDXDtDQCf0wwlqTDCSYp2lnONJeymKHipixSMM1xG8LZUM168MN3Zs0Oowapk1jbq5EmaQzV4ZRZarQhVfipm99oEJi0tOSiXSJgSOK3QS8p9Ah8lFx4TnDql/Y4hOZuS60Jsk1oaBAJPxEf1bbas0hId1B4TWfW7ANmzDBGsx9AqsVpYkLUMCd/YLp3TSCVySXXlaI8EqEGY0ypk6umH9RhVDGTYEiP1s9DSxP1LkWjEn7TtIWmvBTt2rw5elLSUE/MnkM7V+Z+CB3asoRma65vsYA6yXRLh2RMx+hMWVymQKL5SukPQw3ztVgagyAwd0dp9BFu0sP8Jzj1K+eHgqWnpQdLTxo2vCc0Fj/2ywGuPjm6UpEiOFsame3/FJ3YM1WPsfdY+mEeWLlS6kzb1pxwRU1KvmBJpSOl2eXjtwlXZy6sdPxIaaHGZ6wONfXs06/uw0zf4GjXpFkHsXL59Gjzjo2pWBzsmx9G0r5NIDXtlONhmixHbNyGCPto6CveNDqfsxYR2qxjTAlDDvs6hXDyDQVG/zs3WWK0xGitUw+U+SMMw+XLrQC19RqjJZYOV8+pbSN5X0f7IoW0f4TA2oVKxw/XJKOvq0ENw8fCasuT0n8l/EWz0MlBU2r+FB3StgnrW9M/uTElfYfRQNHB8W4J/XXqHaNPUm8SvlO0aL6O85VnYTtfa3drdmbNfuCCscYsDH8UFVMBaqMPfDTQzppqRgxPnC93GSJ52bBF79/hCmkyk0YlL4IzEpcW99JdMLRVadAg2ayREN5qKAS7GVXmE3dDA7OFPWRGZJn9umTaRXNJONVXY+YRtenN+1sycWkRE5T6JRTWRc460uQ3WoEKE+EYZPgza7oE3mD5aZFFSK3QojDB9vjVKdJopX0nJ/BQTfg+oTNr9hE9Fw0jF8impJfbFICeKh5RWdc99TxWhrKuglPOe8KEZi+vjjFTYlOI5ucJQj7NpHAbpNVUm4f0+fXuaKDoDPtjI30ydrr9ZN2Ywmim0sae0Z9vqhb0Ne4S8lh9Uu96FlrBwiwaJ3MfS0mLal9RWQJ+IcnLz3O2oETHTeIjAtr9tDV1Fh0XGYHlI8mT62MFF19Yb3WA1R/4ireJTnPWZ2BnYzmfjzCcRiNj02x4YWCZEaw+Sm3ZMOy70aU6kJovciHGyCt+L4KwqZqlnOjRtnGasEm4U3nbmpRe7TBvonLPlTDl1WS92sDZ2tHeNgw1b5TPSxnPjbHgQnhf0+U0LZCf02Si9R+O14bGA8bDYiZGP47EVIiFldBcSSs4sT9sG4ymnsWToE41ghXZH4I+GGq1pLyAmmM0dOZAP/IMrRBc3v2krxPO+gkQYoYP6XPo5xU5rSJBgKsIsj0mg1EO5fUnJLPIumOMZly2n04cWVRoBcTevOITsdSvUGMmr77vTSAmQLk8qMmUGtOsSdQL3xN3InMY7bCgGy9rb7vGTLScQCQVhDQI42DtYPON1L1DMUykfR/UIZVGNa20zu2E86S43sKlr2byQTP/TSiy0FfysAErnkO3IaBFtH2I3Zxmq8dWuxVaUujLVaZQSNSmFyuPYnWvyoN4j068yJ2AoSCVw0E/q3CGhMuFlPI0AaoNJO2hcerWaLJ84Nq73v5MxSHp97Sv0bCIkCPSHCG+wBU/UWxxiIyjStwwXk3eo9IahmOd4zshfdRCWEJ/atzJNWlhFu9U38MVAkPm2ReNGbufaW3+7nzO5lZoNU5Y+BZs/z6ifgijBTXqDfPrKIXVunVA+L1RNGD+JZivhvR7zGcl5qPCAQsXHluC0sGEqaQf+OCFebBl9v34OJ83xq8pVndR+pE8YnUrqXdJOmgc5FgZSdn9uGibR/z10Pc1fHnD9msCXLuOSsR42eQ89SjmGy34JGPohLM+wfkM5FxR504PRYZVXpsqeq6eJXRU4ntMw0+TSjuHOUdKH0ovU34JfX5c+4OVJtL+Kfn1pJ1pPEjS8Rmuz6BDOvzNL3ZHKlHGEZ+z6rP/XlNebb1g4fwyYBsiUuo8VQDAaMOEMIweTNhlhagGJ1JpXbXN42LgxuSoMGP2Cf1ux87nbACAdQCNGj78Zpky5StUxuEdIUUDtp+DOJPfQS6Eju09fi0KvxSu/bj8oyAEK78vSJlRHWG3yfESC1uGc35GTDtJ/T9JH7GIL1OdfNhwQ0icSH8cMekVatMZZg5ETYQZzcvhmEHNiTn8iSJ8pTSNSYTCOUXoCUyLVFuL05G+d9CYheu6vWD5tYTO56wfPmdnge0a7yCsABYyAI/5l/FitnjMhs912tx+BpRvQ8wPqh/+bh59oZ9VLHy0fr13GmEjhK+t6fGhCPxlwjPVMOE+Nnlqw5H0Fu0sZiRChQZYmjnCauPkDOeHUQu5AuEsR58KaZTS2/Md8ePsGZcMLwrTDbWlJXL5sNbxn22BZ3LKg9r0TO4Dz2fQXXw+l0A6Odlw3Pk6dfvtaPLV6iOq7ZCXWdRpQ58u7BJm1AHZ/zbyVKUlssEhleaoYCs52JI5uBfzparkMZk50Fm4qaOnjrD6FR0ajefTQ3OMjgikfmGp3yn/rZ6/I23cw+vCesHu8Q3hxkJDzldo/5qLeWhSNWvvIZ2c797S0YTO52wutmmPBlC+S4NSbxpamqA71ZSorVfK36qptpD4RMV8uag0pD5dWJmp9KRloPJJ7dc5x4Om7jjaSXpA8zRxtvZJSjcWhsqPo1Nafi1sPoy5uULHsM+qps1i/aUtJOXn3bFcPjeU/1DE9xYLi/XXWL9qE53PWT+wu/KoYU2nTjn/y638pSuUiCl0pDMPr3A5DUMuaMyvFD2YH1vilvfSxDiBCJBxJdjj7xYLS9FEhC//VgihMRNiD701zyPL4bPV5HlkKjqCsvrtFZugOBNhblNyLJz/N3fFVyXcMJEp55HVOScypLtSV1Ke6Pd9xRibU/1wc81lQ30QjnryhHngxXZp6ISzPqLRbc8SZ0sneGgFOQ1ShbFhwWi2KWNkBVZhem34JETSJpm4P7F4tIcrsR7fFSQ7/1s4cbB9yJ/MkImt5/ymQjfJYRNa7B0WlzKLxZhyik9XP5FKKxcvZx1wfYnqn9qNJHXp4vwIowsAQESTwwnoMfNt7FnktxrQhgl5mDuCTyeXfliWWN8K/w55USyehk9T9BcJZnnKdxvb6cuVs5/ohLMO2RHdnDAXoFHBW8k8uEmF1RgQacm0W3KEGpbhv6KMsmS4isNINTui22DQqcJVTGAJw7lFgXqjyXD4WFvE6tIKEZEdo9QkyS1IuEk3Bk67GFtQxMJScG2V2ud6hL2JvDAS5ivNpw4oYVayAMWeC6K9ubBaGqKCpuB6rtzodmsO0G4PrvO2gX7nT0GyIswdV7QKT4Rk9RnmW4eZSmjnVtSxVbg0f82E1LaQNIgrZw5U35FqTGLQaFhygZsw65RLE0aDOsIZlk4qHan5YmFy8jONRlOqwRtKFM5iNEi0gG3v1hzoDQGvv/66OfLII8348ePNQgstZN785jebb3zjG5WdOPD3UUcdZZZffnkbZrvttjMPPPBAJZ2nn37aTJw40Vbo4osvbj7+8Y+b559/vhLmzjvvNFtvvbVZcMEFzUorrWROOOGEHnouvPBCs9Zaa9kw6623nrnsssvMnIBwJTdHoOXbC3LRoDmN3A/H/SR0cfm5vuH6CaWtSBGcw7Q0GhBteC1NgwwtjWE9hW1JxZGESQHWT6m8uDxicSn45deWL8yTG3PYe66vS8dyrO+HtyRwceqOITaPYdcUnxaszntomjQSL3ZzSSXPYd4maQcqjSb4yhwnnH372982p59+uvnhD39o7rvvPvsMQtMPfvCDMgw8n3LKKeaMM84wN954o1lkkUXMDjvsYF5++eUyDAhm99xzj7nyyivNJZdcYq699lqz//77VyTi7bff3owbN87ccsst5sQTTzRf+9rXzJlnnlmGuf76682ee+5pBbvbbrvN7LrrrvZ39913q8s1duzI3z6D8DsExzzqMKLU8BJ6sJ+UDi48xsA1WhvJQKPoxuJqaaBoCukLT5oP44TPdftGbFLi6swX2Lj4GJPG4nF0s21XUwjvNwPODWzMhn+nQrpYoJ79NCT0UH1QUi6Kh2lBpR1DKt+IhWlaaODyrsv3uLwGcUE0VGMXdRYUA4yddtqp+NjHPlZ5t9tuuxUTJ060f8+aNatYbrnlihNPPLH8Pn369GLMmDHFueeea5/vvfde6MrFzTffXIa5/PLLi6GhoeLRRx+1z6eddlqxxBJLFDNnzizDHHbYYcWaa65ZPu++++6WHh+bb7558clPflJcnhkzZlhajJlRvpPrP2b/wjg+wnfatKn86qSF0Yf1Ok2ZpbRy+WrTp+hkyzfJ2J94lAXhpTRiNMQgDReLK+0nrmw95fLKnESTly5Fm7ZOUvq4ZszUyStlHEjGSE7E+mXKGI6lRYWJ9YEm65/LJzWMJF443jR5SOmTxuHGKFt3k0wPb9DQKgUXP6TNzd/wfxsYaM3Z2972NnPVVVeZv/3tb/b5jjvuMH/+85/Ne97zHvs8bdo08/jjj1tTpgPYhDfffHNzww032Gf4H0yZm266aRkGws8zzzxW0+bCbLPNNmaBBRYow4D2berUqeaZZ54pw/j5uDAun36hlOprmvBcF8TS979jYbB0uLD+e8mqBNNkUbRK0sK0NmH6HA3ifIfPdRJDGx4BRn+TK0BJn7A0UPdywrlXgqMlSLqDs5R8ekLatNrcVEi0IxQkdVkHGs11D4i7ZSXg2iVGb3g+mCQtavr30+0Z94IrmLS0S7TgVD5celG+H54xhqTP1Zufh58v9j2qsRwe42FYri6HHF8Q7MSntKRNa4rn6t2aX/7yl63JEfy85p13XuuD9s1vftOaKQEgmAGWXXbZSjx4dt/g/2WWWabyfb755jNLLrlkJQz4tYVpuG9LLLGE/Z/LB8PMmTPtzwHK4hAyBgzazlWeBh+ky04GyKnyuTuxlolL4/nMlJvgsXqQ1E0IiRkGY0CxuFg8nxlK6MIEshwI6cDowhi3hA4uTSo+N9lJJ8JBNKFkhzUj9x5fIF0IYTtge+6yDOMgbe/37bqTHRef65eSdCytk/gxWYc2Kr1U4Q3j+1w7YGlLxjZGb535CsvTrxuM1oLg39I20vQNigZ457sjmbldOLvgggvMpEmTzOTJk80666xjbr/9dnPQQQeZFVZYwey9995m0HHccceZr3/960lxuYGCDo5gq29swhRd1JtwfU6YdzStyMSqFlA15+8g4cOVuf+eSgsrQ06hj6JVUz9heVzckNk2oVmT0JKSjg+K7lzlidV1nbaRTn5+GCpviWabeq8VRupqJzhaK9oZxSHLqXRUhFLu6q2Qf4aHzwZ8IRQ6NItCShipplX0XPIuETw0Qiz3XSrkpGAoQYAK+bdkcTeoi7WBFs4OOeQQqz378Ic/bJ9hh+TDDz9shR4QzpZbbjn7/oknnrC7NR3gecMNN7R/Q5gnn3yyku5rr71md3C6+PA/xPHhnmNh3HcMhx9+uDn44IMrmjPYCeqjLtMZGWxVJhGNJzgQEVtRzf67yiylKzP3jlsdxWioADn0NTYYU+u7rnZLOvmF5Q3zkAo2nMaI0nDEaOLyo6DVmqTS2DSanIS49LhJlG0Xxhwk0pBgmmjhie1NtZOq/ClQ3gAS08pqNEyhgCGJg4WJLYYwDRWXV6ihivEfdgETWHYobVmO8TSUuOAdJAy0z9mLL75ofcN8gHlz1qxZ9m8wRYJwBH5pvgAEvmRbbLGFfYb/p0+fbndhOlx99dU2DfBNc2FgB+err75ahoGdnWuuuaY1abowfj4ujMsHw5gxY+zxHf4PMGMGrp2RQrpi5YQibjUW0kZpkig66pSNQrY0BT4zlffEsRMcjTGmnQK/vn2mVj5TuxaluxmZcCXt3ne0/rh7AxF/pRTNi0SrmYq6/asJoYSrp7qaqzANybiX0orR5j/noF0KSmAJyxfSF46JXq2Vgo/UoJ1qE19TFMbR0KHhW7E2zMGnsTKHkM5TEkjiwXeYt1tFMcDYe++9ixVXXLG45JJLimnTphW/+tWviqWXXro49NBDyzDHH398sfjiixe/+c1vijvvvLPYZZddivHjxxcvvfRSGWbHHXcsNtpoo+LGG28s/vznPxerr756seeee1Z2eC677LLFRz/60eLuu+8uzjvvvGLhhRcufvSjH5Vh/vKXvxTzzTdf8Z3vfKe47777iqOPPrqYf/75i7vuuktcHn+3h+sSIardjv/mh6HSC+NiYaW0SPKX0hzLT/JeA2rHYMquJxUtxI6jWF1wNKF1jux6pOiP0UmWldkVye26pOpeWo+xMLH+Fat7rD4l6UnDU7TGvknzocJLEIvPpZlCF9UmqdC2gbYs1LdYelw8SZ1K30nLo00vVidUOiSo3doN7xyWQjbO2t2tOdDC2bPPPlsceOCBxcorr1wsuOCCxaqrrlp89atfrRx5AcdpHHnkkVa4giM0tt1222Lq1KmVdJ566ikrjC266KLFYostVuy7777Fc889Vwlzxx13FFtttZVNAwRCEPpCXHDBBcUaa6xRLLDAAsU666xTXHrpparycMKZljlImJGWUUugGbySMLnKIWaazLENWgZfG4zgJGljSV1qkFqunG1MlSuVBik9mjQ04zHWf6h0/XJr84vlK/2Opqk4FgEtF3M0gkVkAVV5jyxGNGXEEGtnjE4KknbmxgFWXsnxGNK2jdVLrN+ngkq3LRhBWbH3bQtn3fVNLcK//mHsWNn1D9AlNPZzrf8Dhl4fs5H42DeKDipunbJgaXF09qQFprfA3y7mgxMrc4xWkp7J9e6EzOnrJU2nTptiiPUrKf2SfsnRQLVris+idFxo6dGG5fgB9p2jDeuzsfL0jC2kv4djxHe05/wP7ftJI2PZTx/LI7WO/DBYWaRHPWDpUMD4Rlh/2raN8a1YXcfojIXlEKNjSMBzqbjY+5Qywfu2r2/qhLMBFc6iQkZD4JwzSwYhdJytM8FwgxOjiwsjHfwShpdDOOPSwtLkBC3NRJ/Sf2L9QdLG2noIaZb0jRShjKLBPcfGYC4hUBpOIyBzbS1ZcJE0TKohnAX5U+9F/VSxsJHUe6yPqukz6YIPVyexRYx0ocnlIxVmBl04G6qxCMLqc1TcrXn22WebSy+9tHw+9NBD7UGvcGgs7KbsIAc0ehtClwTYwO2hTbGjiSpb7J20PvzrgKj8cznm9uRLMAdusEsmqMr3uk7+BBydHL0u/7B+K7QKaIi1Zaxtcrddv8apNq7LLyZk+ZOHeNwIw2LhJIcGx9Kgyqaq4+FDVileUretMBpT0yX5oHfnZAwp7RyjiXsOv6H5CvkQVoeaPlAgcTD+FX4b7fNzknD2rW99y14yDoAT8k899VR7x+XSSy9tvvCFL+SmcY4EJ7hgUntMGAg7JNVBw4mZm6RD5p+aBldmCfPjBjMVFoPVhiACHSXExejNhdhq12c61Lee33A5nQaImxx8OjimVumPw/GoyUUimFO0c/Dbyi9bU0JcTLsZm0ikaYXh6pYn5AsYrwjrEKMB65uxRU/dCY3jL9r2COmkFnQY7wzzouqQixPGw/JztEvzD9vNF0jC+UOaFkVXCOk4DcvVTyGHQji/cmXrxyG0SWbNhRde2Nx///1m5ZVXNocddpj597//bc455xx7ufg73vEO85///KcZaudCnzMA5YchUUWnThA9NAjNOdxEiaURnn2D0RorE/dNQgtJj8KvBMtLW/dcO1JpSugp4wSmILIOFOr+GLC2iwmjIT2x9OsKMilpUOOBG5c5BMhYn8pZFirdWD/l2jU2TiX0c3Gx91LEykLRiD3H6OPeUbRJxwOWXuq4lULKZ5vAEMEjc5V1JB244WfAzZqLLrqoeeqpp+zfv//978273/1u+/eCCy5oXnrppbwUzuXgOo4v5YcSv1QL5a8iUwaSVOthv3FmuhbA0RnWhQhBeTQaICz/3Ij1Aen7HHnWyUcbNqUN6pRbOka5dzkhTZ+irU4eucqFaTPq9meMP2LpivmZFh6/4PqFlHfHEAvrzx2S8BI03bdTwbWzFG2fc5Z0QwAIY5/4xCfMRhttZC8lf+9732vfg+ZslVVWyU3jHImyU/iCCaWhQe7LzEqL4MqSSnih6SkaJiKUaSYO6o5QVX0p/OlSkFK3Wdtb6S/Iabg4ujhTGBaOSpeL75uTUidRrSaCio8x/dBc5MJgJiaqbFT+Go0AF9avu7AsmBnMp4XS2Ek0b5Iy5NAyunwxOri+F9M4UXURq4MwfA99gaY+B5+NxQkFNAkw+qk+j8Xxv0u16BxiwqcEnFbY/e9djT24whn4mB1xxBHmkUceMb/85S/NUkstZd/DKfx77rlnbhrnbMBAVGqOpCYELl4Zf5JsoqTCaExypeDk3QMnBWZGkExckjLQtOPXVKUwEo2ZEJswMRq0Zr/UiT4mAFHpxfoLl5e2rmPmvTpCmvR7XUEwB9rKZ7RCKqxKwqvhuaVg6XO82AfNX6vfsXzq8F3ue12eGDPzFkSZY/nWcSvQ8L0m0B2l0SJybcXNKpwVbQpndL6cQBKmxU3eeYUzXnhqSjjj8umHcEbFjSF1YuuncIbFS6kjTdkl4yVMHwuvnYC02k9N3tg40vbXHAj7kqSOU/Kn4mnzr5uf+9aWcFZ3PHDjdCijcCalj6On7aM0xJqzO++8U5zo+uuvn0rPXAXJpIl9S5XmuXjSgaRJP+eqQ8PcU743SbufHjXwpRM7FiemDfD/rmsq0WiJUiaj0JQgXb2mjhNOk6FFDhNNm0hZcFD1g9XjINQDpcml+mZq+/dbYxkbaznaQrqISE1X8r4o6tfLIGi4swpnG264oRkagm3zoJrlS/D666/noK1DgxiUiUQjFMUEk1QtokQ41gzoVGECS0ui7pes2tuAVrMaxknVPDUBR69k9d4GHbEwdZFDu5obTfbfJtLNoZlz/r8pC+SY9YFDTz8vXW36MEEI/LCHErTiLuygzH3ZhLNp06aVf992223mS1/6kjnkkEPMFltsUZ53dtJJJ9nzzjrIIBVE2sagd9q+QXm0xiBA2pZNhaO0g4PSF1OEH8kkmCIwS4TWupoCqVazbrtJ0qkzSWo0zXXMmjFTsoxnxAtYFYhkQgT6XpifFpTAlqLx7wcKrcaN2GA2kMLZuHHjyr8/9KEPmVNOOaXcpelMmSuttJI58sgjza677pqf0jkUEp8rSvrXmm1iDFczmcToC7/F3kmRotGKaTzKuvSEL1QzJ3DY1a72pROBo1HjD4VNSpw5RyOoaOpAMsFR/V8rOGkmCKnGM6Y9w8YiV/5wLGB0cG0Ro4eru5iwJGkbDinmUUwTrEkvFsbXgnJ8yC+/pj1JWrxjM9Aw4WLPacwm6vMu6Z5U3X1PjXupxcKvG8f/JHEorTMHvwwOVHto5w6/7anFlPj0hEHerXnXXXeZ8ePH97yHd/fee28Oujo0DKmAlMsHow3TSJ08fOZDToruPsGAeabm10acOR3aOqlr0pDkJ+373ETblqahaT6ghURg1mjCqDS4PGPvxfAmd1RQ8YSxbP0xUaCQ9IPw2i5NP03RRg55+aVqkts4PWGgdmtuvPHGZt111zU//vGPzQILLGDfvfLKK/bss7vvvtvceuutTdA66oHt9pBozprooHWZslSdzSH3INOs+rUarlxmklxhUxEzq2k1Z5QZTdpXpf29TbOeRlPE5aGlVVNvuYROraay7TGcSziT9DONhjdXuTT8n0s3qlFT1oEmXQ2dWBzq25ByUdM0Bna3po8zzjjDvP/97zdvetObyp2ZsJsTNgpcfPHFuWmcKyAxT9URruqqhXNAaoZzYaVIEbxizDIXNOlpJnVt2m1CojmSmBBT0a/64fKjzKHuG2VSlKKuUNamQNVUXtw3sSlSmLaWNim0cTSL+JQ6aDO8pB1yg9P+5RwjrV3ftNlmm5mHHnrIHHvssVY4g983v/lN+w6+dZCDvTIIuR4oCi9OD0MJr0/irlMK3muuecrJBDQI/VUsmOtSUtLPEaYuMP+Z1toD6S/SCSAHXDv2i2HOKXB1GPMNwup6YNpgmE9hgq3jV+4btmBw76KCcaqZC7muSVRvXpn6tQCzdEIdUmWn5g4J6sRtCo6mAaIrSXMGWGSRRcz++++fl5q5HJTGB538YludvV07sxlVkbQT0ebnGEzsiiSPpp53giuoWKYVpoM471N0i/MQqvU1k1KqRsPGdY69Xlk5LWHMdEHRxPevYfh0TB6a7Z9HtGmd+tFo1FIWCRo6ub6AvRtU7YAW2j5PfouM0TBMhce4/ja52vesF07dCTRhR6PvZE+GocaOJE5GNNaXNLvVFWH7OSaKPikSGhXOAOD8/89//tP6m/nYeeed69I1V4G827Kmw6j6Iu9MwLQ6OVT+knwlaUsFGImGKlZOrd9EjMFLJ86Qbq48qOAzCQtTVPpUXbW/xq9Fa2IKwZm6Y2lzZkcuvDT/GA2cUJjqChDSlepfh9GEoS6dLD2hQDf8N7vAKjVrvXy3h9Y+7NoD+jAH/EoY/3MTuwwF6cT4o0bDXwdDETeVfgtarQlnYL78wAc+YHdtuoNpAe5w2u4Q2kRoBljkknSMiffuRvRWtMxhf+VEHYTpGXjM4Ym1V2JhmJwMM/X8shoM0dVddNKaPMKkiwkCOnyNQI1z2ezOVES4DyeMFFAC7GhkoG2A09yF4QaxDlGeQI0d6u8YhnmP5Libcjxl2nmN0ZIKtwjq97mL3IINoxETaFG3GgzwHivDZNpakgV+emGaA3CmZZJwduCBB9pjM6666ir7/0033WSeeuop88UvftF85zvfyU/lnAypqjwDxEdBhEIYMVGjZglOI9Rwh+/Jm8gnh68WFycmcIkEWI8hSUwqZX5YOw0zv7INCFMRKnhNYATDxFPEJZo7LFzsPadVasJkzcWVaOq4zTqxPiKtQwkaE+h87ZWv3UpMC/07QNiHe8oWmDQxV41BEXBZkz/mdoAhp4CjbE91PWoWu5Or5acUCINwmGyrGwLgNoBjjjnGLL300maeeeaxv6222socd9xx5vOf/3x+Kjv0IDRF+A6kbgUdThbu2f0t9ZFJMY+KTCXYiqUOCIdOiVNwTsTqV9IWMdoq3zPVIbRzSQ+mNRPWF2cCxH7UdzX9RJ8PTXfhO65vYN8ooS6WHvZ3mBeXR+hbiIXHaIi1BwVpO1B9vWcip9IMHOBj7cHR6bc5Of6gnyt5GtV36/RZqm9JebMkvVRg9UilPVtjObtOB0WwFYGafwZAa5asOQOz5Rve8Ab7Nwhojz32mFlzzTXtLQJTp07NTePch1wq1jY6GXLQYsX8MqytC00OvnZAoxmqbVZE6oQ0G2pXcuHqVBBXWgeUyWokfqAdlTglc9oIEc1m4CAVHkczOMFP1EcjGk8q/WTfwgym8GzwtT+Em0AoBPcT0bqv8Bxa8z0SRjFHKOaPku9wtAf80Ql1aFkmVwX60KQ/+45vgeIgcjfnIAuTScIZHEB7xx13WJPm5ptvbu/ThMNozzzzTLPqqqvmp3JugUJACR3Ho2cJ11FvJ5gHUUGCY9KU34EGEjonV9/XYr7YadIUAwycld17VMCp7IbE/fhKh2ZXp6GPR8QnMQU9K2hlWhJG2C+myZkWOc1BqKmjwmFxmipjT1mICSxm8pGWR0qHhT8G3CTt8QWtKTv2LRo+hecCJLRHeO7ACQZI27CbLnp4GGNaDRaCUl41FITrWTggQmFtDMjdyUlmzSOOOMLMmjXL/g3mTbgUfeuttzaXXXaZvXOzQ/OQmCTaBmYuwMwvlQmt7R2lgSobMyNIzANlmBYGcmiyiplIJWa6OuaZmNlFWp9YnlhZKTNdaCrUaM1iPlvatKkwlGuBxgQVmpjCPkuZoKh+oD1XK9XMxqHCEzxzOhVW0xek+VNxNC4gdcyQEsTa032zYQfMrMi5xJR1JvC5LiLuOVJg5m9pePh/7Fgz+JqzHXbYofx7tdVWM/fff795+umnzRJLLFHu2OwghMIEJtmd6Z9rVq7qJuI7NctvdQZ0zTOHKitPajdiDDXvk+M0ff5hlpRZMdzFJBY4E7Vbfp7YtxygyhuL4wPTTGo1YxKhqG2EglsT6feacWqkl3GHLSfUoqZ56nJvYV5JC9C6PFV4HAdGC6uVy73LMMWsSJkUQ/SEFfA4ofWjd65K2+3OavRCIP2ydGfBTKsDgFrnnD344IPm73//u9lmm23MkksuGTetdUgTbJAOE6vqHs1F3Uu7MZU3t0NIQHMP88XS5UwDrez6JMyKHu09dduASTHMN3q8RkPCkAYirU3g4C6dBHPQhmn3mtAQ9eySpcoc+IJV+lgG02JPfw3eU/TXEtADP1NOAODSmn1afdV9I7a44hAVZGJlb3ES7xFgnGtGinkUE44pv6yIUI8KNzkgqNuiHDPyZOv0Efj72Wfb1Z4lCWdwbMbuu+9urrnmGqspe+CBB6yv2cc//nGrPTvppJPyUzonI5fmhzvlH/k7CygneCI/6aq4LiRCSTj5caYLzPTWj7WIo5OatGNms1i9pJSJmiQxU6WUjjbA9T+qf4bvY+ZR947aDNP0BgvJGOPajApXeZeoPac0wH79UJNwRfPT4GKokh/HSwbwyIb4GBcIQYHg5bdHqlDWr8PRJQf9DhKGigR111577WWefPJJ8+Mf/9isvfbadnMACGe/+93vzMEHH2zuueeeZqgd5ch9qz02SdRSw7eAmHCWix5tPWgECwzohILkEcbRQCLYauitC6lwzdEkpbdNxOgN+4x2wSEJ13S9cP5dVP51tU2xcJTbgDTvOtCMrX6jLt+so3FMQWpbDQ3AAq7J+bsRzdnvf/97K4i96U1vqrxfffXVzcMPP5yLtrkPSps5ehq8e1f3GA2MFs7cyMXzwpWrJrvywjRvgjwEqAxo5b2csfSiE6Z256mwnDHNBawC3Qq/ac2k3/+azKvxcrQMzrSPlVUjpHF9VCrcxJ41yLGI6JAJTR6rxOzybM38OzlT+fpFfy7h7IUXXjALL7xwz3vYFDBmzJgcdHVIVA9LbfGDshppws8nmp/AfBQzh5LvhZetV8ykk/SrxejJ5sjl5O69H4+cPD2TEaZNgbSdWQB18B2Oq52QKQE09ySOakmD+xZRmoJFUUwIStUWY+bPGKS+Y5QQRwmKmFY+l3An/S7VTnLCIKcxatT1IzPq0lflU/hiOKfWqsKrMlyIPrcgSTiDYzPOOecc841vfMM+g98ZHK0B5529853vzE3j3INg5cFemzQcVnJGUDItUi0a9j42CCVn3XgXv9fxh2r1sFTlbqUs+WgOr03cFTWnQTP5+IKSL5RS4cI8JGlj4Zuq+5R0qThUmduaWJvOT2t+5WiRmhM1Zse26ludj5A/NYEhwYIp1Yd64H3OwKfsXe96l9l4443N1VdfbXbeeWf7DjRnf/nLX8yb3/zmZqgd5chms46YDiVhe3baKAZQZaDmNH8i8XqET8GOTskKH0XTF+0qVvcovUp6KhqhYJctl09sQqK0LVS48IiFHk0bQ08Ov7ZYvFx+YrFwMc3ZIAnCnLlV6jOXU3BIaVc/XioNKT50KT6FXFoS+nLWcUxrmgUC8+FQYj2wwlkNnt62z5n6ENpXX33V3p958cUX2/s0d9llF2vm3G233cxtt93WCWYd0oGZBGve2eb8r0YzfBNodhD3kTr4/msoHUFcqQATHlgcayf3nfS7U4Lyy8tp3gr77SAIX7nKl7s96iCnnxyWdviLhZOkJc1TSl8OuHFpXSJcusP8oZJPhGeQiMXzv08egMEy2sya888/v7nzzjvtkRlf/epXm6FqLkTb5oCRgVYj7qD4pjFHh9TKryFzKKkBZFbQGH1heDSf2X+p2p/0SUnYku4f4lt9H02W1SrUbWPOTBed/MOrsxTlxtLEBMQ62ksOfjip7xZnbg2FvYovJXEETUo7SgQal67EXy/VN01CizSMJtygmj9ra9gYDVahuHO5zqKj7bm3UbPmF77wBev4f/zxxzdD1RwKXy06duxizaqN5yBI6iaX+WKQ6p9jvk2ZM1Li+ZCaJSV5pUzqObVTbqLWmB078+dgmz9jbSkRzrT5aoRqKv+51vw5QL5po+Iojddee8385Cc/MX/4wx/MJptsYhZZZJHK9+9+97u56JtrEO3MTW6FZvIrfdNqTNy1zUMNFXk0MpK2aZXmi32nGHdqHhI6Y9AIWlKaNJqr0Ygch3VmqaMMxxxQE7IvhFfavPEjKIr4O23fRGju2d1N1aXAn3nE3OmlNxy31IgHtxhkPZ6D2VgWu5JqNPH8JOHs7rvvtpsBAH/7298q37q7NWUYmM6hvZaJ+y7Jg3pXkwkOqgAYQ6p5KifqmgF8UxIVXqL5C8OFZjHqHVUe7co4GdYnR5841d4akyuXtjZejyZE4PeDaRaxyZtsC+7Il5oCUY8WqsET4ZPMmMOn7JfXaQ3Xd6optR8uGwMzjyVAu1BrG+oNAQC4ton6we7NnHj00UfNRz7yEbPUUkuZhRZayKy33npmypQp5XdgikcddZRZfvnl7fftttvOXiflA3aRTpw40aoiF198cXvN1PPPP18JA350cETIggsuaFZaaSV7LEiICy+80Ky11lo2DNBx2WWXmSbgO1+32nH8+yqH/w4dtyn4tDZJs7ROJPUXChex9PoJ55BL0dp6XxHUucZ0iaWhEVywNDTCitQsFPMtQ9NGNj801V6un4TvYt99rZFIW8jwhbrlisZn7tV19FN1ENI8iJqU1Porxw0IoNil6wN0qbcKEwrev7PmBgr/3SDw0RLFAOPpp58uxo0bV+yzzz7FjTfeWDz00EPF7373u+LBBx8swxx//PHF2LFji1//+tfFHXfcUey8887F+PHji5deeqkMs+OOOxYbbLBB8de//rW47rrritVWW63Yc889y+8zZswoll122WLixInF3XffXZx77rnFQgstVPzoRz8qw/zlL38p5p133uKEE04o7r333uKII44o5p9//uKuu+4SlwfygSqH/zlUu1v1XQzScLmB0RqWIXc+knBh2PAdRqu07rk4qWWS0pIr77r0UGG4b/36xeitU+9NhMtRVqxNw/xjYaX9INYXYnn433JB2r6Dgjq0tV2mOnkNYt1z40Qzf+fCAFbPCA477LBiq622Ir/PmjWrWG655YoTTzyxfDd9+vRizJgxVsACgCAFFXrzzTeXYS6//PJiaGioePTRR+3zaaedViyxxBLFzJkzK3mvueaa5fPuu+9e7LTTTpX8N9988+KTn/ykuDxzsnBGYpKZ/csdP3zvnt278JmqHy9cbCIN8yeZPUWboJzchBc+NzXR+OVIFTRitMbK0aTAoqVHQivWVlx8SVtK4kjrP9rWzLsoXUjfjvXJ2DcVmPElbV91XlK+RLwn82b4AIVoWSiaOb4k4FlJ9YfEpf6OgmuHTPT2UzhLMmu2hd/+9rdm0003NR/60IfMMsssYzbaaCNz1llnld+nTZtmHn/8cWvKdIDdFJtvvrm54YYb7DP8D6ZMSMcBws8zzzzmxhtvLMNss802ZoEFFijD7LDDDmbq1KnmmWeeKcP4+bgwLh8MM2fOtDs8/J8E/nDD/DpipjoXNgRlLoqZAENTk8QEGIbD0vBNQW2pkrn6ob5RdS8x9/qQ7vYLaXDvfN8u6hfmh7WByAw4XDZJPuG78G8qPtUOKeDaLmw/rByYv5v/LSxLmD5W1xxS+jw1dkP45Q3jUu4H3JjlQB6VQvSV8Dv1LQWcORsbN2G8kB+1xZO48dcX95aANgpcG/rxsT7lzOJNjJOc8Mf32LFm8DcEtIWHHnrInH766ebggw82X/nKV8zNN99sD8AFIWrvvfe2ghlg2WWXrcSDZ/cN/gfBzsd8881nllxyyUqY8ePH96ThvsGZbvA/lw+G4447znz96183fYHvzFvH10CxewhD1AGXS5/aNMBcETJy3ZPwUnN/IwTihIwyhuFwJNNANjmI/GhyINPusnKX7gT8OyfESsudUzgDSJm4xM8o1d+tDl1tIhdN/vjG6jVa1zn6q4s7fM1bLUT4XeVmFWwzE3UTSu6zGD1eWG5GcZswNDe0SK/X81BZoKYK0m4TxER6URRD5fYYgk/FFi3++0HDQGvO4L5O2BX6rW99y2rN9t9/f7PffvuZM844w4wGHH744fZMFPd75JFH1GlQmooU+KtGznG7x7EbOcldsqKK/crwNW4A0EKjBUQ1QEhduPcp5eA0jBg9mJYGS8cPTz3HwjXdJrkEhJiQJZlktPSEjF6iYYyllYMH5GgzbrKUam21iGkdJX1e2r/D9z0a3eFxTNYxsxGC4y2UdpKCT0ebAoSvYfafQ62X/40Cx7Pc9zBfrE2HmG+SuqnQnyAMQnlnnNWu6mygNWewA/Mtb3lL5d3aa69tfvnLX9q/l1tuOfv/E088YcM6wPOGG25YhnnyySd7zmmDHZwuPvwPcXy451gY9x0DHNQLPw7cKoTs9IIzyHpWFYkrVE7zhQlvlOapQqN3+ny5gsKQcMxGeFeoREvSq3Xz0iuUF75LwmKrdORE/grtyF2jIaPB8mxilci1++xvGTUZDR+BkApugmW1iuGYt9fl2L/KcOH3oaGir9q6OkJmz7vwHlyqXSePtHlME+cEBj9dLKyGF1A0oTyL0dzZsMNXIkUtEL7mnjrGRKsJ0/ArIdRjMcX6MjmPBaAWQo0ouCXt156ANtCasy233NL6ffmAc9XGjRtn/wZTJAhHV111Vfkd/LrAl2yLLbawz/D/9OnTzS233FKGgeM+QCsHvmkuzLXXXmvvDXW48sorzZprrmlNmi6Mn48L4/LRAGzX1MoK+9tBeqxFCiorxxqrNU5LEVs5hWE1q8zwe0z7FJZRulqn6IxBW5/UZB4LH6OpSR8Of1WN9VWN9keqGYpqnWrezZoCqu/6K/eYVjPU0mJ5YPWkbVuttskvS1guyY/Lx9fMSOiRtqlkPHDjXzvGKf6JlbV8z1z3paGhjbmA67dUm8d4QZlWwDeGmDGTUia/XC79gUUxwLjpppuK+eabr/jmN79ZPPDAA8WkSZOKhRdeuPjFL35ROUpj8cUXL37zm98Ud955Z7HLLrugR2lstNFG9jiOP//5z8Xqq69eOUoDdnjCURof/ehH7VEa5513ns0nPEoDaPnOd75T3HfffcXRRx+dfJSGMfD/SHfxEQ5v/1343T1LwKWREpeixU+TCsv9JHWgpZMKh9FK0SRJJ9am2jRy/yhapOXl6k9Cu7R8kny5OG3VYZ00YnVZpyza+kqlo25dUGmH7zE6JHTXrSNpH5DWVUo9cvUTy5f6Hosr+a4teyptJlLmOpD0Lx/dURoBLr744mLddde1x2OstdZaxZlnntlznMaRRx5phSsIs+222xZTp06thHnqqaesMLbooosWiy22WLHvvvsWzz33XCUMnJEGx3ZAGiuuuKIV+kJccMEFxRprrFEssMACxTrrrFNceumlmr7Q07hlR/C2A3MdO/zutlxLIBlY2rgY/bF4UobdJLRMWrs9nh3wkS31MTo0jJ2rW0keFI2Vd8wxJFgdSmmVMv5Y2STxNDRJ05CWles3dWiLtbH2iBs0fl3hDOkTFtT7ROGMqsvUeqZoc7T3lJGqx0g9U2FicaR9iaQ5koeq7xB9hUpf0vZGWT8YLRS4sTLjLNPqURoD7XMGeN/73md/FOC6qGOOOcb+KMDOzMmT3WVfONZff31z3XXXsWHgSA/45QKlvufelX97V31Qfhj+OzQNKZ1BXMr8QDnn9vjkOBW+51NCqfM5WjSomBA4/x/UnwMJi9W1Vy6pCTYsD1k+5iodqjxYemydCq7rkQAtAz/81O1GhSPzJ/qZM5lQ7UG1Y9hXyP6A+EBx6ZP5Ka/2kobl/LDIvuK1JTXGMUj5gf++5x0xXjCzHzcuqPdcPXP8eqTNvXZHxhPVByX5c3RTdHG0hjRz/r8SutH3imuicrvsDAl4Qg8NA2TuHJotLXZoA7VvtSecJEWOrhkhmchiAgPFkGYzf5xZY2nH8tbQTMWVlEECahKK0ZWSlzRu6NSP1aNE+KfqsQ6To2jXtr9kIkuh0++r4QYUbnNKCur0AWn6DqL+IjlyhsiDTZ+a5CO8LdZPfIE5dXMJ1gai8RXh12GfqWzmEvKjGK0xnsjOIcgGtDr80C83xmPYucHI57tYOiS8zSg+ZsyoOX8rMfCaszkSF4w1ZmET3XEZg+8oyYUJgQ4uSmuEpDMyKdGr2phGilsB172UVypwaYCuRP1yRQRnKTQaxBTNIjdB9jjvlhoSvkx1hQZOc8oJtBQoRp8rvAsb/Y5oXLFwKRofLn7sfZttmCOOZPxK+32o9culqQz5gWxB1KsprNDaMLTWlFh4ycJamvaQQICPCZ+VxZP03MsBwkDv1uxAo6lVtGYyc6aE8MfFE6WPXdw7PNhSB5gkrmMKIZ0k3d6hk9aUOWzORE0sEZW9tG5CejEtETbZk+Wve1htREC0+TI7JsMVLUVnuIPL/c/VWw7BGEOFvuFLmcMyuG+i41+CcodmJ4w2PzxZZ4iXDlsWAVw/jyHMj8pHmj/VzhzvoXiT3xexOvK/xegVLXIifTWsq1hZObqxfuH3qxi/9t9RfDBGmyt7uPNS2ifCsIWC76fwUTR/f9d5jXmnDjqzZh/MmsbMMMYsplO1atTQgngcMJ8wP51o/IgqXtXRBRopSbl68iRuUMBWYz10e+cRUSp3jK4ULRBbBoTmWNgwjmSyCcNJwsTy9eNgtMTaN0WzkSOui6/p1yl5SbUHVD6a75zmLUWLgb3H8otpQDi+peVJGN3Y2KRM+z7Q+ho2X1LfMH86lx+VNjc2Y+NWSre0zrFnCW2xusyNoZQ5pi23JCU6zdkoQupqQqo1ioVjV+fE2VZaOvoNrowVEM7zsdUrG0eyQcRe0TIk15Ag4W0coq0kq9uYNoYDt8KnwknDcOUIy8NpHLTlTO3XXJ4+rVJapG2C5ZkLWP/hyug/p9Rxnb5YF5x2qKf/BpoYNt0WysL2+eFDcythJvNaJIr3tK15KkbBHCNF53PWB8yYYYwTvPvBUHpAmF7QQRjxTWsSqOnI0UWRE5y8P2Jy4PMI88sJdhLyTSGBuYyi00+XW8H632N+fZSAhtFDfY9p9GKrfU4rEtLBCSx+HE5rQ+UheU/VPZUfVn8aEy1Vj1i5YnVEfcPipYwJjVZNmoZEUyQRgsp0GH9YDcRlclq2ifG6DmmW9vNYH6+jcdfGifEmLM0hRXgqDFUHXPpY/H6gM2u2CEotWpfhxRg19s19lzL9HMJZzKQlnTg1zF0zGUsEilj6dSEyOysdqVPN4RxdVPy2hLMYHRxtfrw65s2QDo35TzLZpNIRpqkRfrCwsclTOtFhcTkaY32pqXLHzKkanintZ5p6j0HC86S8Tss/sbix8Ll4XlHD/C0Rzto2a3aaszkcWqYbRQaNGaV1kSK2isbSlpQ1tsLUrM5jQhDFRKQMjmNWYq1iIur0JU2fkwqhdftfE3lgeTWZD5avRGOS0je0cVLrOKadjYXzIRWK22yjMF+pVgz97vnmYuNfwjNTNJqxNHPFGYrxusn4HbTSeg3zcHXGxW8anXA2AMjJIDWmi9ggzNYpywNz+QQrn72jOnJrORqBv3EBu9BcdAk6b2KulD84yqRpBtIvBpWz7TVlaFpoGzRo+Ab3XlrHdbS4ZF7speC6TKjFUiytSrkm9fIwH2j/yn3hd+DWkdTG1m91RPDTaH9Zi8hwXao0aJPi9VPnLLtBQrchYJTASfGaCQMbFJRpJ3XVQ60+ten55fOZW7gq9h1MY5MDpSHw43M/jEYpOMdfv12wi37D8vgTRaUcCc622vASVMoz/Avrnqvf8BnrP9I2oujD0qz0NUW6FO0Uff4KnBtzdTWeWHxqjGDfwjGI/ajwITBew9WHtpxcPIqXhHRhfc6NSa6cMed+LI2UcnD9JdaGXHqxcaShK5Y2Ft6vH5QvB0dYFNJx6R+REvBGSVoxuttGpzkb5aijSsYGtg/pioZS/Y7EG149TuDpqbzzrhKp0Bu5DqcfmE3HMF0T6fJy9PorPU6VPlIXvfUgYSTkKpaAL2jF0uf6AdfXUjQodbUuVHqp8cKJPnwnyUNiepLS49DPySW1rbK3reMlE3vzQCHQWnFXHUnTyIERgZGmQ9rvYn04zudH4uRuw+ixR5M8Gv2/FTxxkMYMoNsQ0CLqOBRGbe4KXxIqXF1hJ9SY1AUqnHnA8kplDH6cnBOuHydV+MXCSmjLJZxJ0/TjxBge1XZUelSekv6fu7/Hyoflx43fHGNGU3cUYv0zpe+H6WnalgvDITYetLxUQoeE9+YQWLjxm5quhidgfaIJ4WwoYb6TtJlkbFI0dxsCOtTy6XIdLTbAKt+FfglNgpukUEHE8+doQiOTGhYtR8b6delT2ij/Lj+s/Jg5wg9LhatLc53vdePkXjTUQdO05Gy3ftWZZtHCgvDfYttAOla9swOb9G+i6EStDbGFFuOL5eok11hsQ/tUCBeosXlgUDRlITqfs1EG1g5OHIwqTSdmk6fSwOz0YRqV94hPQd38OThhxv9pweXD+jf4B1RSPirENSFh+XKYvShwAhwFX0jUtJtEW6dJD4sXo7lO3fnMPjaOqLhU+Fia1HMdhPURyztGN1ceTdumllGTdoyWlH44yOgpd3CVFRrGr4PhQ62brpNCMCb8fitpwzDdQUfnczZAiDFI7rmJQ2LLwcikF1NpYwPK94/Qardc+tbnYwKmTTM9V0+JzIbCS4tDWob/ogMNp+c7JGNhsG9aU1johKwRsrjwnAmDCkvRIFnxaxinxoSoBVZe7F3MxMqhjlk8zLMu/HxibS0x0dftT5o08fQLfR+f1Hs5ORsXdjBOoAWGsDzYwoArU1gHsb7A9xEZD4/RJImj6ddc+CLRRSKWx2gQzjqfsxYRs1lrfWbCb1p/GCpNDWLCmdSfAaNRwty5NCX0tAHpRKZlaGH62jJJJ4nYZMr1Lw0jjdHB0daWcBZ+ryucSekI0+TqlaOLihPGC8tel+/0Rzij30m0t2Fcjq5YGhgdmnGbRziTpxVLM1f4FBQJPCWWhgTd3ZpzMTSaDqpDNj0wQmBq5xS1MWZu8t9hZZaYp8L0NHEpGiVlCCcU/0elI1LNS03XxJ2a1DfpBE6FEdXn8F17TcCnv2nB2zcFtTne2lpQSPKJhYlpg2K8ImxPSgsv0Tb3Y0FG0eIj5AeVcRSM0bD8nOBXySM8QkTh+iIpA0VLHWDtXSDCMqWFpPrLaEPnczZgwDoV19liEzoAExTagoT5jkZwQiMWLnWC07YXJ8RyQmGMBu57SjwOPvONgZq0Mfpy9rlYPeeEZOFC0RZOanVojMVNqV9qIYN9k6YhQTiJR8eAd7aZy69HgGxo4eFD2n7h+YnSxUWsPiihqe5cQ/VTB4kQLlkgc2hi7NZBZ9ZsEZxalFvdYZNNyBwkau6YSjwGSh0uySdV3Y3lFaNLAo1qn6Il/MaVV8IYqPzC71ydcO8o1Kk3bTwp/PpLzUvSd6g44XsNvYMGaR/XlJ1qn1g9SgVpLg5Fn6a9KWjGT50+mopYm5QY1pC589hKOicR7xmTqLSMWHvE0sfCNoFCMb9R4bujNOZSaAe3pDNLVxv+N80g8VXyfZmcmG3vWHnQOs5wzIVNN7jWBav7nJs1wrQdHZKJkqIRey/tl5qJOoawL0kmcI4mKh0sbp0+rBGIcwHr35rxi2rbPGf4njjeUS05NOIivhFsSqqU1xNCHB9ix3lk7KXQrxEccyHW18IjM0perTz2Q9OPJZYA6fch4ZjnBEDtnDRoC6xut+aAgOuMMW3aoAIrh1SrEU7OI74T+MRADey4CYa/vYCPi09cscmSE1o4cwL1DitvEyv5ptJO1VbVGQO5x09MoPU1FpX3Sm2RJIz0vaY965js6mhuuavNJHlKyhzTWlNpxCwHMdpSNO9SnqEVlCR1GxM4OaHJ/66tnyEmnnQRJwkzaHNqZ9YcMLOmg7QDc4MaGxQ5VP4aOjm6uTQ16vaQjlSm2Qgmxw9+tH8zWjWN1k3TvqIJzNNMUIKGpl4leUomKT8O9g37PpoQ04LFJiotX+DyotIM6ZAstGK0SxaimjxjB69S41M7frA+StGdJJx5GksNXdj7GC1apKYVE6CKSD/lNF3afhR+x/nMs8aYtBt+UtBtCOgTnBnBNyeE36mwYWd1qvzw2YX1n7E0KdqoZ64c/qoSixeaHXzasTL45fTjYKsrjG5skHHlkXzXAr3AXSB8Y3RIJlCpsKQJyyHW5nXo8+Ng/QD7lrv9BhG5JlWMT1D1XTcfH5o2aoKmSvrIJdsauso0IuM85N09PM9Lo0cwQ9LwkcIrYmWivkvylgCbOzDBsiDmDGpuibWfL+SFAllTfSwFneasT5qzsWNxyZtb4WJhOWjTyTWhxTRWKdo7blWpoUUTjqMPXf0SB9lKVvqS9Ln8RPQlarhS6q9pBqfR0uQSZHILfPjqvPqNKw+nTdG0RVT7JNRWkhoOwgldQlsqSF4X0JLqmyYOJ+TfEv4Wzg3cGNfwGYr3xfpkE2MizItDnX4U085h6DYEzAUYO5bvGBhjxoQ2DprJOfcAk67gNMwf05pgaUjqiPL/wdL36WqSGUkEvdxCdJ22oyYKTliSMlCuX+Rul5hwF3tfBzHtLfUe88PKJeSEmp0QVF2HGuto+symg7YQW0DmFhyp8Rvj1Zq+R6VNCcWxOQdDqMXS0imdy4YY2uvMhdpFtzSf3Og0Zy2iR/JWXI1Up0OS4RF/Ig4pwkFdLVdd7WDocyJZEYb5+hMK5nvFrp79NsYOgFSsvLm6ZOvJz9flRxxGWfqRIZsbKoJBQHeKcJaisZH0QanAJU1vNCFFSy0RsmNIqb/U/Opq3ilaUvtfTEDRasklGrLYt1jYHPUt0falIKahKzJswJDkE4Z99sdDZux+pvM5m+uBnKZOrWZ7EJwsneJzEeaFaa64eH589Bvio4GFjdIuODk7Fl8VvoWDJnvy1PpB+KeLK08EDw+vDNuxX+UV9cfIQc2aetSOBQ248Fy+WLgcwMZqaho56coJCZ8Kw7ZJW53vYVgJHx4NKBytw3Ohz5vq1ElKvH6gO0pjwJGq/s9lNqAmuxIw+dc8tyt35y/TGxZM3AAf/spOeHx6/RPQSlqwvDOfm5YCbZ3GvtXJMyWedCFAhW9yUVCnDvs1sWiE4KbSzglpe+fqk03np4E0b5KWcIEY8iuF/17TdT1IgmsnnM2JoExoDSK370ud9EfMkPnTxuq46bL3C5zfzaCVmaOnrjnHjydNS2IKiqGubw6XLpUGFk5jvoqVN0wzV3q5fYgk5nhJOnX6mLg9kaNtks2ugatLTx9EvmPlqcQL+XC4oA9dLUIhbcKAMJmW0QlnA45wV5F4UhSdh1WQhzxqmCLmDKxlWlL/Oi3jGqgB7tNQV3iWCuCxcDlpyjAZhWFS3sf6IJVfSp+NCTq5Hctz+vnE4mK0t+2bp6m/pAVcjRsWUmmQLiRy1bW0Xmb7lPL0cN9Fc1jixetFg+xbnMfuM4zZb3g3XwvoNgS0iBxbcWt1Vm9ghE7yftqpwpl0pd+0cNb0QB4UbVG/UKcP5hTOYqgrnOXSQsU0F1zaMUf0pjZKYHlIaebySGnL8sgQ5MBYVpvDHADtx+f6w4j2Z0SrIxGQfbrCBRKn4UoRyKTpsLTWWfgK6ItBygOy8SKvbcg0Ak1e20dpdIfQjjJAB8ohHPjO/GHalhEFKxypA20qfWHaVDpYGI623JjbBTNAnXrG2in2jKURe47Fl+SXo4yacmD0kGM0Bw8YRc7hEtTlPep4hO9pLC2Kh0njc2lK85aMQywulw46N9T0zy2a7qNus8EAjoPOrDk3ItXEF3Ps7NAhIzghLCagNUVD7vTqpp8jPcmEnoqKBmn2m940FaauymQv4D89woEkTsELF2GZcvYRX2hDgWrjegNn6VfIETySdMswmnYlhbqCjzcA5+U1hU44G0A0Zmevc+o1MtCciU9k8kQOfvXjhudncSbLmMpdcsgsSoPAvKtFqqmYChMLH4uLtU3OupGaQ2J0pKaN0Ywh1YRDtaGU3rp9TOtPlyPNOqj4KZH3xpo5CqQjvCKupj2a8stLQRs+YnMLOuFsDoWUiWNh2MEeCE/YBKRxQMXetTmwRQ6tisk+Fk6Sb12/vdHEGKl6yCEgS4W+VKT65Wgc8VPHsUSoj9W9lIbsiC0ipbv5cm/AkeTpgbwiKicdgsUGtwCh4lXoTriianYfphfa3ELVfpsw7As2EQ+voc1Pv0xnOP1+HosUQ7choEVUHAovCXZ9xE6Qx055Z1CXqffEQ9TpGmfbWLgw71qas5rX+Ug3J/iQOOBS9SxxSKZobVJzhsXLrTnTOt1L2p4Lp61jKS25tIipwpmmHFQdUXnWFc5qC3exc7BSdy1zRzhQaWpdOZjNCtH0FDRIhbOKhcLbMMEKZwJwmyiweSIqnJmaC7SgfnMsMLoNAR3wTpYZ0EndD3svTaMnbnDyvza9MF7405YnBWFaknSp7yn05CrHaEeOeqD6j7R9m+hzIR2x7xIaYu+5OuDqRkJDDF1/7r15Izc43lm+w/znEF5dl2fF+hnXXyvxJuVz1ifL5d+mMmAYVbs1jz/+eDM0NGQOOuig8t3LL79sDjjgALPUUkuZRRdd1PzP//yPeeKJJyrx/vnPf5qddtrJLLzwwmaZZZYxhxxyiHnttdcqYf74xz+ajTfe2IwZM8asttpq5mc/+1lP/qeeeqpZZZVVzIILLmg233xzc9NNN+UrXOYO0ihDhNWI5yAqEl68gVb5W0qjN4h6Brtgd6n0VwfSyU4rHKTSGouTUi+x/OukJymfNl0NqPRS+wdHYxPjM1c9dOjQof8YNcLZzTffbH70ox+Z9ddfv/L+C1/4grn44ovNhRdeaP70pz+Zxx57zOy2227l99dff90KZq+88oq5/vrrzdlnn20Fr6OOOqoMM23aNBvmne98p7n99tut8PeJT3zC/O53vyvDnH/++ebggw82Rx99tLn11lvNBhtsYHbYYQfz5JNPNltwpRod1Lc5z6ip0BFTwbuTn5V+AI5mygfNfx+G5XwpUn+uLKo4DM11IKkbLj+svlLqWpI/FpbKu267SfNPSVvSdsl9i6nvWB6auFg4rn00ZefyyAlp/cxJqNMO4vgBf5bm1XR996U9J8jnq9ZRjAI899xzxeqrr15ceeWVxdvf/vbiwAMPtO+nT59ezD///MWFF15Yhr3vvvugposbbrjBPl922WXFPPPMUzz++ONlmNNPP71YbLHFipkzZ9rnQw89tFhnnXUqee6xxx7FDjvsUD5vttlmxQEHHFA+v/7668UKK6xQHHfcceJyzJgxw9IG/xeTzOyf9Zqc/avA+64BmlYCYun463SfXmneEv0Klo8krDR9Mi2vLKp4RN1o6jIMF0tf853LB6NTGl5CiyQ9Le112iW5b9RMS1q30jykbRiml1oOLh6WP/VOAnFZHa+M8cxEnpocLyEuVV5pHcb6FBVW097UO03eMVpS+oGE5lTMTsebv1vAqNCcgdkSNFvbbbdd5f0tt9xiXn311cr7tdZay6y88srmhhtusM/w/3rrrWeWXXbZMgxovMC575577inDhGlDGJcGaN0gLz/MPPPMY59dGAwzZ860+fg/wNixAok9UaJ33UgFhd2dXN3A7hfB0RV1QK2qsPKGQzYGPxyUI6UsObVljbU1k0/d9GLpx8Jqw2uRo2xNaomayMNvU814SAGlkaPCxsoYG8Ple8crBTzVjm2ldjVMV9U+Sj6e1EaEy4cPjOaUvJrqOx16MfDC2XnnnWfNiMcdd1zPt8cff9wssMACZvHFF6+8B0EMvrkwvmDmvrtvXBgQpl566SXz3//+15pHsTAuDQxAM+zOdL+VVlqp/OYPfukAiZl1qHCx9FJQEWYEppIU04lW3V5n4qGYV4hY+i4NbFKk8uLS9NOY0xhoG2aMunURaxuuz3GTJBZXI7DEvucY21Q+/RKM5ybzZIgmhWo//bDtMX6GxcGe69CRIqSH33MuRqzebIZpFQMtnD3yyCPmwAMPNJMmTbJO+KMNhx9+uD02w/2gPDHk8DdQx1NoippmEk0DY0KcEMaFi6WhaY9YPlhY6pmLS9GICdfSOqLSldJAQdJOGjrahtSfrE66OcuXcyKTTqgpGtM6ZY6VjxNSuEVgXS0hFl6sTfU0glgavoA1qAur1L43lImO3ML0HC+cgSkRHO5hF+V8881nf+D0f8opp9i/QXMFJsfp06dX4sFuzeWWW87+Df+HuzfdcywMXG660EILmaWXXtrMO++8aBiXBgbY+Qlp+L8cHbIJ4SgmAHDxUlYuEm0RlQ8FTlMXTgacij9kyOHfkhUcB027SxkGpo3TrDKpNOvSpQ3r0xjGx9KQ9q2mGW/Y75uCRtjHwmPjQovRvDhrC6N9EQvABFP33GEuF8623XZbc9ddd9kdlO636aabmokTJ5Z/zz///Oaqq64q40ydOtUenbHFFlvYZ/gf0vB3VV555ZVWUHrLW95ShvHTcGFcGmA63WSTTSphZs2aZZ9dGC3CVSO3UopNLJxgFKMhxCCsHrD8B4EuDoNCX6zPcOZlbMJuS6hJncgk9LXRLpQ2q4m8tRN/TMhuQpDA+BclXGvyrkOrdqGDLXY47S2mTUuBhp/H6lW6EOsnqAU1BWyhLOUDXL/EhNG+8vVilMHfrQn41Kc+Vay88srF1VdfXUyZMqXYYost7M/htddeK9Zdd91i++23L26//fbiiiuuKN74xjcWhx9+eBnmoYceKhZeeOHikEMOsbs9Tz311GLeeee1YR3OO++8YsyYMcXPfvaz4t577y3233//YvHFF6/sAlXt1hTspHIIh1n4vg44GmJ5UnRp8uLKqfmViOza0tArLQ+VZqx+YvE1NHNtJ+1nXLoS2mP5aetDUk8p+Wr7VYz+XHmp+jlSd+GOaW3f0/QVadxYOhw0NGrS0+RbB5q2S80vVzwtDanhY2lJ+rxB3ktoiY3rOC3t7tYc9XdrnnzyyXbnJBw+C7sjYZflaaedVn4Hc+Qll1xiPv3pT1st1yKLLGL23ntvc8wxx5Rhxo8fby699FJ7Ztr3v/9986Y3vcn8+Mc/tmk57LHHHuY///mPPR8NNgFsuOGG5oorrujZJKABNHedcNL4OWjIgVheElqa8J/IgX7TE+YPz1hdtUlnqHkI30nia8YIlbafBmbOlsTTIIzHpV9nVV4nLlcnXFjunUsLq2MOmOaiCaTwW6wPh6DCUGOwTp8P05P2tVh6udNIbXuLyPWABdJPNGOcqjsu7X5oz7q7NVtE7G4uCSOQYlCEmFgnT6GP8z2KlZubCDQMFAsfSyu1feu2ZUr8OnEwaOpbU0+StmibybYhnMXiSgSdWP/lxhmWdur4zjEmmwJHS6x+/DDSfhxLQ8rfBgUp41fah4YU/pdS3syPGzgKi56/c2PUa846dOjQf02YU/yH4eqAm+zrCNW5UafcTWmLNFpHbbqaNtMsligtDjZxSxdfFKThJHXIheG0cNjY4eDXhUYDLKEFSxOLTwkxubTMVD51wfUv7FmjWW4KnXDWJ0icFzWSvx8nHOypq60mzKZNm2JdXVGTU056YiaGWN5+GpL4qQwrpYx1NZqSySLWRjmYIjUOcjLcfpgmNVoDbT5+f9aaodsKmyKcNA2JJi0XYryNqos6ZkxJuNhiKmY21NRXEZnjYnXgh6UWFX44OEPeHiDfEjrhbC5Cm6bOumYxMp67yaCF+9DqrsK1Jp42hJUwP4ouzeJB+r0O/VqhmquzXEIfx/wlbaalo5g0O4LkTMLUSQpLRzKR1q3TVBNVKjSaH4lJTLPw5RZzGr4p5Tux9xh9GmGKWwz3vC9vopHx76FIX6vbH3z6Bw2dcNYnNKH9oMLEJoqc2qNBE+7qpoOBYoapqz+tFiREE2VMgVTD2xSarn8/Tmpcadqx8aoV/GNpcJOxjxQeEk7eqfUdyytnf5PQKOnvTWl/c+dBpafNL2Y6NZPj8dzzUEBHnTkT69+S8dU2D/PRbQgYoA0BUgxCx5GYiuqaxrC0pNqeHMIZtyLVfEvNr8n4OQW6KEOuma+GljYgFaC475L066Yd66PY2NXQLW3DmBZmENEmjZK6HwSzbYi6/CqWzpCyD0rmBkn/pujJNX9L0WnOOgwkUia3mB9Gk+jnJJOSd4pwm0PLJxVqB2kCr7OSzjGpUlquXJCmHfYJjVmNqodQI6JdfA3S4pUzYeZGTGtXx/QnbQ8NsHTaaJ8hwvwaWygMggKkE876AN+pULOajDFDjVpd3ekIX6/cgy1mwggHWZMI67WOJpCLW0fL1yY0DF9Slpwmnya1CnXMKyl0SfOoaybUTtpN1XHMdDYo4yGHZSDHwoYyyWH0YWEpfoP1u5jgTQmJOXhZwaQV0sGZ6EdD3xp11zfNqfBvt8cGD2cPxxCuBCRxXbjYBMuF4ZiEv7oO/8aeqW9YOIy+GB0x+GH9+qTqI5ZujKbU+LlA1TuWf4xhh98whh7TyEgmhZDWcGHg/5qEZuzUyQP7Oxck9Ena2RcAUhaJKYi1b50+kMozsHxjNDQ9xmPANEhaeqTh/by07VME/SwWlsp3tKHTnPUJ2KqAWw2EHbSOKStpNT+xqNXJubJxYXOs7FNXSk1oAn2Ek9mgMhFshe0/Y6AmaKqf91N7yK3IpXGpeJSpJMekHPZrCf+I0ShBE23DaWhc/5Dmm6sPUQsGCZ9pCzHLi0RAlISj0mtzvBZMuSRlrsv72zxGA9AJZ31Gzk6tUefmgGQQ5JqIcoESEDgVPfVct25i2iQpUhikdqIbJMRMLVh4qTa5SYSLq9zCmpYWTbick3CTJtu6kLSFRHMXAuMrbZaRWmD531MX/P3WAMbQjwVfDnTCWZ+BmdKozoQxcw2jCAeQNC6myaorCGDp1B3gOdOSghLyBg0xLYv/DYvjP1MMOVb/Ei0illddNNEXUuiiNMJN0ifVUMf4RExLmmoOq6v5oehpEjlpTQGWj2ZsYfFGg3BVZ25JRT/rpRPO+gXmMD7tgJGaiWoPREtzwTKpmBAgMeFRQmpM2xUblCgjLdvBvjW5oRJSKrQMb74I3yEoMs4KTTKjOmlrBQCtoF5XuBgEaCftWDqaesstvPUDaFkyHXod06ZFQdHhv4/QSgqSk4dMMck7g0xZ1tpjoOGDxQtO6eHlner+0hS6DQGjEJQPhsZUodV8lUKVO6UcEQi1/mG+UIUKMZOAaQyR9Pg02R/idBqG9fPLMWFw+VCQ5q0RzrWmGL9ew7rz41Dls38j9e6b7cqfoA0loNqxLiRpUHTGaAj7WhNMP9W0FGsD7BuVT2xMof2nqNcf6qBO3/H7fhJAIPAWXVS5SxqpBZpg4cal32Qdhv2hDs8tCD4k6bd1eYSfh7+Rrw10mrM+YLZj4bCD/cSR95iWqc7EEftWF5RmLHUFEgtLfmdWXFpactcXq3YvmXs7MxInoFFhWAhWurPLWrRS55gWlcorpoXlaKujgc61IIiZSCWaGkq7KF1gNAmJ2wMnMEu+Y2m2iVCo1mp7fcxeEDXDR2La/9paZ4XGbEixCA3bmdWgDYi2zEd3Q0CLcCcMGwMi+GJR4ctOnsMdN8aYsq7MBWpm19mldGHfe2jGzHpM/j1pIip+/x5CGy5StuwaDok5Yg5CqukxR36axYyUTq6/DrKpro5wpkkjhR6JkCVZqEaFM0KzFbubNDaJ5wJaHopvBXFEfDTGW4JwVHm5viEVllTuHQ0IZxhi+Vf60YSi9RsCOrPmgIEyBUnNC03CV02H5omY6pwzmzUNl0+yKTYwQ9SGIq1+tHMqYiatJkCZyzgTSIr5PVyFt9EmKZpezqTDjdXYGI6ZLFNo5xAzhadqzbC0S/M8Yapsur3R9vDoiOWfa3xhgpRfn1jdc39j6VEuFBoaC6V5U6JBHUR0Zs0+Q2NCoAaPL3zUXS1gKy7OrwBLv86qVwo0vrcCtA6uQvjCpv+OzCcXhPXsvtU143AaCm05Ne0pNZlR4VI0LSFyTV6SPo89+zTGyhaaZrnwXD6p0NQVJuTF0pGmX9F0Zzb9l76zoRbNG5NkmFw0RJKF/MO8Qz7P8cF+Ah0nqT56DYMbg7P/LiruR22hM2u2iFAtKp0Y66iOqbAaSIUw6j3FZKh8Kt9CFb3ATBgTDtEVnUb9nslUqTWT1RXOuLxiAg8lvGohFaxyC2f9hEY4o+JrxnaSwM303UZM1alm/YjW2fGZHkHAz6cfLgURl41om2l2FQam0dSFSYw/acZhGxYSjWk25jJUFc7cl2fBY7wza86tkGq/KBUz+Yuo7GNmi5gpxP+OvvNNBxE1tBaYGp5Kr3wOdkvFypoblEAiMR9Q8bjvqXE5ern4KfUn7WdS2jR5No0UGjnaYn1FWqYYv8k62dZwD5CaFjW7KPsp0Md4LocUHuXnlZIvFr5857UrNf+kYEh5zZ20TJjLkIRHdrs15xJw5gn3LNGEOEQHgGJFLNGISZl2j4lRu1r1wmvNlRjKFdGk6uoJQ45JmzN3aeJR36XaNFJIZfKVfOPo0GiMUujR1CcFbpxhGlfqWapZDONwZZCGy4FSsz1RLmy3pQ2ZG+Dal+yPCVq+XO0Ts0SMhvm0UsfDVxFiC/nQZJykhc6EzqzZJ7Pm2LHx3R6UOpkL26a5UkJHzs4dE3SwAYfFpWhlIdxJypkCuLql0qms9DzTbo+ZmPCPwcw7mjqSgmt3lXBG7CAbNHCCp/8ei4ebTNLzSkUj5sqG0M9JUgzEXDqyGOQXgpWwTDCpSVPi9uFoii2UMJNgXZOpBkM+vUT9St1TqLEX49eQ97MvGjN2P9Cgdbs15zqQZorgsE/sF6rJU1XmGB2+9iX289XclKZFSyO7ohSaMix9SofUOqaHSr5BHYbfuXhkupEyc2ZsKd1Ymiko6x4xaVHlpNpcMhlQaQ7KxC4x9YT9JtRaY+MohyDb1mSrpVdSZ00gV70ml1FgCsbqMyfNZV/0eArnnlIHqX25YFx8YnFCjZn7hqXbJrrdmn2Au90+lN79yaiyilLs6pN8D9Hm6icnRoRB5B2GCYUpJjS7OpcKD7XgneOGHQvAhedoQAWhytlxMg0Amr50kwSyMy5FQPPD+UIM9l4av4dWgTkSCyc1dUsXLtxzTDtH9QNOQ6PV8HCQmrdj8al43PeYFiom7IjHeoZjeDQaolg6I3Tn135J+p/UgjDU03Zx3kDREb7D5loqfL+Es86sOWCH0EbVq5GOLWF2bXY6zrwTC4sKqhIwpjHJhCLJp98DNxWDQnc/TGpa4cyFFYVDdn+lTqA5kSKcASTCGZdGHa29lA6OFi2NKWVI5k9KaPl97F1dOqUCr5QeyXstpGNbEtaF6w6hnQsAuz4qatPEuwexMFR6FDgVsq9iplTnsR9Fbyysnwf2dxMIzUgasxH2PYxHpSmtXywvLg8sPNanpLRT31PKkBOxfH36RdqO4ADQfguyPurc6ajRQHL8J7epx09L0uc4WqgwWB/FxntFiPHvnxUu2FJ/UjMmxu9DGrh4qe0m5YEYnX7e3DuKZgcNHwnTx35U2EFBpznrk+asKEY2BEgnDs0Eg4XnOrVWmyANi8VLiUulwzGHOitgjslh+WjKI9VmSOgOaaEmJj/dENh3afk19LXVV7h6SUmX0lxLNRKafikdq9I+3Rbq1m9KeCx/Kry2ru23ljenxPKM9eNYf9TOH1jcHnqJMNo8JIugocT0MZ6IfY+l2bbmrPM56yNig71pZtA23ACMCRSa9FwaOcEJJtxzW+BWzuGEI2F6lHbEoY6gkCq8asFNTNL2lC5mwvqnwmHvsfaoMwYGEf0oi7YdRHXO7ArMQZcmz9iCEaNRK/CE6XF5xHgGlQ8lYErGfMGM6UHSeOVCJ5wNAFK0PNp0pXFT02+LIUsHtNocZVes8QgUc4pp1GLaHP8bZnIJ08VooujR1kWM8aWknaptDfPntJvuXcz0EruWB5vkVIhcOdRTZ0Hfk0yYOTS4WqROzBT89pLG57Q1qRgE4bgOX+f6G7VA4PL02yMm8Gq1UNJ6HtIKX1AHiTc+kPXZ52uwuovP+wh/ApaEq7M6cExQoq1rglH5g13DiCVhfQavZXIVYS9yKW8oQIU/jmZtncaYoqQ9/X6D0evH59KShtPAp03Tbn7YUGgjNQvMpdZaerG8OPrF5XICY0SwTOlHkjhc/8CEVaxPaOnDJmDNeNcgJtRh3/2flvf64y4F3AIh1xjkykXlEasnKg2OJ6a2Z+Ed8cGGVfpgDwo6n7MWIbVZx1YlDlJGlqp+jtFD5RPTdKQKmdLVWqwMnCZKMzjrMF9NvpzWTZJ2LH0qvjSOtq80gRit0jqj+qumviVthY2H2FiRTHQSejG66/RjTT/R8iMM0naR5O3nrxmDsbxCWqX5aPKS5lNXq5rST7j+XTefQmBixaCZx/Ax3e7dmp1Zcw4E1sGk6ucUAYyLhw1MbMXGMU5uFYm9l5aBooXLexBMIBK0KSRJ82qTpthk3EYbhhq+FAEZg99npZN4bGEnFUYxurTa6rrwNcGadGMLM23+0rBNo+m+nDpu2+4XKf0m/J5jwZILnXDWLzB2bSmjkaBVDQZWpoj/zaCBqy9uYoppRyTpp4TDwveTqeTWikrCS+pYmj63oElZLFATOddGqX2GChvTqsQWLDlMc5LFWBvCvWh8e9ejSfqDT1sPJvP+jRwtsXqXCNzaNCV0YXnHaAuvX4q1ZZFxDpSCW6i7I7DcAfJtoPM56zM09nYn2UsmmJQwjpbQFwDLNwwTasawcoXxqXAhfVS5Q8YpKXcYjyo/V3ZuhRWG95+l5fdXeJiGwGdsfrpYWlj8WF1pzA9cH8LKUJehYn0tFgb7pqE7l7Ab63d+uFDrRqVDtSP1XlJ/fjiqP3HjH6MB6+OSvlinLqV8CfsWXk9EtVEsPY7+lLaV8CMJqLrn2iUcx/aH+HNqaKkztoYEdR/jf6Iy9uvqsKLoR7ZzJ0KfM2pliU1k2EoXY3zUClXSypwQEAuTG5K0KRoxcHRzq0FqgpPQGYubAq7MlJCH0UOVFetnqeGouBioPh0roySvWFlTIelHKXXlpxPjCz6ofGJ0DcIYrSu8c31fwyfDNKi0uXhYOtp+GxPsUhEbVxKelVNiwBZKmrjS+Una97jw3Q0BcyE0goULn+vONiqPSj7IO39ln7KKa3s1QtHNTeDufUwT4+fRNBwz4/IKyxkD154SxFbektUn9z2n9orKO6SjTh3Uyb9JUGNZEy82/qn4Ocoo1YRJ6Gm6TzV5OXgT4NqoSV5dzmOSuWxyNVwTfa/teYlD53PW54vPMeR6H/uWEi6G2CrEVzeH4apHCoxE8s+l8sPHzDPSMklWYNg7iSYDmxApeqm0JYKh5BtGr1QzRWljuDxSyhjGi7UxlTb3TNGsyYNLI5Y2V0YsDhZeU78xcJolTCDSQKJZ8/9PhVTI5MqD1QOmfaPGEcbHsO9qHhCcyxdLR6L98t9r5ghXfo5vSPJP4R/FpHh6Kf2oSY1uHXRmzT5ffK7p2JpvnMARYxR1OqJERVzHvKKddHKpvqXxtEwoTEtLBwatYCRJWzu5xCAVQLF4GLhJVlpGLbR9N2c+qW0s4SWS9HNBko90jKaE0dYhN065BSLHFyT1nJtP+nRp+L2Up1PxuDBh+kOKOkuds2Lt63/vzJoejjvuOPPWt77VvOENbzDLLLOM2XXXXc3UqVMrlfvyyy+bAw44wCy11FJm0UUXNf/zP/9jnnjiiUqYf/7zn2annXYyCy+8sE3nkEMOMa+99lolzB//+Eez8cYbmzFjxpjVVlvN/OxnP+tpyFNPPdWsssoqZsEFFzSbb765uemmm2pffF5XGyKFKm6gPg5Xm3XzcKpjf7Wj1XKlxJOWQ0o3lj7GtGJ5YwyhDq2xeI5Oru78sjqaJHG4Zw6hFoL6SeiltFEp9SntYxj90vTDeP1YpYe0YN+w9s1RTkk6bdeLhJ66/ERKR5PlzpV2rO9qxlHYL4qIew2ZrtRcKqSnbQz0bs0//elPVvD661//aq688krz6quvmu2339688MILZZgvfOEL5uKLLzYXXnihDf/YY4+Z3Xbbrfz++uuvW8HslVdeMddff705++yzreB11FFHlWGmTZtmw7zzne80t99+uznooIPMJz7xCfO73/2uDHP++eebgw8+2Bx99NHm1ltvNRtssIHZYYcdzJNPPqkuFyjPNEKGlmn6wJgHZ6aoc4q6ljYuXk4apNAyWlu+Sb2CrIYJaYXLphHS5OcbEzQxgYiCtiyYOSpF41A33/Ab9XdKW+VYQKTkFcuTEkRimiqqj2N5+2lREy8XD9OAaOtSKzyEdGFl5rRp3HuJQMItaKjwGM8KBRlszOdCP4UdDFw99h3FKMKTTz4JVVb86U9/ss/Tp08v5p9//uLCCy8sw9x33302zA033GCfL7vssmKeeeYpHn/88TLM6aefXiy22GLFzJkz7fOhhx5arLPOOpW89thjj2KHHXYonzfbbLPigAMOKJ9ff/31YoUVViiOO+44Mf0zZsywtBkD/89+57pCCOq9BOFwtJhk7A8brpX8hsPZXyxNIc0pZQnjcPkzbAgvL1MXXBnR90haVDysPDH669QhBmm+0jA5flQdUXRzz9J8+lW2umlJ25b7nrOuYulq86fC16FBW39Y+aX1KaFdQgOVDhZO26YozyL4mDb/VEjqEANLGzKPUXFkdMyev2EebwMDrTkLAUdQAJZcckn7/y233GK1adttt10ZZq211jIrr7yyueGGG+wz/L/eeuuZZZddtgwDGi+wH99zzz1lGD8NF8alAVo3yMsPM88889hnFwbDzJkzbT7+b3Y5Zje1jyZWy65LlQfDTpjtUB/+KmGHw6Vc+lrJLyftCGqt6OAQROWhkKSWZCKdFmXqDJGjztrSukjbOOxf1DssXj+A0dUkLaljJadWA+MD7n1qeiEoXyRt+Zt099DUo8ZFwYek78fSyeXugPEs/10dPi51f2lDszw0sXcea6ofNYFRI5zNmjXLmhu33HJLs+6669p3jz/+uFlggQXM4osvXgkLghh8c2F8wcx9d9+4MCBMvfTSS+a///2vNY9iYVwalM8cbABwv5VWWklsD68zQHriZrS9k3Sl5EHFQd5LmRsXBhVGU6Esr0QoSaYpkY7YWhuLK6EX26kWM/HkFOzrwKdDajatI2jlhKaP5RKMwnyxtMn4k4cPMOXGa80L6zXo6bc18k7tFz18O5I+m5aQfgnPxBYutcerx0NTF3MYpIvH2FwTPg/rhlrDqBHOwPfs7rvvNuedd54ZLTj88MOtts/9HnnkEfvevwKCWm1y/iCSdzlWWZQfDUcf9oz9HSuPJpw/iCltlf8NowfTHMS+27+HJxeOudSFZBXtmLBfztgqkfLd4eJTdViWvzwKhe+nYd3E6KXqNkyPYu4xgYEqd6wNubrC+iCVPwZM4PHL7YeRtiFXz1j9ceE43sW9FwtvRJ7lqfTC9qbaH22ziECD0RG+rwt/HGHlDdu8p17CE/sRHoXWU6IwqhX6U+upQIR1Ki3te/utxYXAHHPO2Wc/+1lzySWXmGuvvda86U1vKt8vt9xy1uQ4ffr0ivYMdmvCNxcm3FXpdnP6YcIdnvAMp/gvtNBCZt5557U/LIxLAwPs/IQfhlKFPMHURoy5xfKKxpcIWEIzYXXiG44zMQg0rIqmmHks3ZxhqTh+eSVtyJVFo2rHBE+flia0MRrasDtUB8lc4As2EmD1nYq65qi6+UrLEQrcFA3hO3U9eXcscmG4d1n7VphXzLVDQn8OWqQuJgmuKFnjt5HfhKLRerbtOTwfhX2/05yZ6uQNgtlFF11krr76ajN+/PhKvW6yySZm/vnnN1dddVX5Do7agKMztthiC/sM/991112VXZWw8xMEr7e85S1lGD8NF8alAaZTyMsPA2ZWeHZhNHA+Z9jK2H9OlfB7tBl1VnSEah1dlXgrPC4clpYmHFcmrF6l9SxZOVGTu1ZLmbKyc981ecTyp+qofMecyp1DW0Bp0qTQxEvVJA+ScElB2i7aelZp3yJmuDAcp6Gso/Uv03Tj2fXhiBktxTVDXJ9+2toT8Yd/oUZUlHcGlxYxcrq2BBD3B6ye2yr/3GTWBFPmL37xCzN58mR71hn4d8EP/MAA4Mf18Y9/3B5xcc0111in/X333dcKTP/v//0/GwaO3gAh7KMf/ai544477PEYRxxxhE3babU+9alPmYceesgceuih5v777zennXaaueCCC+wxHQ6Qx1lnnWWP4rjvvvvMpz/9aXukB+TXJNwA1JhPJAjNDBKhgFpJR+MiauiwTFjZKIYdmm9c2PBdrCw+YnljcaSMOWZCk7afVujF8uLqMIxDpYOlm0uw5Mxi0vKFfSHHRJ+CMN+mhU8uPjWOKH6iXQSIF1fU4ic4jkabd07Brl/CePZ+OkqFkn6iaNA9ZY4ya55++un2/3e84x2V9z/96U/NPvvsY/8++eST7c5JOHwWdkfCLksQrhzAHAkmURCmQGhbZJFFzN57722OOeaYMgxo5C699FIrjH3/+9+3ptMf//jHNi2HPfbYw/znP/+x56OBgLjhhhuaK664omeTgATgcxYyEwBlQpAyvhAU45WYKSkmSk2cXHnK9BQq6RxmSp+OWB1r4AuW0nrnvknaw32jBLQcTF1qpowBq2//G/ecAxLhPKW+6vYdSbxQsMRojY01Kt9YXdc2Uw6P84rJXyysV10ZsLhcOaJ1C7wnZgWYbAYaFZ7ctgmyKQjLUdTRzkN/nNgfAasOuuub+nR9U1EsNtIIQsFBoy3JNTHFNEyVsMEdcCxzdYzSZ5oRX5KSOQU+aSitYAbw6NAIZ5xw0VMWpMxNrrybZDDhxJjST2pP8EhfcOlq+mITyCHYa/Pg2kHST6VpxdKX5C0WrIg2VqXBxKPil2DybxM5hOHRimi/nZynjbD+FPbFnvkqyHskDTgKa6zd3AduUXO15mxuAaZNqKvZCSExr5ADpuJzVO2wsZV9KkJBKxrGh/MrKVeavQHFdUwwiXC1HTM5olo8byXMbajQah1TUZk4zewz8SxtNbRMyfDbfPh8vkGFZrxKtZ1SDWmqVj1bWOvTU2MSDcZXqllcrEXOaeqrI0DYuAPcqRPGaM/zoGPyUO/zANHdCWd9gGTXR+7JqEkmLjUL9HOCxfKuCiMGnyQm5xm8PSZeiQDWb5+R0nmaKbMnzM0O2wZhRp9XbCJVTLRkX1KirTh14ucS7Aa2X/QRbS26xH3b8bcUoTNhI0UbKLix6i+sBZtZ4Ax5/xisuXpDwNyEOs7LjTs8D9BqYo6Csl6lzvuSNMg4ibdDcHnF3rUJLT1UfWnHqh+Wihe+x+KE+WLvqR9X5lgZY/xJS0ObkNKsje9uGkkqKzPOpG3GlSVnnVP9LRZHkg5Fu4Om3aTjQgM/XpuCmc179t1RHdr0OQOb9dixvM06Znrk4lBhKPNL6D/i/43lK/ExidGL2v8TEItfN30uTUm6OfPn2kDaJhrasfQ14cK8qL4XS0vbxlQZtf06pDlmvtT6fcV8qnILM1x9xuomlpaWjlzjIsxf6o/G0UbF15ZZ6jNH9TfqXQrq1LOGPmn/5tLEaB9ShJdCw/9mo/M565AwidZCDv8HzMHfIp8WxqY2mpYSufxKPPOiZDLikFx/WpOuvZoH96XLyWBTAHm7emiiP3F9te1ys+XzfUknlX/1xJXyIsxPNOUO21ZNoMOmxUq7hNf5QN0wfZ8U2rgxw5gOwx2vKcDGmJh3MOWPCqgw7omEKz6KyO5cKQpC6HPfqHLWyasf/KrzOesTMEbmCzbU4JSsOlW+H96hjFz86LvJMuYXplMdsEbuGzEcLsbIazN6hImq/HAy+5U0Xl7M30zgTyLpi7E+Rn3TlpmjRcJkOTpT61clkA5P6twk1Cbq+JKx/cLfTBD4LuagjQpT8qLg/MW6eVZ4M+ZXKhkjk3o3M4mEKIHwmBM9Y0Trc4YJxSaPhrJImBclebQ9/jrhrA+I3a3ZO7irgWLmCNUqdXjFLDF31kET8bUmPQw5ykeabifVT1NS7jYhZpiRsqeYHnMzSK3JViuQhGUM34daIn+SIxczwXEyKdBOplIzaA7EtI0aUxRrVmxos02Z5+T+H+FB9p2RN6bfkAr+RYOkSt0tYCNfm35nnXA2qFDeH8f56XCTG6c+p9TiKJP2hLxwYo76JGiZVbDiwupHO4mTPkFBO2i0GWXdBgcgSn2oRv4uZps6FP2gNlOrnPEze/WuqVP/Ptd+mjApcH2m7kSgTTvsb7E+pRFmKfqkC4cm2m4kTa8sNQQWifDWUw7mUNqmBPs6izU83dl8oQ59uvx6Ialvf04q64CZ3yjNWcFo1GLaNm09ZOOjNdBtCOjThgDNIXZ1GGRMOEtNh7x6JTjQD1utlmEkJj/vkECMltzw/T0wQSwmnPmajSpjpuuISo8rp3QSUmsQgzaR9B2uj3H+M8naTU8DkaMfoH0VyT8MT8XhaOqpH+VBspr8Y32kp9yIVi42QVIHQ6eURQ3EBURaZiotqZCYJJxlnOC1bRyNh/DwmPlRkn+ZBtNOOYQzqa9eqkYewqTO36noNGejAJpBjTEDLD42KcTUuxI6woNf0bwjl4tr0TNpO/iMVuKfgfjfofkYnvGg4SfrVfnuWctERvJU+vJF0uOEGLZMc+K1MzWEvSbyir3jvrOmuAY2wLRhCm0aPeOMcu5viDY23eHNOKlnlmFmX22fxnifhq9q3qPzlltkIov7aJoDcoNEJ5zNYYgOGsbRFO2gg+CXgEzuOVbc2R31G/LjacP3QkO/mDFn8uvRCLOzTSdp7audJFK/+ROdVvPmvrctkLiFQa8Ws08Hq44CAS47MvCtuvUg1RS2Wd+Fx7tQwdLT/vljh6RxQPpvJ5wNAGIaK+p71OSgPHMGy1tDZ11ITSJzBKPNgKjJJCOTSTGfNQZnZiF8+UK/rPC7RAspMculjC8u3xQTraRdVNrWRB/O2eOyXkeQjG2pMKs2b3p9CgNLFzPOKN8rCY09NEh91nx6kDtqXd6UP1zokyhx5wiBpS1yCxH22Z7xp/Dnk4xHrG26Q2jnYIQ2a8nkIPHzoeJQk0esc6qEM8QnIXV1lepHIVplMhdq16U7FTH/j5gvjdafResno+kzWLqckCBt45ivFRaWElRShLNUYUBjipaC6wM5hLMUOmM8RjNW3OTNxdXQKKkvaXpSXhXrU7n6Akcbh9iinKofrXDG0drW2KCg4WVVWts9hLa7vmlAAI0vNW041W3ou+WrbX3VLWYmw8JgYSka7d/BOUGx+Gy5hsvD+aNJ0p/tZzUk/u7KIfGDE+WfCoTuWJ1K6zwMn4KUeC4/3xzmgL3LQaPPVCVCSZhfLP8mJtdcwMY/10/YvgVjIoEv1EHdNKJj2PGYTOMJSx9Lc5AQ4/vS8dDD/4m6l/YdyTwF0I7XHiDzZqN8vQY6s2Yfga5eCAdzzvG8DfgrCGlHlmjC+jkoQpW4VPMSW1VKIRFkNdqDXHXJTV7Y3z49WuFFIkBh6WuEMCwfqWlRomGhJi8pbWEcCqnfwjzCOP7ETAkZUu269LsWovwny/ikP664fuS3RzgWOaE2eBMdN3hZcE0/VZ6QbglSLRiVvLCDfBMO7qbGdRH2zchYji2sHK8PN65Rcf1wbZ9z1h2l0S+z5iVjo8cqVAUI+WBtAqzgkrDdOreJUIIUoSZKJ3ZtVYY2QvON3R6hcMZONTvlMofVRUyQaROxscvF05haUxHlLQnmv5Q0pZCYkqWLFqpOw3Gl3tHXglsDudvcfSP4QbJwFh51JEgnRcDUmOKLSDtjY4iigexDwU5+KlzbR2l0Zs0+I6r2DUxuTU5IbrVCrUxyMieJBk6reUiiYRJvBm1K5e2XjVq1SzVYErMs1ba5oamv0mwxTH9o4qA0DintMYhmixB12ia1TlLHoN+fsL5VtyyciYsbF5QWyH0n84yMn5T6xcZ4SE8ooOSqQwmouqToyjEvUHGw8V4Izc8UrahQ7vHKQVncUejMmn2GlHmkpOdDsgLRwsYJ/LcseoQdPvFcwl9sda1NvyntnsSkhk8y1ZP6R/4eOSmcMoWGEJtXiDix99wkKckLoyvWnrnMfm0w7dz5cOM+JZ9B0UzmHoNYnylNXT4/a9hCoSmXT2Pb5wgOQh/oF/q9oOvMmgO0W1Ok3g4RCEKa09gxYSC3oIQyPILmpoWz1PRqD9LA9JliQukVyBiTDWbeZA7hbcoUhX0vaVSYL7A+1NSkoTE1SrRO/UZbwhkWXmRSjKBu34wtQMXpY9r1DFdOxcYLVa9a02cqrZTp0zf/cWOGrdc+HvY6RLkLefy5QvvkIfPsi8aM3Q/u2OzMmnM8JKp6dZrDnU1jBpCqkwGUCUNjlsNo1uaJvc9dn2U6sR2g2nQFJhSpuahHxZ9w+4IvKHH1XAdU2/jPVHvWzatOf4hp47B2ktYXa2bLxA9S6KA0ldp8OA2xpo5yjWWMBv+5TbhyUf0mNNuF4ySkW0R/Ah+rW/8pvCMHv6nT79x8pOmnTaAza44CkKu/4D406cTcpulz0JBTuxZdHWIrQ3fDwYT0fFmahg9g7W3jERqayFuqRZLWtzPPjsSrRpSszlOYapRxJ2iiUvpYP7VubZuA64zJWB/Ipj1HLuxWQ6oporQ3PjLdK2tpSiwTJiyGgj0lPM4Jc0nT6MyaLSJltwfbqSX3RYZgzGqtmj4pRpVgyk0x4ZH+Glz+Ybo16JAAo1VyaTp1AXDF3FnHpBArdwYfGxc2SQAO0skJagxwJh6O3hw0akyKVHwH0gyJ9WXisGRu8SehcyDNnjl2y8fGHHL5eMyiIDJ9SvJsyEQr6QvZBbXJNeYWDyF93W7NDhWEphlO1RozN/qMRmrKxN7nNMPmQIqZJLrDMbMpk6OP+oaaARm6XbnCuP57l5+E1pjpWgOuz4SmHRfe/x8zIWL09ZhG3U5QpM4k77HvsXrx+xdFr9+/qDEmRWwBhf6Ieun5Tky4XF+gTMpWGxrszMXCS/II85IA6yMxs3cqr6trEvPrPsYf/L8peuvQEhtrmvqr0BxxZ6kLSRtw5QL4c27b6MyaowmWmSO9OaIdGjSzSePAtFqCMLMnD1kWfljqLketdsQxOpbmGKgwYR9x2o6JcZp6aaw6A0vAraC58FFzaWxzRS7zjxZEvqVGJME3MCv8c7Ii/W52ORi+E+lDaPmbMusHgqpm7IVxmhYcfFTyUh48S9Lsp0O1UYP370br3sub02AOIWXj3pUH/07s5Vsc3dpvTaMza7aI2mpRobo2ZiaIqfKj+bUBqQkgB23SwxclBxoK85IypiaRvKpPKCspnE2K1AdhyiXNb5GJqy6zjaURo1GaJmcupczWVDwKsQkxNsmKeIdDwJuSx0uEB0pNrH6YkC4RjZzJULAw7GlvfxwI3AYkY0TlfsDUa5i2pK9q61QknE0accvghTN8jGjNrmE+nVlzLgBcAeGbcTB1qkQdy3UsTsUdU+Vz0Kh4MbVyXXV/3cmVrTfhHZvJQhTBtCXmiLr1RuWL0cCZwRxNFDAafeYaHjZL0eXy9J+xMNK8Obo5s6Jv3nRmykq4oExUO/WYd/y+RtyT679H82X6C2VWxcxRoemGoj3GV2JANYmZ+3VIX9h/qT6FPVNlyEErNq5S47tnn76sfIJwg5HUYdgOPo1oeQJha8j1UwHv6Wl7wQHusb6d2tdzoDNr9hFURyM7IGUmcyuxiekqYfQ9s9LCVjpZzQExjRjxPWmVj5y/RmrGcmjqBGZoicajkXqn8nSmW4UJK9QQhKbUWBmlJuY2QGmqSJN2g/fISkzS0jt4Y5M4pXWMliXUcEyQCWq9eQVmUKHZPkYPBV9ATW4viVvFKOn3g4Ahpk5I7VyNNhgUdGbNFuGrRceOXUykesdOf9YIRiLhLDTrYbv6XFxsF2ARv2sTU4mrmB810IT+dlpGSwpnDZh6OeEstlL0wyTVp2LnUi5tiQNn7pD2E0pQ5YDli7W3VPuAja1Yvqng0uDqgBr/sXpOFs4QaOqzbl6pyJUvyT8EcRovL2YqTuVnMbOz4viQqPm2kH9rAm2bNTvNWZ/MmqGJQ7PK4zppLCz1DqMDW7Fwg8B+Q5yMQzNKk4ilL2WA1ETVxKo2WqeC+H4dO+TqP5i5SypsxwRIsi8W+QUjF0ZSXleXGmE/JmjW0cZU6tmZeJCFkkQbLzHfpYRNnSzDPhLWfficSkdsURt+1yx4qfwlccLwsb4XloGjIZu2VlDmsK4lCwIH4KupWlypNUE7T/YbneasRTjJ25gZpijiknddZqRJo07+sXiSgdLW4MhRHw45JtoQEuaNhUthRlotE5Z/TOPUlOk1lflSbUiZR3IKZ5I0KNRpqzr59kMD7N5J6k3DWzRaS6ofSIREiVAVFVb6JJzlrE9tu0pRZDhLT0Jrb9xnQbXSac7mZMyYIQtXR3sgGbixfHIx8UFYlcRWWqMZftn8FWuqhsx/xz3nQM520GgZc+WZGxLtU0wAnpNRp81SBYOYNpIaJ9K8pO2MhdfSkCqshe9SNKO5MMTUK6e1HG2Yp98EdMARM79oBka/JiHfLIExCf+HxeXiS/PXxKPCh+9jNGOCIBYf+2HgwnH0cnWOxfHfx9qEQ6w8/7+98wC3ojj7+FzaBQSlN+ld6QoiTSD0gCAqomCBUISAQCCIJAqIQTqSB4lGo5AEMWJEJUpAQJDQuyDSpUmvSq/zPf/53H12924959xz99z7/z3P4XLOzs7OO++Ud96dEgsCxe+woXCsG+14GUle5cvP/dG2L37qdKT6DzJYtHuOWxq86p71/27PiUSOoN4263OjrlMem2t7tUNeYT11b7MyWd3nY8Wq9Dn48otjebJswJxW/SfnnCWAJ8Srw3S6Zr3fiu09QSZwGsMZvqt49QbAvJrNl9fCabPdKLDzNmgdTLSjyUgqr5ur38674yedXsZB0LISy1dpbvf7JYjHy5SfH0SfZj+GV9A4NZ3ayRWNoWeNM1bGYrR69ltvUoQzLlCyCZPag4BYEkl7Ew3Rbnbs5KV1fo4/4ezmTbrt32fFqVz7Khf6vGhpDhey1Z30nKUBatrZLwQZwVpHvFYjzu27V3xO99s9060Tt4vH6/9295lGLg57AXnJqI3gIkmzH0+ZNbwfj0E0Hgu3vDXi1fj7ybcg1/yOaGPVKdmVR6dyrMJ0lXqjb9WVXfrsvCdBdGbnTYgVfuOykydWni1jnE7tg19D382Lp3kx/IS1holUJqfyZNceBMlDaxsWK49YLOuVEaPc1mdE63W1YsoHw3500sWzaRx8BC7PMPQjWJ3607uGjjsOcEFAGi0IEOJO11FJLAt/rHBKr1da3Ubv1jhSw5PiZYi4pS2IB1UQwccAABzdSURBVMLLE+AUR1DvhlO+e3ko/T7DS69ucaa2V8Ba/oLI5KeueXmn3cqcn2t28bjFb5e/QcphJPXKDbf0uXnHgpT7SOuDXfqsvzvd5xbOLbwXfp/r536v8hdL3OqEUxmIp0cwyYeeY50enhBAUpVoC2y0o25Ht7jPON1GdNYwfuO2k8mvh8gpP5xG+dHmXSSeE6frqY0fT0eQOPx6Y5ziSU3iMZjy4wmLtRHmJ01+nhuk3vvxhhvvsysf0XjPrO2A3bOseNV3P54nrzRb5YtURjtPZyR6jbUHLUgapeZVNWzdZOwTjNf8PidscM5ZQKZPny4mTpwojh8/LmrUqCGmTZsmHnjggagaWrfrQYm2oLl5GNzu8Zq3ZmvYKDd/yjlrbvEEQtvY0DD/zS098cT6/EhGxUFliIWnwi7dGQYfcyEjNVJSi7TUTyTPdvO+RcQvdd/p0Gu3dIQBJ+9UXA2KFEZOKmWOn/Z+tofgIZs3Fg2ccxaAjz76SAwePFiMHDlSbNq0SRlnrVq1EidPnox6Kw03D0EQ/Ix2nEbadg2j2xwMp48fmdzOPPOTB56eMLsVQT5GsU4jZz8jZjtZ3Z5p/bjpzslz5PZ8X6NPF2PcyUvh59nWuPyUbS/PQ7Qfr2c5yeVnYrVf76z2DGP+uN3r5CGKtB66yWkti9HIaTsY85k/dvcETad2j91vXm2tWzl1S2eQvAmcP5azUv14K63Y3RtJPG5zwoKkw/qb6RkyWBqjPaPUK31pAeecBaBu3bqiTp064s0331Tfb9++LUqUKCFeeOEF8dJLL0V8fJPX3BI3z4ZT5xqGwhWrUaBbHmlY4/SL3/sizU+/evRKg984gqTLGK9dGoLqyS2OIGFSy2thl5ZI8zOacuZW5pyuRZPGSNoHp7oaLV5pCdqe+dFf0HoXRAduOvQT1g9+n+s3ntSqX07Psz7TLh2RpC0pSnmcjHuneDnnLKRcv35dbNy4UTRv3lz/LVOmTOr76tWrU3W1ZhgNrWiIZLQWq3yxG3k7VVCnxsVIEG+NG37SkNZ5H69GPZ44dXyReiXiRSS6MN4Tq3IbND+iKXt+PU6RerDC4jGJNXZe07QkVmVM+pwT57ePNRplYWjrOOfMJ6dPnxa3bt0ShQsXNv2O7zt37rS959q1a+pjtLy90EZ5fke21v87xecHv2H9jESDNAB+R65B4kgNvLwekaY/qNfOzasRy2c7dYSx9EB5pSEWo/2g6UqLzisWcsbKq2qNM7Xx+4wgbU4Qb6xTvFbPSqzrs5P32M7YtIaLRd2Ppsz5MbwjyfN4IkNggLnBOWepyNixY9VrTO2DV6DanDOnUWysR5rW+L1Gy06NUTQNUyReJD/xROo9iKWHIDXxSl9ayeBXP8bfotVbLIm0jPvxxqQ2iVBuY5XOoB4xt3vTU95GWi/t2vq0ktetD4r1MxIVGmc+KVCggMicObM4ceKE6Xd8L1KkiO09w4cPV/PLtM/hw4cDVybr93gUOKcK7Mfgc5IhtdIXBgPEK0w0ugyq93g2SEF1HEnaYtXJu3VMfsp1tB2aVxxe8XoZvnbp9xt3vIlEVrvrXnkYaZ1J7XbWS5d+7k1rnca7T4qGSNrsMEDjzCfZsmUT999/v1iyZIn+GxYE4Hu9evVs70lOThZ33nmn6UMIIYQQ4gbnnAUA22g899xzonbt2mpvs6lTp4pLly6J7t27B4mGEEIIIcQRGmcB6Ny5szh16pQYMWKE2oS2Zs2aYsGCBSkWCRBCCCGERAr3OYsj8d4nhRBCCCHRw33OCCGEEEIyMFwQQAghhBASImicEUIIIYSECBpnhBBCCCEhgsYZIYQQQkiIoHFGCCGEEBIiaJwRQgghhIQIGmeEEEIIISGCxhkhhBBCSIigcUYIIYQQEiJ4tmYckVLqx0AQQgghJDH4+Zd+W+vHUxsaZ3HkzJkz6m+JEiXi+VhCCCGExKgfxxnZqQ2NsziSL18+9ffQoUNxUW6YRhwwSA8fPpyhDnyn3NR3RoDlnOU8I/DTTz+JkiVL6v14akPjLI5kyvT/U/xgmGUkI0UDMlPujAP1nbGgvjMWGVXfmX7px1P9OXF5CiGEEEII8QWNM0IIIYSQEEHjLI4kJyeLkSNHqr8ZCcpNfWcEWM5ZzjMCLOfJccnnJBmvdaGEEEIIIcQTes4IIYQQQkIEjTNCCCGEkBBB44wQQgghJETQOIsBY8aMEfXr1xc5c+YUefLksQ2DjWfbtm2rwhQqVEgMHTpU3Lx50xRm2bJl4r777lMTLsuXLy9mzpyZIp7p06eL0qVLi+zZs4u6deuKdevWiTCAtCclJdl+1q9fr8IcOHDA9vqaNWtMcX388ceicuXKSsZq1aqJ+fPnizADfVhlGjdunCnM1q1bRaNGjZRM2JB3woQJKeJJJLmhyx49eogyZcqIHDlyiHLlyqnFLtevXzeFSY/6tiOs9TJSxo4dK+rUqSNy586t2qtHHnlE7Nq1yxSmSZMmKXTbp0+fwO1emBg1alQKmVA2Na5evSr69esn8ufPL3LlyiUee+wxceLEiYSW2akNwweypiddL1++XDz88MOiWLFiSobPPvvMdB1T8EeMGCGKFi2q2rXmzZuLPXv2mMKcPXtWdO3aVe3xhv4e7eDFixcDt/eeYEEAiY4RI0bIKVOmyMGDB8u77rorxfWbN2/KqlWryubNm8vNmzfL+fPnywIFCsjhw4frYX744QeZM2dOFcf3338vp02bJjNnziwXLFigh/nXv/4ls2XLJt9//325fft22atXL5knTx554sSJNFfhtWvX5LFjx0yfnj17yjJlysjbt2+rMPv378fiE7l48WJTuOvXr+vxrFy5Usk9YcIElQ8vv/yyzJo1q9y2bZsMK6VKlZKjR482yXTx4kX9+k8//SQLFy4su3btKr/77jv54Ycfyhw5csi//vWvCSv3f//7X9mtWze5cOFCuW/fPvn555/LQoUKySFDhuhh0qu+rYS5XkZKq1at5IwZM1R53bJli/z1r38tS5YsaSrXjRs3VrIadYuyHqTdCxsjR46UVapUMcl06tQp/XqfPn1kiRIl5JIlS+SGDRvkgw8+KOvXr5/QMoOTJ0+aZF60aJGqu0uXLk1Xup4/f7784x//KOfOnavk+/TTT03Xx40bp/rwzz77TH777beyffv2qg+7cuWKHqZ169ayRo0acs2aNfJ///ufLF++vHzqqacCtfd+oHEWQ9CY2RlnKBCZMmWSx48f139766235J133qmMGvDiiy+qRsFI586dVSOp8cADD8h+/frp32/duiWLFSsmx44dK8MGOuCCBQsqo8XaWaPyOvHEE0/Itm3bmn6rW7eufP7552WYjbM33njD8fpf/vIXmTdvXl3XYNiwYbJSpUoJLbcVGFhoyNK7vq0kUr2MpvOGLr/55hv9N3TYAwcOdLzHT7sXRuMMHa8d58+fVwOHjz/+WP9tx44dKl9Wr16dsDLbAb2WK1dOH1inR10Li3EGWYsUKSInTpxo0nlycrIysAAGkLhv/fr1poFqUlKSPHLkiO/23g98rRkHVq9erV7XFC5cWP+tVatW6ky67du362HgQjWCMPgd4HXRxo0bTWFwjAS+a2HCxLx589QBsd27d09xrX379srt3bBhQxXOiFc+hBW8xsSrjlq1aomJEyea3PlI+0MPPSSyZctmkgmvic6dO5fQclvPnrM7dy496lsj0eplNLoFVv1+8MEHokCBAqJq1api+PDh4vLly4HavTCC11h47VW2bFn1+gqv6wD0fOPGDZOu8coT5y1quk5Uma1letasWeI3v/mNevWXnnVtZP/+/eL48eMm/eKoRUxTMOoXrzJr166th0F41Pm1a9f6bu/9wLM14wAUbiy0QPuOa25hULivXLmilHrr1i3bMDt37hRh47333lMFsnjx4vpvmKMxefJk0aBBA1WYP/nkEzWXBe/90YG75YOWT2FkwIABaq4gOq5Vq1aphuvYsWNiypQp6jrSjrlZTvrPmzdvQsptZO/evWLatGli0qRJ6V7fRk6fPp1Q9TISbt++LQYNGqT0iI5Zo0uXLqJUqVLKkMEcm2HDhqkOaO7cub7bvbCBjhhzfStVqqTq8KuvvqrmDn333XcqzehwrfOKjeU1EWW2gvp5/vx50a1bt3StaytaOt3aI/zFQNNIlixZVNtvDOPV3vuBxpkDL730khg/frxr5u3YscM0WTQ9Ekk+/Pjjj2LhwoVizpw5pnAYdQ0ePFj/jgnHR48eVZ4mrbNORLmNMlWvXl014M8//7yaVJ1op0FEou8jR46I1q1bi06dOolevXolpL6JM5gUDuNkxYoVpt979+6t/x9eE0yibtasmdi3b59aIJKItGnTxlSXYazBKEFbhgniGQEMrJEPMMTSs67DDo0zB4YMGWIaOdgBt7cfihQpkmL1lrbCB9e0v9ZVP/iOFSFoFDJnzqw+dmG0OMKSDzNmzFCv+Px0wGj8Fi1apH93yofUlDHW+odMeK2J1YoYgTvJ5Ef/YZcbxlbTpk3VauV33nknYfUdKTBA06Jexov+/fuLL774Qq1yM3rBnXSreVHRYftp98IOvGQVK1ZUMrVo0UK98oNXyeg9M+o60WU+ePCgWLx4se4Ry0i6LvJLOpFuGJ8a+F6zZk09zMmTJ033oa3HCk6vttz4DF9ENaOOBFoQYFy9hZUbmCx59epVfUEAVrsYwQoQ64KA/v37myYe33333aGaeIxJlZgUbly15wZWdNaqVcs0Qbxdu3amMPXq1UuoCeKzZs1S+j579qxpgqhxlSJWMVkXBCSa3D/++KOsUKGCfPLJJ9VqrYyq70Sol5HUYyxywMKG3bt3+7pnxYoVarI0Vrn5bffCzoULF1Td/fOf/6wvCPj3v/+tX9+5c6ftgoBElRkLIjAp/saNG+le18JhQcCkSZNMKy/tFgRgpa4GVqzbLQhwa+99pS8q6Yji4MGDakXaq6++KnPlyqX+jw8qtnGZccuWLdWydGyPgZWMdltpDB06VK0Amj59uu1WGigoM2fOVIWkd+/easm+cYVMWoNtE1B4IYMVpHv27NnqGj5jxoxRFRpbEBi3VsiSJYuqIAiDxiLMWyusWrVKrdSEXrGlBAwz6PbZZ5/Vw6BRx9LqZ555Ri2thh6ha+tWGokkNwwzLCFv1qyZ+r9xiX161rcdiVAvg9K3b1810Fy2bJlJt5cvX1bX9+7dq1Zio5PCqlxspVK2bFn50EMP6XH4affCBgaVkBkyoWxiawhsCYHVqtpWGthS5Ouvv1ayYyCBTyLLbBxUQDasLDSSnnR94cIFvX9GP4UtsPB/9OHaVhqou5Bx69atskOHDrZbaWCAuXbtWmWkYoBq3ErDT3vvBxpnMeC5555TirZ+tD1iwIEDB2SbNm3Ufieo7GgErKMThK9Zs6baMwmFH544K9j/DBUIYTBix14rYQKF1LjvjxF0Xvfcc48qqBhRIf3GZekac+bMkRUrVlQyYnuRL7/8UoaVjRs3qq0f0JFlz55dyff666+nGC1ihNmwYUPVicOrgkYgkeVG2bQr80ZnfHrUtxNhr5dBcdKt1iYdOnRIdc758uVTZRqGOgaWxr2v/LZ7YQLbFxUtWlTpEfUU32GcaKCT/u1vf6s8IyjXHTt2NA1IElFmowcIOt61a5fp9/Sk66VLl9qWa/ThmvfslVdeUcYVZMXg05ofZ86cUf0cHDFo17p37647YoK0914k4Z/I39ISQgghhJBYwn3OCCGEEEJCBI0zQgghhJAQQeOMEEIIISRE0DgjhBBCCAkRNM4IIYQQQkIEjTNCCCGEkBBB44wQQgghJETQOCOEEEIICRE0zggJCcuWLRNJSUnqYGU3SpcuLaZOnSrCyMyZM02HQqd1PCS85TgRSc+ykXBB44yQkFC/fn1x7Ngxcdddd7kaKOvXrxe9e/cW6QU7Y7Nz585i9+7dqfrc9GgARipTWhgdmzdvFp06dRKFCxcW2bNnFxUqVBC9evVSeh81apRKj9sHXL9+XUyYMEHUqFFD5MyZUxQoUEA0aNBAzJgxQ9y4cUOF6datm+39e/fuTbU6Ski00DgjJCRky5ZNFClSRO94nChYsKDqiOLJrVu3xO3bt+P2vBw5cohChQrF7XkkvnzxxRfiwQcfFNeuXRMffPCB2LFjh5g1a5Yyel555RXx+9//XhlB2qd48eJi9OjRpt9gmLVq1UqMGzdODVZWrVol1q1bJ/r16yemTZsmtm/frj+vdevWpnvxKVOmTKrVUUKiJrpjRAnJODRu3Fj269dPfXDgbf78+eXLL7+sDsvVOHv2rHzmmWdknjx51AHArVu3lrt37zYdDtyuXTt1HQcn33vvvfpB39qhvOfOnbM9oHfkyJEqXKlSpeQbb7yhx3nw4EHZvn17eccdd8jcuXPLTp06yePHj+vXcV+NGjXkP/7xD3Uv0o4DnX/++WdHWXHANQ5z//zzz9Xh5ZkzZ5b79+9XB7rjQONixYqp9OOQb6TVep8GDo1G2goVKqTSV7t2bblo0SJTntodnG6MBwcP4/cdO3aY0jhlyhRZtmxZ/fu2bdtUfuM5eN7TTz8tT506ZSufW/566dCOyZMny6pVq6o8KV68uOzbt6/pMGRNngULFsjKlSurNLZq1UoePXpUD4PDlzt06CAnTpwoixQpog6axiHb169f18O4pc1NJuj+/vvvV4c141BnHNx84sQJdQ16dToI+tatW/L111+XpUuXltmzZ5fVq1dPcXg9ym+FChXU9SZNmihZtXJsx6VLl9TB2I888ojtdbv7rGUejB8/XmbKlElu2rQpRXjk2cWLF0356pdY1FGvekKIFzTOCPEJDAl0bgMHDpQ7d+6Us2bNUg3vO++8o4eBIQJjZvny5XLLli2qAy5fvrzewbZt21a2aNFCbt26Ve7bt0/+5z//kd98802Khv/atWty6tSpypA6duyY+midvbGjQudZs2ZN2bBhQ7lhwwa5Zs0a1QkjrRroMJDuRx99VBkwSBs6/z/84Q+OsqKDzZo1q6xfv75cuXKlkhedas+ePdVviAOGFwyJ5ORk3UCwGmfIg7fffls9F2FgzKITh0EJzpw5o4yZ0aNH63LaxQOjDvcagZzab8izggULyuHDhysjDh028rlp06a28rnlr5cO7YA+vv76a2XoLFmyRFaqVEkZaNb8bN68uVy/fr3cuHGjekaXLl30MDAikJ4+ffooGVA2gpQvN5nee+89OX/+fFXmVq9eLevVqyfbtGmjrt28eVN+8sknquzBEMZ958+fV9f+9Kc/KWMSRiXuhRzQ97Jly9T1Q4cOqe+DBw/W6wSMPzfjbO7cuer6qlWrpF/sjDMYii1btvS8N6hxFos66lVPCPGCxhkhPoHBg47R6CkbNmyY+g2g4UXDDWNG4/Tp08rDMWfOHPW9WrVqctSoUbbxGxt+OwPFrqP66quvlFcLnaTG9u3bVTzr1q3TjTN08kZP2dChQ2XdunUdZdW8HzAANGBQ4VlHjhwxhW3WrJkyitzSbKRKlSpy2rRptvIYn2+MB9fLlSunf7d601577bUUHfXhw4d1g8NJRmta/ejQD/AuwbNqfBbiRUetMX36dGXIGI0I5AWMJQ14QeHl9Js2P/kPYCAiLs2YsJY9zfuDcmM1onr06KE8bwB6h2fJCOqEm3EGjxeuwwvoF7syArkHDBjgeS/yFeUW3krt8/jjjzuGj7aO+qknhHiRJfoXo4RkHDBPxjjfpF69emLy5MlqThbmzWTJkkXUrVtXv54/f35RqVIldQ0MGDBA9O3bV3z11VeiefPm4rHHHhPVq1ePOD2It0SJEuqjce+996pJyrhWp04dfdJ97ty59TBFixYVJ0+e9JxfY0zbtm3blJwVK1Y0hcO8Ichpx8WLF9Xk7i+//FLN87l586a4cuWKOHToUCA5n3zySTUPac2aNUoHmKd03333icqVK6vr3377rVi6dKnIlStXinv37duXIs1O+NGhHYsXLxZjx44VO3fuFD///LOS8+rVq+Ly5cv6/ED8LVeunKsOqlSpIjJnzmwKg3yPJm1g48aNSg/Ip3PnzunzB6EHlBc7MGEe6W/RooXpd8z1qlWrlp4mY3q0OuEGnAKxIEg8TZs2FW+99Zb+/Y477nAMG20djaSeEGKFxhkhcaRnz55qEjOMFTT+6NBh3L3wwgup+tysWbOavsPA9Jrgj0n5RkMUhhYMB3T0RgMC2BlFAAbVokWLxKRJk0T58uVVnI8//rjq4IOASdi/+tWvxOzZs5Vxhr/oQI1pe/jhh8X48eNT3AsDJzU5cOCAaNeunUrPmDFjRL58+cSKFStEjx49lJyacWanA6uBEYmevLh06ZIqc/jAqMWCEhhl+O6mB+QpQFm9++67TdeSk5MjTo9mtMCQ9TLkvOJBHH6AMYbyF486Gkk9IcQKV2sSEoC1a9eavsOTgy0A0Ajfc889ymNiDHPmzBmxa9cuk3cCXq4+ffqIuXPniiFDhoh3333X0XOFEbgbeObhw4fVR+P7779XWyI4eUQiBd4SpAfeHnR0xg+MJztWrlyptjLo2LGjqFatmgoHYyaonKBr167io48+EqtXrxY//PCD8qZpwIuG1XnwEFrT5uQlsXuuXx0aQScMAwodOAxHGA1Hjx4VscZP2uxkggGDcFjV2KhRI+VttHrscB8w3os4YYTBkLPmqeapRZqwQtJaJ9xo2bKl2vICW2DY4Xc7jy5duiiPJbbksIJtNGCURko0dTSSekKIFRpnhAQAHdXgwYNVh/jhhx+qJfsDBw5U12CkdejQQe3VBM8JXiE9/fTTyuuA38GgQYPEwoULxf79+8WmTZvUqzh0cHbA0MAofMmSJeL06dPqFZMVvHaB0QPDBfGho3z22WdF48aNRe3atWOqWxgdeA7iR6cFGfA8eBbgZbADeYKwW7ZsUfmBDtXqCYKcy5cvF0eOHFFyOvHoo4+KCxcuKA8VXlMVK1ZMv4btE86ePSueeuoptQ8cXmUin7t37+5o+Nnlrx8dWkGnC2MAZQFG4z//+U/x9ttvi1jjJ212MpUsWVIZEVr65s2bJ1577TVT3KVKlVJeOmxxcerUKRUHXoPD8/m73/1O/P3vf1d5ijKGePAdwIDZs2ePGDp0qKoT8Ghi7y83YCz/7W9/U2Wmffv2ysCCwb5hwwbx4osvqjj9gLqEPc2aNWsmpk+frvID8s2ZM0cZyUhXJERbRyOpJ4SkwHNWGiFEXxCArQ2wmg4rtPLmzatWPNptpYFJwpiwjNV0xhVa/fv3VxPbsXILqwsRFpO6nSZl41mYWB6LrTSM4H7E44TTxHKsChwxYoTaWgGrD4sWLSo7duyoVrbZ3YfVi1gxibwoUaKEfPPNN1U+YsWrBlYPYuUd8sRuKw0jTzzxhArz/vvvp7iGfEZatG0msMpw0KBBJv1YsctfLx3agW09kBdaeGxd4TVx/NNPP9XldVpViHwyrrz1kzY7mWbPnq10hjzGSs158+ap65s3b9bvw4pZrOJNSkrSt9JA3mFFIlafQt8os3imtnoRYDUjVowi7kaNGinduC0IMC5KwApixIl7EUfv3r3lnj17fC0I0BYtjB07Vk3ixypgbD/SoEEDOXPmTHnjxg3HfHUjFnXUq54Q4kUS/klpshFCrDRp0kTUrFkztEcnEUIISR/wtSYhhBBCSIigcUYIIYQQEiL4WpMQQgghJETQc0YIIYQQEiJonBFCCCGEhAgaZ4QQQgghIYLGGSGEEEJIiKBxRgghhBASImicEUIIIYSECBpnhBBCCCEhgsYZIYQQQkiIoHFGCCGEECLCw/8B02/RehM4ZM4AAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -3193,7 +3197,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 45, "metadata": {}, "outputs": [], "source": [ @@ -3202,13 +3206,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 46, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0995f27389524fb994389d2956016289", + "model_id": "f00d737907dc48f590a9bbbf0924ce2d", "version_major": 2, "version_minor": 0 }, @@ -3240,13 +3244,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 47, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2e1e3ade15d14e438d49439207cc1414", + "model_id": "6aff80f81c7a4a06bcf51393c38534ca", "version_major": 2, "version_minor": 0 }, @@ -3285,13 +3289,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 48, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3bc9aa68f4c04ddc8c073c38221f9faf", + "model_id": "505f57256f96471c88246c7a7e427584", "version_major": 2, "version_minor": 0 }, @@ -3328,13 +3332,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 49, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "46321b1511aa4c69bdfa8ab6b352f51d", + "model_id": "c75ca128f5b94f0f813c7e0f131da883", "version_major": 2, "version_minor": 0 }, @@ -3384,7 +3388,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "metadata": {}, "outputs": [ { @@ -3454,7 +3458,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 51, "metadata": {}, "outputs": [ { @@ -3537,7 +3541,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 52, "metadata": {}, "outputs": [ { @@ -3593,7 +3597,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 53, "metadata": {}, "outputs": [ { @@ -3602,7 +3606,7 @@ "text": [ "\n", "WARNING: no modified appropriately-coded values found for ['A', 'C'] in the first 100 reads. \n", - "Do you expect this file to contain these modifications? parse_bam is looking for ['A,0,a', 'CG,0,m'] but for ['A', 'C'] found only found [\"C+{'Z'}\", \"A+{'Y'}\"].\n", + "Do you expect this file to contain these modifications? parse_bam is looking for ['A,0,a', 'CG,0,m'] but for ['A', 'C'] found only found [\"A+{'Y'}\", \"C+{'Z'}\"].\n", "\n", "Consider passing only the motifs and mod codes (e.g. m,h,a) that you expect to be present in your file. \n", "You can use modkit adjust-mods --convert [OPTIONS] to update or consolidate mod codes.\n", @@ -3643,13 +3647,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 54, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3f141124ae754f0190a02ac4c29d1eab", + "model_id": "5d57377d6bd74ce2ad60e11459029d71", "version_major": 2, "version_minor": 0 }, @@ -3663,7 +3667,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "23392865b5964ad8a96a4f108cb3a221", + "model_id": "ea7de79d5fd144fc8fe6e331cf8bb9d2", "version_major": 2, "version_minor": 0 }, @@ -3680,8 +3684,9 @@ "" ] }, + "execution_count": 54, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" }, { "data": { @@ -3716,7 +3721,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 55, "metadata": {}, "outputs": [ { @@ -3732,8 +3737,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "\u001b[0;32m>\u001b[0m Converting Z to m\n", "\u001b[0;32m>\u001b[0m Converting Y to a\n", + "\u001b[0;32m>\u001b[0m Converting Z to m\n", "[modkit-core/src/modbam_util/subcommands.rs:774:9] &self.cpg = false\n", "\u001b[0;32m>\u001b[0m done, 1024 records processed\n" ] @@ -3755,7 +3760,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 56, "metadata": {}, "outputs": [ { @@ -3764,8 +3769,9 @@ "''" ] }, + "execution_count": 56, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ @@ -3775,21 +3781,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 57, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\n", - "WARNING: no modified appropriately-coded values found for [] in the first 100 reads. \n", - "Do you expect this file to contain these modifications? parse_bam is looking for ['A,0,a', 'CG,0,m'] but for [] found only found [].\n", - "\n", - "Consider passing only the motifs and mod codes (e.g. m,h,a) that you expect to be present in your file. \n", - "You can use modkit adjust-mods --convert [OPTIONS] to update or consolidate mod codes.\n", - "See https://github.com/nanoporetech/modkit/blob/master/book/src/advanced_usage.md\n", - " \n", "No specified number of cores requested. 10 available on machine, allocating all.\n", "Detected multiple motif contexts with modkit 0.6.x; running per-motif pileups and merging outputs to avoid mixed-motif empty output behavior.\n", "Modification threshold of 128.0 assumed to be for range 0-255. 128.0/255=0.5019607843137255 will be sent to modkit.\n" @@ -3816,13 +3814,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 58, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a41b60014d6443a69d635f36af2fc4e5", + "model_id": "daf9919c66324ff29405d517de62001e", "version_major": 2, "version_minor": 0 }, @@ -3836,7 +3834,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0a738ac82df24d4c96cee1c0ab080a8b", + "model_id": "5177cdbd97374edfb8f81a47203dfec5", "version_major": 2, "version_minor": 0 }, @@ -3853,8 +3851,9 @@ "" ] }, + "execution_count": 58, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" }, { "data": { @@ -3966,7 +3965,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -4000,7 +3999,7 @@ "type": "integer" } ], - "ref": "ec9290ff-b978-49c7-851d-1562312ca1fa", + "ref": "8110799a-da23-41df-b7d4-2149835f5a81", "rows": [ [ "1", @@ -4119,7 +4118,7 @@ "type": "float" } ], - "ref": "9d860709-80e3-4f7e-b0f0-57b002a32e41", + "ref": "7dc4e40d-39c4-4406-ae7a-0a7b3690b935", "rows": [ [ "0", @@ -4339,7 +4338,7 @@ "type": "float" } ], - "ref": "ed14f839-e17c-4773-a96d-bfb116989d36", + "ref": "b0342416-7c5c-4ff5-8b0c-26038eba4b89", "rows": [ [ "0", @@ -4660,7 +4659,7 @@ "type": "integer" } ], - "ref": "32009461-a166-45a7-8f70-c4f05c296546", + "ref": "d143eb08-c011-4f85-90bd-e66d308cefab", "rows": [ [ "0", @@ -4758,7 +4757,7 @@ "type": "float" } ], - "ref": "fb52a39f-8fd8-45b7-a9dc-bfe0f5a7762d", + "ref": "76449b52-614e-46d8-8a4e-3517e345b99c", "rows": [ [ "0", @@ -4847,16 +4846,16 @@ "import numpy as np\n", "import pandas as pd\n", "\n", - "# # If this notebook kernel already imported dimelo before local edits, reload the module.\n", - "# cluster = importlib.reload(cluster)\n", - "# required_kwargs = {\"return_feature_table\", \"scale_features\", \"return_scale_table\"}\n", - "# observed_kwargs = set(inspect.signature(cluster.read_window_feature_matrix).parameters)\n", - "# if not required_kwargs.issubset(observed_kwargs):\n", - "# raise RuntimeError(\n", - "# \"This notebook is using an older dimelo.cluster module. \"\n", - "# f\"Imported from: {cluster.__file__}. \"\n", - "# \"Restart the kernel or install this repo in editable mode with `python -m pip install -e .`.\"\n", - "# )\n", + "# If this notebook kernel already imported dimelo before local edits, reload the module.\n", + "cluster = importlib.reload(cluster)\n", + "required_kwargs = {\"return_feature_table\", \"scale_features\", \"return_scale_table\"}\n", + "observed_kwargs = set(inspect.signature(cluster.read_window_feature_matrix).parameters)\n", + "if not required_kwargs.issubset(observed_kwargs):\n", + " raise RuntimeError(\n", + " \"This notebook is using an older dimelo.cluster module. \"\n", + " f\"Imported from: {cluster.__file__}. \"\n", + " \"Restart the kernel or install this repo in editable mode with `python -m pip install -e .`.\"\n", + " )\n", "\n", "# Fixed window sizes for tutorial reproducibility.\n", "shared_window = 1000\n", @@ -4987,7 +4986,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -4997,8 +4996,9 @@ "Multi-motif reads used: on_target=2173, off_target=4030, total=6203\n", "Default feature matrix: 6203 reads x 31 features\n", "Rich feature matrix: 6203 reads x 108 features\n", - "K-means input: default feature matrix scaled inside read_window_feature_matrix(scale_features=True, family_weighting='equal_family')\n", - "Multi-motif cluster purity vs on/off labels: 0.730\n", + "K-means input for cluster labels: raw default feature matrix (legacy tutorial behavior)\n", + "Scaled default features are still computed for classifier/QC examples below.\n", + "Multi-motif cluster purity vs on/off labels: 0.807\n", "Default feature families\n" ] }, @@ -5022,7 +5022,7 @@ "type": "integer" } ], - "ref": "aa3bc707-96fd-448e-bd0e-45b4efec9cf6", + "ref": "6fbbfd98-4b6f-4847-a23b-e1b3222ad14f", "rows": [ [ "1", @@ -5136,7 +5136,7 @@ "type": "integer" } ], - "ref": "7b661996-a430-4d50-95c1-b78f2e5bfd16", + "ref": "27d9eb70-d64c-4006-9b78-a1b5f22e1109", "rows": [ [ "3", @@ -5283,7 +5283,7 @@ "type": "integer" } ], - "ref": "dcac67dd-a3b8-4cf1-bb7c-063a36691699", + "ref": "12cf3a50-d0de-4702-b54b-586da3d4761f", "rows": [ [ "2", @@ -5431,7 +5431,7 @@ "type": "float" } ], - "ref": "ac71e39c-51e6-48b7-b9ba-21c7573b5f22", + "ref": "8ac416db-f019-4d6d-995a-473831820e35", "rows": [ [ "0", @@ -5797,7 +5797,7 @@ "type": "float" } ], - "ref": "11ef1ccc-4dbe-408e-adac-bc88a12287be", + "ref": "03b0bc38-e805-44b6-a310-ef713790133c", "rows": [ [ "0", @@ -6133,7 +6133,7 @@ "type": "float" } ], - "ref": "cb79bb5a-733b-4c71-a78a-53e2668c24ee", + "ref": "5bc21322-43a2-4c49-8b99-b0090219bf1c", "rows": [ [ "0", @@ -6424,17 +6424,17 @@ "type": "integer" } ], - "ref": "6234c25b-65ec-4f24-9338-506ad502dc65", + "ref": "ec714ede-5002-4247-8a53-24b15f394b81", "rows": [ [ "0", - "3419", - "1062" + "3942", + "1112" ], [ "1", - "611", - "1111" + "88", + "1061" ] ], "shape": { @@ -6473,13 +6473,13 @@ " \n", " \n", " 0\n", - " 3419\n", - " 1062\n", + " 3942\n", + " 1112\n", " \n", " \n", " 1\n", - " 611\n", - " 1111\n", + " 88\n", + " 1061\n", " \n", " \n", "\n", @@ -6488,8 +6488,8 @@ "text/plain": [ "col_0 off_target on_target\n", "row_0 \n", - "0 3419 1062\n", - "1 611 1111" + "0 3942 1112\n", + "1 88 1061" ] }, "metadata": {}, @@ -6497,7 +6497,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -6677,7 +6677,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -6694,7 +6694,7 @@ "
" ] }, - "execution_count": 54, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, @@ -6762,7 +6762,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -6779,7 +6779,7 @@ "
" ] }, - "execution_count": 31, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, @@ -6858,7 +6858,7 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -6922,13 +6922,18 @@ "rawType": "str", "type": "string" }, + { + "name": "cluster_sort", + "rawType": "str", + "type": "string" + }, { "name": "chromosome_blocks", "rawType": "object", "type": "unknown" } ], - "ref": "43b0901f-29f2-4f7a-ae75-a25adb36634a", + "ref": "ed596b6c-f84a-4380-92cd-d9656efcbf0a", "rows": [ [ "0", @@ -6941,11 +6946,12 @@ "True", "source_bed_then_genomic", "max", + "natural", "[{'chrom': 'chr1', 'start_index': 0, 'end_index': 32, 'n_regions': 33}, {'chrom': 'chr2', 'start_index': 33, 'end_index': 35, 'n_regions': 3}, {'chrom': 'chr3', 'start_index': 36, 'end_index': 44, 'n_regions': 9}, {'chrom': 'chr5', 'start_index': 45, 'end_index': 50, 'n_regions': 6}, {'chrom': 'chr6', 'start_index': 51, 'end_index': 92, 'n_regions': 42}, {'chrom': 'chr7', 'start_index': 93, 'end_index': 104, 'n_regions': 12}, {'chrom': 'chr8', 'start_index': 105, 'end_index': 113, 'n_regions': 9}, {'chrom': 'chr9', 'start_index': 114, 'end_index': 122, 'n_regions': 9}, {'chrom': 'chr12', 'start_index': 123, 'end_index': 128, 'n_regions': 6}, {'chrom': 'chr14', 'start_index': 129, 'end_index': 143, 'n_regions': 15}, {'chrom': 'chr15', 'start_index': 144, 'end_index': 167, 'n_regions': 24}, {'chrom': 'chr16', 'start_index': 168, 'end_index': 197, 'n_regions': 30}, {'chrom': 'chr17', 'start_index': 198, 'end_index': 233, 'n_regions': 36}, {'chrom': 'chr19', 'start_index': 234, 'end_index': 254, 'n_regions': 21}, {'chrom': 'chr20', 'start_index': 255, 'end_index': 284, 'n_regions': 30}, {'chrom': 'chr21', 'start_index': 285, 'end_index': 290, 'n_regions': 6}, {'chrom': 'chrX', 'start_index': 291, 'end_index': 299, 'n_regions': 9}]" ] ], "shape": { - "columns": 10, + "columns": 11, "rows": 1 } }, @@ -6977,6 +6983,7 @@ " has_top_regions_table\n", " region_sort\n", " association_strength_aggregate\n", + " cluster_sort\n", " chromosome_blocks\n", " \n", " \n", @@ -6992,6 +6999,7 @@ " True\n", " source_bed_then_genomic\n", " max\n", + " natural\n", " [{'chrom': 'chr1', 'start_index': 0, 'end_inde...\n", " \n", " \n", @@ -7008,8 +7016,8 @@ " top_n_regions_per_cluster has_top_regions_table region_sort \\\n", "0 8 True source_bed_then_genomic \n", "\n", - " association_strength_aggregate \\\n", - "0 max \n", + " association_strength_aggregate cluster_sort \\\n", + "0 max natural \n", "\n", " chromosome_blocks \n", "0 [{'chrom': 'chr1', 'start_index': 0, 'end_inde... " @@ -7058,9 +7066,14 @@ "name": "source_label", "rawType": "str", "type": "string" + }, + { + "name": "strand_label", + "rawType": "str", + "type": "string" } ], - "ref": "80e653e8-84e8-456c-8355-64c2731f9543", + "ref": "d5632efe-6014-4d54-9878-2f24835a2478", "rows": [ [ "0", @@ -7068,7 +7081,8 @@ "chr1", "9169918", "9170236", - "on_target" + "on_target", + "+" ], [ "1", @@ -7076,7 +7090,8 @@ "chr1", "9169985", "9170303", - "on_target" + "on_target", + "+" ], [ "2", @@ -7084,7 +7099,8 @@ "chr1", "9169986", "9170302", - "on_target" + "on_target", + "-" ], [ "3", @@ -7092,7 +7108,8 @@ "chr1", "114358436", "114358754", - "on_target" + "on_target", + "+" ], [ "4", @@ -7100,11 +7117,12 @@ "chr1", "114358437", "114358753", - "on_target" + "on_target", + "-" ] ], "shape": { - "columns": 5, + "columns": 6, "rows": 5 } }, @@ -7132,6 +7150,7 @@ " start\n", " end\n", " source_label\n", + " strand_label\n", " \n", " \n", " \n", @@ -7142,6 +7161,7 @@ " 9169918\n", " 9170236\n", " on_target\n", + " +\n", " \n", " \n", " 1\n", @@ -7150,6 +7170,7 @@ " 9169985\n", " 9170303\n", " on_target\n", + " +\n", " \n", " \n", " 2\n", @@ -7158,6 +7179,7 @@ " 9169986\n", " 9170302\n", " on_target\n", + " -\n", " \n", " \n", " 3\n", @@ -7166,6 +7188,7 @@ " 114358436\n", " 114358754\n", " on_target\n", + " +\n", " \n", " \n", " 4\n", @@ -7174,18 +7197,26 @@ " 114358437\n", " 114358753\n", " on_target\n", + " -\n", " \n", " \n", "\n", "" ], "text/plain": [ - " region_id chrom start end source_label\n", - "0 chr1:9169918-9170236:+ chr1 9169918 9170236 on_target\n", - "1 chr1:9169985-9170303:+ chr1 9169985 9170303 on_target\n", - "2 chr1:9169986-9170302:- chr1 9169986 9170302 on_target\n", - "3 chr1:114358436-114358754:+ chr1 114358436 114358754 on_target\n", - "4 chr1:114358437-114358753:- chr1 114358437 114358753 on_target" + " region_id chrom start end source_label \\\n", + "0 chr1:9169918-9170236:+ chr1 9169918 9170236 on_target \n", + "1 chr1:9169985-9170303:+ chr1 9169985 9170303 on_target \n", + "2 chr1:9169986-9170302:- chr1 9169986 9170302 on_target \n", + "3 chr1:114358436-114358754:+ chr1 114358436 114358754 on_target \n", + "4 chr1:114358437-114358753:- chr1 114358437 114358753 on_target \n", + "\n", + " strand_label \n", + "0 + \n", + "1 + \n", + "2 - \n", + "3 + \n", + "4 - " ] }, "metadata": {}, @@ -7213,7 +7244,7 @@ "type": "integer" } ], - "ref": "55e26722-aa74-4038-baba-5476528d51a8", + "ref": "ba7bf635-1ba7-44d2-b611-907bfe0ba558", "rows": [ [ "off_target", @@ -7332,7 +7363,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -7400,146 +7431,146 @@ "type": "integer" } ], - "ref": "fead3234-1b1f-4e19-8989-6d81a7b7e496", + "ref": "c954f3a2-a1dd-4631-8242-e34cff9a25a1", "rows": [ [ "0", - "chr14:17377273-17377423:+", - "chr14", - "17377273", - "17377423", - "+", + "chr12:57871837-57871987:-", + "chr12", + "57871837", + "57871987", + "-", "0", - "23", + "24", "1.0", - "23", + "24", "1.0", "1" ], [ "1", - "chr14:17377341-17377423:+", - "chr14", - "17377341", - "17377423", - "+", + "chr12:57871885-57871987:-", + "chr12", + "57871885", + "57871987", + "-", "0", - "23", + "24", "1.0", - "23", + "24", "1.0", "2" ], [ "2", - "chr15:38668760-38668867:+", - "chr15", - "38668760", - "38668867", - "+", + "chr12:57875753-57875855:-", + "chr12", + "57875753", + "57875855", + "-", "0", - "19", + "25", "1.0", - "19", + "25", "1.0", "3" ], [ "3", - "chr15:38668760-38668909:+", - "chr15", - "38668760", - "38668909", - "+", + "chr12:57875753-57875903:-", + "chr12", + "57875753", + "57875903", + "-", "0", - "19", + "25", "1.0", - "19", + "25", "1.0", "4" ], [ "4", - "chr16:61261359-61261509:+", - "chr16", - "61261359", - "61261509", + "chr14:17377273-17377423:+", + "chr14", + "17377273", + "17377423", "+", "0", - "18", + "23", "1.0", - "18", + "23", "1.0", "5" ], [ "5", - "chr16:61261438-61261509:+", - "chr16", - "61261438", - "61261509", + "chr14:17377341-17377423:+", + "chr14", + "17377341", + "17377423", "+", "0", - "18", + "23", "1.0", - "18", + "23", "1.0", "6" ], [ "6", - "chr16:61261439-61261509:-", - "chr16", - "61261439", - "61261509", - "-", + "chr14:17381209-17381291:+", + "chr14", + "17381209", + "17381291", + "+", "0", - "18", + "19", "1.0", - "18", + "19", "1.0", "7" ], [ "7", - "chr17:44334564-44334713:-", - "chr17", - "44334564", - "44334713", + "chr15:38664850-38665000:-", + "chr15", + "38664850", + "38665000", "-", "0", - "10", + "22", "1.0", - "10", + "22", "1.0", "8" ], [ "8", - "chr17:45989477-45989793:-", - "chr17", - "45989477", - "45989793", - "-", + "chr9:145236510-145236828:+", + "chr9", + "145236510", + "145236828", + "+", "1", - "17", - "0.9444444444444444", - "18", - "0.9444444444444444", + "19", + "0.9047619047619048", + "21", + "0.9047619047619048", "1" ], [ "9", - "chr16:4281324-4281640:+", - "chr16", - "4281324", - "4281640", - "+", + "chr9:145236511-145236827:-", + "chr9", + "145236511", + "145236827", + "-", "1", - "22", - "0.9166666666666666", - "24", - "0.9166666666666666", + "19", + "0.9047619047619048", + "21", + "0.9047619047619048", "2" ] ], @@ -7583,142 +7614,142 @@ " \n", " \n", " 0\n", - " chr14:17377273-17377423:+\n", - " chr14\n", - " 17377273\n", - " 17377423\n", - " +\n", + " chr12:57871837-57871987:-\n", + " chr12\n", + " 57871837\n", + " 57871987\n", + " -\n", " 0\n", - " 23\n", + " 24\n", " 1.000000\n", - " 23\n", + " 24\n", " 1.000000\n", " 1\n", " \n", " \n", " 1\n", - " chr14:17377341-17377423:+\n", - " chr14\n", - " 17377341\n", - " 17377423\n", - " +\n", + " chr12:57871885-57871987:-\n", + " chr12\n", + " 57871885\n", + " 57871987\n", + " -\n", " 0\n", - " 23\n", + " 24\n", " 1.000000\n", - " 23\n", + " 24\n", " 1.000000\n", " 2\n", " \n", " \n", " 2\n", - " chr15:38668760-38668867:+\n", - " chr15\n", - " 38668760\n", - " 38668867\n", - " +\n", + " chr12:57875753-57875855:-\n", + " chr12\n", + " 57875753\n", + " 57875855\n", + " -\n", " 0\n", - " 19\n", + " 25\n", " 1.000000\n", - " 19\n", + " 25\n", " 1.000000\n", " 3\n", " \n", " \n", " 3\n", - " chr15:38668760-38668909:+\n", - " chr15\n", - " 38668760\n", - " 38668909\n", - " +\n", + " chr12:57875753-57875903:-\n", + " chr12\n", + " 57875753\n", + " 57875903\n", + " -\n", " 0\n", - " 19\n", + " 25\n", " 1.000000\n", - " 19\n", + " 25\n", " 1.000000\n", " 4\n", " \n", " \n", " 4\n", - " chr16:61261359-61261509:+\n", - " chr16\n", - " 61261359\n", - " 61261509\n", + " chr14:17377273-17377423:+\n", + " chr14\n", + " 17377273\n", + " 17377423\n", " +\n", " 0\n", - " 18\n", + " 23\n", " 1.000000\n", - " 18\n", + " 23\n", " 1.000000\n", " 5\n", " \n", " \n", " 5\n", - " chr16:61261438-61261509:+\n", - " chr16\n", - " 61261438\n", - " 61261509\n", + " chr14:17377341-17377423:+\n", + " chr14\n", + " 17377341\n", + " 17377423\n", " +\n", " 0\n", - " 18\n", + " 23\n", " 1.000000\n", - " 18\n", + " 23\n", " 1.000000\n", " 6\n", " \n", " \n", " 6\n", - " chr16:61261439-61261509:-\n", - " chr16\n", - " 61261439\n", - " 61261509\n", - " -\n", + " chr14:17381209-17381291:+\n", + " chr14\n", + " 17381209\n", + " 17381291\n", + " +\n", " 0\n", - " 18\n", + " 19\n", " 1.000000\n", - " 18\n", + " 19\n", " 1.000000\n", " 7\n", " \n", " \n", " 7\n", - " chr17:44334564-44334713:-\n", - " chr17\n", - " 44334564\n", - " 44334713\n", + " chr15:38664850-38665000:-\n", + " chr15\n", + " 38664850\n", + " 38665000\n", " -\n", " 0\n", - " 10\n", + " 22\n", " 1.000000\n", - " 10\n", + " 22\n", " 1.000000\n", " 8\n", " \n", " \n", " 8\n", - " chr17:45989477-45989793:-\n", - " chr17\n", - " 45989477\n", - " 45989793\n", - " -\n", + " chr9:145236510-145236828:+\n", + " chr9\n", + " 145236510\n", + " 145236828\n", + " +\n", " 1\n", - " 17\n", - " 0.944444\n", - " 18\n", - " 0.944444\n", + " 19\n", + " 0.904762\n", + " 21\n", + " 0.904762\n", " 1\n", " \n", " \n", " 9\n", - " chr16:4281324-4281640:+\n", - " chr16\n", - " 4281324\n", - " 4281640\n", - " +\n", + " chr9:145236511-145236827:-\n", + " chr9\n", + " 145236511\n", + " 145236827\n", + " -\n", " 1\n", - " 22\n", - " 0.916667\n", - " 24\n", - " 0.916667\n", + " 19\n", + " 0.904762\n", + " 21\n", + " 0.904762\n", " 2\n", " \n", " \n", @@ -7726,32 +7757,32 @@ "" ], "text/plain": [ - " region_id chrom start end strand cluster count \\\n", - "0 chr14:17377273-17377423:+ chr14 17377273 17377423 + 0 23 \n", - "1 chr14:17377341-17377423:+ chr14 17377341 17377423 + 0 23 \n", - "2 chr15:38668760-38668867:+ chr15 38668760 38668867 + 0 19 \n", - "3 chr15:38668760-38668909:+ chr15 38668760 38668909 + 0 19 \n", - "4 chr16:61261359-61261509:+ chr16 61261359 61261509 + 0 18 \n", - "5 chr16:61261438-61261509:+ chr16 61261438 61261509 + 0 18 \n", - "6 chr16:61261439-61261509:- chr16 61261439 61261509 - 0 18 \n", - "7 chr17:44334564-44334713:- chr17 44334564 44334713 - 0 10 \n", - "8 chr17:45989477-45989793:- chr17 45989477 45989793 - 1 17 \n", - "9 chr16:4281324-4281640:+ chr16 4281324 4281640 + 1 22 \n", + " region_id chrom start end strand cluster \\\n", + "0 chr12:57871837-57871987:- chr12 57871837 57871987 - 0 \n", + "1 chr12:57871885-57871987:- chr12 57871885 57871987 - 0 \n", + "2 chr12:57875753-57875855:- chr12 57875753 57875855 - 0 \n", + "3 chr12:57875753-57875903:- chr12 57875753 57875903 - 0 \n", + "4 chr14:17377273-17377423:+ chr14 17377273 17377423 + 0 \n", + "5 chr14:17377341-17377423:+ chr14 17377341 17377423 + 0 \n", + "6 chr14:17381209-17381291:+ chr14 17381209 17381291 + 0 \n", + "7 chr15:38664850-38665000:- chr15 38664850 38665000 - 0 \n", + "8 chr9:145236510-145236828:+ chr9 145236510 145236828 + 1 \n", + "9 chr9:145236511-145236827:- chr9 145236511 145236827 - 1 \n", "\n", - " fraction total_reads value rank \n", - "0 1.000000 23 1.000000 1 \n", - "1 1.000000 23 1.000000 2 \n", - "2 1.000000 19 1.000000 3 \n", - "3 1.000000 19 1.000000 4 \n", - "4 1.000000 18 1.000000 5 \n", - "5 1.000000 18 1.000000 6 \n", - "6 1.000000 18 1.000000 7 \n", - "7 1.000000 10 1.000000 8 \n", - "8 0.944444 18 0.944444 1 \n", - "9 0.916667 24 0.916667 2 " + " count fraction total_reads value rank \n", + "0 24 1.000000 24 1.000000 1 \n", + "1 24 1.000000 24 1.000000 2 \n", + "2 25 1.000000 25 1.000000 3 \n", + "3 25 1.000000 25 1.000000 4 \n", + "4 23 1.000000 23 1.000000 5 \n", + "5 23 1.000000 23 1.000000 6 \n", + "6 19 1.000000 19 1.000000 7 \n", + "7 22 1.000000 22 1.000000 8 \n", + "8 19 0.904762 21 0.904762 1 \n", + "9 19 0.904762 21 0.904762 2 " ] }, - "execution_count": 56, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -7775,7 +7806,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -7791,7 +7822,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -7883,14 +7914,14 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -7919,6 +7950,7 @@ " \"strand_label\": {\"+\": \"#4C78A8\", \"-\": \"#F58518\", \".\": \"#999999\", \"unknown\": \"#999999\"},\n", " },\n", " cluster_sort=cluster_sort_mode,\n", + " region_sort=['cluster_fraction','genomic'],\n", " group_region_labels=True,\n", " group_label_columns=[\"source_label\", \"chrom\"]\n", ")\n", @@ -7946,7 +7978,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -8107,7 +8139,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -8207,4 +8239,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 6399486..dd86428 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -1814,11 +1814,20 @@ def test_plot_read_cluster_region_association_heatmap_matplotlib_supports_multip if axis is not ax and axis.get_position().x1 <= main_pos.x0 ] assert len(left_side_axes) == 2 - assert sorted(axis.get_title() for axis in left_side_axes) == [ + assert sorted(axis.get_xlabel() for axis in left_side_axes) == [ "Source bed", "Strand", ] assert max(axis.get_position().x1 for axis in left_side_axes) <= main_pos.x0 + fig.canvas.draw() + legend_x0 = [ + legend.get_window_extent(fig.canvas.get_renderer()) + .transformed(fig.transFigure.inverted()) + .x0 + for legend in fig.legends + ] + assert len(legend_x0) == 2 + assert max(legend_x0) - min(legend_x0) < 0.01 def test_plot_read_cluster_region_association_heatmap_preserves_annotations_with_cluster_sort_override():