esphome 0.6.0 → 1.1.0

data/lib/esphome/entities/lock.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ESPHome
+  module Entities
+    class Lock < Entity
+      include HasAssumedState
+      include HasState
+
+      def initialize(_device, list_entities_response)
+        super
+        @supports_open = list_entities_response.supports_open
+        @requires_code = list_entities_response.requires_code
+      end
+
+      def supports_open?
+        @supports_open
+      end
+
+      def requires_code?
+        @requires_code
+      end
+
+      def update(state_response)
+        @state = (state_response.state == :LOCK_STATE_NONE) ? nil : state_response.state[11..].downcase.to_sym
+      end
+
+      def command(command, code = nil)
+        message = Api::LockCommandRequest.new(key:, command: :"LOCK_#{command.to_s.upcase}")
+        if code
+          message.code = code
+          message.has_code = true
+        end
+        device.send(message)
+      end
+
+      def lock(code = nil) = command(:lock, code)
+      def unlock(code = nil) = command(:unlock, code)
+      def open(code = nil) = command(:open, code)
+
+      private
+
+      def inspection_vars
+        super + %i[supports_open? requires_code?]
+      end
+
+      def hideable?(var, val)
+        super ||
+          (var == :supports_open && val) ||
+          (var == :requires_code && val)
+      end
+    end
+  end
+end

data/lib/esphome/entities/number.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ESPHome
+  module Entities
+    class Number < Entity
+      include HasDeviceClass
+      include HasState
+
+      attr_reader :range, :step, :unit_of_measurement, :mode
+
+      def initialize(_device, list_entities_response)
+        super
+
+        @range = Range.new(list_entities_response.min_value, list_entities_response.max_value)
+        @max_value = list_entities_response.max_value
+        @step = list_entities_response.step
+        @unit_of_measurement = list_entities_response.unit_of_measurement
+        @mode = list_entities_response.mode[12..].downcase.to_sym
+      end
+
+      def accuracy_decimals
+        str = step.to_s
+        return 0 unless str.include?(".")
+
+        decimals = str.split(".").last
+        return 0 if decimals == "0"
+
+        decimals.size
+      end
+
+      def formatted_state(state = self.state)
+        result = if state
+                   format("%.#{accuracy_decimals}f", state)
+                 else
+                   "-"
+                 end
+        result += " #{unit_of_measurement}" if unit_of_measurement
+        result
+      end
+
+      def set(state)
+        device.send(Api::NumberCommandRequest.new(key:, state:))
+      end
+
+      private
+
+      def inspection_vars
+        super + %i[range step unit_of_measurement mode]
+      end
+
+      def hideable?(var, val)
+        super || (var == :mode && val == :auto)
+      end
+    end
+  end
+end

data/lib/esphome/entities/select.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ESPHome
+  module Entities
+    class Select < Entity
+      include HasState
+
+      attr_reader :options
+
+      def initialize(_device, list_entities_response)
+        super
+
+        @options = list_entities_response.options.map(&:freeze).freeze
+      end
+
+      def command(state)
+        device.send(Api::SelectCommandRequest.new(key:, state:))
+      end
+
+      private
+
+      def inspection_vars
+        super + [:options]
+      end
+    end
+  end
+end

data/lib/esphome/entities/sensor.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ESPHome
+  module Entities
+    class Sensor < Entity
+      include HasDeviceClass
+      include HasState
+
+      attr_reader :unit_of_measurement,
+                  :accuracy_decimals,
+                  :state_class
+
+      def initialize(_device, list_entities_response)
+        super
+
+        @unit_of_measurement = list_entities_response.unit_of_measurement
+        @accuracy_decimals = list_entities_response.accuracy_decimals
+        @force_update = list_entities_response.force_update
+        @state_class = list_entities_response.state_class[12..].downcase.to_sym
+      end
+
+      def force_update?
+        @force_update
+      end
+
+      def formatted_state
+        result = if state
+                   format("%.#{accuracy_decimals}f", state)
+                 else
+                   "-"
+                 end
+        result += " #{unit_of_measurement}" if unit_of_measurement
+        result
+      end
+
+      private
+
+      def inspection_vars
+        super + %i[unit_of_measurement accuracy_decimals force_update? state_class]
+      end
+
+      def hideable?(var, val)
+        super ||
+          (var == :force_update? && !val) ||
+          (var == :state_class && val == :none)
+      end
+    end
+  end
+end

