Merge branch 'develop'

Author: Leovalcante

random_password_generator/rpg.py

@@ -3,6 +3,7 @@
 import random
 import secrets
 import string
+from typing import Optional
 
 import click
 import requests
@@ -18,6 +19,9 @@
 128+ bits\t= Very Strong; often overkill"""
 
 _available_charsets = {"l", "u", "d", "p"}
+_max_pass_length = 50
+_min_pass_length = 12
+_max_pass_number = 50
 
 
 @click.command(context_settings={'help_option_names': ['-h', '--help']})
@@ -44,15 +48,15 @@ def rpg(pass_length: int, number: int, output: click.File, exclude_charsets: str
     :return: None
     """
     # Check pass_length validity
-    msg.Prints.verbose("Checking <pass-length> ({}) validity".format(pass_length), verbose)
-    if pass_length > 90 or pass_length < 12:
+    msg.Prints.verbose(f"Checking <pass-length> ({pass_length}) validity", verbose)
+    if pass_length > _max_pass_length or pass_length < _min_pass_length:
         raise click.BadArgumentUsage(
-            msg.Echoes.error("Invalid value for \"<pass-length>\": {} is not in the valid range of 12 to 90.")
-            .format(pass_length))
+            msg.Echoes.error(
+                f"Invalid value for \"<pass-length>\": {pass_length} is not in the valid range of 12 to 90."))
 
     # Check number validity
-    msg.Prints.verbose("Checking <pass-number> ({}) validity".format(number), verbose)
-    if number > 50:
+    msg.Prints.verbose(f"Checking <pass-number> ({number}) validity", verbose)
+    if number > _max_pass_number:
         raise click.BadOptionUsage("number", msg.Echoes.error(
             "Invalid value for \"<pass-number>\": the maximum value accepted is 50."))
 
@@ -66,7 +70,7 @@ def rpg(pass_length: int, number: int, output: click.File, exclude_charsets: str
         raise click.BadOptionUsage("--exclude-charsets",
                                    msg.Echoes.error("RPG needs at least one charsets type to generate password."))
     else:
-        if not len(chars) == 4:
+        if not len(chars) == len(string.ascii_lowercase + string.ascii_uppercase + string.digits + string.punctuation):
             # User chose to not use any charsets, print warning message
             msg.Prints.warning("You are going to generate passwords without one or more of default charsets!")
             msg.Prints.warning(
@@ -99,20 +103,20 @@ def rpg(pass_length: int, number: int, output: click.File, exclude_charsets: str
 
     for pw in pw_list:
         if output:
-            output.write("{}\n".format(pw))
+            output.write(f"{pw}\n")
         else:
             msg.Prints.info(pw)
 
     # Calculate entropy and print it
     entropy = _get_entropy(pass_length, chars)
     if output:
-        output.write("\nEntropy: {}".format(entropy))
+        output.write(f"\nEntropy: {entropy}")
     else:
-        msg.Prints.emphasis("\nThe entropy of generated password is: {}".format(entropy))
+        msg.Prints.emphasis(f"\nThe entropy of generated password is: {entropy}")
 
     # Print summary table, only if --verbose or --output
     if output:
-        output.write("\n{}".format(_password_entropy_table))
+        output.write(f"\n{_password_entropy_table}")
     else:
         msg.Prints.verbose(_password_entropy_table, verbose)
 
@@ -124,7 +128,7 @@ def _get_char_list(charsets_to_exclude: str = None) -> list:
     :param str charsets_to_exclude: charsets to exclude
     :return list: available charsets list
     """
-    chars = []
+    chars = ""
 
     charsets = {}
     if charsets_to_exclude is not None:
@@ -134,21 +138,21 @@ def _get_char_list(charsets_to_exclude: str = None) -> list:
     # If charsets is empty, take all charsets
     if not bool(charsets):
         if charsets_to_exclude is not None:
-            return chars
+            return list(chars)
         else:
             charsets = _available_charsets
 
     for cset in charsets:
         if cset == "l":
-            chars.append(string.ascii_lowercase)
+            chars += string.ascii_lowercase
         elif cset == "u":
-            chars.append(string.ascii_uppercase)
+            chars += string.ascii_uppercase
         elif cset == "d":
-            chars.append(string.digits)
+            chars += string.digits
         elif cset == "p":
-            chars.append(string.punctuation)
+            chars += string.punctuation
 
-    return chars
+    return list(chars)
 
 
 def _sanitize_excluded_charsets(charsets_to_sanitize: str) -> set:
@@ -163,7 +167,7 @@ def _sanitize_excluded_charsets(charsets_to_sanitize: str) -> set:
     return set_to_sanitize & _available_charsets
 
 
-def _generate_random_password(length: int, charsets: list, no_safe: bool = False):
+def _generate_random_password(length: int, charsets: list, no_safe: bool = False) -> Optional[str]:
     """
     Generate random password.
 
@@ -173,27 +177,26 @@ def _generate_random_password(length: int, charsets: list, no_safe: bool = False
     :return: str random password | None
     """
     pw = []
-    chars = len(charsets)
 
     # Shuffle chars to change every password generation
     random.shuffle(charsets)
 
     for i in range(length):
         # Append random char into generated password
-        pw.append(secrets.choice(charsets[i % chars]))
+        pw.append(secrets.choice(charsets))
 
     random.shuffle(pw)
-    pw = "".join(pw)
+    pw_str = "".join(pw)
 
     # Check if generated password is in a password leak
     if not no_safe:
-        leaks = _is_leaked_password(pw)
+        leaks = _is_leaked_password(pw_str)
         if leaks == 1:
-            _generate_random_password(length, charsets)
+            return _generate_random_password(length, charsets)
         elif leaks == 9:
             return None
 
-    return pw
+    return pw_str
 
 
 def _is_leaked_password(pw: str) -> int: