from collections import OrderedDict


class Field:
  def __init__(self, name=None):
    self.name = name

  def __get__(self, instance, owner):
    # Вызываем объект как свойство класса
    if instance is None:
      return self
    return instance._data[self.name]

  def __set__(self, instance, value):
    instance._data[self.name] = value


class BooleanField(Field):
  pass


class FloatField(Field):
  pass


class IntField(Field):
  pass


class ObjectIdField(Field):
  pass


class StringField(Field):
  pass


class DocumentMetaclass(type):
  def __new__(cls, name, bases, namespace):
    klass = super().__new__(cls, name, bases, namespace)
    parents = [b for b in bases if isinstance(b, cls)]
    # current class is Document
    # if not parents:
    #   return klass
    print(klass, parents)
    fields = OrderedDict()
    for p in parents:
      fields.update(p._fields)
    klass._fields = fields
    for k, v in namespace.items():
      if isinstance(v, Field):
        if v.name is None:
          v.name = k
        fields[k] = v
    klass._fields = fields
    meta = klass.Meta
    for p in parents:
      meta
    return klass


class Document(metaclass=DocumentMetaclass):
  def __init__(self, **kw):
    self._data = {}
    self._data.update(kw)

  class Meta:
    collection = None
    indexes = ()

  @classmethod
  def find(self, db, *args, **kw):
    pass

  @classmethod
  def insert(self, db, document):
    pass

  @classmethod
  def update(self, db, document):
    pass

  @classmethod
  def delete(self, db, document):
    pass


class User(Document):
  username = StringField()
  password = StringField()