pymscada 0.2.0__py3-none-any.whl → 0.2.6b9__py3-none-any.whl

pymscada/__init__.py

@@ -2,25 +2,31 @@
 from pymscada.bus_client import BusClient
 from pymscada.bus_server import BusServer
 from pymscada.config import Config
+from pymscada.callout import Callout, ALM
 from pymscada.iodrivers.accuweather import AccuWeatherClient
 from pymscada.iodrivers.logix_client import LogixClient
 from pymscada.iodrivers.modbus_client import ModbusClient
 from pymscada.iodrivers.modbus_server import ModbusServer
+from pymscada.iodrivers.piapi import PIWebAPIClient
+from pymscada.iodrivers.sms import SMS
+from pymscada.iodrivers.witsapi import WitsAPIClient
 from pymscada.misc import find_nodes, ramp
 from pymscada.periodic import Periodic
 from pymscada.tag import Tag
-from pymscada.validate import validate
 
 __all__ = [
     'BusClient',
     'BusServer',
     'Config',
+    'Callout', 'ALM',
     'AccuWeatherClient',
     'LogixClient',
     'ModbusClient',
     'ModbusServer',
+    'PIWebAPIClient',
+    'SMS',
+    'WitsAPIClient',
     'find_nodes', 'ramp',
     'Periodic',
     'Tag',
-    'validate',
 ]

pymscada/alarms.py

@@ -11,12 +11,14 @@ ALM = 0
 RTN = 1
 ACT = 2
 INF = 3
+TIMING = 4
 KIND = {
     ALM: 'ALM',
     RTN: 'RTN',
     ACT: 'ACT',
     INF: 'INF'
 }
+
 NORMAL = 0
 ALARM = 1
 
@@ -74,12 +76,11 @@ def standardise_tag_info(tagname: str, tag: dict):
 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]
+    alm_dict = {'for': 0, 'operator': tokens[0], 'value': None}
     try:
         alm_dict['value'] = float(tokens[1])
     except ValueError:
@@ -102,10 +103,11 @@ class Alarm():
     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.
+    Notifies Alarms of state changes via state callback.
     """
 
-    def __init__(self, tagname: str, tag: dict, alarm: str, group: str, rta_cb, alarms) -> None:
+    def __init__(self, tagname: str, tag: dict, alarm: str, group: str,
+                 state_cb) -> None:
         """Initialize alarm with tag and condition(s)."""
         self.alarm_id = f'{tagname} {alarm}'
         self.tag = Tag(tagname, tag['type'])
@@ -114,18 +116,18 @@ class Alarm():
         self.tag.units = tag['units']
         self.tag.add_callback(self.callback)
         self.group = group
-        self.rta_cb = rta_cb
-        self.alarms = alarms
+        self.state_cb = state_cb
+        self.timing_value = None
+        self.timing_us = None
         self.alarm = split_operator(alarm)
         self.in_alarm = False
-        self.checking = False
+        self.disabled_until = 0
 
     def callback(self, tag: Tag):
         """Handle tag value changes and generate ALM/RTN messages."""
-        if tag.value is None:
+        if tag.value is None or tag.time_us < self.disabled_until:
             return
         value = float(tag.value)
-        time_us = tag.time_us
         new_in_alarm = False
         op = self.alarm['operator']
         if op == '>':
@@ -140,39 +142,25 @@ class Alarm():
             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 new_in_alarm:
             if self.alarm['for'] > 0:
-                if not self.checking:
-                    self.checking = True
-                    self.alarms.checking_alarms.append(self)
+                self.state_cb(self, TIMING)
+                self.timing_us = tag.time_us
+                self.timing_value = value
             else:
-                self.generate_alarm(ALM, time_us, value)
+                self.state_cb(self, ALM)
         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
-        })
+            if self.timing_us is not None:
+                if tag.time_us - self.timing_us >= self.alarm['for'] * 1000000:
+                    self.state_cb(self, ALM)
+            self.timing_us = None
+            self.state_cb(self, RTN)
+        self.in_alarm = new_in_alarm
 
     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)
+            self.state_cb(self, ALM)
 
 
 class Alarms:
@@ -218,19 +206,20 @@ class Alarms:
         logging.warning(f'Alarms {bus_ip} {bus_port} {db} {rta_tag}')
         self.alarms: list[Alarm] = []
         self.checking_alarms: list[Alarm] = []
+        self.in_alarm: 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
             group = tag['group']
             for alarm in tag['alarm']:
-                new_alarm = Alarm(tagname, tag, alarm, group, self.rta_cb,
-                                  self)
+                new_alarm = Alarm(tagname, tag, alarm, group, self.state_cb)
                 self.alarms.append(new_alarm)
         self.busclient = BusClient(bus_ip, bus_port, module='Alarms')
         self.rta = Tag(rta_tag, dict)
-        self.rta.value = {}
+        self.rta.value = {'__rta_id__': 0}
         self.busclient.add_callback_rta(rta_tag, self.rta_cb)
+        self.busclient.add_tag(self.rta)
         self._init_db(db, table)
         self.periodic = Periodic(self.periodic_cb, 1.0)
 
@@ -239,6 +228,14 @@ class Alarms:
         self.connection = sqlite3.connect(db)
         self.table = table
         self.cursor = self.connection.cursor()
+        sqlite_version = sqlite3.sqlite_version_info
+        self.has_returning = sqlite_version >= (3, 35, 0)
+        if not self.has_returning:
+            logging.warning(
+                f'SQLite {sqlite3.sqlite_version} is older than 3.35.0. '
+                f'RETURNING clause not supported, using fallback method. '
+                f'Consider upgrading SQLite for better performance.'
+            )
         query = (
             'CREATE TABLE IF NOT EXISTS ' + self.table + ' '
             '(id INTEGER PRIMARY KEY ASC, '
@@ -250,7 +247,6 @@ class Alarms:
         )
         self.cursor.execute(query)
         self.connection.commit()
-        
         startup_record = {
             'action': 'ADD',
             'date_ms': int(time.time() * 1000),
@@ -267,6 +263,39 @@ class Alarms:
         for alarm in self.checking_alarms[:]:
             alarm.check_duration(current_time_us)
 
+    def state_cb(self, alarm: Alarm, state: int):
+        """Handle alarm state changes."""
+        if state == TIMING:
+            self.checking_alarms.append(alarm)
+        elif state == ALM:
+            if alarm in self.checking_alarms:
+                self.checking_alarms.remove(alarm)
+            self.in_alarm.append(alarm)
+            self.generate_alarm(alarm, ALM)
+        elif state == RTN:
+            if alarm in self.checking_alarms:
+                self.checking_alarms.remove(alarm)
+            if alarm in self.in_alarm:
+                self.in_alarm.remove(alarm)
+            self.generate_alarm(alarm, RTN)
+
+    def generate_alarm(self, alarm: Alarm, kind: int):
+        """Generate alarm message."""
+        value = alarm.tag.value
+        if alarm.timing_us is not None:
+            value = alarm.timing_value
+        time_us = alarm.tag.time_us
+        logging.warning(f'Alarm {alarm.alarm_id} {value} {KIND[kind]}')
+        self.rta_cb({
+            'action': 'ADD',
+            'date_ms': int(time_us / 1000),
+            'alarm_string': alarm.alarm_id,
+            'kind': kind,
+            'desc': f'{alarm.tag.desc} {value:.{alarm.tag.dp}f}'
+                    f' {alarm.tag.units}',
+            'group': alarm.group
+        })
+
     def rta_cb(self, request):
         """Respond to Request to Author and publish on rta_tag as needed."""
         if 'action' not in request:
@@ -275,14 +304,27 @@ class Alarms:
             try:
                 logging.info(f'add {request}')
                 with self.connection:
-                    self.cursor.execute(
-                        f'INSERT INTO {self.table} '
-                        '(date_ms, alarm_string, kind, desc, "group") '
-                        'VALUES(:date_ms, :alarm_string, :kind, :desc, :group) '
-                        'RETURNING *;',
-                        request)
-                    res = self.cursor.fetchone()
+                    if self.has_returning:
+                        self.cursor.execute(
+                            f'INSERT INTO {self.table} '
+                            '(date_ms, alarm_string, kind, desc, "group") '
+                            'VALUES(:date_ms, :alarm_string, :kind, :desc, :group) '
+                            'RETURNING *;',
+                            request)
+                        res = self.cursor.fetchone()
+                    else:
+                        self.cursor.execute(
+                            f'INSERT INTO {self.table} '
+                            '(date_ms, alarm_string, kind, desc, "group") '
+                            'VALUES(:date_ms, :alarm_string, :kind, :desc, :group);',
+                            request)
+                        row_id = self.cursor.lastrowid
+                        self.cursor.execute(
+                            f'SELECT * FROM {self.table} WHERE id = ?;',
+                            (row_id,))
+                        res = self.cursor.fetchone()
                     self.rta.value = {
+                        '__rta_id__': 0,
                         'id': res[0],
                         'date_ms': res[1],
                         'alarm_string': res[2],
@@ -296,20 +338,42 @@ class Alarms:
             try:
                 logging.info(f'update {request}')
                 with self.connection:
-                    self.cursor.execute(
-                        f'UPDATE {self.table} SET in_alm = :in_alm '
-                        'WHERE id = :id RETURNING *;',
-                        request)
-                    res = self.cursor.fetchone()
-                    if res:
-                        self.rta.value = {
-                            'id': res[0],
-                            'date_ms': res[1],
-                            'alarm_string': res[2],
-                            'kind': res[3],
-                            'desc': res[4],
-                            'group': res[5]
-                        }
+                    if self.has_returning:
+                        self.cursor.execute(
+                            f'UPDATE {self.table} SET in_alm = :in_alm '
+                            'WHERE id = :id RETURNING *;',
+                            request)
+                        res = self.cursor.fetchone()
+                        if res:
+                            self.rta.value = {
+                                '__rta_id__': 0,
+                                'id': res[0],
+                                'date_ms': res[1],
+                                'alarm_string': res[2],
+                                'kind': res[3],
+                                'desc': res[4],
+                                'group': res[5]
+                            }
+                    else:
+                        self.cursor.execute(
+                            f'UPDATE {self.table} SET in_alm = :in_alm '
+                            'WHERE id = :id;',
+                            request)
+                        if self.cursor.rowcount > 0:
+                            self.cursor.execute(
+                                f'SELECT * FROM {self.table} WHERE id = :id;',
+                                request)
+                            res = self.cursor.fetchone()
+                            if res:
+                                self.rta.value = {
+                                    '__rta_id__': 0,
+                                    'id': res[0],
+                                    'date_ms': res[1],
+                                    'alarm_string': res[2],
+                                    'kind': res[3],
+                                    'desc': res[4],
+                                    'group': res[5]
+                                }
             except sqlite3.IntegrityError as error:
                 logging.warning(f'Alarms rta_cb update {error}')
         elif request['action'] == 'HISTORY':
@@ -346,6 +410,61 @@ class Alarms:
         elif request['action'] == 'IN ALARM':
             self.rta.value = {'__rta_id__': request['__rta_id__'],
                               'data': {'in_alarm': list(self.in_alarm)}}
+        elif request['action'] == 'ENABLE':
+            time_us = int(time.time() * 1000000)
+            local_time = time.localtime(time_us / 1000000)
+            for alarm in self.alarms:
+                if alarm.alarm_id == request['alarm id']:
+                    enable = request['enable']
+                    if enable == 'Enable':
+                        disabled_until_us = 0
+                    else:
+                        if enable == 'Disable until 8am':
+                            target_hour = 8
+                            target_day_offset = 0
+                            next_offset = 1
+                        elif enable == 'Disable until 4pm':
+                            target_hour = 16
+                            target_day_offset = 0
+                            next_offset = 1
+                        elif enable == 'Disable until Monday 8am':
+                            target_hour = 8
+                            target_day_offset = (0 - local_time.tm_wday) % 7
+                            next_offset = 7
+                        else:
+                            disabled_until_us = 0
+                            break
+                        target_s = time.mktime((
+                            local_time.tm_year, local_time.tm_mon,
+                            local_time.tm_mday + target_day_offset,
+                            target_hour, 0, 0, 0, 0, -1
+                        ))
+                        if target_s * 1000000 <= time_us:
+                            target_s = time.mktime((
+                                local_time.tm_year, local_time.tm_mon,
+                                local_time.tm_mday + next_offset, 
+                                target_hour, 0, 0, 0, 0, -1
+                            ))
+                        disabled_until_us = int(target_s * 1000000)
+                    alarm.disabled_until = disabled_until_us
+                    ts = time.strftime(
+                        "%Y-%m-%d %H:%M:%S",
+                        time.localtime(disabled_until_us / 1000000)
+                    )
+                    if disabled_until_us == 0:
+                        desc = 'Enable'
+                    else:
+                        desc = f'Disable until {ts}'
+                    self.rta_cb({
+                        'action': 'ADD',
+                        'date_ms': int(time_us / 1000),
+                        'alarm_string': alarm.alarm_id,
+                        'kind': ACT,
+                        'desc': desc,
+                        'group': alarm.group
+                    })
+                    break
+ 
 
     async def start(self):
         """Async startup."""

pymscada/bus_client.py

@@ -84,6 +84,12 @@ class BusClient:
         """Write a message."""
         if data is None:
             data = b''
+        try:
+            size_total = len(data)
+        except Exception:
+            size_total = 0
+        logging.info(f'{self.module}: write cmd={command} tag_id={tag_id} '
+                     f'size_total={size_total}')
         for i in range(0, len(data) + 1, pc.MAX_LEN):
             snip = data[i:i+pc.MAX_LEN]
             size = len(snip)
@@ -94,7 +100,9 @@ class BusClient:
             except (asyncio.IncompleteReadError, ConnectionResetError):
                 self.read_task.cancel()
             except AttributeError:
-                logging.warning('Attribute Error, TO DO, fix in test')
+                logging.warning(f'{self.module}: write AttributeError '
+                                f'cmd={command} '
+                                f'tag_id={tag_id} size={size}')
 
     def add_tag(self, tag: Tag):
         """Add the new tag and get the tag's bus ID."""
@@ -209,10 +217,12 @@ class BusClient:
             data = struct.unpack_from(f'!{len(value) - 1}s', value, offset=1
                                       )[0].decode()
             data = json.loads(data)
+            logging.info(f'{self.module}: RTA received {tag.name} {data} '
+                         f'from tag_id {tag_id}')
             try:
                 self.rta_handlers[tag.name](data)
             except KeyError:
-                logging.warning(f'unhandled RTA for {tag.name} {data}')
+                logging.warning(f'{self.module}: unhandled RTA for {tag.name} {data}')
         else:
             raise SystemExit(f'Invalid message {cmd}')
 

pymscada/bus_server.py

@@ -18,8 +18,7 @@ class BusTags(type):
         """Return existing tag if tagname already exists."""
         if tagname in cls._tag_by_name:
             return cls._tag_by_name[tagname]
-        tag: 'BusTag' = cls.__new__(cls, tagname)
-        tag.__init__(tagname)
+        tag: 'BusTag' = super().__call__(tagname)
         tag.id = cls._next_id
         cls._next_id += 1
         cls._tag_by_name[tagname] = tag
@@ -35,10 +34,10 @@ class BusTag(metaclass=BusTags):
     def __init__(self, name: bytes):
         """Name and id must be unique."""
         self.name = name
-        self.id = None
+        self.id = 0
         self.time_us: int = 0
         self.value: bytes = b''
-        self.from_bus: 'BusConnection' = None
+        self.from_bus: int = 0
         self.pub = []
 
     def add_callback(self, callback, bus_id):
@@ -51,7 +50,7 @@ class BusTag(metaclass=BusTags):
         if (callback, bus_id) in self.pub:
             self.pub.remove((callback, bus_id))
 
-    def update(self, data: bytes, time_us: int, from_bus: 'BusConnection'):
+    def update(self, data: bytes, time_us: int, from_bus: int):
         """Assign value and update subscribers."""
         self.value = data
         self.time_us = time_us
@@ -111,7 +110,8 @@ class BusConnection():
                 head = await self.reader.readexactly(14)
                 _, cmd, tag_id, size, time_us = unpack('!BBHHQ', head)
             except (ConnectionResetError, asyncio.IncompleteReadError,
-                    asyncio.CancelledError):
+                    asyncio.CancelledError) as e:
+                logging.warning(f'{self.addr} read error: {e}')
                 break
             # if the command packet indicates data, get that too
             if size == 0:
@@ -121,7 +121,8 @@ class BusConnection():
                 payload = await self.reader.readexactly(size)
                 data = unpack(f'!{size}s', payload)[0]
             except (ConnectionResetError, asyncio.IncompleteReadError,
-                    asyncio.CancelledError):
+                    asyncio.CancelledError) as e:
+                logging.warning(f'{self.addr} read payload error: {e}')
                 break
             # if MAX_LEN then a continuation packet is required
             if size == pc.MAX_LEN:
@@ -201,15 +202,21 @@ class BusServer:
             try:
                 tag = BusTags._tag_by_id[tag_id]
             except KeyError:
+                logging.warning(f'RTA KeyError {tag_id}')
                 self.connections[bus_id].write(
                     pc.COMMAND.ERR, tag_id, time_us,
                     f"RTA KeyError {tag_id}".encode())
+                return
             try:
+                logging.info(f'RTA forwarding {tag.name} from_bus={tag.from_bus} '
+                            f'to bus_id={tag.from_bus}')
                 self.connections[tag.from_bus].write(
                     pc.COMMAND.RTA, tag_id, tag.time_us, data)
             except KeyError:
-                logging.warning(f'likely busclient for {tag.name} is gone')
+                logging.warning(f'RTA forwarding failed: busclient for '
+                              f'{tag.name} (from_bus={tag.from_bus}) is gone')
             except Exception as e:
+                logging.warning(f'RTA forwarding error {tag.name}: {e}')
                 self.connections[bus_id].write(
                     pc.COMMAND.ERR, tag_id, time_us,
                     f"RTA {tag_id} {e}".encode())
@@ -283,11 +290,13 @@ class BusServer:
                 self.bus_tag.value = f'\x03{client_addr}: {log_msg}'.encode()
                 self.bus_tag.time_us = int(time.time() * 1e6)
         else:  # consider disconnecting
-            logging.warn(f'invalid message {cmd}')
+            logging.warning(f'invalid message {cmd}')
 
     def read_callback(self, command):
         """Process read messages, delete broken connections."""
         bus_id, cmd, tag_id, time_us, data = command
+        logging.info(f'recv cmd={cmd} tag_id={tag_id} bus_id={bus_id} '
+                     f'size={(0 if data is None else len(data))}')
         if cmd is None:
             # Clean up tag subscriptions before deleting it
             for tag in BusTags._tag_by_id.values():