Утилиты¶

Конвертер цветов¶

Преобразование цветовых моделей между HA (HSV 0-360/0-100/0-100) и Sber (H 0-360, S/V 0-1000).

Color conversion utilities between Home Assistant and Sber HSV color spaces.

ColorConverter ¶

Bidirectional HSV color converter between HA and Sber color spaces.

HA uses: - Hue: 0-360 degrees - Saturation: 0-100% - Brightness (Value): 0-255

Sber uses: - Hue: 0-360 degrees - Saturation: 0-1000 - Value: 100-1000

ha_to_sber_hsv `staticmethod` ¶

ha_to_sber_hsv(ha_hue, ha_saturation, ha_brightness)

Convert HA HSV color values to Sber HSV format.

Conversion rules: - H: 0-360 -> 0-360 (no change) - S: 0-100% -> 0-1000 (multiply by 10) - V: 0-255 -> 100-1000 (linear mapping)

Parameters:

Name	Type	Description	Default
`ha_hue`	`float \| None`	Hue in degrees (0-360), or None for default 0.	required
`ha_saturation`	`float \| None`	Saturation percentage (0-100), or None for default 0.	required
`ha_brightness`	`float \| None`	Brightness value (0-255), or None for default 0.	required

Returns:

Type	Description
`tuple[int, int, int]`	Tuple of (sber_hue, sber_saturation, sber_value) as integers.

Source code in custom_components/sber_mqtt_bridge/devices/utils/color_converter.py

@staticmethod
def ha_to_sber_hsv(
    ha_hue: float | None,
    ha_saturation: float | None,
    ha_brightness: float | None,
) -> tuple[int, int, int]:
    """Convert HA HSV color values to Sber HSV format.

    Conversion rules:
    - H: 0-360 -> 0-360 (no change)
    - S: 0-100% -> 0-1000 (multiply by 10)
    - V: 0-255 -> 100-1000 (linear mapping)

    Args:
        ha_hue: Hue in degrees (0-360), or None for default 0.
        ha_saturation: Saturation percentage (0-100), or None for default 0.
        ha_brightness: Brightness value (0-255), or None for default 0.

    Returns:
        Tuple of (sber_hue, sber_saturation, sber_value) as integers.
    """
    # Нормализация значений HA
    ha_hue = max(0, min(360, ha_hue if ha_hue is not None else 0))  # H: 0–360
    ha_saturation = max(0, min(100, ha_saturation if ha_saturation is not None else 0))  # S: 0–100%
    ha_brightness = int(max(0, min(255, ha_brightness if ha_brightness is not None else 0)))  # V: 0–255

    # Конвертация в Sber HSV
    sber_hue = ha_hue
    sber_saturation = ha_saturation * 10  # 0–100% → 0–1000
    sber_value = (ha_brightness / 255) * 900 + 100  # 0–255 → 100–1000

    return round(sber_hue), round(sber_saturation), round(sber_value)

sber_to_ha_hsv `staticmethod` ¶

sber_to_ha_hsv(sber_hue, sber_saturation, sber_value)

Convert Sber HSV color values to HA HSV format.

Conversion rules: - H: 0-360 -> 0-360 (no change) - S: 0-1000 -> 0-100% (divide by 10) - V: 100-1000 -> 0-255 (linear mapping)

Parameters:

Name	Type	Description	Default
`sber_hue`	`float \| None`	Hue in degrees (0-360), or None for default 0.	required
`sber_saturation`	`float \| None`	Saturation (0-1000), or None for default 0.	required
`sber_value`	`float \| None`	Value/brightness (100-1000), or None for default 0.	required

Returns:

Type	Description
`tuple[int, int, int]`	Tuple of (ha_hue, ha_saturation, ha_brightness) as integers.

Source code in custom_components/sber_mqtt_bridge/devices/utils/color_converter.py

