esphome 2025.8.4__py3-none-any.whl → 2025.9.0b1__py3-none-any.whl

esphome/components/mdns/mdns_component.cpp

@@ -5,6 +5,30 @@
 #include "esphome/core/version.h"
 #include "mdns_component.h"
 
+#ifdef USE_ESP8266
+#include <pgmspace.h>
+// Macro to define strings in PROGMEM on ESP8266, regular memory on other platforms
+#define MDNS_STATIC_CONST_CHAR(name, value) static const char name[] PROGMEM = value
+// Helper to get string from PROGMEM - returns a temporary std::string
+// Only define this function if we have services that will use it
+#if defined(USE_API) || defined(USE_PROMETHEUS) || defined(USE_WEBSERVER) || defined(USE_MDNS_EXTRA_SERVICES)
+static std::string mdns_string_p(const char *src) {
+  char buf[64];
+  strncpy_P(buf, src, sizeof(buf) - 1);
+  buf[sizeof(buf) - 1] = '\0';
+  return std::string(buf);
+}
+#define MDNS_STR(name) mdns_string_p(name)
+#else
+// If no services are configured, we still need the fallback service but it uses string literals
+#define MDNS_STR(name) std::string(name)
+#endif
+#else
+// On non-ESP8266 platforms, use regular const char*
+#define MDNS_STATIC_CONST_CHAR(name, value) static constexpr const char *name = value
+#define MDNS_STR(name) name
+#endif
+
 #ifdef USE_API
 #include "esphome/components/api/api_server.h"
 #endif
@@ -21,103 +45,168 @@ static const char *const TAG = "mdns";
 #define USE_WEBSERVER_PORT 80  // NOLINT
 #endif
 
