release 0.2: Decouple crypto from client, change cli args, return objects instead of single secret.

Author: davidkuda

src/pw_client.py

@@ -9,7 +9,6 @@
 
 import pw_utils
 from pw_encryption import SynchronousEncryption
-from pw_config import ENCRYPTION_KEY
 
 
 class PasswordClient:
@@ -18,27 +17,23 @@ def __init__(self, creds_dir: str, creds_file_path: str):
         self.creds_file_path = creds_file_path
         self.pw_dict = pw_utils.get_pws_from_json_file(creds_file_path)
         # TODO: Move crypto to the command
-        self.crypto = SynchronousEncryption(ENCRYPTION_KEY)
 
-    def get_pw(self, entity: str, attribute: str = None, section: str = None) -> dict:
-        """Get data from self.pw_dict, copy to clipboard and print to console.
+    def get_secrets_data(self, entity: str, section: str = None) -> dict:
+        """Return secrets data from self.pw_dict.
 
         Args:
-            entity (str): The name of the holder of the password, e.g. "GitHub".
-            attribute (str, optional):
-              Defaults to "password". Adjust if you want to retrieve "username"
-              or "website".
+            entity (str):
+                The name of the holder of the password, e.g. "GitHub".
             section (str, optional):
               Defaults to "main". Adjust if you want to access data from an
               other section.
         """
-        if attribute is None:
-            attribute = 'password'
         if section is None:
             section = 'main'
-        pw_data = self.pw_dict[section][entity]
-        return pw_data
+        secrets_data = self.pw_dict[section][entity]
+        return secrets_data
 
+    # TODO: Move generate random pw to utils
     @staticmethod
     def generate_random_password(special_characters=True,
                                  password_length: int = 42) -> str:
@@ -50,24 +45,28 @@ def generate_random_password(special_characters=True,
         random_password = ''.join(random.choice(characters) for i in range(password_length))
         return random_password
 
-    def add_new_pw(self, entity: str, password: str = None, username: str = None,
-                   website: str = None, section: 'str' = None,
-                   encryption: bool = True) -> None:
-        """Adds a new password to the password file.
+    def add_new_secrets_data(self, entity: str, secrets_data: dict,
+                             section: 'str' = None, overwrite: bool = False) -> bool:
+        """Adds new secrets data to the password file.
 
         If the a password already exists in the creds.json file, this method will update it.
 
         Args:
             entity (str): The entity that you need the password for, e.g. "GitHub"
-            password (str, optional): If you want, you can specify a password. If you leave it,
-              it will generate a random password with 42 characters.
-            username (str, optional): Pass a user name if you want to add it to the json file.
-            website (str, optional): Pass a website if you want to add it to the json file.
-            section (str, optional): You may set the section of the json file to which this
-              password will be added to. Defaults to the section "main".
-            encryption (bool, defaults to True):
-              If true this function will decrypt the password before saving it. The function
-              will save the password without encryption if this arg is set to false.
+            secrets_data (dict):
+                A dictionary that you want to store and that holds your
+                secrets. Example:
+                    {'password': 'p4ssw0rd',
+                    'website': 'https://kuda.ai',
+                    'user_name': 'DataDave'}
+            section (str, optional):
+                You may set the section of the json file to which this
+                password will be added to. Defaults to the section "main".
+            overwrite (bool, optional):
+                If set to True, an existing password will be overwritten.
+
+        Returns:
+            bool: True for writing new data, False if no action.
         """
         self.create_backup()
 
