File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/mail.tar
Back
__pycache__/message.cpython-310.pyc 0000644 00000035032 15030020003 0013063 0 ustar 00 o �h]E � @ s� d dl Z d dlmZ d dlmZ d dlmZmZ d dlm Z d dl m Z d dl m Z mZ d dlmZ d d lmZ d d lmZ d d lmZ d d lmZ d d lmZmZm Z m Z d dl m Z m Z d dl!m"Z" d dl#m$Z$ d dl%m&Z& d dl'm(Z(m)Z) e�d�Z*de*_+e�d�Z,ej-e,_+dZ.dZ/G dd� de0�Z1h d�Z2dd� Z3dd � Z4G d d � d �Z5G d d � d e5e�Z6G d!d"� d"e5e�Z7G d#d$� d$e5e�Z8G d%d&� d&�Z9G d'd(� d(e9�Z:dS ))� N��charset)�encoders)� generator�message_from_string)�HeaderParseError)�Header)�Address�parser)�Message)�MIMEBase)� MIMEMessage)� MIMEMultipart)�MIMEText)� formataddr� formatdate� getaddresses� make_msgid)�BytesIO�StringIO)�Path)�settings)�DNS_NAME)� force_str�punycode�utf-8zapplication/octet-streami� c @ s e Zd ZdS )�BadHeaderErrorN)�__name__� __module__� __qualname__� r r �K/usr/local/CyberCP/lib/python3.10/site-packages/django/core/mail/message.pyr # s r > �reply-to� resent-cc� resent-to� resent-bcc� resent-from� resent-sender�cc�to�bcc�from�senderc s� � pt j� t|�}d|v sd|v rtd|| f ��z|�d� W n. tyN | �� tv r=d�� fdd�t |f�D ��}n t |� ��� }Y | |fS Y | |fS w | �� dkr[t |��� }| |fS ) z6Forbid multi-line headers to prevent header injection.� � z;Header values can't contain newlines (got %r for header %r)�ascii�, c 3 s � | ]}t |� �V qd S �N)�sanitize_address)�.0�addr��encodingr r! � <genexpr>C s � �z,forbid_multi_line_headers.<locals>.<genexpr>�subject) r �DEFAULT_CHARSET�strr �encode�UnicodeEncodeError�lower�ADDRESS_HEADERS�joinr r )�name�valr6 r r5 r! �forbid_multi_line_headers7 s* � ��� rB c C sD d}t | t�s=t| �} z t�| �\}}W n tttfy$ td| ��w |r/td|| f ��|jp3d}|j }|j p;d}n | \}}|� dd�\}}|| | }d|v sWd|v r[td ��z |� d � t |�� � }W n tyx t ||�� � }Y nw z|� d � W n ty� t ||�� � }Y nw t|�}t||d �} t|| jf�S ) zF Format a pair of (name, address) or an email address string. NzInvalid address "%s"z2Invalid address; only %s could be parsed from "%s"� �@� r- r. z7Invalid address; address parts cannot contain newlines.r/ )�username�domain)� isinstance�tupler r � get_mailboxr � ValueError� IndexError� display_name� local_partrG �rsplitr; r r< r r r � addr_spec) r4 r6 �address�token�rest�nm� localpartrG � address_parts�parsed_addressr r r! r2 N sD � � � � r2 c @ s e Zd Zddd�Zddd�ZdS ) � MIMEMixinFr- c C �, t � }tj|dd�}|j| ||d� |�� S )a& Return the entire formatted message as a string. Optional `unixfrom' when True, means include the Unix From_ envelope header. This overrides the default as_string() implementation to not mangle lines that begin with 'From '. See bug #13433 for details. F�� mangle_from_��unixfrom�linesep)r r � Generator�flatten�getvalue��selfr] r^ �fp�gr r r! � as_string{ � zMIMEMixin.as_stringc C rY )a" Return the entire formatted message as bytes. Optional `unixfrom' when True, means include the Unix From_ envelope header. This overrides the default as_bytes() implementation to not mangle lines that begin with 'From '. See bug #13433 for details. FrZ r\ )r r �BytesGeneratorr` ra rb r r r! �as_bytes� rg zMIMEMixin.as_bytesN)Fr- )r r r rf ri r r r r! rX z s rX c @ s e Zd Zdd� ZdS )�SafeMIMEMessagec C s" t ||d�\}}t�| ||� d S )Nr/ )rB r � __setitem__�rc r@ rA r r r! rk � s zSafeMIMEMessage.__setitem__N)r r r rk r r r r! rj � s rj c @ s( e Zd Zd dd�Zdd� Zd dd�ZdS ) � SafeMIMEText�plainNc C s || _ tj| |||d� d S )N)�_subtype�_charset)r6 r �__init__)rc �_textro rp r r r! rq � s zSafeMIMEText.__init__c C �$ t ||| j�\}}t�| ||� d S r1 )rB r6 r rk rl r r r! rk � � zSafeMIMEText.__setitem__c C sJ |dkrt |tj�stdd� |�� D ��}|rtnt}tj| ||d� d S )Nr c s s$ � | ] }t |jd d��tkV qdS )�surrogateescape)�errorsN)�lenr; � RFC5322_EMAIL_LINE_LENGTH_LIMIT)r3 �liner r r! r7 � s � �� �z+SafeMIMEText.set_payload.<locals>.<genexpr>r )rH �Charset�any� splitlines�utf8_charset_qp� utf8_charsetr � set_payload)rc �payloadr �has_long_linesr r r! r � s � zSafeMIMEText.set_payload)rn Nr1 )r r r rq rk r r r r r! rm � s rm c @ s e Zd Z ddd�Zdd� ZdS )�SafeMIMEMultipart�mixedNc K s" || _ tj| |||fi |�� d S r1 )r6 r rq )rc ro �boundary� _subpartsr6 �_paramsr r r! rq � s zSafeMIMEMultipart.__init__c C rs r1 )rB r6 r rk rl r r r! rk � rt z SafeMIMEMultipart.__setitem__)r� NNN)r r r rq rk r r r r! r� � s � r� c @ s� e Zd ZdZdZdZdZ d dd�Zd d d �Zd d � Z d d� Z d dd�Z d!dd�Z d"dd�Z dd� Zdd� Zdd� Zd"dd �Zd d � ZdS )#� EmailMessagez"A container for email information.rn r� NrC c C s |rt |t�r td��t|�| _ng | _| r%t | t�r td��t| �| _ng | _|r9t |t�r3td��t|�| _ng | _| rMt | t�rGtd��t| �| _ng | _|pTtj | _ || _ |p\d| _ g | _ |rx|D ]} t | t�rr| �| � qe| j| � qe|p{i | _|| _dS )�g Initialize a single email message (which can be sent to multiple recipients). z%"to" argument must be a list or tuplez%"cc" argument must be a list or tuplez&"bcc" argument must be a list or tuplez+"reply_to" argument must be a list or tuplerC N)rH r: � TypeError�listr) r( r* �reply_tor �DEFAULT_FROM_EMAIL� from_emailr8 �body� attachmentsr �attach� extra_headers� connection) rc r8 r� r� r) r* r� r� �headersr( r� � attachmentr r r! rq � s> zEmailMessage.__init__Fc C s$ ddl m} | js||d�| _| jS )Nr )�get_connection)� fail_silently)�django.core.mailr� r� )rc r� r� r r r! r� � s zEmailMessage.get_connectionc C s� | j ptj}t| j| j|�}| �|�}| j|d< | j� d| j �|d< | � |d| j � | � |d| j � | � |d| j� dd� | jD �}d|vrNttjd �|d < d |vrYttd �|d < | j�� D ]\}}|�� dkrl|||< q^|S )N�Subject�From�To�CczReply-Toc S s g | ]}|� � �qS r )r= )r3 �keyr r r! � <listcomp> � z(EmailMessage.message.<locals>.<listcomp>�date)� localtime�Datez message-id)rG z Message-IDr+ )r6 r r9 rm r� �content_subtype�_create_messager8 r� �getr� � _set_list_header_if_not_emptyr) r( r� r �EMAIL_USE_LOCALTIMEr r �itemsr= )rc r6 �msg� header_namesr@ �valuer r r! �message s$ �zEmailMessage.messagec C s dd� | j | j | j D �S )z� Return a list of all recipients of the email (includes direct addressees as well as Cc and Bcc entries). c S s g | ]}|r|�qS r r )r3 �emailr r r! r� # r� z+EmailMessage.recipients.<locals>.<listcomp>)r) r( r* )rc r r r! � recipients s zEmailMessage.recipientsc C s | � � sdS | �|��| g�S )zSend the email message.r )r� r� � send_messages)rc r� r r r! �send% s zEmailMessage.sendc C s� t |t�r|dus |durtd��| j�|� dS |du r!td��|p+t�|�d p+t}|�dd�\}}|dkrOt |t �rOz|� � }W n t yN t}Y nw | j�|||f� dS )a� Attach a file with the given filename and content. The filename can be omitted and the mimetype is guessed, if not provided. If the first parameter is a MIMEBase subclass, insert it directly into the resulting message attachments. For a text/* mimetype (guessed or specified), when a bytes object is specified as content, decode it as UTF-8. If that fails, set the mimetype to DEFAULT_ATTACHMENT_MIME_TYPE and don't decode the content. NzLcontent and mimetype must not be given when a MIMEBase instance is provided.zcontent must be provided.r �/rE �text) rH r rK r� �append� mimetypes� guess_type� DEFAULT_ATTACHMENT_MIME_TYPE�split�bytes�decode�UnicodeDecodeError)rc �filename�content�mimetype�basetype�subtyper r r! r� - s, � �� �zEmailMessage.attachc C sP t |�}|�d��}|�� }| �|j||� W d � dS 1 s!w Y dS )al Attach a file from the filesystem. Set the mimetype to DEFAULT_ATTACHMENT_MIME_TYPE if it isn't specified and cannot be guessed. For a text/* mimetype (guessed or specified), decode the file's content as UTF-8. If that fails, set the mimetype to DEFAULT_ATTACHMENT_MIME_TYPE and don't decode the content. �rbN)r �open�readr� r@ )rc �pathr� �filer� r r r! � attach_fileU s "�zEmailMessage.attach_filec C s | � |�S r1 )�_create_attachments�rc r� r r r! r� e s z EmailMessage._create_messagec C sr | j r7| jptj}|}t| j|d�}| js|�� r |�|� | j D ]}t |t �r.|�|� q!|�| j |� � q!|S �N)ro r6 ) r� r6 r r9 r� � mixed_subtyper� � is_multipartr� rH r �_create_attachment)rc r� r6 �body_msgr� r r r! r� h s z EmailMessage._create_attachmentsc C s� |� dd�\}}|dkr| jptj}t|||�}|S |dkr>|dkr>t|t�r,|�� }n t|t�s7t t |��}t ||�}|S t ||�}|� |� t�|� |S )z� Convert the content, mimetype pair into a MIME attachment object. If the mimetype is message/rfc822, content may be an email.Message or EmailMessage object, as well as a str. r� rE r� r� �rfc822)r� r6 r r9 rm rH r� r� r r r rj r r �Encoders� encode_base64)rc r� r� r� r� r6 r� r r r! �_create_mime_attachmentv s � � z$EmailMessage._create_mime_attachmentc C sP | � ||�}|r&z|�d� W n ty dd|f}Y nw |jdd|d� |S )zg Convert the filename, content, mimetype triple into a MIME attachment object. r/ r rC zContent-Dispositionr� )r� )r� r; r< � add_header)rc r� r� r� r� r r r! r� � s ��z EmailMessage._create_attachmentc C sJ |r#z| j | }W n ty d�dd� |D ��}Y nw |||< dS dS )zt Set msg's header, either from self.extra_headers, if present, or from the values argument. r0 c s s � | ]}t |�V qd S r1 )r: )r3 �vr r r! r7 � s � z=EmailMessage._set_list_header_if_not_empty.<locals>.<genexpr>N)r� �KeyErrorr? )rc r� �header�valuesr� r r r! r� � s � �z*EmailMessage._set_list_header_if_not_empty) rC rC NNNNNNNN)F)NNNr1 )r r r �__doc__r� r� r6 rq r� r� r� r� r� r� r� r� r� r� r� r r r r! r� � s6 � 6 ( r� c sT e Zd ZdZdZ d � fdd� Zdd� Zd d � Zd d � Z� Z S )�EmailMultiAlternativesz� A version of EmailMessage that makes it easy to send multipart/alternative messages. For example, including text and HTML versions of the text is made easier. � alternativerC Nc s, t � �||||||||| | � | pg | _dS )r� N)�superrq � alternatives) rc r8 r� r� r) r* r� r� r� r� r( r� �� __class__r r! rq � s � z EmailMultiAlternatives.__init__c C s, |du s|du r t d��| j�||f� dS )z-Attach an alternative content representation.Nz+Both content and mimetype must be provided.)rK r� r� )rc r� r� r r r! �attach_alternative� s z)EmailMultiAlternatives.attach_alternativec C s | � | �|��S r1 )r� �_create_alternativesr� r r r! r� � s z&EmailMultiAlternatives._create_messagec C sT | j ptj}| jr(|}t| j|d�}| jr|�|� | jD ] }|�| j|� � q |S r� ) r6 r r9 r� r� �alternative_subtyper� r� r� )rc r� r6 r� r� r r r! r� � s � z+EmailMultiAlternatives._create_alternatives) rC rC NNNNNNNNN) r r r r� r� rq r� r� r� � __classcell__r r r� r! r� � s$ � r� );r� r� r rz r r� r r � email.errorsr � email.headerr �email.headerregistryr r � email.messager �email.mime.baser �email.mime.messager �email.mime.multipartr �email.mime.textr � email.utilsr r r r �ior r �pathlibr � django.confr �django.core.mail.utilsr �django.utils.encodingr r r~ � body_encodingr} �QPr� rx rK r r> rB r2 rX rj rm r� r� r� r r r r! �<module> sF , s __pycache__/__init__.cpython-310.pyc 0000644 00000010456 15030020003 0013201 0 ustar 00 o �h^ � @ s� d Z ddlmZ ddlmZmZmZmZmZm Z m Z m Z ddl m Z mZ ddlmZ g d�Zdd d �Z dd d �Z dd d�Z ddd�Z ddd�ZdS )z Tools for sending email. � )�settings)� DEFAULT_ATTACHMENT_MIME_TYPE�BadHeaderError� EmailMessage�EmailMultiAlternatives�SafeMIMEMultipart� SafeMIMEText�forbid_multi_line_headers� make_msgid)�DNS_NAME� CachedDnsName)� import_string)r r r r r r r r r r �get_connection� send_mail�send_mass_mail� mail_admins� mail_managersNFc K s t | ptj�}|dd|i|��S )z�Load an email backend and return an instance of it. If backend is None (default), use settings.EMAIL_BACKEND. Both fail_silently and other keyword arguments are used in the constructor of the backend. � fail_silentlyN� )r r � EMAIL_BACKEND)�backendr �kwds�klassr r �L/usr/local/CyberCP/lib/python3.10/site-packages/django/core/mail/__init__.pyr * s r c C s< |pt |||d�}t| ||||d�} |r| �|d� | �� S )a� Easy wrapper for sending a single message to a recipient list. All members of the recipient list will see the other recipients in the 'To' field. If from_email is None, use the DEFAULT_FROM_EMAIL setting. If auth_user is None, use the EMAIL_HOST_USER setting. If auth_password is None, use the EMAIL_HOST_PASSWORD setting. Note: The API for this method is frozen. New code wanting to extend the functionality should use the EmailMessage class directly. ��username�passwordr �� connection� text/html)r r �attach_alternative�send) �subject�message� from_email�recipient_listr � auth_user� auth_passwordr � html_message�mailr r r r 6 s � � r c s. � pt |||d�� � fdd�| D �}� �|�S )a' Given a datatuple of (subject, message, from_email, recipient_list), send each message to each recipient list. Return the number of emails sent. If from_email is None, use the DEFAULT_FROM_EMAIL setting. If auth_user and auth_password are set, use them to log in. If auth_user is None, use the EMAIL_HOST_USER setting. If auth_password is None, use the EMAIL_HOST_PASSWORD setting. Note: The API for this method is frozen. New code wanting to extend the functionality should use the EmailMessage class directly. r c s& g | ]\}}}}t ||||� d ��qS )r )r )�.0r" r# �sender� recipientr r r � <listcomp>n s ��z"send_mass_mail.<locals>.<listcomp>)r � send_messages)� datatupler r& r' r �messagesr r r r Z s � � r c C �p t jsdS tdd� t jD ��std��tdt j| f |t jdd� t jD �|d�}|r0|�|d � |j|d � dS ) z?Send a message to the admins, as defined by the ADMINS setting.Nc s �* � | ]}t |ttf�ot|�d kV qdS �� N�� isinstance�list�tuple�len�r* �ar r r � <genexpr>{ � �( z mail_admins.<locals>.<genexpr>z.The ADMINS setting must be a list of 2-tuples.�%s%sc S � g | ]}|d �qS �� r r: r r r r- � � z mail_admins.<locals>.<listcomp>r r �r ) r �ADMINS�all� ValueErrorr �EMAIL_SUBJECT_PREFIX� SERVER_EMAILr r! �r" r# r r r( r) r r r r u � � r c C r1 ) zCSend a message to the managers, as defined by the MANAGERS setting.Nc s r2 r3 r5 r: r r r r< � r= z mail_managers.<locals>.<genexpr>z0The MANAGERS setting must be a list of 2-tuples.r> c S r? r@ r r: r r r r- � rB z!mail_managers.<locals>.<listcomp>r r rC ) r �MANAGERSrE rF r rG rH r r! rI r r r r � rJ r )NF)FNNNN)FNNN)FNN)�__doc__� django.confr �django.core.mail.messager r r r r r r r �django.core.mail.utilsr r �django.utils.module_loadingr �__all__r r r r r r r r r �<module> s& ( �% � �� __pycache__/utils.cpython-310.pyc 0000644 00000001452 15030020003 0012576 0 ustar 00 o �h� � @ s0 d Z ddlZddlmZ G dd� d�Ze� ZdS )z; Email message and email sending related helper functions. � N)�punycodec @ s e Zd Zdd� Zdd� ZdS )� CachedDnsNamec C s | � � S )N)�get_fqdn��self� r �I/usr/local/CyberCP/lib/python3.10/site-packages/django/core/mail/utils.py�__str__ s zCachedDnsName.__str__c C s t | d�s tt�� �| _| jS )N�_fqdn)�hasattrr �socket�getfqdnr r r r r r s zCachedDnsName.get_fqdnN)�__name__� __module__� __qualname__r r r r r r r s r )�__doc__r �django.utils.encodingr r �DNS_NAMEr r r r �<module> s message.py 0000644 00000042535 15030020003 0006532 0 ustar 00 import mimetypes from email import charset as Charset from email import encoders as Encoders from email import generator, message_from_string from email.errors import HeaderParseError from email.header import Header from email.headerregistry import Address, parser from email.message import Message 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, formatdate, 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.encoding import force_str, punycode # Don't BASE64-encode UTF-8 messages so that we avoid unwanted attention from # some spam filters. utf8_charset = Charset.Charset("utf-8") utf8_charset.body_encoding = None # Python defaults to BASE64 utf8_charset_qp = Charset.Charset("utf-8") utf8_charset_qp.body_encoding = Charset.QP # Default MIME type to use on attachments (if it is not explicitly given # and cannot be guessed). DEFAULT_ATTACHMENT_MIME_TYPE = "application/octet-stream" RFC5322_EMAIL_LINE_LENGTH_LIMIT = 998 class BadHeaderError(ValueError): pass # Header names that contain structured address data (RFC 5322). ADDRESS_HEADERS = { "from", "sender", "reply-to", "to", "cc", "bcc", "resent-from", "resent-sender", "resent-to", "resent-cc", "resent-bcc", } def forbid_multi_line_headers(name, val, encoding): """Forbid multi-line headers to prevent header injection.""" encoding = encoding or settings.DEFAULT_CHARSET val = str(val) # val may be lazy if "\n" in val or "\r" in val: raise BadHeaderError( "Header values can't contain newlines (got %r for header %r)" % (val, name) ) try: val.encode("ascii") except UnicodeEncodeError: if name.lower() in ADDRESS_HEADERS: val = ", ".join( sanitize_address(addr, encoding) for addr in getaddresses((val,)) ) else: val = Header(val, encoding).encode() else: if name.lower() == "subject": val = Header(val).encode() return name, val def sanitize_address(addr, encoding): """ Format a pair of (name, address) or an email address string. """ address = None if not isinstance(addr, tuple): addr = force_str(addr) try: token, rest = parser.get_mailbox(addr) except (HeaderParseError, ValueError, IndexError): raise ValueError('Invalid address "%s"' % addr) else: if rest: # The entire email address must be parsed. raise ValueError( 'Invalid address; only %s could be parsed from "%s"' % (token, addr) ) nm = token.display_name or "" localpart = token.local_part domain = token.domain or "" else: nm, address = addr localpart, domain = address.rsplit("@", 1) address_parts = nm + localpart + domain if "\n" in address_parts or "\r" in address_parts: raise ValueError("Invalid address; address parts cannot contain newlines.") # Avoid UTF-8 encode, if it's possible. try: nm.encode("ascii") nm = Header(nm).encode() except UnicodeEncodeError: nm = Header(nm, encoding).encode() try: localpart.encode("ascii") except UnicodeEncodeError: localpart = Header(localpart, encoding).encode() domain = punycode(domain) parsed_address = Address(username=localpart, domain=domain) return formataddr((nm, parsed_address.addr_spec)) class MIMEMixin: def as_string(self, unixfrom=False, linesep="\n"): """Return the entire formatted message as a string. Optional `unixfrom' when True, means include the Unix From_ envelope header. This overrides the default as_string() implementation to not mangle lines that begin with 'From '. See bug #13433 for details. """ fp = StringIO() g = generator.Generator(fp, mangle_from_=False) g.flatten(self, unixfrom=unixfrom, linesep=linesep) return fp.getvalue() def as_bytes(self, unixfrom=False, linesep="\n"): """Return the entire formatted message as bytes. Optional `unixfrom' when True, means include the Unix From_ envelope header. This overrides the default as_bytes() implementation to not mangle lines that begin with 'From '. See bug #13433 for details. """ fp = BytesIO() g = generator.BytesGenerator(fp, mangle_from_=False) g.flatten(self, unixfrom=unixfrom, linesep=linesep) return fp.getvalue() class SafeMIMEMessage(MIMEMixin, MIMEMessage): def __setitem__(self, name, val): # message/rfc822 attachments must be ASCII name, val = forbid_multi_line_headers(name, val, "ascii") MIMEMessage.__setitem__(self, name, val) class SafeMIMEText(MIMEMixin, MIMEText): def __init__(self, _text, _subtype="plain", _charset=None): self.encoding = _charset MIMEText.__init__(self, _text, _subtype=_subtype, _charset=_charset) def __setitem__(self, name, val): name, val = forbid_multi_line_headers(name, val, self.encoding) MIMEText.__setitem__(self, name, val) def set_payload(self, payload, charset=None): if charset == "utf-8" and not isinstance(charset, Charset.Charset): has_long_lines = any( len(line.encode(errors="surrogateescape")) > RFC5322_EMAIL_LINE_LENGTH_LIMIT for line in payload.splitlines() ) # Quoted-Printable encoding has the side effect of shortening long # lines, if any (#22561). charset = utf8_charset_qp if has_long_lines else utf8_charset MIMEText.set_payload(self, payload, charset=charset) 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) class EmailMessage: """A container for email information.""" content_subtype = "plain" mixed_subtype = "mixed" encoding = None # None => use settings default def __init__( self, subject="", body="", from_email=None, to=None, bcc=None, connection=None, attachments=None, headers=None, cc=None, reply_to=None, ): """ Initialize a single email message (which can be sent to multiple recipients). """ if to: if isinstance(to, str): raise TypeError('"to" argument must be a list or tuple') self.to = list(to) else: self.to = [] if cc: if isinstance(cc, str): raise TypeError('"cc" argument must be a list or tuple') self.cc = list(cc) else: self.cc = [] if bcc: if isinstance(bcc, str): raise TypeError('"bcc" argument must be a list or tuple') self.bcc = list(bcc) else: self.bcc = [] if reply_to: if isinstance(reply_to, str): raise TypeError('"reply_to" argument must be a list or tuple') self.reply_to = list(reply_to) else: self.reply_to = [] self.from_email = from_email or settings.DEFAULT_FROM_EMAIL self.subject = subject self.body = body or "" self.attachments = [] if attachments: for attachment in attachments: if isinstance(attachment, MIMEBase): self.attach(attachment) else: self.attach(*attachment) self.extra_headers = headers or {} self.connection = connection def get_connection(self, fail_silently=False): from django.core.mail import get_connection if not self.connection: self.connection = get_connection(fail_silently=fail_silently) return self.connection def message(self): encoding = self.encoding or settings.DEFAULT_CHARSET msg = SafeMIMEText(self.body, self.content_subtype, encoding) msg = self._create_message(msg) msg["Subject"] = self.subject msg["From"] = self.extra_headers.get("From", self.from_email) self._set_list_header_if_not_empty(msg, "To", self.to) self._set_list_header_if_not_empty(msg, "Cc", self.cc) self._set_list_header_if_not_empty(msg, "Reply-To", self.reply_to) # Email header names are case-insensitive (RFC 2045), so we have to # accommodate that when doing comparisons. header_names = [key.lower() for key in self.extra_headers] if "date" not in header_names: # formatdate() uses stdlib methods to format the date, which use # the stdlib/OS concept of a timezone, however, Django sets the # TZ environment variable based on the TIME_ZONE setting which # will get picked up by formatdate(). msg["Date"] = formatdate(localtime=settings.EMAIL_USE_LOCALTIME) if "message-id" not in header_names: # Use cached DNS_NAME for performance msg["Message-ID"] = make_msgid(domain=DNS_NAME) for name, value in self.extra_headers.items(): if name.lower() != "from": # From is already handled msg[name] = value return msg def recipients(self): """ Return a list of all recipients of the email (includes direct addressees as well as Cc and Bcc entries). """ return [email for email in (self.to + self.cc + self.bcc) if email] def send(self, fail_silently=False): """Send the email message.""" if not self.recipients(): # Don't bother creating the network connection if there's nobody to # send to. return 0 return self.get_connection(fail_silently).send_messages([self]) def attach(self, filename=None, content=None, mimetype=None): """ Attach a file with the given filename and content. The filename can be omitted and the mimetype is guessed, if not provided. If the first parameter is a MIMEBase subclass, insert it directly into the resulting message attachments. For a text/* mimetype (guessed or specified), when a bytes object is specified as content, decode it as UTF-8. If that fails, set the mimetype to DEFAULT_ATTACHMENT_MIME_TYPE and don't decode the content. """ if isinstance(filename, MIMEBase): if content is not None or mimetype is not None: raise ValueError( "content and mimetype must not be given when a MIMEBase " "instance is provided." ) self.attachments.append(filename) elif content is None: raise ValueError("content must be provided.") else: mimetype = ( mimetype or mimetypes.guess_type(filename)[0] or DEFAULT_ATTACHMENT_MIME_TYPE ) basetype, subtype = mimetype.split("/", 1) if basetype == "text": if isinstance(content, bytes): try: content = content.decode() except UnicodeDecodeError: # If mimetype suggests the file is text but it's # actually binary, read() raises a UnicodeDecodeError. mimetype = DEFAULT_ATTACHMENT_MIME_TYPE self.attachments.append((filename, content, mimetype)) def attach_file(self, path, mimetype=None): """ Attach a file from the filesystem. Set the mimetype to DEFAULT_ATTACHMENT_MIME_TYPE if it isn't specified and cannot be guessed. For a text/* mimetype (guessed or specified), decode the file's content as UTF-8. If that fails, set the mimetype to DEFAULT_ATTACHMENT_MIME_TYPE and don't decode the content. """ path = Path(path) with path.open("rb") as file: content = file.read() self.attach(path.name, content, mimetype) def _create_message(self, msg): return self._create_attachments(msg) def _create_attachments(self, msg): if self.attachments: encoding = self.encoding or settings.DEFAULT_CHARSET body_msg = msg msg = SafeMIMEMultipart(_subtype=self.mixed_subtype, encoding=encoding) if self.body or body_msg.is_multipart(): msg.attach(body_msg) for attachment in self.attachments: if isinstance(attachment, MIMEBase): msg.attach(attachment) else: msg.attach(self._create_attachment(*attachment)) return msg def _create_mime_attachment(self, content, mimetype): """ Convert the content, mimetype pair into a MIME attachment object. If the mimetype is message/rfc822, content may be an email.Message or EmailMessage object, as well as a str. """ basetype, subtype = mimetype.split("/", 1) if basetype == "text": encoding = self.encoding or settings.DEFAULT_CHARSET attachment = SafeMIMEText(content, subtype, encoding) elif basetype == "message" and subtype == "rfc822": # Bug #18967: Per RFC 2046 Section 5.2.1, message/rfc822 # attachments must not be base64 encoded. if isinstance(content, EmailMessage): # convert content into an email.Message first content = content.message() elif not isinstance(content, Message): # For compatibility with existing code, parse the message # into an email.Message object if it is not one already. content = message_from_string(force_str(content)) attachment = SafeMIMEMessage(content, subtype) else: # Encode non-text attachments with base64. attachment = MIMEBase(basetype, subtype) attachment.set_payload(content) Encoders.encode_base64(attachment) return attachment def _create_attachment(self, filename, content, mimetype=None): """ Convert the filename, content, mimetype triple into a MIME attachment object. """ attachment = self._create_mime_attachment(content, mimetype) if filename: try: filename.encode("ascii") except UnicodeEncodeError: filename = ("utf-8", "", filename) attachment.add_header( "Content-Disposition", "attachment", filename=filename ) return attachment def _set_list_header_if_not_empty(self, msg, header, values): """ Set msg's header, either from self.extra_headers, if present, or from the values argument. """ if values: try: value = self.extra_headers[header] except KeyError: value = ", ".join(str(v) for v in values) msg[header] = value class EmailMultiAlternatives(EmailMessage): """ A version of EmailMessage that makes it easy to send multipart/alternative messages. For example, including text and HTML versions of the text is made easier. """ alternative_subtype = "alternative" def __init__( self, subject="", body="", from_email=None, to=None, bcc=None, connection=None, attachments=None, headers=None, alternatives=None, cc=None, reply_to=None, ): """ Initialize a single email message (which can be sent to multiple recipients). """ super().__init__( subject, body, from_email, to, bcc, connection, attachments, headers, cc, reply_to, ) self.alternatives = alternatives or [] def attach_alternative(self, content, mimetype): """Attach an alternative content representation.""" if content is None or mimetype is None: raise ValueError("Both content and mimetype must be provided.") self.alternatives.append((content, mimetype)) def _create_message(self, msg): return self._create_attachments(self._create_alternatives(msg)) def _create_alternatives(self, msg): encoding = self.encoding or settings.DEFAULT_CHARSET if self.alternatives: body_msg = msg msg = SafeMIMEMultipart( _subtype=self.alternative_subtype, encoding=encoding ) if self.body: msg.attach(body_msg) for alternative in self.alternatives: msg.attach(self._create_mime_attachment(*alternative)) return msg backends/dummy.py 0000644 00000000352 15030020003 0010002 0 ustar 00 """ Dummy email backend that does nothing. """ from django.core.mail.backends.base import BaseEmailBackend class EmailBackend(BaseEmailBackend): def send_messages(self, email_messages): return len(list(email_messages)) backends/base.py 0000644 00000003223 15030020003 0007561 0 ustar 00 """Base email backend class.""" class BaseEmailBackend: """ Base class for email backend implementations. Subclasses must at least overwrite send_messages(). open() and close() can be called indirectly by using a backend object as a context manager: with backend as connection: # do something with connection pass """ def __init__(self, fail_silently=False, **kwargs): self.fail_silently = fail_silently def open(self): """ Open a network connection. This method can be overwritten by backend implementations to open a network connection. It's up to the backend implementation to track the status of a network connection if it's needed by the backend. This method can be called by applications to force a single network connection to be used when sending mails. See the send_messages() method of the SMTP backend for a reference implementation. The default implementation does nothing. """ pass def close(self): """Close a network connection.""" pass def __enter__(self): try: self.open() except Exception: self.close() raise return self def __exit__(self, exc_type, exc_value, traceback): self.close() def send_messages(self, email_messages): """ Send one or more EmailMessage objects and return the number of email messages sent. """ raise NotImplementedError( "subclasses of BaseEmailBackend must override send_messages() method" ) backends/__pycache__/smtp.cpython-310.pyc 0000644 00000010537 15030020003 0014177 0 ustar 00 o �hl � @ sl d Z ddlZddlZddlZddlmZ ddlmZ ddlm Z ddl m Z ddl m Z G dd � d e�ZdS ) zSMTP email backend class.� N)�settings)�BaseEmailBackend��sanitize_address)�DNS_NAME)�cached_propertyc sn e Zd ZdZ d� fdd� Zedd� �Zedd � �Zd d � Z d d � Z dd� Z dd� Z � Z S )� EmailBackendz= A wrapper that manages the SMTP network connection. NFc s� t � j|d� |p tj| _|ptj| _|d u rtjn|| _|d u r$tj n|| _ |d u r.tj n|| _ |d u r8tj n|| _|d u rBtjn|| _| d u rLtjn| | _| d u rVtjn| | _| jrc| j rctd��d | _t�� | _d S )N)� fail_silentlyz^EMAIL_USE_TLS/EMAIL_USE_SSL are mutually exclusive, so only set one of those settings to True.)�super�__init__r � EMAIL_HOST�host� EMAIL_PORT�port�EMAIL_HOST_USER�username�EMAIL_HOST_PASSWORD�password� EMAIL_USE_TLS�use_tls� EMAIL_USE_SSL�use_ssl� EMAIL_TIMEOUT�timeout�EMAIL_SSL_KEYFILE� ssl_keyfile�EMAIL_SSL_CERTFILE� ssl_certfile� ValueError� connection� threading�RLock�_lock) �selfr r r r r r r r r r �kwargs�� __class__� �Q/usr/local/CyberCP/lib/python3.10/site-packages/django/core/mail/backends/smtp.pyr s$ �� �zEmailBackend.__init__c C s | j rtjS tjS )N)r �smtplib�SMTP_SSL�SMTP�r# r' r' r( �connection_class6 s z EmailBackend.connection_classc C s6 | j s| jrtjtjd�}|�| j | j� |S t�� S )N)�protocol)r r �ssl� SSLContext�PROTOCOL_TLS_CLIENT�load_cert_chain�create_default_context)r# � ssl_contextr' r' r( r4 : s zEmailBackend.ssl_contextc C s� | j rdS dt�� i}| jdur| j|d< | jr | j|d< z-| j| j| jfi |��| _ | js9| j r9| j j | jd� | j rH| j rH| j � | j | j � W dS tyX | jsU� Y dS w )z� Ensure an open connection to the email server. Return whether or not a new connection was required (True or False) or None if an exception passed silently. F�local_hostnameNr �context)r6 T)r r �get_fqdnr r r4 r- r r r �starttlsr r �login�OSErrorr )r# �connection_paramsr' r' r( �openC s. �� ��zEmailBackend.openc C s� | j du rdS z8z| j �� W n$ tjtjfy! | j �� Y n tjy3 | jr2Y W d| _ dS � w W d| _ dS W d| _ dS d| _ w )z)Close the connection to the email server.N) r �quitr/ �SSLErrorr) �SMTPServerDisconnected�close� SMTPExceptionr r, r' r' r( r@ d s" ��� �zEmailBackend.closec C s� |sdS | j �= | �� }| jr|du r W d � dS d}|D ] }| �|�}|r-|d7 }q |r<| �� W d � |S W d � |S 1 sGw Y |S )zm Send one or more EmailMessage objects and return the number of email messages sent. r N� )r" r< r �_sendr@ )r# �email_messages�new_conn_created�num_sent�message�sentr' r' r( � send_messagesw s, � � � � � � zEmailBackend.send_messagesc s� |� � sdS |jp tj� t|j� �}� fdd�|� � D �}|�� }z| j�|||j dd�� W dS t j y? | j s<� Y dS w )z-A helper method that does the actual sending.Fc s g | ]}t |� ��qS r' r )�.0�addr��encodingr' r( � <listcomp>� s �z&EmailBackend._send.<locals>.<listcomp>z )�linesepT) � recipientsrM r �DEFAULT_CHARSETr � from_emailrG r �sendmail�as_bytesr) rA r )r# � email_messagerR rP rG r' rL r( rC � s$ ����zEmailBackend._send) NNNNNFNNNN)�__name__� __module__� __qualname__�__doc__r �propertyr- r r4 r< r@ rI rC � __classcell__r' r' r% r( r s* �$ !r )rY r) r/ r � django.confr � django.core.mail.backends.baser �django.core.mail.messager �django.core.mail.utilsr �django.utils.functionalr r r' r' r' r( �<module> s backends/__pycache__/__init__.cpython-310.pyc 0000644 00000000262 15030020003 0014745 0 ustar 00 o �h% � @ s d S )N� r r r �U/usr/local/CyberCP/lib/python3.10/site-packages/django/core/mail/backends/__init__.py�<module> s backends/__pycache__/console.cpython-310.pyc 0000644 00000003331 15030020003 0014650 0 ustar 00 o �h� � @ s4 d Z ddlZddlZddlmZ G dd� de�ZdS )zH Email backend that writes messages to console instead of sending them. � N)�BaseEmailBackendc s, e Zd Z� fdd�Zdd� Zdd� Z� ZS )� EmailBackendc s0 |� dtj�| _t�� | _t� j|i |�� d S )N�stream) �pop�sys�stdoutr � threading�RLock�_lock�super�__init__)�self�args�kwargs�� __class__� �T/usr/local/CyberCP/lib/python3.10/site-packages/django/core/mail/backends/console.pyr s zEmailBackend.__init__c C s^ |� � }|�� }|�� r|�� �� nd}|�|�}| j�d| � | j�d� | j�d� d S )Nzutf-8z%s zO-------------------------------------------------------------------------------� )�message�as_bytes� get_charset�get_output_charset�decoder �write)r r �msg�msg_data�charsetr r r � write_message s � zEmailBackend.write_messagec C s� |sdS d}| j �> z | �� }|D ]}| �|� | j�� |d7 }q|r(| �� W n ty6 | js4� Y n w W d � |S W d � |S 1 sJw Y |S )z6Write all messages to the stream in a thread-safe way.Nr � )r �openr r �flush�close� Exception� fail_silently)r �email_messages� msg_count�stream_createdr r r r � send_messages s4 � ��� � � � � zEmailBackend.send_messages)�__name__� __module__� __qualname__r r r( � __classcell__r r r r r s r )�__doc__r r � django.core.mail.backends.baser r r r r r �<module> s backends/__pycache__/dummy.cpython-310.pyc 0000644 00000001166 15030020003 0014345 0 ustar 00 o �h� � @ s$ d Z ddlmZ G dd� de�ZdS )z( Dummy email backend that does nothing. � )�BaseEmailBackendc @ s e Zd Zdd� ZdS )� EmailBackendc C s t t|��S )N)�len�list)�self�email_messages� r �R/usr/local/CyberCP/lib/python3.10/site-packages/django/core/mail/backends/dummy.py� send_messages s zEmailBackend.send_messagesN)�__name__� __module__� __qualname__r r r r r r s r N)�__doc__� django.core.mail.backends.baser r r r r r �<module> s backends/__pycache__/filebased.cpython-310.pyc 0000644 00000004507 15030020003 0015132 0 ustar 00 o �h1 � @ sL d Z ddlZddlZddlmZ ddlmZ ddlmZ G dd� de �ZdS )z-Email backend that writes messages to a file.� N)�settings)�ImproperlyConfigured)� EmailBackendc sB e Zd Zdd�� fdd� Zdd� Zdd� Zd d � Zd d � Z� ZS ) r N)� file_pathc s� d | _ |d ur || _nttdd �| _tj�| j�| _z tj| jdd� W n" ty2 t d| j �� t yF } z t d| j|f ��d }~ww t� | jtj �sVt d| j ��d |d< t � j|i |�� d S )N�EMAIL_FILE_PATHT)�exist_okzAPath for saving email messages exists, but is not a directory: %sz=Could not create directory for saving email messages: %s (%s)z Could not write to directory: %s�stream)�_fnamer �getattrr �os�path�abspath�makedirs�FileExistsErrorr �OSError�access�W_OK�super�__init__)�selfr �args�kwargs�err�� __class__� �V/usr/local/CyberCP/lib/python3.10/site-packages/django/core/mail/backends/filebased.pyr s6 �������zEmailBackend.__init__c C s4 | j �|�� �� d � | j �d� | j �d� d S )N� sO -------------------------------------------------------------------------------)r �write�message�as_bytes)r r r r r � write_message* s zEmailBackend.write_messagec C sF | j du r tj�� �d�}d|tt| ��f }tj�| j |�| _ | j S )zReturn a unique file name.Nz %Y%m%d-%H%M%Sz %s-%s.log) r �datetime�now�strftime�abs�idr r �joinr )r � timestamp�fnamer r r � _get_filename/ s zEmailBackend._get_filenamec C s" | j d u rt| �� d�| _ dS dS )N�abTF)r �openr* �r r r r r, 7 s zEmailBackend.openc C s6 z| j d ur| j �� W d | _ d S W d | _ d S d | _ w )N)r �closer- r r r r. = s �zEmailBackend.close) �__name__� __module__� __qualname__r r! r* r, r. � __classcell__r r r r r s r ) �__doc__r" r � django.confr �django.core.exceptionsr �!django.core.mail.backends.consoler �ConsoleEmailBackendr r r r �<module> s backends/__pycache__/locmem.cpython-310.pyc 0000644 00000002403 15030020003 0014461 0 ustar 00 o �hu � @ s0 d Z ddlmZ ddlmZ G dd� de�ZdS )z Backend for test environment. � )�mail)�BaseEmailBackendc s( e Zd ZdZ� fdd�Zdd� Z� ZS )� EmailBackendz� An email backend for use during test sessions. The test connection stores email messages in a dummy outbox, rather than sending them out on the wire. The dummy outbox is accessible through the outbox instance attribute. c s* t � j|i |�� ttd�sg t_d S d S )N�outbox)�super�__init__�hasattrr r )�self�args�kwargs�� __class__� �S/usr/local/CyberCP/lib/python3.10/site-packages/django/core/mail/backends/locmem.pyr s �zEmailBackend.__init__c C s. d}|D ]}|� � tj�|� |d7 }q|S )z%Redirect messages to the dummy outboxr � )�messager r �append)r �messages� msg_countr r r r � send_messages s zEmailBackend.send_messages)�__name__� __module__� __qualname__�__doc__r r � __classcell__r r r r r s r N)r � django.corer � django.core.mail.backends.baser r r r r r �<module> s backends/__pycache__/base.cpython-310.pyc 0000644 00000004551 15030020003 0014125 0 ustar 00 o �h� � @ s d Z G dd� d�ZdS )zBase email backend class.c @ sB e Zd ZdZddd�Zdd� Zdd� Zd d � Zd d � Zd d� Z dS )�BaseEmailBackenda3 Base class for email backend implementations. Subclasses must at least overwrite send_messages(). open() and close() can be called indirectly by using a backend object as a context manager: with backend as connection: # do something with connection pass Fc K s || _ d S �N)� fail_silently)�selfr �kwargs� r �Q/usr/local/CyberCP/lib/python3.10/site-packages/django/core/mail/backends/base.py�__init__ s zBaseEmailBackend.__init__c C � dS )a+ Open a network connection. This method can be overwritten by backend implementations to open a network connection. It's up to the backend implementation to track the status of a network connection if it's needed by the backend. This method can be called by applications to force a single network connection to be used when sending mails. See the send_messages() method of the SMTP backend for a reference implementation. The default implementation does nothing. Nr �r r r r �open s zBaseEmailBackend.openc C r )zClose a network connection.Nr r r r r �close( s zBaseEmailBackend.closec C s( z| � � W | S ty | �� � w r )r � Exceptionr r r r r � __enter__, s ��zBaseEmailBackend.__enter__c C s | � � d S r )r )r �exc_type� exc_value� tracebackr r r �__exit__4 s zBaseEmailBackend.__exit__c C s t d��)zm Send one or more EmailMessage objects and return the number of email messages sent. zCsubclasses of BaseEmailBackend must override send_messages() method)�NotImplementedError)r �email_messagesr r r � send_messages7 s �z BaseEmailBackend.send_messagesN)F) �__name__� __module__� __qualname__�__doc__r r r r r r r r r r r s r N)r r r r r r �<module> s backends/console.py 0000644 00000002622 15030020003 0010313 0 ustar 00 """ Email backend that writes messages to console instead of sending them. """ import sys import threading from django.core.mail.backends.base import BaseEmailBackend class EmailBackend(BaseEmailBackend): def __init__(self, *args, **kwargs): self.stream = kwargs.pop("stream", sys.stdout) self._lock = threading.RLock() super().__init__(*args, **kwargs) def write_message(self, message): msg = message.message() msg_data = msg.as_bytes() charset = ( msg.get_charset().get_output_charset() if msg.get_charset() else "utf-8" ) msg_data = msg_data.decode(charset) self.stream.write("%s\n" % msg_data) self.stream.write("-" * 79) self.stream.write("\n") def send_messages(self, email_messages): """Write all messages to the stream in a thread-safe way.""" if not email_messages: return msg_count = 0 with self._lock: try: stream_created = self.open() for message in email_messages: self.write_message(message) self.stream.flush() # flush after each message msg_count += 1 if stream_created: self.close() except Exception: if not self.fail_silently: raise return msg_count backends/filebased.py 0000644 00000004461 15030020003 0010572 0 ustar 00 """Email backend that writes messages to a file.""" import datetime import os from django.conf import settings from django.core.exceptions import ImproperlyConfigured from django.core.mail.backends.console import EmailBackend as ConsoleEmailBackend class EmailBackend(ConsoleEmailBackend): def __init__(self, *args, file_path=None, **kwargs): self._fname = None if file_path is not None: self.file_path = file_path else: self.file_path = getattr(settings, "EMAIL_FILE_PATH", None) self.file_path = os.path.abspath(self.file_path) try: os.makedirs(self.file_path, exist_ok=True) except FileExistsError: raise ImproperlyConfigured( "Path for saving email messages exists, but is not a directory: %s" % self.file_path ) except OSError as err: raise ImproperlyConfigured( "Could not create directory for saving email messages: %s (%s)" % (self.file_path, err) ) # Make sure that self.file_path is writable. if not os.access(self.file_path, os.W_OK): raise ImproperlyConfigured( "Could not write to directory: %s" % self.file_path ) # Finally, call super(). # Since we're using the console-based backend as a base, # force the stream to be None, so we don't default to stdout kwargs["stream"] = None super().__init__(*args, **kwargs) def write_message(self, message): self.stream.write(message.message().as_bytes() + b"\n") self.stream.write(b"-" * 79) self.stream.write(b"\n") def _get_filename(self): """Return a unique file name.""" if self._fname is None: timestamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S") fname = "%s-%s.log" % (timestamp, abs(id(self))) self._fname = os.path.join(self.file_path, fname) return self._fname def open(self): if self.stream is None: self.stream = open(self._get_filename(), "ab") return True return False def close(self): try: if self.stream is not None: self.stream.close() finally: self.stream = None backends/__init__.py 0000644 00000000045 15030020003 0010405 0 ustar 00 # Mail backends shipped with Django. backends/smtp.py 0000644 00000013154 15030020003 0007636 0 ustar 00 """SMTP email backend class.""" import smtplib import ssl import threading from django.conf import settings from django.core.mail.backends.base import BaseEmailBackend from django.core.mail.message import sanitize_address from django.core.mail.utils import DNS_NAME from django.utils.functional import cached_property class EmailBackend(BaseEmailBackend): """ A wrapper that manages the SMTP network connection. """ def __init__( self, 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, ): super().__init__(fail_silently=fail_silently) self.host = host or settings.EMAIL_HOST self.port = port or settings.EMAIL_PORT self.username = settings.EMAIL_HOST_USER if username is None else username self.password = settings.EMAIL_HOST_PASSWORD if password is None else password self.use_tls = settings.EMAIL_USE_TLS if use_tls is None else use_tls self.use_ssl = settings.EMAIL_USE_SSL if use_ssl is None else use_ssl self.timeout = settings.EMAIL_TIMEOUT if timeout is None else timeout self.ssl_keyfile = ( settings.EMAIL_SSL_KEYFILE if ssl_keyfile is None else ssl_keyfile ) self.ssl_certfile = ( settings.EMAIL_SSL_CERTFILE if ssl_certfile is None else ssl_certfile ) if self.use_ssl and self.use_tls: raise ValueError( "EMAIL_USE_TLS/EMAIL_USE_SSL are mutually exclusive, so only set " "one of those settings to True." ) self.connection = None self._lock = threading.RLock() @property def connection_class(self): return smtplib.SMTP_SSL if self.use_ssl else smtplib.SMTP @cached_property def ssl_context(self): if self.ssl_certfile or self.ssl_keyfile: ssl_context = ssl.SSLContext(protocol=ssl.PROTOCOL_TLS_CLIENT) ssl_context.load_cert_chain(self.ssl_certfile, self.ssl_keyfile) return ssl_context else: return ssl.create_default_context() def open(self): """ Ensure an open connection to the email server. Return whether or not a new connection was required (True or False) or None if an exception passed silently. """ if self.connection: # Nothing to do if the connection is already open. return False # If local_hostname is not specified, socket.getfqdn() gets used. # For performance, we use the cached FQDN for local_hostname. connection_params = {"local_hostname": DNS_NAME.get_fqdn()} if self.timeout is not None: connection_params["timeout"] = self.timeout if self.use_ssl: connection_params["context"] = self.ssl_context try: self.connection = self.connection_class( self.host, self.port, **connection_params ) # TLS/SSL are mutually exclusive, so only attempt TLS over # non-secure connections. if not self.use_ssl and self.use_tls: self.connection.starttls(context=self.ssl_context) if self.username and self.password: self.connection.login(self.username, self.password) return True except OSError: if not self.fail_silently: raise def close(self): """Close the connection to the email server.""" if self.connection is None: return try: try: self.connection.quit() except (ssl.SSLError, smtplib.SMTPServerDisconnected): # This happens when calling quit() on a TLS connection # sometimes, or when the connection was already disconnected # by the server. self.connection.close() except smtplib.SMTPException: if self.fail_silently: return raise finally: self.connection = None def send_messages(self, email_messages): """ Send one or more EmailMessage objects and return the number of email messages sent. """ if not email_messages: return 0 with self._lock: new_conn_created = self.open() if not self.connection or new_conn_created is None: # We failed silently on open(). # Trying to send would be pointless. return 0 num_sent = 0 for message in email_messages: sent = self._send(message) if sent: num_sent += 1 if new_conn_created: self.close() return num_sent def _send(self, email_message): """A helper method that does the actual sending.""" if not email_message.recipients(): return False encoding = email_message.encoding or settings.DEFAULT_CHARSET from_email = sanitize_address(email_message.from_email, encoding) recipients = [ sanitize_address(addr, encoding) for addr in email_message.recipients() ] message = email_message.message() try: self.connection.sendmail( from_email, recipients, message.as_bytes(linesep="\r\n") ) except smtplib.SMTPException: if not self.fail_silently: raise return False return True backends/locmem.py 0000644 00000001565 15030020003 0010132 0 ustar 00 """ Backend for test environment. """ from django.core import mail from django.core.mail.backends.base import BaseEmailBackend class EmailBackend(BaseEmailBackend): """ An email backend for use during test sessions. The test connection stores email messages in a dummy outbox, rather than sending them out on the wire. The dummy outbox is accessible through the outbox instance attribute. """ def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) if not hasattr(mail, "outbox"): mail.outbox = [] def send_messages(self, messages): """Redirect messages to the dummy outbox""" msg_count = 0 for message in messages: # .message() triggers header validation message.message() mail.outbox.append(message) msg_count += 1 return msg_count __init__.py 0000644 00000011536 15030020003 0006642 0 ustar 00 """ Tools for sending email. """ from django.conf import settings # Imported for backwards compatibility and for the sake # of a cleaner namespace. These symbols used to be in # django/core/mail.py before the introduction of email # backends and the subsequent reorganization (See #10355) from django.core.mail.message import ( DEFAULT_ATTACHMENT_MIME_TYPE, BadHeaderError, EmailMessage, EmailMultiAlternatives, SafeMIMEMultipart, SafeMIMEText, forbid_multi_line_headers, make_msgid, ) from django.core.mail.utils import DNS_NAME, CachedDnsName from django.utils.module_loading import import_string __all__ = [ "CachedDnsName", "DNS_NAME", "EmailMessage", "EmailMultiAlternatives", "SafeMIMEText", "SafeMIMEMultipart", "DEFAULT_ATTACHMENT_MIME_TYPE", "make_msgid", "BadHeaderError", "forbid_multi_line_headers", "get_connection", "send_mail", "send_mass_mail", "mail_admins", "mail_managers", ] def get_connection(backend=None, fail_silently=False, **kwds): """Load an email backend and return an instance of it. If backend is None (default), use settings.EMAIL_BACKEND. Both fail_silently and other keyword arguments are used in the constructor of the backend. """ klass = import_string(backend or settings.EMAIL_BACKEND) return klass(fail_silently=fail_silently, **kwds) def send_mail( subject, message, from_email, recipient_list, fail_silently=False, auth_user=None, auth_password=None, connection=None, html_message=None, ): """ Easy wrapper for sending a single message to a recipient list. All members of the recipient list will see the other recipients in the 'To' field. If from_email is None, use the DEFAULT_FROM_EMAIL setting. If auth_user is None, use the EMAIL_HOST_USER setting. If auth_password is None, use the EMAIL_HOST_PASSWORD setting. Note: The API for this method is frozen. New code wanting to extend the functionality should use the EmailMessage class directly. """ connection = connection or get_connection( username=auth_user, password=auth_password, fail_silently=fail_silently, ) mail = EmailMultiAlternatives( subject, message, from_email, recipient_list, connection=connection ) if html_message: mail.attach_alternative(html_message, "text/html") return mail.send() def send_mass_mail( datatuple, fail_silently=False, auth_user=None, auth_password=None, connection=None ): """ Given a datatuple of (subject, message, from_email, recipient_list), send each message to each recipient list. Return the number of emails sent. If from_email is None, use the DEFAULT_FROM_EMAIL setting. If auth_user and auth_password are set, use them to log in. If auth_user is None, use the EMAIL_HOST_USER setting. If auth_password is None, use the EMAIL_HOST_PASSWORD setting. Note: The API for this method is frozen. New code wanting to extend the functionality should use the EmailMessage class directly. """ connection = connection or get_connection( username=auth_user, password=auth_password, fail_silently=fail_silently, ) messages = [ EmailMessage(subject, message, sender, recipient, connection=connection) for subject, message, sender, recipient in datatuple ] return connection.send_messages(messages) def mail_admins( subject, message, fail_silently=False, connection=None, html_message=None ): """Send a message to the admins, as defined by the ADMINS setting.""" if not settings.ADMINS: return if not all(isinstance(a, (list, tuple)) and len(a) == 2 for a in settings.ADMINS): raise ValueError("The ADMINS setting must be a list of 2-tuples.") mail = EmailMultiAlternatives( "%s%s" % (settings.EMAIL_SUBJECT_PREFIX, subject), message, settings.SERVER_EMAIL, [a[1] for a in settings.ADMINS], connection=connection, ) if html_message: mail.attach_alternative(html_message, "text/html") mail.send(fail_silently=fail_silently) def mail_managers( subject, message, fail_silently=False, connection=None, html_message=None ): """Send a message to the managers, as defined by the MANAGERS setting.""" if not settings.MANAGERS: return if not all(isinstance(a, (list, tuple)) and len(a) == 2 for a in settings.MANAGERS): raise ValueError("The MANAGERS setting must be a list of 2-tuples.") mail = EmailMultiAlternatives( "%s%s" % (settings.EMAIL_SUBJECT_PREFIX, subject), message, settings.SERVER_EMAIL, [a[1] for a in settings.MANAGERS], connection=connection, ) if html_message: mail.attach_alternative(html_message, "text/html") mail.send(fail_silently=fail_silently) utils.py 0000644 00000000772 15030020003 0006243 0 ustar 00 """ Email message and email sending related helper functions. """ import socket from django.utils.encoding import punycode # Cache the hostname, but do it lazily: socket.getfqdn() can take a couple of # seconds, which slows down the restart of the server. class CachedDnsName: def __str__(self): return self.get_fqdn() def get_fqdn(self): if not hasattr(self, "_fqdn"): self._fqdn = punycode(socket.getfqdn()) return self._fqdn DNS_NAME = CachedDnsName()
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings