class TelldusCore(object):
"""The main class for tellcore-py.
Has methods for adding devices and for enumerating controllers, devices and
sensors. Also handles callbacks; both registration and making sure the
callbacks are processed in the main thread instead of the callback thread.
"""
def __init__(self, library_path=None, callback_dispatcher=None):
"""Create a new TelldusCore instance.
Only one instance should be used per program.
:param str library_path: Passed to the :class:`.library.Library`
constructor.
:param str callback_dispatcher: An instance implementing the
:class:`.library.BaseCallbackDispatcher` interface (
e.g. :class:`QueuedCallbackDispatcher` or
:class:`AsyncioCallbackDispatcher`) A callback dispatcher must be
provided if callbacks are to be used.
"""
super(TelldusCore, self).__init__()
self.lib = Library(library_path, callback_dispatcher)
def __getattr__(self, name):
if name == 'callback_dispatcher':
return self.lib.callback_dispatcher
raise AttributeError(name)
def register_device_event(self, callback):
"""Register a new device event callback handler.
See :ref:`event-example` for more information.
:return: the callback id
"""
return self.lib.tdRegisterDeviceEvent(callback)
def register_device_change_event(self, callback):
"""Register a new device change event callback handler.
See :ref:`event-example` for more information.
:return: the callback id
"""
return self.lib.tdRegisterDeviceChangeEvent(callback)
def register_raw_device_event(self, callback):
"""Register a new raw device event callback handler.
See :ref:`event-example` for more information.
:return: the callback id
"""
return self.lib.tdRegisterRawDeviceEvent(callback)
def register_sensor_event(self, callback):
"""Register a new sensor event callback handler.
See :ref:`event-example` for more information.
:return: the callback id
"""
return self.lib.tdRegisterSensorEvent(callback)
def register_controller_event(self, callback):
"""Register a new controller event callback handler.
See :ref:`event-example` for more information.
:return: the callback id
"""
return self.lib.tdRegisterControllerEvent(callback)
def unregister_callback(self, cid):
"""Unregister a callback handler.
:param int id: the callback id as returned from one of the
register_*_event methods.
"""
self.lib.tdUnregisterCallback(cid)
def devices(self):
"""Return all known devices.
:return: list of :class:`Device` or :class:`DeviceGroup` instances.
"""
devices = []
count = self.lib.tdGetNumberOfDevices()
for i in range(count):
device = DeviceFactory(self.lib.tdGetDeviceId(i), lib=self.lib)
devices.append(device)
return devices
def sensors(self):
"""Return all known sensors.
:return: list of :class:`Sensor` instances.
"""
sensors = []
try:
while True:
sensor = self.lib.tdSensor()
sensors.append(Sensor(lib=self.lib, **sensor))
except TelldusError as e:
if e.error != const.TELLSTICK_ERROR_DEVICE_NOT_FOUND:
raise
return sensors
def controllers(self):
"""Return all known controllers.
Requires Telldus core library version >= 2.1.2.
:return: list of :class:`Controller` instances.
"""
controllers = []
try:
while True:
controller = self.lib.tdController()
del controller["name"]
del controller["available"]
controllers.append(Controller(lib=self.lib, **controller))
except TelldusError as e:
if e.error != const.TELLSTICK_ERROR_NOT_FOUND:
raise
return controllers
def add_device(self, name, protocol, model=None, **parameters):
"""Add a new device.
:return: a :class:`Device` or :class:`DeviceGroup` instance.
"""
device = Device(self.lib.tdAddDevice(), lib=self.lib)
try:
device.name = name
device.protocol = protocol
if model:
device.model = model
for key, value in parameters.items():
device.set_parameter(key, value)
# Return correct type
return DeviceFactory(device.id, lib=self.lib)
except Exception:
import sys
exc_info = sys.exc_info()
try:
device.remove()
except:
pass
if "with_traceback" in dir(Exception):
raise exc_info[0].with_traceback(exc_info[1], exc_info[2])
else:
exec("raise exc_info[0], exc_info[1], exc_info[2]")
def add_group(self, name, devices):
"""Add a new device group.
:return: a :class:`DeviceGroup` instance.
"""
device = self.add_device(name, "group")
device.add_to_group(devices)
return device
def send_raw_command(self, command, reserved=0):
"""Send a raw command."""
return self.lib.tdSendRawCommand(command, reserved)
def connect_controller(self, vid, pid, serial):
"""Connect a controller."""
self.lib.tdConnectTellStickController(vid, pid, serial)
def disconnect_controller(self, vid, pid, serial):
"""Disconnect a controller."""
self.lib.tdDisconnectTellStickController(vid, pid, serial)