cpass-cli 1.0.0__py3-none-any.whl

cpass/main.py

@@ -0,0 +1,406 @@
+import argparse
+import re
+import os
+import random
+import string
+from MorseCodePy import encode, decode
+from prettytable import PrettyTable
+
+def ischaotic(text: str) -> bool:
+    """Determine if a string is chaotic case.
+
+    Args:
+        text (str): Your string.
+    
+    Returns:
+        bool: Return True if the string is chaotic case. False if not.
+    """
+    return not (text.islower() or text.isupper() or text.istitle())
+
+def isspecial(text: str) -> bool:
+    """Determine if the text contains specials character only.
+
+    Args:
+        text (str): The text.
+    
+    Returns:
+        bool: Return True if the text contains only specials character. False if not.
+    """
+    specials = string.punctuation + string.whitespace
+    return all(c in specials for c in text)
+
+def is_not_supported(text: str) -> str:
+    """Determine if a special character is supported for encoding or not.
+    
+    Args:
+        text (str): The text.
+
+    Returns:
+        str: Returns all unsupported specials characters.
+    """
+    specials_not_supported: list[str] = ["#", "[", "]", "{", "}", "<", ">", "|", "*", "µ", "£", "^", "~", "°", "`", "§", "%"]
+    return ', '.join([f'"{char}"' for char in text if char in specials_not_supported])
+
+def transform_string(text: str, fingerprint: str) -> str:
+    """Transform letters in uppercase or lowercase according to the fingerprint.
+    
+    Args:
+        text (str): Original string.
+        fingerprint (str): Fingerprint of the original string.
+    
+    Returns:
+        str: Return the tranformed string.
+    """
+    transformed_string: list[str] = []
+    for index, letter in enumerate(text):
+        if fingerprint[index] == '1':
+            transformed_string.append(letter.lower())
+        elif fingerprint[index] == '2':
+            transformed_string.append(letter.upper())
+        else:
+            transformed_string.append(letter)
+    return ''.join(transformed_string)
+
+def fingerprint(text: str) -> str:
+    """Create a fingerprint to determine which letter is uppercase ou lowercase.
+
+    Args:
+        text (str): Your text.
+    
+    Returns:
+        str: Returns the fingerprint of the text.
+    """
+    counter: list[str] = []
+    for char in text:
+        if char.islower():
+            counter.append('1')
+        elif char.isupper():
+            counter.append('2')
+        else:
+            counter.append(str(random.randint(3, 9)))
+    return ''.join(counter)
+
+def detect_file_or_text(input: str) -> str:
+    """Detect if the input is a text or a file path.
+    
+    Args:
+        input (str): The input
+    
+    Returns:
+        str: Return the content of the input/file.
+    """
+    if os.path.isfile(input):
+        with open(input) as f:
+            return f.read()
+    return input
+
+def format_words(text: str) -> list[str]:
+    """Format textual words to a list.
+
+    Args:
+        text (str): Your textual words.
+    
+    Returns:
+        list[str]: Return a list of formatted words.
+    """
+    words: list[str] = text.splitlines()
+    return [re.sub(r"^\d+\.", "", word).strip() for word in words]
+
+def show_encoded_secret_words(text: str, language: str, dot: str, dash: str, hidden: bool) -> None:
+    """Show your original and encoded words in a table.
+    
+    Args:
+        text (str): Your textual words.
+        language (str): Language of your words.
+        dot (str): Character representing the dot.
+        dash (str): Character representing the dash.
+        hidden (bool): Display or not your original words.
+    """
+    table = PrettyTable()
+    table.align = 'l'
+    formatted_words: list[str] = format_words(text)
+    table.field_names = ["Original words", "Encoded words"]
+    for index, word in enumerate(formatted_words):
+        encoded_word: str = encode(word, language=language, dot=dot, dash=dash)
+        table.add_row([f"{index+1}. {"******" if hidden else word}", f"{index+1}. {encoded_word}"])
+    
+    print(table)
+
+def show_decoded_secret_words(text: str, language: str, dot: str, dash: str, hidden: bool) -> None:
+    """Show your encoded and decoded words in a table.
+    
+    Args:
+        text (str): Your encoded words.
+        language (str): Language of your (decoded) words.
+        dot (str): Character representing the dot.
+        dash (str): Character representing the dash.
+        hidden (bool): Display or not your decoded words.
+    """
+    table = PrettyTable()
+    table.align = 'l'
+    formatted_words: list[str] = format_words(text)
+    table.field_names = ["Encoded words", "Decoded words"]
+    for index, word in enumerate(formatted_words):
+        decoded_word: str = decode(word, language=language, dot=dot, dash=dash)
+        table.add_row([f"{index+1}. {word}", f"{index+1}. {"******" if hidden else decoded_word}"])
+    
+    print(table)
+
+def encode_secret_words(text: str, language: str, dot: str, dash: str, output: str) -> None:
+    """Encode your words and store the value in a txt file.
+
+    Args:
+        text (str): Your textual words.
+        language (str): Language of your words.
+        dot (str): Character representing the dot.
+        dash (str): Character representing the dash.
+        output (str): Path of the output file.
+    """
+    formatted_words: list[str] = format_words(text)
+    encoded_words: list[str] = [f"{index+1}. {encode(word, language=language, dot=dot, dash=dash)}" for index, word in enumerate(formatted_words)]
+    with open(output, 'w') as f:
+        f.write("\n".join(encoded_words))
+        print("Your encoded secret words have been successfully saved in:", output)
+
+def decode_secret_words(text: str, language: str, dot: str, dash: str, output: str) -> None:
+    """Decode your words and store the value in a txt file.
+
+    Args:
+        text (str): Your encoded words.
+        language (str): Language of your (decoded) words.
+        dot (str): Character representing the dot.
+        dash (str): Character representing the dash.
+        output (str): Path of the output file.
+    """
+    formatted_words: list[str] = format_words(text)
+    decoded_words: list[str] = [f"{index+1}. {decode(word, language=language, dot=dot, dash=dash)}" for index, word in enumerate(formatted_words)]
+    with open(output, 'w') as f:
+        f.write("\n".join(decoded_words))
+        print("Your decoded secret words have been successfully saved in:", output)
+
+def main():
+    """Main program"""
+    parser = argparse.ArgumentParser(
+        prog="cPass",
+        description="Encode/Decode your passwords with Morse code."
+    )
+
+    parser.add_argument('-v', '--version',
+        action='version',
+        version='%(prog)s v1.0.0',
+        help="Version of the %(prog)s program.")
+
+    subparser = parser.add_subparsers(dest='subcommand')
+
+    ### ENCODE subcommand
+    encode_subcommand = subparser.add_parser("encode", help="Encode your passphrase/password/file")
+    encode_subcommand.add_argument('input', type=str, help="Your passphrase/password/file path to encode")
+    encode_subcommand.add_argument('-L', '--language',
+        type=str,
+        choices=['english', 'french', 'spanish', 'russian', 'ukrainian', 'numbers', 'special'],
+        default="english",
+        help="Language of your passphrase/password (default: english)")
+    encode_subcommand.add_argument('-d', '--dot',
+        type=str,
+        default='.',
+        help="Character representing the dot (default: '.')")
+    encode_subcommand.add_argument('-D', '--dash',
+        type=str,
+        default='-',
+        help="Character representing the dash (default: '-')")
+    encode_subcommand.add_argument('-s', '--separator',
+        type=str,
+        default='/',
+        help="Character representing the words spacing (default: '/')")
+    encode_subcommand.add_argument('-o', '--output',
+        type=str,
+        help="Path to store the encoded passphrase/password/file")
+    encode_subcommand.add_argument('--markup',
+        action='store_true',
+        help="Show the original character in brackets before its Morse code")
+
+    ### DECODE subcommand
+    decode_subcommand = subparser.add_parser("decode", help="Decode your passphrase/password/file")
+    decode_subcommand.add_argument('input', type=str, help="Your passphrase/password/file path to decode")
+    decode_subcommand.add_argument('-L', '--language',
+        type=str,
+        choices=['english', 'french', 'spanish', 'russian', 'ukrainian', 'numbers', 'special'],
+        default="english",
+        help="Language of your passphrase/password (default: english)")
+    decode_subcommand.add_argument('-d', '--dot',
+        type=str,
+        default='.',
+        help="Character representing the dot (default: '.')")
+    decode_subcommand.add_argument('-D', '--dash',
+        type=str,
+        default='-',
+        help="Character representing the dash (default: '-')")
+    decode_subcommand.add_argument('-s', '--separator',
+        type=str,
+        default='/',
+        help="Character representing the words spacing (default: '/')")
+    decode_subcommand.add_argument('-o', '--output',
+        type=str,
+        help="Path to store the decoded passphrase/password/file")
+    decode_subcommand.add_argument('--markup',
+        action='store_true',
+        help="Show the original Morse code sequence in brackets before the decoded character")
+
+    decode_subcommand_group = decode_subcommand.add_mutually_exclusive_group()
+    decode_subcommand_group.add_argument('-u', '--upper-case',
+        action='store_true',
+        help="Show your passphrase in UPPERCASE")
+    decode_subcommand_group.add_argument('-t', '--title-case',
+        action='store_true',
+        help="Show your passphrase in Title Case")
+    decode_subcommand_group.add_argument('-f', '--fingerprint',
+        type=str,
+        help="Determine which letter is uppercase or lowercase. The length of the fingerprint must match with the length of your (decoded) passphrase")
+
+    ### ENCRYPTO subcommand
+    encrypto_subcommand = subparser.add_parser('encrypto', help="Encode your secret words")
+    encrypto_subcommand.add_argument('input',
+        type=str,
+        help="Your file path of your secret words to encode")
+    encrypto_subcommand.add_argument('-L', '--language',
+        type=str,
+        choices=['english', 'french', 'spanish', 'russian', 'ukrainian', 'numbers', 'special'],
+        default="english",
+        help="Language of your secret words (default: english)")
+    encrypto_subcommand.add_argument('-d', '--dot',
+        type=str,
+        default='.',
+        help="Character representing the dot (default: '.')")
+    encrypto_subcommand.add_argument('-D', '--dash',
+        type=str,
+        default='-',
+        help="Character representing the dash (default: '-')")
+    encrypto_subcommand.add_argument('-o', '--output',
+        type=str,
+        help="Path to store your encoded secret words")
+    encrypto_subcommand.add_argument('--hidden',
+        action="store_true",
+        help="Hide your original secret words")
+    
+    ### DECRYPTO subcommand
+    decrypto_subcommand = subparser.add_parser('decrypto', help="Decode your secret words")
+    decrypto_subcommand.add_argument('input',
+        type=str,
+        help="Your file path of your encoded secret words to decode")
+    decrypto_subcommand.add_argument('-L', '--language',
+        type=str,
+        choices=['english', 'french', 'spanish', 'russian', 'ukrainian', 'numbers', 'special'],
+        default="english",
+        help="Language of your secret words (default: english)")
+    decrypto_subcommand.add_argument('-d', '--dot',
+        type=str,
+        default='.',
+        help="Character representing the dot (default: '.')")
+    decrypto_subcommand.add_argument('-D', '--dash',
+        type=str,
+        default='-',
+        help="Character representing the dash (default: '-')")
+    decrypto_subcommand.add_argument('-o', '--output',
+        type=str,
+        help="Path to store your decoded secret words")
+    decrypto_subcommand.add_argument('--hidden',
+        action="store_true",
+        help="Hide your decoded secret words")
+
+    args = parser.parse_args()
+
+    if args.subcommand:
+        if args.input:
+            pp = detect_file_or_text(args.input)
+        else:
+            print("Error: The input argument cannot be empty.")
+            exit()
+        
+        if args.subcommand == 'encode':
+            if is_not_supported(pp):
+                print(f"These specials characters aren't supported: {is_not_supported(pp)}")
+                exit()
+
+            pp = " ".join(pp.splitlines())
+
+            encoded_string: str = encode(pp,
+                language=args.language,
+                dash=args.dash,
+                dot=args.dot,
+                separator=args.separator,
+                markup=args.markup)
+            if args.output:
+                with open(args.output, 'w') as f:
+                    f.write(encoded_string)
+                    print(f"Your encoded password is stored in \"{args.output}\".")
+                    if ischaotic(pp) and not (pp.isdigit() or isspecial(pp)):
+                        print(f"Fingerprint: {fingerprint(pp)}")
+            else:
+                print(encoded_string)
+                if ischaotic(pp) and not (pp.isdigit() or isspecial(pp)):
+                    print(f"Fingerprint: {fingerprint(pp)}")
+        elif args.subcommand == 'decode':
+            pp = " ".join(pp.splitlines())
+            decoded_string: str = decode(pp,
+                language=args.language,
+                dot=args.dot,
+                dash=args.dash,
+                separator=args.separator,
+                markup=args.markup)
+            if args.output:
+                with open(args.output, 'w') as f:
+                    if args.upper_case:
+                        f.write(decoded_string.upper())
+                    elif args.title_case:
+                        f.write(decoded_string.title())
+                    elif args.fingerprint:
+                        if len(decoded_string) == len(args.fingerprint):
+                            f.write(transform_string(decoded_string, args.fingerprint))
+                        else:
+                            print(f"Error with fingerprint: {args.fingerprint}")
+                            exit()
+                    else:
+                        f.write(decoded_string)
+                    print(f"Your decoded password is stored in \"{args.output}\".")
+            else:
+                if args.upper_case:
+                    print(decoded_string.upper())
+                elif args.title_case:
+                    print(decoded_string.title())
+                elif args.fingerprint:
+                    if len(decoded_string) == len(args.fingerprint):
+                        print(transform_string(decoded_string, args.fingerprint))
+                    else:
+                        print(f"Error with fingerprint: {args.fingerprint}")
+                else:
+                    print(decoded_string)
+        elif args.subcommand == 'encrypto':
+            if args.output:
+                encode_secret_words(pp,
+                    language=args.language,
+                    dot=args.dot,
+                    dash=args.dash,
+                    output=args.output)
+            else:
+                show_encoded_secret_words(pp,
+                    language=args.language,
+                    dot=args.dot,
+                    dash=args.dash,
+                    hidden=args.hidden)
+        elif args.subcommand == 'decrypto':
+            if args.output:
+                decode_secret_words(pp,
+                    language=args.language,
+                    dot=args.dot,
+                    dash=args.dash,
+                    output=args.output)
+            else:
+                show_decoded_secret_words(pp,
+                    language=args.language,
+                    dot=args.dot,
+                    dash=args.dash,
+                    hidden=args.hidden)
+
+if __name__ == "__main__":
+    main()
+