Codespell for examples. (#849)

janiversen · web-flow · commit 00171303c852 · 2022-04-25T21:05:44.000+02:00
diff --git a/examples/common/README.rst b/examples/common/README.rst
@@ -12,7 +12,7 @@ pymodbus
 You can use pymodbus as a testing server by simply modifying
 one of the run scripts supplied here. There is an
 asynchronous version and a synchronous version (that really
-differ in how mnay dependencies you are willing to have).
+differ in how many dependencies you are willing to have).
 Regardless of which one you choose, they can be started
 quite easily::
 
diff --git a/examples/common/async_asyncio_client.py b/examples/common/async_asyncio_client.py
@@ -116,7 +116,7 @@ async def start_async_test(client):
         'write_address': 1,
         'write_registers': [20] * 8,
     }
-    _logger.debug("Read write registeres simulataneously")
+    _logger.debug("Read write registers simultaneously")
     rq = await client.readwrite_registers(unit=UNIT, **arguments)
     rr = await client.read_holding_registers(1, 8, unit=UNIT)
     assert rq.function_code < 0x80     # test that we are not an error
diff --git a/examples/common/async_asyncio_serial_client.py b/examples/common/async_asyncio_serial_client.py
@@ -109,7 +109,7 @@ async def start_async_test(client): # pylint: disable=redefined-outer-name
             'write_address': 1,
             'write_registers': [20] * 8,
         }
-        log.debug("Read write registers simulataneously")
+        log.debug("Read write registers simultaneously")
         rq = await client.readwrite_registers(unit=UNIT, **arguments)
         rr = await client.read_holding_registers(1, 8, unit=UNIT)
         assert rq.function_code < 0x80     # test that we are not an error
diff --git a/examples/common/async_tornado_client_serial.py b/examples/common/async_tornado_client_serial.py
@@ -132,7 +132,7 @@ def begin_asynchronous_test(client, protocol): #NOSONAR pylint: disable=redefine
 # ---------------------------------------------------------------------------#
 
 def err(*args, **kwargs):
-    """" Errror. """
+    """" handle error. """
     txt = f"Err {args} {kwargs}"
     log.error(txt)
 
diff --git a/examples/common/asynchronous_processor.py b/examples/common/asynchronous_processor.py
@@ -108,7 +108,7 @@ def error_handler(self, failure): # pylint: disable=no-self-use
 #
 #     Factory(Protocol) -> ProtocolInstance
 #
-# It also persists data between client instances (think protocol singelton).
+# It also persists data between client instances (think protocol singleton).
 # --------------------------------------------------------------------------- #
 class ExampleFactory(ClientFactory):
     """ Example factory. """
diff --git a/examples/common/asynchronous_server.py b/examples/common/asynchronous_server.py
@@ -58,7 +58,7 @@ def run_async_server():
     #     store = ModbusSlaveContext()
     #
     # Finally, you are allowed to use the same DataBlock reference for every
-    # table or you you may use a seperate DataBlock for each table.
+    # table or you you may use a separate DataBlock for each table.
     # This depends if you would like functions to be able to access and modify
     # the same data or not::
     #
diff --git a/examples/common/changing_framers.py b/examples/common/changing_framers.py
@@ -8,7 +8,7 @@
 (like a binary framer over a serial connection).
 
 It should be noted that although you are not limited to trying whatever
-you would like, the library makes no gurantees that all framers with
+you would like, the library makes no guarantees that all framers with
 all transports will produce predictable or correct results (for example
 tcp transport with an RTU framer). However, please let us know of any
 success cases that are not documented!
diff --git a/examples/common/modbus_payload.py b/examples/common/modbus_payload.py
@@ -94,8 +94,8 @@ def run_binary_payload_ex():
         print()
         builder = BinaryPayloadBuilder(byteorder=byte_endian,
                                        wordorder=word_endian)
