esphome 0.6.0 → 1.1.0

data/lib/esphome/entities/climate.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+module ESPHome
+  module Entities
+    class Climate < Entity
+      include HasState
+
+      BASE_FAN_MODES = Api::ClimateCommandRequest.descriptor.lookup("fan_mode")
+                                                 .subtype
+                                                 .map { |value| value.name[12..].downcase.to_sym }
+                                                 .freeze
+      private_constant :BASE_FAN_MODES
+      BASE_PRESETS = Api::ClimateCommandRequest.descriptor.lookup("preset")
+                                               .subtype
+                                               .map { |value, _number| value.to_s }
+                                               .reject { |value| value == "CLIMATE_PRESET_NONE" }
+                                               .map { |value| value[15..].downcase.to_sym }
+                                               .freeze
+      private_constant :BASE_PRESETS
+      UNIT_SYMBOLS = {
+        celsius: "°C",
+        fahrenheit: "°F",
+        kelvin: "K"
+      }.freeze
+
+      module Features
+        SUPPORTS_CURRENT_TEMPERATURE = 1 << 0
+        SUPPORTS_TWO_POINT_TARGET_TEMPERATURE = 1 << 1
+        REQUIRES_TWO_POINT_TARGET_TEMPERATURE = 1 << 2
+        SUPPORTS_CURRENT_HUMIDITY = 1 << 3
+        SUPPORTS_TARGET_HUMIDITY = 1 << 4
+        SUPPORTS_ACTION = 1 << 5
+      end
+
+      attr_reader :supported_modes,
+                  :visual_temperature_range,
+                  :visual_target_temperature_step,
+                  :supported_fan_modes,
+                  :supported_swing_modes,
+                  :supported_presets,
+                  :visual_humidity_range,
+                  :current_temperature,
+                  :target_temperature,
+                  :target_temperature_low,
+                  :target_temperature_high,
+                  :action,
+                  :fan_mode,
+                  :swing_mode,
+                  :preset,
+                  :current_humidity,
+                  :target_humidity,
+                  :temperature_unit
+
+      def initialize(_device, list_entities_response)
+        super
+
+        if list_entities_response.feature_flags
+          @supports_current_temperature = list_entities_response.feature_flags.anybits?(Features::SUPPORTS_CURRENT_TEMPERATURE)
+          @supports_two_point_target_temperature = list_entities_response.feature_flags.anybits?(Features::SUPPORTS_TWO_POINT_TARGET_TEMPERATURE)
+          @supports_current_humidity = list_entities_response.feature_flags.anybits?(Features::SUPPORTS_CURRENT_HUMIDITY)
+          @supports_target_humidity = list_entities_response.feature_flags.anybits?(Features::SUPPORTS_TARGET_HUMIDITY)
+          @supports_action = list_entities_response.feature_flags.anybits?(Features::SUPPORTS_ACTION)
+        else
+          @supports_current_temperature = list_entities_response.supports_current_temperature
+          @supports_two_point_target_temperature = list_entities_response.supports_two_point_target_temperature
+          @supports_current_humidity = list_entities_response.supports_current_humidity
+          @supports_target_humidity = list_entities_response.supports_target_humidity
+          @supports_action = list_entities_response.supports_action
+        end
+        @supported_modes = list_entities_response.supported_modes.map { |m| m[13..].downcase.to_sym }.freeze
+        @visual_temperature_range = Range.new(list_entities_response.visual_min_temperature,
+                                              list_entities_response.visual_max_temperature)
+        @visual_target_temperature_step = list_entities_response.visual_target_temperature_step
+        @supported_fan_modes = list_entities_response.supported_fan_modes.map { |m| m[12..].downcase.to_sym }
+        @supported_swing_modes = list_entities_response.supported_swing_modes.map { |m| m[14..].downcase.to_sym }.freeze
+        @supported_fan_modes.concat(list_entities_response.supported_custom_fan_modes.map(&:to_sym))
+        @supported_fan_modes.freeze
+        @supported_presets = list_entities_response.supported_presets.map { |p| p[15..].downcase.to_sym }
+        if list_entities_response.legacy_supports_away && !@supported_presets.include?(:away)
+          @supported_presets.push(:away)
+        end
+        @supported_presets.concat(list_entities_response.supported_custom_presets.map(&:to_sym))
+        @supported_presets.freeze
+        @visual_humidity_range = Range.new(list_entities_response.visual_min_humidity,
+                                           list_entities_response.visual_max_humidity)
+        @temperature_unit = list_entities_response.temperature_unit&.[](17..)&.downcase&.to_sym || :celsius
+      end
+
+      def current_temperature?
+        @supports_current_temperature
+      end
+
+      def two_point_target_temperature?
+        @supports_two_point_target_temperature
+      end
+
+      def action?
+        @supports_action
+      end
+
+      def current_humidity?
+        @supports_current_humidity
+      end
+
+      def target_humidity?
+        @supports_target_humidity
+      end
+
+      def update(state_response)
+        @state = state_response.mode[13..].downcase.to_sym
+        @current_temperature = state_response.current_temperature if current_temperature?
+        if two_point_target_temperature?
+          @target_temperature_low = state_response.target_temperature_low
+          @target_temperature_high = state_response.target_temperature_high
+        else
+          @target_temperature = state_response.target_temperature
+        end
+        @action = state_response.action[15..].downcase.to_sym if action?
+        @fan_mode = if state_response.custom_fan_mode.empty?
+                      state_response.fan_mode[12..].downcase.to_sym
+                    else
+                      state_response.custom_fan_mode.downcase.to_sym
+                    end
+        @swing_mode = state_response.swing_mode[14..].downcase.to_sym
+        @preset = if !state_response.custom_preset.empty?
+                    state_response.custom_preset.to_sym
+                  elsif state_response.unused_legacy_away
+                    :away
+                  elsif state_response.preset == :CLIMATE_PRESET_NONE
+                    nil
+                  else
+                    state_response.preset[15..].downcase.to_sym
+                  end
+        @current_humidity = state_response.current_humidity if current_humidity?
+        @target_humidity = state_response.target_humidity if target_humidity?
+      end
+
+      def formatted_state
+        formatted_segments.join(" ")
+      end
+
+      def formatted_segments
+        segments = [state.nil? ? "-" : state.to_s]
+        segments << "(#{action || "-"})" if action?
+        segments << "#{format_temperature(current_temperature)} /" if current_temperature?
+        if two_point_target_temperature?
+          segments << format_temperature(target_temperature_low)
+          segments << "-"
+          segments << format_temperature(target_temperature_high)
+        else
+          segments << format_temperature(target_temperature)
+        end
+        segments << "fan: #{fan_mode || "-"}" unless supported_fan_modes.empty?
+        segments << "swing: #{swing_mode || "-"}" unless supported_swing_modes.empty?
+        segments << formatted_preset_segment unless supported_presets.empty?
+        segments << "#{current_humidity || "-"} %RH" if current_humidity?
+        segments << "/" if current_humidity? && target_humidity?
+        segments << "#{target_humidity || "-"} %RH" if target_humidity?
+        segments
+      end
+
+      def formatted_fan_segment
+        "fan: #{fan_mode || "-"}"
+      end
+
+      def formatted_swing_segment
+        "swing: #{swing_mode || "-"}"
+      end
+
+      def formatted_preset_segment
+        preset ? preset.to_s : "<preset>"
+      end
+
+      def temperature_decimals
+        str = visual_target_temperature_step.to_s
+        return 0 unless str.include?(".")
+
+        str.split(".").last.sub(/0+\z/, "").length
+      end
+
+      def format_temperature(value)
+        return "-" if value.nil?
+
+        format("%.#{temperature_decimals}f #{unit_symbol}", value)
+      end
+
+      def format_humidity(value)
+        return "-" if value.nil?
+
+        format("%.0f %%RH", value)
+      end
+
+      def unit_symbol
+        UNIT_SYMBOLS[temperature_unit]
+      end
+
+      def change_mode(mode)
+        device.send(Api::ClimateCommandRequest.new(key:,
+                                                   has_mode: true,
+                                                   mode: :"CLIMATE_MODE_#{mode.to_s.upcase}"))
+      end
+
+      def change_fan_mode(mode)
+        mode = mode.to_sym
+        if BASE_FAN_MODES.include?(mode)
+          device.send(Api::ClimateCommandRequest.new(key:,
+                                                     has_fan_mode: true,
+                                                     fan_mode: :"CLIMATE_FAN_#{mode.to_s.upcase}"))
+        else
+          device.send(Api::ClimateCommandRequest.new(key:,
+                                                     has_custom_fan_mode: true,
+                                                     custom_fan_mode: mode.to_s))
+        end
+      end
+
+      def change_target_temperature(value = nil, low: nil, high: nil)
+        command = Api::ClimateCommandRequest.new(key:)
+        if low
+          command.has_target_temperature_low = true
+          command.target_temperature_low = low
+        end
+        if high
+          command.has_target_temperature_high = true
+          command.target_temperature_high = high
+        end
+        if value
+          command.has_target_temperature = true
+          command.target_temperature = value
+        end
+        device.send(command)
+      end
+
+      def change_swing_mode(mode)
+        device.send(Api::ClimateCommandRequest.new(key:,
+                                                   has_swing_mode: true,
+                                                   swing_mode: :"CLIMATE_SWING_#{mode.to_s.upcase}"))
+      end
+
+      def change_target_humidity(value)
+        device.send(Api::ClimateCommandRequest.new(key:,
+                                                   has_target_humidity: true,
+                                                   target_humidity: value))
+      end
+
+      def change_preset(value)
+        value = value.to_sym
+        if BASE_PRESETS.include?(value)
+          device.send(Api::ClimateCommandRequest.new(key:,
+                                                     has_preset: true,
+                                                     preset: :"CLIMATE_PRESET_#{value.to_s.upcase}"))
+        else
+          device.send(Api::ClimateCommandRequest.new(key:,
+                                                     has_custom_preset: true,
+                                                     custom_preset: value.to_s))
+        end
+      end
+    end
+  end
+end

