def available_hardware(__cls__):
__CACHE_KEY = 'known_sensors'
cache = terrariumCache()
known_sensors = cache.get_data(__CACHE_KEY)
if known_sensors is None:
known_sensors = {}
all_types = []
# Start dynamically loading sensors (based on: https://www.bnmetrics.com/blog/dynamic-import-in-python3)
for file in sorted(Path(__file__).parent.glob('*_sensor.py')):
imported_module = import_module( '.' + file.stem, package='{}'.format(__name__))
for i in dir(imported_module):
attribute = getattr(imported_module, i)
if inspect.isclass(attribute) and attribute != __cls__ and issubclass(attribute, __cls__):
setattr(sys.modules[__name__], file.stem, attribute)
if attribute.HARDWARE is not None:
known_sensors[attribute.HARDWARE] = attribute
all_types += attribute.TYPES
# Update sensors that do not have a known type. Those are remote and scripts sensors
all_types = list(set(all_types))
for hardware in known_sensors:
if len(known_sensors[hardware].TYPES) == 0:
known_sensors[hardware].TYPES = all_types
cache.set_data(__CACHE_KEY,known_sensors,-1)
return known_sensors
def available_hardware(__cls__):
__CACHE_KEY = 'known_displays'
cache = terrariumCache()
data = cache.get_data(__CACHE_KEY)
if data is None:
data = {}
# Start dynamically loading sensors (based on: https://www.bnmetrics.com/blog/dynamic-import-in-python3)
for file in sorted(Path(__file__).parent.glob('*_display.py')):
imported_module = import_module('.' + file.stem,
package='{}'.format(__name__))
for i in dir(imported_module):
attribute = getattr(imported_module, i)
if inspect.isclass(
attribute
) and attribute != terrariumDisplay and issubclass(
attribute, terrariumDisplay):
setattr(sys.modules[__name__], file.stem, attribute)
data[attribute.HARDWARE] = attribute
cache.set_data(__CACHE_KEY, data, -1)
return data
def __init__(self,
switchid,
address,
name='',
prev_state=None,
callback=None):
self.__cache = terrariumCache()
super(terrariumPowerSwitchDenkoviV2,
self).__init__(switchid, address, name, prev_state, callback)
def _load_hardware(self):
EMAIL = terrariumUtils.decrypt(os.environ.get('MEROSS_EMAIL',''))
PASSWORD = terrariumUtils.decrypt(os.environ.get('MEROSS_PASSWORD',''))
if '' == EMAIL or '' == PASSWORD:
raise terrariumSensorLoadingException('Meross cloud is not enabled.')
self._cache = terrariumCache()
return self.address
def _load_hardware(self):
# Use an internal caching for speeding things up.
self.__state_cache = terrariumCache()
self._cloud = TerrariumMerossCloud()
address = self._address
if len(address) == 1:
# When no channels/plugs defined always use the first one...
address.append(0)
self._device['device'] = address[0]
self._device['switch'] = int(address[1])
return self._device['device']
def __init__(self, username, password):
self.__engine = {
'cache': terrariumCache(),
'running': False,
'reconnecting': False,
'restart_counter': 0,
'error': False,
'event': None,
'asyncio': terrariumAsync()
}
self._data = {}
self._username = username
self._password = password
self.start()
def _load_hardware(self):
# Input format should be either:
# - [IP],[POWER_SWITCH_NR]
# Use an internal caching for speeding things up.
self.__state_cache = terrariumCache()
self._async = terrariumAsync()
address = self._address
if len(address) == 1:
self._device['device'] = SmartPlug(address[0])
self._device['switch'] = 0
else:
self._device['device'] = SmartStrip(address[0])
self._device['switch'] = int(address[1])-1
return self._device['device']
def _load_hardware(self):
self.__cache = terrariumCache()
address = self._address
if len(address) == 1:
address.append(1)
elif address[1] is None or '' == address[1]:
address[1] = 1
number_mode = len(str(address[1])) <= 2 and terrariumUtils.is_float(address[1])
# Only reduce the boardnumber if in number mode
if number_mode:
address[1] = int(address[1])
address[1] -= 1 # Reduce board number by one, human start counting at 1, computers at 0 (zero)
scan_regex = r'^(?P<serial>[^ ]+)\W(\[(?P<device>[^\]]+\]))\W\[id=\d\]$'
counter = 0
cmd = self.__CMD + ['list']
try:
data = subprocess.check_output(cmd).strip().decode('utf-8').strip().split('\n')
except subprocess.CalledProcessError as ex:
# Device does not exists....
return False
for line in data:
line = re.match(scan_regex,line)
if line is not None:
line = line.groupdict()
if (number_mode and counter != address[1]) or (not number_mode and address[1] != line['serial']):
counter += 1
continue
self._device['device'] = line['serial']
self._device['type'] = 'v2' if 'mcp' in line['device'].lower() else ''
self._device['switch'] = int(address[0])
if self._device['switch'] == 0:
self._device['switch'] = self.__get_relay_count()
self.address = '{},{}'.format(self._device['switch'],self._device['device'])
break
return self._device['device']
def _load_hardware(self):
# Input format should be either:
# - http://[HOST]#[POWER_SWITCH_NR]
# - http://[HOST]/#[POWER_SWITCH_NR]
# - http://[PASSWORD]@[HOST]#[POWER_SWITCH_NR]
# - http://[PASSWORD]@[HOST]/#[POWER_SWITCH_NR]
address = self._address
# Try Tasmota
# http://sonoff/cm?cmnd=Power[POWER_SWITCH_NR]%201
# http://sonoff/cm?cmnd=Power[POWER_SWITCH_NR]%200
# http://sonoff/cm?user=admin&password=joker&cmnd=Power[POWER_SWITCH_NR]%201
device = f'{address["protocol"]}://{address["host"]}/cm?'
if 'user' in address and 'password' in address:
device += f'user={address["user"]}&password={address["password"]}&'
device += 'cmnd='
state = terrariumUtils.get_remote_data(f'{device}Status%200')
if state is None:
return None
# Create the cache key for caching the relay states.
# This is usefull when there are more then 1 relay per hardware device.
self.__cache_key = md5(
f'{self.HARDWARE}{state["StatusNET"]["Mac"].lower()}'.encode(
)).hexdigest()
self.__cache = terrariumCache()
self.__cache.set_data(self.__cache_key, state['StatusSTS'],
self._CACHE_TIMEOUT)
# We need the use the address_nr value also, as there can multiple relays per sonoff device.
if self._device['id'] is None:
self.id = md5(
f'{self.HARDWARE}{state["StatusNET"]["Mac"].lower()}{address["nr"]}'
.encode()).hexdigest()
return device
def __init__(self, id, _, address, name = '', prev_state = None, callback = None):
self._device = {'device' : None,
'address' : None,
'name' : None,
'switch' : None,
'type' : None,
'id' : None,
'wattage' : 0.0,
'flow' : 0.0,
'last_update' : 0,
'value' : self.OFF}
self.__relay_cache = terrariumCache()
self._timer = None
self.id = id
self.name = name
self.address = address
self.callback = callback
self.load_hardware()
def __init__(self, id, _, sensor_type, address, name = '', unit_value_callback = None, trigger_callback = None):
self._device = {'id' : None,
'name' : None,
'address' : None,
'type' : sensor_type, # Readonly property
'device' : None,
'cache_key' : None,
'power_mngt' : None,
'erratic_errors' : 0,
'last_update' : 0,
'value' : None}
self._sensor_cache = terrariumCache()
self.__unit_value_callback = unit_value_callback
self.__trigger_callback = trigger_callback
# Set the properties
self.id = id
self.name = name
self.address = address
# Load hardware can update the address value that is used for making a unique ID when not set
self.load_hardware()
def _load_hardware(self):
# Input format should be either:
# - http://[HOST]#[POWER_SWITCH_NR]
# - http://[HOST]/#[POWER_SWITCH_NR]
# - http://[PASSWORD]@[HOST]#[POWER_SWITCH_NR]
# - http://[PASSWORD]@[HOST]/#[POWER_SWITCH_NR]
address = self._address
# TEMP data. Will be overwritten by the return value later on
self._device['device'] = energenieconnector.EnergenieConnector(
f'{address["protocol"]}://{address["host"]}', address['passwd'])
if not self.__connect():
raise terrariumRelayLoadingException(
f'Failed loading relay {self}. Unable to login')
# Create the cache key for caching the relay states.
# This is usefull when there are more then 1 relay per hardware device.
self.__cache_key = md5(
f'{self.HARDWARE}{address["host"]}'.encode()).hexdigest()
self.__cache = terrariumCache()
self.__logout()
return self._device['device']
