bonesistools 1.2.8__tar.gz → 1.2.9__tar.gz

{bonesistools-1.2.8 → bonesistools-1.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bonesistools
-Version: 1.2.8
+Version: 1.2.9
 Summary: Bioinformatics toolkit for upstream and downstream analyses around the BoNesis framework
 Project-URL: Repository, https://github.com/bnediction/bonesistools
 Author: Théo Roncalli

{bonesistools-1.2.8 → bonesistools-1.2.9}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 [project]
 name = "bonesistools"
 description = "Bioinformatics toolkit for upstream and downstream analyses around the BoNesis framework"
-version = "1.2.8"
+version = "1.2.9"
 license = "CECILL-2.1"
 credits = ["BNeDiction", "PEPR Santé Numérique 2030"]
 authors = [

{bonesistools-1.2.8 → bonesistools-1.2.9}/src/bonesistools/sctools/datasets/_geo.py

@@ -32,6 +32,8 @@ _GEO_FTP_BASE = "https://ftp.ncbi.nlm.nih.gov/geo"
 _GSM_PATTERN = re.compile(r"^GSM[0-9]+$")
 _DOWNLOAD_CHUNK_SIZE = 1024 * 1024
 _DOWNLOAD_HEADERS = {"User-Agent": "bonesistools"}
+_DOWNLOAD_LABEL_WIDTH = len("barcodes.tsv.gz")
+_DOWNLOAD_SPEED_WIDTH = len("999.99K/s")
 _SUPPLEMENTARY_SUFFIXES = (
     "_matrix.mtx.gz",
     "_barcodes.tsv.gz",
@@ -316,10 +318,12 @@ def _print_download_progress(
 ) -> None:
 
     speed = downloaded / elapsed if elapsed > 0 else 0
+    label = _format_download_label(filename)
+    speed_label = f"{_format_bytes(speed)}/s"
     if total is None or total == 0:
         print(
-            f"\rdownloading {filename} {_format_bytes(downloaded):>8} "
-            f"{_format_bytes(speed)}/s",
+            f"\r{label} {_format_bytes(downloaded):>8} "
+            f"{speed_label:>{_DOWNLOAD_SPEED_WIDTH}}",
             end="",
             file=file,
             flush=True,
@@ -334,8 +338,8 @@ def _print_download_progress(
     else:
         bar = "=" * filled + ">" + "." * max(0, width - filled - 1)
     print(
-        f"\rdownloading {filename} {percent:3d}%[{bar}] "
-        f"{_format_bytes(downloaded):>8} {_format_bytes(speed)}/s "
+        f"\r{label} {percent:3d}%[{bar}] "
+        f"{_format_bytes(downloaded):>8} {speed_label:>{_DOWNLOAD_SPEED_WIDTH}} "
         f"in {_format_duration(elapsed)}",
         end="",
         file=file,
@@ -343,6 +347,11 @@ def _print_download_progress(
     )
 
 
+def _format_download_label(filename: str) -> str:
+
+    return f"downloading {filename:<{_DOWNLOAD_LABEL_WIDTH}}"
+
+
 def _format_bytes(size: float) -> str:
 
     units = ("B", "K", "M", "G", "T")
@@ -354,7 +363,7 @@ def _format_bytes(size: float) -> str:
             return f"{value:.2f}{unit}"
         value /= 1024
 
-    return f"{value:.2f}T"
+    return f"{value:.2f}T"  # pragma: no cover - defensive fallback
 
 
 def _format_duration(seconds: float) -> str:
@@ -421,7 +430,11 @@ def _read_10x_mtx(
     feature_path: Path,
 ) -> AnnData:
 
-    counts = sparse.csr_matrix(scipy.io.mmread(str(matrix_path)))
+    try:
+        matrix = scipy.io.mmread(str(matrix_path), spmatrix=True)
+    except TypeError:
+        matrix = scipy.io.mmread(str(matrix_path))
+    counts = sparse.csr_matrix(matrix)
     obs_names = pd.Index(
         _read_table(barcodes_path).iloc[:, 0].astype(str),
         name=None,

{bonesistools-1.2.8 → bonesistools-1.2.9}/src/bonesistools/sctools/datasets/_registry.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 import os
 import shutil
 from pathlib import Path
-from typing import Callable, Dict, List
+from typing import Any, Callable, Dict, Iterable, List, Optional
 
 import pandas as pd
 from anndata import AnnData
@@ -25,6 +25,8 @@ _DATASET_LOADERS: Dict[str, _DatasetLoader] = {
     "nestorowa": _load_nestorowa,
     "pbmc3k": _load_pbmc3k,
 }
+_OBSERVATION_COUNT_FIELDS = ("cells", "barcodes", "observations")
+_FEATURE_COUNT_FIELDS = ("genes", "peaks")
 
 
 def load(
@@ -58,11 +60,13 @@ def load(
     dataset_name = _as_dataset_name(name)
     quiet = _as_boolean(quiet, "quiet")
     loader = _DATASET_LOADERS[dataset_name]
-
-    return loader(
+    adata = loader(
         _dataset_cache_dir(dataset_name),
         quiet,
     )
+    _validate_dataset_shape(dataset_name, adata)
+
+    return adata
 
 
 def info(name: str) -> Dict[str, object]:
@@ -159,6 +163,84 @@ def _as_dataset_name(name: str) -> str:
     return dataset_name
 
 
+def _validate_dataset_shape(
+    name: str,
+    adata: AnnData,
+) -> None:
+
+    metadata = _DATASETS[name]
+    expected_observations = _expected_count(
+        metadata,
+        _OBSERVATION_COUNT_FIELDS,
+    )
+    expected_features = _expected_feature_count(metadata)
+    errors = []
+    if expected_observations is not None and adata.n_obs != expected_observations:
+        errors.append(
+            f"expected {expected_observations} observations but found "
+            f"{adata.n_obs}"
+        )
+    if expected_features is not None and adata.n_vars != expected_features:
+        errors.append(
+            f"expected {expected_features} features but found {adata.n_vars}"
+        )
+    if len(errors) == 0:
+        return
+
+    details = "; ".join(errors)
+    raise ValueError(
+        f"invalid cached dataset {name!r}: {details}. "
+        f"Clear cached files with bt.sct.datasets.clear({name!r}) and retry."
+    )
+
+
+def _expected_count(
+    metadata: Dict[str, Any],
+    fields: Iterable[str],
+) -> Optional[int]:
+
+    for field in fields:
+        if field in metadata:
+            return _metadata_count(metadata[field], field)
+
+    return None
+
+
+def _expected_feature_count(metadata: Dict[str, Any]) -> Optional[int]:
+
+    if "features" in metadata:
+        return _metadata_count(metadata["features"], "features")
+
+    counts = [
+        _metadata_count(metadata[field], field)
+        for field in _FEATURE_COUNT_FIELDS
+        if field in metadata
+    ]
+    if len(counts) == 0:
+        return None
+
+    return sum(counts)
+
+
+def _metadata_count(
+    value: object,
+    field: str,
+) -> int:
+
+    if not isinstance(value, int) or isinstance(value, bool):
+        raise TypeError(
+            f"invalid dataset metadata for '{field}': expected {int} "
+            f"but received {type(value)}"
+        )
+    if value < 0:
+        raise ValueError(
+            f"invalid dataset metadata for '{field}': expected non-negative "
+            f"value but received {value!r}"
+        )
+
+    return value
+
+
 def _dataset_cache_root() -> Path:
 
     root = Path(os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache"))

{bonesistools-1.2.8 → bonesistools-1.2.9}/src/bonesistools/sctools/datasets/datasets.json

@@ -7,7 +7,7 @@
     "cells": 1656,
     "genes": 46078,
     "source": "NCBI GEO (GSE81682)",
-    "license": "not specified",
+    "license": "Not specified",
     "url": "https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE81682",
     "citation": "Nestorowa et al. (2016). A single-cell resolution map of mouse hematopoietic stem and progenitor cell differentiation. Blood, 128(8), e20-e31."
   },

{bonesistools-1.2.8 → bonesistools-1.2.9}/src/bonesistools/sctools/plotting/_barplot.py

@@ -30,12 +30,13 @@ from .._typing import ScData, anndata_or_mudata_checker
 from ._colors import QUALITATIVE_COLORS, generate_colormap
 from ._utils import (
     _resolve_legend_argument,
+    apply_legend,
     colormap_colors,
     colors_from_uns,
-    figure_from_axes,
     qualitative_color_values,
+    save_figure,
     set_axis_label,
-    set_window_title,
+    set_title,
 )
 
 Colors = Union[
@@ -48,94 +49,6 @@ Colors = Union[
 Orientation = Literal["vertical", "horizontal"]
 
 
-def __ordered_values(
-    series: pd.Series,
-    order: Optional[Sequence[object]],
-) -> Sequence[object]:
-
-    if order is not None:
-        return list(order)
-
-    if isinstance(series.dtype, pd.CategoricalDtype):
-        return list(series.cat.categories)
-
-    return list(pd.unique(series.dropna()))
-
-
-def __index_from_values(values: Sequence[object], name: str) -> pd.Index:
-
-    return pd.Index(np.asarray(list(values), dtype=object), name=name)
-
-
-def __normalize_colors(
-    colors: Optional[Colors],
-    values: Sequence[object],
-    scdata: ScData,
-    uns_key: str,
-) -> Sequence[object]:
-
-    if colors is None:
-        colors = colors_from_uns(scdata, uns_key, values)
-
-    if colors is None:
-        colors = qualitative_color_values(
-            len(values),
-            QUALITATIVE_COLORS,
-            generate_colormap,
-        )
-
-    if isinstance(colors, ListedColormap):
-        colors = colormap_colors(colors)
-
-    if isinstance(colors, str):
-        colors = plt.get_cmap(colors)
-
-    if isinstance(colors, Colormap):
-        positions = np.linspace(0, 1, len(values))
-        return cast(Sequence[object], colors(positions))
-
-    if isinstance(colors, MappingABC):
-        missing = [value for value in values if value not in colors]
-
-        if missing:
-            raise KeyError(f"missing colors for values: {missing!r}")
-
-        return [colors[value] for value in values]
-
-    color_values = list(cast(Sequence[object], colors))
-
-    if len(color_values) < len(values):
-        raise ValueError(
-            f"invalid argument value for 'colors': "
-            f"expected at least {len(values)} colors but received {len(color_values)}"
-        )
-
-    return color_values[0 : len(values)]
-
-
-def __apply_ticklabel_colors(
-    ax: Axes,
-    colors: Optional[Mapping[object, object]],
-    orientation: Orientation,
-) -> None:
-
-    if colors is None:
-        return None
-
-    ticklabels = (
-        ax.get_xticklabels() if orientation == "vertical" else ax.get_yticklabels()
-    )
-
-    for ticklabel in ticklabels:
-        value = ticklabel.get_text()
-
-        if value in colors:
-            ticklabel.set_color(cast(Any, colors[value]))
-            ticklabel.set_fontweight("bold")
-
-    return None
-
-
 @overload
 def composition(
     scdata: ScData,
@@ -317,12 +230,66 @@ def composition(
 
     legend = _resolve_legend_argument(legend, kwargs)
 
+    table, groups, segments = __composition_table(
+        scdata,
+        obs=obs,
+        groupby=groupby,
+        obs_order=obs_order,
+        group_order=group_order,
+        dropna=dropna,
+        normalize=normalize,
+    )
+    color_values = __normalize_colors(colors, segments, scdata, obs)
+    fig, ax = __composition_figure(ax, kwargs)
+
+    bar_kwargs = kwargs["bar"] if "bar" in kwargs else {}
+    table.plot(
+        kind="bar" if orientation == "vertical" else "barh",
+        stacked=True,
+        width=width,
+        color=color_values,
+        ax=ax,
+        **bar_kwargs,
+    )
+
+    __set_composition_axes(
+        ax,
+        normalize=normalize,
+        percent=percent,
+        orientation=orientation,
+        xlabel=xlabel,
+        ylabel=ylabel,
+        kwargs=kwargs,
+    )
+
+    if group_colors is None:
+        group_colors = colors_from_uns(scdata, groupby, groups)
+    __apply_ticklabel_colors(ax, group_colors, orientation)
+    set_title(fig, ax, title)
+    apply_legend(ax, legend, remove=True)
+
+    if save_figure(fig, outfile):
+        return None
+
+    return fig, ax
+
+
+def __composition_table(
+    scdata: ScData,
+    *,
+    obs: str,
+    groupby: str,
+    obs_order: Optional[Sequence[object]],
+    group_order: Optional[Sequence[object]],
+    dropna: bool,
+    normalize: bool,
+) -> Tuple[pd.DataFrame, Sequence[object], Sequence[object]]:
+
     data = scdata.obs[[groupby, obs]]
     data = data.dropna() if dropna else data
 
     groups = __ordered_values(scdata.obs[groupby], group_order)
     segments = __ordered_values(scdata.obs[obs], obs_order)
-
     counts = pd.crosstab(data[groupby], data[obs])
     counts = counts.reindex(
         index=__index_from_values(groups, groupby),
@@ -330,38 +297,43 @@ def composition(
         fill_value=0,
     )
 
-    if normalize:
-        totals = counts.sum(axis=1)
-        empty_groups = list(totals[totals == 0].index)
+    if not normalize:
+        return counts, groups, segments
 
-        if empty_groups:
-            raise ValueError(
-                f"cannot normalize composition for empty groups: {empty_groups!r}"
-            )
+    totals = counts.sum(axis=1)
+    empty_groups = list(totals[totals == 0].index)
+    if empty_groups:
+        raise ValueError(
+            f"cannot normalize composition for empty groups: {empty_groups!r}"
+        )
+    return counts.div(totals, axis=0), groups, segments
 
-        table = counts.div(totals, axis=0)
-    else:
-        table = counts
 
-    color_values = __normalize_colors(colors, segments, scdata, obs)
+def __composition_figure(
+    ax: Optional[Axes],
+    kwargs: Mapping[str, Any],
+) -> Tuple[Figure, Axes]:
 
-    if ax is None:
-        fig = plt.figure()
-        ax = fig.subplots()
-        fig.set_figheight(kwargs["figheight"] if "figheight" in kwargs else 3)
-        fig.set_figwidth(kwargs["figwidth"] if "figwidth" in kwargs else 6)
-    else:
-        fig = figure_from_axes(ax)
+    if ax is not None:
+        return cast(Figure, ax.figure), ax
 
-    bar_kwargs = kwargs["bar"] if "bar" in kwargs else {}
-    table.plot(
-        kind="bar" if orientation == "vertical" else "barh",
-        stacked=True,
-        width=width,
-        color=color_values,
-        ax=ax,
-        **bar_kwargs,
-    )
+    fig = plt.figure()
+    ax = fig.subplots()
+    fig.set_figheight(kwargs["figheight"] if "figheight" in kwargs else 3)
+    fig.set_figwidth(kwargs["figwidth"] if "figwidth" in kwargs else 6)
+    return fig, ax
+
+
+def __set_composition_axes(
+    ax: Axes,
+    *,
+    normalize: bool,
+    percent: bool,
+    orientation: Orientation,
+    xlabel: Optional[Union[str, Mapping[str, Any]]],
+    ylabel: Optional[Union[str, Mapping[str, Any]]],
+    kwargs: Mapping[str, Any],
+) -> None:
 
     set_axis_label(ax, "xlabel", xlabel)
     set_axis_label(ax, "ylabel", ylabel)
@@ -396,36 +368,92 @@ def composition(
     )
     for ticklabel in ticklabels:
         ticklabel.set_rotation(rotation)
+    return None
 
-    if group_colors is None:
-        group_colors = colors_from_uns(scdata, groupby, groups)
-    __apply_ticklabel_colors(ax, group_colors, orientation)
 
-    if title:
-        if isinstance(title, str):
-            set_window_title(fig, title)
-            ax.set_title(title)
-        elif isinstance(title, dict):
-            set_window_title(fig, title["label"])
-            ax.set_title(**title)
-        else:
-            raise TypeError(
-                f"unsupported argument type for 'title': "
-                f"expected {str} or {dict} but received {type(title)}"
-            )
-
-    existing_legend = ax.get_legend()
-
-    if legend is True:
-        ax.legend()
-    elif legend is not False:
-        ax.legend(**legend)
-    elif existing_legend is not None:
-        existing_legend.remove()
-
-    if outfile:
-        plt.savefig(outfile, bbox_inches="tight")
-        plt.close(fig)
+def __ordered_values(
+    series: pd.Series,
+    order: Optional[Sequence[object]],
+) -> Sequence[object]:
+
+    if order is not None:
+        return list(order)
+
+    if isinstance(series.dtype, pd.CategoricalDtype):
+        return list(series.cat.categories)
+
+    return list(pd.unique(series.dropna()))
+
+
+def __index_from_values(values: Sequence[object], name: str) -> pd.Index:
+
+    return pd.Index(np.asarray(list(values), dtype=object), name=name)
+
+
+def __normalize_colors(
+    colors: Optional[Colors],
+    values: Sequence[object],
+    scdata: ScData,
+    uns_key: str,
+) -> Sequence[object]:
+
+    if colors is None:
+        colors = colors_from_uns(scdata, uns_key, values)
+
+    if colors is None:
+        colors = qualitative_color_values(
+            len(values),
+            QUALITATIVE_COLORS,
+            generate_colormap,
+        )
+
+    if isinstance(colors, ListedColormap):
+        colors = colormap_colors(colors)
+
+    if isinstance(colors, str):
+        colors = plt.get_cmap(colors)
+
+    if isinstance(colors, Colormap):
+        positions = np.linspace(0, 1, len(values))
+        return cast(Sequence[object], colors(positions))
+
+    if isinstance(colors, MappingABC):
+        missing = [value for value in values if value not in colors]
+
+        if missing:
+            raise KeyError(f"missing colors for values: {missing!r}")
+
+        return [colors[value] for value in values]
+
+    color_values = list(cast(Sequence[object], colors))
+
+    if len(color_values) < len(values):
+        raise ValueError(
+            f"invalid argument value for 'colors': "
+            f"expected at least {len(values)} colors but received {len(color_values)}"
+        )
+
+    return color_values[0 : len(values)]
+
+
+def __apply_ticklabel_colors(
+    ax: Axes,
+    colors: Optional[Mapping[object, object]],
+    orientation: Orientation,
+) -> None:
+
+    if colors is None:
         return None
 
-    return fig, ax
+    ticklabels = (
+        ax.get_xticklabels() if orientation == "vertical" else ax.get_yticklabels()
+    )
+
+    for ticklabel in ticklabels:
+        value = ticklabel.get_text()
+
+        if value in colors:
+            ticklabel.set_color(cast(Any, colors[value]))
+            ticklabel.set_fontweight("bold")
+
+    return None