Fix docstring indentation issues

Author: hukkinj1

src/ecdsa/ecdh.py

@@ -63,7 +63,7 @@ def __init__(self, curve=None, private_key=None, public_key=None):
         :type private_key: SigningKey
         :param public_key:  `their` public key for ECDH
         :type public_key: VerifyingKey
-       """
+        """
         self.curve = curve
         self.private_key = None
         self.public_key = None

src/ecdsa/ecdsa.py

@@ -68,18 +68,17 @@ class InvalidPointError(RuntimeError):
 
 
 class Signature(object):
-    """ECDSA signature.
-  """
+    """ECDSA signature."""
 
     def __init__(self, r, s):
         self.r = r
         self.s = s
 
     def recover_public_keys(self, hash, generator):
         """Returns two public keys for which the signature is valid
-    hash is signed hash
-    generator is the used generator of the signature
-    """
+        hash is signed hash
+        generator is the used generator of the signature
+        """
         curve = generator.curve()
         n = generator.order()
         r = self.r
@@ -108,20 +107,18 @@ def recover_public_keys(self, hash, generator):
 
 
 class Public_key(object):
-    """Public key for ECDSA.
-  """
+    """Public key for ECDSA."""
 
     def __init__(self, generator, point, verify=True):
-        """
-    Low level ECDSA public key object.
+        """Low level ECDSA public key object.
 
-    :param generator: the Point that generates the group (the base point)
-    :param point: the Point that defines the public key
-    :param bool verify: if True check if point is valid point on curve
+        :param generator: the Point that generates the group (the base point)
+        :param point: the Point that defines the public key
+        :param bool verify: if True check if point is valid point on curve
 
-    :raises InvalidPointError: if the point parameters are invalid or
-        point does not lie on the curve
-    """
+        :raises InvalidPointError: if the point parameters are invalid or
+            point does not lie on the curve
+        """
 
         self.curve = generator.curve()
         self.generator = generator
@@ -154,8 +151,8 @@ def __eq__(self, other):
 
     def verifies(self, hash, signature):
         """Verify that signature is a valid signature of hash.
-    Return True if the signature is valid.
-    """
+        Return True if the signature is valid.
+        """
 
         # From X9.62 J.3.1.
 
@@ -179,13 +176,12 @@ def verifies(self, hash, signature):
 
 
 class Private_key(object):
-    """Private key for ECDSA.
-  """
+    """Private key for ECDSA."""
 
     def __init__(self, public_key, secret_multiplier):
         """public_key is of class Public_key;
-    secret_multiplier is a large integer.
-    """
+        secret_multiplier is a large integer.
+        """
 
         self.public_key = public_key
         self.secret_multiplier = secret_multiplier
@@ -201,18 +197,18 @@ def __eq__(self, other):
 
     def sign(self, hash, random_k):
         """Return a signature for the provided hash, using the provided
-    random nonce.  It is absolutely vital that random_k be an unpredictable
-    number in the range [1, self.public_key.point.order()-1].  If
-    an attacker can guess random_k, he can compute our private key from a
-    single signature.  Also, if an attacker knows a few high-order
-    bits (or a few low-order bits) of random_k, he can compute our private
-    key from many signatures.  The generation of nonces with adequate
-    cryptographic strength is very difficult and far beyond the scope
-    of this comment.
-
-    May raise RuntimeError, in which case retrying with a new
-    random value k is in order.
-    """
+        random nonce.  It is absolutely vital that random_k be an unpredictable
+        number in the range [1, self.public_key.point.order()-1].  If
+        an attacker can guess random_k, he can compute our private key from a
+        single signature.  Also, if an attacker knows a few high-order
+        bits (or a few low-order bits) of random_k, he can compute our private
+        key from many signatures.  The generation of nonces with adequate
+        cryptographic strength is very difficult and far beyond the scope
+        of this comment.
+
+        May raise RuntimeError, in which case retrying with a new
+        random value k is in order.
+        """
 
         G = self.public_key.generator
         n = G.order()

src/ecdsa/ellipticcurve.py

@@ -61,13 +61,13 @@ class CurveFp(object):
 
         def __init__(self, p, a, b, h=None):
             """
-        The curve of points satisfying y^2 = x^3 + a*x + b (mod p).
+            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.
-        """
+            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.
+            """
             self.__p = mpz(p)
             self.__a = mpz(a)
             self.__b = mpz(b)
@@ -79,13 +79,13 @@ def __init__(self, p, a, b, h=None):
 
         def __init__(self, p, a, b, h=None):
             """
-        The curve of points satisfying y^2 = x^3 + a*x + b (mod p).
+            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.
-        """
+            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.
+            """
             self.__p = p
             self.__a = a
             self.__b = b
@@ -131,32 +131,32 @@ def __str__(self):
 
 class PointJacobi(object):
     """
-  Point on an elliptic curve. Uses Jacobi coordinates.
+    Point on an elliptic curve. Uses Jacobi coordinates.
 
-  In Jacobian coordinates, there are three parameters, X, Y and Z.
-  They correspond to affine parameters 'x' and 'y' like so:
+    In Jacobian coordinates, there are three parameters, X, Y and Z.
+    They correspond to affine parameters 'x' and 'y' like so:
 
-  x = X / Z²
-  y = Y / Z³
-  """
+    x = X / Z²
+    y = Y / Z³
+    """
 
     def __init__(self, curve, x, y, z, order=None, generator=False):
         """
-      Initialise a point that uses Jacobi representation internally.
-
-      :param CurveFp curve: curve on which the point resides
-      :param int x: the X parameter of Jacobi representation (equal to x when
-        converting from affine coordinates
-      :param int y: the Y parameter of Jacobi representation (equal to y when
-        converting from affine coordinates
-      :param int z: the Z parameter of Jacobi representation (equal to 1 when
-        converting from affine coordinates
-      :param int order: the point order, must be non zero when using
-        generator=True
-      :param bool generator: the point provided is a curve generator, as
-        such, it will be commonly used with scalar multiplication. This will
-        cause to precompute multiplication table for it
-      """
+        Initialise a point that uses Jacobi representation internally.
+
+        :param CurveFp curve: curve on which the point resides
+        :param int x: the X parameter of Jacobi representation (equal to x when
+          converting from affine coordinates
+        :param int y: the Y parameter of Jacobi representation (equal to y when
+          converting from affine coordinates
+        :param int z: the Z parameter of Jacobi representation (equal to 1 when
+          converting from affine coordinates
+        :param int order: the point order, must be non zero when using
+          generator=True
+        :param bool generator: the point provided is a curve generator, as
+          such, it will be commonly used with scalar multiplication. This will
+          cause to precompute multiplication table for it
+        """
         self.__curve = curve
         # since it's generally better (faster) to use scaled points vs unscaled
         # ones, use writer-biased RWLock for locking:
@@ -220,8 +220,8 @@ def __eq__(self, other):
     def order(self):
         """Return the order of the point.
 
-      None if it is undefined.
-      """
+        None if it is undefined.
+        """
         return self.__order
 
     def curve(self):
@@ -230,13 +230,13 @@ def curve(self):
 
     def x(self):
         """
-      Return affine x coordinate.
+        Return affine x coordinate.
 
-      This method should be used only when the 'y' coordinate is not needed.
-      It's computationally more efficient to use `to_affine()` and then
-      call x() and y() on the returned instance. Or call `scale()`
-      and then x() and y() on the returned instance.
-      """
+        This method should be used only when the 'y' coordinate is not needed.
+        It's computationally more efficient to use `to_affine()` and then
+        call x() and y() on the returned instance. Or call `scale()`
+        and then x() and y() on the returned instance.
+        """
         try:
             self._scale_lock.reader_acquire()
             if self.__z == 1:
@@ -251,13 +251,13 @@ def x(self):
 
     def y(self):
         """
-      Return affine y coordinate.
+        Return affine y coordinate.
 
-      This method should be used only when the 'x' coordinate is not needed.
-      It's computationally more efficient to use `to_affine()` and then
-      call x() and y() on the returned instance. Or call `scale()`
-      and then x() and y() on the returned instance.
-      """
+        This method should be used only when the 'x' coordinate is not needed.
+        It's computationally more efficient to use `to_affine()` and then
+        call x() and y() on the returned instance. Or call `scale()`
+        and then x() and y() on the returned instance.
+        """
         try:
             self._scale_lock.reader_acquire()
             if self.__z == 1:
@@ -272,10 +272,10 @@ def y(self):
 
     def scale(self):
         """
-      Return point scaled so that z == 1.
+        Return point scaled so that z == 1.
 
-      Modifies point in place, returns self.
-      """
+        Modifies point in place, returns self.
+        """
         try:
             self._scale_lock.reader_acquire()
             if self.__z == 1:
@@ -312,10 +312,10 @@ def to_affine(self):
     def from_affine(point, generator=False):
         """Create from an affine point.
 
-      :param bool generator: set to True to make the point to precalculate
-        multiplication table - useful for public point when verifying many
-        signatures (around 100 or so) or for generator points of a curve.
-      """
+        :param bool generator: set to True to make the point to precalculate
+          multiplication table - useful for public point when verifying many
+          signatures (around 100 or so) or for generator points of a curve.
+        """
         return PointJacobi(
             point.curve(), point.x(), point.y(), 1, point.order(), generator
         )