python-snap7 1.3__tar.gz → 1.4__tar.gz

{python-snap7-1.3 → python_snap7-1.4}/MANIFEST.in

@@ -1,2 +1 @@
 include README.rst
-

python_snap7-1.4/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.1
+Name: python-snap7
+Version: 1.4
+Summary: Python wrapper for the snap7 library
+Author-email: Gijs Molenaar <gijsmolenaar@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/gijzelaerr/python-snap7
+Project-URL: Documentation, https://python-snap7.readthedocs.io/en/latest/
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Topic :: System :: Hardware
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Manufacturing
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: mypy; extra == "test"
+Requires-Dist: types-setuptools; extra == "test"
+Requires-Dist: ruff; extra == "test"
+Provides-Extra: cli
+Requires-Dist: rich; extra == "cli"
+Requires-Dist: click; extra == "cli"
+Provides-Extra: doc
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: sphinx_rtd_theme; extra == "doc"

python_snap7-1.4/README.rst

@@ -0,0 +1,21 @@
+About
+=====
+
+This is a ctypes-based Python wrapper for snap7. Snap7 is an open-source,
+32/64 bit, multi-platform Ethernet communication suite for interfacing natively
+with Siemens S7 PLCs.
+
+Python-snap7 is tested with Python 3.9+, on Windows, Linux and OS X.
+
+The full documentation is available on `Read The Docs <https://python-snap7.readthedocs.io/en/latest/>`_.
+
+
+Installation
+============
+
+If you are running Windows, Mac OS X or GNU/Linux on an Intel x64 or ARM 64 compatible platform you can use the binary wheel installation::
+
+   $ pip install python-snap7
+
+
+Otherwise, please read the `online installation documentation <https://python-snap7.readthedocs.io/en/latest/installation.html>`_.

python_snap7-1.4/pyproject.toml

@@ -0,0 +1,69 @@
+[build-system]
+requires = ["setuptools>=68.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "python-snap7"
+version = "1.4"
+description = "Python wrapper for the snap7 library"
+authors = [
+    {name = "Gijs Molenaar", email = "gijsmolenaar@gmail.com"},
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Topic :: System :: Hardware",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Manufacturing",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+license = {text = "MIT"}
+requires-python = ">=3.8"
+
+[project.urls]
+Homepage = "https://github.com/gijzelaerr/python-snap7"
+Documentation = "https://python-snap7.readthedocs.io/en/latest/"
+
+[project.optional-dependencies]
+test = ["pytest", "mypy", "types-setuptools", "ruff"]
+cli = ["rich", "click" ]
+doc = ["sphinx", "sphinx_rtd_theme"]
+
+[tool.setuptools.package-data]
+snap7 = ["py.typed", "lib/libsnap7.so", "lib/snap7.dll", "lib/libsnap7.dylib"]
+
+[tool.setuptools.packages.find]
+include = ["snap7*"]
+
+[project.scripts]
+snap7-server = "snap7.server.__main__:main"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers =[
+    "client",
+    "common",
+    "logo",
+    "mainloop",
+    "partner",
+    "server",
+    "util"
+    ]
+
+[tool.mypy]
+ignore_missing_imports = true
+
+[tool.ruff]
+output-format = "full"
+line-length = 130
+target-version = "py38"
+
+[lint]
+ignore = []
+mccabe.max-complexity = 10

python_snap7-1.4/python_snap7.egg-info/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.1
+Name: python-snap7
+Version: 1.4
+Summary: Python wrapper for the snap7 library
+Author-email: Gijs Molenaar <gijsmolenaar@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/gijzelaerr/python-snap7
+Project-URL: Documentation, https://python-snap7.readthedocs.io/en/latest/
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Topic :: System :: Hardware
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Manufacturing
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: mypy; extra == "test"
+Requires-Dist: types-setuptools; extra == "test"
+Requires-Dist: ruff; extra == "test"
+Provides-Extra: cli
+Requires-Dist: rich; extra == "cli"
+Requires-Dist: click; extra == "cli"
+Provides-Extra: doc
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: sphinx_rtd_theme; extra == "doc"

{python-snap7-1.3 → python_snap7-1.4}/python_snap7.egg-info/SOURCES.txt

@@ -1,8 +1,7 @@
 LICENSE
 MANIFEST.in
 README.rst
-setup.cfg
-setup.py
+pyproject.toml
 python_snap7.egg-info/PKG-INFO
 python_snap7.egg-info/SOURCES.txt
 python_snap7.egg-info/dependency_links.txt
@@ -17,14 +16,17 @@ snap7/logo.py
 snap7/partner.py
 snap7/py.typed
 snap7/types.py
-snap7/util.py
 snap7/client/__init__.py
 snap7/server/__init__.py
 snap7/server/__main__.py
-test/test_client.py
-test/test_common.py
-test/test_logo_client.py
-test/test_mainloop.py
-test/test_partner.py
-test/test_server.py
-test/test_util.py
+snap7/util/__init__.py
+snap7/util/db.py
+snap7/util/getters.py
+snap7/util/setters.py
+tests/test_client.py
+tests/test_common.py
+tests/test_logo_client.py
+tests/test_mainloop.py
+tests/test_partner.py
+tests/test_server.py
+tests/test_util.py

{python-snap7-1.3 → python_snap7-1.4}/python_snap7.egg-info/requires.txt

@@ -1,5 +1,6 @@
 
 [cli]
+rich
 click
 
 [doc]
@@ -8,7 +9,6 @@ sphinx_rtd_theme
 
 [test]
 pytest
-pytest-asyncio
 mypy
-pycodestyle
 types-setuptools
+ruff

python_snap7-1.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

{python-snap7-1.3 → python_snap7-1.4}/snap7/__init__.py

@@ -1,7 +1,8 @@
 """
 The Snap7 Python library.
 """
-import pkg_resources
+
+from importlib.metadata import version, PackageNotFoundError
 
 from . import client
 from . import common
@@ -11,9 +12,9 @@ from . import server
 from . import types
 from . import util
 
-__all__ = ['client', 'common', 'error', 'logo', 'server', 'types', 'util']
+__all__ = ["client", "common", "error", "logo", "server", "types", "util"]
 
 try:
-    __version__ = pkg_resources.require("python-snap7")[0].version
-except pkg_resources.DistributionNotFound:
+    __version__ = version("python-snap7")
+except PackageNotFoundError:
     __version__ = "0.0rc0"

{python-snap7-1.3 → python_snap7-1.4}/snap7/client/__init__.py

@@ -1,18 +1,20 @@
 """
 Snap7 client used for connection to a siemens 7 server.
 """
+
 import re
 import logging
-from ctypes import byref, create_string_buffer, sizeof
+from ctypes import CFUNCTYPE, byref, create_string_buffer, sizeof
 from ctypes import Array, c_byte, c_char_p, c_int, c_int32, c_uint16, c_ulong, c_void_p
 from datetime import datetime
-from typing import List, Optional, Tuple, Union
+from typing import Any, Callable, List, Optional, Tuple, Union
 
 from ..common import check_error, ipv4, load_library
 from ..types import S7SZL, Areas, BlocksList, S7CpInfo, S7CpuInfo, S7DataItem
 from ..types import S7OrderCode, S7Protection, S7SZLList, TS7BlockInfo, WordLen
 from ..types import S7Object, buffer_size, buffer_type, cpu_statuses, param_types
-from ..types import S7CpuInfo, RemotePort, wordlen_to_ctypes, block_types
+from ..types import RemotePort, wordlen_to_ctypes, block_types
+
 logger = logging.getLogger(__name__)
 
 
@@ -68,8 +70,7 @@ class Client:
         self.destroy()
 
     def create(self):
-        """Creates a SNAP7 client.
-        """
+        """Creates a SNAP7 client."""
         logger.info("creating snap7 client")
         self._library.Cli_Create.restype = c_void_p
         self._pointer = S7Object(self._library.Cli_Create())
@@ -190,9 +191,7 @@ class Client:
         logger.info(f"connecting to {address}:{tcpport} rack {rack} slot {slot}")
 
         self.set_param(RemotePort, tcpport)
-        return self._library.Cli_ConnectTo(
-            self._pointer, c_char_p(address.encode()),
-            c_int(rack), c_int(slot))
+        return self._library.Cli_ConnectTo(self._pointer, c_char_p(address.encode()), c_int(rack), c_int(slot))
 
     def db_read(self, db_number: int, start: int, size: int) -> bytearray:
         """Reads a part of a DB from a PLC
@@ -220,9 +219,7 @@ class Client:
 
         type_ = wordlen_to_ctypes[WordLen.Byte.value]
         data = (type_ * size)()
-        result = (self._library.Cli_DBRead(
-            self._pointer, db_number, start, size,
-            byref(data)))
+        result = self._library.Cli_DBRead(self._pointer, db_number, start, size, byref(data))
         check_error(result, context="client")
         return bytearray(data)
 
@@ -250,8 +247,7 @@ class Client:
         size = len(data)
         cdata = (type_ * size).from_buffer_copy(data)
         logger.debug(f"db_write db_number:{db_number} start:{start} size:{size} data:{data}")
-        return self._library.Cli_DBWrite(self._pointer, db_number, start, size,
-                                         byref(cdata))
+        return self._library.Cli_DBWrite(self._pointer, db_number, start, size, byref(cdata))
 
     def delete(self, block_type: str, block_num: int) -> int:
         """Delete a block into AG.
@@ -283,11 +279,9 @@ class Client:
         _buffer = buffer_type()
         size = c_int(sizeof(_buffer))
         block_type = block_types[_type]
-        result = self._library.Cli_FullUpload(self._pointer, block_type,
-                                              block_num, byref(_buffer),
-                                              byref(size))
+        result = self._library.Cli_FullUpload(self._pointer, block_type, block_num, byref(_buffer), byref(size))
         check_error(result, context="client")
-        return bytearray(_buffer)[:size.value], size.value
+        return bytearray(_buffer)[: size.value], size.value
 
     def upload(self, block_num: int) -> bytearray:
         """Uploads a block from AG.
@@ -302,15 +296,14 @@ class Client:
             Buffer with the uploaded block.
         """
         logger.debug(f"db_upload block_num: {block_num}")
-        block_type = block_types['DB']
+        block_type = block_types["DB"]
         _buffer = buffer_type()
         size = c_int(sizeof(_buffer))
 
-        result = self._library.Cli_Upload(self._pointer, block_type, block_num,
-                                          byref(_buffer), byref(size))
+        result = self._library.Cli_Upload(self._pointer, block_type, block_num, byref(_buffer), byref(size))
 
         check_error(result, context="client")
-        logger.info(f'received {size} bytes')
+        logger.info(f"received {size} bytes")
         return bytearray(_buffer)
 
     @error_wrap
@@ -332,8 +325,7 @@ class Client:
         type_ = c_byte
         size = len(data)
         cdata = (type_ * len(data)).from_buffer_copy(data)
-        return self._library.Cli_Download(self._pointer, block_num,
-                                          byref(cdata), size)
+        return self._library.Cli_Download(self._pointer, block_num, byref(cdata), size)
 
     def db_get(self, db_number: int) -> bytearray:
         """Uploads a DB from AG using DBRead.
@@ -357,35 +349,33 @@ class Client:
         """
         logger.debug(f"db_get db_number: {db_number}")
         _buffer = buffer_type()
-        result = self._library.Cli_DBGet(
-            self._pointer, db_number, byref(_buffer),
-            byref(c_int(buffer_size)))
+        result = self._library.Cli_DBGet(self._pointer, db_number, byref(_buffer), byref(c_int(buffer_size)))
         check_error(result, context="client")
         return bytearray(_buffer)
 
     def read_area(self, area: Areas, dbnumber: int, start: int, size: int) -> bytearray:
         """Reads a data area from a PLC
-        With it you can read DB, Inputs, Outputs, Merkers, Timers and Counters.
+                With it you can read DB, Inputs, Outputs, Merkers, Timers and Counters.
 
-        Args:
-            area: area to be read from.
-            dbnumber: number of the db to be read from. In case of Inputs, Marks or Outputs, this should be equal to 0.
-            start: byte index to start reading.
-            size: number of bytes to read.
+                Args:
+                    area: area to be read from.
+                    dbnumber: number of the db to be read from. In case of Inputs, Marks or Outputs, this should be equal to 0.
+                    start: byte index to start reading.
+                    size: number of bytes to read.
 
-        Returns:
-            Buffer with the data read.
+                Returns:
+                    Buffer with the data read.
 
-        Raises:
-            :obj:`ValueError`: if the area is not defined in the `Areas`
+                Raises:
+                    :obj:`ValueError`: if the area is not defined in the `Areas`
 
-        Example:
-            >>> import snap7
-            >>> client = snap7.client.Client()
-            >>> client.connect("192.168.0.1", 0, 0)
-            >>> buffer = client.read_area(Areas.DB, 1, 10, 4)  # Reads the DB number 1 from the byte 10 to the byte 14.
-            >>> buffer
-            bytearray(b'\\x00\\x00')
+                Example:
+        import snap7.util.db            >>> import snap7
+                    >>> client = snap7.client.Client()
+                    >>> client.connect("192.168.0.1", 0, 0)
+                    >>> buffer = client.read_area(snap7.util.db.DB, 1, 10, 4)  # Reads the DB number 1 from the byte 10 to the byte 14.
+                    >>> buffer
+                    bytearray(b'\\x00\\x00')
         """
         if area not in Areas:
             raise ValueError(f"{area} is not implemented in types")
@@ -396,10 +386,12 @@ class Client:
         else:
             wordlen = WordLen.Byte
         type_ = wordlen_to_ctypes[wordlen.value]
-        logger.debug(f"reading area: {area.name} dbnumber: {dbnumber} start: {start}: amount {size}: wordlen: {wordlen.name}={wordlen.value}")
+        logger.debug(
+            f"reading area: {area.name} dbnumber: {dbnumber} start: {start} amount: {size} "
+            f"wordlen: {wordlen.name}={wordlen.value}"
+        )
         data = (type_ * size)()
-        result = self._library.Cli_ReadArea(self._pointer, area.value, dbnumber, start,
-                                            size, wordlen.value, byref(data))
+        result = self._library.Cli_ReadArea(self._pointer, area.value, dbnumber, start, size, wordlen.value, byref(data))
         check_error(result, context="client")
         return bytearray(data)
 
@@ -417,11 +409,13 @@ class Client:
             Snap7 error code.
 
         Exmaple:
+            >>> import snap7.util.db
             >>> import snap7
             >>> client = snap7.client.Client()
             >>> client.connect("192.168.0.1", 0, 0)
             >>> buffer = bytearray([0b00000001])
-            >>> client.write_area(Areas.DB, 1, 10, buffer)  # Writes the bit 0 of the byte 10 from the DB number 1 to TRUE.
+            # Writes the bit 0 of the byte 10 from the DB number 1 to TRUE.
+            >>> client.write_area(snap7.util.DB, 1, 10, buffer)
         """
         if area == Areas.TM:
             wordlen = WordLen.Timer
@@ -431,11 +425,12 @@ class Client:
             wordlen = WordLen.Byte
         type_ = wordlen_to_ctypes[WordLen.Byte.value]
         size = len(data)
-        logger.debug(f"writing area: {area.name} dbnumber: {dbnumber} start: {start}: size {size}: "
-                     f"wordlen {wordlen.name}={wordlen.value} type: {type_}")
+        logger.debug(
+            f"writing area: {area.name} dbnumber: {dbnumber} start: {start}: size {size}: "
+            f"wordlen {wordlen.name}={wordlen.value} type: {type_}"
+        )
         cdata = (type_ * len(data)).from_buffer_copy(data)
-        return self._library.Cli_WriteArea(self._pointer, area.value, dbnumber, start,
-                                           size, wordlen.value, byref(cdata))
+        return self._library.Cli_WriteArea(self._pointer, area.value, dbnumber, start, size, wordlen.value, byref(cdata))
 
     def read_multi_vars(self, items) -> Tuple[int, S7DataItem]:
         """Reads different kind of variables from a PLC simultaneously.
@@ -446,8 +441,7 @@ class Client:
         Returns:
             Tuple with the return code from the snap7 library and the list of items.
         """
-        result = self._library.Cli_ReadMultiVars(self._pointer, byref(items),
-                                                 c_int32(len(items)))
+        result = self._library.Cli_ReadMultiVars(self._pointer, byref(items), c_int32(len(items)))
         check_error(result, context="client")
         return result, items
 
@@ -494,10 +488,7 @@ class Client:
 
         data = (c_uint16 * size)()
         count = c_int(size)
-        result = self._library.Cli_ListBlocksOfType(
-            self._pointer, _blocktype,
-            byref(data),
-            byref(count))
+        result = self._library.Cli_ListBlocksOfType(self._pointer, _blocktype, byref(data), byref(count))
 
         logger.debug(f"number of items found: {count}")
 
@@ -563,8 +554,7 @@ class Client:
         """
         if len(password) > 8:
             raise ValueError("Maximum password length is 8")
-        return self._library.Cli_SetSessionPassword(self._pointer,
-                                                    c_char_p(password.encode()))
+        return self._library.Cli_SetSessionPassword(self._pointer, c_char_p(password.encode()))
 
     @error_wrap
     def clear_session_password(self) -> int:
@@ -593,14 +583,12 @@ class Client:
         """
         if not re.match(ipv4, address):
             raise ValueError(f"{address} is invalid ipv4")
-        result = self._library.Cli_SetConnectionParams(self._pointer, address,
-                                                       c_uint16(local_tsap),
-                                                       c_uint16(remote_tsap))
+        result = self._library.Cli_SetConnectionParams(self._pointer, address, c_uint16(local_tsap), c_uint16(remote_tsap))
         if result != 0:
             raise ValueError("The parameter was invalid")
 
     def set_connection_type(self, connection_type: int):
-        """ Sets the connection resource type, i.e the way in which the Clients connects to a PLC.
+        """Sets the connection resource type, i.e the way in which the Clients connects to a PLC.
 
         Args:
             connection_type: 1 for PG, 2 for OP, 3 to 10 for S7 Basic
@@ -609,8 +597,7 @@ class Client:
             :obj:`ValueError`: if the result of setting the connection type is
                 different than 0.
         """
-        result = self._library.Cli_SetConnectionType(self._pointer,
-                                                     c_uint16(connection_type))
+        result = self._library.Cli_SetConnectionType(self._pointer, c_uint16(connection_type))
         if result != 0:
             raise ValueError("The parameter was invalid")
 
@@ -642,8 +629,7 @@ class Client:
         type_ = wordlen_to_ctypes[wordlen.value]
         data = (type_ * size)()
         logger.debug(f"ab_read: start: {start}: size {size}: ")
-        result = self._library.Cli_ABRead(self._pointer, start, size,
-                                          byref(data))
+        result = self._library.Cli_ABRead(self._pointer, start, size, byref(data))
         check_error(result, context="client")
         return bytearray(data)
 
@@ -662,8 +648,7 @@ class Client:
         size = len(data)
         cdata = (type_ * size).from_buffer_copy(data)
         logger.debug(f"ab write: start: {start}: size: {size}: ")
-        return self._library.Cli_ABWrite(
-            self._pointer, start, size, byref(cdata))
+        return self._library.Cli_ABWrite(self._pointer, start, size, byref(cdata))
 
     def as_ab_read(self, start: int, size: int, data) -> int:
         """Reads a part of IPU area from a PLC asynchronously.
@@ -677,8 +662,7 @@ class Client:
             Snap7 code.
         """
         logger.debug(f"ab_read: start: {start}: size {size}: ")
-        result = self._library.Cli_AsABRead(self._pointer, start, size,
-                                            byref(data))
+        result = self._library.Cli_AsABRead(self._pointer, start, size, byref(data))
         check_error(result, context="client")
         return result
 
@@ -697,13 +681,12 @@ class Client:
         size = len(data)
         cdata = (type_ * size).from_buffer_copy(data)
         logger.debug(f"ab write: start: {start}: size: {size}: ")
-        result = self._library.Cli_AsABWrite(
-            self._pointer, start, size, byref(cdata))
+        result = self._library.Cli_AsABWrite(self._pointer, start, size, byref(cdata))
         check_error(result, context="client")
         return result
 
     def as_compress(self, time: int) -> int:
-        """	Performs the Compress action asynchronously.
+        """Performs the Compress action asynchronously.
 
         Args:
             time: timeout.
@@ -927,12 +910,7 @@ class Client:
         check_error(result, context="client")
 
         return datetime(
-            year=buffer[5] + 1900,
-            month=buffer[4] + 1,
-            day=buffer[3],
-            hour=buffer[2],
-            minute=buffer[1],
-            second=buffer[0]
+            year=buffer[5] + 1900, month=buffer[4] + 1, day=buffer[3], hour=buffer[2], minute=buffer[1], second=buffer[0]
         )
 
     @error_wrap
@@ -969,10 +947,30 @@ class Client:
         check_error(result, context="client")
         return result
 
-    def set_as_callback(self, pfn_clicompletion, p_usr):
-        # Cli_SetAsCallback
-        result = self._library.Cli_SetAsCallback(self._pointer, pfn_clicompletion, p_usr)
-        check_error(result, context='client')
+    def set_as_callback(self, call_back: Callable[..., Any]) -> int:
+        logger.info("setting event callback")
+        callback_wrap: Callable[..., Any] = CFUNCTYPE(None, c_void_p, c_int, c_int)
+
+        def wrapper(usrptr: Optional[c_void_p], op_code: int, op_result: int) -> int:
+            """Wraps python function into a ctypes function
+
+            Args:
+                usrptr: not used
+                op_code:
+                op_result:
+
+            Returns:
+                Should return an int
+            """
+            logger.info(f"callback event: op_code: {op_code} op_result: {op_result}")
+            call_back(op_code, op_result)
+            return 0
+
+        self._callback = callback_wrap(wrapper)
+        usrPtr = c_void_p()
+
+        result = self._library.Cli_SetAsCallback(self._pointer, self._callback, usrPtr)
+        check_error(result, context="client")
         return result
 
     def wait_as_completion(self, timeout: int) -> int:
@@ -1017,7 +1015,10 @@ class Client:
         Returns:
             Snap7 code.
         """
-        logger.debug(f"reading area: {area.name} dbnumber: {dbnumber} start: {start}: amount {size}: wordlen: {wordlen.name}={wordlen.value}")
+        logger.debug(
+            f"reading area: {area.name} dbnumber: {dbnumber} start: {start} amount: {size} "
+            f"wordlen: {wordlen.name}={wordlen.value}"
+        )
         result = self._library.Cli_AsReadArea(self._pointer, area.value, dbnumber, start, size, wordlen.value, pusrdata)
         check_error(result, context="client")
         return result
@@ -1050,8 +1051,9 @@ class Client:
             Snap7 code.
         """
         type_ = wordlen_to_ctypes[WordLen.Byte.value]
-        logger.debug(f"writing area: {area.name} dbnumber: {dbnumber} start: {start}: size {size}: "
-                     f"wordlen {wordlen} type: {type_}")
+        logger.debug(
+            f"writing area: {area.name} dbnumber: {dbnumber} start: {start}: size {size}: " f"wordlen {wordlen} type: {type_}"
+        )
         cdata = (type_ * len(pusrdata)).from_buffer_copy(pusrdata)
         res = self._library.Cli_AsWriteArea(self._pointer, area.value, dbnumber, start, size, wordlen.value, byref(cdata))
         check_error(res, context="client")
@@ -1238,7 +1240,7 @@ class Client:
         Returns:
             Snap7 code.
         """
-        block_type = block_types['DB']
+        block_type = block_types["DB"]
         result = self._library.Cli_AsUpload(self._pointer, block_type, block_num, byref(_buffer), byref(size))
         check_error(result, context="client")
         return result
@@ -1350,7 +1352,7 @@ class Client:
         text = create_string_buffer(buffer_size)
         response = self._library.Cli_ErrorText(error_code, byref(text), text_length)
         check_error(response)
-        result = bytearray(text)[:text_length.value].decode().strip('\x00')
+        result = bytearray(text)[: text_length.value].decode().strip("\x00")
         return result
 
     def get_cp_info(self) -> S7CpInfo:
@@ -1437,7 +1439,7 @@ class Client:
         cdata = (c_byte * len(data)).from_buffer_copy(data)
         response = self._library.Cli_IsoExchangeBuffer(self._pointer, byref(cdata), byref(size))
         check_error(response)
-        result = bytearray(cdata)[:size.value]
+        result = bytearray(cdata)[: size.value]
         return result
 
     def mb_read(self, start: int, size: int) -> bytearray:
@@ -1499,7 +1501,7 @@ class Client:
         items_count = c_int(sizeof(szl_list))
         response = self._library.Cli_ReadSZLList(self._pointer, byref(szl_list), byref(items_count))
         check_error(response, context="client")
-        result = bytearray(szl_list.List)[:items_count.value]
+        result = bytearray(szl_list.List)[: items_count.value]
         return result
 
     def set_plc_system_datetime(self) -> int: