esphome 2024.7.2__py3-none-any.whl → 2024.8.0__py3-none-any.whl

esphome/core/bytebuffer.cpp

@@ -0,0 +1,134 @@
+#include "bytebuffer.h"
+#include <cassert>
+
+namespace esphome {
+
+ByteBuffer ByteBuffer::create(size_t capacity) {
+  std::vector<uint8_t> data(capacity);
+  return {data};
+}
+
+ByteBuffer ByteBuffer::wrap(uint8_t *ptr, size_t len) {
+  std::vector<uint8_t> data(ptr, ptr + len);
+  return {data};
+}
+
+ByteBuffer ByteBuffer::wrap(std::vector<uint8_t> data) { return {std::move(data)}; }
+
+void ByteBuffer::set_limit(size_t limit) {
+  assert(limit <= this->get_capacity());
+  this->limit_ = limit;
+}
+void ByteBuffer::set_position(size_t position) {
+  assert(position <= this->get_limit());
+  this->position_ = position;
+}
+void ByteBuffer::clear() {
+  this->limit_ = this->get_capacity();
+  this->position_ = 0;
+}
+uint16_t ByteBuffer::get_uint16() {
+  assert(this->get_remaining() >= 2);
+  uint16_t value;
+  if (endianness_ == LITTLE) {
+    value = this->data_[this->position_++];
+    value |= this->data_[this->position_++] << 8;
+  } else {
+    value = this->data_[this->position_++] << 8;
+    value |= this->data_[this->position_++];
+  }
+  return value;
+}
+
+uint32_t ByteBuffer::get_uint32() {
+  assert(this->get_remaining() >= 4);
+  uint32_t value;
+  if (endianness_ == LITTLE) {
+    value = this->data_[this->position_++];
+    value |= this->data_[this->position_++] << 8;
+    value |= this->data_[this->position_++] << 16;
+    value |= this->data_[this->position_++] << 24;
+  } else {
+    value = this->data_[this->position_++] << 24;
+    value |= this->data_[this->position_++] << 16;
+    value |= this->data_[this->position_++] << 8;
+    value |= this->data_[this->position_++];
+  }
+  return value;
+}
+uint32_t ByteBuffer::get_uint24() {
+  assert(this->get_remaining() >= 3);
+  uint32_t value;
+  if (endianness_ == LITTLE) {
+    value = this->data_[this->position_++];
+    value |= this->data_[this->position_++] << 8;
+    value |= this->data_[this->position_++] << 16;
+  } else {
+    value = this->data_[this->position_++] << 16;
+    value |= this->data_[this->position_++] << 8;
+    value |= this->data_[this->position_++];
+  }
+  return value;
+}
+uint32_t ByteBuffer::get_int24() {
+  auto value = this->get_uint24();
+  uint32_t mask = (~(uint32_t) 0) << 23;
+  if ((value & mask) != 0)
+    value |= mask;
+  return value;
+}
+uint8_t ByteBuffer::get_uint8() {
+  assert(this->get_remaining() >= 1);
+  return this->data_[this->position_++];
+}
+float ByteBuffer::get_float() {
+  auto value = this->get_uint32();
+  return *(float *) &value;
+}
+void ByteBuffer::put_uint8(uint8_t value) {
+  assert(this->get_remaining() >= 1);
+  this->data_[this->position_++] = value;
+}
+
+void ByteBuffer::put_uint16(uint16_t value) {
+  assert(this->get_remaining() >= 2);
+  if (this->endianness_ == LITTLE) {
+    this->data_[this->position_++] = (uint8_t) value;
+    this->data_[this->position_++] = (uint8_t) (value >> 8);
+  } else {
+    this->data_[this->position_++] = (uint8_t) (value >> 8);
+    this->data_[this->position_++] = (uint8_t) value;
+  }
+}
+void ByteBuffer::put_uint24(uint32_t value) {
+  assert(this->get_remaining() >= 3);
+  if (this->endianness_ == LITTLE) {
+    this->data_[this->position_++] = (uint8_t) value;
+    this->data_[this->position_++] = (uint8_t) (value >> 8);
+    this->data_[this->position_++] = (uint8_t) (value >> 16);
+  } else {
+    this->data_[this->position_++] = (uint8_t) (value >> 16);
+    this->data_[this->position_++] = (uint8_t) (value >> 8);
+    this->data_[this->position_++] = (uint8_t) value;
+  }
+}
+void ByteBuffer::put_uint32(uint32_t value) {
+  assert(this->get_remaining() >= 4);
+  if (this->endianness_ == LITTLE) {
+    this->data_[this->position_++] = (uint8_t) value;
+    this->data_[this->position_++] = (uint8_t) (value >> 8);
+    this->data_[this->position_++] = (uint8_t) (value >> 16);
+    this->data_[this->position_++] = (uint8_t) (value >> 24);
+  } else {
+    this->data_[this->position_++] = (uint8_t) (value >> 24);
+    this->data_[this->position_++] = (uint8_t) (value >> 16);
+    this->data_[this->position_++] = (uint8_t) (value >> 8);
+    this->data_[this->position_++] = (uint8_t) value;
+  }
+}
+void ByteBuffer::put_float(float value) { this->put_uint32(*(uint32_t *) &value); }
+void ByteBuffer::flip() {
+  this->limit_ = this->position_;
+  this->position_ = 0;
+}
+}  // namespace esphome

