pymscada 0.1.11__py3-none-any.whl → 0.1.11b2__py3-none-any.whl

pymscada/iodrivers/openweather.py

@@ -0,0 +1,126 @@
+"""Poll OpenWeather current and forecast APIs."""
+import asyncio
+import aiohttp
+import logging
+from time import time
+from pymscada.bus_client import BusClient
+from pymscada.periodic import Periodic
+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:
+        """
+        Connect to bus on bus_ip:bus_port.
+
+        api dict should contain:
+        - api_key: OpenWeatherMap API key
+        - locations: dict of location names and coordinates
+        - times: list of hours ahead to fetch forecast data for
+        - units: optional units (standard, metric, imperial)
+        """
+        self.busclient = None
+        if bus_ip is not None:
+            self.busclient = BusClient(bus_ip, bus_port, module='OpenWeather')
+        self.proxy = proxy
+        self.map_bus = id(self)
+        self.tags = {tagname: Tag(tagname, float) for tagname in tags}
+        self.api_key = api['api_key']
+        self.units = api.get('units', 'standard')
+        self.locations = api.get('locations', {})
+        self.parameters = api.get('parameters', {})
+        self.times = api.get('times', [3, 6, 12, 24, 48])
+        self.current_url = "https://api.openweathermap.org/data/2.5/weather"
+        self.forecast_url = "https://api.openweathermap.org/data/2.5/forecast"
+        self.queue = asyncio.Queue()
+        self.session = None
+        self.handle = None
+        self.periodic = None
+
+    def update_tags(self, location, data, suffix):
+        """Update tags for forecast weather."""
+        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')
+
+    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)
+
+    async def fetch_current_data(self):
+        """Fetch current weather data for all locations."""
+        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}')
+
+    async def fetch_forecast_data(self):
+        """Fetch forecast weather data for all locations."""
+        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.forecast_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 forecast API error '
+                            f'for {location}: {resp.status}')
+            except Exception as e:
+                logging.warning('OpenWeather forecast API error for '
+                    f'{location}: {e}')
+
+    async def poll(self):
+        """Poll OpenWeather APIs every 10 minutes."""
+        now = int(time())
+        if now % 600 == 0:  # Every 10 minutes
+            await self.fetch_current_data()
+        if now % 10800 == 60:  # Every 3 hours, offset by 1 minute
+            await self.fetch_forecast_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/main.py

@@ -1,311 +1,57 @@
 """Main server entry point."""
 import argparse
 import asyncio
-from importlib.metadata import version
 import logging
 import sys
