Código de exercício da Acens sobre POO e metaclass

db.py

import pickle
import os


class ModelBase(type):

    models = []

    def __new__(cls, name, bases, attrs):
        attrs.update({
            'sequence': 0,
            'objects': []
        })
        new_model = super(ModelBase, cls).__new__(cls, name, bases, attrs)
        if new_model.__name__ != "Model":
            cls.models.append(new_model)
        return new_model

    @classmethod
    def load_data(cls):
        for model in cls.models:
            model.load()

    @classmethod
    def clean_data(cls):
        for model in cls.models:
            model.clean_data()


class Model(object):
    __metaclass__ = ModelBase

    def __init__(self):
        self.id = None

    @classmethod
    def clean_data(cls):
        filename = "%s.pickle" % cls.__name__.lower()
        if os.path.exists(filename):
            os.remove(filename)

    @classmethod
    def load(cls):
        filename = "%s.pickle" % cls.__name__.lower()
        if not os.path.exists(filename):
            return
        with open(filename) as f:
            data = pickle.load(f)
            cls.sequence = data['sequence']
            cls.objects = data['objects']

    @classmethod
    def commit(cls):
        filename = "%s.pickle" % cls.__name__.lower()
        with open(filename, 'w') as f:
            data = {
                'sequence': cls.sequence,
                'objects': cls.objects,
            }
            pickle.dump(data, f)

    def delete(self):
        for i, obj in enumerate(self.__class__.objects):
            if obj.id == self.id and obj is self:
                del self.__class__.objects[i]
                self.__class__.commit()
                return

    def create(self):
        self.__class__.sequence += 1
        self.id = self.__class__.sequence
        self.__class__.objects.append(self)

    def save(self):
        if self.id is None:
            self.create()
        self.__class__.commit()

    @classmethod
    def find_by(cls, attr, value):
        for o in cls.objects:
            if not hasattr(o, attr):
                print "Error: %s attr invalid to %s!" % (attr, cls.__name__)
                return None
            if getattr(o, attr) == value:
                return o
        return None

    def __repr__(self):
        obj_id = str(self.id) if self.id is not None else str(None)
        return "<%s: %s>" % (self.__class__.__name__, obj_id)

    def __str__(self):
        return repr(self)


def load_data():
    ModelBase.load_data()


def clean_data():
    ModelBase.clean_data()

models.py

import db

class User(db.Model):

    def __init__(self, name):
        super(User, self).__init__()
        self.name = name

    def __str__(self):
        return self.name


class Book(db.Model):

    def __init__(self, title):
        super(Book, self).__init__()
        self.title = title

    def __str__(self):
        return self.title


if __name__ == '__main__':
    db.load_data()
    u1 = User('fabio')
    u1.save()
    u2 = User('pedro')
    u2.save()
    for u in User.objects:
        print u, u.id

    b1 = Book('Mulheres')
    b1.save()
    b2 = Book('Pulp')
    b2.save()

    for b in Book.objects:
        print b, b.id
    b2.delete()
    for b in Book.objects:
        print b, b.id