Drop smartir from root (48f4f2f0) · Commits · Dmitrii Safronov / SmartIR

smartir/init.py

deleted100644 → 0

+0 −173

Original line number	Diff line number	Diff line
		import asyncio
		import binascii
		from distutils.version import StrictVersion
		import json
		import logging
		import os.path
		import requests
		import struct
		import voluptuous as vol

		from homeassistant.const import (
		ATTR_FRIENDLY_NAME, __version__ as current_ha_version)
		import homeassistant.helpers.config_validation as cv
		from homeassistant.helpers.typing import ConfigType

		_LOGGER = logging.getLogger(__name__)

		DOMAIN = 'smartir'
		VERSION = '1.7.1'
		MANIFEST_URL = (
		"https://raw.githubusercontent.com/"
		"smartHomeHub/SmartIR/{}/"
		"custom_components/smartir/manifest.json")
		REMOTE_BASE_URL = (
		"https://raw.githubusercontent.com/"
		"smartHomeHub/SmartIR/{}/"
		"custom_components/smartir/")
		COMPONENT_ABS_DIR = os.path.dirname(
		os.path.abspath(__file__))

		CONF_CHECK_UPDATES = 'check_updates'
		CONF_UPDATE_BRANCH = 'update_branch'

		CONFIG_SCHEMA = vol.Schema({
		DOMAIN: vol.Schema({
		vol.Optional(CONF_CHECK_UPDATES, default=True): cv.boolean,
		vol.Optional(CONF_UPDATE_BRANCH, default='master'): vol.In(
		['master', 'rc'])
		})
		}, extra=vol.ALLOW_EXTRA)

		async def async_setup(hass, config):
		"""Set up the SmartIR component."""
		conf = config.get(DOMAIN)

		if conf is None:
		return True

		check_updates = conf[CONF_CHECK_UPDATES]
		update_branch = conf[CONF_UPDATE_BRANCH]

		async def _check_updates(service):
		await _update(hass, update_branch)

		async def _update_component(service):
		await _update(hass, update_branch, True)

		hass.services.async_register(DOMAIN, 'check_updates', _check_updates)
		hass.services.async_register(DOMAIN, 'update_component', _update_component)

		if check_updates:
		await _update(hass, update_branch, False, False)

		return True

		async def _update(hass, branch, do_update=False, notify_if_latest=True):
		try:
		request = requests.get(MANIFEST_URL.format(branch), stream=True, timeout=10)
		except:
		_LOGGER.error("An error occurred while checking for updates. "
		"Please check your internet connection.")
		return

		if request.status_code != 200:
		_LOGGER.error("Invalid response from the server while "
		"checking for a new version")
		return

		data = request.json()
		min_ha_version = data['homeassistant']
		last_version = data['updater']['version']
		release_notes = data['updater']['releaseNotes']

		if StrictVersion(last_version) <= StrictVersion(VERSION):
		if notify_if_latest:
		hass.components.persistent_notification.async_create(
		"You're already using the latest version!", title='SmartIR')
		return

		if StrictVersion(current_ha_version) < StrictVersion(min_ha_version):
		hass.components.persistent_notification.async_create(
		"There is a new version of SmartIR integration, but it is incompatible "
		"with your system. Please first update Home Assistant.", title='SmartIR')
		return

		if do_update is False:
		hass.components.persistent_notification.async_create(
		"A new version of SmartIR integration is available ({}). "
		"Call the ``smartir.update_component`` service to update "
		"the integration. \n\n Release notes: \n{}"
		.format(last_version, release_notes), title='SmartIR')
		return

		# Begin update
		files = data['updater']['files']
		has_errors = False

		for file in files:
		try:
		source = REMOTE_BASE_URL.format(branch) + file
		dest = os.path.join(COMPONENT_ABS_DIR, file)
		os.makedirs(os.path.dirname(dest), exist_ok=True)
		Helper.downloader(source, dest)
		except:
		has_errors = True
		_LOGGER.error("Error updating %s. Please update the file manually.", file)

		if has_errors:
		hass.components.persistent_notification.async_create(
		"There was an error updating one or more files of SmartIR. "
		"Please check the logs for more information.", title='SmartIR')
		else:
		hass.components.persistent_notification.async_create(
		"Successfully updated to {}. Please restart Home Assistant."
		.format(last_version), title='SmartIR')

		class Helper():
		@staticmethod
		def downloader(source, dest):
		req = requests.get(source, stream=True, timeout=10)

		if req.status_code == 200:
		with open(dest, 'wb') as fil:
		for chunk in req.iter_content(1024):
		fil.write(chunk)
		else:
		raise Exception("File not found")

		@staticmethod
		def pronto2lirc(pronto):
		codes = [int(binascii.hexlify(pronto[i:i+2]), 16) for i in range(0, len(pronto), 2)]

		if codes[0]:
		raise ValueError("Pronto code should start with 0000")
		if len(codes) != 4 + 2 * (codes[2] + codes[3]):
		raise ValueError("Number of pulse widths does not match the preamble")

		frequency = 1 / (codes[1] * 0.241246)
		return [int(round(code / frequency)) for code in codes[4:]]

		@staticmethod
		def lirc2broadlink(pulses):
		array = bytearray()

		for pulse in pulses:
		pulse = int(pulse * 269 / 8192)

		if pulse < 256:
		array += bytearray(struct.pack('>B', pulse))
		else:
		array += bytearray([0x00])
		array += bytearray(struct.pack('>H', pulse))

		packet = bytearray([0x26, 0x00])
		packet += bytearray(struct.pack('<H', len(array)))
		packet += array
		packet += bytearray([0x0d, 0x05])

		# Add 0s to make ultimate packet size a multiple of 16 for 128-bit AES encryption.
		remainder = (len(packet) + 4) % 16
		if remainder:
		packet += bytearray(16 - remainder)
		return packet

