Refactor / improve python modbus

code-generation/language-python/src/main/java/org/apache/plc4x/language/python/PythonLanguageTemplateHelper.java

@@ -803,8 +803,8 @@ private String toBinaryTermExpression(Field field, TypeReference fieldType, Bina
                 // Except for doing a nil or not-nil check :-(
                 // So in case of such a check, we need to suppress the pointer-access.
                 boolean suppressPointerAccessOverride = (operation.equals("==") || operation.equals("!=")) && ((a instanceof NullLiteral) || (b instanceof NullLiteral));
-                String aExpression = toExpression(field, null, a, parserArguments, serializerArguments, serialize, suppressPointerAccessOverride);
-                String bExpression = toExpression(field, null, b, parserArguments, serializerArguments, serialize, suppressPointerAccessOverride);
+                String aExpression = toExpression(field, null, a, parserArguments, serializerArguments, serialize, true);
+                String bExpression = toExpression(field, null, b, parserArguments, serializerArguments, serialize, true);
                 return tracer + "bool((" + aExpression + ") " + operation + " (" + bExpression + "))";
             case ">>":
             case "<<":
@@ -813,21 +813,21 @@ private String toBinaryTermExpression(Field field, TypeReference fieldType, Bina
                 tracer = tracer.dive("bitwise");
                 // We don't want casts here
                 return tracer +
-                    toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, false) +
+                    toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, true) +
                     operation + " " +
-                    toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, false);
+                    toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, true);
             default:
                 tracer = tracer.dive("default");
                 if (fieldType instanceof StringTypeReference) {
                     tracer = tracer.dive("string type reference");
-                    return tracer + toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, false) +
+                    return tracer + toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, true) +
                         operation + " " +
-                        toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, false);
+                        toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, true);
                 }
                 return tracer +
-                    toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, false) +
+                    toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, true) +
                     operation + " " +
-                    toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, false);
+                    toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, true);
         }
     }
 
