refactor: Avoid pass-through design by manipulating the data directly in pw_command.py (and not in pw_json_client.py)

Author: davidkuda

src/pw/pw_cli.py

@@ -5,7 +5,7 @@
 import pyperclip
 
 from .pw_json_client import SecretsDataJSONClient
-from .pw_utils import generate_random_password
+from .pw_utils import generate_random_password, find_key
 from crypto.pw_encryption import SynchronousEncryption
 
 
@@ -18,27 +18,40 @@ def __init__(self, pw_client: SecretsDataJSONClient,
         self.args = args
 
     def get_all_sections(self) -> List[str]:
-        return self.pw_client.get_sections()
+        """Get all sections of the secrets data file (json)."""
+        return [pw for pw in self.pw_client.pw_dict.keys()]
+        # yield from self.pw_dict.keys()
 
     def print_keys_of_section(self):
+        """Output all available keys of a section to the console."""
         if self.args.section is None:
             self.args.section = 'main'
-        self.pw_client.print_keys_of_section(self.args.section)
+        for key in self.pw_client.pw_dict[self.args.section].keys():
+            print(key)
 
     def create_section(self):
-        return self.pw_client.create_section(self.args.section)
+        """Creates a new section."""
+        
+        if self._check_existence_of_section(self.args.section):
+            return print(f'Section {self.args.section} exists already.')
+
+        self.pw_client.pw_dict[self.args.section] = {}
+        self.pw_client.save_dict_to_file()
+        print(f'Created a new section: "{self.args.section}".')
+    
+    def _check_existence_of_section(self, section: str):
+        if section in self.pw_client.pw_dict:
+            return True
 
     def add_new_secrets_data(self):
-        args = self.args
-
         secrets_data = {}
 
-        if args.set_password:
-            new_password = args.set_password
+        if self.args.set_password:
+            new_password = self.args.set_password
         else:
             new_password = generate_random_password(
-                password_length=args.random_password_length,
-                special_characters=args.no_special_characters)
+                password_length=self.args.random_password_length,
+                special_characters=self.args.no_special_characters)
         pyperclip.copy(new_password)
         encrypted_password = self.crypto.encrypt(new_password)
         secrets_data['password'] = encrypted_password
@@ -63,39 +76,65 @@ def add_new_secrets_data(self):
                 encrypted_value = self.crypto.encrypt(value)
                 secrets_data[key] = encrypted_value
 
-        self.pw_client.add_new_secrets_data(entity=args.new_secrets_data,
-                                     secrets_data=secrets_data,
-                                     section=args.section,
-                                     overwrite=args.overwrite)
+        if self.args.section is None:
+            self.args.section = 'main'
+
+        if not self._check_existence_of_section(self.args.section):
+            self.create_section()
+
+        if (
+            self.args.entity in self.pw_client.pw_dict[self.args.section]
+            and self.args.overwrite is False
+        ):
+            print('Entity is already there. Nothing happened.')
+            print('Use the -ow / --overwrite option to update existing secrets data.')
+            return False
 
+        entity = self.args.new_secrets_data
+        new_secrets_data = {entity: secrets_data}
+
+        print(f'Created new password for "{entity}".')
+        print('')
+
+        self.pw_client.pw_dict[self.args.section].update(new_secrets_data)
+        self.pw_client.save_dict_to_file()
         return True
 
     def update_secrets_data(self):
-        """`pw -u <key>=<value> <entity>`"""
+        """`pw -u <key>=<value> (-s <section>="main") <entity>`"""
         k, v = self.args.update.split('=')
         new_data = {k: self.crypto.encrypt(v)}
-        self.pw_client.update_secrets_data(
-            entity=self.args.entity,
-            section=self.args.section,
-            new_data=new_data)
+        
+        if self.args.section is None:
+            self.args.section = 'main'
+              
+        self.pw_client.pw_dict[self.args.section][self.args.entity].update(new_data)
+        self.pw_client.save_dict_to_file()
 
     def get_secrets_data(self):
-        secrets_data = self.pw_client.get_secrets_data(
-            entity=self.args.entity,
-            section=self.args.section)
+        if self.args.section is None:
+            self.args.section = 'main'
+        secrets_data = self.pw_client.pw_dict[self.args.section][self.args.entity]
         return secrets_data
 
     def remove_secrets_data(self):
         key = self.args.remove_entity
-        self.pw_client.remove_secrets_data(key, self.args.section)
+        section = self.args.section or 'main'
+        self.pw_client.pw_dict[section].pop(key)
+        self.pw_client.save_dict_to_file()
+        print(f'Deleted {key} from {section}')
+        print('')
         return True
 
     def remove_section(self):
-        self.pw_client.remove_section(self.args.remove_section)
+        section = self.args.remove_section
+        self.pw_client.pw_dict.pop(section)
+        self.pw_client.save_dict_to_file()
+        print(f'Removed Section: "{section}"')
         return True
 
     def find_secrets_data(self):