-from pymscada.bus_server import BusServer
-from pymscada.checkout import checkout
-from pymscada.config import Config
-from pymscada.console import Console
-from pymscada.files import Files
-from pymscada.history import History
-from pymscada.opnotes import OpNotes
-from pymscada.www_server import WwwServer
-from pymscada.iodrivers.accuweather import AccuWeatherClient
-from pymscada.iodrivers.logix_client import LogixClient
-from pymscada.iodrivers.modbus_client import ModbusClient
-from pymscada.iodrivers.modbus_server import ModbusServer
-from pymscada.iodrivers.ping_client import PingClient
-from pymscada.iodrivers.snmp_client import SnmpClient
-from pymscada.validate import validate
-
-
-class Module():
-    """Default Module."""
-
-    name = None
-    help = None
-    epilog = None
-    module = None
-    config = True
-    tags = True
-    sub = None
-    await_future = True
-
-    def __init__(self, subparser: argparse._SubParsersAction):
-        """Add arguments common to all subparsers."""
-        self.sub = subparser.add_parser(
-            self.name, help=self.help, epilog=self.epilog)
-        self.sub.set_defaults(app=self)
-        if self.config:
-            self.sub.add_argument(
-                '--config', metavar='file', default=f'{self.name}.yaml',
-                help=f"Config file, default is '{self.name}.yaml'")
-        if self.tags:
-            self.sub.add_argument(
-                '--tags', metavar='file', default='tags.yaml',
-                help="Tags file, default is 'tags.yaml'")
-        self.sub.add_argument('--verbose', action='store_true',
-                              help="Set level to logging.INFO")
-
-
-class _Bus(Module):
-    """Bus Server."""
-
-    name = 'bus'
-    help = 'run the message bus'
-    tags = False
-
-    def run_once(self, options):
-        """Create the module."""
-        config = Config(options.config)
-        self.module = BusServer(**config)
-
-
-class _WwwServer(Module):
-    """WWW Server Module."""
-
-    name = 'wwwserver'
-    help = 'serve web pages'
-
-    def run_once(self, options):
-        """Create the module."""
-        config = Config(options.config)
-        tag_info = dict(Config(options.tags))
-        self.module = WwwServer(tag_info=tag_info, **config)
-
-
-class _History(Module):
-    """History Module."""
-
-    name = 'history'
-    help = 'collect and serve history'
-
-    def run_once(self, options):
-        """Create the module."""
-        config = Config(options.config)
-        tag_info = dict(Config(options.tags))
-        self.module = History(tag_info=tag_info, **config)
-
-
-class _Files(Module):
-    """Files Module."""
-
-    name = 'files'
-    help = 'receive and send files'
-    tags = False
-
-    def run_once(self, options):
-        """Create the module."""
-        config = Config(options.config)
-        self.module = Files(**config)
-
-
-class _OpNotes(Module):
-    """Operator Notes Module."""
-
-    name = 'opnotes'
-    help = 'present and manage operator notes'
-    tags = False
-
-    def run_once(self, options):
-        """Create the module."""
-        config = Config(options.config)
-        self.module = OpNotes(**config)
-
-
-class _Console(Module):
-    """Bus Module."""
-
-    name = 'console'
-    help = 'interactive bus console'
-    config = False
-    await_future = False
-
-    def __init__(self, subparser: argparse._SubParsersAction):
-        super().__init__(subparser)
-        self.sub.add_argument(
-            '-p', '--port', action='store', type=int, default=1324,
-            help='connect to port (default: 1324)')
-        self.sub.add_argument(
-            '-i', '--ip', action='store', default='localhost',
-            help='connect to ip address (default: locahost)')
-
-    def run_once(self, options):
-        """Create the module."""
-        tag_info = dict(Config(options.tags))
-        self.module = Console(options.ip, options.port, tag_info)
-
-
-class _checkout(Module):
-    """Bus Module."""
-
-    name = 'checkout'
-    help = 'create example config files'
-    epilog = """
-        To add to systemd `f="pymscada-bus" && cp config/$f.service
-        /lib/systemd/system && systemctl enable $f && systemctl start
-        $f`"""
-    config = False
-    tags = False
-
-    def __init__(self, subparser: argparse._SubParsersAction):
-        super().__init__(subparser)
-        self.sub.add_argument(
-            '--overwrite', action='store_true', default=False,
-            help='checkout may overwrite files, CARE!')
-        self.sub.add_argument(
-            '--diff', action='store_true', default=False,
-            help='compare default with existing')
-
-    def run_once(self, options):
-        """Create the module."""
-        checkout(overwrite=options.overwrite, diff=options.diff)
-
-
-class _validate(Module):
-    """Bus Module."""
-
-    name = 'validate'
-    help = 'validate config files'
-    config = False
-    tags = False
-
-    def __init__(self, subparser: argparse._SubParsersAction):
-        super().__init__(subparser)
-        self.sub.add_argument(
-            '--path', metavar='file',
-            help='default is current working directory')
-
-    def run_once(self, options):
-        """Create the module."""
-        r, e, p = validate(options.path)
-        if r:
-            print(f'Config files in {p} valid.')
-        else:
-            print(e)
-
-
-class _AccuWeatherClient(Module):
-    """Bus Module."""
-
-    name = 'accuweatherclient'
-    help = 'poll weather information'
-
-    def run_once(self, options):
-        """Create the module."""
-        config = Config(options.config)
-        self.module = AccuWeatherClient(**config)
-
-
-class _LogixClient(Module):
-    """Bus Module."""
-
-    name = 'logixclient'
-    help = 'poll/write to logix devices'
-
-    def run_once(self, options):
-        """Create the module."""
-        config = Config(options.config)
-        self.module = LogixClient(**config)
-
-
-class _ModbusServer(Module):
-    """Bus Module."""
-
-    name = 'modbusserver'
-    help = 'receive modbus messages'
-    epilog = """
-        Needs `setcap CAP_NET_BIND_SERVICE=+eip /usr/bin/python3.nn` to
-        bind to port 502."""
-    tags = False
-
-    def run_once(self, options):
-        """Create the module."""
-        config = Config(options.config)
-        self.module = ModbusServer(**config)
-
-
-class _ModbusClient(Module):
-    """Bus Module."""
-
-    name = 'modbusclient'
-    help = 'poll/write to modbus devices'
-    tags = False
-
-    def run_once(self, options):
-        """Create the module."""
-        config = Config(options.config)
-        self.module = ModbusClient(**config)
-
-
-class _PingClient(Module):
-    """Bus Module."""
-
-    name = 'ping'
-    help = 'ping a list of addresses, return time'
-    epilog = """
-        Needs `setcap CAP_NET_RAW+ep /usr/bin/python3.nn` to open SOCK_RAW
-    """
-    tags = False
-
-    def run_once(self, options):
-        """Create the module."""
-        if sys.platform.startswith("win"):
-            asyncio.set_event_loop_policy(
-                asyncio.WindowsSelectorEventLoopPolicy())
-        config = Config(options.config)
-        self.module = PingClient(**config)
-
-
-class _SnmpClient(Module):
-    """Bus Module."""
-
-    name = 'snmpclient'
-    help = 'poll snmp oids'
-    tags = False
-
-    def run_once(self, options):
-        """Create the module."""
-        config = Config(options.config)
-        self.module = SnmpClient(**config)
+from importlib.metadata import version
+from pymscada.module_config import ModuleFactory
 
 
-def args(_version: str):
+def args():
     """Read commandline arguments."""
     parser = argparse.ArgumentParser(
         prog='pymscada',
         description='Connect IO, logic, applications, and webpage UI',
-        epilog=f'Python Mobile SCADA {_version}'
+        epilog=f'Python Mobile SCADA {version("pymscada")}'
     )