@@ -1281,7 +1281,7 @@ private String toCastVariableExpression(Field field, TypeReference typeReference
 
     private String toOptionalVariableExpression(Field field, TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean suppressPointerAccess, Tracer tracer) {
         tracer = tracer.dive("optional fields");
-        return tracer + "(" + (suppressPointerAccess || (typeReference != null && typeReference.isComplexTypeReference()) ? "" : "*") + variableLiteral.getName() + ")" +
+        return tracer + (suppressPointerAccess || (typeReference != null && typeReference.isComplexTypeReference()) ? "" : "*") + camelCaseToSnakeCase(variableLiteral.getName()) +
             variableLiteral.getChild().map(child -> "." + camelCaseToSnakeCase(toVariableExpression(field, typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess, true))).orElse("");
     }
 

plc4py/plc4py/PlcDriverManager.py

@@ -35,24 +35,47 @@ class PlcDriverManager:
     _driver_map: Dict[str, Type[PlcDriver]] = field(default_factory=lambda: {})
 
     def __post_init__(self):
+        """
+        Initialize the PLC Driver Manager.
+
+        This function is called automatically when a new instance of the
+        PlcDriverManager class is created.
+
+        It registers the available drivers, by loading the entry points
+        defined in the "plc4py.drivers" namespace.
+        """
+        # Log the class loader used
         logging.info(
             f"Instantiating new PLC Driver Manager with class loader {self.class_loader}"
         )
+
+        # Add the PlcDriverClassLoader hookspecs to the class loader
         self.class_loader.add_hookspecs(PlcDriverClassLoader)
+
+        # Log the registration of drivers
         logging.info("Registering available drivers...")
 
+        # Register the plc4py.drivers package
         import plc4py.drivers
 
         self.class_loader.register(plc4py.drivers)
+
+        # Load the setuptools entry points defined in the "plc4py.drivers" namespace
         self.class_loader.load_setuptools_entrypoints("plc4py.drivers")
+
+        # Create a dictionary mapping the hook names to the PlcDriver instances
         self._driver_map = {
             key: loader
             for key, loader in zip(
                 self.class_loader.hook.key(), self.class_loader.hook.get_driver()
             )
         }
+
+        # Log the successful registration of each driver
         for driver in self._driver_map:
             logging.info(f"... {driver} .. OK")
+
+        # Check for any pending plugins
         self.class_loader.check_pending()
 
     @asynccontextmanager
@@ -95,9 +118,13 @@ def get_driver(self, protocol_code: str) -> Type[PlcDriver]:
 
     def get_driver_for_url(self, url: str) -> Type[PlcDriver]:
         """
-        Returns the driver class that matches that identified within the connection string
+        Returns the driver class that matches the one identified within the connection string.
+
         :param url: The plc connection string
-        :return: the protocol code
+        :return: The driver class that matches the protocol code identified within the connection string
         """
+        # Extract the protocol code from the connection string
         protocol_code = get_protocol_code(url)
+
+        # Retrieve the driver class using the protocol code
         return self._driver_map[protocol_code]

plc4py/plc4py/drivers/modbus/ModbusConfiguration.py

@@ -25,13 +25,17 @@ class ModbusConfiguration(PlcConfiguration):
     """
 
     def __init__(self, url):
-        super().__init__(url)
-
-        if self.transport is None:
-            self.transport = "tcp"
+        """
+        Initializes the ModbusConfiguration with the given URL.
 
-        if self.port is None:
-            self.port = 502
+        Args:
+            url (str): The URL of the Modbus device.
+        """
+        super().__init__(url)
 
-        if "unit_identifier" not in self.parameters:
-            self.unit_identifier = 1
+        # Set the transport to TCP if not specified
+        self.transport = self.transport or "tcp"
+        # Set the port to 502 if not specified
+        self.port = self.port or 502
+        # Get the unit identifier from the parameters, default to 1
+        self.unit_identifier = self.parameters.get("unit_identifier", 1)

plc4py/plc4py/drivers/modbus/ModbusConnection.py

@@ -16,208 +16,22 @@
 # specific language governing permissions and limitations
 # under the License.
 #
-import asyncio
-import logging
-from typing import Type, Awaitable
+from plc4py.spi.configuration.PlcConfiguration import PlcConfiguration
 
-import plc4py
-from plc4py.api.PlcConnection import PlcConnection, PlcConnectionMetaData
-from plc4py.api.PlcDriver import PlcDriver
-from plc4py.api.authentication.PlcAuthentication import PlcAuthentication
-from plc4py.api.messages.PlcResponse import (
-    PlcResponse,
-    PlcReadResponse,
-    PlcWriteResponse,
-    PlcTagResponse,
-)
-from plc4py.api.messages.PlcRequest import (
-    ReadRequestBuilder,
-    PlcRequest,
-    PlcReadRequest,
-    PlcWriteRequest,
-)
-from plc4py.api.value.PlcValue import PlcResponseCode
-from plc4py.drivers.PlcDriverLoader import PlcDriverLoader
-from plc4py.drivers.modbus.ModbusConfiguration import ModbusConfiguration
-from plc4py.drivers.modbus.ModbusDevice import ModbusDevice
-from plc4py.drivers.modbus.ModbusProtocol import ModbusProtocol
-from plc4py.drivers.modbus.ModbusTag import ModbusTagBuilder
-from plc4py.spi.messages.PlcReader import PlcReader
-from plc4py.spi.messages.PlcRequest import DefaultReadRequestBuilder
-from plc4py.spi.messages.PlcWriter import PlcWriter
-from plc4py.spi.transport.Plc4xBaseTransport import Plc4xBaseTransport
-from plc4py.spi.transport.TCPTransport import TCPTransport
 
-
-class ModbusConnection(PlcConnection, PlcReader, PlcWriter, PlcConnectionMetaData):
+class ModbusConfiguration(PlcConfiguration):
     """
-    Modbus TCP PLC connection implementation
+    Specific Modbus Configuration
     """
 
-    def __init__(self, config: ModbusConfiguration, transport: Plc4xBaseTransport):
-        super().__init__(config)
-        self._configuration: ModbusConfiguration
-        self._device: ModbusDevice = ModbusDevice(self._configuration)
-        self._transport: Plc4xBaseTransport = transport
-
-    @staticmethod
-    async def create(url: str):
-        """
-        Static Factory to return an instance of a ModbusConnection.
-        It creates the TCP connection to the Modbus device before returning.
-
-        :param url: PLC4X connection string of the Modbus TCP connection
-        :return ModbusConnection instance using the configuration from the url provided
-        """
-        config = ModbusConfiguration(url)
-        loop = asyncio.get_running_loop()
-        connection_future = loop.create_future()
-        transport = await asyncio.wait_for(
-            TCPTransport.create(
-                protocol_factory=lambda: ModbusProtocol(connection_future),
-                host=config.host,
-                port=config.port,
-            ),
-            10,
-        )
-        return ModbusConnection(config, transport)
-
-    def is_connected(self) -> bool:
-        """
-        Indicates if the connection is established to a remote PLC.
-        :return: True if connection, False otherwise
-        """
-        if self._transport is not None:
-            return not self._transport.is_closing()
-        else:
-            return False
-
-    def close(self) -> None:
-        """
-        Closes the connection to the remote PLC.
-        :return:
-        """
-        if self._transport is not None:
-            self._transport.close()
-
-    def read_request_builder(self) -> ReadRequestBuilder:
-        """
-        :return: read request builder.
-        """
-        return DefaultReadRequestBuilder(ModbusTagBuilder)
-
-    async def execute(self, request: PlcRequest) -> PlcResponse:
-        """
-        Executes a PlcRequest as long as it's already connected
-        :param request: Plc Request to execute
-        :return: The response from the Plc/Device
-        """
-        if not self.is_connected():
-            return self._default_failed_request(PlcResponseCode.NOT_CONNECTED)
-
-        if isinstance(request, PlcReadRequest):
-            return await self._read(request)
-        elif isinstance(request, PlcWriteRequest):
-            return await self._write(request)
-
-        return self._default_failed_request(PlcResponseCode.NOT_CONNECTED)
-
-    def _check_connection(self) -> bool:
-        return self._device is None
-
-    async def _read(self, request: PlcReadRequest) -> PlcReadResponse:
-        """
-        Executes a PlcReadRequest
-        """
-        if self._check_connection():
-            logging.error("No device is set in the modbus connection!")
-            return self._default_failed_request(PlcResponseCode.NOT_CONNECTED)
-        try:
-            logging.debug("Sending read request to Modbus Device")
-            response = await asyncio.wait_for(
-                self._device.read(request, self._transport), 5
-            )
-            return response
-        except Exception:
-            # TODO:- This exception is very general and probably should be replaced
-            return PlcReadResponse(PlcResponseCode.INTERNAL_ERROR, {})
-
-    async def _write(self, request: PlcWriteRequest) -> PlcTagResponse:
-        """
-        Executes a PlcWriteRequest
-        """
-        if self._check_connection():
-            logging.error("No device is set in the modbus connection!")
-            return self._default_failed_request(PlcResponseCode.NOT_CONNECTED)
+    def __init__(self, url):
+        super().__init__(url)
 
-        try:
-            logging.debug("Sending write request to Modbus Device")
-            response = await asyncio.wait_for(
-                self._device.write(request, self._transport), 5
-            )
-            return response
-        except Exception:
-            # TODO:- This exception is very general and probably should be replaced
-            return PlcWriteResponse(PlcResponseCode.INTERNAL_ERROR, {})
-
-    def is_read_supported(self) -> bool:
-        """
-        Indicates if the connection supports read requests.
-        :return: True if connection supports reading, False otherwise
-        """
-        return True
-
-    def is_write_supported(self) -> bool:
-        """
-        Indicates if the connection supports write requests.
-        :return: True if connection supports writing, False otherwise
-        """
-        return False
-
-    def is_subscribe_supported(self) -> bool:
-        """
-        Indicates if the connection supports subscription requests.
-        :return: True if connection supports subscriptions, False otherwise
-        """
-        return False
-
-    def is_browse_supported(self) -> bool:
-        """
-        Indicates if the connection supports browsing requests.
-        :return: True if connection supports browsing, False otherwise
-        """
-        return False
-
-
-class ModbusDriver(PlcDriver):
-    def __init__(self):
-        super().__init__()
-        self.protocol_code = "modbus-tcp"
-        self.protocol_name = "Modbus TCP"
-
-    async def get_connection(
-        self, url: str, authentication: PlcAuthentication = PlcAuthentication()
-    ) -> PlcConnection:
-        """
-        Connects to a PLC using the given plc connection string.
-        :param url: plc connection string
-        :param authentication: authentication credentials.
-        :return PlcConnection: PLC Connection object
-        """
-        return await ModbusConnection.create(url)
-
-
-class ModbusDriverLoader(PlcDriverLoader):
-    """
-    Modbus Driver Pluggy Hook Implmentation, lets pluggy find the driver by name
-    """
+        if self.transport is None:
+            self.transport = "tcp"
 
-    @staticmethod
-    @plc4py.hookimpl
-    def get_driver() -> Type[ModbusDriver]:
-        return ModbusDriver
+        if self.port is None:
+            self.port = 502
 
-    @staticmethod
-    @plc4py.hookimpl
-    def key() -> str:
-        return "modbus"
+        if "unit_identifier" not in self.parameters:
+            self.unit_identifier = 1