pymscada 0.1.11b9__py3-none-any.whl → 0.2.0rc1__py3-none-any.whl

pymscada/checkout.py

@@ -6,100 +6,98 @@ import sys
 from pymscada.config import get_demo_files, get_pdf_files
 
 
-PATH = {
-    '__PYTHON__': Path(f'{sys.exec_prefix}/bin/python').absolute(),
-    '__PYMSCADA__': Path(sys.argv[0]).absolute(),
-    '__DIR__': Path('.').absolute(),
-    '__HOME__': Path.home().absolute(),
-    '__USER__': getpass.getuser()
-}
-if sys.platform == "win32":
-    PATH = {
-        '__PYTHON__': Path(f'{sys.exec_prefix}/python.exe').absolute(),
-        '__PYMSCADA__': Path(sys.argv[0]).absolute(),
-        '__DIR__': Path('.').absolute(),
-        '__HOME__': Path.home(),
-        '__USER__': getpass.getuser()
-    }
+class Checkout:
+    """Create and manage configuration files."""
+    
+    def __init__(self, **kwargs):
+        """Initialize paths and settings."""
+        self.path = {
+            '__PYTHON__': Path(f'{sys.exec_prefix}/bin/python').absolute(),
+            '__PYMSCADA__': Path(sys.argv[0]).absolute(),
+            '__DIR__': Path('.').absolute(),
+            '__HOME__': Path.home().absolute(),
+            '__USER__': getpass.getuser()
+        }
+        if sys.platform == "win32":
+            self.path['__PYTHON__'] = Path(f'{sys.exec_prefix}/python.exe').absolute()
+        
+        self.overwrite = kwargs.get('overwrite', False)
+        self.diff = kwargs.get('diff', False)
 
-def make_history():
-    """Make the history folder if missing."""
-    history_dir = PATH['__DIR__'].joinpath('history')
-    if not history_dir.exists():
-        print("making 'history' folder")
-        history_dir.mkdir()
+    def make_history(self):
+        """Make the history folder if missing."""
+        history_dir = self.path['__DIR__'].joinpath('history')
+        if not history_dir.exists():
+            print("making 'history' folder")
+            history_dir.mkdir()
 
+    def make_pdf(self):
+        """Make the pdf folder if missing."""
+        pdf_dir = self.path['__DIR__'].joinpath('pdf')
+        if not pdf_dir.exists():
+            print('making pdf dir')
+            pdf_dir.mkdir()
+        for pdf_file in get_pdf_files():
+            target = pdf_dir.joinpath(pdf_file.name)
+            target.write_bytes(pdf_file.read_bytes())
 
-def make_pdf():
-    """Make the pdf folder if missing."""
-    pdf_dir = PATH['__DIR__'].joinpath('pdf')
-    if not pdf_dir.exists():
-        print('making pdf dir')
-        pdf_dir.mkdir()
-    for pdf_file in get_pdf_files():
-        target = pdf_dir.joinpath(pdf_file.name)
-        target.write_bytes(pdf_file.read_bytes())
+    def make_config(self):
+        """Make the config folder, if missing, and copy files in."""
+        config_dir = self.path['__DIR__'].joinpath('config')
+        if not config_dir.exists():
+            print('making config dir')
+            config_dir.mkdir()
+        for config_file in get_demo_files():
+            target = config_dir.joinpath(config_file.name)
+            rt = 'Creating '
+            if target.exists():
+                if self.overwrite:
+                    rt = 'Replacing '
+                    target.unlink()
+                else:
+                    continue
+            print(f'{rt} {target}')
+            rd_bytes = config_file.read_bytes()
+            if target.name.lower() != 'readme.md':
+                for k, v in self.path.items():
+                    rd_bytes = rd_bytes.replace(k.encode(), str(v).encode())
+            target.write_bytes(rd_bytes)
 
+    def read_with_subst(self, file: Path):
+        """Read the file and replace DIR markers."""
+        rd = file.read_bytes().decode()
+        for k, v in self.path.items():
+            rd = rd.replace(k, str(v))
+        lines = rd.splitlines()
+        return lines
 
-def make_config(overwrite: bool):
-    """Make the config folder, if missing, and copy files in."""
-    config_dir = PATH['__DIR__'].joinpath('config')
-    if not config_dir.exists():
-        print('making config dir')
-        config_dir.mkdir()
-    for config_file in get_demo_files():
-        target = config_dir.joinpath(config_file.name)
-        rt = 'Creating '
-        if target.exists():
-            if overwrite:
-                rt = 'Replacing '
-                target.unlink()
+    def compare_config(self):
+        """Compare old and new config."""
+        config_dir = self.path['__DIR__'].joinpath('config')
+        if not config_dir.exists():
+            print('No config dir, are you in the right directory')
+            return
+        for config_file in get_demo_files():
+            target = config_dir.joinpath(config_file.name)
+            if target.exists():
+                new_lines = self.read_with_subst(config_file)
+                old_lines = self.read_with_subst(target)
+                diff = list(difflib.unified_diff(old_lines, new_lines,
+                            fromfile=str(target), tofile=str(config_file)))
+                if len(diff):
+                    print('\n'.join(diff), '\n')
             else:
-                continue
-        print(f'{rt} {target}')
-        rd_bytes = config_file.read_bytes()
-        if target.name.lower() != 'readme.md':
-            for k, v in PATH.items():
-                rd_bytes = rd_bytes.replace(k.encode(), str(v).encode())
-        target.write_bytes(rd_bytes)
+                print(f'\n--- MISSING FILE\n\n+++ {config_file}')
 
-
-def read_with_subst(file: Path):
-    """Read the file and replace DIR markers."""
-    rd = file.read_bytes().decode()
-    for k, v in PATH.items():
-        rd = rd.replace(k, str(v))
-    lines = rd.splitlines()
-    return lines
-
-
-def compare_config():
-    """Compare old and new config."""
-    config_dir = PATH['__DIR__'].joinpath('config')
-    if not config_dir.exists():
-        print('No config dir, are you in the right directory')
-        return
-    for config_file in get_demo_files():
-        target = config_dir.joinpath(config_file.name)
-        if target.exists():
-            new_lines = read_with_subst(config_file)
-            old_lines = read_with_subst(target)
-            diff = list(difflib.unified_diff(old_lines, new_lines,
-                        fromfile=str(target), tofile=str(config_file)))
-            if len(diff):
-                print('\n'.join(diff), '\n')
+    async def start(self):
+        """Execute checkout process."""
+        for name in ['__PYTHON__', '__PYMSCADA__', '__DIR__', '__HOME__']:
+            if not self.path[name].exists():
+                raise SystemExit(f'{self.path[name]} is missing')
+        
+        if self.diff:
+            self.compare_config()
         else:
-            print(f'\n--- MISSING FILE\n\n+++ {config_file}')
-
-
-def checkout(overwrite=False, diff=False):
-    """Do it."""
-    for name in ['__PYTHON__', '__PYMSCADA__', '__DIR__', '__HOME__']:
-        if not PATH[name].exists():
-            raise SystemExit(f'{PATH[name]} is missing')
-    if diff:
-        compare_config()
-    else:
-        make_history()
-        make_pdf()
-        make_config(overwrite)
+            self.make_history()
+            self.make_pdf()
+            self.make_config()

pymscada/demo/openweather.yaml

@@ -2,7 +2,7 @@ bus_ip: 127.0.0.1
 bus_port: 1324
 proxy:
 api:
-  api_key: ${OPENWEATHER_API_KEY}
+  api_key: ${OPENWEATHERMAP_API_KEY}
   units: metric
   locations:
     Murupara:

pymscada/demo/{pymscada-io-accuweather.service → pymscada-io-openweather.service}

@@ -1,11 +1,11 @@
 [Unit]
-    Description=pymscada - AccuWeather client
+    Description=pymscada - Open Weather client
     BindsTo=pymscada-bus.service
     After=pymscada-bus.service
 
 [Service]
     WorkingDirectory=__DIR__
-    ExecStart=__PYMSCADA__ accuweatherclient --config __DIR__/config/accuweather.yaml
+    ExecStart=__PYMSCADA__ openweatherclient --config __DIR__/config/openweather.yaml
     Restart=always
     RestartSec=5
     User=__USER__

pymscada/history.py

@@ -1,11 +1,33 @@
-"""Store and provide history."""
+"""Store and provide history.
+
+History File Structure
+---------------------
+History files are binary files stored as <tagname>_<time_us>.dat where time_us
+is the microsecond timestamp of the first entry in that file.
+
+Each file contains a series of fixed-size records (16 bytes each):
+- For integer tags: 8 bytes timestamp (uint64) + 8 bytes value (int64)
+- For float tags: 8 bytes timestamp (uint64) + 8 bytes value (double)
+
+Files are organized in chunks:
+- Each chunk is 1024 records (16KB)
+- Each file contains up to 64 chunks (1MB)
+- New files are created when:
+  1. Current file reaches max size (64 chunks)
+  2. Manual flush() is called
+  3. Application shutdown
+
+Timestamps are stored as microseconds since epoch in network byte order (big-endian).
+Values are also stored in network byte order.
+"""
 import atexit
 import logging
 from pathlib import Path
 from struct import pack, pack_into, unpack_from, error
 import time
