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

pymscada/iodrivers/sms.py

@@ -0,0 +1,212 @@
+"""SMS to RUT241"""
+import asyncio
+from aiohttp import web, ClientSession
+import logging
+import socket
+from typing import Callable
+
+from pymscada.bus_client import BusClient
+from pymscada.misc import find_nodes
+from pymscada.periodic import Periodic
+from pymscada.tag import Tag
+
+
+class RUT241:
+    """RUT241 SMS modem."""
+    # disable RMS settings
+    # just use admin for api call, too damned obscure to configure
+    # need to configure SMS to http gateway for incoming SMS
+    # point to this server, use aiohttp to serve, awkward but
+    # by exception so fast and light
+    # set the http forward to use sms_number and sms_message
+    # If keeping it simple (i.e. limit to SMS and LAN)
+    # Network WAN - turn all off, LAN - static, Wireless - turn off
+    
+    
+    def __init__(self, ip: str = None, username: str = None,
+                 password: str = None, port: int = 8080,
+                 recv_cb: Callable = None, info: dict = {}):
+        if ip is None:
+            raise ValueError('ip is required')
+        if username is None:
+            raise ValueError('username is required')
+        if password is None:
+            raise ValueError('password is required')
+
+        self.ip = ip
+        self.username = username
+        self.password = password
+        self.port = port
+        self.recv_cb = recv_cb
+        self.tags = {}
+        for info, tagname in info.items():
+            self.tags[info] = Tag(tagname, str)
+        self.token = None
+        self.modem = None
+        self.carrier = None
+        self.webapp = None
+
+    async def login(self):
+        url = f'https://{self.ip}/api/login'
+        json = {'username': self.username,
+                'password': self.password}
+        headers = {'Content-Type': 'application/json'}
+        async with ClientSession() as session:
+            async with session.post(url, json=json, headers=headers,
+                    ssl=False) as response:
+                if response.status == 200:
+                    resp = await response.json()
+                    self.token = resp['data']['token']
+                    logging.info(f'RUT241 login token {self.token}')
+                else:
+                    logging.error(f'RUT241 login error {response.status} '
+                                  f'{response.text}')
+
+    async def get_modem_info(self):
+        if self.token is None:
+            await self.login()
+        if self.token is None:
+            return
+        url = f'https://{self.ip}/api/modems/apns/status'
+        headers = {'Authorization': f'Bearer {self.token}'}
+        async with ClientSession() as session:
+            async with session.get(url, headers=headers, ssl=False) as response:
+                if response.status == 200:
+                    resp = await response.json()
+                    self.modem = next(find_nodes('modem', resp))['modem']
+                    self.carrier = next(find_nodes('carrier', resp))['carrier']
+                    logging.info(f'RUT241 {self.modem} on {self.carrier}')
+                else:
+                    self.token = None
+                    logging.error(f'RUT241 lost token {response.status} '
+                                  f'{response.text}')
+
+    async def send_sms(self, phone: str, message: str):
+        url = f'https://{self.ip}/api/messages/actions/send'
+        headers = {'Authorization': f'Bearer {self.token}',
+                   'Content-Type': 'application/json'}
+        json = {'data': {
+                    'number': phone,
+                    'message': message,
+                    'modem': self.modem
+                }}
+        logging.info(f'RUT241 {json}')
+        async with ClientSession() as session:
+            async with session.post(url, headers=headers, json=json, ssl=False) as response:
+                if response.status == 200:
+                    resp = await response.json()
+                    logging.info(f'RUT241 {resp}')
+                else:
+                    logging.error(f'RUT241 {response.status} {response.text}')
+
+    async def listen_sms(self):
+        webserver = web.Application()
+        
+        async def post_handler(request):
+            data = await request.post()
+            if data['sms_message'][:2].upper() == 'IN':
+                tag = self.tags['__default__']
+                if tag.value is None:
+                    message = '__default__'
+                else:
+                    message = tag.value
+                asyncio.create_task(self.send_sms(data['sms_number'], message))
+                return web.Response(text='OK', status=200)
+            if self.recv_cb is not None:
+                self.recv_cb(dict(data))
+            return web.Response(text='OK', status=200)
+        
+        webserver.router.add_post('/', post_handler)
+        self.webapp = web.AppRunner(webserver)
+        await self.webapp.setup()
+        site = web.TCPSite(self.webapp, '0.0.0.0', self.port)
+        await site.start()
+
+    async def stop_listening(self):
+        if self.webapp is not None:
+            await self.webapp.cleanup()
+
+
+class SMS:
+    """Connect to SMS modem."""
+
+    def __init__(
+        self,
+        bus_ip: str | None = '127.0.0.1',
+        bus_port: int | None = 1324,
+        sms_send_tag: str = '__sms_send__',
+        sms_recv_tag: str = '__sms_recv__',
+        modem: str = 'rut241',
+        modem_ip: str | None = None,
+        username: str | None = None,
+        password: str | None = None,
+        listen_port: int | None = 8080,
+        info: dict = {}
+    ) -> None:
+        """
+        Connect to SMS, only RUT240 at the moment.
+        For testing bus_ip can be None to skip connection.
+        ip must be valid and reachable, check.
+        """
+        if bus_ip is None:
+            logging.warning('Callout 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(sms_send_tag, str) or not sms_send_tag:
+            raise ValueError('sms_send_tag must be a non-empty string')
+        if not isinstance(sms_recv_tag, str) or not sms_recv_tag:
+            raise ValueError('sms_recv_tag must be a non-empty string')
+        if modem == 'rut241':
+            self.modem = RUT241(ip=modem_ip, username=username,
+                                password=password, port=listen_port,
+                                recv_cb=self.sms_recv_cb, info=info)
+        else:
+            raise ValueError(f'Unknown modem type: {type}')
+
+        logging.warning(f'SMS {bus_ip} {bus_port} {sms_send_tag} '
+                        f'{sms_recv_tag}')
+        self.sms_send = Tag(sms_send_tag, dict)
+        self.sms_send.add_callback(self.sms_send_cb)
+        self.sms_recv = Tag(sms_recv_tag, dict)
+        self.tags = {}
+        for info, tagname in info.items():
+            self.tags[info] = Tag(tagname, str)
+        self.busclient = None
+        if bus_ip is not None:
+            self.busclient = BusClient(bus_ip, bus_port, module='SMS')
+        self.periodic = Periodic(self.periodic_cb, 60.0)
+
+    def sms_send_cb(self, tag: Tag):
+        """Handle SMS messages from the modem."""
+        if tag.value is None:
+            return
+        number = tag.value['number']
+        message = tag.value['message']
+        logging.info(f'Sending SMS to {number}: {message}')
+        asyncio.create_task(self.modem.send_sms(number, message))
+
+    def sms_recv_cb(self, value: dict):
+        """Handle SMS messages from the modem."""
+        self.sms_recv.value = {
+            'number': value['sms_number'],
+            'message': value['sms_message']
+        }
+
+    async def periodic_cb(self):
+        """Periodic callback to check alarms and send callouts."""
+        await self.modem.get_modem_info()
+
+    async def start(self):
+        """Async startup."""
+        if self.busclient is not None:
+            await self.busclient.start()
+        await self.modem.get_modem_info()
+        await self.modem.listen_sms()
+        await self.periodic.start()

pymscada/iodrivers/witsapi.py

@@ -17,8 +17,7 @@ class WitsAPIClient:
         bus_ip: str | None = '127.0.0.1',
         bus_port: int = 1324,
         proxy: str | None = None,
-        api: dict = {},
-        tags: list = []
+        api: dict = {}
     ) -> None:
         """
         Connect to bus on bus_ip:bus_port.
@@ -41,21 +40,21 @@ class WitsAPIClient:
             raise ValueError("proxy must be a string or None")
         if not isinstance(api, dict):
             raise ValueError("api must be a dictionary")
-        if not isinstance(tags, list):
-            raise ValueError("tags must be a list")
 
         self.busclient = None
         if bus_ip is not None:
             self.busclient = BusClient(bus_ip, bus_port, module='WitsAPI')
         self.proxy = proxy
-        self.map_bus = id(self)
-        self.tags = {tagname: Tag(tagname, float) for tagname in tags}
-        
+        self.tags = {}
         # API configuration
         self.client_id = api['client_id']
         self.client_secret = api['client_secret']
         self.base_url = api['url']
         self.gxp_list = api.get('gxp_list', [])
+        for gxp in self.gxp_list:
+            self.tags[gxp] = Tag(gxp, float)
+            self.tags[f"{gxp}_Realtime"] = Tag(f"{gxp}_Realtime", float)
+            self.tags[f"{gxp}_Forecast"] = Tag(f"{gxp}_Forecast", float)
         self.back = api.get('back', 2)
         self.forward = api.get('forward', 72)
         
@@ -146,34 +145,26 @@ class WitsAPIClient:
 
     def update_tags(self, prices):
         """Update tags with price data"""
-        for node in prices:
-            rtd = {}
-            for trading_time in prices[node]:
-                if 'RTD' in prices[node][trading_time]:
-                    rtd_price, _ = prices[node][trading_time]['RTD']
-                    rtd[trading_time] = rtd_price
-                    continue
-                prss_price = None
-                prsl_price = None
-                if 'PRSS' in prices[node][trading_time]:
-                    prss_price, prss_last_run = prices[node][trading_time]['PRSS']
-                if 'PRSL' in prices[node][trading_time]:
-                    prsl_price, prsl_last_run = prices[node][trading_time]['PRSL']
-                if prsl_price is not None and prss_price is not None:
-                    if prss_last_run > prsl_last_run:
-                        rtd[trading_time] = prss_price
-                    else:
-                        rtd[trading_time] = prsl_price
-                    continue
-                if prss_price is not None:
-                    rtd[trading_time] = prss_price
-                elif prsl_price is not None:
-                    rtd[trading_time] = prsl_price
-            tagname = f"{node}_RTD"
-            if tagname in self.tags:
-                for trading_time in sorted(rtd.keys()):
-                    time_us = int(trading_time * 1_000_000)
-                    self.tags[tagname].value = rtd[trading_time], time_us, self.map_bus
+        tags = self.tags
+        for tagname, data in prices.items():
+            realtime = f"{tagname}_Realtime"
+            forecast = f"{tagname}_Forecast"
+            times = sorted(prices[tagname].keys())
+            for time_s in times:
+                time_us = int(time_s * 1_000_000)
+                if 'RTD' in data[time_s]:
+                    value, _ = data[time_s]['RTD']
+                    if True or time_us > tags[realtime].time_us:
+                        tags[realtime].value = value, time_us
+                        tags[tagname].value = value, time_us
+                if 'PRSS' in data[time_s]:
+                    value, _ = data[time_s]['PRSS']
+                    tags[forecast].value = value, time_us
+                    tags[tagname].value = value, time_us
+                elif 'PRSL' in data[time_s]:
+                    value, _ = data[time_s]['PRSL']
+                    tags[forecast].value = value, time_us
+                    tags[tagname].value = value, time_us
 
     async def handle_response(self):
         """Handle responses from the API."""

pymscada/module_config.py

@@ -69,19 +69,6 @@ def create_module_registry():
             module_class='pymscada.callout:Callout',
             tags=False
         ),
-        ModuleDefinition(
-            name='validate',
-            help='validate config files',
-            module_class='pymscada.validate:validate',
-            config=False,
-            tags=False,
-            extra_args=[
-                ModuleArgument(
-                    ('--path',),
-                    {'metavar': 'file', 'help': 'default is current working directory'}
-                )
-            ]
-        ),
         ModuleDefinition(
             name='checkout',
             help='create example config files',
@@ -139,10 +126,23 @@ def create_module_registry():
             module_class='pymscada.iodrivers.openweather:OpenWeatherClient',
             tags=False,
             epilog=dedent("""
