[RPSDK-1347] Improve eRPC python implementation

Signed-off-by: Michal Princ <michal.princ@nxp.com>

Author: JanKomarekNXP

CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+### Fixed
+- Python code of the eRPC infrastructure was updated to match the proper python code style, add type annotations and improve readability.
+
 ## [1.14.0]
 
 ### Added

erpc_python/erpc/__init__.py

@@ -1,12 +1,11 @@
 #!/usr/bin/env python
 
-# Copyright 2016 NXP
-# All rights reserved.
+# Copyright 2016-2025 NXP
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
 import os
-import typing
+from typing import Any
 # Yocto and python27 combination
 if "IS_YOCTO" in os.environ:
     from . import erpc_version
@@ -20,12 +19,11 @@
     from . import simple_server
     from . import transport
 
-
 class Reference(object):
     """ Simple container class used for pass by reference.
     """
 
-    def __init__(self, value: typing.Any = None):
+    def __init__(self, value: Any = None):
         # Read/write attribute holding the referent.
         self.value = value
 

erpc_python/erpc/arbitrator.py

@@ -1,52 +1,59 @@
 #!/usr/bin/env python
 
-# Copyright 2016 NXP
+# Copyright 2016-2025 NXP
 # All rights reserved.
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
 import threading
+import dataclasses
+from typing import Optional, TYPE_CHECKING
 
-from .codec import MessageType
+from .codec import MessageType, Codec
 from .transport import Transport
-from .client import RequestContext
+from .client import RequestError
 
+if TYPE_CHECKING:
+    from .client import RequestContext
 
+
+@dataclasses.dataclass
 class ClientInfo:
-    event = None
-    msg = None
+    event: threading.Event
+    message: Optional[bytearray] = None
 
 
 class TransportArbitrator(Transport):
-    """ Shares a transport between a server and multiple clients.
+    """ Shares transport between a server and multiple clients.
 
     Args:
         Transport (_type_): Inherit and define transport interface methods
     """
 
-    def __init__(self, sharedTransport=None, codec=None):
+    def __init__(self, sharedTransport: Optional[Transport] = None, codec: Optional[Codec] = None):
+        super().__init__()
         self._transport = sharedTransport
         self._codec = codec
-        self._pending_clients = {}
+        self._pending_clients: dict[int, ClientInfo] = {}
         self._lock = threading.Lock()
 
     @property
-    def shared_transport(self):
+    def shared_transport(self) -> Optional[Transport]:
         return self._transport
 
     @shared_transport.setter
-    def shared_transport(self, transport):
+    def shared_transport(self, transport: Transport):
         self._transport = transport
 
     @property
-    def codec(self):
+    def codec(self) -> Optional[Codec]:
         return self._codec
 
     @codec.setter
-    def codec(self, theCodec):
+    def codec(self, theCodec: Codec):
         self._codec = theCodec
 
-    def send(self, message):
+    def send(self, message: bytes):
         assert self._transport is not None, "No shared transport was set"
         self._transport.send(message)
 
@@ -77,13 +84,13 @@ def receive(self):
                     client = self._pending_clients[info.sequence]
                 finally:
                     self._lock.release()
-                client.msg = msg
+                client.message = msg
                 client.event.set()
             except KeyError:
                 # No client was found, unexpected sequence number!
                 pass
 
-    def prepare_client_receive(self, requestContext: RequestContext):
+    def prepare_client_receive(self, requestContext: "RequestContext"):
         """ Add a client request to the client list.
 
         This call is made by the client thread prior to sending the invocation to the server. It
@@ -98,10 +105,9 @@ def prepare_client_receive(self, requestContext: RequestContext):
         """
 
         # Create pending client info.
-        info = ClientInfo()
-        info.event = threading.Event()
+        info = ClientInfo(threading.Event())
 
-        # Add this client to the pending clients dict.
+        # Add this client to the pending clients' dict.
         try:
             self._lock.acquire()
             self._pending_clients[requestContext.sequence] = info
@@ -110,10 +116,10 @@ def prepare_client_receive(self, requestContext: RequestContext):
 
         return requestContext.sequence
 
-    def client_receive(self, token: int):
+    def client_receive(self, token: int) -> bytearray:
         """ Receive method for the client.
 
-        Blocks until the a reply message is received with the expected sequence number that is
+        Blocks until the reply message is received with the expected sequence number that is
         associated with @a token. The client must have called prepare_client_receive() previously.
 
         Args:
@@ -133,14 +139,15 @@ def client_receive(self, token: int):
             # Wait for the reply to be received.
             client.event.wait()
 
-            # Remove this client from the pending clients dict.
+            # Remove this client from the pending clients' dict.
             try:
                 self._lock.acquire()
                 del self._pending_clients[token]
             finally:
                 self._lock.release()
 
             # Return the received message.
-            return client.msg
+            assert client.message # Message should be available at this moment
+            return client.message
         except KeyError:
-            pass
+            raise RequestError(f"Pending client with token '{token}' not found")

erpc_python/erpc/basic_codec.py

@@ -1,13 +1,14 @@
 #!/usr/bin/env python
 
 # Copyright (c) 2015 Freescale Semiconductor, Inc.
-# Copyright 2016-2017 NXP
-# All rights reserved.
+# Copyright 2016-2025 NXP
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
 import struct
-from .codec import (MessageType, MessageInfo, Codec, CodecError)
+from typing import Any
+
+from .codec import MessageType, MessageInfo, Codec, CodecError
 
 
 class BasicCodec(Codec):
@@ -19,68 +20,68 @@ class BasicCodec(Codec):
 
     BASIC_CODEC_VERSION = 1
 
-    def start_write_message(self, msgInfo):
+    def start_write_message(self, msgInfo: MessageInfo):
         header = (self.BASIC_CODEC_VERSION << 24) \
-            | ((msgInfo.service & 0xff) << 16) \
-            | ((msgInfo.request & 0xff) << 8) \
-            | (msgInfo.type.value & 0xff)
+                 | ((msgInfo.service & 0xff) << 16) \
+                 | ((msgInfo.request & 0xff) << 8) \
+                 | (msgInfo.type.value & 0xff)
         self.write_uint32(header)
         self.write_uint32(msgInfo.sequence)
 
-    def _write(self, fmt, value):
+    def _write(self, fmt: str, value: Any):
         self._buffer += struct.pack(fmt, value)
         self._cursor += struct.calcsize(fmt)
 
-    def write_bool(self, value):
+    def write_bool(self, value: bool):
         self._write('<?', value)
 
-    def write_int8(self, value):
+    def write_int8(self, value: int):
         self._write('<b', value)
 
-    def write_int16(self, value):
+    def write_int16(self, value: int):
         self._write('<h', value)
 
-    def write_int32(self, value):
+    def write_int32(self, value: int):
         self._write('<i', value)
 
-    def write_int64(self, value):
+    def write_int64(self, value: int):
         self._write('<q', value)
 
-    def write_uint8(self, value):
+    def write_uint8(self, value: int):
         self._write('<B', value)
 
-    def write_uint16(self, value):
+    def write_uint16(self, value: int):
         self._write('<H', value)
 
-    def write_uint32(self, value):
+    def write_uint32(self, value: int):
         self._write('<I', value)
 
-    def write_uint64(self, value):
+    def write_uint64(self, value: int):
         self._write('<Q', value)
 
-    def write_float(self, value):
+    def write_float(self, value: float):
         self._write('<f', value)
 
-    def write_double(self, value):
+    def write_double(self, value: float):
         self._write('<d', value)
 
-    def write_string(self, value):
+    def write_string(self, value: str):
         self.write_binary(value.encode())
 
-    def write_binary(self, value):
+    def write_binary(self, value: bytes):
         self.write_uint32(len(value))
         self._buffer += value
 
-    def start_write_list(self, length):
+    def start_write_list(self, length: int):
         self.write_uint32(length)
 
-    def start_write_union(self, discriminator):
+    def start_write_union(self, discriminator: int):
         self.write_uint32(discriminator)
 
-    def write_null_flag(self, flag):
+    def write_null_flag(self, flag: int):
         self.write_uint8(1 if flag else 0)
 
-    def start_read_message(self):
+    def start_read_message(self) -> MessageInfo:
         """ Returns 4-tuple of msgType, service, request, sequence.
 
         Raises:
@@ -96,71 +97,71 @@ def start_read_message(self):
             raise CodecError("unsupported codec version %d" % version)
         service = (header >> 16) & 0xff
         request = (header >> 8) & 0xff
-        msgType = MessageType(header & 0xff)
-        return MessageInfo(type=msgType, service=service, request=request, sequence=sequence)
+        msg_type = MessageType(header & 0xff)
+        return MessageInfo(type=msg_type, service=service, request=request, sequence=sequence)
 
-    def _read(self, fmt):
+    def _read(self, fmt: str):
         result = struct.unpack_from(fmt, self._buffer, self._cursor)
         self._cursor += struct.calcsize(fmt)
         return result[0]
 
-    def read_bool(self):
+    def read_bool(self) -> bool:
         return self._read('<?')
 
-    def read_int8(self):
+    def read_int8(self) -> int:
         return self._read('<b')
 
-    def read_int16(self):
+    def read_int16(self) -> int:
         return self._read('<h')
 
-    def read_int32(self):
+    def read_int32(self) -> int:
         return self._read('<i')
 
-    def read_int64(self):
+    def read_int64(self) -> int:
         return self._read('<q')
 
-    def read_uint8(self):
+    def read_uint8(self) -> int:
         return self._read('<B')
 
-    def read_uint16(self):
+    def read_uint16(self) -> int:
         return self._read('<H')
 
-    def read_uint32(self):
+    def read_uint32(self) -> int:
         return self._read('<I')
 
-    def read_uint64(self):
+    def read_uint64(self) -> int:
         return self._read('<Q')
 
-    def read_float(self):
+    def read_float(self) -> float:
         return self._read('<f')
 
-    def read_double(self):
+    def read_double(self) -> float:
         return self._read('<d')
 
-    def read_string(self):
+    def read_string(self) -> str:
         return self.read_binary().decode()
 
-    def read_binary(self):
+    def read_binary(self) -> bytearray:
         length = self.read_uint32()
-        data = self._buffer[self._cursor:self._cursor+length]
+        data = self._buffer[self._cursor:self._cursor + length]
         self._cursor += length
         return data
 
-    def start_read_list(self):
+    def start_read_list(self) -> int:
         """ Function which should be called on list de-serialization.
 
         Returns:
             int: Int of list length.
         """
         return self.read_uint32()
 
-    def start_read_union(self):
+    def start_read_union(self) -> int:
         """ Function which should be called on union de-serialization.
 
         Returns:
             int: Int of union discriminator.
         """
         return self.read_int32()
 
-    def read_null_flag(self):
+    def read_null_flag(self) -> int:
         return self.read_uint8()