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 is moderately readable but has several issues. The import section is lengthy but organized by type. The class definition is simple, but the __init__ method contains multiple operations in a single line and lacks type hints or docstrings. The __setitem__ method chains a helper function call with a parent method call, which reduces clarity. The use of double underscores and mixing of MIMEMixin and MIMEMultipart inheritance creates ambiguity about the class's true purpose. While the code is flat and not deeply nested, the lack of comments explaining the safety wrapper's intent hurts comprehension. The variable naming like _subtype and **_params is conventional for MIME but may confuse newcomers. Overall, the code is functional but could benefit from better documentation and clearer separation of actions.
Run 2
The code has a clear logical organization with imports grouped by source (standard library, third-party, local modules), which aids readability. The class structure is simple with straightforward inheritance and an explicit constructor that delegates to the parent class while adding an encoding attribute. However, readability is reduced by several factors: the constructor uses positional arguments with underscore-prefixed names suggesting internal use, which is not immediately clear. The __setitem__ method chains a function call with a parent method call in a single expression, reducing action granularity. The purpose of forbid_multi_line_headers is only hinted at by its name, but its behavior and side effects remain unclear without context. Variable names like _params and _subtype are cryptic. The code is concise but could be more readable with better parameter naming and by separating the validation from the assignment in __setitem__. The reading flow is generally natural, but the mix of protected-style parameters and method chaining makes the intent somewhat ambiguous.
Run 3
The code is partially readable. The imports are logically grouped and ordered, which aids navigation. The class definition and constructor signature are clear. However, readability is hurt by the presence of deprecated or complex utilities (e.g., deprecation wrappers) and by MIME's inherent reliance on single-letter variables like '_params', which obscure intent. The `__setitem__` method performs validation and assignment cleanly, but the overall structure remains flat yet dense due to the large import block. While not deeply nested, the code assumes familiarity with Django's email internals, making it less accessible to general readers. Concise but domain-heavy.
Run 1
Code Structure: Imports precede a small, logically organized class, though many imports are unused in this excerpt. Nesting: Methods are flat with no nested control flow. Clarity of intent: SafeMIMEMultipart and forbid_multi_line_headers clearly convey header-safety behavior, although MIMEMixin and the validation helper are not defined here, and val is a generic name. Code length: The class is concise, but the extensive import block dominates the excerpt. Action granularity: Each statement performs a distinct action; tuple unpacking naturally represents the validation result. Reading flow: Initialization followed by header assignment is easy to follow, with consistent formatting and a readable multiline signature. Additional separation between import groups and before the class would improve scanning.
Run 2
Code Structure: Imports precede a compact class with clearly separated initialization and header-assignment methods, though many imports are unused in this excerpt. Nesting: Flat methods with no nested control flow make the code easy to scan. Clarity of intent: SafeMIMEMultipart and forbid_multi_line_headers communicate safe MIME header handling, although MIMEMixin and the validation helper are defined elsewhere. Code length: The class is concise, but the extensive import block outweighs the implementation shown. Action granularity: Each statement performs a single clear operation. Reading flow: Initialization followed by customized header assignment is natural; explicit parent-class calls are understandable, though super() could make the inheritance flow more idiomatic.
Run 3
Code Structure: Imports are grouped logically, and the class cleanly separates initialization from header assignment, though many imports are unused in this excerpt. Nesting: Both methods are flat and easy to follow. Clarity of intent: The class name and header-validation call clearly suggest safe MIME handling, but MIMEMixin and forbid_multi_line_headers are not defined here, and abbreviated parameter names require familiarity with the underlying API. Code length: The class is concise; the extensive import section is disproportionate to the shown functionality. Action granularity: Each statement performs a distinct operation, with tuple assignment naturally representing one validation step. Reading flow: Initialization followed by assignment interception creates a natural progression, although an additional blank line before the class and a short explanatory docstring would improve presentation.