pymscada 0.2.0rc3__py3-none-any.whl → 0.2.0rc6__py3-none-any.whl

pymscada/alarms.py

@@ -3,15 +3,179 @@ 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, TagInfo, TYPES
+from pymscada.periodic import Periodic
+from pymscada.tag import Tag, TYPES
 
 ALM = 0
 RTN = 1
 ACT = 2
 INF = 3
 
+KIND = {
+    ALM: 'ALM',
+    RTN: 'RTN',
+    ACT: 'ACT',
+    INF: 'INF'
+}
+
+NORMAL = 0
+ALARM = 1
+
+"""
+Database schema:
+
+alarms contains an event log of changes as they occur, this
+includes information on actions taken by the alarm system.
+
+CREATE TABLE IF NOT EXISTS alarms (
+    id INTEGER PRIMARY KEY ASC,
+    date_ms INTEGER,
+    alarm_string TEXT,
+    kind INTEGER,     # one of ALM, RTN, ACT, INF
+    desc TEXT,
+    group TEXT
+)
+"""
+
+
+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 'area' not in tag:
+        tag['area'] = ''
+    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'] = ''
+    if 'alarm' in tag:
+        if isinstance(tag['alarm'], str):
+            tag['alarm'] = [tag['alarm']]
+        if not isinstance(tag['alarm'], list):
+            logging.warning(f"Tag {tagname} has invalid alarm {tag['alarm']}")
+            del tag['alarm']
+
+
+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]
+    try:
+        alm_dict['value'] = float(tokens[1])
+    except ValueError:
+        raise ValueError(f"Invalid alarm {alarm}")
+    if len(tokens) == 4:
+        if tokens[2] != 'for':
+            raise ValueError(f"Invalid alarm {alarm}")
+        try:
+            alm_dict['for'] = int(tokens[3])
+        except ValueError:
+            raise ValueError(f"Invalid alarm {alarm}")
+    return alm_dict
+
+
+class Alarm():
+    """
+    Single alarm class.
+
+    Alarms are defined by a tag and a condition. Tags may have multiple
+    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.
+    """
+
+    def __init__(self, tagname: str, tag: dict, alarm: str, area: str, rta_cb, alarms) -> None:
+        """Initialize alarm with tag and condition(s)."""
+        self.alarm_id = f'{tagname} {alarm}'
+        self.tag = Tag(tagname, tag['type'])
+        self.tag.desc = tag['desc']
+        self.tag.dp = tag['dp']
+        self.tag.units = tag['units']
+        self.tag.add_callback(self.callback)
+        self.area = area
+        self.rta_cb = rta_cb
+        self.alarms = alarms
+        self.alarm = split_operator(alarm)
+        self.in_alarm = False
+        self.checking = False
+
+    def callback(self, tag: Tag):
+        """Handle tag value changes and generate ALM/RTN messages."""
+        if tag.value is None:
+            return
+        value = float(tag.value)
+        time_us = tag.time_us
+        new_in_alarm = False
+        op = self.alarm['operator']
+        if op == '>':
+            new_in_alarm = value > self.alarm['value']
+        elif op == '<':
+            new_in_alarm = value < self.alarm['value']
+        elif op == '==':
+            new_in_alarm = value == self.alarm['value']
+        elif op == '>=':
+            new_in_alarm = value >= self.alarm['value']
+        elif op == '<=':
+            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 self.alarm['for'] > 0:
+                if not self.checking:
+                    self.checking = True
+                    self.alarms.checking_alarms.append(self)
+            else:
+                self.generate_alarm(ALM, time_us, value)
+        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.area
+        })
+
+    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)
+
 
 class Alarms:
     """Connect to bus_ip:bus_port, store and provide Alarms."""
@@ -22,7 +186,7 @@ class Alarms:
         bus_port: int | None = 1324,
         db: str | None = None,
         table: str = 'alarms',
-        tag_info: TagInfo = {},
+        tag_info: dict[str, dict] = {},
         rta_tag: str = '__alarms__'
     ) -> None:
         """
@@ -54,84 +218,56 @@ class Alarms:
             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.alarm_test: dict[str, dict] = {}
-        self.in_alarm: set[str] = set()
+        self.alarms: list[Alarm] = []
+        self.checking_alarms: list[Alarm] = []
         for tagname, tag in tag_info.items():
-            if 'alarm' not in tag:
+            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].add_callback(self.alarm_cb)
-            operator, value = tag['alarm'].split(' ')
-            self.alarm_test[tagname] = [
-                {
-                    '==': (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],
-                float(value)
-            ]
-        self.table = table
-        self.cursor = self.connection.cursor()
+            area = tag['area']
+            for alarm in tag['alarm']:
+                new_alarm = Alarm(tagname, tag, alarm, area, self.rta_cb, self)
+                self.alarms.append(new_alarm)
         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)
-        self._init_table()
-        atexit.register(self.close)
-
-    def alarm_cb(self, tag):
-        """Callback for alarm tags."""
-        operator, value = self.alarm_test[tag.name]
-        if operator(tag.value, value) and tag.name not in self.in_alarm:
-            logging.warning(f'Alarm {tag.name} {tag.value}')
-            alarm_record = {
-                'action': 'ADD',
-                'date_ms': int(tag.time_us / 1000),
-                'tagname': tag.name,
-                'transition': ALM,
-                'description': f'{tag.desc} {tag.value}'
-            }
-            self.rta_cb(alarm_record)
-            self.in_alarm.add(tag.name)
-        elif not operator(tag.value, value) and tag.name in self.in_alarm:
-            logging.info(f'No alarm {tag.name} {tag.value}')
-            alarm_record = {
-                'action': 'ADD',
-                'date_ms': int(tag.time_us / 1000),
-                'tagname': tag.name,
-                'transition': RTN,
-                'description': f'{tag.desc} {tag.value}'
-            }
-            self.rta_cb(alarm_record)
-            self.in_alarm.remove(tag.name)
-
-    def _init_table(self):
+        self._init_db(db, table)
+        self.periodic = Periodic(self.periodic_cb, 1.0)
+
+    def _init_db(self, db, table):
         """Initialize the database table schema."""
+        self.connection = sqlite3.connect(db)
+        self.table = table
+        self.cursor = self.connection.cursor()
         query = (
-            'CREATE TABLE IF NOT EXISTS ' + self.table +
+            'CREATE TABLE IF NOT EXISTS ' + self.table + ' '
             '(id INTEGER PRIMARY KEY ASC, '
             'date_ms INTEGER, '
-            'tagname TEXT, '
-            'transition INTEGER, '
-            'description TEXT)'
+            'alarm_string TEXT, '
+            'kind INTEGER, '
+            'desc TEXT, '
+            '"group" TEXT)'
         )
         self.cursor.execute(query)
+        self.connection.commit()
         
-        # Add startup record using existing ADD functionality
         startup_record = {
             'action': 'ADD',
             'date_ms': int(time.time() * 1000),
-            'tagname': self.rta.name,
-            'transition': INF,
-            'description': 'Alarm logging started'
+            'alarm_string': self.rta.name,
+            'kind': INF,
+            'desc': 'Alarm logging started',
+            'group': '__system__'
         }
         self.rta_cb(startup_record)
 
+    async def periodic_cb(self):
+        """Periodic callback to check alarms."""
+        current_time_us = int(time.time() * 1000000)
+        for alarm in self.checking_alarms[:]:
+            alarm.check_duration(current_time_us)
+
     def rta_cb(self, request):
         """Respond to Request to Author and publish on rta_tag as needed."""
         if 'action' not in request:
@@ -142,20 +278,41 @@ class Alarms:
                 with self.connection:
                     self.cursor.execute(
                         f'INSERT INTO {self.table} '
-                        '(date_ms, tagname, transition, description) '
-                        'VALUES(:date_ms, :tagname, :transition, :description) '
+                        '(date_ms, alarm_string, kind, desc, "group") '
+                        'VALUES(:date_ms, :alarm_string, :kind, :desc, :group) '
                         'RETURNING *;',
                         request)
                     res = self.cursor.fetchone()
                     self.rta.value = {
                         'id': res[0],
                         'date_ms': res[1],
-                        'tagname': res[2],
-                        'transition': res[3],
-                        'description': res[4]
+                        'alarm_string': res[2],
+                        'kind': res[3],
+                        'desc': res[4],
+                        'group': 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],
+                            'alarm_string': res[2],
+                            'kind': res[3],
+                            'desc': res[4],
+                            'group': 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}')
@@ -168,27 +325,30 @@ class Alarms:
                             '__rta_id__': request['__rta_id__'],
                             'id': res[0],
                             'date_ms': res[1],
-                            'tagname': res[2],
-                            'transition': res[3],
-                            'description': res[4]
+                            'alarm_string': res[2],
+                            'kind': res[3],
+                            'desc': res[4],
+                            'group': 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()
-
-    def close(self):
-        """Clean shutdown of alarms logging."""
-        shutdown_record = {
-            'action': 'ADD',
-            'date_ms': int(time.time() * 1000),
-            'tagname': self.rta.name,
-            'transition': INF,
-            'description': 'Alarm logging stopped'
-        }
-        try:
-            self.rta_cb(shutdown_record)
-        except sqlite3.Error as e:
-            logging.error(f'Error during alarm shutdown: {e}')
+        await self.periodic.start()

pymscada/console.py

@@ -3,7 +3,8 @@ import asyncio
 import logging
 import sys
 from pymscada.bus_client import BusClient
-from pymscada.tag import Tag, tag_for_web, TagInfo
+from pymscada.tag import Tag
+from pymscada.www_server import standardise_tag_info
 try:
     import termios
     import tty
@@ -153,7 +154,7 @@ class Console:
     """Provide a text console to interact with a Bus."""
 
     def __init__(self, bus_ip: str = '127.0.0.1', bus_port: int = 1324,
-                 tag_info: dict[str, TagInfo] = {}) -> None:
+                 tag_info: dict = {}) -> None:
         """
         Connect to bus_ip:bus_port and provide console interaction with a Bus.
 
