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(LOG_PREFIX + '.IdeAlarmZone.' +
self.name.decode('utf8'))
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('ideAlarm Zone ' + self.name.decode('utf8') +
' initialized with ' + str(self.openSections) +
' open sensors')
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=%s", self.registration)
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, callback, triggers, extended=False, name=None):
self.triggers = triggers
self.callback = callback
self.extended = extended
if name is None and hasattr(callback, '__name__'):
name = callback.__name__
self.log = logging.getLogger(LOG_PREFIX +
("" if name is None else ("." + name)))
def init(self, *args, **kwargs):
scope.SimpleRule.__init__(self)
set_uid_prefix(self)
self.log = logging.getLogger(LOG_PREFIX + "." + clazz.__name__)
clazz.__init__(self, *args, **kwargs)
if self.description is None and clazz.__doc__:
self.description = clazz.__doc__
if hasattr(self, "getEventTriggers"):
self.triggers = log_traceback(self.getEventTriggers)()
elif hasattr(self, "getEventTrigger"):
# For OH1 compatibility
self.triggers = log_traceback(self.getEventTrigger)()
def __init__(self):
self.log = logging.getLogger(LOG_PREFIX + "." + type(self).__module__ + "." + type(self).__name__)
self.events = scope.events
self.triggers = []
self.description = type(self).__doc__ if type(self).__doc__ else None
set_uid_prefix(self)
super(scope.SimpleRule, self)
self.execute = self.run#log_traceback(self.run)
self.triggers = log_traceback(self.getEventTriggers)()
addRule(self)
class OsgiEventAdmin(object):
log = logging.getLogger("jython.openhab.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=%s", self.registration)
def handleEvent(self, event):
self.log.debug("handling event %s", event)
for listener in OsgiEventAdmin._event_listeners:
try:
listener(event)
except:
self.log.error("Listener failed: %s",
traceback.format_exc())
def dispose(self):
self.registration.unregister()
@classmethod
def add_listener(cls, listener):
cls.log.debug("adding listener admin=%s %s", 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 %s", 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 tts(ttsSay, ttsPrio=PRIO['MODERATE'], **keywords):
'''
Text To Speak function. First argument is positional and mandatory.
Remaining arguments are optionally keyword arguments.
Example: tts("Hello")
Example: tts("Hello", PRIO['HIGH'], ttsRoom='Kitchen', ttsVol=42, ttsLang='en-GB', ttsVoice='Brian')
@param param1: Text to speak (positional argument)
@param param2: Priority as defined by PRIO. Defaults to PRIO['MODERATE']
@param ttsRoom: Room to speak in. Defaults to "All".
@return: this is a description of what is returned
'''
module_name = 'speak'
log = logging.getLogger(LOG_PREFIX+'.'+module_name+'.tts')
ttsRoom = 'All' if 'ttsRoom' not in keywords else keywords['ttsRoom']
ttsVol = None if 'ttsVol' not in keywords else keywords['ttsVol']
ttsLang = 'sv-SE' if 'ttsLang' not in keywords else keywords['ttsLang']
ttsVoice = 'Astrid' if 'ttsVoice' not in keywords else keywords['ttsVoice']
if not ttsVol or ttsVol >= 70:
if ttsPrio == PRIO['LOW']:
ttsVol = 30
elif ttsPrio == PRIO['MODERATE']:
ttsVol = 40
elif ttsPrio == PRIO['HIGH']:
ttsVol = 60
elif ttsPrio == PRIO['EMERGENCY']:
ttsVol = 70
else:
ttsVol = 50
hour = DateTime.now().getHourOfDay()
# (ideAlarm.isArmed('Bostaden') and ttsPrio <= PRIO['MODERATE']): didn't work out due to circulare reference of ideAlarm
if (hour < 7 or hour > 21) or \
((getItemValue('Z1_Arming_Mode', 0) != 0) and ttsPrio <= PRIO['MODERATE']):
log.info("TTS: ttsPrio is to low to speak \'" + ttsSay + "\' at this moment")
return False
log.info("TTS: Speaking \'" + ttsSay + "\'")
# The following will execute as user openhab and that users public key
# **must** have been added into authorized_keys
os.system('/home/john/node-sonos2domo/speak.sh ' \
+ ttsRoom + ' ' + str(ttsVol) + ' ' + ttsLang + ' ' + ttsVoice + ' ' + ttsSay \
+ ' > /dev/null 2>&1 &')
return True
def __init__(self, parent, cfg):
'''
Initialise the IdeAlarmSensor class
Expects:
- Parent object
- cfg (dictionary) The sensor's configuration dictionary
'''
self.name = cfg['name']
_label = 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(LOG_PREFIX + '.IdeAlarmSensor.' +
self.name.decode('utf8'))
def sms(message, subscriber='John'):
'''
Sends an SMS message through ClickaTell gateway.
Example: sms("Hello")
Example: sms("Hello", 'Carl')
@param param1: SMS Text
@param param2: Subscriber. A numeric phone number or a subscriber (String)
'''
log = logging.getLogger(LOG_PREFIX)
ClickatellSender = '45123456789'
ClickatellAPIUser = '******'
ClickatellAPIPassw = 'riuyYGVTua8k'
ClickatellAPIId = 1234567
phoneNumbers = {
'Anna': '467395646546',
'Veronica': '461565136511'
}
phoneNumber = phoneNumbers.get(subscriber, None)
if phoneNumber is None:
if subscriber.isdigit():
phoneNumber = subscriber
else:
log.error("Invalid subscriber")
return
gateway = Clickatell(ClickatellAPIUser, ClickatellAPIPassw, ClickatellAPIId, ClickatellSender)
message = {'to': phoneNumber, 'text': message}
log.info("Sending SMS to: " + str(phoneNumber))
retval, msg = gateway.sendmsg(message)
if retval == True:
log.info("SMS Sent: " + msg)
else:
log.error("Error while sending SMS: " + str(retval))
return
def __init__(self):
'''
Initialise the IdeAlarm class
Expects:
- Nothing really...
'''
self.__version__ = '1.0.0'
self.__version_info__ = tuple(
[int(num) for num in self.__version__.split('.')])
self.log = logging.getLogger(LOG_PREFIX + '.IdeAlarm V' +
self.__version__)
import idealarm.config ######### TEMP
#reload(idealarm.config) ######### TEMP
#self.log.debug('Configuration file has been reloaded!!!') ######### TEMP
import idealarm.config as _cfg
self.alarmTestMode = _cfg.ALARM_TEST_MODE
self.loggingLevel = _cfg.LOGGING_LEVEL
self.nagIntervalMinutes = _cfg.NAG_INTERVAL_MINUTES
self.timeCreated = DateTime.now()
self.alarmZones = []
for i in range(len(_cfg.ALARM_ZONES)):
zoneNumber = i + 1
self.alarmZones.append(
IdeAlarmZone(self, zoneNumber, _cfg.ALARM_ZONES[i]))
for alarmZone in self.alarmZones:
alarmZone.getNagSensors()
self.log.info('ideAlarm object initialized with ' +
str(len(self.alarmZones)) + ' zones at ' +
str(self.timeCreated))
import java.util
import traceback
import uuid
import traceback
from org.eclipse.smarthome.automation import Visibility
from org.eclipse.smarthome.config.core import Configuration
from org.eclipse.smarthome.automation.handler import TriggerHandler
import openhab
scriptExtension.importPreset("RuleSupport")
scriptExtension.importPreset("RuleFactories")
from openhab.log import logging
log = logging.getLogger("jython.openhab.triggers.OsgiEventTrigger")
from openhab.osgi.events import OsgiEventAdmin, event_dict, osgi_triggers
class OsgiEventTriggerHandlerFactory(TriggerHandlerFactory):
def __init__(self):
self.handlers = []
class Handler(TriggerHandler):
def __init__(self, factory, runtime_trigger):
try:
self.rule_engine_callback = None
self.factory = factory
self.trigger = osgi_triggers.get(runtime_trigger.id,
runtime_trigger)
self.filter = getattr(self.trigger, "event_filter", None)
# -*- coding: utf-8 -*-
import weakref # Using this to prevent problems with garbage collection
# Get direct access to the JSR223 scope types and objects (for Jython modules imported into scripts)
from openhab.jsr223.scope import events, itemRegistry
from org.eclipse.smarthome.model.persistence.extensions import PersistenceExtensions
from openhab.triggers import ItemCommandTrigger, ItemStateChangeTrigger
from org.joda.time import DateTime
from openhab.log import logging, LOG_PREFIX
from logging import DEBUG, INFO, WARNING, ERROR
log = logging.getLogger(LOG_PREFIX + '.ideAlarm')
#import mylib.utils ######### TEMP
#reload(mylib.utils) ######### TEMP
from mylib.utils import getEvent, isActive, getItemValue, postUpdateCheckFirst, sendCommandCheckFirst, kw
from idealarm import custom
#reload(custom) ######### TEMP
ZONESTATUS = {'NORMAL': 0, 'ALERT': 1, 'ERROR': 2, 'TRIPPED': 3, 'ARMING': 4}
ARMINGMODE = {'DISARMED': 0, 'ARMED_HOME': 1, 'ARMED_AWAY': 2}
class IdeAlarmError(Exception):
'''
Base class for IdeAlarm errors
'''
import time
from openhab.osgi import get_service
from openhab.log import logging
log = logging.getLogger("registry_example")
rule_registry = get_service("org.eclipse.smarthome.automation.RuleRegistry")
# Get rules by tags
# Tags can be set in rule constructors
# Example: self.tags = ["tag1", "tag2"]
rules = rule_registry.getByTag("a")
for rule in rules:
rule_status = rule_registry.getStatusInfo(rule.UID)
log.info("rule_status=%s", rule_status)
# disable a rule
rule_registry.setEnabled(rule.UID, False)
# later...
time.sleep(1)
# reenable the rule
rule_registry.setEnabled(rule.UID, True)
# fire the rule manually (with inputs)
log.info("triggering rule manually")
rule_registry.runNow(rule.UID, False, {'name': 'EXAMPLE'})
def __init__(self, ip, mac):
self._ip = ip
self._mac = binascii.unhexlify(mac.replace(":", ""))
self._logger = logging.getLogger('{}@{}'.format(self.__class__.__name__, ip))
self._last_subscr_time = 0
self._socket = _create_orvibo_socket()
from openhab.actions import Astro
from openhab.log import logging
from java.util import Date
logging.getLogger("org.eclipse.smarthome.automation").info(
"Sunrise: %s",
Astro.getAstroSunsetStart(Date(2017, 7, 25), 38.897096, -77.036545).time)
from org.openhab.core.items import ItemProvider
import openhab.osgi as osgi
from openhab.log import logging
_log = logging.getLogger("Jsr223ItemProvider")
class Jsr223ItemProvider(ItemProvider):
def __init__(self):
self._items = {}
self._listeners = []
def getItems(self):
return self._items.values()
def addItem(self, item):
self._items[item.name] = item
for listener in self._listeners:
listener.itemAdded(self, item)
def removeItem(self, item_name):
item = self._items.get(item_name)
if item:
del self._items[item_name]
for listener in self._listeners:
listener.itemRemoved(self, item)
def _removeAllItems(self):
old_items = self._items
self._items = {}
for listener in self._listeners:
import collections
import openhab
from openhab.log import logging
log = logging.getLogger(
"org.eclipse.smarthome.automation.JythonExtensionProvider")
def scriptLoaded(*args):
try:
from java.lang import Class
name = "org.eclipse.smarthome.automation.module.script.ScriptExtensionProvider"
ScriptExtensionProvider = Class.forName(
name, True,
scriptExtension.getClass().getClassLoader())
class JythonExtensionProvider(ScriptExtensionProvider):
def __init__(self):
self._defaultPresets = set()
self._presets = set()
self._preset_values = collections.defaultdict(list)
self._values = {}
def getDefaultPresets(self):
"""These presets will always get injected into the ScriptEngine on instance creation."""
return self._defaultPresets
def getPresets(self):
"""Returns the provided Presets which are supported by this ScriptExtensionProvider.
Presets define imports which will be injected into the ScriptEngine if called by "importPreset".
Note: default preset names must also be in this list.
from org.osgi.service.cm import ManagedService
from org.eclipse.smarthome.config.core import Configuration
from org.eclipse.smarthome.automation.handler import TriggerHandler
import openhab
from openhab.jsr223 import scope
scope.scriptExtension.importPreset("RuleSupport")
from openhab.osgi import bundle_context
from openhab.log import logging
import uuid
import java.util
log = logging.getLogger("jython.openhab.osgi.events")
def hashtable(*key_values):
"""
:param key_values: 2-tuples of (key, value)
:return: initialized Hashtable
"""
ht = java.util.Hashtable()
for k, v in key_values:
ht.put(k, v)
return ht
class OsgiEventAdmin(object):
log = logging.getLogger("jython.openhab.osgi.events.OsgiEventAdmin")
import json
import esper.java
import openhab
from openhab.log import logging
from openhab.osgi.events import OsgiEventAdmin
from java.lang import String, Double, Object
from java.util import Date
from com.espertech.esper.client import EPServiceProviderManager, Configuration
log = logging.getLogger("com.eclipse.smarthome.automation.Esper")
item_state_schema = {
"type": String,
"time": Date,
"name": String,
"state": Object
}
item_state_changed_schema = {
"type": String,
"time": Date,
"name": String,
"previous_state": Object,
"state": Object
}
item_command_schema = {
import re
import collections
import json
import pykka
import threading
from openhab.osgi.events import OsgiEventAdmin, log_event, event_dict
from org.osgi.framework import Filter
from openhab.log import logging
openhab_log = logging.getLogger("ActorExample")
from org.python.modules.sre import PatternObject
pykka.ActorRegistry.stop_all()
class LogActor(pykka.ThreadingActor):
def __init__(self):
pykka.ThreadingActor.__init__(self)
def on_receive(self, message):
openhab_log.info(message.get('message'))
logger_ref = LogActor.start()
def log(fmt, *args):
logger_ref.tell({'message': fmt.format(*args)})
