Skip to content

Instantly share code, notes, and snippets.

View model_from_db.py
class Model(metaclass=ModelBase):
# ...
@classmethod
def from_db(cls, db, field_names, values):
if len(values) != len(cls._meta.concrete_fields):
values_iter = iter(values)
values = [
next(values_iter) if f.attname in field_names else DEFERRED
View exclusion.py
class Exclusion(models.Model):
"""
Models a period of time we wish to exclude a particular student from being included in some data report.
"""
student = models.ForeignKey(Student, on_delete=models.CASCADE)
start = models.DateField("exclusion_start")
end = models.DateField("exclusion_end")
active = models.BooleanField(verbose_name="Still send digital communications.", default=True)
def __str__(self):
View descriptor_get.py
data = instance.__dict__ # get the specific Student instance's symbol table
field_name = self.field.attname # pull out the field name (first name, in our case)
if data.get(field_name, self) is self:
# Let's see if the field is part of the parent chain. If so we
# might be able to reuse the already loaded value. Refs #18343.
val = self._check_parent_chain(instance) # check if this value is already pulled down from the db upstream
if val is None:
instance.refresh_from_db(fields=[field_name])
val = getattr(instance, field_name)
data[field_name] = val # set the student instance __dict__ key for future attribute lookups!
View modified__get__.py
def __get__(self, instance, owner):
"""
Instead of directly returning the value directory, we look up each instance's value using
the instance itself as the key.
"""
if instance is not None: # attribute lookup initiated from instance
if len(self._instance_values) < NonNullStringDescriptor.CAPACITY:
self._instance_values[instance] = self.__default
return self._instance_values.get(instance, self.__default)
else: # attribute lookup initiated via class
View weakref.py
from weakref import WeakKeyDictionary
class NonNullStringDescriptor:
CAPACITY = 2 # maximum of two instances can store their non-default attribute values here
def __init__(self, value: str = "Default Name"):
self._instance_values = WeakKeyDictionary()
self.__default = value
def __get__(self, instance, owner):
View undesired_behavior.py
if __name__ == "__main__":
student = Person()
studentB = Person()
print(student.name) # Default Name
print(studentB.name) # Default Name
studentB.name = "Changed Name!!!"
print(studentB.name) # "Changed Name!!!"
print(student.name) # "Changed Name!!!"
View contribute_to_class.py
def contribute_to_class(self, cls, name, private_only=False):
"""
Register the field with the model class it belongs to.
If private_only is True, create a separate instance of this field
for every subclass of cls, even if cls is not an abstract model.
"""
self.set_attributes_from_name(name)
self.model = cls
cls._meta.add_field(self, private=private_only)
View static_properties.py
class AbstractBaseUser(models.Model):
password = models.CharField(_('password'), max_length=128)
last_login = models.DateTimeField(_('last login'), blank=True, null=True)
is_active = True
# ....
@property
def is_anonymous(self):
View property.py
class property(object):
def __init__(self, fget: Optional[Callable[[Any], Any]] = ...,
fset: Optional[Callable[[Any, Any], None]] = ...,
fdel: Optional[Callable[[Any], None]] = ...,
doc: Optional[str] = ...) -> None: ...
def getter(self, fget: Callable[[Any], Any]) -> property: ...
def setter(self, fset: Callable[[Any, Any], None]) -> property: ...
def deleter(self, fdel: Callable[[Any], None]) -> property: ...
def __get__(self, obj: Any, type: Optional[type] = ...) -> Any: ...
def __set__(self, obj: Any, value: Any) -> None: ...
View static_prop.py
class StudentWithStaticProp:
def __init__(self):
self._name = "Default Name"
def _name(self):
return "A new name, never changes"
name = property(_name)