pymscada 0.2.0rc4__py3-none-any.whl → 0.2.0rc7__py3-none-any.whl

pymscada/demo/callout.yaml

@@ -0,0 +1,16 @@
+bus_ip: 127.0.0.1
+bus_port: 1324
+rta_tag: __callout__
+alarms: __alarms__
+ack: SI_Alarm_Ack
+status: SO_Alarm_Status
+callees:
+- name: A name
+  sms: A number
+- name: B name
+  sms: B number
+groups:
+- name: Aniwhenua Station
+  group:
+- name: Aniwhenua System
+  group: System

pymscada/demo/pymscada-io-witsapi.service

@@ -0,0 +1,15 @@
+[Unit]
+    Description=pymscada - WITS client
+    BindsTo=pymscada-bus.service
+    After=pymscada-bus.service
+
+[Service]
+    WorkingDirectory=__DIR__
+    ExecStart=__PYMSCADA__ witsapiclient --config __DIR__/config/witsapi.yaml
+    Restart=always
+    RestartSec=5
+    User=__USER__
+    Group=__USER__
+
+[Install]
+    WantedBy=multi-user.target

pymscada/demo/tags.yaml

@@ -113,10 +113,14 @@ localhost_ping:
   desc: Ping time to localhost
   type: float
   units: ms
+  alarm: '> 500 for 300'
+  group: System
 google_ping:
   desc: Ping time to google
   type: float
   units: ms
+  alarm: '> 100 for 30'
+  group: System
 Murupara_Temp:
   desc: Murupara Temperature
   type: float

pymscada/demo/witsapi.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/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-0.2.0rc4.dist-info → pymscada-0.2.0rc7.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pymscada
-Version: 0.2.0rc4
+Version: 0.2.0rc7
 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
@@ -21,6 +21,7 @@ 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.0rc4.dist-info → pymscada-0.2.0rc7.dist-info}/RECORD

@@ -1,16 +1,17 @@
 pymscada/__init__.py,sha256=NV_cIIwe66Ugp8ns426rtfJIIyskWbqwImD9p_5p0bQ,739
 pymscada/__main__.py,sha256=WcyVlrYOoDdktJhOoyubTOycMwpayksFdxwelRU5xpQ,272
-pymscada/alarms.py,sha256=KiGws42xu8Bcmy_hhZkKoYhfNzUzICSV7f8xQcY7M8c,13715
-pymscada/bus_client.py,sha256=ROShMcR2-y_i5CIvPxRdCRr-NpnMANjKFdLjKjMTRwo,9117
+pymscada/alarms.py,sha256=eo-9-DSwV825ihuHApaYkADPpLouKbNLHyh0z4bdPoU,12936
+pymscada/bus_client.py,sha256=eRGvHQ4sFM_n3rKvKDWZQJPQJqvKMWvxbH3MjtT2WBo,9131
 pymscada/bus_server.py,sha256=k7ht2SAr24Oab0hBOPeW4NRDF_RK-F46iE0cMzh7K4w,12323
+pymscada/callout.py,sha256=o_GCB-3IFG-QIcHfrmW-N9CTTlsIu9nMLC-F1jQu1hQ,7274
 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=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
@@ -23,6 +24,7 @@ pymscada/demo/__init__.py,sha256=WsDDgkWnZBJbt2-cJCdc2NvRAv_T4a7WOC1Q0k_l0gI,29
 pymscada/demo/accuweather.yaml,sha256=Fk4rV0S8jCau0173QCzKW8TdUbc4crYVi0aD8fPLNgU,322
 pymscada/demo/alarms.yaml,sha256=Ea8tLZ0aEiyKM_m5MN1TF6xS-lI5ReXiz2oUPO8GvmQ,110
 pymscada/demo/bus.yaml,sha256=zde5JDo2Yv5s7NvJ569gAEoTDvsvgBwRPxfrYhsxj3w,26
+pymscada/demo/callout.yaml,sha256=ze2UfAymU05lzVp-t8wSa9hYJMGSkhT4FwL4rVJQG4o,270
 pymscada/demo/files.yaml,sha256=XWtmGDJxtD4qdl2h7miUfJYkDKsvwNTgQjlGpR6LQNs,163
 pymscada/demo/history.yaml,sha256=c0OuYe8LbTeZqJGU2WKGgTEkOA0IYAjO3e046ddQB8E,55
 pymscada/demo/logixclient.yaml,sha256=G_NlJhBYwT1a9ceHDgO6fCNKFmBM2pVO_t9Xa1NqlRY,912
@@ -43,10 +45,12 @@ pymscada/demo/pymscada-io-modbusserver.service,sha256=g7Rzm6zGLq_qvTJRL_pcLl4Ps7
 pymscada/demo/pymscada-io-openweather.service,sha256=SQnZ-cq1V3qvZY7EgR_Vx36vCOw1ipfGoLoutHsxtNk,359
 pymscada/demo/pymscada-io-ping.service,sha256=Fm8qR4IVq0NupEvHLGONXGwjjQsx5VqaBYPewhg7-k4,329
 pymscada/demo/pymscada-io-snmpclient.service,sha256=Rsm8uiwnoGx-1MkXqYgtj4UP9-r7AEEeB9yoR0y0oVA,343
+pymscada/demo/pymscada-io-witsapi.service,sha256=ZjNwUnZg7WZsCaBFk8aNibnCbwqtbhl1i9D8tdUGXiQ,343
 pymscada/demo/pymscada-opnotes.service,sha256=TlrTRgP3rzrlXT8isAGT_Wy38ScDjT1VvnlgW84XiS8,354
 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/tags.yaml,sha256=1HH9SqevBE0P0NXHK0Slfu68gwx5iKpgyirClmAcXGY,2814
+pymscada/demo/witsapi.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 +65,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.0rc4.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-pymscada-0.2.0rc4.dist-info/METADATA,sha256=F9_ab9hHNXQhJaoVfC7CtuEPKgMh5eDAaZOt8GdIr1M,2371
-pymscada-0.2.0rc4.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
-pymscada-0.2.0rc4.dist-info/entry_points.txt,sha256=2UJBi8jrqujnerrcXcq4F8GHJYVDt26sacXl94t3sd8,56
-pymscada-0.2.0rc4.dist-info/top_level.txt,sha256=LxIB-zrtgObJg0fgdGZXBkmNKLDYHfaH1Hw2YP2ZMms,9
-pymscada-0.2.0rc4.dist-info/RECORD,,
+pymscada-0.2.0rc7.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+pymscada-0.2.0rc7.dist-info/METADATA,sha256=fSgmvdFEaztKuACzjhu9ya2By5ufTzj1PAYfM4z0dVk,2393
+pymscada-0.2.0rc7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pymscada-0.2.0rc7.dist-info/entry_points.txt,sha256=2UJBi8jrqujnerrcXcq4F8GHJYVDt26sacXl94t3sd8,56
+pymscada-0.2.0rc7.dist-info/top_level.txt,sha256=LxIB-zrtgObJg0fgdGZXBkmNKLDYHfaH1Hw2YP2ZMms,9
+pymscada-0.2.0rc7.dist-info/RECORD,,

{pymscada-0.2.0rc4.dist-info → pymscada-0.2.0rc7.dist-info}/WHEEL

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