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

pymscada/callout.py

@@ -25,41 +25,72 @@ Operation:
 """
 
 ALM = 0
+RTN = 1
+
 IDLE = 0
 NEW_ALM = 1
 CALLOUT = 2
 
+SENT = 0
+REMIND = 1
 
-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
 
+class CalloutCallee:
+    """Track status of callee for callout."""
 
-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
+    def __init__(self, callee: dict):
+        if not isinstance(callee, dict) or 'name' not in callee or \
+                'sms' not in callee:
+            logging.warning(f'Callee malformed {callee}')
+            return
+        self.name = callee['name']
+        self.sms = callee['sms']
+        self.role = callee.get('role', '')
+        self.group = callee.get('group', '')
+        self.delay_ms = 0
+
+    def set_role(self, role: str, delay_ms: int):
+        self.role = role
+        self.delay_ms = delay_ms
+
+    def set_group(self, group: str):
+        self.group = group
+
+
+class CalloutAlarm:
+    """Track status of alarm for callout."""
+
+    def __init__(self, alm_tag_value):
+        if not isinstance(alm_tag_value, dict) or \
+                'date_ms' not in alm_tag_value or \
+                'alarm_string' not in alm_tag_value or \
+                'desc' not in alm_tag_value or \
+                'group' not in alm_tag_value or \
+                'kind' not in alm_tag_value:
+            logging.warning(f'alarms_cb malformed {alm_tag_value}')
+            raise ValueError(f'alarms_cb malformed {alm_tag_value}')
+        self.date_ms = alm_tag_value['date_ms']
+        self.alarm_string = alm_tag_value['alarm_string']
+        self.desc = alm_tag_value['desc']
+        self.group = alm_tag_value['group']
+        self.sent: set[CalloutCallee] = set()
+        self.remind: set[CalloutCallee] = set()
+
+    def callee_in_group(self, callee: CalloutCallee, groups: dict):
+        if callee.group == '':
+            return True
+        if callee.group not in groups:
+            return False
+        group = groups[callee.group]
+        if 'tagnames' in group:
+            for tagname in group['tagnames']:
+                if self.alarm_string.startswith(tagname):
+                    return True
+        if 'groups' in group:
+            for group in group['groups']:
+                if self.group in group:
+                    return True
+        return False
 
 
 class Callout:
@@ -71,10 +102,13 @@ class Callout:
         bus_port: int | None = 1324,
         rta_tag: str = '__callout__',
         alarms_tag: str | None = None,
+        sms_send_tag: str | None = None,
+        sms_recv_tag: str | None = None,
         ack_tag: str | None = None,
         status_tag: str | None = None,
-        callees: list | None = None,
-        groups: list | None = None
+        callees: list = [],
+        groups: dict = {},
+        escalation: dict = {}
     ) -> None:
         """
         Connect to bus_ip:bus_port, monitor alarms and manage callouts.
@@ -99,106 +133,169 @@ class Callout:
                 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')
+        if alarms_tag is None:
+            raise ValueError('alarms_tag must be defined')
+        if sms_send_tag is None:
+            raise ValueError('sms_send_tag must be defined')
+        if sms_recv_tag is None:
+            raise ValueError('sms_recv_tag must be defined')
 
-        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
+        logging.warning(f'Callout {bus_ip} {bus_port} {rta_tag} '
+                        f'{sms_send_tag} {sms_recv_tag}')
+        self.callees: list[CalloutCallee] = []
+        for callee in callees:
+            self.callees.append(CalloutCallee(callee))
+        self.groups = groups
+        self.escalation = escalation
+        self.alarms: list[CalloutAlarm] = []
+        self.alarms_tag = Tag(alarms_tag, dict)
+        self.alarms_tag.add_callback(self.alarms_cb)
+        self.sms_recv_tag = Tag(sms_recv_tag, dict)
+        self.sms_recv_tag.add_callback(self.sms_recv_cb)
+        self.sms_send_tag = Tag(sms_send_tag, dict)
+        if ack_tag is not None:
+            self.ack_tag = Tag(ack_tag, int)
+            self.ack_tag.add_callback(self.ack_cb)
         if status_tag is not None:
             self.status = Tag(status_tag, int)
-            self.status.value = IDLE
+        else:
+            self.status = None
         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.set_rta_value(rta_id=0)
         self.busclient.add_callback_rta(rta_tag, self.rta_cb)
         self.periodic = Periodic(self.periodic_cb, 1.0)
 
-    def alarms_cb(self, request):
+    def set_rta_value(self, rta_id: int):
+        """Publish the current configuration to the RTA tag."""
+        callees = [{'name': callee.name, 'sms': callee.sms, 'role': callee.role,
+                    'group': callee.group, 'delay_ms': callee.delay_ms}
+                    for callee in self.callees]
+        self.rta.value = {'__rta_id__': rta_id,
+                          'callees': callees,
+                          'groups': self.groups,
+                          'escalation': list(self.escalation.keys())}
+
+    def alarms_cb(self, alm_tag):
         """Handle alarm messages from alarms.py."""
-        if request['kind'] != ALM:
+        if alm_tag.value['kind'] != ALM:
             return
-        alarm = {
-            'date_ms': request['date_ms'],
-            'alarm_string': request['alarm_string'],
-            'desc': request['desc'],
-            'group': request['group'],
-            'sent': {}
-        }
+        alarm = CalloutAlarm(alm_tag.value)
         self.alarms.append(alarm)
         logging.info(f'Added alarm to list: {alarm}')
+        if self.status is not None and self.status.value == IDLE:
+            self.status.value = NEW_ALM
 
-    def ack_cb(self, ack: str):
+    def ack_cb(self, ack_tag):
         """Handle ACK requests for alarm acknowledgment."""
-        if ack == '__all':
+        if ack_tag.value == 1:
             self.alarms = []
+            if self.status is not None:
+                self.status.value = IDLE
+            logging.info('ACK: all alarms cleared')
+
+    def sms_recv_cb(self, sms_recv_tag: Tag):
+        """Handle SMS messages from the modem."""
+        logging.info(f'sms_recv_cb {sms_recv_tag.value}')
+        if not isinstance(sms_recv_tag.value, dict) or \
+                'number' not in sms_recv_tag.value or \
+                'message' not in sms_recv_tag.value:
+            logging.warning(f'sms_recv_cb invalid {sms_recv_tag.value}')
             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
+        number = sms_recv_tag.value['number']
+        name = [callee.name for callee in self.callees if callee.sms == number][0]
+        message = sms_recv_tag.value['message'][:2].upper()
+        if message in ['OK', 'AC', 'TH']:
+            new_alarms = []
+            for alarm in self.alarms:
+                if name in alarm.sent:
+                    continue
+                new_alarms.append(alarm)
+            self.alarms = new_alarms
+            if self.status is not None:
+                self.status.value = IDLE
+            logging.info('ACK: all alarms cleared')
 
     def rta_cb(self, request):
         """Handle RTA requests for callout configuration."""
         logging.info(f'rta_cb {request}')
         if 'action' not in request:
             logging.warning(f'rta_cb malformed {request}')