+from typing import TypedDict, Optional
 from pymscada.bus_client import BusClient
-from pymscada.tag import Tag, TYPES
+from pymscada.tag import Tag, TagInfo, TYPES
 
 
 ITEM_SIZE = 16  # Q + q, Q or d
@@ -14,6 +36,16 @@ CHUNK_SIZE = ITEM_COUNT * ITEM_SIZE
 FILE_CHUNKS = 64
 
 
+class Request(TypedDict, total=False):
+    """Type definition for request dictionary."""
+    tagname: str 
+    start_ms: Optional[int]  # Allow web client to use native ms
+    start_us: Optional[int]  # Native for pymscada server
+    end_ms: Optional[int]
+    end_us: Optional[int]
+    __rta_id__: Optional[int]  # Empty for a change that must be broadcast
+
+
 def tag_for_history(tagname: str, tag: dict):
     """Correct tag dictionary in place to be suitable for web client."""
     tag['name'] = tagname
@@ -189,7 +221,7 @@ class History():
     """Connect to bus_ip:bus_port, store and provide a value history."""
 
     def __init__(self, bus_ip: str = '127.0.0.1', bus_port: int = 1324,
-                 path: str = 'history', tag_info: dict = {},
+                 path: str = 'history', tag_info: TagInfo = {},
                  rta_tag: str = '__history__') -> None:
         """
         Connect to bus_ip:bus_port, store and provide a value history.
@@ -217,7 +249,7 @@ class History():
         self.rta.value = b'\x00\x00\x00\x00\x00\x00'
         self.busclient.add_callback_rta(rta_tag, self.rta_cb)
 
-    def rta_cb(self, request):
+    def rta_cb(self, request: Request):
         """Respond to bus requests for data to publish on rta."""
         if 'start_ms' in request:
             request['start_us'] = request['start_ms'] * 1000

pymscada/iodrivers/openweather.py

@@ -41,82 +41,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/main.py

@@ -39,7 +39,7 @@ async def run():
     if not options.verbose:
         root_logger.setLevel(logging.WARNING)
     factory = ModuleFactory()
-    module = factory.create_module(options.module_name, options)
+    module = factory.create_module(options)
     if module is not None:
         if hasattr(module, 'start'):
             await module.start()

pymscada/module_config.py

@@ -75,9 +75,10 @@ def create_module_registry():
         ModuleDefinition(
             name='checkout',
             help='create example config files',
-            module_class='pymscada.checkout:checkout',
+            module_class='pymscada.checkout:Checkout',
             config=False,
             tags=False,
+            await_future=False,
             epilog=dedent("""
                 To add to systemd:
                   su -
@@ -156,12 +157,12 @@ def create_module_registry():
                 like to see correctly typed values and set values."""),
             extra_args=[
                 ModuleArgument(
-                    ('-p', '--port'),
+                    ('-p', '--bus-port'),
                     {'action': 'store', 'type': int, 'default': 1324,
                      'help': 'connect to port (default: 1324)'}
                 ),
                 ModuleArgument(
-                    ('-i', '--ip'),
+                    ('-i', '--bus-ip'),
                     {'action': 'store', 'default': 'localhost',
                      'help': 'connect to ip address (default: localhost)'}
                 )
@@ -208,9 +209,11 @@ class ModuleFactory:
                 parser.add_argument(*arg.args, **arg.kwargs)
         return parser
 
-    def create_module(self, module_name: str, options: argparse.Namespace):
+    def create_module(self, options: argparse.Namespace):
         """Create a module instance based on configuration and options."""
-        module_def = self.modules[module_name]
+        if options.module_name not in self.modules:
+            raise ValueError(f'{options.module_name} does not exist')
+        module_def = self.modules[options.module_name]
         logging.info(f'Python Mobile SCADA {version("pymscada")} '
                      f'starting {module_def.name}')
         # Import the module class only when needed
@@ -220,13 +223,14 @@ class ModuleFactory:
             actual_class = getattr(module, class_name)
         else:
             actual_class = module_def.module_class
-            
         kwargs = {}
         if module_def.config:
-            kwargs.update(Config(options.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',{}))
+        if module_def.extra_args:
+            for arg in module_def.extra_args:
+                arg_name = arg.args[-1].lstrip('-').replace('-', '_')
+                if hasattr(options, arg_name):
+                    kwargs[arg_name] = getattr(options, arg_name)
         return actual_class(**kwargs)

pymscada/opnotes.py

@@ -14,8 +14,8 @@ class OpNotes:
         """
         Connect to bus_ip:bus_port, serve and update operator notes database.
 
