import imaplib
import email.header
import sys, re
import email
import os
from email.Iterators import typed_subpart_iterator
class getMail(object):
	def login(self, username, password):
		self.mail = imaplib.IMAP4_SSL('imap.gmail.com')
		rc, self.response = self.mail.login(username,password)
		return rc

	def logout(self):
		self.mail.expunge()
		self.mail.close()
		self.mail.logout()

	def get_all_uid(self):
		self.mail.list()
		self.mail.select("inbox")
		rc, self.response = self.mail.uid('search', None, "ALL")
		return self.response[0].split()

	def fetch_mail(self,uid):
		rc, response = self.mail.uid('fetch', uid, '(RFC822)')
		raw = response[0][1]
		email_message = email.message_from_string(raw)
		email_message.get_payload(0).get_payload(decode=True)
		return email_message

	def get_unread_count(self, folder='inbox'):
		rc, self.message = self.mail.status(folder, "(UNSEEN)")
		unreadCount = re.search("UNSEEN (\d+)", self.message[0]).group(1)
		return unreadCount

	def get_mail_count(self, folder='inbox'):
		rc, self.response = self.mail.select(folder)
		return self.response[0]

	def decodeHeaderStr(stringList):
		resultStr = ""
		for item in stringList:
			try:
				if item[1] == None:
					resultStr += unicode(item[0], 'euc-kr').encode('utf-8')
				else:
					resultStr += unicode(item[0], item[1]).encode('utf-8')
			except:
				pass

		return resultStr

	def get_att():
		detach_dir = '.'
		for part in email_message.walk():
			if part.get_content_maintype() == 'multipart':
				continue
			if part.get('Content-Disposition') is None:
				continue
			filename = part.get_filename()
			att_path = os.path.join(detach_dir, filename)
			if not os.path.isfile(att_path) :
				fp = open(att_path, 'wb')
				fp.write(part.get_payload(decode=True))
				fp.close()

	def get_charset(message, default="ascii"):
		if message.get_content_charset():
			return message.get_content_charset()

		if message.get_charset():
			return message.get_charset()

		return default

def get_body(message):
    if message.is_multipart():
        #get the plain text version only
        text_parts = [part
                      for part in typed_subpart_iterator(message,
                                                         'text',
                                                         'plain')]
        body = []
        for part in text_parts:
            charset = get_charset(part, get_charset(message))
            body.append(unicode(part.get_payload(decode=True),
                                charset,
                                "replace"))

        return u"\n".join(body).strip()

    else: # if it is not multipart, the payload will be a string
          # representing the message body
        body = unicode(message.get_payload(decode=True),
                       get_charset(message),
                       "replace")
        return body.strip()

g=getMail()
g.login('', '')
print g.response
print g.get_unread_count()+" New, " +g.get_mail_count()+ " Total Messages."
if g.get_mail_count()<=0:
	sys.exit(-1)

for item in g.get_all_uid():
	print g.fetch_mail(item)['To']
	print g.fetch_mail(item)['From']
	print g.fetch_mail(item)['Subject']
	print ""

email_message = email.message_from_string(raw_email)
email_message.get_payload(0).get_payload(decode=True)

#print email_message['To']

#print email.utils.parseaddr(email_message['From'])

#print email_message.items() # print all headers

s=email_message['Subject']
print decodeHeaderStr(email.header.decode_header(s))



print get_body(email_message)
#print get_first_text_block,email_message



-----------

#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# purgegmail.py
#
# Google mail purge utility
#            - delete all mail before purgeDate(datetime.date(2007,11,06))
#
# [2009-11-17 Tue] Jaemok Jeong(jmjeong@gmail.com)
#

import imaplib, email, rfc822
import datetime, time
import email.header
import getpass
import sys

# add user information
gmail_user = ''                         # gmail nemustech 계정(jmjeong@nemustech.co.kr)
gmail_pass = ''                         # gmail nemustech 암호
purgeDate = datetime.date(2008,05,06)   # 이 날짜 앞의 메일들은 전부 삭제
verbose    = True

# constant
gmail_host = 'imap.gmail.com'

def decodeHeaderStr(stringList):
    resultStr = ""
    for item in stringList:
        try:
            if item[1] == None:
                # encoding이 없으면 euc-kr로 간주?
                resultStr += unicode(item[0], 'euc-kr').encode('utf-8')
            else:
                resultStr += unicode(item[0], item[1]).encode('utf-8')
        except:
            pass

    return resultStr

def process():

    imap = imaplib.IMAP4_SSL(gmail_host)

    try:
        imap.login(gmail_user, gmail_pass)
    except:
        print "Login failed"
        sys.exit(-1)

    num = imap.select()

    searchString = ('(before "%s")' % purgeDate.strftime("%d-%b-%Y"))
    type, data = imap.search (None, searchString)

    y_or_n = raw_input("Delete %d messages? " % len(data[0].split(' ')))
    if (not (y_or_n == 'y' or y_or_n == 'Y')): return

    for num in data[0].split():
        imap.store(num, '+FLAGS', '\\Deleted')

        if verbose:
            typ, data = imap.fetch(num, '(BODY[HEADER.FIELDS (FROM SUBJECT DATE)])')

            emailBody = data[0][1]
            mail = email.message_from_string(emailBody)

            # print "--"
            # print ':' + mail['Subject'] + ':'
            # print ':' + mail['From'] + ':'
            # print ':' + mail['Date'] + ':'
            # print "--"

            try:
                subjectStr = email.header.decode_header(mail['Subject'])
                fromStr = email.header.decode_header(mail['From'].replace('"', ''))
                date = datetime.date.fromtimestamp(time.mktime(rfc822.parsedate(mail['Date'])))
            except email.header.HeaderParseError:
                print "error"
                pass

            print "Deleted : " + decodeHeaderStr(subjectStr) + ":::" \
                  + decodeHeaderStr(fromStr) + ":::" + date.strftime("%m-%d-%y")

    imap.expunge()              # permanently remove deleted items

    imap.close()
    imap.logout()

if __name__ == '__main__':
    if gmail_user == '':
        gmail_user = raw_input('id: ')
    if gmail_pass == '':
        gmail_pass = getpass.getpass()

    process()
----------------


# note that if you want to get text content (body) and the email contains
# multiple payloads (plaintext/ html), you must parse each message separately.
# use something like the following: (taken from a stackoverflow post)
def get_first_text_block(self, email_message_instance):
    maintype = email_message_instance.get_content_maintype()
    if maintype == 'multipart':
        for part in email_message_instance.get_payload():
            if part.get_content_maintype() == 'text':
                return part.get_payload()
    elif maintype == 'text':
        return email_message_instance.get_payload()


def getheader(header_text, default="ascii"):

    headers = decode_header(header_text)
    header_sections = [unicode(text, charset or default)
                       for text, charset in headers]
    return u"".join(header_sections)