esphome 2024.10.3__py3-none-any.whl → 2024.11.0b1__py3-none-any.whl

esphome/components/http_request/http_request.h

@@ -22,6 +22,63 @@ struct Header {
   const char *value;
 };
 
+// Some common HTTP status codes
+enum HttpStatus {
+  HTTP_STATUS_OK = 200,
+  HTTP_STATUS_NO_CONTENT = 204,
+  HTTP_STATUS_PARTIAL_CONTENT = 206,
+
+  /* 3xx - Redirection */
+  HTTP_STATUS_MULTIPLE_CHOICES = 300,
+  HTTP_STATUS_MOVED_PERMANENTLY = 301,
+  HTTP_STATUS_FOUND = 302,
+  HTTP_STATUS_SEE_OTHER = 303,
+  HTTP_STATUS_NOT_MODIFIED = 304,
+  HTTP_STATUS_TEMPORARY_REDIRECT = 307,
+  HTTP_STATUS_PERMANENT_REDIRECT = 308,
+
+  /* 4XX - CLIENT ERROR */
+  HTTP_STATUS_BAD_REQUEST = 400,
+  HTTP_STATUS_UNAUTHORIZED = 401,
+  HTTP_STATUS_FORBIDDEN = 403,
+  HTTP_STATUS_NOT_FOUND = 404,
+  HTTP_STATUS_METHOD_NOT_ALLOWED = 405,
+  HTTP_STATUS_NOT_ACCEPTABLE = 406,
+  HTTP_STATUS_LENGTH_REQUIRED = 411,
+
+  /* 5xx - Server Error */
+  HTTP_STATUS_INTERNAL_ERROR = 500
+};
+
+/**
+ * @brief Returns true if the HTTP status code is a redirect.
+ *
+ * @param status the HTTP status code to check
+ * @return true if the status code is a redirect, false otherwise
+ */
+inline bool is_redirect(int const status) {
+  switch (status) {
+    case HTTP_STATUS_MOVED_PERMANENTLY:
+    case HTTP_STATUS_FOUND:
+    case HTTP_STATUS_SEE_OTHER:
+    case HTTP_STATUS_TEMPORARY_REDIRECT:
+    case HTTP_STATUS_PERMANENT_REDIRECT:
+      return true;
+    default:
+      return false;
+  }
+}
+
+/**
+ * @brief Checks if the given HTTP status code indicates a successful request.
+ *
+ * A successful request is one where the status code is in the range 200-299
+ *
+ * @param status the HTTP status code to check
+ * @return true if the status code indicates a successful request, false otherwise
+ */
+inline bool is_success(int const status) { return status >= HTTP_STATUS_OK && status < HTTP_STATUS_MULTIPLE_CHOICES; }
+
 class HttpRequestComponent;
 
 class HttpContainer : public Parented<HttpRequestComponent> {
@@ -78,8 +135,8 @@ class HttpRequestComponent : public Component {
 
  protected:
   const char *useragent_{nullptr};
-  bool follow_redirects_;
-  uint16_t redirect_limit_;
+  bool follow_redirects_{};
+  uint16_t redirect_limit_{};
   uint16_t timeout_{4500};
   uint32_t watchdog_timeout_{0};
 };
@@ -100,6 +157,8 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
 
   void register_response_trigger(HttpRequestResponseTrigger *trigger) { this->response_triggers_.push_back(trigger); }
 
+  void register_error_trigger(Trigger<> *trigger) { this->error_triggers_.push_back(trigger); }
+
   void set_max_response_buffer_size(size_t max_response_buffer_size) {
     this->max_response_buffer_size_ = max_response_buffer_size;
   }
@@ -129,6 +188,8 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
     auto container = this->parent_->start(this->url_.value(x...), this->method_.value(x...), body, headers);
 
     if (container == nullptr) {
+      for (auto *trigger : this->error_triggers_)
+        trigger->trigger(x...);
       return;
     }
 
@@ -180,7 +241,8 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
   std::map<const char *, TemplatableValue<const char *, Ts...>> headers_{};
   std::map<const char *, TemplatableValue<std::string, Ts...>> json_{};
   std::function<void(Ts..., JsonObject)> json_func_{nullptr};
-  std::vector<HttpRequestResponseTrigger *> response_triggers_;
+  std::vector<HttpRequestResponseTrigger *> response_triggers_{};
+  std::vector<Trigger<> *> error_triggers_{};
 
   size_t max_response_buffer_size_{SIZE_MAX};
 };

esphome/components/http_request/http_request_arduino.cpp