@@ -177,7 +178,7 @@ class Console:
         self.busclient = BusClient(bus_ip, bus_port, module='Console')
         self.tags: dict[str, Tag] = {}
         for tagname, tag in tag_info.items():
-            tag_for_web(tagname, tag)
+            standardise_tag_info(tagname, tag)
             self.tags[tagname] = Tag(tagname, tag['type'])
 
     def write_tag(self, tag: Tag):

pymscada/demo/wits.yaml

@@ -0,0 +1,17 @@
+bus_ip: 127.0.0.1
+bus_port: 1324
+proxy:
+api:
+  url: 'https://api.electricityinfo.co.nz'
+  client_id: ${WITS_CLIENT_ID}
+  client_secret: ${WITS_CLIENT_SECRET}
+  gxp_list:
+    - MAT1101
+    - CYD2201
+    - BEN2201
+  back: 1
+  forward: 12
+tags:
+  - MAT1101_RTD
+  - CYD2201_RTD
+  - BEN2201_RTD

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/iodrivers/witsapi.py

@@ -0,0 +1,217 @@
+"""Poll WITS GXP pricing real time dispatch and forecast."""
+import asyncio
+import aiohttp
+import datetime
+import logging
+import socket
+from time import time
+from pymscada.bus_client import BusClient
+from pymscada.periodic import Periodic
+from pymscada.tag import Tag
+
+class WitsAPIClient:
+    """Get pricing data from WITS GXP APIs."""
+
+    def __init__(
+        self,
+        bus_ip: str | None = '127.0.0.1',
+        bus_port: int = 1324,
+        proxy: str | None = None,
+        api: dict = {},
+        tags: list = []
+    ) -> None:
+        """
+        Connect to bus on bus_ip:bus_port.
+
+        api dict should contain:
+        - client_id: WITS API client ID
+        - client_secret: WITS API client secret
+        - url: WITS API base URL
+        - gxp_list: list of GXP nodes to fetch prices for
+        - schedules: list of schedule types to fetch
+        - back: number of periods to look back
+        - forward: number of periods to look forward
+        """
+        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, 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}
+        
+        # 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', [])
+        self.back = api.get('back', 2)
+        self.forward = api.get('forward', 72)
+        
+        self.session = None
+        self.handle = None
+        self.periodic = None
+        self.queue = asyncio.Queue()
+
+    async def get_token(self):
+        """Get a new OAuth token"""
+        auth_url = f"{self.base_url}/login/oauth2/token"
+        data = {
+            "grant_type": "client_credentials",
+            "client_id": self.client_id,
+            "client_secret": self.client_secret
+        }
+        headers = {"Content-Type": "application/x-www-form-urlencoded"}
+        try:
+            async with self.session.post(auth_url, data=data, headers=headers) as response:
+                if response.status == 200:
+                    result = await response.json()
+                    self.session.headers.update({
+                        "Authorization": f"Bearer {result['access_token']}"
+                    })
+                    return result["access_token"]
+                else:
+                    error_text = await response.text()
+                    logging.error(f'WITS API auth error: {error_text}')
+                    return None
+        except Exception as e:
+            logging.error(f'WITS API auth error: {type(e).__name__} - {str(e)}')
+            return None
+
+    async def get_multi_schedule_prices(self):
+        """Get prices across multiple schedules"""
+        endpoint = "api/market-prices/v1/prices"
+        params = {
+            'schedules': 'RTD,PRSS,PRSL',
+            'marketType': 'E',
+            'offset': 0
+        }
+        if self.gxp_list:
+            params['nodes'] = ','.join(self.gxp_list)
+        if self.back:
+            params['back'] = min(self.back, 48)
+        if self.forward:
+            params['forward'] = min(self.forward, 48)
+            
+        query = '&'.join(f"{k}={v}" for k, v in params.items())
+        url = f"{self.base_url}/{endpoint}?{query}"
+        
+        try:
+            async with self.session.get(url, proxy=self.proxy) as response:
+                if response.status == 200:
+                    return await response.json()
+                else:
+                    error_text = await response.text()
+                    logging.error(f'WITS API error: {error_text}')
+                    return None
+        except Exception as e:
+            logging.error(f'WITS API error: {type(e).__name__} - {str(e)}')
+            return None
+
+    def parse_prices(self, response):
+        """Parse API response into structured price dictionary"""
+        if not response:
+            return {}
+        prices = {}
+        for schedule_data in response:
+            schedule = schedule_data['schedule']
+            if 'prices' not in schedule_data:
+                continue
+            for price in schedule_data['prices']:
+                node = price['node']
+                trading_time = int(datetime.datetime.fromisoformat(
+                    price['tradingDateTime'].replace('Z', '+00:00')
+                ).timestamp())
+                last_run = int(datetime.datetime.fromisoformat(
+                    price['lastRunTime'].replace('Z', '+00:00')
+                ).timestamp())
+                
+                if node not in prices:
+                    prices[node] = {}
+                if trading_time not in prices[node]:
+                    prices[node][trading_time] = {}
+                prices[node][trading_time][schedule] = [price['price'], last_run]
+        return prices
+
+    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
+
+    async def handle_response(self):
+        """Handle responses from the API."""
+        while True:
+            try:
+                prices = await self.queue.get()
+                if prices:
+                    parsed_prices = self.parse_prices(prices)
+                    self.update_tags(parsed_prices)
+                self.queue.task_done()
+            except Exception as e:
+                logging.error(f'Error handling response: {type(e).__name__} - {str(e)}')
+
+    async def fetch_data(self):
+        """Fetch price data from WITS API."""
+        try:
+            if self.session is None:
+                self.session = aiohttp.ClientSession()
+            token = await self.get_token()
+            if token:
+                prices = await self.get_multi_schedule_prices()
+                if prices:
+                    await self.queue.put(prices)
+        except Exception as e:
+            logging.error(f'Error fetching data: {type(e).__name__} - {str(e)}')
+
+    async def poll(self):
+        """Poll WITS API every 5 minutes."""
+        now = int(time())
+        if now % 300 == 0:  # Every 5 minutes
+            asyncio.create_task(self.fetch_data())
+
+    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/witsapi_POC.py

