,h ddlmZddlZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z m Z ddl mZddlmZmZddlmZmZmZmZmZmZmZdd lmZdd lmZdd lmZdd lmZdd lm Z m!Z!ddl"m#Z$m%Z&ddl'm(Z(m)Z)m*Z*ddl+m,Z,m-Z-m.Z.ej^Z/ere0Z1ee2Z3gdZ4dejjvrdejjd<dejjvrdejjd<dejjvrdejjd<dejjvrdejjd<dejjvrdejjd<dejjvrdejjd<dejjvrdejjd<dZ6dZ7dZ8d Z9d!Z:d"Z;d#Zd&Z?d'Z@d(ZAd)ZBe@d*e>d+e=d,eAd-e?d.iZCGd/d0eDZEGd1d2e d2d3ZFGd4d5e d5d6ZGGd7d8e d8d9ZHd:ZIGd;dZMdVd?ZNGd@dAeZOdBZPdCZQdDZRdEZSdFZTdGZUdHZVdIZWdJZXdKZYdLZZdMZ[dNZ\eJZ]GdOdPeJZ^dQZ_dRZ`dSZaGdTdUeZby)W)unicode_literalsN) namedtuple)datetimedate) itemgetter) LoggerAdapter getLogger)moves iteritems text_type integer_typesPY3 binary_type iterbytes) exceptions)imap4)response_lexer)tls)datetime_to_INTERNALDATEformat_criteria_date)encodedecode)parse_responseparse_message_listparse_fetch_response)to_bytes to_unicodeassert_imap_protocol) IMAPClient SocketTimeoutDELETEDSEENANSWEREDFLAGGEDDRAFTRECENTXLIST)NONAUTHAUTHSELECTEDIDLESTARTTLS)r)IDUNSELECT)r*r+ENABLE)r*MOVEs\Deleteds\Seens \Answereds\Flaggeds\Drafts\Recents\Alls\Archives\Draftss\Junks\Sents\Trash))r2)zINBOX..)Sentz Sent Itemsz Sent items)Drafts)Archive)Trashz Deleted ItemszDeleted Messages)JunkSpamcfeZdZdZeedZeedZeedZy) Namespacec4tj||||fSN)tuple__new__)clspersonalothershareds W/var/www/html/Resume-Scraper/venv/lib/python3.12/site-packages/imapclient/imapclient.pyr?zNamespace.__new__hs}}S8UF";<<rrN) __name__ __module__ __qualname__r?propertyrrArBrCrErDr;r;fs3= 1 &H Z] #E jm $FrEr;ceZdZdZy)r!aRepresents timeout configuration for an IMAP connection. :ivar connect: maximum time to wait for a connection attempt to remote server :ivar read: maximum time to wait for performing a read/write operation As an example, ``SocketTimeout(connect=15, read=60)`` will make the socket timeout if the connection takes more than 15 seconds to establish but read/write operations can take up to 60 seconds once the connection is done. NrGrHrI__doc__rKrErDr!r!prEr!z connect readceZdZdZy)MailboxQuotaRootszQuota roots associated with a mailbox. Represents the response of a GETQUOTAROOT command. :ivar mailbox: the mailbox :ivar quota_roots: list of quota roots associated with the mailbox NrMrKrErDrQrQ|srErQzmailbox quota_rootsceZdZdZy)Quotaa>Resource quota. Represents the response of a GETQUOTA command. :ivar quota_roots: the quota roots for which the limit apply :ivar resource: the resource being limited (STORAGE, MESSAGES...) :ivar usage: the current usage of the resource :ivar limit: the maximum allowed usage of the resource NrMrKrErDrSrSrOrErSzquota_root resource usage limitcfd}|S)zEDecorator raising CapabilityError when a capability is not available.cFtjfd}|S)Nc|js$tjdj|g|i|S)Nz%Server does not support {} capability)has_capabilityrCapabilityErrorformat)clientargskwargs capabilityfuncs rDwrapperz=require_capability..actual_decorator..wrappersI((4 00;BB:N000 0rE) functoolswraps)r^r_r]s` rDactual_decoratorz,require_capability..actual_decorators%   1  1rErK)r]rbs` rDrequire_capabilityrcs  rEc eZdZdZej ZejZejZ d]dZ dZ dZ dZdZedZed d^d Zd Zd_d Zd^d ZdZdZeddZedd^dZdZdZdZdZeddZd`dZ edd`dZ!d`dZ"dZ#dZ$d Z%dad!Z&ed"d#Z'd$Z(d%Z)ed&d'Z*ed&d^d(Z+ed&d)Z,d^d*Z-d+Z.d,Z/d-Z0d.Z1d/Z2d0Z3d1Z4dbd2Z5ed3dcd4Z6d5Z7ed6ddd7Z8ded8Z9d9Z:dad:Z;dad;Zdad>Z?dad?Z@dad@ZAdadAZBd^dBZCdfdCZDdDZEedEdFZFd^dGZGedHdIZHedHdJZIedKdgdLZJedKdhdMZKedKdNZLedKdOZMdPZNdQZOdidRZPdjdSZQdTZRdUZSdVZTdWZUdXZVdYZWdZZXd[ZYed\ZZy)kr aA connection to the IMAP server specified by *host* is made when this class is instantiated. *port* defaults to 993, or 143 if *ssl* is ``False``. If *use_uid* is ``True`` unique message UIDs be used for all calls that accept message ids (defaults to ``True``). If *ssl* is ``True`` (the default) a secure connection will be made. Otherwise an insecure connection over plain text will be established. If *ssl* is ``True`` the optional *ssl_context* argument can be used to provide an ``ssl.SSLContext`` instance used to control SSL/TLS connection parameters. If this is not provided a sensible default context will be used. If *stream* is ``True`` then *host* is used as the command to run to establish a connection to the IMAP server (defaults to ``False``). This is useful for exotic connection or authentication setups. Use *timeout* to specify a timeout for the socket connected to the IMAP server. The timeout can be either a float number, or an instance of :py:class:`imapclient.SocketTimeout`. * If a single float number is passed, the same timeout delay applies during the initial connection to the server and for all future socket reads and writes. * In case of a ``SocketTimeout``, connection timeout and read/write operations can have distinct timeouts. * The default is ``None``, where no timeout is used. The *normalise_times* attribute specifies whether datetimes returned by ``fetch()`` are normalised to the local system time and include no timezone information (native), or are datetimes that include timezone information (aware). By default *normalise_times* is True (times are normalised to the local system time). This attribute can be changed between ``fetch()`` calls if required. Can be used as a context manager to automatically close opened connections: >>> with IMAPClient(host="imap.foo.org") as client: ... client.login("bar@foo.org", "passwd") Nc|r| td|rtd| |xrdxsd}|r|dk(rtjd||_||_||_||_||_||_d|_ d|_ t|ts t||}||_ d|_d|_d|_|j#|_tj'd|j|rd nd |j)t+t-d t/}d |j$_|j&|j$_y) Nz#can't set 'port' when 'stream' Truez%can't use 'ssl' when 'stream' is TrueizfAttempting to establish an encrypted connection to a port (143) often used for unencrypted connectionsTFzConnected to host %s over %szSSL/TLSz plain textzimapclient.imaplib) ValueErrorloggerwarninghostportssl ssl_contextstreamuse_uid folder_encodenormalise_times isinstancer!_timeout_starttls_done_cached_capabilities _idle_tag _create_IMAP4_imapdebug_set_read_timeoutIMAPlibLoggerAdapterr dict_mesg) selfrkrlrprmrorntimeoutimaplib_loggers rD__init__zIMAPClient.__init__s7  !FGG !HII \;3%#D 43; NN) *  &  !#'=1#GW5G #$(!'')  3TYY"%Y< 9  - * +TV  )// rEc|Sr=rKrs rD __enter__zIMAPClient.__enter__ s rEc |jy#t$rA |jYy#t$r!}tj d|Yd}~Yyd}~wwxYwwxYw)zLogout and closes the connection when exiting the context manager. All exceptions during logout and connection shutdown are caught because an error here usually means the connection was already closed. z*Could not close the connection cleanly: %sN)logout Exceptionshutdownriinfo)rexc_typeexc_valexc_tbes rD__exit__zIMAPClient.__exit__ sU  M KKM M M  M H!LL M Ms) A/ AAAAAcZ|jrtj|jS|jr@t j |j|j|j|jStj|j|j|jSr=) roimaplib IMAP4_streamrkrmr IMAP4_TLSrlrnrtrIMAP4WithTimeoutrs rDrxzIMAPClient._create_IMAP4st ;;'' 2 2 88==DIIt7G7G!%0 0%%diiDMMJJrEc||j0|jj|jjyyr=)rt_sock settimeoutreadrs rDr{zIMAPClient._set_read_timeout%s- == $ JJ ! !$--"4"4 5 %rEcXt|jd|jjS)Nsslobj)getattrrysockrs rDrzIMAPClient._sock)stzz8TZZ__==rEr-c|js |jrtjd|jj d\}}|j d||d|_tj|jj||j|j_ |jjjd|j_ |dS)aSwitch to an SSL encrypted connection by sending a STARTTLS command. The *ssl_context* argument is optional and should be a :py:class:`ssl.SSLContext` object. If no SSL context is given, a SSL context with reasonable default settings will be used. You can enable checking of the hostname in the certificate presented by the server against the hostname which was used for connecting, by setting the *check_hostname* attribute of the SSL context to ``True``. The default SSL context has this setting enabled. Raises :py:exc:`Error` if the SSL connection could not be established. Raises :py:exc:`AbortError` if the server does not support STARTTLS or an SSL connection is already established. zTLS session already establishedr-starttlsTrbr) rmrurIMAPClientAbortErrorry_simple_command_checkokr wrap_socketrrkmakefilefile)rrntypdatas rDrzIMAPClient.starttls/s$ 88t**112ST TJJ..z: T j#t,"//$**//; R **//2248 AwrEc |jdt|t|d}t jd||S#tj$r#}tjt |d}~wwxYw)zVLogin using *username* and *password*, returning the server response. loginTunpackNzLogged in as %s)_command_and_checkrrIMAPClientError LoginErrorstrrir)rusernamepasswordrvrs rDrzIMAPClient.loginMsu 0((8$8$ )B  %x0 )) 0''A/ / 0s'AA7A22A7cd|d|d|rd|zz dz  |jd|fdS#tj$r#}tjt |d}~wwxYw)zAuthenticate using the OAUTH2 method. Gmail and Yahoo both support the 'XOAUTH2' mechanism, but Yahoo requires the 'vendor' portion in the payload. zuser=z auth=Bearer z vendor=%s authenticatecSr=rK)x auth_strings rDz)IMAPClient.oauth2_login..is;rENrrrrr)ruser access_tokenmechvendorrrs @rD oauth2_loginzIMAPClient.oauth2_login^sq 6:<H  =61 1Kt  0**>4AVW W)) 0''A/ / 0s1A'A""A'c|sd}|d|d| |jddfddS#tj$r#}tjt |d}~wwxYw) zGAuthenticate using the PLAIN method (requires server support). r2rPLAINcSr=rK)_rs rDrz(IMAPClient.plain_login..tskrETrNr)ridentityrauthorization_identityrrs @rD plain_loginzIMAPClient.plain_loginmsf&%' "&7DYbf*g g)) 0''A/ / 0s)AAAc|jj\}}|jdd||tj d|dS)z/Logout, returning the server response. BYErzLogged out, connection closedr)ryr _check_resprir)rrrs rDrzIMAPClient.logoutxsDJJ%%' T #t4 34AwrEcb|jjtjdy)zClose the connection to the IMAP server (without logging out) In most cases, :py:meth:`.logout` should be used instead of this. The logout method also shutdown down the connection. zConnection closedN)ryrrirrs rDrzIMAPClient.shutdowns!  '(rEr0c |jjdk7r,tjd|jjz|j d|Dcgc] }t |c}ddd}|sgS|j Scc}w)a0Activate one or more server side capability extensions. Most capabilities do not need to be enabled. This is only required for extensions which introduce backwards incompatible behaviour. Two capabilities which may require enable are ``CONDSTORE`` and ``UTF8=ACCEPT``. A list of the requested extensions that were successfully enabled on the server is returned. Once enabled each extension remains active until the IMAP connection is closed. See :rfc:`5161` for more details. r*z"ENABLE command illegal in state %ssENABLEFENABLEDT)uid response_namer)rystaterIllegalStateError_raw_command_untaggedrsplit)r capabilitiescresps rDenablezIMAPClient.enables" ::  v %..4tzz7G7GG )) ". /QXa[ /# * Izz| 0sB r.cv|d}nXt|ts tdtdtj j |jD}|jjd|\}}|jd|||jj||d\}}t|S)zIssue the ID command, returning a dict of server implementation fields. *parameters* should be specified as a dictionary of field/value pairs, for example: ``{"name": "IMAPClient", "version": "0.12"}`` NILz#'parameters' should be a dictionaryc32K|]}t|ywr=)_quote).0vs rD z!IMAPClient.id_..s#Cq #Cr.id) rsr} TypeErrorseq_to_parenstr itertoolschain from_iterableitemsryrr_untagged_responser)r parametersr[rrs rDid_zIMAPClient.id_s  Dj$/ EFF"#C--j.>.>.@A#CCDJJ..tT: T dC&JJ11#tTB Td##rEc|jr0|jjdk(rd|_|j S|jr |jSt |jj }|jdd}|r%|j|d|_|jS|jjdvr!|j |_|jStd|jjDS)aReturns the server capability list. If the session is authenticated and the server has returned an untagged CAPABILITY response at authentication time, this response will be returned. Otherwise, the CAPABILITY command will be issued to the server, with the results cached for future calls. If the session is not yet authenticated, the capabilities requested at connection time will be returned. r)N CAPABILITYr)r+r*c32K|]}t|ywr=)rrrs rDrz*IMAPClient.capabilities..sBQXa[Br) ruryrrv_do_capabilites_dict_bytes_normaliseruntagged_responsespop_normalise_capabilitesr>r)runtaggedresponses rDrzIMAPClient.capabilitiess   4::#3#3y#@(,D %'') )  $ $,, ,*$***G*GH<< d3 (,(C(CHQK(PD %,, , ::  3 3(,(<(<(>D %,, ,B$***A*ABBBrEcJ|jdd}|j|S)Nr]Tr)rrr raw_responses rDrzIMAPClient._do_capabilitess(..|D.I **<88rEcft|}t|jjSr=)rr>upperrrs rDrz!IMAPClient._normalise_capabilitess) - \'')//122rEcTt|j|jvS)zGReturn ``True`` if the IMAP server has the given *capability*. )rrr)rr]s rDrWzIMAPClient.has_capabilitys& #))+t/@/@/BBBrE NAMESPACEc2|jd}g}t|D]o}||j|g}|D]8\}}|jr t |}|j|t |f:|jt |qt|S)aReturn the namespace for the account as a (personal, other, shared) tuple. Each element may be None if no namespace of that type exists, or a sequence of (prefix, separator) pairs. For convenience the tuple elements may be accessed positionally or using attributes named *personal*, *other* and *shared*. See :rfc:`2342` for more details. namespace)rrappendrq decode_utf7rr>r;)rrpartsitem convertedprefix separators rDrzIMAPClient.namespaces&&{3"4( /D| T" )-F%FI))!,V!4$$fj.C%DEF U9-. /%  rEc(|jd||S)a*Get a listing of folders on the server as a list of ``(flags, delimiter, name)`` tuples. Specifying *directory* will limit returned folders to the given base directory. The directory and any child directories will returned. Specifying *pattern* will limit returned folders to those with matching names. The wildcards are supported in *pattern*. ``*`` matches zero or more of any character and ``%`` matches 0 or more characters except the folder delimiter. Calling list_folders with no arguments will recursively list all folders available for the logged in user. Folder names are always returned as unicode strings, and decoded from modified UTF-7, except if folder_decode is not set. LIST_do_listr directorypatterns rD list_folderszIMAPClient.list_folderss*}}VY88rEr(c(|jd||S)a0Execute the XLIST command, returning ``(flags, delimiter, name)`` tuples. This method returns special flags for each folder and a localized name for certain folders (e.g. the name of the inbox may be localized and the flags can be used to determine the actual inbox, even if the name has been localized. A ``XLIST`` response could look something like:: [((b'\HasNoChildren', b'\Inbox'), b'/', u'Inbox'), ((b'\Noselect', b'\HasChildren'), b'/', u'[Gmail]'), ((b'\HasNoChildren', b'\AllMail'), b'/', u'[Gmail]/All Mail'), ((b'\HasNoChildren', b'\Drafts'), b'/', u'[Gmail]/Drafts'), ((b'\HasNoChildren', b'\Important'), b'/', u'[Gmail]/Important'), ((b'\HasNoChildren', b'\Sent'), b'/', u'[Gmail]/Sent Mail'), ((b'\HasNoChildren', b'\Spam'), b'/', u'[Gmail]/Spam'), ((b'\HasNoChildren', b'\Starred'), b'/', u'[Gmail]/Starred'), ((b'\HasNoChildren', b'\Trash'), b'/', u'[Gmail]/Trash')] This is a *deprecated* Gmail-specific IMAP extension (See https://developers.google.com/gmail/imap_extensions#xlist_is_deprecated for more information). The *directory* and *pattern* arguments are as per list_folders(). r(rr s rD xlist_folderszIMAPClient.xlist_folders+s<}}Wi99rEc(|jd||S)zReturn a list of subscribed folders on the server as ``(flags, delimiter, name)`` tuples. The default behaviour will list all subscribed folders. The *directory* and *pattern* arguments are as per list_folders(). LSUBrr s rDlist_sub_folderszIMAPClient.list_sub_foldersKs}}VY88rEc|j|}|j|}|jj|||\}}|j||||jj |||\}}|j |Sr=)_normalise_folderryrrr_proc_folder_list)rcmdr r rdats rDrzIMAPClient._do_listTs{**95 ((1::--c9gFS c3$::00c3?S%%c**rEc|Dcgc] }|dvs| }}g}t|}|r^|dd\}}}|dd}t|ttfr t |}n|j r t |}|j|||f|r^|Scc}w)N)rEN)rrsintlongr rqrr)r folder_datarretparsedflagsdelimnames rDrzIMAPClient._proc_folder_list\s)4Ot;7NtO O ,!' E5$ABZF$d ,!##"4( JJud+ , %Ps BBc|jdr<|jD])}|st|ddkDs|dd|k(s$|dcS|jdr|jj}nt }|D]M}t j|tD]*}|d|z}|j|}|s |ddccSOy)aTry to locate a special folder, like the Sent or Trash folder. >>> server.find_special_folder(imapclient.SENT) 'INBOX.Sent' This function tries its best to find the correct folder (if any) but uses heuristics when the server is unable to precisely tell where special folders are located. Returns the name of the folder if found, or None otherwise. z SPECIAL-USErrrFr)r N) rWr lenrrA_POPULAR_PERSONAL_NAMESPACES_POPULAR_SPECIAL_FOLDERSgetr>)r folder_flagfolderpersonal_namespacespersonal_namespacer  sent_folderss rDfind_special_folderzIMAPClient.find_special_folderts   } -++- %c&)nq0VAYq\[5P!!9$ %   { +"&.."2";"; "> "5 . 377 UWM .,Q/'9#000A '?1--  . .rEc|jd|j|||j|jjS)aSet the current folder on the server. Future calls to methods such as search and fetch will act on the selected folder. Returns a dictionary containing the ``SELECT`` response. At least the ``b'EXISTS'``, ``b'FLAGS'`` and ``b'RECENT'`` keys are guaranteed to exist. An example:: {b'EXISTS': 3, b'FLAGS': (b'\Answered', b'\Flagged', b'\Deleted', ... ), b'RECENT': 0, b'PERMANENTFLAGS': (b'\Answered', b'\Flagged', b'\Deleted', ... ), b'READ-WRITE': True, b'UIDNEXT': 11, b'UIDVALIDITY': 1239278212} select)rr_process_select_responseryr)rr'readonlys rD select_folderzIMAPClient.select_folders<$ $*@*@*H(S,,TZZ-J-JKKrEr/crtjd|jjd\}}|dS)a"Unselect the current folder and release associated resources. Unlike ``close_folder``, the ``UNSELECT`` command does not expunge the mailbox, keeping messages with \Deleted flag set for example. Returns the UNSELECT response string returned by the server. z < UNSELECTr/r)rirzryr)r_typrs rDunselect_folderzIMAPClient.unselect_folders1  \"ZZ// ; dAwrEct|}i}|jdgD]]}tjd|}|s|j d}|dk(s3t |j dj ||<_t|D]^\}}|j}|dvr|dvrt|d}n,|d k(rd }n$|d k(rt |dd d j }|||<`|S)NOKs(\[(?P[A-Z-]+)( \((?P.*)\))?\]keyPERMANENTFLAGSr)sOKr7)sEXISTSsRECENTsUIDNEXTs UIDVALIDITYs HIGHESTMODSEQrs READ-WRITETFLAGSr) rr%rematchgroupr>rr rr)rrroutliner;r6values rDr.z#IMAPClient._process_select_responses)$/LLr* BDHHI4PEkk%(++$U[[%8%>%>%@ACH  B$H- JC))+C00\\E!H  %eAhqn2245CH  rEc\|jjd}|j|dS)aExecute the NOOP command. This command returns immediately, returning any server side status updates. It can also be used to reset any auto-logout timers. The return value is the server command response message followed by a list of status responses. For example:: (b'NOOP completed.', [(4, b'EXISTS'), (3, b'FETCH', (b'FLAGS', (b'bar', b'sne'))), (6, b'FETCH', (b'FLAGS', (b'sne',)))]) NOOP)ry_command_consume_until_tagged_response)rtags rDnoopzIMAPClient.noops+ jj!!&)223??rEr,c|jjd|_|jj}|t j d|zy)aPut the server into IDLE mode. In this mode the server will return unsolicited responses about changes to the selected mailbox. This method returns immediately. Use ``idle_check()`` to look for IDLE responses and ``idle_done()`` to stop IDLE mode. .. note:: Any other commmands issued while the server is in IDLE mode will fail. See :rfc:`2177` for more information about the IDLE extension. r,NzUnexpected IDLE response: %s)ryrBrw _get_responserr)rrs rDidlezIMAPClient.idlesN ,,V4zz'')  ,,-Kd-RS S rEcn|j}|jd|jd g}tj|ggg|\}}}|r7 |jj }|j t|6||jd|j!S#tjtjf$rYHtj$r,tjd}d|jdvrYwxYw#|jd|j!wxYw)aCheck for any IDLE responses sent by the server. This method should only be called if the server is in IDLE mode (see ``idle()``). By default, this method will block until an IDLE response is received. If *timeout* is provided, the call will block for at most this many seconds while waiting for an IDLE response. The return value is a list of received IDLE responses. These will be parsed with values converted to appropriate types. For example:: [(b'OK', b'Still here'), (1, b'EXISTS'), (1, b'FETCH', (b'FLAGS', (b'\NotJunk',)))] NrrEOF)rr setblockingr-ry _get_liner_parse_untagged_responsesocketrerrorr AbortErrorsysexc_infor[r{)rrrrespsrsrr>errs rD idle_checkzIMAPClient.idle_checks&zz   %E}}dVRW=HB1 E#zz335 %=d%CD   Q   " " $#NNFLL9%00""llnQ/ CHHQK/!!"   Q   " " $s;"DB+-D+#DD:D D DD#D4ctjd|jjd|j |j dS)aTake the server out of IDLE mode. This method should only be called if the server is already in IDLE mode. The return value is of the form ``(command_text, idle_responses)`` where *command_text* is the text sent by the server when the IDLE command finished (eg. ``b'Idle terminated'``) and *idle_responses* is a list of parsed idle responses received since the last call to ``idle_check()`` (if any). These are returned in parsed form as per ``idle_check()``. z< DONEsDONE r,)rirzrysendrCrwrs rD idle_donezIMAPClient.idle_done-s7  X  $224>>6JJrEc$|d}n t|}ddj|z}|j|}|jd||}t |} |d}tt|S#t $rt dt|zwxYw)a+Return the status of *folder*. *what* should be a sequence of status items to query. This defaults to ``('MESSAGES', 'RECENT', 'UIDNEXT', 'UIDVALIDITY', 'UNSEEN')``. Returns a dictionary of the status items for the folder with keys matching *what*. )MESSAGESr'UIDNEXT UIDVALIDITYUNSEENz(%s) statusr9z folder_status ValueError: Input ) normalise_text_listjoinrrrrhrrr}as_pairs)rr'whatwhat_fnamerr status_itemss rD folder_statuszIMAPClient.folder_status@s <MD&t,D#((4.)&&v.&&x>!$' P#BXNO O Ps A..!Bc(|jddS)z[Close the currently selected folder, returning the server response string. closeTr)rrs rD close_folderzIMAPClient.close_folderYs&&wt&<t|jd|dkDS)z:Return ``True`` if *folder* exists on the server. r2r)r"r ros rD folder_existszIMAPClient.folder_existsqs!4$$R01A55rEcD|jd|j|S)zESubscribe to *folder*, returning the server response string. subscribernros rDsubscribe_folderzIMAPClient.subscribe_foldervs"&&{D4J4J64RSSrEcD|jd|j|S)zGUnsubscribe to *folder*, returning the server response string. unsubscribernros rDunsubscribe_folderzIMAPClient.unsubscribe_folder{s"&&}d6L6LV6TUUrEc&|j||S)a$ Return a list of messages ids from the currently selected folder matching *criteria*. *criteria* should be a sequence of one or more criteria items. Each criteria item may be either unicode or bytes. Example values:: [u'UNSEEN'] [u'SMALLER', 500] [b'NOT', b'DELETED'] [u'TEXT', u'foo bar', u'FLAGGED', u'SUBJECT', u'baz'] [u'SINCE', date(2005, 4, 3)] IMAPClient will perform conversion and quoting as required. The caller shouldn't do this. It is also possible (but not recommended) to pass the combined criteria as a single string. In this case IMAPClient won't perform quoting, allowing lower-level specification of criteria. Examples of this style:: u'UNSEEN' u'SMALLER 500' b'NOT DELETED' u'TEXT "foo bar" FLAGGED SUBJECT "baz"' b'SINCE 03-Apr-2005' To support complex search expressions, criteria lists can be nested. IMAPClient will insert parentheses in the right places. The following will match messages that are both not flagged and do not have "foo" in the subject: ['NOT', ['SUBJECT', 'foo', 'FLAGGED']] *charset* specifies the character set of the criteria. It defaults to US-ASCII as this is the only charset that a server is required to support by the RFC. UTF-8 is commonly supported however. Any criteria specified using unicode will be encoded as per *charset*. Specifying a unicode criteria that can not be encoded using *charset* will result in an error. Any criteria specified using bytes will be sent as-is but should use an encoding that matches *charset* (the character set given is still passed on to the server). See :rfc:`3501#section-6.4.4` for more details. Note that criteria arguments that are 8-bit will be transparently sent by IMAPClient as IMAP literals to ensure adherence to IMAP standards. The returned list of message ids will have a special *modseq* attribute. This is set if the server included a MODSEQ value to the search response (i.e. if a MODSEQ criteria was included in the search). _search)rcriteriacharsets rDsearchzIMAPClient.searchsx||Hg..rEz X-GM-EXT-1c*|jd|g|S)aSearch using Gmail's X-GM-RAW attribute. *query* should be a valid Gmail search query string. For example: ``has:attachment in:unread``. The search string may be unicode and will be encoded using the specified *charset* (defaulting to UTF-8). This method only works for IMAP servers that support X-GM-RAW, which is only likely to be Gmail. See https://developers.google.com/gmail/imap_extensions#extension_of_the_search_command_x-gm-raw for more info. sX-GM-RAWr)rqueryrs rD gmail_searchzIMAPClient.gmail_searchs||[%0'::rEc g}|r|jdt|g|jt|| |jd|}t!|S#tj j $rz}tjdt|}|rStjdj|jdt|tsd|z|d}~wwxYw)NsCHARSETsSEARCHz"SEARCH command error: BAD \[(.+)\]z{original_msg} This error may have been caused by a syntax error in the criteria: {criteria} Please refer to the documentation for more information about search criteria syntax.. https://imapclient.readthedocs.io/en/master/#imapclient.IMAPClient.searchr"%s") original_msgr)extendr_normalise_search_criteriarrIMAP4rOr:r;rrInvalidCriteriaErrorrYr<rslistr)rrrr[rrms rDrzIMAPClient._searchs  KKXg%67 8 .xAB --i>D("$'''}}"" >AGA 55` V%&WWQZ:DXt:T(!2  [c   # sAC17A5C,,C1SORTct|t|g}|jt|||j d|d}|j Dcgc] }t |c}Scc}w)aReturn a list of message ids from the currently selected folder, sorted by *sort_criteria* and optionally filtered by *criteria*. *sort_criteria* may be specified as a sequence of strings or a single string. IMAPClient will take care any required conversions. Valid *sort_criteria* values:: ['ARRIVAL'] ['SUBJECT', 'ARRIVAL'] 'ARRIVAL' 'REVERSE SIZE' The *criteria* and *charset* arguments are as per :py:meth:`.search`. See :rfc:`5256` for full details. Note that SORT is an extension to the IMAP4 standard so it may not be supported by all IMAP servers. sSORTTr)_normalise_sort_criteriarrrrrr)r sort_criteriarrr[idsis rDsortzIMAPClient.sortsf0 %] 3 W   .xAB(($t(D!$-AQ---sA-ct|}|jd|zstjd|z|t|gt ||z}|j d|}t |S)aReturn a list of messages threads from the currently selected folder which match *criteria*. Each returned thread is a list of messages ids. An example return value containing three message threads:: ((1, 2), (3,), (4, 5, 6)) The optional *algorithm* argument specifies the threading algorithm to use. The *criteria* and *charset* arguments are as per :py:meth:`.search`. See :rfc:`5256` for more details. sTHREAD=z2The server does not support %s threading algorithmsTHREAD)rrWrrXrrr)r algorithmrrr[rs rDthreadzIMAPClient.thread sy"Y' "": #9:,,DyP 8G,- &x 9:)))T:d##rEcL|j|dg}|j|dS)zReturn the flags set for each message in *messages* from the currently selected folder. The return value is a dictionary structured like this: ``{ msgid1: (flag1, flag2, ... ), }``. FLAGSr8)fetch_filter_fetch_dict)rmessagesrs rD get_flagszIMAPClient.get_flags's)::h 2&&x::rEc.|jd||d|S)zAdd *flags* to *messages* in the currently selected folder. *flags* should be a sequence of strings. Returns the flags set for each modified message (see *get_flags*), or None if *silent* is true. s+FLAGSr8silent_storerrrrs rD add_flagszIMAPClient.add_flags1s{{9hx{OOrEc.|jd||d|S)aRemove one or more *flags* from *messages* in the currently selected folder. *flags* should be a sequence of strings. Returns the flags set for each modified message (see *get_flags*), or None if *silent* is true. s-FLAGSr8rrrs rD remove_flagszIMAPClient.remove_flags;s{{9hx{OOrEc.|jd||d|S)zSet the *flags* for *messages* in the currently selected folder. *flags* should be a sequence of strings. Returns the flags set for each modified message (see *get_flags*), or None if *silent* is true. r8rrrs rD set_flagszIMAPClient.set_flagsFs{{8Xuhv{NNrEc|j|dg}|j|d}t|Dcic]\}}|t|c}}Scc}}w)a>Return the label set for each message in *messages* in the currently selected folder. The return value is a dictionary structured like this: ``{ msgid1: (label1, label2, ... ), }``. This only works with IMAP servers that support the X-GM-LABELS attribute (eg. Gmail). X-GM-LABELS)rrr utf7_decode_sequence)rrrmsglabelss rDget_gmail_labelszIMAPClient.get_gmail_labelsQs]::h(89**8^D#,X#68C)&118 88sAc,|jd|||S)aWAdd *labels* to *messages* in the currently selected folder. *labels* should be a sequence of strings. Returns the label set for each modified message (see *get_gmail_labels*), or None if *silent* is true. This only works with IMAP servers that support the X-GM-LABELS attribute (eg. Gmail). s +X-GM-LABELSr_gm_label_storerrrrs rDadd_gmail_labelszIMAPClient.add_gmail_labels`s%##OXv+1$3 3rEc,|jd|||S)apRemove one or more *labels* from *messages* in the currently selected folder, or None if *silent* is true. *labels* should be a sequence of strings. Returns the label set for each modified message (see *get_gmail_labels*). This only works with IMAP servers that support the X-GM-LABELS attribute (eg. Gmail). s -X-GM-LABELSrrrs rDremove_gmail_labelszIMAPClient.remove_gmail_labelsns%##OXv+1$3 3rEc,|jd|||S)adSet the *labels* for *messages* in the currently selected folder. *labels* should be a sequence of strings. Returns the label set for each modified message (see *get_gmail_labels*), or None if *silent* is true. This only works with IMAP servers that support the X-GM-LABELS attribute (eg. Gmail). rrrrs rDset_gmail_labelszIMAPClient.set_gmail_labels}s%##NHf+1$3 3rEc2|j|t|S)zDelete one or more *messages* from the currently selected folder. Returns the flags set for each modified message (see *get_flags*). r)rr")rrrs rDdelete_messageszIMAPClient.delete_messagess~~h~??rEc|siSdt|t||r t|ndg}|jr|jdd|jj |}|jj d|\}}|jd|||jj||d\}}t||j|jS)aRetrieve selected *data* associated with one or more *messages* in the currently selected folder. *data* should be specified as a sequnce of strings, one item per data selector, for example ``['INTERNALDATE', 'RFC822']``. *modifiers* are required for some extensions to the IMAP protocol (eg. :rfc:`4551`). These should be a sequnce of strings if specified, for example ``['CHANGEDSINCE 123']``. A dictionary is returned, indexed by message number. Each item in this dictionary is also a dictionary, with an entry corresponding to each item in *data*. Returned values will be appropriately typed. For example, integer values will be returned as Python integers, timestamps will be returned as datetime instances and ENVELOPE responses will be returned as :py:class:`Envelope ` instances. String data will generally be returned as bytes (Python 3) or str (Python 2). In addition to an element for each *data* item, the dict returned for each message also contains a *SEQ* key containing the sequence number for the message. This allows for mapping between the UID and sequence number (when the *use_uid* property is ``True``). Example:: >> c.fetch([3293, 3230], ['INTERNALDATE', 'FLAGS']) {3230: {b'FLAGS': (b'\Seen',), b'INTERNALDATE': datetime.datetime(2011, 1, 30, 13, 32, 9), b'SEQ': 84}, 3293: {b'FLAGS': (), b'INTERNALDATE': datetime.datetime(2011, 2, 24, 19, 30, 36), b'SEQ': 110}} FETCHNrUIDr) join_message_idsseq_to_parenstr_upperrpinsertryrB_command_completerrrrr)rrr modifiersr[rDrs rDrzIMAPClient.fetchsPI  X & !$ '09 !) ,t   << KK5 !!djj!!4(JJ00#> T gsD)JJ11#tWE T#D$*>*> MMrEc |r,dt|z}tr t|}nt|}nd}|j d|j |t ||t|dS)aoAppend a message to *folder*. *msg* should be a string contains the full message including headers. *flags* should be a sequence of message flags to set. If not specified no flags will be set. *msg_time* is an optional datetime instance specifying the date and time to set on the message. The server will set a time if it isn't specified. If *msg_time* contains timezone information (tzinfo), this will be honoured. Otherwise the local machine's time zone sent to the server. Returns the APPEND response as returned by the server. rNrTr)rrrrrrr)rr'rrmsg_timetime_vals rDrzIMAPClient.appendsp"  8 BBH%h/#H-H&&x'+'='=f'E'6u'='/'/}.2 '4 4rEc^|jdt||j|ddS)zCopy one or more messages from the current folder to *folder*. Returns the COPY response string returned by the server. copyTrrrrrrrr's rDrzIMAPClient.copys9 &&v'7'A'+'='=f'E+/'> >rEr1c^|jdt||j|ddS)zAtomically move messages to another folder. Requires the MOVE capability, see :rfc:`6851`. :param messages: List of message UIDs to move. :param folder: The destination folder name. moveTrrrs rDrzIMAPClient.moves9&&v'7'A'+'='=f'E+/'> >rEc|r4|js td|jdt|dS|jj d}|j |dS)a2When, no *messages* are specified, remove all messages from the currently selected folder that have the ``\Deleted`` flag set. The return value is the server response message followed by a list of expunge responses. For example:: ('Expunge completed.', [(2, 'EXPUNGE'), (1, 'EXPUNGE'), (0, 'RECENT')]) In this case, the responses indicate that the message with sequence numbers 2 and 1 where deleted, leaving no recent messages in the folder. See :rfc:`3501#section-6.4.3` section 6.4.3 and :rfc:`3501#section-7.4.1` section 7.4.1 for more details. When *messages* are specified, remove the specified messages from the selected folder, provided those messages also have the ``\Deleted`` flag set. The return value is ``None`` in this case. Expunging messages by id(s) requires that *use_uid* is ``True`` for the client. See :rfc:`4315#section-2.1` section 2.1 for more details. z(cannot EXPUNGE by ID when not using uidsEXPUNGETr)rprhrrryrBrC)rrrDs rDexpungezIMAPClient.expunges`< << !KLL**96Fx6PVZ*[ [jj!!),223 BBrEACLc|jd|j|}ttj|}|dd}t dt |dDcgc]}||||dzfc}Scc}w)zeReturns a list of ``(who, acl)`` tuples describing the access controls for *folder*. getaclrNrrF)rrrr TokenSourcexranger")rr'rrrs rDrzIMAPClient.getacl+ss &&x1G1G1OP^//56ab 28CJ2JKQq5Q<(KKKsA4cL|jd|j|||dS)zSet an ACL (*what*) for user (*who*) for a folder. Set *what* to an empty string to remove an ACL. Returns the server response string. setaclTrrn)rr'whords rDrzIMAPClient.setacl5s4&&x'+'='=f'E'*D.2'4 4rEQUOTAc*|j|dS)z\Get the quotas associated with a mailbox. Returns a list of Quota objects. r)get_quota_root)rmailboxs rD get_quotazIMAPClient.get_quotaAs ""7+A..rEcJt|jdt|S)a Get the quotas associated with a quota root. This method is not private but put behind an underscore to show that it is a low-level function. Users probably want to use `get_quota` instead. Returns a list of Quota objects. getquota) _parse_quotarr)r quota_roots rD _get_quotazIMAPClient._get_quotaIs&  # #Jz0B C  rEc |jdt|dd}t|jjdg}t |}t t|d|ddDcgc] }t|c}}|t|fScc}w) a/Get the quota roots for a mailbox. The IMAP server responds with the quota root and the quotas associated so there is usually no need to call `get_quota` after. See :rfc:`2087` for more details. Return a tuple of MailboxQuotaRoots and list of Quota associated s GETQUOTAROOTF QUOTAROOTrrrrrN) rrpop_with_defaultryrrrQrr)rrquota_root_rep quota_repqrs rDrzIMAPClient.get_quota_rootWs33 Xg.E%4 %TZZ%B%BGRP '7& ~a( )$212$6 7qZ] 7 < 222 8s$B c|syd}t}|D]`}| |j}n||jk7r td|jdj |j |j bdj|}tt|tdj |g}|jd|dd }t|S) z[Set one or more quotas on resources. :param quotas: list of Quota objects Nz*set_quota only accepts a single quota rootz{} {}r_z({})sSETQUOTAFrr) rrrhrrYresourcelimitrbrrrr)rquotasrset_quota_argsquotar[rs rD set_quotazIMAPClient.set_quotans    E!"-- u/// !MNN  ! !u~~u{{;   .1 VJ' ( V]]>2 3  -- 5. H%%rEcZ||k7r&tj|dt|dy)zcCheck command responses for errors. Raises IMAPClient.Error if the command fails. z failed: rN)rrr)rexpectedcommandrrs rDrzIMAPClient._check_resps2 (?,,TXYZT[I\-]^ ^ rEc|jj}g} |jj}||rn|jt |;|j |\}}|j ||||d|fS)Nr)rytagged_commandsrGrrMrr)rrDrrrSr>rrs rDrCz)IMAPClient._consume_until_tagged_responses**44::++-Ds# LL1$7 8  $'', T gsD)Aw~rEc|j|||\}}||}|jj||t|\}}|j t||||r|dS|S)Nrr) _raw_commandryrrr)rrr[rrrrrs rDrz IMAPClient._raw_command_untaggedso%%gt%= T  #MJJ11#tZ =VW T j)35 7N rEc|j}t|tr t|}t|ts|g}|jj }t |g}|r|jr|jd|j|g}t||zD]\}}t|ts tdt|r|rDdj|} tjd| |jj!| g}t|t"r |j$}|j'|||r|jj!d|j||rBdj|} tjd| |jj!| |jj!d|jj)t+||S)a}Run the specific command with the arguments given. 8-bit arguments are sent as literals. The return value is (typ, data). This sidesteps much of imaplib's command sending infrastructure because imaplib can't send more than one literal. *command* should be specified as bytes. *args* should be specified as a list of bytes. sUIDz$command args must be passed as bytes z> %ss )rrsr>rry_new_tagrrpr_iter_with_lastbytesrh_is8bitrbrirzrX_quotedoriginal _send_literalrr) rrr[rrDrr>ris_lastr=s rDrzIMAPClient._raw_commands--/ dE ":D$%6Djj!!#3- 4<< MM& ! g,Vd]; "MD'dE* !GHHt}))D/CLL-JJOOC(DdG,==D""3-JJOOD) D!' "* ))D/C LL % JJOOC   zz++Jw,?EErEc&dtt|jdzdz}tj ||j j ||j jrc|j jj|}|r!tjdt|z|j jrctj dt|d|j j |y)z:Send a single literal for the command with *tag*. s {asciis} z=unexpected response while waiting for continuation response: z (literal) > %sN)rr"rrirzryrXrGrr%rrrepr debug_trunc)rrDrr= tagged_resps rDrzIMAPClient._send_literalsc#d)n++G44x? S jj&&(**4488=K 55S%&''jj&&(  (+dC*@A rEcrt|dd}t|dd}|rJddj|z|r>|jr2tr t |}|j j |g|\}}n't|j t |}||\}}|j||||r|dS|S)NrFrzunexpected keyword args: z, r) rrbrprrryrrr) rrr[r\rrrrmeths rDrzIMAPClient._command_and_checks!&(E:vue4J669JJJ 4<<$W-& w66IC4::z'':;Dd IC gsD) 7N rEc,|jd|||y)Nr5)r)rrrrs rDrzIMAPClient._checkoks wT2rEc|j|||j|d|}|r(t|Dcic]\}}|t|c}}SdScc}}w)Nrr)r_normalise_labelsr r)rrrrrrrs rDrzIMAPClient._gm_label_store sn;;sHd.D.DV.L)&:tfdt|DS)Nc32K|]\}}||fywr=rK)rmsgidrr6s rDrz0IMAPClient._filter_fetch_dict..&s&>#tDI&>s)r}r )r fetch_dictr6s `rDrzIMAPClient._filter_fetch_dict%s">'0'<>> >rEct|tr|jd}|jr t |}t |S)Nr)rsrrrq encode_utf7r)r folder_names rDrzIMAPClient._normalise_folder)s: k; /%,,W5K   %k2Kk""rEct|ttfr|f}|Dcgc]}tt |c}Scc}wr=)rsr rrr)rrls rDrzIMAPClient._normalise_labels0s5 fy+6 7YF0671{1~&777s<cN |jjS#t$rYywxYw)z"access the server greeting messageN)rywelcomeAttributeErrorrs rDrzIMAPClient.welcome5s) ::%% %   s  $$)NTTFNNr=)XOAUTH2N)r2*)F)ALLN)UTF-8)r#r$) REFERENCESr#r$)rKN)INBOX)r2)NFT)T)[rGrHrIrNrrErrorrrPIMAPClientReadOnlyError ReadOnlyErrorrrrrxr{rJrrcrrrrrrrrrrrrWrr rrrrr+r0r3r.rErHrVrYrhrkrprvryr{r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrCrrrrrrrrrrrrKrErDr r s`0j  & &E00J66MGL+/,0\ MK6>>  #$:" 0 0)!">$$*%CN93C $!%!69. :!:>9+0!FL* # $ 4@&T T(.% .%`K K$,2= ^ 4^ 6 T V </| %;&; (:. .<$8;P P O 8 3 3 3@7Nr4@> >  >#CJLL 4 4 /!/   !   3!3, &!&@_  5Fn$"3N 2(>#8 rEr ct|tr'|jdd}|jdd}d}n&|jdd}|jdd}d}||z|zS) N\z\\"z\"\\\"\")rsr replace)argrs rDrr>sd#y!kk$'kk#u% kk%)kk$'  s7Q;rEc X|stjd|sd}t|ttfr t ||gSg}|D]}t|t r*|jt|jd=t|ttfr|jt|nt|ttfr3t|}d|dz|d<|ddz|d<|j!||jt"j%t |||S)Nzno criteria specifiedus-asciir(rr9))rrrsr rrrrrrrrrrr>rrrmaybe)rrr=rinners rDrrIs --.EFF (Y 457+,, C ? dC JJs4y''0 1 x. / JJ+D1 2 tUm ,.t4EeAhE!Hb D(E"I JJu  JJw}}XdG%<= > ? JrEcpt|ttfr|g}ddjd|DzdzS)Nr5rc3NK|]}t|jywr=)rrrrs rDrz+_normalise_sort_criteria..fsHtHTN002Hs#%r6)rsr rrb)rrs rDrrcs7(Y 45: $))HxHH H4 OOrEc eZdZdZedZy)rz This class holds a quoted bytes value which provides access to the unquoted value via the *original* attribute. They should be created via the *maybe* classmethod. c|jdd}|jdd}||k7sd|vs|s|d|zdz}||_|S|S)a!Maybe quote a bytes value. If the input requires no quoting it is returned unchanged. If quoting is required a *_quoted* instance is returned. This holds the quoted version of the input while also providing access to the original unquoted source. r-r.r/r0r)r1r)r@rquotedr=s rDr7z _quoted.maybeqsZ!!%1f- X vdVmd*+C#CLJrEN)rGrHrIrN classmethodr7rKrErDrrisrErc*tt|Sr=)r_normalise_text_listrs rDraras $U+ ,,rEc*tt|Sr=_join_and_parenrArBs rDrrs /6 77rEc8tdt|DS)Nc3<K|]}|jywr=)rr;s rDrz(seq_to_parenstr_upper..sPD4::<PsrDrBs rDrrs P4H4OP PPrEc0ddj|zdzS)N(r_))rbrBs rDrErEs % 3 &&rEcFt|ttfr|f}d|DS)Nc32K|]}t|ywr=)rrs rDrz'_normalise_text_list..s )aJqM )r)rsr rrBs rDrArAs#%)[12 )5 ))rEct|tttfr t |f}dj d|DS)z|Convert a sequence of messages ids or a single integer message id into an id byte string for use with IMAP commands ,c32K|]}t|ywr=)_maybe_int_to_bytes)rrs rDrz#join_message_ids..s>(+>r)rsr rr rrb)rs rDrrs7(Y ]CDX&( 99>X> >>rEclt|trt|jdSt |S)Nr4)rsr rrr)vals rDrPrPs)#}%3xz** C=rEct|jd|dd}|jdrt|jddSt |gS)Ns* rF)sOK sNO rr)r startswithr>rr)texts rDrMrMsN/0 8D '(TZZa()) 4& !!rEc0||vr|j|S|Sr=)r)dctr6defaults rDrrs czwws| NrEc#HKd}d}|D]}|dzr||fn|}|dz }yw)NrrFrrK)rr last_itemrs rDrcrcs> AI q5T/ !I Q s "c2t|}t|||Sr=)iterzip)ras rD as_tripletsr_s U A q!Q<rEc8tdt|DS)Nc3&K|] }|dkD yw)NrK)rbs rDrz_is8bit..s01q3w0s)anyr)rs rDrrs 0 $0 00rEc#`Kt|dz }t|D]\}}|||k(fyw)Nr)r" enumerate)rlast_irrs rDrrs: Z!^FU# 4AK s,.c@eZdZdZdZdZeZdZefdZ efdZ dZ y) rzMWrap a dict with unicode/bytes keys and normalise the keys to bytes. c||_yr=)_d)rds rDrz_dict_bytes_normaliser.__init__s rEc#dKt|jD]\}}t||fywr=)r rjr)rr6r?s rDr z _dict_bytes_normaliser.iteritemss1#DGG, 'JC3-& & 's.0cP|j|D]}||jvsyy)NTF) _gen_keysrj)rinkks rD __contains__z#_dict_bytes_normaliser.__contains__s-$ ADGG| rEc|j|D]} |j|cS|tk(r t||S#t$rY7wxYwr=)rnrjKeyError _not_presentrrorXrps rDr%z_dict_bytes_normaliser.getsZ$ A wwqz!  l "3-    s> A  A c|j|D]} |jj|cS|tk(r t||S#t$rYCwxYwr=)rnrjrrsrtrus rDrz_dict_bytes_normaliser.pops^$ A ww{{1~%  l "3-    sA  AAc#jK|t|trt|yt|ywr=)rsrrr)rrps rDrnz _dict_bytes_normaliser._gen_keyss) a %Q- 1+ s13N) rGrHrIrNrr rrqrtr%rrnrKrErDrrs6' E , ,rErct||kr t|S|dz}t|d|dzt|| dzS)NrFz...)r"r )rmaxlenhls rDr r sE 1vAw 1B #2<5 42#$= 00rEc>|Dcgc] }t|c}Scc}wr=)r)seqss rDrrs$' (qKN (( (sc t|}t}t|D]N\}}t|D];}|j t t |t |d|d|d=P|S)NrrrF)rrusager)rrrcr_rrSr)rrrquota_resource_infosquota_resource_infos rDrrsy)I B,4Y,?( (#./C#D   IIe%j1#$7$:;)!,)!,    IrEc"eZdZdZfdZxZS)r|zCAdapter preventing IMAP secrets from going to the logging facility.cdD]@}|jds||vs|j|d}dj||}ntt|||S)N)LOGIN AUTHENTICATE>rz{}{} **REDACTED**)rTrrYsuperr|process)rrr\r msg_start __class__s rDrzIMAPlibLoggerAdapter.process#sh0 G~~c"w#~IIg.q1 )00GD   )48   rE)rGrHrIrNr __classcell__)rs@rDr|r| sM  rEr|r=)c __future__rr`rrr-rNrQr: collectionsrrroperatorrloggingrr sixr r r r rrrr2rrrr datetime_utilrr imap_utf7rrrrresponse_parserrrrutilrrrrrrrGri__all__Commandsr"r#r$r%r&r'r#ARCHIVEDRAFTSJUNKSENTTRASHr#r$r>r;r!rQrSrcobjectr rrrrrarrrErArrPrMrrcr_rrrtrr rrr|rKrErDrs ( "#,WWWICUU<<  D 8  H  '""" ?GW !!!>GVW%%%#/GZ w