thyra 4.3.1__tar.gz → 4.3.2__tar.gz

{thyra-4.3.1 → thyra-4.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: thyra
-Version: 4.3.1
+Version: 4.3.2
 Summary: A modern Python library for converting Mass Spectrometry Imaging (MSI) data into SpatialData/Zarr format - your portal to spatial omics
 Project-URL: Homepage, https://github.com/M4i-Imaging-Mass-Spectrometry/thyra
 Project-URL: Repository, https://github.com/M4i-Imaging-Mass-Spectrometry/thyra

{thyra-4.3.1 → thyra-4.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "thyra"
-version = "4.3.1"
+version = "4.3.2"
 description = "A modern Python library for converting Mass Spectrometry Imaging (MSI) data into SpatialData/Zarr format - your portal to spatial omics"
 authors = [{ name = "Theodoros Visvikis", email = "t.visvikis@maastrichtuniversity.nl" }]
 maintainers = [{ name = "Theodoros Visvikis", email = "t.visvikis@maastrichtuniversity.nl" }]

{thyra-4.3.1 → thyra-4.3.2}/thyra/__init__.py

@@ -67,7 +67,7 @@ warnings.filterwarnings(
     category=FutureWarning,
 )
 
-__version__ = "4.3.1"
+__version__ = "4.3.2"
 
 #: Public name -> the module that defines it, imported on first access.
 _LAZY_ATTRS = {

{thyra-4.3.1 → thyra-4.3.2}/thyra/convert.py

@@ -358,9 +358,12 @@ def _determine_pixel_size(
     essential_metadata = reader.get_essential_metadata()
 
     if essential_metadata.pixel_size is None:
-        logger.error("Pixel size not found in metadata")
-        logger.error("Use --pixel-size parameter (e.g., --pixel-size 25)")
-        raise ConversionRefused("Pixel size not found in metadata")
+        # Said once: the refusal is logged where it is caught. Logging it
+        # here as well printed the same line twice.
+        raise ConversionRefused(
+            "Pixel size not found in metadata. Pass it with --pixel-size "
+            "(for example --pixel-size 25)."
+        )
 
     final_pixel_size = essential_metadata.pixel_size[0]  # Use X size
     logger.info(f"Detected pixel size: {final_pixel_size:.1f} um")

{thyra-4.3.1 → thyra-4.3.2}/thyra/metadata/extractors/imzml_extractor.py

@@ -159,6 +159,138 @@ def _family_from_model_text(text: str) -> Optional[str]:
     return None
 
 
+def instrument_info_from_configurations(configs: List[Any]) -> Dict[str, Any]:
+    """Instrument model, serial number, analyzer and family of a run.
+
+    ``configs`` are instrument configurations shaped as pyimzml parses
+    them: each has ``param_by_accession`` and ``param_by_name`` dicts, a
+    valueless term reads as ``True``, and ``components`` lists objects with
+    a ``type`` and their own ``param_by_accession``. The imzML extractor
+    passes pyimzml's own; the mzPeak extractor builds the same shape from
+    the archive's JSON.
+
+    Returns:
+        ``instrument_model``, ``instrument_serial_number``, ``analyzer`` and
+        ``instrument_type``, each only when the configurations state it.
+    """
+    info: Dict[str, Any] = {}
+    if not configs:
+        return info
+
+    model = _instrument_model(configs)
+    if model:
+        info["instrument_model"] = model
+
+    serial = _config_param(configs, "MS:1000529")
+    if isinstance(serial, str) and serial.strip():
+        info["instrument_serial_number"] = serial.strip()
+
+    analyzer_accession = _analyzer_accession(configs)
+    if analyzer_accession is not None:
+        info["analyzer"] = ONTOLOGY.terms[analyzer_accession][0]
+
+    family = _analyzer_family(configs, analyzer_accession, model)
+    if family is not None:
+        info["instrument_type"] = family
+
+    return info
+
+
+def _config_param(configs: List[Any], accession: str) -> Any:
+    """The first value any configuration declares for ``accession``."""
+    for config in configs:
+        params = getattr(config, "param_by_accession", None)
+        if isinstance(params, dict) and accession in params:
+            return params[accession]
+    return None
+
+
+def _instrument_model(configs: List[Any]) -> Optional[str]:
+    """The declared instrument model, from the shape the exporter chose.
+
+    Vendors write the model two ways: generic ``MS:1000031 instrument
+    model`` carrying the name as free text, or the model's own child term
+    as a valueless flag (``MS:1001549 solariX``, ``MS:1003124 timsTOF
+    fleX``).  The explicit value wins; a known model accession resolves
+    through the shipped ontology table; and a term newer than the table is
+    still usable when its *name* identifies a family.
+    """
+    value = _config_param(configs, "MS:1000031")
+    if isinstance(value, str) and value.strip():
+        return value.strip()
+
+    for config in configs:
+        params = getattr(config, "param_by_accession", None)
+        if not isinstance(params, dict):
+            continue
+        for accession in params:
+            if accession in _MODEL_FAMILIES:
+                return ONTOLOGY.terms[accession][0]
+
+    for config in configs:
+        params = getattr(config, "param_by_name", None)
+        if not isinstance(params, dict):
+            continue
+        for name, value in params.items():
+            if (
+                isinstance(name, str)
+                and value is True
+                and _family_from_model_text(name) is not None
+            ):
+                return name
+
+    return None
+
+
+def _analyzer_accession(configs: List[Any]) -> Optional[str]:
+    """The highest-priority analyzer term declared on any componentList."""
+    declared: set = set()
+    for config in configs:
+        for component in getattr(config, "components", None) or []:
+            if getattr(component, "type", None) != "analyzer":
+                continue
+            params = getattr(component, "param_by_accession", None)
+            if isinstance(params, dict):
+                declared.update(params)
+
+    for accession in _ANALYZER_ACCESSIONS:
+        if accession in declared:
+            return accession
+    return None
+
+
+def _analyzer_family(
+    configs: List[Any],
+    analyzer_accession: Optional[str],
+    model: Optional[str],
+) -> Optional[str]:
+    """Resolve the axis family, preferring the analyzer declaration.
+
+    The analyzer cvParam states the physics outright, so it outranks the
+    model term, which outranks a substring match on free-form model text.
+    A file that declares none of the three resolves to ``None``.
+    """
+    if analyzer_accession in _ANALYZER_FAMILIES:
+        return _ANALYZER_FAMILIES[analyzer_accession]
+    if analyzer_accession is not None:
+        # A recognised analyzer outside the family table (TOF, ion trap)
+        # is a real declaration; do not second-guess it from the model.
+        return None
+
+    for config in configs:
+        params = getattr(config, "param_by_accession", None)
+        if not isinstance(params, dict):
+            continue
+        for accession in params:
+            family = _MODEL_FAMILIES.get(accession)
+            if family is not None:
+                return family
+
+    if model is not None:
+        return _family_from_model_text(model)
+    return None
+
+
 class ImzMLMetadataExtractor(MetadataExtractor):
     """ImzML-specific metadata extractor with optimized two-phase extraction."""
 
@@ -824,29 +956,12 @@ class ImzMLMetadataExtractor(MetadataExtractor):
           chain matches on (``"FT-ICR"`` / ``"Orbitrap"``), when the analyzer
           or the model resolves to a family the chain distinguishes.  Absent
           otherwise: an unstated analyzer stays unstated.
-        """
-        info: Dict[str, Any] = {}
-        configs = self._instrument_configurations()
-        if not configs:
-            return info
-
-        model = self._instrument_model(configs)
-        if model:
-            info["instrument_model"] = model
 
-        serial = self._config_param(configs, "MS:1000529")
-        if isinstance(serial, str) and serial.strip():
-            info["instrument_serial_number"] = serial.strip()
-
-        analyzer_accession = self._analyzer_accession(configs)
-        if analyzer_accession is not None:
-            info["analyzer"] = ONTOLOGY.terms[analyzer_accession][0]
-
-        family = self._analyzer_family(configs, analyzer_accession, model)
-        if family is not None:
-            info["instrument_type"] = family
-
-        return info
+        The rules live in :func:`instrument_info_from_configurations`, which
+        the mzPeak extractor calls too, so an archive and the imzML it was
+        made from resolve to the same instrument.
+        """
+        return instrument_info_from_configurations(self._instrument_configurations())
 
     def _instrument_configurations(self) -> List[Any]:
         """The parsed instrumentConfiguration ParamGroups, in document order."""
@@ -856,100 +971,6 @@ class ImzMLMetadataExtractor(MetadataExtractor):
             return []
         return list(configs.values())
 
-    @staticmethod
-    def _config_param(configs: List[Any], accession: str) -> Any:
-        """The first value any configuration declares for ``accession``."""
-        for config in configs:
-            params = getattr(config, "param_by_accession", None)
-            if isinstance(params, dict) and accession in params:
-                return params[accession]
-        return None
-
-    def _instrument_model(self, configs: List[Any]) -> Optional[str]:
-        """The declared instrument model, from the shape the exporter chose.
-
-        Vendors write the model two ways: generic ``MS:1000031 instrument
-        model`` carrying the name as free text, or the model's own child term
-        as a valueless flag (``MS:1001549 solariX``, ``MS:1003124 timsTOF
-        fleX``).  The explicit value wins; a known model accession resolves
-        through the shipped ontology table; and a term newer than the table is
-        still usable when its *name* identifies a family.
-        """
-        value = self._config_param(configs, "MS:1000031")
-        if isinstance(value, str) and value.strip():
-            return value.strip()
-
-        for config in configs:
-            params = getattr(config, "param_by_accession", None)
-            if not isinstance(params, dict):
-                continue
-            for accession in params:
-                if accession in _MODEL_FAMILIES:
-                    return ONTOLOGY.terms[accession][0]
-
-        for config in configs:
-            params = getattr(config, "param_by_name", None)
-            if not isinstance(params, dict):
-                continue
-            for name, value in params.items():
-                if (
-                    isinstance(name, str)
-                    and value is True
-                    and _family_from_model_text(name) is not None
-                ):
-                    return name
-
-        return None
-
-    @staticmethod
-    def _analyzer_accession(configs: List[Any]) -> Optional[str]:
-        """The highest-priority analyzer term declared on any componentList."""
-        declared: set = set()
-        for config in configs:
-            for component in getattr(config, "components", None) or []:
-                if getattr(component, "type", None) != "analyzer":
-                    continue
-                params = getattr(component, "param_by_accession", None)
-                if isinstance(params, dict):
-                    declared.update(params)
-
-        for accession in _ANALYZER_ACCESSIONS:
-            if accession in declared:
-                return accession
-        return None
-
-    def _analyzer_family(
-        self,
-        configs: List[Any],
-        analyzer_accession: Optional[str],
-        model: Optional[str],
-    ) -> Optional[str]:
-        """Resolve the axis family, preferring the analyzer declaration.
-
-        The analyzer cvParam states the physics outright, so it outranks the
-        model term, which outranks a substring match on free-form model text.
-        A file that declares none of the three resolves to ``None``.
-        """
-        if analyzer_accession in _ANALYZER_FAMILIES:
-            return _ANALYZER_FAMILIES[analyzer_accession]
-        if analyzer_accession is not None:
-            # A recognised analyzer outside the family table (TOF, ion trap)
-            # is a real declaration; do not second-guess it from the model.
-            return None
-
-        for config in configs:
-            params = getattr(config, "param_by_accession", None)
-            if not isinstance(params, dict):
-                continue
-            for accession in params:
-                family = _MODEL_FAMILIES.get(accession)
-                if family is not None:
-                    return family
-
-        if model is not None:
-            return _family_from_model_text(model)
-        return None
-
     def _extract_raw_metadata(self) -> Dict[str, Any]:
         """Extract raw metadata from imzmldict and spectrum cvParams."""
         raw_metadata = {}

{thyra-4.3.1 → thyra-4.3.2}/thyra/metadata/extractors/mzpeak_extractor.py

@@ -12,14 +12,20 @@ from __future__ import annotations
 import logging
 import math
 from pathlib import Path
+from types import SimpleNamespace
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
 
 import numpy as np
 
 from ...core.base_extractor import MetadataExtractor
 from ..constants import ImzMLAccessions, SpectrumType
+from ..ontology.cache import ONTOLOGY
 from ..types import ComprehensiveMetadata, EssentialMetadata
-from .imzml_extractor import UM_PER_UNIT, has_old_pixel_size_name
+from .imzml_extractor import (
+    UM_PER_UNIT,
+    has_old_pixel_size_name,
+    instrument_info_from_configurations,
+)
 
 if TYPE_CHECKING:  # pragma: no cover - typing only
     # Imported for typing only. A runtime import here would be a cycle:
@@ -84,10 +90,11 @@ class MzPeakMetadataExtractor(MetadataExtractor):
         coordinates = index.coordinates
         raw = index.raw_positions
 
-        # Grid is sized from what the file actually contains. mzPeak also
-        # declares IMS:1000042/43, but a declared extent that disagrees with
-        # the positions would silently pad or clip the output, so the
-        # declaration is kept as provenance only.
+        # Grid is sized from what the file actually contains, from index 0
+        # (the base, as D14 sets it for imzML) to the largest position.
+        # mzPeak also declares IMS:1000042/43, but a declared extent that
+        # disagrees with the positions would silently pad or clip the
+        # output, so the declaration is kept as provenance only.
         dimensions = (
             int(coordinates[:, 0].max()) + 1,
             int(coordinates[:, 1].max()) + 1,
@@ -123,12 +130,20 @@ class MzPeakMetadataExtractor(MetadataExtractor):
         data: the metadata member has one row per spectrum, so this is a
         9-row read on a 36k-point file and stays a one-row-per-spectrum read
         at any scale.
+
+        A spectrum that is not converted (on no pixel, or an MSn spectrum
+        beside MS1) does not widen the range.
         """
         table = self.archive.parquet("spectrum", "metadata").read(
-            columns=["lowest_observed_mz", "highest_observed_mz"]
+            columns=["index", "lowest_observed_mz", "highest_observed_mz"]
         )
         low = np.asarray(table.column("lowest_observed_mz").to_numpy(), dtype=float)
         high = np.asarray(table.column("highest_observed_mz").to_numpy(), dtype=float)
+        index = self.archive.spatial_index()
+        if not index.complete:
+            rows = np.asarray(table.column("index").to_numpy(), dtype=np.int64)
+            kept = np.isin(rows, index.spectrum_indices)
+            low, high = low[kept], high[kept]
         low = low[np.isfinite(low)]
         high = high[np.isfinite(high)]
         if low.size == 0 or high.size == 0:
@@ -174,7 +189,12 @@ class MzPeakMetadataExtractor(MetadataExtractor):
         x = parameters.get(ImzMLAccessions.PIXEL_SIZE_X)
         y = parameters.get(ImzMLAccessions.PIXEL_SIZE_Y)
         if x is None and y is None:
-            logger.info("Pixel size not found in metadata of %s", self.data_path.name)
+            logger.info(
+                "%s states no pixel size: its scan settings hold neither %s " "nor %s.",
+                self.data_path.name,
+                ImzMLAccessions.PIXEL_SIZE_X,
+                ImzMLAccessions.PIXEL_SIZE_Y,
+            )
             return None
         if x is not None and y is not None and not self._has_old_name(x):
             return self._declared_pair(x, y)
@@ -446,6 +466,11 @@ class MzPeakMetadataExtractor(MetadataExtractor):
         nulls = self.archive.null_count()
         if not nulls:
             return declared
+        if not index.complete:
+            # The padding count covers the whole member and cannot be split
+            # by spectrum, so with spectra left out the count keeps its
+            # padding: an upper bound rather than a figure too low.
+            return declared
         return max(0, declared - int(nulls))
 
     # ------------------------------------------------------------------
@@ -507,11 +532,74 @@ class MzPeakMetadataExtractor(MetadataExtractor):
         }
 
     def _instrument_info(self, metadata: Dict[str, Any]) -> Dict[str, Any]:
-        """Instrument and software lists, as the archive records them."""
-        return {
-            "instrument_configuration_list": metadata.get(
-                "instrument_configuration_list"
-            ),
-            "software_list": metadata.get("software_list"),
-            "data_processing_method_list": metadata.get("data_processing_method_list"),
-        }
+        """The instrument as the imzML route reads it, and the raw lists.
+
+        Model, serial number, analyzer and family are resolved by the
+        function the imzML extractor uses, so an archive converts on the
+        same mass axis as the imzML it was made from. The family is what
+        picks the axis: without it an Orbitrap archive was binned as an
+        unknown instrument.
+        """
+        configurations = metadata.get("instrument_configuration_list")
+        info = instrument_info_from_configurations(
+            _as_parsed_configurations(configurations)
+        )
+        info.update(
+            {
+                "instrument_configuration_list": configurations,
+                "software_list": metadata.get("software_list"),
+                "data_processing_method_list": metadata.get(
+                    "data_processing_method_list"
+                ),
+            }
+        )
+        return info
+
+
+def _as_parsed_parameters(parameters: Any) -> SimpleNamespace:
+    """One mzPeak parameter list in the shape pyimzml gives a ParamGroup.
+
+    As pyimzml does, a term without a value reads as ``True`` and a known
+    accession is named by the ontology, not by the name the writer gave.
+    """
+    by_accession: Dict[str, Any] = {}
+    by_name: Dict[str, Any] = {}
+    for parameter in parameters if isinstance(parameters, list) else []:
+        if not isinstance(parameter, dict):
+            continue
+        value = parameter.get("value")
+        value = True if value is None else value
+        accession = parameter.get("accession")
+        name = parameter.get("name")
+        if isinstance(accession, str) and accession:
+            by_accession.setdefault(accession, value)
+            known = ONTOLOGY.terms.get(accession)
+            if known:
+                name = known[0]
+        if isinstance(name, str) and name:
+            by_name.setdefault(name, value)
+    return SimpleNamespace(param_by_accession=by_accession, param_by_name=by_name)
+
+
+def _as_parsed_configurations(configurations: Any) -> List[SimpleNamespace]:
+    """The archive's instrument configurations, shaped as pyimzml parses them.
+
+    See :func:`~.imzml_extractor.instrument_info_from_configurations`.
+    mzPeak writes a component's kind as ``component_type`` ("analyzer",
+    "ionsource", "detector"); pyimzml calls it ``type``.
+    """
+    parsed: List[SimpleNamespace] = []
+    for configuration in configurations if isinstance(configurations, list) else []:
+        if not isinstance(configuration, dict):
+            continue
+        group = _as_parsed_parameters(configuration.get("parameters"))
+        components = []
+        for component in configuration.get("components") or []:
+            if not isinstance(component, dict):
+                continue
+            parsed_component = _as_parsed_parameters(component.get("parameters"))
+            parsed_component.type = component.get("component_type")
+            components.append(parsed_component)
+        group.components = components
+        parsed.append(group)
+    return parsed

{thyra-4.3.1 → thyra-4.3.2}/thyra/readers/mzpeak/chunk_decoding.py

@@ -79,6 +79,17 @@ REFUSED_TERMS: Dict[str, str] = {
     "MS:9999002": "timsTOF m/z grid of the reference implementation",
 }
 
+#: Grid models the default timsTOF (TDF) lane of mzpeak-convert writes.
+TIMSTOF_GRID_TYPES = ("MS:9999001", "MS:9999002")
+
+#: What a refusal of those models adds: the option of that converter that
+#: writes the m/z themselves (checked against the help of 0.16.0).
+TIMSTOF_GRID_HINT = (
+    " mzpeak-convert writes this model for a timsTOF .d by default. Convert "
+    "the .d again with --no-ims-compact to store m/z Thyra reads, or "
+    "convert the .d with Thyra directly."
+)
+
 #: Transforms of the intensity array, by the column that holds them.
 INTENSITY_TRANSFORMS: Dict[str, str] = {
     "intensity_numpress_slof_bytes": "MS:1002314",
@@ -208,10 +219,11 @@ def validate_encodings(
         return
     for grid_type in grid_types:
         if grid_type not in DECODED_GRID_TYPES:
+            hint = TIMSTOF_GRID_HINT if grid_type in TIMSTOF_GRID_TYPES else ""
             raise ConversionRefused(
                 f"{source} stores m/z on a grid of type "
                 f"{describe_term(grid_type)}, which Thyra does not decode. "
-                f"It decodes {_decoded(DECODED_GRID_TYPES)}."
+                f"It decodes {_decoded(DECODED_GRID_TYPES)}.{hint}"
             )