finish version 0.0.1

Author: litcoderr

README.md

@@ -1,6 +1,4 @@
-# loadit
-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.
+# Importify
+Import and export your configuration like a boss !!
 
 ## Usage

examples/__init__.py

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

examples/export_dict.py

@@ -1,7 +1,6 @@
 """
-This demo demonstrates export_dict() method that can extract dictionary from any Serializable object recursively.
-
-Usage:
+This demo demonstrates export_dict() method
+that can extract dictionary from any Serializable object recursively.
 """
 from . import MasterConfig
 
@@ -10,5 +9,3 @@
     master_config = MasterConfig()
 
     extracted_dict = master_config.export_dict()
-    
-    print(extracted_dict)

examples/export_json.py

@@ -1,7 +1,6 @@
 """
-This demo demonstrates export_json() method that saves Serializable object to json file.
-'
-Usage:
+This demo demonstrates export_json() method
+that saves Serializable object to json file.
 """
 from . import MasterConfig
 
@@ -19,11 +18,8 @@
 
     # 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

@@ -1 +1 @@
-{"loadit_is_awesome": true, "loadit_sub_config": {"loadit_is_legit": true, "loadit_sub_sub_config": {"loadit_can_go_deep": true}}}
+{"is_awesome": true, "nested": {"is_legit": true, "double_nested": {"is_intuitive": true}}}

examples/import_json.py

@@ -1,25 +1,16 @@
 """
-This demo demonstrates import_json() method that imports data from json file and loads recursively.
-
-Usage:
+This demo demonstrates import_json() method
+that imports data from json file and loads recursively.
 """
 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')
-
+    succeded, master_config = MasterConfig.import_json(path=file_path, ignore_error=True)

examples/parse.py

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

importify/__init__.py

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

importify/interface.py

@@ -1,29 +1,46 @@
+
+
 from typing import Tuple, Dict, Any, Optional, List
 import sys
 import json
 import argparse
 
-DELIM = "__"
+DELIM = "."
+
+
+def json_serializable(x):
+    try:
+        json.dumps(x)
+        return True
+    except:
+        return False
 
 
 class Serializable:
     def __init__(self):
-        pass
+        self.parser = SerializableParser(instance=self)
 
     # 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
+        delete_queue = []
         for key, obj in parent_dict.items():
             if isinstance(obj, Serializable):
                 parent_dict[key] = obj.export_dict()
+            elif not json_serializable(obj):
+                delete_queue.append(key)
+
+        # delete non json serializables
+        for key in delete_queue:
+            del parent_dict[key]
 
         return parent_dict
 
@@ -45,16 +62,16 @@ def export_json(self, path: str, ignore_error=True) -> bool:
             with open(path, 'w') as file:
                 file.write(json.dumps(extracted_dict, ensure_ascii=False))
         except Exception as e:
-            succeed= False
-            print(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.
         """
@@ -65,9 +82,9 @@ def import_dict(self, data: Dict[str, Any]):
                 else:
                     setattr(self, key, value)
         return self
-    
+
     @classmethod
-    def import_json(cls, path: str, ignore_error: bool = True)\
+    def import_json(cls, path: str, ignore_error: bool = True) \
             -> Tuple[bool, Optional['Serializable']]:
         try:
             with open(path, 'r') as file:
@@ -78,12 +95,15 @@ def import_json(cls, path: str, ignore_error: bool = True)\
             if not ignore_error:
                 sys.exit()
             return False, None
-    
-    # Parsing related method
+
+    # Parsing Method
     def parse(self):
+        self.parser.parse()
+
+    def parse_(self):
         """Implement argument parsing functionality based on object elements
         """
-        parser = argparse.ArgumentParser() 
+        parser = argparse.ArgumentParser()
         for key, value in self.strip_dict().items():
             parser.add_argument('--{}'.format(key), type=type(value))
         args = parser.parse_args()
@@ -103,24 +123,56 @@ def strip_dict(self, prefix: str = "") -> Dict[str, Any]:
         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():
+                for k, v in value.strip_dict(prefix=prefix + key + DELIM).items():
                     stripped_dict[k] = v
             else:
-                stripped_dict[prefix+key] = value
+                stripped_dict[prefix + key] = value
         return stripped_dict
-    
-    def unstrip_dict(self, data: Dict[str, Any]):
+
+    # Utility
+    @staticmethod
+    def is_base(key):
+        BASE = ['parser']
+        return key in BASE
+
+    def strip(self, prefix: str = "") -> Dict[str, Any]:
+        """ Strip arguments.
+
+        Args:
+            instance: Parent Serializable instance
+            prefix: Prefix string.
+
+        Returns:
+            Stripped dictionary.
+        """
+        stripped_dicts = {}
+        for key, value in self.__dict__.items():
+            if isinstance(value, Serializable):
+                for child_key, child_value in value.strip(prefix=prefix+key+DELIM).items():
+                    stripped_dicts[child_key] = child_value
+            elif Serializable.is_base(key):
+                continue
+            else:
+                stripped_dicts[prefix+key] = value
+        return stripped_dicts
+
+    def unstrip(self, data: Dict[str, Any]) -> Dict[str, Dict[str, Any]]:
         """Unstrip parsed dictionary and save.
 
         Args:
             data: stripped dictionary
+
+        Returns:
+            Dictionary consisting reference and key to value
         """
+        result = {}
         for key, value in data.items():
             key_path = key.split(DELIM)
             ref, k = self.get_attribute(key_path)
-            setattr(ref, k, value)
+            result[key] = {"reference": ref, "key": k, "value": value}
+        return result
 
-    def get_attribute(self, key_path: List[str]):
+    def get_attribute(self, key_path: List[str]) -> Tuple[Any, str]:
         """Return key path corresponding instance
 
         Args:
@@ -134,3 +186,41 @@ def get_attribute(self, key_path: List[str]):
             return getattr(self, child_attr_name).get_attribute(key_path)
         else:
             return self, key_path[0]
+
+
+class SerializableParser:
+    def __init__(self, instance):
+        self.instance = instance
+
+    def parse(self):
+        """Parse method.
+        """
+        # Strip dicts for parser
+        dicts = self.instance.strip()
+
+        # Parse
+        boolean_keys = []
+        parser = argparse.ArgumentParser()
+        for key, value in dicts.items():
+            if type(value) == bool:
+                boolean_keys.append(key)
+                if value:
+                    default = "True"
+                else:
+                    default = "False"
+                parser.add_argument('--{key}'.format(key=key), type=str, choices=["True", "False"], default=default,
+                                    help="boolean option.")
+            else:
+                parser.add_argument('--{key}'.format(key=key), type=type(value), default=value)
+        args = vars(parser.parse_args())
+
+        # Deal with stringed boolean attributes
+        for key in boolean_keys:
+            if args[key] == "True":
+                args[key] = True
+            else:
+                args[key] = False
+
+        # Unstrip and Update
+        for stripped_key, res in self.instance.unstrip(args).items():
+            setattr(res["reference"], res["key"], res["value"])