Class Options

django.db.models.options.Options

Declaration

class Options

source link

Methods

▷ def __init__(self, meta, app_label=None)
source link
▷ def __repr__(self)
source link
▷ def __str__(self)
source link
▷ def add_field(self, field, private=False)
source link
▷ def add_manager(self, manager)
source link
▷ def app_config(self) @property
@property
def app_config(self)
source link
▷ def base_manager(self) @cached_property
@cached_property
def base_manager(self)
source link
▷ def can_migrate(self, connection)
Return True if the model can/should be migrated on the `connection`. `connection` can be either a real connection or a connection alias.
source link

▶ def concrete_fields(self) @cached_property

Return a list of all concrete fields on the model and its parents.

@cached_property
def concrete_fields(self)

source link

Private API intended only to be used by Django itself; get_fields()
combined with filtering of field properties is the public API for
obtaining this field list.

▷ def contribute_to_class(self, cls, name)
source link
▷ def db_returning_fields(self) @cached_property
Private API intended only to be used by Django itself. Fields to be returned after a database insert.
@cached_property
def db_returning_fields(self)
source link
▷ def default_manager(self) @cached_property
@cached_property
def default_manager(self)
source link
▶ def fields(self) @cached_property
Return a list of all forward fields on the model and its parents, excluding ManyToManyFields.
@cached_property
def fields(self)
source link
```
Private API intended only to be used by Django itself; get_fields()
combined with filtering of field properties is the public API for
obtaining this field list.
```
▷ def fields_map(self) @cached_property
@cached_property
def fields_map(self)
source link

▶ def get_ancestor_link(self, ancestor)

Return the field on the current model which points to the given

source link

"ancestor". This is possible an indirect link (a pointer to a parent
model, which points, eventually, to the ancestor). Used when
constructing table joins for model inheritance.

Return None if the model isn't an ancestor of this one.

▷ def get_base_chain(self, model)
Return a list of parent classes leading to `model` (ordered from closest to most distant ancestor). This has to handle the case where `model` is a grandparent or even more distant relation.
source link
▷ def get_field(self, field_name)
Return a field instance given the name of a forward or reverse field.
source link
▶ def get_fields(self, include_parents=True, include_hidden=False)
Return a list of fields associated to the model. By default, include forward and reverse fields, fields derived from inheritance, but not hidden fields. The returned fields can be changed using the parameters:
source link
```
- include_parents: include fields derived from inheritance
- include_hidden:  include fields that have a related_name that
                   starts with a "+"
```
▷ def get_parent_list(self)
Return all the ancestors of this model as a list ordered by MRO. Useful for determining if something is an ancestor, regardless of lineage.
source link
▷ def get_path_from_parent(self, parent)
Return a list of PathInfos containing the path from the parent model to the current model, or an empty list if parent is not a parent of the current model.
source link
▷ def get_path_to_parent(self, parent)
Return a list of PathInfos containing the path from the current model to the parent model, or an empty list if parent is not a parent of the current model.
source link
▷ def installed(self) @property
@property
def installed(self)
source link
▷ def label(self) @property
@property
def label(self)
source link
▷ def label_lower(self) @property
@property
def label_lower(self)
source link

▶ def local_concrete_fields(self) @cached_property

Return a list of all concrete fields on the model.

@cached_property
def local_concrete_fields(self)

source link

Private API intended only to be used by Django itself; get_fields()
combined with filtering of field properties is the public API for
obtaining this field list.

▷ def managers(self) @cached_property
@cached_property
def managers(self)
source link
▷ def managers_map(self) @cached_property
@cached_property
def managers_map(self)
source link
▶ def many_to_many(self) @cached_property
Return a list of all many to many fields on the model and its parents.
@cached_property
def many_to_many(self)
source link
```
Private API intended only to be used by Django itself; get_fields()
combined with filtering of field properties is the public API for
obtaining this list.
```
▶ def related_objects(self) @cached_property
Return all related objects pointing to the current model. The related objects can come from a one-to-one, one-to-many, or many-to-many field relation type.
@cached_property
def related_objects(self)
source link
```
Private API intended only to be used by Django itself; get_fields()
combined with filtering of field properties is the public API for
obtaining this field list.
```
▷ def setup_pk(self, field)
source link
▷ def setup_proxy(self, target)
Do the internal setup so that the current model is a proxy for "target".
source link
▶ def swapped(self) @property
Has this model been swapped out for another? If so, return the model name of the replacement; otherwise, return None.
@property
def swapped(self)
source link
```
For historical reasons, model name lookups using get_model() are
case insensitive, so we make sure we are case insensitive here.
```
▷ def total_unique_constraints(self) @cached_property
Return a list of total unique constraints. Useful for determining set of fields guaranteed to be unique for all rows.
@cached_property
def total_unique_constraints(self)
source link
▷ def verbose_name_raw(self) @property
Return the untranslated verbose name.
@property
def verbose_name_raw(self)
source link

Reexports

Imported in django.test.utils.
Imported in django.db.models.base.