pymscada 0.1.11__tar.gz → 0.1.11b3__tar.gz

{pymscada-0.1.11 → pymscada-0.1.11b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pymscada
-Version: 0.1.11
+Version: 0.1.11b3
 Summary: Shared tag value SCADA with python backup and Angular UI
 Author-Email: Jamie Walton <jamie@walton.net.nz>
 License: GPL-3.0-or-later
@@ -11,11 +11,11 @@ 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
+Project-URL: Bug Tracker, https://github.com/jamie0walton/pymscada/issues
 Requires-Python: >=3.9
 Requires-Dist: PyYAML>=6.0.1
 Requires-Dist: aiohttp>=3.8.5
-Requires-Dist: pymscada-html>=0.1.2
+Requires-Dist: pymscada-html>=0.1.10b2
 Requires-Dist: cerberus>=1.3.5
 Requires-Dist: pycomm3>=1.2.14
 Requires-Dist: pysnmplib>=5.0.24

{pymscada-0.1.11 → pymscada-0.1.11b3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pymscada"
-version = "0.1.11"
+version = "0.1.11b3"
 description = "Shared tag value SCADA with python backup and Angular UI"
 authors = [
     { name = "Jamie Walton", email = "jamie@walton.net.nz" },
@@ -8,7 +8,7 @@ authors = [
 dependencies = [
     "PyYAML>=6.0.1",
     "aiohttp>=3.8.5",
-    "pymscada-html>=0.1.2",
+    "pymscada-html>=0.1.10b2",
     "cerberus>=1.3.5",
     "pycomm3>=1.2.14",
     "pysnmplib>=5.0.24",
@@ -54,3 +54,6 @@ pdm = []
 omit = [
     "tests/*",
 ]
+
+[tool.pytest.ini_options]
+addopts = "-v -s"

{pymscada-0.1.11 → pymscada-0.1.11b3}/src/pymscada/bus_client.py

@@ -42,26 +42,26 @@ class BusClient:
             self.to_publish[tag.name] = tag
             return
         if tag.type is float:
-            data = struct.pack('!Bd', pc.TYPE_FLOAT, tag.value)
+            data = struct.pack('!Bd', pc.TYPE.FLOAT, tag.value)
         elif tag.type is int:
-            data = struct.pack('!Bq', pc.TYPE_INT, tag.value)
+            data = struct.pack('!Bq', pc.TYPE.INT, tag.value)
         elif tag.type is bytes:
             size = len(tag.value)
             try:
-                data = struct.pack(f'!B{size}s', pc.TYPE_BYTES, tag.value)
+                data = struct.pack(f'!B{size}s', pc.TYPE.BYTES, tag.value)
             except struct.error as e:
                 logging.error(f'bus_client {tag.name} {e}')
         elif tag.type is str:
             size = len(tag.value)
-            data = struct.pack(f'!B{size}s', pc.TYPE_STR, tag.value.encode())
+            data = struct.pack(f'!B{size}s', pc.TYPE.STR, tag.value.encode())
         elif tag.type in [list, dict]:
             jsonstr = json.dumps(tag.value).encode()
             size = len(jsonstr)
-            data = struct.pack(f'!B{size}s', pc.TYPE_JSON, jsonstr)
+            data = struct.pack(f'!B{size}s', pc.TYPE.JSON, jsonstr)
         else:
             logging.warning(f'publish {tag.name} unhandled {tag.type}')
             return
-        self.write(pc.CMD_SET, tag.id, tag.time_us, data)
+        self.write(pc.COMMAND.SET, tag.id, tag.time_us, data)
 
     def add_callback_rta(self, tagname, handler):
         """Collect callback handlers."""
@@ -75,10 +75,10 @@ class BusClient:
         time_us = int(time.time() * 1e6)
         jsonstr = json.dumps(request).encode()
         size = len(jsonstr)
-        data = struct.pack(f'>B{size}s', pc.TYPE_JSON, jsonstr)
-        self.write(pc.CMD_RTA, self.tag_by_name[tagname].id, time_us, data)
+        data = struct.pack(f'>B{size}s', pc.TYPE.JSON, jsonstr)
+        self.write(pc.COMMAND.RTA, self.tag_by_name[tagname].id, time_us, data)
 
-    def write(self, command: pc.COMMANDS, tag_id: int, time_us: int,
+    def write(self, command: pc.COMMAND, tag_id: int, time_us: int,
               data: bytes):
         """Write a message."""
         if data is None:
@@ -101,14 +101,14 @@ class BusClient:
         self.tag_by_name[tag.name] = tag
         if tag.value is not None:
             self.to_publish[tag.name] = tag
-        self.write(pc.CMD_ID, 0, 0, tag.name.encode())
+        self.write(pc.COMMAND.ID, 0, 0, tag.name.encode())
 
     async def open_connection(self):
         """Establish connection and callbacks."""
         self.reader, self.writer = await asyncio.open_connection(
             self.ip, self.port)
         self.addr = self.writer.get_extra_info('sockname')
-        self.write(pc.CMD_LOG, 0, 0, f'{self.module} connected'.encode())
+        self.write(pc.COMMAND.LOG, 0, 0, f'{self.module} connected'.encode())
         logging.warning(f'connected {self.addr} {self.port}')
         for tag in Tag.get_all_tags().values():
             self.add_tag(tag)
@@ -157,14 +157,15 @@ class BusClient:
 
     def process(self, cmd, tag_id, time_us, value):
         """Process bus message, updating the local tag value."""
-        if cmd == pc.CMD_ERR:
-            logging.warning(f'Bus server error {tag_id} {value}')
+        if cmd == pc.COMMAND.ERR:
+            logging.warning(f'Bus server error {tag_id} '
+                            f'{pc.COMMAND.text(cmd)} {value}')
             return
-        if cmd == pc.CMD_ID:
+        if cmd == pc.COMMAND.ID:
             tag = self.tag_by_name[value.decode()]
             tag.id = tag_id
             self.tag_by_id[tag_id] = tag
-            self.write(pc.CMD_SUB, tag.id, 0, b'')
+            self.write(pc.COMMAND.SUB, tag.id, 0, b'')
             if tag.name in self.tag_by_name:
                 self.tag_by_id[tag.id] = tag
             if tag.name in self.to_publish:
@@ -172,7 +173,7 @@ class BusClient:
                 del self.to_publish[tag.name]
             return
         tag = self.tag_by_id[tag_id]
-        if cmd == pc.CMD_SET:
+        if cmd == pc.COMMAND.SET:
             if value is None:
                 try:
                     if self.tag_info is None:
@@ -186,17 +187,17 @@ class BusClient:
                     pass
                 return
             data_type = struct.unpack_from('!B', value, offset=0)[0]
-            if data_type == pc.TYPE_FLOAT:
+            if data_type == pc.TYPE.FLOAT:
                 data = struct.unpack_from('!d', value, offset=1)[0]
-            elif data_type == pc.TYPE_INT:
+            elif data_type == pc.TYPE.INT:
                 data = struct.unpack_from('!q', value, offset=1)[0]
-            elif data_type == pc.TYPE_BYTES:
+            elif data_type == pc.TYPE.BYTES:
                 data = struct.unpack_from(f'!{len(value) - 1}s', value,
                                           offset=1)[0]
-            elif data_type == pc.TYPE_STR:
+            elif data_type == pc.TYPE.STR:
                 data = struct.unpack_from(f'!{len(value) - 1}s', value,
                                           offset=1)[0].decode()
-            elif data_type == pc.TYPE_JSON:
+            elif data_type == pc.TYPE.JSON:
                 data = json.loads(struct.unpack_from(f'!{len(value) - 1}s',
                                                      value, offset=1
                                                      )[0].decode())
@@ -204,7 +205,7 @@ class BusClient:
                 logging.warning(f'process error {tag.name} {tag.type} {value}')
                 return
             tag.value = data, time_us, id(self)
-        elif cmd == pc.CMD_RTA:
+        elif cmd == pc.COMMAND.RTA:
             data = struct.unpack_from(f'!{len(value) - 1}s', value, offset=1
                                       )[0].decode()
             data = json.loads(data)

{pymscada-0.1.11 → pymscada-0.1.11b3}/src/pymscada/bus_server.py

@@ -85,12 +85,12 @@ class BusConnection():
         del self.addr
         del self.pending
 
-    def write(self, command: pc.COMMANDS, tag_id: int, time_us: int,
+    def write(self, command: pc.COMMAND, tag_id: int, time_us: int,
               data: bytes):
         """Write a message."""
         if data is None:
             data = b''
-        logging.info(f'write {pc.CMD_TEXT[command]} {tag_id}')
+        logging.info(f'write {command.text} {tag_id}')
         for i in range(0, len(data) + 1, pc.MAX_LEN):
             snip = data[i:i+pc.MAX_LEN]
             size = len(snip)
@@ -168,78 +168,78 @@ class BusServer:
         if tag.from_bus == bus_id:
             return
         try:
-            self.connections[bus_id].write(pc.CMD_SET, tag.id, tag.time_us,
+            self.connections[bus_id].write(pc.COMMAND.SET, tag.id, tag.time_us,
                                            tag.value)
         except KeyError:
             tag.del_callback(self.publish, bus_id)
 
-    def process(self, bus_id, cmd, tag_id, time_us, data):
+    def process(self, bus_id, cmd: int, tag_id, time_us, data):
         """Process bus message, updating the local tag value."""
-        logging.info(f'write {pc.CMD_TEXT[cmd]} {tag_id} '
+        logging.info(f'write {pc.COMMAND.text(cmd)} {tag_id} '
                      f'{"None" if data is None else data[:20]}')
-        if cmd == pc.CMD_SET:
+        if cmd == pc.COMMAND.SET:
             try:
                 tag = BusTags._tag_by_id[tag_id]
                 tag.update(data, time_us, bus_id)
             except KeyError:
                 self.connections[bus_id].write(
-                    pc.CMD_ERR, tag_id, time_us,
+                    pc.COMMAND.ERR, tag_id, time_us,
                     f"SET KeyError {tag_id}".encode())
-        elif cmd == pc.CMD_RTA:
+        elif cmd == pc.COMMAND.RTA:
             try:
                 tag = BusTags._tag_by_id[tag_id]
             except KeyError:
                 self.connections[bus_id].write(
-                    pc.CMD_ERR, tag_id, time_us,
+                    pc.COMMAND.ERR, tag_id, time_us,
                     f"RTA KeyError {tag_id}".encode())
             try:
                 self.connections[tag.from_bus].write(
-                    pc.CMD_RTA, tag_id, tag.time_us, data)
+                    pc.COMMAND.RTA, tag_id, tag.time_us, data)
             except KeyError:
                 logging.warning(f'likely busclient for {tag.name} is gone')
             except Exception as e:
                 self.connections[bus_id].write(
-                    pc.CMD_ERR, tag_id, time_us,
+                    pc.COMMAND.ERR, tag_id, time_us,
                     f"RTA {tag_id} {e}".encode())
             """Reply comes from another BusClient, not the Server."""
-        elif cmd == pc.CMD_SUB:
+        elif cmd == pc.COMMAND.SUB:
             try:
                 tag = BusTags._tag_by_id[tag_id]
             except KeyError:
                 self.connections[bus_id].write(
-                    pc.CMD_ERR, tag_id, time_us,
+                    pc.COMMAND.ERR, tag_id, time_us,
                     f"SUBscribe KeyError {tag_id}".encode())
-            self.connections[bus_id].write(pc.CMD_SET, tag_id, tag.time_us,
+            self.connections[bus_id].write(pc.COMMAND.SET, tag_id, tag.time_us,
                                            tag.value)
             tag.add_callback(self.publish, bus_id)
-        elif cmd == pc.CMD_ID:
+        elif cmd == pc.COMMAND.ID:
             try:
                 tag = BusTags._tag_by_name[data]
             except KeyError:
                 self.connections[bus_id].write(
-                    pc.CMD_ERR, tag_id, time_us,
+                    pc.COMMAND.ERR, tag_id, time_us,
                     f"ID {data} undefined".encode())
                 tag = BusTag(data)
-            self.connections[bus_id].write(pc.CMD_ID, tag.id, tag.time_us,
+            self.connections[bus_id].write(pc.COMMAND.ID, tag.id, tag.time_us,
                                            tag.name)
-        elif cmd == pc.CMD_GET:
+        elif cmd == pc.COMMAND.GET:
             try:
                 tag = BusTags._tag_by_id[tag_id]
             except KeyError:
                 self.connections[bus_id].write(
-                    pc.CMD_ERR, tag_id, time_us,
+                    pc.COMMAND.ERR, tag_id, time_us,
                     f"GET KeyError for {tag_id}".encode())
-            self.connections[bus_id].write(pc.CMD_SET, tag.id, tag.time_us,
+            self.connections[bus_id].write(pc.COMMAND.SET, tag.id, tag.time_us,
                                            tag.value)
-        elif cmd == pc.CMD_UNSUB:
+        elif cmd == pc.COMMAND.UNSUB:
             try:
                 tag = BusTags._tag_by_id[tag_id]
             except KeyError:
                 self.connections[bus_id].write(
-                    pc.CMD_ERR, tag_id, time_us,
+                    pc.COMMAND.ERR, tag_id, time_us,
                     f"UNSubscribe KeyError for {tag_id}".encode())
             tag.del_callback(self.publish, bus_id)
-        elif cmd == pc.CMD_LIST:
+        elif cmd == pc.COMMAND.LIST:
             tagname_list = []
             if len(data) == 0:
                 for _, tag in BusTags._tag_by_id.items():
@@ -260,8 +260,8 @@ class BusServer:
                     if data in tag.name:
                         tagname_list.append(tag.name)
             self.connections[bus_id].write(
-                pc.CMD_LIST, 0, time_us, b' '.join(tagname_list))
-        elif cmd == pc.CMD_LOG:
+                pc.COMMAND.LIST, 0, time_us, b' '.join(tagname_list))
+        elif cmd == pc.COMMAND.LOG:
             if len(data) > 300:
                 logging.warning(f'process: log message too long from {bus_id}')
             else:
@@ -273,6 +273,9 @@ class BusServer:
         """Process read messages, delete broken connections."""
         bus_id, cmd, tag_id, time_us, data = command
         if cmd is None:
+            # Clean up tag subscriptions before deleting it
+            for tag in BusTags._tag_by_id.values():
+                tag.del_callback(self.publish, bus_id)
             self.connections[bus_id].delete()
             del self.connections[bus_id]
             return

{pymscada-0.1.11 → pymscada-0.1.11b3}/src/pymscada/checkout.py

@@ -57,21 +57,17 @@ def make_config(overwrite: bool):
             else:
                 continue
         print(f'{rt} {target}')
-        if str(target).endswith('service'):
-            rd_bytes = config_file.read_bytes()
-            for k, v in PATH.items():
-                rd_bytes = rd_bytes.replace(k.encode(),str(v).encode())
-            target.write_bytes(rd_bytes)
-        else:
-            target.write_bytes(config_file.read_bytes())
+        rd_bytes = config_file.read_bytes()
+        for k, v in PATH.items():
+            rd_bytes = rd_bytes.replace(k.encode(), str(v).encode())
+        target.write_bytes(rd_bytes)
 
 
 def read_with_subst(file: Path):
     """Read the file and replace DIR markers."""
     rd = file.read_bytes().decode()
-    if str(file).endswith('service'):
-        for k, v in PATH.items():
-            rd = rd.replace(k, str(v))
+    for k, v in PATH.items():
+        rd = rd.replace(k, str(v))
     lines = rd.splitlines()
     return lines
 

{pymscada-0.1.11 → pymscada-0.1.11b3}/src/pymscada/console.py

@@ -13,7 +13,6 @@ except ModuleNotFoundError:
 
 class EC:
     """Escape codes."""
-
     backspace = b'\x7f'
     enter = b'\r'
     tab = b'\t'
@@ -59,17 +58,14 @@ class KeypressProtocol(asyncio.Protocol):
     def data_received(self, data):
         """Got keypress, update edit line, send to writer."""
         if len(data) == 1:
-            if data == EC.backspace:
+            if data == EC.backspace and self.cursor > 0:
                 self.line = self.line[:self.cursor-1] + self.line[self.cursor:]
-                if self.cursor > 0:
-                    self.cursor -= 1
+                self.cursor -= 1
             elif data == EC.enter:
-                self.stash = None
-                if self.lines:
-                    if self.line != self.lines[-1]:
-                        self.lines.append(self.line)
-                else:
+                if self.line and (not self.lines or
+                                  self.line != self.lines[-1]):
                     self.lines.append(self.line)
+                self.stash = None
                 self.edit_line(None, 0)
                 self.process_command(self.line)
                 self.line = None
@@ -129,11 +125,12 @@ class ConsoleWriter:
 
     def write(self, data: bytes):
         """Stream writer, primarily for logging."""
+        cursor_str = b''
+        if self.edit is not None and self.cursor > 0:
+            cursor_str = b'\x1b[' + str(self.cursor).encode() + b'C'
         ln = EC.cr_clr + data + b'\r\n'
         if self.edit is not None:
-            ln += EC.cr_clr + self.edit + EC.mv_left
-            if self.cursor > 0:
-                ln += b'\x1b[' + str(self.cursor).encode() + b'C'
+            ln += EC.cr_clr + self.edit + EC.mv_left + cursor_str
         sys.stdout.buffer.write(ln)
         sys.stdout.flush()
 
@@ -173,8 +170,8 @@ class Console:
         # all to add '\r\n' to the logging output
         logger = logging.getLogger()
         handler = CustomHandler()
-        handler.setFormatter(logging.Formatter(
-            '%(levelname)s:%(name)s:%(message)s'))
+        handler.setFormatter(logging.Formatter('%(levelname)s:console: '
+                                               '%(message)s'))
         logger.handlers.clear()
         logger.addHandler(handler)
         self.busclient = BusClient(bus_ip, bus_port, module='Console')

pymscada-0.1.11b3/src/pymscada/demo/openweather.yaml

@@ -0,0 +1,25 @@
+bus_ip: 127.0.0.1
+bus_port: 1325
+proxy:
+api:
+  api_key: ${OPENWEATHER_API_KEY}
+  units: metric
+  locations:
+    Murupara:
+      lat: -38.45747036367239
+      lon: 176.70484322806843
+  times: [3]
+  parameters:
+  - Temp
+  - WindSpeed
+  - WindDir
+  - Rain
+tags:
+  - Murupara_Temp
+  - Murupara_WindSpeed
+  - Murupara_WindDir
+  - Murupara_Rain
+  - Murupara_Temp_03
+  - Murupara_WindSpeed_03
+  - Murupara_WindDir_03
+  - Murupara_Rain_03

{pymscada-0.1.11 → pymscada-0.1.11b3}/src/pymscada/demo/ping.yaml

@@ -4,9 +4,6 @@ tags:
   localhost_ping:
     type: ping
     addr: '127.0.0.1'
-  electronet_ping:
-    type: ping
-    addr: electronet.co.nz
   google_ping:
     type: ping
     addr: www.google.com

pymscada-0.1.11b3/src/pymscada/demo/tags.yaml

@@ -0,0 +1,119 @@
+__bus__:
+  desc: Bus Server Info
+  type: str
+__files__:
+  desc: File Server
+  type: dict
+__history__:
+  desc: History
+  type: bytes
+__opnotes__:
+  desc: Operator Notes
+  type: dict
+__alarms__:
+  desc: Alarms
+  type: dict
+IntSet:
+  desc: Integer Setpoint
+  type: int
+  min: -100
+  max: 100
+  init: 1
+IntVal:
+  desc: Integer Value
+  type: int
+  min: -100
+  max: 100
+  init: 1
+FloatSet:
+  desc: Float Setpoint
+  type: float
+  min: -1.e+100
+  max: 1.e+100
+  units: 'm'
+  dp: 1
+  init: 2
+FloatVal:
+  desc: Float Value
+  type: float
+  min: -1.e+100
+  max: 1.e+100
+  units: 'm'
+  dp: 1
+  init: 2
+MultiSet:
+  desc: Multi Setpoint
+  multi:
+   - zero
+   - one
+   - two
+   - three
+  init: 0
+MultiVal:
+  desc: Multi Value
+  multi:
+   - zero
+   - one
+   - two
+   - three
+  init: 0
+StringSet:
+  desc: String Setpoint
+  type: str
+  init: a string
+StringVal:
+  desc: String Value
+  type: str
+  init: a string
+TimeSet:
+  desc: Time Setpoint
+  type: int
+  init: 1234567890
+  format: time
+TimeVal:
+  desc: Time Value
+  type: int
+  init: 1234567890
+  format: time
+DateSet:
+  desc: Date Setpoint
+  type: int
+  init: 1234567890
+  format: date
+DateVal:
+  desc: Date Value
+  type: int
+  init: 1234567890
+  format: date
+DateTimeSet:
+  desc: Date Time Setpoint
+  type: int
+  init: 1234567890
+  format: datetime
+DateTimeVal:
+  desc: Date Time Value
+  type: int
+  init: 1234567890
+  format: datetime
+MultiSelect:
+  desc: Select Dict Multi
+  type: dict
+  init:
+    labels: [A, B, C, D, E, F, G, H]
+    values: [0, 1, 2, 3, 3, 4, 4, 3]
+    locks: [1, 0, 0, 0, 0, 0, 0, 1]
+FloatSelect:
+  desc: Select Dict Float
+  type: dict
+  init:
+    labels: [Floats, For, This, Tag]
+    values: [0.1, 0.1, 0.2, 0.3]
+    locks: [0, 1, 0, 0]
+localhost_ping:
+  desc: Ping time to localhost
+  type: int
+  units: ms
+google_ping:
+  desc: Ping time to google
+  type: int
+  units: ms

pymscada-0.1.11b3/src/pymscada/demo/wwwserver.yaml

@@ -0,0 +1,81 @@
+bus_ip: 127.0.0.1
+bus_port: 1324
+ip: 0.0.0.0
+port: 8324
+get_path:
+serve_path: __HOME__
+pages:
+- name: Notes
+  parent:
+  items:
+  - type: opnotes
+    site: [Site 1, Site 2]
+    by: [B1, B2]
+- name: Default Main
+  parent:
+  items:
+  - {desc: Default tags, type: h1}
+  - {tagname: IntSet, type: setpoint}
+  - {tagname: IntVal, type: value}
+  - {tagname: FloatSet, type: setpoint}
+  - {tagname: FloatVal, type: value}
+  - {tagname: MultiSet, type: setpoint}
+  - {tagname: MultiVal, type: value}
+  - {tagname: StringSet, type: setpoint}
+  - {tagname: StringVal, type: value}
+  - {tagname: TimeSet, type: setpoint}
+  - {tagname: TimeVal, type: value}
+  - {tagname: DateSet, type: setpoint}
+  - {tagname: DateVal, type: value}
+  - {tagname: DateTimeSet, type: setpoint}
+  - {tagname: DateTimeVal, type: value}
+  - type: selectdict
+    tagname: MultiSelect
+    opts:
+      type: multi
+      multi:
+      - Zero
+      - One
+      - Two
+      - Three
+      - Four
+      - Five
+  - {tagname: FloatSelect, type: selectdict, opts: {type: float, dp: 2}}
+- name: Files
+  parent:
+  items:
+  - type: files
+- name: Ping Values
+  parent:
+  items:
+  - {desc: Default tags, type: h1}
+  - {tagname: localhost_ping, type: value}
+  - {tagname: google_ping, type: value}
+  - {tagname: electronet_ping, type: value}
+- name: Ping Trend
+  parent:
+  items:
+  - type: uplot  # Do all times in seconds, which uplot uses.
+    ms:
+      desc: Ping Trend
+      age: 172800
+      legend_pos: left
+      time_pos: left
+      time_res: m
+    axes:
+    - scale: x
+      range: [-86400, 0]  # 86400 172800 1209600
+    - scale: mS
+      range: [0.0, 1.0]
+      dp: 1
+    series:
+    - tagname: localhost_ping
+      label: localhost
+      scale: mS
+      color: black
+      dp: 1
+    - tagname: google_ping
+      label: google
+      scale: mS
+      color: red
+      dp: 1