Mengirim surel

Although Python provides a mail sending interface via the smtplib module, Django provides a couple of light wrappers over it. These wrappers are provided to make sending email extra quick, to help test email sending during development, and to provide support for platforms that can't use SMTP.

Kode tinggal dalam modul django.core.mail.

Quick examples

Use send_mail() for straightforward email sending. For example, to send a plain text message:

from django.core.mail import send_mail

send_mail(
    "Subject here",
    "Here is the message.",
    "from@example.com",
    ["to@example.com"],
    fail_silently=False,
)

When additional email sending functionality is needed, use EmailMessage or EmailMultiAlternatives. For example, to send a multipart email that includes both HTML and plain text versions with a specific template and custom headers, you can use the following approach:

from django.core.mail import EmailMultiAlternatives
from django.template.loader import render_to_string

# First, render the plain text content.
text_content = render_to_string(
    "templates/emails/my_email.txt",
    context={"my_variable": 42},
)

# Secondly, render the HTML content.
html_content = render_to_string(
    "templates/emails/my_email.html",
    context={"my_variable": 42},
)

# Then, create a multipart email instance.
msg = EmailMultiAlternatives(
    "Subject here",
    text_content,
    "from@example.com",
    ["to@example.com"],
    headers={"List-Unsubscribe": "<mailto:unsub@example.com>"},
)

# Lastly, attach the HTML content to the email instance and send.
msg.attach_alternative(html_content, "text/html")
msg.send()

Surat dikirim menggunakan rumah SMTP dan port ditentukan dalam pengaturan EMAIL_HOST dan EMAIL_PORT. Pengaturan EMAIL_HOST_USER dan EMAIL_HOST_PASSWORD settings, jika disetel, digunakan untuk mengotentifikasi pada peladen SMTP, dan pengaturan EMAIL_USE_TLS dan EMAIL_USE_SSL mengendalikan apakah hubungan aman digunakan.

Catatan

Kumpulan karakter dari surel dikirim dengan django.core.mail akan disetel ke nilai dari pengaturan DEFAULT_CHARSET anda.

send_mail()

send_mail(subject, message, from_email, recipient_list, fail_silently=False, auth_user=None, auth_password=None, connection=None, html_message=None)[sumber]

Dalam kebanyakan kasus, anda dapat mengirim surel menggunakan django.core.mail.send_mail().

Parameter subject, message, from_email dan recipient_list dibutuhkan.

  • subject: Sebuah string.

  • message: Sebuah string.

  • from_email: Sebuah string. Jika None, Django aan menggunakan nilai dari pengaturan DEFAULT_FROM_EMAIL.

  • recipient_list: Sebuah daftar dari string, setiap alamat surel. Setiap anggota dari recipient_list akan melihat penerima lain dalam bidang "To:" dari pesan surel.

  • fail_silently: A boolean. When it's False, send_mail() will raise an smtplib.SMTPException if an error occurs. See the smtplib docs for a list of possible exceptions, all of which are subclasses of SMTPException.

  • auth_user: Pilihan nama pengguna untuk digunakan mengautentifikasi ke peladen SMTP. Jika ini tidak disediakan, Django akan menggunakan nilai dari pengaturan EMAIL_HOST_USER.

  • auth_password: Sandi pilihan digunakan untuk mengautentifikasi ke peladen SMTP. Jika ini tidak disediakan, Django akan menggunakan nilai dari pengaturan EMAIL_HOST_PASSWORD

  • connection: Backend surel pilihan digunakan untuk mengirim surat. Jika tidak ditentukan, sebuah instance dari backend awalan akan digunakan. Lihat dokumentasi pada Email backends 1 untuk rincian lebih.

  • html_message: Jika html_message disediakan, surel dihasilkan akan berupa surel multipart/alternative dengan message sebagai jenis isi text/plain dan html_message sebagai jenis isi text/html.

Nilai kembalian akan berupa angka dari pesan terkirim yang berhasil (yang dapat berupa 0 atau 1 sejak itu hanya daoat mengirim satu pesan).

send_mass_mail()

send_mass_mail(datatuple, fail_silently=False, auth_user=None, auth_password=None, connection=None)[sumber]

django.core.mail.send_mass_mail() diperuntukkan untuk menangani penyuratan elektronik masal.

datatuple adalah sebuah tuple yang setiap unsur adalah dalam bentuk ini:

(subject, message, from_email, recipient_list)

