def scriptUnloaded(): if core.JythonItemChannelLinkProvider is not None: core.osgi.unregister_service(core.JythonItemChannelLinkProvider) core.JythonItemChannelLinkProvider = None logging.getLogger(LOG_PREFIX + ".core.JythonItemChannelLinkProvider.scriptUnloaded" ).debug("Unregistered service")
def scriptUnloaded(): if core.JythonItemChannelLinkProvider is not None: unregister_service(core.JythonItemChannelLinkProvider) core.JythonItemChannelLinkProvider = None logging.getLogger( "{}.core.JythonItemChannelLinkProvider.scriptUnloaded".format( LOG_PREFIX)).debug("Unregistered service")
def scriptLoaded(id): if core.JythonItemChannelLinkProvider is not None: core.osgi.register_service(core.JythonItemChannelLinkProvider, [provider_class]) logging.getLogger(LOG_PREFIX + ".core.JythonItemChannelLinkProvider.scriptLoaded" ).debug("Registered service")
def scriptLoaded(id): if core.JythonExtensionProvider is not None: scriptExtension.addScriptExtensionProvider( core.JythonExtensionProvider) logging.getLogger( "{}.core.JythonExtensionProvider.scriptLoaded".format( LOG_PREFIX)).debug("Registered service")
def scriptLoaded(id): if core.JythonBindingInfoProvider is not None: core.osgi.register_service(core.JythonBindingInfoProvider, [provider_class]) logging.getLogger( "{}.core.JythonBindingInfoProvider.scriptLoaded".format( LOG_PREFIX)).debug("Registered service")
def scriptUnloaded(): if core.JythonBindingInfoProvider is not None: core.osgi.unregister_service(core.JythonBindingInfoProvider) core.JythonBindingInfoProvider = None logging.getLogger( "{}.core.JythonBindingInfoProvider.scriptUnloaded".format( LOG_PREFIX)).debug("Unregistered service")
def scriptUnloaded(): if core.JythonTransformationService is not None: unregister_service(core.JythonTransformationService) core.JythonTransformationService = None logging.getLogger( "{}.core.JythonTransformationService.scriptUnloaded".format( LOG_PREFIX)).debug("Unregistered service")
def scriptUnloaded(): if core.JythonExtensionProvider is not None: scriptExtension.removeScriptExtensionProvider( core.JythonExtensionProvider) core.JythonExtensionProvider = None logging.getLogger( "{}.core.JythonExtensionProvider.scriptUnloaded".format( LOG_PREFIX)).debug("Unregistered service")
def scriptLoaded(id): if core.JythonTransformationService is not None: core.osgi.register_service(core.JythonTransformationService, [transformation_class], {'smarthome.transform': 'JYTHON'}) logging.getLogger( "{}.core.JythonTransformationService.scriptLoaded".format( LOG_PREFIX)).debug("Registered service")
def scriptLoaded(script): if core.JythonTransformationService is not None: register_service(core.JythonTransformationService, [TRANSFORMATION_CLASS], {'smarthome.transform': 'JYTHON'}) logging.getLogger( "{}.core.JythonTransformationService.scriptLoaded".format( LOG_PREFIX)).debug("Registered service")
def __init__(self): logging.getLogger("{}.core.JythonExtensionProvider".format( LOG_PREFIX)).debug("Start init") self._defaultPresets = set() self._presets = set() self._preset_values = collections.defaultdict(list) self._values = {} logging.getLogger("{}.core.JythonExtensionProvider".format( LOG_PREFIX)).debug("End init")
def __init__(self, parent, zoneNumber, cfg): ''' Initialise the IdeAlarmZone class Expects: - Parent object - zoneNumber (integer) The zone's ordinal number - cfg (dictionary) The zone's configuration dictionary ''' self._armingMode = None self._zoneStatus = None self.zoneNumber = zoneNumber self.alertDevices = cfg['alertDevices'] self.name = cfg['name'] self.armAwayToggleSwitch = cfg['armAwayToggleSwitch'] self.armHomeToggleSwitch = cfg['armHomeToggleSwitch'] self.mainZone = cfg['mainZone'] self.canArmWithTrippedSensors = cfg['canArmWithTrippedSensors'] self.alarmTestMode = parent.alarmTestMode self.parent = weakref.ref(parent) # <= garbage-collector safe! self.log = logging.getLogger(u"{}.IdeAlarmZone.Zone.{}".format( LOG_PREFIX, self.zoneNumber)) self.sensors = [] for sensor in cfg['sensors']: self.sensors.append(IdeAlarmSensor(self, sensor)) self.armingModeItem = cfg['armingModeItem'] self.statusItem = cfg['statusItem'] self.openSections = self.countOpenSections() self.setArmingMode( getItemValue(self.armingModeItem, ARMINGMODE['DISARMED']) ) # Will also set the zone status to normal self.log.info( u"ideAlarm Zone {} initialized with {} open sensors".format( self.name.decode('utf8'), self.openSections))
def sms(message, subscriber='Default'): ''' Sends an SMS message through ClickaTell gateway. Example: sms("Hello") Example: sms("Hello", 'Amanda') @param param1: SMS Text @param param2: Subscriber. A numeric phone number or a phonebook name entry (String) ''' log = logging.getLogger(LOG_PREFIX + ".community.clickatell.sendsms") phoneNumber = clickatell_configuration['phonebook'].get(subscriber, None) if phoneNumber is None: if subscriber.isdigit(): phoneNumber = subscriber else: log.warn("Subscriber [{}] wasn't found in the phone book".format( subscriber)) return gateway = Clickatell(clickatell_configuration['user'], clickatell_configuration['password'], clickatell_configuration['apiid'], clickatell_configuration['sender']) message = {'to': phoneNumber, 'text': message} log.info("Sending SMS to: [{}]".format(phoneNumber)) retval, msg = gateway.sendmsg(message) if retval == True: log.info("SMS sent: [{}]".format(msg)) else: log.warn("Error while sending SMS: [{}]".format(retval)) return
def __init__(self): ''' Initialise the IdeAlarm class Expects: - Nothing really... ''' self.__version__ = '4.0.0' self.__version_info__ = tuple( [int(num) for num in self.__version__.split('.')]) self.log = logging.getLogger("{}.IdeAlarm V{}".format( LOG_PREFIX, self.__version__)) self.alarmTestMode = idealarm_configuration['ALARM_TEST_MODE'] self.loggingLevel = idealarm_configuration['LOGGING_LEVEL'] self.log.setLevel(self.loggingLevel) self.nagIntervalMinutes = idealarm_configuration[ 'NAG_INTERVAL_MINUTES'] self.timeCreated = DateTime.now() self.alarmZones = [] for i in range(len(idealarm_configuration['ALARM_ZONES'])): zoneNumber = i + 1 self.alarmZones.append( IdeAlarmZone(self, zoneNumber, idealarm_configuration['ALARM_ZONES'][i])) for alarmZone in self.alarmZones: alarmZone.getNagSensors() self.log.info("ideAlarm object initialized with {} zones at {}".format( len(self.alarmZones), format_date(self.timeCreated, customDateTimeFormats['dateTime'])))
def __init__(self, test_case, trigger_item_name, result_item_name): self.test_case = test_case self.trigger_item_name = trigger_item_name self.result_item_name = result_item_name self.triggers = [ ItemStateUpdateTrigger(trigger_item_name, OnOffType.ON) ] self.logger = logging.getLogger(type(self).__name__)
def __init__(self): self.log = logging.getLogger( "jython.openhab.osgi.events.OsgiEventHandler") self.registration = bundle_context.registerService( EventHandler, self, hashtable((EventConstants.EVENT_TOPIC, ["*"]))) self.log.info("Registered openHAB OSGI event listener service") self.log.debug("Registration: [{}]".format(self.registration))
def removeOWMItems(): removeOWMItems.log = logging.getLogger(LOG_PREFIX + ".removeOWMItems") from core.items import remove_item for item in ir.getItemsByTag("OpenWeatherMap"): removeOWMItems.log.debug("removeOWMItems: [{}]".format(item)) remove_item(item) '''
def __init__(self): self.log = logging.getLogger( "{}.core.osgi.events.OsgiEventHandler") self.registration = BUNDLE_CONTEXT.registerService( EventHandler, self, hashtable((EventConstants.EVENT_TOPIC, ["*"]))) self.log.info("Registered openHAB OSGi event listener service") self.log.debug("Registration: [{}]".format(self.registration))
def removeGrafanaItems(): removeGrafanaItems.log = logging.getLogger( "{}.removeGrafanaItems".format(LOG_PREFIX)) removeGrafanaItems.log.info("Remove existing Items...") for item in ir.getItemsByTag("Grafana"): removeGrafanaItems.log.info("Remove Grafana Item [{}]".format( item.name)) remove_item(item) remove_item(GRAFANA_GROUP)
def showGrafanaItems(): showGrafanaItems.log = logging.getLogger( "{}.showGrafanaItems".format(LOG_PREFIX)) showGrafanaItems.log.info("Show Items metadata...") from core.metadata import get_metadata for item in itemRegistry.getAll(): metadata = get_metadata(item.name, "Grafana_Graphs") if metadata is not None: showGrafanaItems.log.info("{}\n{}".format(item, metadata.configuration))
def calcNextSunTimes(): calcNextSunTimes.log = logging.getLogger( "{}.calcNextSunTimes".format(LOG_PREFIX)) if str(items["Astro_Day_Phase"]) in ["DAYLIGHT", "NOON"]: calcNextSunTimes.log.info( "Daylight - next sunrise is tomorrow, next sunset is today") events.postUpdate("Astro_Sun_RiseNext", str(ir.getItem("Astro_Sun_RiseTomorrow").state)) events.postUpdate("Astro_Sun_SetNext", str(ir.getItem("Astro_Sun_SetTime").state)) elif str(ir.getItem("Astro_Day_Phase").state) == "SUN_RISE": calcNextSunTimes.log.info("Sunrise - next sunrise and sunset is today") events.postUpdate("Astro_Sun_RiseNext", str(ir.getItem("Astro_Sun_RiseTime").state)) events.postUpdate("Astro_Sun_SetNext", str(ir.getItem("Astro_Sun_SetTime").state)) elif str(ir.getItem("Astro_Day_Phase").state) == "SUN_SET": calcNextSunTimes.log.info( "Sunset - next sunrise is tomorrow and sunset is today") events.postUpdate("Astro_Sun_RiseNext", str(ir.getItem("Astro_Sun_RiseTomorrow").state)) events.postUpdate("Astro_Sun_SetNext", str(ir.getItem("Astro_Sun_SetTime").state)) elif str(ir.getItem("Astro_Day_Phase").state) in [ "ASTRO_DAWN", "NAUTIC_DAWN", "CIVIL_DAWN" ]: calcNextSunTimes.log.info("Dawn - next sunrise and sunset is today") events.postUpdate("Astro_Sun_RiseNext", str(ir.getItem("Astro_Sun_RiseTime").state)) events.postUpdate("Astro_Sun_SetNext", str(ir.getItem("Astro_Sun_SetTime").state)) elif str(ir.getItem("Astro_Day_Phase").state) in [ "ASTRO_DUSK", "NAUTIC_DUSK", "CIVIL_DUSK" ]: calcNextSunTimes.log.info("Dusk - next sunrise and sunset is tomorrow") events.postUpdate("Astro_Sun_RiseNext", str(ir.getItem("Astro_Sun_RiseTomorrow").state)) events.postUpdate("Astro_Sun_SetNext", str(ir.getItem("Astro_Sun_SetTomorrow").state)) else: if DateTime.now().getHourOfDay() > 12: calcNextSunTimes.log.info( "Before midnight - next sunrise and sunset is tomorrow") events.postUpdate("Astro_Sun_RiseNext", str(ir.getItem("Astro_Sun_RiseTomorrow").state)) events.postUpdate("Astro_Sun_SetNext", str(ir.getItem("Astro_Sun_SetTomorrow").state)) else: calcNextSunTimes.log.info( "After midnight - next sunrise and sunset is today") events.postUpdate("Astro_Sun_RiseNext", str(ir.getItem("Astro_Sun_RiseTime").state)) events.postUpdate("Astro_Sun_SetNext", str(ir.getItem("Astro_Sun_SetTime").state))
def to_joda_datetime(value): """ Converts any of the supported date types to ``org.joda.time.DateTime``. If ``value`` does not have timezone information, the system default will be used. Examples: .. code-block:: joda_time = to_joda_datetime(items["date_item"]) Args: value: the value to convert Returns: org.joda.time.DateTime: the converted value None: if ``org.joda.time`` is not available Raises: TypeError: if the type of ``value`` is not suported by this package """ if JodaDateTime is None: frame = inspect.stack()[1] logging.getLogger("{}.date".format(LOG_PREFIX)).warn( "'{func}' ({file}:{line}) called 'to_joda_datetime' but Joda is not available" .format(file=frame.filename, line=frame.lineno, func=frame.function)) del frame return None if isinstance(value, JodaDateTime): return value value_zoneddatetime = to_java_zoneddatetime(value) return JodaDateTime( value_zoneddatetime.toInstant().toEpochMilli(), JodaDateTimeZone.forTimeZone( TimeZone.getTimeZone(value_zoneddatetime.getZone())))
def refreshImageItem(itemName): refreshImageItem.log = logging.getLogger( "{}.grafanaRefreshInit".format(LOG_PREFIX)) panelUrl = GRAFANA_URL + "&panelId=" + \ str(get_key_value(itemName, "Grafana_Graphs", "PanelId")) + \ "&from=" + str(get_key_value(itemName, "Grafana_Graphs", "RangeFrom")) rangeTo = str(get_key_value(itemName, "Grafana_Graphs", "RangeTo")) if rangeTo != "": panelUrl += "&to=" + rangeTo panelUrl += "&theme=" + str( get_key_value(itemName, "Grafana_Graphs", "Theme")) refreshImageItem.log.debug("Refresh Item URL [{}]".format(panelUrl)) imageSnapshot = getSnapshotImage(panelUrl, itemName) events.postUpdate(itemName, imageSnapshot)
class OsgiEventAdmin(object): _event_handler = None event_listeners = [] log = logging.getLogger( u"{}.core.osgi.events.OsgiEventAdmin".format(LOG_PREFIX)) # Singleton class OsgiEventHandler(EventHandler): def __init__(self): self.log = logging.getLogger( "{}.core.osgi.events.OsgiEventHandler") self.registration = BUNDLE_CONTEXT.registerService( EventHandler, self, hashtable((EventConstants.EVENT_TOPIC, ["*"]))) self.log.info("Registered openHAB OSGi event listener service") self.log.debug("Registration: [{}]".format(self.registration)) def handleEvent(self, event): self.log.critical("Handling event: [{}]".format(event)) for listener in OsgiEventAdmin.event_listeners: try: listener(event) except: self.log.error("Listener failed: '{}'".format( traceback.format_exc())) def dispose(self): self.registration.unregister() @classmethod def add_listener(class_, listener): class_.log.debug("Adding listener admin: '{} {}'".format( id(class_), listener)) class_.event_listeners.append(listener) if len(class_.event_listeners) == 1: if class_._event_handler is None: class_._event_handler = class_.OsgiEventHandler() @classmethod def remove_listener(class_, listener): class_.log.debug("Removing listener: '{}'".format(listener)) if listener in class_.event_listeners: class_.event_listeners.remove(listener) if not class_.event_listeners: if class_._event_handler is not None: class_.log.info( "Unregistering openHAB OSGi event listener service") class_._event_handler.dispose() class_._event_handler = None
def __init__(self, callback, triggers, name=None, description=None, tags=None): self.triggers = triggers if name is None: if hasattr(callback, '__name__'): name = callback.__name__ else: name = "JSR223-Jython" self.name = name callback.log = logging.getLogger("{}.{}".format(LOG_PREFIX, name)) self.callback = log_traceback(callback) if description is not None: self.description = description if tags is not None: self.tags = set(tags)
def addDayModeItem(): addDayModeItem.log = logging.getLogger("{}.addDayModeItem".format(LOG_PREFIX)) # scriptExtension.importPreset("RuleSupport") try: if ir.getItems("Day_Mode") == []: add_item("Day_Mode", item_type="String", groups=["gAstro,gPersist"], label="Current day mode [%s]", category="sunset", tags=["Astro"] ) except: import traceback addDayModeItem.log.error(traceback.format_exc())
class OsgiEventAdmin(object): log = logging.getLogger(LOG_PREFIX + ".osgi.events.OsgiEventAdmin") _event_handler = None _event_listeners = [] # Singleton class OsgiEventHandler(EventHandler): def __init__(self): self.log = logging.getLogger("jython.openhab.osgi.events.OsgiEventHandler") self.registration = bundle_context.registerService( EventHandler, self, hashtable((EventConstants.EVENT_TOPIC, ["*"]))) self.log.info("Registered openHAB OSGI event listener service") self.log.debug("Registration: [{}]".format(self.registration)) def handleEvent(self, event): self.log.debug("Handling event: [{}]".format(event)) for listener in OsgiEventAdmin._event_listeners: try: listener(event) except: self.log.error("Listener failed: [{}]".format(traceback.format_exc())) def dispose(self): self.registration.unregister() @classmethod def add_listener(cls, listener): cls.log.debug("Adding listener admin: [{} {}]".format (id(cls), listener)) cls._event_listeners.append(listener) if len(cls._event_listeners) == 1: if cls._event_handler is None: cls._event_handler = cls.OsgiEventHandler() @classmethod def remove_listener(cls, listener): cls.log.debug("Removing listener: [{}]".format(listener)) if listener in cls._event_listeners: cls._event_listeners.remove(listener) if len(cls._event_listeners) == 0: if cls._event_handler is not None: cls.log.info("Unregistering openHAB OSGI event listener service") cls._event_handler.dispose() cls._event_handler = None
def __init__(self, parent, cfg): ''' Initialise the IdeAlarmSensor class Expects: - Parent object - cfg (dictionary) The sensor's configuration dictionary ''' self.name = cfg['name'] _label = scope.itemRegistry.getItem(self.name).label self.label = _label if _label is not None else 'Sensor has no label' self.parent = weakref.ref(parent) # <= garbage-collector safe! self.sensorClass = cfg['sensorClass'] self.nag = cfg['nag'] self.nagTimeoutMins = cfg['nagTimeoutMins'] self.armWarn = cfg['armWarn'] self.enabled = cfg['enabled'] self.log = logging.getLogger(u"{}.IdeAlarmSensor.{}".format( LOG_PREFIX, self.name.decode('utf8')))
def temperatureLivingroom(event): temperatureLivingroom.log = logging.getLogger( "{}.temperatureLivingroom".format(LOG_PREFIX)) temperatureLivingroom.log.debug( "Updating avg livingroom temp from changed [{}]".format( event.itemName)) if ir.getItem("CV_Temp_Livingroom").state is not None: if ir.getItem("NHC_Temp_Livingroom").state is not None: events.postUpdate( "Temp_Avg_Livingroom", str((float(str(ir.getItem("CV_Temp_Livingroom").state)) + float(str(ir.getItem("NHC_Temp_Livingroom").state))) / 2)) else: events.postUpdate("Temp_Avg_Livingroom", str(ir.getItem("CV_Temp_Livingroom").state)) elif items.NHC_Temp_Livingroom is not None: events.postUpdate("Temp_Avg_Livingroom", str(ir.getItem("NHC_Temp_Livingroom").state)) else: temperatureLivingroom.log.warn("Living room temp sensors are NULL")
def init(self, *args, **kwargs): scope.SimpleRule.__init__(self) if name is None: if hasattr(clazz, '__name__'): self.name = clazz.__name__ else: self.name = "JSR223-Jython" else: self.name = name #set_uid_prefix(self) self.log = logging.getLogger("{}.{}".format(LOG_PREFIX, self.name)) clazz.__init__(self, *args, **kwargs) if description is not None: self.description = description elif self.description is None and clazz.__doc__: self.description = clazz.__doc__ if hasattr(self, "getEventTriggers"): self.triggers = log_traceback(self.getEventTriggers)() if tags is not None: self.tags = set(tags)