User:Xvedejas/Useful Hints

Simulate Abstract Fields

Like in C#, we want subclasses to re-implement our methods, so the solution is to raise a nice error if they do not override them.

def abstract():
    import inspect
    caller = inspect.getouterframes(inspect.currentframe())[1][3]
    raise NotImplementedError(caller + ' must be implemented in subclass')

class AbstractClass():
    def Method1(self, arg): abstract()
    def Method2(self, arg): abstract()
    def Method3(self, arg): abstract()

Not Implemented Error

In smalltalk, objects have a method called "notImplemented" that is called whenever the object doesn't know what to do with a message it receives. In python we have __getattr__(), which is also called when a method is not found.

class MyClass():
    def test(self):
        print "good"
    def __getattr__(self, name):
        print "not good, " + name + " not found"

>>> MyClass().test()
good
>>> MyClass().testabcdefg()
not good, testabcdefg not found

Save/Load Datatype

Contents can literally be any built-in datatype, be it a list or dictionary(or any type that implements __repr__() and works with eval()); and it will appear just like that type in every way except that added functionality

class Data():
    def __init__(self, filename, contents, overwrite = True):
        self.Filename = filename
        if overwrite:
            self.Contents = contents
            self.Save()
        else:
            self.Load()
 
    def Load(self, filename = None):
        if (filename == None):
            filename = self.Filename
        theFile = open(filename, 'r')
        data = theFile.read()
        theFile.close()
        try:
            self.Contents = eval(data)
        except SyntaxError as error:
            raise SyntaxError("Malformed string from file " + self.Filename)
 
    def Save(self, filename = None):
        if (filename == None):
            filename = self.Filename
        theFile = open(filename, 'w')
        theFile.write(repr(self.Contents))
        theFile.close()
 
    def __getattr__(self, name):
        return getattr(self.Contents, name)

Auto Save/Load Dictionary

This dictionary tries to read/write to a file every single time you change it. I'm sure there's a purpose for something like this...

Note: This *is* sort of a hack, anything that modifies the dictionary needs to be reimplemented.

class PersistDict():
    def __init__(self, filename, contents = {}, overwrite = True):
        self.Filename = filename
        if overwrite:
            self.__SetContents(contents)
    
    def __GetContents(self):
        self.File = open(self.Filename, 'r')
        data = self.File.read()
        self.File.close()
        try:
            contents = eval(data)
        except SyntaxError as error:
            raise SyntaxError("Malformed dictionary string from file " + self.Filename)
        return contents
    
    def __SetContents(self, value):
        self.File = open(self.Filename, 'w')
        self.File.write(repr(value))
        self.File.close()
   
    # This only helps us with methods that don't modify our dictionary
    def __getattr__(self, name):
        return getattr(self.__GetContents(), name)
    
    # This lets us modify our dictionary by setting keys (dict[key] = value)
    def __setitem__(self, key, value):
        contents = self.__GetContents()
        contents[key] = value
        self.__SetContents(contents)
    
    # You can add back certain functionality like this
    def clear(self):
        self.__SetContents({})
    
    # Or this
    def pop(self, item):
        contents = self.__GetContents()
        value = contents.pop(item)
        self.__SetContents(contents)
        return value