import itertools import warnings from mongoengine.base.common import _document_registry from mongoengine.base.fields import ( BaseField, ComplexBaseField, ObjectIdField, ) from mongoengine.common import _import_class from mongoengine.errors import InvalidDocumentError from mongoengine.queryset import ( DO_NOTHING, DoesNotExist, MultipleObjectsReturned, QuerySetManager, ) __all__ = ("DocumentMetaclass", "TopLevelDocumentMetaclass") class DocumentMetaclass(type): """Metaclass for all documents.""" # TODO lower complexity of this method def __new__(mcs, name, bases, attrs): flattened_bases = mcs._get_bases(bases) super_new = super().__new__ # If a base class just call super metaclass = attrs.get("my_metaclass") if metaclass and issubclass(metaclass, DocumentMetaclass): return super_new(mcs, name, bases, attrs) attrs["_is_document"] = attrs.get("_is_document", False) attrs["_cached_reference_fields"] = [] # EmbeddedDocuments could have meta data for inheritance if "meta" in attrs: attrs["_meta"] = attrs.pop("meta") # EmbeddedDocuments should inherit meta data if "_meta" not in attrs: meta = MetaDict() for base in flattened_bases[::-1]: # Add any mixin metadata from plain objects if hasattr(base, "meta"): meta.merge(base.meta) elif hasattr(base, "_meta"): meta.merge(base._meta) attrs["_meta"] = meta attrs["_meta"][ "abstract" ] = False # 789: EmbeddedDocument shouldn't inherit abstract # If allow_inheritance is True, add a "_cls" string field to the attrs if attrs["_meta"].get("allow_inheritance"): StringField = _import_class("StringField") attrs["_cls"] = StringField() # Handle document Fields # Merge all fields from subclasses doc_fields = {} for base in flattened_bases[::-1]: if hasattr(base, "_fields"): doc_fields.update(base._fields) # Standard object mixin - merge in any Fields if not hasattr(base, "_meta"): base_fields = {} for attr_name, attr_value in base.__dict__.items(): if not isinstance(attr_value, BaseField): continue attr_value.name = attr_name if not attr_value.db_field: attr_value.db_field = attr_name base_fields[attr_name] = attr_value doc_fields.update(base_fields) # Discover any document fields field_names = {} for attr_name, attr_value in attrs.items(): if not isinstance(attr_value, BaseField): continue attr_value.name = attr_name if not attr_value.db_field: attr_value.db_field = attr_name doc_fields[attr_name] = attr_value # Count names to ensure no db_field redefinitions field_names[attr_value.db_field] = ( field_names.get(attr_value.db_field, 0) + 1 ) # Ensure no duplicate db_fields duplicate_db_fields = [k for k, v in field_names.items() if v > 1] if duplicate_db_fields: msg = "Multiple db_fields defined for: %s " % ", ".join(duplicate_db_fields) raise InvalidDocumentError(msg) # Set _fields and db_field maps attrs["_fields"] = doc_fields attrs["_db_field_map"] = { k: getattr(v, "db_field", k) for k, v in doc_fields.items() } attrs["_reverse_db_field_map"] = { v: k for k, v in attrs["_db_field_map"].items() } attrs["_fields_ordered"] = tuple( i[1] for i in sorted((v.creation_counter, v.name) for v in doc_fields.values()) ) # # Set document hierarchy # superclasses = () class_name = [name] for base in flattened_bases: if not getattr(base, "_is_base_cls", True) and not getattr( base, "_meta", {} ).get("abstract", True): # Collate hierarchy for _cls and _subclasses class_name.append(base.__name__) if hasattr(base, "_meta"): # Warn if allow_inheritance isn't set and prevent # inheritance of classes where inheritance is set to False allow_inheritance = base._meta.get("allow_inheritance") if not allow_inheritance and not base._meta.get("abstract"): raise ValueError( "Document %s may not be subclassed. " 'To enable inheritance, use the "allow_inheritance" meta attribute.' % base.__name__ ) # Get superclasses from last base superclass document_bases = [b for b in flattened_bases if hasattr(b, "_class_name")] if document_bases: superclasses = document_bases[0]._superclasses superclasses += (document_bases[0]._class_name,) _cls = ".".join(reversed(class_name)) attrs["_class_name"] = _cls attrs["_superclasses"] = superclasses attrs["_subclasses"] = (_cls,) attrs["_types"] = attrs["_subclasses"] # TODO depreciate _types # Create the new_class new_class = super_new(mcs, name, bases, attrs) # Set _subclasses for base in document_bases: if _cls not in base._subclasses: base._subclasses += (_cls,) base._types = base._subclasses # TODO depreciate _types ( Document, EmbeddedDocument, DictField, CachedReferenceField, ) = mcs._import_classes() if issubclass(new_class, Document): new_class._collection = None # Add class to the _document_registry _document_registry[new_class._class_name] = new_class # Handle delete rules for field in new_class._fields.values(): f = field if f.owner_document is None: f.owner_document = new_class delete_rule = getattr(f, "reverse_delete_rule", DO_NOTHING) if isinstance(f, CachedReferenceField): if issubclass(new_class, EmbeddedDocument): raise InvalidDocumentError( "CachedReferenceFields is not allowed in EmbeddedDocuments" ) if f.auto_sync: f.start_listener() f.document_type._cached_reference_fields.append(f) if isinstance(f, ComplexBaseField) and hasattr(f, "field"): delete_rule = getattr(f.field, "reverse_delete_rule", DO_NOTHING) if isinstance(f, DictField) and delete_rule != DO_NOTHING: msg = ( "Reverse delete rules are not supported " "for %s (field: %s)" % (field.__class__.__name__, field.name) ) raise InvalidDocumentError(msg) f = field.field if delete_rule != DO_NOTHING: if issubclass(new_class, EmbeddedDocument): msg = ( "Reverse delete rules are not supported for " "EmbeddedDocuments (field: %s)" % field.name ) raise InvalidDocumentError(msg) f.document_type.register_delete_rule(new_class, field.name, delete_rule) if ( field.name and hasattr(Document, field.name) and EmbeddedDocument not in new_class.mro() ): msg = "%s is a document method and not a valid field name" % field.name raise InvalidDocumentError(msg) return new_class @classmethod def _get_bases(mcs, bases): if isinstance(bases, BasesTuple): return bases seen = [] bases = mcs.__get_bases(bases) unique_bases = (b for b in bases if not (b in seen or seen.append(b))) return BasesTuple(unique_bases) @classmethod def __get_bases(mcs, bases): for base in bases: if base is object: continue yield base yield from mcs.__get_bases(base.__bases__) @classmethod def _import_classes(mcs): Document = _import_class("Document") EmbeddedDocument = _import_class("EmbeddedDocument") DictField = _import_class("DictField") CachedReferenceField = _import_class("CachedReferenceField") return Document, EmbeddedDocument, DictField, CachedReferenceField class TopLevelDocumentMetaclass(DocumentMetaclass): """Metaclass for top-level documents (i.e. documents that have their own collection in the database. """ def __new__(mcs, name, bases, attrs): flattened_bases = mcs._get_bases(bases) super_new = super().__new__ # Set default _meta data if base class, otherwise get user defined meta if attrs.get("my_metaclass") == TopLevelDocumentMetaclass: # defaults attrs["_meta"] = { "abstract": True, "max_documents": None, "max_size": None, "ordering": [], # default ordering applied at runtime "indexes": [], # indexes to be ensured at runtime "id_field": None, "index_background": False, "index_opts": None, "delete_rules": None, # allow_inheritance can be True, False, and None. True means # "allow inheritance", False means "don't allow inheritance", # None means "do whatever your parent does, or don't allow # inheritance if you're a top-level class". "allow_inheritance": None, } attrs["_is_base_cls"] = True attrs["_meta"].update(attrs.get("meta", {})) else: attrs["_meta"] = attrs.get("meta", {}) # Explicitly set abstract to false unless set attrs["_meta"]["abstract"] = attrs["_meta"].get("abstract", False) attrs["_is_base_cls"] = False # Set flag marking as document class - as opposed to an object mixin attrs["_is_document"] = True # Ensure queryset_class is inherited if "objects" in attrs: manager = attrs["objects"] if hasattr(manager, "queryset_class"): attrs["_meta"]["queryset_class"] = manager.queryset_class # Clean up top level meta if "meta" in attrs: del attrs["meta"] # Find the parent document class parent_doc_cls = [ b for b in flattened_bases if b.__class__ == TopLevelDocumentMetaclass ] parent_doc_cls = None if not parent_doc_cls else parent_doc_cls[0] # Prevent classes setting collection different to their parents # If parent wasn't an abstract class if ( parent_doc_cls and "collection" in attrs.get("_meta", {}) and not parent_doc_cls._meta.get("abstract", True) ): msg = "Trying to set a collection on a subclass (%s)" % name warnings.warn(msg, SyntaxWarning) del attrs["_meta"]["collection"] # Ensure abstract documents have abstract bases if attrs.get("_is_base_cls") or attrs["_meta"].get("abstract"): if parent_doc_cls and not parent_doc_cls._meta.get("abstract", False): msg = "Abstract document cannot have non-abstract base" raise ValueError(msg) return super_new(mcs, name, bases, attrs) # Merge base class metas. # Uses a special MetaDict that handles various merging rules meta = MetaDict() for base in flattened_bases[::-1]: # Add any mixin metadata from plain objects if hasattr(base, "meta"): meta.merge(base.meta) elif hasattr(base, "_meta"): meta.merge(base._meta) # Set collection in the meta if its callable if getattr(base, "_is_document", False) and not base._meta.get("abstract"): collection = meta.get("collection", None) if callable(collection): meta["collection"] = collection(base) meta.merge(attrs.get("_meta", {})) # Top level meta # Only simple classes (i.e. direct subclasses of Document) may set # allow_inheritance to False. If the base Document allows inheritance, # none of its subclasses can override allow_inheritance to False. simple_class = all( b._meta.get("abstract") for b in flattened_bases if hasattr(b, "_meta") ) if ( not simple_class and meta["allow_inheritance"] is False and not meta["abstract"] ): raise ValueError( "Only direct subclasses of Document may set " '"allow_inheritance" to False' ) # Set default collection name if "collection" not in meta: meta["collection"] = ( "".join("_%s" % c if c.isupper() else c for c in name) .strip("_") .lower() ) attrs["_meta"] = meta # Call super and get the new class new_class = super_new(mcs, name, bases, attrs) meta = new_class._meta # Set index specifications meta["index_specs"] = new_class._build_index_specs(meta["indexes"]) # If collection is a callable - call it and set the value collection = meta.get("collection") if callable(collection): new_class._meta["collection"] = collection(new_class) # Provide a default queryset unless exists or one has been set if "objects" not in dir(new_class): new_class.objects = QuerySetManager() # Validate the fields and set primary key if needed for field_name, field in new_class._fields.items(): if field.primary_key: # Ensure only one primary key is set current_pk = new_class._meta.get("id_field") if current_pk and current_pk != field_name: raise ValueError("Cannot override primary key field") # Set primary key if not current_pk: new_class._meta["id_field"] = field_name new_class.id = field # If the document doesn't explicitly define a primary key field, create # one. Make it an ObjectIdField and give it a non-clashing name ("id" # by default, but can be different if that one's taken). if not new_class._meta.get("id_field"): id_name, id_db_name = mcs.get_auto_id_names(new_class) new_class._meta["id_field"] = id_name new_class._fields[id_name] = ObjectIdField(db_field=id_db_name) new_class._fields[id_name].name = id_name new_class.id = new_class._fields[id_name] new_class._db_field_map[id_name] = id_db_name new_class._reverse_db_field_map[id_db_name] = id_name # Prepend the ID field to _fields_ordered (so that it's *always* # the first field). new_class._fields_ordered = (id_name,) + new_class._fields_ordered # Merge in exceptions with parent hierarchy. exceptions_to_merge = (DoesNotExist, MultipleObjectsReturned) module = attrs.get("__module__") for exc in exceptions_to_merge: name = exc.__name__ parents = tuple( getattr(base, name) for base in flattened_bases if hasattr(base, name) ) or (exc,) # Create a new exception and set it as an attribute on the new # class. exception = type(name, parents, {"__module__": module}) setattr(new_class, name, exception) return new_class @classmethod def get_auto_id_names(mcs, new_class): """Find a name for the automatic ID field for the given new class. Return a two-element tuple where the first item is the field name (i.e. the attribute name on the object) and the second element is the DB field name (i.e. the name of the key stored in MongoDB). Defaults to ('id', '_id'), or generates a non-clashing name in the form of ('auto_id_X', '_auto_id_X') if the default name is already taken. """ id_name, id_db_name = ("id", "_id") existing_fields = {field_name for field_name in new_class._fields} existing_db_fields = {v.db_field for v in new_class._fields.values()} if id_name not in existing_fields and id_db_name not in existing_db_fields: return id_name, id_db_name id_basename, id_db_basename, i = ("auto_id", "_auto_id", 0) for i in itertools.count(): id_name = f"{id_basename}_{i}" id_db_name = f"{id_db_basename}_{i}" if id_name not in existing_fields and id_db_name not in existing_db_fields: return id_name, id_db_name class MetaDict(dict): """Custom dictionary for meta classes. Handles the merging of set indexes """ _merge_options = ("indexes",) def merge(self, new_options): for k, v in new_options.items(): if k in self._merge_options: self[k] = self.get(k, []) + v else: self[k] = v class BasesTuple(tuple): """Special class to handle introspection of bases tuple in __new__""" pass