-        TODO
-        Write something.
+        Open an Operator notes table, creating if necessary. Provide additions,
+        updates, deletions and history requests via the rta_tag.
 
         Event loop must be running.
         """
@@ -25,19 +25,55 @@ class OpNotes:
         self.connection = sqlite3.connect(db)
         self.table = table
         self.cursor = self.connection.cursor()
+        self._init_table()
+        self.busclient = BusClient(bus_ip, bus_port, module='OpNotes')
+        self.rta = Tag(rta_tag, dict)
+        self.rta.value = {}
+        self.busclient.add_callback_rta(rta_tag, self.rta_cb)
+
+    def _init_table(self):
+        """Initialize or upgrade the database table schema."""
         query = (
             'CREATE TABLE IF NOT EXISTS ' + self.table +
             '(id INTEGER PRIMARY KEY ASC, '
             'date_ms INTEGER, '
             'site TEXT, '
             'by TEXT, '
-            'note TEXT)'
+            'note TEXT, '
+            'abnormal INTEGER)'
         )
         self.cursor.execute(query)
-        self.busclient = BusClient(bus_ip, bus_port, module='OpNotes')
-        self.rta = Tag(rta_tag, dict)
-        self.rta.value = {}
-        self.busclient.add_callback_rta(rta_tag, self.rta_cb)
+        self.cursor.execute(f"PRAGMA table_info({self.table})")
+        columns = {col[1]: col[2] for col in self.cursor.fetchall()}
+        if 'abnormal' not in columns:
+            # Add abnormal as INTEGER from original schema
+            logging.warning(f'Upgrading {self.table} schema to include '
+                          'abnormal INTEGER, CANNOT revert automatically!')
+            self.cursor.execute(
+                f'ALTER TABLE {self.table} ADD COLUMN abnormal INTEGER')
+        elif columns['abnormal'].upper() == 'BOOLEAN':
+            # Change abnormal from BOOLEAN to INTEGER
+            logging.warning(f'Upgrading {self.table} abnormal from BOOLEAN to '
+                          'INTEGER, CANNOT revert automatically!')
+            self.cursor.execute(
+                f'CREATE TABLE {self.table}_new '
+                '(id INTEGER PRIMARY KEY ASC, '
+                'date_ms INTEGER, '
+                'site TEXT, '
+                'by TEXT, '
+                'note TEXT, '
+                'abnormal INTEGER)'
+            )
+            self.cursor.execute(
+                f'INSERT INTO {self.table}_new '
+                f'SELECT id, date_ms, site, by, note, '
+                f'CASE WHEN abnormal THEN 1 ELSE 0 END '
+                f'FROM {self.table}'
+            )
+            self.cursor.execute(f'DROP TABLE {self.table}')
+            self.cursor.execute(
+                f'ALTER TABLE {self.table}_new RENAME TO {self.table}'
+            )
 
     def rta_cb(self, request):
         """Respond to Request to Author and publish on rta_tag as needed."""
@@ -48,8 +84,10 @@ class OpNotes:
                 logging.info(f'add {request}')
                 with self.connection:
                     self.cursor.execute(
-                        f'INSERT INTO {self.table} (date_ms, site, by, note) '
-                        'VALUES(:date_ms, :site, :by, :note) RETURNING *;',
+                        f'INSERT INTO {self.table} '
+                        '(date_ms, site, by, note, abnormal) '
+                        'VALUES(:date_ms, :site, :by, :note, :abnormal) '
+                        'RETURNING *;',
                         request)
                     res = self.cursor.fetchone()
                     self.rta.value = {
@@ -57,7 +95,8 @@ class OpNotes:
                         'date_ms': res[1],
                         'site': res[2],
                         'by': res[3],
-                        'note': res[4]
+                        'note': res[4],
+                        'abnormal': res[5]
                     }
             except sqlite3.IntegrityError as error:
                 logging.warning(f'OpNotes rta_cb {error}')
@@ -67,14 +106,15 @@ class OpNotes:
                 with self.connection:
                     self.cursor.execute(
                         f'REPLACE INTO {self.table} VALUES(:id, :date_ms, '
-                        ':site, :by, :note) RETURNING *;', request)
+                        ':site, :by, :note, :abnormal) RETURNING *;', request)
                     res = self.cursor.fetchone()
                     self.rta.value = {
                         'id': res[0],
                         'date_ms': res[1],
                         'site': res[2],
                         'by': res[3],
-                        'note': res[4]
+                        'note': res[4],
+                        'abnormal': res[5]
                     }
             except sqlite3.IntegrityError as error:
                 logging.warning(f'OpNotes rta_cb {error}')
@@ -101,7 +141,8 @@ class OpNotes:
                             'date_ms': res[1],
                             'site': res[2],
                             'by': res[3],
-                            'note': res[4]
+                            'note': res[4],
+                            'abnormal': res[5]
                         }
             except sqlite3.IntegrityError as error:
                 logging.warning(f'OpNotes rta_cb {error}')

pymscada/protocol_constants.py

@@ -1,44 +1,62 @@
 """
 Protocol description and protocol constants.
 
