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-structured and highly readable. Import statements are cleanly organized by library/source. The class has a clear purpose (manager for Permission model), and the `use_in_migrations` flag is explicit. The `get_by_natural_key` method is concise, with one clear action per logical portion. Naming is descriptive. The only minor deduction is that the nested call to `get_by_natural_key` for ContentType slightly increases reading complexity, but it is still understandable and follows Django conventions. Overall, it is idiomatic and easy to follow.
Run 3
The code is generally readable but has some minor issues. The import block is organized, though it contains unused imports (send_mail, make_password, AbstractBaseUser, BaseUserManager, auth, PermissionDenied, EmptyManager, timezone, UnicodeUsernameValidator) which adds unnecessary length and clutter. The class definition is clear with an appropriate manager inheritance. The get_by_natural_key method has reasonable structure but could benefit from breaking the nested get_by_natural_key call into a separate line for better readability. The method chains are logical and the parameter naming is clear. The code demonstrates good use of Django conventions and follows a natural flow from imports to class definition to method implementation. However, the unused imports suggest the code was copied from a larger module without cleanup, which impacts clarity of intent.
Run 1
Code Structure: Imports and a focused manager class are logically organized, though many imports are unused in this snippet. Nesting: Shallow class/method nesting is easy to follow; the nested lookup adds only modest complexity. Clarity of intent: Descriptive names clearly communicate retrieval of a permission by its natural key, although Django familiarity helps. Code length: The method is concise, but the extensive import list distracts from its small implementation. Action granularity: Arguments are neatly separated across lines, and the return expression represents one cohesive operation. Reading flow: The progression from imports to class configuration to lookup method is natural, with consistent formatting and a clearly readable multiline query.
Run 2
Code Structure: Imports and a small manager class are logically organized, although many imports are unused in this snippet. Nesting: The class and method introduce minimal nesting; the nested lookup remains easy to follow. Clarity of intent: Descriptive class, method, and parameter names clearly communicate a permission lookup by natural key. Code length: The implementation is concise, but the extensive import block outweighs the actual logic. Action granularity: Each statement performs a coherent action, though the return expression combines content-type resolution with permission retrieval. Reading flow: Conventional formatting and multiline arguments provide a natural flow, with only minor visual complexity from the chained, nested lookup.
Run 3
Code Structure: Imports precede a focused manager class and a single method, providing clear organization. Nesting: Shallow overall, with only a nested lookup inside the return expression. Clarity of intent: Descriptive class, method, and parameter names clearly communicate permission retrieval by natural key, although Django familiarity helps. Code length: The implementation is concise, but many imports are unused in the provided snippet and add clutter. Action granularity: Each statement has a clear role; the return expression combines content-type lookup and permission retrieval without becoming difficult to follow. Reading flow: Consistent indentation and multiline keyword arguments make the method easy to scan. Additional spacing between import groups and before the class would improve readability.