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

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,217 @@
+"""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',
+            tags=False
+        ),
+        ModuleDefinition(
+            name='opnotes',
+            help='operator notes',
+            module_class='pymscada.opnotes:OpNotes',
+            tags=False
+        ),
+        ModuleDefinition(
+            name='validate',
+            help='validate config files',
+            module_class='pymscada.validate:validate',
+            config=False,
+            tags=False,
+            extra_args=[
+                ModuleArgument(
+                    ('--path',),
+                    {'metavar': 'file', 'help': 'default is current working directory'}
+                )
+            ]
+        ),
+        ModuleDefinition(
+            name='checkout',
+            help='create example config files',
+            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',
+            tags=False
+        ),
+        ModuleDefinition(
+            name='logixclient',
+            help='poll/write to logix devices',
+            module_class='pymscada.iodrivers.logix_client:LogixClient',
+            tags=False
+        ),
+        ModuleDefinition(
+            name='modbusclient',
+            help='poll/write modbus devices',
+            module_class='pymscada.iodrivers.modbus_client:ModbusClient',
+            tags=False
+        ),
+        ModuleDefinition(
+            name='modbusserver',
+            help='serve modbus devices',
+            module_class='pymscada.iodrivers.modbus_server:ModbusServer',
+            tags=False
+        ),
+        ModuleDefinition(
+            name='openweatherclient',
+            help='poll OpenWeather current and forecast data',
+            module_class='pymscada.iodrivers.openweather:OpenWeatherClient',
+            tags=False
+        ),
+        ModuleDefinition(
+            name='pingclient',
+            help='ping network devices',
+            module_class='pymscada.iodrivers.ping_client:PingClient',
+            tags=False
+        ),
+        ModuleDefinition(
+            name='snmpclient',
+            help='poll SNMP devices',
+            module_class='pymscada.iodrivers.snmp_client:SnmpClient',
+            tags=False
+        ),
+        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)

pymscada/protocol_constants.py

@@ -16,17 +16,17 @@ rarely.
 - data size of 8-bit char
 
 command
-- CMD_ID data is tagname
+- CMD.ID data is tagname
   - reply: CMD_ID with tag_id and data as tagname
-- CMD_SET id, data is typed or json packed
+- CMD.SET id, data is typed or json packed
   - no reply
-- CMD_UNSUB id
+- CMD.UNSUB id
   - no reply
-- CMD_GET id
-- CMD_RTA id, data is request to author
-- CMD_SUB id
+- CMD.GET id
+- CMD.RTA id, data is request to author
+- CMD.SUB id
   - reply: SET id and value, value may be None
-- CMD_LIST
+- CMD.LIST
   - size == 0x00
     - tags with values newer than time_us
   - size > 0x00
@@ -34,43 +34,33 @@ command
     - text$ matches start of tagname
     - text matches anywhere in tagname
   - reply: LIST data as space separated tagnames
-- CMD_LOG data to logging.warning
+- CMD.LOG data to logging.warning
 """
 
 # Tuning constants
 MAX_LEN = 65535 - 14  # TODO fix server(?) when 3
 
-# Network protocol commands
-CMD_ID = 1  # query / inform tag ID - data is tagname bytes string
-CMD_SET = 2  # set a tag
-CMD_GET = 3  # get a tag
-CMD_RTA = 4  # request to author
-CMD_SUB = 5  # subscribe to a tag
-CMD_UNSUB = 6  # unsubscribe from a tag
-CMD_LIST = 7  # bus list tags
-CMD_ERR = 8  # action failed
-CMD_LOG = 9  # bus print a logging message
+from enum import IntEnum
 
-CMD_TEXT = {
-    1: 'CMD_ID',
-    2: 'CMD_SET',
-    3: 'CMD_GET',
-    4: 'CMD_RTA',
-    5: 'CMD_SUB',
-    6: 'CMD_UNSUB',
-    7: 'CMD_LIST',
-    8: 'CMD_ERR',
-    9: 'CMD_LOG'
-}
+class COMMAND(IntEnum):
+    ID = 1     # query / inform tag ID - data is tagname bytes string
+    SET = 2    # set a tag
+    GET = 3    # get a tag
+    RTA = 4    # request to author
+    SUB = 5    # subscribe to a tag
+    UNSUB = 6  # unsubscribe from a tag
+    LIST = 7   # bus list tags
+    ERR = 8    # action failed
+    LOG = 9    # bus print a logging message
 
-COMMANDS = [CMD_ID, CMD_SET, CMD_GET, CMD_RTA, CMD_SUB, CMD_UNSUB, CMD_LIST,
-            CMD_ERR, CMD_LOG]
+    @staticmethod
+    def text(cmd) -> str:
+        """Return command text description for enum or int."""
+        return COMMAND(cmd).name
 
-# data types
-TYPE_INT = 1  # 64 bit signed integer
-TYPE_FLOAT = 2  # 64 bit IEEE float
-TYPE_STR = 3  # string
-TYPE_BYTES = 4
-TYPE_JSON = 5
-
-TYPES = [TYPE_INT, TYPE_FLOAT, TYPE_STR, TYPE_BYTES, TYPE_JSON]
+class TYPE(IntEnum):
+    INT = 1    # 64 bit signed integer
+    FLOAT = 2  # 64 bit IEEE float
+    STR = 3    # string
+    BYTES = 4  # raw bytes
+    JSON = 5   # JSON encoded data