---
title: "Seoladh ríomhphoist"
version: 6.0
locale: ga
source: https://docs.djangoproject.com/ga/6.0/topics/email/
canonical: https://djangodocs.dev/ga/6.0/topics/email/
---
# Seoladh ríomhphoist

Cé go soláthraíonn Python comhéadan seolta ríomhphoist tríd an modúl: mod: smtplib, soláthraíonn Django cúpla fillteán éadrom air. Cuirtear na fillteáin seo ar fáil chun ríomhphost a sheoladh go tapa, chun cabhrú le seoladh ríomhphoist a thástáil le linn na forbartha, agus chun tacaíocht a sholáthar d'ardáin nach féidir leo SMTP a úsáid.

Tá an cód ina gcónaí sa mhodúl `django.core.mail`.

## Samplaí gasta

Úsáid: func: send\_mail le haghaidh seoladh ríomhphoist simplí. Mar shampla, chun teachtaireacht téacs simplí a sheoladh:

```
from django.core.mail import send_mail

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

Nuair a bhíonn feidhmiúlacht bhreise seolta ríomhphoist ag teastáil, bain úsáid as: class: EmailMessage nó:class: EmailMultiAlternatives. Mar shampla, chun ríomhphost ilpháirteach a sheoladh a chuimsíonn leaganacha HTML agus téacs simplí le teimpléad ar leith agus ceanntásca saincheaptha, is féidir leat an cur chuige seo a leanas a úsáid:

```
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="Subject here",
    body=text_content,
    from_email="from@example.com",
    to=["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()
```

Seoltar ríomhphost ag baint úsáide as an óstach SMTP agus an calafort a shonraítear sna socruithe:: EMAIL\_HOST agus:setting: EMAIL\_PORT. Úsáidtear socruithe an:SETTING: EMAIL\_HOST\_USER agus:setting: EMAIL\_HOST\_PASSWORD, má tá sé socraithe, chun fíordheimhniú chuig an bhfreastalaí SMTP, agus rialaíonn an:setting: EMAIL\_USE\_TLS agus:setting: EMAIL\_USE\_SSL an bhfuil nasc slán.

> **Note**
>
> Socrófar an tacar carachtair ríomhphoist a sheoltar le `django.core.mail` ar luach do shuíomh: DEFAULT\_CHARSET.

## seol\_mail () \`\`

#### `send_mail(subject, message, from_email, recipient_list, * (Keyword-only parameters separator (PEP 3102)), fail_silently=False, auth_user=None, auth_password=None, connection=None, html_message=None)`

I bhformhór na gcásanna, is féidir leat ríomhphost a sheoladh ag baint úsáide as django.core.mail.send\_mail () .

Teastaíonn na paraiméadair ```ábhar ``, `teachtaire```, from\_email\` agus `liosta_faighteannaithe`.

- ábhar : Sreang.
- teachtaireacht : Sreang.
- `from_email`: teaghrán. Má tá `None`, úsáidfidh Django luach an socruithe:: DEFAULT\_FROM\_EMAIL.
- `recipient_list`: Liosta teaghráin, seoladh ríomhphoist gach ceann acu. Feicfidh gach ball de `recipient_list` na faighteoirí eile sa réimse “Chun:” den teachtaireacht ríomhphoist.

The following parameters are optional, and must be given as keyword arguments
if used.

- `fail_silently`: Boolean. Nuair a bhíonn sé False\`, ardóidh send\_mail () an:exc: smtplib.smtpException má tharlaíonn earráid. Féach na docs: mod: smtplib le haghaidh liosta de na heisceachtaí féideartha, agus is fo-aicmí iad uile ceann de: exc: ~smtplib.smtpException.
- `auth_user`: An t-ainm úsáideora roghnach le húsáid chun fíordheimhniú chuig an bhfreastalaí SMTP. Mura gcuirtear é seo ar fáil, úsáidfidh Django luach an socruithe: setting: EMAIL\_HOST\_USER.
- `auth_password`: An pasfhocal roghnach le húsáid chun fíordheimhniú chuig an bhfreastalaí SMTP. Mura gcuirtear é seo ar fáil, úsáidfidh Django luach an socruithe:: EMAIL\_HOST\_PASSWORD.
- `nasc`: An cúltaca roghnach ríomhphoist le húsáid chun an post a sheoladh. Mura bhfuil sé sonraithe, úsáidfear sampla den chúltaca réamhshocraithe. Féach an doiciméadú ar:ref: Ríomhphost backends \<topic-email-backends\>\`le haghaidh tuilleadh sonraí.
- `html_message`: Má chuirtear html\_message\` ar fáil, beidh an ríomhphost mar thoradh air:: mimetype: multipart/alternative \`r-phost le \`\`teachtaire\` mar an cineál ábhair: mimetype: text/plain agus `html_message` mar an:mimetype: text/html cineál ábhair.

Is é an luach tuairisceáin líon na dteachtaireachtaí a sheachadadh go rathúil (ar féidir iad a bheith `0` nó `1` ós rud é nach féidir leis ach teachtaireacht amháin a sheoladh).

> **Deprecated since Django 6.0**
>
> Deprecated since version 6.0: Passing `fail_silently` and later parameters as positional arguments is
> deprecated.

## seol\_mass\_mail () \`\`

#### `send_mass_mail(datatuple, * (Keyword-only parameters separator (PEP 3102)), fail_silently=False, auth_user=None, auth_password=None, connection=None)`

Tá sé beartaithe ag django.core.mail.send\_mass\_mail () ollseoladh ríomhphoist a láimhseáil.

Is é datatuple\` tuple ina bhfuil gach eilimint sa fhormáid seo:

```
(subject, message, from_email, recipient_list)
```

`fail_silently`, `auth_user`, `auth_password` and `connection` have the
same functions as in [`send_mail()`](#django.core.mail.send_mail). They must be given as keyword arguments
if used.

Each separate element of `datatuple` results in a separate email message.
As in [`send_mail()`](#django.core.mail.send_mail), recipients in the same `recipient_list` will all see
the other addresses in the email messages' "To:" field.

Mar shampla, chuirfeadh an cód seo a leanas dhá theachtaireacht éagsúla chuig dhá shraith éagsúla faighteoirí; áfach, ní osclófaí ach nasc amháin leis an bhfreastalaí ríomhphoist:

```
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)
```

Is é an luach tuairisceáin líon na dteachtaireachtaí a sheachadadh go rathúil.

> **Deprecated since Django 6.0**
>
> Deprecated since version 6.0: Passing `fail_silently` and later parameters as positional arguments is
> deprecated.

### ```send_mass_mail () ``vs ``send_mail ()```

The main difference between [`send_mass_mail()`](#django.core.mail.send_mass_mail) and [`send_mail()`](#django.core.mail.send_mail) is
that [`send_mail()`](#django.core.mail.send_mail) opens a connection to the mail server each time it's
executed, while [`send_mass_mail()`](#django.core.mail.send_mass_mail) uses a single connection for all of its
messages. This makes [`send_mass_mail()`](#django.core.mail.send_mass_mail) slightly more efficient.

## mail\_admins () \`\`

#### `mail_admins(subject, message, * (Keyword-only parameters separator (PEP 3102)), fail_silently=False, connection=None, html_message=None)`

Is aicearra é django.core.mail.mail\_admins () chun ríomhphost a sheoladh chuig riarthóirí an láithreáin, mar a shainmhínítear sa socrú: ADMINS.

Réamhshocraíonn ```mail_admins () ``an t-ábhar le luach an socrú: `EMAIL_SUBJECT_PREFIX`, arb é``` "\[Django\] “de réir réamhshocraithe.

Is é ceannteideal “Ó:” an ríomhphoist luach an socruithe: setting: SERVER\_EMAIL.

Tá an modh seo ann le haghaidh áisiúlachta agus inléiteachta.

Má chuirtear html\_message\` ar fáil, beidh an ríomhphost mar thoradh air:: mimetype: multipart/alternative \`r-phost le \`teachtaire\` mar an:mimetype: text/plain cineál ábhair agus html\_message\` mar an cineál ábhair: mimetype: text/html.

> **Deprecated since Django 6.0**
>
> Deprecated since version 6.0: Passing `fail_silently` and later parameters as positional arguments is
> deprecated.

## bainisteoirí poist () \`\`

#### `mail_managers(subject, message, * (Keyword-only parameters separator (PEP 3102)), fail_silently=False, connection=None, html_message=None)`

Tá ```django.core.mail.mail_managers () ``díreach cosúil le ``mail_admins ()```, ach amháin go seolann sé ríomhphost chuig bainisteoirí an láithreáin, mar a shainmhínítear sa socrú: MANAGERS.

> **Deprecated since Django 6.0**
>
> Deprecated since version 6.0: Passing `fail_silently` and later parameters as positional arguments is
> deprecated.

## Samplaí

Seolann sé ríomhphost amháin chuig [john@example.com](mailto:john@example.com) agus [jane@example.com](mailto:jane@example.com), agus tá an bheirt acu le feiceáil sa “Chun:”:

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

This sends a message to `john@example.com` and `jane@example.com`, with
them both receiving a separate email:

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

## Instealladh ceannteidil

Is saothrú slándála é [instealladh ceannteannair](http://www.nyphp.org/phundamentals/8_Preventing-Email-Header-Injection.html) ina gcuireann ionsaitheoir ceannteidil ríomhphoist breise isteach chun an “Chun:” agus “Ó:” a rialú i dteachtaireachtaí ríomhphoist a ghineann do scripteanna.

The Django email functions outlined above all protect against header injection
by forbidding newlines in header values. If any `subject`, `from_email` or
`recipient_list` contains a newline (in either Unix, Windows or Mac style),
the email function (e.g. [`send_mail()`](#django.core.mail.send_mail)) will raise [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError) and,
hence, will not send the email. It's your responsibility to validate all data
before passing it to the email functions.

Má tá ceanntásca i “teachtaireacht” ag tús an teaghrán, clófar na ceanntásca mar an chéad ghiotán den teachtaireacht ríomhphoist.

Here's an example view that takes a `subject`, `message` and `from_email`
from the request's POST data, sends that to `admin@example.com` and redirects
to "/contact/thanks/" when it's done:

```
from django.core.mail import 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 ValueError:
            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.")
