def __init__(self, smarthome, smartvisu_dir='', overwrite_templates='Yes', visu_style='std', smartvisu_version=''): self.logger = logging.getLogger(__name__) self._sh = smarthome self.items = Items.get_instance() self.smartvisu_dir = smartvisu_dir self.smartvisu_version = smartvisu_version self.overwrite_templates = overwrite_templates self.visu_style = visu_style.lower() if not self.visu_style in ['std','blk']: self.visu_style = 'std' self.logger.warning("SmartVisuGenerator: visu_style '{}' unknown, using visu_style '{1}'".format(visu_style, self.visu_style)) self.logger.info("Generating pages for smartVISU v{}".format(self.smartvisu_version)) self.outdir = os.path.join(self.smartvisu_dir, 'pages', 'smarthome') self.tpldir = os.path.join(self.smartvisu_dir, 'pages', 'base', 'tplNG') self.tmpdir = os.path.join(self.smartvisu_dir, 'temp') if self.smartvisu_version == '2.9': self.tpldir = os.path.join(self.smartvisu_dir, 'dropins') self.thisplgdir = os.path.dirname(os.path.abspath(__file__)) self.copy_templates() self.pages() self.logger.info("Generating pages for smartVISU v{} End".format(self.smartvisu_version))
def __init__(self, webif_dir, plugin): """ Initialization of instance of class WebInterface :param webif_dir: directory where the webinterface of the plugin resides :param plugin: instance of the plugin :type webif_dir: str :type plugin: object """ self.logger = plugin.logger self.webif_dir = webif_dir self.plugin = plugin self.items = Items.get_instance() self.last_upload = "" self.tplenv = self.init_template_environment() self.knxdaemon = '' if os.name != 'nt': if self.get_process_info("ps cax|grep eibd") != '': self.knxdaemon = 'eibd' if self.get_process_info("ps cax|grep knxd") != '': if self.knxdaemon != '': self.knxdaemon += ' and ' self.knxdaemon += 'knxd' else: self.knxdaemon = 'can not be determined when running on Windows'
def __init__(self, smarthome, update='False', ip='127.0.0.1', port=2323, hashed_password=''): """ Constructor :param smarthome: smarthomeNG instance :param update: Flag: Updates allowed :param ip: IP to bind on :param port: Port to bind on :param hashed_password: Hashed password that is required to logon """ self.logger = logging.getLogger(__name__) self.items = Items.get_instance() if hashed_password is None or hashed_password == '': self.logger.warning( "CLI: You should set a password for this plugin.") hashed_password = None elif hashed_password.lower() == 'none': hashed_password = None elif not Utils.is_hash(hashed_password): self.logger.error( "CLI: Value given for 'hashed_password' is not a valid hash value. Login will not be possible" ) lib.connection.Server.__init__(self, ip, port) self.sh = smarthome self.updates_allowed = Utils.to_bool(update) self.hashed_password = hashed_password self.commands = CLICommands(self.sh, self.updates_allowed, self) self.alive = False
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 yaml_syntax_checker(self, yaml_code): check_result = '' if yaml_code == '': return check_result yaml_code = self.strip_empty_lines(yaml_code) import lib.shyaml as shyaml import lib.config as shconfig # load yaml code to dict ydata, get error message (if error occures) to estr ydata, estr = shyaml.yaml_load_fromstring(yaml_code, True) self.logger.info( "yaml_syntax_checker(): type(ydata) = {},estr='{}'".format( type(ydata), estr)) if estr != '': check_result = 'ERROR: \n\n' + estr elif not isinstance(ydata, collections.OrderedDict): check_result = 'ERROR: \n\n' + 'No valid YAML code' elif ydata != None: # found valid yaml code # Test if the loaded data items with 'struct' attribute config = collections.OrderedDict() self.items = Items.get_instance() struct_dict = self.items.structs._struct_definitions shconfig.search_for_struct_in_items(ydata, struct_dict, config) self.logger.info("ydata = {}".format(ydata)) self.logger.info("config = {}".format(config)) # return data structure converted back to yaml format check_result = convert_yaml(config).replace('\n\n', '\n') return check_result
def items_json(self, mode="tree"): """ returns a list of items as json structure :param mode: tree (default) or list structure """ if self.items == None: self.items = Items.get_instance() items_sorted = sorted(self.items.return_items(), key=lambda k: str.lower(k['_path']), reverse=False) if mode == 'tree': parent_items_sorted = [] for item in items_sorted: if "." not in item._path: parent_items_sorted.append(item) (item_data, item_count) = self._build_item_tree(parent_items_sorted) self.logger.info( "admin: items_json: In tree-mode, {} items returned".format( item_count)) return json.dumps([item_count, item_data]) else: item_list = [] for item in items_sorted: item_list.append(item._path) self.logger.info( "admin: items_json: Not in tree-mode, {} items returned". format(len(item_list))) return json.dumps(item_list)
def eval_syntax_checker(self, eval_code, relative_to): expanded_code = '' # set up environment for calculating eval-expression sh = self._sh shtime = Shtime.get_instance() items = Items.get_instance() import math import lib.userfunctions as uf eval_code = eval_code.replace('\r', '').replace('\n', ' ').replace(' ', ' ').strip() if relative_to == '': expanded_code = eval_code else: rel_to_item = items.return_item(relative_to) if rel_to_item is not None: expanded_code = rel_to_item.get_stringwithabsolutepathes( eval_code, 'sh.', '(') expanded_code = rel_to_item.get_stringwithabsolutepathes( expanded_code, 'sh.', '.property') else: expanded_code = "Error: Item {} does not exist!".format( relative_to) try: value = eval(expanded_code) except Exception as e: check_result = "Problem evaluating {}: {}".format( expanded_code, e) else: check_result = value return expanded_code, check_result
def __init__(self, smarthome): self._sh = smarthome global _scenes_instance if _scenes_instance is not None: import inspect curframe = inspect.currentframe() calframe = inspect.getouterframes(curframe, 2) logger.critical("A second 'scenes' object has been created. There should only be ONE instance of class 'Scenes'!!! Called from: {} ({})".format(calframe[1][1], calframe[1][3])) _scenes_instance = self self.items = Items.get_instance() self._scenes = {} self._learned_values = {} self._scenes_dir = smarthome.base_dir + '/scenes/' if not os.path.isdir(self._scenes_dir): logger.warning("Directory scenes not found. Ignoring scenes.".format(self._scenes_dir)) return # for item in smarthome.return_items(): for item in self.items.return_items(): if item.type() == 'scene': scene_file = os.path.join(self._scenes_dir, item.id()) scene_file_yaml = yaml.yaml_load(scene_file+'.yaml', ordered=False, ignore_notfound=True) if scene_file_yaml is not None: # Reading yaml file with scene definition for state in scene_file_yaml: actions = scene_file_yaml[state]['actions'] if isinstance(actions, dict): actions = [ actions ] if isinstance( actions, list ): for action in actions: if isinstance(action, dict): self._add_scene_entry(item, str(state), action.get('item', ''), str(action.get('value', '')), action.get('learn', ''), scene_file_yaml[state].get('name', '')) else: logger.warning("Scene {}, state {}: action '{}' is not a dict".format(item, state, action)) else: logger.warning("Scene {}, state {}: actions are not a list".format(item, state)) self._load_learned_values(str(item.id())) else: # Trying to read conf file with scene definition scene_conf_file = scene_file + '.conf' try: with open(scene_conf_file, 'r', encoding='UTF-8') as f: reader = csv.reader(f, delimiter=' ') for row in reader: if row == []: # ignore empty lines continue if row[0][0] == '#': # ignore comments continue self._add_scene_entry(item, row[0], row[1], row[2]) except Exception as e: logger.warning("Problem reading scene file {0}: {1}".format(scene_file, e)) continue item.add_method_trigger(self._trigger)
def __init__(self, smarthome, driver, connect, prefix="", cycle=60): self._sh = smarthome self.shtime = Shtime.get_instance() self.items = Items.get_instance() self.logger = logging.getLogger(__name__) self._dump_cycle = int(cycle) self._name = self.get_instance_name() self._replace = { table: table if prefix == "" else prefix + "_" + table for table in ["log", "item"] } self._replace['item_columns'] = ", ".join(COL_ITEM) self._replace['log_columns'] = ", ".join(COL_LOG) self._buffer = {} self._buffer_lock = threading.Lock() self._dump_lock = threading.Lock() self._db = lib.db.Database( ("" if prefix == "" else prefix.capitalize() + "_") + "Database", driver, Utils.string_to_list(connect)) self._initialized = False self._initialize() smarthome.scheduler.add('Database dump ' + self._name + ("" if prefix == "" else " [" + prefix + "]"), self._dump, cycle=self._dump_cycle, prio=5) if not self.init_webinterface(): self._init_complete = False
def __init__(self, abitem, name, allow_value_list=False, value_type=None): super().__init__(abitem) self.__name = name self.__allow_value_list = allow_value_list self.__value = None self.__item = None self.__eval = None self.__regex = None self.__struct = None self.__varname = None self.__template = None self._additional_sources = [] self.itemsApi = Items.get_instance() self.__itemClass = Item self.__listorder = [] self.__type_listorder = [] self.__valid_valuetypes = [ "value", "regex", "eval", "var", "item", "template", "struct" ] if value_type == "str": self.__cast_func = StateEngineTools.cast_str elif value_type == "num": self.__cast_func = StateEngineTools.cast_num elif value_type == "item": self.__cast_func = self.cast_item elif value_type == "bool": self.__cast_func = StateEngineTools.cast_bool elif value_type == "time": self.__cast_func = StateEngineTools.cast_time elif value_type == "list": self.__cast_func = StateEngineTools.cast_list else: self.__cast_func = None
def __init__(self, abitem, item_state): super().__init__(abitem) self.itemsApi = Items.get_instance() self.__item = item_state self.__itemClass = Item try: self.__id = self.__item.property.path self._log_info("Init state {}", self.__id) except Exception as err: self.__id = None self._log_info("Problem init state ID of Item {}. {}", self.__item, err) self.__text = StateEngineValue.SeValue(self._abitem, "State Name", False, "str") self.__use = StateEngineValue.SeValue(self._abitem, "State configuration extension", True, "item") self.__release = StateEngineValue.SeValue(self._abitem, "State released by", True, "item") self.__name = '' self.__use_done = [] self.__conditions = StateEngineConditionSets.SeConditionSets( self._abitem) self.__actions_enter_or_stay = StateEngineActions.SeActions( self._abitem) self.__actions_enter = StateEngineActions.SeActions(self._abitem) self.__actions_stay = StateEngineActions.SeActions(self._abitem) self.__actions_leave = StateEngineActions.SeActions(self._abitem) self._log_increase_indent() try: self.__fill(self.__item, 0) finally: self._log_decrease_indent()
def item_change_value_html(self, item_path, value): """ Is called by items.html when an item value has been changed """ if self.items is None: self.items = Items.get_instance() self.logger.info( "item_change_value_html: item '{}' set to value '{}'".format( item_path, value)) item_data = [] try: item = self.items.return_item(item_path) except Exception as e: self.logger.error( "item_change_value_html: item '{}' set to value '{}' - Exception {}" .format(item_path, value, e)) return if 'num' in item.type(): if "." in value or "," in value: value = float(value) else: value = int(value) item(value, caller='admin') return
def __init__(self, smarthome, mode="all"): self.logger.debug("Plugin '{}': '__init__'".format(self.get_fullname())) self._mode = mode self.items = Items.get_instance() if not self.init_webinterfaces(): self._init_complete = False
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, abitem, name: str): super().__init__(abitem) self.shtime = Shtime.get_instance() self.items = Items.get_instance() self._name = name self.__delay = StateEngineValue.SeValue(self._abitem, "delay") self.__repeat = None self.__order = StateEngineValue.SeValue(self._abitem, "order", False, "num") self._scheduler_name = None
def __init__(self, module): self._sh = module._sh self.module = module self.base_dir = self._sh.get_basedir() self.logger = logging.getLogger(__name__) self.items = Items.get_instance() 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): """ 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, sh): super().__init__() self.logger = logging.getLogger('{}.general'.format(__name__)) self.itemsApi = Items.get_instance() self.__items = self.abitems = {} self.mod_http = None self.__sh = sh self.alive = False self.__cli = None self.init_webinterface() self.__log_directory = self.get_parameter_value("log_directory") try: log_level = self.get_parameter_value("log_level") StateEngineDefaults.log_level = log_level log_directory = self.__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) self.get_sh( ).stateengine_plugin_functions = StateEngineFunctions.SeFunctions( self.get_sh(), self.logger) StateEngineCurrent.init(self.get_sh()) base = self.get_sh().get_basedir() log_directory = SeLogger.create_logdirectory(base, log_directory) if log_level > 0: text = "StateEngine extended logging is active. Logging to '{0}' with log level {1}." self.logger.info(text.format(log_directory, log_level)) log_maxage = self.get_parameter_value("log_maxage") if 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) except Exception as ex: self._init_complete = False self.logger.warning( "Problem loading Stateengine plugin: {}".format(ex)) return
def __init__(self, webif_dir, plugin): """ Initialization of instance of class WebInterface :param webif_dir: directory where the webinterface of the plugin resides :param plugin: instance of the plugin :type webif_dir: str :type plugin: object """ self.logger = plugin.logger self.webif_dir = webif_dir self.plugin = plugin self.items = Items.get_instance() self.tplenv = self.init_template_environment() # try to get API handles self.items = Items.get_instance() self.logics = Logics.get_instance()
def index(self, reload=None): """ Build index.html for cherrypy Display a list of all connected visu clients Render the template and return the html file to be delivered to the browser :return: contents of the template after beeing rendered """ # get API handles that were unavailable during __init__ if self.items is None: self.items = Items.get_instance() if self.logics is None: self.logics = Logics.get_instance() clients = [] for clientinfo in self.plugin.return_clients(): c = clientinfo.get('addr', '') client = dict() client['ip'] = clientinfo.get('ip', '') client['port'] = clientinfo.get('port', '') try: client['name'] = socket.gethostbyaddr(client['ip'])[0] except: client['name'] = client['ip'] client['sw'] = clientinfo.get('sw', '') client['swversion'] = clientinfo.get('swversion', '') client['protocol'] = clientinfo.get('protocol', '') client['hostname'] = clientinfo.get('hostname', '') client['browser'] = clientinfo.get('browser', '') client['browserversion'] = clientinfo.get('browserversion', '') clients.append(client) clients_sorted = sorted(clients, key=lambda k: k['name']) plgitems = [] for item in self.items.return_items(): if ('visu_acl' in item.conf): plgitems.append(item) plglogics = [] for logic in self.logics.return_logics(): plglogics.append(self.logics.get_logic_info(logic)) tmpl = self.tplenv.get_template('index.html') return tmpl.render(p=self.plugin, items=sorted(plgitems, key=lambda k: str.lower(k['_path'])), logics=sorted(plglogics, key=lambda k: str.lower(k['name'])), clients=clients_sorted, client_count=len(clients_sorted))
def __init__(self, sh, *args, **kwargs): self.logger.debug("Plugin '{}': '__init__'".format( self.get_fullname())) # Call init code of parent class (SmartPlugin or MqttPlugin) super().__init__() self._mode = self.get_parameter_value('mode') self.items = Items.get_instance() if not self.init_webinterfaces(): self._init_complete = False
def __init__(self, sh): """ Initalizes the plugin. If the sh object is needed at all, the method self.get_sh() should be used 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__) self.items = Items.get_instance() self.updates_allowed = self.get_parameter_value('update') self.ip = self.get_parameter_value('ip') self.port = self.get_parameter_value('port') self.hashed_password = self.get_parameter_value('hashed_password') if self.hashed_password is None or self.hashed_password == '': self.logger.warning( "CLI: You should set a password for this plugin.") self.hashed_password = None elif self.hashed_password.lower() == 'none': self.hashed_password = None elif not Utils.is_hash(self.hashed_password): self.logger.error( "CLI: Value given for 'hashed_password' is not a valid hash value. Login will not be possible" ) name = 'plugins.' + self.get_fullname() self.server = Tcp_server(interface=self.ip, port=self.port, name=name, mode=Tcp_server.MODE_TEXT_LINE) self.server.set_callbacks(incoming_connection=self.handle_connection) self.commands = CLICommands(self.get_sh(), self.updates_allowed, self) self.alive = False # On initialization error use: # self._init_complete = False # return # if plugin should start even without web interface self.init_webinterface(WebInterface)
async def get_shng_class_instances(self): """ Ensure that the instance vars for items and logics are initialized """ while self.items is None: self.items = Items.get_instance() if self.items is None: await asyncio.sleep(1) while self.logics is None: self.logics = Logics.get_instance() if self.logics is None: await asyncio.sleep(1) return
def read(self, id=None): """ Handle GET requests for scenes API """ if self.items == None: self.items = Items.get_instance() from lib.scene import Scenes get_param_func = getattr(Scenes, "get_instance", None) if callable(get_param_func): supported = True self.scenes = Scenes.get_instance() scene_list = [] if self.scenes is not None: scene_list = self.scenes.get_loaded_scenes() disp_scene_list = [] for scene in scene_list: scene_dict = {} scene_dict['path'] = scene # scene_dict['name'] = str(self._sh.return_item(scene)) scene_dict['name'] = str(self.items.return_item(scene)) action_list = self.scenes.get_scene_actions(scene) scene_dict['value_list'] = action_list # scene_dict[scene] = action_list disp_action_list = [] for value in action_list: action_dict = {} action_dict['action'] = value action_dict[ 'action_name'] = self.scenes.get_scene_action_name( scene, value) action_list = self.scenes.return_scene_value_actions( scene, value) for action in action_list: if not isinstance(action[0], str): action[0] = action[0].id() action_dict['action_list'] = action_list disp_action_list.append(action_dict) scene_dict['values'] = disp_action_list self.logger.debug( "scenes_html: disp_action_list for scene {} = {}".format( scene, disp_action_list)) disp_scene_list.append(scene_dict) else: supported = False return json.dumps(disp_scene_list)
def read(self, id=None): """ Handle GET requests """ if self.items is None: self.items = Items.get_instance() items_sorted = sorted(self.items.return_items(), key=lambda k: str.lower(k['_path']), reverse=False) item_list = [] for item in items_sorted: item_list.append(item._path) return json.dumps(item_list)
def __init__(self, webif_dir, plugin): """ Initialization of instance of class WebInterface :param webif_dir: directory where the webinterface of the plugin resides :param plugin: instance of the plugin :type webif_dir: str :type plugin: object """ self.logger = logging.getLogger(__name__) self.webif_dir = webif_dir self.plugin = plugin self.itemsApi = Items.get_instance() self.tplenv = self.init_template_environment()
def __init__(self, abitem, struct_path, global_struct): super().__init__(abitem) self.itemsApi = Items.get_instance() self.struct_path = struct_path self._conf = {} self._full_conf = {} self._struct = None self._global_struct = global_struct # copy.deepcopy(self.itemsApi.return_struct_definitions()) self._struct_rest = None self._children_structs = [] self._parent_struct = None self.valid_se_use = False self.property = StructProperty(self) self.convert()
def __init__(self, abitem, name: str): super().__init__(abitem) self._parent = abitem self._caller = StateEngineDefaults.plugin_identification self.shtime = Shtime.get_instance() self.items = Items.get_instance() self._name = name self.__delay = StateEngineValue.SeValue(self._abitem, "delay") self.__repeat = None self.conditionset = StateEngineValue.SeValue(self._abitem, "conditionset", True, "str") self.__mode = StateEngineValue.SeValue(self._abitem, "mode", True, "str") self.__order = StateEngineValue.SeValue(self._abitem, "order", False, "num") self._scheduler_name = None self.__function = None self.__template = None
def __init__(self, smarthome, data_file, callers=None): self.logger = logging.getLogger(__name__) self.logger.info('Init Simulation release 1.5.0.6') self._sh = smarthome self.shtime = Shtime.get_instance() self._datafile = data_file self.lastday = '' self.items = Items.get_instance() self.scheduler = Scheduler.get_instance() self._callers = callers self._items = [] self.scheduler_add('midnight', self._midnight, cron='0 0 * *', prio=3) if not self.init_webinterface(): self._init_complete = False
def __init__(self, webif_dir, plugin): """ Initialization of instance of class WebInterface :param webif_dir: directory where the webinterface of the plugin resides :param plugin: instance of the plugin :type webif_dir: str :type plugin: object """ self.logger = plugin.logger self.webif_dir = webif_dir self.plugin = plugin self.tplenv = self.init_template_environment() self.tplenv.filters['dateformat'] = self.dateformat self.tplenv.filters['timeformat'] = self.timeformat self.items = Items.get_instance()
def __init__(self, smarthome): threading.Thread.__init__(self, name='Scheduler') logger.info('Init Scheduler') self._sh = smarthome self._lock = threading.Lock() self._runc = threading.Condition() global _scheduler_instance if _scheduler_instance is not None: import inspect curframe = inspect.currentframe() calframe = inspect.getouterframes(curframe, 4) logger.critical("A second 'scheduler' object has been created. There should only be ONE instance of class 'Scheduler'!!! Called from: {} ({})".format(calframe[1][1], calframe[1][3])) _scheduler_instance = self self.shtime = Shtime.get_instance() self.items = Items.get_instance()
def __init__(self, smarthome, userlogicconf, envlogicconf): logger.info('Start Logics') self.shtime = Shtime.get_instance() self.items = Items.get_instance() self.plugins = Plugins.get_instance() self.scheduler = Scheduler.get_instance() self._sh = smarthome self._userlogicconf = userlogicconf self._env_dir = smarthome._env_dir self._envlogicconf = envlogicconf self._etc_dir = smarthome._etc_dir self._logic_dir = smarthome._logic_dir self._workers = [] self._logics = {} self._bytecode = {} self.alive = True global _logics_instance if _logics_instance is not None: import inspect curframe = inspect.currentframe() calframe = inspect.getouterframes(curframe, 4) logger.critical("A second 'logics' object has been created. There should only be ONE instance of class 'Logics'!!! Called from: {} ({})".format(calframe[1][1], calframe[1][3])) _logics_instance = self self.scheduler = Scheduler.get_instance() _config = {} self._systemlogics = self._read_logics(envlogicconf, self._env_dir) _config.update(self._systemlogics) self._userlogics = self._read_logics(userlogicconf, self._logic_dir) _config.update(self._userlogics) for name in _config: self._load_logic(name, _config)
def add(self, name, obj, prio=3, cron=None, cycle=None, value=None, offset=None, next=None, from_smartplugin=False): """ Adds an entry to the scheduler. :param name: :param obj: :param prio: a priority with default of 3 having 1 as most important and higher numbes less important :param cron: a crontab entry of type string or a list of entries :param cycle: a time given as integer in seconds or a string with a time given in seconds and a value after an equal sign :param value: :param offset: an optional offset for cycle. If not given, cycle start point will be varied between 10..15 seconds to prevent too many scheduler entries with the same starting times :param next: :param from_smartplugin: """ if self.shtime == None: self.shtime = Shtime.get_instance() if self.shtime == None: self.items = Items.get_instance() self._lock.acquire() if isinstance(cron, str): cron = [cron, ] if isinstance(cron, list): _cron = {} for entry in cron: desc, __, _value = entry.partition('=') desc = desc.strip() if _value == '': _value = None else: _value = _value.strip() if desc.startswith('init'): offset = 5 # default init offset desc, op, seconds = desc.partition('+') if op: offset += int(seconds) else: desc, op, seconds = desc.partition('-') if op: offset -= int(seconds) value = _value # next = self._sh.now() + datetime.timedelta(seconds=offset) next = self.shtime.now() + datetime.timedelta(seconds=offset) else: _cron[desc] = _value if _cron == {}: cron = None else: cron = _cron if isinstance(cycle, int): cycle = {cycle: None} elif isinstance(cycle, str): cycle, __, _value = cycle.partition('=') try: cycle = int(cycle.strip()) except Exception: logger.warning("Scheduler: invalid cycle entry for {0} {1}".format(name, cycle)) return if _value != '': _value = _value.strip() else: _value = None cycle = {cycle: _value} if cycle is not None and offset is None: # spread cycle jobs offset = random.randint(10, 15) # change name for multi instance plugins if obj.__class__.__name__ == 'method': if isinstance(obj.__self__, SmartPlugin): if obj.__self__.get_instance_name() != '': #if not (name).startswith(self._pluginname_prefix): if not from_smartplugin: name = name +'_'+ obj.__self__.get_instance_name() logger.debug("Scheduler: Name changed by adding plugin instance name to: " + name) self._scheduler[name] = {'prio': prio, 'obj': obj, 'cron': cron, 'cycle': cycle, 'value': value, 'next': next, 'active': True} if next is None: self._next_time(name, offset) self._lock.release()