vima-spatial 0.2.3__tar.gz → 0.2.4__tar.gz

{vima_spatial-0.2.3 → vima_spatial-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vima-spatial
-Version: 0.2.3
+Version: 0.2.4
 Summary: variational inference-based microniche analysis
 Home-page: https://github.com/yakirr/vima
 Author: Yakir Reshef

{vima_spatial-0.2.3 → vima_spatial-0.2.4}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = vima-spatial
-version = 0.2.3
+version = 0.2.4
 author = Yakir Reshef
 author_email = yreshef@broadinstitute.org
 description = variational inference-based microniche analysis

{vima_spatial-0.2.3 → vima_spatial-0.2.4}/src/vima/__init__.py

@@ -1,3 +1,4 @@
+from ._settings import settings, Verbosity
 from . import data as d
 from . import cc
 from . import train as t
@@ -7,12 +8,14 @@ from . import models
 
 from .data.patchcollection import PatchCollection
 from .data.samples import read_samples, reindex_by_sid
+from .data.download import download_zenodo
 from .train.training import train, fit, set_seed
 from .cc import latentreps, association, compute_mams
 from .fingerprints import Fingerprints
 from .patchfeatures import cell_type_counts, expression_profiles, test_features
 
-__all__ = ['d', 'cc', 't', 'pp', 'v', 'models',
-           'PatchCollection', 'read_samples', 'reindex_by_sid',
+__all__ = ['settings', 'Verbosity',
+           'd', 'cc', 't', 'pp', 'v', 'models',
+           'PatchCollection', 'read_samples', 'reindex_by_sid', 'download_zenodo',
            'train', 'fit', 'set_seed', 'latentreps', 'association', 'compute_mams',
            'Fingerprints', 'cc', 'cell_type_counts', 'expression_profiles', 'test_features']

vima_spatial-0.2.4/src/vima/_settings.py

@@ -0,0 +1,200 @@
+"""Unified output control for vima.
+
+All informational output in the package flows through a single ``logging``
+logger (``vima._settings.logger``, named ``"vima"``) and a single progress-bar
+helper (``settings.progress``). User-facing controls live on the module-level
+``settings`` object, exposed as ``vima.settings``.
+
+Three independent knobs:
+
+* ``settings.verbosity`` -- how much informational output to emit. Three levels:
+
+  ==================  ===  ================  ==================================
+  name                int  logging level     what is shown
+  ==================  ===  ================  ==================================
+  ``"minimal"``       0    ``WARNING``       warnings/errors, progress bars,
+                                             and results only (e.g. the
+                                             ``association`` p-value)
+  ``"default"``       1    ``INFO``          + high-level progress messages
+  ``"verbose"``       2    ``DEBUG``         + detailed diagnostics
+  ==================  ===  ================  ==================================
+
+* ``settings.diagnostic_plots`` -- how many diagnostic plots to draw, on the same
+  three-level scale as ``verbosity``: ``"minimal"`` draws none, ``"default"`` draws
+  the plots historically shown by default (QC, mean-variance, embeddings), and
+  ``"verbose"`` additionally draws the more detailed plots. Until it is set
+  explicitly, it *tracks* ``verbosity`` -- so setting ``verbosity`` alone also
+  controls the plots; assigning ``diagnostic_plots`` decouples the two.
+
+* ``settings.progress_bars`` -- whether tqdm progress bars are shown. Orthogonal
+  to verbosity (bars stay on even at ``"minimal"``); set ``False`` for batch or
+  cluster runs.
+
+Guidelines for package code:
+
+* ``logger.info(...)``  -- normal progress messages (visible at ``default``).
+* ``logger.debug(...)`` -- detailed diagnostics (visible only at ``verbose``).
+* ``logger.warning(...)`` -- warnings the user should see at every level.
+* ``settings.result(...)`` -- user-facing results shown at every level.
+* ``settings.progress(iterable, name=...)`` -- wrap any loop needing a bar.
+* ``if settings.show_plots(...):`` -- guard a diagnostic plot. Pass ``"verbose"``
+  for the detailed plots; the default level guards the standard ones.
+"""
+
+import sys
+import logging
+from enum import IntEnum
+
+from tqdm.auto import tqdm
+
+__all__ = ["Verbosity", "settings", "logger"]
+
+
+class Verbosity(IntEnum):
+    """Amount of informational output emitted by vima."""
+
+    minimal = 0  # warnings + progress bars + results only
+    default = 1  # + high-level info messages (the historical default)
+    verbose = 2  # + detailed diagnostics
+
+    @classmethod
+    def parse(cls, value):
+        """Coerce an int, name string, or Verbosity into a Verbosity."""
+        if isinstance(value, cls):
+            return value
+        if isinstance(value, str):
+            try:
+                return cls[value]
+            except KeyError:
+                raise ValueError(
+                    f"unknown verbosity {value!r}; "
+                    f"expected one of {[v.name for v in cls]} or 0/1/2"
+                )
+        return cls(value)
+
+
+_LOGGING_LEVELS = {
+    Verbosity.minimal: logging.WARNING,
+    Verbosity.default: logging.INFO,
+    Verbosity.verbose: logging.DEBUG,
+}
+
+logger = logging.getLogger("vima")
+
+# ANSI colors: debug messages are grayed out, results are green.
+_GRAY, _GREEN, _RESET = "\033[90m", "\033[32m", "\033[0m"
+
+
+class _ColorFormatter(logging.Formatter):
+    """Format log records, graying out DEBUG-level messages."""
+
+    def format(self, record):
+        msg = super().format(record)
+        if record.levelno == logging.DEBUG:
+            return f"{_GRAY}{msg}{_RESET}"
+        return msg
+
+
+class _TqdmLoggingHandler(logging.StreamHandler):
+    """Route log records through ``tqdm.write`` so they never corrupt an active
+    progress bar. When no bar is live, ``tqdm.write`` degrades to a plain write
+    to the stream, so logging in loops without a bar is unaffected. This keeps
+    the two output channels fully decoupled: progress bars honor
+    ``settings.progress_bars`` and log messages honor ``settings.verbosity``,
+    independent of each other.
+    """
+
+    def emit(self, record):
+        try:
+            msg = self.format(record)
+            tqdm.write(msg, file=self.stream, end=self.terminator)
+        except Exception:
+            self.handleError(record)
+
+
+class Settings:
+    """Global vima output settings; access via the ``vima.settings`` singleton."""
+
+    def __init__(self):
+        # Attach a single stdout handler and keep our records off the root
+        # logger so vima's output is independent of any host logging config.
+        # The "vima" logger is a process-global singleton that survives module
+        # reloads, so clear any handler we previously attached before adding a
+        # new one; otherwise re-importing vima (e.g. importlib.reload in a
+        # notebook) accumulates handlers and every message prints N times.
+        # Match by class *name*, not isinstance: each reload defines a fresh
+        # _TqdmLoggingHandler class, so handlers left by earlier reloads are
+        # instances of a different (stale) class object and would fail an
+        # isinstance check against the current class.
+        for h in list(logger.handlers):
+            if type(h).__name__ == "_TqdmLoggingHandler":
+                logger.removeHandler(h)
+        handler = _TqdmLoggingHandler(sys.stdout)
+        handler.setFormatter(_ColorFormatter("%(message)s"))
+        logger.addHandler(handler)
+        logger.propagate = False
+
+        self.progress_bars = True
+        self._verbosity = None
+        # ``diagnostic_plots`` tracks ``verbosity`` until the user sets it.
+        self._diagnostic_plots = None
+        self._diagnostic_plots_explicit = False
+        self.verbosity = Verbosity.default
+
+    @property
+    def verbosity(self):
+        """Current :class:`Verbosity` level (see module docstring)."""
+        return self._verbosity
+
+    @verbosity.setter
+    def verbosity(self, value):
+        self._verbosity = Verbosity.parse(value)
+        logger.setLevel(_LOGGING_LEVELS[self._verbosity])
+        if not self._diagnostic_plots_explicit:
+            self._diagnostic_plots = self._verbosity
+
+    @property
+    def diagnostic_plots(self):
+        """:class:`Verbosity` level controlling how many diagnostic plots are drawn.
+
+        Tracks :attr:`verbosity` until assigned; assigning it decouples the two.
+        """
+        return self._diagnostic_plots
+
+    @diagnostic_plots.setter
+    def diagnostic_plots(self, value):
+        self._diagnostic_plots = Verbosity.parse(value)
+        self._diagnostic_plots_explicit = True
+
+    def show_plots(self, level=Verbosity.default):
+        """Whether diagnostic plots at ``level`` should be drawn.
+
+        ``level`` is anything :meth:`Verbosity.parse` accepts (default the
+        standard-plot level); pass ``"verbose"`` for the more detailed plots.
+        """
+        return self._diagnostic_plots >= Verbosity.parse(level)
+
+    def progress(self, iterable=None, name=None, total=None, ncols=100, desc=None, **kwargs):
+        """tqdm wrapper honoring ``settings.progress_bars``.
+
+        Central replacement for the per-module ``pb = lambda ...`` helpers.
+        ``name`` is a brief label for the loop, shown as the tqdm ``desc``
+        prefix (``desc`` is still accepted as an alias; ``name`` wins).
+        """
+        using_widget = any(
+            cls.__module__ == "tqdm.notebook"
+            for cls in tqdm.mro()
+        )
+        return tqdm( 
+            iterable, desc=name if name is not None else desc, total=total,
+            ncols=ncols * (7 if using_widget else 1),
+            bar_format='{l_bar}{bar}{r_bar}',
+            disable=not self.progress_bars, **kwargs,
+        )
+
+    def result(self, message):
+        """Emit a user-facing result, shown at every verbosity level."""
+        tqdm.write(f"{_GREEN}{message}{_RESET}", file=sys.stdout)
+
+
+settings = Settings()

{vima_spatial-0.2.3 → vima_spatial-0.2.4}/src/vima/cc.py

@@ -1,4 +1,4 @@
-import os
+import os, gc
 from concurrent.futures import ThreadPoolExecutor
 import numpy as np
 import scanpy as sc
@@ -11,9 +11,8 @@ import warnings
 import scipy.sparse as sp
 import scipy.stats as st
 from argparse import Namespace
-from tqdm import tqdm
 from .fingerprints import Fingerprints
-pb = lambda x: tqdm(x, ncols=100)
+from ._settings import Verbosity, settings, logger
 
 def anndata(patchmeta, Z, var_names=None, use_rep='X', n_comps=10, **kwargs):
     """
@@ -86,7 +85,7 @@ def apply(models, P, batch_size=1000, with_mse=False):
     if with_mse:
         MSEs = {modelid: [] for modelid in range(len(models))}
     with torch.no_grad():
-        for batch in pb(eval_loader):
+        for batch in settings.progress(eval_loader, name='apply models'):
             for modelid, model in enumerate(models):
                 if with_mse:
                     x_recon, mean, _ = model(batch, sample_from_latent=False)
@@ -129,12 +128,12 @@ def latentreps(models, P, use_rep='X', n_comps=100, with_mse=True, **kwargs):
         Per-model embeddings and neighbor graphs, with ``.obs`` carrying patch
         metadata.
     """
-    print('applying models')
+    logger.info('applying models')
     result = apply(models, P, with_mse=with_mse)
     Zs, MSEs = result if with_mse else (result, None)
 
-    print('computing nearest-neighbor graphs')
-    ds = [anndata(P.meta, Z, use_rep=use_rep, n_comps=n_comps, **kwargs) for Z in pb(Zs)]
+    logger.info('computing nearest-neighbor graphs')
+    ds = [anndata(P.meta, Z, use_rep=use_rep, n_comps=n_comps, **kwargs) for Z in settings.progress(Zs, name='nearest-neighbor graphs')]
     fp = Fingerprints.from_list(ds)
     
     if MSEs is not None:
@@ -288,7 +287,7 @@ def _association(MAMresid, M, y, batches, donorids, rng, Nnull=10_000,
 
     # compute global p-vaule
     p = ((nullglobalstats >= globalstat).sum() + 1)/(len(nullglobalstats) + 1)
-    print(f'\033[32mP = {p}\033[0m')
+    settings.result(f'\033[32mP = {p}\033[0m')
     if p <= 1/(Nnull + 1)+1e-10:
         warnings.warn('global association p-value attained minimal possible value. '+\
                 'Consider increasing Nnull')
@@ -302,16 +301,14 @@ def _association(MAMresid, M, y, batches, donorids, rng, Nnull=10_000,
     res = {'p':p, 'mncorrs':mncorrs_meta, 'fdrs':fdrs,
             'globalstat':globalstat, 'nullglobalstats':nullglobalstats,
             'weights':weights,
-            'nullmncorrs':nullmncorrs_meta,
             'permodel_mncorrs':mncorrs,
-            'MAMres':MAMresid,
             'ycond':ycond
             }
 
     return Namespace(**res)
 
 
-def compute_mams(ds, sid_name, nsteps=None, self_weight=1, show_progress=False):
+def compute_mams(ds, sid_name, nsteps=None, self_weight=1, show_progress=None):
     """
     Precompute per-model sample-by-microniche abundance matrices.
 
@@ -331,9 +328,11 @@ def compute_mams(ds, sid_name, nsteps=None, self_weight=1, show_progress=False):
     list
         One abundance matrix per model.
     """
-    print('computing MAT') #TODO: rename MAM to MAT in code if we keep this nomenclature
+    if show_progress is None:
+        show_progress = settings.verbosity >= Verbosity.verbose
+    logger.info('computing MAT') #TODO: rename MAM to MAT in code if we keep this nomenclature
     MAMs = []
-    for d in tqdm(ds.modelspecific_fingerprints(), total=ds.nmodels, ncols=100):
+    for d in settings.progress(ds.modelspecific_fingerprints(), total=ds.nmodels, name='compute MAMs'):
         NAM = cna.tl._nam._nam(d, sid_name, nsteps=nsteps, self_weight=self_weight,
                                show_progress=show_progress)
         MAMs.append(NAM)
@@ -342,7 +341,7 @@ def compute_mams(ds, sid_name, nsteps=None, self_weight=1, show_progress=False):
 def association(ds, y, sid_name, batches=None, covs=None, donorids=None, key_added='mncoef',
                 return_full=False, ridges=None, MAMs=None,
                 Nnull=10_000, seed=0, make_umap=True,
-                nsteps=None, show_progress=False, allow_low_sample_size=False,
+                nsteps=None, show_progress=None, allow_low_sample_size=False,
                 max_num_mns=5_000, **kwargs):
     """
     Test patch fingerprints for association with a sample-level phenotype.
@@ -391,6 +390,8 @@ def association(ds, y, sid_name, batches=None, covs=None, donorids=None, key_add
         `return_full` is True, returns ``(res, D)`` with the full result object
         in place of `p`.
     """
+    if show_progress is None:
+        show_progress = settings.verbosity >= Verbosity.verbose
     rng = np.random.default_rng(seed)
     np.random.seed(seed)
 
@@ -414,7 +415,7 @@ def association(ds, y, sid_name, batches=None, covs=None, donorids=None, key_add
     kept = np.logical_and.reduce(kepts)
 
     for i in range(len(MAMs_filtered)):
-        MAMs_filtered[i] = MAMs_filtered[i][ds.obs.index[kept]]
+        MAMs_filtered[i] = MAMs_filtered[i].iloc[:,kept]
 
     # residualize NAMs
     MAMs_concat = pd.concat(MAMs_filtered, axis=1)
@@ -427,7 +428,7 @@ def association(ds, y, sid_name, batches=None, covs=None, donorids=None, key_add
                         show_progress=show_progress)
     MAMs_concat = res.namresid
 
-    print('performing association test')
+    logger.info('performing association test')
     n_samples, n_total = MAMs_concat.shape
     Npatches = n_total // ds.nmodels
     MAMresid = MAMs_concat.values.reshape(n_samples, ds.nmodels, Npatches)
@@ -441,6 +442,7 @@ def association(ds, y, sid_name, batches=None, covs=None, donorids=None, key_add
         **kwargs)
     res.__dict__.update(vars(res_)) # add info from from res_ to res
     res.kept = kept
+    gc.collect()
     
     # make anndata with results
     D = ds.weighted_avg_graph(res.weights, kept, make_umap=make_umap)

{vima_spatial-0.2.3 → vima_spatial-0.2.4}/src/vima/data/__init__.py

@@ -1,2 +1,3 @@
 from .patchcollection import *
 from .samples import *
+from .download import *

vima_spatial-0.2.4/src/vima/data/download.py

@@ -0,0 +1,62 @@
+"""Utilities for fetching example/demo datasets."""
+
+import os
+import json
+from urllib.request import urlopen, Request
+
+from .._settings import settings, logger
+
+__all__ = ["download_zenodo"]
+
+
+def download_zenodo(record_id, target_dir, chunk_size=1024 * 1024):
+    """Download every file attached to a Zenodo record into ``target_dir``.
+
+    Parameters
+    ----------
+    record_id
+        Zenodo record id -- the number in the record URL, e.g. ``"21535534"``.
+    target_dir
+        Directory to write the files into; created if it does not exist.
+    chunk_size
+        Streaming chunk size in bytes.
+    """
+    os.makedirs(target_dir, exist_ok=True)
+    with urlopen(f"https://zenodo.org/api/records/{record_id}") as r:
+        files = json.load(r)["files"]
+    for i, f in enumerate(files):
+        url = f["links"]["self"]
+        fname = f["key"]
+        size = f.get("size", 0)
+        dest = os.path.join(target_dir, fname)
+        logger.info(f"[{i + 1}/{len(files)}] downloading {fname}")
+        req = Request(url, headers={"User-Agent": "vima"})
+        with urlopen(req) as resp, open(dest, "wb") as out, \
+                settings.progress(total=size, name=fname,
+                                  unit="B", unit_scale=True) as pbar:
+            while True:
+                chunk = resp.read(chunk_size)
+                if not chunk:
+                    break
+                out.write(chunk)
+                pbar.update(len(chunk))
+
+def download_toy_rawdata(target_dir):
+    """Download the toy raw data for the demo.
+
+    Parameters
+    ----------
+    target_dir
+        Directory to write the files into; created if it does not exist.
+    """
+    download_zenodo("20433752", target_dir)
+
+def download_toy_metadata_and_fingerprints(target_dir):
+    """Download the toy metadata and precomputed fingerprints for the demo.
+
+    Parameters
+    ----------
+    target_dir
+        Directory to write the files into; created if it does not exist.
+    """
+    download_zenodo("21535534", target_dir)

{vima_spatial-0.2.3 → vima_spatial-0.2.4}/src/vima/data/patchcollection.py

@@ -4,10 +4,10 @@ from torchvision import transforms
 import numpy as np
 import pandas as pd
 import random
+import logging
 import torch
 from . import samples as vds
-from tqdm import tqdm
-pb = lambda x: tqdm(x, ncols=100)
+from .._settings import settings, logger
 
 class ToTorch:
     """Transform converting an array to a channels-first torch tensor."""
@@ -55,7 +55,7 @@ class PatchCollection(Dataset):
     """
 
     @staticmethod
-    def choose_patches(samples, patchsize, patchstride, max_frac_empty, verbose=False):
+    def choose_patches(samples, patchsize, patchstride, max_frac_empty):
         """
         Pick patch grid positions for each sample, keeping only patches with
         enough non-empty pixels.
@@ -72,7 +72,7 @@ class PatchCollection(Dataset):
         """
         patchmeta = []
 
-        for s in pb(samples.values()):
+        for s in settings.progress(samples.values(), name='choose patches'):
             mask = vds.get_mask(s)
             starts = np.array([
                 [i, j]
@@ -123,7 +123,7 @@ class PatchCollection(Dataset):
                 self.meta[col] = pd.factorize(self.meta.sid.map(mapping))[0]
                 self._covariate_cols.append(col)
 
-    def compute_stats(self, percentile_thresh, verbose=False):
+    def compute_stats(self, percentile_thresh):
         """
         Compute per-marker mean, std, and display percentiles over a random
         subset of patches.
@@ -139,12 +139,12 @@ class PatchCollection(Dataset):
         self.vmin = (-self.means - self.percentiles)/self.stds
         self.vmax = (-self.means + self.percentiles)/self.stds
 
-        if verbose:
+        if logger.isEnabledFor(logging.DEBUG):
             fmt = lambda a: '  '.join(f'{v:.2g}' for v in a)
-            print(f'per-channel means: {fmt(self.means)}')
-            print(f'per-channel stds:  {fmt(self.stds)}')
+            logger.debug(f'per-channel means: {fmt(self.means)}')
+            logger.debug(f'per-channel stds:  {fmt(self.stds)}')
 
-    def normalize(self, normalization, verbose=False):
+    def normalize(self, normalization):
         """
         Apply the chosen per-marker normalization to the stored patches.
 
@@ -157,8 +157,8 @@ class PatchCollection(Dataset):
         if normalization is not None and normalization not in ['center', 'standardize', 'none']:
             raise ValueError('normalization must equal "standardize" | "center" | "none" | None')
         
-        if verbose: print(f'Normalizing color channels (normalization={normalization})...')
-        
+        logger.debug(f'Normalizing color channels (normalization={normalization})...')
+
         self.empty = np.zeros(self.patches.shape[-1], dtype=np.float32)
         if normalization == 'standardize' or normalization == 'center':
             self.patches = self.patches - self.means[None,None,None,:]
@@ -169,22 +169,21 @@ class PatchCollection(Dataset):
         self.normalization = normalization
 
     def __init__(self, samples, patchsize=40, patchstride=10, max_frac_empty=0.8,
-                normalization='standardize', percentile_thresh=99, verbose=False,
+                normalization='standardize', percentile_thresh=99,
                 covariates=None, condition_on_sid=True):
         self.samples = samples
         self.patchstride = patchstride
         self._covariate_cols = []
-        self.meta = PatchCollection.choose_patches(samples, patchsize, patchstride, max_frac_empty, verbose=verbose)
+        self.meta = PatchCollection.choose_patches(samples, patchsize, patchstride, max_frac_empty)
         self.nmarkers = next(iter(samples.values())).sizes['marker']
 
         self.pytorch_mode()
         self.make_patchmeta(covariates=covariates, condition_on_sid=condition_on_sid)
-        self.compute_stats(percentile_thresh, verbose=verbose)
-        self.normalize(normalization=normalization, verbose=verbose)
+        self.compute_stats(percentile_thresh)
+        self.normalize(normalization=normalization)
         self.augmentation_off()
 
-    def refined(self, max_frac_empty, tol=1e-10, normalization='standardize', percentile_thresh=99,
-                verbose=False):
+    def refined(self, max_frac_empty, tol=1e-10, normalization='standardize', percentile_thresh=99):
         """
         Return a copy restricted to denser patches.
 
@@ -202,8 +201,7 @@ class PatchCollection(Dataset):
         keep = np.where(empty_frac < max_frac_empty)[0]
         result = copy.copy(self)
         result.subset(keep,
-                      normalization=normalization, percentile_thresh=percentile_thresh,
-                      verbose=verbose)
+                      normalization=normalization, percentile_thresh=percentile_thresh)
         return result
 
     @property
@@ -224,9 +222,9 @@ class PatchCollection(Dataset):
     def augmentation_on(self):
         """Enable random rotation and horizontal flip augmentation (pytorch mode only)."""
         if self.dim_order != 'pytorch':
-            print('WARNING: Data augmentation only available in pytorch mode. Will leave augmentation off')
+            logger.warning('Data augmentation only available in pytorch mode. Will leave augmentation off')
             return
-        print('\033[90m[PatchCollection: data augmentation on]\033[0m')
+        logger.debug('[PatchCollection: data augmentation on]')
         self.transform = transforms.Compose([
             ToTorch(),
             RandomDiscreteRotation(),
@@ -234,7 +232,7 @@ class PatchCollection(Dataset):
             ])
     def augmentation_off(self):
         """Disable rotation and flip augmentation."""
-        print('\033[90m[PatchCollection: data augmentation is off]\033[0m')
+        logger.debug('[PatchCollection: data augmentation is off]')
         self.transform = transforms.Compose([
             ToTorch(),
             ])
@@ -246,22 +244,22 @@ class PatchCollection(Dataset):
     def pytorch_mode(self):
         """Switch patch output to channels-first (C, H, W) torch layout."""
         self.dim_order = 'pytorch'
-        print('\033[90m[PatchCollection: in pytorch mode]\033[0m')
+        logger.debug('[PatchCollection: in pytorch mode]')
     def numpy_mode(self):
         """Switch patch output to ``(H, W, C)`` numpy layout and turn augmentation off."""
         self.dim_order = 'numpy'
         self.augmentation_off()
-        print('\033[90m[PatchCollection: in numpy mode]\033[0m')
+        logger.debug('[PatchCollection: in numpy mode]')
 
-    def subset(self, ix, percentile_thresh, normalization, verbose):
+    def subset(self, ix, percentile_thresh, normalization):
         """
         Restrict the collection in place to the given patch indices and recompute
         normalization statistics.
         """
         self.patches = self.patches[ix]
         self.meta = self.meta.iloc[ix]
-        self.compute_stats(percentile_thresh, verbose=verbose)
-        self.normalize(normalization=normalization, verbose=verbose)
+        self.compute_stats(percentile_thresh)
+        self.normalize(normalization=normalization)
 
     def __repr__(self):
         ps = self.meta.patchsize.iloc[0]

{vima_spatial-0.2.3 → vima_spatial-0.2.4}/src/vima/data/samples.py

@@ -5,8 +5,7 @@ import xarray as xr
 import pandas as pd
 import matplotlib.pyplot as plt
 import cv2 as cv2
-from tqdm import tqdm
-pb = lambda x: tqdm(x, ncols=100)
+from .._settings import settings
 
 def read_samples(files, stop_after=None):
     """
@@ -30,7 +29,7 @@ def read_samples(files, stop_after=None):
     if stop_after is None: stop_after = len(files)
 
     samples = {}
-    for f in pb(files[:stop_after]):
+    for f in settings.progress(files[:stop_after], name='read samples'):
         s = xr.open_dataarray(f).astype(np.float32)
         s.attrs['sid'] = os.path.splitext(os.path.basename(f))[0]
         samples[s.sid] = s

{vima_spatial-0.2.3 → vima_spatial-0.2.4}/src/vima/fingerprints.py

@@ -4,9 +4,7 @@ import anndata as ad
 import scanpy as sc
 import scipy.sparse as sp
 import cna
-import copy
-from tqdm import tqdm
-pb = lambda x: tqdm(x, ncols=100)
+from ._settings import settings, logger
 
 
 class _ObsmView:
@@ -79,11 +77,15 @@ class Fingerprints:
         return Fingerprints(self._adata[key].copy())
 
     def select_model(self, i):
-        """Return model `i`'s embedding and neighbor graph as an AnnData."""
-        d = ad.AnnData(X=self._adata.obsm[f'X_{i}'], obs=self._adata.obs.copy())
+        """
+        Return model `i`'s embedding and neighbor graph as an AnnData. Does not
+        make copies of the underlying data, so modifications may affect the
+        original Fingerprints object as well.
+        """
+        d = ad.AnnData(X=self._adata.obsm[f'X_{i}'], obs=self._adata.obs)
         d.obsp['connectivities'] = self._adata.obsp[f'connectivities_{i}']
         d.obsp['distances'] = self._adata.obsp[f'distances_{i}']
-        d.obsm = copy.deepcopy(self._adata.obsm)
+        d.obsm = dict(self.obsm.items())
         d.uns['neighbors'] = self._adata.uns[f'neighbors_{i}']
         return d
 
@@ -151,7 +153,7 @@ class Fingerprints:
                        'n_neighbors': 15, 'use_rep': 'X', 'n_pcs': None},
         }
         if make_umap:
-            print('Computing UMAP...')
+            logger.info('Computing UMAP...')
             sc.tl.umap(D, neighbors_key='neighbors')
         return D
 
@@ -165,7 +167,7 @@ class Fingerprints:
 
     def compute_nngs(self, **kwargs):
         """Recompute and store each model's nearest-neighbor graph."""
-        for i in pb(range(self.nmodels)):
+        for i in settings.progress(range(self.nmodels)):
             d = self.select_model(i)
             sc.pp.neighbors(d, **kwargs)
             self._adata.obsp[f'connectivities_{i}'] = d.obsp['connectivities']
@@ -220,7 +222,7 @@ class Fingerprints:
         NAM -= NAM.mean(axis=0)
         NAM /= NAM.std(axis=0)
         _, _, VT = np.linalg.svd(NAM, full_matrices=False)
-        print(VT.shape)
+        logger.debug('VT shape: %s', VT.shape)
         return pd.DataFrame(VT.T, index=NAM.columns,
                             columns=[f'PC{i+1}' for i in range(VT.shape[0])])