@@ -113,11 +113,10 @@ std::shared_ptr<HttpContainer> HttpRequestArduino::start(std::string url, std::s
     return nullptr;
   }
 
-  if (container->status_code < 200 || container->status_code >= 300) {
+  if (!is_success(container->status_code)) {
     ESP_LOGE(TAG, "HTTP Request failed; URL: %s; Code: %d", url.c_str(), container->status_code);
     this->status_momentary_error("failed", 1000);
-    container->end();
-    return nullptr;
+    // Still return the container, so it can be used to get the status code and error message
   }
 
   int content_length = container->client_.getSize();

esphome/components/http_request/http_request_idf.cpp

@@ -6,7 +6,6 @@
 #include "esphome/components/watchdog/watchdog.h"
 
 #include "esphome/core/application.h"
-#include "esphome/core/defines.h"
 #include "esphome/core/log.h"
 
 #if CONFIG_MBEDTLS_CERTIFICATE_BUNDLE
@@ -118,20 +117,14 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::start(std::string url, std::strin
     return nullptr;
   }
 
-  auto is_ok = [](int code) { return code >= HttpStatus_Ok && code < HttpStatus_MultipleChoices; };
-
   container->content_length = esp_http_client_fetch_headers(client);
   container->status_code = esp_http_client_get_status_code(client);
-  if (is_ok(container->status_code)) {
+  if (is_success(container->status_code)) {
     container->duration_ms = millis() - start;
     return container;
   }
 
   if (this->follow_redirects_) {
-    auto is_redirect = [](int code) {
-      return code == HttpStatus_MovedPermanently || code == HttpStatus_Found || code == HttpStatus_SeeOther ||
-             code == HttpStatus_TemporaryRedirect || code == HttpStatus_PermanentRedirect;
-    };
     auto num_redirects = this->redirect_limit_;
     while (is_redirect(container->status_code) && num_redirects > 0) {
       err = esp_http_client_set_redirection(client);
@@ -142,9 +135,9 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::start(std::string url, std::strin
         return nullptr;
       }
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-      char url[256]{};
-      if (esp_http_client_get_url(client, url, sizeof(url) - 1) == ESP_OK) {
-        ESP_LOGV(TAG, "redirecting to url: %s", url);
+      char redirect_url[256]{};
+      if (esp_http_client_get_url(client, redirect_url, sizeof(redirect_url) - 1) == ESP_OK) {
+        ESP_LOGV(TAG, "redirecting to url: %s", redirect_url);
       }
 #endif
       err = esp_http_client_open(client, 0);
@@ -157,7 +150,7 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::start(std::string url, std::strin
 
       container->content_length = esp_http_client_fetch_headers(client);
       container->status_code = esp_http_client_get_status_code(client);
-      if (is_ok(container->status_code)) {
+      if (is_success(container->status_code)) {
         container->duration_ms = millis() - start;
         return container;
       }
@@ -172,8 +165,7 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::start(std::string url, std::strin
 
   ESP_LOGE(TAG, "HTTP Request failed; URL: %s; Code: %d", url.c_str(), container->status_code);
   this->status_momentary_error("failed", 1000);
-  esp_http_client_cleanup(client);
-  return nullptr;
+  return container;
 }
 
 int HttpContainerIDF::read(uint8_t *buf, size_t max_len) {

esphome/components/http_request/ota/ota_http_request.cpp

@@ -106,7 +106,7 @@ uint8_t OtaHttpRequestComponent::do_ota_() {
 
   auto container = this->parent_->get(url_with_auth);
 
-  if (container == nullptr) {
+  if (container == nullptr || container->status_code != HTTP_STATUS_OK) {
     return OTA_CONNECTION_ERROR;
   }
 

esphome/components/http_request/update/http_request_update.cpp

@@ -31,7 +31,7 @@ void HttpRequestUpdate::setup() {
 void HttpRequestUpdate::update() {
   auto container = this->request_parent_->get(this->source_url_);
 
-  if (container == nullptr) {
+  if (container == nullptr || container->status_code != HTTP_STATUS_OK) {
     std::string msg = str_sprintf("Failed to fetch manifest from %s", this->source_url_.c_str());
     this->status_set_error(msg.c_str());
     return;

esphome/components/i2c_device/__init__.py

@@ -0,0 +1,26 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import i2c
+from esphome.const import CONF_ID
+
+DEPENDENCIES = ["i2c"]
+CODEOWNERS = ["@gabest11"]
+MULTI_CONF = True
+
+i2c_device_ns = cg.esphome_ns.namespace("i2c_device")
+
+I2CDeviceComponent = i2c_device_ns.class_(
+    "I2CDeviceComponent", cg.Component, i2c.I2CDevice
+)
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_ID): cv.declare_id(I2CDeviceComponent),
+    }
+).extend(i2c.i2c_device_schema(None))
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)

esphome/components/i2c_device/i2c_device.cpp

@@ -0,0 +1,17 @@
+#include "i2c_device.h"
+#include "esphome/core/log.h"
+#include "esphome/core/hal.h"
+#include <cinttypes>
+
+namespace esphome {
+namespace i2c_device {
+
+static const char *const TAG = "i2c_device";
+
+void I2CDeviceComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "I2CDevice");
+  LOG_I2C_DEVICE(this);
+}
+
+}  // namespace i2c_device
+}  // namespace esphome

esphome/components/i2c_device/i2c_device.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/i2c/i2c.h"
+
+namespace esphome {
+namespace i2c_device {
+
+class I2CDeviceComponent : public Component, public i2c::I2CDevice {
+ public:
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+
+ protected:
+};
+
+}  // namespace i2c_device
+}  // namespace esphome

esphome/components/i2s_audio/__init__.py

@@ -8,7 +8,7 @@ from esphome.components.esp32.const import (
     VARIANT_ESP32S3,
 )
 import esphome.config_validation as cv
-from esphome.const import CONF_CHANNEL, CONF_ID, CONF_SAMPLE_RATE
+from esphome.const import CONF_BITS_PER_SAMPLE, CONF_CHANNEL, CONF_ID, CONF_SAMPLE_RATE
 from esphome.cpp_generator import MockObjClass
 import esphome.final_validate as fv
 
@@ -25,13 +25,11 @@ CONF_I2S_LRCLK_PIN = "i2s_lrclk_pin"
 CONF_I2S_AUDIO = "i2s_audio"
 CONF_I2S_AUDIO_ID = "i2s_audio_id"
 
-CONF_BITS_PER_SAMPLE = "bits_per_sample"
 CONF_I2S_MODE = "i2s_mode"
 CONF_PRIMARY = "primary"
 CONF_SECONDARY = "secondary"
 
 CONF_USE_APLL = "use_apll"
-CONF_BITS_PER_SAMPLE = "bits_per_sample"
 CONF_BITS_PER_CHANNEL = "bits_per_channel"
 CONF_MONO = "mono"
 CONF_LEFT = "left"

esphome/components/i2s_audio/speaker/__init__.py

@@ -16,16 +16,18 @@ from .. import (
     register_i2s_audio_component,
 )
 
-CODEOWNERS = ["@jesserockz"]
+AUTO_LOAD = ["audio"]
+CODEOWNERS = ["@jesserockz", "@kahrendt"]
 DEPENDENCIES = ["i2s_audio"]
 
 I2SAudioSpeaker = i2s_audio_ns.class_(
     "I2SAudioSpeaker", cg.Component, speaker.Speaker, I2SAudioOut
 )
 
-
+CONF_BUFFER_DURATION = "buffer_duration"
 CONF_DAC_TYPE = "dac_type"
 CONF_I2S_COMM_FMT = "i2s_comm_fmt"
+CONF_NEVER = "never"
 
 i2s_dac_mode_t = cg.global_ns.enum("i2s_dac_mode_t")
 INTERNAL_DAC_OPTIONS = {
@@ -72,8 +74,12 @@ BASE_SCHEMA = (
     .extend(
         {
             cv.Optional(
-                CONF_TIMEOUT, default="100ms"
+                CONF_BUFFER_DURATION, default="500ms"
             ): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_TIMEOUT, default="500ms"): cv.Any(
+                cv.positive_time_period_milliseconds,
+                cv.one_of(CONF_NEVER, lower=True),
+            ),
         }
     )
     .extend(cv.COMPONENT_SCHEMA)
@@ -115,4 +121,6 @@ async def to_code(config):
     else:
         cg.add(var.set_dout_pin(config[CONF_I2S_DOUT_PIN]))
         cg.add(var.set_i2s_comm_fmt(config[CONF_I2S_COMM_FMT]))
-    cg.add(var.set_timeout(config[CONF_TIMEOUT]))
+    if config[CONF_TIMEOUT] != CONF_NEVER:
+        cg.add(var.set_timeout(config[CONF_TIMEOUT]))
+    cg.add(var.set_buffer_duration(config[CONF_BUFFER_DURATION]))