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 PermissionManager(models.Manager):
use_in_migrations = True
def get_by_natural_key(self, codename, app_label, model):
return self.get(
codename=codename,
content_type=ContentType.objects.db_manager(self.db).get_by_natural_key(
app_label, model
),
)
Run 1
The code demonstrates good readability. Structure is logical: imports are grouped, and the class has a clear purpose. Nesting is minimal—only one nested call inside `get_by_natural_key`, which is necessary and clearly formatted. Intent is clear: the manager retrieves a permission by its natural key components. Code length is concise; no extra methods or comments are needed. Action granularity is appropriate: one meaningful action per line, with keyword arguments kept on separate lines for clarity. Reading flow is natural—signature, return, and nested call follow a top-to-bottom order. Minor deductions: unused imports (`auth`, `AbstractBaseUser`, etc.) could confuse readers, and the `use_in_migrations = True` line lacks context for novices, but these are minor. Overall, the code is well-structured and easy to follow.
Run 2
The code is well-organized with clear imports and a single, focused class. The PermissionManager class has a clear purpose and overrides get_by_natural_key in a straightforward manner. Nesting is minimal, with only one level inside the method. The use of keyword arguments in the get() call enhances clarity. The code is concise and avoids unnecessary repetition. Action granularity is appropriate, with one logical operation per line. The main readability challenge is the line continuation for content_type, which slightly interrupts flow but follows PEP 8. Overall, this is highly readable Django model manager code.
Run 3
The code is well-structured and highly readable. It uses clear import organization from standard library, Django core, and local modules. The PermissionManager class has a single purpose with a flat, non-nested method and good naming. The get_by_natural_key method retrieves a ContentType via natural key, with clear variable names (codename, app_label, model). Although the nested db_manager call adds indentation, it remains explicit and avoids unnecessary line breaks. The code is concise, with one logical action per line, and follows Django conventions.
Run 1
Code Structure: Imports precede a focused manager class, providing clear organization, although many imports are unused in this snippet. Nesting: Shallow structure; the nested database lookup is easy to follow. Clarity of intent: Descriptive class, method, and parameter names clearly communicate retrieval by a natural key. Code length: The implementation is concise, but the extensive imports add visual overhead relative to the small method. Action granularity: Each statement has a distinct purpose, and multiline arguments keep the compound lookup readable. Reading flow: Conventional formatting and logical argument ordering support a natural top-to-bottom reading flow; an additional blank line before the class would improve separation.
Run 2
Code Structure: Imports and a focused manager class provide clear organization, though most imports are unused in this snippet. Nesting: Minimal control-flow nesting; the nested lookup is formatted clearly. Clarity of intent: Descriptive class, method, and parameter names communicate a natural-key permission lookup, although understanding the details requires Django familiarity. Code length: The implementation is concise, but the extensive import block adds unnecessary visual overhead for the code shown. Action granularity: A single return expression combines two related database lookups, with line breaks making their relationship easy to follow. Reading flow: Conventional formatting and sensible argument ordering support natural reading, slightly weakened by the disproportionate import section.
Run 3
Code Structure: Imports and the manager class are logically organized, although many imports are unused in this snippet. Nesting: Shallow method nesting; the nested lookup remains easy to follow. Clarity of intent: Descriptive class, method, and parameter names make the natural-key permission lookup clear, assuming familiarity with Django. Code length: The implementation is concise, but the lengthy import list adds clutter relative to the small method. Action granularity: The return statement combines content-type resolution and permission retrieval, though multiline formatting clearly separates their arguments. Reading flow: Conventional indentation and formatting provide a natural top-to-bottom flow; an additional blank line before the class would improve separation.