[pre-commit.ci] pre-commit autoupdate (#11322)

* [pre-commit.ci] pre-commit autoupdate

updates:
- [github.com/astral-sh/ruff-pre-commit: v0.2.2 → v0.3.2](https://github.com/astral-sh/ruff-pre-commit/compare/v0.2.2...v0.3.2)
- [github.com/pre-commit/mirrors-mypy: v1.8.0 → v1.9.0](https://github.com/pre-commit/mirrors-mypy/compare/v1.8.0...v1.9.0)

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

hashes/adler32.py

@@ -1,11 +1,11 @@
 """
-    Adler-32 is a checksum algorithm which was invented by Mark Adler in 1995.
-    Compared to a cyclic redundancy check of the same length, it trades reliability for
-    speed (preferring the latter).
-    Adler-32 is more reliable than Fletcher-16, and slightly less reliable than
-    Fletcher-32.[2]
+Adler-32 is a checksum algorithm which was invented by Mark Adler in 1995.
+Compared to a cyclic redundancy check of the same length, it trades reliability for
+speed (preferring the latter).
+Adler-32 is more reliable than Fletcher-16, and slightly less reliable than
+Fletcher-32.[2]
 
-    source: https://en.wikipedia.org/wiki/Adler-32
+source: https://en.wikipedia.org/wiki/Adler-32
 """
 
 MOD_ADLER = 65521

hashes/hamming_code.py

@@ -4,44 +4,44 @@
 # Black: True
 
 """
-    * This code implement the Hamming code:
-        https://en.wikipedia.org/wiki/Hamming_code - In telecommunication,
-    Hamming codes are a family of linear error-correcting codes. Hamming
-    codes can detect up to two-bit errors or correct one-bit errors
-    without detection of uncorrected errors. By contrast, the simple
-    parity code cannot correct errors, and can detect only an odd number
-    of bits in error. Hamming codes are perfect codes, that is, they
-    achieve the highest possible rate for codes with their block length
-    and minimum distance of three.
+* This code implement the Hamming code:
+    https://en.wikipedia.org/wiki/Hamming_code - In telecommunication,
+Hamming codes are a family of linear error-correcting codes. Hamming
+codes can detect up to two-bit errors or correct one-bit errors
+without detection of uncorrected errors. By contrast, the simple
+parity code cannot correct errors, and can detect only an odd number
+of bits in error. Hamming codes are perfect codes, that is, they
+achieve the highest possible rate for codes with their block length
+and minimum distance of three.
 
-    * the implemented code consists of:
-        * a function responsible for encoding the message (emitterConverter)
-            * return the encoded message
-        * a function responsible for decoding the message (receptorConverter)
-            * return the decoded message and a ack of data integrity
+* the implemented code consists of:
+    * a function responsible for encoding the message (emitterConverter)
+        * return the encoded message
+    * a function responsible for decoding the message (receptorConverter)
+        * return the decoded message and a ack of data integrity
 
-    * how to use:
-            to be used you must declare how many parity bits (sizePari)
-        you want to include in the message.
-            it is desired (for test purposes) to select a bit to be set
-        as an error. This serves to check whether the code is working correctly.
-            Lastly, the variable of the message/word that must be desired to be
-        encoded (text).
+* how to use:
+        to be used you must declare how many parity bits (sizePari)
+    you want to include in the message.
+        it is desired (for test purposes) to select a bit to be set
+    as an error. This serves to check whether the code is working correctly.
+        Lastly, the variable of the message/word that must be desired to be
+    encoded (text).
 
-    * how this work:
-            declaration of variables (sizePari, be, text)
+* how this work:
+        declaration of variables (sizePari, be, text)
 
-            converts the message/word (text) to binary using the
-        text_to_bits function
-            encodes the message using the rules of hamming encoding
-            decodes the message using the rules of hamming encoding
-            print the original message, the encoded message and the
-        decoded message
+        converts the message/word (text) to binary using the
+    text_to_bits function
+        encodes the message using the rules of hamming encoding
+        decodes the message using the rules of hamming encoding
+        print the original message, the encoded message and the
+    decoded message
 
-            forces an error in the coded text variable
-            decodes the message that was forced the error
-            print the original message, the encoded message, the bit changed
-        message and the decoded message
+        forces an error in the coded text variable
+        decodes the message that was forced the error
+        print the original message, the encoded message, the bit changed
+    message and the decoded message
 """
 
 # Imports

hashes/luhn.py

@@ -1,4 +1,5 @@
-""" Luhn Algorithm """
+"""Luhn Algorithm"""
+
 from __future__ import annotations
 
 

hashes/sdbm.py

@@ -1,21 +1,21 @@
 """
-    This algorithm was created for sdbm (a public-domain reimplementation of ndbm)
-    database library.
-    It was found to do well in scrambling bits, causing better distribution of the keys
-    and fewer splits.
-    It also happens to be a good general hashing function with good distribution.
-    The actual function (pseudo code) is:
-        for i in i..len(str):
-            hash(i) = hash(i - 1) * 65599 + str[i];
+This algorithm was created for sdbm (a public-domain reimplementation of ndbm)
+database library.
+It was found to do well in scrambling bits, causing better distribution of the keys
+and fewer splits.
+It also happens to be a good general hashing function with good distribution.
+The actual function (pseudo code) is:
+    for i in i..len(str):
+        hash(i) = hash(i - 1) * 65599 + str[i];
 
-    What is included below is the faster version used in gawk. [there is even a faster,
-    duff-device version]
-    The magic constant 65599 was picked out of thin air while experimenting with
-    different constants.
-    It turns out to be a prime.
-    This is one of the algorithms used in berkeley db (see sleepycat) and elsewhere.
+What is included below is the faster version used in gawk. [there is even a faster,
+duff-device version]
+The magic constant 65599 was picked out of thin air while experimenting with
+different constants.
+It turns out to be a prime.
+This is one of the algorithms used in berkeley db (see sleepycat) and elsewhere.
 
-    source: http://www.cse.yorku.ca/~oz/hash.html
+source: http://www.cse.yorku.ca/~oz/hash.html
 """
 
 

hashes/sha1.py

@@ -25,6 +25,7 @@ the final hash.
 
 Reference: https://deadhacker.com/2006/02/21/sha-1-illustrated/
 """
+
 import argparse
 import hashlib  # hashlib is only used inside the Test class
 import struct