@@ -77,23 +76,19 @@ def add_new_pw(self, entity: str, password: str = None, username: str = None,
         if not self.check_existence_of_section(section):
             self.create_section(section)
 
-        if password is None:
-            password = self.generate_random_password()
-        pyperclip.copy(password)
+        if entity in self.pw_dict[section] and overwrite is False:
+            print('Entity is already there. Nothing happened.')
+            print('Use the -ow / --overwrite option to update existing secrets data.')
+            return False
 
-        if encryption:
-            password = self.crypto.encrypt(password)
-
-        new_password = {entity: {}}
-        new_password[entity]['password'] = password
-        new_password[entity]['username'] = username if username else 'not specified'
-        new_password[entity]['website'] = website if website else 'not specified'
+        new_secrets_data = {entity: secrets_data}
 
         print(f'Created new password for "{entity}".')
         print('')
 
-        self.pw_dict[section].update(new_password)
+        self.pw_dict[section].update(new_secrets_data)
         self.save_dict_to_file()
+        return True
 
     def create_backup(self):
         """Create a backup of the dictionary with the passwords."""
@@ -133,7 +128,7 @@ def remove_section(self, section):
         self.save_dict_to_file()
         print(f'Removed Section: "{section}"')
 
-    def remove_password(self, entity: str, section: str = None) -> None:
+    def remove_entity(self, entity: str, section: str = None) -> None:
         """Removes a password from the creds.json file."""
         section = section or 'main'
         self.pw_dict[section].pop(entity)
@@ -161,13 +156,3 @@ def manipulate_passwords(self, crypto: Callable = None) -> None:
                 manipulated_password = crypto(current_password)
                 v["password"] = manipulated_password
         self.save_dict_to_file()
-
-    def encrypt_single_string(self, text: str) -> str:
-        return self.crypto.encrypt(text)
-
-    def encrypt_all_passwords(self):
-        self.create_backup()
-        self.manipulate_passwords(self.crypto.encrypt)
-
-    def decrypt_all_passwords(self):
-        self.manipulate_passwords(self.crypto.decrypt)

src/pw_command.py

@@ -1,31 +1,14 @@
 #!/opt/homebrew/Caskroom/miniconda/base/bin/python
-"""
-Execute this command to get pw from json into clipboard.
-Type "pw -h" to get help on all available commands.
-Basic usage: "pw <entity>" -> Gets password of entity from main section.
-
-The creds.json file should look like this:
-
-"section": {
-        "entity": {
-            "password": "lorem",
-            "username": "ipsum",
-            "additional_info": "...",
-            "website": "www.kuda.ai"
-        }
-    }
-"""
 import argparse
 
 import pyperclip
 
-from pw_config import CREDS_DIR, CREDS_FILE_PATH
+from pw_config import CREDS_DIR, CREDS_FILE_PATH, ENCRYPTION_KEY
 import pw_client
 from pw_encryption import SynchronousEncryption
-from pw_config import ENCRYPTION_KEY
 
 HELP_TEXT = {
-    'input': 'Name of entity that holds the password.',
+    'entity': 'Name of entity that holds the password.',
     'all_sections': 'Print all available sections.',
     'section':
         '''Pass a section to print all entities of that section.
@@ -45,17 +28,27 @@
 }
 
 
+# TODO: Can I attach a callable / function directly to arg parse so
+# TODO: that I can avoid the exhaustingly long if / else statements below?
 def parse_args():
     parser = argparse.ArgumentParser(description='Manage your passwords from your terminal.')
-    parser.add_argument('input', type=str, help=HELP_TEXT['input'], nargs='?')
+    parser.add_argument('entity', type=str, help=HELP_TEXT['entity'], nargs='?')
+
+    parser.add_argument('-k', '--secret_key', type=str, default='password')
+    parser.add_argument('-ks', '--available_keys', action='store_true')
     parser.add_argument('-as', '--all_sections', action='store_true', help=HELP_TEXT['all_sections'])
     parser.add_argument('-s', '--section', type=str, help=HELP_TEXT['section'])
     parser.add_argument('-r', '--generate_random_pw', action='store_true', help=HELP_TEXT['generate_random_pw'])
-    parser.add_argument('-n', '--add_new_password', type=str, help=HELP_TEXT['add_new_password'])
+    parser.add_argument('-rl', '--random_password_length', type=int, default=42)
+
+    parser.add_argument('-n', '--new_secrets_data', type=str, help=HELP_TEXT['add_new_password'])
+    parser.add_argument('-pw', '--set_password', type=str, help=HELP_TEXT['set_password'])
     parser.add_argument('-u', '--username', type=str)
     parser.add_argument('-w', '--website', type=str)
-    parser.add_argument('-pw', '--set_password', type=str, help=HELP_TEXT['set_password'])
-    parser.add_argument('-rm', '--remove_password', type=str, help=HELP_TEXT['remove'])
+    parser.add_argument('--kwargs', '--keyword_arguments', type=str)
+    parser.add_argument('-ow', '--overwrite', action='store_true')
+
+    parser.add_argument('-rm', '--remove_entity', type=str, help=HELP_TEXT['remove'])
     parser.add_argument('-rms', '--remove_section', type=str, help=HELP_TEXT['remove'])
 
     args = parser.parse_args()
@@ -67,67 +60,88 @@ def main():
     crypto = SynchronousEncryption(ENCRYPTION_KEY)
     pw = pw_client.PasswordClient(CREDS_DIR, CREDS_FILE_PATH)
 
-    # TODO: Get data inside pw_command.py
-    # pw_data = pw.get_pw(???)
-
     if args.all_sections:
         return pw.print_sections()
 
-    if args.add_new_password:
+    if args.new_secrets_data:
+        secrets_data = {}
+
         if args.set_password:
-            encrypted_password = crypto.encrypt(args.set_password)
+            new_password = args.set_password
         else:
-            new_random_password = pw.generate_random_password()
-            encrypted_password = crypto.encrypt(new_random_password)
-        return pw.add_new_pw(entity=args.add_new_password, username=args.username,
-                             website=args.website, section=args.section,
-                             password=encrypted_password)
-
-    if args.username:
-        decrypted_username = pw.get_pw(args.username, 'username', args.section)
-        encrypted_username = crypto.encrypt(decrypted_username)
-        return encrypted_username
-
-    if args.website:
-        return pw.get_pw(args.website, 'website', args.section)
-
-    if args.remove_password:
-        return pw.remove_password(entity=args.remove_password, section=args.section)
+            new_password = pw.generate_random_password(password_length=args.random_password_length)
+        encrypted_password = crypto.encrypt(new_password)
+        secrets_data['password'] = encrypted_password
+
+        if args.username:
+            encrypted_username = crypto.encrypt(args.username)
+            secrets_data['username'] = encrypted_username
+
+        if args.website:
+            encrypted_website = crypto.encrypt(args.website)
+            secrets_data['website'] = encrypted_website
+
+        if args.kwargs:
+            kwargs_as_list = args.kwargs.split(',')
+            for kwarg in kwargs_as_list:
+                if len(kwarg.split('=')) > 2:
+                    print('There is something wrong with your kwargs ...')
+                    print('Desired format:')
+                    print('"pw --kwargs brand=fender,guitar=strat,string_gauge=0.10"')
+                    print('')
+                key, value = kwarg.split('=')
+                encrypted_value = crypto.encrypt(value)
+                secrets_data[key] = encrypted_value
+
+        pw.add_new_secrets_data(entity=args.new_secrets_data,
+                                secrets_data=secrets_data,
+                                section=args.section,
+                                overwrite=args.overwrite)
+
+        return True
+
+    if args.remove_entity:
+        return pw.remove_entity(entity=args.remove_entity, section=args.section)
 
     if args.remove_section:
         return pw.remove_section(args.remove_section)
 
-    if args.section and args.input:
-        encrypted_password = pw.get_pw(entity=args.input, section=args.section)
-        password = crypto.decrypt(encrypted_password)
-        return password
-
+    # TODO: Move logic of "create new section if not exists" to client
     if args.section:
         try:
             return pw.print_keys_of_section(args.section)
         except KeyError:
             return pw.create_section(args.section)
 
+    # TODO: Move function "generate_random_pw" from pw_client to utils
     if args.generate_random_pw:
-        if args.input is not None:
-            random_pw = pw.generate_random_password(password_length=int(args.input))
+        if args.entity is not None:
+            random_pw = pw.generate_random_password(password_length=args.random_password_length)
         else:
-            random_pw = pw.generate_random_password()
+            random_pw = pw.generate_random_password(password_length=args.random_password_length)
         pyperclip.copy(random_pw)
         print('The random password has been copied into your clipboard.')
         print('')
         return random_pw
 
-    if args.input is None:
-        return print('Nothing happened. No flags used. No args passed after pw command.')
+    if args.entity is None:
+        print('Nothing happened. No flags used. No args passed after pw command.')
+        return False
 
-    if args.input:
-        encrypted_password = pw.get_pw(args.input)
-        decrypted_password = crypto.decrypt(encrypted_password)
-        pyperclip.copy(decrypted_password)
-        print(f'Copied {attribute} for "{entity}" into your clipboard.')
+    secrets_data = pw.get_secrets_data(entity=args.entity, section=args.section)
+
+    if args.available_keys:
+        print(f'There are {len(secrets_data.keys())} available keys for {args.entity}:')
+        print(', '.join(secrets_data.keys()))
+        return True
+
+    if args.entity:
+        encrypted_secret_value = secrets_data[args.secret_key]
+        decrypted_secret_value = crypto.decrypt(encrypted_secret_value)
+        pyperclip.copy(decrypted_secret_value)
+        print(f'Copied {args.secret_key} for "{args.entity}" into your clipboard.')
         print('')
-        return encrypted_password
+        return True
 
 
 def decrypt_pw_file():
@@ -145,4 +159,3 @@ def encrypt_pw_file():
 
     # decrypt_pw_file()
     # encrypt_pw_file()
-