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