pymscada 0.2.0rc8__py3-none-any.whl → 0.2.2__py3-none-any.whl

pymscada/iodrivers/piapi.py

@@ -0,0 +1,133 @@
+"""Poll OSI PI WebAPI for tag values."""
+import asyncio
+import aiohttp
+from datetime import datetime
+import logging
+import socket
+from time import time
+from pymscada.misc import find_nodes
+from pymscada.bus_client import BusClient
+from pymscada.periodic import Periodic
+from pymscada.tag import Tag
+
+class PIWebAPIClient:
+    """Get tag data from OSI PI WebAPI."""
+
+    def __init__(
+        self,
+        bus_ip: str | None = '127.0.0.1',
+        bus_port: int = 1324,
+        proxy: str | None = None,
+        api: dict = {},
+        tags: dict = {}
+    ) -> None:
+        """
+        Connect to bus on bus_ip:bus_port.
+
+        api dict should contain:
+        - url: PI WebAPI base URL
+        - webid: PI WebID for the stream set
+        - averaging: averaging period in seconds
+        
+        tags dict should contain:
+        - tagname: pitag mapping for each tag
+        """
+        if bus_ip is not None:
+            try:
+                socket.gethostbyname(bus_ip)
+            except socket.gaierror:
+                raise ValueError(f"Invalid bus_ip: {bus_ip}")
+        if not isinstance(proxy, str) and proxy is not None:
+            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, dict):
+            raise ValueError("tags must be a dictionary")
+
+        self.busclient = None
+        if bus_ip is not None:
+            self.busclient = BusClient(bus_ip, bus_port, module='PIWebAPI')
+        self.proxy = proxy
+        self.base_url = api['url'].rstrip('/')
+        self.webid = api['webid']
+        self.averaging = api.get('averaging', 300)
+        self.tags = {}
+        self.pitag_map = {}
+        self.scale = {}
+        for tagname, config in tags.items():
+            self.tags[tagname] = Tag(tagname, float)
+            self.pitag_map[config['pitag']] = tagname
+            if 'scale' in config:
+                self.scale[tagname] = config['scale']
+        self.session = None
+        self.handle = None
+        self.periodic = None
+        self.queue = asyncio.Queue()
+
+    def update_tags(self, pitag: str, values: list):
+        tag = self.tags[self.pitag_map[pitag]]
+        scale = None
+        if tag.name in self.scale:
+            scale = self.scale[tag.name]
+        data = {}
+        for item in values:
+            value = item['Value']
+            dt = datetime.fromisoformat(value['Timestamp'].replace('Z', '+00:00'))
+            time_us = int(dt.timestamp() * 1e6)
+            data[time_us] = value['Value']
+        times_us = sorted(data.keys())
+        for time_us in times_us:
+            if time_us > tag.time_us:
+                if data[time_us] is None:
+                    logging.error(f'{tag.name} is None at {time_us}')
+                    continue
+                if scale is not None:
+                    data[time_us] = data[time_us] / scale
+                tag.value = data[time_us], time_us
+
+    async def handle_response(self):
+        """Handle responses from the API."""
+        while True:
+            values = await self.queue.get()
+            for value in find_nodes('Name' , values):
+                if value['Name'] in self.pitag_map:
+                    self.update_tags(value['Name'], value['Items'])
+            self.queue.task_done()
+
+    async def get_pi_data(self, now):
+        """Get PI data from WebAPI."""
+        time = now - (now % self.averaging)
+        start_time = datetime.fromtimestamp(time - self.averaging * 12).isoformat()
+        end_time = datetime.fromtimestamp(time).isoformat()
+        url = f"{self.base_url}/piwebapi/streamsets/{self.webid}/summary?" \
+            f"startTime={start_time}&endTime={end_time}" \
+            "&summaryType=Average&calculationBasis=TimeWeighted" \
+            f"&summaryDuration={self.averaging}s"
+        async with self.session.get(url) as response:
+            return await response.json()
+
+    async def fetch_data(self, now):
+        """Fetch values from PI Web API."""
+        try:
+            if self.session is None:
+                connector = aiohttp.TCPConnector(ssl=False)
+                self.session = aiohttp.ClientSession(connector=connector)
+            json_data = await self.get_pi_data(now)
+            if json_data:
+                await self.queue.put(json_data)
+        except Exception as e:
+            logging.error(f'Error fetching data: {type(e).__name__} - {str(e)}')
+
+    async def poll(self):
+        """Poll PI API."""
+        now = int(time())
+        if now % self.averaging == 15:
+            asyncio.create_task(self.fetch_data(now))
+
+    async def start(self):
+        """Start bus connection and API polling."""
+        if self.busclient is not None:
+            await self.busclient.start()
+        self.handle = asyncio.create_task(self.handle_response())
+        self.periodic = Periodic(self.poll, 1.0)
+        await self.periodic.start()

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

@@ -52,7 +52,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):
@@ -115,6 +115,7 @@ class OpNotes:
                         request)
                     res = self.cursor.fetchone()
                     self.rta.value = {
+                        '__rta_id__': 0,
                         'id': res[0],
                         'date_ms': res[1],
                         'site': res[2],
@@ -133,6 +134,7 @@ class OpNotes:
                         ':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],
@@ -148,7 +150,7 @@ class OpNotes:
                 with self.connection:
                     self.cursor.execute(
                         f'DELETE FROM {self.table} WHERE id = :id;', request)
-                    self.rta.value = {'id': request['id']}
+                    self.rta.value = {'__rta_id__': 0, 'id': request['id']}
             except sqlite3.IntegrityError as error:
                 logging.warning(f'OpNotes rta_cb {error}')
         elif request['action'] == 'HISTORY':