pymscada 0.2.0rc2__tar.gz → 0.2.0rc4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pymscada
-Version: 0.2.0rc2
+Version: 0.2.0rc4
 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
@@ -17,7 +17,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: PyYAML>=6.0.1
 Requires-Dist: aiohttp>=3.8.5
-Requires-Dist: pymscada-html==0.2.0rc2
+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

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

@@ -1,6 +1,6 @@
 [project]
 name = "pymscada"
-version = "0.2.0rc2"
+version = "0.2.0rc4"
 description = "Shared tag value SCADA with python backup and Angular UI"
 authors = [
     {name = "Jamie Walton", email = "jamie@walton.net.nz"},
@@ -8,7 +8,7 @@ authors = [
 dependencies = [
     "PyYAML>=6.0.1",          # all
     "aiohttp>=3.8.5",         # www_server
-    "pymscada-html==0.2.0rc2",   # www_server
+    "pymscada-html==0.2.0rc4",   # www_server
     "cerberus>=1.3.5",        # validate
     "pycomm3>=1.2.14",        # logix_client
     "pysnmplib>=5.0.24",      # DON'T use pysnmp, dead

pymscada-0.2.0rc4/src/pymscada/alarms.py

@@ -0,0 +1,358 @@
+"""Alarms handling."""
+import logging
+import sqlite3  # note that sqlite3 has blocking calls
+import socket
+import time
+import atexit
+from pymscada.bus_client import BusClient
+from pymscada.tag import Tag, TYPES
+
+ALM = 0
+RTN = 1
+ACT = 2
+INF = 3
+
+NORMAL = 0
+ALARM = 1
+
+
+def standardise_tag_info(tagname: str, tag: dict):
+    """Correct tag dictionary in place to be suitable for modules."""
+    tag['name'] = tagname
+    tag['id'] = None
+    if 'desc' not in tag:
+        logging.warning(f"Tag {tagname} has no description, using name")
+        tag['desc'] = tag['name']
+    if 'multi' in tag:
+        tag['type'] = int
+    else:
+        if 'type' not in tag:
+            tag['type'] = float
+        else:
+            if tag['type'] not in TYPES:
+                tag['type'] = str
+            else:
+                tag['type'] = TYPES[tag['type']]
+    if 'dp' not in tag:
+        if tag['type'] == int:
+            tag['dp'] = 0
+        else:
+            tag['dp'] = 2
+    if 'units' not in tag:
+        tag['units'] = ''
+
+
+class Alarm:
+    """Manages multiple alarm conditions for a single tag."""
+    def __init__(self, tag: Tag, conditions: str | list[str]):
+        """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
+
+
+class Alarms:
+    """Connect to bus_ip:bus_port, store and provide Alarms."""
+
+    def __init__(
+        self,
+        bus_ip: str | None = '127.0.0.1',
+        bus_port: int | None = 1324,
+        db: str | None = None,
+        table: str = 'alarms',
+        tag_info: dict[str, dict] = {},
+        rta_tag: str = '__alarms__'
+    ) -> None:
+        """
+        Connect to bus_ip:bus_port, serve and update alarms database.
+
+        Open an Alarms table, creating if necessary. Provide additions
+        and history requests via the rta_tag.
+
+        Event loop must be running.
+
+        For testing only: bus_ip can be None to skip connection.
+        """
+        if db is None:
+            raise SystemExit('Alarms db must be defined')
+        if bus_ip is None:
+            logging.warning('Alarms 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')
+        if not isinstance(table, str) or not table:
+            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] = {}
+        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()
+        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]
+
+    def _init_table(self):
+        """Initialize the database table schema."""
+        query = (
+            'CREATE TABLE IF NOT EXISTS ' + self.table +
+            '(id INTEGER PRIMARY KEY ASC, '
+            'date_ms INTEGER, '
+            'tag_alm TEXT, '
+            'kind INTEGER, '
+            'desc TEXT, '
+            'in_alm INTEGER)'
+        )
+        self.cursor.execute(query)
+        
+        # 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,
+            'kind': INF,
+            'desc': 'Alarm logging started',
+            'in_alm': NORMAL
+        }
+        self.rta_cb(startup_record)
+
+    def rta_cb(self, request):
+        """Respond to Request to Author and publish on rta_tag as needed."""
+        if 'action' not in request:
+            logging.warning(f'rta_cb malformed {request}')
+        elif request['action'] == 'ADD':
+            try:
+                logging.info(f'add {request}')
+                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) '
+                        'RETURNING *;',
+                        request)
+                    res = self.cursor.fetchone()
+                    self.rta.value = {
+                        'id': res[0],
+                        'date_ms': res[1],
+                        'tag_alm': res[2],
+                        'kind': res[3],
+                        'desc': res[4],
+                        'in_alm': res[5]
+                    }
+            except sqlite3.IntegrityError as error:
+                logging.warning(f'Alarms rta_cb {error}')
+        elif request['action'] == 'UPDATE':
+            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],
+                            'tag_alm': res[2],
+                            'kind': res[3],
+                            'desc': res[4],
+                            'in_alm': res[5]
+                        }
+            except sqlite3.IntegrityError as error:
+                logging.warning(f'Alarms rta_cb update {error}')
+        elif request['action'] == 'HISTORY':
+            try:
+                logging.info(f'history {request}')
+                with self.connection:
+                    self.cursor.execute(
+                        f'SELECT * FROM {self.table} WHERE date_ms > :date_ms '
+                        'ORDER BY (date_ms - :date_ms);', request)
+                    for res in self.cursor.fetchall():
+                        self.rta.value = {
+                            '__rta_id__': request['__rta_id__'],
+                            'id': res[0],
+                            'date_ms': res[1],
+                            'tag_alm': res[2],
+                            'kind': res[3],
+                            'desc': res[4],
+                            'in_alm': res[5]
+                        }
+            except sqlite3.IntegrityError as error:
+                logging.warning(f'Alarms rta_cb {error}')
+        elif request['action'] == 'BULK HISTORY':
+            try:
+                logging.info(f'bulk history {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}
+            except sqlite3.IntegrityError as error:
+                logging.warning(f'Alarms rta_cb {error}')
+        elif request['action'] == 'IN ALARM':
+            self.rta.value = {'__rta_id__': request['__rta_id__'],
+                              'data': {'in_alarm': list(self.in_alarm)}}
+
+    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}')

pymscada-0.2.0rc4/src/pymscada/demo/alarms.yaml

@@ -0,0 +1,5 @@
+bus_ip: 127.0.0.1
+bus_port: 1324
+rta_tag: __alarms__
+db: __HOME__/config/pymscada-alarms.sqlite
+table: alarms

pymscada-0.2.0rc4/src/pymscada/demo/pymscada-alarms.service

@@ -0,0 +1,16 @@
+[Unit]
+    Description=pymscada - alarms
+    BindsTo=pymscada-bus.service
+    After=pymscada-bus.service
+
+[Service]
+    WorkingDirectory=__DIR__
+    ExecStart=__PYMSCADA__ alarms --config __DIR__/config/alarms.yaml --tags __DIR__/config/tags.yaml
+    Restart=always
+    RestartSec=5
+    User=__USER__
+    Group=__USER__
+    KillSignal=SIGINT
+
+[Install]
+    WantedBy=multi-user.target

{pymscada-0.2.0rc2 → pymscada-0.2.0rc4}/src/pymscada/history.py

@@ -28,7 +28,7 @@ import time
 import socket
 from typing import TypedDict, Optional
 from pymscada.bus_client import BusClient
-from pymscada.tag import Tag, TagInfo, TYPES
+from pymscada.tag import Tag, TYPES
 
 
 ITEM_SIZE = 16  # Q + q, Q or d
@@ -37,21 +37,12 @@ CHUNK_SIZE = ITEM_COUNT * ITEM_SIZE
 FILE_CHUNKS = 64
 
 
-class Request(TypedDict, total=False):
-    """Type definition for request dictionary."""
-    tagname: str 
-    start_ms: Optional[int]  # Allow web client to use native ms
-    start_us: Optional[int]  # Native for pymscada server
-    end_ms: Optional[int]
-    end_us: Optional[int]
-    __rta_id__: Optional[int]  # Empty for a change that must be broadcast
-
-
-def tag_for_history(tagname: str, tag: dict):
-    """Correct tag dictionary in place to be suitable for web client."""
+def standardise_tag_info(tagname: str, tag: dict):
+    """Correct tag dictionary in place to be suitable for modules."""
     tag['name'] = tagname
     tag['id'] = None
     if 'desc' not in tag:
+        logging.warning(f"Tag {tagname} has no description, using name")
         tag['desc'] = tag['name']
     if 'multi' in tag:
         tag['type'] = int
@@ -71,6 +62,16 @@ def tag_for_history(tagname: str, tag: dict):
         tag['deadband'] = None
 
 
+class Request(TypedDict, total=False):
+    """Type definition for request dictionary."""
+    tagname: str 
+    start_ms: Optional[int]  # Allow web client to use native ms
+    start_us: Optional[int]  # Native for pymscada server
+    end_ms: Optional[int]
+    end_us: Optional[int]
+    __rta_id__: Optional[int]  # Empty for a change that must be broadcast
+
+
 def get_tag_hist_files(path: Path, tagname: str) -> dict[int, Path]:
     """Parse path for history files matching tagname."""
     files_us = {}
@@ -226,7 +227,7 @@ class History():
         bus_ip: str = '127.0.0.1',
         bus_port: int = 1324,
         path: str = 'history',
-        tag_info: TagInfo = {},
+        tag_info: dict[str, dict] = {},
         rta_tag: str | None = '__history__'
     ) -> None:
         """
@@ -260,7 +261,7 @@ class History():
         self.tags: dict[str, Tag] = {}
         self.hist_tags: dict[str, TagHistory] = {}
         for tagname, tag in tag_info.items():
-            tag_for_history(tagname, tag)
+            standardise_tag_info(tagname, tag)
             if tag['type'] not in [float, int]:
                 continue
             self.hist_tags[tagname] = TagHistory(

{pymscada-0.2.0rc2 → pymscada-0.2.0rc4}/src/pymscada/module_config.py

@@ -5,7 +5,6 @@ from textwrap import dedent
 from importlib.metadata import version
 import logging
 from pymscada.config import Config
-from pymscada.console import Console
 
 class ModuleArgument:
     def __init__(self, args: tuple[str, ...], kwargs: dict[str, Any]):
@@ -59,6 +58,11 @@ def create_module_registry():
             module_class='pymscada.opnotes:OpNotes',
             tags=False
         ),
+        ModuleDefinition(
+            name='alarms',
+            help='alarms',
+            module_class='pymscada.alarms:Alarms'
+        ),
         ModuleDefinition(
             name='validate',
             help='validate config files',

{pymscada-0.2.0rc2 → pymscada-0.2.0rc4}/src/pymscada/opnotes.py

@@ -24,17 +24,22 @@ class OpNotes:
         updates, deletions and history requests via the rta_tag.
 
         Event loop must be running.
+
+        For testing only: bus_ip can be None to skip connection.
         """
         if db is None:
             raise SystemExit('OpNotes db must be defined')
-        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 bus_ip is None:
+            logging.warning('OpNotes 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')
         if not isinstance(table, str) or not table:

{pymscada-0.2.0rc2 → pymscada-0.2.0rc4}/src/pymscada/tag.py

@@ -7,7 +7,6 @@ bus_id is python id(), 0 is null pointer in c, 0 is local bus.
 import time
 import array
 import logging
-from typing import TypedDict, Union, Optional, Type, List
 
 TYPES = {
     'int': int,
@@ -19,28 +18,6 @@ TYPES = {
 }
 
 
-def tag_for_web(tagname: str, tag: dict):
-    """Correct tag dictionary in place to be suitable for web client."""
-    tag['name'] = tagname
-    tag['id'] = None
-    if 'desc' not in tag:
-        tag['desc'] = tag.name
-    if 'multi' in tag:
-        tag['type'] = 'int'
-    else:
-        if 'type' not in tag:
-            tag['type'] = 'float'
-        else:
-            if tag['type'] not in TYPES:
-                tag['type'] = 'str'
-    if tag['type'] == 'int':
-        tag['dp'] = 0
-    elif tag['type'] == 'float' and 'dp' not in tag:
-        tag['dp'] = 2
-    elif tag['type'] == 'str' and 'dp' in tag:
-        del tag['dp']
-
-
 class UniqueTag(type):
     """Super Tag class only create unique tags for unique tag names."""
 
@@ -311,20 +288,3 @@ class Tag(metaclass=UniqueTag):
                 self.values = array.array('d')
         else:
             raise TypeError(f"shard invalid {self.name} not int, float")
-
-
-class TagInfo(TypedDict, total=False):
-    """Type definition for tag information dictionary."""
-    name: str 
-    id: Optional[int]
-    desc: str
-    type: Union[str, Type[int], Type[float], Type[str], Type[list],
-                Type[dict], Type[bytes]]
-    multi: Optional[List[str]]
-    min: Optional[Union[float, int]]
-    max: Optional[Union[float, int]]
-    deadband: Optional[Union[float, int]]
-    units: Optional[str]
-    dp: Optional[int]
-    format: Optional[str]
-    init: Optional[Union[int, float, str]]

{pymscada-0.2.0rc2 → pymscada-0.2.0rc4}/src/pymscada/www_server.py

@@ -8,10 +8,32 @@ import socket
 import time
 from pymscada.bus_client import BusClient
 import pymscada.protocol_constants as pc
-from pymscada.tag import Tag, tag_for_web, TYPES
+from pymscada.tag import Tag, TYPES
 from pymscada_html import get_html_file
 
 
+def standardise_tag_info(tagname: str, tag: dict):
+    """Correct tag dictionary in place to be suitable for web client."""
+    tag['name'] = tagname
+    tag['id'] = None
+    if 'desc' not in tag:
+        tag['desc'] = tagname
+    if 'multi' in tag:
+        tag['type'] = 'int'
+    else:
+        if 'type' not in tag:
+            tag['type'] = 'float'
+        else:
+            if tag['type'] not in TYPES:
+                tag['type'] = 'str'
+    if tag['type'] == 'int':
+        tag['dp'] = 0
+    elif tag['type'] == 'float' and 'dp' not in tag:
+        tag['dp'] = 2
+    elif tag['type'] == 'str' and 'dp' in tag:
+        del tag['dp']
+
+
 class Interface():
     """Provide an interface between web client rta and the action."""
 
@@ -36,12 +58,12 @@ class WSHandler():
 
     def __init__(self, ws: web.WebSocketResponse, pages: dict,
                  tag_info: dict[str, Tag], do_rta, interface: Interface,
-                 webclient: dict):
+                 config: dict):
         """Create callbacks to monitor tag values."""
         self.ws = ws
         self.pages = pages
         self.tag_info = tag_info
-        self.webclient = webclient
+        self.config = config
         self.tag_by_id: dict[int, Tag] = {}
         self.tag_by_name: dict[str, Tag] = {}
         self.queue = asyncio.Queue()
@@ -143,7 +165,7 @@ class WSHandler():
 
     def notify_id(self, tag: Tag):
         """Must be done here."""
-        logging.info(f'{self.rta_id}: send id to webclient for {tag.name}')
+        logging.info(f'{self.rta_id}: send id to browser for {tag.name}')
         self.tag_info[tag.name]['id'] = tag.id
         self.tag_by_id[tag.id] = tag
         self.tag_by_name[tag.name] = tag
@@ -172,7 +194,7 @@ class WSHandler():
         """Run while the connection is active and don't return."""
         send_queue = asyncio.create_task(self.send_queue())
         self.queue.put_nowait(
-            (False, {'type': 'webclient', 'payload': self.webclient}))
+            (False, {'type': 'config', 'payload': self.config}))
         self.queue.put_nowait(
             (False, {'type': 'pages', 'payload': self.pages}))
         async for msg in self.ws:
@@ -213,7 +235,7 @@ class WSHandler():
 
 
 class WwwServer:
-    """Connect to bus on bus_ip:bus_port, serve on ip:port for webclient."""
+    """Connect to bus on bus_ip:bus_port, serve on ip:port for webserver."""
 
     def __init__(
         self,
@@ -224,15 +246,15 @@ class WwwServer:
         get_path: str | None = None,
         tag_info: dict = {},
         pages: dict = {},
-        webclient: dict = {},
+        config: dict = {},
         serve_path: str | None = None,
         www_tag: str = '__wwwserver__'
     ) -> None:
         """
-        Connect to bus on bus_ip:bus_port, serve on ip:port for webclient.
+        Connect to bus on bus_ip:bus_port, serve on ip:port for webserver.
 
-        Serves the webclient files at /, as a relative path. The webclient uses
-        a websocket connection to request and set tag values and subscribe to
+        Serves the files at /, as a relative path. The browser uses a
+        websocket connection to request and set tag values and subscribe to
         changes.
 
         Event loop must be running.
@@ -263,10 +285,10 @@ class WwwServer:
         self.get_path = get_path
         self.serve_path = Path(serve_path) if serve_path else None
         for tagname, tag in tag_info.items():
-            tag_for_web(tagname, tag)
+            standardise_tag_info(tagname, tag)
         self.tag_info = tag_info
         self.pages = pages
-        self.webclient = webclient
+        self.config = config
         self.interface = Interface(www_tag)
 
     async def redirect_handler(self, _request: web.Request):
@@ -305,7 +327,7 @@ class WwwServer:
         ws = web.WebSocketResponse(max_msg_size=0)  # disables max message size
         await ws.prepare(request)
         await WSHandler(ws, self.pages, self.tag_info, self.busclient.rta,
-                        self.interface, self.webclient).connection_active()
+                        self.interface, self.config).connection_active()
         await ws.close()
         logging.info(f"WS closed {peer}")
         return ws

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pymscada
-Version: 0.2.0rc2
+Version: 0.2.0rc4
 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
@@ -17,7 +17,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: PyYAML>=6.0.1
 Requires-Dist: aiohttp>=3.8.5
-Requires-Dist: pymscada-html==0.2.0rc2
+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

{pymscada-0.2.0rc2 → pymscada-0.2.0rc4}/src/pymscada.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ README.md
 pyproject.toml
 src/pymscada/__init__.py
 src/pymscada/__main__.py
+src/pymscada/alarms.py
 src/pymscada/bus_client.py
 src/pymscada/bus_server.py
 src/pymscada/checkout.py
@@ -30,6 +31,7 @@ src/pymscada.egg-info/top_level.txt
 src/pymscada/demo/README.md
 src/pymscada/demo/__init__.py
 src/pymscada/demo/accuweather.yaml
+src/pymscada/demo/alarms.yaml
 src/pymscada/demo/bus.yaml
 src/pymscada/demo/files.yaml
 src/pymscada/demo/history.yaml
@@ -40,6 +42,7 @@ src/pymscada/demo/modbusserver.yaml
 src/pymscada/demo/openweather.yaml
 src/pymscada/demo/opnotes.yaml
 src/pymscada/demo/ping.yaml
+src/pymscada/demo/pymscada-alarms.service
 src/pymscada/demo/pymscada-bus.service
 src/pymscada/demo/pymscada-demo-modbus_plc.service
 src/pymscada/demo/pymscada-files.service
@@ -74,6 +77,7 @@ src/pymscada/pdf/two.pdf
 src/pymscada/pdf/__pycache__/__init__.cpython-311.pyc
 src/pymscada/tools/snmp_client2.py
 src/pymscada/tools/walk.py
+tests/test_alarms.py
 tests/test_bus_server.py
 tests/test_config.py
 tests/test_history.py

{pymscada-0.2.0rc2 → pymscada-0.2.0rc4}/src/pymscada.egg-info/requires.txt

@@ -1,6 +1,6 @@
 PyYAML>=6.0.1
 aiohttp>=3.8.5
-pymscada-html==0.2.0rc2
+pymscada-html==0.2.0rc4
 cerberus>=1.3.5
 pycomm3>=1.2.14
 pysnmplib>=5.0.24

pymscada-0.2.0rc4/tests/test_alarms.py

@@ -0,0 +1,128 @@
+"""Test Alarms."""
+from pathlib import Path
+import pytest
+from pymscada.alarms import Alarms, ALM, RTN, ACT, INF
+from pymscada.tag import Tag
+
+
+@pytest.fixture(scope='module')
+def alarms_db():
+    """Create a fixture for DB access."""
+    tag_info = {
+        'localhost_ping': {
+            'desc': 'Ping time to localhost',
+            'units': 'ms',
+            'alarm': '> 2',
+            'type': 'float',
+        }
+    }
+    Path('tests/test_assets/alarms.sqlite').unlink(missing_ok=True)
+    return Alarms(bus_ip=None, bus_port=None,
+                 db='tests/test_assets/alarms.sqlite',
+                 tag_info=tag_info)
+
+
+@pytest.fixture(scope='module')
+def alarms_tag():
+    """Create the RTA tag."""
+    return Tag('__alarms__', dict)
+
+
+@pytest.fixture(scope='module')
+def reply_tag():
+    """Create the reply tag."""
+    return Tag('__wwwserver__', dict)
+
+
+def test_db_and_tag(alarms_db, alarms_tag):
+    """Basic tests."""
+    db = alarms_db
+    tag = alarms_tag  # Alarms sets the tag value for www clients.
+
+    db._init_table()
+    
+    # Verify startup record was created
+    assert tag.value['kind'] == 3  # INF
+    assert 'Alarm logging started' in tag.value['desc']
+    
+    # Test adding an alarm
+    record = {
+        'action': 'ADD',
+        'tagname': 'TEST_TAG',
+        'date_ms': 1234567890123,
+        'kind': ALM,
+        'desc': 'Test alarm condition'
+    }
+    db.rta_cb(record)
+    assert tag.value['id'] == 2  # Second record after startup
+    assert tag.value['kind'] == 0
+    assert tag.value['desc'] == 'Test alarm condition'
+
+
+def test_history_queries(alarms_db, alarms_tag, reply_tag):
+    """Test history queries."""
+    BUSID = 999
+    db = alarms_db
+    a_tag: Tag = alarms_tag
+    a_values = []
+
+    def a_cb(tag):
+        a_values.append(tag.value)
+
+    a_tag.add_callback(a_cb, BUSID)
+    
+    # Add some test records
+    record = {
+        'action': 'ADD',
+        'tagname': 'TEST_TAG',
+        'date_ms': 12345,
+        'kind': ALM,
+        'desc': 'Test alarm'
+    }
+    
+    for i in range(10):
+        record['date_ms'] -= 1
+        record['transition'] = i % 4  # Cycle through transitions
+        db.rta_cb(record)
+    
+    rq = {
+        '__rta_id__': BUSID,
+        'action': 'HISTORY',
+        'date_ms': 12345 - 5.1,
+        'reply_tag': '__wwwserver__'
+    }
+    db.rta_cb(rq)
+    assert a_values[10]['date_ms'] == 12340
+    assert a_values[-1]['desc'] == 'Alarm logging started'
+
+    db.close()
+    assert a_values[-1]['kind'] == INF
+    assert a_values[-1]['desc'] == 'Alarm logging stopped'
+
+
+def test_alarm_tag(alarms_db, alarms_tag):
+    """Test alarm tag callback."""
+    BUSID = 999
+    db = alarms_db
+    db._init_table()
+    a_tag = alarms_tag
+    a_values = []
+
+    def a_cb(tag):
+        a_values.append(tag.value)
+
+    a_tag.add_callback(a_cb, BUSID)
+
+    ping_tag = db.tags['localhost_ping']
+    ping_tag.value = (3.0, 12345000, BUSID)
+    rq = {
+        '__rta_id__': BUSID,
+        'action': 'HISTORY',
+        'date_ms': 10000,
+        'reply_tag': '__wwwserver__'
+    }
+    db.rta_cb(rq)
+    for record in a_values:
+        if record['tagname'] == 'localhost_ping':
+            assert record['kind'] == ALM
+            assert record['desc'] == 'Ping time to localhost 3.0'

{pymscada-0.2.0rc2 → pymscada-0.2.0rc4}/tests/test_opnotes.py

@@ -11,8 +11,7 @@ from pymscada.tag import Tag
 def opnotes_db():
     """Create a fixture for DB access."""
     Path('tests/test_assets/db.sqlite').unlink(missing_ok=True)
-    return OpNotes(bus_ip=None, bus_port=None,
-                   db='tests/test_assets/db.sqlite')
+    return OpNotes(bus_ip=None, db='tests/test_assets/db.sqlite')
 
 
 @pytest.fixture(scope='module')

{pymscada-0.2.0rc2 → pymscada-0.2.0rc4}/tests/test_periodic.py

@@ -34,11 +34,11 @@ async def test_periodic():
 
 @pytest.mark.asyncio()
 async def test_timechange():
-    """Periodic should run four times in 0.41 seconds."""
+    """Periodic should run four times in 0.42 seconds."""
     resetflag()
     periodic = Periodic(do_period, 0.1)
     await periodic.start()
-    await asyncio.sleep(0.21)
+    await asyncio.sleep(0.22)
     periodic.period = 0.3
     await asyncio.sleep(0.2)
     await periodic.stop()