eliminates implicit Optional

pymodbus/client/base.py

@@ -4,7 +4,7 @@
 import asyncio
 import socket
 from dataclasses import dataclass
-from typing import Any, Callable
+from typing import Any, Callable, cast
 
 from pymodbus.client.mixin import ModbusClientMixin
 from pymodbus.exceptions import ConnectionException, ModbusIOException
@@ -22,7 +22,7 @@ class ModbusBaseClient(ModbusClientMixin, ModbusProtocol):
 
     **Parameters common to all clients**:
 
-    :param framer: (optional) Modbus Framer class.
+    :param framer: Modbus Framer class.
     :param timeout: (optional) Timeout for a request, in seconds.
     :param retries: (optional) Max number of retries per request.
     :param retry_on_empty: (optional) Retry on empty response.
@@ -53,20 +53,20 @@ class ModbusBaseClient(ModbusClientMixin, ModbusProtocol):
     class _params:
         """Parameter class."""
 
-        retries: int = None
-        retry_on_empty: bool = None
-        close_comm_on_error: bool = None
-        strict: bool = None
-        broadcast_enable: bool = None
-        reconnect_delay: int = None
+        retries: int | None = None
+        retry_on_empty: bool | None = None
+        close_comm_on_error: bool | None = None
+        strict: bool | None = None
+        broadcast_enable: bool | None = None
+        reconnect_delay: int | None = None
 
-        source_address: tuple[str, int] = None
+        source_address: tuple[str, int] | None = None
 
-        server_hostname: str = None
+        server_hostname: str | None = None
 
     def __init__(  # pylint: disable=too-many-arguments
         self,
-        framer: type[ModbusFramer] = None,
+        framer: type[ModbusFramer],
         timeout: float = 3,
         retries: int = 3,
         retry_on_empty: bool = False,
@@ -122,10 +122,10 @@ def __init__(  # pylint: disable=too-many-arguments
         self.transaction = DictTransactionManager(
             self, retries=retries, retry_on_empty=retry_on_empty, **kwargs
         )
-        self.reconnect_delay_current = self.params.reconnect_delay
+        self.reconnect_delay_current = cast(float, self.params.reconnect_delay)
         self.use_udp = False
         self.state = ModbusTransactionState.IDLE
-        self.last_frame_end: float = 0
+        self.last_frame_end: float | None = 0
         self.silent_interval: float = 0
 
     # ----------------------------------------------------------------------- #
@@ -164,7 +164,7 @@ def idle_time(self) -> float:
             return 0
         return self.last_frame_end + self.silent_interval
 
-    def execute(self, request: ModbusRequest = None) -> ModbusResponse:
+    def execute(self, request: ModbusRequest | None = None) -> ModbusResponse:
         """Execute request and get response (call **sync/async**).
 
         :param request: The request to process
@@ -210,15 +210,15 @@ async def async_execute(self, request=None):
 
         return resp
 
-    def callback_data(self, data: bytes, addr: tuple = None) -> int:
+    def callback_data(self, data: bytes, addr: tuple | None = None) -> int:
         """Handle received data
 
         returns number of bytes consumed
         """
         self.framer.processIncomingPacket(data, self._handle_response, slave=0)
         return len(data)
 
-    def callback_disconnected(self, _reason: Exception) -> None:
+    def callback_disconnected(self, _reason: Exception | None) -> None:
         """Handle lost connection"""
         for tid in list(self.transaction):
             self.raise_future(

pymodbus/client/mixin.py

@@ -502,7 +502,7 @@ def read_fifo_queue(self, address: int = 0x0000, **kwargs: Any) -> ModbusRespons
     # code 0x2B sub 0x0D: CANopen General Reference Request and Response, NOT IMPLEMENTED
 
     def read_device_information(
-        self, read_code: int = None, object_id: int = 0x00, **kwargs: Any
+        self, read_code: Union[int, None] = None, object_id: int = 0x00, **kwargs: Any
     ) -> ModbusResponse:
         """Read FIFO queue (code 0x2B sub 0x0E).
 

pymodbus/client/serial.py

@@ -141,6 +141,7 @@ def __init__(
 
         self.last_frame_end = None
 
+        assert isinstance(self.comm_params.baudrate, int)
         self._t0 = float(1 + bytesize + stopbits) / self.comm_params.baudrate
 
         # Check every 4 bytes / 2 registers if the reading is ready

pymodbus/client/tcp.py

@@ -3,7 +3,7 @@
 import select
 import socket
 import time
-from typing import Any, Tuple, Type
+from typing import Any, Optional, Tuple, Type
 
 from pymodbus.client.base import ModbusBaseClient
 from pymodbus.exceptions import ConnectionException
@@ -40,7 +40,7 @@ def __init__(
         host: str,
         port: int = 502,
         framer: Type[ModbusFramer] = ModbusSocketFramer,
-        source_address: Tuple[str, int] = None,
+        source_address: Optional[Tuple[str, int]] = None,
         **kwargs: Any,
     ) -> None:
         """Initialize Asyncio Modbus TCP Client."""
@@ -102,7 +102,7 @@ def __init__(
         host: str,
         port: int = 502,
         framer: Type[ModbusFramer] = ModbusSocketFramer,
-        source_address: Tuple[str, int] = None,
+        source_address: Optional[Tuple[str, int]] = None,
         **kwargs: Any,
     ) -> None:
         """Initialize Modbus TCP Client."""

pymodbus/client/tls.py

@@ -1,7 +1,7 @@
 """Modbus client async TLS communication."""
 import socket
 import ssl
-from typing import Any, Type
+from typing import Any, Optional, Type
 
 from pymodbus.client.tcp import AsyncModbusTcpClient, ModbusTcpClient
 from pymodbus.framer import ModbusFramer
@@ -44,11 +44,11 @@ def __init__(
         host: str,
         port: int = 802,
         framer: Type[ModbusFramer] = ModbusTlsFramer,
-        sslctx: ssl.SSLContext = None,
-        certfile: str = None,
-        keyfile: str = None,
-        password: str = None,
-        server_hostname: str = None,
+        sslctx: Optional[ssl.SSLContext] = None,
+        certfile: Optional[str] = None,
+        keyfile: Optional[str] = None,
+        password: Optional[str] = None,
+        server_hostname: Optional[str] = None,
         **kwargs: Any,
     ):
         """Initialize Asyncio Modbus TLS Client."""
@@ -113,11 +113,11 @@ def __init__(
         host: str,
         port: int = 802,
         framer: Type[ModbusFramer] = ModbusTlsFramer,
-        sslctx: ssl.SSLContext = None,
-        certfile: str = None,
-        keyfile: str = None,
-        password: str = None,
-        server_hostname: str = None,
+        sslctx: Optional[ssl.SSLContext] = None,
+        certfile: Optional[str] = None,
+        keyfile: Optional[str] = None,
+        password: Optional[str] = None,
+        server_hostname: Optional[str] = None,
         **kwargs: Any,
     ):
         """Initialize Modbus TLS Client."""

pymodbus/client/udp.py

@@ -1,7 +1,7 @@
 """Modbus client async UDP communication."""
 import asyncio
 import socket
-from typing import Any, Tuple, Type
+from typing import Any, Optional, Tuple, Type
 
 from pymodbus.client.base import ModbusBaseClient
 from pymodbus.exceptions import ConnectionException
@@ -45,7 +45,7 @@ def __init__(
         host: str,
         port: int = 502,
         framer: Type[ModbusFramer] = ModbusSocketFramer,
-        source_address: Tuple[str, int] = None,
+        source_address: Optional[Tuple[str, int]] = None,
         **kwargs: Any,
     ) -> None:
         """Initialize Asyncio Modbus UDP Client."""
@@ -106,7 +106,7 @@ def __init__(
         host: str,
         port: int = 502,
         framer: Type[ModbusFramer] = ModbusSocketFramer,
-        source_address: Tuple[str, int] = None,
+        source_address: Optional[Tuple[str, int]] = None,
         **kwargs: Any,
     ) -> None:
         """Initialize Modbus UDP Client."""

pymodbus/datastore/simulator.py

@@ -3,7 +3,7 @@
 import random
 import struct
 from datetime import datetime
-from typing import Any, Callable, Dict, List
+from typing import Any, Callable, Dict, List, Optional
 
 
 WORD_SIZE = 16
@@ -30,7 +30,7 @@ class Cell:
     access: bool = False
     value: int = 0
     action: int = 0
-    action_kwargs: Dict[str, Any] = None
+    action_kwargs: Optional[Dict[str, Any]] = None
     count_read: int = 0
     count_write: int = 0
 

pymodbus/logging.py

@@ -17,7 +17,7 @@
 
 
 def pymodbus_apply_logging_config(
-    level: Union[str, int] = logging.DEBUG, log_file_name: str = None
+    level: Union[str, int] = logging.DEBUG, log_file_name: Union[str, None] = None
 ):
     """Apply basic logging configuration used by default by Pymodbus maintainers.
 

pymodbus/repl/client/helper.py

@@ -229,7 +229,7 @@ def get_commands(client):
 class Result:
     """Represent result command."""
 
-    function_code: int = None
+    function_code: Union[int, None] = None
     data: Union[Dict[int, Any], Any] = None
 
     def __init__(self, result):

pymodbus/server/async_io.py

@@ -5,7 +5,7 @@
 import time
 import traceback
 from contextlib import suppress
-from typing import Union
+from typing import Optional, Union
 
 from pymodbus.datastore import ModbusServerContext
 from pymodbus.device import ModbusControlBlock, ModbusDeviceIdentification
@@ -84,7 +84,7 @@ def callback_connected(self) -> None:
                 traceback.format_exc(),
             )
 
-    def callback_disconnected(self, call_exc: Exception) -> None:
+    def callback_disconnected(self, call_exc: Optional[Exception]) -> None:
         """Call when connection is lost."""
         try:
             if self.handler_task:
@@ -239,7 +239,7 @@ async def _recv_(self):  # pragma: no cover
             result = None
         return result
 
-    def callback_data(self, data: bytes, addr: tuple = None) -> int:
+    def callback_data(self, data: bytes, addr: Union[tuple, None] = None) -> int:
         """Handle received data."""
         if addr:
             self.receive_queue.put_nowait((data, addr))
@@ -563,7 +563,9 @@ class _serverList:
     :meta private:
     """
 
-    active_server: Union[ModbusTcpServer, ModbusUdpServer, ModbusSerialServer] = None
+    active_server: Union[
+        ModbusTcpServer, ModbusUdpServer, ModbusSerialServer, None
+    ] = None
 
     def __init__(self, server):
         """Register new server."""

pymodbus/server/reactive/main.py

@@ -97,10 +97,10 @@ class ReactiveModbusSlaveContext(ModbusSlaveContext):
 
     def __init__(
         self,
-        discrete_inputs: BaseModbusDataBlock = None,
-        coils: BaseModbusDataBlock = None,
-        input_registers: BaseModbusDataBlock = None,
-        holding_registers: BaseModbusDataBlock = None,
+        discrete_inputs: BaseModbusDataBlock | None = None,
+        coils: BaseModbusDataBlock | None = None,
+        input_registers: BaseModbusDataBlock | None = None,
+        holding_registers: BaseModbusDataBlock | None = None,
         zero_mode: bool = False,
         randomize: int = 0,
         change_rate: int = 0,

pymodbus/server/simulator/http_server.py

@@ -5,13 +5,13 @@
 import json
 import os
 from time import time
-from typing import List
+from typing import Any, List, Optional, cast
 
 
 try:
     from aiohttp import web
 except ImportError:
-    web = None
+    web = cast(Any, None)
 
 import contextlib
 
@@ -124,7 +124,7 @@ def __init__(
         http_port: int = 8080,
         log_file: str = "server.log",
         json_file: str = "setup.json",
-        custom_actions_module: str = None,
+        custom_actions_module: Optional[str] = None,
     ):
         """Initialize http interface."""
         if not web:
@@ -157,7 +157,7 @@ def __init__(
             del server["port"]
         device = setup["device_list"][modbus_device]
         self.datastore_context = ModbusSimulatorContext(
-            device, custom_actions_dict or None
+            device, custom_actions_dict or {}
         )
         datastore = ModbusServerContext(slaves=self.datastore_context, single=True)
         comm = comm_class[server.pop("comm")]