fix and check for lines 80 chars and longer

Author: tomato42

src/ecdsa/ecdh.py

@@ -29,7 +29,9 @@ class NoCurveError(Exception):
 
 
 class InvalidCurveError(Exception):
-    """ECDH. Raised in case the public and private keys use different curves."""
+    """
+    ECDH. Raised in case the public and private keys use different curves.
+    """
 
     pass
 
@@ -174,7 +176,8 @@ def load_private_key_der(self, private_key_der):
         Note, the only DER format supported is the RFC5915
         Look at keys.py:SigningKey.from_der()
 
-        :param private_key_der: string with the DER encoding of private ECDSA key
+        :param private_key_der: string with the DER encoding of private ECDSA
+            key
         :type private_key_der: string
 
         :raises InvalidCurveError: private_key curve not the same as self.curve

src/ecdsa/ellipticcurve.py

@@ -64,9 +64,9 @@ def __init__(self, p, a, b, h=None):
             The curve of points satisfying y^2 = x^3 + a*x + b (mod p).
 
             h is an integer that is the cofactor of the elliptic curve domain
-            parameters; it is the number of points satisfying the elliptic curve
-            equation divided by the order of the base point. It is used for selection
-            of efficient algorithm for public point verification.
+            parameters; it is the number of points satisfying the elliptic
+            curve equation divided by the order of the base point. It is used
+            for selection of efficient algorithm for public point verification.
             """
             self.__p = mpz(p)
             self.__a = mpz(a)
@@ -82,9 +82,9 @@ def __init__(self, p, a, b, h=None):
             The curve of points satisfying y^2 = x^3 + a*x + b (mod p).
 
             h is an integer that is the cofactor of the elliptic curve domain
-            parameters; it is the number of points satisfying the elliptic curve
-            equation divided by the order of the base point. It is used for selection
-            of efficient algorithm for public point verification.
+            parameters; it is the number of points satisfying the elliptic
+            curve equation divided by the order of the base point. It is used
+            for selection of efficient algorithm for public point verification.
             """
             self.__p = p
             self.__a = a
@@ -228,7 +228,8 @@ def __eq__(self, other):
         zz2 = z2 * z2 % p
 
         # compare the fractions by bringing them to the same denominator
-        # depend on short-circuit to save 4 multiplications in case of inequality
+        # depend on short-circuit to save 4 multiplications in case of
+        # inequality
         return (x1 * zz2 - x2 * zz1) % p == 0 and (
             y1 * zz2 * z2 - y2 * zz1 * z1
         ) % p == 0
@@ -309,8 +310,8 @@ def scale(self):
             zz_inv = z_inv * z_inv % p
             self.__x = self.__x * zz_inv % p
             self.__y = self.__y * zz_inv * z_inv % p
-            # we are setting the z last so that the check above will return true
-            # only after all values were already updated
+            # we are setting the z last so that the check above will return
+            # true only after all values were already updated
             self.__z = 1
         finally:
             self._scale_lock.writer_release()
@@ -599,7 +600,7 @@ def __mul__(self, other):
 
     @staticmethod
     def _leftmost_bit(x):
-        """Return integer with the same magnitude as x but hamming weight of 1"""
+        """Return integer with the same magnitude as x but only one bit set"""
         assert x > 0
         result = 1
         while result <= x:
@@ -688,9 +689,9 @@ def __init__(self, curve, x, y, order=None):
         # self.curve is allowed to be None only for INFINITY:
         if self.__curve:
             assert self.__curve.contains_point(x, y)
-        # for curves with cofactor 1, all points that are on the curve are scalar
-        # multiples of the base point, so performing multiplication is not
-        # necessary to verify that. See Section 3.2.2.1 of SEC 1 v2
+        # for curves with cofactor 1, all points that are on the curve are
+        # scalar multiples of the base point, so performing multiplication is
+        # not necessary to verify that. See Section 3.2.2.1 of SEC 1 v2
         if curve and curve.cofactor() != 1 and order:
             assert self * order == INFINITY
 

src/ecdsa/keys.py

