objectify.py

"""
Turn dict into class object
 dictionary = {
     "name": "Steve",
     "age": 18,
     "dob": "08/23/2000",
     0: {
         "name": "April",
         "age": 23,
         "hi-how-are-you": "good",
         "steve joe": "o"
         }
     }
 }
as you can see the it supports nested dictionarys also ints as keys

object = Object(dictionary)
object.name -> Steve
object['name'] -> Steve
object._0.name -> April
object[0].name -> April
object[0].hi_how_are_you -> good
object[0]['hi-how-you'] > good
object[0]['steve joe'] ->
object[0].steve_joe -> o
"""


from typing import Any


class Objectify:
    def __init__(self, d: dict = {}, objectify=True):
        if objectify: self.toObject(d)
    
    def isEmpty(self):
        if len(self.toDict().keys()) == 0:
            return True
        else: 
            return False

    @classmethod
    def isString(self, string):
        if type(string) == type(""):
            return True

    @classmethod
    def isInt(self, int):
        if type(int) == type(2):
            return True

    @classmethod
    def isObjectify(self, obj):
        if type(obj) == type(Objectify()):
            return True
    
    @classmethod
    def isList(self, obj):
        if type(obj) == type([]):
            return True

    def get(self, key, return_false=False):
        if type(key) == type(2):
                key = "_" + str(key)
        key=str(key).replace(" ", "_").replace("-", "_")
        if hasattr(self, key):
            return getattr(self, key)
        else:
            if not return_false:
                return Objectify()
            else:
                return False
    
    def set(self, key, value):
        key=str(key).replace(" ", "_").replace("-", "_")
        if type(key) == type(2):
                key = "_" + str(key)
        if type(value) == type({}):
            setattr(self, key, Objectify(value))
        else:   
            setattr(self, key, value)
    
    def toDict(self):
        dict = {}
        for key, value in iter(self.__dict__.items()):
            if type(value) == type(self):
                dict[key] = value.toDict()
            else:
                dict[key] = value
        return dict

    def toObject(self, d: dict):
        for key, value in iter(d.items()):
            if type(key) == type(2):
                key = "_" + str(key)
            key=key.replace(" ", "_").replace("-", "_")
            if type(value) == type({}):
                setattr(self, key, Objectify(value))
            else:
                setattr(self, key, value)

    def __delitem__(self, name: Any):
        name=str(name).replace(" ", "_").replace("-", "_")
        if type(name) == type(2):
                name = "_" + name
        try:
            delattr(self, name)
        except: pass

    def __getitem__(self, name: Any) -> Any:
        name=str(name).replace(" ", "_").replace("-", "_")
        if type(name) == type(2):
            name = "_" + name
        if hasattr(self, name):
            return getattr(self, name)
    
    def __setitem__(self, name: Any, value: Any) -> None:
        if type(value) == type({}):
            value = Objectify(value)
        self.set(name, value)
    
    def __repr__(self):
        return str(self.toDict())

if __name__=="__main__":
    d = {
        "name": "me",
        "hi hi": 0,
        "hi-2": 0,
        "nested": {
            "name": "nested_1",
            "nested":{
                "name": "nested_2"
            }
        }
    }
    object = Objectify(d)
    print(object['nested']['nested']['name'], object['hi hi'], object['hi-2'])