@staticmethod
def sber_to_ha_hsv(
    sber_hue: float | None,
    sber_saturation: float | None,
    sber_value: float | None,
) -> tuple[int, int, int]:
    """Convert Sber HSV color values to HA HSV format.

    Conversion rules:
    - H: 0-360 -> 0-360 (no change)
    - S: 0-1000 -> 0-100% (divide by 10)
    - V: 100-1000 -> 0-255 (linear mapping)

    Args:
        sber_hue: Hue in degrees (0-360), or None for default 0.
        sber_saturation: Saturation (0-1000), or None for default 0.
        sber_value: Value/brightness (100-1000), or None for default 0.

    Returns:
        Tuple of (ha_hue, ha_saturation, ha_brightness) as integers.
    """
    # Нормализация значений Sber
    sber_hue = max(0, min(360, sber_hue if sber_hue is not None else 0))  # H: 0–360
    sber_saturation = max(0, min(1000, sber_saturation if sber_saturation is not None else 0))  # S: 0–1000
    if sber_value is None:
        sber_value = 0
    sber_value = max(0, min(1000, sber_value))  # V: 0–1000 (values <100 map to brightness 0)

    # Конвертация в HA HSV
    ha_hue = sber_hue
    ha_saturation = sber_saturation / 10  # 0–1000 → 0–100%
    ha_brightness = max(0.0, ((sber_value - 100) / 900) * 255)  # 100–1000 → 0–255; <100 → 0

    return round(ha_hue), round(ha_saturation), round(ha_brightness)

Линейный конвертер¶

Линейное масштабирование значений между диапазонами HA и Sber.

Linear value converter between Home Assistant and Sber numeric ranges.

LinearConverter ¶

LinearConverter()

Bidirectional linear interpolation converter between HA and Sber value ranges.

Converts numeric values between two configurable ranges using linear interpolation. Supports optional range inversion (reversed mapping).

Default ranges: - Sber side: 0-1000 - HA side: 0-255

Attributes:

Name	Type	Description
`sber_side_min`	`int`	Minimum value on the Sber side.
`sber_side_max`	`int`	Maximum value on the Sber side.
`ha_side_min`	`int`	Minimum value on the HA side.
`ha_side_max`	`int`	Maximum value on the HA side.
`is_reversed`	`bool`	Whether the Sber range is inverted relative to the HA range.

Initialize with default ranges: Sber 0-1000, HA 0-255.

Source code in custom_components/sber_mqtt_bridge/devices/utils/linear_converter.py

def __init__(self) -> None:
    """Initialize with default ranges: Sber 0-1000, HA 0-255."""
    self.sber_side_min: int = 0
    self.sber_side_max: int = 1000
    self.ha_side_min: int = 0
    self.ha_side_max: int = 255
    self.is_reversed: bool = False

set_reversed ¶

set_reversed(is_reversed)

Set whether the conversion should reverse the direction.

When reversed, the maximum Sber value maps to the minimum HA value and vice versa.

Parameters:

Name	Type	Description	Default
`is_reversed`	`bool`	True to enable reversed mapping.	required

Source code in custom_components/sber_mqtt_bridge/devices/utils/linear_converter.py

def set_reversed(self, is_reversed: bool) -> None:
    """Set whether the conversion should reverse the direction.

    When reversed, the maximum Sber value maps to the minimum HA value
    and vice versa.

    Args:
        is_reversed: True to enable reversed mapping.
    """
    self.is_reversed = is_reversed

set_sber_limits ¶

set_sber_limits(sber_side_min, sber_side_max)

Set the Sber-side value range.

Parameters:

Name	Type	Description	Default
`sber_side_min`	`int`	Minimum Sber value (must be less than max).	required
`sber_side_max`	`int`	Maximum Sber value.	required

Raises:

Type	Description
`ValueError`	If sber_side_min >= sber_side_max.

Source code in custom_components/sber_mqtt_bridge/devices/utils/linear_converter.py

def set_sber_limits(self, sber_side_min: int, sber_side_max: int) -> None:
    """Set the Sber-side value range.

    Args:
        sber_side_min: Minimum Sber value (must be less than max).
        sber_side_max: Maximum Sber value.

    Raises:
        ValueError: If sber_side_min >= sber_side_max.
    """
    if sber_side_min < sber_side_max:
        self.sber_side_min = sber_side_min
        self.sber_side_max = sber_side_max
    else:
        raise ValueError("sber_side_min must be less than sber_side_max")

set_ha_limits ¶

set_ha_limits(ha_side_min, ha_side_max)

Set the HA-side value range.

Parameters:

Name	Type	Description	Default
`ha_side_min`	`int`	Minimum HA value (must be less than max).	required
`ha_side_max`	`int`	Maximum HA value.	required

Raises:

Type	Description
`ValueError`	If ha_side_min >= ha_side_max.

Source code in custom_components/sber_mqtt_bridge/devices/utils/linear_converter.py

def set_ha_limits(self, ha_side_min: int, ha_side_max: int) -> None:
    """Set the HA-side value range.

    Args:
        ha_side_min: Minimum HA value (must be less than max).
        ha_side_max: Maximum HA value.

    Raises:
        ValueError: If ha_side_min >= ha_side_max.
    """
    if ha_side_min < ha_side_max:
        self.ha_side_min = ha_side_min
        self.ha_side_max = ha_side_max
    else:
        raise ValueError("ha_side_min must be less than ha_side_max")

sber_to_ha ¶

sber_to_ha(sber_value)

Convert a Sber-side value to the corresponding HA-side value.

Values outside the Sber range are clamped to HA min/max.

Parameters:

Name	Type	Description	Default
`sber_value`	`int \| float`	Numeric value in Sber range.	required

Returns:

Type	Description
`int`	Rounded integer value in HA range.

Source code in custom_components/sber_mqtt_bridge/devices/utils/linear_converter.py

def sber_to_ha(self, sber_value: int | float) -> int:
    """Convert a Sber-side value to the corresponding HA-side value.

    Values outside the Sber range are clamped to HA min/max.

    Args:
        sber_value: Numeric value in Sber range.

    Returns:
        Rounded integer value in HA range.
    """
    if sber_value < self.sber_side_min:
        return self.ha_side_max if self.is_reversed else self.ha_side_min
    if sber_value > self.sber_side_max:
        return self.ha_side_min if self.is_reversed else self.ha_side_max
    sber_delta = (sber_value - self.sber_side_min) if not self.is_reversed else (self.sber_side_max - sber_value)
    return round(
        sber_delta * (self.ha_side_max - self.ha_side_min) / (self.sber_side_max - self.sber_side_min)
        + self.ha_side_min
    )

ha_to_sber ¶

ha_to_sber(ha_value)

Convert an HA-side value to the corresponding Sber-side value.

Values outside the HA range are clamped to Sber min/max.

Parameters:

Name	Type	Description	Default
`ha_value`	`int \| float`	Numeric value in HA range.	required

Returns:

Type	Description
`int`	Rounded integer value in Sber range.

Source code in custom_components/sber_mqtt_bridge/devices/utils/linear_converter.py

def ha_to_sber(self, ha_value: int | float) -> int:
    """Convert an HA-side value to the corresponding Sber-side value.

    Values outside the HA range are clamped to Sber min/max.

    Args:
        ha_value: Numeric value in HA range.

    Returns:
        Rounded integer value in Sber range.
    """
    if ha_value < self.ha_side_min:
        return self.sber_side_min
    if ha_value > self.ha_side_max:
        return self.sber_side_max
    ha_delta = (ha_value - self.ha_side_min) if not self.is_reversed else (self.ha_side_max - ha_value)
    return round(
        ha_delta * (self.sber_side_max - self.sber_side_min) / (self.ha_side_max - self.ha_side_min)
        + self.sber_side_min
    )

Утилиты¶

Конвертер цветов¶

ColorConverter ¶

ha_to_sber_hsv staticmethod ¶

sber_to_ha_hsv staticmethod ¶

Линейный конвертер¶

LinearConverter ¶

set_reversed ¶

set_sber_limits ¶

set_ha_limits ¶

sber_to_ha ¶

ha_to_sber ¶

ha_to_sber_hsv `staticmethod` ¶

sber_to_ha_hsv `staticmethod` ¶