@@ -0,0 +1,246 @@
+import aiohttp
+import asyncio
+import datetime
+
+class WitsAPIClient:
+    def __init__(self, url, client_id, client_secret):
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.base_url = url
+        self.session = None
+        
+    async def __aenter__(self):
+        """Create session and get token on entry"""
+        self.session = aiohttp.ClientSession()
+        return self
+        
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Close session on exit"""
+        if self.session:
+            await self.session.close()
+    
+    async def get_token(self):
+        """Get a new OAuth token"""
+        auth_url = f"{self.base_url}/login/oauth2/token"
+        data = {
+            "grant_type": "client_credentials",
+            "client_id": self.client_id,
+            "client_secret": self.client_secret
+        }
+        
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded"
+        }
+        
+        try:
+            async with self.session.post(auth_url, data=data, headers=headers) as response:
+                if response.status == 200:
+                    result = await response.json()
+                    self.session.headers.update({
+                        "Authorization": f"Bearer {result['access_token']}"
+                    })
+                    return result["access_token"]
+                else:
+                    error_text = await response.text()
+                    return None
+        except Exception as e:
+            return None
+
+    async def get(self, endpoint):
+        """Make a GET request to the WITS API"""
+        url = f"{self.base_url}/{endpoint}"
+        try:
+            async with self.session.get(url) as response:
+                if response.status == 200:
+                    result = await response.json()
+                    return result
+                else:
+                    error_text = await response.text()
+                    return None
+        except Exception as e:
+            return None
+
+    async def get_schedules(self):
+        """Get list of schedules for which pricing data is available"""
+        endpoint = "api/market-prices/v1/schedules"
+        return await self.get(endpoint)
+
+    async def get_nodes(self):
+        """Get list of GXP/GIP nodes supported by this API"""
+        endpoint = "api/market-prices/v1/nodes"
+        return await self.get(endpoint)
+
+    async def get_schedule_prices(self, schedule='RTD', market_type='E', nodes=None, 
+                                back=None, forward=None, from_date=None, to_date=None, 
+                                island=None, offset=0):
+        """Get prices for a single schedule
+        Args:
+            schedule: Schedule type (e.g. 'RTD' for Real Time Dispatch)
+            market_type: 'E' for energy prices, 'R' for reserve prices
+            nodes: List of node IDs to filter by
+            back: Number of trading periods to look back (1-48)
+            forward: Number of trading periods to look ahead (1-48)
+            from_date: Start datetime (RFC3339 format)
+            to_date: End datetime (RFC3339 format)
+            island: Filter by island ('NI' or 'SI')
+            offset: Pagination offset
+        """
+        endpoint = f"api/market-prices/v1/schedules/{schedule}/prices"
+        params = {
+            'marketType': market_type,
+            'offset': offset
+        }
+        if nodes:
+            params['nodes'] = ','.join(nodes) if isinstance(nodes, list) else nodes
+        if back:
+            params['back'] = min(back, 48)
+        if forward:
+            params['forward'] = min(forward, 48)
+        if from_date:
+            params['from'] = from_date
+        if to_date:
+            params['to'] = to_date
+        if island:
+            params['island'] = island
+        query = '&'.join(f"{k}={v}" for k, v in params.items())
+        return await self.get(f"{endpoint}?{query}")
+
+    async def get_multi_schedule_prices(self, schedules, market_type='E', nodes=None,
+                                      back=None, forward=None, from_date=None, 
+                                      to_date=None, island=None, offset=0):
+        """Get prices across multiple schedules
+        Args:
+            schedules: List of schedule types
+            market_type: 'E' for energy prices, 'R' for reserve prices
+            nodes: List of node IDs to filter by
+            back: Number of trading periods to look back (1-48)
+            forward: Number of trading periods to look ahead (1-48)
+            from_date: Start datetime (RFC3339 format)
+            to_date: End datetime (RFC3339 format)
+            island: Filter by island ('NI' or 'SI')
+            offset: Pagination offset
+        """
+        endpoint = "api/market-prices/v1/prices"
+        params = {
+            'schedules': ','.join(schedules) if isinstance(schedules, list) else schedules,
+            'marketType': market_type,
+            'offset': offset
+        }
+        if nodes:
+            params['nodes'] = ','.join(nodes) if isinstance(nodes, list) else nodes
+        if back:
+            params['back'] = min(back, 48)
+        if forward:
+            params['forward'] = min(forward, 48)
+        if from_date:
+            params['from'] = from_date
+        if to_date:
+            params['to'] = to_date
+        if island:
+            params['island'] = island
+        query = '&'.join(f"{k}={v}" for k, v in params.items())
+        return await self.get(f"{endpoint}?{query}")
+
+    def parse_prices(self, response):
+        """Parse API response into structured price dictionary
+        Returns dict in format:
+            {node: {trading_time_utc: {schedule: [price, last_run_utc]}}}
+        """
+        if not response:
+            return {}
+        prices = {}
+        for schedule_data in response:
+            schedule = schedule_data['schedule']
+            if 'prices' not in schedule_data:
+                continue
+            for price in schedule_data['prices']:
+                node = price['node']
+                trading_time = int(datetime.datetime.fromisoformat(
+                    price['tradingDateTime'].replace('Z', '+00:00')
+                ).timestamp())
+                last_run = int(datetime.datetime.fromisoformat(
+                    price['lastRunTime'].replace('Z', '+00:00')
+                ).timestamp())
+                
+                if node not in prices:
+                    prices[node] = {}
+                if trading_time not in prices[node]:
+                    prices[node][trading_time] = {}
+                prices[node][trading_time][schedule] = [price['price'], last_run]
+        
+        # Create RTD_forecast schedule
+        for node in prices:
+            for trading_time in prices[node]:
+                if 'RTD' in prices[node][trading_time]:
+                    prices[node][trading_time]['RTD_forecast'] = prices[node][trading_time]['RTD']
+                else:
+                    # Find most recent schedule by last run time
+                    latest_schedule = None
+                    latest_last_run = 0
+                    for schedule in prices[node][trading_time]:
+                        if prices[node][trading_time][schedule][1] > latest_last_run:
+                            latest_last_run = prices[node][trading_time][schedule][1]
+                            latest_schedule = schedule
+                    if latest_schedule:
+                        prices[node][trading_time]['RTD_forecast'] = \
+                            prices[node][trading_time][latest_schedule]
+        
+        return prices
+    
+    def print_prices(self, prices):
+        """Print prices in structured format with time information"""
+        now = datetime.datetime.now(datetime.timezone.utc)
+        now_ts = now.timestamp()
+        for node in sorted(prices.keys()):
+            print(f" - {node}:")
+            for trading_time in sorted(prices[node].keys()):
+                time_diff = trading_time - now_ts
+                # For future times on 30 minute boundaries, show half-hour intervals
+                if time_diff > 0 and trading_time % 1800 == 0:
+                    half_hours = int(time_diff / 1800)
+                    time_str = f"(+{half_hours})"
+                else:
+                    # For past times or non-30min intervals, show actual time
+                    dt = datetime.datetime.fromtimestamp(trading_time, 
+                                                       datetime.timezone.utc)
+                    time_str = f"({dt.strftime('%Y-%m-%d %H:%M:%S')})"
+                
+                print(f"   - Trading Time UTC: {trading_time} {time_str}")
+                for schedule in sorted(prices[node][trading_time].keys()):
+                    if schedule in ['RTD', 'PRSS', 'PRSL', 'RTD_forecast']:
+                        price, last_run = prices[node][trading_time][schedule]
+                        last_run_dt = datetime.datetime.fromtimestamp(
+                            last_run, datetime.timezone.utc)
+                        print(f"        {schedule:12} Price: {price:8.2f}, "
+                              f"Last Run: {last_run_dt.strftime('%H:%M:%S')}")
+
+
+async def main(config):
+    async with WitsAPIClient(url=config['url'],client_id=config['client_id'],
+                             client_secret=config['client_secret']) as client:
+        token = await client.get_token()
+        if token:
+            multi_prices = await client.get_multi_schedule_prices(
+                schedules=config['schedules'],
+                nodes=config['gxp_list'],
+                back=config['back'],
+                forward=config['forward']
+            )
+            if multi_prices:
+                prices_dict = client.parse_prices(multi_prices)
+                client.print_prices(prices_dict)
+        await asyncio.sleep(1)
+
+
+CONFIG = {
+    'url': 'https://api.electricityinfo.co.nz',
+    'gxp_list': ['MAT1101', 'CYD2201', 'BEN2201'],
+    'schedules': ['RTD', 'PRSS', 'PRSL'],
+    'back': 2,
+    'forward': 72,
+    'client_id': 'xx',
+    'client_secret': 'xx'
+}
+
+if __name__ == "__main__":
+    asyncio.run(main(CONFIG))

pymscada/module_config.py

@@ -150,6 +150,18 @@ def create_module_registry():
             module_class='pymscada.iodrivers.snmp_client:SnmpClient',
             tags=False
         ),
+        ModuleDefinition(
+            name='witsapi',
+            help='poll WITS GXP pricing real time dispatch and forecast',
+            module_class='pymscada.iodrivers.witsapi:WitsAPIClient',
+            tags=False,
+            epilog=dedent("""
+                WITS_CLIENT_ID and 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'""")
+        ),
         ModuleDefinition(
             name='console',
             help='interactive bus console',

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'] = 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 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/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.0rc3.dist-info → pymscada-0.2.0rc6.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pymscada
-Version: 0.2.0rc3
+Version: 0.2.0rc6
 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,10 +17,11 @@ 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
+Dynamic: license-file
 
 # pymscada
 #### [Docs](https://github.com/jamie0walton/pymscada/blob/main/docs/README.md)

{pymscada-0.2.0rc3.dist-info → pymscada-0.2.0rc6.dist-info}/RECORD

@@ -1,23 +1,23 @@
 pymscada/__init__.py,sha256=NV_cIIwe66Ugp8ns426rtfJIIyskWbqwImD9p_5p0bQ,739
 pymscada/__main__.py,sha256=WcyVlrYOoDdktJhOoyubTOycMwpayksFdxwelRU5xpQ,272
-pymscada/alarms.py,sha256=BM6R-PFf7EazhGdGHJ1XeAcCoi83Ro9XvEl_9cp-iCI,7326
+pymscada/alarms.py,sha256=iGRf_ybe2KGiFpN7EwAHzqiCyyPYaWgL5zd34SSdrU8,12895
 pymscada/bus_client.py,sha256=ROShMcR2-y_i5CIvPxRdCRr-NpnMANjKFdLjKjMTRwo,9117
 pymscada/bus_server.py,sha256=k7ht2SAr24Oab0hBOPeW4NRDF_RK-F46iE0cMzh7K4w,12323
 pymscada/checkout.py,sha256=RLuCMTEuUI7pp1hIRAUPbo8xYFta8TjArelx0SD4gOY,3897
 pymscada/config.py,sha256=vwGxieaJBYXiHNQEOYVDFaPuGmnUlCnbNm_W9bugKlc,1851
-pymscada/console.py,sha256=zM6TNXJY8ROcVzO3UBzi1qDSiit7mfLr2YprRoxv2oQ,8824
+pymscada/console.py,sha256=EEsJLCvn8AFimN8qGNilX0ks6t3OFcGW5nw6OVAXfac,8850
 pymscada/files.py,sha256=iouEOPfEkVI0Qbbf1p-L324Y04zSrynVypLW0-1MThA,2499
-pymscada/history.py,sha256=qXbCkHQC_j7HF9b1PvnF93d4HvW9ODJeSc9tvy63o10,11513
+pymscada/history.py,sha256=7UEOeMnlSMv0LoWTqLWx7QwOW1FZZ4wAvzH6v6b0_vI,11592
 pymscada/main.py,sha256=d6EnK4-tEcvM5AqMHYhvqlnSh-E_wd0Tuxk-kXYSiDw,1854
 pymscada/misc.py,sha256=0Cj6OFhQonyhyk9x0BG5MiS-6EPk_w6zvavt8o_Hlf0,622
-pymscada/module_config.py,sha256=r1JBjOXtMk7n09kvlvnmA3d_BySEmJpdefFhRNKPdAY,8824
+pymscada/module_config.py,sha256=sEoLUhMUFJfalH3CbhNPIqQd1bAL7bWCyPSMUKs6HJ4,9370
 pymscada/opnotes.py,sha256=MKM51IrB93B2-kgoTzlpOLpaMYs-7rPQHWmRLME-hQQ,7952
 pymscada/periodic.py,sha256=MLlL93VLvFqBBgjO1Us1t0aLHTZ5BFdW0B__G02T1nQ,1235
 pymscada/protocol_constants.py,sha256=lPJ4JEgFJ_puJjTym83EJIOw3UTUFbuFMwg3ohyUAGY,2414
 pymscada/samplers.py,sha256=t0IscgsCm5YByioOZ6aOKMO_guDFS_wxnJSiOGKI4Nw,2583
-pymscada/tag.py,sha256=G0P9t3G6heQ1kBWPnc0u8qN6UvjG4xtyI9w_KqGr4Q0,10682
+pymscada/tag.py,sha256=hTRxogw8BXAi1OJpM1Lhx4KKMqZ53y7D5KcCycO7fRQ,9471
 pymscada/validate.py,sha256=fPMlP6RscYuTIgdEJjJ0ZZI0OyVSat1lpqg254wqpdE,13140
-pymscada/www_server.py,sha256=rz6Yictg_Ony8zW76An5bv_cZN5aLi-QW3B85uWMgXQ,13152
+pymscada/www_server.py,sha256=NfvX9jbVWY2qxWM6TfWUcwsCY7lR-dkty1nCOXyoWTA,13747
 pymscada/demo/README.md,sha256=iNcVbCTkq-d4agLV-979lNRaqf_hbJCn3OFzY-6qfU8,880
 pymscada/demo/__init__.py,sha256=WsDDgkWnZBJbt2-cJCdc2NvRAv_T4a7WOC1Q0k_l0gI,29
 pymscada/demo/accuweather.yaml,sha256=Fk4rV0S8jCau0173QCzKW8TdUbc4crYVi0aD8fPLNgU,322
@@ -47,6 +47,7 @@ pymscada/demo/pymscada-opnotes.service,sha256=TlrTRgP3rzrlXT8isAGT_Wy38ScDjT1Vvn
 pymscada/demo/pymscada-wwwserver.service,sha256=7Qy2wsMmFEsQn-b5mgAcsrAQZgXynkv8SpHD6hLvRGc,370
 pymscada/demo/snmpclient.yaml,sha256=z8iACrFvMftYUtqGrRjPZYZTpn7aOXI-Kp675NAM8cU,2013
 pymscada/demo/tags.yaml,sha256=9xydsQriKT0lNAW533rz-FMVgoedn6Lwc50AnNig7-k,2733
+pymscada/demo/wits.yaml,sha256=B8F136jvLIYU8t-pOdsEU_j97qMo3RgGQ1Rs4ExhmeE,289
 pymscada/demo/wwwserver.yaml,sha256=mmwvSLUXUDCIPaHeCJdCETAp9Cc4wb5CuK_aGv01KWk,2759
 pymscada/demo/__pycache__/__init__.cpython-311.pyc,sha256=tpxZoW429YA-2mbwzOlhBmbSTcbvTJqgKCfDRMrhEJE,195
 pymscada/iodrivers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -61,15 +62,17 @@ pymscada/iodrivers/ping_client.py,sha256=UOQgUfoIcYqy5VvKyJ8XGHHjeSRTfjmrhyWEojh
 pymscada/iodrivers/ping_map.py,sha256=EbOteqfEYKIOMqPymROJ4now2If-ekEj6jnM5hthoSA,1403
 pymscada/iodrivers/snmp_client.py,sha256=66-IDzddeKcSnqOzNXIZ8wuuAqhIxZjyLNrDwDvHCvw,2708
 pymscada/iodrivers/snmp_map.py,sha256=sDdIR5ZPAETpozDfBt_XQiZ-f4t99UCPlzj7BxFxQyM,2369
+pymscada/iodrivers/witsapi.py,sha256=Ga6JpEQRUciT_LxWW36LsVGkUeWjModtzPoWYIzyzHs,8381
+pymscada/iodrivers/witsapi_POC.py,sha256=dQcR2k1wsLb_cnNqvAB4kJ7FdY0BlcnxiMoepr28Ars,10132
 pymscada/pdf/__init__.py,sha256=WsDDgkWnZBJbt2-cJCdc2NvRAv_T4a7WOC1Q0k_l0gI,29
 pymscada/pdf/one.pdf,sha256=eoJ45DrAjVZrwmwdA_EAz1fwmT44eRnt_tkc2pmMrKY,1488
 pymscada/pdf/two.pdf,sha256=TAuW5yLU1_wfmTH_I5ezHwY0pxhCVuZh3ixu0kwmJwE,1516
 pymscada/pdf/__pycache__/__init__.cpython-311.pyc,sha256=4KTfXrV9bGDbTIEv-zgIj_LvzLbVTj77lEC1wzMh9e0,194
 pymscada/tools/snmp_client2.py,sha256=pdn5dYyEv4q-ubA0zQ8X-3tQDYxGC7f7Xexa7QPaL40,1675
 pymscada/tools/walk.py,sha256=OgpprUbKLhEWMvJGfU1ckUt_PFEpwZVOD8HucCgzmOc,1625
-pymscada-0.2.0rc3.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-pymscada-0.2.0rc3.dist-info/METADATA,sha256=ezP-4JEdjL8qwHVyi0q9xrpgaft2BJNez1Ai96k1e5k,2371
-pymscada-0.2.0rc3.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-pymscada-0.2.0rc3.dist-info/entry_points.txt,sha256=2UJBi8jrqujnerrcXcq4F8GHJYVDt26sacXl94t3sd8,56
-pymscada-0.2.0rc3.dist-info/top_level.txt,sha256=LxIB-zrtgObJg0fgdGZXBkmNKLDYHfaH1Hw2YP2ZMms,9
-pymscada-0.2.0rc3.dist-info/RECORD,,
+pymscada-0.2.0rc6.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+pymscada-0.2.0rc6.dist-info/METADATA,sha256=QdAhMpE2X7HmhVO0H6XvXjnjQO7JZka7zlWoXKle2vg,2393
+pymscada-0.2.0rc6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pymscada-0.2.0rc6.dist-info/entry_points.txt,sha256=2UJBi8jrqujnerrcXcq4F8GHJYVDt26sacXl94t3sd8,56
+pymscada-0.2.0rc6.dist-info/top_level.txt,sha256=LxIB-zrtgObJg0fgdGZXBkmNKLDYHfaH1Hw2YP2ZMms,9
+pymscada-0.2.0rc6.dist-info/RECORD,,

{pymscada-0.2.0rc3.dist-info → pymscada-0.2.0rc6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any