Add support for `.mca` files (Multi Channel Analyzer spectrum files)

[PierreRaybaut]

Multi Channel Analyzer (MCA) spectrum files are already partially supported thanks to the Text Import Wizard (see #236).

The purpose of this issue is to add native support to DataLab.

[PierreRaybaut]

Here is a test plugin for future MCA file reading functionality.

How to test it?
Simply copy/paste the script below into a file named cdl_mca_format.py for example, and add this file to your DataLab plugin directory.

# -*- coding: utf-8 -*-

"""
MCA Format Plugin for DataLab
=============================

This plugin is an example of how to add a new MCA file format to DataLab.
"""

from __future__ import annotations

import datetime
import re
import warnings

import numpy as np
from scipy.interpolate import interp1d

from cdl.config import _
from cdl.core.io.base import FormatInfo
from cdl.core.io.signal.base import SignalFormatBase
from cdl.obj import SignalObj
from cdl.utils.qthelpers import CallbackWorker


class MCAFile:
    """Class to handle MCA files."""

    def __init__(self, filename: str) -> None:
        self.filename = filename
        self.raw_data: str = ""
        self.xlabel: str | None = None
        self.x: np.ndarray | None = None
        self.y: np.ndarray | None = None
        self.metadata: dict[str, str] = {}

    def __try_decode(self, raw_bytes: bytes) -> str:
        """Try to decode raw bytes with the specified encoding."""
        encodings_to_try = ["utf-8", "utf-8-sig", "latin-1", "cp1252"]
        for enc in encodings_to_try:
            try:
                return raw_bytes.decode(enc)
            except UnicodeDecodeError:
                continue
        # If all attempts fail, use 'utf-8' with replacement
        warnings.warn("All decoding attempts failed. Used 'utf-8' with replacement.")
        return raw_bytes.decode("utf-8", errors="replace")

    def _read_raw_data(self) -> str:
        """Read the raw data from the MCA file, trying multiple encodings."""
        with open(self.filename, "rb") as file:
            raw_bytes = file.read()
        raw_data = self.__try_decode(raw_bytes)
        self.raw_data = raw_data.replace("\r\n", "\n").replace("\r", "\n")

    def _read_section(self, section: str) -> str | None:
        """Read a section from the raw data."""
        pattern = f"(?:.*)(^<<{section}>>$)(.*?)(?:<<.*>>)"
        match = re.search(pattern, self.raw_data, re.DOTALL + re.MULTILINE)
        if match:
            return match.group(2).strip()
        return None

    def _extract_metadata_from_section(
        self, section: str
    ) -> dict[str, str | float | int | datetime.datetime]:
        """Extract metadata from a specific section."""
        section_contents = self._read_section(section)
        if section_contents is None:
            return {}
        metadata = {}
        patterns = (r"(.*?) - (.*?)$", r"(.*?)\s*: \s*(.*)$", r"(.*?)\s*=\s*(.*);")
        for line in section_contents.splitlines():
            for pattern in patterns:
                match = re.match(pattern, line)
                if match:
                    key, value_str = match.groups()
                    value_str = value_str.strip()
                    # Try to convert the value to a number or datetime
                    try:
                        if value_str.isdigit():
                            value = int(value_str)
                        else:
                            try:
                                value = float(value_str)
                            except ValueError:
                                # Try to parse as datetime
                                try:
                                    value = datetime.datetime.strptime(
                                        value_str, "%m/%d/%Y %H:%M:%S"
                                    )
                                except ValueError:
                                    value = value_str  # Keep as string
                    except ValueError:
                        value = value_str
                    metadata[key.strip()] = value
                    break
        return metadata

    def read(self) -> None:
        """Read the MCA file and extract data and metadata."""
        self._read_raw_data()
        self.metadata = self._extract_metadata_from_section("PMCA SPECTRUM")
        additional_metadata = self._extract_metadata_from_section("DPP STATUS")
        self.metadata.update(additional_metadata)
        data_section = self._read_section("DATA")
        self.y = np.fromstring(data_section, sep=" ") if data_section else None
        if self.y is not None:
            self.x = np.arange(len(self.y))
            cal_section = self._read_section("CALIBRATION")
            if cal_section:
                cal_metadata = self._extract_metadata_from_section(cal_section)
                self.xlabel = cal_metadata.get("LABEL")
                cal_data = np.array(
                    [
                        [float(v) for v in val.split(" ")]
                        for val in cal_section.splitlines()[1:]
                    ]
                )
                self.x = interp1d(
                    cal_data[:, 0],
                    cal_data[:, 1],
                    bounds_error=False,
                    fill_value="extrapolate",
                )(self.x)


class MCASignalFormat(SignalFormatBase):
    """Object representing a MCA signal file type"""

    FORMAT_INFO = FormatInfo(
        name=_("MCA files"),
        extensions="*.mca",
        readable=True,
        writeable=False,
    )

    def read(
        self, filename: str, worker: CallbackWorker | None = None
    ) -> list[SignalObj]:
        """Read list of signal objects from file

        Args:
            filename: File name
            worker: Callback worker object

        Returns:
            List of signal objects
        """
        mca = MCAFile(filename)
        mca.read()
        obj = self.create_object(filename)
        obj.set_xydata(mca.x, mca.y)
        obj.xlabel = mca.xlabel or ""
        obj.metadata = mca.metadata
        return [obj]

[PierreRaybaut]

Here is the same plugin ported to DataLab 1.0 (only the imports change):

# -*- coding: utf-8 -*-

"""
MCA Format Plugin for DataLab
=============================

This plugin is an example of how to add a new MCA file format to DataLab.
"""

from __future__ import annotations

import datetime
import re
import warnings

import numpy as np
from scipy.interpolate import interp1d
from sigima.io.base import FormatInfo
from sigima.io.signal.base import SignalFormatBase
from sigima.objects.signal import SignalObj
from sigima.worker import CallbackWorkerProtocol

from datalab.config import _


class MCAFile:
    """Class to handle MCA files."""

    def __init__(self, filename: str) -> None:
        self.filename = filename
        self.raw_data: str = ""
        self.xlabel: str | None = None
        self.x: np.ndarray | None = None
        self.y: np.ndarray | None = None
        self.metadata: dict[str, str] = {}

    def __try_decode(self, raw_bytes: bytes) -> str:
        """Try to decode raw bytes with the specified encoding."""
        encodings_to_try = ["utf-8", "utf-8-sig", "latin-1", "cp1252"]
        for enc in encodings_to_try:
            try:
                return raw_bytes.decode(enc)
            except UnicodeDecodeError:
                continue
        # If all attempts fail, use 'utf-8' with replacement
        warnings.warn("All decoding attempts failed. Used 'utf-8' with replacement.")
        return raw_bytes.decode("utf-8", errors="replace")

    def _read_raw_data(self) -> str:
        """Read the raw data from the MCA file, trying multiple encodings."""
        with open(self.filename, "rb") as file:
            raw_bytes = file.read()
        raw_data = self.__try_decode(raw_bytes)
        self.raw_data = raw_data.replace("\r\n", "\n").replace("\r", "\n")

    def _read_section(self, section: str) -> str | None:
        """Read a section from the raw data."""
        pattern = f"(?:.*)(^<<{section}>>$)(.*?)(?:<<.*>>)"
        match = re.search(pattern, self.raw_data, re.DOTALL + re.MULTILINE)
        if match:
            return match.group(2).strip()
        return None

    def _extract_metadata_from_section(
        self, section: str
    ) -> dict[str, str | float | int | datetime.datetime]:
        """Extract metadata from a specific section."""
        section_contents = self._read_section(section)
        if section_contents is None:
            return {}
        metadata = {}
        patterns = (r"(.*?) - (.*?)$", r"(.*?)\s*: \s*(.*)$", r"(.*?)\s*=\s*(.*);")
        for line in section_contents.splitlines():
            for pattern in patterns:
                match = re.match(pattern, line)
                if match:
                    key, value_str = match.groups()
                    value_str = value_str.strip()
                    # Try to convert the value to a number or datetime
                    try:
                        if value_str.isdigit():
                            value = int(value_str)
                        else:
                            try:
                                value = float(value_str)
                            except ValueError:
                                # Try to parse as datetime
                                try:
                                    value = datetime.datetime.strptime(
                                        value_str, "%m/%d/%Y %H:%M:%S"
                                    )
                                except ValueError:
                                    value = value_str  # Keep as string
                    except ValueError:
                        value = value_str
                    metadata[key.strip()] = value
                    break
        return metadata

    def read(self) -> None:
        """Read the MCA file and extract data and metadata."""
        self._read_raw_data()
        self.metadata = self._extract_metadata_from_section("PMCA SPECTRUM")
        additional_metadata = self._extract_metadata_from_section("DPP STATUS")
        self.metadata.update(additional_metadata)
        data_section = self._read_section("DATA")
        self.y = np.fromstring(data_section, sep=" ") if data_section else None
        if self.y is not None:
            self.x = np.arange(len(self.y))
            cal_section = self._read_section("CALIBRATION")
            if cal_section:
                cal_metadata = self._extract_metadata_from_section(cal_section)
                self.xlabel = cal_metadata.get("LABEL")
                cal_data = np.array(
                    [
                        [float(v) for v in val.split(" ")]
                        for val in cal_section.splitlines()[1:]
                    ]
                )
                self.x = interp1d(
                    cal_data[:, 0],
                    cal_data[:, 1],
                    bounds_error=False,
                    fill_value="extrapolate",
                )(self.x)


class MCASignalFormat(SignalFormatBase):
    """Object representing a MCA signal file type"""

    FORMAT_INFO = FormatInfo(
        name=_("MCA files"),
        extensions="*.mca",
        readable=True,
        writeable=False,
    )

    def read(
        self, filename: str, worker: CallbackWorkerProtocol | None = None
    ) -> list[SignalObj]:
        """Read list of signal objects from file

        Args:
            filename: File name
            worker: Callback worker object

        Returns:
            List of signal objects
        """
        mca = MCAFile(filename)
        mca.read()
        obj = self.create_object(filename)
        obj.set_xydata(mca.x, mca.y)
        obj.xlabel = mca.xlabel or ""
        obj.metadata = mca.metadata
        return [obj]

[PierreRaybaut]

MCA file support is now available in Sigima (and DataLab 1.0):
DataLab-Platform/Sigima@f6d9154