pymscada 0.1.11b10__py3-none-any.whl → 0.2.0__py3-none-any.whl

pymscada/iodrivers/openweather.py

@@ -2,6 +2,7 @@
 import asyncio
 import aiohttp
 import logging
+import socket
 from time import time
 from pymscada.bus_client import BusClient
 from pymscada.periodic import Periodic
@@ -10,8 +11,14 @@ from pymscada.tag import Tag
 class OpenWeatherClient:
     """Get weather data from OpenWeather Current and Forecast APIs."""
 
-    def __init__(self, bus_ip: str = '127.0.0.1', bus_port: int = 1324,
-                 proxy: str = None, api: dict = {}, tags: dict = {}) -> None:
+    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.
 
@@ -21,6 +28,18 @@ class OpenWeatherClient:
         - times: list of hours ahead to fetch forecast data for
         - units: optional units (standard, metric, imperial)
         """
+        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='OpenWeather')
@@ -41,82 +60,144 @@ class OpenWeatherClient:
 
     def update_tags(self, location, data, suffix):
         """Update tags for forecast weather."""
+        if 'dt' not in data:
+            logging.error(f'No timestamp in data for {location}, skipping update')
+            return
         for parameter in self.parameters:
             tagname = f"{location}_{parameter}{suffix}"
-            if parameter == 'Temp':
-                value = data['main']['temp']
-            elif parameter == 'WindSpeed':
-                value = data['wind']['speed']
-            elif parameter == 'WindDir':
-                value = data['wind'].get('deg', 0)
-            elif parameter == 'Rain':
-                value = data.get('rain', {}).get('1h', 0)
             try:
-                self.tags[tagname].value = value
-            except KeyError:
-                logging.warning(f'{tagname} not found setting weather value')
+                if parameter == 'Temp':
+                    main_data = data.get('main', {})
+                    value = main_data.get('temp', 0)
+                elif parameter == 'WindSpeed':
+                    wind_data = data.get('wind', {})
+                    value = wind_data.get('speed', 0)
+                elif parameter == 'WindDir':
+                    wind_data = data.get('wind', {})
+                    value = wind_data.get('deg', 0)
+                elif parameter == 'Rain':
+                    rain_data = data.get('rain', {})
+                    value = rain_data.get('1h', 0)
+                else:
+                    logging.warning(f'Unknown parameter {parameter} for {tagname}')
+                    continue
+                time_us = int(data['dt'] * 1_000_000)
+                self.tags[tagname].value = value, time_us, self.map_bus
+                logging.debug(f'Updated {tagname} = {value} at timestamp {data["dt"]}')
+            except Exception as e:
+                logging.error(
+                    f'Error updating {tagname}: {type(e).__name__} - {str(e)}'
+                )
 
     async def handle_response(self):
         """Handle responses from the API."""
         while True:
-            location, data = await self.queue.get()
-            now = int(time())
-            if 'dt' in data:
-                self.update_tags(location, data, '')
-            elif 'list' in data:
-                for forecast in data['list']:
-                    hours_ahead = int((forecast['dt'] - now) / 3600)
-                    if hours_ahead not in self.times:
-                        continue
-                    suffix = f'_{hours_ahead:02d}'
-                    self.update_tags(location, forecast, suffix)
+            try:
+                location, data = await self.queue.get()
+                logging.debug(f'Processing data for {location}')
+                
+                if 'dt' in data:  # Current weather data
+                    self.update_tags(location, data, '')
+                elif 'list' in data:  # Forecast data
+                    now = int(time())
+                    for forecast in data['list']:
+                        hours_ahead = int((forecast['dt'] - now) / 3600)
+                        if hours_ahead in self.times:
+                            suffix = f'_{hours_ahead:02d}'
+                            self.update_tags(location, forecast, suffix)
+                
+                self.queue.task_done()
+            except Exception as e:
+                logging.error(f'Error handling response: {type(e).__name__} - {str(e)}')
 
     async def fetch_current_data(self):
         """Fetch current weather data for all locations."""
-        logging.info('fetching current')
-        if self.session is None:
-            self.session = aiohttp.ClientSession()
-        for location, coords in self.locations.items():
-            base_params = {'lat': coords['lat'], 'lon': coords['lon'],
-                'appid': self.api_key, 'units': self.units }
-            try:
-                async with self.session.get(self.current_url,
-                        params=base_params, proxy=self.proxy) as resp:
-                    if resp.status == 200:
-                        self.queue.put_nowait((location, await resp.json()))
-                    else:
-                        logging.warning('OpenWeather current API error for '
-                            f'{location}: {resp.status}')
-            except Exception as e:
-                logging.warning('OpenWeather current API error for '
-                    f'{location}: {e}')
+        try:
+            if self.session is None:
+                self.session = aiohttp.ClientSession()
+            
+            for location, coords in self.locations.items():
+                base_params = {
+                    'lat': coords.get('lat'),
+                    'lon': coords.get('lon'),
+                    'appid': self.api_key,
+                    'units': self.units
+                }
+                
+                # Validate required parameters
+                if not all(base_params.values()):
+                    logging.error(
+                        f'Missing required parameters for {location}: '
+                        f'{[k for k, v in base_params.items() if not v]}'
+                    )
+                    continue
+                    
+                try:
+                    async with self.session.get(
+                        self.current_url,
+                        params=base_params,
+                        proxy=self.proxy,
+                        timeout=30  # Add timeout
+                    ) as resp:
+                        if resp.status == 200:
+                            data = await resp.json()
+                            logging.debug(
+                                f'Received current weather data for {location}'
+                            )
+                            await self.queue.put((location, data))
+                        else:
+                            error_text = await resp.text()
+                            logging.error(
+                                f'OpenWeather API error for {location}: '
+                                f'Status: {resp.status}, Response: {error_text[:200]}'
+                            )
+                            
+                except asyncio.TimeoutError:
+                    logging.error(f'Timeout fetching data for {location}')
+                except aiohttp.ClientError as e:
+                    logging.error(
+                        f'Network error for {location}: {type(e).__name__} - {str(e)}'
+                    )
+                except Exception as e:
+                    logging.error(
+                        f'Unexpected error for {location}: {type(e).__name__} - {str(e)}'
+                    )
+                    
+        except Exception as e:
+            logging.error(f'Fatal error in fetch_current_data: {type(e).__name__} - {str(e)}')
 
     async def fetch_forecast_data(self):
         """Fetch forecast weather data for all locations."""
-        logging.info('fetching forecast')
         if self.session is None:
             self.session = aiohttp.ClientSession()
         for location, coords in self.locations.items():
-            base_params = {'lat': coords['lat'], 'lon': coords['lon'],
-                'appid': self.api_key, 'units': self.units }
+            base_params = {
+                'lat': coords['lat'], 
+                'lon': coords['lon'],
+                'appid': self.api_key, 
+                'units': self.units 
+            }
             try:
                 async with self.session.get(self.forecast_url,
                         params=base_params, proxy=self.proxy) as resp:
                     if resp.status == 200:
-                        self.queue.put_nowait((location, await resp.json()))
+                        data = await resp.json()
+                        logging.info(f'Queue forecast {location} {data}')
+                        await self.queue.put((location, data))
                     else:
-                        logging.warning('OpenWeather forecast API error '
-                            f'for {location}: {resp.status}')
+                        logging.error(f'OpenWeather forecast API error for '
+                            f'{location}: Status:{resp.status}, '
+                            f'Response:{await resp.text()}')
             except Exception as e:
-                logging.warning('OpenWeather forecast API error for '
-                    f'{location}: {e}')
+                logging.error(f'OpenWeather forecast API error for {location}: '
+                    f'Exception:{type(e).__name__}, Message:{str(e)}')
 
     async def poll(self):
         """Poll OpenWeather APIs every 10 minutes."""
         now = int(time())
         if now % 600 == 0:  # Every 10 minutes
             asyncio.create_task(self.fetch_current_data())
-        if now % 10800 == 60:  # Every 3 hours, offset by 1 minute
+        if now % 3600 == 60:  # Every 3 hours, offset by 1 minute
             asyncio.create_task(self.fetch_forecast_data())
 
     async def start(self):

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()
+
+