esphome 2024.12.4__py3-none-any.whl → 2025.2.0b1__py3-none-any.whl

esphome/components/opentherm/opentherm_macros.h

@@ -28,6 +28,9 @@ namespace opentherm {
 #ifndef OPENTHERM_INPUT_SENSOR_LIST
 #define OPENTHERM_INPUT_SENSOR_LIST(F, sep)
 #endif
+#ifndef OPENTHERM_SETTING_LIST
+#define OPENTHERM_SETTING_LIST(F, sep)
+#endif
 
 // Use macros to create fields for every entity specified in the ESPHome configuration
 #define OPENTHERM_DECLARE_SENSOR(entity) sensor::Sensor *entity;
@@ -36,6 +39,7 @@ namespace opentherm {
 #define OPENTHERM_DECLARE_NUMBER(entity) OpenthermNumber *entity;
 #define OPENTHERM_DECLARE_OUTPUT(entity) OpenthermOutput *entity;
 #define OPENTHERM_DECLARE_INPUT_SENSOR(entity) sensor::Sensor *entity;
+#define OPENTHERM_DECLARE_SETTING(type, entity, def) type entity = def;
 
 // Setter macros
 #define OPENTHERM_SET_SENSOR(entity) \
@@ -56,6 +60,9 @@ namespace opentherm {
 #define OPENTHERM_SET_INPUT_SENSOR(entity) \
   void set_##entity(sensor::Sensor *sensor) { this->entity = sensor; }
 
+#define OPENTHERM_SET_SETTING(type, entity, def) \
+  void set_##entity(type value) { this->entity = value; }
+
 // ===== hub.cpp macros =====
 
 // *_MESSAGE_HANDLERS are generated in defines.h and look like this:
@@ -85,6 +92,9 @@ namespace opentherm {
 #ifndef OPENTHERM_INPUT_SENSOR_MESSAGE_HANDLERS
 #define OPENTHERM_INPUT_SENSOR_MESSAGE_HANDLERS(MESSAGE, ENTITY, entity_sep, postscript, msg_sep)
 #endif
+#ifndef OPENTHERM_SETTING_MESSAGE_HANDLERS
+#define OPENTHERM_SETTING_MESSAGE_HANDLERS(MESSAGE, ENTITY, entity_sep, postscript, msg_sep)
+#endif
 
 // Write data request builders
 #define OPENTHERM_MESSAGE_WRITE_MESSAGE(msg) \
@@ -92,6 +102,7 @@ namespace opentherm {
     data.type = MessageType::WRITE_DATA; \
     data.id = request_id;
 #define OPENTHERM_MESSAGE_WRITE_ENTITY(key, msg_data) message_data::write_##msg_data(this->key->state, data);
+#define OPENTHERM_MESSAGE_WRITE_SETTING(key, msg_data) message_data::write_##msg_data(this->key, data);
 #define OPENTHERM_MESSAGE_WRITE_POSTSCRIPT \
   return data; \
   }

esphome/components/opentherm/schema.py

@@ -2,8 +2,9 @@
 # inputs of the OpenTherm component.
 
 from dataclasses import dataclass
-from typing import Optional, TypeVar
+from typing import Optional, TypeVar, Any
 
+import esphome.config_validation as cv
 from esphome.const import (
     UNIT_CELSIUS,
     UNIT_EMPTY,
@@ -64,6 +65,7 @@ class SensorSchema(EntitySchema):
     icon: Optional[str] = None
     device_class: Optional[str] = None
     disabled_by_default: bool = False
+    order: Optional[int] = None
 
 
 SENSORS: dict[str, SensorSchema] = {
@@ -399,6 +401,7 @@ SENSORS: dict[str, SensorSchema] = {
         message="OT_VERSION_DEVICE",
         keep_updated=False,
         message_data="f88",
+        order=2,
     ),
     "device_type": SensorSchema(
         description="Device product type",
@@ -409,6 +412,7 @@ SENSORS: dict[str, SensorSchema] = {
         message="VERSION_DEVICE",
         keep_updated=False,
         message_data="u8_hb",
+        order=0,
     ),
     "device_version": SensorSchema(
         description="Device product version",
@@ -419,6 +423,7 @@ SENSORS: dict[str, SensorSchema] = {
         message="VERSION_DEVICE",
         keep_updated=False,
         message_data="u8_lb",
+        order=0,
     ),
     "device_id": SensorSchema(
         description="Device ID code",
@@ -429,6 +434,7 @@ SENSORS: dict[str, SensorSchema] = {
         message="DEVICE_CONFIG",
         keep_updated=False,
         message_data="u8_lb",
+        order=4,
     ),
     "otc_hc_ratio_ub": SensorSchema(
         description="OTC heat curve ratio upper bound",
@@ -457,6 +463,7 @@ SENSORS: dict[str, SensorSchema] = {
 class BinarySensorSchema(EntitySchema):
     icon: Optional[str] = None
     device_class: Optional[str] = None
+    order: Optional[int] = None
 
 
 BINARY_SENSORS: dict[str, BinarySensorSchema] = {
@@ -525,48 +532,56 @@ BINARY_SENSORS: dict[str, BinarySensorSchema] = {
         message="DEVICE_CONFIG",
         keep_updated=False,
         message_data="flag8_hb_0",
+        order=4,
     ),
     "control_type_on_off": BinarySensorSchema(
         description="Configuration: Control type is on/off",
         message="DEVICE_CONFIG",
         keep_updated=False,
         message_data="flag8_hb_1",
+        order=4,
     ),
     "cooling_supported": BinarySensorSchema(
         description="Configuration: Cooling supported",
         message="DEVICE_CONFIG",
         keep_updated=False,
         message_data="flag8_hb_2",
+        order=4,
     ),
     "dhw_storage_tank": BinarySensorSchema(
         description="Configuration: DHW storage tank",
         message="DEVICE_CONFIG",
         keep_updated=False,
         message_data="flag8_hb_3",
+        order=4,
     ),
     "controller_pump_control_allowed": BinarySensorSchema(
         description="Configuration: Controller pump control allowed",
         message="DEVICE_CONFIG",
         keep_updated=False,
         message_data="flag8_hb_4",
+        order=4,
     ),
     "ch2_present": BinarySensorSchema(
         description="Configuration: CH2 present",
         message="DEVICE_CONFIG",
         keep_updated=False,
         message_data="flag8_hb_5",
+        order=4,
     ),
     "water_filling": BinarySensorSchema(
         description="Configuration: Remote water filling",
         message="DEVICE_CONFIG",
         keep_updated=False,
         message_data="flag8_hb_6",
+        order=4,
     ),
     "heat_mode": BinarySensorSchema(
         description="Configuration: Heating or cooling",
         message="DEVICE_CONFIG",
         keep_updated=False,
         message_data="flag8_hb_7",
+        order=4,
     ),
     "dhw_setpoint_transfer_enabled": BinarySensorSchema(
         description="Remote boiler parameters: DHW setpoint transfer enabled",
@@ -812,3 +827,65 @@ INPUTS: dict[str, InputSchema] = {
         auto_max_value=AutoConfigure(message="OTC_CURVE_BOUNDS", message_data="u8_hb"),
     ),
 }
+
+
+@dataclass
+class SettingSchema(EntitySchema):
+    backing_type: str
+    validation_schema: cv.Schema
+    default_value: Any
+    order: Optional[int] = None
+
+
+SETTINGS: dict[str, SettingSchema] = {
+    "controller_product_type": SettingSchema(
+        description="Controller product type",
+        message="VERSION_CONTROLLER",
+        keep_updated=False,
+        message_data="u8_hb",
+        backing_type="uint8_t",
+        validation_schema=cv.int_range(min=0, max=255),
+        default_value=0,
+        order=1,
+    ),
+    "controller_product_version": SettingSchema(
+        description="Controller product version",
+        message="VERSION_CONTROLLER",
+        keep_updated=False,
+        message_data="u8_lb",
+        backing_type="uint8_t",
+        validation_schema=cv.int_range(min=0, max=255),
+        default_value=0,
+        order=1,
+    ),
+    "opentherm_version_controller": SettingSchema(
+        description="Version of OpenTherm implemented by controller",
+        message="OT_VERSION_CONTROLLER",
+        keep_updated=False,
+        message_data="f88",
+        backing_type="float",
+        validation_schema=cv.positive_float,
+        default_value=0,
+        order=3,
+    ),
+    "controller_configuration": SettingSchema(
+        description="Controller configuration",
+        message="CONTROLLER_CONFIG",
+        keep_updated=False,
+        message_data="u8_hb",
+        backing_type="uint8_t",
+        validation_schema=cv.int_range(min=0, max=255),
+        default_value=0,
+        order=5,
+    ),
+    "controller_id": SettingSchema(
+        description="Controller ID code",
+        message="CONTROLLER_CONFIG",
+        keep_updated=False,
+        message_data="u8_lb",
+        backing_type="uint8_t",
+        validation_schema=cv.int_range(min=0, max=255),
+        default_value=0,
+        order=5,
+    ),
+}

esphome/components/opentherm/validate.py

@@ -9,12 +9,17 @@ from .schema import TSchema
 
 
 def create_entities_schema(
-    entities: dict[str, schema.EntitySchema],
+    entities: dict[str, TSchema],
     get_entity_validation_schema: Callable[[TSchema], cv.Schema],
 ) -> Schema:
     entity_schema = {}
     for key, entity in entities.items():
-        entity_schema[cv.Optional(key)] = get_entity_validation_schema(entity)
+        schema_key = (
+            cv.Optional(key, entity.default_value)
+            if hasattr(entity, "default_value")
+            else cv.Optional(key)
+        )
+        entity_schema[schema_key] = get_entity_validation_schema(entity)
     return cv.Schema(entity_schema)
 
 

esphome/components/pca6416a/pca6416a.h

@@ -52,6 +52,8 @@ class PCA6416AGPIOPin : public GPIOPin {
   void set_inverted(bool inverted) { inverted_ = inverted; }
   void set_flags(gpio::Flags flags) { flags_ = flags; }
 
+  gpio::Flags get_flags() const override { return this->flags_; }
+
  protected:
   PCA6416AComponent *parent_;
   uint8_t pin_;

esphome/components/pca9554/pca9554.h

@@ -65,6 +65,8 @@ class PCA9554GPIOPin : public GPIOPin {
   void set_inverted(bool inverted) { inverted_ = inverted; }
   void set_flags(gpio::Flags flags) { flags_ = flags; }
 
+  gpio::Flags get_flags() const override { return this->flags_; }
+
  protected:
   PCA9554Component *parent_;
   uint8_t pin_;

esphome/components/pcf8574/pcf8574.h

@@ -54,6 +54,8 @@ class PCF8574GPIOPin : public GPIOPin {
   void set_inverted(bool inverted) { inverted_ = inverted; }
   void set_flags(gpio::Flags flags) { flags_ = flags; }
 
+  gpio::Flags get_flags() const override { return this->flags_; }
+
  protected:
   PCF8574Component *parent_;
   uint8_t pin_;

esphome/components/preferences/__init__.py

@@ -1,6 +1,6 @@
-from esphome.const import CONF_ID
 import esphome.codegen as cg
 import esphome.config_validation as cv
+from esphome.const import CONF_ID
 
 CODEOWNERS = ["@esphome/core"]
 
@@ -11,9 +11,7 @@ CONF_FLASH_WRITE_INTERVAL = "flash_write_interval"
 CONFIG_SCHEMA = cv.Schema(
     {
         cv.GenerateID(): cv.declare_id(IntervalSyncer),
-        cv.Optional(
-            CONF_FLASH_WRITE_INTERVAL, default="60s"
-        ): cv.positive_time_period_milliseconds,
+        cv.Optional(CONF_FLASH_WRITE_INTERVAL, default="60s"): cv.update_interval,
     }
 ).extend(cv.COMPONENT_SCHEMA)
 

esphome/components/preferences/syncer.h

@@ -8,15 +8,22 @@ namespace preferences {
 
 class IntervalSyncer : public Component {
  public:
-  void set_write_interval(uint32_t write_interval) { write_interval_ = write_interval; }
+  void set_write_interval(uint32_t write_interval) { this->write_interval_ = write_interval; }
   void setup() override {
-    set_interval(write_interval_, []() { global_preferences->sync(); });
+    if (this->write_interval_ != 0) {
+      set_interval(this->write_interval_, []() { global_preferences->sync(); });
+    }
+  }
+  void loop() override {
+    if (this->write_interval_ == 0) {
+      global_preferences->sync();
+    }
   }
   void on_shutdown() override { global_preferences->sync(); }
   float get_setup_priority() const override { return setup_priority::BUS; }
 
  protected:
-  uint32_t write_interval_;
+  uint32_t write_interval_{60000};
 };
 
 }  // namespace preferences

esphome/components/prometheus/prometheus_handler.cpp

@@ -59,6 +59,36 @@ void PrometheusHandler::handleRequest(AsyncWebServerRequest *req) {
     this->text_sensor_row_(stream, obj, area, node, friendly_name);
 #endif
 
+#ifdef USE_NUMBER
+  this->number_type_(stream);
+  for (auto *obj : App.get_numbers())
+    this->number_row_(stream, obj, area, node, friendly_name);
+#endif
+
+#ifdef USE_SELECT
+  this->select_type_(stream);
+  for (auto *obj : App.get_selects())
+    this->select_row_(stream, obj, area, node, friendly_name);
+#endif
+
+#ifdef USE_MEDIA_PLAYER
+  this->media_player_type_(stream);
+  for (auto *obj : App.get_media_players())
+    this->media_player_row_(stream, obj, area, node, friendly_name);
+#endif
+
+#ifdef USE_UPDATE
+  this->update_entity_type_(stream);
+  for (auto *obj : App.get_updates())
+    this->update_entity_row_(stream, obj, area, node, friendly_name);
+#endif
+
+#ifdef USE_VALVE
+  this->valve_type_(stream);
+  for (auto *obj : App.get_valves())
+    this->valve_row_(stream, obj, area, node, friendly_name);
+#endif
+
   req->send(stream);
 }
 
@@ -511,6 +541,289 @@ void PrometheusHandler::text_sensor_row_(AsyncResponseStream *stream, text_senso
 }
 #endif
 
+// Type-specific implementation
+#ifdef USE_NUMBER
+void PrometheusHandler::number_type_(AsyncResponseStream *stream) {
+  stream->print(F("#TYPE esphome_number_value gauge\n"));
+  stream->print(F("#TYPE esphome_number_failed gauge\n"));
+}
+void PrometheusHandler::number_row_(AsyncResponseStream *stream, number::Number *obj, std::string &area,
+                                    std::string &node, std::string &friendly_name) {
+  if (obj->is_internal() && !this->include_internal_)
+    return;
+  if (!std::isnan(obj->state)) {
+    // We have a valid value, output this value
+    stream->print(F("esphome_number_failed{id=\""));
+    stream->print(relabel_id_(obj).c_str());
+    add_area_label_(stream, area);
+    add_node_label_(stream, node);
+    add_friendly_name_label_(stream, friendly_name);
+    stream->print(F("\",name=\""));
+    stream->print(relabel_name_(obj).c_str());
+    stream->print(F("\"} 0\n"));
+    // Data itself
+    stream->print(F("esphome_number_value{id=\""));
+    stream->print(relabel_id_(obj).c_str());
+    add_area_label_(stream, area);
+    add_node_label_(stream, node);
+    add_friendly_name_label_(stream, friendly_name);
+    stream->print(F("\",name=\""));
+    stream->print(relabel_name_(obj).c_str());
+    stream->print(F("\"} "));
+    stream->print(obj->state);
+    stream->print(F("\n"));
+  } else {
+    // Invalid state
+    stream->print(F("esphome_number_failed{id=\""));
+    stream->print(relabel_id_(obj).c_str());
+    add_area_label_(stream, area);
+    add_node_label_(stream, node);
+    add_friendly_name_label_(stream, friendly_name);
+    stream->print(F("\",name=\""));
+    stream->print(relabel_name_(obj).c_str());
+    stream->print(F("\"} 1\n"));
+  }
+}
+#endif
+
+#ifdef USE_SELECT
+void PrometheusHandler::select_type_(AsyncResponseStream *stream) {
+  stream->print(F("#TYPE esphome_select_value gauge\n"));
+  stream->print(F("#TYPE esphome_select_failed gauge\n"));
+}
+void PrometheusHandler::select_row_(AsyncResponseStream *stream, select::Select *obj, std::string &area,
+                                    std::string &node, std::string &friendly_name) {
+  if (obj->is_internal() && !this->include_internal_)
+    return;
+  if (obj->has_state()) {
+    // We have a valid value, output this value
+    stream->print(F("esphome_select_failed{id=\""));
+    stream->print(relabel_id_(obj).c_str());
+    add_area_label_(stream, area);
+    add_node_label_(stream, node);
+    add_friendly_name_label_(stream, friendly_name);
+    stream->print(F("\",name=\""));
+    stream->print(relabel_name_(obj).c_str());
+    stream->print(F("\"} 0\n"));
+    // Data itself
+    stream->print(F("esphome_select_value{id=\""));
+    stream->print(relabel_id_(obj).c_str());
+    add_area_label_(stream, area);
+    add_node_label_(stream, node);
+    add_friendly_name_label_(stream, friendly_name);
+    stream->print(F("\",name=\""));
+    stream->print(relabel_name_(obj).c_str());
+    stream->print(F("\",value=\""));
+    stream->print(obj->state.c_str());
+    stream->print(F("\"} "));
+    stream->print(F("1.0"));
+    stream->print(F("\n"));
+  } else {
+    // Invalid state
+    stream->print(F("esphome_select_failed{id=\""));
+    stream->print(relabel_id_(obj).c_str());
+    add_area_label_(stream, area);
+    add_node_label_(stream, node);
+    add_friendly_name_label_(stream, friendly_name);
+    stream->print(F("\",name=\""));
+    stream->print(relabel_name_(obj).c_str());
+    stream->print(F("\"} 1\n"));
+  }
+}
+#endif
+
+#ifdef USE_MEDIA_PLAYER
+void PrometheusHandler::media_player_type_(AsyncResponseStream *stream) {
+  stream->print(F("#TYPE esphome_media_player_state_value gauge\n"));
+  stream->print(F("#TYPE esphome_media_player_volume gauge\n"));
+  stream->print(F("#TYPE esphome_media_player_is_muted gauge\n"));
+  stream->print(F("#TYPE esphome_media_player_failed gauge\n"));
+}
+void PrometheusHandler::media_player_row_(AsyncResponseStream *stream, media_player::MediaPlayer *obj,
+                                          std::string &area, std::string &node, std::string &friendly_name) {
+  if (obj->is_internal() && !this->include_internal_)
+    return;
+  stream->print(F("esphome_media_player_failed{id=\""));
+  stream->print(relabel_id_(obj).c_str());
+  add_area_label_(stream, area);
+  add_node_label_(stream, node);
+  add_friendly_name_label_(stream, friendly_name);
+  stream->print(F("\",name=\""));
+  stream->print(relabel_name_(obj).c_str());
+  stream->print(F("\"} 0\n"));
+  // Data itself
+  stream->print(F("esphome_media_player_state_value{id=\""));
+  stream->print(relabel_id_(obj).c_str());
+  add_area_label_(stream, area);
+  add_node_label_(stream, node);
+  add_friendly_name_label_(stream, friendly_name);
+  stream->print(F("\",name=\""));
+  stream->print(relabel_name_(obj).c_str());
+  stream->print(F("\",value=\""));
+  stream->print(media_player::media_player_state_to_string(obj->state));
+  stream->print(F("\"} "));
+  stream->print(F("1.0"));
+  stream->print(F("\n"));
+  stream->print(F("esphome_media_player_volume{id=\""));
+  stream->print(relabel_id_(obj).c_str());
+  add_area_label_(stream, area);
+  add_node_label_(stream, node);
+  add_friendly_name_label_(stream, friendly_name);
+  stream->print(F("\",name=\""));
+  stream->print(relabel_name_(obj).c_str());
+  stream->print(F("\"} "));
+  stream->print(obj->volume);
+  stream->print(F("\n"));
+  stream->print(F("esphome_media_player_is_muted{id=\""));
+  stream->print(relabel_id_(obj).c_str());
+  add_area_label_(stream, area);
+  add_node_label_(stream, node);
+  add_friendly_name_label_(stream, friendly_name);
+  stream->print(F("\",name=\""));
+  stream->print(relabel_name_(obj).c_str());
+  stream->print(F("\"} "));
+  if (obj->is_muted()) {
+    stream->print(F("1.0"));
+  } else {
+    stream->print(F("0.0"));
+  }
+  stream->print(F("\n"));
+}
+#endif
+
+#ifdef USE_UPDATE
+void PrometheusHandler::update_entity_type_(AsyncResponseStream *stream) {
+  stream->print(F("#TYPE esphome_update_entity_state gauge\n"));
+  stream->print(F("#TYPE esphome_update_entity_info gauge\n"));
+  stream->print(F("#TYPE esphome_update_entity_failed gauge\n"));
+}
+
+void PrometheusHandler::handle_update_state_(AsyncResponseStream *stream, update::UpdateState state) {
+  switch (state) {
+    case update::UpdateState::UPDATE_STATE_UNKNOWN:
+      stream->print("unknown");
+      break;
+    case update::UpdateState::UPDATE_STATE_NO_UPDATE:
+      stream->print("none");
+      break;
+    case update::UpdateState::UPDATE_STATE_AVAILABLE:
+      stream->print("available");
+      break;
+    case update::UpdateState::UPDATE_STATE_INSTALLING:
+      stream->print("installing");
+      break;
+    default:
+      stream->print("invalid");
+      break;
+  }
+}
+
+void PrometheusHandler::update_entity_row_(AsyncResponseStream *stream, update::UpdateEntity *obj, std::string &area,
+                                           std::string &node, std::string &friendly_name) {
+  if (obj->is_internal() && !this->include_internal_)
+    return;
+  if (obj->has_state()) {
+    // We have a valid value, output this value
+    stream->print(F("esphome_update_entity_failed{id=\""));
+    stream->print(relabel_id_(obj).c_str());
+    add_area_label_(stream, area);
+    add_node_label_(stream, node);
+    add_friendly_name_label_(stream, friendly_name);
+    stream->print(F("\",name=\""));
+    stream->print(relabel_name_(obj).c_str());
+    stream->print(F("\"} 0\n"));
+    // First update state
+    stream->print(F("esphome_update_entity_state{id=\""));
+    stream->print(relabel_id_(obj).c_str());
+    add_area_label_(stream, area);
+    add_node_label_(stream, node);
+    add_friendly_name_label_(stream, friendly_name);
+    stream->print(F("\",name=\""));
+    stream->print(relabel_name_(obj).c_str());
+    stream->print(F("\",value=\""));
+    handle_update_state_(stream, obj->state);
+    stream->print(F("\"} "));
+    stream->print(F("1.0"));
+    stream->print(F("\n"));
+    // Next update info
+    stream->print(F("esphome_update_entity_info{id=\""));
+    stream->print(relabel_id_(obj).c_str());
+    add_area_label_(stream, area);
+    add_node_label_(stream, node);
+    add_friendly_name_label_(stream, friendly_name);
+    stream->print(F("\",name=\""));
+    stream->print(relabel_name_(obj).c_str());
+    stream->print(F("\",current_version=\""));
+    stream->print(obj->update_info.current_version.c_str());
+    stream->print(F("\",latest_version=\""));
+    stream->print(obj->update_info.latest_version.c_str());
+    stream->print(F("\",title=\""));
+    stream->print(obj->update_info.title.c_str());
+    stream->print(F("\"} "));
+    stream->print(F("1.0"));
+    stream->print(F("\n"));
+  } else {
+    // Invalid state
+    stream->print(F("esphome_update_entity_failed{id=\""));
+    stream->print(relabel_id_(obj).c_str());
+    add_area_label_(stream, area);
+    add_node_label_(stream, node);
+    add_friendly_name_label_(stream, friendly_name);
+    stream->print(F("\",name=\""));
+    stream->print(relabel_name_(obj).c_str());
+    stream->print(F("\"} 1\n"));
+  }
+}
+#endif
+
+#ifdef USE_VALVE
+void PrometheusHandler::valve_type_(AsyncResponseStream *stream) {
+  stream->print(F("#TYPE esphome_valve_operation gauge\n"));
+  stream->print(F("#TYPE esphome_valve_failed gauge\n"));
+  stream->print(F("#TYPE esphome_valve_position gauge\n"));
+}
+
+void PrometheusHandler::valve_row_(AsyncResponseStream *stream, valve::Valve *obj, std::string &area, std::string &node,
+                                   std::string &friendly_name) {
+  if (obj->is_internal() && !this->include_internal_)
+    return;
+  stream->print(F("esphome_valve_failed{id=\""));
+  stream->print(relabel_id_(obj).c_str());
+  add_area_label_(stream, area);
+  add_node_label_(stream, node);
+  add_friendly_name_label_(stream, friendly_name);
+  stream->print(F("\",name=\""));
+  stream->print(relabel_name_(obj).c_str());
+  stream->print(F("\"} 0\n"));
+  // Data itself
+  stream->print(F("esphome_valve_operation{id=\""));
+  stream->print(relabel_id_(obj).c_str());
+  add_area_label_(stream, area);
+  add_node_label_(stream, node);
+  add_friendly_name_label_(stream, friendly_name);
+  stream->print(F("\",name=\""));
+  stream->print(relabel_name_(obj).c_str());
+  stream->print(F("\",operation=\""));
+  stream->print(valve::valve_operation_to_str(obj->current_operation));
+  stream->print(F("\"} "));
+  stream->print(F("1.0"));
+  stream->print(F("\n"));
+  // Now see if position is supported
+  if (obj->get_traits().get_supports_position()) {
+    stream->print(F("esphome_valve_position{id=\""));
+    stream->print(relabel_id_(obj).c_str());
+    add_area_label_(stream, area);
+    add_node_label_(stream, node);
+    add_friendly_name_label_(stream, friendly_name);
+    stream->print(F("\",name=\""));
+    stream->print(relabel_name_(obj).c_str());
+    stream->print(F("\"} "));
+    stream->print(obj->position);
+    stream->print(F("\n"));
+  }
+}
+#endif
+
 }  // namespace prometheus
 }  // namespace esphome
 #endif