-        strng = "abcdefgh"
-        builder.add_string(strng)
+        my_string = "abcdefgh"
+        builder.add_string(my_string)
         builder.add_bits([0, 1, 0, 1, 1, 0, 1, 0])
         builder.add_8bit_int(-0x12)
         builder.add_8bit_uint(0x12)
@@ -170,7 +170,7 @@ def run_binary_payload_ex():
                 "Make sure wordorder is consistent between BinaryPayloadBuilder and BinaryPayloadDecoder"  # pylint: disable=protected-access
 
         decoded = OrderedDict([
-            ('string', decoder.decode_string(len(strng))),
+            ('string', decoder.decode_string(len(my_string))),
             ('bits', decoder.decode_bits()),
             ('8int', decoder.decode_8bit_int()),
             ('8uint', decoder.decode_8bit_uint()),
diff --git a/examples/common/synchronous_client.py b/examples/common/synchronous_client.py
@@ -153,7 +153,7 @@ def run_sync_client():
         'write_address':   1, # noqa E221
         'write_registers': [20] * 8,
     }
-    log.debug("Read write registeres simulataneously")
+    log.debug("Read write registers simultaneously")
     rq = client.readwrite_registers(unit=UNIT, **arguments)
     rr = client.read_holding_registers(1, 8, unit=UNIT)
     assert not rq.isError()      # test that we are not an error
diff --git a/examples/contrib/bcd_payload.py b/examples/contrib/bcd_payload.py
@@ -72,10 +72,10 @@ def __init__(self, payload=None, endian=Endian.Little):
         """ Initialize a new instance of the payload builder
 
         :param payload: Raw payload data to initialize with
-        :param endian: The endianess of the payload
+        :param endian: The endianness of the payload
         """
-        self._payload = payload or []
         self._endian = endian
+        self._payload = payload or []
 
     def __str__(self):
         """ Return the payload buffer as a string
@@ -165,7 +165,7 @@ def fromRegisters(registers, endian=Endian.Little): # pylint: disable=invalid-na
         been decoded by the rest of the library.
 
         :param registers: The register results to initialize with
-        :param endian: The endianess of the payload
+        :param endian: The endianness of the payload
         :returns: An initialized PayloadDecoder
         """
         if isinstance(registers, list):  # repack into flat binary
@@ -181,7 +181,7 @@ def fromCoils(coils, endian=Endian.Little): # pylint: disable=invalid-name
         The coils are treated as a list of bit(boolean) values.
 
         :param coils: The coil results to initialize with
-        :param endian: The endianess of the payload
+        :param endian: The endianness of the payload
         :returns: An initialized PayloadDecoder
         """
         if isinstance(coils, list):
diff --git a/examples/contrib/concurrent_client.py b/examples/contrib/concurrent_client.py
@@ -148,7 +148,7 @@ def _manager_worker_process(output_queue, my_futures, is_shutdown):
 # -------------------------------------------------------------------------- #
 class ConcurrentClient(ModbusClientMixin):
     """ This is a high performance client that can be used
-    to read/write a large number of reqeusts at once asyncronously.
+    to read/write a large number of requests at once asynchronously.
     This operates with a backing worker pool of processes or threads
     to achieve its performance.
     """
diff --git a/examples/contrib/libmodbus_client.py b/examples/contrib/libmodbus_client.py
@@ -102,7 +102,7 @@
 LIB = compiler.dlopen('modbus')  # create our bindings
 
 # -------------------------------------------------------------------------- #
-# helper utilites
+# helper utilities
 # -------------------------------------------------------------------------- #
 
 
@@ -172,7 +172,7 @@ def create_rtu_client(cls, **kwargs):
         return cls(my_client)
 
     def __init__(self, my_client):
-        """ Initalize a new instance of the LibmodbusLevel1Client. This
+        """ Initialize a new instance of the LibmodbusLevel1Client. This
         method should not be used, instead new instances should be created
         using the two supplied factory methods:
 
@@ -395,7 +395,7 @@ class LibmodbusClient(ModbusClientMixin):
     }
 
     def __init__(self, my_client):
-        """ Initalize a new instance of the LibmodbusClient. This should
+        """ Initialize a new instance of the LibmodbusClient. This should
         be initialized with one of the LibmodbusLevel1Client instances:
 
         * LibmodbusLevel1Client.create_rtu_client(...)
diff --git a/examples/contrib/modbus_mapper.py b/examples/contrib/modbus_mapper.py
@@ -32,7 +32,7 @@
         index += mapping[i]['size']
 
 Also, using the same input mapping parsers, we can generate
-populated slave contexts that can be run behing a modbus server::
+populated slave contexts that can be run behind a modbus server::
 
     from modbus_mapper import csv_mapping_parser
     from modbus_mapper import modbus_context_decoder
diff --git a/examples/contrib/modbus_saver.py b/examples/contrib/modbus_saver.py
@@ -31,9 +31,9 @@
 
 class ModbusDatastoreSaver:
     """ An abstract base class that can be used to implement
-    a persistance format for the modbus server context. In
+    a persistence format for the modbus server context. In
     order to use it, just complete the necessary callbacks
-    (SAX style) that your persistance format needs.
+    (SAX style) that your persistence format needs.
     """
 
     def __init__(self, context, path=None):
diff --git a/examples/contrib/modbus_scraper.py b/examples/contrib/modbus_scraper.py
@@ -143,7 +143,7 @@ def error_handler(self, failure): # pylint: disable=no-self-use
 #
 #     Factory(Protocol) -> ProtocolInstance
 #
-# It also persists data between client instances (think protocol singelton).
+# It also persists data between client instances (think protocol singleton).
 # --------------------------------------------------------------------------- #
 class ScraperFactory(ClientFactory):
     """ Scraper factory. """
diff --git a/examples/contrib/modbus_simulator.py b/examples/contrib/modbus_simulator.py
@@ -63,7 +63,7 @@ class Configuration: # pylint: disable=too-few-public-methods
     """
 
     def __init__(self, config):
-        """ Trys to load a configuration file, lets the file not
+        """ Tries to load a configuration file, lets the file not
         found exception fall through
 
         :param config: The pickled datastore
diff --git a/examples/contrib/modicon_payload.py b/examples/contrib/modicon_payload.py
@@ -28,7 +28,7 @@ def __init__(self, payload=None, endian=Endian.Little):
         """ Initialize a new instance of the payload builder
 
         :param payload: Raw payload data to initialize with
-        :param endian: The endianess of the payload
+        :param endian: The endianness of the payload
         """
         self._payload = payload or []
         self._endian = endian
@@ -172,7 +172,7 @@ def from_registers(registers, endian=Endian.Little):
         been decoded by the rest of the library.
 
         :param registers: The register results to initialize with
-        :param endian: The endianess of the payload
+        :param endian: The endianness of the payload
         :returns: An initialized PayloadDecoder
         """
         if isinstance(registers, list):  # repack into flat binary
@@ -188,7 +188,7 @@ def from_coils(coils, endian=Endian.Little):
         The coils are treated as a list of bit(boolean) values.
 
         :param coils: The coil results to initialize with
-        :param endian: The endianess of the payload
+        :param endian: The endianness of the payload
         :returns: An initialized PayloadDecoder
         """
         if isinstance(coils, list):
diff --git a/examples/contrib/remote_server_context.py b/examples/contrib/remote_server_context.py
@@ -165,7 +165,7 @@ def __str__(self):
         return f"Remote Server Context{self._client}"
 
     def __iter__(self):
-        """ Iterater over the current collection of slave
+        """ Iterator over the current collection of slave
         contexts.
 
         :returns: An iterator over the slave contexts
diff --git a/examples/contrib/sunspec_client.py b/examples/contrib/sunspec_client.py
@@ -119,7 +119,7 @@ class SunspecModel: # pylint: disable=too-few-public-methods
     OutbackSystemControl                     = 64120  # noqa E221
 
     # ---------------------------------------------
-    # 64xxx Vender Extension Block
+    # 64xxx Vendor Extension Block
     # ---------------------------------------------
     EndOfSunSpecMap                          = 65535  # noqa E221
 
diff --git a/examples/contrib/thread_safe_datastore.py b/examples/contrib/thread_safe_datastore.py
@@ -6,7 +6,7 @@
 
 class ContextWrapper:
     """ This is a simple wrapper around enter
-    and exit functions that conforms to the pyhton
+    and exit functions that conforms to the python
     context manager protocol:
 
     with ContextWrapper(enter, leave):
@@ -29,7 +29,7 @@ def __exit__(self, *args):
 
 
 class ReadWriteLock:
-    """ This reader writer lock gurantees write order, but not
+    """ This reader writer lock guarantees write order, but not
     read order and is generally biased towards allowing writes
     if they are available to prevent starvation.
 

Original file line number	Diff line number	Diff line change
`@@ -116,7 +116,7 @@ async def start_async_test(client):`
`116`	`116`	`'write_address': 1,`
`117`	`117`	`'write_registers': [20] * 8,`
`118`	`118`	`}`
`119`		`- _logger.debug("Read write registeres simulataneously")`
	`119`	`+ _logger.debug("Read write registers simultaneously")`
`120`	`120`	`rq = await client.readwrite_registers(unit=UNIT, **arguments)`
`121`	`121`	`rr = await client.read_holding_registers(1, 8, unit=UNIT)`
`122`	`122`	`assert rq.function_code < 0x80 # test that we are not an error`
Original file line number	Diff line number	Diff line change
`@@ -109,7 +109,7 @@ async def start_async_test(client): # pylint: disable=redefined-outer-name`
`109`	`109`	`'write_address': 1,`
`110`	`110`	`'write_registers': [20] * 8,`
`111`	`111`	`}`
`112`		`- log.debug("Read write registers simulataneously")`
	`112`	`+ log.debug("Read write registers simultaneously")`
`113`	`113`	`rq = await client.readwrite_registers(unit=UNIT, **arguments)`
`114`	`114`	`rr = await client.read_holding_registers(1, 8, unit=UNIT)`
`115`	`115`	`assert rq.function_code < 0x80 # test that we are not an error`
Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ def error_handler(self, failure): # pylint: disable=no-self-use`
`108`	`108`	`#`
`109`	`109`	`# Factory(Protocol) -> ProtocolInstance`
`110`	`110`	`#`
`111`		`-# It also persists data between client instances (think protocol singelton).`
	`111`	`+# It also persists data between client instances (think protocol singleton).`
`112`	`112`	`# --------------------------------------------------------------------------- #`
`113`	`113`	`class ExampleFactory(ClientFactory):`
`114`	`114`	`""" Example factory. """`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ def run_async_server():`
`58`	`58`	`# store = ModbusSlaveContext()`
`59`	`59`	`#`
`60`	`60`	`# Finally, you are allowed to use the same DataBlock reference for every`
`61`		`- # table or you you may use a seperate DataBlock for each table.`
	`61`	`+ # table or you you may use a separate DataBlock for each table.`
`62`	`62`	`# This depends if you would like functions to be able to access and modify`
`63`	`63`	`# the same data or not::`
`64`	`64`	`#`
Original file line number	Diff line number	Diff line change
`@@ -153,7 +153,7 @@ def run_sync_client():`
`153`	`153`	`'write_address': 1, # noqa E221`
`154`	`154`	`'write_registers': [20] * 8,`
`155`	`155`	`}`
`156`		`- log.debug("Read write registeres simulataneously")`
	`156`	`+ log.debug("Read write registers simultaneously")`
`157`	`157`	`rq = client.readwrite_registers(unit=UNIT, **arguments)`
`158`	`158`	`rr = client.read_holding_registers(1, 8, unit=UNIT)`
`159`	`159`	`assert not rq.isError() # test that we are not an error`