smartir/climate.py

deleted100644 → 0

+0 −385

Original line number	Diff line number	Diff line
		import asyncio
		import json
		import logging
		import os.path

		import voluptuous as vol

		from homeassistant.components.climate import ClimateDevice, PLATFORM_SCHEMA
		from homeassistant.components.climate.const import (
		HVAC_MODE_OFF, HVAC_MODE_HEAT, HVAC_MODE_COOL,
		HVAC_MODE_DRY, HVAC_MODE_FAN_ONLY, HVAC_MODE_AUTO,
		SUPPORT_TARGET_TEMPERATURE, SUPPORT_FAN_MODE,
		HVAC_MODES, ATTR_HVAC_MODE)
		from homeassistant.const import (
		CONF_NAME, STATE_ON, STATE_UNKNOWN, ATTR_TEMPERATURE,
		PRECISION_TENTHS, PRECISION_HALVES, PRECISION_WHOLE)
		from homeassistant.core import callback
		from homeassistant.helpers.event import async_track_state_change
		import homeassistant.helpers.config_validation as cv
		from homeassistant.helpers.restore_state import RestoreEntity
		from . import COMPONENT_ABS_DIR, Helper
		from .controller import Controller

		_LOGGER = logging.getLogger(__name__)

		DEFAULT_NAME = "SmartIR Climate"

		CONF_UNIQUE_ID = 'unique_id'
		CONF_DEVICE_CODE = 'device_code'
		CONF_CONTROLLER_DATA = "controller_data"
		CONF_TEMPERATURE_SENSOR = 'temperature_sensor'
		CONF_HUMIDITY_SENSOR = 'humidity_sensor'
		CONF_POWER_SENSOR = 'power_sensor'

		SUPPORT_FLAGS = (
		SUPPORT_TARGET_TEMPERATURE \|
		SUPPORT_FAN_MODE
		)

		PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
		vol.Optional(CONF_UNIQUE_ID): cv.string,
		vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
		vol.Required(CONF_DEVICE_CODE): cv.positive_int,
		vol.Required(CONF_CONTROLLER_DATA): cv.string,
		vol.Optional(CONF_TEMPERATURE_SENSOR): cv.entity_id,
		vol.Optional(CONF_HUMIDITY_SENSOR): cv.entity_id,
		vol.Optional(CONF_POWER_SENSOR): cv.entity_id
		})

		async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
		"""Set up the IR Climate platform."""
		device_code = config.get(CONF_DEVICE_CODE)
		device_files_subdir = os.path.join('codes', 'climate')
		device_files_absdir = os.path.join(COMPONENT_ABS_DIR, device_files_subdir)

		if not os.path.isdir(device_files_absdir):
		os.makedirs(device_files_absdir)

		device_json_filename = str(device_code) + '.json'
		device_json_path = os.path.join(device_files_absdir, device_json_filename)

		if not os.path.exists(device_json_path):
		_LOGGER.warning("Couldn't find the device Json file. The component will " \
		"try to download it from the GitHub repo.")

		try:
		codes_source = ("https://raw.githubusercontent.com/"
		"smartHomeHub/SmartIR/master/"
		"codes/climate/{}.json")

		Helper.downloader(codes_source.format(device_code), device_json_path)
		except:
		_LOGGER.error("There was an error while downloading the device Json file. " \
		"Please check your internet connection or if the device code " \
		"exists on GitHub. If the problem still exists please " \
		"place the file manually in the proper directory.")
		return

		with open(device_json_path) as j:
		try:
		device_data = json.load(j)
		except:
		_LOGGER.error("The device Json file is invalid")
		return

		async_add_entities([SmartIRClimate(
		hass, config, device_data
		)])

		class SmartIRClimate(ClimateDevice, RestoreEntity):
		def __init__(self, hass, config, device_data):
		self.hass = hass
		self._unique_id = config.get(CONF_UNIQUE_ID)
		self._name = config.get(CONF_NAME)
		self._device_code = config.get(CONF_DEVICE_CODE)
		self._controller_data = config.get(CONF_CONTROLLER_DATA)
		self._temperature_sensor = config.get(CONF_TEMPERATURE_SENSOR)
		self._humidity_sensor = config.get(CONF_HUMIDITY_SENSOR)
		self._power_sensor = config.get(CONF_POWER_SENSOR)

		self._manufacturer = device_data['manufacturer']
		self._supported_models = device_data['supportedModels']
		self._supported_controller = device_data['supportedController']
		self._commands_encoding = device_data['commandsEncoding']
		self._min_temperature = device_data['minTemperature']
		self._max_temperature = device_data['maxTemperature']
		self._precision = device_data['precision']

		valid_hvac_modes = [x for x in device_data['operationModes'] if x in HVAC_MODES]

		self._operation_modes = [HVAC_MODE_OFF] + valid_hvac_modes
		self._fan_modes = device_data['fanModes']
		self._commands = device_data['commands']

		self._target_temperature = self._min_temperature
		self._hvac_mode = HVAC_MODE_OFF
		self._current_fan_mode = self._fan_modes[0]
		self._last_on_operation = None

		self._current_temperature = None
		self._current_humidity = None

		self._unit = hass.config.units.temperature_unit
		self._support_flags = SUPPORT_FLAGS

		self._temp_lock = asyncio.Lock()
		self._on_by_remote = False

		#Init the IR/RF controller
		self._controller = Controller(
		self.hass,
		self._supported_controller,
		self._commands_encoding,
		self._controller_data)

		async def async_added_to_hass(self):
		"""Run when entity about to be added."""
		await super().async_added_to_hass()

		last_state = await self.async_get_last_state()

		if last_state is not None:
		self._hvac_mode = last_state.state
		self._current_fan_mode = last_state.attributes['fan_mode']
		self._target_temperature = last_state.attributes['temperature']

		if 'last_on_operation' in last_state.attributes:
		self._last_on_operation = last_state.attributes['last_on_operation']

		if self._temperature_sensor:
		async_track_state_change(self.hass, self._temperature_sensor,
		self._async_temp_sensor_changed)

		temp_sensor_state = self.hass.states.get(self._temperature_sensor)
		if temp_sensor_state and temp_sensor_state.state != STATE_UNKNOWN:
		self._async_update_temp(temp_sensor_state)

		if self._humidity_sensor:
		async_track_state_change(self.hass, self._humidity_sensor,
		self._async_humidity_sensor_changed)

		humidity_sensor_state = self.hass.states.get(self._humidity_sensor)
		if humidity_sensor_state and humidity_sensor_state.state != STATE_UNKNOWN:
		self._async_update_humidity(humidity_sensor_state)

		if self._power_sensor:
		async_track_state_change(self.hass, self._power_sensor,
		self._async_power_sensor_changed)

		@property
		def unique_id(self):
		"""Return a unique ID."""
		return self._unique_id

		@property
		def name(self):
		"""Return the name of the climate device."""
		return self._name

		@property
		def state(self):
		"""Return the current state."""
		if self._on_by_remote:
		return STATE_ON
		if self.hvac_mode != HVAC_MODE_OFF:
		return self.hvac_mode
		return HVAC_MODE_OFF

		@property
		def temperature_unit(self):
		"""Return the unit of measurement."""
		return self._unit

		@property
		def min_temp(self):
		"""Return the polling state."""
		return self._min_temperature

		@property
		def max_temp(self):
		"""Return the polling state."""
		return self._max_temperature

		@property
		def target_temperature(self):
		"""Return the temperature we try to reach."""
		return self._target_temperature

		@property
		def target_temperature_step(self):
		"""Return the supported step of target temperature."""
		return self._precision

		@property
		def hvac_modes(self):
		"""Return the list of available operation modes."""
		return self._operation_modes

		@property
		def hvac_mode(self):
		"""Return hvac mode ie. heat, cool."""
		return self._hvac_mode

		@property
		def last_on_operation(self):
		"""Return the last non-idle operation ie. heat, cool."""
		return self._last_on_operation

		@property
		def fan_modes(self):
		"""Return the list of available fan modes."""
		return self._fan_modes

		@property
		def fan_mode(self):
		"""Return the fan setting."""
		return self._current_fan_mode

		@property
		def current_temperature(self):
		"""Return the current temperature."""
		return self._current_temperature

		@property
		def current_humidity(self):
		"""Return the current humidity."""
		return self._current_humidity

		@property
		def supported_features(self):
		"""Return the list of supported features."""
		return self._support_flags

		@property
		def device_state_attributes(self) -> dict:
		"""Platform specific attributes."""
		return {
		'last_on_operation': self._last_on_operation,
		'device_code': self._device_code,
		'manufacturer': self._manufacturer,
		'supported_models': self._supported_models,
		'supported_controller': self._supported_controller,
		'commands_encoding': self._commands_encoding,
		}

		async def async_set_temperature(self, **kwargs):
		"""Set new target temperatures."""
		hvac_mode = kwargs.get(ATTR_HVAC_MODE)
		temperature = kwargs.get(ATTR_TEMPERATURE)

		if temperature is None:
		return

		if temperature < self._min_temperature or temperature > self._max_temperature:
		_LOGGER.warning('The temperature value is out of min/max range')
		return

		if self._precision == PRECISION_WHOLE:
		self._target_temperature = round(temperature)
		else:
		self._target_temperature = round(temperature, 1)

		if hvac_mode:
		await self.async_set_hvac_mode(hvac_mode)
		return

		if not self._hvac_mode.lower() == HVAC_MODE_OFF:
		await self.send_command()

		await self.async_update_ha_state()

		async def async_set_hvac_mode(self, hvac_mode):
		"""Set operation mode."""
		self._hvac_mode = hvac_mode

		if not hvac_mode == HVAC_MODE_OFF:
		self._last_on_operation = hvac_mode

		await self.send_command()
		await self.async_update_ha_state()

		async def async_set_fan_mode(self, fan_mode):
		"""Set fan mode."""
		self._current_fan_mode = fan_mode

		if not self._hvac_mode.lower() == HVAC_MODE_OFF:
		await self.send_command()
		await self.async_update_ha_state()

		async def async_turn_off(self):
		"""Turn off."""
		await self.async_set_hvac_mode(HVAC_MODE_OFF)

		async def async_turn_on(self):
		"""Turn on."""
		if self._last_on_operation is not None:
		await self.async_set_hvac_mode(self._last_on_operation)
		else:
		await self.async_set_hvac_mode(self._operation_modes[1])

		async def send_command(self):
		async with self._temp_lock:
		self._on_by_remote = False
		operation_mode = self._hvac_mode
		fan_mode = self._current_fan_mode
		target_temperature = '{0:g}'.format(self._target_temperature)

		if operation_mode.lower() == HVAC_MODE_OFF:
		command = self._commands['off']
		else:
		command = self._commands[operation_mode][fan_mode][target_temperature]

		try:
		await self._controller.send(command)
		except Exception as e:
		_LOGGER.exception(e)

		async def _async_temp_sensor_changed(self, entity_id, old_state, new_state):
		"""Handle temperature sensor changes."""
		if new_state is None:
		return

		self._async_update_temp(new_state)
		await self.async_update_ha_state()

		async def _async_humidity_sensor_changed(self, entity_id, old_state, new_state):
		"""Handle humidity sensor changes."""
		if new_state is None:
		return

		self._async_update_humidity(new_state)
		await self.async_update_ha_state()

		async def _async_power_sensor_changed(self, entity_id, old_state, new_state):
		"""Handle power sensor changes."""
		if new_state is None:
		return

		if new_state.state == STATE_ON and self._hvac_mode == HVAC_MODE_OFF:
		self._on_by_remote = True
		await self.async_update_ha_state()

		if new_state.state == HVAC_MODE_OFF:
		self._on_by_remote = False
		if self._hvac_mode != HVAC_MODE_OFF:
		self._hvac_mode = HVAC_MODE_OFF
		await self.async_update_ha_state()

		@callback
		def _async_update_temp(self, state):
		"""Update thermostat with latest state from temperature sensor."""
		try:
		if state.state != STATE_UNKNOWN:
		self._current_temperature = float(state.state)
		except ValueError as ex:
		_LOGGER.error("Unable to update from temperature sensor: %s", ex)

		@callback
		def _async_update_humidity(self, state):
		"""Update thermostat with latest state from humidity sensor."""
		try:
		if state.state != STATE_UNKNOWN:
		self._current_humidity = float(state.state)
		except ValueError as ex:
		_LOGGER.error("Unable to update from humidity sensor: %s", ex)
		No newline at end of file

smartir/controller.py

deleted100644 → 0

+0 −102

Original line number	Diff line number	Diff line
		import asyncio
		from base64 import b64encode
		import binascii
		import logging

		from homeassistant.const import ATTR_ENTITY_ID
		from homeassistant.core import split_entity_id
		from . import Helper

		_LOGGER = logging.getLogger(__name__)

		BROADLINK_CONTROLLER = 'Broadlink'
		XIAOMI_CONTROLLER = 'Xiaomi'
		MQTT_CONTROLLER = 'MQTT'

		ENC_BASE64 = 'Base64'
		ENC_HEX = 'Hex'
		ENC_PRONTO = 'Pronto'
		ENC_RAW = 'Raw'

		BROADLINK_COMMANDS_ENCODING = [
		ENC_BASE64, ENC_HEX, ENC_PRONTO]

		XIAOMI_COMMANDS_ENCODING = [
		ENC_PRONTO, ENC_RAW]

		MQTT_COMMANDS_ENCODING = [ENC_RAW]

		class Controller():
		def __init__(self, hass, controller, encoding, controller_data):
		if controller not in [
		BROADLINK_CONTROLLER, XIAOMI_CONTROLLER, MQTT_CONTROLLER]:
		raise Exception("The controller is not supported.")

		if controller == BROADLINK_CONTROLLER:
		if encoding not in BROADLINK_COMMANDS_ENCODING:
		raise Exception("The encoding is not supported "
		"by the Broadlink controller.")

		if controller == XIAOMI_CONTROLLER:
		if encoding not in XIAOMI_COMMANDS_ENCODING:
		raise Exception("The encoding is not supported "
		"by the Xiaomi controller.")

		if controller == MQTT_CONTROLLER:
		if encoding not in MQTT_COMMANDS_ENCODING:
		raise Exception("The encoding is not supported "
		"by the mqtt controller.")

		self.hass = hass
		self._controller = controller
		self._encoding = encoding
		self._controller_data = controller_data

		async def send(self, command):
		if self._controller == BROADLINK_CONTROLLER:
		if self._encoding == ENC_HEX:
		try:
		command = binascii.unhexlify(command)
		command = b64encode(command).decode('utf-8')
		except:
		raise Exception("Error while converting "
		"Hex to Base64 encoding")

		if self._encoding == ENC_PRONTO:
		try:
		command = command.replace(' ', '')
		command = bytearray.fromhex(command)
		command = Helper.pronto2lirc(command)
		command = Helper.lirc2broadlink(command)
		command = b64encode(command).decode('utf-8')
		except:
		raise Exception("Error while converting "
		"Pronto to Base64 encoding")

		service_data = {
		'host': self._controller_data,
		'packet': command
		}

		await self.hass.services.async_call(
		'broadlink', 'send', service_data)


		if self._controller == XIAOMI_CONTROLLER:
		service_data = {
		ATTR_ENTITY_ID: self._controller_data,
		'command': self._encoding.lower() + ':' + command
		}

		await self.hass.services.async_call(
		'remote', 'send_command', service_data)


		if self._controller == MQTT_CONTROLLER:
		service_data = {
		'topic': self._controller_data,
		'payload': command
		}

		await self.hass.services.async_call(
		'mqtt', 'publish', service_data)
		No newline at end of file

smartir/fan.py

deleted100644 → 0

+0 −260

File deleted.

Preview size limit exceeded, changes collapsed.

smartir/manifest.json

deleted100644 → 0

+0 −22

Original line number	Diff line number	Diff line
		{
		"domain": "smartir",
		"name": "SmartIR",
		"documentation": "https://github.com/smartHomeHub/SmartIR",
		"dependencies": [],
		"codeowners": ["@smartHomeHub"],
		"requirements": [],
		"homeassistant": "0.96.0b1",
		"updater": {
		"version": "1.7.0",
		"releaseNotes": "-- Add config option to override source names in media_player platform<br> -- Add support for Simbio AC unit<br> -- Add support for Mitsubishi MSZ-AP50VGKD unit",
		"files": [
		"__init__.py",
		"climate.py",
		"media_player.py",
		"fan.py",
		"controller.py",
		"manifest.json",
		"services.yaml"
		]
		}
		}