```

> **Changed in Django 6.0**
>
> Older versions raised `django.core.mail.BadHeaderError` for some
> invalid headers. This has been replaced with `ValueError`.

## An rang `EmailMessage`

Django's [`send_mail()`](#django.core.mail.send_mail) and [`send_mass_mail()`](#django.core.mail.send_mass_mail) functions are actually
thin wrappers that make use of the [`EmailMessage`](#django.core.mail.EmailMessage) class.

Not all features of the [`EmailMessage`](#django.core.mail.EmailMessage) class are available through the
[`send_mail()`](#django.core.mail.send_mail) and related wrapper functions. If you wish to use advanced
features, such as BCC'ed recipients, file attachments, or multi-part email,
you'll need to create [`EmailMessage`](#django.core.mail.EmailMessage) instances directly.

> **Note**
>
> This is a design feature. [`send_mail()`](#django.core.mail.send_mail) and related functions were
> originally the only interface Django provided. However, the list of
> parameters they accepted was slowly growing over time. It made sense to
> move to a more object-oriented design for email messages and retain the
> original functions only for backwards compatibility.

[`EmailMessage`](#django.core.mail.EmailMessage) is responsible for creating the email message itself. The
[email backend](#topic-email-backends) is then responsible for sending the
email.

For convenience, [`EmailMessage`](#django.core.mail.EmailMessage) provides a [`send()`](#django.core.mail.EmailMessage.send)
method for sending a single email. If you need to send multiple messages, the
email backend API [provides an alternative](#topics-sending-multiple-emails).

### `Ríomhphost teachtaire` Cuspóirí

#### `class EmailMessage`

The `EmailMessage` class is initialized with the following
parameters. All parameters are optional and can be set at any time prior
to calling the [`send()`](#django.core.mail.EmailMessage.send) method.

The first four parameters can be passed as positional or keyword arguments,
but must be in the given order if positional arguments are used:

- ábhar : Líne ábhair an ríomhphoist.
- corp : An téacs comhlachta. Ba chóir go mbeadh sé seo ná teachtaireacht téacs simplí.
- `from_email`: Seoladh an tseoltóra. \< [fred@example.com](mailto:fred@example.com) \>Tá an dá fhoirm `fred@example.com` agus "Fred dlíthiúil. Má fhágtar amach, úsáidtear an socrú:setting: DEFAULT\_FROM\_EMAIL.
- : Liosta nó feadán de sheoltaí faighteora.

The following parameters must be given as keyword arguments if used:

- `cc`: Liosta nó cúpla de sheoltaí faighteora a úsáidtear sa cheanntásc “Cc” agus an ríomhphost á sheoladh.
- `bcc`: Liosta nó tuple seoltaí a úsáidtear sa cheanntásc “Bcc” agus an ríomhphost á sheoladh.
- `reply_to`: Liosta nó cúpla de sheoltaí faighteora a úsáidtear sa cheanntásc “Reply-To” agus an ríomhphost á sheoladh.
- `attachments`: A list of attachments to put on the message. Each can
  be an instance of [`MIMEPart`](https://docs.python.org/3/library/email.message.html#email.message.MIMEPart) or
  [`EmailAttachment`](#django.core.mail.EmailAttachment), or a tuple with attributes
  `(filename, content, mimetype)`.

  > **Changed in Django 5.2**
  >
  > Support for [`EmailAttachment`](#django.core.mail.EmailAttachment) items of `attachments` was
  > added.

  > **Changed in Django 6.0**
  >
  > Support for [`MIMEPart`](https://docs.python.org/3/library/email.message.html#email.message.MIMEPart) objects in the
  > `attachments` list was added.

  > **Deprecated since Django 6.0**
  >
  > Deprecated since version 6.0: Support for Python's legacy [`MIMEBase`](https://docs.python.org/3/library/email.mime.html#email.mime.base.MIMEBase)
  > objects in `attachments` is deprecated. Use
  > [`MIMEPart`](https://docs.python.org/3/library/email.message.html#email.message.MIMEPart) instead.
- `headers`: Foclóir ceanntásca breise le cur ar an teachtaireacht. Is iad na heochracha ainm an ceanntásc, is iad luachanna na luachanna ceanntásc. Is faoin nglaoiteoir atá sé a chinntiú go bhfuil ainmneacha agus luachanna ceanntásc san fhormáid cheart do theachtaireacht ríomhphoist. Is é an tréith chomhfhreagrach ná `extra_headers`.
- `connection`: An [email backend](#topic-email-backends) instance.
  Use this parameter if you are sending the `EmailMessage` via
  [`send()`](#django.core.mail.EmailMessage.send) and you want to use the same connection for multiple
  messages. If omitted, a new connection is created when [`send()`](#django.core.mail.EmailMessage.send) is
  called. This parameter is ignored when using
  [send\_messages()](#topics-sending-multiple-emails).

> **Deprecated since Django 6.0**
>
> Deprecated since version 6.0: Passing all except the first four parameters as positional arguments is
> deprecated.

Mar shampla:

```
from django.core.mail import EmailMessage

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