-    s = parser.add_subparsers(title='module')
-    _Bus(s)
-    _WwwServer(s)
-    _History(s)
-    _Files(s)
-    _OpNotes(s)
-    _Console(s)
-    _checkout(s)
-    _validate(s)
-    _AccuWeatherClient(s)
-    _LogixClient(s)
-    _ModbusServer(s)
-    _ModbusClient(s)
-    _PingClient(s)
-    _SnmpClient(s)
+    factory = ModuleFactory()
+    subparsers = parser.add_subparsers(title='module', dest='module_name')
+    for _, module_def in factory.modules.items():
+        factory.add_module_parser(subparsers, module_def)
     return parser.parse_args()
 
 
 async def run():
-    """Run bus and wwwserver."""
-    _version = version("pymscada")
-    logging.warning(f'pymscada {_version} starting')
-    options = args(_version)
-    if options.verbose:
-        logging.getLogger().setLevel(logging.INFO)
-    options.app.run_once(options)
-    if options.app.module is not None:
-        await options.app.module.start()
-        if options.app.await_future:
-            await asyncio.get_event_loop().create_future()
+    """Run the selected module."""
+    options = args()
+    if not options.module_name:
+        print("Error: Please specify a module to run")
+        sys.exit(1)
+    root_logger = logging.getLogger()
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter('%(levelname)s:pymscada: %(message)s')
+    handler.setFormatter(formatter)
+    root_logger.handlers.clear()  # Remove any existing handlers
+    root_logger.addHandler(handler)
+    root_logger.setLevel(logging.INFO)
+    logging.info(f'Python Mobile SCADA {version("pymscada")} starting '
+                 f'{options.module_name}')
+    if not options.verbose:
+        root_logger.setLevel(logging.WARNING)
+    factory = ModuleFactory()
+    module = factory.create_module(options.module_name, options)
+    if module is not None:
+        if hasattr(module, 'start'):
+            await module.start()
+        if options.module_name in factory.modules:
+            module_def = factory.modules[options.module_name]
+            if module_def.await_future:
+                await asyncio.get_event_loop().create_future()
+
+
+def main():
+    """Entry point."""
+    asyncio.run(run())
+
+if __name__ == '__main__':
+    main()