fail_silently, auth_user dan auth_password mempunyai fungsi sama seperti dalam send_mail().

Setiap unsur terpisah dari datatuple menghasilkan dalam pesan surel terpisah. Seperti dalam send_mail(), penerima dalam recipient_list sama akan semua melihat alamat-alamat lain dalam pesan surel' bidang "To:".

Sebagai contoh, kode berikut akan mengirim dua pesan berbeda pada dua kumpulan berbeda dari penerima; bagaimanapun, hanya satu hubungan ke peladen surat akan dibuka:

message1 = (
    "Subject here",
    "Here is the message",
    "from@example.com",
    ["first@example.com", "other@example.com"],
)
message2 = (
    "Another Subject",
    "Here is another message",
    "from@example.com",
    ["second@test.com"],
)
send_mass_mail((message1, message2), fail_silently=False)

Nilai kembalian akan berupa angka dari pesan terkirim berhasil.

send_mass_mail() x send_mail()

Perbedaan utama diantara send_mass_mail() dan send_mail() adalah bahwa send_mail() membuka sebuah hubungan ke peladen surel setiap itu dijalankan, selagi send_mass_mail() menggunakan hubungan tunggal untuk semua pesan-pesannya. Ini membuat send_mass_mail() sedikit lebih efesien.

mail_admins()

mail_admins(subject, message, fail_silently=False, connection=None, html_message=None)[sumber]

django.core.mail.mail_admins() adalah jalan pintas untuk mengirim sebuah surel pada admin situs, seperti ditentukan dalam pengaturan ADMINS.

mail_admins() mengawali subyek dengan nilai dari pengaturan EMAIL_SUBJECT_PREFIX, yaitu "[Django] " secara awalan.

Kepala "From:" dari surel akan berupa nilai dari pengaturan SERVER_EMAIL.

Metode ini ada untuk kenyamanan dan kesiapan.

Jika html_message disediakan, surel dihasilkan akan berupa surel multipart/alternative dengan message seperti jenis isi text/plain dan html_message seperti jenis isi text/html.

mail_managers()

mail_managers(subject, message, fail_silently=False, connection=None, html_message=None)[sumber]

django.core.mail.mail_managers() seperti mail_admins(), kecuali itu mengirim sebuah surel ke pengelola situs, seperti ditentukan dalam pengaturan MANAGERS.

Contoh

Ini mengirim surel tunggal kepada john@example.com dan jane@example.com, dengan keduanya mereka muncul dalam "To:":

send_mail(
    "Subject",
    "Message.",
    "from@example.com",
    ["john@example.com", "jane@example.com"],
)

Ini mengirim sebuah pesan ke john@example.com dan jane@example.com, dengan keduanya menerima surel terpisah:

datatuple = (
    ("Subject", "Message.", "from@example.com", ["john@example.com"]),
    ("Subject", "Message.", "from@example.com", ["jane@example.com"]),
)
send_mass_mail(datatuple)

Mencegah penyuntikan kepala

Header injection adalah memanfaatkan keamanan dimana seorang penyerang memasukkan kepala surel tambahan untuk mengendalikan "To:" dan "From:" dalam pesan-pesan surel yang tulisan-tulisan anda dibangkitkan.

Fungsi-fungsi surel Django diuraikan diatas semua dilindungi terhadap suntukan kepala dengan melarang baris baru dalam nilai kepala. Jika ada subject, from_email atau recepient_list mengandung sebuah baris baru (dalam salah satu gaya Unix, Windows, atau Mac), fungsi surel (sebagai contoh send_mail()) akan memunculkan django.core.mail.BadHeaderError (sebuah subkelas dari ValueError) dan, karenanya, tidak akan mengirim surel. Itu adalah tanggung jawab anda untuk mengesahkan semua data sebelum melewatkan itu ke fungsi-fungsi surel.

If a message contains headers at the start of the string, the headers will be printed as the first bit of the email message.

Ini adalah sebuah contoh tampilan yang mengambil subject, message dan from_email dari data POST permintaan, mengirim itu ke admin@example.com dan mengalihkan ke "/contact/thanks/" ketika itu selesai:

from django.core.mail import BadHeaderError, send_mail
from django.http import HttpResponse, HttpResponseRedirect


