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):
"""
An abstract base class implementing a fully featured User model with
admin-compliant permissions.
Username and password are required. Other fields are optional.
"""
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):
"""
Return the first_name plus the last_name, with a space in between.
"""
full_name = "%s %s" % (self.first_name, self.last_name)
return full_name.strip()
def get_short_name(self):
"""Return the short name for the user."""
return self.first_name
def email_user(self, subject, message, from_email=None, **kwargs):
"""Send an email to this user."""
send_mail(subject, message, from_email, [self.email], **kwargs)
Run 1
The code is well-structured and highly readable. It follows Django model conventions with clear separation of concerns. The class is organized logically: fields are grouped together, followed by the manager, constants, Meta class, and methods. Nesting is minimal — the main indentation comes from field definition arguments, which is idiomatic for Django models. Each model field and method has a clear purpose, enhanced by descriptive names and docstrings. The code is concise but not overly compressed; field definitions are multi-line for readability. Action granularity is good, with one logical operation per line. Reading flow is natural, moving from field definitions to class constants to methods. Minor issues include the unused imports at the top (e.g., `Iterable`, `apps`, `ContentType`, `PermissionDenied`, `EmptyManager`) which could be removed, and a slight inconsistency in using string formatting (`"%s %s"`) versus f-strings, but these don't significantly impact readability.
Run 2
The code is highly readable and well-structured. It follows Django conventions, with clear separation of imports, model fields, Meta class, and methods. The field definitions are logically grouped and formatted consistently, with descriptive help_text and error messages. Nesting is minimal, with only one level in the Meta class and field definitions. Each field and method has a clear purpose, and the docstrings explain intent briefly. Action granularity is appropriate—most lines perform a single action, such as defining a field or returning a value. The reading flow is natural, starting with fields and progressing to methods. The only minor drawbacks are the slightly verbose field definitions (e.g., help_text strings) and the presence of unused imports (e.g., apps, ContentType, EmptyManager), which could confuse readers. Overall, the code is concise for what it accomplishes and maintains a clear, logical structure.
Run 3
The code is highly readable. It follows a logical structure with clear section separation: imports, class definition, fields, manager, Meta, and methods. Nesting is minimal and flat, with no deeply nested logic. Intent is clear due to descriptive names, helpful help_text attributes, and concise docstrings. Code length is appropriate for a Django model; repeated field patterns are idiomatic. Action granularity is good, with each model field and method body containing one primary action. Reading flow is natural, progressing from field definitions to methods. Minor deductions: the get_full_name method could use an f-string, and the imports at the top are somewhat verbose, but this is typical for Django. Overall, the code is well-organized, maintainable, and follows Django best practices.
Run 1
Code Structure: Clearly organized into imports, model fields, configuration, metadata, and methods. Nesting: Shallow, with indentation primarily used for field arguments and the Meta class rather than complex control flow. Clarity of intent: Descriptive names, docstrings, and field help text make the model's purpose clear; however, PermissionsMixin and UserManager are not defined or imported in the snippet, and several imports are unused. Code length: Appropriate for a declarative Django model, though unused imports add clutter. Action granularity: Statements generally perform one action each, and multiline field declarations improve scanning. Reading flow: Natural progression from user attributes to configuration and behavior, with consistent formatting and short, focused methods.
Run 2
Code Structure: Fields, manager, configuration, metadata, and methods are grouped logically. Nesting: Minimal control-flow nesting; multiline field declarations remain easy to follow. Clarity of intent: Descriptive names, help text, and method docstrings clearly explain the user model, though PermissionsMixin and UserManager are undefined in this snippet. Code length: Appropriate for the model, but several unused imports add clutter. Action granularity: Statements generally perform one action each, with readable formatting for complex declarations. Reading flow: The progression from model fields to configuration and behavior is natural and consistent. Minor dependency gaps and import noise prevent a higher score.
Run 3
Code Structure: Fields, manager, configuration, metadata, and methods are logically grouped. Nesting: Shallow nesting makes the class easy to scan; multiline field declarations remain manageable. Clarity of intent: Descriptive names, docstrings, and field help text clearly communicate purpose, although PermissionsMixin and UserManager are not defined or imported in the snippet. Code length: Mostly concise, with useful declarative detail, but several unused imports add clutter. Action granularity: Each statement performs one clear action, and methods have narrowly focused responsibilities. Reading flow: The progression from model fields to configuration and behavior is natural and consistent. Minor import clutter and unresolved dependencies prevent a higher score.