docstrings

src/crypto_VDF/utils/number_theory.py

@@ -6,13 +6,15 @@
 class NumberTheory:
 
     @staticmethod
-    def gcd(a, b):
+    def gcd(a: int, b: int) -> int:
         """
         Euclidian algorithm to find the Greatest Common Divisor
 
-        :param a:
-        :param b:
-        :return: gcd of a and b
+        Args:
+            a:
+            b:
+        Returns:
+            gcd of a and b
         """
         r = a % b
         while r != 0:
@@ -22,16 +24,36 @@ def gcd(a, b):
         return b
 
     @classmethod
-    def check_quadratic_residue(cls, x, modulus):
+    def check_quadratic_residue(cls, x, modulus) -> bool:
+        """
+        Check if a number is a modular quadratic residue +
+
+        Args:
+            x: number to check if it is in QN_{modulus}^{+}
+            modulus: modulo defining the group QN_{modulus}^{+}
+        Returns:
+            True if yes, False if no
+        """
         return cls.gcd(a=pow(abs(x), 2) % modulus, b=modulus) == 1
 
     @classmethod
-    def generate_quadratic_residue(cls, modulus: int, max_iters=1000000000):
+    def generate_quadratic_residue(cls, modulus: int, max_iters: int = 1000000000) -> int:
+        """
+        Generate a random number in QN_{modulus}^{+}
+
+        Args:
+            modulus:
+            max_iters:
+        Returns:
+            Random number in QN_{modulus}^{+}
+        Raises:
+            Raises QuadraticResidueFailed if the number is not found
+        """
         i = 0
         while i < max_iters:
             x = random.randint(0, modulus - 1)
             if cls.check_quadratic_residue(x, modulus):
                 return x
             i += 1
         raise QuadraticResidueFailed(
-            f"Failed to create a quadratic residue of modulus {modulus} in {max_iters} iterations")
+            f"Failed to create a quadratic residue + of modulus {modulus} in {max_iters} iterations")

src/crypto_VDF/utils/prime_numbers.py

@@ -14,7 +14,8 @@ def k_bit_numer(k: int) -> Generator[int, None, None]:
         Generate an iterator object of k bits with the first bit being 1 (starting with the first bit being 0 is like
          having a k-1 bit number) and other k-1 random bits.
 
-        :param k: length of the iterator to return
+        Args:
+            k: length of the iterator to return
         """
         if k > 1:
             yield 1
@@ -38,16 +39,20 @@ def fermat_test(n: int, t=100) -> bool:
         return True
 
     @classmethod
-    def k_bit_prim_number(cls, k, t=100, max_iter=10000):
+    def k_bit_prim_number(cls, k, t: int = 100, max_iter: int = 10000) -> KBitPrimeResponse:
         """
         Generate a k-bit prime number
 
-        :param k: length of bit of the prime number to generate
-        :param t: repeat parameter of the Fermat Test
-        :param max_iter: maximum possible iterations allowed for succeeding to generate the prime number -
+        Args:
+            k: length of bit of the prime number to generate
+            t: repeat parameter of the Fermat Test
+            max_iter: maximum possible iterations allowed for succeeding to generate the prime number -
             default max_iter = 10000 to have a high probability of successfully generating the prime number
              for k <= 2000 bits
-        :return: KBitPrimeResponse(status: bool, base_10: int, base_2: list)
+        Returns:
+            KBitPrimeResponse(status: bool, base_10: int, base_2: list)
+        Raises:
+            Raises PrimeNumberNotFound if the k-bt prime number is not fond
         """
         i = 0
         while i < max_iter:
@@ -57,4 +62,4 @@ def k_bit_prim_number(cls, k, t=100, max_iter=10000):
             if response:
                 return KBitPrimeResponse(base_10=base_10_n, base_2=k_bit_n)
             i += 1
-        return PrimeNumberNotFound
+        raise PrimeNumberNotFound

src/crypto_VDF/utils/utils.py

@@ -61,9 +61,12 @@ def base_to_10(numb: [int], base: int) -> int:
     """
     Convert number from base "base" to base 10 integer
 
-    :param numb: number in big number form in base "base" in [a_k,a_{k-1},..a_1,a_0] form
-    :param base: base in which "numb" is written
-    :return: integer corresponding to the base 10 of "numb"
+    Args:
+        numb: number in big number form in base "base" in [a_k,a_{k-1},..a_1,a_0] form
+        base: base in which "numb" is written
+
+    Returns:
+        Integer corresponding to the base 10 of "numb"
     """
     base_10 = 0
     for i in range(len(numb)):