Tá na modhanna seo a leanas ag an rang:

#### `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(* (Keyword-only parameters separator (PEP 3102)), policy=email.policy.default)`

Constructs and returns a Python [`email.message.EmailMessage`](https://docs.python.org/3/library/email.message.html#email.message.EmailMessage)
object representing the message to be sent.

The keyword argument `policy` allows specifying the set of rules for
updating and serializing the representation of the message. It must be
an [`email.policy.Policy`](https://docs.python.org/3/library/email.policy.html#module-email.policy) object. Defaults to
[`email.policy.default`](https://docs.python.org/3/library/email.policy.html#email.policy.default). In certain cases you may want to use
[`SMTP`](https://docs.python.org/3/library/email.policy.html#email.policy.SMTP), [`SMTPUTF8`](https://docs.python.org/3/library/email.policy.html#email.policy.SMTPUTF8) or a custom
policy. For example,
[`django.core.mail.backends.smtp.EmailBackend`](#django.core.mail.backends.smtp.EmailBackend) uses the
[`SMTP`](https://docs.python.org/3/library/email.policy.html#email.policy.SMTP) policy to ensure `\r\n` line endings as
required by the SMTP protocol.

If you ever need to extend Django's [`EmailMessage`](#django.core.mail.EmailMessage) class,
you'll probably want to override this method to put the content you
want into the Python EmailMessage object.

> **Changed in Django 6.0**
>
> The `policy` keyword argument was added and the return type was
> updated to an instance of [`EmailMessage`](https://docs.python.org/3/library/email.message.html#email.message.EmailMessage).

#### `recipients()`

Returns a list of all the recipients of the message, whether they're
recorded in the `to`, `cc` or `bcc` attributes. This is another
method you might need to override when subclassing, because the SMTP
server needs to be told the full list of recipients when the message
is sent. If you add another way to specify recipients in your class,
they need to be returned from this method as well.

#### `attach(filename, content, mimetype)`

#### `attach(mimepart)`

Creates a new attachment and adds it to the message. There are two ways
to call `attach()`:

- You can pass it three arguments: `filename`, `content` and
  `mimetype`. `filename` is the name of the file attachment as it
  will appear in the email, `content` is the data that will be
  contained inside the attachment and `mimetype` is the optional MIME
  type for the attachment. If you omit `mimetype`, the MIME content
  type will be guessed from the filename of the attachment.

  Mar shampla:

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

  If you specify a `mimetype` of `message/rfc822`,
  `content` can be a [`django.core.mail.EmailMessage`](#django.core.mail.EmailMessage) or
  Python's [`email.message.EmailMessage`](https://docs.python.org/3/library/email.message.html#email.message.EmailMessage) or
  [`email.message.Message`](https://docs.python.org/3/library/email.compat32-message.html#email.message.Message).

  Maidir le mimetype\` ag tosú le:mimetype: text/, táthar ag súil go mbeidh an t-ábhar ina shreang. Déanfar sonraí dénártha a dhíchódú ag baint úsáide as UTF-8, agus má theipeann air sin, athrófar an cineál MIME go: mimetype: application/octet-stream agus cuirfear na sonraí ceangailte gan athrú.
- Or for attachments requiring additional headers or parameters, you
  can pass `attach()` a single Python
  [`MIMEPart`](https://docs.python.org/3/library/email.message.html#email.message.MIMEPart) object. This will be attached
  directly to the resulting message. For example, to attach an inline
  image with a `Content-ID`:

  ```
  import email.utils
  from email.message import MIMEPart
  from django.core.mail import EmailMultiAlternatives

  message = EmailMultiAlternatives(...)
  image_data_bytes = ...  # Load image as bytes

  # Create a random Content-ID, including angle brackets
  cid = email.utils.make_msgid()
  inline_image = email.message.MIMEPart()
  inline_image.set_content(
      image_data_bytes,
      maintype="image",
      subtype="png",  # or "jpeg", etc. depending on the image type
      disposition="inline",
      cid=cid,
  )
  message.attach(inline_image)
  # Refer to Content-ID in HTML without angle brackets
  message.attach_alternative(f'… <img src="cid:{cid[1:-1]}"> …', "text/html")
  ```

  Python's [`email.contentmanager.set_content()`](https://docs.python.org/3/library/email.contentmanager.html#email.contentmanager.set_content) documentation
  describes the supported arguments for `MIMEPart.set_content()`.

  > **Changed in Django 6.0**
  >
  > Support for [`MIMEPart`](https://docs.python.org/3/library/email.message.html#email.message.MIMEPart) attachments was
  > added.

  > **Deprecated since Django 6.0**
  >
  > Deprecated since version 6.0: Support for [`email.mime.base.MIMEBase`](https://docs.python.org/3/library/email.mime.html#email.mime.base.MIMEBase) attachments is
  > deprecated. Use [`MIMEPart`](https://docs.python.org/3/library/email.message.html#email.message.MIMEPart) instead.

#### `attach_file(path, mimetype=None)`

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()`](#django.core.mail.EmailMessage.attach).

#### `class EmailAttachment`

> **New in Django 5.2**

A named tuple to store attachments to an email.

The named tuple has the following indexes:

- ainm comhad \`\`
- `content`
- `mimetype`

### Cineálacha eile ábhair a sheoladh

#### Leaganacha ábhar iolracha

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`](#django.core.mail.EmailMultiAlternatives) class.

#### `class EmailMultiAlternatives`

A subclass of [`EmailMessage`](#django.core.mail.EmailMessage) that allows additional versions of the
message body in the email via the [`attach_alternative()`](#django.core.mail.EmailMultiAlternatives.attach_alternative) method. This
directly inherits all methods (including the class initialization) from
[`EmailMessage`](#django.core.mail.EmailMessage).

#### `alternatives`

A list of [`EmailAlternative`](#django.core.mail.EmailAlternative) named tuples.
This is particularly useful in tests:

```
self.assertEqual(len(msg.alternatives), 1)
self.assertEqual(msg.alternatives[0].content, html_content)
self.assertEqual(msg.alternatives[0].mimetype, "text/html")
```

Alternatives should only be added using the [`attach_alternative()`](#django.core.mail.EmailMultiAlternatives.attach_alternative)
method, or passed to the constructor.

> **Changed in Django 5.2**
>
> In older versions, `alternatives` was a list of regular tuples,
> as opposed to [`EmailAlternative`](#django.core.mail.EmailAlternative) named tuples.

#### `attach_alternative(content, mimetype)`

Ceangail léiriú malartach ar chomhlacht na teachtaireachta sa ríomhphost.

Mar shampla, chun teaglaim téacs agus HTML a sheoladh, d'fhéadfá scríobh:

```
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()
```

#### `body_contains(text)`

> **New in Django 5.2**

Returns a boolean indicating whether the provided `text` is
contained in the email `body` and in all attached MIME type
`text/*` alternatives.

This can be useful when testing emails. For example:

```
def test_contains_email_content(self):
    subject = "Hello World"
    from_email = "from@example.com"
    to = "to@example.com"
    msg = EmailMultiAlternatives(subject, "I am content.", from_email, [to])
    msg.attach_alternative("<p>I am content.</p>", "text/html")

    self.assertIs(msg.body_contains("I am content"), True)
    self.assertIs(msg.body_contains("<p>I am content.</p>"), False)
```

#### `class EmailAlternative`

> **New in Django 5.2**

A named tuple to store alternative versions of email content.

The named tuple has the following indexes:

- `content`
- `mimetype`

#### Nuashonrú an cineál ábhair réamhshocrai

By default, the MIME type of the `body` parameter in an [`EmailMessage`](#django.core.mail.EmailMessage)
is `"text/plain"`. It is good practice to leave this alone, because it
guarantees that any recipient will be able to read the email, regardless of
their mail client. However, if you are confident that your recipients can
handle an alternative content type, you can use the `content_subtype`
attribute on the [`EmailMessage`](#django.core.mail.EmailMessage) class to change the main content type.
The major type will always be `"text"`, but you can change the subtype. For
example:

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

## Cúltaca ríomhphoist

Láimhseálann an cúltaca ríomhphoist seoladh iarbhír ríomhphoist.

Tá na modhanna seo a leanas ag an rang cúltaca ríomhphoist:

- Cruthaíonn open () nasc seolta ríomhphoist fadtréimhseolta.
- Dúnann close () an nasc seolta ríomhphoist reatha.
- `send_messages(email_messages)` sends a list of [`EmailMessage`](#django.core.mail.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.

Is féidir é a úsáid freisin mar bhainisteoir comhthéacs, a ghlaoidh go huathoibríoch ar ```open () ``agus ``close ()``` de réir mar is gá:

```
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()
```

### Sampla de chúltaca ríomhphoist a fháil

The [`get_connection()`](#django.core.mail.get_connection) function in `django.core.mail` returns an
instance of the email backend that you can use.

#### `get_connection(backend=None, * (Keyword-only parameters separator (PEP 3102)), fail_silently=False, **kwargs)`

De réir réamhshocraithe, cuirfidh glao chuig get\_connection () \`\`sampla den chúltaca ríomhphoist a shonraítear in:setting: \`EMAIL\_BACKEND ar ais. Má shonraíonn tú an argóint `backend`, cuirfear sampla den chúltaca sin.

The keyword-only `fail_silently` argument controls how the backend should
handle errors. If `fail_silently` is True, exceptions during the email
sending process will be silently ignored.

All other keyword arguments are passed directly to the constructor of the
email backend.

Seolann Django le roinnt cúltaca seolta ríomhphoist. Seachas an cúltaca SMTP (arb é an réamhshocrú), níl na cúltaca seo úsáideach ach le linn tástála agus forbartha. \<topic-custom-email-backend\>Má tá riachtanais speisialta seolta ríomhphoist agat, is féidir leat: ref: scríobh do chúltaca ríomhphoist féin .

> **Deprecated since Django 6.0**
>
> Deprecated since version 6.0: Passing `fail_silently` as positional argument is deprecated.

#### Cúltaca 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)`

Is é seo an cúltaca réamhshocraithe. Seolfar ríomhphost trí fhreastalaí SMTP.

Aisghabtar an luach do gach argóint ón suíomh meaitseála más é `None` an argóint:

- `host`: :socrú: EMAIL\_HOST
- `port`: :socrú: EMAIL\_PORT
- ainm úsáideora : :setting: EMAIL\_HOST\_USER
- pasfhocal : :socrú: EMAIL\_HOST\_PASSWORD
- `use_tls`: :socrú: EMAIL\_USE\_TLS
- `use_ssl`: :socrú: EMAIL\_USE\_SSL
- `timeout`: :socrú: EMAIL\_TIMEOUT
- `ssl_keyfile`: :socrú: EMAIL\_SSL\_KEYFILE
- `ssl_certfile`: :socrú: EMAIL\_SSL\_CERTFILE

Is é an cúltaca SMTP an chumraíocht réamhshocraithe a d'oidhreacht Django. Más mian leat é a shonrú go sainráite, cuir an méid seo a leanas i do shocruithe:

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

If unspecified, the default `timeout` will be the one provided by
[`socket.getdefaulttimeout()`](https://docs.python.org/3/library/socket.html#socket.getdefaulttimeout), which defaults to `None` (no timeout).

#### Cúltaca consól

In ionad fíor-ríomhphoist a sheoladh amach ní scríobhann an cúltaca an chonsól ach na ríomhphoist a sheolfaí chuig an aschur caighdeánach. De réir réamhshocraithe, scríobhann cúltaca an chonsól chuig `stdout`. Is féidir leat réad difriúil cosúil le sruth a úsáid tríd an argóint eochairfhocal sruth\` a sholáthar agus an nasc á thógáil.

Chun an cúltaca seo a shonrú, cuir an méid seo a leanas i do shocruithe:

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

Níl an cúltaca seo beartaithe le húsáid i dtáirgeadh - cuirtear ar fáil é mar áisiúlacht is féidir a úsáid le linn na forbartha.

#### Cúltaca comhad

The file backend writes emails to a file. A new file is created for each new
session that is opened on this backend. The directory to which the files are
written is either taken from the [`EMAIL_FILE_PATH`](/ga/6.0/ref/settings/#std-setting-EMAIL_FILE_PATH) setting or from the
`file_path` keyword when creating a connection with [`get_connection()`](#django.core.mail.get_connection).

Chun an cúltaca seo a shonrú, cuir an méid seo a leanas i do shocruithe:

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

Níl an cúltaca seo beartaithe le húsáid i dtáirgeadh - cuirtear ar fáil é mar áisiúlacht is féidir a úsáid le linn na forbartha.

#### Cúlcheann in-chuimhne

The `'locmem'` backend stores messages in a special attribute of the
`django.core.mail` module. The `outbox` attribute is created when the first
message is sent. It's a list with an [`EmailMessage`](#django.core.mail.EmailMessage) instance for each
message that would be sent.

Chun an cúltaca seo a shonrú, cuir an méid seo a leanas i do shocruithe:

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

Níl an cúltaca seo beartaithe le húsáid i dtáirgeadh - cuirtear ar fáil é mar áisiúlacht is féidir a úsáid le linn forbartha agus tástála.

\<topics-testing-email\>Raitheoir tástála Django: ref: úsáideann an cúltaca seo go huathoibríoch le haghaidh tástála .

#### Cúltaca dummy

Mar a thugann an t-ainm le tuiscint nach ndéanann an cúltaca dummy aon rud le do theachtaireachtaí. Chun an cúltaca seo a shonrú, cuir an méid seo a leanas i do shocruithe:

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

Níl an cúltaca seo beartaithe le húsáid i dtáirgeadh - cuirtear ar fáil é mar áisiúlacht is féidir a úsáid le linn na forbartha.

> **There are community-maintained solutions too!**
>
> Django has a vibrant ecosystem. There are email backends
> highlighted on the [Community Ecosystem](https://www.djangoproject.com/community/ecosystem/#email-and-notifications) page. The Django Packages
> [Email grid](https://djangopackages.org/grids/g/email/) has even more options for you!

### Cúlcheann ríomhphoist saincheaptha a shainiú

Más gá duit conas a sheoltar ríomhphoist a athrú is féidir leat do chúltaca ríomhphoist féin a scríobh. Is é an socrú: SETTING: EMAIL\_BACKEND i do chomhad socruithe ansin an cosán allmhairithe Python do do rang cúltaca.

Custom email backends should subclass `BaseEmailBackend` that is located in
the `django.core.mail.backends.base` module. A custom email backend must
implement the `send_messages(email_messages)` method. This method receives a
list of [`EmailMessage`](#django.core.mail.EmailMessage) instances and returns the number of successfully
delivered messages. If your backend has any concept of a persistent session or
connection, you should also implement the `open()` and `close()` methods.
Refer to `smtp.EmailBackend` for a reference implementation.

### Seoladh ríomhphoist iliom

Is próiseas costasach é nasc SMTP a bhunú agus a dhúnadh (nó aon nasc líonra eile, ar an ábhar sin). Má tá a lán ríomhphoist agat le seoladh, bíonn sé ciallmhar nasc SMTP a athúsáid, seachas nasc a chruthú agus a scriosadh gach uair is mian leat ríomhphost a sheoladh.

Tá dhá bhealach ann a insíonn tú do chúltaca ríomhphoist nasc a athúsáid.

Ar dtús, is féidir leat an modh send\_messages () \`\`a úsáid ar nasc. Tógann sé seo liosta de:class: \`EmailMessage (nó fo-aicme) cásanna, agus seolann sé iad go léir ag baint úsáide as an nasc aonair sin. Mar thoradh air sin, déantar neamhaird ar haon:class: nasc \<EmailMessage\>\`atá socraithe ar theachtaireacht aonair.

For example, if you have a function called `get_notification_email()` that
returns a list of [`EmailMessage`](#django.core.mail.EmailMessage) objects representing some periodic
email you wish to send out, you could send these emails using a single call to
`send_messages()`:

```
from django.core import mail

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

Sa sampla seo, osclaíonn an glao chuig send\_messages () nasc ar an gcúltaca, seolann sé liosta na dteachtaireachtaí, agus ansin dúnann sé an nasc arís.

Is é an dara cur chuige ná na modhanna ```open () ``agus ``close ()``` a úsáid ar an gcúltaca ríomhphoist chun an nasc a rialú de láimh. Ní osclóidh nó ní dhúnfaidh send\_messages () an nasc de láimh má tá sé oscailte cheana féin, mar sin má osclaíonn tú an nasc de láimh, is féidir leat rialú a dhéanamh nuair a dhúntar é. Mar shampla:

```
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()
```

## Ríomhphost a chumrú le haghaidh forbartha

Tá amanna ann nuair nach dteastaíonn uait Django ríomhphoist a sheoladh ar chor ar bith. Mar shampla, agus tú ag forbairt láithreán gréasáin, is dócha nach dteastaíonn uait na mílte ríomhphost a sheoladh amach - ach b'fhéidir gur mhaith leat a bhailíochtú go seolfar ríomhphoist chuig na daoine cearta faoi na coinníollacha cearta, agus go mbeidh an t-ábhar ceart sna ríomhphoist sin.

Is é an bealach is éasca chun ríomhphost a chumrú d'fhorbairt áitiúil ná cúltaca ríomhphoist: ref: console \<topic-email-console-backend\>\`a úsáid. Atreoraíonn an cúltaca seo gach ríomhphost chuig \`stdout\`, rud a ligeann duit ábhar an phoist a iniúchadh.

Is féidir le cúltaca rí \<topic-email-file-backend\>omhphoist: Ref: comhad a bheith úsáideach le linn na forbartha freisin - tugann an cúltaca seo ábhar gach nasc SMTP le comhad is féidir a iniúchadh ag do chuid fóillíochta.

Cur chuige eile is ea freastalaí SMTP “buma” a úsáid a fhaigheann na ríomhphoist go háitiúil agus a thaispeánann iad chuig an teirminéal, ach nach seolann aon rud i ndáiríre. Soláthraíonn an pacáiste: pypi: aiosmtpd bealach chun é seo a chur i gcrích:

```shell
python -m pip install "aiosmtpd >= 1.4.5"

python -m aiosmtpd -n -l localhost:8025
```

Cuirfidh an t-ordú seo tús le freastalaí SMTP íosta ag éisteacht ar chalafort 8025 de localhost. Priontáil an freastalaí seo chuig aschur caighdeánach gach ceanntáil ríomhphoist agus an corp Ní gá duit ansin ach an: setting: EMAIL\_HOST agus:setting: EMAIL\_PORT a shocrú dá réir. Le haghaidh plé níos mionsonraithe ar roghanna freastalaí SMTP, féach doiciméadú an mhodúil [aiosmtpd](https://aiosmtpd.readthedocs.io/en/latest/).

Le haghaidh faisnéise maidir le haonad-tástáil ríomhphoist a sheoladh i d'iarratas, féach an ranna:ref: topics-testing-email den doiciméad tástála.