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)