esphome/core/bytebuffer.h

@@ -0,0 +1,96 @@
+#pragma once
+
+#include <utility>
+#include <vector>
+#include <cinttypes>
+#include <cstddef>
+
+namespace esphome {
+
+enum Endian { LITTLE, BIG };
+
+/**
+ * A class modelled on the Java ByteBuffer class. It wraps a vector of bytes and permits putting and getting
+ * items of various sizes, with an automatically incremented position.
+ *
+ * There are three variables maintained pointing into the buffer:
+ *
+ * 0 <= position <= limit <= capacity
+ *
+ * capacity: the maximum amount of data that can be stored
+ * limit: the limit of the data currently available to get or put
+ * position: the current insert or extract position
+ *
+ * In addition a mark can be set to the current position with mark(). A subsequent call to reset() will restore
+ * the position to the mark.
+ *
+ * The buffer can be marked to be little-endian (default) or big-endian. All subsequent operations will use that order.
+ *
+ */
+class ByteBuffer {
+ public:
+  /**
+   * Create a new Bytebuffer with the given capacity
+   */
+  static ByteBuffer create(size_t capacity);
+  /**
+   * Wrap an existing vector in a Bytebufffer
+   */
+  static ByteBuffer wrap(std::vector<uint8_t> data);
+  /**
+   * Wrap an existing array in a Bytebufffer
+   */
+  static ByteBuffer wrap(uint8_t *ptr, size_t len);
+
+  // Get one byte from the buffer, increment position by 1
+  uint8_t get_uint8();
+  // Get a 16 bit unsigned value, increment by 2
+  uint16_t get_uint16();
+  // Get a 24 bit unsigned value, increment by 3
+  uint32_t get_uint24();
+  // Get a 32 bit unsigned value, increment by 4
+  uint32_t get_uint32();
+  // signed versions of the get functions
+  uint8_t get_int8() { return (int8_t) this->get_uint8(); };
+  int16_t get_int16() { return (int16_t) this->get_uint16(); }
+  uint32_t get_int24();
+  int32_t get_int32() { return (int32_t) this->get_uint32(); }
+  // Get a float value, increment by 4
+  float get_float();
+
+  // put values into the buffer, increment the position accordingly
+  void put_uint8(uint8_t value);
+  void put_uint16(uint16_t value);
+  void put_uint24(uint32_t value);
+  void put_uint32(uint32_t value);
+  void put_float(float value);
+
+  inline size_t get_capacity() const { return this->data_.size(); }
+  inline size_t get_position() const { return this->position_; }
+  inline size_t get_limit() const { return this->limit_; }
+  inline size_t get_remaining() const { return this->get_limit() - this->get_position(); }
+  inline Endian get_endianness() const { return this->endianness_; }
+  inline void mark() { this->mark_ = this->position_; }
+  inline void big_endian() { this->endianness_ = BIG; }
+  inline void little_endian() { this->endianness_ = LITTLE; }
+  void set_limit(size_t limit);
+  void set_position(size_t position);
+  // set position to 0, limit to capacity.
+  void clear();
+  // set limit to current position, postition to zero. Used when swapping from write to read operations.
+  void flip();
+  // retrieve a pointer to the underlying data.
+  uint8_t *array() { return this->data_.data(); };
+  void rewind() { this->position_ = 0; }
+  void reset() { this->position_ = this->mark_; }
+
+ protected:
+  ByteBuffer(std::vector<uint8_t> data) : data_(std::move(data)) { this->limit_ = this->get_capacity(); }
+  std::vector<uint8_t> data_;
+  Endian endianness_{LITTLE};
+  size_t position_{0};
+  size_t mark_{0};
+  size_t limit_{0};
+};
+
+}  // namespace esphome