data/lib/esphome/entities/cover.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module ESPHome
+  module Entities
+    class Cover < Entity
+      include HasDeviceClass
+      include HasAssumedState
+
+      attr_reader :position, :tilt, :current_operation
+
+      def initialize(_device, list_entities_response)
+        super
+
+        @supports_position = list_entities_response.supports_position
+        @supports_stop = list_entities_response.supports_stop
+        @supports_tilt = list_entities_response.supports_tilt
+        @position = @tilt = @current_operation = nil
+      end
+
+      def position?
+        @supports_position
+      end
+
+      def tilt?
+        @supports_tilt
+      end
+
+      def stop?
+        @supports_stop
+      end
+
+      def formatted_state
+        formatted_segments.join(" ")
+      end
+
+      def formatted_segments
+        segments = [formatted_position_segment]
+        if tilt?
+          segments << "-"
+          segments << formatted_tilt_segment
+        end
+        segments << formatted_operation_segment
+      end
+
+      def formatted_position_segment
+        if position?
+          formatted_percentage_segment(position)
+        elsif position == 1.0 # rubocop:disable Lint/FloatComparison
+          "OPEN"
+        elsif position == 0.0
+          "CLOSED"
+        else
+          "-"
+        end
+      end
+
+      def formatted_tilt_segment
+        formatted_percentage_segment(tilt)
+      end
+
+      def formatted_operation_segment
+        "(#{current_operation || "-"})"
+      end
+
+      def update(state_response)
+        @position = state_response.position if state_response.position
+        @tilt = state_response.tilt if tilt?
+
+        @current_operation = if state_response.current_operation == :COVER_OPERATION_IDLE
+                               :idle
+                             else
+                               state_response.current_operation[19..].downcase.to_sym
+                             end
+      end
+
+      def command(position: nil, tilt: nil)
+        command = Api::CoverCommandRequest.new(key:)
+        if position
+          command.has_position = true
+          command.position = position
+        end
+        if tilt
+          command.has_tilt = true
+          command.tilt = tilt
+        end
+        device.send(command)
+      end
+
+      def open
+        device.send(Api::CoverCommandRequest.new(key:,
+                                                 has_legacy_command: true,
+                                                 legacy_command: :LEGACY_COVER_COMMAND_OPEN,
+                                                 has_position: true,
+                                                 position: 1.0))
+      end
+
+      def close
+        device.send(Api::CoverCommandRequest.new(key:,
+                                                 has_legacy_command: true,
+                                                 legacy_command: :LEGACY_COVER_COMMAND_CLOSE,
+                                                 has_position: true,
+                                                 position: 0.0))
+      end
+
+      def stop
+        device.send(Api::CoverCommandRequest.new(key:,
+                                                 has_legacy_command: true,
+                                                 legacy_command: :LEGACY_COVER_COMMAND_STOP,
+                                                 stop: true))
+      end
+
+      private
+
+      def formatted_percentage_segment(value)
+        "#{if value.nil?
+             "_"
+           elsif value.finite?
+             (value * 100).round
+           else
+             value
+           end}%"
+      end
+
+      def inspection_vars
+        super + %i[position tilt current_operation]
+      end
+
+      def hideable?(var, val)
+        super ||
+          (var == :position && !position?) ||
+          (var == :tilt && !tilt?)
+      end
+    end
+  end
+end

data/lib/esphome/entities/date.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ESPHome
+  module Entities
+    class Date < Entity
+      include HasState
+
+      def update(state_response)
+        @state = if state_response.missing_state
+                   nil
+                 else
+                   ::Date.new(state_response.year,
+                              state_response.month,
+                              state_response.day)
+                 end
+      end
+
+      def command(state)
+        device.send(Api::DateCommandRequest.new(key:, year: state.year, month: state.month, day: state.day))
+      end
+    end
+  end
+end

data/lib/esphome/entities/date_time.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ESPHome
+  module Entities
+    class DateTime < Entity
+      include HasState
+
+      def update(state_response)
+        @state = if state_response.missing_state
+                   nil
+                 else
+                   ::Time.at(state_response.epoch_seconds)
+                 end
+      end
+
+      def command(state)
+        device.send(Api::DateTimeCommandRequest.new(key:, epoch_seconds: state.to_i))
+      end
+    end
+  end
+end

data/lib/esphome/entities/fan.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module ESPHome
+  module Entities
+    class Fan < Entity
+      include HasState
+
+      attr_reader :speed_count,
+                  :preset_modes,
+                  :speed,
+                  :direction,
+                  :preset_mode
+
+      def initialize(_device, list_entities_response)
+        super
+
+        @supports_oscillation = list_entities_response.supports_oscillation
+        @supports_speed = list_entities_response.supports_speed
+        @speed_count = list_entities_response.supported_speed_count if speed?
+        @speed_count = 3 if speed_count.zero? && speed?
+        @preset_modes = list_entities_response.supported_preset_modes.map(&:freeze).freeze
+
+        @oscillating = @speed = @direction = @preset_mode = nil
+      end
+
+      def oscillation?
+        @supports_oscillation
+      end
+
+      def speed?
+        @supports_speed
+      end
+
+      def oscillating?
+        @oscillating
+      end
+
+      def formatted_state
+        result = case state
+                 when nil then "-"
+                 when true then "on"
+                 else "off"
+                 end
+        if speed?
+          result +=
+            if speed_count == 100
+              " #{speed || "-"}%"
+            else
+              " #{speed || "-"}/#{speed_count}"
+            end
+        end
+        result += " oscillating" if oscillating?
+        result += " reversed" if direction == :reverse
+        result += " (#{preset_mode})" if preset_mode
+        result
+      end
+
+      def update(state_response)
+        @state = state_response.state
+        @oscillating = state_response.oscillating
+        @speed = state_response.speed_level
+        if speed? && speed.nil?
+          @speed = { FAN_SPEED_LOW: 1,
+                     FAN_SPEED_MEDIUM: 2,
+                     FAN_SPEED_HIGH: 3 }[state_response.speed]
+        end
+        @direction = state_response.direction[14..].downcase.to_sym
+        @preset_mode = state_response.preset_mode.empty? ? nil : state_response.preset_mode
+      end
+
+      private
+
+      def inspection_vars
+        super + %i[oscillation? speed_count preset_modes speed oscillating? direction preset_mode]
+      end
+
+      def hideable?(var, val)
+        super ||
+          (var == :oscillation && !oscillation?) ||
+          (var == :speed_count && !speed?) ||
+          (var == :preset_modes && preset_modes.empty?) ||
+          (var == :speed && !speed?) ||
+          (var == :oscillating && !oscillating?) ||
+          (var == :direction && direction == :forward) ||
+          (var == :preset_mode && preset_mode.nil?)
+      end
+    end
+  end
+end

data/lib/esphome/entities/light.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module ESPHome
+  module Entities
+    class Light < Entity
+      include HasState
+
+      attr_reader :supported_color_modes,
+                  :mireds_range,
+                  :effects,
+                  :brightness,
+                  :color_mode,
+                  :color_brightness,
+                  :color_temperature,
+                  :red,
+                  :green,
+                  :blue,
+                  :white,
+                  :cold_white,
+                  :warm_white,
+                  :transition_length,
+                  :flash_effect,
+                  :effect
+
+      def initialize(_device, list_entities_response)
+        super
+
+        @supported_color_modes = list_entities_response.supported_color_modes.map { |mode| mode[11..].downcase.to_sym }
+        if @supported_color_modes.empty?
+          @supported_color_modes << :brightness if list_entities_response.legacy_supports_brightness
+          @supported_color_modes << :rgb if list_entities_response.legacy_supports_rgb
+          @supported_color_modes << :white if list_entities_response.legacy_supports_white
+          @supported_color_modes << :color_temperature if list_entities_response.legacy_supports_color_temperature
+          @supported_color_modes = [:on_off] if @supported_color_modes.empty?
+        end
+        @supported_color_modes = @supported_color_modes.to_set { |mode| transform_color_mode(mode) }.freeze
+
+        @mireds_range = Range.new(list_entities_response.min_mireds, list_entities_response.max_mireds)
+
+        @effects = list_entities_response.effects.map(&:freeze).freeze
+
+        @brightness = @color_temperature = @red = @green = @blue = @white = @cold_white = @warm_white = nil
+      end
+
+      def brightness?
+        @supported_color_modes.include?(:brightness)
+      end
+
+      def white?
+        @supported_color_modes.intersect?(%i[white ww rgbw rgbww])
+      end
+
+      def rgb?
+        @supported_color_modes.intersect?(%i[rgb rgbw rgb_color_temperature rgbww])
+      end
+
+      def color_temperature?
+        @supported_color_modes.intersect?(%i[color_temperature rgb_color_temperature])
+      end
+
+      def ww?
+        @supported_color_modes.intersect?(%i[ww rgbww])
+      end
+
+      def update(state_response)
+        @state = state_response.state
+        @brightness = state_response.brightness if brightness?
+        @color_mode = state_response.color_mode
+        if rgb?
+          @color_brightness = state_response.color_brightness
+          @red = state_response.red
+          @green = state_response.green
+          @blue = state_response.blue
+        end
+        @white = state_response.white if white?
+        @color_temperature = state_response.color_temperature if color_temperature?
+        if ww?
+          @cold_white = state_response.cold_white
+          @warm_white = state_response.warm_white
+        end
+        @effect = state_response.effect.empty? ? nil : state_response.effect
+      end
+
+      def formatted_state
+        result = case state
+                 when nil then "-"
+                 when true then "on"
+                 else "off"
+                 end
+        result += " #{brightness || color_brightness || "-"}%" if brightness?
+
+        if effect
+          result += effect
+        else
+          result += " #{color_temperature || "-"} mired" if color_temperature?
+
+          color = []
+          color.push(red, green, blue) if rgb?
+          color.push(white) if white?
+          color.push(cold_white, warm_white) if ww?
+          result += " (#{color.map { |c| c || "-" }.join(",")})" unless color.empty?
+        end
+
+        result += " @ #{transition_length} ms" if transition_length
+        result += " (flash)" if flash_effect
+
+        result
+      end
+
+      private
+
+      def transform_color_mode(mode)
+        case mode
+        when :cold_warm_white then :ww
+        when :rgb_white then :rgbw
+        when :rgb_cold_warm_white then :rgbww
+        else mode
+        end
+      end
+
+      def inspection_vars
+        super + %i[supported_color_modes
+                   mireds_range
+                   effects
+                   brightness
+                   color_mode
+                   color_brightness
+                   color_temperature
+                   red
+                   green
+                   blue
+                   white
+                   cold_white
+                   warm_white
+                   transition_length
+                   flash_effect
+                   effect]
+      end
+
+      def hideable?(var, val)
+        super ||
+          (var == :supported_color_modes && supported_color_modes.size <= 1) ||
+          (var == :mireds_range && !color_temperature?) ||
+          (var == :effects && effects.empty?) ||
+          (var == :brightness && !brightness?) ||
+          (var == :color_mode && supported_color_modes.size <= 1) ||
+          (var == :color_brightness && !brightness? && !rgb?) ||
+          (var == :color_temperature && !color_temperature?) ||
+          (%i[red green blue].include?(var) && !rgb?) ||
+          (var == :white && !white?) ||
+          (%(cold_white warm_white).include?(var) && !ww?) ||
+          (var == :transition_length && !transition_length) ||
+          (var == :flash_effect && !flash_effect) ||
+          (var == :effect && effects.empty?)
+      end
+    end
+  end
+end