Spade

Mini Shell

Directory:~$ /lib64/python3.6/email/__pycache__/
Upload File
[Home] [System Details] [Kill Me]
Current File:~$ //lib64/python3.6/email/__pycache__/_policybase.cpython-36.opt-1.pyc

3


 \�:�@s�dZddlZddlmZddlmZddlmZdddgZGd	d
�d
�Z	dd�Z
d
d�ZGdd�de	ejd�Z
eGdd�de
��Ze�ZdS)zwPolicy
framework for the email package.

Allows fine grained feature control of how the package parses and emits
data.
�N)�header)�charset)�_has_surrogates�Policy�Compat32�compat32cs@eZdZdZ�fdd�Zdd�Zdd�Zdd	�Zd
d�Z�Z	S)�_PolicyBasea�Policy Object basic framework.

    This class is useless unless subclassed.  A subclass should define
    class attributes with defaults for any values that are to be
    managed by the Policy object.  The constructor will then allow
    non-default values to be set for these attributes at instance
    creation time.  The instance will be callable, taking these same
    attributes keyword arguments, and returning a new instance
    identical to the called instance except for those values changed
    by the keyword arguments.  Instances may be added, yielding new
    instances with any non-default values from the right hand
    operand overriding those in the left hand operand.  That is,

        A + B == A(<non-default values of B>)

    The repr of an instance can be used to reconstruct the object
    if and only if the repr of the values can be used to reconstruct
    those values.

    csLxF|j�D]:\}}t||�r0tt|�j||�q
tdj||jj���q
WdS)z�Create new Policy, possibly overriding some defaults.

        See class docstring for a list of overridable attributes.

        z*{!r} is an invalid keyword argument for
{}N)	�items�hasattr�superr�__setattr__�	TypeError�format�	__class__�__name__)�self�kw�name�value)r��#/usr/lib64/python3.6/_policybase.py�__init__)s
z_PolicyBase.__init__cCs*dd�|jj�D�}dj|jjdj|��S)NcSsg|]\}}dj||��qS)z{}={!r})r)�.0rrrrr�
<listcomp>8sz(_PolicyBase.__repr__.<locals>.<listcomp>z{}({})z,
)�__dict__r	rrr�join)r�argsrrr�__repr__7sz_PolicyBase.__repr__cKsz|jj|j�}x$|jj�D]\}}tj|||�qWx@|j�D]4\}}t||�sdtdj||jj	���tj|||�q>W|S)z�Return
a new instance with specified attributes changed.

        The new instance has the same attribute values as the current
object,
        except for the changes passed in as keyword arguments.

        z*{!r} is an invalid keyword argument for {})
r�__new__rr	�objectrr
r
rr)rrZ	newpolicy�attrrrrr�clone<s
z_PolicyBase.clonecCs,t||�rd}nd}t|j|jj|���dS)Nz'{!r}
object attribute {!r} is read-onlyz!{!r} object has no attribute {!r})r
�AttributeErrorrrr)rrr�msgrrrrNs
z_PolicyBase.__setattr__cCs|jf|j�S)z�Non-default values
from right operand override those from left.

        The object returned is a new instance of the subclass.

        )r!r)r�otherrrr�__add__Usz_PolicyBase.__add__)
r�
__module__�__qualname__�__doc__rrr!rr%�
__classcell__rr)rrrsrcCs,|jdd�d}|jdd�d}|d|S)N�
�r)�rsplit�split)�docZ	added_docrrr�_append_doc^sr/cCs�|jr(|jjd�r(t|jdj|j�|_xf|jj�D]X\}}|jr4|jjd�r4x<dd�|jD�D](}tt||�d�}|r`t||j�|_Pq`Wq4W|S)N�+rcss
|]}|j�D]
}|VqqdS)N)�mro)r�base�crrr�	<genexpr>hsz%_extend_docstrings.<locals>.<genexpr>r()r(�
startswithr/�	__bases__rr	�getattr)�clsrr
r3r.rrr�_extend_docstringscs
r9c@s�eZdZdZdZdZdZdZdZdZ	dd�Z
d	d
�Zdd�Ze
jd
d��Ze
jdd��Ze
jdd��Ze
jdd��Ze
jdd��ZdS)raI	Controls
for how messages are interpreted and formatted.

    Most of the classes and many of the methods in the email package accept
    Policy objects as parameters.  A Policy object contains a set of values
and
    functions that control how input is interpreted and how output is
rendered.
    For example, the parameter 'raise_on_defect' controls whether
or not an RFC
    violation results in an error being raised or not, while
'max_line_length'
    controls the maximum length of output lines when a Message is
serialized.

    Any valid attribute may be overridden when a Policy is created by
passing
    it as a keyword argument to the constructor.  Policy objects are
immutable,
    but a new Policy object can be created with only certain values changed
by
    calling the Policy instance with keyword arguments.  Policy objects can
    also be added, producing a new Policy object in which the non-default
    attributes set in the right hand operand overwrite those specified in
the
    left operand.

    Settable attributes:

    raise_on_defect     -- If true, then defects should be raised as
errors.
                           Default: False.

    linesep             -- string containing the value to use as separation
                           between output lines.  Default '\n'.

    cte_type            -- Type of allowed content transfer encodings

                           7bit  -- ASCII only
                           8bit  -- Content-Transfer-Encoding: 8bit is
allowed

                           Default: 8bit.  Also controls the disposition of
                           (RFC invalid) binary data in headers; see the
                           documentation of the binary_fold method.

    max_line_length     -- maximum length of lines, excluding
'linesep',
                           during serialization.  None or 0 means no line
                           wrapping is done.  Default is 78.

    mangle_from_        -- a flag that, when True escapes From_ lines in
the
                           body of the message by putting a `>' in
front of
                           them. This is used when the message is being
                           serialized by a generator. Default: True.

    message_factory     -- the class to use to create new message objects.
                           If the value is None, the default is Message.

    Fr*Z8bit�NNcCs|jr
|�|j||�dS)aZBased on policy, either raise defect or call
register_defect.

            handle_defect(obj, defect)

        defect should be a Defect subclass, but in any case must be an
        Exception subclass.  obj is the object on which the defect should
be
        registered if it is not raised.  If the raise_on_defect is True,
the
        defect is raised as an error, otherwise the object and the defect
are
        passed to register_defect.

        This method is intended to be called by parsers that discover
defects.
        The email package parsers always call it with Defect instances.

       
N)�raise_on_defect�register_defect)r�obj�defectrrr�
handle_defect�szPolicy.handle_defectcCs|jj|�dS)a�Record
'defect' on 'obj'.

        Called by handle_defect if raise_on_defect is False.  This method
is
        part of the Policy API so that Policy subclasses can implement
custom
        defect handling.  The default implementation calls the append
method of
        the defects attribute of obj.  The objects used by the email
package by
        default that get passed to this method will always have a defects
        attribute with an append method.

       
N)Zdefects�append)rr=r>rrrr<�szPolicy.register_defectcCsdS)a[Return
the maximum allowed number of headers named 'name'.

        Called when a header is added to a Message object.  If the returned
        value is not 0 or None, and there are already a number of headers
with
        the name 'name' equal to the value returned, a ValueError
is raised.

        Because the default behavior of Message's __setitem__ is to
append the
        value to the list of headers, it is easy to create duplicate
headers
        without realizing it.  This method allows certain headers to be
limited
        in the number of instances of that header that may be added to a
        Message programmatically.  (The limit is not observed by the
parser,
        which will faithfully produce as many headers as exist in the
message
        being parsed.)

        The default implementation returns None for all header names.
       
Nr)rrrrr�header_max_count�szPolicy.header_max_countcCst�dS)aZGiven
a list of linesep terminated strings constituting the lines of
        a single header, return the (name, value) tuple that should be
stored
        in the model.  The input lines should retain their terminating
linesep
        characters.  The lines passed in by the email package may contain
        surrogateescaped binary data.
       
N)�NotImplementedError)r�sourcelinesrrr�header_source_parse�szPolicy.header_source_parsecCst�dS)z�Given
the header name and the value provided by the application
        program, return the (name, value) that should be stored in the
model.
       
N)rB)rrrrrr�header_store_parse�szPolicy.header_store_parsecCst�dS)awGiven
the header name and the value from the model, return the value
        to be returned to the application program that is requesting that
        header.  The value passed in by the email package may contain
        surrogateescaped binary data if the lines were parsed by a
BytesParser.
        The returned value should not contain any surrogateescaped data.

       
N)rB)rrrrrr�header_fetch_parse�s	zPolicy.header_fetch_parsecCst�dS)a�Given
the header name and the value from the model, return a string
        containing linesep characters that implement the folding of the
header
        according to the policy controls.  The value passed in by the email
        package may contain surrogateescaped binary data if the lines were
        parsed by a BytesParser.  The returned value should not contain any
        surrogateescaped data.

        N)rB)rrrrrr�fold�s
zPolicy.foldcCst�dS)a%Given the header name and the value from
the model, return binary
        data containing linesep characters that implement the folding of
the
        header according to the policy controls.  The value passed in by
the
        email package may contain surrogateescaped binary data.

       
N)rB)rrrrrr�fold_binaryszPolicy.fold_binary)rr&r'r(r;�linesep�cte_type�max_line_length�mangle_from_Zmessage_factoryr?r<rA�abc�abstractmethodrDrErFrGrHrrrrrps0

)�	metaclassc@sLeZdZdZdZdd�Zdd�Zdd�Zd	d
�Zdd�Z	d
d�Z
dd�ZdS)rz�+
    This particular policy is the backward compatibility Policy.  It
    replicates the behavior of the email package version 5.1.
   
TcCs0t|t�s|St|�r(tj|tj|d�S|SdS)N)r�header_name)�
isinstance�strrr�Header�_charset�UNKNOWN8BIT)rrrrrr�_sanitize_headers

zCompat32._sanitize_headercCs>|djdd�\}}|jd�dj|dd��}||jd�fS)a:+
        The name is parsed as everything up to the ':' and
returned unmodified.
        The value is determined by stripping leading whitespace off the
        remainder of the first line, joining all subsequent lines together,
and
        stripping any trailing carriage return or linefeed characters.

        r�:r+z 	�Nz
)r-�lstripr�rstrip)rrCrrrrrrD%szCompat32.header_source_parsecCs||fS)z>+
        The name and value are returned unmodified.
       
r)rrrrrrrE1szCompat32.header_store_parsecCs|j||�S)z�+
        If the value contains binary data, it is converted into a Header
object
        using the unknown-8bit charset.  Otherwise it is returned
unmodified.
       
)rV)rrrrrrrF7szCompat32.header_fetch_parsecCs|j||dd�S)a+
        Headers are folded using the Header folding algorithm, which
preserves
        existing line breaks in the value, and wraps each resulting line to
the
        max_line_length.  Non-ASCII binary data are CTE encoded using the
        unknown-8bit charset.

       
T)�sanitize)�_fold)rrrrrrrG>sz
Compat32.foldcCs"|j|||jdkd�}|jdd�S)a�+
        Headers are folded using the Header folding algorithm, which
preserves
        existing line breaks in the value, and wraps each resulting line to
the
        max_line_length.  If cte_type is 7bit, non-ascii binary data is CTE
        encoded using the unknown-8bit charset.  Otherwise the original
source
        header is used, with its existing line breaks and/or binary data.

       
Z7bit)r[�ascii�surrogateescape)r\rJ�encode)rrrZfoldedrrrrHHs	zCompat32.fold_binarycCs�g}|jd|�t|t�r\t|�rL|r<tj|tj|d�}qZ|j|�d}q`tj||d�}n|}|dk	r�d}|jdk	r||j}|j|j	|j
|d��|j|j
�dj|�S)Nz%s: )rrP)rPr)rI�
maxlinelenrX)r@rQrRrrrSrTrUrKr_rIr)rrrr[�parts�hr`rrrr\Ts&



zCompat32._foldN)rr&r'r(rLrVrDrErFrGrHr\rrrrrs
)r(rMZemailrrrTZemail.utilsr�__all__rr/r9�ABCMetarrrrrrr�<module>sL

f