data/lib/esphome/entities/switch.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ESPHome
+  module Entities
+    class Switch < Entity
+      include HasDeviceClass
+      include HasAssumedState
+      include HasState
+
+      def update(state_response)
+        @state = state_response.state
+      end
+
+      def command(state)
+        device.send(Api::SwitchCommandRequest.new(key:, state:))
+      end
+
+      def formatted_state = state ? "on" : "off"
+
+      def on = command(true)
+      def off = command(false)
+    end
+  end
+end

data/lib/esphome/entities/text.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ESPHome
+  module Entities
+    class Text < Entity
+      include HasState
+
+      attr_reader :length_range, :pattern, :mode
+
+      def initialize(_device, list_entities_response)
+        super
+
+        @length_range = Range.new(list_entities_response.min_length, list_entities_response.max_length)
+        @pattern = list_entities_response.pattern.empty? ? nil : list_entities_response.pattern
+        @mode = list_entities_response.mode[10..].downcase.to_sym
+      end
+
+      def command(state)
+        device.send(Api::TextCommandRequest.new(key:, state:))
+      end
+
+      private
+
+      def inspection_vars
+        super + %i[length_range pattern mode]
+      end
+
+      def hideable?(var, val)
+        super ||
+          (var == :length_range && length_range == (0..0)) ||
+          (var == :pattern && pattern.nil?) ||
+          (var == :mode && val == :text)
+      end
+    end
+  end
+end

data/lib/esphome/entities/text_sensor.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ESPHome
+  module Entities
+    class TextSensor < Entity
+      include HasDeviceClass
+      include HasState
+    end
+  end
+end

data/lib/esphome/entities/time.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ESPHome
+  module Entities
+    class Time < Entity
+      include HasState
+
+      def update(state_response)
+        @state = if state_response.missing_state
+                   nil
+                 elsif defined?(ActiveSupport::Duration)
+                   state_response.hour.hours +
+                     state_response.minute.minutes +
+                     state_response.second.seconds
+                 else
+                   [state_response.hour, state_response.minute, state_response.second]
+                 end
+      end
+
+      def formatted_state
+        return format("%02d:%02d:%02d", *state) if state.is_a?(Array)
+
+        super
+      end
+
+      def command(state)
+        if defined?(ActiveSupport::Duration)
+          parts = state.parts
+          device.send(Api::TimeCommandRequest.new(key:,
+                                                  hour: parts[:hours] || 0,
+                                                  minute: parts[:minutes] || 0,
+                                                  second: parts[:seconds] || 0))
+        else
+          device.send(Api::TimeCommandRequest.new(key:, hour: state[0], minute: state[1], second: state[2]))
+        end
+      end
+    end
+  end
+end

