source: gmail-contacts-to-vcf.py @ d473bae

#!/usr/bin/env python
# -*- coding: utf-8 -*-
u"""
GMail contacts to VCF
---------------------

Exports Gmail contacts to a vcard (VCF) file. This can be done through the
Gmail web interface, but this script is more complete (more fields are
exported) and can be run automatically and periodically, for example as a
backup system.


.. :Authors:
       Aurélien Bompard <aurelien@bompard.org> <http://aurelien.bompard.org>

.. :License:
       GNU GPL v3 or later

"""

from __future__ import with_statement # compat python 2.5

import os
import sys
import getpass
import base64
from urlparse import urlparse
from cStringIO import StringIO
from optparse import OptionParser

import atom
import gdata.contacts
import gdata.contacts.service
import gdata.contacts.client
import vobject



class Contacts(object):

    def __init__(self, email, password):
        """
        Takes an email and password corresponding to a gmail account to
        connect to the Contacts feed.

        :param email: The e-mail address of the account to use.
        :param password: The password corresponding to the account specified by
            the email parameter.
        """
        self.gd_client = gdata.contacts.client.ContactsClient()
        self.gd_client.source = os.path.basename(sys.argv[0])
        self.gd_client.ClientLogin(email, password, self.gd_client.source)
        self.groups = {}
        self.maingroup = None


    def dump(self, filename):
        self.list_groups()
        query = gdata.contacts.client.ContactsQuery()
        query.max_results = 999
        feed = self.gd_client.GetContacts(q=query)

        with open(filename, "w") as vcf_file:
            for i, entry in enumerate(feed.entry):
                if entry.title.text is None:
                    continue # likely to be a collected address
                all_group_ids = [ g.href for g in entry.group_membership_info ]
                if self.maingroup not in all_group_ids:
                    # Don't store this contact, it's a collected address
                    continue
                print i+1, entry.title.text.encode("utf8")
                #print entry
                contact = self._make_contact(entry)
                if contact is None:
                    continue
                vcf_file.write(contact.serialize())
                vcf_file.write("\r\n")


    def _make_contact(self, entry):
        """Builds a VCard entry from a Google Atom entry and returns it"""

        # Name
        contact = vobject.vCard()
        contact.add("n")
        contact.n.value = vobject.vcard.Name()
        if entry.name.given_name:
            contact.n.value.given = entry.name.given_name.text
        if entry.name.family_name:
            contact.n.value.family = entry.name.family_name.text
        if entry.name.name_prefix:
            contact.n.value.prefix = entry.name.name_prefix.text
        if entry.name.additional_name:
            contact.n.value.additional = entry.name.additional_name.text
        contact.add("fn")
        contact.fn.value = entry.name.full_name.text
        contact.add("name").value = entry.title.text

        # Email addresses
        for email in entry.email:
            c_email = contact.add("email")
            c_email.value = email.address
            if email.primary and email.primary == 'true':
                c_email.type_param = "PREF"

        # Note
        if entry.content:
            contact.add("note").value = entry.content.text

        # Groups
        groups = []
        for group in entry.group_membership_info:
            if group.href not in self.groups:
                continue
            groups.append(self.groups[group.href])
        if groups:
            contact.add("categories").value = groups

        # Modification time
        contact.add("rev")
        contact.rev.value = entry.updated.text

        # Phone
        for phone in entry.phone_number:
            phone_type = urlparse(phone.rel).fragment
            if phone_type == "mobile":
                phone_type = "cell"
            elif phone_type == "work_fax":
                phone_type = "fax"
            tel = contact.add("tel")
            tel.value = phone.text
            tel.type_param = phone_type.upper()

        # Organization
        if entry.organization:
            contact.add("org").value = [entry.organization.name.text]

        # Birthday
        if entry.birthday:
            contact.add("bday").value = entry.birthday.when

        # Address
        for address in entry.structured_postal_address:
            adr = contact.add("adr")
            adr.value = vobject.vcard.Address()
            if address.street:
                adr.value.street = address.street.text,
            if address.city:
                adr.value.city = address.city.text,
            if address.region:
                adr.value.region = address.region.text,
            if address.neighborhood:
                adr.value.code = address.neighborhood.text,
            if address.postcode:
                adr.value.code = address.postcode.text,
            if address.country:
                adr.value.country = address.country.text,
            if address.po_box:
                adr.value.box = address.po_box.text,
            adr_type = urlparse(address.rel).fragment
            adr.type_param = adr_type.upper()

        # Photo
        for link in entry.link:
            if link.rel != "http://schemas.google.com/contacts/2008/rel#photo":
                continue
            if "{http://schemas.google.com/g/2005}etag" not in link._other_attributes:
                continue
            hosted_image_binary = self.gd_client.GetPhoto(entry)
            if hosted_image_binary:
                contact.add("photo")
                contact.photo.value = hosted_image_binary
                contact.photo.encoding_param = "b"
                contact.photo.type_param = "image/jpeg"
            #with open("%s.jpg" % entry.title.text, "w") as img:
            #    img.write(hosted_image_binary)

        # IM
        im_addrs = []
        for im in entry.im:
            proto = urlparse(im.protocol).fragment
            im_addrs.append( (proto, im.address) )
        if im_addrs:
            c_im = contact.add("x-kaddressbook-x-imaddress")
            c_im.value = " ".join("(%s)%s" % addr for addr in im_addrs)

        # Website
        for website in entry.website:
            contact.add("url").value = website.href

        # Display extended properties.
        for extended_property in entry.extended_property:
            if extended_property.value:
                value = extended_property.value
            else:
                value = extended_property.GetXmlBlob()
            print '    Extended Property - %s: %s' % (extended_property.name, value)

        return contact


    def list_groups(self):
        """
        Lists all Google contact groups and stores them in self.groups.
        The main "My Contacts" group is stored in self.maingroup to filter contacts.
        """
        query = gdata.service.Query(feed='/m8/feeds/groups/default/full')
        query.max_results = 2
        feed = self.gd_client.GetGroups()
        for entry in feed.entry:
            if entry.system_group is not None:
                if entry.system_group.id == "Contacts":
                    self.maingroup = entry.id.text
                continue
            self.groups[entry.id.text] = entry.title.text



def parse_opts():
    usage = "%prog [--user email_address] [--password password] [--filename vcard_file]"
    parser = OptionParser(usage)
    parser.add_option("-u", "--user", help="full email address")
    parser.add_option("-p", "--password")
    parser.add_option("-f", "--filename", help="VCard file to write to")
    opts, args = parser.parse_args()
    while not opts.user:
        opts.user = raw_input("Please enter your username: ")
    while not opts.password:
        print "Please enter your password: ",
        opts.password = getpass.getpass()
        if not opts.password:
            print "Password cannot be blank."
    while not opts.filename:
        opts.filename = raw_input("Please enter the VCard file: ")
    return opts


def main():
    opts = parse_opts()

    try:
        contacts = Contacts(opts.user, opts.password)
    except gdata.service.BadAuthentication:
        print 'Invalid user credentials given.'
        return

    contacts.dump(opts.filename)



if __name__ == '__main__':
    main()