def send_email(request):
    subject = request.POST.get("subject", "")
    message = request.POST.get("message", "")
    from_email = request.POST.get("from_email", "")
    if subject and message and from_email:
        try:
            send_mail(subject, message, from_email, ["admin@example.com"])
        except BadHeaderError:
            return HttpResponse("Invalid header found.")
        return HttpResponseRedirect("/contact/thanks/")
    else:
        # In reality we'd use a form class
        # to get proper validation errors.
        return HttpResponse("Make sure all fields are entered and valid.")

Kelas EmailMessage

Fungsi-fungsi send_mail() dan send_mass_mail() sebenarnya pembungkus kecil yang memanfaatkan dari kelas EmailMessage.

Tidak semua fitur dari kelas EmailMessage tersedia melalui send_mail() dan fungsi-fungsi pembungkus terkait. Jika anda menginginkan menggunakan fitur-fitur lanjutan, seperti penerima BCC, lampiran berkas, atau banyak-bagian surel, anda akan butuh membuat instance EmailMessage langsung.

Catatan

Ini adalah fitur rancangan. send_mail() dan fungsi-fungsi terkait aslinya hanya antarmuka Django sediakan. Bagaimanapun, daftar dari parameter mereka terima pelan-pelan tumbuh terhadap waktu. Itu masuk akal memindahkan rancangan berorientasi-obyek untuk pesan-pesan surel dan memelihara fungsi-fungsi asli hanya untuk kesesuaian kebelakang.

EmailMessage bertanggungjawab untuk membuat pesan surel itu sendiri. email backend 1 kemudian bertanggungjawab untuk mengirim surel.

For convenience, EmailMessage provides a send() method for sending a single email. If you need to send multiple messages, the email backend API provides an alternative.

Obyek EmailMessage

class EmailMessage[sumber]

Kelas EmailMessage diawalkan dengan parameter-parameter berikut (dalam urutan diberikan, jika penempatan argumen-argumen digunakan). Semua parameter adalah pilihan dan dapat disetel pada waktu kapanpun sebelum memanggil metode send().

  • subject: Pokok baris dari surel.

  • body: Teks badan. Ini harus berupa pesan teks polos.

  • from_email: The sender's address. Both fred@example.com and "Fred" <fred@example.com> forms are legal. If omitted, the DEFAULT_FROM_EMAIL setting is used.

  • to: Sebuah list atau tuple dari alamat-alamat penerima.

  • bcc: Sebuah list atau tuple dari alamat-alamat digunakan dalam kepala "Bcc" ketika mengirim surel.

  • connection: An email backend instance. Use this parameter if you are sending the EmailMessage via send() and you want to use the same connection for multiple messages. If omitted, a new connection is created when send() is called. This parameter is ignored when using send_messages().

  • attachments: A list of attachments to put on the message. These can be either MIMEBase instances, or (filename, content, mimetype) triples.

  • header: Sebuah dictionary dari kepala tambahan untuk menaruh pesan. Kunci-kunci adalah nama kepala, nilai-nilai adalah nilai-nilai kepala. Itu terserah pada pemanggil untuk memastikan nama=nama dan nilai-nilai dalam bentuk benar untuk pesan surel. Atribut sesuai adalah extra_headers.

  • cc: Sebuah list atau tuple dari alamat-alamat penerima digunakan dalam kepala "Cc" ketika mengirim surel.

  • reply_to: Sebuah list atau tuple dari alamat-alamat penerima dalam kepala "Reply-To" ketika mengirim surel.

Sebagai contoh:

from django.core.mail import EmailMessage

email = EmailMessage(
    "Hello",
    "Body goes here",
    "from@example.com",
    ["to1@example.com", "to2@example.com"],
    ["bcc@example.com"],
    reply_to=["another@example.com"],
    headers={"Message-ID": "foo"},
)

