9
9
from homeassistant .helpers .entity_platform import AddEntitiesCallback
10
10
11
11
from .const import CONF_NAME , DEFAULT_NAME , DOMAIN
12
- from .entity import MhEntity
12
+ from .entity import MhEngEntity , MhEntity , MhEnvEntity , MhHeaterEntity
13
13
14
14
_logger = logging .getLogger (__package__ )
15
15
@@ -27,6 +27,7 @@ async def async_setup_entry(
27
27
async_add_entities (
28
28
[
29
29
MhSeverityBinarySensor (coordinator , entry ),
30
+ MhDataActualBinarySensor (coordinator , entry ),
30
31
]
31
32
+ list (
32
33
chain .from_iterable (
@@ -39,150 +40,129 @@ async def async_setup_entry(
39
40
)
40
41
)
41
42
+ list (
42
- MhEngBinarySensor (coordinator , entry , eng )
43
- for eng in coordinator .data .get ("engs" , [])
43
+ MhEnvSeverityBinarySensor (coordinator , entry , env )
44
+ for env in coordinator .data .get ("envs" , [])
45
+ )
46
+ + list (
47
+ chain .from_iterable (
48
+ [
49
+ MhEngTurnedOnBinarySensor (coordinator , entry , eng ),
50
+ MhEngSeverityBinarySensor (coordinator , entry , eng ),
51
+ ]
52
+ for eng in coordinator .data .get ("engs" , [])
53
+ )
44
54
)
45
55
)
46
56
47
57
48
- class MhHeaterBinarySensor (MhEntity , BinarySensorEntity ):
49
- """myheat Binary Sensor class."""
50
-
51
- _key = ""
58
+ class MhDataActualBinarySensor (MhEntity , BinarySensorEntity ):
59
+ """myheat Data Actual (connected) Binary Sensor class."""
52
60
53
- def __init__ (self , coordinator , config_entry , heater : dict ):
54
- super ().__init__ (coordinator , config_entry )
55
- self .heater_name = heater ["name" ]
56
- self .heater_id = heater ["id" ]
61
+ _attr_device_class = "connectivity"
57
62
58
63
@property
59
- def name (self ):
60
- """Return the name of the sensor."""
61
- name = self .config_entry .data .get (CONF_NAME , DEFAULT_NAME )
62
- return f"{ name } { self .heater_name } { self ._key } "
64
+ def name (self ) -> str :
65
+ return f"{ self ._mh_name } dataActual"
63
66
64
67
@property
65
68
def unique_id (self ):
66
- """Return a unique ID to use for this entity."""
67
- return f"{ super ().unique_id } htr{ self .heater_id } { self ._key } "
68
-
69
- @property
70
- def is_on (self ):
71
- """Return true if the binary_sensor is on."""
72
- return self ._heater ().get (self ._key )
73
-
74
- @property
75
- def _mh_dev_name_suffix (self ):
76
- return f" { self .heater_name } "
69
+ return f"{ super ().unique_id } dataActual"
77
70
78
71
@property
79
- def _mh_identifiers (self ):
80
- return (DOMAIN , f"{ super ().unique_id } htr{ self .heater_id } " )
81
-
82
- def _heater (self ) -> dict :
83
- if not self .coordinator .data .get ("dataActual" , False ):
84
- _logger .warninig ("data not actual! %s" , self .coordinator .data )
85
- return {}
86
-
87
- heaters = self .coordinator .data .get ("heaters" , [])
88
- for h in heaters :
89
- if h ["id" ] == self .heater_id :
90
- return h
91
- return {}
92
-
93
-
94
- class MhHeaterDisabledBinarySensor (MhHeaterBinarySensor ):
95
- _key = "disabled"
96
- _attr_icon = "mdi:electric-switch"
97
- _attr_device_class = None
98
-
99
-
100
- class MhHeaterBurnerWaterBinarySensor (MhHeaterBinarySensor ):
101
- _key = "burnerWater"
102
- _attr_icon = "mdi:fire"
103
- _attr_device_class = "heat"
104
-
105
-
106
- class MhHeaterBurnerHeatingBinarySensor (MhHeaterBinarySensor ):
107
- _key = "burnerHeating"
108
- _attr_icon = "mdi:fire"
109
- _attr_device_class = "heat"
110
-
72
+ def is_on (self ) -> bool | None :
73
+ return self .coordinator .data .get ("dataActual" )
111
74
112
- class MhSeverityBinarySensor (MhEntity , BinarySensorEntity ):
113
- """myheat Binary Sensor class."""
114
75
76
+ class MhSeverityBinarySensorBase (BinarySensorEntity ):
115
77
_attr_device_class = "problem"
116
- _attr_icon = "mdi:water-boiler-alert"
117
78
118
- @property
119
- def name (self ) -> str :
120
- """Return the name of the sensor."""
121
- name = self .config_entry .data .get (CONF_NAME , DEFAULT_NAME )
122
- return f"{ name } severity"
123
-
124
- @property
125
- def unique_id (self ):
126
- """Return a unique ID to use for this entity."""
127
- return f"{ super ().unique_id } severity"
79
+ def _severity (self ) -> (int | None , str | None ):
80
+ return None , None
128
81
129
82
@property
130
83
def is_on (self ) -> bool | None :
131
- """Return true if the binary_sensor is on."""
132
-
133
- severity = self .coordinator .data .get ("severity" )
84
+ severity , _ = self ._severity ()
134
85
if severity is None :
135
86
return None
136
87
137
- return severity > 1
88
+ # device_class:problem -> on means problem detected
89
+ return severity != 1
138
90
139
91
@property
140
92
def extra_state_attributes (self ):
141
- desc = self .coordinator . data . get ( "severityDesc" )
93
+ severity , desc = self ._severity ( )
142
94
return {
95
+ "value" : severity ,
143
96
"description" : desc ,
144
97
}
145
98
146
99
147
- class MhEngBinarySensor (MhEntity , BinarySensorEntity ):
148
- """myheat Binary Sensor class."" "
100
+ class MhSeverityBinarySensor (MhEntity , MhSeverityBinarySensorBase ):
101
+ _attr_icon = "mdi:water-boiler-alert "
149
102
150
- def __init__ (self , coordinator , config_entry , eng : dict ):
151
- super ().__init__ (coordinator , config_entry )
152
- self .eng_name = eng ["name" ]
153
- self .eng_id = eng ["id" ]
103
+ def _severity (self ) -> (int | None , str | None ):
104
+ return (
105
+ self .coordinator .data .get ("severity" ),
106
+ self .coordinator .data .get ("severityDesc" ),
107
+ )
154
108
155
109
@property
156
- def name (self ):
157
- """Return the name of the sensor."""
158
- name = self .config_entry .data .get (CONF_NAME , DEFAULT_NAME )
159
- return f"{ name } { self .eng_name } "
110
+ def name (self ) -> str :
111
+ return f"{ self ._mh_name } severity"
160
112
161
113
@property
162
114
def unique_id (self ):
163
- """Return a unique ID to use for this entity."""
164
- return f"{ super ().unique_id } eng{ self .eng_id } "
115
+ return f"{ super ().unique_id } severity"
165
116
117
+
118
+ class MhEnvSeverityBinarySensor (MhEnvEntity , MhSeverityBinarySensorBase ):
119
+ _key = "severity"
120
+ _attr_icon = "mdi:water-boiler-alert"
121
+
122
+ def _severity (self ) -> (int | None , str | None ):
123
+ e = self .get_env ()
124
+ return (
125
+ e .get ("severity" ),
126
+ e .get ("severityDesc" ),
127
+ )
128
+
129
+
130
+ class MhEngSeverityBinarySensor (MhEngEntity , MhSeverityBinarySensorBase ):
131
+ _key = "severity"
132
+
133
+ def _severity (self ) -> (int | None , str | None ):
134
+ e = self .get_eng ()
135
+ return (
136
+ e .get ("severity" ),
137
+ e .get ("severityDesc" ),
138
+ )
139
+
140
+
141
+ class MhHeaterBinarySensor (MhHeaterEntity , BinarySensorEntity ):
166
142
@property
167
143
def is_on (self ):
168
- """Return true if the binary_sensor is on."""
169
- return self ._eng ().get ("turnedOn" )
144
+ return self .get_heater ().get (self ._key )
170
145
171
- @property
172
- def _mh_dev_name_suffix (self ):
173
- return f" { self .eng_name } "
174
146
147
+ class MhHeaterDisabledBinarySensor (MhHeaterBinarySensor ):
148
+ _key = "disabled"
149
+ _attr_icon = "mdi:electric-switch"
150
+ _attr_device_class = None
151
+
152
+
153
+ class MhHeaterBurnerWaterBinarySensor (MhHeaterBinarySensor ):
154
+ _key = "burnerWater"
155
+ _attr_icon = "mdi:fire"
156
+ _attr_device_class = "heat"
157
+
158
+
159
+ class MhHeaterBurnerHeatingBinarySensor (MhHeaterBinarySensor ):
160
+ _key = "burnerHeating"
161
+ _attr_icon = "mdi:fire"
162
+ _attr_device_class = "heat"
163
+
164
+
165
+ class MhEngTurnedOnBinarySensor (MhEngEntity , BinarySensorEntity ):
175
166
@property
176
- def _mh_identifiers (self ):
177
- return (DOMAIN , f"{ super ().unique_id } eng{ self .eng_id } " )
178
-
179
- def _eng (self ) -> dict :
180
- if not self .coordinator .data .get ("dataActual" , False ):
181
- _logger .warninig ("data not actual! %s" , self .coordinator .data )
182
- return {}
183
-
184
- engs = self .coordinator .data .get ("engs" , [])
185
- for e in engs :
186
- if e ["id" ] == self .eng_id :
187
- return e
188
- return {}
167
+ def is_on (self ):
168
+ return self .get_eng ().get ("turnedOn" )
0 commit comments