-        elif request['action'] == 'ALL':
-            self.rta.value = {'callees': self.callees, 'groups': self.groups}
+            return
+        if request['action'] == 'GET CONFIG':
+            self.set_rta_value(rta_id=request['__rta_id__'])
         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."""
+                if callee.name == request['name']:
+                    if not 'role' in request and not 'group' in request:
+                        logging.warning(f'rta_cb invalid request: {request}')
+                        return
+                    role = request['role']
+                    group = request['group']
+                    valid_role = role == '' or role in self.escalation
+                    valid_group = group == '' or group in self.groups
+                    if not valid_role or not valid_group:
+                        logging.warning(f'rta_cb MODIFY invalid: {request}')
+                        return
+                    callee.set_role(role, self.escalation.get(role, 0))
+                    callee.set_group(group)
+            self.set_rta_value(rta_id=0)
+
+    def check_callee_messages(self, callee: CalloutCallee, time_ms):
+        if callee.role == '':
+            return ''
+        callee_alarms = set()
+        for alarm in self.alarms:
+            if alarm.callee_in_group(callee, self.groups):
+                callee_alarms.add(alarm)
+        notify_message = ''
+        remind_message = ''
+        notify_ms = time_ms - callee.delay_ms
+        remind_ms = notify_ms - 60000
+        notify = []
+        remind = []
+        for alarm in callee_alarms:
+            if not callee.name in alarm.sent and notify_ms > alarm.date_ms:
+                notify_message += f'{alarm.desc}\n'
+                alarm.sent.add(callee.name)
+            else:
+                notify.append(alarm)
+            if not callee.name in alarm.remind and remind_ms > alarm.date_ms:
+                remind_message += f'{alarm.desc}\n'
+                alarm.remind.add(callee.name)
+            else:
+                remind.append(alarm)
+        message = ''
+        if notify_message != '':
+            message += f'ALARMS\n{notify_message}'
+            for alarm in notify:
+                message += f'{alarm.desc}\n'
+                alarm.sent.add(callee.name)
+        if remind_message != '':
+            message += f'REMINDERS\n{remind_message}'
+            for alarm in remind:
+                message += f'{alarm.desc}\n'
+                alarm.remind.add(callee.name)
+        return message
+
+    def check_alarms(self):
+        """Check alarms for each callee."""
         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
+            message = self.check_callee_messages(callee, time_ms)
+            if message == '':
+                continue
+            logging.info(f'Sending message to {callee.name}: {message}')
+            self.sms_send_tag.value = {
+                'number': callee.sms,
+                'message': 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()
+        self.check_alarms()
 
     async def start(self):
         """Async startup."""

pymscada/config.py

@@ -2,6 +2,8 @@
 import importlib.resources
 from importlib.abc import Traversable
 import logging
+import os
+import re
 from pathlib import Path
 from yaml import safe_load_all, YAMLError
 from pymscada import demo, pdf
@@ -38,6 +40,21 @@ def get_pdf_files() -> list[Traversable]:
     return files
 
 
+def _expand_env_vars(value):
+    """Recursively expand environment variables in config values."""
+    if isinstance(value, str):
+        pattern = re.compile(r'\$\{([^}]+)\}')
+        def replace_env(match):
+            env_var = match.group(1)
+            return os.environ.get(env_var, match.group(0))
+        return pattern.sub(replace_env, value)
+    elif isinstance(value, dict):
+        return {k: _expand_env_vars(v) for k, v in value.items()}
+    elif isinstance(value, list):
+        return [_expand_env_vars(item) for item in value]
+    return value
+
+
 class Config(dict):
     """Read config from yaml file."""
 
@@ -55,7 +72,9 @@ class Config(dict):
         with open(fp, 'r') as fh:
             try:
                 for data in safe_load_all(fh):
+                    if '__vars__' in data:
+                        del data['__vars__']
                     for x in data:
-                        self[x] = data[x]
+                        self[x] = _expand_env_vars(data[x])
             except YAMLError as e:
                 raise SystemExit(f'failed to load {filename} {e}')

pymscada/console.py

@@ -1,6 +1,7 @@
 """Interactive console."""
 import asyncio
 import logging
+import os
 import sys
 from pymscada.bus_client import BusClient
 from pymscada.tag import Tag
@@ -123,6 +124,10 @@ class ConsoleWriter:
         """Init."""
         self.edit = None
         self.cursor = 0
+        # Make stdout non-blocking to avoid BlockingIOError in async context
+        import fcntl
+        flags = fcntl.fcntl(sys.stdout.fileno(), fcntl.F_GETFL)
+        fcntl.fcntl(sys.stdout.fileno(), fcntl.F_SETFL, flags | os.O_NONBLOCK)
 
     def write(self, data: bytes):
         """Stream writer, primarily for logging."""
@@ -132,22 +137,30 @@ class ConsoleWriter:
         ln = EC.cr_clr + data + b'\r\n'
         if self.edit is not None:
             ln += EC.cr_clr + self.edit + EC.mv_left + cursor_str
-        sys.stdout.buffer.write(ln)
-        sys.stdout.flush()
+        try:
+            os.write(sys.stdout.fileno(), ln)
+        except BlockingIOError:
+            # If stdout buffer is full, skip this write to avoid blocking
+            pass
 
     def edit_line(self, edit: bytes, cursor: int):
         """Update the edit line and cursor position."""
         self.edit = edit
         if self.edit is None:
-            sys.stdout.buffer.write(b'\r\n')
-            sys.stdout.flush()
+            try:
+                os.write(sys.stdout.fileno(), b'\r\n')
+            except BlockingIOError:
+                pass
             return
         self.cursor = cursor
         ln = EC.cr_clr + self.edit + EC.mv_left
         if self.cursor > 0:
             ln += b'\x1b[' + str(self.cursor).encode() + b'C'
-        sys.stdout.buffer.write(ln)
-        sys.stdout.flush()
+        try:
+            os.write(sys.stdout.fileno(), ln)
+        except BlockingIOError:
+            # If stdout buffer is full, skip this write to avoid blocking
+            pass
 
 
 class Console:

pymscada/demo/callout.yaml

@@ -2,8 +2,15 @@ bus_ip: 127.0.0.1
 bus_port: 1324
 rta_tag: __callout__
 alarms_tag: __alarms__
+sms_send_tag: __sms_send__
+sms_recv_tag: __sms_recv__
 ack_tag: SI_Alarm_Ack
 status_tag: SO_Alarm_Status
+escalation:
+- OnCall: 60000
+- Backup 1: 180000
+- Backup 2: 300000
+- Escalate: 600000
 callees:
 - name: A name
   sms: A number
@@ -11,7 +18,9 @@ callees:
 - name: B name
   sms: B number
 groups:
-- name: Aniwhenua Station
-  group:
-- name: Aniwhenua System
-  group: System
+  Wind:
+    tagnames: [Mt, Fh]
+  System:
+    groups: [__system__, Comms]
+  Test:
+    tagnames: [alarm]

pymscada/demo/files.yaml

@@ -3,8 +3,9 @@ bus_port: 1324
 path: __HOME__
 files:
 - path: pdf/one.pdf
-  desc: PDF
+  desc: One PDF
 - path: pdf/two.pdf
-  desc: PDF
+  desc: Two PDF
+- path: pdf/*.pdf
 - path: config/*.yaml
 - path: history/*.dat

pymscada/demo/openweather.yaml

@@ -2,7 +2,8 @@ bus_ip: 127.0.0.1
 bus_port: 1324
 proxy:
 api:
-  api_key: ${OPENWEATHERMAP_API_KEY}
+  # tagnames are assigned by location_parameter, i.e. Murupara_Temp
+  api_key: ${MSCADA_OPENWEATHERMAP_API_KEY}
   units: metric
   locations:
     Murupara:
@@ -13,13 +14,4 @@ api:
   - Temp
   - WindSpeed
   - WindDir
-  - Rain
-tags:
-  - Murupara_Temp
-  - Murupara_WindSpeed
-  - Murupara_WindDir
-  - Murupara_Rain
-  - Murupara_Temp_03
-  - Murupara_WindSpeed_03
-  - Murupara_WindDir_03
-  - Murupara_Rain_03
+  - Rain

pymscada/demo/piapi.yaml

@@ -0,0 +1,15 @@
+bus_ip: 127.0.0.1
+bus_port: 1324
+proxy:
+api:
+  url: ${MSCADA_PI_URL}
+  webid: ${MSCADA_PI_WEBID}
+  averaging: 300
+tags:
+  I_An_G1_MW:
+    pitag: AnG1.AIMw
+  I_An_G2_MW:
+    pitag: AnG2.AIMw
+  I_Ko_Gn_MW:
+    pitag: KoGn.AIkW
+    scale: 1000

pymscada/demo/pymscada-io-piapi.service

@@ -0,0 +1,15 @@
+[Unit]
+    Description=pymscada - OSI PI client
+    BindsTo=pymscada-bus.service
+    After=pymscada-bus.service
+
+[Service]
+    WorkingDirectory=__DIR__
+    ExecStart=__PYMSCADA__ witsapiclient --config __DIR__/config/piapi.yaml
+    Restart=always
+    RestartSec=5
+    User=__USER__
+    Group=__USER__
+
+[Install]
+    WantedBy=multi-user.target

pymscada/demo/pymscada-io-sms.service

@@ -0,0 +1,18 @@
+[Unit]
+    Description=pymscada - SMS client
+    BindsTo=pymscada-bus.service
+    After=pymscada-bus.service
+
+[Service]
+    Environment="MSCADA_SMS_IP=an_ip_address"
+    Environment="MSCADA_SMS_USERNAME=a_user"
+    Environment="MSCADA_SMS_PASSWORD=a_password"
+    WorkingDirectory=__DIR__
+    ExecStart=__PYMSCADA__ sms --config __DIR__/config/sms.yaml
+    Restart=always
+    RestartSec=5
+    User=root
+    Group=root
+
+[Install]
+    WantedBy=multi-user.target

pymscada/demo/sms.yaml

@@ -0,0 +1,11 @@
+bus_ip: 127.0.0.1
+bus_port: 1324
+sms_send_tag: __sms_send__
+sms_recv_tag: __sms_recv__
+modem: rut241
+modem_ip: ${MSCADA_SMS_IP}
+username: ${MSCADA_SMS_USERNAME}
+password: ${MSCADA_SMS_PASSWORD}
+listen_port: 8080
+info:
+  __default__: info

pymscada/demo/tags.yaml

@@ -13,6 +13,9 @@ __opnotes__:
 __alarms__:
   desc: Alarms
   type: dict
+info:
+  desc: Info
+  type: str
 IntSet:
   desc: Integer Setpoint
   type: int

pymscada/demo/witsapi.yaml

@@ -2,16 +2,14 @@ bus_ip: 127.0.0.1
 bus_port: 1324
 proxy:
 api:
-  url: 'https://api.electricityinfo.co.nz'
-  client_id: ${WITS_CLIENT_ID}
-  client_secret: ${WITS_CLIENT_SECRET}
+  # tagnames are assigned by gxp_list
+  # i.e. MAT1101, MAT1101_Realtime, MAT1101_Forecast
+  url: ${MSCADA_WITS_URL}
+  client_id: ${MSCADA_WITS_CLIENT_ID}
+  client_secret: ${MSCADA_WITS_CLIENT_SECRET}
   gxp_list:
     - MAT1101
     - CYD2201
     - BEN2201
   back: 1
-  forward: 12
-tags:
-  - MAT1101_RTD
-  - CYD2201_RTD
-  - BEN2201_RTD
+  forward: 12

pymscada/demo/wwwserver.yaml

@@ -1,9 +1,20 @@
+__vars__:
+- &primary_color darkmagenta
+- &secondary_color green
 bus_ip: 127.0.0.1
 bus_port: 1324
 ip: 0.0.0.0
 port: 8324
 get_path:
 serve_path: __HOME__
+config:
+  primary_color: *primary_color
+  secondary_color: *secondary_color
+  mscada_link: http://127.0.0.1/
+  people:
+  - name: John Smith
+    email: john.smith@example.com
+    phone: '+64not_a_number'
 pages:
 - name: Notes
   parent:
@@ -78,6 +89,10 @@ pages:
       scale: mS
       color: red
       dp: 1
+    bands:
+    - series: [localhost_ping, google_ping]
+      fill: [green, 0.3]
+      dir: 1
 - name: Weather
   parent:
   items:

pymscada/files.py

@@ -33,6 +33,7 @@ class Files():
         self.rta = Tag(rta_tag, dict)
         self.rta.value = {}
         self.busclient.add_callback_rta(rta_tag, self.rta_cb)
+        self.busclient.add_tag(self.rta)
 
     def rta_cb(self, request):
         """Respond to Request to Author and publish on rta_tag as needed."""