master: initial update

Author: litcoderr

.gitignore

@@ -127,3 +127,5 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+.idea
+

README.md

@@ -1,2 +1,6 @@
 # loadit
-Load and save your configuration like a BOSS
+Load and save your configuration like a BOSS !!!
+
+Have you ever experienced parsing code for your configuration being verbose? LoadIt neatly organizes your configuration in one python object and can be saved or imported from json file. Also if you ever need cli argument parsing feature, you are good to go with one line of code. Folks are always welcome to contribute.
+
+## Usage

examples/__init__.py

@@ -0,0 +1,25 @@
+# temporary for test use
+import sys
+sys.path.insert(0, "/Users/litcoderr/project/loadit")
+#####
+"""
+This demonstrates how you can construct a serializable configuration object
+"""
+from loadit import Serializable
+
+
+class MasterConfig(Serializable):
+    def __init__(self):
+        self.loadit_is_awesome = True
+        self.loadit_sub_config = NestedConfig()
+
+
+class NestedConfig(Serializable):
+    def __init__(self):
+        self.loadit_is_legit = True
+        self.loadit_sub_sub_config = NestedNestedConfig()
+
+
+class NestedNestedConfig(Serializable):
+    def __init__(self):
+        self.loadit_can_go_deep = True

examples/export_dict.py

@@ -0,0 +1,14 @@
+"""
+This demo demonstrates export_dict() method that can extract dictionary from any Serializable object recursively.
+
+Usage:
+"""
+from . import MasterConfig
+
+
+if __name__ == "__main__":
+    master_config = MasterConfig()
+    
+    extracted_dict = master_config.export_dict()
+    
+    print(extracted_dict)

examples/export_json.py

@@ -0,0 +1,29 @@
+"""
+This demo demonstrates export_json() method that saves Serializable object to json file.
+'
+Usage:
+"""
+from . import MasterConfig
+
+
+if __name__ == "__main__":
+    import os
+    import json
+
+    # Initialize configuration object
+    master_config = MasterConfig()
+
+    # Set json file path
+    current_file_path = os.path.dirname(os.path.abspath(__file__))
+    file_path = os.path.join(current_file_path, "exported.json")
+    
+    # Export to json
+    succeded = master_config.export_json(path=file_path, ignore_error=True)
+    
+    print('Save status: {succeded}'.format(succeded=succeded))
+
+    # Now lets see if json file has been succesfully saved.
+    with open(file_path, 'r') as file:
+        data = json.load(file)
+    print(data)
+

examples/exported.json

@@ -0,0 +1 @@
+{"loadit_is_awesome": true, "loadit_sub_config": {"loadit_is_legit": true, "loadit_sub_sub_config": {"loadit_can_go_deep": true}}}

examples/import_json.py

@@ -0,0 +1,25 @@
+"""
+This demo demonstrates import_json() method that imports data from json file and loads recursively.
+
+Usage:
+"""
+from . import MasterConfig
+
+
+if __name__ == "__main__":
+    import os
+    import json
+
+    # Set json file path
+    current_file_path = os.path.dirname(os.path.abspath(__file__))
+    file_path = os.path.join(current_file_path, "exported.json")
+    
+    # Import from json
+    succeded, master_config= MasterConfig.import_json(path=file_path, ignore_error=True)
+
+    if succeded:
+        print('succeded...')
+        print(master_config.export_dict())
+    else:
+        print('failed to import json')
+

examples/parse.py

@@ -0,0 +1,20 @@
+"""
+This demo demonstrates parse() method that implements argument parsing fucntionality based on object elements.
+
+Usage:
+"""
+
+from . import MasterConfig
+
+
+if __name__ == "__main__":
+    master_config = MasterConfig()
+    print('before parsing:')
+    print(master_config.export_dict())
+    
+    # parse
+    master_config.parse()
+    
+    print('after parseing:')
+    print(master_config.export_dict())
+

loadit/__init__.py

