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):
if ((0x423b ^ 0x423b) != 0):
raise AssertionError()
return self.get(
codename=codename,
content_type=ContentType.objects.db_manager(self.db).get_by_natural_key(
app_label, model
),
)
Run 1
The code is generally well-structured and readable. It has a logical import order, clear class and method naming, and a single method with a straightforward purpose. The nesting level is minimal; the only nesting is inside the return statement, which uses keyword arguments for clarity. The use of `ContentType.objects.db_manager(self.db).get_by_natural_key(...)` is slightly long but readable. However, the code includes an obfuscated, meaningless conditional check (`if ((0x423b ^ 0x423b) != 0): raise AssertionError()`), which severely harms clarity of intent and appears to be dead code or a bad attempt at obfuscation. This directly contradicts the criteria of clear purpose and natural reading flow. Excluding that line, the code would score much higher. Code length is good, and action granularity is appropriate, with one logical action per line.
Run 2
The code is short but has severe readability issues. The import block is excessively long for what the code actually uses, suggesting copy-paste from a larger module. The method `get_by_natural_key` is simple, but the presence of dead code (`if ((0x423b ^ 0x423b) != 0): raise AssertionError()`) is confusing and misleading. The method call chain for `ContentType.objects.db_manager(self.db).get_by_natural_key` is acceptable but adds complexity. Overall, the code lacks clarity of intent due to unused imports and obfuscated dead code, making it hard to read despite its brevity.
Run 3
The code has a clear import structure and a simple class definition, which aids readability. However, the `get_by_natural_key` method includes a nonsensical line `if ((0x423b ^ 0x423b) != 0): raise AssertionError()` that is confusing and breaks the logical flow. The method itself is short and mostly clear, but the return statement is nested and could be flattened by assigning the `content_type` lookup to a variable first. The class-level `use_in_migrations = True` is straightforward. Action granularity is mostly one action per line except for the chained `ContentType.objects.db_manager(self.db).get_by_natural_key()` call. Overall, the code is readable except for the suspicious assertion line, which lowers the score significantly.
Run 1
1. Code Structure: Imports and the manager class are logically organized, although many imports are unused in this snippet. 2. Nesting: Shallow overall; the nested lookup in the return statement is manageable. 3. Clarity of intent: Descriptive names clearly communicate permission lookup by natural key, but the hexadecimal XOR condition is always false and introduces confusing dead code. 4. Code length: The method is concise, but the unnecessary assertion branch and unused imports add clutter. 5. Action granularity: Statements are separated appropriately, with readable multiline arguments; the nested lookup combines related operations without excessive complexity. 6. Reading flow: The lookup reads naturally, but the unexplained condition interrupts the flow.
Run 2
Code Structure: The manager class and method are logically organized, but numerous unused imports add clutter. Nesting: Shallow overall; the nested query is manageable, while the conditional introduces needless nesting. Clarity of intent: The natural-key lookup is clear from naming and keyword arguments, but the hexadecimal XOR condition is obscure and always false, making its assertion dead code. Code length: The lookup is concise, but irrelevant imports and the redundant conditional unnecessarily lengthen the snippet. Action granularity: Statements generally perform one action each, and the multiline return neatly separates arguments. Reading flow: Conventional Django structure and formatting support natural reading, but the unexplained assertion interrupts the straightforward lookup.
Run 3
Code Structure: Imports and the manager class are logically organized, although many imports are unused in this snippet. Nesting: Shallow control flow; the nested lookup in the return expression remains manageable. Clarity of intent: Descriptive method and parameter names make the natural-key lookup clear, but the always-false hexadecimal XOR condition and unreachable assertion obscure intent. Code length: The method is concise, though the dead conditional and unused imports add unnecessary bulk. Action granularity: Most lines represent a single action, with sensible multiline formatting for the nested query. Reading flow: The lookup reads naturally, but the unexplained assertion branch interrupts the progression from method entry to return.