-Bus holds a tag forever, assigns a tag id forever, holds a tag value with len
-< 1000 forever, otherwise wipes periodically. So assign tagnames once, at the
-start of your program; use RTA as an update messenger, share whole structures
-rarely.
+Bus holds a tag forever, assigning a new ID for each new tagname.
 
-- version 16-bit unsigned int == 0x01
-- command 16-bit unsigned int
-- tag_id 32-bit unsigned int     0 is not a valid tag_id
-- size 32-bit unsigned int
-  - if size == 0xff  continuation mandatory
-  - size 0x00 completes an empty continuation
-- time_us 128-bit unsigned int, UTC microseconds
-- data size of 8-bit char
+Bus protocol message format:
+- version: 8-bit unsigned int == 0x01
+- command: 8-bit unsigned int
+- tag_id: 16-bit unsigned int (0 is valid for ID requests)
+- size: 16-bit unsigned int
+- time_us: 64-bit unsigned int, UTC microseconds
+- data: variable length bytes of size
 
-command
-- CMD.ID data is tagname
-  - reply: CMD_ID with tag_id and data as tagname
-- CMD.SET id, data is typed or json packed
-  - no reply
-- CMD.UNSUB id
-  - no reply
-- 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
-  - size == 0x00
-    - tags with values newer than time_us
-  - size > 0x00
-    - ^text matches start of tagname
-    - text$ matches start of tagname
-    - text matches anywhere in tagname
-  - reply: LIST data as space separated tagnames
-- CMD.LOG data to logging.warning
+Commands:
+- CMD.ID: Query/inform tag ID
+  - Request: data is tagname as bytes
+  - Reply: CMD.ID with assigned tag_id and tagname as data
+  - Error: CMD.ERR if tagname undefined
+  
+- CMD.SET: Set a tag value
+  - Data format: TYPE byte + typed value
+  - No reply
+  - Error: CMD.ERR if tag_id invalid
+  
+- CMD.GET: Get a tag value
+  - Request: empty data
+  - Reply: CMD.SET with current value
+  - Error: CMD.ERR if tag_id invalid
+  
+- CMD.RTA: Request to author
+  - Request: JSON encoded request
+  - Reply: Comes from target client, not server
+  - Error: CMD.ERR if tag_id invalid or target gone
+  
+- CMD.SUB: Subscribe to tag updates
+  - Request: empty data
+  - Reply: CMD.SET with current value
+  - Error: CMD.ERR if tag_id invalid
+  
+- CMD.UNSUB: Unsubscribe from tag
+  - No reply
+  - Error: CMD.ERR if tag_id invalid
+  
+- CMD.LIST: List tags
+  - Empty data: tags newer than time_us
+  - ^text: tags starting with text
+  - text$: tags ending with text 
+  - text: tags containing text
+  - Reply: CMD.LIST with space-separated tagnames
+  
+- CMD.LOG: Log message
+  - Data: Message to log (max 300 bytes)
+  - Updates __bus__ tag with client address and message
+
+Large messages are split into MAX_LEN chunks. Final chunk size < MAX_LEN.
 """
 
 # Tuning constants
-MAX_LEN = 65535 - 14  # TODO fix server(?) when 3
+MAX_LEN = 65535 - 14  # Maximum data size per message
 
 from enum import IntEnum
 

pymscada/tag.py

@@ -7,6 +7,7 @@ bus_id is python id(), 0 is null pointer in c, 0 is local bus.
 import time
 import array
 import logging
+from typing import TypedDict, Union, Optional, Type, List
 
 TYPES = {
     'int': int,
@@ -310,3 +311,20 @@ class Tag(metaclass=UniqueTag):
                 self.values = array.array('d')
         else:
             raise TypeError(f"shard invalid {self.name} not int, float")
+
+
+class TagInfo(TypedDict, total=False):
+    """Type definition for tag information dictionary."""
+    name: str 
+    id: Optional[int]
+    desc: str
+    type: Union[str, Type[int], Type[float], Type[str], Type[list],
+                Type[dict], Type[bytes]]
+    multi: Optional[List[str]]
+    min: Optional[Union[float, int]]
+    max: Optional[Union[float, int]]
+    deadband: Optional[Union[float, int]]
+    units: Optional[str]
+    dp: Optional[int]
+    format: Optional[str]
+    init: Optional[Union[int, float, str]]

{pymscada-0.1.11b9.dist-info → pymscada-0.2.0rc1.dist-info}/METADATA

@@ -1,25 +1,26 @@
 Metadata-Version: 2.1
 Name: pymscada
-Version: 0.1.11b9
+Version: 0.2.0rc1
 Summary: Shared tag value SCADA with python backup and Angular UI
-Author-Email: Jamie Walton <jamie@walton.net.nz>
+Author-email: Jamie Walton <jamie@walton.net.nz>
 License: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/jamie0walton/pymscada
+Project-URL: Bug Tracker, https://github.com/jamie0walton/pymscada/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: JavaScript
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Classifier: Environment :: Console
 Classifier: Development Status :: 1 - Planning
-Project-URL: Homepage, https://github.com/jamie0walton/pymscada
-Project-URL: Bug Tracker, https://github.com/jamie0walton/pymscada/issues
 Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: PyYAML>=6.0.1
 Requires-Dist: aiohttp>=3.8.5
-Requires-Dist: pymscada-html>=0.1.10b5
+Requires-Dist: pymscada-html==0.2.0rc1
 Requires-Dist: cerberus>=1.3.5
 Requires-Dist: pycomm3>=1.2.14
 Requires-Dist: pysnmplib>=5.0.24
-Description-Content-Type: text/markdown
 
 # pymscada
 #### [Docs](https://github.com/jamie0walton/pymscada/blob/main/docs/README.md)

{pymscada-0.1.11b9.dist-info → pymscada-0.2.0rc1.dist-info}/RECORD

@@ -1,14 +1,22 @@
-pymscada-0.1.11b9.dist-info/METADATA,sha256=_Vl7Sc7VlQZgKxlhqBtIRwQ6i6kuux42oMrXRmzYhZ0,2349
-pymscada-0.1.11b9.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-pymscada-0.1.11b9.dist-info/entry_points.txt,sha256=j_UgZmqFhNquuFC2M8g5-8X9FCpp2RaDb7NrExzkj1c,72
-pymscada-0.1.11b9.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
 pymscada/__init__.py,sha256=NV_cIIwe66Ugp8ns426rtfJIIyskWbqwImD9p_5p0bQ,739
 pymscada/__main__.py,sha256=WcyVlrYOoDdktJhOoyubTOycMwpayksFdxwelRU5xpQ,272
 pymscada/bus_client.py,sha256=ZUCynJtEvmHruzLS6ZAzp-_0dv1A1u_POgemb38kHuc,8989
 pymscada/bus_server.py,sha256=eD4Fz4Sv4EIu2vney_d0jAryiCk5eoH5NQA-dAZRTqA,12029
-pymscada/checkout.py,sha256=1Al29nVqCebupYvMgcY5boz772PtsVp1MVbYaQajV5Q,3373
+pymscada/checkout.py,sha256=RLuCMTEuUI7pp1hIRAUPbo8xYFta8TjArelx0SD4gOY,3897
 pymscada/config.py,sha256=vwGxieaJBYXiHNQEOYVDFaPuGmnUlCnbNm_W9bugKlc,1851
 pymscada/console.py,sha256=b4gm7cuhYKGFNtHoxygWkrqiN42mU8DM4KUi-Q74M4U,8793
+pymscada/files.py,sha256=MisnKoWvkffPMSj6sGVmm-4fh866x4UX3t9LJg4oCfk,2400
+pymscada/history.py,sha256=p3dvrOcGJhQXtM0vfFI4PmEZFnW_-SuAk18yvosaucc,10697
+pymscada/main.py,sha256=d6EnK4-tEcvM5AqMHYhvqlnSh-E_wd0Tuxk-kXYSiDw,1854
+pymscada/misc.py,sha256=0Cj6OFhQonyhyk9x0BG5MiS-6EPk_w6zvavt8o_Hlf0,622
+pymscada/module_config.py,sha256=3-15qhCLsi_xR4i0cy2XZ74w5n0ZcqW2nPcX_Qtc6fU,8720
+pymscada/opnotes.py,sha256=5SjAqycWypLNidXjXF2xHc7n4xinflTxJTKafB7WN-Q,7083
+pymscada/periodic.py,sha256=MLlL93VLvFqBBgjO1Us1t0aLHTZ5BFdW0B__G02T1nQ,1235
+pymscada/protocol_constants.py,sha256=lPJ4JEgFJ_puJjTym83EJIOw3UTUFbuFMwg3ohyUAGY,2414
+pymscada/samplers.py,sha256=t0IscgsCm5YByioOZ6aOKMO_guDFS_wxnJSiOGKI4Nw,2583
+pymscada/tag.py,sha256=GINy8gE1TPLFnuJLVVSui4Ke3IQlOGRy6_ePAlGlvj4,10683
+pymscada/validate.py,sha256=fPMlP6RscYuTIgdEJjJ0ZZI0OyVSat1lpqg254wqpdE,13140
+pymscada/www_server.py,sha256=rV1Vsk3J1wBhFMBCnK33SziNuTGgVwNc5zLjQQFxJ-s,12021
 pymscada/demo/README.md,sha256=iNcVbCTkq-d4agLV-979lNRaqf_hbJCn3OFzY-6qfU8,880
 pymscada/demo/__init__.py,sha256=WsDDgkWnZBJbt2-cJCdc2NvRAv_T4a7WOC1Q0k_l0gI,29
 pymscada/demo/accuweather.yaml,sha256=Fk4rV0S8jCau0173QCzKW8TdUbc4crYVi0aD8fPLNgU,322
@@ -19,17 +27,17 @@ pymscada/demo/logixclient.yaml,sha256=G_NlJhBYwT1a9ceHDgO6fCNKFmBM2pVO_t9Xa1NqlR
 pymscada/demo/modbus_plc.py,sha256=3zZHHbyrdxyryEHBeNIw-fpcDGcS1MaJiqEwQDr6zWI,2397
 pymscada/demo/modbusclient.yaml,sha256=geeCsUJZkkEj7jjXR_Yk6R5zA5Ta9IczrHsARz7ZgXY,1099
 pymscada/demo/modbusserver.yaml,sha256=67_mED6jXgtnzlDIky9Cg4j-nXur06iz9ve3JUwSyG8,1133
-pymscada/demo/openweather.yaml,sha256=eFaRc7JxkEwRswCtmJiypsfR5xgQR-R-UtwvfwDHw-w,430
+pymscada/demo/openweather.yaml,sha256=n8aPc_Ar6uiM-XbrEbBydABxFYm2uv_49dGo8u7DI8Q,433
 pymscada/demo/opnotes.yaml,sha256=gdT8DKaAV4F6u9trLCPyBgf449wYaP_FF8GCbjXm9-k,105
 pymscada/demo/ping.yaml,sha256=fm3eUdR2BwnPI_lU_V07qgmDxjSoPP6lPazYB6ZgpVg,149
 pymscada/demo/pymscada-bus.service,sha256=F3ViriRXyMKdCY3tHa3wXAnv2Fo2_16-EScTLsYnSOA,261
 pymscada/demo/pymscada-demo-modbus_plc.service,sha256=EtbWDwqAs4nLNLKScUiHcUWU1b6_tRBeAAVGi9q95hY,320
 pymscada/demo/pymscada-files.service,sha256=iLOfbl4SCxAwYHT20XCGHU0BJsUVicNHjHzKS8xIdgA,326
 pymscada/demo/pymscada-history.service,sha256=61c5RqOmJ13Dl1yyRfsChKOdXp2W-xfYyCOYoJHLkh8,386
-pymscada/demo/pymscada-io-accuweather.service,sha256=M_dnPYwmvTpYGF5AbMStbYL6VCWgOFR50nRRpfqvpBo,358
 pymscada/demo/pymscada-io-logixclient.service,sha256=mn4UzkiOfYqHvgfTFSkUeoPFQQXZboet5I0m7-L5SAY,348
 pymscada/demo/pymscada-io-modbusclient.service,sha256=eTgNdK10dJCs2lLPhmHBh-3j6Ltx2oyU_MNl2f3xnhg,348
 pymscada/demo/pymscada-io-modbusserver.service,sha256=g7Rzm6zGLq_qvTJRL_pcLl4Ps7CNIa2toeGhPNp_oEc,348
+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-opnotes.service,sha256=TlrTRgP3rzrlXT8isAGT_Wy38ScDjT1VvnlgW84XiS8,354
@@ -37,8 +45,7 @@ pymscada/demo/pymscada-wwwserver.service,sha256=7Qy2wsMmFEsQn-b5mgAcsrAQZgXynkv8
 pymscada/demo/snmpclient.yaml,sha256=z8iACrFvMftYUtqGrRjPZYZTpn7aOXI-Kp675NAM8cU,2013
 pymscada/demo/tags.yaml,sha256=9xydsQriKT0lNAW533rz-FMVgoedn6Lwc50AnNig7-k,2733
 pymscada/demo/wwwserver.yaml,sha256=mmwvSLUXUDCIPaHeCJdCETAp9Cc4wb5CuK_aGv01KWk,2759
-pymscada/files.py,sha256=MisnKoWvkffPMSj6sGVmm-4fh866x4UX3t9LJg4oCfk,2400
-pymscada/history.py,sha256=G079gHfzasmGtI5ANS8MdETD4bdZg5vHE_yTKk7atHw,9504
+pymscada/demo/__pycache__/__init__.cpython-311.pyc,sha256=tpxZoW429YA-2mbwzOlhBmbSTcbvTJqgKCfDRMrhEJE,195
 pymscada/iodrivers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymscada/iodrivers/accuweather.py,sha256=p_OYJtCrtbSQYjgf06Yk3Qc9wGpkx8ogn81XNGd19fE,3842
 pymscada/iodrivers/logix_client.py,sha256=eqmiYLYUBHbr7wTljomGIZVNvXe-5WleGKfzwcHXO8w,2829
@@ -46,24 +53,20 @@ pymscada/iodrivers/logix_map.py,sha256=ljjBAMJcw199v1V5u0Yfl38U6zbZzba5mdY4I3Zvd
 pymscada/iodrivers/modbus_client.py,sha256=DIGrEPz_Bwwj9CEeog5fQqiAu1UMV7xVL6KxlKgXNPs,9592
 pymscada/iodrivers/modbus_map.py,sha256=af2J3CGSeYQ4mSy8rNsERp9z7fRgRUYk3it5Mrc_IQA,7255
 pymscada/iodrivers/modbus_server.py,sha256=VqvjOJ4-LOVaD1jOK22raXhrCshJEaWlMxLvn5xMnFc,6570
-pymscada/iodrivers/openweather.py,sha256=w_OSL5UG30IBTuaR6Exmao7XJae_hKo1JM04XT8Ke7M,5580
+pymscada/iodrivers/openweather.py,sha256=Z9gYvgBlO4379K51gcblEIZ_O5ZY5MlCZ7NG9dX9Y_4,8359
 pymscada/iodrivers/ping_client.py,sha256=UOQgUfoIcYqy5VvKyJ8XGHHjeSRTfjmrhyWEojhIZQk,4188
 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/main.py,sha256=XtASmPZoQMuzDCHlH3P9XwgYskeLtNdl-hc1tDI7ljc,1875
-pymscada/misc.py,sha256=0Cj6OFhQonyhyk9x0BG5MiS-6EPk_w6zvavt8o_Hlf0,622
-pymscada/module_config.py,sha256=Sq9DDND0WotxwdY7mRHG8G-WNPYqWp9fxvx38--kwr0,8462
-pymscada/opnotes.py,sha256=pxjFgy4uMnAmJcfrk8BX4Gl5j0z4fFb5waXcqI6UJ_M,5133
 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/periodic.py,sha256=MLlL93VLvFqBBgjO1Us1t0aLHTZ5BFdW0B__G02T1nQ,1235
-pymscada/protocol_constants.py,sha256=ooGmBM7WGWWdN10FObdjzcYieK8WN7Zy6qVxtD93LMk,1963
-pymscada/samplers.py,sha256=t0IscgsCm5YByioOZ6aOKMO_guDFS_wxnJSiOGKI4Nw,2583
-pymscada/tag.py,sha256=Oxh70q2MrPAEI94v4QsWt4gD8QP6BlfzNv9xXeeUFys,10103
+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/validate.py,sha256=fPMlP6RscYuTIgdEJjJ0ZZI0OyVSat1lpqg254wqpdE,13140
-pymscada/www_server.py,sha256=rV1Vsk3J1wBhFMBCnK33SziNuTGgVwNc5zLjQQFxJ-s,12021
-pymscada-0.1.11b9.dist-info/RECORD,,
+pymscada-0.2.0rc1.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+pymscada-0.2.0rc1.dist-info/METADATA,sha256=fizfH7pRV5twgKOLBboB9eeU-wjZxoANsfoHX2ZsXfU,2371
+pymscada-0.2.0rc1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+pymscada-0.2.0rc1.dist-info/entry_points.txt,sha256=2UJBi8jrqujnerrcXcq4F8GHJYVDt26sacXl94t3sd8,56
+pymscada-0.2.0rc1.dist-info/top_level.txt,sha256=LxIB-zrtgObJg0fgdGZXBkmNKLDYHfaH1Hw2YP2ZMms,9
+pymscada-0.2.0rc1.dist-info/RECORD,,

{pymscada-0.1.11b9.dist-info → pymscada-0.2.0rc1.dist-info}/WHEEL

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

{pymscada-0.1.11b9.dist-info → pymscada-0.2.0rc1.dist-info}/entry_points.txt

@@ -1,5 +1,2 @@
 [console_scripts]
 pymscada = pymscada.__main__:cmd_line
-
-[gui_scripts]
-

pymscada-0.2.0rc1.dist-info/top_level.txt

@@ -0,0 +1 @@
+pymscada