Source code
import email.message
import email.policy
import mimetypes
import warnings
from collections import namedtuple
from datetime import datetime, timezone
from email import charset as Charset
from email import generator
from email.errors import HeaderParseError
from email.header import Header
from email.headerregistry import Address, AddressHeader, parser
from email.mime.base import MIMEBase
from email.mime.message import MIMEMessage
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.utils import formataddr, getaddresses, make_msgid
from io import BytesIO, StringIO
from pathlib import Path
from django.conf import settings
from django.core.mail.utils import DNS_NAME
from django.utils.deprecation import (
RemovedInDjango70Warning,
deprecate_posargs,
warn_about_external_use,
)
from django.utils.encoding import force_bytes, force_str, punycode
from django.utils.timezone import get_current_timezone
from .deprecation import (
CONNECTION_ARG_WARNING,
FAIL_SILENTLY_ARG_WARNING,
report_using_incompatibility,
)
class SafeMIMEMultipart(MIMEMixin, MIMEMultipart):
def __init__(
self, _subtype="mixed", boundary=None, _subparts=None, encoding=None, **_params
):
self.encoding = encoding
MIMEMultipart.__init__(self, _subtype, boundary, _subparts, **_params)
def __setitem__(self, name, val):
name, val = forbid_multi_line_headers(name, val, self.encoding)
MIMEMultipart.__setitem__(self, name, val)
Run 1
The code demonstrates good organization through logical imports and a clear class hierarchy. The SafeMIMEMultipart class extends MIMEMixin and MIMEMultipart with a focused single responsibility. Nesting is minimal—only the __init__ method signature spans multiple lines for readability. Intent is clear: creating a safe multipart MIME class with validation for multi-line headers. The __setitem__ override clearly handles header injection prevention. Code length is appropriate, and action granularity is mostly one action per line, though the multi-line function signatures could be slightly more readable with better formatting. Reading flow is natural, with imports grouped by type (stdlib, Django, local) and methods organized logically. Minor deductions include the somewhat cluttered import section and the multi-line signature that could benefit from more consistent indentation or documentation explaining the 'forbid_multi_line_headers' purpose.
Run 2
The code imports many modules without clear organization or grouping, which reduces readability. The class `SafeMIMEMultipart` is short but inherits from `MIMEMixin` and `MIMEMultipart`; `MIMEMixin` is never defined or imported, so the intent is unclear and the code appears broken. Nesting is minimal, but method overrides lack docstrings or comments explaining why they exist. The `__init__` and `__setitem__` methods are concise but terse—parameter names like `_subtype` and `_params` are not self-explanatory. Action granularity is good; most lines do one thing. However, the overall structure feels fragmented due to missing context and unclear inheritance. The reading flow is interrupted by the need to infer purpose from Django internals without documentation.
Run 3
The code demonstrates good readability due to clear organizational structure, minimal nesting, and direct intent. The imports are logically grouped (standard library, Django dependencies, local modules), and the class definition is straightforward. The __init__ method properly passes parameters to its parent class, maintaining clear action granularity. The __setitem__ override has a single responsibility and includes a descriptive function name (forbid_multi_line_headers) that aids understanding. Minor deductions include: the MIMEMixin import is not shown but presumably exists, the deprecation import ordering could be more alphabetized, and the _params double-asterisk pattern requires some Python knowledge. The code remains concise without unnecessary verbosity. Reading flow is natural, progressing from imports to class definition to method implementations. The overall structure supports easy comprehension of the security-focused modification to standard email handling.
Run 1
Code Structure: Imports precede a compact class with logically separated initialization and header assignment methods, though many imports are unused in this excerpt. Nesting: Minimal nesting makes both methods easy to follow. Clarity of intent: The class name and header-validation call communicate safe MIME handling, but MIMEMixin and forbid_multi_line_headers are not defined in the excerpt. Code length: The class is concise, while the extensive import section outweighs the shown implementation. Action granularity: Each statement performs one clear action. Reading flow: Initialization followed by the header-assignment override is natural; an additional blank line before the class would improve visual separation.
Run 2
Code Structure: Imports precede a compact class with clearly separated initialization and header-setting methods, though many imports are unused in this excerpt. Nesting: Methods are flat, with no nested control flow. Clarity of intent: The class name and header-validation call communicate safe multipart message handling; undefined dependencies such as MIMEMixin and forbid_multi_line_headers require external context. Code length: The implementation is concise, but the extensive import block outweighs the small class shown. Action granularity: Each statement performs one clear action. Reading flow: Initialization followed by header assignment is natural, and formatting is consistent, although additional spacing between import groups and before the class would improve visual organization.
Run 3
Code Structure: Imports are grouped sensibly, and the class has two focused methods, though many imports are unused in this excerpt. Nesting: The methods are flat, with no nested control flow. Clarity of intent: SafeMIMEMultipart and forbid_multi_line_headers clearly suggest header validation, but MIMEMixin and the validation helper are not defined here, limiting standalone understanding. Code length: The class is concise, although the extensive import block outweighs the implementation shown. Action granularity: Statements generally perform one action per line; tuple unpacking naturally captures the validation result. Reading flow: Initialization followed by header assignment handling is logical and easy to follow. Explicit parent-class calls and abbreviated parameter names add minor reading friction.