Kelas mempunyai cara berikut:

  • send(fail_silently=False) sends the message. If a connection was specified when the email was constructed, that connection will be used. Otherwise, an instance of the default backend will be instantiated and used. If the keyword argument fail_silently is True, exceptions raised while sending the message will be quashed. An empty list of recipients will not raise an exception. It will return 1 if the message was sent successfully, otherwise 0.

  • message() constructs a django.core.mail.SafeMIMEText object (a subclass of Python's MIMEText class) or a django.core.mail.SafeMIMEMultipart object holding the message to be sent. If you ever need to extend the EmailMessage class, you'll probably want to override this method to put the content you want into the MIME object.

  • recipients() mengembalikan daftar dari semua penerima dari pesan, apakah mereka adalah terekam dalam atribut to, cc atau bcc. Ini adalah metode lain anda mungkin butuh untuk menimpa ketika mensubkelaskan, karena peladen SMTP butuh diberitahu daftar penuh dari penerima ketika pesan dikirim. Jika anda menambah cara lain untuk menentukan penerima dalam kelas anda, mereka butuh dikembalikan dari metode ini juga.

  • attach() membuat lampiran berkas baru dan menambahkan itu ke pesan. Ada dua cara memanggil attach():

    • You can pass it a single argument that is a MIMEBase instance. This will be inserted directly into the resulting message.

    • Kalau tidak, anda dapat melewatkan tiga argumen attach(): filename, content dan mimetype. filename adalah nama dari lampiran berkas ketika itu muncul dalam surel, content adalah data yang akan di isi didalam lampiran dan mimetype adalah jenis MIME untuk lampiran. Jika anda menghilangkan mimetype, jenis isi MIME akan ditebak dari nama berkas dari lampiran.

      Sebagai contoh:

      message.attach("design.png", img_data, "image/png")

      If you specify a mimetype of message/rfc822, it will also accept django.core.mail.EmailMessage and email.message.Message.

      For a mimetype starting with text/, content is expected to be a string. Binary data will be decoded using UTF-8, and if that fails, the MIME type will be changed to application/octet-stream and the data will be attached unchanged.

      In addition, message/rfc822 attachments will no longer be base64-encoded in violation of RFC 2046 Section 5.2.1, which can cause issues with displaying the attachments in Evolution and Thunderbird.

  • attach_file() creates a new attachment using a file from your filesystem. Call it with the path of the file to attach and, optionally, the MIME type to use for the attachment. If the MIME type is omitted, it will be guessed from the filename. You can use it like this:

    message.attach_file("/images/weather_map.png")

    For MIME types starting with text/, binary data is handled as in attach().

Mengirim pilihan lain jenis isi

Sending multiple content versions

It can be useful to include multiple versions of the content in an email; the classic example is to send both text and HTML versions of a message. With Django's email library, you can do this using the EmailMultiAlternatives class.

class EmailMultiAlternatives[sumber]

A subclass of EmailMessage that has an additional attach_alternative() method for including extra versions of the message body in the email. All the other methods (including the class initialization) are inherited directly from EmailMessage.

attach_alternative(content, mimetype)[sumber]

Attach an alternative representation of the message body in the email.

For example, to send a text and HTML combination, you could write:

from django.core.mail import EmailMultiAlternatives

subject = "hello"
from_email = "from@example.com"
to = "to@example.com"
text_content = "This is an important message."
html_content = "<p>This is an <strong>important</strong> message.</p>"
msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
msg.attach_alternative(html_content, "text/html")
msg.send()

Updating the default content type

Secara awalan, jenis MIME dari parameter body dalam sebuah EmailMessage adalah "text/plain". Itu adalah praktik bagus untuk meninggalkan ini sendiri, karena itu menjamin penerima manapun akan dapat membaca surel, tidak peduli dari surat klien mereka. Bagaimanapun, jika anda sedang percaya diri bahwa penerima anda dapat menangani sebuah jenis isi lain, anda dapat menggunakan atribut content_subtype pada kelas EmailMessage untuk merubah jenis isi utama. Jenis utama akan selalu "text", tetapi anda dapat merubah subjenis. Sebagai contoh:

msg = EmailMessage(subject, html_content, from_email, [to])
msg.content_subtype = "html"  # Main content is now text/html
msg.send()

Backend email

Pengiriman sebenarnya dari sebuah surel ditangani oleh backend email.

Kelas backend surel mempunyai metode-metode berikut:

  • open() instantiates a long-lived email-sending connection.

  • close() menutup hubungan mengirim-surel saat ini.

  • send_messages(email_messages) sends a list of EmailMessage objects. If the connection is not open, this call will implicitly open the connection, and close the connection afterward. If the connection is already open, it will be left open after mail has been sent.

Itu dapat juga digunakan sebagai pengelola konteks, yang akan otomatis memanggil open() dan close() sesuai kebutuhan:

from django.core import mail

with mail.get_connection() as connection:
    mail.EmailMessage(
        subject1,
        body1,
        from1,
        [to1],
        connection=connection,
    ).send()
    mail.EmailMessage(
        subject2,
        body2,
        from2,
        [to2],
        connection=connection,
    ).send()

Mengambil sebuah instance dari sebuah backend surel.

Fungsi get_connection() dalam django.core.mail mengembalikan sebuah instance dari backend surel yang anda dapat gunakan.

get_connection(backend=None, fail_silently=False, *args, **kwargs)[sumber]

Secara awalan, sebuah panggilan pada get_connection() akan mengembalikan sebuah instance dari backend surel ditentukan dalam EMAIL_BACKEND. Jika anda menentukan argumen backend, sebuah instance dari backend itu akan diinstasiasikan.

Argumen fail_silently mengendalikan bagaimana backend harus menangani kesalahan. Jika fail_silently adalah True, pengecualian selama pengolahan mengirim surel akan secara diam diabaikan.

Semua argumen lain dilewatkan langsung ke pembangun dari backend surel.

Django dikirim dengan beberapa backend pengiriman surel. Dengan pengecualian dari backend SMTP (yaitu awalan), backend ini hanya berguna selama percobaan dan pengembangan. Jika anda mempunyai persyaratan mengirim surel khusus, anda dapat write your own email backend.

Backend SMTP

class backends.smtp.EmailBackend(host=None, port=None, username=None, password=None, use_tls=None, fail_silently=False, use_ssl=None, timeout=None, ssl_keyfile=None, ssl_certfile=None, **kwargs)

Ini adalah backend awalan. Surel akan dikirim melalui peladen SMTP.

Nilai untuk setiap argumen diambil dari pencocokan pengaturan jika argumen adalah None:

Backend SMTP adalah konfigurasi awalan diwarisi oleh Django. Jika anda ingin menentukan itu secara jelas, taruh berikut dalam pengaturan anda:

EMAIL_BACKEND = "django.core.mail.backends.smtp.EmailBackend"

Jika tidak ditentukan, timeout awalan akan berupa satu disediakan oleh socket.getdefaulttimeout(), yang awalan pada None (tidak ada waktu habis).

Backend konsol

Daripada mengirim keluar surel asli backend konsol hanya menulis surel yang akan dikirim ke keluaran standar. Secara awalan, backend konsol menulis ke stdout. Anda dapat menggunakan obyek aliran-seperti berbeda dengan menyediakan argumen katakunci stream ketika membangun hubungan.

Untuk menentukan backend ini, taruh berikut dalam pengaturan anda:

EMAIL_BACKEND = "django.core.mail.backends.console.EmailBackend"

Backend ini tidak diperuntukkan untuk penggunaan dalam produksi -- itu disediakan sebagai kenyamanan yang dapat digunakan selama pengembangan.

Backend berkas

Backend berkas menulis surel pada sebuah berkas. Sebuah berkas baru dibuat untuk setiap sesi baru yang terbuka pada backend ini. Direktori dimana berkas-berkas ditulis adalah baik diambil dari pengaturan EMAIL_FILE_PATH atau dari katakunci file_path ketika membuat sebuah hubungan dengan get_connection().

Untuk menentukan backend ini, taruh berikut dalam pengaturan anda:

EMAIL_BACKEND = "django.core.mail.backends.filebased.EmailBackend"
EMAIL_FILE_PATH = "/tmp/app-messages"  # change this to a proper location

Backend ini tidak diperuntukkan untuk penggunaan dalam produksi -- itu disediakan sebagai kenyamanan yang dapat digunakan selama pengembangan.

backend di-memory

Backend 'locmem' menyimpan pesan-pesan dalam atribut khusus dari modul django.core.mail. Atribut outbox dibuat ketika pesan pertama dikirim. Itu adalah daftar dalam sebuah instance EmailMessage untuk setiap pesan yang akan dikirim.

Untuk menentukan backend ini, taruh berikut dalam pengaturan anda:

EMAIL_BACKEND = "django.core.mail.backends.locmem.EmailBackend"

Backend ini tidak dimaksudkan untuk digunakan dalam produksi -- itu disediakan sebagai kenyamanan yang dapat digunakan selama pengembangan dan percobaan.

Django's test runner automatically uses this backend for testing.

Backend tiruan

Ketika nama menganjurkan backend tiruan tidak melakukan apapun dengan pesan-pesan anda. Untuk menentukan backend ini, taruh berikut dalam pengaturan anda:

EMAIL_BACKEND = "django.core.mail.backends.dummy.EmailBackend"

Backend ini tidak diperuntukkan untuk penggunaan dalam produksi -- itu disediakan sebagai kenyamanan yang dapat digunakan selama pengembangan.

Menentukan penyesuaian backend surel

Jika anda butuh merubah bagaimana surel dikirim anda dapat menulis backend surel anda sendiri. Pengaturan EMAIL_BACKEND dalam berkas pengaturan anda adalah kemudian Pythn mengimpor jalur untuk kelas backend anda.

Backend surel penyesuaian harus subkelas BaseEmailBackend yaitu bertempat dalam modul django.core.mail.backends.base. Sebuah backend surel penyesuaian harus menerapkan metode send_messages(email_messages). Metode ini menerima daftar dari instance EmailMessage dan mengembalikan sejumlah dari pesan-pesan terkirim. Jika backend anda mempunyai konsep apapun dari sesi atau hubungan yang gigih, anda harus juga menerapkan metode open() dan close(). Mengacu pada smtp.EmailBackend untuk penerapan acuan.

Mengirim banyak surel

Membangun dan menutup hubungan SMTP (atau hubungan jaringan lain, untuk masalah itu) adalah sebuah pengolahan yang mahal. Jika anda mempunyai banyak surel untuk dikirim, itu masuk akal menggunakan kembali hubungan SMTP, daripada membuat dan manghancurkan hubungan setiap kali anda ingin mengirim surel.

Ada dua cara memberitahu sebuah backend surel untuk menggunakan kembali sebuah hubungan.

Firstly, you can use the send_messages() method on a connection. This takes a list of EmailMessage (or subclass) instances, and sends them all using that single connection. As a consequence, any connection set on an individual message is ignored.

Sebagai contoh, jika anda mempunyai sebuah fungsi dipanggil get_notification_email() yang mengembalikan daftar dari obyek EmailMessage mewakili beberapa surel berkala anda ingin kirimkan, anda dapat mengirim surel ini menggunakan panggilan tunggal untuk send_messages:

from django.core import mail

connection = mail.get_connection()  # Use default email connection
messages = get_notification_email()
connection.send_messages(messages)

Dalam contoh ini, panggilan pada send_messages() membuka hubungan pada backend, mengirim daftar pesan-pesan, dan kemudian menutup hubungan kembali.

Pendekatan kedua adalah menggunakan metode open() dan close() pada backend surel untuk secara manual mengendalikan hubungan. send_messages() tidak akan secara manual membuka atau menutup hubungan jika itu sudah terbuka, jadi jika anda membuka secara munual hubungan, anda dapat mengendalikan ketika itu tertutup. Sebagai contoh:

from django.core import mail

connection = mail.get_connection()

# Manually open the connection
connection.open()

# Construct an email message that uses the connection
email1 = mail.EmailMessage(
    "Hello",
    "Body goes here",
    "from@example.com",
    ["to1@example.com"],
    connection=connection,
)
email1.send()  # Send the email

# Construct two more messages
email2 = mail.EmailMessage(
    "Hello",
    "Body goes here",
    "from@example.com",
    ["to2@example.com"],
)
email3 = mail.EmailMessage(
    "Hello",
    "Body goes here",
    "from@example.com",
    ["to3@example.com"],
)

# Send the two emails in a single call -
connection.send_messages([email2, email3])
# The connection was already open so send_messages() doesn't close it.
# We need to manually close the connection.
connection.close()

Konfigurasi surel untuk pengembangan

Ada saatnya ketika anda tidak ingn Django mengirim surel sama sekali. Sebagai contoh, selagi mengembangkan sebuah situs jaringan, anda mungkin tidak ingin mengirim ribuan surel -- tetapi anda mungkin ingin mensahkan surel akan dikirim ke orang benar dibawah suasana yang benar, dan surel itu akan mengandung isi benar.

The easiest way to configure email for local development is to use the console email backend. This backend redirects all email to stdout, allowing you to inspect the content of mail.

Backend surel file dapat berguna selama pengembangan -- backend ini membuang isi dari setiap hubungan SMTP ke sebuah berkas yang dapat diperiksa pada waktu luang anda.

Another approach is to use a "dumb" SMTP server that receives the emails locally and displays them to the terminal, but does not actually send anything. The aiosmtpd package provides a way to accomplish this:

python -m pip install aiosmtpd

python -m aiosmtpd -n -l localhost:8025

This command will start a minimal SMTP server listening on port 8025 of localhost. This server prints to standard output all email headers and the email body. You then only need to set the EMAIL_HOST and EMAIL_PORT accordingly. For a more detailed discussion of SMTP server options, see the documentation of the aiosmtpd module.

For information about unit-testing the sending of emails in your application, see the Layanan surel section of the testing documentation.

Back to Top