class XKNX:
"""Class for reading and writing KNX/IP packets."""
# pylint: disable=too-many-instance-attributes
DEFAULT_ADDRESS = '15.15.250'
def __init__(self,
config=None,
loop=None,
own_address=Address(DEFAULT_ADDRESS),
address_format=AddressFormat.LEVEL3,
telegram_received_cb=None,
device_updated_cb=None):
"""Initialize XKNX class."""
# pylint: disable=too-many-arguments
self.devices = Devices()
self.telegrams = asyncio.Queue()
self.loop = loop or asyncio.get_event_loop()
self.sigint_received = asyncio.Event()
self.telegram_queue = TelegramQueue(self)
self.state_updater = None
self.knxip_interface = None
self.started = False
self.address_format = address_format
self.own_address = own_address
self.logger = logging.getLogger('xknx.log')
self.knx_logger = logging.getLogger('xknx.knx')
self.telegram_logger = logging.getLogger('xknx.telegram')
if config is not None:
Config(self).read(config)
if telegram_received_cb is not None:
self.telegram_queue.register_telegram_received_cb(
telegram_received_cb)
if device_updated_cb is not None:
self.devices.register_device_updated_cb(device_updated_cb)
def __del__(self):
"""Destructor. Cleaning up if this was not done before."""
if self.started:
try:
task = self.loop.create_task(self.stop())
self.loop.run_until_complete(task)
except RuntimeError as exp:
self.logger.warning("Could not close loop, reason: %s", exp)
@asyncio.coroutine
def start(self,
state_updater=False,
daemon_mode=False,
connection_config=ConnectionConfig()):
"""Start XKNX module. Connect to KNX/IP devices and start state updater."""
self.knxip_interface = KNXIPInterface(
self, connection_config=connection_config)
yield from self.knxip_interface.start()
yield from self.telegram_queue.start()
if state_updater:
from xknx.core import StateUpdater
self.state_updater = StateUpdater(self)
yield from self.state_updater.start()
if daemon_mode:
yield from self.loop_until_sigint()
self.started = True
@asyncio.coroutine
def join(self):
"""Wait until all telegrams were processed."""
yield from self.telegrams.join()
def _stop_knxip_interface_if_exists(self):
"""Stop KNXIPInterface if initialized."""
if self.knxip_interface is not None:
yield from self.knxip_interface.stop()
self.knxip_interface = None
@asyncio.coroutine
def stop(self):
"""Stop XKNX module."""
yield from self.join()
yield from self.telegram_queue.stop()
yield from self._stop_knxip_interface_if_exists()
self.started = False
@asyncio.coroutine
def loop_until_sigint(self):
"""Loop until Crtl-C was pressed."""
def sigint_handler():
"""End loop."""
self.sigint_received.set()
self.loop.add_signal_handler(signal.SIGINT, sigint_handler)
self.logger.warning('Press Ctrl+C to stop')
yield from self.sigint_received.wait()
class XKNX:
"""Class for reading and writing KNX/IP packets."""
# pylint: disable=too-many-instance-attributes
DEFAULT_ADDRESS = '15.15.250'
DEFAULT_RATE_LIMIT = 20
def __init__(self,
config=None,
loop=None,
own_address=PhysicalAddress(DEFAULT_ADDRESS),
address_format=GroupAddressType.LONG,
telegram_received_cb=None,
device_updated_cb=None,
rate_limit=DEFAULT_RATE_LIMIT,
multicast_group=DEFAULT_MCAST_GRP,
multicast_port=DEFAULT_MCAST_PORT):
"""Initialize XKNX class."""
# pylint: disable=too-many-arguments
self.devices = Devices()
self.telegrams = asyncio.Queue()
self.loop = loop or asyncio.get_event_loop()
self.sigint_received = asyncio.Event()
self.telegram_queue = TelegramQueue(self)
self.state_updater = StateUpdater(self)
self.knxip_interface = None
self.started = asyncio.Event()
self.address_format = address_format
self.own_address = own_address
self.rate_limit = rate_limit
self.multicast_group = multicast_group
self.multicast_port = multicast_port
self.logger = logging.getLogger('xknx.log')
self.knx_logger = logging.getLogger('xknx.knx')
self.telegram_logger = logging.getLogger('xknx.telegram')
self.raw_socket_logger = logging.getLogger('xknx.raw_socket')
self.connection_config = None
self.version = VERSION
if config is not None:
Config(self).read(config)
if telegram_received_cb is not None:
self.telegram_queue.register_telegram_received_cb(telegram_received_cb)
if device_updated_cb is not None:
self.devices.register_device_updated_cb(device_updated_cb)
def __del__(self):
"""Destructor. Cleaning up if this was not done before."""
if self.started.is_set():
try:
task = self.loop.create_task(self.stop())
self.loop.run_until_complete(task)
except RuntimeError as exp:
self.logger.warning("Could not close loop, reason: %s", exp)
async def start(self,
state_updater=False,
daemon_mode=False,
connection_config=None):
"""Start XKNX module. Connect to KNX/IP devices and start state updater."""
if connection_config is None:
if self.connection_config is None:
connection_config = ConnectionConfig()
else:
connection_config = self.connection_config
self.knxip_interface = KNXIPInterface(self, connection_config=connection_config)
self.logger.info('XKNX v%s starting %s connection to KNX bus.',
VERSION, connection_config.connection_type.name.lower())
await self.knxip_interface.start()
await self.telegram_queue.start()
if state_updater:
self.state_updater.start()
self.started.set()
if daemon_mode:
await self.loop_until_sigint()
async def join(self):
"""Wait until all telegrams were processed."""
await self.telegrams.join()
async def _stop_knxip_interface_if_exists(self):
"""Stop KNXIPInterface if initialized."""
if self.knxip_interface is not None:
await self.knxip_interface.stop()
self.knxip_interface = None
async def stop(self):
"""Stop XKNX module."""
self.state_updater.stop()
await self.join()
await self.telegram_queue.stop()
await self._stop_knxip_interface_if_exists()
self.started.clear()
async def loop_until_sigint(self):
"""Loop until Crtl-C was pressed."""
def sigint_handler():
"""End loop."""
self.sigint_received.set()
if platform == "win32":
self.logger.warning('Windows does not support signals')
else:
self.loop.add_signal_handler(signal.SIGINT, sigint_handler)
self.logger.warning('Press Ctrl+C to stop')
await self.sigint_received.wait()
class XKNX:
"""Class for reading and writing KNX/IP packets."""
# pylint: disable=too-many-instance-attributes
DEFAULT_ADDRESS = '15.15.250'
DEFAULT_RATE_LIMIT = 20
def __init__(self,
config=None,
loop=None,
own_address=PhysicalAddress(DEFAULT_ADDRESS),
address_format=GroupAddressType.LONG,
telegram_received_cb=None,
device_updated_cb=None,
rate_limit=DEFAULT_RATE_LIMIT):
"""Initialize XKNX class."""
# pylint: disable=too-many-arguments
self.devices = Devices()
self.telegrams = asyncio.Queue()
self.loop = loop or asyncio.get_event_loop()
self.sigint_received = asyncio.Event()
self.telegram_queue = TelegramQueue(self)
self.state_updater = None
self.knxip_interface = None
self.started = False
self.address_format = address_format
self.own_address = own_address
self.rate_limit = rate_limit
self.logger = logging.getLogger('xknx.log')
self.knx_logger = logging.getLogger('xknx.knx')
self.telegram_logger = logging.getLogger('xknx.telegram')
self.connection_config = None
if config is not None:
Config(self).read(config)
if telegram_received_cb is not None:
self.telegram_queue.register_telegram_received_cb(telegram_received_cb)
if device_updated_cb is not None:
self.devices.register_device_updated_cb(device_updated_cb)
def __del__(self):
"""Destructor. Cleaning up if this was not done before."""
if self.started:
try:
task = self.loop.create_task(self.stop())
self.loop.run_until_complete(task)
except RuntimeError as exp:
self.logger.warning("Could not close loop, reason: %s", exp)
async def start(self,
state_updater=False,
daemon_mode=False,
connection_config=None):
"""Start XKNX module. Connect to KNX/IP devices and start state updater."""
if connection_config is None:
if self.connection_config is None:
connection_config = ConnectionConfig()
else:
connection_config = self.connection_config
self.knxip_interface = KNXIPInterface(self, connection_config=connection_config)
await self.knxip_interface.start()
await self.telegram_queue.start()
if state_updater:
from xknx.core import StateUpdater
self.state_updater = StateUpdater(self)
await self.state_updater.start()
if daemon_mode:
await self.loop_until_sigint()
self.started = True
async def join(self):
"""Wait until all telegrams were processed."""
await self.telegrams.join()
async def _stop_knxip_interface_if_exists(self):
"""Stop KNXIPInterface if initialized."""
if self.knxip_interface is not None:
await self.knxip_interface.stop()
self.knxip_interface = None
async def stop(self):
"""Stop XKNX module."""
await self.join()
await self.telegram_queue.stop()
await self._stop_knxip_interface_if_exists()
self.started = False
async def loop_until_sigint(self):
"""Loop until Crtl-C was pressed."""
def sigint_handler():
"""End loop."""
self.sigint_received.set()
if platform == "win32":
self.logger.warning('Windows does not support signals')
else:
self.loop.add_signal_handler(signal.SIGINT, sigint_handler)
self.logger.warning('Press Ctrl+C to stop')
await self.sigint_received.wait()
class XKNX:
"""Class for reading and writing KNX/IP packets."""
# pylint: disable=too-many-instance-attributes
DEFAULT_ADDRESS = "15.15.250"
DEFAULT_RATE_LIMIT = 20
def __init__(
self,
config=None,
own_address=DEFAULT_ADDRESS,
address_format=GroupAddressType.LONG,
telegram_received_cb=None,
device_updated_cb=None,
rate_limit=DEFAULT_RATE_LIMIT,
multicast_group=DEFAULT_MCAST_GRP,
multicast_port=DEFAULT_MCAST_PORT,
log_directory=None,
state_updater=False,
daemon_mode=False,
connection_config=ConnectionConfig(),
):
"""Initialize XKNX class."""
# pylint: disable=too-many-arguments
self.devices = Devices()
self.telegrams = asyncio.Queue()
self.sigint_received = asyncio.Event()
self.telegram_queue = TelegramQueue(self)
self.state_updater = StateUpdater(self)
self.knxip_interface = None
self.started = asyncio.Event()
self.address_format = address_format
self.own_address = PhysicalAddress(own_address)
self.rate_limit = rate_limit
self.multicast_group = multicast_group
self.multicast_port = multicast_port
self.connection_config = connection_config
self.start_state_updater = state_updater
self.daemon_mode = daemon_mode
self.version = VERSION
if log_directory is not None:
self.setup_logging(log_directory)
if config is not None:
Config(self).read(config)
if telegram_received_cb is not None:
self.telegram_queue.register_telegram_received_cb(
telegram_received_cb)
if device_updated_cb is not None:
self.devices.register_device_updated_cb(device_updated_cb)
def __del__(self):
"""Destructor. Cleaning up if this was not done before."""
if self.started.is_set():
try:
loop = asyncio.get_event_loop()
loop.run_until_complete(self.stop())
except RuntimeError as exp:
logger.warning("Could not close loop, reason: %s", exp)
async def __aenter__(self):
"""Start XKNX from context manager."""
await self.start()
return self
async def __aexit__(self, exc_type, exc, traceback):
"""Stop XKNX from context manager."""
await self.stop()
async def start(self):
"""Start XKNX module. Connect to KNX/IP devices and start state updater."""
self.knxip_interface = KNXIPInterface(
self, connection_config=self.connection_config)
logger.info(
"XKNX v%s starting %s connection to KNX bus.",
VERSION,
self.connection_config.connection_type.name.lower(),
)
await self.knxip_interface.start()
await self.telegram_queue.start()
if self.start_state_updater:
self.state_updater.start()
self.started.set()
if self.daemon_mode:
await self.loop_until_sigint()
async def join(self):
"""Wait until all telegrams were processed."""
await self.telegrams.join()
async def _stop_knxip_interface_if_exists(self):
"""Stop KNXIPInterface if initialized."""
if self.knxip_interface is not None:
await self.knxip_interface.stop()
self.knxip_interface = None
async def stop(self):
"""Stop XKNX module."""
self.state_updater.stop()
await self.join()
await self.telegram_queue.stop()
await self._stop_knxip_interface_if_exists()
self.started.clear()
async def loop_until_sigint(self):
"""Loop until Crtl-C was pressed."""
def sigint_handler():
"""End loop."""
self.sigint_received.set()
if platform == "win32":
logger.warning("Windows does not support signals")
else:
loop = asyncio.get_running_loop()
loop.add_signal_handler(signal.SIGINT, sigint_handler)
logger.warning("Press Ctrl+C to stop")
await self.sigint_received.wait()
@staticmethod
def setup_logging(log_directory: str):
"""Configure logging to file."""
if not os.path.isdir(log_directory):
logger.warning("The provided log directory does not exist.")
return
_handler = TimedRotatingFileHandler(
filename=f"{log_directory}{os.sep}xknx.log",
when="midnight",
backupCount=7,
encoding="utf-8",
)
_formatter = logging.Formatter(
"%(asctime)s | %(name)s | %(levelname)s | %(message)s",
datefmt="%Y-%m-%d %H:%M:%S",
)
_handler.setFormatter(_formatter)
_handler.setLevel(logging.DEBUG)
for log_namespace in [
"xknx.log",
"xknx.knx",
"xknx.raw_socket",
"xknx.telegram",
"xknx.state_updater",
]:
_logger = logging.getLogger(log_namespace)
_logger.addHandler(_handler)
class XKNX:
"""Class for reading and writing KNX/IP packets."""
DEFAULT_ADDRESS = "15.15.250"
DEFAULT_RATE_LIMIT = 20
def __init__(
self,
own_address: str | IndividualAddress = DEFAULT_ADDRESS,
address_format: GroupAddressType = GroupAddressType.LONG,
telegram_received_cb: Callable[[Telegram], Awaitable[None]]
| None = None,
device_updated_cb: Callable[[Device], Awaitable[None]]
| None = None,
connection_state_changed_cb: Callable[[XknxConnectionState],
Awaitable[None]]
| None = None,
rate_limit: int = DEFAULT_RATE_LIMIT,
multicast_group: str = DEFAULT_MCAST_GRP,
multicast_port: int = DEFAULT_MCAST_PORT,
log_directory: str | None = None,
state_updater: TrackerOptionType = False,
daemon_mode: bool = False,
connection_config: ConnectionConfig = ConnectionConfig(),
) -> None:
"""Initialize XKNX class."""
self.connection_manager = ConnectionManager()
self.devices = Devices()
self.knxip_interface = knx_interface_factory(
self, connection_config=connection_config)
self.management = Management(self)
self.telegrams: asyncio.Queue[Telegram | None] = asyncio.Queue()
self.telegram_queue = TelegramQueue(self)
self.state_updater = StateUpdater(self,
default_tracker_option=state_updater)
self.task_registry = TaskRegistry(self)
self.current_address = IndividualAddress(0)
self.daemon_mode = daemon_mode
self.multicast_group = multicast_group
self.multicast_port = multicast_port
self.own_address = IndividualAddress(own_address)
self.rate_limit = rate_limit
self.sigint_received = asyncio.Event()
self.started = asyncio.Event()
self.version = VERSION
GroupAddress.address_format = address_format # for global string representation
if log_directory is not None:
self.setup_logging(log_directory)
if telegram_received_cb is not None:
self.telegram_queue.register_telegram_received_cb(
telegram_received_cb)
if device_updated_cb is not None:
self.devices.register_device_updated_cb(device_updated_cb)
if connection_state_changed_cb is not None:
self.connection_manager.register_connection_state_changed_cb(
connection_state_changed_cb)
def __del__(self) -> None:
"""Destructor. Cleaning up if this was not done before."""
if self.started.is_set():
try:
loop = asyncio.get_event_loop()
loop.run_until_complete(self.stop())
except RuntimeError as exp:
logger.warning("Could not close loop, reason: %s", exp)
async def __aenter__(self) -> "XKNX":
"""Start XKNX from context manager."""
await self.start()
return self
async def __aexit__(
self,
exc_type: type[BaseException] | None,
exc: BaseException | None,
traceback: TracebackType | None,
) -> None:
"""Stop XKNX from context manager."""
await self.stop()
async def start(self) -> None:
"""Start XKNX module. Connect to KNX/IP devices and start state updater."""
if self.knxip_interface.connection_config.threaded:
await self.connection_manager.register_loop()
self.task_registry.start()
logger.info(
"XKNX v%s starting %s connection to KNX bus.",
VERSION,
self.knxip_interface.connection_config.connection_type.name.lower(
),
)
await self.knxip_interface.start()
await self.telegram_queue.start()
self.state_updater.start()
self.started.set()
if self.daemon_mode:
await self.loop_until_sigint()
async def join(self) -> None:
"""Wait until all telegrams were processed."""
await self.telegrams.join()
async def stop(self) -> None:
"""Stop XKNX module."""
self.task_registry.stop()
self.state_updater.stop()
await self.join()
await self.telegram_queue.stop()
await self.knxip_interface.stop()
self.started.clear()
async def loop_until_sigint(self) -> None:
"""Loop until Crtl-C was pressed."""
def sigint_handler() -> None:
"""End loop."""
self.sigint_received.set()
if platform == "win32":
logger.warning("Windows does not support signals")
else:
loop = asyncio.get_running_loop()
loop.add_signal_handler(signal.SIGINT, sigint_handler)
logger.warning("Press Ctrl+C to stop")
await self.sigint_received.wait()
@staticmethod
def setup_logging(log_directory: str) -> None:
"""Configure logging to file."""
if not os.path.isdir(log_directory):
logger.warning("The provided log directory does not exist.")
return
_handler = TimedRotatingFileHandler(
filename=f"{log_directory}{os.sep}xknx.log",
when="midnight",
backupCount=7,
encoding="utf-8",
)
_formatter = logging.Formatter(
"%(asctime)s | %(name)s | %(levelname)s | %(message)s",
datefmt="%Y-%m-%d %H:%M:%S",
)
_handler.setFormatter(_formatter)
_handler.setLevel(logging.DEBUG)
for log_namespace in [
"xknx.log",
"xknx.knx",
"xknx.raw_socket",
"xknx.telegram",
"xknx.state_updater",
]:
_logger = logging.getLogger(log_namespace)
_logger.addHandler(_handler)