Source code
from collections.abc import Iterable
from django.apps import apps
from django.contrib import auth
from django.contrib.auth.base_user import AbstractBaseUser, BaseUserManager
from django.contrib.auth.hashers import make_password
from django.contrib.contenttypes.models import ContentType
from django.core.exceptions import PermissionDenied
from django.core.mail import send_mail
from django.db import models
from django.db.models.manager import EmptyManager
from django.utils import timezone
from django.utils.translation import gettext_lazy as _
from .validators import UnicodeUsernameValidator
class AbstractUser(AbstractBaseUser, PermissionsMixin):
username_validator = UnicodeUsernameValidator()
username = models.CharField(
_("username"),
max_length=150,
unique=True,
help_text=_(
"Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only."
),
validators=[username_validator],
error_messages={
"unique": _("A user with that username already exists."),
},
)
first_name = models.CharField(_("first name"), max_length=150, blank=True)
last_name = models.CharField(_("last name"), max_length=150, blank=True)
email = models.EmailField(_("email address"), blank=True)
is_staff = models.BooleanField(
_("staff status"),
default=False,
help_text=_("Designates whether the user can log into this admin site."),
)
is_active = models.BooleanField(
_("active"),
default=True,
help_text=_(
"Designates whether this user should be treated as active. "
"Unselect this instead of deleting accounts."
),
)
date_joined = models.DateTimeField(_("date joined"), default=timezone.now)
objects = UserManager()
EMAIL_FIELD = "email"
USERNAME_FIELD = "username"
REQUIRED_FIELDS = ["email"]
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
abstract = True
def clean(self):
super().clean()
self.email = self.__class__.objects.normalize_email(self.email)
def get_full_name(self):
full_name = "%s %s" % (self.first_name, self.last_name)
return full_name.strip()
def get_short_name(self):
return self.first_name
def email_user(self, subject, message, from_email=None, **kwargs):
send_mail(subject, message, from_email, [self.email], **kwargs)
Run 1
The code is well-structured, with clear separation of model fields, Meta class, and methods. Nesting is minimal, and the field definitions follow Django conventions closely, which improves readability for experienced developers. The clarity of intent is strong, as each field and method has a self-explanatory name and purpose. The code length is appropriate for a Django abstract user model, avoiding unnecessary verbosity. Action granularity is mostly one action per line, though some field definitions span multiple lines for readability—a beneficial trade-off. Reading flow is natural, with model fields grouped logically and methods following fields. Minor issues include an unused import (EmptyManager), a missing newline after the class declaration, and some empty lines inside method bodies. The code assumes familiarity with Django, which is appropriate given its context. Overall, this is a highly readable Django model implementation.
Run 2
The code is highly readable. It follows a logical structure with clear section separation, including all model fields, managers, meta options, and methods in an orderly manner. Nesting is minimal and well-controlled. Each class attribute and method exhibits clear intent, with descriptive names and helpful help_text. The code is concise, avoiding unnecessary verbosity while maintaining completeness. Action granularity is generally one action per line, especially in complex field definitions and method bodies. The reading flow is natural, guiding the reader from field definitions through Meta options to methods. Minor deductions: some blank lines contain trailing whitespace, and a few method docstrings are missing, but these are trivial. Overall, this is an exemplar of Django model code following community best practices.
Run 3
The code is well-structured with clear separation of fields, methods, and Meta class. It uses Django conventions effectively, and each field definition is readable with logical keyword arguments. Nesting is minimal, and the overall flow is natural. Minor deductions: some lines are long (e.g., field definitions), and there are unnecessary blank lines and unused imports that slightly reduce cleanliness. The intent of each method is straightforward, and action granularity is mostly one action per line. Overall, the code is highly readable but could be slightly improved by removing unused imports and reducing line length.
Run 1
Code Structure: Fields, manager, configuration, metadata, and methods are logically grouped, though unused imports add clutter and PermissionsMixin and UserManager lack visible definitions or imports. Nesting: Shallow nesting makes the class easy to scan; multiline field declarations remain clear. Clarity of intent: Descriptive field and method names, plus help text, clearly communicate a Django user model's purpose. Code length: Generally concise, with appropriate detail for field configuration, although unused imports and stray blank lines are unnecessary. Action granularity: Each statement performs one clear action, and short methods avoid combining unrelated operations. Reading flow: The progression from model fields to configuration and behavior is natural, but missing dependencies and inconsistent whitespace slightly interrupt comprehension.
Run 2
Code Structure: Fields, manager, configuration, metadata, and methods are logically grouped using familiar Django conventions, though PermissionsMixin and UserManager are not defined or imported in the snippet. Nesting: Shallow; only field configuration and the Meta class add nesting. Clarity of intent: Descriptive field and method names, along with help text, make the user model's purpose clear. Code length: Mostly concise, but several unused imports and unnecessary blank lines add clutter. Action granularity: Statements generally perform one action each, and multiline field declarations keep options easy to scan. Reading flow: Natural progression from model fields to configuration and behavior; missing dependencies and excess whitespace slightly interrupt an otherwise readable presentation.
Run 3
Code Structure: Fields, manager, configuration, metadata, and methods are logically grouped using standard Django conventions. Nesting: Shallow nesting and straightforward methods make the code easy to follow. Clarity of intent: Descriptive field and method names, along with help text, clearly communicate purpose; however, PermissionsMixin and UserManager are not defined or imported in the snippet. Code length: Mostly concise, though several unused imports and unnecessary blank lines add clutter. Action granularity: Statements generally perform one action per line, while multiline field declarations keep complex options readable. Reading flow: The progression from model declarations to behavior is natural and consistent, with minor interruptions from whitespace and missing dependencies.