pymscada 0.2.0rc4__tar.gz → 0.2.0rc7__tar.gz

{pymscada-0.2.0rc4/src/pymscada.egg-info → pymscada-0.2.0rc7}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pymscada
-Version: 0.2.0rc4
+Version: 0.2.0rc7
 Summary: Shared tag value SCADA with python backup and Angular UI
 Author-email: Jamie Walton <jamie@walton.net.nz>
 License: GPL-3.0-or-later
@@ -21,6 +21,7 @@ Requires-Dist: pymscada-html==0.2.0rc4
 Requires-Dist: cerberus>=1.3.5
 Requires-Dist: pycomm3>=1.2.14
 Requires-Dist: pysnmplib>=5.0.24
+Dynamic: license-file
 
 # pymscada
 #### [Docs](https://github.com/jamie0walton/pymscada/blob/main/docs/README.md)

{pymscada-0.2.0rc4 → pymscada-0.2.0rc7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pymscada"
-version = "0.2.0rc4"
+version = "0.2.0rc7"
 description = "Shared tag value SCADA with python backup and Angular UI"
 authors = [
     {name = "Jamie Walton", email = "jamie@walton.net.nz"},

{pymscada-0.2.0rc4 → pymscada-0.2.0rc7}/src/pymscada/alarms.py

@@ -3,18 +3,39 @@ import logging
 import sqlite3  # note that sqlite3 has blocking calls
 import socket
 import time
-import atexit
 from pymscada.bus_client import BusClient
+from pymscada.periodic import Periodic
 from pymscada.tag import Tag, TYPES
 
 ALM = 0
 RTN = 1
 ACT = 2
 INF = 3
-
+KIND = {
+    ALM: 'ALM',
+    RTN: 'RTN',
+    ACT: 'ACT',
+    INF: 'INF'
+}
 NORMAL = 0
 ALARM = 1
 
+"""
+Database schema:
+
+alarms contains an event log of changes as they occur, this
+includes information on actions taken by the alarm system.
+
+CREATE TABLE IF NOT EXISTS alarms (
+    id INTEGER PRIMARY KEY ASC,
+    date_ms INTEGER,
+    alarm_string TEXT,
+    kind INTEGER,     # one of ALM, RTN, ACT, INF
+    desc TEXT,
+    group TEXT
+)
+"""
+
 
 def standardise_tag_info(tagname: str, tag: dict):
     """Correct tag dictionary in place to be suitable for modules."""
@@ -23,6 +44,8 @@ def standardise_tag_info(tagname: str, tag: dict):
     if 'desc' not in tag:
         logging.warning(f"Tag {tagname} has no description, using name")
         tag['desc'] = tag['name']
+    if 'group' not in tag:
+        tag['group'] = ''
     if 'multi' in tag:
         tag['type'] = int
     else:
@@ -40,51 +63,116 @@ def standardise_tag_info(tagname: str, tag: dict):
             tag['dp'] = 2
     if 'units' not in tag:
         tag['units'] = ''
+    if 'alarm' in tag:
+        if isinstance(tag['alarm'], str):
+            tag['alarm'] = [tag['alarm']]
+        if not isinstance(tag['alarm'], list):
+            logging.warning(f"Tag {tagname} has invalid alarm {tag['alarm']}")
+            del tag['alarm']
+
 
+def split_operator(alarm: str) -> dict:
+    """Split alarm string into operator and value."""
+    tokens = alarm.split(' ')
+    alm_dict = {'for': 0}
+    if len(tokens) not in (2, 4):
+        raise ValueError(f"Invalid alarm {alarm}")
+    if tokens[0] not in ['>', '<', '==', '>=', '<=']:
+        raise ValueError(f"Invalid alarm {alarm}")
+    alm_dict['operator'] = tokens[0]
+    try:
+        alm_dict['value'] = float(tokens[1])
+    except ValueError:
+        raise ValueError(f"Invalid alarm {alarm}")
+    if len(tokens) == 4:
+        if tokens[2] != 'for':
+            raise ValueError(f"Invalid alarm {alarm}")
+        try:
+            alm_dict['for'] = int(tokens[3])
+        except ValueError:
+            raise ValueError(f"Invalid alarm {alarm}")
+    return alm_dict
 
-class Alarm:
-    """Manages multiple alarm conditions for a single tag."""
-    def __init__(self, tag: Tag, conditions: str | list[str]):
+
+class Alarm():
+    """
+    Single alarm class.
+
+    Alarms are defined by a tag and a condition. Tags may have multiple
+    conditions, each combination of tag and condition is a separate Alarm.
+
+    Monitors tag value through the Tag callback. Tracks in alarm state.
+    Generates the ALM and RTN messages for Alarms to publish via rta_tag.
+    """
+
+    def __init__(self, tagname: str, tag: dict, alarm: str, group: str, rta_cb, alarms) -> None:
         """Initialize alarm with tag and condition(s)."""
-        if tag.type not in (int, float):
-            raise ValueError(f"Alarms only supported for numeric types, not {tag.type}")
-            
-        self.tag = tag
-        self.tests: list[tuple[str, callable, float]] = []
-        
-        # Handle both string and list conditions
-        if isinstance(conditions, str):
-            conditions = [conditions]
-            
-        for condition in conditions:
-            operator_str, value = condition.split(' ')
-            self.tests.append((
-                condition,
-                {
-                    '==': (lambda x, y: x == y),
-                    '<': (lambda x, y: x < y),
-                    '>': (lambda x, y: x > y),
-                    '<=': (lambda x, y: x <= y),
-                    '>=': (lambda x, y: x >= y)
-                }[operator_str],
-                float(value)
-            ))
-            
-    def check_conditions(self, in_alarm: set[str]) -> list[tuple[str, bool, float, int]]:
-        """Check all conditions and return list of changes.
-        Returns list of (alarm_ref, is_in_alarm, value, timestamp) for changed states."""
-        changes = []
-        for condition_str, test, value in self.tests:
-            alarm_ref = f"{self.tag.name} {condition_str}"
-            is_in_alarm = test(self.tag.value, value)
-            
-            if is_in_alarm and alarm_ref not in in_alarm:
-                changes.append((alarm_ref, True, self.tag.value, self.tag.time_us))
-                
-            elif not is_in_alarm and alarm_ref in in_alarm:
-                changes.append((alarm_ref, False, self.tag.value, self.tag.time_us))
-                
-        return changes
+        self.alarm_id = f'{tagname} {alarm}'
+        self.tag = Tag(tagname, tag['type'])
+        self.tag.desc = tag['desc']
+        self.tag.dp = tag['dp']
+        self.tag.units = tag['units']
+        self.tag.add_callback(self.callback)
+        self.group = group
+        self.rta_cb = rta_cb
+        self.alarms = alarms
+        self.alarm = split_operator(alarm)
+        self.in_alarm = False
+        self.checking = False
+
+    def callback(self, tag: Tag):
+        """Handle tag value changes and generate ALM/RTN messages."""
+        if tag.value is None:
+            return
+        value = float(tag.value)
+        time_us = tag.time_us
+        new_in_alarm = False
+        op = self.alarm['operator']
+        if op == '>':
+            new_in_alarm = value > self.alarm['value']
+        elif op == '<':
+            new_in_alarm = value < self.alarm['value']
+        elif op == '==':
+            new_in_alarm = value == self.alarm['value']
+        elif op == '>=':
+            new_in_alarm = value >= self.alarm['value']
+        elif op == '<=':
+            new_in_alarm = value <= self.alarm['value']
+        if new_in_alarm == self.in_alarm:
+            return
+        self.in_alarm = new_in_alarm
+        if self.in_alarm:
+            if self.alarm['for'] > 0:
+                if not self.checking:
+                    self.checking = True
+                    self.alarms.checking_alarms.append(self)
+            else:
+                self.generate_alarm(ALM, time_us, value)
+        else:
+            if self.checking:
+                self.checking = False
+                self.alarms.checking_alarms.remove(self)
+            self.generate_alarm(RTN, time_us, value)
+
+    def generate_alarm(self, kind: int, time_us: int, value: float):
+        """Generate alarm message."""
+        logging.warning(f'Alarm {self.alarm_id} {value} {KIND[kind]}')
+        self.rta_cb({
+            'action': 'ADD',
+            'date_ms': int(time_us / 1000),
+            'alarm_string': self.alarm_id,
+            'kind': kind,
+            'desc': f'{self.tag.desc} {value:.{self.tag.dp}f}'
+                    f' {self.tag.units}',
+            'group': self.group
+        })
+
+    def check_duration(self, current_time_us: int):
+        """Check if alarm condition has been met for required duration."""
+        if current_time_us - self.tag.time_us >= self.alarm['for'] * 1000000:
+            self.generate_alarm(ALM, current_time_us, self.tag.value)
+            self.checking = False
+            self.alarms.checking_alarms.remove(self)
 
 
 class Alarms:
@@ -128,124 +216,57 @@ class Alarms:
             raise ValueError('table must be a non-empty string')
 
         logging.warning(f'Alarms {bus_ip} {bus_port} {db} {rta_tag}')
-        self.connection = sqlite3.connect(db)
-        self.tags: dict[str, Tag] = {}
-        self.alarms: dict[str, Alarm] = {}
-        self.in_alarm: dict[str, int] = {}
+        self.alarms: list[Alarm] = []
+        self.checking_alarms: list[Alarm] = []
         for tagname, tag in tag_info.items():
             standardise_tag_info(tagname, tag)
             if 'alarm' not in tag or tag['type'] not in (int, float):
                 continue
-            self.tags[tagname] = Tag(tagname, tag['type'])
-            self.tags[tagname].desc = tag['desc']
-            self.tags[tagname].dp = tag['dp']
-            self.tags[tagname].units = tag['units']
-            self.tags[tagname].add_callback(self.alarm_cb)
-            self.alarms[tagname] = Alarm(self.tags[tagname], tag['alarm'])
-        self.table = table
-        self.cursor = self.connection.cursor()
+            group = tag['group']
+            for alarm in tag['alarm']:
+                new_alarm = Alarm(tagname, tag, alarm, group, self.rta_cb,
+                                  self)
+                self.alarms.append(new_alarm)
         self.busclient = BusClient(bus_ip, bus_port, module='Alarms')
         self.rta = Tag(rta_tag, dict)
         self.rta.value = {}
         self.busclient.add_callback_rta(rta_tag, self.rta_cb)
-        atexit.register(self.close)
-
-    def alarm_cb(self, tag: Tag):
-        """Callback for alarm tags."""
-        if tag.name not in self.alarms:
-            return
-        changes = self.alarms[tag.name].check_conditions(self.in_alarm)
-        for alarm_ref, is_in_alarm, value, time_us in changes:
-            self._handle_alarm_change(
-                alarm_ref, 
-                is_in_alarm, 
-                tag, 
-                value, 
-                time_us
-            )
-
-    def _handle_alarm_change(self, alarm_ref: str, is_in_alarm: bool, 
-                           tag: Tag, value: float, time_us: int):
-        """Handle alarm state changes and database updates."""
-        if is_in_alarm:
-            logging.warning(f'Alarm {alarm_ref} {value}')
-            kind = ALM
-            state = ALARM
-            alarm_record = {
-                'action': 'ADD',
-                'date_ms': int(time_us / 1000),
-                'tag_alm': alarm_ref,
-                'kind': kind,
-                'desc': f'{tag.desc} {value:.{tag.dp}f} {tag.units}',
-                'in_alm': state
-            }
-            self.rta_cb(alarm_record)
-            self.in_alarm[alarm_ref] = self.rta.value['id']
-        else:
-            logging.info(f'No alarm {alarm_ref} {value}')
-            if alarm_ref in self.in_alarm:
-                # First update the existing alarm record to NORMAL
-                update_record = {
-                    'action': 'UPDATE',
-                    'id': self.in_alarm[alarm_ref],
-                    'in_alm': NORMAL
-                }
-                self.rta_cb(update_record)
-                
-                # Then add the RTN record
-                rtn_record = {
-                    'action': 'ADD',
-                    'date_ms': int(time_us / 1000),
-                    'tag_alm': alarm_ref,
-                    'kind': RTN,
-                    'desc': f'{tag.desc} {value:.{tag.dp}f} {tag.units}',
-                    'in_alm': NORMAL
-                }
-                self.rta_cb(rtn_record)
-                del self.in_alarm[alarm_ref]
+        self._init_db(db, table)
+        self.periodic = Periodic(self.periodic_cb, 1.0)
 
-    def _init_table(self):
+    def _init_db(self, db, table):
         """Initialize the database table schema."""
+        self.connection = sqlite3.connect(db)
+        self.table = table
+        self.cursor = self.connection.cursor()
         query = (
-            'CREATE TABLE IF NOT EXISTS ' + self.table +
+            'CREATE TABLE IF NOT EXISTS ' + self.table + ' '
             '(id INTEGER PRIMARY KEY ASC, '
             'date_ms INTEGER, '
-            'tag_alm TEXT, '
+            'alarm_string TEXT, '
             'kind INTEGER, '
             'desc TEXT, '
-            'in_alm INTEGER)'
+            '"group" TEXT)'
         )
         self.cursor.execute(query)
+        self.connection.commit()
         
-        # Clear any existing ALARM states
-        try:
-            with self.connection:
-                # Update all alarm records to NORMAL
-                self.cursor.execute(
-                    f'SELECT id, tag_alm FROM {self.table} WHERE in_alm = ?',
-                    (ALARM,))
-                alarm_records = self.cursor.fetchall()
-                for record_id, tag_alm in alarm_records:
-                    update_record = {
-                        'action': 'UPDATE',
-                        'id': record_id,
-                        'in_alm': NORMAL
-                    }
-                    self.rta_cb(update_record)
-        except sqlite3.Error as e:
-            logging.error(f'Error clearing alarm states during startup: {e}')
-        
-        # Add startup record using existing ADD functionality
         startup_record = {
             'action': 'ADD',
             'date_ms': int(time.time() * 1000),
-            'tag_alm': self.rta.name,
+            'alarm_string': self.rta.name,
             'kind': INF,
             'desc': 'Alarm logging started',
-            'in_alm': NORMAL
+            'group': '__system__'
         }
         self.rta_cb(startup_record)
 
+    async def periodic_cb(self):
+        """Periodic callback to check alarms."""
+        current_time_us = int(time.time() * 1000000)
+        for alarm in self.checking_alarms[:]:
+            alarm.check_duration(current_time_us)
+
     def rta_cb(self, request):
         """Respond to Request to Author and publish on rta_tag as needed."""
         if 'action' not in request:
@@ -256,18 +277,18 @@ class Alarms:
                 with self.connection:
                     self.cursor.execute(
                         f'INSERT INTO {self.table} '
-                        '(date_ms, tag_alm, kind, desc, in_alm) '
-                        'VALUES(:date_ms, :tag_alm, :kind, :desc, :in_alm) '
+                        '(date_ms, alarm_string, kind, desc, "group") '
+                        'VALUES(:date_ms, :alarm_string, :kind, :desc, :group) '
                         'RETURNING *;',
                         request)
                     res = self.cursor.fetchone()
                     self.rta.value = {
                         'id': res[0],
                         'date_ms': res[1],
-                        'tag_alm': res[2],
+                        'alarm_string': res[2],
                         'kind': res[3],
                         'desc': res[4],
-                        'in_alm': res[5]
+                        'group': res[5]
                     }
             except sqlite3.IntegrityError as error:
                 logging.warning(f'Alarms rta_cb {error}')
@@ -284,10 +305,10 @@ class Alarms:
                         self.rta.value = {
                             'id': res[0],
                             'date_ms': res[1],
-                            'tag_alm': res[2],
+                            'alarm_string': res[2],
                             'kind': res[3],
                             'desc': res[4],
-                            'in_alm': res[5]
+                            'group': res[5]
                         }
             except sqlite3.IntegrityError as error:
                 logging.warning(f'Alarms rta_cb update {error}')
@@ -303,10 +324,10 @@ class Alarms:
                             '__rta_id__': request['__rta_id__'],
                             'id': res[0],
                             'date_ms': res[1],
-                            'tag_alm': res[2],
+                            'alarm_string': res[2],
                             'kind': res[3],
                             'desc': res[4],
-                            'in_alm': res[5]
+                            'group': res[5]
                         }
             except sqlite3.IntegrityError as error:
                 logging.warning(f'Alarms rta_cb {error}')
@@ -329,30 +350,4 @@ class Alarms:
     async def start(self):
         """Async startup."""
         await self.busclient.start()
-        self._init_table()
-
-    def close(self):
-        """Clean shutdown of alarms logging."""
-        for alarm_ref, record_id in self.in_alarm.items():
-            update_record = {
-                'action': 'UPDATE',
-                'id': record_id,
-                'in_alm': NORMAL
-            }
-            try:
-                self.rta_cb(update_record)
-            except sqlite3.Error as e:
-                logging.error(f'Error clearing alarm {alarm_ref}: {e}')
-        
-        shutdown_record = {
-            'action': 'ADD',
-            'date_ms': int(time.time() * 1000),
-            'tag_alm': self.rta.name,
-            'kind': INF,
-            'desc': 'Alarm logging stopped',
-            'in_alm': NORMAL
-        }
-        try:
-            self.rta_cb(shutdown_record)
-        except sqlite3.Error as e:
-            logging.error(f'Error during alarm shutdown: {e}')
+        await self.periodic.start()

{pymscada-0.2.0rc4 → pymscada-0.2.0rc7}/src/pymscada/bus_client.py

@@ -17,8 +17,8 @@ class BusClient:
     the client dies. A connection is mandatory for the client to run.
     """
 
-    def __init__(self, ip: str = '127.0.0.1', port: int = 1324, tag_info=None,
-                 module: str = '_unset_'):
+    def __init__(self, ip: str | None = '127.0.0.1', port: int | None = 1324,
+                 tag_info=None, module: str = '_unset_'):
         """Create bus server."""
         self.ip = ip
         self.port = port

pymscada-0.2.0rc7/src/pymscada/callout.py

@@ -0,0 +1,203 @@
+"""Callout handling."""
+import logging
+import socket
+import time
+from pymscada.bus_client import BusClient
+from pymscada.periodic import Periodic
+from pymscada.tag import Tag
+
+
+"""
+Callout monitors alarms and sends SMS notifications to configured callees.
+
+Configuration:
+- callees: list of recipients with SMS numbers, delays, and group filters
+- alarms_tag: RTA tag receiving alarms from alarms.py
+- ack_tag: tag for receiving acknowledgments
+- rta_tag: tag for configuration updates and SMS requests
+
+Operation:
+1. Collect alarms from alarms_tag (kind=ALM)
+2. For each callee, check if alarms match their group filter and delay
+3. Send SMS via rta_tag when conditions are met
+4. Track sent notifications in alarm['sent'] hash
+5. Remove alarms when callee acknowledges (matches their group)
+"""
+
+ALM = 0
+IDLE = 0
+NEW_ALM = 1
+CALLOUT = 2
+
+
+def normalise_callees(callees: list | None):
+    """Normalise callees to include delay_ms and remove delay."""
+    if callees is None:
+        return []
+    for callee in callees:
+        if 'sms' not in callee:
+            raise ValueError(f'Callee {callee["name"]} has no sms number')
+        if 'delay' in callee:
+            callee['delay_ms'] = callee['delay'] * 1000
+            del callee['delay']
+        else:
+            callee['delay_ms'] = 0
+        if 'group' not in callee:
+            callee['group'] = []
+    callees.sort(key=lambda x: x['delay_ms'])
+    return callees
+
+
+def alarm_in_callee_group(alarm_group: list, callee_group: list):
+    """Check if alarm_group is in callee_group."""
+    if not callee_group:
+        if not alarm_group:
+            return ''
+        return alarm_group[0]
+    if not alarm_group:
+        return None
+    for group in alarm_group:
+        if group in callee_group:
+            return group
+    return None
+
+
+class Callout:
+    """Connect to bus_ip:bus_port, monitor alarms and manage callouts."""
+
+    def __init__(
+        self,
+        bus_ip: str | None = '127.0.0.1',
+        bus_port: int | None = 1324,
+        rta_tag: str = '__callout__',
+        alarms_tag: str | None = None,
+        ack_tag: str | None = None,
+        status_tag: str | None = None,
+        callees: list | None = None,
+        groups: list | None = None
+    ) -> None:
+        """
+        Connect to bus_ip:bus_port, monitor alarms and manage callouts.
+
+        Monitor alarms via alarms_tag and manage callout messages to callees
+        based on configured delays and area filters.
+
+        Event loop must be running.
+
+        For testing only: bus_ip can be None to skip connection.
+        """
+        if bus_ip is None:
+            logging.warning('Callout has bus_ip=None, only use for testing')
+        else:
+            try:
+                socket.gethostbyname(bus_ip)
+            except socket.gaierror as e:
+                raise ValueError(f'Cannot resolve IP/hostname: {e}')
+            if not isinstance(bus_port, int):
+                raise TypeError('bus_port must be an integer')
+            if not 1024 <= bus_port <= 65535:
+                raise ValueError('bus_port must be between 1024 and 65535')
+        if not isinstance(rta_tag, str) or not rta_tag:
+            raise ValueError('rta_tag must be a non-empty string')
+
+        logging.warning(f'Callout {bus_ip} {bus_port} {rta_tag}')
+        self.alarms = []
+        self.callees = normalise_callees(callees)
+        self.groups = []
+        if groups is not None:
+            self.groups = groups
+        self.status = None
+        if status_tag is not None:
+            self.status = Tag(status_tag, int)
+            self.status.value = IDLE
+        self.busclient = BusClient(bus_ip, bus_port, module='Callout')
+        self.busclient.add_callback_rta(alarms_tag, self.alarms_cb)
+        self.busclient.add_callback_rta(ack_tag, self.ack_cb)
+        self.rta = Tag(rta_tag, dict)
+        self.rta.value = {}
+        self.busclient.add_callback_rta(rta_tag, self.rta_cb)
+        self.periodic = Periodic(self.periodic_cb, 1.0)
+
+    def alarms_cb(self, request):
+        """Handle alarm messages from alarms.py."""
+        if request['kind'] != ALM:
+            return
+        alarm = {
+            'date_ms': request['date_ms'],
+            'alarm_string': request['alarm_string'],
+            'desc': request['desc'],
+            'group': request['group'],
+            'sent': {}
+        }
+        self.alarms.append(alarm)
+        logging.info(f'Added alarm to list: {alarm}')
+
+    def ack_cb(self, ack: str):
+        """Handle ACK requests for alarm acknowledgment."""
+        if ack == '__all':
+            self.alarms = []
+            return
+        callee = None
+        for c in self.callees:
+            if ack == c['sms']:
+                callee = c
+                break
+            if ack == c['name']:
+                callee = c
+                break
+        if callee is None:
+            logging.warning(f'ACK rejected: {ack}')
+            return
+        logging.info(f'ACK accepted: {ack}')
+        group = callee['group']
+        remaining_alarms = []
+        for alarm in self.alarms:
+            alarm_group = alarm_in_callee_group(alarm['group'], group)
+            if alarm_group is None:
+                remaining_alarms.append(alarm)
+        self.alarms = remaining_alarms
+
+    def rta_cb(self, request):
+        """Handle RTA requests for callout configuration."""
+        if 'action' not in request:
+            logging.warning(f'rta_cb malformed {request}')
+        elif request['action'] == 'MODIFY':
+            for callee in self.callees:
+                if callee['name'] == request['name']:
+                    if 'delay' in request:
+                        callee['delay_ms'] = request['delay'] * 1000
+                    if 'group' in request:
+                        callee['group'] = request['group']
+                    logging.info(f'Modified callee with {request}')
+
+    def check_callouts(self):
+        """Check alarms and send callouts. Can be called independently for testing."""
+        time_ms = int(time.time() * 1000)
+        for callee in self.callees:
+            message = ''
+            count = 0
+            group = callee['group']
+            notify_ms = time_ms - callee['delay_ms']
+            for alarm in self.alarms:
+                if alarm['date_ms'] < notify_ms:
+                    alarm_group = alarm_in_callee_group(alarm['group'], group)
+                    if alarm_group is not None and callee['name'] not in alarm['sent']:
+                        count += 1
+                        message += f"{alarm['alarm_string']}\n"
+                        alarm['sent'][callee['name']] = time_ms
+            if count > 0:
+                send_message = f"{alarm_group} {count} unack alarms\n{message}"
+                logging.warning(f'Callout to {callee["name"]}: {send_message}')
+                self.rta.value = {'action': 'SMS', 'sms': callee['sms'],
+                                  'message': send_message}
+                if self.status is not None:
+                    self.status.value = CALLOUT
+
+    async def periodic_cb(self):
+        """Periodic callback to check alarms and send callouts."""
+        self.check_callouts()
+
+    async def start(self):
+        """Async startup."""
+        await self.busclient.start()
+        await self.periodic.start()