def __init__(self, sh, *args, **kwargs):
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self.sh = self.get_sh()
self.service_port = self.get_parameter_value('service_port')
self.service_https_certfile = None
self.service_https_keyfile = None
self.service_host = '0.0.0.0'
self.devices = AlexaDevices()
self.actions = AlexaActions(self.sh, self.logger, self.devices)
self._proto = protocoll()
self.service = AlexaService(self._proto, self.logger,
self.PLUGIN_VERSION, self.devices,
self.actions, self.service_host,
int(self.service_port),
self.service_https_certfile,
self.service_https_keyfile)
self.action_count_v2 = 0
self.action_count_v3 = 0
self.init_webinterface()
def __init__(self, smarthome):
self._ip = self.get_parameter_value("ip")
self._token = self.get_parameter_value("token")
self._cycle = self.get_parameter_value("read_cycle")
self._discovererror = 0
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self.messages = {}
self.found = False
self._lock = threading.Lock()
self.retry_count_max = 3
self.retry_count = 1
self._connected = False
self._data = {}
self._data['state'] = 'disconnected'
if not self.init_webinterface():
self._init_complete = False
if self._token == '':
self.logger.error(
"Xiaomi_Robvac: No Key for Communication given, Plugin would not start!"
)
pass
else:
self.logger.debug("Xiaomi_Robvac: Plugin Start!")
if self._cycle > 10:
self.scheduler_add('Xiaomi_Robvac Read cycle',
self._read,
prio=5,
cycle=self._cycle)
else:
self.logger.warning(
"Xiaomi_Robvac: Read Cycle is too fast! < 10s, not starting!"
)
def __init__(self, smarthome):
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self._project = self.get_parameter_value('project')
self._apikey = self.get_parameter_value('apikey')
self._tools = Tools()
self.lock = threading.Lock()
def __init__(self, sh ):
"""
Initalizes the plugin.
If you need the sh object at all, use the method self.get_sh() to get it. There should be almost no need for
a reference to the sh object any more.
Plugins have to use the new way of getting parameter values:
use the SmartPlugin method get_parameter_value(parameter_name). Anywhere within the Plugin you can get
the configured (and checked) value for a parameter by calling self.get_parameter_value(parameter_name). It
returns the value in the datatype that is defined in the metadata.
"""
# Call init code of parent class (SmartPlugin)
super().__init__()
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
# get the parameters for the plugin (as defined in metadata plugin.yaml):
self.tcp_acl = self.parse_acl(self.get_parameter_value('tcp_acl'))
self.udp_acl = self.parse_acl(self.get_parameter_value('udp_acl'))
self.http_acl = self.parse_acl(self.get_parameter_value('http_acl'))
if self.get_parameter_value('tcp') == 'yes':
self.add_listener('tcp', self.get_parameter_value('ip'), self.get_parameter_value('port'), self.tcp_acl,
generic=True)
if self.get_parameter_value('udp') == 'yes':
self.add_listener('udp', self.get_parameter_value('ip'), self.get_parameter_value('port'), self.udp_acl,
generic=True)
if self.get_parameter_value('http') != 'no':
self.add_listener('http', self.get_parameter_value('ip'), self.get_parameter_value('http'), self.http_acl,
generic=True)
def __init__(self, sh):
# Call init code of parent class (SmartPlugin)
super().__init__()
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self.logger.info("Init Buderus")
# Exit if the required package(s) could not be imported
if not REQUIRED_PACKAGE_IMPORTED:
self.logger.error(
"{}: Unable to import Python package 'Crypto.Cipher'".format(
self.get_fullname()))
return
self.__ua = "TeleHeater/2.2.3"
self.__content_type = "application/json"
self._host = self.get_parameter_value('host')
self._key = binascii.unhexlify(self.get_parameter_value('key'))
self._cycle = self.get_parameter_value('cycle')
self._ids = {}
self.opener = urllib.request.build_opener()
self.opener.addheaders = [('User-agent', self.__ua),
('Accept', self.__content_type)]
def __init__(self, sh):
"""
Initalizes the plugin.
"""
# Call init code of parent class (SmartPlugin)
super().__init__()
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
# get the parameters for the plugin (as defined in metadata plugin.yaml):
rrd_dir = self.get_parameter_value('rrd_dir')
if rrd_dir is None:
rrd_dir = self.get_sh().base_dir + '/var/rrd/'
self._rrd_dir = rrd_dir
self._rrds = {}
self.step = self.get_parameter_value('step')
# Initialization code goes here
if not REQUIRED_PACKAGE_IMPORTED:
self._init_complete = False
self.logger.error(
"{}: Unable to import Python package 'rrdtool'".format(
self.get_fullname()))
return
self.init_webinterface()
return
def __init__(self, smarthome):
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self._host = self.get_parameter_value('host')
if self._host is None:
self._host = self.get_parameter_value('lirc_host')
self._port = self.get_parameter_value('port')
self._autoreconnect = self.get_parameter_value('autoreconnect')
self._connect_retries = self.get_parameter_value('connect_retries')
self._connect_cycle = self.get_parameter_value('connect_cycle')
name = 'plugins.' + self.get_fullname()
self._lirc_tcp_connection = Tcp_client(
host=self._host,
port=self._port,
name=name,
autoreconnect=self._autoreconnect,
connect_retries=self._connect_retries,
connect_cycle=self._connect_cycle,
binary=True,
terminator=b'\n')
self._lirc_tcp_connection.set_callbacks(
connected=self._on_connect,
data_received=self._on_received_data,
disconnected=self._on_disconnect)
self._cmd_lock = threading.Lock()
self._reply_lock = threading.Condition()
self._lircd_version = ''
self._responseStr = None
self._parseLine = 0
self._error = False
self._lirc_server_alive = False
def __init__(self, smarthome):
# Call init code of parent class (SmartPlugin)
super().__init__()
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self.logger.info("Init Yamaha")
self._yamaha_cmds = ['state', 'power', 'input', 'volume', 'mute']
self._yamaha_ignore_cmds = ['play_info', 'list_info']
self._yamaha_rxv = {}
self.sock = None
self.mcast_addr = "239.255.255.250"
self.mcast_port = 1900
self.mcast_buffer = 1024
self.mcast_service = "urn:schemas-yamaha-com:service:X_YamahaRemoteControl:1"
# On initialization error use:
if not REQUIRED_PACKAGE_IMPORTED:
self._init_complete = False
return
# if plugin should start even without web interface
self.init_webinterface()
def __init__(self, sh, *args, **kwargs):
"""
Initalizes the plugin. The parameters describe for this method are pulled from the entry in plugin.conf.
:param sh: **Deprecated**: The instance of the smarthome object. For SmartHomeNG versions 1.4 and up: **Don't use it**!
:param *args: **Deprecated**: Old way of passing parameter values. For SmartHomeNG versions 1.4 and up: **Don't use it**!
:param **kwargs:**Deprecated**: Old way of passing parameter values. For SmartHomeNG versions 1.4 and up: **Don't use it**!
The parameters *args and **kwargs are the old way of passing parameters. They are deprecated. They are imlemented
to support oder plugins. Plugins for SmartHomeNG v1.4 and beyond should use the new way of getting parameter values:
use the SmartPlugin method get_parameter_value(parameter_name) instead. Anywhere within the Plugin you can get
the configured (and checked) value for a parameter by calling self.get_parameter_value(parameter_name). It
returns the value in the datatype that is defined in the metadata.
"""
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self.logger.info('Init Volkszaehler Plugin')
# get the parameters for the plugin (as defined in metadata plugin.yaml):
self._host = self.get_parameter_value('host')
self._url = self.get_parameter_value('url')
# none of the parameters may be left out
if not self._host or not self._url:
self._init_complete = False
return
def __init__(self, sh, *args, **kwargs):
"""
Initalizes the plugin. The parameters describe for this method are pulled from the entry in plugin.conf.
"""
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
try:
# sh = self.get_sh() to get it.
self.host = self.get_parameter_value('host')
self.port = self.get_parameter_value('port')
pass
except KeyError as e:
self.logger.critical(
"Plugin '{}': Inconsistent plugin (invalid metadata definition: {} not defined)"
.format(self.get_shortname(), e))
self._init_complete = False
return
# Initialization code goes here
lib.connection.Client.__init__(self,
self.host,
self.port,
monitor=True)
self.terminator = RESP_DELIMITER
self.params = {}
self.sources = {}
self.init_webinterface()
return
def __init__(self, sh):
"""
Initalizes the plugin.
If you need the sh object at all, use the method self.get_sh() to get it. There should be almost no need for
a reference to the sh object any more.
Plugins have to use the new way of getting parameter values:
use the SmartPlugin method get_parameter_value(parameter_name). Anywhere within the Plugin you can get
the configured (and checked) value for a parameter by calling self.get_parameter_value(parameter_name). It
returns the value in the datatype that is defined in the metadata.
"""
# Call init code of parent class (SmartPlugin)
super().__init__()
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
# get the parameters for the plugin (as defined in metadata plugin.yaml):
self._sh = self.get_sh()
self._host = self.get_parameter_value('host')
self._port = self.get_parameter_value('port')
self._kathreinid = self.get_parameter_value('kathreinid')
# if plugin should start even without web interface
self.init_webinterface()
# if plugin should not start without web interface
# if not self.init_webinterface():
# self._init_complete = False
return
def __init__(self, sh):
"""
Initalizes the plugin. The parameters describe for this method are pulled from the entry in plugin.conf.
"""
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
# If an package import with try/except is done, handle an import error like this:
self.logger.debug("init {}".format(__name__))
self._init_complete = False
# Exit if the required package(s) could not be imported
# if not REQUIRED_PACKAGE_IMPORTED:
# self.logger.error("Unable to import Python package '<exotic package>'")
# self._init_complete = False
# return
# if plugin should not start without web interface
if not self.init_webinterface():
self._init_complete = False
return
self.logger.debug("init done")
self._init_complete = True
def __init__(self, sh, *args, **kwargs):
"""
Initalizes the plugin. The parameters describe for this method are pulled from the entry in plugin.conf.
"""
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self._sh = sh
# get the parameters for the plugin (as defined in metadata plugin.yaml):
self.fw2x = self.get_parameter_value('fw2x')
self.host = self.get_parameter_value('host')
self.cycle = self.get_parameter_value('cycle')
# Initialization code goes here
self._count_inverter = 0
self._count_strings = []
self._items = {}
self._last_datetime = None
self._is_online = True
self.first_poll = True
# if plugin should start even without web interface
self.init_webinterface()
def __init__(self, sh):
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self.init_webinterface()
self._name = self.get_fullname()
if not REQUIRED_PACKAGE_IMPORTED:
self.logger.error(
"{}: Unable to import Python package 'GPIO'".format(
self._name))
self._init_complete = False
return
try:
self._items = []
self._itemsdict = {}
self._initdict = {}
self._mode = self.get_parameter_value('mode').upper()
self._bouncetime = self.get_parameter_value('bouncetime')
GPIO.setwarnings(False)
if self._mode == "BCM":
GPIO.setmode(GPIO.BCM)
else:
GPIO.setmode(GPIO.BOARD)
self.logger.debug("{}: Mode set to {}. Bouncetime: {}".format(
self._name, self._mode, self._bouncetime))
self.alive = False
self._lock = threading.Lock()
except Exception:
self._init_complete = False
return
def __init__(self, sh, *args, **kwargs):
"""
Initalizes the plugin. The parameters describe for this method are pulled from the entry in plugin.yaml.
"""
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self._pollfailed = 0
# get the parameters for the plugin (as defined in metadata plugin.yaml):
self._unifi_controller_url = self.get_parameter_value(
UniFiConst.PARAMETER_URL)
self._unifi_user = self.get_parameter_value(UniFiConst.PARAMETER_USER)
self._unifi_password = self.get_parameter_value(
UniFiConst.PARAMETER_PWD)
self._unifi_site_id = self.get_parameter_value(
UniFiConst.PARAMETER_SITE_ID)
self._model = UniFiControllerClientModel(
UniFiAPI(username=self._unifi_user,
password=self._unifi_password,
site=self._unifi_site_id,
baseurl=self._unifi_controller_url,
verify_ssl=False))
# cycle time in seconds, only needed, if hardware/interface needs to be
# polled for value changes by adding a scheduler entry in the run method of this plugin
# (maybe you want to make it a plugin parameter?)
self._cycle = self.get_parameter_value(UniFiConst.PARAMETER_CYCLE_TIME)
self._logging = True
self.init_webinterface()
return
def __init__(self, sh, *args, **kwargs):
"""
Initalizes the plugin. The parameters describe for this method are pulled from the entry in plugin.conf.
:param sh: **Deprecated**: The instance of the smarthome object. For SmartHomeNG versions 1.4 and up: **Don't use it**!
:param *args: **Deprecated**: Old way of passing parameter values. For SmartHomeNG versions 1.4 and up: **Don't use it**!
:param **kwargs:**Deprecated**: Old way of passing parameter values. For SmartHomeNG versions 1.4 and up: **Don't use it**!
"""
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self.logger.debug("rtr: init method called")
self.alive = None
sh = self.get_sh()
self.path = sh.base_dir + '/var/rtr/timer/'
self._items = Items.get_instance()
# preset the controller defaults
self._defaults['Tlast'] = time.time()
self._defaults['Kp'] = self.get_parameter_value('default_Kp')
self._defaults['Ki'] = self.get_parameter_value('default_Ki')
self._defaults['tempBoostTime'] = self.get_parameter_value('defaultBoostTime')
self._defaults['valveProtect'] = self.get_parameter_value('defaultValveProtect')
self._cycle_time = self.get_parameter_value('cycle_time')
self._defaultOnExpiredTimer = self.get_parameter_value('defaultOnExpiredTimer')
return
def __init__(self, sh, *args, **kwargs):
"""
Initializes the plugin
"""
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self._key = self.get_parameter_value('key')
if self.get_parameter_value(
'latitude') != '' and self.get_parameter_value(
'longitude') != '':
self._lat = self.get_parameter_value('latitude')
self._lon = self.get_parameter_value('longitude')
else:
self.logger.debug(
"__init__: latitude and longitude not provided, using shng system values instead."
)
self._lat = self.get_sh()._lat
self._lon = self.get_sh()._lon
self._lang = self.get_parameter_value('lang')
self._units = self.get_parameter_value('units')
self._jsonData = {}
self._session = requests.Session()
self._cycle = int(self.get_parameter_value('cycle'))
self._items = {}
self.init_webinterface()
def __init__(self, smarthome):
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
try:
self._host = self.get_parameter_value('host')
self._port = self.get_parameter_value('port')
self._autoreconnect = self.get_parameter_value('autoreconnect')
self._connect_retries = self.get_parameter_value('connect_retries')
self._connect_cycle = self.get_parameter_value('connect_cycle')
self._squeezebox_server_alive = False
self._web_port = self.get_parameter_value('web_port')
name = 'plugins.' + self.get_fullname()
self._squeezebox_tcp_connection = Tcp_client(
host=self._host,
port=self._port,
name=name,
autoreconnect=self._autoreconnect,
connect_retries=self._connect_retries,
connect_cycle=self._connect_cycle,
binary=True,
terminator=b'\r\n')
self._squeezebox_tcp_connection.set_callbacks(
connected=self._on_connect,
data_received=self._on_received_data,
disconnected=self._on_disconnect)
self._val = {}
self._obj = {}
self._init_cmds = []
self._listen = False
except Exception:
self._init_complete = False
return
def __init__(self, sh, *args, **kwargs):
global paired_nukis
global nuki_event_items
global nuki_action_items
global nuki_door_items
global nuki_battery_items
global lock
global request_queue
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self._base_url = self.get_parameter_value(
'protocol') + '://' + self.get_parameter_value(
'bridge_ip') + ":" + str(
self.get_parameter_value('bridge_port')) + '/'
self._token = self.get_parameter_value('bridge_api_token')
self._action = ''
self._noWait = self.get_parameter_value('no_wait')
self.items = Items.get_instance()
if not self.init_webinterfaces():
self._init_complete = False
self._callback_ip = self.mod_http.get_local_ip_address(
) # get_parameter_value('bridge_callback_ip')
self._callback_port = self.mod_http.get_local_servicesport(
) # get_parameter_value('bridge_callback_port')
if self._callback_ip is None or self._callback_ip in ['0.0.0.0', '']:
self._callback_ip = self.get_local_ipv4_address()
if not self._callback_ip:
self.logger.critical(
"Plugin '{}': Could not fetch internal ip address. Set it manually!"
.format(self.get_shortname()))
self.alive = False
return
self.logger.info(
"Plugin '{pluginname}': using local ip address {ip}".format(
pluginname=self.get_shortname(), ip=self._callback_ip))
else:
self.logger.info(
"Plugin '{pluginname}': using given ip address {ip}".format(
pluginname=self.get_shortname(), ip=self._callback_ip))
self._callback_url = "http://{ip}:{port}/nuki_callback/".format(
ip=self._callback_ip, port=self._callback_port)
self._lockActions = [
1, # unlock
2, # lock
3, # unlatch
4, # lockAndGo
5, # lockAndGoWithUnlatch
]
self.init_webinterface()
def __init__(self, sh, *args, **kwargs):
"""
Initializes the Telegram plugin
The params are documented in ``plugin.yaml`` and values will be obtained through get_parameter_value(parameter_name)
"""
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self.logger.debug("init {}".format(__name__))
self._init_complete = False
# Exit if the required package(s) could not be imported
if not REQUIRED_PACKAGE_IMPORTED:
self.logger.error(
"{}: Unable to import Python package 'python-telegram-bot'".
format(self.get_fullname()))
return
#self._instance = self.get_parameter_value('instance') # the instance of the plugin
self._name = self.get_parameter_value('name')
self._token = self.get_parameter_value('token')
self._welcome_msg = self.get_parameter_value('welcome_msg')
self._bye_msg = self.get_parameter_value('bye_msg')
self._no_access_msg = self.get_parameter_value('no_access_msg')
self._no_write_access_msg = self.get_parameter_value(
'no_write_access_msg')
self._long_polling_timeout = self.get_parameter_value(
'long_polling_timeout')
self._pretty_thread_names = self.get_parameter_value(
'pretty_thread_names')
# the Updater class continuously fetches new updates from telegram and passes them on to the Dispatcher class.
self._updater = Updater(token=self._token)
self._bot = self._updater.bot
self.logger.info("Telegram bot is listening: {0}".format(
self._bot.getMe()))
# Dispatcher that handles the updates and dispatches them to the handlers.
dispatcher = self._updater.dispatcher
dispatcher.add_error_handler(self.eHandler)
dispatcher.add_handler(CommandHandler('time', self.cHandler_time))
dispatcher.add_handler(CommandHandler('help', self.cHandler_help))
dispatcher.add_handler(CommandHandler('hide', self.cHandler_hide))
dispatcher.add_handler(CommandHandler('list', self.cHandler_list))
dispatcher.add_handler(CommandHandler('info', self.cHandler_info))
dispatcher.add_handler(CommandHandler('start', self.cHandler_start))
dispatcher.add_handler(CommandHandler('lo', self.cHandler_lo))
dispatcher.add_handler(
CommandHandler('tr', self.cHandler_tr, pass_args=True))
dispatcher.add_handler(MessageHandler(Filters.text, self.mHandler))
self.init_webinterface()
self.logger.debug("init done")
self._init_complete = True
def __init__(self, sh, *args, **kwargs):
"""
Initalizes the plugin. The parameters describe for this method are pulled from the entry in plugin.conf.
"""
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
# get the parameters for the plugin (as defined in metadata plugin.yaml):
self.ip = self.get_parameter_value('listen_ip')
self.port = self.get_parameter_value('listen_port')
self.acl = self.parse_acl(self.get_parameter_value('acl'))
self.default_access = self.get_parameter_value('default_access')
try:
self.config = os.path.expanduser(
self.get_parameter_value('config_file'))
except:
pass
# Initialization code goes here
dest = "http:{}:{}".format(self.ip, self.port)
logger.info("SP: Adding listener on: {}".format(dest))
self.dispatcher = HTTPDispatcher(self.parse_input, self.ip, self.port)
self.listeners[dest] = {
'items': {},
'logics': {},
'acl': self.parse(self.acl)
}
speech_plugin_path = os.path.dirname(os.path.realpath(__file__))
if not os.path.exists(self.config):
try_other_path = os.path.join(speech_plugin_path, self.config)
if os.path.exists(try_other_path):
self.config = try_other_path
else:
self.logger.error(
"Configuration file with base path of plugin '{}' not found"
.format(try_other_path))
self._init_complete = False
return
config_base = os.path.basename(self.config)
if config_base == "speech.py":
sys.path.append(os.path.dirname(self.config))
global varParse, dictError
self.logger.info(
"Configuration file '{}' successfully imported".format(
self.config))
else:
self.logger.error(
"Configuration file '{}' error, the filename should be speech.py"
.format(config_base))
self._init_complete = False
return
# if plugin should start even without web interface
self.init_webinterface()
def __init__(self, sh, *args, **kwargs):
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self._apiKey = self.get_parameter_value('apiKey')
self._userKey = self.get_parameter_value('userKey')
self._device = self.get_parameter_value('device')
self._po = Http()
def __init__(self, smarthome):
super().__init__()
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
try:
self.shtime = Shtime.get_instance()
self.handle_login = self.get_parameter_value('handle_login')
try:
self.dl = Http(timeout=self.get_parameter_value('timeout'),
hide_login=self.handle_login)
except:
self.dl = Http(hide_login=self.handle_login)
self._items = []
self._icals = {}
self._ical_aliases = {}
self._cycle = self.get_parameter_value('cycle')
calendars = self.get_parameter_value('calendars')
config_dir = self.get_parameter_value('directory')
except Exception as err:
self.logger.error('Problems initializing: {}'.format(err))
self._init_complete = False
return
try:
self._directory = '{}/{}'.format(self.get_vardir(), config_dir)
except Exception:
self._directory = '{}/var/{}'.format(smarthome.get_basedir(),
config_dir)
self._directory = os.path.normpath(self._directory)
try:
os.makedirs(self._directory)
self.logger.debug('Created {} subfolder in var'.format(config_dir))
except OSError as e:
if e.errno != errno.EEXIST:
self.logger.error(
'Problem creating {} folder in {}/var'.format(
config_dir, smarthome.get_basedir()))
self._init_complete = False
return
for calendar in calendars:
if isinstance(calendar, dict):
calendar = list("{!s}:{!s}".format(k, v)
for (k, v) in calendar.items())[0]
if ':' in calendar and 'http' != calendar[:4]:
name, _, cal = calendar.partition(':')
calendar = cal.strip()
self.logger.info(
'Registering calendar {} with alias {}.'.format(
Network.clean_uri(calendar, self.handle_login), name))
self._ical_aliases[name.strip()] = calendar
else:
self.logger.info(
'Registering calendar {} without alias.'.format(
Network.clean_uri(calendar, self.handle_login)))
calendar = calendar.strip()
self._icals[calendar] = self._read_events(calendar)
self.shtime = Shtime.get_instance()
def __init__(self, smarthome):
# Call init code of parent class (SmartPlugin)
super().__init__()
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self._apikey = self.get_parameter_value('apikey')
def __init__(self, sh, *args, **kwargs):
"""
Initalizes the plugin. The parameters describe for this method are pulled from the entry in plugin.conf.
:param sh: **Deprecated**: The instance of the smarthome object. For SmartHomeNG versions 1.4 and up: **Don't use it**!
:param *args: **Deprecated**: Old way of passing parameter values. For SmartHomeNG versions 1.4 and up: **Don't use it**!
:param **kwargs:**Deprecated**: Old way of passing parameter values. For SmartHomeNG versions 1.4 and up: **Don't use it**!
If you need the sh object at all, use the method self.get_sh() to get it. There should be almost no need for
a reference to the sh object any more.
The parameters *args and **kwargs are the old way of passing parameters. They are deprecated. They are imlemented
to support oder plugins. Plugins for SmartHomeNG v1.4 and beyond should use the new way of getting parameter values:
use the SmartPlugin method get_parameter_value(parameter_name) instead. Anywhere within the Plugin you can get
the configured (and checked) value for a parameter by calling self.get_parameter_value(parameter_name). It
returns the value in the datatype that is defined in the metadata.
"""
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
# get the parameters for the plugin (as defined in metadata plugin.yaml):
# self.param1 = self.get_parameter_value('param1')
self.user = self.get_parameter_value('user')
self.password = self.get_parameter_value('password')
self.img_pfad = self.get_parameter_value('img_pfad')
self.cycle = self.get_parameter_value('cycle')
self.indego_url = self.get_parameter_value('indego_url')
self.parent_item = self.get_parameter_value('parent_item')
self.context_id = ''
self.user_id = ''
self.alm_sn = ''
self.alert_reset = True
self.auth()
self.add_keys = {}
# Check for initialization errors:
if not self.indego_url:
self._init_complete = False
return
if not self.parent_item:
self._init_complete = False
return
# The following part of the __init__ method is only needed, if a webinterface is being implemented:
# if plugin should start even without web interface
self.init_webinterface()
# if plugin should not start without web interface
# if not self.init_webinterface():
# self._init_complete = False
return
def __init__(self, sh):
"""
Initalizes the plugin. The parameters described for this method are pulled from the entry in plugin.yaml.
:param sh: The instance of the smarthome object, save it for later references
:param apikey: api key needed to access wunderground
:param language: language for the forcast messages
:param location: location to display the weather for
:param cycle: number of seconds between updates
:param item_subtree: subtree of items in which the plugin looks for items to update
:param log_start: x
"""
# Call init code of parent class (SmartPlugin)
super().__init__()
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self.items = Items.get_instance()
languagedict = {"de": "DL", "en": "EN", 'fr': "FR"}
self.apikey = self.get_parameter_value('apikey')
if self.apikey == '':
self.logger.error(
"Wunderground: No api key specified, plugin is not starting")
self.language = ''
self.language = languagedict.get(
self.get_parameter_value('language').lower())
if self.language == None:
self.language = self.get_parameter_value('language').upper()
self.location = self.get_parameter_value('location')
if self.location == '':
self.logger.error(
"Wunderground: No location specified, plugin is not starting")
self.url = 'https://api.wunderground.com/api/' + self.apikey + '/conditions/forecast/lang:' + self.language + '/q/' + self.location + '.json'
self.logger.info("Wunderground: url={}".format(str(self.url)))
self._cycle = self.get_parameter_value('cycle')
#self._cycle = 600
#self.logger.error("Wunderground: Invalid value '"+str(cycle)+"' configured for attribute cycle in plugin.conf, using '"+str(self._cycle)+"' instead")
self.item_subtree = self.get_parameter_value('item_subtree')
if self.item_subtree == '':
self.logger.warning(
"Wunderground: item_subtree is not configured, searching complete item-tree instead. Please configure item_subtree to reduce processing overhead"
)
# if plugin should start even without web interface
self.init_webinterface()
return
def __init__(self, smarthome):
self.host = self.get_parameter_value('host')
self.port = self.get_parameter_value('port')
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
lib.connection.Client.__init__(self, self.host, self.port, monitor=True)
self.logger.debug("init knx")
self.shtime = Shtime.get_instance()
busmonitor = self.get_parameter_value('busmonitor')
self.gal = {} # group addresses to listen to {DPT: dpt, ITEMS: [item 1, item 2, ..., item n], LOGICS: [ logic 1, logic 2, ..., logic n]}
self.gar = {} # group addresses to reply if requested from knx, {DPT: dpt, ITEM: item, LOGIC: None}
self._init_ga = []
self._cache_ga = [] # group addresses which should be initalized by the knxd cache
self._cache_ga_response_pending = []
self.time_ga = self.get_parameter_value('time_ga')
self.date_ga = self.get_parameter_value('date_ga')
send_time = self.get_parameter_value('send_time')
self._bm_separatefile = False
self._bm_format= "BM': {1} set {2} to {3}"
# following needed for statistics
self.enable_stats = self.get_parameter_value('enable_stats')
self.stats_ga = {} # statistics for used group addresses on the BUS
self.stats_pa = {} # statistics for used group addresses on the BUS
self.stats_last_read = None # last read request from KNX
self.stats_last_write = None # last write from KNX
self.stats_last_response = None # last response from KNX
self.stats_last_action = None # the newes
if busmonitor.lower() in ['on','true']:
self._busmonitor = self.logger.info
elif busmonitor.lower() in ['off','false']:
self._busmonitor = self.logger.debug
elif busmonitor.lower() == 'logger':
self._bm_separatefile = True
self._bm_format = "{0};{1};{2};{3}"
self._busmonitor = logging.getLogger("knx_busmonitor").info
self.logger.warning("Using busmonitor (L) = '{}'".format(busmonitor))
else:
self.logger.warning("Invalid value '{}' configured for parameter 'busmonitor', using 'false'".format(busmonitor))
self._busmonitor = self.logger.debug
if send_time:
self._sh.scheduler.add('KNX[{0}] time'.format(self.get_instance_name()), self._send_time, prio=5, cycle=int(send_time))
self.readonly = self.get_parameter_value('readonly')
if self.readonly:
self.logger.warning("!!! KNX Plugin in READONLY mode !!! ")
self.init_webinterface()
return
def __init__(self, sh):
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self.items = Items.get_instance()
self.__items = self.abitems = {}
self.__sh = sh
self.alive = False
self.__cli = None
self.init_webinterface()
try:
log_level = self.get_parameter_value("log_level")
log_directory = self.get_parameter_value("log_directory")
self.logger.info(
"Init StateEngine (log_level={0}, log_directory={1})".format(
log_level, log_directory))
StateEngineDefaults.startup_delay = self.get_parameter_value(
"startup_delay_default")
StateEngineDefaults.suspend_time = self.get_parameter_value(
"suspend_time_default")
StateEngineDefaults.instant_leaveaction = self.get_parameter_value(
"instant_leaveaction")
StateEngineDefaults.write_to_log(self.logger)
StateEngineCurrent.init(self.get_sh())
if log_level > 0:
if log_directory[0] != "/":
base = self.get_sh().get_basedir()
if base[-1] != "/":
base += "/"
log_directory = base + log_directory
if not os.path.exists(log_directory):
os.makedirs(log_directory)
text = "StateEngine extended logging is active. Logging to '{0}' with loglevel {1}."
self.logger.info(text.format(log_directory, log_level))
log_maxage = self.get_parameter_value("log_maxage")
if log_level > 0 and log_maxage > 0:
self.logger.info(
"StateEngine extended log files will be deleted after {0} days."
.format(log_maxage))
SeLogger.set_logmaxage(log_maxage)
cron = ['init', '30 0 * *']
self.scheduler_add('StateEngine: Remove old logfiles',
SeLogger.remove_old_logfiles,
cron=cron,
offset=0)
SeLogger.set_loglevel(log_level)
SeLogger.set_logdirectory(log_directory)
self.get_sh(
).stateengine_plugin_functions = StateEngineFunctions.SeFunctions(
self.get_sh(), self.logger)
except Exception:
self._init_complete = False
return
def __init__(self, sh):
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self._helios_ip = self.get_parameter_value('helios_ip')
self._client = ModbusTcpClient(self._helios_ip)
self.alive = False
self._is_connected = False
self._update_cycle = self.get_parameter_value('update_cycle')
def __init__(self, sh, *args, **kwargs):
"""
old: smarthome,
serial_port='/dev/ttyUSB0',
baudrate=115200,
poll_period=300,
min_update_period=86400,
max_update_period=300
server_host = '0.0.0.0'
server_port = 57483
"""
from bin.smarthome import VERSION
if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5':
self.logger = logging.getLogger(__name__)
self.logger.debug("init {}".format(__name__))
self._init_complete = False
# Exit if the required package(s) could not be imported
if not REQUIRED_PACKAGE_IMPORTED:
self.logger.error("{}: Unable to import Python package 'pyserial'".format(self.get_fullname()))
return
# Get Parameters
self._poll_period = self.get_parameter_value('poll_period')
min_update_period = self.get_parameter_value('min_update_period')
self._min_update_period = datetime.timedelta(seconds=int(min_update_period))
max_update_period = self.get_parameter_value('max_update_period')
self._max_update_period = datetime.timedelta(seconds=int(max_update_period))
self._serial_port = self.get_parameter_value('serial_port')
self._baudrate = self.get_parameter_value('baudrate')
self._server_host = self.get_parameter_value('server_host')
self._server_port = self.get_parameter_value('server_port')
self._params = {}
# pass the own logger on
self._thzProtocol = ThzProtocol.ThzProtocol(self._serial_port, self._baudrate, self.logger)
self._msgList = {}
self._logRegisterId = None
# pass the own logger on
self._thzServer = ThzServer(self, self._server_host, self._server_port, self.logger)
self._curData = {}
self._extMsgList = {}
self.init_webinterface()
self.logger.debug("init done")
self._init_complete = True
