def __init__(self,name,registrations):
assert type(name)==str
assert type(registrations)==list
for r in registrations:
assert type(r)==dict
for k in r.keys():
assert k in ['signal','sender','callback']
# log
log.info("create instance")
# store params
self.dataLock = threading.RLock()
self.registrations = []
# give this thread a name
self.name = name
# local variables
self.goOn = True
# register registrations
for r in registrations:
self.register(
sender = r['sender'],
signal = r['signal'],
callback = r['callback'],
)
# connect to dispatcher
dispatcher.connect(
receiver = self._eventBusNotification,
)
def __init__(self):
dispatcher.connect(self.handle_image_load_event, signal='load_image', sender=dispatcher.Any)
dispatcher.connect(self.handle_filter_event, signal='apply_filter', sender=dispatcher.Any)
self.image = None
self.im_processor = ImageProcessor()
self.user_interface = GUI()
self.user_interface.run()
def __init__(self, node, network, new_entity_ids):
"""Initialize node."""
# pylint: disable=import-error
super().__init__()
from openzwave.network import ZWaveNetwork
from pydispatch import dispatcher
self._network = network
self.node = node
self.node_id = self.node.node_id
self._name = node_name(self.node)
self._product_name = node.product_name
self._manufacturer_name = node.manufacturer_name
self.old_entity_id = "{}.{}_{}".format(
DOMAIN, slugify(self._name), self.node_id)
self.new_entity_id = "{}.{}".format(DOMAIN, slugify(self._name))
if not new_entity_ids:
self.entity_id = self.old_entity_id
self._attributes = {}
self.wakeup_interval = None
self.location = None
self.battery_level = None
dispatcher.connect(
self.network_node_changed, ZWaveNetwork.SIGNAL_VALUE_CHANGED)
dispatcher.connect(self.network_node_changed, ZWaveNetwork.SIGNAL_NODE)
dispatcher.connect(
self.network_node_changed, ZWaveNetwork.SIGNAL_NOTIFICATION)
dispatcher.connect(
self.network_node_event, ZWaveNetwork.SIGNAL_NODE_EVENT)
dispatcher.connect(
self.network_scene_activated, ZWaveNetwork.SIGNAL_SCENE_EVENT)
def __init__(self,refresh_period=REFRESH_PERIOD):
# log
log.info('creating instance')
# store params
self.refresh_period = refresh_period
# initialize parent class
threading.Thread.__init__(self)
# give this thread a name
self.name = 'DustLink'
# local variables
self.goOn = True
self.dataLock = threading.Lock()
self.gateway = None
self.lbr = None
self.dataConnector = None
# connect to dispatcher
dispatcher.connect(
self.tearDown,
signal = 'tearDown',
weak = False,
)
# start itself
self.start()
def __init__(self, value, refresh, delay):
"""Initialize the light."""
from openzwave.network import ZWaveNetwork
from pydispatch import dispatcher
zwave.ZWaveDeviceEntity.__init__(self, value, DOMAIN)
self._brightness = None
self._state = None
self._delay = delay
self._refresh_value = refresh
self._zw098 = None
# Enable appropriate workaround flags for our device
# Make sure that we have values for the key before converting to int
if (value.node.manufacturer_id.strip() and
value.node.product_id.strip()):
specific_sensor_key = (int(value.node.manufacturer_id, 16),
int(value.node.product_id, 16))
if specific_sensor_key in DEVICE_MAPPINGS:
if DEVICE_MAPPINGS[specific_sensor_key] == WORKAROUND_ZW098:
_LOGGER.debug("AEOTEC ZW098 workaround enabled")
self._zw098 = 1
self.update_properties()
# Used for value change event handling
self._refreshing = False
self._timer = None
_LOGGER.debug('self._refreshing=%s self.delay=%s',
self._refresh_value, self._delay)
dispatcher.connect(
self._value_changed, ZWaveNetwork.SIGNAL_VALUE_CHANGED)
def configure():
level = cbpos.config['app', 'log']
level = getattr(logging, level if level in LEVELS else LEVELS[0])
filename = cbpos.config['app', 'log_file']
filepath = os.path.realpath(filename) if filename != '' else None
use_colors = bool(cbpos.config['app', 'log_use_colors'])
root = logging.getLogger()
root.setLevel(level)
# The standard format used for file logging and console logging
log_format = '%(name)s: %(message)s (%(filename)s:%(lineno)s)'
long_log_format = '[%(levelname)8s]\t'+log_format
console = logging.StreamHandler()
# Format with colors
if use_colors and ColoredFormatter is not None:
console.setFormatter(ColoredFormatter(log_format))
else:
console.setFormatter(logging.Formatter(long_log_format))
if filepath:
# Set up logging to a file
fh = logging.FileHandler(filepath, 'w')
fh.setFormatter(logging.Formatter(long_log_format))
root.addHandler(fh)
else:
root.addHandler(console)
# Log any signal from any sender
dispatcher.connect(log_signals, signal=dispatcher.Any, sender=dispatcher.Any)
def run(config_path=None):
if config_path != None and not os.path.isfile(config_path):
raise Exception('config_path does not exist! %s' % config_path)
elif config_path is None:
config_path = resource_filename("illiquids", "tornado.conf")
if not os.path.isfile(config_path):
raise Exception('no config_path!')
tornado.options.parse_config_file(config_path)
tornado.options.parse_command_line()
logging.info("Loaded tornado config %s " % config_path)
application = Application()
logging.info('listening on port:%s' % options.port)
#Native Tornado stuff
application.listen(options.port)
io_loop = tornado.ioloop.IOLoop.instance()
def shutdown():
logging.warning('Service request message to shut down')
io_loop.stop()
dispatcher.connect(shutdown, SHUTTING_DOWN)
io_loop.start()
return application
def __init__(self,signal,sender,notifCallback):
# log
log.debug("create instance")
# store params
self.notifCallback = notifCallback
self.sender = sender
# initialize parent class
threading.Thread.__init__(self)
# give this thread a name
self.name = 'MoteConnectorConsumer'
# local variables
self.goOn = True
self.dataQueue = Queue.Queue(self.QUEUESIZE)
# connect to dispatcher
dispatcher.connect(
#notifCallback,
self._eventBusNotification,
signal = signal,
)
def __init__(self):
self.wm = pyinotify.WatchManager()
# These two instance variables are assumed to be constant
self.watch_channel = getsig('watch')
self.organize_channel = getsig('organize')
self.watch_listener = StoreWatchListener(signal = self.watch_channel)
self.__timeout_thread = ManagerTimeout(self)
self.__timeout_thread.daemon = True
self.__timeout_thread.start()
self.organize = {
'organize_path' : None,
'imported_path' : None,
'recorded_path' : None,
'problem_files_path' : None,
'organizer' : None,
'problem_handler' : None,
'organize_listener' : OrganizeListener(signal=
self.organize_channel),
}
def dummy(sender, event): self.watch_move( event.path, sender=sender )
dispatcher.connect(dummy, signal=getsig('watch_move'),
sender=dispatcher.Any, weak=False)
def subwatch_add(sender, directory):
self.__add_watch(directory, self.watch_listener)
dispatcher.connect(subwatch_add, signal=getsig('add_subwatch'),
sender=dispatcher.Any, weak=False)
# A private mapping path => watch_descriptor
# we use the same dictionary for organize, watch, store wd events.
# this is a little hacky because we are unable to have multiple wd's
# on the same path.
self.__wd_path = {}
# The following set isn't really necessary anymore. Should be
# removed...
self.watched_directories = set([])
def _fromXMLElement(cls, xmlElement, network = None):
frame = NeuroptikonFrame()
# Restore any console history.
commandHistoryElement = xmlElement.find('CommandHistory')
if commandHistoryElement is not None:
history = []
for commandElement in commandHistoryElement.findall('Command'):
history += [commandElement.text]
frame._console.history = history
# TODO: set frame position and size
# Populate the display (can't use the _fromXMLElement pattern here because it doesn't seem possible to re-parent a wx.GLCanvas.
displayElement = xmlElement.find('Display')
if displayElement is None:
raise ValueError, gettext('Display windows must contain a display')
frame.display.autoVisualize = False
frame.display.setNetwork(network)
if network:
dispatcher.connect(frame.networkDidChangeSavePath, ('set', 'savePath'), network)
frame.display._fromXMLElement(displayElement)
frame.networkDidChangeSavePath()
frame.setModified(False)
wx.GetApp().inspector.inspectDisplay(frame.display)
return frame
def __init__(self, serialport):
# log
log.info("creating instance")
# store params
self.serialport = serialport
# local variables
self.parser = OpenParser.OpenParser()
self.stateLock = threading.Lock()
self.networkPrefix = None
self._subcribedDataForDagRoot = False
# give this thread a name
self.name = "moteConnector@{0}".format(self.serialport)
eventBusClient.eventBusClient.__init__(
self,
name=self.name,
registrations=[
{"sender": self.WILDCARD, "signal": "infoDagRoot", "callback": self._infoDagRoot_handler},
{"sender": self.WILDCARD, "signal": "cmdToMote", "callback": self._cmdToMote_handler},
],
)
# subscribe to dispatcher
dispatcher.connect(self._sendToParser, signal="fromMoteProbe@" + self.serialport)
def depend_signal( self, signal, sender=dispatcher.Any ):
"""Depend on signal from sender"""
dispatcher.connect(
self.clear,#receiver
signal,
sender,
)
def __init__(self, node, network):
"""Initialize node."""
# pylint: disable=import-error
super().__init__()
from openzwave.network import ZWaveNetwork
from pydispatch import dispatcher
self._network = network
self.node = node
self.node_id = self.node.node_id
self._name = node_name(self.node)
self._product_name = node.product_name
self._manufacturer_name = node.manufacturer_name
self._unique_id = self._compute_unique_id()
self._attributes = {}
self.wakeup_interval = None
self.location = None
self.battery_level = None
dispatcher.connect(
self.network_node_changed, ZWaveNetwork.SIGNAL_VALUE_CHANGED)
dispatcher.connect(self.network_node_changed, ZWaveNetwork.SIGNAL_NODE)
dispatcher.connect(
self.network_node_changed, ZWaveNetwork.SIGNAL_NOTIFICATION)
dispatcher.connect(
self.network_node_event, ZWaveNetwork.SIGNAL_NODE_EVENT)
dispatcher.connect(
self.network_scene_activated, ZWaveNetwork.SIGNAL_SCENE_EVENT)
def inner(receiver):
if isinstance(signal, Signal):
# preferable: involves proper logging
signal.connect(receiver=receiver, sender=sender, weak=weak)
else:
connect(receiver, signal=signal, sender=sender, weak=weak)
return receiver
def __init__(self, parent):
mdc_gui.MultiPing.__init__(self, parent)
self.ping_list = ObjectListView(self.olv_panel, wx.ID_ANY,
style=wx.LC_REPORT |
wx.SUNKEN_BORDER)
self.ping_list.Bind(wx.EVT_LIST_ITEM_RIGHT_CLICK,
self.MultiPingOnContextMenu)
self.ping_list.SetColumns(
[ColumnDefn("IP", "center", 100, "ip_address"),
ColumnDefn("MAC", "center", 130, "mac_address"),
ColumnDefn("Hostname", "center", 130, "hostname"),
ColumnDefn("Serial", "center", 150, "serial"),
ColumnDefn("Successful Pings", "center", 110, "success"),
ColumnDefn("Failed Pings", "center", 80, "failed")])
self.olv_sizer.Add(self.ping_list, 1, wx.ALL | wx.EXPAND, 0)
self.olv_sizer.Layout()
self.parent = parent
self.log_link_txt.SetURL(os.path.join(self.parent.path, 'ping_logs'))
self.SetTitle("Multiple Ping Monitor")
self.Bind(wx.EVT_CLOSE, self.on_close)
self.redraw_timer = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.on_refresh, self.redraw_timer)
self.redraw_timer.Start(1000)
dispatcher.connect(self.list_update,
signal='Ping Model Update',
sender=dispatcher.Any)
def __init__(self, *args, **kwargs):
self._set_ref_object(Scraper, **kwargs)
self.scraper = self.ref_object
self._set_config(**kwargs)
if self.scraper.checker_set.count() == 0:
msg = "No checkers defined for scraper!"
logging.error(msg)
raise CloseSpider(msg)
for checker in self.scraper.checker_set.all():
if checker.checker_type == '4':
if not checker.checker_ref_url:
msg = "Please provide a reference url for your checker ({c}) (Command: {cr}).".format(c=str(checker), cr=self.command)
logging.error(msg)
raise CloseSpider(msg)
if checker.checker_type == 'X':
if not checker.checker_x_path or not checker.checker_ref_url:
msg = "Please provide the necessary x_path fields for your checker ({c}) (Command: {cr}).".format(c=str(checker), cr=self.command)
logging.error(msg)
raise CloseSpider(msg)
self._set_request_kwargs()
self._set_meta_splash_args()
dispatcher.connect(self.response_received, signal=signals.response_received)
def __init__(self, value):
"""Initialize the zwave hvac."""
from openzwave.network import ZWaveNetwork
from pydispatch import dispatcher
ZWaveDeviceEntity.__init__(self, value, DOMAIN)
self._node = value.node
self._target_temperature = None
self._current_temperature = None
self._current_operation = None
self._operation_list = None
self._current_operation_state = None
self._current_fan_mode = None
self._fan_list = None
self._current_swing_mode = None
self._swing_list = None
self._unit = None
self._zxt_120 = None
self.update_properties()
# register listener
dispatcher.connect(
self.value_changed, ZWaveNetwork.SIGNAL_VALUE_CHANGED)
# Make sure that we have values for the key before converting to int
if (value.node.manufacturer_id.strip() and
value.node.product_id.strip()):
specific_sensor_key = (int(value.node.manufacturer_id, 16),
int(value.node.product_id, 16),
value.index)
if specific_sensor_key in DEVICE_MAPPINGS:
if DEVICE_MAPPINGS[specific_sensor_key] == WORKAROUND_ZXT_120:
_LOGGER.debug("Remotec ZXT-120 Zwave Thermostat as HVAC")
self._zxt_120 = 1
def __init__(self,refresh_period=REFRESH_PERIOD):
# log
log.info('creating instance')
# store params
self.refresh_period = refresh_period
# initialize parent class
threading.Thread.__init__(self)
# give this thread a name
self.name = 'DataConnector'
# local variables
self.goOn = True
self.dataLock = threading.Lock()
self.udpListeners = {}
self.appIdentifier = AppIdentifier.AppIdentifier()
self.appPayloadParsers = {}
self.appDataPublishers = {}
self.appInjectors = {}
self.mirrorEngine = MirrorEngine.MirrorEngine()
self.googleSyncEngine = GoogleSyncEngine.GoogleSyncEngine()
self.xivelySyncEngine = XivelySyncEngine.XivelySyncEngine()
# connect to dispatcher
dispatcher.connect(
self.tearDown,
signal = 'tearDown',
weak = False,
)
# start itself
self.start()
def __init__(self, playerOne=None, playerTwo=None):
"""Inits an instance of the Game class.
PlayerOne is always the human side of the game.
Args:
playerOne (Optional[model.player.Player]):
The human player (default is None).
playerTwo (Optional[model.player.Player]):
The AI player (default is None).
"""
self.playerOne = playerOne
self.playerTwo = playerTwo
self.listeners = list()
self.aiPlayer = self.playerOne if self.playerOne.isAi \
else self.playerTwo
self._board = Board()
self._uuid = None
self._moves = list()
self.status = Status.InProgress
self.nextPlayer = self.playerOne
dispatcher.connect(self._onAiMoveResponse, signal=Events.aiResponse)
def inspectDisplay(self, display):
# Object inspectors are supposed to work purely at the network/biological layer so they don't need to know what the display is.
self.display = display
self.objects = ObjectList()
self.updatingObjects = False
for visible in display.selection():
if visible.client.__class__ == self.__class__.objectClass():
self.objects.append(visible.client)
dispatcher.connect(self.nameChanged, ('set', 'name'), visible.client)
for attributePath in self.inspectedAttributes():
if '.' in attributePath:
(subObject, attribute) = attributePath.split('.')
object = getattr(visible.client, subObject)
else:
object = visible.client
attribute = attributePath
dispatcher.connect(self.inspectedAttributeChanged, ('set', attribute), object)
# Set the icon
image = self.objects[0].__class__.image()
if image == None:
pass
else:
scaledImage = image.Rescale(32, 32, wx.IMAGE_QUALITY_HIGH)
self.iconField.SetBitmap(wx.BitmapFromImage(scaledImage))
self.populateNameField()
self.populateObjectSizer()
self._window.Layout()
def __init__ (self, type=None, *args, **kwargs):
self.type = type
self.kind = self.type.lower()
super(Session, self).__init__(*args, **kwargs)
dispatcher.connect(self.initialize, signals.session_created, sender=self)
self.active = 0
logging.debug("Created new session: %s" % self.name)
def register(self, callback, event, sender=dispatcher.Any, weak=True, expiry=-1, priority=dispatcher.LOWEST_PRIORITY):
# register to receive events
# if expiry == -1, then it is continuous, otherwise number is the number of times
# that the callback is processed
# XXX Major python problem - each callback must be a separate function (or wrapped in a lambda)
# which makes it hard to disconnect it
dispatcher.connect(callback, signal=event, sender=sender,weak=weak,expiry=expiry,priority=priority)
def __init__(self, jobs_root_path, jobs_loader):
self.control_threads = {}
self.jobs_loader = jobs_loader
self.job_configs = jobs_loader.get_jobs()
self.jobs_root_path = jobs_root_path
dispatcher.connect(self.handle_job_signal, signal=JOB_COMMAND_SIGNAL, sender=dispatcher.Any)
dispatcher.connect(self.handle_generic_signal, signal=COMMAND_SIGNAL, sender=dispatcher.Any)
def test_signal(self):
'''
Test if setting a value the widget value is changed
:return:
'''
# QT Stuff
app = QApplication([])
view1 = guidatawrapper.GuidataView(viewname='test_signal: Change one value and apply', qtapp=app)
(data1, widgettype1, widget1) = guidatawrapper.unittest.TestGuidataUtility.create_widget1(value=-2)
view1.addWidgets(widget1)
# prepare signal calls
_viewChanged = [0]
def on_viewUpdated():
_viewChanged[0] = 1
# Connect the signal
dispatcher.connect(on_viewUpdated, signal=view.GenericView.SIGNAL_VIEWUPDATE, sender=view1)
# test by setting directly the value in the dataclass associated to widget
data1[0].value = 2.1
self.assertEqual(_viewChanged[0], 1)
# test the set widget
_viewChanged[0] = 0
widget1[0].setWidgetValue(3)
self.assertEqual(_viewChanged[0], 1)
def registerCallback(
cls,
key,
function = None,
node = None,
capture = 0,
):
"""Register callback function for the given key (possibly node-specific)
key -- as returned by event.getKey()
function -- callable function taking at least an
event object as it's first parameter, or None
node -- the node to be watched, None to register a
context-level callback ( default )
capture -- if true, capture events before passing to
children, rather than processing during the
bubbling phase. (default false)
Note: this method would normally be called by a sub-
class with the calculated key for the sub-class.
return previous callback function or None
"""
previous = cls._removeCurrentCallbacks( key, node=node, capture=capture )
if function is not None:
metaKey = (cls.type,capture,key)
if __debug__:
log.info( """Register(%(capture)s): %(metaKey)r for node %(node)r -> %(function)r"""%locals())
dispatcher.connect( function, sender=node, signal=metaKey )
assert len(dispatcher.getReceivers(
sender=node,
signal=metaKey,
)) == 1, """Have != 1 registered handlers for %(metaKey)r for node %(node)r"""%locals()
return previous
def from_crawler(cls, crawler, *args, **kwargs):
spider = cls(*args, **kwargs)
spider._set_crawler(crawler)
spider._set_ref_object(Scraper, **kwargs)
spider.scraper = spider.ref_object
spider._set_config(**kwargs)
if spider.scraper.checker_set.count() == 0:
msg = "No checkers defined for scraper!"
spider.dds_logger.error(msg)
raise CloseSpider(msg)
for checker in spider.scraper.checker_set.all():
if checker.checker_type == '4':
if not checker.checker_ref_url:
msg = "Please provide a reference url for your checker ({c}).".format(c=str(checker))
spider.dds_logger.error(msg)
raise CloseSpider(msg)
if checker.checker_type == 'X':
if not checker.checker_x_path or not checker.checker_ref_url:
msg = "Please provide the necessary x_path fields for your checker ({c}).".format(c=str(checker))
spider.dds_logger.error(msg)
raise CloseSpider(msg)
spider._set_request_kwargs()
spider._set_meta_splash_args()
dispatcher.connect(spider.response_received, signal=signals.response_received)
return spider
def __init__(self,serialportName,serialportBaudrate):
# log
log.debug("create instance")
# store params
self.serialportName = serialportName
self.serialportBaudrate = serialportBaudrate
# local variables
self.hdlc = OpenHdlc.OpenHdlc()
self.lastRxByte = self.hdlc.HDLC_FLAG
self.busyReceiving = False
self.inputBuf = ''
self.outputBuf = []
self.outputBufLock = threading.RLock()
# initialize the parent class
threading.Thread.__init__(self)
# give this thread a name
self.name = 'moteProbeSerialThread@'+self.serialportName
# connect to dispatcher
dispatcher.connect(
self.send,
signal = 'bytesFromTcpPort'+self.serialportName,
)
def test_000_network_start_stop(self):
self.driver_ready = False
self.driver_removed = False
self.options = ZWaveOption(device=self.device, user_path=self.userpath)
self.options.set_log_file("OZW_Log.log")
self.options.set_append_log_file(False)
self.options.set_console_output(False)
self.options.set_save_log_level("Debug")
self.options.set_logging(True)
self.options.lock()
dispatcher.connect(self.driver_ready_message, ZWaveNetwork.SIGNAL_DRIVER_READY)
dispatcher.connect(self.driver_removed_message, ZWaveNetwork.SIGNAL_DRIVER_REMOVED)
self.network = ZWaveNetwork(self.options)
for i in range(0, SLEEP):
if self.network.state>=self.network.STATE_AWAKED:
break
else:
time.sleep(1.0)
self.assertTrue(self.driver_ready)
self.network.stop()
for i in range(0, SLEEP):
if self.network.state==self.network.STATE_STOPPED:
break
else:
time.sleep(1.0)
self.assertEqual(self.network.state, self.network.STATE_STOPPED)
def connect(self, receiver, sender=Any, weak=True):
"""
Connect receiver to sender for this signal. Wrapper for
:func:`connect`. Usage::
from xyz import post_save
def log_saving_event(**kwargs):
...
# call log_saving_event each time a Note is saved
post_save.connect(log_saving_event, Note)
Publishes a debug log message via Python's `logging` module.
"""
connect(receiver, signal=self, sender=sender, weak=weak)
# Log readable representation of both signal and receiver.
# This is cheap because signals are mostly connected on start.
if hasattr(receiver, '__module__') and hasattr(receiver, '__name__'):
rcvr_repr = u'{0}.{1}'.format(receiver.__module__,
receiver.__name__)
else:
rcvr_repr = unicode(repr(receiver))
logger.debug('Subscribed {rcvr_repr} to "{self}"'.format(**locals()))
def test_910_controller_stats_poll(self):
self.stats_received = None
dispatcher.connect(self.louie_controller_stats, ZWaveController.SIGNAL_CONTROLLER_STATS)
self.network.controller.poll_stats = 8
for i in range(0,10):
#print("self.ctrl_command_result = %s" % self.ctrl_command_result)
if self.stats_received is not None:
break
else:
time.sleep(1.0)
self.assertEqual(type(self.stats_received), type({}))
self.assertTrue('SOFCnt' in self.stats_received)
self.stats_received = None
for i in range(0,10):
#print("self.ctrl_command_result = %s" % self.ctrl_command_result)
if self.stats_received is not None:
break
else:
time.sleep(1.0)
self.assertEqual(type(self.stats_received), type({}))
self.network.controller.poll_stats = 0
self.stats_received = None
for i in range(0,12):
#print("self.ctrl_command_result = %s" % self.ctrl_command_result)
if self.stats_received is not None:
break
else:
time.sleep(1.0)
self.assertEqual(self.stats_received, None)
def set(self, **kwargs):
"""Set configuration parameters.
**kwargs (dict): settings to be sent. Example:
{'setting_1': 'value_1', 'setting_2': 'value_2'}
pause (string): pause status
'pause' = all pause Interfacer fully, nothing read, processed or posted.
'pause' = in pauses the input only, no input read performed
'pause' = out pauses output only, input is read, processed but not posted to buffer
'pause' = off pause is off and Interfacer is fully operational (default)
"""
#def setall(self, **kwargs):
for key, setting in self._defaults.iteritems():
if key in kwargs.keys():
setting = kwargs[key]
else:
setting = self._defaults[key]
if key in self._settings and self._settings[key] == setting:
continue
#self.set(key, setting)
#def set(self, key, setting):
#if key == 'pause' and str(setting).lower() in ['all', 'in', 'out', 'off']:
elif key == 'pause' and str(setting).lower() in [
'all', 'in', 'out', 'off'
]:
pass
elif key == 'interval' and str(setting).isdigit():
pass
elif key == 'nodeoffset' and str(setting).isdigit():
pass
elif key == 'datacode' and str(setting) in [
'0', 'b', 'B', 'h', 'H', 'L', 'l', 'f'
]:
pass
elif key == 'scale' and (int(setting == 1)
or not (int(setting % 10))):
pass
elif key == 'timestamped' and str(setting).lower() in [
'true', 'false'
]:
pass
elif key == 'targeted' and str(setting).lower() in [
'true', 'false'
]:
pass
elif key == 'pubchannels':
pass
elif key == 'subchannels':
pass
# elif key == 'rxchannels' and int(setting) >= 0 and int(setting) < 256:
# pass
# elif key == 'txchannels' and int(setting) >= 0 and int(setting) < 256:
# pass
else:
self._log.warning(
"In interfacer set '%s' is not a valid setting for %s: %s"
% (str(setting), self.name, key))
continue
self._settings[key] = setting
self._log.debug("Setting " + self.name + " " + key + ": " +
str(setting))
# Is there a better place to put this?
for channel in self._settings["subchannels"]:
dispatcher.connect(self.receiver, channel)
self._log.debug("Interfacer: Subscribed to channel' : " +
str(channel))
async def async_setup_entry(hass, config_entry):
"""Set up Z-Wave from a config entry.
Will automatically load components to support devices found on the network.
"""
from pydispatch import dispatcher
# pylint: disable=import-error
from openzwave.option import ZWaveOption
from openzwave.network import ZWaveNetwork
from openzwave.group import ZWaveGroup
# Merge config entry and yaml config
config = config_entry.data
if DATA_ZWAVE_CONFIG in hass.data:
config = {**config, **hass.data[DATA_ZWAVE_CONFIG]}
# Update hass.data with merged config so we can access it elsewhere
hass.data[DATA_ZWAVE_CONFIG] = config
# Load configuration
use_debug = config.get(CONF_DEBUG, DEFAULT_DEBUG)
autoheal = config.get(CONF_AUTOHEAL, DEFAULT_CONF_AUTOHEAL)
device_config = EntityValues(
config.get(CONF_DEVICE_CONFIG),
config.get(CONF_DEVICE_CONFIG_DOMAIN),
config.get(CONF_DEVICE_CONFIG_GLOB),
)
usb_path = config[CONF_USB_STICK_PATH]
_LOGGER.info("Z-Wave USB path is %s", usb_path)
# Setup options
options = ZWaveOption(
usb_path,
user_path=hass.config.config_dir,
config_path=config.get(CONF_CONFIG_PATH),
)
options.set_console_output(use_debug)
if config.get(CONF_NETWORK_KEY):
options.addOption("NetworkKey", config[CONF_NETWORK_KEY])
await hass.async_add_executor_job(options.lock)
network = hass.data[DATA_NETWORK] = ZWaveNetwork(options, autostart=False)
hass.data[DATA_DEVICES] = {}
hass.data[DATA_ENTITY_VALUES] = []
registry = await async_get_registry(hass)
wsapi.async_load_websocket_api(hass)
if use_debug: # pragma: no cover
def log_all(signal, value=None):
"""Log all the signals."""
print("")
print("SIGNAL *****", signal)
if value and signal in (
ZWaveNetwork.SIGNAL_VALUE_CHANGED,
ZWaveNetwork.SIGNAL_VALUE_ADDED,
ZWaveNetwork.SIGNAL_SCENE_EVENT,
ZWaveNetwork.SIGNAL_NODE_EVENT,
ZWaveNetwork.SIGNAL_AWAKE_NODES_QUERIED,
ZWaveNetwork.SIGNAL_ALL_NODES_QUERIED,
ZWaveNetwork.SIGNAL_ALL_NODES_QUERIED_SOME_DEAD,
):
pprint(_obj_to_dict(value))
print("")
dispatcher.connect(log_all, weak=False)
def value_added(node, value):
"""Handle new added value to a node on the network."""
# Check if this value should be tracked by an existing entity
for values in hass.data[DATA_ENTITY_VALUES]:
values.check_value(value)
for schema in DISCOVERY_SCHEMAS:
if not check_node_schema(node, schema):
continue
if not check_value_schema(
value, schema[const.DISC_VALUES][const.DISC_PRIMARY]):
continue
values = ZWaveDeviceEntityValues(hass, schema, value, config,
device_config, registry)
# We create a new list and update the reference here so that
# the list can be safely iterated over in the main thread
new_values = hass.data[DATA_ENTITY_VALUES] + [values]
hass.data[DATA_ENTITY_VALUES] = new_values
platform = EntityPlatform(
hass=hass,
logger=_LOGGER,
domain=DOMAIN,
platform_name=DOMAIN,
platform=None,
scan_interval=DEFAULT_SCAN_INTERVAL,
entity_namespace=None,
async_entities_added_callback=lambda: None,
)
platform.config_entry = config_entry
def node_added(node):
"""Handle a new node on the network."""
entity = ZWaveNodeEntity(node, network)
async def _add_node_to_component():
if hass.data[DATA_DEVICES].get(entity.unique_id):
return
name = node_name(node)
generated_id = generate_entity_id(DOMAIN + ".{}", name, [])
node_config = device_config.get(generated_id)
if node_config.get(CONF_IGNORED):
_LOGGER.info("Ignoring node entity %s due to device settings",
generated_id)
return
hass.data[DATA_DEVICES][entity.unique_id] = entity
await platform.async_add_entities([entity])
if entity.unique_id:
hass.async_add_job(_add_node_to_component())
return
@callback
def _on_ready(sec):
_LOGGER.info("Z-Wave node %d ready after %d seconds",
entity.node_id, sec)
hass.async_add_job(_add_node_to_component)
@callback
def _on_timeout(sec):
_LOGGER.warning(
"Z-Wave node %d not ready after %d seconds, "
"continuing anyway",
entity.node_id,
sec,
)
hass.async_add_job(_add_node_to_component)
hass.add_job(check_has_unique_id, entity, _on_ready, _on_timeout)
def node_removed(node):
node_id = node.node_id
node_key = f"node-{node_id}"
_LOGGER.info("Node Removed: %s", hass.data[DATA_DEVICES][node_key])
for key in list(hass.data[DATA_DEVICES]):
if not key.startswith(f"{node_id}-"):
continue
entity = hass.data[DATA_DEVICES][key]
_LOGGER.info("Removing Entity - value: %s - entity_id: %s", key,
entity.entity_id)
hass.add_job(entity.node_removed())
del hass.data[DATA_DEVICES][key]
entity = hass.data[DATA_DEVICES][node_key]
hass.add_job(entity.node_removed())
del hass.data[DATA_DEVICES][node_key]
def network_ready():
"""Handle the query of all awake nodes."""
_LOGGER.info("Z-Wave network is ready for use. All awake nodes "
"have been queried. Sleeping nodes will be "
"queried when they awake.")
hass.bus.fire(const.EVENT_NETWORK_READY)
def network_complete():
"""Handle the querying of all nodes on network."""
_LOGGER.info("Z-Wave network is complete. All nodes on the network "
"have been queried")
hass.bus.fire(const.EVENT_NETWORK_COMPLETE)
def network_complete_some_dead():
"""Handle the querying of all nodes on network."""
_LOGGER.info("Z-Wave network is complete. All nodes on the network "
"have been queried, but some nodes are marked dead")
hass.bus.fire(const.EVENT_NETWORK_COMPLETE_SOME_DEAD)
dispatcher.connect(value_added,
ZWaveNetwork.SIGNAL_VALUE_ADDED,
weak=False)
dispatcher.connect(node_added, ZWaveNetwork.SIGNAL_NODE_ADDED, weak=False)
dispatcher.connect(node_removed,
ZWaveNetwork.SIGNAL_NODE_REMOVED,
weak=False)
dispatcher.connect(network_ready,
ZWaveNetwork.SIGNAL_AWAKE_NODES_QUERIED,
weak=False)
dispatcher.connect(network_complete,
ZWaveNetwork.SIGNAL_ALL_NODES_QUERIED,
weak=False)
dispatcher.connect(
network_complete_some_dead,
ZWaveNetwork.SIGNAL_ALL_NODES_QUERIED_SOME_DEAD,
weak=False,
)
def add_node(service):
"""Switch into inclusion mode."""
_LOGGER.info("Z-Wave add_node have been initialized")
network.controller.add_node()
def add_node_secure(service):
"""Switch into secure inclusion mode."""
_LOGGER.info("Z-Wave add_node_secure have been initialized")
network.controller.add_node(True)
def remove_node(service):
"""Switch into exclusion mode."""
_LOGGER.info("Z-Wave remove_node have been initialized")
network.controller.remove_node()
def cancel_command(service):
"""Cancel a running controller command."""
_LOGGER.info("Cancel running Z-Wave command")
network.controller.cancel_command()
def heal_network(service):
"""Heal the network."""
_LOGGER.info("Z-Wave heal running")
network.heal()
def soft_reset(service):
"""Soft reset the controller."""
_LOGGER.info("Z-Wave soft_reset have been initialized")
network.controller.soft_reset()
def test_network(service):
"""Test the network by sending commands to all the nodes."""
_LOGGER.info("Z-Wave test_network have been initialized")
network.test()
def stop_network(_service_or_event):
"""Stop Z-Wave network."""
_LOGGER.info("Stopping Z-Wave network")
network.stop()
if hass.state == CoreState.running:
hass.bus.fire(const.EVENT_NETWORK_STOP)
async def rename_node(service):
"""Rename a node."""
node_id = service.data.get(const.ATTR_NODE_ID)
node = network.nodes[node_id]
name = service.data.get(const.ATTR_NAME)
node.name = name
_LOGGER.info("Renamed Z-Wave node %d to %s", node_id, name)
update_ids = service.data.get(const.ATTR_UPDATE_IDS)
# We want to rename the device, the node entity,
# and all the contained entities
node_key = f"node-{node_id}"
entity = hass.data[DATA_DEVICES][node_key]
await entity.node_renamed(update_ids)
for key in list(hass.data[DATA_DEVICES]):
if not key.startswith(f"{node_id}-"):
continue
entity = hass.data[DATA_DEVICES][key]
await entity.value_renamed(update_ids)
async def rename_value(service):
"""Rename a node value."""
node_id = service.data.get(const.ATTR_NODE_ID)
value_id = service.data.get(const.ATTR_VALUE_ID)
node = network.nodes[node_id]
value = node.values[value_id]
name = service.data.get(const.ATTR_NAME)
value.label = name
_LOGGER.info("Renamed Z-Wave value (Node %d Value %d) to %s", node_id,
value_id, name)
update_ids = service.data.get(const.ATTR_UPDATE_IDS)
value_key = f"{node_id}-{value_id}"
entity = hass.data[DATA_DEVICES][value_key]
await entity.value_renamed(update_ids)
def set_poll_intensity(service):
"""Set the polling intensity of a node value."""
node_id = service.data.get(const.ATTR_NODE_ID)
value_id = service.data.get(const.ATTR_VALUE_ID)
node = network.nodes[node_id]
value = node.values[value_id]
intensity = service.data.get(const.ATTR_POLL_INTENSITY)
if intensity == 0:
if value.disable_poll():
_LOGGER.info("Polling disabled (Node %d Value %d)", node_id,
value_id)
return
_LOGGER.info("Polling disabled failed (Node %d Value %d)", node_id,
value_id)
else:
if value.enable_poll(intensity):
_LOGGER.info(
"Set polling intensity (Node %d Value %d) to %s",
node_id,
value_id,
intensity,
)
return
_LOGGER.info("Set polling intensity failed (Node %d Value %d)",
node_id, value_id)
def remove_failed_node(service):
"""Remove failed node."""
node_id = service.data.get(const.ATTR_NODE_ID)
_LOGGER.info("Trying to remove zwave node %d", node_id)
network.controller.remove_failed_node(node_id)
def replace_failed_node(service):
"""Replace failed node."""
node_id = service.data.get(const.ATTR_NODE_ID)
_LOGGER.info("Trying to replace zwave node %d", node_id)
network.controller.replace_failed_node(node_id)
def set_config_parameter(service):
"""Set a config parameter to a node."""
node_id = service.data.get(const.ATTR_NODE_ID)
node = network.nodes[node_id]
param = service.data.get(const.ATTR_CONFIG_PARAMETER)
selection = service.data.get(const.ATTR_CONFIG_VALUE)
size = service.data.get(const.ATTR_CONFIG_SIZE)
for value in node.get_values(
class_id=const.COMMAND_CLASS_CONFIGURATION).values():
if value.index != param:
continue
if value.type == const.TYPE_BOOL:
value.data = int(selection == "True")
_LOGGER.info(
"Setting config parameter %s on Node %s "
"with bool selection %s",
param,
node_id,
str(selection),
)
return
if value.type == const.TYPE_LIST:
value.data = str(selection)
_LOGGER.info(
"Setting config parameter %s on Node %s "
"with list selection %s",
param,
node_id,
str(selection),
)
return
if value.type == const.TYPE_BUTTON:
network.manager.pressButton(value.value_id)
network.manager.releaseButton(value.value_id)
_LOGGER.info(
"Setting config parameter %s on Node %s "
"with button selection %s",
param,
node_id,
selection,
)
return
value.data = int(selection)
_LOGGER.info(
"Setting config parameter %s on Node %s "
"with selection %s",
param,
node_id,
selection,
)
return
node.set_config_param(param, selection, size)
_LOGGER.info(
"Setting unknown config parameter %s on Node %s "
"with selection %s",
param,
node_id,
selection,
)
def refresh_node_value(service):
"""Refresh the specified value from a node."""
node_id = service.data.get(const.ATTR_NODE_ID)
value_id = service.data.get(const.ATTR_VALUE_ID)
node = network.nodes[node_id]
node.values[value_id].refresh()
_LOGGER.info("Node %s value %s refreshed", node_id, value_id)
def set_node_value(service):
"""Set the specified value on a node."""
node_id = service.data.get(const.ATTR_NODE_ID)
value_id = service.data.get(const.ATTR_VALUE_ID)
value = service.data.get(const.ATTR_CONFIG_VALUE)
node = network.nodes[node_id]
node.values[value_id].data = value
_LOGGER.info("Node %s value %s set to %s", node_id, value_id, value)
def print_config_parameter(service):
"""Print a config parameter from a node."""
node_id = service.data.get(const.ATTR_NODE_ID)
node = network.nodes[node_id]
param = service.data.get(const.ATTR_CONFIG_PARAMETER)
_LOGGER.info(
"Config parameter %s on Node %s: %s",
param,
node_id,
get_config_value(node, param),
)
def print_node(service):
"""Print all information about z-wave node."""
node_id = service.data.get(const.ATTR_NODE_ID)
node = network.nodes[node_id]
nice_print_node(node)
def set_wakeup(service):
"""Set wake-up interval of a node."""
node_id = service.data.get(const.ATTR_NODE_ID)
node = network.nodes[node_id]
value = service.data.get(const.ATTR_CONFIG_VALUE)
if node.can_wake_up():
for value_id in node.get_values(
class_id=const.COMMAND_CLASS_WAKE_UP):
node.values[value_id].data = value
_LOGGER.info("Node %s wake-up set to %d", node_id, value)
else:
_LOGGER.info("Node %s is not wakeable", node_id)
def change_association(service):
"""Change an association in the zwave network."""
association_type = service.data.get(const.ATTR_ASSOCIATION)
node_id = service.data.get(const.ATTR_NODE_ID)
target_node_id = service.data.get(const.ATTR_TARGET_NODE_ID)
group = service.data.get(const.ATTR_GROUP)
instance = service.data.get(const.ATTR_INSTANCE)
node = ZWaveGroup(group, network, node_id)
if association_type == "add":
node.add_association(target_node_id, instance)
_LOGGER.info(
"Adding association for node:%s in group:%s "
"target node:%s, instance=%s",
node_id,
group,
target_node_id,
instance,
)
if association_type == "remove":
node.remove_association(target_node_id, instance)
_LOGGER.info(
"Removing association for node:%s in group:%s "
"target node:%s, instance=%s",
node_id,
group,
target_node_id,
instance,
)
async def async_refresh_entity(service):
"""Refresh values that specific entity depends on."""
entity_id = service.data.get(ATTR_ENTITY_ID)
async_dispatcher_send(hass,
SIGNAL_REFRESH_ENTITY_FORMAT.format(entity_id))
def refresh_node(service):
"""Refresh all node info."""
node_id = service.data.get(const.ATTR_NODE_ID)
node = network.nodes[node_id]
node.refresh_info()
def reset_node_meters(service):
"""Reset meter counters of a node."""
node_id = service.data.get(const.ATTR_NODE_ID)
instance = service.data.get(const.ATTR_INSTANCE)
node = network.nodes[node_id]
for value in node.get_values(
class_id=const.COMMAND_CLASS_METER).values():
if value.index != const.INDEX_METER_RESET:
continue
if value.instance != instance:
continue
network.manager.pressButton(value.value_id)
network.manager.releaseButton(value.value_id)
_LOGGER.info("Resetting meters on node %s instance %s....",
node_id, instance)
return
_LOGGER.info(
"Node %s on instance %s does not have resettable "
"meters.",
node_id,
instance,
)
def heal_node(service):
"""Heal a node on the network."""
node_id = service.data.get(const.ATTR_NODE_ID)
update_return_routes = service.data.get(const.ATTR_RETURN_ROUTES)
node = network.nodes[node_id]
_LOGGER.info("Z-Wave node heal running for node %s", node_id)
node.heal(update_return_routes)
def test_node(service):
"""Send test messages to a node on the network."""
node_id = service.data.get(const.ATTR_NODE_ID)
messages = service.data.get(const.ATTR_MESSAGES)
node = network.nodes[node_id]
_LOGGER.info("Sending %s test-messages to node %s.", messages, node_id)
node.test(messages)
def start_zwave(_service_or_event):
"""Startup Z-Wave network."""
_LOGGER.info("Starting Z-Wave network...")
network.start()
hass.bus.fire(const.EVENT_NETWORK_START)
async def _check_awaked():
"""Wait for Z-wave awaked state (or timeout) and finalize start."""
_LOGGER.debug("network state: %d %s", network.state,
network.state_str)
start_time = dt_util.utcnow()
while True:
waited = int((dt_util.utcnow() - start_time).total_seconds())
if network.state >= network.STATE_AWAKED:
# Need to be in STATE_AWAKED before talking to nodes.
_LOGGER.info("Z-Wave ready after %d seconds", waited)
break
elif waited >= const.NETWORK_READY_WAIT_SECS:
# Wait up to NETWORK_READY_WAIT_SECS seconds for the Z-Wave
# network to be ready.
_LOGGER.warning(
"Z-Wave not ready after %d seconds, continuing anyway",
waited)
_LOGGER.info("final network state: %d %s", network.state,
network.state_str)
break
else:
await asyncio.sleep(1)
hass.async_add_job(_finalize_start)
hass.add_job(_check_awaked)
def _finalize_start():
"""Perform final initializations after Z-Wave network is awaked."""
polling_interval = convert(config.get(CONF_POLLING_INTERVAL), int)
if polling_interval is not None:
network.set_poll_interval(polling_interval, False)
poll_interval = network.get_poll_interval()
_LOGGER.info("Z-Wave polling interval set to %d ms", poll_interval)
hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, stop_network)
# Register node services for Z-Wave network
hass.services.register(DOMAIN, const.SERVICE_ADD_NODE, add_node)
hass.services.register(DOMAIN, const.SERVICE_ADD_NODE_SECURE,
add_node_secure)
hass.services.register(DOMAIN, const.SERVICE_REMOVE_NODE, remove_node)
hass.services.register(DOMAIN, const.SERVICE_CANCEL_COMMAND,
cancel_command)
hass.services.register(DOMAIN, const.SERVICE_HEAL_NETWORK,
heal_network)
hass.services.register(DOMAIN, const.SERVICE_SOFT_RESET, soft_reset)
hass.services.register(DOMAIN, const.SERVICE_TEST_NETWORK,
test_network)
hass.services.register(DOMAIN, const.SERVICE_STOP_NETWORK,
stop_network)
hass.services.register(DOMAIN,
const.SERVICE_RENAME_NODE,
rename_node,
schema=RENAME_NODE_SCHEMA)
hass.services.register(DOMAIN,
const.SERVICE_RENAME_VALUE,
rename_value,
schema=RENAME_VALUE_SCHEMA)
hass.services.register(
DOMAIN,
const.SERVICE_SET_CONFIG_PARAMETER,
set_config_parameter,
schema=SET_CONFIG_PARAMETER_SCHEMA,
)
hass.services.register(
DOMAIN,
const.SERVICE_SET_NODE_VALUE,
set_node_value,
schema=SET_NODE_VALUE_SCHEMA,
)
hass.services.register(
DOMAIN,
const.SERVICE_REFRESH_NODE_VALUE,
refresh_node_value,
schema=REFRESH_NODE_VALUE_SCHEMA,
)
hass.services.register(
DOMAIN,
const.SERVICE_PRINT_CONFIG_PARAMETER,
print_config_parameter,
schema=PRINT_CONFIG_PARAMETER_SCHEMA,
)
hass.services.register(
DOMAIN,
const.SERVICE_REMOVE_FAILED_NODE,
remove_failed_node,
schema=NODE_SERVICE_SCHEMA,
)
hass.services.register(
DOMAIN,
const.SERVICE_REPLACE_FAILED_NODE,
replace_failed_node,
schema=NODE_SERVICE_SCHEMA,
)
hass.services.register(
DOMAIN,
const.SERVICE_CHANGE_ASSOCIATION,
change_association,
schema=CHANGE_ASSOCIATION_SCHEMA,
)
hass.services.register(DOMAIN,
const.SERVICE_SET_WAKEUP,
set_wakeup,
schema=SET_WAKEUP_SCHEMA)
hass.services.register(DOMAIN,
const.SERVICE_PRINT_NODE,
print_node,
schema=NODE_SERVICE_SCHEMA)
hass.services.register(
DOMAIN,
const.SERVICE_REFRESH_ENTITY,
async_refresh_entity,
schema=REFRESH_ENTITY_SCHEMA,
)
hass.services.register(DOMAIN,
const.SERVICE_REFRESH_NODE,
refresh_node,
schema=NODE_SERVICE_SCHEMA)
hass.services.register(
DOMAIN,
const.SERVICE_RESET_NODE_METERS,
reset_node_meters,
schema=RESET_NODE_METERS_SCHEMA,
)
hass.services.register(
DOMAIN,
const.SERVICE_SET_POLL_INTENSITY,
set_poll_intensity,
schema=SET_POLL_INTENSITY_SCHEMA,
)
hass.services.register(DOMAIN,
const.SERVICE_HEAL_NODE,
heal_node,
schema=HEAL_NODE_SCHEMA)
hass.services.register(DOMAIN,
const.SERVICE_TEST_NODE,
test_node,
schema=TEST_NODE_SCHEMA)
# Setup autoheal
if autoheal:
_LOGGER.info("Z-Wave network autoheal is enabled")
async_track_time_change(hass, heal_network, hour=0, minute=0, second=0)
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_START, start_zwave)
hass.services.async_register(DOMAIN, const.SERVICE_START_NETWORK,
start_zwave)
for entry_component in SUPPORTED_PLATFORMS:
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(
config_entry, entry_component))
return True
def louie_network_ready(network):
L.l.info(
'Louie signal: ZWave network is ready : {} nodes were found.'.format(
network.nodes_count))
L.l.info('Louie signal: Controller : {}'.format(network.controller))
dispatcher.connect(louie_node_update, ZWaveNetwork.SIGNAL_NODE)
# dispatcher.connect(louie_value, ZWaveNetwork.SIGNAL_VALUE)
dispatcher.connect(louie_value_refreshed,
ZWaveNetwork.SIGNAL_VALUE_REFRESHED)
dispatcher.connect(louie_value_added, ZWaveNetwork.SIGNAL_VALUE_ADDED)
dispatcher.connect(louie_value_changed, ZWaveNetwork.SIGNAL_VALUE_CHANGED)
dispatcher.connect(louie_value_removed, ZWaveNetwork.SIGNAL_VALUE_REMOVED)
dispatcher.connect(louie_ctrl_message, ZWaveController.SIGNAL_CONTROLLER)
dispatcher.connect(louie_button_on, ZWaveNetwork.SIGNAL_BUTTON_ON)
dispatcher.connect(louie_button_off, ZWaveNetwork.SIGNAL_BUTTON_OFF)
dispatcher.connect(louie_node_event, ZWaveNetwork.SIGNAL_NODE_EVENT)
dispatcher.connect(louie_node_event, ZWaveNetwork.SIGNAL_NODE_ADDED)
dispatcher.connect(louie_node_event, ZWaveNetwork.SIGNAL_NODE_NEW)
dispatcher.connect(louie_scene_event, ZWaveNetwork.SIGNAL_SCENE_EVENT)
def __init__(self, **kwargs):
"""Attrs initialized here have names as in :dict:`_initials`
Doctests
++++++++
>>> t.start()
(True, 'OK')
# >>> t.hard_reset(force=True)
# (True, 'OK')
# >>> print("*** Action needed for node to be _added_ ***") # doctest:+ELLIPSIS
# *** ...
# >>> t.add_node() # doctest:+ELLIPSIS
# {...}
"""
if self._initialized:
raise RuntimeErr("[Bug] backend already initialized!?")
self._initialized = True
# set defaults
for attr in self._initials.keys():
setattr(self, attr, self._initials[attr])
# ...remainder.
for k in kwargs.keys():
if not hasattr(self, k):
raise AttributeError(
"{}: no such attribute in definition of class {}.".format(
k, self.__class__.__name__))
else:
setattr(self, k, kwargs[k])
# we put all artifacts here
user_path = os.path.expanduser(os.path.expandvars(self.ozw_user_path))
try:
os.makedirs(self.ozw_user_path, exist_ok=True)
except Exception as e:
raise RuntimeError("Can't create user_path: {}".format(e))
self.logger = logging.getLogger(__name__)
self.logger.setLevel(self.log_level)
fh = logging.FileHandler("{}/{}.log".format(self.ozw_user_path,
__name__),
mode='w')
fh.setLevel(self.log_level)
fh.setFormatter(
logging.Formatter(self.log_format_dbg if self.log_level <= logging.
DEBUG else self.log_format))
self.logger.addHandler(fh)
self.logger.debug('initializing OZW backend...')
options = ZWaveOption(self.device,
config_path=self.ozw_config_path,
user_path=self.ozw_user_path)
options.set_log_file('OZW.log')
options.set_append_log_file(False)
options.set_console_output(False)
options.set_save_log_level(
'Debug' if self.log_level <= logging.DEBUG else 'Warning')
options.set_logging(True)
options.lock()
self.network = ZWaveNetwork(options, autostart=False)
# A dispatcher associates a callback method to a signal. Signals
# are generated by the library python-openzwave. Once a signal is
# received, its associated callback is executed (see "_node_added"
# example below in "_network_started" method)
dispatcher.connect(self._network_started,
ZWaveNetwork.SIGNAL_NETWORK_STARTED)
dispatcher.connect(self._network_ready,
ZWaveNetwork.SIGNAL_NETWORK_READY)
# Yep! It's really 'RESETTED', wanna file a bug for bad english usage? ;-)
dispatcher.connect(self._network_reset,
ZWaveNetwork.SIGNAL_NETWORK_RESETTED)
# dynamically set on add/remove events. See notification handlers below.
self.node_added = None
self.node_removed = None
self.timestamps = {
} # times of the last values' update for each sensor
# The different stages that a node object gets through before being
# ready. [BUG] Why do we need to explicitly list them? Anyway to get
# them from the lib?
self.queryStages = {
"None": 1, # Query process hasn't started for this node
"ProtocolInfo": 2, # Retrieve protocol information
"Probe": 3, # Ping node to see if alive
"WakeUp": 4, # Start wake up process if a sleeping node
"ManufacturerSpecific1":
5, # Retrieve manufacturer name and product ids if ProtocolInfo lets us
"NodeInfo":
6, # Retrieve info about supported, controlled command classes
"NodePlusInfo":
7, # Retrieve Z-Wave+ info and update device classes (Added by Edin et Daniel)
"SecurityReport":
8, # Retrieve a list of Command Classes that require Security
"ManufacturerSpecific2":
9, # Retrieve manufacturer name and product ids
"Versions": 10, # Retrieve version information
"Instances":
11, # Retrieve information about multiple command class instances
"Static": 12, # Retrieve static information (doesn't change)
"Probe1": 13, # Ping a node upon starting with configuration
"Associations": 14, # Retrieve information about associations
"Neighbors": 15, # Retrieve node neighbor list
"Session":
16, # Retrieve session information (changes infrequently)
"Dynamic": 17, # Retrieve dynamic information (changes frequently)
"Configuration":
18, # Retrieve configurable parameter information (only done on request)
"Complete": 19 # Query process is completed for this node
}
def setup(hass, config):
"""
Setup Z-wave.
Will automatically load components to support devices found on the network.
"""
# pylint: disable=global-statement, import-error
global NETWORK
from pydispatch import dispatcher
from openzwave.option import ZWaveOption
from openzwave.network import ZWaveNetwork
# Load configuration
use_debug = str(config[DOMAIN].get(CONF_DEBUG)) == '1'
customize = config[DOMAIN].get(CONF_CUSTOMIZE, {})
# Setup options
options = ZWaveOption(
config[DOMAIN].get(CONF_USB_STICK_PATH, DEFAULT_CONF_USB_STICK_PATH),
user_path=hass.config.config_dir,
config_path=config[DOMAIN].get('config_path',
DEFAULT_ZWAVE_CONFIG_PATH),
)
options.set_console_output(use_debug)
options.lock()
NETWORK = ZWaveNetwork(options, autostart=False)
if use_debug:
def log_all(signal, value=None):
""" Log all the signals. """
print("")
print("SIGNAL *****", signal)
if value and signal in (ZWaveNetwork.SIGNAL_VALUE_CHANGED,
ZWaveNetwork.SIGNAL_VALUE_ADDED):
pprint(_obj_to_dict(value))
print("")
dispatcher.connect(log_all, weak=False)
def value_added(node, value):
""" Called when a value is added to a node on the network. """
for (component, discovery_service, command_ids, value_type,
value_genre) in DISCOVERY_COMPONENTS:
if value.command_class not in command_ids:
continue
if value_type is not None and value_type != value.type:
continue
if value_genre is not None and value_genre != value.genre:
continue
# Ensure component is loaded
bootstrap.setup_component(hass, component, config)
# Configure node
name = "{}.{}".format(component, _object_id(value))
node_config = customize.get(name, {})
polling_intensity = convert(
node_config.get(CONF_POLLING_INTENSITY), int)
if polling_intensity is not None:
value.enable_poll(polling_intensity)
# Fire discovery event
hass.bus.fire(
EVENT_PLATFORM_DISCOVERED, {
ATTR_SERVICE: discovery_service,
ATTR_DISCOVERED: {
ATTR_NODE_ID: node.node_id,
ATTR_VALUE_ID: value.value_id,
}
})
def scene_activated(node, scene_id):
""" Called when a scene is activated on any node in the network. """
name = _node_name(node)
object_id = "{}_{}".format(slugify(name), node.node_id)
hass.bus.fire(EVENT_SCENE_ACTIVATED, {
ATTR_ENTITY_ID: object_id,
ATTR_SCENE_ID: scene_id
})
dispatcher.connect(value_added,
ZWaveNetwork.SIGNAL_VALUE_ADDED,
weak=False)
dispatcher.connect(scene_activated,
ZWaveNetwork.SIGNAL_SCENE_EVENT,
weak=False)
def add_node(event):
""" Switch into inclusion mode """
NETWORK.controller.begin_command_add_device()
def remove_node(event):
""" Switch into exclusion mode"""
NETWORK.controller.begin_command_remove_device()
def stop_zwave(event):
""" Stop Z-wave. """
NETWORK.stop()
def start_zwave(event):
""" Called when Home Assistant starts up. """
NETWORK.start()
polling_interval = convert(config[DOMAIN].get(CONF_POLLING_INTERVAL),
int)
if polling_interval is not None:
NETWORK.set_poll_interval(polling_interval, False)
hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, stop_zwave)
# register add / remove node services for zwave sticks without
# hardware inclusion button
hass.services.register(DOMAIN, SERVICE_ADD_NODE, add_node)
hass.services.register(DOMAIN, SERVICE_REMOVE_NODE, remove_node)
hass.bus.listen_once(EVENT_HOMEASSISTANT_START, start_zwave)
return True
def __init__(self, parent):
StatusBar.__init__(self, parent)
connect(self.update, signal='status_update', sender=Any)
connect(self.clear, signal='status_clear', sender=Any)
def __init__(self, redis_host, redis_port, *args, **kwargs):
super(HistoricSoldURLCollector, self).__init__()
self.sold_age = kwargs.get('SOLD_AGE', '12m')
self.max_locations_per_run = int(kwargs.get('MAX_LOC_PER_RUN', 5))
self.redis = self._connect_to_redis(redis_host, redis_port)
dispatcher.connect(self.spider_closed, signals.spider_closed)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.items = []
dispatcher.connect(self.load_asin, signals.engine_started)
def __init__(self, flask_app, socket_io):
dispatcher.connect(self.taking_image,
signal=CarStatus.TAKING_IMAGE,
sender=dispatcher.Any)
dispatcher.connect(self.image_taken,
signal=CarStatus.IMAGE_TAKEN,
sender=dispatcher.Any)
dispatcher.connect(self.uploading_image,
signal=CarStatus.UPLOADING_IMAGE,
sender=dispatcher.Any)
dispatcher.connect(self.image_uploaded,
signal=CarStatus.IMAGE_UPLOADED,
sender=dispatcher.Any)
dispatcher.connect(self.analysing_image,
signal=CarStatus.ANALYSING_IMAGE,
sender=dispatcher.Any)
dispatcher.connect(self.traffic_light_detected,
signal=CarStatus.TRAFFIC_LIGHT_DETECTED,
sender=dispatcher.Any)
dispatcher.connect(self.traffic_light_not_present,
signal=CarStatus.TRAFFIC_LIGHT_NOT_PRESENT,
sender=dispatcher.Any)
dispatcher.connect(self.move_forward,
signal=CarStatus.MOVING_FORWARD,
sender=dispatcher.Any)
dispatcher.connect(self.stopped,
signal=CarStatus.STOPPED,
sender=dispatcher.Any)
self._flaskApp = flask_app
self._socketIo = socket_io
def __init__(self):
dispatcher.connect(self.spider_closed, signals.spider_closed)
def __init__(self):
dispatcher.connect(self._exit, signal=Signals.EXIT, sender=dispatcher.Any)
self._run()
def __init__(self, node, network):
"""Initialize node."""
super().__init__()
from openzwave.network import ZWaveNetwork
from pydispatch import dispatcher
self._network = network
self.node = node
self.node_id = self.node.node_id
self._name = node_name(self.node)
self._product_name = node.product_name
self._manufacturer_name = node.manufacturer_name
self._unique_id = self._compute_unique_id()
self._application_version = None
self._attributes = {}
self.wakeup_interval = None
self.location = None
self.battery_level = None
dispatcher.connect(self.network_node_value_added,
ZWaveNetwork.SIGNAL_VALUE_ADDED)
dispatcher.connect(self.network_node_changed,
ZWaveNetwork.SIGNAL_VALUE_CHANGED)
dispatcher.connect(self.network_node_changed, ZWaveNetwork.SIGNAL_NODE)
dispatcher.connect(self.network_node_changed,
ZWaveNetwork.SIGNAL_NOTIFICATION)
dispatcher.connect(self.network_node_event,
ZWaveNetwork.SIGNAL_NODE_EVENT)
dispatcher.connect(self.network_scene_activated,
ZWaveNetwork.SIGNAL_SCENE_EVENT)
def messageHandler(self, randWakeup):
print("randWakeup = %d at %d\n" % (randWakeup, self.env.now))
dispatcher.connect(self.handler,
signal=TRANSFER_SIGNAL,
sender=TRANSFER_SENDER)
def setup(hass, config):
"""Set up Z-Wave.
Will automatically load components to support devices found on the network.
"""
descriptions = conf_util.load_yaml_config_file(
os.path.join(os.path.dirname(__file__), 'services.yaml'))
from pydispatch import dispatcher
# pylint: disable=import-error
from openzwave.option import ZWaveOption
from openzwave.network import ZWaveNetwork
from openzwave.group import ZWaveGroup
# Load configuration
use_debug = config[DOMAIN].get(CONF_DEBUG)
autoheal = config[DOMAIN].get(CONF_AUTOHEAL)
device_config = EntityValues(config[DOMAIN][CONF_DEVICE_CONFIG],
config[DOMAIN][CONF_DEVICE_CONFIG_DOMAIN],
config[DOMAIN][CONF_DEVICE_CONFIG_GLOB])
new_entity_ids = config[DOMAIN][CONF_NEW_ENTITY_IDS]
if not new_entity_ids:
_LOGGER.warning(
"ZWave entity_ids will soon be changing. To opt in to new "
"entity_ids now, set `new_entity_ids: true` under zwave in your "
"configuration.yaml. See the following blog post for details: "
"https://home-assistant.io/blog/2017/06/15/zwave-entity-ids/")
# Setup options
options = ZWaveOption(config[DOMAIN].get(CONF_USB_STICK_PATH),
user_path=hass.config.config_dir,
config_path=config[DOMAIN].get(CONF_CONFIG_PATH))
options.set_console_output(use_debug)
if CONF_NETWORK_KEY in config[DOMAIN]:
options.addOption("NetworkKey", config[DOMAIN][CONF_NETWORK_KEY])
options.lock()
network = hass.data[DATA_NETWORK] = ZWaveNetwork(options, autostart=False)
hass.data[DATA_DEVICES] = {}
hass.data[DATA_ENTITY_VALUES] = []
if use_debug: # pragma: no cover
def log_all(signal, value=None):
"""Log all the signals."""
print("")
print("SIGNAL *****", signal)
if value and signal in (ZWaveNetwork.SIGNAL_VALUE_CHANGED,
ZWaveNetwork.SIGNAL_VALUE_ADDED,
ZWaveNetwork.SIGNAL_SCENE_EVENT,
ZWaveNetwork.SIGNAL_NODE_EVENT,
ZWaveNetwork.SIGNAL_AWAKE_NODES_QUERIED,
ZWaveNetwork.SIGNAL_ALL_NODES_QUERIED):
pprint(_obj_to_dict(value))
print("")
dispatcher.connect(log_all, weak=False)
def value_added(node, value):
"""Handle new added value to a node on the network."""
# Check if this value should be tracked by an existing entity
for values in hass.data[DATA_ENTITY_VALUES]:
values.check_value(value)
for schema in DISCOVERY_SCHEMAS:
if not check_node_schema(node, schema):
continue
if not check_value_schema(
value, schema[const.DISC_VALUES][const.DISC_PRIMARY]):
continue
values = ZWaveDeviceEntityValues(hass, schema, value, config,
device_config)
# We create a new list and update the reference here so that
# the list can be safely iterated over in the main thread
new_values = hass.data[DATA_ENTITY_VALUES] + [values]
hass.data[DATA_ENTITY_VALUES] = new_values
component = EntityComponent(_LOGGER, DOMAIN, hass)
def node_added(node):
"""Handle a new node on the network."""
entity = ZWaveNodeEntity(node, network, new_entity_ids)
name = node_name(node)
if new_entity_ids:
generated_id = generate_entity_id(DOMAIN + '.{}', name, [])
else:
generated_id = entity.entity_id
node_config = device_config.get(generated_id)
if node_config.get(CONF_IGNORED):
_LOGGER.info("Ignoring node entity %s due to device settings",
generated_id)
return
component.add_entities([entity])
def network_ready():
"""Handle the query of all awake nodes."""
_LOGGER.info("Zwave network is ready for use. All awake nodes "
"have been queried. Sleeping nodes will be "
"queried when they awake.")
hass.bus.fire(const.EVENT_NETWORK_READY)
def network_complete():
"""Handle the querying of all nodes on network."""
_LOGGER.info("Z-Wave network is complete. All nodes on the network "
"have been queried")
hass.bus.fire(const.EVENT_NETWORK_COMPLETE)
dispatcher.connect(value_added,
ZWaveNetwork.SIGNAL_VALUE_ADDED,
weak=False)
dispatcher.connect(node_added, ZWaveNetwork.SIGNAL_NODE_ADDED, weak=False)
dispatcher.connect(network_ready,
ZWaveNetwork.SIGNAL_AWAKE_NODES_QUERIED,
weak=False)
dispatcher.connect(network_complete,
ZWaveNetwork.SIGNAL_ALL_NODES_QUERIED,
weak=False)
def add_node(service):
"""Switch into inclusion mode."""
_LOGGER.info("Z-Wave add_node have been initialized")
network.controller.add_node()
def add_node_secure(service):
"""Switch into secure inclusion mode."""
_LOGGER.info("Z-Wave add_node_secure have been initialized")
network.controller.add_node(True)
def remove_node(service):
"""Switch into exclusion mode."""
_LOGGER.info("Z-Wwave remove_node have been initialized")
network.controller.remove_node()
def cancel_command(service):
"""Cancel a running controller command."""
_LOGGER.info("Cancel running Z-Wave command")
network.controller.cancel_command()
def heal_network(service):
"""Heal the network."""
_LOGGER.info("Z-Wave heal running")
network.heal()
def soft_reset(service):
"""Soft reset the controller."""
_LOGGER.info("Z-Wave soft_reset have been initialized")
network.controller.soft_reset()
def test_network(service):
"""Test the network by sending commands to all the nodes."""
_LOGGER.info("Z-Wave test_network have been initialized")
network.test()
def stop_network(_service_or_event):
"""Stop Z-Wave network."""
_LOGGER.info("Stopping Z-Wave network")
network.stop()
if hass.state == CoreState.running:
hass.bus.fire(const.EVENT_NETWORK_STOP)
def rename_node(service):
"""Rename a node."""
node_id = service.data.get(const.ATTR_NODE_ID)
node = network.nodes[node_id]
name = service.data.get(const.ATTR_NAME)
node.name = name
_LOGGER.info("Renamed Z-Wave node %d to %s", node_id, name)
def rename_value(service):
"""Rename a node value."""
node_id = service.data.get(const.ATTR_NODE_ID)
value_id = service.data.get(const.ATTR_VALUE_ID)
node = network.nodes[node_id]
value = node.values[value_id]
name = service.data.get(const.ATTR_NAME)
value.label = name
_LOGGER.info("Renamed Z-Wave value (Node %d Value %d) to %s", node_id,
value_id, name)
def set_poll_intensity(service):
"""Set the polling intensity of a node value."""
node_id = service.data.get(const.ATTR_NODE_ID)
value_id = service.data.get(const.ATTR_VALUE_ID)
node = network.nodes[node_id]
value = node.values[value_id]
intensity = service.data.get(const.ATTR_POLL_INTENSITY)
if intensity == 0:
if value.disable_poll():
_LOGGER.info("Polling disabled (Node %d Value %d)", node_id,
value_id)
return
_LOGGER.info("Polling disabled failed (Node %d Value %d)", node_id,
value_id)
else:
if value.enable_poll(intensity):
_LOGGER.info("Set polling intensity (Node %d Value %d) to %s",
node_id, value_id, intensity)
return
_LOGGER.info("Set polling intensity failed (Node %d Value %d)",
node_id, value_id)
def remove_failed_node(service):
"""Remove failed node."""
node_id = service.data.get(const.ATTR_NODE_ID)
_LOGGER.info("Trying to remove zwave node %d", node_id)
network.controller.remove_failed_node(node_id)
def replace_failed_node(service):
"""Replace failed node."""
node_id = service.data.get(const.ATTR_NODE_ID)
_LOGGER.info("Trying to replace zwave node %d", node_id)
network.controller.replace_failed_node(node_id)
def set_config_parameter(service):
"""Set a config parameter to a node."""
node_id = service.data.get(const.ATTR_NODE_ID)
node = network.nodes[node_id]
param = service.data.get(const.ATTR_CONFIG_PARAMETER)
selection = service.data.get(const.ATTR_CONFIG_VALUE)
size = service.data.get(const.ATTR_CONFIG_SIZE)
for value in (node.get_values(
class_id=const.COMMAND_CLASS_CONFIGURATION).values()):
if value.index != param:
continue
if value.type in [const.TYPE_LIST, const.TYPE_BOOL]:
value.data = selection
_LOGGER.info(
"Setting config list parameter %s on Node %s "
"with selection %s", param, node_id, selection)
return
value.data = int(selection)
_LOGGER.info(
"Setting config parameter %s on Node %s "
"with selection %s", param, node_id, selection)
return
node.set_config_param(param, selection, size)
_LOGGER.info(
"Setting unknown config parameter %s on Node %s "
"with selection %s", param, node_id, selection)
def print_config_parameter(service):
"""Print a config parameter from a node."""
node_id = service.data.get(const.ATTR_NODE_ID)
node = network.nodes[node_id]
param = service.data.get(const.ATTR_CONFIG_PARAMETER)
_LOGGER.info("Config parameter %s on Node %s: %s", param, node_id,
get_config_value(node, param))
def print_node(service):
"""Print all information about z-wave node."""
node_id = service.data.get(const.ATTR_NODE_ID)
node = network.nodes[node_id]
nice_print_node(node)
def set_wakeup(service):
"""Set wake-up interval of a node."""
node_id = service.data.get(const.ATTR_NODE_ID)
node = network.nodes[node_id]
value = service.data.get(const.ATTR_CONFIG_VALUE)
if node.can_wake_up():
for value_id in node.get_values(
class_id=const.COMMAND_CLASS_WAKE_UP):
node.values[value_id].data = value
_LOGGER.info("Node %s wake-up set to %d", node_id, value)
else:
_LOGGER.info("Node %s is not wakeable", node_id)
def change_association(service):
"""Change an association in the zwave network."""
association_type = service.data.get(const.ATTR_ASSOCIATION)
node_id = service.data.get(const.ATTR_NODE_ID)
target_node_id = service.data.get(const.ATTR_TARGET_NODE_ID)
group = service.data.get(const.ATTR_GROUP)
instance = service.data.get(const.ATTR_INSTANCE)
node = ZWaveGroup(group, network, node_id)
if association_type == 'add':
node.add_association(target_node_id, instance)
_LOGGER.info(
"Adding association for node:%s in group:%s "
"target node:%s, instance=%s", node_id, group, target_node_id,
instance)
if association_type == 'remove':
node.remove_association(target_node_id, instance)
_LOGGER.info(
"Removing association for node:%s in group:%s "
"target node:%s, instance=%s", node_id, group, target_node_id,
instance)
@asyncio.coroutine
def async_refresh_entity(service):
"""Refresh values that specific entity depends on."""
entity_id = service.data.get(ATTR_ENTITY_ID)
async_dispatcher_send(hass,
SIGNAL_REFRESH_ENTITY_FORMAT.format(entity_id))
def refresh_node(service):
"""Refresh all node info."""
node_id = service.data.get(const.ATTR_NODE_ID)
node = network.nodes[node_id]
node.refresh_info()
def reset_node_meters(service):
"""Reset meter counters of a node."""
node_id = service.data.get(const.ATTR_NODE_ID)
instance = service.data.get(const.ATTR_INSTANCE)
node = network.nodes[node_id]
for value in (node.get_values(
class_id=const.COMMAND_CLASS_METER).values()):
if value.index != const.INDEX_METER_RESET:
continue
if value.instance != instance:
continue
network.manager.pressButton(value.value_id)
network.manager.releaseButton(value.value_id)
_LOGGER.info("Resetting meters on node %s instance %s....",
node_id, instance)
return
_LOGGER.info(
"Node %s on instance %s does not have resettable "
"meters.", node_id, instance)
def start_zwave(_service_or_event):
"""Startup Z-Wave network."""
_LOGGER.info("Starting Z-Wave network...")
network.start()
hass.bus.fire(const.EVENT_NETWORK_START)
# Need to be in STATE_AWAKED before talking to nodes.
# Wait up to NETWORK_READY_WAIT_SECS seconds for the zwave network
# to be ready.
for i in range(const.NETWORK_READY_WAIT_SECS):
_LOGGER.debug("network state: %d %s", network.state,
network.state_str)
if network.state >= network.STATE_AWAKED:
_LOGGER.info("Z-Wave ready after %d seconds", i)
break
time.sleep(1)
else:
_LOGGER.warning(
"zwave not ready after %d seconds, continuing anyway",
const.NETWORK_READY_WAIT_SECS)
_LOGGER.info("final network state: %d %s", network.state,
network.state_str)
polling_interval = convert(config[DOMAIN].get(CONF_POLLING_INTERVAL),
int)
if polling_interval is not None:
network.set_poll_interval(polling_interval, False)
poll_interval = network.get_poll_interval()
_LOGGER.info("Z-Wave polling interval set to %d ms", poll_interval)
hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, stop_network)
# Register node services for Z-Wave network
hass.services.register(DOMAIN, const.SERVICE_ADD_NODE, add_node,
descriptions[const.SERVICE_ADD_NODE])
hass.services.register(DOMAIN, const.SERVICE_ADD_NODE_SECURE,
add_node_secure,
descriptions[const.SERVICE_ADD_NODE_SECURE])
hass.services.register(DOMAIN, const.SERVICE_REMOVE_NODE, remove_node,
descriptions[const.SERVICE_REMOVE_NODE])
hass.services.register(DOMAIN, const.SERVICE_CANCEL_COMMAND,
cancel_command,
descriptions[const.SERVICE_CANCEL_COMMAND])
hass.services.register(DOMAIN, const.SERVICE_HEAL_NETWORK,
heal_network,
descriptions[const.SERVICE_HEAL_NETWORK])
hass.services.register(DOMAIN, const.SERVICE_SOFT_RESET, soft_reset,
descriptions[const.SERVICE_SOFT_RESET])
hass.services.register(DOMAIN, const.SERVICE_TEST_NETWORK,
test_network,
descriptions[const.SERVICE_TEST_NETWORK])
hass.services.register(DOMAIN, const.SERVICE_STOP_NETWORK,
stop_network,
descriptions[const.SERVICE_STOP_NETWORK])
hass.services.register(DOMAIN, const.SERVICE_START_NETWORK,
start_zwave,
descriptions[const.SERVICE_START_NETWORK])
hass.services.register(DOMAIN,
const.SERVICE_RENAME_NODE,
rename_node,
descriptions[const.SERVICE_RENAME_NODE],
schema=RENAME_NODE_SCHEMA)
hass.services.register(DOMAIN,
const.SERVICE_RENAME_VALUE,
rename_value,
descriptions[const.SERVICE_RENAME_VALUE],
schema=RENAME_VALUE_SCHEMA)
hass.services.register(
DOMAIN,
const.SERVICE_SET_CONFIG_PARAMETER,
set_config_parameter,
descriptions[const.SERVICE_SET_CONFIG_PARAMETER],
schema=SET_CONFIG_PARAMETER_SCHEMA)
hass.services.register(
DOMAIN,
const.SERVICE_PRINT_CONFIG_PARAMETER,
print_config_parameter,
descriptions[const.SERVICE_PRINT_CONFIG_PARAMETER],
schema=PRINT_CONFIG_PARAMETER_SCHEMA)
hass.services.register(DOMAIN,
const.SERVICE_REMOVE_FAILED_NODE,
remove_failed_node,
descriptions[const.SERVICE_REMOVE_FAILED_NODE],
schema=NODE_SERVICE_SCHEMA)
hass.services.register(DOMAIN,
const.SERVICE_REPLACE_FAILED_NODE,
replace_failed_node,
descriptions[const.SERVICE_REPLACE_FAILED_NODE],
schema=NODE_SERVICE_SCHEMA)
hass.services.register(DOMAIN,
const.SERVICE_CHANGE_ASSOCIATION,
change_association,
descriptions[const.SERVICE_CHANGE_ASSOCIATION],
schema=CHANGE_ASSOCIATION_SCHEMA)
hass.services.register(DOMAIN,
const.SERVICE_SET_WAKEUP,
set_wakeup,
descriptions[const.SERVICE_SET_WAKEUP],
schema=SET_WAKEUP_SCHEMA)
hass.services.register(DOMAIN,
const.SERVICE_PRINT_NODE,
print_node,
descriptions[const.SERVICE_PRINT_NODE],
schema=NODE_SERVICE_SCHEMA)
hass.services.register(DOMAIN,
const.SERVICE_REFRESH_ENTITY,
async_refresh_entity,
descriptions[const.SERVICE_REFRESH_ENTITY],
schema=REFRESH_ENTITY_SCHEMA)
hass.services.register(DOMAIN,
const.SERVICE_REFRESH_NODE,
refresh_node,
descriptions[const.SERVICE_REFRESH_NODE],
schema=NODE_SERVICE_SCHEMA)
hass.services.register(DOMAIN,
const.SERVICE_RESET_NODE_METERS,
reset_node_meters,
descriptions[const.SERVICE_RESET_NODE_METERS],
schema=RESET_NODE_METERS_SCHEMA)
hass.services.register(DOMAIN,
const.SERVICE_SET_POLL_INTENSITY,
set_poll_intensity,
descriptions[const.SERVICE_SET_POLL_INTENSITY],
schema=SET_POLL_INTENSITY_SCHEMA)
# Setup autoheal
if autoheal:
_LOGGER.info("Z-Wave network autoheal is enabled")
track_time_change(hass, heal_network, hour=0, minute=0, second=0)
hass.bus.listen_once(EVENT_HOMEASSISTANT_START, start_zwave)
return True
def __init__(
self,
workflow_id,
phase,
artifacts_dir,
comparison_pairs=None,
show_all_axes=False,
):
"""
This method instantiates an object of type TensorboardSummaryHook. The signature of this method is similar to
that of every other hook. There is one additional parameter called `comparison_pairs` which is meant to
hold a list of lists each containing a pair of input/output names that share the same dimensionality and can be
compared to each other.
A typical use of `comparison_pairs` is when users want to plot a pr_curve or a confusion matrix by comparing
some input with some output. Eg. by comparing the labels with the predictions.
.. code-block:: python
from eisen.utils.logging import TensorboardSummaryHook
workflow = # Eg. An instance of Training workflow
logger = TensorboardSummaryHook(
workflow_id=workflow.id,
phase='Training',
artifacts_dir='/artifacts/dir'
comparison_pairs=[['labels', 'predictions']]
)
:param workflow_id: string containing the workflow id of the workflow being monitored (workflow_instance.id)
:type workflow_id: UUID
:param phase: string containing the name of the phase (training, testing, ...) of the workflow monitored
:type phase: str
:param artifacts_dir: whether the history of all models that were at a certain point the best should be saved
:type artifacts_dir: bool
:param comparison_pairs: list of lists of pairs, which are names of inputs and outputs to be compared directly
:type comparison_pairs: list of lists of strings
:param show_all_axes: whether any volumetric data should be shown as axial + sagittal + coronal
:type show_all_axes: bool
<json>
[
{"name": "comparison_pairs", "type": "list:list:string", "value": ""},
{"name": "show_all_axes", "type": "bool", "value": "false"}
]
</json>
"""
self.workflow_id = workflow_id
self.phase = phase
self.comparison_pairs = comparison_pairs
self.show_all_axes = show_all_axes
if not os.path.exists(artifacts_dir):
raise ValueError("The directory specified to save artifacts does not exist!")
dispatcher.connect(self.end_epoch, signal=EISEN_END_EPOCH_EVENT, sender=workflow_id)
self.artifacts_dir = os.path.join(artifacts_dir, "summaries", phase)
if not os.path.exists(self.artifacts_dir):
os.makedirs(self.artifacts_dir)
self.writer = SummaryWriter(log_dir=self.artifacts_dir)
def subscribe(self, handle_new_gateway):
"""Subscribe to gateway events."""
dispatcher.connect(handle_new_gateway,
signal=AQARA_EVENT_NEW_GATEWAY,
sender=self)
def __init__(self, *a, **kw):
print("derp")
super(infochoice, self).__init__(*a, **kw)
self._data = []
self._headers = set()
dispatcher.connect(self.spider_closed, signals.spider_closed)
def __init__(self, **kwargs):
super(JobsScreen, self).__init__(**kwargs)
dispatcher.connect(self._on_status_update,
"CI_UPDATE",
sender=dispatcher.Any)
def init():
thread_pool.add_interval_callable(thread_run,
run_interval_second=P.interval)
dispatcher.connect(_init_recovery,
signal=Constant.SIGNAL_USB_DEVICE_CHANGE,
sender=dispatcher.Any)
def __init__(self,
version_full,
nobins=False,
restrictions=None,
force_restrictions=False):
self.prefsdir = user_data_dir("HondaECU", "MCUInnovationsInc")
if not os.path.exists(self.prefsdir):
os.makedirs(self.prefsdir)
self.configfile = os.path.join(self.prefsdir, 'hondaecu.ini')
self.config = configparser.ConfigParser()
if os.path.isfile(self.configfile):
self.config.read(self.configfile)
if not "retries" in self.config['DEFAULT']:
self.config['DEFAULT'] = {'retries': '1'}
self.nobins = nobins
self.restrictions = restrictions
self.force_restrictions = force_restrictions
self.run = True
self.active_ftdi_device = None
self.ftdi_devices = {}
self.__clear_data()
if getattr(sys, 'frozen', False):
self.basepath = sys._MEIPASS
else:
self.basepath = os.path.dirname(os.path.realpath(__file__))
self.version_full = version_full
self.version_short = self.version_full.split("-")[0]
self.apps = {
"flash": {
"label": "Flash",
"panel": HondaECU_FlashPanel,
},
# "hrc": {
# "label":"HRC Data Settings",
# "panel":HondaECU_HRCDataSettingsPanel,
# },
"data": {
"label": "Data Logging",
"panel": HondaECU_DatalogPanel,
},
"dtc": {
"label": "Trouble Codes",
"panel": HondaECU_ErrorPanel,
},
}
self.appanels = {}
wx.Frame.__init__(self,
None,
title="HondaECU %s" % (self.version_short),
style=wx.DEFAULT_FRAME_STYLE ^ wx.RESIZE_BORDER,
size=(500, 300))
ib = wx.IconBundle()
ib.AddIcon(os.path.join(self.basepath, "images", "honda.ico"))
self.SetIcons(ib)
self.menubar = wx.MenuBar()
self.SetMenuBar(self.menubar)
fileMenu = wx.Menu()
self.menubar.Append(fileMenu, '&File')
quitItem = wx.MenuItem(fileMenu, wx.ID_EXIT, '&Quit\tCtrl+Q')
self.Bind(wx.EVT_MENU, self.OnClose, quitItem)
fileMenu.Append(quitItem)
helpMenu = wx.Menu()
self.menubar.Append(helpMenu, '&Help')
debugItem = wx.MenuItem(helpMenu, wx.ID_ANY, 'Show debug log')
self.Bind(wx.EVT_MENU, self.OnDebug, debugItem)
helpMenu.Append(debugItem)
helpMenu.AppendSeparator()
detectmapItem = wx.MenuItem(helpMenu, wx.ID_ANY, 'Detect map id')
self.Bind(wx.EVT_MENU, self.OnDetectMap, detectmapItem)
helpMenu.Append(detectmapItem)
checksumItem = wx.MenuItem(helpMenu, wx.ID_ANY,
'Validate bin checksum')
self.Bind(wx.EVT_MENU, self.OnBinChecksum, checksumItem)
helpMenu.Append(checksumItem)
self.statusicons = [
wx.Image(os.path.join(self.basepath, "images/bullet_black.png"),
wx.BITMAP_TYPE_ANY).ConvertToBitmap(),
wx.Image(os.path.join(self.basepath, "images/bullet_yellow.png"),
wx.BITMAP_TYPE_ANY).ConvertToBitmap(),
wx.Image(os.path.join(self.basepath, "images/bullet_green.png"),
wx.BITMAP_TYPE_ANY).ConvertToBitmap(),
wx.Image(os.path.join(self.basepath, "images/bullet_blue.png"),
wx.BITMAP_TYPE_ANY).ConvertToBitmap(),
wx.Image(os.path.join(self.basepath, "images/bullet_purple.png"),
wx.BITMAP_TYPE_ANY).ConvertToBitmap(),
wx.Image(os.path.join(self.basepath, "images/bullet_red.png"),
wx.BITMAP_TYPE_ANY).ConvertToBitmap()
]
self.statusbar = ESB.EnhancedStatusBar(self, -1)
self.SetStatusBar(self.statusbar)
self.statusbar.SetSize((-1, 28))
self.statusicon = wx.StaticBitmap(self.statusbar)
self.statusicon.SetBitmap(self.statusicons[0])
self.ecmidl = wx.StaticText(self.statusbar)
self.flashcountl = wx.StaticText(self.statusbar)
self.dtccountl = wx.StaticText(self.statusbar)
self.statusbar.SetFieldsCount(4)
self.statusbar.SetStatusWidths([32, 170, 130, 110])
self.statusbar.AddWidget(self.statusicon, pos=0)
self.statusbar.AddWidget(self.ecmidl,
pos=1,
horizontalalignment=ESB.ESB_ALIGN_LEFT)
self.statusbar.AddWidget(self.flashcountl,
pos=2,
horizontalalignment=ESB.ESB_ALIGN_LEFT)
self.statusbar.AddWidget(self.dtccountl,
pos=3,
horizontalalignment=ESB.ESB_ALIGN_LEFT)
self.statusbar.SetStatusStyles(
[wx.SB_SUNKEN, wx.SB_SUNKEN, wx.SB_SUNKEN, wx.SB_SUNKEN])
self.outerp = wx.Panel(self)
self.adapterboxp = wx.Panel(self.outerp)
self.adapterboxsizer = wx.StaticBoxSizer(wx.VERTICAL, self.adapterboxp,
"FTDI Devices:")
self.adapterboxp.SetSizer(self.adapterboxsizer)
self.adapterlist = wx.Choice(self.adapterboxp,
wx.ID_ANY,
size=(-1, 32))
self.adapterboxsizer.Add(self.adapterlist,
1,
wx.ALL | wx.EXPAND,
border=10)
self.labelbook = LB.LabelBook(self.outerp,
agwStyle=LB.INB_FIT_LABELTEXT
| LB.INB_LEFT | LB.INB_DRAW_SHADOW
| LB.INB_GRADIENT_BACKGROUND)
self.bookpages = {}
maxdims = [0, 0]
for a, d in self.apps.items():
enablestates = None
if "enable" in self.apps[a]:
enablestates = self.apps[a]["enable"]
self.bookpages[a] = d["panel"](self, a, self.apps[a], enablestates)
x, y = self.bookpages[a].GetSize()
if x > maxdims[0]:
maxdims[0] = x
if y > maxdims[1]:
maxdims[1] = y
self.labelbook.AddPage(self.bookpages[a], d["label"], False)
for k in self.bookpages.keys():
self.bookpages[k].SetMinSize(maxdims)
self.modelp = wx.Panel(self.outerp, style=wx.BORDER_SUNKEN)
self.modelbox = wx.BoxSizer(wx.VERTICAL)
self.modell = wx.StaticText(self.modelp,
label="",
style=wx.ALIGN_CENTRE_HORIZONTAL
| wx.ALIGN_CENTRE_VERTICAL)
self.ecupnl = wx.StaticText(self.modelp,
label="",
style=wx.ALIGN_CENTRE_HORIZONTAL
| wx.ALIGN_CENTRE_VERTICAL)
font1 = self.GetFont().Bold()
font2 = self.GetFont().Bold()
font1.SetPointSize(font1.GetPointSize() * 1.25)
font2.SetPointSize(font2.GetPointSize() * 2)
self.modell.SetFont(font2)
self.ecupnl.SetFont(font1)
self.modelbox.AddSpacer(5)
self.modelbox.Add(self.modell, 0, wx.CENTER)
self.modelbox.Add(self.ecupnl, 0, wx.CENTER)
self.modelbox.AddSpacer(5)
self.modelp.SetSizer(self.modelbox)
self.outersizer = wx.BoxSizer(wx.VERTICAL)
self.outersizer.Add(self.adapterboxp, 0, wx.EXPAND | wx.ALL, 5)
self.outersizer.Add(self.modelp, 0, wx.EXPAND | wx.ALL, 5)
self.outersizer.Add(self.labelbook, 2, wx.EXPAND | wx.ALL, 5)
self.outerp.SetSizer(self.outersizer)
self.mainsizer = wx.BoxSizer(wx.VERTICAL)
self.mainsizer.Add(self.outerp, 1, wx.EXPAND)
self.mainsizer.SetSizeHints(self)
self.SetSizer(self.mainsizer)
self.adapterlist.Bind(wx.EVT_CHOICE, self.OnAdapterSelected)
self.Bind(wx.EVT_CLOSE, self.OnClose)
self.debuglog = HondaECU_LogPanel(self)
dispatcher.connect(self.USBMonitorHandler,
signal="USBMonitor",
sender=dispatcher.Any)
dispatcher.connect(self.AppPanelHandler,
signal="AppPanel",
sender=dispatcher.Any)
dispatcher.connect(self.KlineWorkerHandler,
signal="KlineWorker",
sender=dispatcher.Any)
self.usbmonitor = USBMonitor(self)
self.klineworker = KlineWorker(self)
self.Layout()
self.Center()
self.Show()
self.usbmonitor.start()
self.klineworker.start()
self.powercycle = PowerCycleDialog(None)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.items = {}
self.found = {}
dispatcher.connect(self.init_scrapy, signals.engine_started)
dispatcher.connect(self.close_scrapy, signals.engine_stopped)
def __init__(self,
version_full,
nobins=False,
restrictions=None,
force_restrictions=False):
self.nobins = nobins
self.restrictions = restrictions
self.force_restrictions = force_restrictions
self.run = True
self.active_ftdi_device = None
self.ftdi_devices = {}
self.__clear_data()
if getattr(sys, 'frozen', False):
self.basepath = sys._MEIPASS
else:
self.basepath = os.path.dirname(os.path.realpath(__file__))
self.version_full = version_full
self.version_short = self.version_full.split("-")[0]
self.apps = {
"flash": {
"label":
"Flash",
"icon":
"images/chip2.png",
"conflicts": ["data", "hrc"],
"panel":
HondaECU_FlashPanel,
"disabled":
True,
"enable": [
ECUSTATE.OK, ECUSTATE.RECOVER_OLD, ECUSTATE.RECOVER_NEW,
ECUSTATE.WRITEx00, ECUSTATE.WRITEx30, ECUSTATE.READ
],
},
"tunehelper": {
"label": "Tune",
"icon": "images/bike.png",
"panel": HondaECU_TunePanelHelper,
},
"info": {
"label": "ECU Info",
"icon": "images/info2.png",
"conflicts": ["flash", "hrc"],
"panel": HondaECU_InfoPanel,
},
"data": {
"label": "Data Logging",
"icon": "images/monitor.png",
"conflicts": ["flash", "hrc"],
"panel": HondaECU_DatalogPanel,
"disabled": True,
"enable": [ECUSTATE.OK],
},
"dtc": {
"label": "Trouble Codes",
"icon": "images/warning.png",
"conflicts": ["flash", "hrc"],
"panel": HondaECU_ErrorPanel,
"disabled": True,
"enable": [ECUSTATE.OK],
},
# "hrcsettings": {
# "label":"HRC Settings",
# "icon":"images/cog.png",
# "conflicts":["flash","data","dtc","info"],
# "panel":HondaECU_HRCDataSettingsPanel,
# "disabled":True,
# "enable": [ECUSTATE.OK],
# },
}
self.appanels = {}
wx.Frame.__init__(self,
None,
title="HondaECU %s :: Control Panel" %
(self.version_short),
style=wx.DEFAULT_FRAME_STYLE ^ wx.RESIZE_BORDER,
size=(500, 300))
ib = wx.IconBundle()
ib.AddIcon(os.path.join(self.basepath, "images", "honda.ico"))
self.SetIcons(ib)
self.menubar = wx.MenuBar()
self.SetMenuBar(self.menubar)
fileMenu = wx.Menu()
self.menubar.Append(fileMenu, '&File')
self.devicesMenu = wx.Menu()
fileMenu.AppendSubMenu(self.devicesMenu, "Devices")
fileMenu.AppendSeparator()
quitItem = wx.MenuItem(fileMenu, wx.ID_EXIT, '&Quit\tCtrl+Q')
self.Bind(wx.EVT_MENU, self.OnClose, quitItem)
fileMenu.Append(quitItem)
helpMenu = wx.Menu()
self.menubar.Append(helpMenu, '&Help')
debugItem = wx.MenuItem(helpMenu, wx.ID_ANY, 'Show debug log')
self.Bind(wx.EVT_MENU, self.OnDebug, debugItem)
helpMenu.Append(debugItem)
helpMenu.AppendSeparator()
detectmapItem = wx.MenuItem(helpMenu, wx.ID_ANY, 'Detect map id')
self.Bind(wx.EVT_MENU, self.OnDetectMap, detectmapItem)
helpMenu.Append(detectmapItem)
checksumItem = wx.MenuItem(helpMenu, wx.ID_ANY,
'Validate bin checksum')
self.Bind(wx.EVT_MENU, self.OnBinChecksum, checksumItem)
helpMenu.Append(checksumItem)
self.statusbar = self.CreateStatusBar(1)
self.statusbar.SetSize((-1, 28))
self.statusbar.SetStatusStyles([wx.SB_SUNKEN])
self.SetStatusBar(self.statusbar)
self.outerp = wx.Panel(self)
self.wrappanel = wx.Panel(self.outerp)
wrapsizer = wx.WrapSizer(wx.HORIZONTAL)
self.appbuttons = {}
for a, d in self.apps.items():
icon = wx.Image(os.path.join(self.basepath, d["icon"]),
wx.BITMAP_TYPE_ANY).ConvertToBitmap()
enablestates = None
if "enable" in d:
enablestates = d["enable"]
self.appbuttons[a] = HondaECU_AppButton(a,
enablestates,
self.wrappanel,
wx.ID_ANY,
icon,
label=d["label"])
if "disabled" in d and d["disabled"]:
self.appbuttons[a].Disable()
wrapsizer.Add(self.appbuttons[a], 0)
self.Bind(wx.EVT_BUTTON, self.OnAppButtonClicked,
self.appbuttons[a])
self.wrappanel.SetSizer(wrapsizer)
self.outersizer = wx.BoxSizer(wx.VERTICAL)
self.outersizer.Add(self.wrappanel, 1, wx.EXPAND)
self.outerp.SetSizer(self.outersizer)
self.mainsizer = wx.BoxSizer(wx.VERTICAL)
self.mainsizer.Add(self.outerp, 1, wx.EXPAND)
self.SetSizer(self.mainsizer)
self.Bind(wx.EVT_CLOSE, self.OnClose)
self.debuglog = HondaECU_LogPanel(self)
dispatcher.connect(self.USBMonitorHandler,
signal="USBMonitor",
sender=dispatcher.Any)
dispatcher.connect(self.AppPanelHandler,
signal="AppPanel",
sender=dispatcher.Any)
dispatcher.connect(self.KlineWorkerHandler,
signal="KlineWorker",
sender=dispatcher.Any)
dispatcher.connect(self.TunePanelHelperHandler,
signal="TunePanelHelper",
sender=dispatcher.Any)
self.usbmonitor = USBMonitor(self)
self.klineworker = KlineWorker(self)
self.Layout()
self.mainsizer.Fit(self)
self.Center()
self.Show()
self.usbmonitor.start()
self.klineworker.start()
def _init_controller():
if P.module_imported:
device = '{}{}'.format(P.device, P.device_index)
L.l.info('Zwave initialising on {}'.format(device))
_stop_net()
# Define some manager options
try:
options = ZWaveOption(device,
config_path="../openzwave/config",
user_path=".",
cmd_line="")
options.set_log_file(P.log_file)
options.set_append_log_file(True)
options.set_console_output(False)
# options.set_save_log_level('Debug')
# options.set_save_log_level('Info')
options.set_save_log_level('Warning')
# options.set_save_log_level('Error')
options.set_logging(False)
#options.set_logging(True)
# options.set_poll_interval(5)
options.set_save_configuration(True)
options.lock()
# Create a network object
P.network = ZWaveNetwork(options, log=None, autostart=False)
dispatcher.connect(louie_network_started,
ZWaveNetwork.SIGNAL_NETWORK_STARTED)
dispatcher.connect(louie_network_failed,
ZWaveNetwork.SIGNAL_NETWORK_FAILED)
dispatcher.connect(louie_network_resetted,
ZWaveNetwork.SIGNAL_NETWORK_RESETTED)
dispatcher.connect(louie_network_ready,
ZWaveNetwork.SIGNAL_NETWORK_READY)
dispatcher.connect(louie_network_stopped,
ZWaveNetwork.SIGNAL_NETWORK_STOPPED)
dispatcher.connect(louie_network_awaked,
ZWaveNetwork.SIGNAL_NETWORK_AWAKED)
P.network.start()
L.l.info("Waiting for zwave driver")
for i in range(0, 120):
if P.network.state >= P.network.STATE_STARTED:
L.l.info("Zwave driver started")
break
else:
time.sleep(0.1)
if P.network.state < P.network.STATE_STARTED:
L.l.info(
"Can't initialise zwave driver. Look at the logs in {}".
format(P.log_file))
return False
L.l.info("Home id : {}, Nodes in network : {}".format(
P.network.home_id_str, P.network.nodes_count))
L.l.info("Waiting 120 sec for zwave network to become ready")
for i in range(0, 240):
if P.network.state >= P.network.STATE_READY:
break
else:
time.sleep(0.5)
# L.l.info("state = {}".format(P.network.state))
if not P.network.is_ready:
L.l.info(
"Can't start network! Look at the logs in OZW_Log.log")
P.network.stop()
return False
else:
L.l.info("Zwave network is started!")
# print nodes
for node_id in P.network.nodes:
node = P.network.nodes[node_id]
try:
L.l.info("Node {}={}".format(node_id, node))
# L.l.info("Node {} attrib: model={} man={} prod_name={} prod_id={}".format(
# node_id, node.manufacturer_name, node.product_name, node.product_id))
except Exception as ex:
pass
# not working
# P.network.set_poll_interval(milliseconds=3000, bIntervalBetweenPolls=False)
# P.network.test(1)
variable.USB_PORTS_IN_USE.append(device)
return True
except ZWaveException as ze:
L.l.error('Unable to init zwave, exception={}'.format(ze))
P.device_index += 1
if P.device_index > 3:
P.device_index = 0
return False
def componentComplete(self):
super(Marquee, self).componentComplete()
self.on_show_marquee.connect(self.on_show_marquee_on_ui_thread)
dispatcher.connect(self.on_marquee,
signals.SHOW_MARQUEE,
sender=dispatcher.Any)
dispatcher.connect(louie_value_update, ZWaveNetwork.SIGNAL_VALUE)
def louie_node_update(network, node):
print("Hello from node : {}.".format(node))
def louie_value_update(network, node, value):
print("Hello from value : {}.".format(value))
#Create a network object
network = ZWaveNetwork(options, autostart=False)
# We connect to the louie dispatcher
dispatcher.connect(louie_network_started, ZWaveNetwork.SIGNAL_NETWORK_STARTED)
dispatcher.connect(louie_network_failed, ZWaveNetwork.SIGNAL_NETWORK_FAILED)
dispatcher.connect(louie_network_ready, ZWaveNetwork.SIGNAL_NETWORK_READY)
# Start the network
network.start()
# Wait for network
print("***** Waiting for network to become ready : ")
for i in range(0, 90):
if network.state >= network.STATE_READY:
print("***** Network is ready")
break
else:
sys.stdout.write(".")
sys.stdout.flush()
def subscribe(self, handle_new_device):
"""Subscribe to new device event."""
dispatcher.connect(handle_new_device,
signal=AQARA_EVENT_NEW_DEVICE,
sender=self)
def connect(self, handler, signal, sender=dispatcher.Any, weak=False):
if isinstance(signal, dict):
signal = json.dumps(signal)
logging.getLogger('system').debug(self.id+" connecting signal to handler "+str(signal))
dispatcher.connect(receiver=handler, signal=signal, sender=sender, weak=weak)
def _do_onStartup_DispatchRegistration():
dispatcher.connect(_log_modem_traffic, signal='MODEM_COMMAND')
dispatcher.connect(_log_modem_traffic, signal='MODEM_RESPONSE')
def subscribe_update(self, handle_update):
"""subscribe to sensor update event"""
dispatcher.connect(handle_update, signal=HASS_UPDATE_SIGNAL, sender=self)
def __init__(self):
# 信号量
self.chrome = Chrome_Tool()
super().__init__()
dispatcher.connect(self.spider_closed, signal=signals.spider_closed)
self.number = 1