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

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/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/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/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/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/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/demo/tags.yaml

@@ -109,157 +109,11 @@ FloatSelect:
     labels: [Floats, For, This, Tag]
     values: [0.1, 0.1, 0.2, 0.3]
     locks: [0, 1, 0, 0]
-cpu_temp:
-  desc: CPU Load
-  type: float
-  min: 0
-  max: 100
-  units: '°C'
-  dp: 1
-cpu_load:
-  desc: Float Value
-  type: float
-  min: 0
-  max: 100
-  units: '%'
-  dp: 1
-disk_use:
-  desc: Float Value
-  type: float
-  min: 0
-  max: 100
-  units: '%'
-  dp: 1
-sim_IntSet:  # for the demo PLC sim_ tags not required
-  desc: Simulation tag
-  type: int
-sim_IntVal:
-  desc: Simulation tag
-  type: int
-sim_FloatSet:
-  desc: Simulation tag
-  type: float
-sim_FloatVal:
-  desc: Simulation tag
-  type: float
-sim_MultiSet:
-  desc: Simulation tag
-  type: int
-sim_MultiVal:
-  desc: Simulation tag
-  type: int
-sim_TimeSet:
-  desc: Simulation tag
-  type: int
-sim_TimeVal:
-  desc: Simulation tag
-  type: int
-sim_DateSet:
-  desc: Simulation tag
-  type: int
-sim_DateVal:
-  desc: Simulation tag
-  type: int
-sim_DateTimeSet:
-  desc: Simulation tag
-  type: int
-sim_DateTimeVal:
-  desc: Simulation tag
-  type: int
-Ani_Fin_20:
-  desc: 'Logix Fin[20]'
-  type: float
-  dp: 2
-Ani_Fout_20:
-  desc: 'Logix Fout[20]'
-  type: float
-  dp: 2
-Ani_Iin_20:
-  desc: 'Logix Iin[20]'
-  type: int
-Ani_Iout_20:
-  desc: 'Logix Iout[20]'
-  type: int
-Ani_Iout_21_0:
-  desc: 'Logix Iout[21].0'
-  multi:
-  - 'Off'
-  - 'On'
-Ani_Iout_21_1:
-  desc: 'Logix Iout[21].1'
-  multi:
-  - 'Off'
-  - 'On'
-Ani_Iin_21_0:
-  desc: 'Logix Iin[21].0'
-  multi:
-  - 'Off'
-  - 'On'
-Ani_Iin_21_1:
-  desc: 'Logix Iin[21].1'
-  multi:
-  - 'Off'
-  - 'On'
-InVar:
-  desc: InVar
-  type: float
-OutVar:
-  desc: OutVar
-  type: float
-Router_eth1_bytes_in:
-  desc: eth1 bytes in
-  type: int
-Router_eth1_bytes_out:
-  desc: eth1 bytes out
-  type: int
-Router_eth2_bytes_in:
-  desc: eth2 bytes in
-  type: int
-Router_eth2_bytes_out:
-  desc: eth2 bytes out
-  type: int
-Router_eth3_bytes_in:
-  desc: eth3 bytes in
-  type: int
-Router_eth3_bytes_out:
-  desc: eth3 bytes out
-  type: int
-Router_eth4_bytes_in:
-  desc: eth4 bytes in
-  type: int
-Router_eth4_bytes_out:
-  desc: eth4 bytes out
-  type: int
-Router_eth5_bytes_in:
-  desc: eth5 bytes in
-  type: int
-Router_eth5_bytes_out:
-  desc: eth5 bytes out
-  type: int
-Router_eth6_bytes_in:
-  desc: eth6 bytes in
-  type: int
-Router_eth6_bytes_out:
-  desc: eth6 bytes out
-  type: int
-Router_eth7_bytes_in:
-  desc: eth7 bytes in
-  type: int
-Router_eth7_bytes_out:
-  desc: eth7 bytes out
-  type: int
-Router_eth8_bytes_in:
-  desc: eth8 bytes in
-  type: int
-Router_eth8_bytes_out:
-  desc: eth8 bytes out
-  type: int
 localhost_ping:
   desc: Ping time to localhost
+  type: int
   units: ms
 google_ping:
   desc: Ping time to google
-  units: ms
-electronet_ping:
-  desc: Ping time to electronet
+  type: int
   units: ms