data_structures.py

from dataclasses import dataclass
from enum import Enum
from typing import Iterator, Optional


class State(float, Enum):
    """Enum representation of the possible states of a refrigerator machine."""

    NORMAL = 0
    AGGREGATE_FAN_FAULT = 1
    EVAPORATOR_FAN_FAULT = 2
    COMPRESSOR_FAULT = 3
    DEFROSTING = 6


@dataclass(frozen=True)
class Channel:
    """Helper channel representation class."""

    name: str
    code_name: str

    def __repr__(self) -> str:
        return self.code_name


@dataclass(frozen=True)
class DetectionRange:
    """Helper object which represents a detection range for RS classifiers."""

    minimum: float
    maximum: float
    state: State
    required_state: Optional[State] = None

    def __repr__(self) -> str:
        """Debug representation of the object.

        Returns:
            str: String representation of the object

        """
        return (
            "DetectionRange("
            f"state={self.state}, "
            f"minimum={self.minimum}, "
            f"maximum={self.maximum}, "
            f"required_state={self.required_state}"
            ")"
        )

    def in_range(self, value: float) -> bool:
        """Check if given value is in the defined object's range."""
        return self.minimum < value <= self.maximum


@dataclass(frozen=True)
class DetectionSet:
    """RS detection set representation helper class."""

    channel: Channel
    ranges: list[DetectionRange]


@dataclass(frozen=True)
class DetectionSets:
    """RS detection sets representation helper class."""

    set_1: DetectionSet
    set_2: Optional[DetectionSet] = None
    set_3: Optional[DetectionSet] = None
    set_4: Optional[DetectionSet] = None
    set_5: Optional[DetectionSet] = None

    @property
    def _all_sets(self) -> list[DetectionSet]:
        """Property which allows to iterate over the detection sets.

        Returns:
            list[DetectionSet]: List of detection sets

        """
        return [
            _set
            for _set in [
                self.set_1,
                self.set_2,
                self.set_3,
                self.set_4,
                self.set_5,
            ]
            if _set is not None
        ]

    @property
    def sets(self) -> Iterator[DetectionSet]:
        """Property which allows to iterate over the detection sets.

        Returns:
            Iterator[DetectionSet]: Iterator over detection sets

        """
        return iter([detection_set for detection_set in self._all_sets])

    @property
    def channels(self) -> Iterator[str]:
        """Property which allows to iterate over channels used in sets.

        Returns:
            Iterator[str]: Iterator over channels used in sets

        """
        return iter(
            [
                detection_set.channel.code_name
                for detection_set in self._all_sets
            ]
        )