12633263274

Committed 06 Jan 2025 01:20PM UTC coverage: 83.698% (+2.1%) from 81.598%

Build # 12633263274

Build Type

push

github

Committed by

psomhorst

Commit Message

Bump version: 1.5.1 → 1.5.2

Run Details

347 of 454 branches covered (76.43%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

9 existing lines in 4 files now uncovered.

1373 of 1601 relevant lines covered (85.76%)

0.86 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.74

/eitprocessing/datahandling/eitdata.py

from __future__ import annotations

import warnings
from dataclasses import dataclass, field
from enum import auto
from pathlib import Path
from typing import TYPE_CHECKING, TypeVar

import numpy as np
from strenum import LowercaseStrEnum

from eitprocessing.datahandling import DataContainer
from eitprocessing.datahandling.mixins.slicing import SelectByTime

if TYPE_CHECKING:
    from typing_extensions import Self


T = TypeVar("T", bound="EITData")


@dataclass(eq=False)
class EITData(DataContainer, SelectByTime):
    """Container for EIT impedance data.

    This class holds the pixel impedance from an EIT measurement, as well as metadata describing the measurement. The
    class is meant to hold data from (part of) a singular continuous measurement.

    This class can't be initialized directly. Instead, use `load_eit_data(<path>, vendor=<vendor>)` to load data from
    disk.

    Args:
        path: The path of list of paths of the source from which data was derived.
        nframes: Number of frames.
        time: The time of each frame (since start measurement).
        sample_frequency: The (average) frequency at which the frames are collected, in Hz.
        vendor: The vendor of the device the data was collected with.
        label: Computer readable label identifying this dataset.
        name: Human readable name for the data.
        pixel_impedance: Impedance values for each pixel at each frame.
    """  # TODO: fix docstring

    path: str | Path | list[Path | str] = field(compare=False, repr=False)
    nframes: int = field(repr=False)
    time: np.ndarray = field(repr=False)
    sample_frequency: float = field(metadata={"check_equivalence": True}, repr=False)
    vendor: Vendor = field(metadata={"check_equivalence": True}, repr=False)
    label: str | None = field(default=None, compare=False, metadata={"check_equivalence": True})
    description: str = field(default="", compare=False, repr=False)
    name: str | None = field(default=None, compare=False, repr=False)
    pixel_impedance: np.ndarray = field(repr=False, kw_only=True)

    def __post_init__(self):
        if not self.label:
            self.label = f"{self.__class__.__name__}_{id(self)}"

        self.path = self.ensure_path_list(self.path)
        if len(self.path) == 1:
            self.path = self.path[0]

        self.name = self.name or self.label

        if (lv := len(self.pixel_impedance)) != (lt := len(self.time)):
            msg = f"The number of time points ({lt}) does not match the number of pixel impedance values ({lv})."
            raise ValueError(msg)

    @property
    def framerate(self) -> float:
        """Deprecated alias to `sample_frequency`."""
        warnings.warn(
            "The `framerate` attribute has been deprecated. Use `sample_frequency` instead.",
            DeprecationWarning,
        )
        return self.sample_frequency

    @staticmethod
    def ensure_path_list(
        path: str | Path | list[str | Path],
    ) -> list[Path]:
        """Return the path or paths as a list.

        The path of any EITData object can be a single str/Path or a list of str/Path objects. This method returns a
        list of Path objects given either a str/Path or list of str/Paths.
        """
        if isinstance(path, list):
            return [Path(p) for p in path]
        return [Path(path)]

    def __add__(self: T, other: T) -> T:
        return self.concatenate(other)

    def concatenate(self: T, other: T, newlabel: str | None = None) -> T:  # noqa: D102, will be moved to mixin in future
        # Check that data can be concatenated
        self.isequivalent(other, raise_=True)
        if np.min(other.time) <= np.max(self.time):
            msg = f"Concatenation failed. Second dataset ({other.name}) may not start before first ({self.name}) ends."
            raise ValueError(msg)

        self_path = self.ensure_path_list(self.path)
        other_path = self.ensure_path_list(other.path)
        newlabel = newlabel or f"Merge of <{self.label}> and <{other.label}>"

        return self.__class__(
            vendor=self.vendor,
            path=[*self_path, *other_path],
            label=self.label,  # TODO: using newlabel leads to errors
            sample_frequency=self.sample_frequency,
            nframes=self.nframes + other.nframes,
            time=np.concatenate((self.time, other.time)),
            pixel_impedance=np.concatenate((self.pixel_impedance, other.pixel_impedance), axis=0),
        )

    def _sliced_copy(
        self,
        start_index: int,
        end_index: int,
        newlabel: str,  # noqa: ARG002
    ) -> Self:
        cls = self.__class__
        time = np.copy(self.time[start_index:end_index])
        nframes = len(time)

        pixel_impedance = np.copy(self.pixel_impedance[start_index:end_index, :, :])

        return cls(
            path=self.path,
            nframes=nframes,
            vendor=self.vendor,
            time=time,
            sample_frequency=self.sample_frequency,
            label=self.label,  # newlabel gives errors
            pixel_impedance=pixel_impedance,
        )

    def __len__(self):
        return self.pixel_impedance.shape[0]

    def calculate_global_impedance(self) -> np.ndarray:
        """Return the global impedance, i.e. the sum of all included pixels at each frame."""
        return np.nansum(self.pixel_impedance, axis=(1, 2))


class Vendor(LowercaseStrEnum):
    """Enum indicating the vendor (manufacturer) of the source EIT device."""

    DRAEGER = auto()
    TIMPEL = auto()
    SENTEC = auto()
    DRAGER = DRAEGER
    DRÄGER = DRAEGER  # noqa: PLC2401

1	from __future__ import annotations	1✔
2
3	import warnings	1✔
4	from dataclasses import dataclass, field	1✔
5	from enum import auto	1✔
6	from pathlib import Path	1✔
7	from typing import TYPE_CHECKING, TypeVar	1✔
8
9	import numpy as np	1✔
10	from strenum import LowercaseStrEnum	1✔
11
12	from eitprocessing.datahandling import DataContainer	1✔
13	from eitprocessing.datahandling.mixins.slicing import SelectByTime	1✔
14
15	if TYPE_CHECKING:
16	from typing_extensions import Self
17
18
19	T = TypeVar("T", bound="EITData")	1✔
20
21
22	@dataclass(eq=False)	1✔
23	class EITData(DataContainer, SelectByTime):	1✔
24	"""Container for EIT impedance data.
25
26	This class holds the pixel impedance from an EIT measurement, as well as metadata describing the measurement. The
27	class is meant to hold data from (part of) a singular continuous measurement.
28
29	This class can't be initialized directly. Instead, use `load_eit_data(<path>, vendor=<vendor>)` to load data from
30	disk.
31
32	Args:
33	path: The path of list of paths of the source from which data was derived.
34	nframes: Number of frames.
35	time: The time of each frame (since start measurement).
36	sample_frequency: The (average) frequency at which the frames are collected, in Hz.
37	vendor: The vendor of the device the data was collected with.
38	label: Computer readable label identifying this dataset.
39	name: Human readable name for the data.
40	pixel_impedance: Impedance values for each pixel at each frame.
41	""" # TODO: fix docstring
42
43	path: str \| Path \| list[Path \| str] = field(compare=False, repr=False)	1✔
44	nframes: int = field(repr=False)	1✔
45	time: np.ndarray = field(repr=False)	1✔
46	sample_frequency: float = field(metadata={"check_equivalence": True}, repr=False)	1✔
47	vendor: Vendor = field(metadata={"check_equivalence": True}, repr=False)	1✔
48	label: str \| None = field(default=None, compare=False, metadata={"check_equivalence": True})	1✔
49	description: str = field(default="", compare=False, repr=False)	1✔
50	name: str \| None = field(default=None, compare=False, repr=False)	1✔
51	pixel_impedance: np.ndarray = field(repr=False, kw_only=True)	1✔
52
53	def __post_init__(self):	1✔
54	if not self.label:	1!
UNCOV 55	self.label = f"{self.__class__.__name__}_{id(self)}"	×
56
57	self.path = self.ensure_path_list(self.path)	1✔
58	if len(self.path) == 1:	1✔
59	self.path = self.path[0]	1✔
60
61	self.name = self.name or self.label	1✔
62
63	if (lv := len(self.pixel_impedance)) != (lt := len(self.time)):	1!
64	msg = f"The number of time points ({lt}) does not match the number of pixel impedance values ({lv})."	×
UNCOV 65	raise ValueError(msg)	×
66
67	@property	1✔
68	def framerate(self) -> float:	1✔
69	"""Deprecated alias to `sample_frequency`."""
UNCOV 70	warnings.warn(	×
71	"The `framerate` attribute has been deprecated. Use `sample_frequency` instead.",
72	DeprecationWarning,
73	)
UNCOV 74	return self.sample_frequency	×
75
76	@staticmethod	1✔
77	def ensure_path_list(	1✔
78	path: str \| Path \| list[str \| Path],
79	) -> list[Path]:
80	"""Return the path or paths as a list.
81
82	The path of any EITData object can be a single str/Path or a list of str/Path objects. This method returns a
83	list of Path objects given either a str/Path or list of str/Paths.
84	"""
85	if isinstance(path, list):	1✔
86	return [Path(p) for p in path]	1✔
87	return [Path(path)]	1✔
88
89	def __add__(self: T, other: T) -> T:	1✔
UNCOV 90	return self.concatenate(other)	×
91
92	def concatenate(self: T, other: T, newlabel: str \| None = None) -> T: # noqa: D102, will be moved to mixin in future	1✔
93	# Check that data can be concatenated
94	self.isequivalent(other, raise_=True)	1✔
95	if np.min(other.time) <= np.max(self.time):	1✔
96	msg = f"Concatenation failed. Second dataset ({other.name}) may not start before first ({self.name}) ends."	1✔
97	raise ValueError(msg)	1✔
98
99	self_path = self.ensure_path_list(self.path)	1✔
100	other_path = self.ensure_path_list(other.path)	1✔
101	newlabel = newlabel or f"Merge of <{self.label}> and <{other.label}>"	1✔
102
103	return self.__class__(	1✔
104	vendor=self.vendor,
105	path=[self_path, other_path],
106	label=self.label, # TODO: using newlabel leads to errors
107	sample_frequency=self.sample_frequency,
108	nframes=self.nframes + other.nframes,
109	time=np.concatenate((self.time, other.time)),
110	pixel_impedance=np.concatenate((self.pixel_impedance, other.pixel_impedance), axis=0),
111	)
112
113	def _sliced_copy(	1✔
114	self,
115	start_index: int,
116	end_index: int,
117	newlabel: str, # noqa: ARG002
118	) -> Self:
119	cls = self.__class__	1✔
120	time = np.copy(self.time[start_index:end_index])	1✔
121	nframes = len(time)	1✔
122
123	pixel_impedance = np.copy(self.pixel_impedance[start_index:end_index, :, :])	1✔
124
125	return cls(	1✔
126	path=self.path,
127	nframes=nframes,
128	vendor=self.vendor,
129	time=time,
130	sample_frequency=self.sample_frequency,
131	label=self.label, # newlabel gives errors
132	pixel_impedance=pixel_impedance,
133	)
134
135	def __len__(self):	1✔
136	return self.pixel_impedance.shape[0]	1✔
137
138	def calculate_global_impedance(self) -> np.ndarray:	1✔
139	"""Return the global impedance, i.e. the sum of all included pixels at each frame."""
140	return np.nansum(self.pixel_impedance, axis=(1, 2))	1✔
141
142
143	class Vendor(LowercaseStrEnum):	1✔
144	"""Enum indicating the vendor (manufacturer) of the source EIT device."""
145
146	DRAEGER = auto()	1✔
147	TIMPEL = auto()	1✔
148	SENTEC = auto()	1✔
149	DRAGER = DRAEGER	1✔
150	DRÄGER = DRAEGER # noqa: PLC2401	1✔

EIT-ALIVE / eitprocessing / 12633263274

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous