�

Ϫ�fI}���
�dZd
dl
mZ
Gd�de�ZGd�de�ZGd�de�ZGd	�d
e�ZGd�de�ZGd
�de�ZGd�de�Z	Gd�de�Z
Gd�de�ZGd�de�ZGd�de�Z
Gd�de
�ZGd�de�ZGd�de�ZGd�d e�ZGd!�d"e�ZGd#�d$e�ZGd%�d&e�ZGd'�d(e�ZGd)�d*e�ZGd+�d,e�Zgd-�
Zy.)/z/
Interfaces for L{twisted.mail}.

@since: 16.5
�)
�	Interfacec
�"�eZ
dZd
Zd�Zd�Zd�Zy)�IChallengeResponsez;
    An C{IMAPrev4} authorization challenge mechanism.
    c��y
)zd
        Return a client challenge.

        @return: A challenge.
        @rtype: L{bytes}
        N�r��9/usr/lib/python3/dist-packages/twisted/mail/interfaces.py�getChallengezIChallengeResponse.getChallenge��rc
��y
)aL

        Extract a username and possibly a password from a response and
        assign them to C{username} and C{password} instance variables.

        @param response: A decoded response.
        @type response: L{bytes}

        @see: L{credentials.IUsernamePassword} or
            L{credentials.IUsernameHashedPassword}
        Nr)
�responses
 r	�setResponsezIChallengeResponse.setResponserrc��y
)a=

        Are there more challenges than just the first?  If so, callers
        should challenge clients with the result of L{getChallenge},
        and check their response with L{setResponse} in a loop until
        this returns L{False}

        @return: Are there more challenges?
        @rtype: L{bool}
        Nrrrr	�moreChallengesz!IChallengeResponse.moreChallenges'rrN)�__name__�
__module__�__qualname__�__doc__r
rrrrr	rrs����
�	rrc
��eZ
dZd
�Zd�Zy)�IClientAuthenticationc��y
)zl
        Return an identifier associated with this authentication scheme.

        @rtype: L{bytes}
        Nrrrr	�getNamezIClientAuthentication.getName4rrc��y
)z7
        Generate a challenge response string.
        Nr)�secret�	challenges  r	�challengeResponsez'IClientAuthentication.challengeResponse;rrN)rrrrrrrr	rr3s���rrc
�.�eZ
dZd
Zd�Zd�Zd�Zd�Zd�Zy)�IServerFactoryPOP3a�
    An interface for querying capabilities of a POP3 server.

    Any cap_* method may raise L{NotImplementedError} if the particular
    capability is not supported. If L{cap_EXPIRE()} does not raise
    L{NotImplementedError}, L{perUserExpiration()} must be implemented,
    otherwise they are optional. If L{cap_LOGIN_DELAY()} is implemented,
    L{perUserLoginDelay()} must be implemented, otherwise they are optional.

    @type challengers: L{dict} of L{bytes} -> L{IUsernameHashedPassword
        <cred.credentials.IUsernameHashedPassword>}
    @ivar challengers: A mapping of challenger names to
        L{IUsernameHashedPassword <cred.credentials.IUsernameHashedPassword>}
        provider.
    c��y
)z�
        Return a string describing the POP3 server implementation.

        @rtype: L{bytes}
        @return: Server implementation information.
        Nrrrr	�cap_IMPLEMENTATIONz%IServerFactoryPOP3.cap_IMPLEMENTATIONRrrc��y
)z�
        Return the minimum number of days messages are retained.

        @rtype: L{int} or L{None}
        @return: The minimum number of days messages are retained or none, if
            the server never deletes messages.
        Nrrrr	�
cap_EXPIREzIServerFactoryPOP3.cap_EXPIREZrrc��y
)z�
        Indicate whether the message expiration policy differs per user.

        @rtype: L{bool}
        @return: C{True} when the message expiration policy differs per user,
            C{False} otherwise.
        Nrrrr	�perUserExpirationz$IServerFactoryPOP3.perUserExpirationcrrc��y
)z�
        Return the minimum number of seconds between client logins.

        @rtype: L{int}
        @return: The minimum number of seconds between client logins.
        Nrrrr	�cap_LOGIN_DELAYz"IServerFactoryPOP3.cap_LOGIN_DELAYlrrc��y
)z�
        Indicate whether the login delay period differs per user.

        @rtype: L{bool}
        @return: C{True} when the login delay differs per user, C{False}
            otherwise.
        Nrrrr	�perUserLoginDelayz$IServerFactoryPOP3.perUserLoginDelaytrrN)	rrrrr r"r$r&r(rrr	rrAs ��� ����rrc�6�eZ
dZd
Zd	d�
Zd�Zd�Zd�Zd�Zd�Z	y)
�IMailboxPOP3a�

    An interface for mailbox access.

    Message indices are 0-based.

    @type loginDelay: L{int}
    @ivar loginDelay: The number of seconds between allowed logins for the
        user associated with this mailbox.

    @type messageExpiration: L{int}
    @ivar messageExpiration: The number of days messages in this mailbox will
        remain on the server before being deleted.
    Nc
��y
)a
        Retrieve the size of a message, or, if none is specified, the size of
        each message in the mailbox.

        @type index: L{int} or L{None}
        @param index: The 0-based index of the message.

        @rtype: L{int}, sequence of L{int}, or L{Deferred <defer.Deferred>}
        @return: The number of octets in the specified message, or, if an
            index is not specified, a sequence of the number of octets for
            all messages in the mailbox or a deferred which fires with
            one of those. Any value which corresponds to a deleted message
            is set to 0.

        @raise ValueError or IndexError: When the index does not correspond to
            a message in the mailbox.  The use of ValueError is preferred.
        Nr�
�indexs
 r	�listMessageszIMailboxPOP3.listMessages�rrc
��y
)a�

        Retrieve a file containing the contents of a message.

        @type index: L{int}
        @param index: The 0-based index of a message.

        @rtype: file-like object
        @return: A file containing the message.

        @raise ValueError or IndexError: When the index does not correspond to
            a message in the mailbox.  The use of ValueError is preferred.
        Nrr,s
 r	�
getMessagezIMailboxPOP3.getMessage�rrc
��y
)a�

        Get a unique identifier for a message.

        @type index: L{int}
        @param index: The 0-based index of a message.

        @rtype: L{bytes}
        @return: A string of printable characters uniquely identifying the
            message for all time.

        @raise ValueError or IndexError: When the index does not correspond to
            a message in the mailbox.  The use of ValueError is preferred.
        Nrr,s
 r	�getUidlzIMailboxPOP3.getUidl�rrc
��y
)a�

        Mark a message for deletion.

        This must not change the number of messages in this mailbox.  Further
        requests for the size of the deleted message should return 0.  Further
        requests for the message itself may raise an exception.

        @type index: L{int}
        @param index: The 0-based index of a message.

        @raise ValueError or IndexError: When the index does not correspond to
            a message in the mailbox.  The use of ValueError is preferred.
        Nrr,s
 r	�
deleteMessagezIMailboxPOP3.deleteMessage�rrc��y
)z�
        Undelete all messages marked for deletion.

        Any message which can be undeleted should be returned to its original
        position in the message sequence and retain its original UID.
        Nrrrr	�undeleteMessageszIMailboxPOP3.undeleteMessages�rrc��y
)zJ
        Discard the contents of any message marked for deletion.
        Nrrrr	�synczIMailboxPOP3.sync�rr�
N)
rrrrr.r0r2r4r6r8rrr	r*r*~s%����&�
�
��rr*c
�"�eZ
dZd
Zd�Zd�Zd�Zy)�IDomainz)
    An interface for email domains.
    c
��y
)a�

        Check whether a user exists in this domain.

        @type user: L{User}
        @param user: A user.

        @rtype: no-argument callable which returns L{IMessageSMTP} provider
        @return: A function which takes no arguments and returns a message
            receiver for the user.

        @raise SMTPBadRcpt: When the given user does not exist in this domain.
        Nr�
�users
 r	�existszIDomain.exists�rrc��y
)z�
        Add a user to this domain.

        @type user: L{bytes}
        @param user: A username.

        @type password: L{bytes}
        @param password: A password.
        Nr)r>�passwords  r	�addUserzIDomain.addUser�rrc��y
)z�
        Return credentials checkers for this domain.

        @rtype: L{list} of L{ICredentialsChecker
            <twisted.cred.checkers.ICredentialsChecker>} provider
        @return: Credentials checkers for this domain.
        Nrrrr	�getCredentialsCheckerszIDomain.getCredentialsCheckers�rrN)rrrrr?rBrDrrr	r;r;�s����	�rr;c
��eZ
dZd
Zd�Zy)�IAliasz#
    An interface for aliases.
    c��y
)z{
        Create a message receiver.

        @rtype: L{IMessageSMTP} provider
        @return: A message receiver.
        Nrrrr	�createMessageReceiverzIAlias.createMessageReceiver
rrN)rrrrrHrrr	rFrF
s���rrFc��eZ
dZd
Zd�Zdd�
Zy)�IAliasableDomainzO
    An interface for email domains which can be aliased to other domains.
    c
��y
)z�
        Set the group of defined aliases for this domain.

        @type aliases: L{dict} of L{bytes} -> L{IAlias} provider
        @param aliases: A mapping of domain name to alias.
        Nr)
�aliasess
 r	�
setAliasGroupzIAliasableDomain.setAliasGroup
rrNc��y
)a�
        Check whether a user exists in this domain or an alias of it.

        @type user: L{User}
        @param user: A user.

        @type memo: L{None} or L{dict} of
            L{AliasBase <twisted.mail.alias.AliasBase>}
        @param memo: A record of the addresses already considered while
            resolving aliases. The default value should be used by all external
            code.

        @rtype: no-argument callable which returns L{IMessageSMTP} provider
        @return: A function which takes no arguments and returns a message
            receiver for the user.

        @raise SMTPBadRcpt: When the given user does not exist in this domain
            or an alias of it.
        Nr)r>�memos  r	r?zIAliasableDomain.exists
rrr9)rrrrrMr?rrr	rJrJ
s����rrJc
��eZ
dZd
�Zd�Zd�Zy)�IMessageDeliveryc��y
)a
        Generate the Received header for a message.

        @type helo: 2-L{tuple} of L{bytes} and L{bytes}.
        @param helo: The argument to the HELO command and the client's IP
        address.

        @type origin: L{Address}
        @param origin: The address the message is from

        @type recipients: L{list} of L{User}
        @param recipients: A list of the addresses for which this message
        is bound.

        @rtype: L{bytes}
        @return: The full C{"Received"} header string.
        Nr)�helo�origin�
recipientss   r	�receivedHeaderzIMessageDelivery.receivedHeader4
rrc
��y
)a#
        Validate the address for which the message is destined.

        @type user: L{User}
        @param user: The address to validate.

        @rtype: no-argument callable
        @return: A L{Deferred} which becomes, or a callable which takes no
            arguments and returns an object implementing L{IMessageSMTP}. This
            will be called and the returned object used to deliver the message
            when it arrives.

        @raise SMTPBadRcpt: Raised if messages to the address are not to be
            accepted.
        Nrr=s
 r	�
validateTozIMessageDelivery.validateToG
rrc��y
)a#
        Validate the address from which the message originates.

        @type helo: 2-L{tuple} of L{bytes} and L{bytes}.
        @param helo: The argument to the HELO command and the client's IP
        address.

        @type origin: L{Address}
        @param origin: The address the message is from

        @rtype: L{Deferred} or L{Address}
        @return: C{origin} or a L{Deferred} whose callback will be
        passed C{origin}.

        @raise SMTPBadSender: Raised of messages from this address are
        not to be accepted.
        Nr)rSrTs  r	�validateFromzIMessageDelivery.validateFromX
rrN)rrrrVrXrZrrr	rQrQ3
s���&�"rrQc
��eZ
dZd
Zd�Zy)�IMessageDeliveryFactorya�

    An alternate interface to implement for handling message delivery.

    It is useful to implement this interface instead of L{IMessageDelivery}
    directly because it allows the implementor to distinguish between different
    messages delivery over the same connection. This can be used to optimize
    delivery of a single message to multiple recipients, something which cannot
    be done by L{IMessageDelivery} implementors due to their lack of
    information.
    c��y
)zf
        Return an L{IMessageDelivery} object.

        This will be called once per message.
        Nrrrr	�getMessageDeliveryz*IMessageDeliveryFactory.getMessageDeliveryx
rrN)rrrrr^rrr	r\r\l
s��	�rr\c
�"�eZ
dZd
Zd�Zd�Zd�Zy)�IMessageSMTPzF
    Interface definition for messages that can be sent via SMTP.
    c
��y
)z&
        Handle another line.
        Nr)
�lines
 r	�lineReceivedzIMessageSMTP.lineReceived�
rrc��y
)z�
        Handle end of message.

        return a deferred. The deferred should be called with either:
        callback(string) or errback(error)

        @rtype: L{Deferred}
        Nrrrr	�eomReceivedzIMessageSMTP.eomReceived�
rrc��y
)z_
        Handle message truncated.

        semantics should be to discard the message
        Nrrrr	�connectionLostzIMessageSMTP.connectionLost�
rrN)rrrrrcrergrrr	r`r`�
s����
�rr`c
�*�eZ
dZd
�Zd�Zd�Zd�Zd�Zy)�IMessageIMAPPartc
��y
)a�

        Retrieve a group of message headers.

        @type names: L{tuple} of L{str}
        @param names: The names of the headers to retrieve or omit.

        @type negate: L{bool}
        @param negate: If True, indicates that the headers listed in C{names}
            should be omitted from the return value, rather than included.

        @rtype: L{dict}
        @return: A mapping of header field names to header field values
        Nr)�negate�namess  r	�
getHeaderszIMessageIMAPPart.getHeaders�
rrc��y
)zR
        Retrieve a file object containing only the body of this message.
        Nrrrr	�getBodyFilezIMessageIMAPPart.getBodyFile�
rrc��y
)z^
        Retrieve the total size, in octets, of this message.

        @rtype: L{int}
        Nrrrr	�getSizezIMessageIMAPPart.getSize�
rrc��y
)zV
        Indicate whether this message has subparts.

        @rtype: L{bool}
        Nrrrr	�isMultipartzIMessageIMAPPart.isMultipart�
rrc
��y
)a�

        Retrieve a MIME sub-message

        @type part: L{int}
        @param part: The number of the part to retrieve, indexed from 0.

        @raise IndexError: Raised if the specified part does not exist.
        @raise TypeError: Raised if this message is not multipart.

        @rtype: Any object implementing L{IMessageIMAPPart}.
        @return: The specified sub-part.
        Nr)
�parts
 r	�
getSubPartzIMessageIMAPPart.getSubPart�
rrN)rrrrmrorqrsrvrrr	riri�
s��
��
��rric
��eZ
dZd
�Zd�Zd�Zy)�IMessageIMAPc��y
)zN
        Retrieve the unique identifier associated with this message.
        Nrrrr	�getUIDzIMessageIMAP.getUID�
rrc��y
)z�
        Retrieve the flags associated with this message.

        @rtype: C{iterable}
        @return: The flags, represented as strings.
        Nrrrr	�getFlagszIMessageIMAP.getFlags�
rrc��y
)z�
        Retrieve the date internally associated with this message.

        @rtype: L{bytes}
        @return: An RFC822-formatted date string.
        Nrrrr	�getInternalDatezIMessageIMAP.getInternalDate�
rrN)rrrrzr|r~rrr	rxrx�
s���
�rrxc
��eZ
dZd
Zd�Zy)�IMessageIMAPFilez�
    Optional message interface for representing messages as files.

    If provided by message objects, this interface will be used instead the
    more complex MIME-based interface.
    c��y
)z�
        Return a file-like object opened for reading.

        Reading from the returned file will return all the bytes of which this
        message consists.
        Nrrrr	�openzIMessageIMAPFile.open�
rrN)rrrrr�rrr	r�r��
����rr�c
��eZ
dZd
�Zy)�ISearchableIMAPMailboxc��y
)a{
        Search for messages that meet the given query criteria.

        If this interface is not implemented by the mailbox,
        L{IMailboxIMAP.fetch} and various methods of L{IMessageIMAP} will be
        used instead.

        Implementations which wish to offer better performance than the default
        implementation should implement this interface.

        @type query: L{list}
        @param query: The search criteria

        @type uid: L{bool}
        @param uid: If true, the IDs specified in the query are UIDs; otherwise
            they are message sequence IDs.

        @rtype: L{list} or L{Deferred}
        @return: A list of message sequence numbers or message UIDs which match
            the search criteria or a L{Deferred} whose callback will be invoked
            with such a list.

        @raise IllegalQueryError: Raised when query is not valid.
        Nr)�query�uids  r	�searchzISearchableIMAPMailbox.search�
rrN)rrrr�rrr	r�r��
s��rr�c
�"�eZ
dZd
Zd�Zd�Zd�Zy)�IMailboxIMAPListenerz<
    Interface for objects interested in mailbox events
    c
��y
)z�
        Indicates that the write status of a mailbox has changed.

        @type writeable: L{bool}
        @param writeable: A true value if write is now allowed, false
            otherwise.
        Nr)
�	writeables
 r	�modeChangedz IMailboxIMAPListener.modeChangedrrc
��y
)z�
        Indicates that the flags of one or more messages have changed.

        @type newFlags: L{dict}
        @param newFlags: A mapping of message identifiers to tuples of flags
            now set on that message.
        Nr)
�newFlagss
 r	�flagsChangedz!IMailboxIMAPListener.flagsChanged rrc��y
)a�

        Indicates that the number of messages in a mailbox has changed.

        @type exists: L{int} or L{None}
        @param exists: The total number of messages now in this mailbox. If the
            total number of messages has not changed, this should be L{None}.

        @type recent: L{int}
        @param recent: The number of messages now flagged C{\Recent}. If the
            number of recent messages has not changed, this should be L{None}.
        Nr)r?�recents  r	�newMessagesz IMailboxIMAPListener.newMessages)rrN)rrrrr�r�r�rrr	r�r�s�����rr�c
��eZ
dZd
�Zy)�IMessageIMAPCopierc
��y
)aK
        Copy the given message object into this mailbox.

        The message object will be one which was previously returned by
        L{IMailboxIMAP.fetch}.

        Implementations which wish to offer better performance than the default
        implementation should implement this interface.

        If this interface is not implemented by the mailbox,
        L{IMailboxIMAP.addMessage} will be used instead.

        @rtype: L{Deferred} or L{int}
        @return: Either the UID of the message or a Deferred which fires with
            the UID when the copy finishes.
        Nr)
�
messageObjects
 r	�copyzIMessageIMAPCopier.copy8rrN)rrrr�rrr	r�r�7s��rr�c
��eZ
dZd
Zd�Zd�Zy)�IMailboxIMAPInfoz�
    Interface specifying only the methods required for C{listMailboxes}.

    Implementations can return objects implementing only these methods for
    return to C{listMailboxes} if it can allow them to operate more
    efficiently.
    c��y
)a

        Return the flags defined in this mailbox

        Flags with the \ prefix are reserved for use as system flags.

        @rtype: L{list} of L{str}
        @return: A list of the flags that can be set on messages in this
            mailbox.
        Nrrrr	r|zIMailboxIMAPInfo.getFlagsTrrc��y
)zl
        Get the character which delimits namespaces for in this mailbox.

        @rtype: L{bytes}
        Nrrrr	�getHierarchicalDelimiterz)IMailboxIMAPInfo.getHierarchicalDelimiter_rrN)rrrrr|r�rrr	r�r�Ks���	�rr�c
�f�eZ
dZd
�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zd�Zd�Zy)�IMailboxIMAPc��y
)za
        Return the unique validity identifier for this mailbox.

        @rtype: L{int}
        Nrrrr	�getUIDValidityzIMailboxIMAP.getUIDValidityhrrc��y
)zk
        Return the likely UID for the next message added to this mailbox.

        @rtype: L{int}
        Nrrrr	�
getUIDNextzIMailboxIMAP.getUIDNextorrc
��y
)z�
        Return the UID of a message in the mailbox

        @type message: L{int}
        @param message: The message sequence number

        @rtype: L{int}
        @return: The UID of the message.
        Nr)
�messages
 r	rzzIMailboxIMAP.getUIDvrrc��y
)zX
        Return the number of messages in this mailbox.

        @rtype: L{int}
        Nrrrr	�getMessageCountzIMailboxIMAP.getMessageCount�rrc��y
)z_
        Return the number of messages with the 'Recent' flag.

        @rtype: L{int}
        Nrrrr	�getRecentCountzIMailboxIMAP.getRecentCount�rrc��y
)z_
        Return the number of messages with the 'Unseen' flag.

        @rtype: L{int}
        Nrrrr	�getUnseenCountzIMailboxIMAP.getUnseenCount�rrc��y
)z�
        Get the read/write status of the mailbox.

        @rtype: L{int}
        @return: A true value if write permission is allowed, a false value
            otherwise.
        Nrrrr	�isWriteablezIMailboxIMAP.isWriteable�rrc��y
)z�
        Called before this mailbox is deleted, permanently.

        If necessary, all resources held by this mailbox should be cleaned up
        here. This function _must_ set the \Noselect flag on this mailbox.
        Nrrrr	�destroyzIMailboxIMAP.destroy�rrc
��y
)aa
        Return status information about this mailbox.

        Mailboxes which do not intend to do any special processing to generate
        the return value, C{statusRequestHelper} can be used to build the
        dictionary by calling the other interface methods which return the data
        for each name.

        @type names: Any iterable
        @param names: The status names to return information regarding. The
            possible values for each name are: MESSAGES, RECENT, UIDNEXT,
            UIDVALIDITY, UNSEEN.

        @rtype: L{dict} or L{Deferred}
        @return: A dictionary containing status information about the requested
            names is returned. If the process of looking this information up
            would be costly, a deferred whose callback will eventually be
            passed this dictionary is returned instead.
        Nr)
rls
 r	�
requestStatuszIMailboxIMAP.requestStatus�rrc
��y
)a

        Add a mailbox change listener

        @type listener: Any object which implements C{IMailboxIMAPListener}
        @param listener: An object to add to the set of those which will be
            notified when the contents of this mailbox change.
        Nr�
�listeners
 r	�addListenerzIMailboxIMAP.addListener�rrc
��y
)aY

        Remove a mailbox change listener

        @type listener: Any object previously added to and not removed from
            this mailbox as a listener.
        @param listener: The object to remove from the set of listeners.

        @raise ValueError: Raised when the given object is not a listener for
            this mailbox.
        Nrr�s
 r	�removeListenerzIMailboxIMAP.removeListener�rrc��y
)a�
        Add the given message to this mailbox.

        @type message: A file-like object
        @param message: The RFC822 formatted message

        @type flags: Any iterable of L{bytes}
        @param flags: The flags to associate with this message

        @type date: L{bytes}
        @param date: If specified, the date to associate with this message.

        @rtype: L{Deferred}
        @return: A deferred whose callback is invoked with the message id if
            the message is added successfully and whose errback is invoked
            otherwise.

        @raise ReadOnlyMailbox: Raised if this Mailbox is not open for
            read-write.
        Nr)r��flags�dates   r	�
addMessagezIMailboxIMAP.addMessage�rrc��y
)aW

        Remove all messages flagged \Deleted.

        @rtype: L{list} or L{Deferred}
        @return: The list of message sequence numbers which were deleted, or a
            L{Deferred} whose callback will be invoked with such a list.

        @raise ReadOnlyMailbox: Raised if this Mailbox is not open for
            read-write.
        Nrrrr	�expungezIMailboxIMAP.expunge�rrc��y
)a�

        Retrieve one or more messages.

        @type messages: C{MessageSet}
        @param messages: The identifiers of messages to retrieve information
            about

        @type uid: L{bool}
        @param uid: If true, the IDs specified in the query are UIDs; otherwise
            they are message sequence IDs.

        @rtype: Any iterable of two-tuples of message sequence numbers and
            implementors of C{IMessageIMAP}.
        Nr)�messagesr�s  r	�fetchzIMailboxIMAP.fetch�rrc��y
)a�
        Set the flags of one or more messages.

        @type messages: A MessageSet object with the list of messages requested
        @param messages: The identifiers of the messages to set the flags of.

        @type flags: sequence of L{str}
        @param flags: The flags to set, unset, or add.

        @type mode: -1, 0, or 1
        @param mode: If mode is -1, these flags should be removed from the
            specified messages. If mode is 1, these flags should be added to
            the specified messages. If mode is 0, all existing flags should be
            cleared and these flags should be added.

        @type uid: L{bool}
        @param uid: If true, the IDs specified in the query are UIDs; otherwise
            they are message sequence IDs.

        @rtype: L{dict} or L{Deferred}
        @return: A L{dict} mapping message sequence numbers to sequences of
            L{str} representing the flags set on the message after this
            operation has been performed, or a L{Deferred} whose callback will
            be invoked with such a L{dict}.

        @raise ReadOnlyMailbox: Raised if this mailbox is not open for
            read-write.
        Nr)r�r��moder�s    r	�storezIMailboxIMAP.storerrN)rrrr�r�rzr�r�r�r�r�r�r�r�r�r�r�r�rrr	r�r�gsM����	�������*�
��,
�� rr�c
��eZ
dZd
Zd�Zy)�ICloseableMailboxIMAPz�
    A supplementary interface for mailboxes which require cleanup on close.

    Implementing this interface is optional. If it is implemented, the protocol
    code will call the close method defined whenever a mailbox is closed.
    c��y
)z�
        Close this mailbox.

        @return: A L{Deferred} which fires when this mailbox has been closed,
            or None if the mailbox can be closed immediately.
        Nrrrr	�closezICloseableMailboxIMAP.close*rrN)rrrrr�rrr	r�r�"r�rr�c�J�eZ
dZd
Zdd�
Zd�Zd
d�
Zd�Zd�Zd�Z	d	�Z
d
�Zd�Zy)�IAccountIMAPz�
    Interface for Account classes

    Implementors of this interface should consider implementing
    C{INamespacePresenter}.
    Nc��y
)a�
        Add a new mailbox to this account

        @type name: L{bytes}
        @param name: The name associated with this mailbox. It may not contain
            multiple hierarchical parts.

        @type mbox: An object implementing C{IMailboxIMAP}
        @param mbox: The mailbox to associate with this name. If L{None}, a
            suitable default is created and used.

        @rtype: L{Deferred} or L{bool}
        @return: A true value if the creation succeeds, or a deferred whose
            callback will be invoked when the creation succeeds.

        @raise MailboxException: Raised if this mailbox cannot be added for
            some reason. This may also be raised asynchronously, if a
            L{Deferred} is returned.
        Nr)�name�mboxs  r	�
addMailboxzIAccountIMAP.addMailbox;rrc
��y
)a�
        Create a new mailbox from the given hierarchical name.

        @type pathspec: L{bytes}
        @param pathspec: The full hierarchical name of a new mailbox to create.
            If any of the inferior hierarchical names to this one do not exist,
            they are created as well.

        @rtype: L{Deferred} or L{bool}
        @return: A true value if the creation succeeds, or a deferred whose
            callback will be invoked when the creation succeeds.

        @raise MailboxException: Raised if this mailbox cannot be added. This
            may also be raised asynchronously, if a L{Deferred} is returned.
        Nr)
�pathspecs
 r	�createzIAccountIMAP.createPrrc��y
)aF
        Acquire a mailbox, given its name.

        @type name: L{bytes}
        @param name: The mailbox to acquire

        @type rw: L{bool}
        @param rw: If a true value, request a read-write version of this
            mailbox. If a false value, request a read-only version.

        @rtype: Any object implementing C{IMailboxIMAP} or L{Deferred}
        @return: The mailbox object, or a L{Deferred} whose callback will be
            invoked with the mailbox object. None may be returned if the
            specified mailbox may not be selected for any reason.
        Nr)r��rws  r	�selectzIAccountIMAP.selectarrc
��y
)a�

        Delete the mailbox with the specified name.

        @type name: L{bytes}
        @param name: The mailbox to delete.

        @rtype: L{Deferred} or L{bool}
        @return: A true value if the mailbox is successfully deleted, or a
            L{Deferred} whose callback will be invoked when the deletion
            completes.

        @raise MailboxException: Raised if this mailbox cannot be deleted. This
            may also be raised asynchronously, if a L{Deferred} is returned.
        Nr�
r�s
 r	�deletezIAccountIMAP.deleterrrc��y
)ag
        Rename a mailbox

        @type oldname: L{bytes}
        @param oldname: The current name of the mailbox to rename.

        @type newname: L{bytes}
        @param newname: The new name to associate with the mailbox.

        @rtype: L{Deferred} or L{bool}
        @return: A true value if the mailbox is successfully renamed, or a
            L{Deferred} whose callback will be invoked when the rename
            operation is completed.

        @raise MailboxException: Raised if this mailbox cannot be renamed. This
            may also be raised asynchronously, if a L{Deferred} is returned.
        Nr)�oldname�newnames  r	�renamezIAccountIMAP.rename�rrc
��y
)a�

        Check the subscription status of a mailbox

        @type name: L{bytes}
        @param name: The name of the mailbox to check

        @rtype: L{Deferred} or L{bool}
        @return: A true value if the given mailbox is currently subscribed to,
            a false value otherwise. A L{Deferred} may also be returned whose
            callback will be invoked with one of these values.
        Nrr�s
 r	�isSubscribedzIAccountIMAP.isSubscribed�rrc
��y
)a!
        Subscribe to a mailbox

        @type name: L{bytes}
        @param name: The name of the mailbox to subscribe to

        @rtype: L{Deferred} or L{bool}
        @return: A true value if the mailbox is subscribed to successfully, or
            a Deferred whose callback will be invoked with this value when the
            subscription is successful.

        @raise MailboxException: Raised if this mailbox cannot be subscribed
            to. This may also be raised asynchronously, if a L{Deferred} is
            returned.
        Nrr�s
 r	�	subscribezIAccountIMAP.subscribe�rrc
��y
)a3
        Unsubscribe from a mailbox

        @type name: L{bytes}
        @param name: The name of the mailbox to unsubscribe from

        @rtype: L{Deferred} or L{bool}
        @return: A true value if the mailbox is unsubscribed from successfully,
            or a Deferred whose callback will be invoked with this value when
            the unsubscription is successful.

        @raise MailboxException: Raised if this mailbox cannot be unsubscribed
            from. This may also be raised asynchronously, if a L{Deferred} is
            returned.
        Nrr�s
 r	�unsubscribezIAccountIMAP.unsubscribe�rrc��y
)a�
        List all the mailboxes that meet a certain criteria

        @type ref: L{bytes}
        @param ref: The context in which to apply the wildcard

        @type wildcard: L{bytes}
        @param wildcard: An expression against which to match mailbox names.
            '*' matches any number of characters in a mailbox name, and '%'
            matches similarly, but will not match across hierarchical
            boundaries.

        @rtype: L{list} of L{tuple}
        @return: A list of C{(mailboxName, mailboxObject)} which meet the given
            criteria. C{mailboxObject} should implement either
            C{IMailboxIMAPInfo} or C{IMailboxIMAP}. A Deferred may also be
            returned.
        Nr)�ref�wildcards  r	�
listMailboxeszIAccountIMAP.listMailboxes�rrr9)
T)
rrrrr�r�r�r�r�r�r�r�r�rrr	r�r�3s4����*�"�"� �&��"�"rr�c
��eZ
dZd
�Zd�Zd�Zy)�INamespacePresenterc��y
)a�

        Report the available personal namespaces.

        Typically there should be only one personal namespace. A common name
        for it is C{""}, and its hierarchical delimiter is usually C{"/"}.

        @rtype: iterable of two-tuples of strings
        @return: The personal namespaces and their hierarchical delimiters. If
            no namespaces of this type exist, None should be returned.
        Nrrrr	�getPersonalNamespacesz)INamespacePresenter.getPersonalNamespaces�rrc��y
)a�

        Report the available shared namespaces.

        Shared namespaces do not belong to any individual user but are usually
        to one or more of them. Examples of shared namespaces might be
        C{"#news"} for a usenet gateway.

        @rtype: iterable of two-tuples of strings
        @return: The shared namespaces and their hierarchical delimiters. If no
            namespaces of this type exist, None should be returned.
        Nrrrr	�getSharedNamespacesz'INamespacePresenter.getSharedNamespaces�rrc��y
)a

        Report the available user namespaces.

        These are namespaces that contain folders belonging to other users
        access to which this account has been granted.

        @rtype: iterable of two-tuples of strings
        @return: The user namespaces and their hierarchical delimiters. If no
            namespaces of this type exist, None should be returned.
        Nrrrr	�getUserNamespacesz%INamespacePresenter.getUserNamespaces�rrN)rrrr�r�r�rrr	r�r��s��
��
rr�)r�r�r�r�r�rxr�r�rir�r�rQr\r`r;rFrJr*rrN)r�zope.interfacerrrrr*r;rFrJrQr\r`rirxr�r�r�r�r�r�r�r�r��__all__rrr	�<module>r�
s%
�


�
�
%�"
��"
�J

�I�
�:
��:
�z
Y

�9�Y

�x%
�i�%
�P

�Y�
� 
�w� 
�F
6
�y�6
�r

�i�
�(
�9�
�8/
�y�/
�d

�#�
�.
�y�
�"
�Y�
�8"
�9�"
�J

��
�(
�y�
�8x
�#�x
�v
�I�
�"c
�9�c
�L$
�)�$
�N
�r