data/lib/esphome/entity.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module ESPHome
+  class Entity
+    module HasState
+      def self.included(klass)
+        super
+
+        klass.attr_reader :state
+      end
+
+      # @!visibility private
+      def initialize(...)
+        super
+        @state = nil
+      end
+
+      def update(state_response)
+        @state = state_response.missing_state ? nil : state_response.state
+      end
+
+      def formatted_state
+        state.nil? ? "-" : state.to_s
+      end
+
+      private
+
+      def inspection_vars
+        super + [:state]
+      end
+    end
+
+    module HasAssumedState
+      def self.included(klass)
+        super
+
+        klass.attr_reader :assumed_state
+      end
+
+      # @!visibility private
+      def initialize(_device, list_entities_response)
+        super
+
+        @assumed_state = list_entities_response.assumed_state
+      end
+
+      def assumed_state?
+        @assumed_state
+      end
+
+      private
+
+      def inspection_vars
+        super + [:assumed_state?]
+      end
+
+      def hideable?(var, val)
+        super || (var == :assumed_state? && !val)
+      end
+    end
+
+    module HasDeviceClass
+      def self.included(klass)
+        super
+
+        klass.attr_reader :device_class
+      end
+
+      # @!visibility private
+      def initialize(_device, list_entities_response)
+        super
+
+        @device_class = list_entities_response.device_class.empty? ? nil : list_entities_response.device_class
+      end
+
+      private
+
+      def inspection_vars
+        super + [:device_class]
+      end
+
+      def hideable?(var, val)
+        super || (var == :device_class && val.nil?)
+      end
+    end
+
+    attr_reader :device,
+                :object_id_,
+                :key,
+                :name,
+                :icon,
+                :disabled_by_default,
+                :entity_category
+
+    # @!visibility private
+    def initialize(device, list_entities_response)
+      @device = device
+      @object_id_ = list_entities_response.name.downcase.tr(" ", "_").gsub(/[^a-z0-9_-]/, "_")
+      @key = list_entities_response.key
+      @name = list_entities_response.name
+      @icon = list_entities_response.icon.empty? ? nil : list_entities_response.icon
+      @disabled_by_default = list_entities_response.disabled_by_default
+      @entity_category = list_entities_response.entity_category[16..].downcase.to_sym
+    end
+
+    # @return [String]
+    def inspect
+      vars = inspection_vars.filter_map do |var|
+        val = __send__(var)
+        next if hideable?(var, val)
+
+        "#{var}=#{val.inspect}"
+      end
+      "#<#{self.class.name} #{vars.join(", ")}>"
+    end
+
+    private
+
+    def inspection_vars
+      %i[object_id_ key name icon disabled_by_default entity_category]
+    end
+
+    def hideable?(var, val)
+      (var == :disabled_by_default && !val) ||
+        (var == :icon && val.nil?) ||
+        (var == :entity_category && val == :none)
+    end
+  end
+end
+
+require_relative "entities/binary_sensor"
+require_relative "entities/button"
+require_relative "entities/climate"
+require_relative "entities/cover"
+require_relative "entities/date"
+require_relative "entities/date_time"
+require_relative "entities/fan"
+require_relative "entities/light"
+require_relative "entities/lock"
+require_relative "entities/number"
+require_relative "entities/select"
+require_relative "entities/sensor"
+require_relative "entities/switch"
+require_relative "entities/text"
+require_relative "entities/text_sensor"
+require_relative "entities/time"

data/lib/esphome/error.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ESPHome
+  class Error < StandardError; end
+
+  class DeviceError < Error; end
+  class NotConnectedError < Error; end
+  class DeviceConnectionError < DeviceError; end
+  class AuthenticationError < DeviceError; end
+  class InvalidPasswordError < AuthenticationError; end
+  class ConnectionClosedError < DeviceConnectionError; end
+  class ProtocolError < DeviceError; end
+  class PlaintextProtocolError < ProtocolError; end
+  class UnknownProtocolError < ProtocolError; end
+  class MessageError < DeviceError; end
+  class InvalidMessageLengthError < MessageError; end
+  class UnknownMessageError < MessageError; end
+
+  class DashboardError < Error; end
+  class NoSuchDeviceError < DashboardError; end
+  class MissingEncryptionKeyError < DashboardError; end
+
+  class SerialProxyError < Error; end
+  class NoSuchSerialProxyError < SerialProxyError; end
+  class MissingProxyError < SerialProxyError; end
+  class MissingDeviceError < SerialProxyError; end
+  class UnexpectedMessage < SerialProxyError; end
+end