@@ -0,0 +1,4 @@
+# Copyright @Litcoderr. github: https://github.com/litcoderr
+
+from .interface import Serializable
+

loadit/interface.py

@@ -0,0 +1,136 @@
+from typing import Tuple, Dict, Any, Optional, List
+import sys
+import json
+import argparse
+
+DELIM = "__"
+
+
+class Serializable:
+    def __init__(self):
+        pass
+
+    # Export Methods
+    def export_dict(self) -> Dict[str, Any]:
+        """export dictionary recursively
+        
+        Returns:
+            Dictionary that consists child arguments recursively.
+        """
+        # Get current item in dictionary
+        parent_dict = self.__dict__.copy()
+
+        # Build child dictionary recursively
+        for key, obj in parent_dict.items():
+            if isinstance(obj, Serializable):
+                parent_dict[key] = obj.export_dict()
+
+        return parent_dict
+
+    def export_json(self, path: str, ignore_error=True) -> bool:
+        """
+
+        Args:
+            path: path of json file to be saved.
+
+        Returns:
+            succeed saving json file or not.
+        """
+        succeed = True
+        try:
+            # extract dictionary
+            extracted_dict = self.export_dict()
+
+            # save as json
+            with open(path, 'w') as file:
+                file.write(json.dumps(extracted_dict, ensure_ascii=False))
+        except Exception as e:
+            succeed= False
+            print(e)        
+            if not ignore_error:
+                sys.exit()
+        return succeed
+    
+    # Import Methods
+    def import_dict(self, data: Dict[str, Any]):
+        """Import arguments from dictionary
+        
+        Args:
+            data: dictionary that consists child argument recursively.
+        """
+        for key, value in data.items():
+            if hasattr(self, key):
+                if isinstance(getattr(self, key), Serializable):
+                    setattr(self, key, getattr(self, key).import_dict(value))
+                else:
+                    setattr(self, key, value)
+        return self
+    
+    @classmethod
+    def import_json(cls, path: str, ignore_error: bool = True)\
+            -> Tuple[bool, Optional['Serializable']]:
+        try:
+            with open(path, 'r') as file:
+                data = json.load(file)
+            return True, cls().import_dict(data)
+        except Exception as e:
+            print(e)
+            if not ignore_error:
+                sys.exit()
+            return False, None
+    
+    # Parsing related method
+    def parse(self):
+        """Implement argument parsing functionality based on object elements
+        """
+        parser = argparse.ArgumentParser() 
+        for key, value in self.strip_dict().items():
+            parser.add_argument('--{}'.format(key), type=type(value))
+        args = parser.parse_args()
+        print(vars(args))
+        self.unstrip_dict(vars(args))
+
+    # Utility
+    def strip_dict(self, prefix: str = "") -> Dict[str, Any]:
+        """Strips dictionary recursively.
+
+        Args:
+            prefix: prefix string.
+
+        Returns:
+            dictionary with stripped keys.
+        """
+        stripped_dict = {}
+        for key, value in self.__dict__.items():
+            if isinstance(value, Serializable):
+                for k, v in value.strip_dict(prefix=prefix+key+DELIM).items():
+                    stripped_dict[k] = v
+            else:
+                stripped_dict[prefix+key] = value
+        return stripped_dict
+    
+    def unstrip_dict(self, data: Dict[str, Any]):
+        """Unstrip parsed dictionary and save.
+
+        Args:
+            data: stripped dictionary
+        """
+        for key, value in data.items():
+            key_path = key.split(DELIM)
+            ref, k = self.get_attribute(key_path)
+            setattr(ref, k, value)
+
+    def get_attribute(self, key_path: List[str]):
+        """Return key path corresponding instance
+
+        Args:
+            key_path: heirechical key path.
+
+        Returns:
+            key path corresponding instance
+        """
+        if len(key_path) > 1:
+            child_attr_name = key_path.pop(0)
+            return getattr(self, child_attr_name).get_attribute(key_path)
+        else:
+            return self, key_path[0]