pymscada 0.2.5__tar.gz → 0.2.6b1__tar.gz

{pymscada-0.2.5/src/pymscada.egg-info → pymscada-0.2.6b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymscada
-Version: 0.2.5
+Version: 0.2.6b1
 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

{pymscada-0.2.5 → pymscada-0.2.6b1}/pyproject.toml

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

{pymscada-0.2.5 → pymscada-0.2.6b1}/src/pymscada/__init__.py

@@ -2,6 +2,7 @@
 from pymscada.bus_client import BusClient
 from pymscada.bus_server import BusServer
 from pymscada.config import Config
+from pymscada.callout import Callout, alarm_in_group, ALM
 from pymscada.iodrivers.accuweather import AccuWeatherClient
 from pymscada.iodrivers.logix_client import LogixClient
 from pymscada.iodrivers.modbus_client import ModbusClient
@@ -17,6 +18,7 @@ __all__ = [
     'BusClient',
     'BusServer',
     'Config',
+    'Callout', 'alarm_in_group', ALM,
     'AccuWeatherClient',
     'LogixClient',
     'ModbusClient',

{pymscada-0.2.5 → pymscada-0.2.6b1}/src/pymscada/alarms.py

@@ -11,6 +11,7 @@ ALM = 0
 RTN = 1
 ACT = 2
 INF = 3
+TIMING = 4
 KIND = {
     ALM: 'ALM',
     RTN: 'RTN',
@@ -75,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:
@@ -103,11 +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:
+                 state_cb) -> None:
         """Initialize alarm with tag and condition(s)."""
         self.alarm_id = f'{tagname} {alarm}'
         self.tag = Tag(tagname, tag['type'])
@@ -116,18 +116,16 @@ 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.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 == '>':
@@ -142,39 +140,19 @@ 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)
             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
-        })
+            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:
@@ -220,19 +198,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 = {'__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)
 
@@ -280,6 +259,37 @@ 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
+        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:
@@ -394,6 +404,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-0.2.5 → pymscada-0.2.6b1}/src/pymscada/bus_client.py

@@ -77,6 +77,9 @@ class BusClient:
         jsonstr = json.dumps(request).encode()
         size = len(jsonstr)
         data = struct.pack(f'>B{size}s', pc.TYPE.JSON, jsonstr)
+        action = request.get("action", "unknown")
+        tag_id = self.tag_by_name[tagname].id
+        logging.info(f'{self.module}: RTA sending {tagname} {action} to tag_id {tag_id}')
         self.write(pc.COMMAND.RTA, self.tag_by_name[tagname].id, time_us, data)
 
     def write(self, command: pc.COMMAND, tag_id: int, time_us: int,
@@ -209,10 +212,13 @@ class BusClient:
             data = struct.unpack_from(f'!{len(value) - 1}s', value, offset=1
                                       )[0].decode()
             data = json.loads(data)
+            action = data.get("action", "unknown")
+            logging.info(f'{self.module}: RTA received {tag.name} {action} '
+                        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-0.2.5 → pymscada-0.2.6b1}/src/pymscada/bus_server.py

@@ -201,15 +201,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())

{pymscada-0.2.5 → pymscada-0.2.6b1}/src/pymscada/callout.py

@@ -145,6 +145,7 @@ class Callout:
                           'groups': self.groups,
                           'escalation': self.escalation}
         self.busclient.add_callback_rta(rta_tag, self.rta_cb)
+        self.busclient.add_tag(self.rta)
         self.periodic = Periodic(self.periodic_cb, 1.0)
 
     def alarms_cb(self, alm_tag):

{pymscada-0.2.5 → pymscada-0.2.6b1}/src/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-0.2.5 → pymscada-0.2.6b1}/src/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-0.2.5 → pymscada-0.2.6b1}/src/pymscada/demo/openweather.yaml

@@ -2,6 +2,7 @@ bus_ip: 127.0.0.1
 bus_port: 1324
 proxy:
 api:
+  # tagnames are assigned by location_parameter, i.e. Murupara_Temp
   api_key: ${MSCADA_OPENWEATHERMAP_API_KEY}
   units: metric
   locations:
@@ -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-0.2.5 → pymscada-0.2.6b1}/src/pymscada/demo/piapi.yaml

@@ -2,8 +2,8 @@ bus_ip: 127.0.0.1
 bus_port: 1324
 proxy:
 api:
-  url: 'https://192.168.15.1/'
-  webid: F1Em9DA80Xftdkec1gdWFtX7NAm1eiSAyV8BG1mAAMKQIjRQUEdQSVxQSU9ORUVSXFdFQkFQSVxNT0JJTEVTQ0FEQQ
+  url: ${MSCADA_PI_URL}
+  webid: ${MSCADA_PI_WEBID}
   averaging: 300
 tags:
   I_An_G1_MW:

{pymscada-0.2.5 → pymscada-0.2.6b1}/src/pymscada/demo/witsapi.yaml

@@ -2,7 +2,9 @@ bus_ip: 127.0.0.1
 bus_port: 1324
 proxy:
 api:
-  url: 'https://api.electricityinfo.co.nz'
+  # 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:
@@ -10,8 +12,4 @@ api:
     - CYD2201
     - BEN2201
   back: 1