-        results_as_generator = self.pw_client.find_key(self.args.find)
+        results_as_generator = find_key(self.args.find, self.pw_client.pw_dict)
         results = list(results_as_generator)
         for result in results:
             print(f'Found "{result["entity"]}" in section "{result["section"]}".')

src/pw/pw_json_client.py

@@ -1,95 +1,18 @@
 import json
 import datetime
-from typing import List
-
-from pw.pw_utils import get_pws_from_json_file
 
 
 class SecretsDataJSONClient:
     def __init__(self, creds_dir: str, creds_file_path: str):
         self.creds_dir = creds_dir
         self.creds_file_path = creds_file_path
-        self.pw_dict = get_pws_from_json_file(creds_file_path)
-
-    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".
-            section (str, optional):
-              Defaults to "main". Adjust if you want to access data from an
-              other section.
-        """
-        if section is None:
-            section = 'main'
-        secrets_data = self.pw_dict[section][entity]
-        return secrets_data
-
-    def remove_secrets_data(self, key: str, section: str = None):
-        """Removes a password from the creds.json file."""
-        section = section or 'main'
-        self.pw_dict[section].pop(key)
-        self.save_dict_to_file()
-        print(f'Deleted {key} from {section}')
-        print('')
-
-    def find_key(self, search_term: str) -> List[dict]:
-        """Iterate over all secrets and yield a secret's name that matches the search_term."""
-        for section, secrets in self.pw_dict.items():
-            for secret in secrets:
-                if search_term.lower() in secret.lower():
-                    yield {'entity': secret,
-                           'section': section}
-
-    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"
-            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.pw_dict = self.get_pws_from_json_file()
         self.create_backup()
 
-        if section is None:
-            section = 'main'
-
-        if not self.check_existence_of_section(section):
-            self.create_section(section)
-
-        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
-
-        new_secrets_data = {entity: secrets_data}
-
-        print(f'Created new password for "{entity}".')
-        print('')
-
-        self.pw_dict[section].update(new_secrets_data)
-        self.save_dict_to_file()
-        return True
-
-    def update_secrets_data(self, entity:str, section: str, new_data: dict):
-        self.pw_dict[section][entity].update(new_data)
-        self.save_dict_to_file()
+    def get_pws_from_json_file(self):
+        """Loads json data into python to retrieve passwords that are stored as key value pairs."""
+        with open(self.creds_file_path) as pws:
+            return json.load(pws)
 
     def create_backup(self):
         """Create a backup of the dictionary with the passwords."""
@@ -101,35 +24,3 @@ def create_backup(self):
     def save_dict_to_file(self):
         with open(self.creds_file_path, 'w') as pw_file_json:
             json.dump(self.pw_dict, pw_file_json)
-
-    def create_section(self, section_name: str) -> None:
-        """Creates a new section."""
-        if self.check_existence_of_section(section_name):
-            return print(f'Section {section_name} exists already.')
-        self.pw_dict[section_name] = {}
-        self.save_dict_to_file()
-        print(f'Created a new section: "{section_name}".')
-
-    def get_sections(self) -> List[str]:
-        """Get all sections of the secrets data file (json)."""
-        return [pw for pw in self.pw_dict.keys()]
-        # yield from self.pw_dict.keys()
-
-    def print_keys_of_section(self, section_name: str = None):
-        """Output all available keys of a section to the console."""
-        for key in self.pw_dict[section_name].keys():
-            print(key)
-
-    def check_existence_of_section(self, section: str):
-        if section in self.pw_dict:
-            return True
-
-    def remove_section(self, section):
-        self.pw_dict.pop(section)
-        self.save_dict_to_file()
-        print(f'Removed Section: "{section}"')
-
-    def open_pw_file(pw_file_path, app: str = 'Sublime'):
-        """Open pw file with an app (default: Sublime)."""
-        raise NotImplementedError
-

src/pw/pw_utils.py

@@ -1,6 +1,7 @@
 import json
 import random
 import string
+from typing import Generator
 
 
 class HelpTexts:
@@ -32,16 +33,18 @@ def generate_random_password(special_characters=True,
         characters = digits + letters + punctuation
         random_password = ''.join(random.choice(characters) for i in range(password_length))
         return random_password
-
-
-def get_pws_from_json_file(file_path):
-    """Loads json data into python to retrieve passwords that are stored as key value pairs."""
-    with open(file_path) as pws:
-        return json.load(pws)
-
+    
 
 def my_exchandler(type, value, traceback):
     """Set 'sys.excepthook' to myexchandler to avoid traceback.
      Credits: https://stackoverflow.com/questions/38598740/raising-errors-without-traceback
     """
     print(value)
+
+
+def find_key(key: str, dictionary: dict) -> Generator[dict, None, None]:
+    """Iterate a dict recursively and yield all values if key matches."""
+    for section, secrets in dictionary:
+        for secret in secrets:
+            if key.lower() in secret.lower():
+                yield {'entity': secret, 'section': section}