pyxcp 0.21.9__cp39-cp39-win_amd64.whl → 0.22.23__cp39-cp39-win_amd64.whl

pyxcp/transport/eth.py

@@ -1,66 +1,78 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
 import selectors
 import socket
 import struct
 import threading
 from collections import deque
-from time import perf_counter
-from time import sleep
-from time import time
+from typing import Optional
 
 from pyxcp.transport.base import BaseTransport
-from pyxcp.utils import SHORT_SLEEP
+from pyxcp.utils import short_sleep
+
 
 DEFAULT_XCP_PORT = 5555
 RECV_SIZE = 8196
 
 
+def socket_to_str(sock: socket.socket) -> str:
+    peer = sock.getpeername()
+    local = sock.getsockname()
+    AF = {
+        socket.AF_INET: "AF_INET",
+        socket.AF_INET6: "AF_INET6",
+    }
+    TYPE = {
+        socket.SOCK_DGRAM: "SOCK_DGRAM",
+        socket.SOCK_STREAM: "SOCK_STREAM",
+    }
+    family = AF.get(sock.family, "OTHER")
+    typ = TYPE.get(sock.type, "UNKNOWN")
+    res = f"XCPonEth - Connected to: {peer[0]}:{peer[1]}  local address: {local[0]}:{local[1]} [{family}][{typ}]"
+    return res
+
+
 class Eth(BaseTransport):
     """"""
 
-    PARAMETER_MAP = {
-        #                  Type    Req'd   Default
-        "HOST": (str, False, "localhost"),
-        "PORT": (int, False, 5555),
-        "BIND_TO_ADDRESS": (str, False, ""),
-        "BIND_TO_PORT": (int, False, 5555),
-        "PROTOCOL": (str, False, "TCP"),
-        "IPV6": (bool, False, False),
-        "TCP_NODELAY": (bool, False, False),
-    }
-
     MAX_DATAGRAM_SIZE = 512
     HEADER = struct.Struct("<HH")
     HEADER_SIZE = HEADER.size
 
-    def __init__(self, config=None, policy=None):
-        super(Eth, self).__init__(config, policy)
-        self.loadConfig(config)
-        self.host = self.config.get("HOST")
-        self.port = self.config.get("PORT")
-        self.protocol = self.config.get("PROTOCOL")
-        self.ipv6 = self.config.get("IPV6")
-        self.use_tcp_no_delay = self.config.get("TCP_NODELAY")
-        address_to_bind = self.config.get("BIND_TO_ADDRESS")
-        port_to_bind = self.config.get("BIND_TO_PORT")
-        self._local_address = (address_to_bind, port_to_bind) if address_to_bind else None
+    def __init__(self, config=None, policy=None, transport_layer_interface: Optional[socket.socket] = None) -> None:
+        super().__init__(config, policy, transport_layer_interface)
+        self.load_config(config)
+        self.host: str = self.config.host
+        self.port: int = self.config.port
+        self.protocol: int = self.config.protocol
+        self.ipv6: bool = self.config.ipv6
+        self.use_tcp_no_delay: bool = self.config.tcp_nodelay
+        address_to_bind: str = self.config.bind_to_address
+        bind_to_port: int = self.config.bind_to_port
+        self._local_address = (address_to_bind, bind_to_port) if address_to_bind else None
         if self.ipv6 and not socket.has_ipv6:
-            raise RuntimeError("IPv6 not supported by your platform.")
+            msg = "XCPonEth - IPv6 not supported by your platform."
+            self.logger.critical(msg)
+            raise RuntimeError(msg)
         else:
             address_family = socket.AF_INET6 if self.ipv6 else socket.AF_INET
         proto = socket.SOCK_STREAM if self.protocol == "TCP" else socket.SOCK_DGRAM
         if self.host.lower() == "localhost":
             self.host = "::1" if self.ipv6 else "localhost"
