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 demonstrates good readability with a clear structure and logical organization. The imports are well-grouped, separating standard library, third-party, and local modules. The class definition follows a single responsibility principle and displays clean action granularity with one operation per line. Nesting is minimal, maintaining a flat structure that enhances comprehension. Variable naming is descriptive and follows Python conventions. The method override in SafeMIMEMultipart clearly expresses its intent to sanitize headers before setting them. While the code could benefit from a class-level docstring explaining the 'Safe' prefix's purpose, the overall flow is natural and the logic is easy to follow. The parameter naming with underscore prefixes follows established conventions for internal parameters, and the explicit call to MIMEMultipart.__init__ makes the inheritance chain clear.
Run 3
The code shows reasonable organization with clear imports and a logical class definition, but has some readability issues. The SafeMIMEMultipart class is fairly flat with low nesting, which is good, and the action granularity is mostly one action per line. However, the intent is partially obscured: the mixin MIMEMixin is used but not imported in the snippet, and the constructor parameter naming with leading underscores is non-standard and confusing. The forbid_multi_line_headers function is called without visible import, making the dependency unclear. The __setitem__ override is concise but the reasoning for the override isn't documented. Overall, the code is functional but would benefit from clearer naming, additional comments explaining security-related overrides, and explicit import clarity.
Run 1
Code Structure: Imports and a small class are logically organized, although many imports are unused in this excerpt and referenced helpers are defined elsewhere. Nesting: Methods are flat, with no nested control flow. Clarity of intent: The class name and header-validation call communicate safe MIME handling, though MIMEMixin and forbid_multi_line_headers require external context. Code length: The class is concise, but the extensive import block outweighs the implementation shown. Action granularity: Each statement performs one clear action; tuple unpacking naturally captures the validation result. Reading flow: Initialization followed by header assignment is natural, and formatting is consistent. Additional separation between import groups and before the class would improve scanning.
Run 2
Code Structure: Imports precede a small, logically organized class, though many imports are unused in this excerpt and referenced helpers are not defined here. Nesting: Methods are flat, with no nested control flow. Clarity of intent: SafeMIMEMultipart and forbid_multi_line_headers clearly suggest header-safety enforcement; abbreviated parameters such as val and _params are less descriptive. Code length: The class is concise, but the extensive import section outweighs its implementation. Action granularity: Each statement performs one clear action; the tuple assignment naturally represents a single validation operation. Reading flow: Initialization followed by header-assignment handling is natural, and formatting is consistent, although additional spacing between import groups and before the class would improve scanning.
Run 3
Code Structure: Imports precede a compact class with clearly separated initialization and header-setting methods, although many imports are unused in this excerpt. Nesting: Methods are flat, with no nested conditionals or loops. Clarity of intent: Class and helper names communicate safe multipart handling and header validation; however, MIMEMixin and forbid_multi_line_headers are not defined here, and val is less descriptive than value. Code length: The class is concise, but the extensive import block overwhelms its small implementation. Action granularity: Each statement performs a focused operation; unpacking validated header values is natural. Reading flow: Initialization followed by header assignment is logical and easy to follow, though missing context and limited spacing between imports and the class slightly weaken readability.