esphome/core/color.h

@@ -85,22 +85,26 @@ struct Color {
   }
   inline Color operator+(const Color &add) const ESPHOME_ALWAYS_INLINE {
     Color ret;
-    if (uint8_t(add.r + this->r) < this->r)
+    if (uint8_t(add.r + this->r) < this->r) {
       ret.r = 255;
-    else
+    } else {
       ret.r = this->r + add.r;
-    if (uint8_t(add.g + this->g) < this->g)
+    }
+    if (uint8_t(add.g + this->g) < this->g) {
       ret.g = 255;
-    else
+    } else {
       ret.g = this->g + add.g;
-    if (uint8_t(add.b + this->b) < this->b)
+    }
+    if (uint8_t(add.b + this->b) < this->b) {
       ret.b = 255;
-    else
+    } else {
       ret.b = this->b + add.b;
-    if (uint8_t(add.w + this->w) < this->w)
+    }
+    if (uint8_t(add.w + this->w) < this->w) {
       ret.w = 255;
-    else
+    } else {
       ret.w = this->w + add.w;
+    }
     return ret;
   }
   inline Color &operator+=(const Color &add) ESPHOME_ALWAYS_INLINE { return *this = (*this) + add; }
@@ -108,22 +112,26 @@ struct Color {
   inline Color &operator+=(uint8_t add) ESPHOME_ALWAYS_INLINE { return *this = (*this) + add; }
   inline Color operator-(const Color &subtract) const ESPHOME_ALWAYS_INLINE {
     Color ret;
-    if (subtract.r > this->r)
+    if (subtract.r > this->r) {
       ret.r = 0;
-    else
+    } else {
       ret.r = this->r - subtract.r;
-    if (subtract.g > this->g)
+    }
+    if (subtract.g > this->g) {
       ret.g = 0;
-    else
+    } else {
       ret.g = this->g - subtract.g;
-    if (subtract.b > this->b)
+    }
+    if (subtract.b > this->b) {
       ret.b = 0;
-    else
+    } else {
       ret.b = this->b - subtract.b;
-    if (subtract.w > this->w)
+    }
+    if (subtract.w > this->w) {
       ret.w = 0;
-    else
+    } else {
       ret.w = this->w - subtract.w;
+    }
     return ret;
   }
   inline Color &operator-=(const Color &subtract) ESPHOME_ALWAYS_INLINE { return *this = (*this) - subtract; }

esphome/core/config.py

@@ -3,9 +3,9 @@ import multiprocessing
 import os
 import re
 
+from esphome import automation
 import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome import automation
 from esphome.const import (
     CONF_ARDUINO_VERSION,
     CONF_AREA,
@@ -16,11 +16,11 @@ from esphome.const import (
     CONF_COMPILE_PROCESS_LIMIT,
     CONF_ESPHOME,
     CONF_FRAMEWORK,
+    CONF_FRIENDLY_NAME,
     CONF_INCLUDES,
     CONF_LIBRARIES,
     CONF_MIN_VERSION,
     CONF_NAME,
-    CONF_FRIENDLY_NAME,
     CONF_ON_BOOT,
     CONF_ON_LOOP,
     CONF_ON_SHUTDOWN,
@@ -34,8 +34,8 @@ from esphome.const import (
     CONF_TYPE,
     CONF_VERSION,
     KEY_CORE,
-    TARGET_PLATFORMS,
     PLATFORM_ESP8266,
+    TARGET_PLATFORMS,
     __version__ as ESPHOME_VERSION,
 )
 from esphome.core import CORE, coroutine_with_priority

esphome/core/defines.h

@@ -38,11 +38,23 @@
 #define USE_LIGHT
 #define USE_LOCK
 #define USE_LOGGER
+#define USE_LVGL
+#define USE_LVGL_ANIMIMG
+#define USE_LVGL_BINARY_SENSOR
+#define USE_LVGL_BUTTONMATRIX
+#define USE_LVGL_FONT
+#define USE_LVGL_IMAGE
+#define USE_LVGL_KEYBOARD
+#define USE_LVGL_KEY_LISTENER
+#define USE_LVGL_TOUCHSCREEN
+#define USE_LVGL_ROTARY_ENCODER
 #define USE_MDNS
 #define USE_MEDIA_PLAYER
 #define USE_MQTT
+#define USE_NETWORK
 #define USE_NEXTION_TFT_UPLOAD
 #define USE_NUMBER
+#define USE_ONLINE_IMAGE_PNG_SUPPORT
 #define USE_OTA
 #define USE_OTA_PASSWORD
 #define USE_OTA_STATE_CALLBACK
@@ -147,6 +159,7 @@
 #endif
 
 // Disabled feature flags
-// #define USE_BSEC  // Requires a library with proprietary license.
+// #define USE_BSEC   // Requires a library with proprietary license
+// #define USE_BSEC2  // Requires a library with proprietary license
 
 #define USE_DASHBOARD_IMPORT

esphome/core/entity_base.h

@@ -63,7 +63,7 @@ class EntityBase {
   EntityCategory entity_category_{ENTITY_CATEGORY_NONE};
 };
 
-class EntityBase_DeviceClass {
+class EntityBase_DeviceClass {  // NOLINT(readability-identifier-naming)
  public:
   /// Get the device class, using the manual override if set.
   std::string get_device_class();
@@ -74,7 +74,7 @@ class EntityBase_DeviceClass {
   const char *device_class_{nullptr};  ///< Device class override
 };
 
-class EntityBase_UnitOfMeasurement {
+class EntityBase_UnitOfMeasurement {  // NOLINT(readability-identifier-naming)
  public:
   /// Get the unit of measurement, using the manual override if set.
   std::string get_unit_of_measurement();

esphome/core/entity_helpers.py

@@ -1,6 +1,5 @@
-import esphome.final_validate as fv
-
 from esphome.const import CONF_ID
+import esphome.final_validate as fv
 
 
 def inherit_property_from(property_to_inherit, parent_id_property, transform=None):

esphome/core/gpio.h

@@ -62,24 +62,6 @@ class GPIOPin {
   virtual bool is_internal() { return false; }
 };
 
-/**
- * A pin to replace those that don't exist.
- */
-class NullPin : public GPIOPin {
- public:
-  void setup() override {}
-
-  void pin_mode(gpio::Flags _) override {}
-
-  bool digital_read() override { return false; }
-
-  void digital_write(bool _) override {}
-
-  std::string dump_summary() const override { return {"Not used"}; }
-};
-
-static GPIOPin *const NULL_PIN = new NullPin();
-
 /// Copy of GPIOPin that is safe to use from ISRs (with no virtual functions)
 class ISRInternalGPIOPin {
  public:

esphome/core/helpers.h

@@ -680,7 +680,7 @@ template<class T> class ExternalRAMAllocator {
   }
 
  private:
-  Flags flags_{Flags::NONE};
+  Flags flags_{Flags::ALLOW_FAILURE};
 };
 
 /// @}

esphome/core/optional.h

@@ -24,7 +24,7 @@ namespace esphome {
 
 struct nullopt_t {  // NOLINT
   struct init {};   // NOLINT
-  nullopt_t(init) {}
+  nullopt_t(init /*unused*/) {}
 };
 
 // extra parenthesis to prevent the most vexing parse:
@@ -42,13 +42,13 @@ template<typename T> class optional {  // NOLINT
 
   optional() {}
 
-  optional(nullopt_t) {}
+  optional(nullopt_t /*unused*/) {}
 
   optional(T const &arg) : has_value_(true), value_(arg) {}  // NOLINT
 
   template<class U> optional(optional<U> const &other) : has_value_(other.has_value()), value_(other.value()) {}
 
-  optional &operator=(nullopt_t) {
+  optional &operator=(nullopt_t /*unused*/) {
     reset();
     return *this;
   }
@@ -104,7 +104,6 @@ template<typename T> class optional {  // NOLINT
     has_value_ = true;
   }
 
- private:
   bool has_value_{false};  // NOLINT
   value_type value_;       // NOLINT
 };
@@ -131,29 +130,29 @@ template<typename T, typename U> inline bool operator>=(optional<T> const &x, op
 
 // Comparison with nullopt
 
-template<typename T> inline bool operator==(optional<T> const &x, nullopt_t) { return (!x); }
+template<typename T> inline bool operator==(optional<T> const &x, nullopt_t /*unused*/) { return (!x); }
 
-template<typename T> inline bool operator==(nullopt_t, optional<T> const &x) { return (!x); }
+template<typename T> inline bool operator==(nullopt_t /*unused*/, optional<T> const &x) { return (!x); }
 
-template<typename T> inline bool operator!=(optional<T> const &x, nullopt_t) { return bool(x); }
+template<typename T> inline bool operator!=(optional<T> const &x, nullopt_t /*unused*/) { return bool(x); }
 
-template<typename T> inline bool operator!=(nullopt_t, optional<T> const &x) { return bool(x); }
+template<typename T> inline bool operator!=(nullopt_t /*unused*/, optional<T> const &x) { return bool(x); }
 
-template<typename T> inline bool operator<(optional<T> const &, nullopt_t) { return false; }
+template<typename T> inline bool operator<(optional<T> const & /*unused*/, nullopt_t /*unused*/) { return false; }
 
-template<typename T> inline bool operator<(nullopt_t, optional<T> const &x) { return bool(x); }
+template<typename T> inline bool operator<(nullopt_t /*unused*/, optional<T> const &x) { return bool(x); }
 
-template<typename T> inline bool operator<=(optional<T> const &x, nullopt_t) { return (!x); }
+template<typename T> inline bool operator<=(optional<T> const &x, nullopt_t /*unused*/) { return (!x); }
 
-template<typename T> inline bool operator<=(nullopt_t, optional<T> const &) { return true; }
+template<typename T> inline bool operator<=(nullopt_t /*unused*/, optional<T> const & /*unused*/) { return true; }
 
-template<typename T> inline bool operator>(optional<T> const &x, nullopt_t) { return bool(x); }
+template<typename T> inline bool operator>(optional<T> const &x, nullopt_t /*unused*/) { return bool(x); }
 
-template<typename T> inline bool operator>(nullopt_t, optional<T> const &) { return false; }
+template<typename T> inline bool operator>(nullopt_t /*unused*/, optional<T> const & /*unused*/) { return false; }
 
-template<typename T> inline bool operator>=(optional<T> const &, nullopt_t) { return true; }
+template<typename T> inline bool operator>=(optional<T> const & /*unused*/, nullopt_t /*unused*/) { return true; }
 
-template<typename T> inline bool operator>=(nullopt_t, optional<T> const &x) { return (!x); }
+template<typename T> inline bool operator>=(nullopt_t /*unused*/, optional<T> const &x) { return (!x); }
 
 // Comparison with T
 

esphome/coroutine.py

@@ -43,13 +43,13 @@ the last `yield` expression defines what is returned.
 """
 
 import collections
+from collections.abc import Awaitable, Generator, Iterator
 import functools
 import heapq
 import inspect
 import logging
 import types
 from typing import Any, Callable
-from collections.abc import Awaitable, Generator, Iterator
 
 _LOGGER = logging.getLogger(__name__)
 

esphome/cpp_generator.py

@@ -1,8 +1,8 @@
 import abc
+from collections.abc import Sequence
 import inspect
 import math
 import re
-from collections.abc import Sequence
 from typing import Any, Callable, Optional, Union
 
 from esphome.core import (

esphome/cpp_helpers.py

@@ -12,15 +12,13 @@ from esphome.const import (
     CONF_UPDATE_INTERVAL,
     KEY_PAST_SAFE_MODE,
 )
-
-from esphome.core import coroutine, ID, CORE
+from esphome.core import CORE, ID, coroutine
 from esphome.coroutine import FakeAwaitable
-from esphome.types import ConfigType, ConfigFragmentType
 from esphome.cpp_generator import add, get_variable
 from esphome.cpp_types import App
+from esphome.helpers import sanitize, snake_case
+from esphome.types import ConfigFragmentType, ConfigType
 from esphome.util import Registry, RegistryEntry
-from esphome.helpers import snake_case, sanitize
-
 
 _LOGGER = logging.getLogger(__name__)
 

esphome/dashboard/core.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
 import asyncio
+from collections.abc import Coroutine
 import contextlib
-import logging
-import threading
 from dataclasses import dataclass
 from functools import partial
+import logging
+import threading
 from typing import TYPE_CHECKING, Any, Callable
-from collections.abc import Coroutine
 
 from ..zeroconf import DiscoveredImport
 from .dns import DNSCache

esphome/dashboard/dashboard.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 import asyncio
+from asyncio import events
+from concurrent.futures import ThreadPoolExecutor
 import logging
 import os
 import socket
 import threading
-import traceback
-from asyncio import events
-from concurrent.futures import ThreadPoolExecutor
 from time import monotonic
+import traceback
 from typing import Any
 
 from esphome.storage_json import EsphomeStorageJSON, esphome_storage_path

esphome/dashboard/entries.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import asyncio
+from collections import defaultdict
 import logging
 import os
-from collections import defaultdict
 from typing import TYPE_CHECKING, Any
 
 from esphome import const, util

esphome/dashboard/util/file.py

@@ -1,7 +1,7 @@
 import logging
 import os
-import tempfile
 from pathlib import Path
+import tempfile
 
 _LOGGER = logging.getLogger(__name__)
 

esphome/dashboard/web_server.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import base64
+from collections.abc import Iterable
 import datetime
 import functools
 import gzip
@@ -9,13 +10,12 @@ import hashlib
 import json
 import logging
 import os
+from pathlib import Path
 import secrets
 import shutil
 import subprocess
 import threading
 import time
-from collections.abc import Iterable
-from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, TypeVar
 from urllib.parse import urlparse
 
@@ -26,13 +26,13 @@ import tornado.httpserver
 import tornado.httputil
 import tornado.ioloop
 import tornado.iostream
+from tornado.log import access_log
 import tornado.netutil
 import tornado.process
 import tornado.queues
 import tornado.web
 import tornado.websocket
 import yaml
-from tornado.log import access_log
 from yaml.nodes import Node
 
 from esphome import const, platformio_api, yaml_util

esphome/external_files.py

@@ -1,13 +1,15 @@
 from __future__ import annotations
 
+from datetime import datetime
 import logging
-from pathlib import Path
 import os
-from datetime import datetime
+from pathlib import Path
+
 import requests
+
 import esphome.config_validation as cv
-from esphome.core import CORE, TimePeriodSeconds
 from esphome.const import __version__
+from esphome.core import CORE, TimePeriodSeconds
 
 _LOGGER = logging.getLogger(__name__)
 CODEOWNERS = ["@landonr"]

esphome/final_validate.py

@@ -1,9 +1,9 @@
 from abc import ABC, abstractmethod
-from typing import Any
 import contextvars
+from typing import Any
 
-from esphome.types import ConfigFragmentType, ID, ConfigPathType
 import esphome.config_validation as cv
+from esphome.types import ID, ConfigFragmentType, ConfigPathType
 
 
 class FinalValidateConfig(ABC):