from dataclasses import dataclass from pathlib import Path from typing import Any import yaml from app.my_dataclasses import ( MIN_FAN_SPEED, MAX_FAN_SPEED, ) @dataclass( frozen=True, slots=True, ) class Co2Config: base_speed: int hysteresis: int thresholds: tuple[ tuple[int, int], ... ] @dataclass( frozen=True, slots=True, ) class TemperatureConfig: hysteresis: float @dataclass( frozen=True, slots=True, ) class ElicaAssistConfig: enabled: bool # (скорость Tion, скорость Elica) speed_map: tuple[ tuple[int, int], ... ] @dataclass( frozen=True, slots=True, ) class AutoConfig: version: int check_interval: float co2: Co2Config temperature: TemperatureConfig elica_assist: ElicaAssistConfig @dataclass( frozen=True, slots=True, ) class AutoConfigComponents: version: int check_interval: float co2: Co2Config | None temperature: TemperatureConfig | None elica_assist: ElicaAssistConfig | None errors: dict[str, str] def _require_dict(name: str, value: Any) -> dict: if not isinstance(value, dict): raise ValueError( f"{name} must be an object" ) return value def _parse_speed(name: str, value: Any) -> int: if type(value) is not int: raise ValueError( f"{name} must be an integer" ) if not ( MIN_FAN_SPEED <= value <= MAX_FAN_SPEED ): raise ValueError( f"{name} must be between " f"{MIN_FAN_SPEED} and " f"{MAX_FAN_SPEED}" ) return value def _parse_thresholds(value: Any) -> tuple[ tuple[int, int], ... ]: if not isinstance(value, list): raise ValueError( "co2.thresholds must be a list" ) if not value: raise ValueError( "co2.thresholds cannot be empty" ) result = [] previous_ppm = None previous_speed = None for index, item in enumerate(value): item = _require_dict( f"co2.thresholds[{index}]", item, ) unknown = set(item) - { "ppm", "speed", } if unknown: raise ValueError( f"Unknown fields in " f"co2.thresholds[{index}]: " f"{sorted(unknown)}" ) if "ppm" not in item: raise ValueError( f"co2.thresholds[{index}].ppm " f"is required" ) if "speed" not in item: raise ValueError( f"co2.thresholds[{index}].speed " f"is required" ) ppm = item["ppm"] if type(ppm) is not int: raise ValueError( f"co2.thresholds[{index}].ppm " f"must be an integer" ) if ppm <= 0: raise ValueError( f"co2.thresholds[{index}].ppm " f"must be > 0" ) speed = _parse_speed( ( f"co2.thresholds" f"[{index}].speed" ), item["speed"], ) if ( previous_ppm is not None and ppm <= previous_ppm ): raise ValueError( "CO2 thresholds must be " "strictly increasing" ) if ( previous_speed is not None and speed <= previous_speed ): raise ValueError( "AUTO speeds must be " "strictly increasing" ) result.append( ( ppm, speed, ) ) previous_ppm = ppm previous_speed = speed return tuple(result) def _parse_co2(value: Any) -> Co2Config: data = _require_dict( "co2", value, ) unknown = set(data) - { "base_speed", "hysteresis", "thresholds", } if unknown: raise ValueError( f"Unknown CO2 config fields: " f"{sorted(unknown)}" ) if "base_speed" not in data: raise ValueError( "co2.base_speed is required" ) if "hysteresis" not in data: raise ValueError( "co2.hysteresis is required" ) if "thresholds" not in data: raise ValueError( "co2.thresholds is required" ) base_speed = _parse_speed( "co2.base_speed", data["base_speed"], ) hysteresis = data["hysteresis"] if type(hysteresis) is not int: raise ValueError( "co2.hysteresis must be " "an integer" ) if hysteresis < 0: raise ValueError( "co2.hysteresis must be >= 0" ) thresholds = _parse_thresholds( data["thresholds"] ) first_speed = thresholds[0][1] if first_speed <= base_speed: raise ValueError( "First threshold speed must be " "greater than base_speed" ) return Co2Config( base_speed=base_speed, hysteresis=hysteresis, thresholds=thresholds, ) def _parse_temperature(value: Any) -> TemperatureConfig: data = _require_dict( "temperature", value, ) unknown = ( set(data) - { "hysteresis", } ) if unknown: raise ValueError( f"Unknown temperature config fields: " f"{sorted(unknown)}" ) hysteresis = data.get( "hysteresis" ) if ( type(hysteresis) not in { int, float, } ): raise ValueError( "temperature.hysteresis " "must be a number" ) hysteresis = float(hysteresis) if hysteresis < 0: raise ValueError( "temperature.hysteresis " "must be >= 0" ) return TemperatureConfig( hysteresis=hysteresis, ) def _parse_elica_assist(value: Any) -> ElicaAssistConfig: data = _require_dict( "elica_assist", value, ) unknown = ( set(data) - { "enabled", "speed_map", } ) if unknown: raise ValueError( "Unknown elica_assist config fields: " f"{sorted(unknown)}" ) enabled = data.get("enabled") if type(enabled) is not bool: raise ValueError( "elica_assist.enabled " "must be a boolean" ) speed_map_data = data.get( "speed_map" ) if not isinstance( speed_map_data, dict, ): raise ValueError( "elica_assist.speed_map " "must be an object" ) speed_map = [] for tion_speed, elica_speed in ( speed_map_data.items() ): if type(tion_speed) is not int: raise ValueError( "elica_assist.speed_map keys " "must be integers" ) if not ( MIN_FAN_SPEED <= tion_speed <= MAX_FAN_SPEED ): raise ValueError( "Tion speed in " "elica_assist.speed_map " f"must be between " f"{MIN_FAN_SPEED} and " f"{MAX_FAN_SPEED}" ) if type(elica_speed) is not int: raise ValueError( "Elica speed in " "elica_assist.speed_map " "must be an integer" ) if not 1 <= elica_speed <= 4: raise ValueError( "Elica speed in " "elica_assist.speed_map " "must be between 1 and 4" ) speed_map.append( ( tion_speed, elica_speed, ) ) speed_map.sort() return ElicaAssistConfig( enabled=enabled, speed_map=tuple(speed_map), ) def _load_auto_root(path: str | Path) -> tuple[dict, int, float]: path = Path(path) with path.open( "r", encoding="utf-8", ) as file: raw = yaml.safe_load(file) data = _require_dict( "AUTO config", raw, ) unknown = set(data) - { "version", "check_interval", "co2", "temperature", "elica_assist", } if unknown: raise ValueError( f"Unknown AUTO config fields: " f"{sorted(unknown)}" ) version = data.get("version") if version != 1: raise ValueError( f"Unsupported AUTO config " f"version: {version!r}" ) check_interval = data.get( "check_interval" ) if ( type(check_interval) not in {int,float,} ): raise ValueError( "check_interval must be a number" ) if check_interval <= 0: raise ValueError( "check_interval must be > 0" ) return (data, version, float(check_interval)) def load_auto_config( path: str | Path, ) -> AutoConfig: ( data, version, check_interval, ) = _load_auto_root(path) # -------------------------------------------------- # CO2 # -------------------------------------------------- if "co2" not in data: raise ValueError("co2 config is required") co2 = _parse_co2(data["co2"]) # -------------------------------------------------- # Temperature # -------------------------------------------------- if "temperature" not in data: raise ValueError("temperature config is required") temperature = _parse_temperature(data["temperature"]) # -------------------------------------------------- # Elica Auto Assist # -------------------------------------------------- if "elica_assist" not in data: raise ValueError("elica_assist config is required") elica_assist = _parse_elica_assist(data["elica_assist"]) return AutoConfig( version=version, check_interval=check_interval, co2=co2, temperature=temperature, elica_assist=elica_assist, ) def load_auto_config_components(path: str | Path) -> AutoConfigComponents: ( data, version, check_interval, ) = _load_auto_root(path) errors: dict[str, str] = {} # -------------------------------------------------- # CO2 # -------------------------------------------------- co2 = None if "co2" not in data: errors["co2"] = "ValueError: co2 config is required" else: try: co2 = _parse_co2(data["co2"]) except Exception as exc: errors["co2"] = ( f"{type(exc).__name__}: {exc}" ) # -------------------------------------------------- # Temperature # -------------------------------------------------- temperature = None if "temperature" not in data: errors["temperature"] = "ValueError: temperature config is required" else: try: temperature = _parse_temperature(data["temperature"]) except Exception as exc: errors["temperature"] = ( f"{type(exc).__name__}: {exc}" ) # -------------------------------------------------- # Elica Assist # -------------------------------------------------- elica_assist = None if "elica_assist" not in data: errors["elica_assist"] = "ValueError: elica_assist config is required" else: try: elica_assist = _parse_elica_assist(data["elica_assist"]) except Exception as exc: errors["elica_assist"] = ( f"{type(exc).__name__}: {exc}" ) return AutoConfigComponents( version=version, check_interval=check_interval, co2=co2, temperature=temperature, elica_assist=elica_assist, errors=errors, )