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 highly readable with a clear, logical structure. Imports are organized and follow Django conventions, and the class definition with its single method is concise and focused. The method body demonstrates shallow nesting, with only one nested function call that is clearly indented and easy to follow. Intent is unambiguous: it retrieves a permission by natural key using ContentType lookup. Action granularity is excellent — one logical action per line. The reading flow is natural: from imports to class definition to method logic. The only minor deduction is because `get_by_natural_key` uses a slightly long nested call for ContentType that could optionally be split for absolute clarity, but overall this remains very clean, maintainable, and readable code.
Run 3
The code is well-structured and readable. It has a clear and logical organization: imports are grouped and ordered (standard library, Django libs, local), followed by a class definition. Nesting is minimal, with only one method containing a single nested call, which is acceptable. Intent is clear—the PermissionManager is a model manager that retrieves permissions by natural key. While the file is short, it is complete for its purpose; no unnecessary code is present. Action granularity is mostly one action per line, though the nested get_by_natural_key call could be broken out for slightly better readability. Reading flow is natural, moving from imports to class definition to method logic. Overall, it is concise and maintainable, with only a minor opportunity to reduce nesting.
Run 1
Code Structure: Imports precede a clearly defined manager class, providing logical organization, though many imports are unused in this snippet. Nesting: Shallow class and method nesting is easy to follow; the nested lookup adds only minor complexity. Clarity of intent: Descriptive names clearly communicate retrieval of a permission by its natural key. Code length: The implementation is concise, but the unused imports add clutter. Action granularity: Each statement performs a coherent action, with the related content-type lookup naturally embedded in the query. Reading flow: Conventional formatting and multiline arguments support smooth reading, although an additional blank line before the class would improve separation.
Run 2
Code Structure: Imports and a focused manager class are logically organized, though most imports are unused in this snippet. Nesting: Minimal control-flow nesting; the nested lookup is clearly formatted. Clarity of intent: Descriptive class, method, and parameter names communicate retrieval of a permission by its natural key. Code length: The implementation is concise, but the unused imports add clutter. Action granularity: Statements are distinct, although the return expression combines content-type retrieval with permission retrieval. Reading flow: Conventional Django patterns and consistent indentation make the code easy to follow; extracting the content-type lookup could slightly improve readability.
Run 3
Code Structure: Imports and a focused manager class are logically organized, although many imports are unused in this snippet. Nesting: Shallow overall; the nested content-type lookup is straightforward and formatted clearly. Clarity of intent: Descriptive class, method, and parameter names make the natural-key permission lookup understandable, especially to Django developers. Code length: The method is concise, but the extensive import list adds unnecessary length to the shown code. Action granularity: The return expression combines two related lookups, with clear line breaks separating their arguments. Reading flow: Execution proceeds naturally from the manager definition to the lookup method; conventional formatting makes it easy to follow.