-                OPENWEATHERMAP_API_KEY can be set in the openweathermap.yaml
+                MSCADA_OPENWEATHERMAP_API_KEY can be set in the openweathermap.yaml
+                or as an environment variable:
+                  vi ~/.bashrc
+                  export MSCADA_OPENWEATHERMAP_API_KEY='1234567890'""")
+        ),
+        ModuleDefinition(
+            name='sms',
+            help='send and receive SMS messages through an RUT241 modem',
+            module_class='pymscada.iodrivers.sms:SMS',
+            tags=False,
+            epilog=dedent("""
+                MSCADA_SMS_IP, MSCADA_SMS_USERNAME, MSCADA_SMS_PASSWORD can be set in the sms.yaml
                 or as an environment variable:
                   vi ~/.bashrc
-                  export OPENWEATHERMAP_API_KEY='1234567890'""")
+                  export MSCADA_SMS_IP='192.168.1.2'
+                  export MSCADA_SMS_USERNAME='smsuser'
+                  export MSCADA_SMS_PASSWORD='smspass'""")
         ),
         ModuleDefinition(
             name='pingclient',
@@ -162,11 +162,17 @@ def create_module_registry():
             module_class='pymscada.iodrivers.witsapi:WitsAPIClient',
             tags=False,
             epilog=dedent("""
-                WITS_CLIENT_ID and WITS_CLIENT_SECRET can be set in the wits.yaml
+                MSCADA_WITS_CLIENT_ID and MSCADA_WITS_CLIENT_SECRET can be set in the wits.yaml
                 or as environment variables:
                   vi ~/.bashrc
-                  export WITS_CLIENT_ID='your_client_id'
-                  export WITS_CLIENT_SECRET='your_client_secret'""")
+                  export MSCADA_WITS_CLIENT_ID='your_client_id'
+                  export MSCADA_WITS_CLIENT_SECRET='your_client_secret'""")
+        ),
+        ModuleDefinition(
+            name='piapi',
+            help='poll WITS GXP pricing real time dispatch and forecast',
+            module_class='pymscada.iodrivers.piapi:PIWebAPIClient',
+            tags=False
         ),
         ModuleDefinition(
             name='console',

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
 
@@ -11,7 +12,7 @@ class OpNotes:
 
     def __init__(
         self,
-        bus_ip: str = '127.0.0.1',
+        bus_ip: str|None = '127.0.0.1',
         bus_port: int = 1324,
         db: str | None = None,
         table: str = 'opnotes',
@@ -52,7 +53,7 @@ class OpNotes:
         self._init_table()
         self.busclient = BusClient(bus_ip, bus_port, module='OpNotes')
         self.rta = Tag(rta_tag, dict)
-        self.rta.value = {}
+        self.rta.value = {'__rta_id__': 0}
         self.busclient.add_callback_rta(rta_tag, self.rta_cb)
 
     def _init_table(self):
@@ -101,12 +102,21 @@ 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}')
                 with self.connection:
+                    if not isinstance(request, dict) or \
+                            'date_ms' not in request or \
+                            'site' not in request or \
+                            'by' not in request or \
+                            'note' not in request or \
+                            'abnormal' not in request:
+                        logging.warning(f'rta_cb ADD malformed {request}')
+                        return
                     self.cursor.execute(
                         f'INSERT INTO {self.table} '
                         '(date_ms, site, by, note, abnormal) '
@@ -114,7 +124,8 @@ class OpNotes:
                         'RETURNING *;',
                         request)
                     res = self.cursor.fetchone()
-                    self.rta.value = {
+                    response = {
+                        '__rta_id__': 0,
                         'id': res[0],
                         'date_ms': res[1],
                         'site': res[2],
@@ -122,17 +133,27 @@ class OpNotes:
                         'note': res[4],
                         'abnormal': res[5]
                     }
-            except sqlite3.IntegrityError as error:
+                    self.rta.value = response
+            except sqlite3.Error as error:
                 logging.warning(f'OpNotes rta_cb {error}')
         elif request['action'] == 'MODIFY':
             try:
-                logging.info(f'modify {request}')
                 with self.connection:
+                    if not isinstance(request, dict) or \
+                            'id' not in request or \
+                            'date_ms' not in request or \
+                            'site' not in request or \
+                            'by' not in request or \
+                            'note' not in request or \
+                            'abnormal' not in request:
+                        logging.warning(f'rta_cb MODIFY malformed {request}')
+                        return
                     self.cursor.execute(
                         f'REPLACE INTO {self.table} VALUES(:id, :date_ms, '
                         ':site, :by, :note, :abnormal) RETURNING *;', request)
                     res = self.cursor.fetchone()
                     self.rta.value = {
+                        '__rta_id__': 0,
                         'id': res[0],
                         'date_ms': res[1],
                         'site': res[2],
@@ -140,20 +161,22 @@ class OpNotes:
                         'note': res[4],
                         'abnormal': res[5]
                     }
-            except sqlite3.IntegrityError as error:
+            except sqlite3.Error as error:
                 logging.warning(f'OpNotes rta_cb {error}')
         elif request['action'] == 'DELETE':
             try:
-                logging.info(f'delete {request}')
                 with self.connection:
+                    if not isinstance(request, dict) or \
+                            'id' not in request:
+                        logging.warning(f'rta_cb DELETE malformed {request}')
+                        return
                     self.cursor.execute(
                         f'DELETE FROM {self.table} WHERE id = :id;', request)
-                    self.rta.value = {'id': request['id']}
-            except sqlite3.IntegrityError as error:
+                    self.rta.value = {'__rta_id__': 0, 'id': request['id']}
+            except sqlite3.Error as error:
                 logging.warning(f'OpNotes rta_cb {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 '
@@ -168,19 +191,18 @@ class OpNotes:
                             'note': res[4],
                             'abnormal': res[5]
                         }
-            except sqlite3.IntegrityError as error:
+            except sqlite3.Error as error:
                 logging.warning(f'OpNotes 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:
+                    response = {'__rta_id__': request['__rta_id__'], 'data': results}
+                    self.rta.value = response
+            except sqlite3.Error as error:
                 logging.warning(f'OpNotes rta_cb {error}')
 
     async def start(self):

pymscada/tag.py

@@ -21,10 +21,10 @@ TYPES = {
 class UniqueTag(type):
     """Super Tag class only create unique tags for unique tag names."""
 
-    __cache = {}
+    __cache: dict[str, 'Tag'] = {}
     __notify = None
 
-    def __call__(cls, tagname: str, tagtype: type = None):
+    def __call__(cls, tagname: str, tagtype: type | None = None):
         """Each time a new tag is created, check if it is really new."""
         if tagname in cls.__cache:
             tag = cls.__cache[tagname]
@@ -33,8 +33,7 @@ class UniqueTag(type):
         else:
             if tagtype is None:
                 raise TypeError(f"{tagname} type is undefined.")
-            tag = cls.__new__(cls, tagname, tagtype)
-            tag.__init__(tagname, tagtype)
+            tag: Tag = super().__call__(tagname, tagtype)
             tag.id = None
             cls.__cache[tagname] = tag
             if cls.__notify is not None:
@@ -43,11 +42,11 @@ class UniqueTag(type):
 
     def tagnames(cls) -> list[str]:
         """Return all tagnames of class Tag."""
-        return cls.__cache.keys()
+        return cls.__cache.keys()  # type: ignore
 
-    def tags(cls) -> list:
+    def tags(cls) -> list['Tag']:
         """Return all tags of class Tag."""
-        return cls.__cache.values()
+        return cls.__cache.values()  # type: ignore
 
     def set_notify(cls, callback):
         """Set ONE routine to notify when new tags are added."""