+// Define all constant strings using the macro
+MDNS_STATIC_CONST_CHAR(SERVICE_ESPHOMELIB, "_esphomelib");
+MDNS_STATIC_CONST_CHAR(SERVICE_TCP, "_tcp");
+MDNS_STATIC_CONST_CHAR(SERVICE_PROMETHEUS, "_prometheus-http");
+MDNS_STATIC_CONST_CHAR(SERVICE_HTTP, "_http");
+
+MDNS_STATIC_CONST_CHAR(TXT_FRIENDLY_NAME, "friendly_name");
+MDNS_STATIC_CONST_CHAR(TXT_VERSION, "version");
+MDNS_STATIC_CONST_CHAR(TXT_MAC, "mac");
+MDNS_STATIC_CONST_CHAR(TXT_PLATFORM, "platform");
+MDNS_STATIC_CONST_CHAR(TXT_BOARD, "board");
+MDNS_STATIC_CONST_CHAR(TXT_NETWORK, "network");
+MDNS_STATIC_CONST_CHAR(TXT_API_ENCRYPTION, "api_encryption");
+MDNS_STATIC_CONST_CHAR(TXT_API_ENCRYPTION_SUPPORTED, "api_encryption_supported");
+MDNS_STATIC_CONST_CHAR(TXT_PROJECT_NAME, "project_name");
+MDNS_STATIC_CONST_CHAR(TXT_PROJECT_VERSION, "project_version");
+MDNS_STATIC_CONST_CHAR(TXT_PACKAGE_IMPORT_URL, "package_import_url");
+
+MDNS_STATIC_CONST_CHAR(PLATFORM_ESP8266, "ESP8266");
+MDNS_STATIC_CONST_CHAR(PLATFORM_ESP32, "ESP32");
+MDNS_STATIC_CONST_CHAR(PLATFORM_RP2040, "RP2040");
+
+MDNS_STATIC_CONST_CHAR(NETWORK_WIFI, "wifi");
+MDNS_STATIC_CONST_CHAR(NETWORK_ETHERNET, "ethernet");
+MDNS_STATIC_CONST_CHAR(NETWORK_THREAD, "thread");
+
 void MDNSComponent::compile_records_() {
   this->hostname_ = App.get_name();
 
-  this->services_.clear();
+  // Calculate exact capacity needed for services vector
+  size_t services_count = 0;
+#ifdef USE_API
+  if (api::global_api_server != nullptr) {
+    services_count++;
+  }
+#endif
+#ifdef USE_PROMETHEUS
+  services_count++;
+#endif
+#ifdef USE_WEBSERVER
+  services_count++;
+#endif
+#ifdef USE_MDNS_EXTRA_SERVICES
+  services_count += this->services_extra_.size();
+#endif
+  // Reserve for fallback service if needed
+  if (services_count == 0) {
+    services_count = 1;
+  }
+  this->services_.reserve(services_count);
+
 #ifdef USE_API
   if (api::global_api_server != nullptr) {
-    MDNSService service{};
-    service.service_type = "_esphomelib";
-    service.proto = "_tcp";
+    this->services_.emplace_back();
+    auto &service = this->services_.back();
+    service.service_type = MDNS_STR(SERVICE_ESPHOMELIB);
+    service.proto = MDNS_STR(SERVICE_TCP);
     service.port = api::global_api_server->get_port();
-    if (!App.get_friendly_name().empty()) {
-      service.txt_records.push_back({"friendly_name", App.get_friendly_name()});
+
+    const std::string &friendly_name = App.get_friendly_name();
+    bool friendly_name_empty = friendly_name.empty();
+
+    // Calculate exact capacity for txt_records
+    size_t txt_count = 3;  // version, mac, board (always present)
+    if (!friendly_name_empty) {
+      txt_count++;  // friendly_name
     }
-    service.txt_records.push_back({"version", ESPHOME_VERSION});
-    service.txt_records.push_back({"mac", get_mac_address()});
-    const char *platform = nullptr;
-#ifdef USE_ESP8266
-    platform = "ESP8266";
+#if defined(USE_ESP8266) || defined(USE_ESP32) || defined(USE_RP2040) || defined(USE_LIBRETINY)
+    txt_count++;  // platform
 #endif
-#ifdef USE_ESP32
-    platform = "ESP32";
+#if defined(USE_WIFI) || defined(USE_ETHERNET) || defined(USE_OPENTHREAD)
+    txt_count++;  // network
 #endif
-#ifdef USE_RP2040
-    platform = "RP2040";
+#ifdef USE_API_NOISE
+    txt_count++;  // api_encryption or api_encryption_supported
 #endif
-#ifdef USE_LIBRETINY
-    platform = lt_cpu_get_model_name();
+#ifdef ESPHOME_PROJECT_NAME
+    txt_count += 2;  // project_name and project_version
 #endif
-    if (platform != nullptr) {
-      service.txt_records.push_back({"platform", platform});
+#ifdef USE_DASHBOARD_IMPORT
+    txt_count++;  // package_import_url
+#endif
+
+    auto &txt_records = service.txt_records;
+    txt_records.reserve(txt_count);
+
+    if (!friendly_name_empty) {
+      txt_records.push_back({MDNS_STR(TXT_FRIENDLY_NAME), friendly_name});
     }
+    txt_records.push_back({MDNS_STR(TXT_VERSION), ESPHOME_VERSION});
+    txt_records.push_back({MDNS_STR(TXT_MAC), get_mac_address()});
 
-    service.txt_records.push_back({"board", ESPHOME_BOARD});
+#ifdef USE_ESP8266
+    txt_records.push_back({MDNS_STR(TXT_PLATFORM), MDNS_STR(PLATFORM_ESP8266)});
+#elif defined(USE_ESP32)
+    txt_records.push_back({MDNS_STR(TXT_PLATFORM), MDNS_STR(PLATFORM_ESP32)});
+#elif defined(USE_RP2040)
+    txt_records.push_back({MDNS_STR(TXT_PLATFORM), MDNS_STR(PLATFORM_RP2040)});
+#elif defined(USE_LIBRETINY)
+    txt_records.emplace_back(MDNSTXTRecord{"platform", lt_cpu_get_model_name()});
+#endif
+
+    txt_records.push_back({MDNS_STR(TXT_BOARD), ESPHOME_BOARD});
 
 #if defined(USE_WIFI)
-    service.txt_records.push_back({"network", "wifi"});
+    txt_records.push_back({MDNS_STR(TXT_NETWORK), MDNS_STR(NETWORK_WIFI)});
 #elif defined(USE_ETHERNET)
-    service.txt_records.push_back({"network", "ethernet"});
+    txt_records.push_back({MDNS_STR(TXT_NETWORK), MDNS_STR(NETWORK_ETHERNET)});
 #elif defined(USE_OPENTHREAD)
-    service.txt_records.push_back({"network", "thread"});
+    txt_records.push_back({MDNS_STR(TXT_NETWORK), MDNS_STR(NETWORK_THREAD)});
 #endif
 
 #ifdef USE_API_NOISE
+    MDNS_STATIC_CONST_CHAR(NOISE_ENCRYPTION, "Noise_NNpsk0_25519_ChaChaPoly_SHA256");
     if (api::global_api_server->get_noise_ctx()->has_psk()) {
-      service.txt_records.push_back({"api_encryption", "Noise_NNpsk0_25519_ChaChaPoly_SHA256"});
+      txt_records.push_back({MDNS_STR(TXT_API_ENCRYPTION), MDNS_STR(NOISE_ENCRYPTION)});
     } else {
-      service.txt_records.push_back({"api_encryption_supported", "Noise_NNpsk0_25519_ChaChaPoly_SHA256"});
+      txt_records.push_back({MDNS_STR(TXT_API_ENCRYPTION_SUPPORTED), MDNS_STR(NOISE_ENCRYPTION)});
     }
 #endif
 
 #ifdef ESPHOME_PROJECT_NAME
-    service.txt_records.push_back({"project_name", ESPHOME_PROJECT_NAME});
-    service.txt_records.push_back({"project_version", ESPHOME_PROJECT_VERSION});
+    txt_records.push_back({MDNS_STR(TXT_PROJECT_NAME), ESPHOME_PROJECT_NAME});
+    txt_records.push_back({MDNS_STR(TXT_PROJECT_VERSION), ESPHOME_PROJECT_VERSION});
 #endif  // ESPHOME_PROJECT_NAME
 
 #ifdef USE_DASHBOARD_IMPORT
-    service.txt_records.push_back({"package_import_url", dashboard_import::get_package_import_url()});
+    txt_records.push_back({MDNS_STR(TXT_PACKAGE_IMPORT_URL), dashboard_import::get_package_import_url()});
 #endif
-
-    this->services_.push_back(service);
   }
 #endif  // USE_API
 
 #ifdef USE_PROMETHEUS
-  {
-    MDNSService service{};
-    service.service_type = "_prometheus-http";
-    service.proto = "_tcp";
-    service.port = USE_WEBSERVER_PORT;
-    this->services_.push_back(service);
-  }
+  this->services_.emplace_back();
+  auto &prom_service = this->services_.back();
+  prom_service.service_type = MDNS_STR(SERVICE_PROMETHEUS);
+  prom_service.proto = MDNS_STR(SERVICE_TCP);
+  prom_service.port = USE_WEBSERVER_PORT;
 #endif
 
 #ifdef USE_WEBSERVER
-  {
-    MDNSService service{};
-    service.service_type = "_http";
-    service.proto = "_tcp";
-    service.port = USE_WEBSERVER_PORT;
-    this->services_.push_back(service);
-  }
+  this->services_.emplace_back();
+  auto &web_service = this->services_.back();
+  web_service.service_type = MDNS_STR(SERVICE_HTTP);
+  web_service.proto = MDNS_STR(SERVICE_TCP);
+  web_service.port = USE_WEBSERVER_PORT;
 #endif
 
 #ifdef USE_MDNS_EXTRA_SERVICES
   this->services_.insert(this->services_.end(), this->services_extra_.begin(), this->services_extra_.end());
 #endif
 
-  if (this->services_.empty()) {
-    // Publish "http" service if not using native API
-    // This is just to have *some* mDNS service so that .local resolution works
-    MDNSService service{};
-    service.service_type = "_http";
-    service.proto = "_tcp";
-    service.port = USE_WEBSERVER_PORT;
-    service.txt_records.push_back({"version", ESPHOME_VERSION});
-    this->services_.push_back(service);
-  }
+#if !defined(USE_API) && !defined(USE_PROMETHEUS) && !defined(USE_WEBSERVER) && !defined(USE_MDNS_EXTRA_SERVICES)
+  // Publish "http" service if not using native API or any other services
+  // This is just to have *some* mDNS service so that .local resolution works
+  this->services_.emplace_back();
+  auto &fallback_service = this->services_.back();
+  fallback_service.service_type = "_http";
+  fallback_service.proto = "_tcp";
+  fallback_service.port = USE_WEBSERVER_PORT;
+  fallback_service.txt_records.emplace_back(MDNSTXTRecord{"version", ESPHOME_VERSION});
+#endif
 }
 
 void MDNSComponent::dump_config() {
@@ -125,6 +214,7 @@ void MDNSComponent::dump_config() {
                 "mDNS:\n"
                 "  Hostname: %s",
                 this->hostname_.c_str());
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
   ESP_LOGV(TAG, "  Services:");
   for (const auto &service : this->services_) {
     ESP_LOGV(TAG, "  - %s, %s, %d", service.service_type.c_str(), service.proto.c_str(),
@@ -134,6 +224,7 @@ void MDNSComponent::dump_config() {
                const_cast<TemplatableValue<std::string> &>(record.value).value().c_str());
     }
   }
+#endif
 }
 
 std::vector<MDNSService> MDNSComponent::get_services() { return this->services_; }

esphome/components/media_player/__init__.py

@@ -14,7 +14,7 @@ from esphome.const import (
 )
 from esphome.core import CORE
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
-from esphome.coroutine import coroutine_with_priority
+from esphome.coroutine import CoroPriority, coroutine_with_priority
 from esphome.cpp_generator import MockObjClass
 
 CODEOWNERS = ["@jesserockz"]
@@ -303,7 +303,7 @@ async def media_player_volume_set_action(config, action_id, template_arg, args):
     return var
 
 
-@coroutine_with_priority(100.0)
+@coroutine_with_priority(CoroPriority.CORE)
 async def to_code(config):
     cg.add_global(media_player_ns.using)
     cg.add_define("USE_MEDIA_PLAYER")

esphome/components/micro_wake_word/__init__.py

@@ -201,7 +201,7 @@ def _validate_manifest_version(manifest_data):
         else:
             raise cv.Invalid("Invalid manifest version")
     else:
-        raise cv.Invalid("Invalid manifest file, missing 'version' key.")
+        raise cv.Invalid("Invalid manifest file, missing 'version' key")
 
 
 def _process_http_source(config):
@@ -421,7 +421,7 @@ def _feature_step_size_validate(config):
         if features_step_size is None:
             features_step_size = model_step_size
         elif features_step_size != model_step_size:
-            raise cv.Invalid("Cannot load models with different features step sizes.")
+            raise cv.Invalid("Cannot load models with different features step sizes")
 
 
 FINAL_VALIDATE_SCHEMA = cv.All(

esphome/components/microphone/__init__.py

@@ -12,7 +12,7 @@ from esphome.const import (
     CONF_TRIGGER_ID,
 )
 from esphome.core import CORE
-from esphome.coroutine import coroutine_with_priority
+from esphome.coroutine import CoroPriority, coroutine_with_priority
 
 AUTO_LOAD = ["audio"]
 CODEOWNERS = ["@jesserockz", "@kahrendt"]
@@ -213,7 +213,7 @@ automation.register_condition(
 )(microphone_action)
 
 
-@coroutine_with_priority(100.0)
+@coroutine_with_priority(CoroPriority.CORE)
 async def to_code(config):
     cg.add_global(microphone_ns.using)
     cg.add_define("USE_MICROPHONE")

esphome/components/mipi/__init__.py

@@ -2,7 +2,7 @@
 # Various configuration constants for MIPI displays
 # Various utility functions for MIPI DBI configuration
 
-from typing import Any
+from typing import Any, Self
 
 from esphome.components.const import CONF_COLOR_DEPTH
 from esphome.components.display import CONF_SHOW_TEST_CARD, display_ns
@@ -222,7 +222,13 @@ def delay(ms):
 
 
 class DriverChip:
-    models = {}
+    """
+    A class representing a MIPI DBI driver chip model.
+    The parameters supplied as defaults will be used to provide default values for the display configuration.
+    Setting swap_xy to cv.UNDEFINED will indicate that the model does not support swapping X and Y axes.
+    """
+
+    models: dict[str, Self] = {}
 
     def __init__(
         self,
@@ -232,7 +238,7 @@ class DriverChip:
     ):
         name = name.upper()
         self.name = name
-        self.initsequence = initsequence or defaults.get("init_sequence")
+        self.initsequence = initsequence
         self.defaults = defaults
         DriverChip.models[name] = self
 
@@ -246,6 +252,17 @@ class DriverChip:
         return models
 
     def extend(self, name, **kwargs) -> "DriverChip":
+        """
+        Extend the current model with additional parameters or a modified init sequence.
+        Parameters supplied here will override the defaults of the current model.
+        if the initsequence is not provided, the current model's initsequence will be used.
+        If add_init_sequence is provided, it will be appended to the current initsequence.
+        :param name:
+        :param kwargs:
+        :return:
+        """
+        initsequence = list(kwargs.pop("initsequence", self.initsequence))
+        initsequence.extend(kwargs.pop("add_init_sequence", ()))
         defaults = self.defaults.copy()
         if (
             CONF_WIDTH in defaults
@@ -260,23 +277,39 @@ class DriverChip:
         ):
             defaults[CONF_NATIVE_HEIGHT] = defaults[CONF_HEIGHT]
         defaults.update(kwargs)
-        return DriverChip(name, initsequence=self.initsequence, **defaults)
+        return self.__class__(name, initsequence=tuple(initsequence), **defaults)
 
     def get_default(self, key, fallback: Any = False) -> Any:
         return self.defaults.get(key, fallback)
 
+    @property
+    def transforms(self) -> set[str]:
+        """
+        Return the available transforms for this model.
+        """
+        if self.get_default("no_transform", False):
+            return set()
+        if self.get_default(CONF_SWAP_XY) != cv.UNDEFINED:
+            return {CONF_MIRROR_X, CONF_MIRROR_Y, CONF_SWAP_XY}
+        return {CONF_MIRROR_X, CONF_MIRROR_Y}
+
     def option(self, name, fallback=False) -> cv.Optional:
         return cv.Optional(name, default=self.get_default(name, fallback))
 
     def rotation_as_transform(self, config) -> bool:
         """
         Check if a rotation can be implemented in hardware using the MADCTL register.
-        A rotation of 180 is always possible, 90 and 270 are possible if the model supports swapping X and Y.
+        A rotation of 180 is always possible if x and y mirroring are supported, 90 and 270 are possible if the model supports swapping X and Y.
         """
+        transforms = self.transforms
         rotation = config.get(CONF_ROTATION, 0)
-        return rotation and (
-            self.get_default(CONF_SWAP_XY) != cv.UNDEFINED or rotation == 180
-        )
+        if rotation == 0 or not transforms:
+            return False
+        if rotation == 180:
+            return CONF_MIRROR_X in transforms and CONF_MIRROR_Y in transforms
+        if rotation == 90:
+            return CONF_SWAP_XY in transforms and CONF_MIRROR_X in transforms
+        return CONF_SWAP_XY in transforms and CONF_MIRROR_Y in transforms
 
     def get_dimensions(self, config) -> tuple[int, int, int, int]:
         if CONF_DIMENSIONS in config:
@@ -301,10 +334,10 @@ class DriverChip:
 
         # if mirroring axes and there are offsets, also mirror the offsets to cater for situations where
         # the offset is asymmetric
-        if transform[CONF_MIRROR_X]:
+        if transform.get(CONF_MIRROR_X):
             native_width = self.get_default(CONF_NATIVE_WIDTH, width + offset_width * 2)
             offset_width = native_width - width - offset_width
-        if transform[CONF_MIRROR_Y]:
+        if transform.get(CONF_MIRROR_Y):
             native_height = self.get_default(
                 CONF_NATIVE_HEIGHT, height + offset_height * 2
             )
@@ -314,7 +347,7 @@ class DriverChip:
             90,
             270,
         )
-        if transform[CONF_SWAP_XY] is True or rotated:
+        if transform.get(CONF_SWAP_XY) is True or rotated:
             width, height = height, width
             offset_height, offset_width = offset_width, offset_height
         return width, height, offset_width, offset_height
@@ -324,27 +357,50 @@ class DriverChip:
         transform = config.get(
             CONF_TRANSFORM,
             {
-                CONF_MIRROR_X: self.get_default(CONF_MIRROR_X, False),
-                CONF_MIRROR_Y: self.get_default(CONF_MIRROR_Y, False),
-                CONF_SWAP_XY: self.get_default(CONF_SWAP_XY, False),
+                CONF_MIRROR_X: self.get_default(CONF_MIRROR_X),
+                CONF_MIRROR_Y: self.get_default(CONF_MIRROR_Y),
+                CONF_SWAP_XY: self.get_default(CONF_SWAP_XY),
             },
         )
+        # fill in defaults if not provided
+        mirror_x = transform.get(CONF_MIRROR_X, self.get_default(CONF_MIRROR_X))
+        mirror_y = transform.get(CONF_MIRROR_Y, self.get_default(CONF_MIRROR_Y))
+        swap_xy = transform.get(CONF_SWAP_XY, self.get_default(CONF_SWAP_XY))
+        transform[CONF_MIRROR_X] = mirror_x
+        transform[CONF_MIRROR_Y] = mirror_y
+        transform[CONF_SWAP_XY] = swap_xy
 
         # Can we use the MADCTL register to set the rotation?
         if can_transform and CONF_TRANSFORM not in config:
             rotation = config[CONF_ROTATION]
             if rotation == 180:
-                transform[CONF_MIRROR_X] = not transform[CONF_MIRROR_X]
-                transform[CONF_MIRROR_Y] = not transform[CONF_MIRROR_Y]
+                transform[CONF_MIRROR_X] = not mirror_x
+                transform[CONF_MIRROR_Y] = not mirror_y
             elif rotation == 90:
-                transform[CONF_SWAP_XY] = not transform[CONF_SWAP_XY]
-                transform[CONF_MIRROR_X] = not transform[CONF_MIRROR_X]
+                transform[CONF_SWAP_XY] = not swap_xy
+                transform[CONF_MIRROR_X] = not mirror_x
             else:
-                transform[CONF_SWAP_XY] = not transform[CONF_SWAP_XY]
-                transform[CONF_MIRROR_Y] = not transform[CONF_MIRROR_Y]
+                transform[CONF_SWAP_XY] = not swap_xy
+                transform[CONF_MIRROR_Y] = not mirror_y
             transform[CONF_TRANSFORM] = True
         return transform
 
+    def add_madctl(self, sequence: list, config: dict):
+        # Add the MADCTL command to the sequence based on the configuration.
+        use_flip = config.get(CONF_USE_AXIS_FLIPS)
+        madctl = 0
+        transform = self.get_transform(config)
+        if transform[CONF_MIRROR_X]:
+            madctl |= MADCTL_XFLIP if use_flip else MADCTL_MX
+        if transform[CONF_MIRROR_Y]:
+            madctl |= MADCTL_YFLIP if use_flip else MADCTL_MY
+        if transform.get(CONF_SWAP_XY) is True:  # Exclude Undefined
+            madctl |= MADCTL_MV
+        if config[CONF_COLOR_ORDER] == MODE_BGR:
+            madctl |= MADCTL_BGR
+        sequence.append((MADCTL, madctl))
+        return madctl
+
     def get_sequence(self, config) -> tuple[tuple[int, ...], int]:
         """
         Create the init sequence for the display.
@@ -367,21 +423,9 @@ class DriverChip:
             pixel_mode = PIXEL_MODES[pixel_mode]
         sequence.append((PIXFMT, pixel_mode))
 
-        # Does the chip use the flipping bits for mirroring rather than the reverse order bits?
-        use_flip = config.get(CONF_USE_AXIS_FLIPS)
-        madctl = 0
-        transform = self.get_transform(config)
         if self.rotation_as_transform(config):
             LOGGER.info("Using hardware transform to implement rotation")
-        if transform.get(CONF_MIRROR_X):
-            madctl |= MADCTL_XFLIP if use_flip else MADCTL_MX
-        if transform.get(CONF_MIRROR_Y):
-            madctl |= MADCTL_YFLIP if use_flip else MADCTL_MY
-        if transform.get(CONF_SWAP_XY) is True:  # Exclude Undefined
-            madctl |= MADCTL_MV
-        if config[CONF_COLOR_ORDER] == MODE_BGR:
-            madctl |= MADCTL_BGR
-        sequence.append((MADCTL, madctl))
+        madctl = self.add_madctl(sequence, config)
         if config[CONF_INVERT_COLORS]:
             sequence.append((INVON,))
         else:

esphome/components/mipi_rgb/__init__.py

@@ -0,0 +1,2 @@
+CODEOWNERS = ["@clydebarrow"]
+DOMAIN = "mipi_rgb"