@@ -801,9 +801,8 @@ def from_secret_exponent(cls, secexp, curve=NIST192p, hashfunc=sha1):
         n = curve.order
         if not 1 <= secexp < n:
             raise MalformedPointError(
-                "Invalid value for secexp, expected integer between 1 and {0}".format(
-                    n
-                )
+                "Invalid value for secexp, expected integer "
+                "between 1 and {0}".format(n)
             )
         pubkey_point = curve.generator * secexp
         if hasattr(pubkey_point, "scale"):
@@ -845,9 +844,8 @@ def from_string(cls, string, curve=NIST192p, hashfunc=sha1):
         string = normalise_bytes(string)
         if len(string) != curve.baselen:
             raise MalformedPointError(
-                "Invalid length of private key, received {0}, expected {1}".format(
-                    len(string), curve.baselen
-                )
+                "Invalid length of private key, received {0}, "
+                "expected {1}".format(len(string), curve.baselen)
             )
         secexp = string_to_number(string)
         return cls.from_secret_exponent(secexp, curve, hashfunc)
@@ -1035,7 +1033,8 @@ def from_der(cls, string, hashfunc=sha1):
         # pubkey_str = der.remove_bitstring(pubkey_bitstring, 0)
         # if empty != "":
         #     raise der.UnexpectedDER("trailing junk after DER privkey "
-        #                             "pubkeystr: %s" % binascii.hexlify(empty))
+        #                             "pubkeystr: %s"
+        #                             % binascii.hexlify(empty))
 
         # our from_string method likes fixed-length privkey strings
         if len(privkey_str) < curve.baselen:

src/ecdsa/rfc6979.py

@@ -44,7 +44,8 @@ def generate_k(order, secexp, hash_func, data, retry_gen=0, extra_entropy=b""):
     """
         order - order of the DSA generator used in the signature
         secexp - secure exponent (private key) in numeric form
-        hash_func - reference to the same hash function used for generating hash
+        hash_func - reference to the same hash function used for generating
+            hash
         data - hash in binary form of the signing data
         retry_gen - int - how many good 'k' values to skip before returning
         extra_entropy - extra added data in binary form as per section-3.6 of

src/ecdsa/util.py

@@ -281,8 +281,9 @@ def sigencode_der(r, s, order):
 
 
 # canonical versions of sigencode methods
-# these enforce low S values, by negating the value (modulo the order) if above order/2
-# see CECKey::Sign() https://github.com/bitcoin/bitcoin/blob/master/src/key.cpp#L214
+# these enforce low S values, by negating the value (modulo the order) if
+# above order/2 see CECKey::Sign()
+# https://github.com/bitcoin/bitcoin/blob/master/src/key.cpp#L214
 def sigencode_strings_canonize(r, s, order):
     if s > order / 2:
         s = order - s
@@ -379,16 +380,14 @@ def sigdecode_strings(rs_strings, order):
     if not len(r_str) == l:
         raise MalformedSignature(
             "Invalid length of first string ('r' parameter), "
-            "expected {0} bytes long, provided string is {1} bytes long".format(
-                l, len(r_str)
-            )
+            "expected {0} bytes long, provided string is {1} "
+            "bytes long".format(l, len(r_str))
         )
     if not len(s_str) == l:
         raise MalformedSignature(
             "Invalid length of second string ('s' parameter), "
-            "expected {0} bytes long, provided string is {1} bytes long".format(
-                l, len(s_str)
-            )
+            "expected {0} bytes long, provided string is {1} "
+            "bytes long".format(l, len(s_str))
         )
     r = string_to_number_fixedlen(r_str, order)
     s = string_to_number_fixedlen(s_str, order)

tox.ini

@@ -84,6 +84,5 @@ commands =
 exclude = src/ecdsa/test*.py
 # We're just getting started. For now, ignore the following problems:
 # E203: whitespace before ':' (this needs to be ignored for black compatibility)
-# E501: line too long
 # E741: ambiguous variable name
-extend-ignore = E203,E501,E741
+extend-ignore = E203,E741