AIRZONECLOUD

[ernestomedinanievas]

""Platform error 'climate' from integration 'airzonecloud' - cannot import name 'TEMP_CELSIUS' from 'homeassistant.const' (/usr/src/homeassistant/homeassistant/const.py)""

desde la ultima actualización de home assistant sale este error y por lo tanto ha dejado de funcionar

[ernestomedinanievas]

he editado y copiado todo tal y como me has dicho, y ahora sale este mensaje "Platform error 'climate' from integration 'airzonecloud' - Exception importing custom_components.airzonecloud.climate"

…

________________________________ De: Reister777 ***@***.***> Enviado: martes, 7 de enero de 2025 17:43 Para: max13fr/Airzonecloud-HomeAssistant ***@***.***> Cc: ernestomedinanievas ***@***.***>; Author ***@***.***> Asunto: Re: [max13fr/Airzonecloud-HomeAssistant] AIRZONECLOUD (Issue #40) I've fixed the issue (and others) with the help of ChatGPT. Just edit the file climate.py with this: import logging from typing import Any, Dict, List, Optional from datetime import timedelta from homeassistant.const import UnitOfTemperature, ATTR_TEMPERATURE from homeassistant.util.unit_conversion import TemperatureConverter from homeassistant.components.climate import ClimateEntity, ClimateEntityFeature from homeassistant.components.climate.const import HVACMode from .const import CONF_USERNAME, CONF_PASSWORD from AirzoneCloud import AirzoneCloud init logger _LOGGER = logging.getLogger(name) default refresh interval SCAN_INTERVAL = timedelta(seconds=10) AIRZONECLOUD_HVAC_MODES = [ HVACMode.OFF, HVACMode.HEAT, HVACMode.COOL, HVACMode.DRY, HVACMode.FAN_ONLY, ] async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the Airzonecloud platform asynchronously.""" username = config.get(CONF_USERNAME) password = config.get(CONF_PASSWORD) if username is None or password is None: _LOGGER.error("Missing username or password config") return api = None try: api = await hass.async_add_executor_job(AirzoneCloud, username, password) except Exception as err: _LOGGER.error("Error initializing AirzoneCloud: %s", err) await hass.services.async_call( "persistent_notification", "create", {"title": "Airzonecloud error", "message": str(err)}, ) return entities = [] for installation in api.installations: for group in installation.groups: entities.append(AirzonecloudGroup(group)) for device in group.devices: entities.append(AirzonecloudDevice(device)) async_add_entities(entities) class AirzonecloudDevice(ClimateEntity): """Representation of an Airzonecloud Device (a thermostat zone)""" def __init__(self, device): """Initialize the device""" self._device = device _LOGGER.info("init device {} ({})".format(self.name, self.unique_id)) @Property def unique_id(self) -> Optional[str]: """Return a unique ID.""" return "device_" + self._device.id @Property def name(self): """Return the name of the sensor.""" return "{} - {}".format(self._device.group.name, self._device.name) @Property def temperature_unit(self): """Return the unit of measurement used by the platform.""" return UnitOfTemperature.CELSIUS @Property def hvac_mode(self) -> str: """Return hvac operation ie. heat, cool mode.""" mode = self._device.mode if self._device.is_on: if mode in [ "cooling", "air-cooling", "radiant-cooling", "combined-cooling", ]: return HVACMode.COOL if mode in [ "heating", "air-heating", "radiant-heating", "combined-heating", "emergency-heating", ]: return HVACMode.HEAT if mode == "ventilation": return HVACMode.FAN_ONLY if mode == "dehumidify": return HVACMode.DRY return HVACMode.OFF @Property def hvac_modes(self) -> List[str]: """Return the list of available hvac operation modes.""" return AIRZONECLOUD_HVAC_MODES @Property def fan_mode(self) -> Optional[str]: """Return the current fan mode.""" return self._device.fan_mode if hasattr(self._device, "fan_mode") else "auto" @Property def fan_modes(self) -> Optional[List[str]]: """Return the list of available fan modes.""" return ["auto", "low", "medium", "high"] @Property def supported_features(self) -> int: """Return the list of supported features.""" return ClimateEntityFeature.TARGET_TEMPERATURE | ClimateEntityFeature.FAN_MODE class AirzonecloudGroup(ClimateEntity): """Representation of an Airzonecloud Group (the air conditioner hardware)""" def __init__(self, group): """Initialize the group""" self._group = group _LOGGER.info("init group {} ({})".format(self.name, self.unique_id)) @Property def unique_id(self) -> Optional[str]: """Return a unique ID.""" return "group_" + self._group.id @Property def name(self): """Return the name of the sensor.""" return "{}".format(self._group.name) @Property def temperature_unit(self): """Return the unit of measurement used by the platform.""" return UnitOfTemperature.CELSIUS @Property def hvac_mode(self) -> str: """Return the current HVAC mode for the group.""" mode = self._group.mode if self._group.is_on: if mode in ["cooling", "air-cooling", "radiant-cooling", "combined-cooling"]: return HVACMode.COOL if mode in ["heating", "air-heating", "radiant-heating", "combined-heating", "emergency-heating"]: return HVACMode.HEAT if mode == "ventilation": return HVACMode.FAN_ONLY if mode == "dehumidify": return HVACMode.DRY return HVACMode.OFF @Property def hvac_modes(self) -> List[str]: """Return the list of available HVAC operation modes.""" return AIRZONECLOUD_HVAC_MODES @Property def supported_features(self) -> int: """Return the list of supported features.""" return ClimateEntityFeature(0) async def async_update(self): """Update the group state asynchronously.""" await hass.async_add_executor_job(self._group.refresh_devices) — Reply to this email directly, view it on GitHub<#40 (comment)>, or unsubscribe<https://github.com/notifications/unsubscribe-auth/AOTH52KAGSDFLSNHQQQUHVD2JP72VAVCNFSM6AAAAABUVMYJZWVHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHMZDKNZVG43DINBUHA>. You are receiving this because you authored the thread.Message ID: ***@***.***>

[Reister777]

Indeed in the end doesn't work, I'll try something later.

[Reister777]

Here it is the code fixed @max13fr please take a look:

import logging
from typing import Any, Dict, List, Optional
from datetime import timedelta

# Cambiamos TEMP_CELSIUS por UnitOfTemperature, mantenemos ATTR_TEMPERATURE
from homeassistant.const import UnitOfTemperature, ATTR_TEMPERATURE
from homeassistant.util.unit_conversion import TemperatureConverter

# Importamos ClimateEntity y ClimateEntityFeature
from homeassistant.components.climate import ClimateEntity, ClimateEntityFeature

# Definimos localmente los modos HVAC para evitar el ImportError
HVAC_MODE_OFF = "off"
HVAC_MODE_HEAT = "heat"
HVAC_MODE_COOL = "cool"
HVAC_MODE_DRY = "dry"
HVAC_MODE_FAN_ONLY = "fan_only"

# Este valor es equivalente a "soportar la temperatura objetivo" (era SUPPORT_TARGET_TEMPERATURE).
# Devuelve un IntFlag oficial de HA, no uno nuestro, para no chocar con las comparaciones internas.
SUPPORT_TARGET_TEMPERATURE = ClimateEntityFeature.TARGET_TEMPERATURE

from .const import CONF_USERNAME, CONF_PASSWORD

# init logger
_LOGGER = logging.getLogger(__name__)

# default refresh interval
SCAN_INTERVAL = timedelta(seconds=10)

AIRZONECLOUD_HVAC_MODES = [
    HVAC_MODE_OFF,
    HVAC_MODE_HEAT,
    HVAC_MODE_COOL,
    HVAC_MODE_DRY,
    HVAC_MODE_FAN_ONLY,
]


def setup_platform(hass, config, add_entities, discovery_info=None):
    """Set up the Airzonecloud platform"""
    username = config.get(CONF_USERNAME)
    password = config.get(CONF_PASSWORD)
    if username is None or password is None:
        _LOGGER.error("missing username or password config")
        return

    from AirzoneCloud import AirzoneCloud

    api = None
    try:
        api = AirzoneCloud(username, password)
    except Exception as err:
        _LOGGER.error(err)
        hass.services.call(
            "persistent_notification",
            "create",
            {"title": "Airzonecloud error", "message": str(err)},
        )
        return

    entities = []
    for installation in api.installations:
        for group in installation.groups:
            entities.append(AirzonecloudGroup(group))
            for device in group.devices:
                entities.append(AirzonecloudDevice(device))

    add_entities(entities)


class AirzonecloudDevice(ClimateEntity):
    """Representation of an Airzonecloud Device (a thermostat zone)"""

    def __init__(self, device):
        """Initialize the device"""
        self._device = device
        _LOGGER.info("init device {} ({})".format(self.name, self.unique_id))

    @property
    def unique_id(self) -> Optional[str]:
        """Return a unique ID."""
        return "device_" + self._device.id

    @property
    def name(self):
        """Return the name of the sensor."""
        return "{} - {}".format(self._device.group.name, self._device.name)

    @property
    def temperature_unit(self):
        """Return the unit of measurement used by the platform."""
        return UnitOfTemperature.CELSIUS

    @property
    def hvac_mode(self) -> str:
        """Return hvac operation ie. heat, cool mode."""
        mode = self._device.mode

        if self._device.is_on:
            if mode in ["cooling", "air-cooling", "radiant-cooling", "combined-cooling"]:
                return HVAC_MODE_COOL

            if mode in [
                "heating",
                "air-heating",
                "radiant-heating",
                "combined-heating",
                "emergency-heating",
            ]:
                return HVAC_MODE_HEAT

            if mode == "ventilation":
                return HVAC_MODE_FAN_ONLY

            if mode == "dehumidify":
                return HVAC_MODE_DRY

        return HVAC_MODE_OFF

    @property
    def hvac_modes(self) -> List[str]:
        """Return the list of available hvac operation modes."""
        return AIRZONECLOUD_HVAC_MODES

    @property
    def current_humidity(self) -> Optional[float]:
        """Return the current humidity."""
        return self._device.current_humidity

    @property
    def current_temperature(self) -> Optional[float]:
        """Return the current temperature."""
        return self._device.current_temperature

    @property
    def target_temperature(self) -> Optional[float]:
        """Return the temperature we try to reach."""
        return self._device.target_temperature

    @property
    def target_temperature_step(self) -> Optional[float]:
        """Return the supported step of target temperature."""
        return self._device.step_temperature

    @property
    def supported_features(self):
        """Return the list of supported features as an IntFlag of Home Assistant."""
        return SUPPORT_TARGET_TEMPERATURE

    @property
    def min_temp(self) -> float:
        """Return the minimum temperature."""
        return TemperatureConverter.convert(
            self._device.min_temperature, UnitOfTemperature.CELSIUS, self.temperature_unit
        )

    @property
    def max_temp(self) -> float:
        """Return the maximum temperature."""
        return TemperatureConverter.convert(
            self._device.max_temperature, UnitOfTemperature.CELSIUS, self.temperature_unit
        )

    def set_temperature(self, **kwargs) -> None:
        """Set new target temperature."""
        temperature = kwargs.get(ATTR_TEMPERATURE)
        if temperature is not None:
            self._device.set_temperature(round(float(temperature), 1))

    def set_hvac_mode(self, hvac_mode: str) -> None:
        """Set new target hvac mode."""
        if hvac_mode == HVAC_MODE_OFF:
            self._device.turn_off()
        else:
            if not self._device.is_on:
                self._device.turn_on(auto_refresh=False)

            # set hvac mode on parent system
            if hvac_mode == HVAC_MODE_HEAT:
                self._device.group.set_mode("heating")
            elif hvac_mode == HVAC_MODE_COOL:
                self._device.group.set_mode("cooling")
            elif hvac_mode == HVAC_MODE_DRY:
                self._device.group.set_mode("dehumidify")
            elif hvac_mode == HVAC_MODE_FAN_ONLY:
                self._device.group.set_mode("ventilation")

    def turn_on(self):
        """Turn on."""
        self._device.turn_on()

    def turn_off(self):
        """Turn off."""
        self._device.turn_off()


class AirzonecloudGroup(ClimateEntity):
    """Representation of an Airzonecloud Group (the air conditioner hardware)"""

    def __init__(self, group):
        """Initialize the group"""
        self._group = group
        _LOGGER.info("init group {} ({})".format(self.name, self.unique_id))

    @property
    def unique_id(self) -> Optional[str]:
        """Return a unique ID."""
        return "group_" + self._group.id

    @property
    def name(self):
        """Return the name of the sensor."""
        return "{}".format(self._group.name)

    @property
    def temperature_unit(self):
        """Return the unit of measurement used by the platform."""
        return UnitOfTemperature.CELSIUS

    @property
    def hvac_mode(self) -> str:
        """Return hvac operation ie. heat, cool mode."""
        mode = self._group.mode

        if self._group.is_on:
            if mode in ["cooling", "air-cooling", "radiant-cooling", "combined-cooling"]:
                return HVAC_MODE_COOL

            if mode in [
                "heating",
                "air-heating",
                "radiant-heating",
                "combined-heating",
                "emergency-heating",
            ]:
                return HVAC_MODE_HEAT

            if mode == "ventilation":
                return HVAC_MODE_FAN_ONLY

            if mode == "dehumidify":
                return HVAC_MODE_DRY

        return HVAC_MODE_OFF

    @property
    def hvac_modes(self) -> List[str]:
        """Return the list of available hvac operation modes."""
        return AIRZONECLOUD_HVAC_MODES

    @property
    def supported_features(self):
        """
        Este Group no soporta ajuste de temperatura.
        Devolvemos 0 para que sea un IntFlag válido y no dé error.
        """
        return ClimateEntityFeature(0)

    def set_hvac_mode(self, hvac_mode: str) -> None:
        """Set new target hvac mode."""
        if hvac_mode == HVAC_MODE_OFF:
            self._group.set_mode("stop")
        elif hvac_mode == HVAC_MODE_HEAT:
            self._group.set_mode("heating")
        elif hvac_mode == HVAC_MODE_COOL:
            self._group.set_mode("cooling")
        elif hvac_mode == HVAC_MODE_DRY:
            self._group.set_mode("dehumidify")
        elif hvac_mode == HVAC_MODE_FAN_ONLY:
            self._group.set_mode("ventilation")

    def turn_on(self):
        """Turn on."""
        self._group.turn_on()

    def turn_off(self):
        """Turn off."""
        self._group.turn_off()

    def update(self):
        """Refresh devices from the Airzonecloud API."""
        self._group.refresh_devices()

[max13fr]

Hello,

Sorry I don't use this plugin anymore (as my old airzone webserver hardware died, so I bought a new card compatible with https://www.home-assistant.io/integrations/airzone/). In addition, I lack free time a lot.

I push a proper fix on climate.py, can you check it's fix the issue before I publish a new version to be clean ?

[Reister777]

Hi, it is working!

Thanks!

[pgpana]

Hello to everybody.
I tested It but It does not work on my HA system.
Can you confirm that same code fix the issues?

[pgpana]

I added a line at the top with instruction:
import logging

Now It seems working.

[Reister777]

Hello,

Sorry I don't use this plugin anymore (as my old airzone webserver hardware died, so I bought a new card compatible with https://www.home-assistant.io/integrations/airzone/). In addition, I lack free time a lot.

I push a proper fix on climate.py, can you check it's fix the issue before I publish a new version to be clean ?

It is not working. You are missing some more fixes from my code like:
HVAC_MODE_OFF = "off"
HVAC_MODE_HEAT = "heat"
HVAC_MODE_COOL = "cool"
HVAC_MODE_DRY = "dry"
HVAC_MODE_FAN_ONLY = "fan_only"

[Reister777]

I added a line at the top with instruction: import logging

Now It seems working.

Sorry indeed an issue with the quotes in my comment skipped the first line. Fixed in my code.

[max13fr]

Hello,

Sorry for my mistake, can you retry now with the last version of climate.py in the repo ?

Max

[Reister777]

Hello @max13fr
I still think we need to check:

Importing HVACMode vs. Local Constants

The new code imports HVACMode (e.g., HVACMode.HEAT, HVACMode.OFF) from homeassistant.components.climate.const.
In some Home Assistant versions, these enums are no longer available or have changed, so we previously defined local constants like HVAC_MODE_OFF = "off" to avoid import errors.

Using UnitOfTemperature.TEMP_CELSIUS vs. UnitOfTemperature.CELSIUS

The new code references UnitOfTemperature.TEMP_CELSIUS.
In more recent Home Assistant versions, the preferred (or only) option might be UnitOfTemperature.CELSIUS.
Depending on the version, UnitOfTemperature.TEMP_CELSIUS may still work, or it might have been deprecated/removed.

Relying on ClimateEntityFeature vs. Local IntFlags

The new code uses ClimateEntityFeature.TARGET_TEMPERATURE directly.
In certain Home Assistant versions, returning a plain integer for supported features could lead to errors (TypeError: argument of type 'int' is not iterable).
We sometimes introduced our own IntFlag or used the built-in ClimateEntityFeature differently to avoid compatibility issues.

[Reister777]

And here you can see the code with the comments in English (sorry for the first post in Spanish):

import logging
from typing import Any, Dict, List, Optional
from datetime import timedelta

# Replace TEMP_CELSIUS with UnitOfTemperature.CELSIUS.
# Keep ATTR_TEMPERATURE from homeassistant.const.
from homeassistant.const import UnitOfTemperature, ATTR_TEMPERATURE
from homeassistant.util.unit_conversion import TemperatureConverter

# Import only ClimateEntity to avoid potential import issues with modes/features in some HA versions.
from homeassistant.components.climate import ClimateEntity

# If needed, define local HVAC modes to avoid ImportError in newer HA versions.
HVAC_MODE_OFF = "off"
HVAC_MODE_HEAT = "heat"
HVAC_MODE_COOL = "cool"
HVAC_MODE_DRY = "dry"
HVAC_MODE_FAN_ONLY = "fan_only"

# Some newer HA versions expect climate feature flags as IntFlags, not just int.
from enum import IntFlag

class MyClimateEntityFeature(IntFlag):
    TARGET_TEMPERATURE = 1

# Equivalent to the old SUPPORT_TARGET_TEMPERATURE:
SUPPORT_TARGET_TEMPERATURE = MyClimateEntityFeature.TARGET_TEMPERATURE

# Import user credentials or config keys from a local const file:
from .const import CONF_USERNAME, CONF_PASSWORD

_LOGGER = logging.getLogger(__name__)

# Default refresh interval
SCAN_INTERVAL = timedelta(seconds=10)

AIRZONECLOUD_HVAC_MODES = [
    HVAC_MODE_OFF,
    HVAC_MODE_HEAT,
    HVAC_MODE_COOL,
    HVAC_MODE_DRY,
    HVAC_MODE_FAN_ONLY,
]

def setup_platform(hass, config, add_entities, discovery_info=None):
    """Set up the AirzoneCloud platform in Home Assistant."""
    username = config.get(CONF_USERNAME)
    password = config.get(CONF_PASSWORD)
    if username is None or password is None:
        _LOGGER.error("Missing username or password in config")
        return

    from AirzoneCloud import AirzoneCloud

    api = None
    try:
        api = AirzoneCloud(username, password)
    except Exception as err:
        _LOGGER.error(err)
        hass.services.call(
            "persistent_notification",
            "create",
            {"title": "AirzoneCloud error", "message": str(err)},
        )
        return

    entities = []
    for installation in api.installations:
        for group in installation.groups:
            entities.append(AirzonecloudGroup(group))
            for device in group.devices:
                entities.append(AirzonecloudDevice(device))

    add_entities(entities)


class AirzonecloudDevice(ClimateEntity):
    """Represents an AirzoneCloud Device (a thermostat zone)."""

    def __init__(self, device):
        """Initialize the device."""
        self._device = device
        _LOGGER.info("Initializing device %s (%s)", self.name, self.unique_id)

    @property
    def unique_id(self) -> Optional[str]:
        """Return a unique ID for this device."""
        return "device_" + self._device.id

    @property
    def name(self):
        """Return the name of the device."""
        return f"{self._device.group.name} - {self._device.name}"

    @property
    def temperature_unit(self):
        """Return the temperature unit used by this device."""
        return UnitOfTemperature.CELSIUS

    @property
    def hvac_mode(self) -> str:
        """Return the current HVAC mode (heat, cool, etc.)."""
        mode = self._device.mode

        if self._device.is_on:
            if mode in [
                "cooling",
                "air-cooling",
                "radiant-cooling",
                "combined-cooling",
            ]:
                return HVAC_MODE_COOL

            if mode in [
                "heating",
                "air-heating",
                "radiant-heating",
                "combined-heating",
                "emergency-heating",
            ]:
                return HVAC_MODE_HEAT

            if mode == "ventilation":
                return HVAC_MODE_FAN_ONLY

            if mode == "dehumidify":
                return HVAC_MODE_DRY

        return HVAC_MODE_OFF

    @property
    def hvac_modes(self) -> List[str]:
        """Return the list of supported HVAC modes."""
        return AIRZONECLOUD_HVAC_MODES

    @property
    def current_humidity(self) -> Optional[float]:
        """Return the current relative humidity."""
        return self._device.current_humidity

    @property
    def current_temperature(self) -> Optional[float]:
        """Return the current temperature."""
        return self._device.current_temperature

    @property
    def target_temperature(self) -> Optional[float]:
        """Return the target temperature."""
        return self._device.target_temperature

    @property
    def target_temperature_step(self) -> Optional[float]:
        """Return the increment step for target temperature changes."""
        return self._device.step_temperature

    @property
    def supported_features(self):
        """
        Return supported features as an IntFlag.

        In newer HA versions, comparisons like 
        `if ClimateEntityFeature.TARGET_HUMIDITY in supported_features:` 
        expect a flag, not an int.
        """
        return SUPPORT_TARGET_TEMPERATURE

    @property
    def min_temp(self) -> float:
        """Return the minimum allowed temperature."""
        return TemperatureConverter.convert(
            self._device.min_temperature,
            UnitOfTemperature.CELSIUS,
            self.temperature_unit,
        )

    @property
    def max_temp(self) -> float:
        """Return the maximum allowed temperature."""
        return TemperatureConverter.convert(
            self._device.max_temperature,
            UnitOfTemperature.CELSIUS,
            self.temperature_unit,
        )

    def set_temperature(self, **kwargs) -> None:
        """Set the new target temperature."""
        temperature = kwargs.get(ATTR_TEMPERATURE)
        if temperature is not None:
            self._device.set_temperature(round(float(temperature), 1))

    def set_hvac_mode(self, hvac_mode: str) -> None:
        """Set a new HVAC mode."""
        if hvac_mode == HVAC_MODE_OFF:
            self._device.turn_off()
        else:
            if not self._device.is_on:
                self._device.turn_on(auto_refresh=False)

            # Update the parent system's mode.
            if hvac_mode == HVAC_MODE_HEAT:
                self._device.group.set_mode("heating")
            elif hvac_mode == HVAC_MODE_COOL:
                self._device.group.set_mode("cooling")
            elif hvac_mode == HVAC_MODE_DRY:
                self._device.group.set_mode("dehumidify")
            elif hvac_mode == HVAC_MODE_FAN_ONLY:
                self._device.group.set_mode("ventilation")

    def turn_on(self):
        """Turn on the device."""
        self._device.turn_on()

    def turn_off(self):
        """Turn off the device."""
        self._device.turn_off()


class AirzonecloudGroup(ClimateEntity):
    """Represents an AirzoneCloud Group (the main AC hardware)."""

    def __init__(self, group):
        """Initialize the group."""
        self._group = group
        _LOGGER.info("Initializing group %s (%s)", self.name, self.unique_id)

    @property
    def unique_id(self) -> Optional[str]:
        """Return a unique ID for this group."""
        return "group_" + self._group.id

    @property
    def name(self):
        """Return the group's name."""
        return f"{self._group.name}"

    @property
    def temperature_unit(self):
        """Return the temperature unit used by this group."""
        return UnitOfTemperature.CELSIUS

    @property
    def hvac_mode(self) -> str:
        """Return the current HVAC mode for this group."""
        mode = self._group.mode

        if self._group.is_on:
            if mode in [
                "cooling",
                "air-cooling",
                "radiant-cooling",
                "combined-cooling",
            ]:
                return HVAC_MODE_COOL

            if mode in [
                "heating",
                "air-heating",
                "radiant-heating",
                "combined-heating",
                "emergency-heating",
            ]:
                return HVAC_MODE_HEAT

            if mode == "ventilation":
                return HVAC_MODE_FAN_ONLY

            if mode == "dehumidify":
                return HVAC_MODE_DRY

        return HVAC_MODE_OFF

    @property
    def hvac_modes(self) -> List[str]:
        """Return the list of available HVAC modes for this group."""
        return AIRZONECLOUD_HVAC_MODES

    @property
    def supported_features(self):
        """
        Return 0 if this group does not support changing temperature.
        Must return an IntFlag to avoid comparison errors in HA code.
        """
        return MyClimateEntityFeature(0)

    def set_hvac_mode(self, hvac_mode: str) -> None:
        """Set a new HVAC mode for the group."""
        if hvac_mode == HVAC_MODE_OFF:
            self._group.set_mode("stop")
        elif hvac_mode == HVAC_MODE_HEAT:
            self._group.set_mode("heating")
        elif hvac_mode == HVAC_MODE_COOL:
            self._group.set_mode("cooling")
        elif hvac_mode == HVAC_MODE_DRY:
            self._group.set_mode("dehumidify")
        elif hvac_mode == HVAC_MODE_FAN_ONLY:
            self._group.set_mode("ventilation")

    def turn_on(self):
        """Turn on the group."""
        self._group.turn_on()

    def turn_off(self):
        """Turn off the group."""
        self._group.turn_off()

    def update(self):
        """Refresh the group's devices from the AirzoneCloud API."""
        self._group.refresh_devices()

Key Points
We define local HVAC_MODE_* constants to avoid import errors in newer Home Assistant versions (if HVACMode is missing).
We replaced TEMP_CELSIUS with UnitOfTemperature.CELSIUS.
We use an IntFlag for supported_features to prevent the TypeError: argument of type 'int' is not iterable.
Everything else (class names, methods, logic) is the same as the original

[ernestomedinanievas]

he copiado el ultimo codigo y he reiniciado, el error de reinicio en home assistant ya no sale pero la integracion sigue sin funcionar, no lee datos y todas las entidades estan fuera de linea

[Reister777]

Pon el error de los logs,a mí me funciona correctamente

[ernestomedinanievas]

Pon el error de los logs,a mí me funciona correctamente

no me da error de nada, simplemente no lee, no realizado ningun cambio solo he editado el archivo y copiado todo el codigo del mensaje anterior, nada mas