-  forward: 12
-tags:
-  - MAT1101_RTD
-  - CYD2201_RTD
-  - BEN2201_RTD
+  forward: 12

{pymscada-0.2.5 → pymscada-0.2.6b1}/src/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."""

{pymscada-0.2.5 → pymscada-0.2.6b1}/src/pymscada/history.py

@@ -272,6 +272,7 @@ class History():
         self.rta = Tag(rta_tag, bytes)
         self.rta.value = b'\x00\x00\x00\x00\x00\x00'  # rta_id is 0
         self.busclient.add_callback_rta(rta_tag, self.rta_cb)
+        self.busclient.add_tag(self.rta)
 
     def rta_cb(self, request: Request):
         """Respond to bus requests for data to publish on rta."""

{pymscada-0.2.5 → pymscada-0.2.6b1}/src/pymscada/opnotes.py

@@ -2,6 +2,7 @@
 import logging
 import sqlite3  # note that sqlite3 has blocking calls
 import socket
+from datetime import datetime
 from pymscada.bus_client import BusClient
 from pymscada.tag import Tag
 
@@ -54,6 +55,7 @@ class OpNotes:
         self.rta = Tag(rta_tag, dict)
         self.rta.value = {'__rta_id__': 0}
         self.busclient.add_callback_rta(rta_tag, self.rta_cb)
+        self.busclient.add_tag(self.rta)
 
     def _init_table(self):
         """Initialize or upgrade the database table schema."""
@@ -101,11 +103,14 @@ class OpNotes:
 
     def rta_cb(self, request):
         """Respond to Request to Author and publish on rta_tag as needed."""
+        local_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        logging.info(f'[{local_time}] RTA callback received: {request}')
+        
         if 'action' not in request:
             logging.warning(f'rta_cb malformed {request}')
         elif request['action'] == 'ADD':
             try:
-                logging.info(f'add {request}')
+                logging.info(f'[{local_time}] ADD request: {request}')
                 with self.connection:
                     self.cursor.execute(
                         f'INSERT INTO {self.table} '
@@ -114,7 +119,7 @@ class OpNotes:
                         'RETURNING *;',
                         request)
                     res = self.cursor.fetchone()
-                    self.rta.value = {
+                    response = {
                         '__rta_id__': 0,
                         'id': res[0],
                         'date_ms': res[1],
@@ -123,11 +128,13 @@ class OpNotes:
                         'note': res[4],
                         'abnormal': res[5]
                     }
+                    self.rta.value = response
+                    logging.info(f'[{local_time}] ADD response sent: {response}')
             except sqlite3.IntegrityError as error:
                 logging.warning(f'OpNotes rta_cb {error}')
         elif request['action'] == 'MODIFY':
             try:
-                logging.info(f'modify {request}')
+                logging.info(f'[{local_time}] MODIFY request: {request}')
                 with self.connection:
                     self.cursor.execute(
                         f'REPLACE INTO {self.table} VALUES(:id, :date_ms, '
@@ -146,7 +153,7 @@ class OpNotes:
                 logging.warning(f'OpNotes rta_cb {error}')
         elif request['action'] == 'DELETE':
             try:
-                logging.info(f'delete {request}')
+                logging.info(f'[{local_time}] DELETE request: {request}')
                 with self.connection:
                     self.cursor.execute(
                         f'DELETE FROM {self.table} WHERE id = :id;', request)
@@ -155,7 +162,7 @@ class OpNotes:
                 logging.warning(f'OpNotes rta_cb {error}')
         elif request['action'] == 'HISTORY':
             try:
-                logging.info(f'history {request}')
+                logging.info(f'[{local_time}] HISTORY request: {request}')
                 with self.connection:
                     self.cursor.execute(
                         f'SELECT * FROM {self.table} WHERE date_ms > :date_ms '
@@ -174,14 +181,15 @@ class OpNotes:
                 logging.warning(f'OpNotes rta_cb {error}')
         elif request['action'] == 'BULK HISTORY':
             try:
-                logging.info(f'bulk history {request}')
+                logging.info(f'[{local_time}] BULK HISTORY request: {request}')
                 with self.connection:
                     self.cursor.execute(
                         f'SELECT * FROM {self.table} WHERE date_ms > :date_ms '
                         'ORDER BY -date_ms;', request)
                     results = list(self.cursor.fetchall())
-                    self.rta.value = {'__rta_id__': request['__rta_id__'],
-                                      'data': results}
+                    response = {'__rta_id__': request['__rta_id__'], 'data': results}
+                    self.rta.value = response
+                    logging.info(f'[{local_time}] BULK HISTORY response sent: {len(results)} records for rta_id {request["__rta_id__"]}')
             except sqlite3.IntegrityError as error:
                 logging.warning(f'OpNotes rta_cb {error}')
 

{pymscada-0.2.5 → pymscada-0.2.6b1/src/pymscada.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymscada
-Version: 0.2.5
+Version: 0.2.6b1
 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

{pymscada-0.2.5 → pymscada-0.2.6b1}/tests/test_callout.py

@@ -1,6 +1,6 @@
 """Test Callout."""
 import pytest
-from pymscada.callout import Callout, alarm_in_callee_group, ALM
+from pymscada.callout import Callout, alarm_in_group, ALM
 
 
 BUS_ID = 123