pymscada/module_config.py

@@ -0,0 +1,208 @@
+"""Module configuration and factory system."""
+from typing import Any, Optional, Type
+import argparse
+from importlib.metadata import version
+import logging
+from pymscada.config import Config
+from pymscada.console import Console
+
+class ModuleArgument:
+    def __init__(self, args: tuple[str, ...], kwargs: dict[str, Any]):
+        self.args = args
+        self.kwargs = kwargs
+
+class ModuleDefinition:
+    """Defines a module's configuration and behavior."""
+    def __init__(self, name: str, help: str, module_class: Type[Any], *,
+                 config: bool = True, tags: bool = True,
+                 epilog: Optional[str] = None,
+                 extra_args: list[ModuleArgument] = None,
+                 await_future: bool = True):
+        self.name = name
+        self.help = help
+        self.module_class = module_class
+        self.config = config
+        self.tags = tags
+        self.epilog = epilog
+        self.extra_args = extra_args
+        self.await_future = await_future
+
+def create_module_registry():
+    """Create the central module registry with lazy imports."""
+    return [
+        ModuleDefinition(
+            name='bus',
+            help='run the message bus',
+            module_class='pymscada.bus_server:BusServer',
+            tags=False
+        ),
+        ModuleDefinition(
+            name='wwwserver',
+            help='serve web pages',
+            module_class='pymscada.www_server:WwwServer'
+        ),
+        ModuleDefinition(
+            name='history',
+            help='save tag changes to database',
+            module_class='pymscada.history:History'
+        ),
+        ModuleDefinition(
+            name='files',
+            help='serve files',
+            module_class='pymscada.files:Files'
+        ),
+        ModuleDefinition(
+            name='opnotes',
+            help='operator notes',
+            module_class='pymscada.opnotes:OpNotes'
+        ),
+        ModuleDefinition(
+            name='validate',
+            help='validate config files',
+            module_class='pymscada.validate:validate',
+            config=False,
+            tags=False,
+            extra_args=[
+                ModuleArgument(
+                    ('--path',),
+                    {'metavar': 'file', 'help': 'default is current working directory'}
+                )
+            ]
+        ),
+        ModuleDefinition(
+            name='checkout',
+            help='create example config files',
+            module_class='pymscada.checkout:checkout',
+            config=False,
+            tags=False,
+            epilog="""To add to systemd `f="pymscada-bus" && cp config/$f.service
+                     /lib/systemd/system && systemctl enable $f && systemctl start $f`""",
+            extra_args=[
+                ModuleArgument(
+                    ('--overwrite',),
+                    {'action': 'store_true', 'default': False,
+                     'help': 'checkout may overwrite files, CARE!'}
+                ),
+                ModuleArgument(
+                    ('--diff',),
+                    {'action': 'store_true', 'default': False,
+                     'help': 'compare default with existing'}
+                )
+            ]
+        ),
+        ModuleDefinition(
+            name='accuweatherclient',
+            help='poll weather information',
+            module_class='pymscada.iodrivers.accuweather:AccuWeatherClient'
+        ),
+        ModuleDefinition(
+            name='logixclient',
+            help='poll/write to logix devices',
+            module_class='pymscada.iodrivers.logix_client:LogixClient'
+        ),
+        ModuleDefinition(
+            name='modbusclient',
+            help='poll/write modbus devices',
+            module_class='pymscada.iodrivers.modbus_client:ModbusClient'
+        ),
+        ModuleDefinition(
+            name='modbusserver',
+            help='serve modbus devices',
+            module_class='pymscada.iodrivers.modbus_server:ModbusServer'
+        ),
+        ModuleDefinition(
+            name='openweatherclient',
+            help='poll OpenWeather current and forecast data',
+            module_class='pymscada.iodrivers.openweather:OpenWeatherClient'
+        ),
+        ModuleDefinition(
+            name='pingclient',
+            help='ping network devices',
+            module_class='pymscada.iodrivers.ping_client:PingClient'
+        ),
+        ModuleDefinition(
+            name='snmpclient',
+            help='poll SNMP devices',
+            module_class='pymscada.iodrivers.snmp_client:SnmpClient'
+        ),
+        ModuleDefinition(
+            name='console',
+            help='interactive bus console',
+            module_class='pymscada.console:Console',
+            config=False,
+            await_future=False,
+            extra_args=[
+                ModuleArgument(
+                    ('-p', '--port'),
+                    {'action': 'store', 'type': int, 'default': 1324,
+                     'help': 'connect to port (default: 1324)'}
+                ),
+                ModuleArgument(
+                    ('-i', '--ip'),
+                    {'action': 'store', 'default': 'localhost',
+                     'help': 'connect to ip address (default: localhost)'}
+                )
+            ]
+        ),
+    ]
+
+class ModuleFactory:
+    """Creates and manages module instances."""
+    
+    def __init__(self):
+        self.modules = {m.name: m for m in create_module_registry()}
+        
+    def add_module_parser(self, subparser: argparse._SubParsersAction, 
+                         module_def: ModuleDefinition) -> argparse.ArgumentParser:
+        """Add a parser for a module with its arguments."""
+        parser = subparser.add_parser(
+            module_def.name,
+            help=module_def.help,
+            epilog=module_def.epilog
+        )
+        if module_def.config:
+            parser.add_argument(
+                '--config',
+                metavar='file',
+                default=f'{module_def.name}.yaml',
+                help=f"Config file, default is '{module_def.name}.yaml'"
+            )
+        if module_def.tags:
+            parser.add_argument(
+                '--tags',
+                metavar='file',
+                default='tags.yaml',
+                help="Tags file, default is 'tags.yaml'"
+            )
+        parser.add_argument(
+            '--verbose',
+            action='store_true',
+            help="Set level to logging.INFO"
+        )
+        if module_def.extra_args:
+            for arg in module_def.extra_args:
+                parser.add_argument(*arg.args, **arg.kwargs)
+        return parser
+
+    def create_module(self, module_name: str, options: argparse.Namespace):
+        """Create a module instance based on configuration and options."""
+        module_def = self.modules[module_name]
+        logging.info(f'Python Mobile SCADA {version("pymscada")} '
+                     f'starting {module_def.name}')
+        # Import the module class only when needed
+        if isinstance(module_def.module_class, str):
+            module_path, class_name = module_def.module_class.split(':')
+            module = __import__(module_path, fromlist=[class_name])
+            actual_class = getattr(module, class_name)
+        else:
+            actual_class = module_def.module_class
+            
+        kwargs = {}
+        if module_def.config:
+            kwargs.update(Config(options.config))  
+        if module_def.tags:
+            kwargs['tag_info'] = dict(Config(options.tags))
+        if module_name == 'console':
+            return Console(options.ip, options.port,
+                         kwargs.get('tag_info',{}))
+        return actual_class(**kwargs)