pymscada 0.2.5__tar.gz → 0.2.6b4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymscada
-Version: 0.2.5
+Version: 0.2.6b4
 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.6b4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pymscada"
-version = "0.2.5"
+version = "0.2.6b4"
 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.6b4}/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.6b4}/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.6b4}/src/pymscada/bus_client.py

@@ -77,6 +77,10 @@ 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'
+                     f' 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,
@@ -84,6 +88,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 +104,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 +221,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.6b4}/src/pymscada/bus_server.py

@@ -111,7 +111,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 +122,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 +203,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())
@@ -288,6 +296,8 @@ class BusServer:
     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():

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