-        addrinfo = socket.getaddrinfo(self.host, self.port, address_family, proto)
-        (
-            self.address_family,
-            self.socktype,
-            self.proto,
-            self.canonname,
-            self.sockaddr,
-        ) = addrinfo[0]
-        self.status = 0
+
+        try:
+            addrinfo = socket.getaddrinfo(self.host, self.port, address_family, proto)
+            (
+                self.address_family,
+                self.socktype,
+                self.proto,
+                self.canonname,
+                self.sockaddr,
+            ) = addrinfo[0]
+        except BaseException as ex:  # noqa: B036
+            msg = f"XCPonEth - Failed to resolve address {self.host}:{self.port}"
+            self.logger.critical(msg)
+            raise Exception(msg) from ex
+        self.status: int = 0
         self.sock = socket.socket(self.address_family, self.socktype, self.proto)
         self.selector = selectors.DefaultSelector()
         self.selector.register(self.sock, selectors.EVENT_READ)
@@ -74,8 +86,10 @@ class Eth(BaseTransport):
         if self._local_address:
             try:
                 self.sock.bind(self._local_address)
-            except BaseException as ex:
-                raise Exception(f"Failed to bind socket to given address {self._local_address}") from ex
+            except BaseException as ex:  # noqa: B036
+                msg = f"XCPonEth - Failed to bind socket to given address {self._local_address}"
+                self.logger.critical(msg)
+                raise Exception(msg) from ex
         self._packet_listener = threading.Thread(
             target=self._packet_listen,
             args=(),
@@ -83,43 +97,40 @@ class Eth(BaseTransport):
         )
         self._packets = deque()
 
-    def connect(self):
+    def connect(self) -> None:
         if self.status == 0:
             self.sock.connect(self.sockaddr)
-            self.startListener()
+            self.logger.info(socket_to_str(self.sock))
+            self.start_listener()
             self.status = 1  # connected
 
-    def startListener(self):
-        super().startListener()
+    def start_listener(self) -> None:
+        super().start_listener()
         if self._packet_listener.is_alive():
             self._packet_listener.join()
         self._packet_listener = threading.Thread(target=self._packet_listen)
         self._packet_listener.start()
 
-    def close(self):
+    def close(self) -> None:
         """Close the transport-layer connection and event-loop."""
-        self.finishListener()
+        self.finish_listener()
         if self.listener.is_alive():
             self.listener.join()
         if self._packet_listener.is_alive():
             self._packet_listener.join()
-        self.closeConnection()
+        self.close_connection()
 
-    def _packet_listen(self):
-        use_tcp = self.use_tcp
+    def _packet_listen(self) -> None:
+        use_tcp: bool = self.use_tcp
         EVENT_READ = selectors.EVENT_READ
-
         close_event_set = self.closeEvent.is_set
         socket_fileno = self.sock.fileno
         select = self.selector.select
-
         _packets = self._packets
-
         if use_tcp:
             sock_recv = self.sock.recv
         else:
             sock_recv = self.sock.recvfrom
-
         while True:
             try:
                 if close_event_set() or socket_fileno() == -1:
@@ -127,8 +138,7 @@ class Eth(BaseTransport):
                 sel = select(0.02)
                 for _, events in sel:
                     if events & EVENT_READ:
-                        recv_timestamp = time()
-
+                        recv_timestamp = self.timestamp.value
                         if use_tcp:
                             response = sock_recv(RECV_SIZE)
                             if not response:
@@ -145,41 +155,33 @@ class Eth(BaseTransport):
                                 break
                             else:
                                 _packets.append((response, recv_timestamp))
-            except BaseException:
+            except BaseException:  # noqa: B036
                 self.status = 0  # disconnected
                 break
 
-    def listen(self):
+    def listen(self) -> None:
         HEADER_UNPACK_FROM = self.HEADER.unpack_from
         HEADER_SIZE = self.HEADER_SIZE
-        processResponse = self.processResponse
+        process_response = self.process_response
         popleft = self._packets.popleft
-
         close_event_set = self.closeEvent.is_set
         socket_fileno = self.sock.fileno
-
         _packets = self._packets
-        length, counter = None, None
-
-        data = bytearray(b"")
-
+        length: Optional[int] = None
+        counter: int = 0
+        data: bytearray = bytearray(b"")
         while True:
             if close_event_set() or socket_fileno() == -1:
                 return
-
-            count = len(_packets)
-
+            count: int = len(_packets)
             if not count:
-                sleep(SHORT_SLEEP)
+                short_sleep()
                 continue
-
             for _ in range(count):
                 bts, timestamp = popleft()
-
                 data += bts
-                current_size = len(data)
-                current_position = 0
-
+                current_size: int = len(data)
+                current_position: int = 0
                 while True:
                     if length is None:
                         if current_size >= HEADER_SIZE:
@@ -192,24 +194,20 @@ class Eth(BaseTransport):
                     else:
                         if current_size >= length:
                             response = data[current_position : current_position + length]
-                            processResponse(response, length, counter, timestamp)
-
+                            process_response(response, length, counter, timestamp)
                             current_size -= length
                             current_position += length
-
                             length = None
-
                         else:
-
                             data = data[current_position:]
                             break
 
-    def send(self, frame):
-        self.pre_send_timestamp = time()
+    def send(self, frame) -> None:
+        self.pre_send_timestamp = self.timestamp.value
         self.sock.send(frame)
-        self.post_send_timestamp = time()
+        self.post_send_timestamp = self.timestamp.value
 
-    def closeConnection(self):
+    def close_connection(self) -> None:
         if not self.invalidSocket:
             # Seems to be problematic /w IPv6
             # if self.status == 1:
@@ -217,5 +215,5 @@ class Eth(BaseTransport):
             self.sock.close()
 
     @property
-    def invalidSocket(self):
+    def invalidSocket(self) -> bool:
         return not hasattr(self, "sock") or self.sock.fileno() == -1

pyxcp/transport/sxi.py

@@ -1,8 +1,7 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 import struct
-from time import perf_counter
-from time import time
+from collections import deque
+from dataclasses import dataclass
+from typing import Optional
 
 import serial
 
@@ -10,78 +9,125 @@ import pyxcp.types as types
 from pyxcp.transport.base import BaseTransport
 
 
+@dataclass
+class HeaderValues:
+    length: int = 0
+    counter: int = 0
+    filler: int = 0
+
+
+RECV_SIZE = 16384
+
+
 class SxI(BaseTransport):
     """"""
 
-    PARAMETER_MAP = {
-        #                        Type    Req'd   Default
-        "PORT": (str, False, "COM1"),
-        "BITRATE": (int, False, 38400),
-        "BYTESIZE": (int, False, 8),
-        "PARITY": (str, False, "N"),
-        "STOPBITS": (int, False, 1),
-    }
-
-    MAX_DATAGRAM_SIZE = 512
-    TIMEOUT = 0.75
-    HEADER = struct.Struct("<HH")
-    HEADER_SIZE = HEADER.size
-
-    def __init__(self, config=None, policy=None):
-        super(SxI, self).__init__(config, policy)
-        self.loadConfig(config)
-        self.portName = self.config.get("PORT")
-        self.baudrate = self.config.get("BITRATE")
-
-    def __del__(self):
-        self.closeConnection()
-
-    def connect(self):
-
-        self.logger.debug("Trying to open serial commPort {}.".format(self.portName))
-        try:
-            self.commPort = serial.Serial(self.portName, self.baudrate, timeout=SxI.TIMEOUT)
-        except serial.SerialException as e:
-            self.logger.error("{}".format(e))
-            raise
-        self.logger.info("Serial commPort openend as '{}' @ {} Bits/Sec.".format(self.commPort.portstr, self.baudrate))
-        self.startListener()
-
-    def output(self, enable):
+    def __init__(self, config=None, policy=None, transport_layer_interface: Optional[serial.Serial] = None) -> None:
+        super().__init__(config, policy, transport_layer_interface)
+        self.load_config(config)
+        self.port_name = self.config.port
+        self.baudrate = self.config.bitrate
+        self.bytesize = self.config.bytesize
+        self.parity = self.config.parity
+        self.stopbits = self.config.stopbits
+        self.mode = self.config.mode
+        self.header_format = self.config.header_format
+        self.tail_format = self.config.tail_format
+        self.framing = self.config.framing
+        self.esc_sync = self.config.esc_sync
+        self.esc_esc = self.config.esc_esc
+        self.make_header()
+        self.comm_port: serial.Serial
+
+        if self.has_user_supplied_interface and transport_layer_interface:
+            self.comm_port = transport_layer_interface
+        else:
+            self.logger.info(f"XCPonSxI - trying to open serial comm_port {self.port_name}.")
+            try:
+                self.comm_port = serial.Serial(
+                    port=self.port_name,
+                    baudrate=self.baudrate,
+                    bytesize=self.bytesize,
+                    parity=self.parity,
+                    stopbits=self.stopbits,
+                    timeout=self.timeout,
+                    write_timeout=self.timeout,
+                )
+            except serial.SerialException as e:
+                self.logger.critical(f"XCPonSxI - {e}")
+                raise
+        self._packets = deque()
+
+    def __del__(self) -> None:
+        self.close_connection()
+
+    def make_header(self) -> None:
+        def unpack_len(args):
+            (length,) = args
+            return HeaderValues(length=length)
+
+        def unpack_len_counter(args):
+            length, counter = args
+            return HeaderValues(length=length, counter=counter)
+
+        def unpack_len_filler(args):
+            length, filler = args
+            return HeaderValues(length=length, filler=filler)
+
+        HEADER_FORMATS = {
+            "HEADER_LEN_BYTE": ("B", unpack_len),
+            "HEADER_LEN_CTR_BYTE": ("BB", unpack_len_counter),
+            "HEADER_LEN_FILL_BYTE": ("BB", unpack_len_filler),
+            "HEADER_LEN_WORD": ("H", unpack_len),
+            "HEADER_LEN_CTR_WORD": ("HH", unpack_len_counter),
+            "HEADER_LEN_FILL_WORD": ("HH", unpack_len_filler),
+        }
+        fmt, unpacker = HEADER_FORMATS[self.header_format]
+        self.HEADER = struct.Struct(f"<{fmt}")
+        self.HEADER_SIZE = self.HEADER.size
+        self.unpacker = unpacker
+
+    def connect(self) -> None:
+        self.logger.info(f"XCPonSxI - serial comm_port openend: {self.comm_port.portstr}@{self.baudrate} Bits/Sec.")
+        self.start_listener()
+
+    def output(self, enable) -> None:
         if enable:
-            self.commPort.rts = False
-            self.commPort.dtr = False
+            self.comm_port.rts = False
+            self.comm_port.dtr = False
         else:
-            self.commPort.rts = True
-            self.commPort.dtr = True
+            self.comm_port.rts = True
+            self.comm_port.dtr = True
 
-    def flush(self):
-        self.commPort.flush()
+    def flush(self) -> None:
+        self.comm_port.flush()
 
-    def listen(self):
+    def start_listener(self) -> None:
+        super().start_listener()
 
+    def listen(self) -> None:
         while True:
-            if self.closeEvent.isSet():
+            if self.closeEvent.is_set():
                 return
-            if not self.commPort.inWaiting():
+            if not self.comm_port.in_waiting:
                 continue
 
-            recv_timestamp = time()
-            length, counter = self.HEADER.unpack(self.commPort.read(self.HEADER_SIZE))
+            recv_timestamp = self.timestamp.value
+            header_values = self.unpacker(self.HEADER.unpack(self.comm_port.read(self.HEADER_SIZE)))
+            length, counter, _ = header_values.length, header_values.counter, header_values.filler
 
-            response = self.commPort.read(length)
+            response = self.comm_port.read(length)
             self.timing.stop()
 
             if len(response) != length:
                 raise types.FrameSizeError("Size mismatch.")
+            self.process_response(response, length, counter, recv_timestamp)
 
-            self.processResponse(response, length, counter, recv_timestamp)
-
-    def send(self, frame):
-        self.pre_send_timestamp = time()
-        self.commPort.write(frame)
-        self.post_send_timestamp = time()
+    def send(self, frame) -> None:
+        self.pre_send_timestamp = self.timestamp.value
+        self.comm_port.write(frame)
+        self.post_send_timestamp = self.timestamp.value
 
-    def closeConnection(self):
-        if hasattr(self, "commPort") and self.commPort.isOpen():
-            self.commPort.close()
+    def close_connection(self) -> None:
+        if hasattr(self, "comm_port") and self.comm_port.is_open and not self.has_user_supplied_interface:
+            self.comm_port.close()