Initial driver for Apple devices

src/calibre/customize/builtins.py

@@ -430,7 +430,7 @@ from calibre.ebooks.txt.output import TXTOutput
 
 from calibre.customize.profiles import input_profiles, output_profiles
 
-
+from calibre.devices.apple.driver import ITUNES
 from calibre.devices.hanlin.driver import HANLINV3, HANLINV5, BOOX
 from calibre.devices.blackberry.driver import BLACKBERRY
 from calibre.devices.cybook.driver import CYBOOK
@@ -496,6 +496,7 @@ plugins += [
 ]
 # Order here matters. The first matched device is the one used.
 plugins += [
+    ITUNES,
     HANLINV3,
     HANLINV5,
     BLACKBERRY,

src/calibre/devices/apple/__init__.py

@@ -0,0 +1,2 @@
+__license__   = 'GPL v3'
+__copyright__ = '2008, Kovid Goyal <kovid at kovidgoyal.net>'

src/calibre/devices/apple/driver.py

@@ -0,0 +1,875 @@
+'''
+    Device driver for iTunes
+
+    GRiker
+
+    22 May 2010
+'''
+import atexit, cStringIO, datetime, os, re, shutil, sys, time, zipfile
+
+from calibre.constants import DEBUG
+from calibre import fit_image
+from calibre.constants import isosx, iswindows
+from calibre.devices.interface import DevicePlugin
+from calibre.ebooks.metadata import MetaInformation
+from calibre.library.server.utils import strftime
+from calibre.ptempfile import PersistentTemporaryFile, cleanup
+from calibre.utils.config import Config, config_dir
+from calibre.utils.date import parse_date
+from calibre.utils.logging import Log
+
+from PIL import Image as PILImage, TarIO
+
+if isosx:
+    import appscript, osax
+
+if iswindows:
+    import win32com.client
+
+class UserInteractionRequired(Exception):
+    pass
+
+class UserFeedback(Exception):
+   INFO = 0
+   WARN = 1
+   ERROR = 2
+
+   def __init__(self, msg, details, level):
+       Exception.__init__(self, msg)
+       self.level = level
+       self.details = details
+       self.msg = msg
+
+class ITUNES(DevicePlugin):
+    name = 'Apple device interface'
+    gui_name = 'Apple device'
+    icon = I('devices/ipad.png')
+    description    = _('Communicate with iBooks through iTunes.')
+    supported_platforms = ['windows','osx']
+    author = 'GRiker'
+    driver_version = '0.1'
+
+    OPEN_FEEDBACK_MESSAGE = _('Apple device detected, launching iTunes')
+
+    FORMATS = ['epub']
+
+    VENDOR_ID = [0x05ac]
+    # Product IDs:
+    #  0x129a:iPad
+    #  0x1292:iPhone 3G
+    #PRODUCT_ID = [0x129a,0x1292]
+    PRODUCT_ID = [0x129a]
+    BCD = [0x01]
+
+    # Properties
+    cached_books = {}
+    cache_dir = os.path.join(config_dir, 'caches', 'itunes')
+    iTunes= None
+    log = Log()
+    path_template = 'iTunes/%s - %s.epub'
+    presync = False
+    update_list = []
+    sources = None
+    update_msg = None
+    update_needed = False
+    use_thumbnail_as_cover = False
+
+    # Public methods
+    def add_books_to_metadata(self, locations, metadata, booklists):
+        '''
+        Add locations to the booklists. This function must not communicate with
+        the device.
+        @param locations: Result of a call to L{upload_books}
+        @param metadata: List of MetaInformation objects, same as for
+        :method:`upload_books`.
+        @param booklists: A tuple containing the result of calls to
+                                (L{books}(oncard=None), L{books}(oncard='carda'),
+                                L{books}(oncard='cardb')).
+        '''
+        if DEBUG:
+            self.log.info( "ITUNES.add_books_to_metadata()")
+
+        task_count = float(len(self.update_list))
+
+        # Delete any obsolete copies of the book from the booklist
+        if self.update_list:
+            for (j,p_book) in enumerate(self.update_list):
+                #self.log.info("ITUNES.add_books_to_metadata(): looking for %s" % p_book['lib_book'])
+                for i,bl_book in enumerate(booklists[0]):
+                    #self.log.info("ITUNES.add_books_to_metadata(): evaluating %s" % bl_book.library_id)
+                    if bl_book.library_id == p_book['lib_book']:
+                        booklists[0].pop(i)
+                        #self.log.info("ITUNES.add_books_to_metadata(): removing %s" % p_book['title'])
+                        break
+                else:
+                    self.log.error("ITUNES.add_books_to_metadata(): update_list item '%s' not found in booklists[0]" % p_book['title'])
+
+                self.report_progress(j+1/task_count, _('Updating device metadata listing...'))
+            self.report_progress(1.0, _('Updating device metadata listing...'))
+
+        # Add new books to booklists[0]
+        for new_book in locations[0]:
+            booklists[0].append(new_book)
+
+    def books(self, oncard=None, end_session=True):
+        """
+        Return a list of ebooks on the device.
+        @param oncard:  If 'carda' or 'cardb' return a list of ebooks on the
+                        specific storage card, otherwise return list of ebooks
+                        in main memory of device. If a card is specified and no
+                        books are on the card return empty list.
+        @return: A BookList.
+
+        Implementation notes:
+        iTunes does not sync purchased books, they are only on the device.  They are visible, but
+        they are not backed up to iTunes.  Since calibre can't manage them, don't show them in the
+        list of device books.
+
+        """
+        if DEBUG:
+            self.log.info("ITUNES:books(oncard=%s)" % oncard)
+
+        if not oncard:
+            # Fetch a list of books from iPod device connected to iTunes
+            if isosx:
+
+                # Fetch Library|Books
+                library_books = self._get_library_books()
+
+                if 'iPod' in self.sources:
+                    device = self.sources['iPod']
+                    if 'Books' in self.iTunes.sources[device].playlists.name():
+                        booklist = BookList(self.log)
+                        cached_books = {}
+                        device_books = self._get_device_books()
+                        book_count = float(len(device_books))
+                        for (i,book) in enumerate(device_books):
+                            this_book = Book(book.name(), book.artist())
+                            this_book.path = self.path_template % (book.name(), book.artist())
+                            this_book.datetime = parse_date(str(book.date_added())).timetuple()
+                            this_book.db_id = None
+                            this_book.device_collections = []
+                            this_book.library_id = library_books[this_book.path] if this_book.path in library_books else None
+                            this_book.size = book.size()
+                            this_book.thumbnail = self._generate_thumbnail(this_book.path, book)
+
+                            booklist.add_book(this_book, False)
+
+                            cached_books[this_book.path] = {
+                             'title':book.name(),
+                             'author':book.artist(),
+                             'lib_book':library_books[this_book.path] if this_book.path in library_books else None
+                             }
+
+                            self.report_progress(i+1/book_count, _('%d of %d' % (i+1, book_count)))
+
+                        self.report_progress(1.0, _('finished'))
+                        self.cached_books = cached_books
+                        if DEBUG:
+                            self._dump_cached_books()
+                        return booklist
+                    else:
+                        # No books installed on this device
+                        return []
+        else:
+            return []
+
+    def can_handle(self, device_info, debug=False):
+        '''
+        Unix version of :method:`can_handle_windows`
+
+        :param device_info: Is a tupe of (vid, pid, bcd, manufacturer, product,
+        serial number)
+
+        Confirm that:
+            - iTunes is running
+            - there is an iPod-type device connected
+        This gets called first when the device fingerprint is read, so it needs to
+        instantiate iTunes if necessary
+        This gets called ~1x/second while device fingerprint is sensed
+        '''
+
+        if isosx:
+            if self.iTunes:
+                # Check for connected book-capable device
+                try:
+                    names = [s.name() for s in self.iTunes.sources()]
+                    kinds = [str(s.kind()).rpartition('.')[2] for s in self.iTunes.sources()]
+                    self.sources = sources = dict(zip(kinds,names))
+                    if 'iPod' in sources:
+                        if DEBUG:
+                            sys.stdout.write('.')
+                            sys.stdout.flush()
+                        return True
+                    else:
+                        if DEBUG:
+                            self.log.info("ITUNES.can_handle(): device ejected")
+                        return False
+                except:
+                    # iTunes connection failed, probably not running anymore
+                    self.log.error("ITUNES.can_handle(): lost connection to iTunes")
+                    return False
+            else:
+                # can_handle() is called once before open(), so need to return True
+                # to keep things going
+                if DEBUG:
+                    self.log.info("ITUNES:can_handle(): iTunes not yet instantiated")
+                return True
+
+    def can_handle_windows(self, device_id, debug=False):
+        '''
+        Optional method to perform further checks on a device to see if this driver
+        is capable of handling it. If it is not it should return False. This method
+        is only called after the vendor, product ids and the bcd have matched, so
+        it can do some relatively time intensive checks. The default implementation
+        returns True. This method is called only on windows. See also
+        :method:`can_handle`.
+
+        :param device_info: On windows a device ID string. On Unix a tuple of
+        ``(vendor_id, product_id, bcd)``.
+        '''
+
+        return False
+
+    def card_prefix(self, end_session=True):
+        '''
+        Return a 2 element list of the prefix to paths on the cards.
+        If no card is present None is set for the card's prefix.
+        E.G.
+        ('/place', '/place2')
+        (None, 'place2')
+        ('place', None)
+        (None, None)
+        '''
+        if DEBUG:
+            self.log.info("ITUNES:card_prefix()")
+        return (None,None)
+
+    def delete_books(self, paths, end_session=True):
+        '''
+        Delete books at paths on device.
+        iTunes doesn't let us directly delete a book on the device.
+        If the requested paths are deletable (i.e., it's in the Library|Books list),
+        delete the paths from the library, then update iPad
+
+        '''
+        undeletable_titles = []
+        for path in paths:
+            if self.cached_books[path]['lib_book']:
+                if DEBUG:
+                    self.log.info("ITUNES:delete_books(): Deleting '%s' from iTunes library" % (path))
+                self._remove_iTunes_dir(self.cached_books[path])
+                self.iTunes.delete(self.cached_books[path]['lib_book'])
+                self.update_needed = True
+                self.update_msg = "Deleted books from device"
+
+            else:
+                undeletable_titles.append(self.cached_books[path]['title'])
+
+        if undeletable_titles:
+            raise UserFeedback(_('You cannot delete purchased books. To do so delete them from the device itself. The books that could not be deleted are:'), details='\n'.join(undeletable_titles), level=UserFeedback.WARN)
+
+    def eject(self):
+        '''
+        Un-mount / eject the device from the OS. This does not check if there
+        are pending GUI jobs that need to communicate with the device.
+        '''
+        if DEBUG:
+            self.log.info("ITUNES:eject(): ejecting '%s'" % self.sources['iPod'])
+        self.iTunes.eject(self.sources['iPod'])
+        self.iTunes = None
+        self.sources = None
+
+    def free_space(self, end_session=True):
+        """
+        Get free space available on the mountpoints:
+          1. Main memory
+          2. Card A
+          3. Card B
+
+        @return: A 3 element list with free space in bytes of (1, 2, 3). If a
+        particular device doesn't have any of these locations it should return -1.
+        """
+        if DEBUG:
+            self.log.info("ITUNES:free_space()")
+
+        free_space = 0
+        if isosx:
+            if 'iPod' in self.sources:
+                connected_device = self.sources['iPod']
+                free_space = self.iTunes.sources[connected_device].free_space()
+
+        return (free_space,-1,-1)
+
+    def get_device_information(self, end_session=True):
+        """
+        Ask device for device information. See L{DeviceInfoQuery}.
+        @return: (device name, device version, software version on device, mime type)
+        """
+        if DEBUG:
+            self.log.info("ITUNES:get_device_information()")
+
+        return ('iPad','hw v1.0','sw v1.0', 'mime type')
+
+    def get_file(self, path, outfile, end_session=True):
+        '''
+        Read the file at C{path} on the device and write it to outfile.
+        @param outfile: file object like C{sys.stdout} or the result of an C{open} call
+        '''
+        if DEBUG:
+            self.log.info("ITUNES.get_file(): exporting '%s'" % path)
+        outfile.write(open(self.cached_books[path]['lib_book'].location().path).read())
+
+    def open(self):
+        '''
+        Perform any device specific initialization. Called after the device is
+        detected but before any other functions that communicate with the device.
+        For example: For devices that present themselves as USB Mass storage
+        devices, this method would be responsible for mounting the device or
+        if the device has been automounted, for finding out where it has been
+        mounted. The base class within USBMS device.py has a implementation of
+        this function that should serve as a good example for USB Mass storage
+        devices.
+        '''
+
+        if isosx:
+            # Launch iTunes if not already running
+            if DEBUG:
+                self.log.info("ITUNES:open(): Instantiating iTunes")
+
+            # Instantiate iTunes
+            running_apps = appscript.app('System Events')
+            if not 'iTunes' in running_apps.processes.name():
+                if DEBUG:
+                    self.log.info( "ITUNES:open(): Launching iTunes" )
+                self.iTunes = iTunes= appscript.app('iTunes', hide=True)
+                iTunes.run()
+                if DEBUG:
+                    self.log.info( "%s - %s (launched), driver version %s" % \
+                        (self.iTunes.name(), self.iTunes.version(), self.driver_version))
+            else:
+                self.iTunes = appscript.app('iTunes')
+                if DEBUG:
+                    self.log.info( " %s - %s (already running), driver version %s" % \
+                        (self.iTunes.name(), self.iTunes.version(), self.driver_version))
+
+            # Init the iTunes source list
+            names = [s.name() for s in self.iTunes.sources()]
+            kinds = [str(s.kind()).rpartition('.')[2] for s in self.iTunes.sources()]
+            self.sources = sources = dict(zip(kinds,names))
+
+            # Check to see if Library|Books out of sync with Device|Books
+            if 'iPod' in self.sources and self.presync:
+                lb_count = len(self._get_library_books())
+                db_count = len(self._get_device_books())
+                pb_count = len(self._get_purchased_book_ids())
+                if db_count != lb_count + pb_count:
+                    if DEBUG:
+                        self.log.info( "ITUNES.open(): pre-syncing iTunes with device")
+                        self.log.info( " Library|Books         : %d" % lb_count)
+                        self.log.info( " Devices|iPad|Books    : %d" % db_count)
+                        self.log.info( " Devices|iPad|Purchased: %d" % pb_count)
+                    self._update_device(msg="Presyncing iTunes with device, mismatched book count")
+            else:
+                if DEBUG:
+                    self.log.info( "Skipping pre-sync check")
+
+            # Create thumbs archive
+            archive_path = os.path.join(self.cache_dir, "thumbs.zip")
+
+            if not os.path.exists(self.cache_dir):
+                if DEBUG:
+                    self.log.info(" creating thumb cache '%s'" % self.cache_dir)
+                os.makedirs(self.cache_dir)
+
+            if not os.path.exists(archive_path):
+                self.log.info(" creating zip archive")
+                zfw = zipfile.ZipFile(archive_path, mode='w')
+                zfw.writestr("iTunes Thumbs Archive",'')
+                zfw.close()
+            else:
+                if DEBUG:
+                    self.log.info(" existing thumb cache at '%s'" % archive_path)
+
+        if iswindows:
+            # Launch iTunes if not already running
+            if DEBUG:
+                self.log.info("ITUNES:open(): Instantiating iTunes")
+
+    def remove_books_from_metadata(self, paths, booklists):
+        '''
+        Remove books from the metadata list. This function must not communicate
+        with the device.
+        @param paths: paths to books on the device.
+        @param booklists:  A tuple containing the result of calls to
+                                (L{books}(oncard=None), L{books}(oncard='carda'),
+                                L{books}(oncard='cardb')).
+        '''
+        if DEBUG:
+            self.log.info("ITUNES.remove_books_from_metadata():")
+        for path in paths:
+            if self.cached_books[path]['lib_book']:
+                # Remove from the booklist
+                for i,book in enumerate(booklists[0]):
+                    if book.path == path:
+                        self.log.info(" removing '%s' from calibre booklist, index: %d" % (path, i))
+                        booklists[0].pop(i)
+                        break
+                else:
+                    self.log.error("ITUNES.remove_books_from_metadata(): '%s' not found in self.cached_book" % path)
+
+                # Remove from cached_books
+                if DEBUG:
+                    self.log.info("ITUNES.remove_books_from_metadata(): Removing '%s' from self.cached_books" % path)
+                self.cached_books.pop(path)
+
+            else:
+                self.log.warning("ITUNES.remove_books_from_metadata(): skipping purchased book, can't remove via automation interface")
+
+    def reset(self, key='-1', log_packets=False, report_progress=None,
+            detected_device=None) :
+        """
+        :key: The key to unlock the device
+        :log_packets: If true the packet stream to/from the device is logged
+        :report_progress: Function that is called with a % progress
+                                (number between 0 and 100) for various tasks
+                                If it is called with -1 that means that the
+                                task does not have any progress information
+        :detected_device: Device information from the device scanner
+        """
+        if DEBUG:
+            self.log.info("ITUNE.reset()")
+
+    def set_progress_reporter(self, report_progress):
+        '''
+        @param report_progress: Function that is called with a % progress
+                                (number between 0 and 100) for various tasks
+                                If it is called with -1 that means that the
+                                task does not have any progress information
+        '''
+        if DEBUG:
+            self.log.info("ITUNES:set_progress_reporter()")
+        self.report_progress = report_progress
+
+    def settings(self):
+        '''
+        Should return an opts object. The opts object should have one attribute
+        `format_map` which is an ordered list of formats for the device.
+        '''
+        if DEBUG:
+            self.log.info("ITUNES.settings()")
+        klass = self if isinstance(self, type) else self.__class__
+        c = Config('device_drivers_%s' % klass.__name__, _('settings for device drivers'))
+        c.add_opt('format_map', default=self.FORMATS,
+            help=_('Ordered list of formats the device will accept'))
+        return c.parse()
+
+    def sync_booklists(self, booklists, end_session=True):
+        '''
+        Update metadata on device.
+        @param booklists: A tuple containing the result of calls to
+                                (L{books}(oncard=None), L{books}(oncard='carda'),
+                                L{books}(oncard='cardb')).
+        '''
+        if DEBUG:
+            self.log.info("ITUNES:sync_booklists():")
+        if self.update_needed:
+            self._update_device(msg=self.update_msg)
+            self.update_needed = False
+
+        # Get actual size of updated books on device
+        if self.update_list:
+            if DEBUG:
+                self.log.info("ITUNES:sync_booklists(): update_list:")
+                for ub in self.update_list:
+                    self.log.info(" '%s'" % ub['title'])
+
+            for updated_book in self.update_list:
+                size_on_device = self._get_device_book_size(updated_book['title'], updated_book['author'])
+                if size_on_device:
+                    for book in booklists[0]:
+                        if book.title == updated_book['title'] and \
+                           book.author[0] == updated_book['author']:
+                            book.size = size_on_device
+                            break
+                    else:
+                        self.log.error("ITUNES:sync_booklists(): could not update book size for '%s'" % updated_book['title'])
+
+                else:
+                    self.log.error("ITUNES:sync_booklists(): could not find '%s' on device" % updated_book['title'])
+            self.update_list = []
+
+    def total_space(self, end_session=True):
+        """
+        Get total space available on the mountpoints:
+            1. Main memory
+            2. Memory Card A
+            3. Memory Card B
+
+        @return: A 3 element list with total space in bytes of (1, 2, 3). If a
+        particular device doesn't have any of these locations it should return 0.
+        """
+        if DEBUG:
+            self.log.info("ITUNES:total_space()")
+        capacity = 0
+        if isosx:
+            if 'iPod' in self.sources:
+                connected_device = self.sources['iPod']
+                capacity = self.iTunes.sources[connected_device].capacity()
+
+        return (capacity,-1,-1)
+
+    def upload_books(self, files, names, on_card=None, end_session=True,
+                     metadata=None):
+        '''
+        Upload a list of books to the device. If a file already
+        exists on the device, it should be replaced.
+        This method should raise a L{FreeSpaceError} if there is not enough
+        free space on the device. The text of the FreeSpaceError must contain the
+        word "card" if C{on_card} is not None otherwise it must contain the word "memory".
+        :files: A list of paths and/or file-like objects.
+        :names: A list of file names that the books should have
+        once uploaded to the device. len(names) == len(files)
+        :return: A list of 3-element tuples. The list is meant to be passed
+        to L{add_books_to_metadata}.
+        :metadata: If not None, it is a list of :class:`MetaInformation` objects.
+        The idea is to use the metadata to determine where on the device to
+        put the book. len(metadata) == len(files). Apart from the regular
+        cover (path to cover), there may also be a thumbnail attribute, which should
+        be used in preference. The thumbnail attribute is of the form
+        (width, height, cover_data as jpeg).
+        '''
+
+        new_booklist = []
+        self.update_list = []
+
+        if isosx:
+
+            file_count = float(len(files))
+            for (i,file) in enumerate(files):
+
+                path = self.path_template % (metadata[i].title, metadata[i].author[0])
+
+                # Delete existing from Library|Books, add to self.update_list
+                # for deletion from booklist[0] during add_books_to_metadata
+                if path in self.cached_books:
+                    self.update_list.append(self.cached_books[path])
+
+                    if DEBUG:
+                        self.log.info("ITUNES.upload_books():")
+                        self.log.info( " deleting existing '%s'" % (path))
+                    self._remove_iTunes_dir(self.cached_books[path])
+                    self.iTunes.delete(self.cached_books[path]['lib_book'])
+
+                # Add to iTunes Library|Books
+                if isinstance(file,PersistentTemporaryFile):
+                    added = self.iTunes.add(appscript.mactypes.File(file._name))
+                else:
+                    added = self.iTunes.add(appscript.mactypes.File(file))
+
+                thumb = None
+                try:
+                    if self.use_thumbnail_as_cover:
+                        # Use thumbnail data as artwork
+                        added.artworks[1].data_.set(metadata[i].thumbnail[2])
+                        thumb = metadata[i].thumbnail[2]
+                    else:
+                        # Use cover data as artwork
+                        cover_data = open(metadata[i].cover,'rb')
+                        added.artworks[1].data_.set(cover_data.read())
+
+                        # Resize for thumb
+                        width = metadata[i].thumbnail[0]
+                        height = metadata[i].thumbnail[1]
+                        im = PILImage.open(metadata[i].cover)
+                        im = im.resize((width, height), PILImage.ANTIALIAS)
+                        of = cStringIO.StringIO()
+                        im.convert('RGB').save(of, 'JPEG')
+                        thumb = of.getvalue()
+
+                    # Cache the thumbnail always, could be updated
+                    if DEBUG:
+                        self.log.info( " refreshing cached thumb for '%s'" % metadata[i].title)
+                    archive_path = os.path.join(self.cache_dir, "thumbs.zip")
+                    zfw = zipfile.ZipFile(archive_path, mode='a')
+                    thumb_path = path.rpartition('.')[0] + '.jpg'
+                    zfw.writestr(thumb_path, thumb)
+                    zfw.close()
+                except:
+                    self.log.error("ITUNES.upload_books(): error converting '%s' to thumb for '%s'" % (metadata[i].cover,metadata[i].title))
+
+                # Create a new Book
+                this_book = Book(metadata[i].title, metadata[i].author[0])
+                this_book.datetime = parse_date(str(added.date_added())).timetuple()
+                this_book.db_id = None
+                this_book.device_collections = []
+                this_book.library_id = added
+                this_book.path = path
+                this_book.size = added.size()   # Updated later from actual storage size
+                this_book.thumbnail = thumb
+                this_book.iTunes_id = added
+
+                new_booklist.append(this_book)
+
+                # Flesh out the iTunes metadata
+                added.comment.set("added by calibre %s" % strftime('%Y-%m-%d %H:%M:%S'))
+                if metadata[i].rating:
+                    added.rating.set(metadata[i].rating*10)
+                added.sort_artist.set(metadata[i].author_sort.title())
+                added.sort_name.set(this_book.title_sorter)
+
+                # Set genre from metadata
+                # iTunes grabs the first dc:subject from the opf metadata,
+                # But we can manually override with first tag starting with alpha
+                for tag in metadata[i].tags:
+                    if self._is_alpha(tag[0]):
+                        added.genre.set(tag)
+                        break
+
+                # Add new_book to self.cached_paths
+                self.cached_books[this_book.path] = {
+                 'title': this_book.title,
+                 'author': this_book.author,
+                 'lib_book': added
+                 }
+
+                # Report progress
+                self.report_progress(i+1/file_count, _('%d of %d' % (i+1, file_count)))
+
+            self.report_progress(1.0, _('finished'))
+
+            # Tell sync_booklists we need a re-sync
+            self.update_needed = True
+            self.update_msg = "Added books to device"
+
+        return (new_booklist, [], [])
+
+    # Private methods
+    def _dump_booklist(self,booklist, header="booklists[0]"):
+        '''
+        '''
+        self.log.info()
+        self.log.info(header)
+        self.log.info( "%s" % ('-' * len(header)))
+        for i,book in enumerate(booklist):
+            self.log.info( "%2d %-25.25s %s" % (i,book.title, book.library_id))
+        self.log.info()
+
+    def _dump_cached_books(self):
+        '''
+        '''
+        self.log.info("\n%-40.40s %-12.12s" % ('Device Books','In Library'))
+        self.log.info("%-40.40s %-12.12s" % ('------------','----------'))
+        for cb in self.cached_books.keys():
+            self.log.info("%-40.40s %6.6s" % (self.cached_books[cb]['title'], 'yes' if self.cached_books[cb]['lib_book'] else ' no'))
+        self.log.info("\n")
+
+    def _hexdump(self, src, length=16):
+        '''
+        '''
+        FILTER=''.join([(len(repr(chr(x)))==3) and chr(x) or '.' for x in range(256)])
+        N=0; result=''
+        while src:
+           s,src = src[:length],src[length:]
+           hexa = ' '.join(["%02X"%ord(x) for x in s])
+           s = s.translate(FILTER)
+           result += "%04X   %-*s   %s\n" % (N, length*3, hexa, s)
+           N+=length
+        print result
+
+    def _get_library_books(self):
+        '''
+        '''
+        lib = self.iTunes.sources['library']
+        library_books = {}
+        if 'Books' in lib.playlists.name():
+            lib_books = lib.playlists['Books'].file_tracks()
+            for book in lib_books:
+                path = self.path_template % (book.name(), book.artist())
+                library_books[path] = book
+        return library_books
+
+    def _get_device_book_size(self, title, author):
+        '''
+        Fetch the size of a book stored on the device
+        '''
+        if DEBUG:
+            self.log.info("ITUNES._get_device_book_size(): looking for title: '%s' author: %s" % (title,author))
+
+        device_books = self._get_device_books()
+        for d_book in device_books:
+            if DEBUG:
+                self.log.info(" evaluating title: '%s' author: '%s'" % (d_book.name(), d_book.artist()))
+            if d_book.name() == title and d_book.artist() == author:
+                return d_book.size()
+        else:
+            self.log.error("ITUNES._get_device_book_size(): could not find '%s' by '%s' in device_books" % (title,author))
+            return None
+
+    def _get_device_books(self):
+        '''
+        '''
+        if 'iPod' in self.sources:
+            device = self.sources['iPod']
+            device_books = []
+            if 'Books' in self.iTunes.sources[device].playlists.name():
+                return self.iTunes.sources[device].playlists['Books'].file_tracks()
+
+    def _generate_thumbnail(self, book_path, book):
+        '''
+        Convert iTunes artwork to thumbnail
+        Cache generated thumbnails
+        cache_dir = os.path.join(config_dir, 'caches', 'itunes')
+        '''
+        archive_path = os.path.join(self.cache_dir, "thumbs.zip")
+        thumb_path = book_path.rpartition('.')[0] + '.jpg'
+
+        try:
+            zfr = zipfile.ZipFile(archive_path)
+            thumb_data = zfr.read(thumb_path)
+            zfr.close()
+        except:
+            zfw = zipfile.ZipFile(archive_path, mode='a')
+        else:
+            if DEBUG:
+                self.log.info("ITUNES._generate_thumbnail(): cached thumb found for '%s'" % book.name())
+            return thumb_data
+
+        try:
+            # Resize the cover
+            data = book.artworks[1].raw_data().data
+            #self._hexdump(data[:256])
+            im = PILImage.open(cStringIO.StringIO(data))
+            scaled, width, height = fit_image(im.size[0],im.size[1], 60, 80)
+            im = im.resize((int(width),int(height)), PILImage.ANTIALIAS)
+            thumb = cStringIO.StringIO()
+            im.convert('RGB').save(thumb,'JPEG')
+
+            # Cache the tagged thumb
+            if DEBUG:
+                self.log.info("ITUNES._generate_thumbnail(): generated thumb for '%s', caching" % book.name())
+            zfw.writestr(thumb_path, thumb.getvalue())
+            zfw.close()
+            return thumb.getvalue()
+        except:
+            self.log.error("ITUNES._generate_thumbnail(): error generating thumb for '%s'" % book.name())
+            return None
+
+    def _get_purchased_book_ids(self):
+        '''
+        '''
+        if 'iPod' in self.sources:
+            device = self.sources['iPod']
+            if 'Purchased' in self.iTunes.sources[device].playlists.name():
+                return [pb.database_ID() for pb in self.iTunes.sources[device].playlists['Purchased'].file_tracks()]
+            else:
+                return []
+
+    def _is_alpha(self,char):
+        '''
+        '''
+        if not re.search('[a-zA-Z]',char):
+            return False
+        else:
+            return True
+
+    def _remove_iTunes_dir(self, cached_book):
+        '''
+        iTunes does not delete books from storage when removing from database
+        '''
+        storage_path = os.path.split(cached_book['lib_book'].location().path)
+        if DEBUG:
+            self.log.info( "ITUNES._remove_iTunes_dir():")
+            self.log.info( " removing storage_path: %s" % storage_path[0])
+        shutil.rmtree(storage_path[0])
+
+    def _update_device(self, msg='', wait=True):
+        '''
+
+        '''
+        if DEBUG:
+            self.log.info("ITUNES:_update_device(): %s" % msg)
+        self.iTunes.update()
+
+        if wait:
+            # This works if iTunes has books not yet synced to iPad.
+            if DEBUG:
+                self.log.info("Waiting for iPad sync to complete ...",)
+            while len(self._get_device_books()) != (len(self._get_library_books()) + len(self._get_purchased_book_ids())):
+                if DEBUG:
+                    sys.stdout.write('.')
+                    sys.stdout.flush()
+                time.sleep(2)
+            print
+
+class BookList(list):
+    '''
+    A list of books. Each Book object must have the fields:
+      1. title
+      2. authors
+      3. size (file size of the book)
+      4. datetime (a UTC time tuple)
+      5. path (path on the device to the book)
+      6. thumbnail (can be None) thumbnail is either a str/bytes object with the
+         image data or it should have an attribute image_path that stores an
+         absolute (platform native) path to the image
+      7. tags (a list of strings, can be empty).
+    '''
+
+    __getslice__ = None
+    __setslice__ = None
+    log = None
+
+    def __init__(self, log):
+        self.log = log
+
+    def supports_collections(self):
+        ''' Return True if the the device supports collections for this book list. '''
+        return False
+
+    def add_book(self, book, replace_metadata):
+        '''
+        Add the book to the booklist. Intent is to maintain any device-internal
+        metadata. Return True if booklists must be sync'ed
+        '''
+        if DEBUG:
+            self.log.info("BookList.add_book(): adding %s" % book)
+        self.append(book)
+
+    def remove_book(self, book):
+        '''
+        Remove a book from the booklist. Correct any device metadata at the
+        same time
+        '''
+        raise NotImplementedError()
+
+    def get_collections(self, collection_attributes):
+        '''
+        Return a dictionary of collections created from collection_attributes.
+        Each entry in the dictionary is of the form collection name:[list of
+        books]
+
+        The list of books is sorted by book title, except for collections
+        created from series, in which case series_index is used.
+
+        :param collection_attributes: A list of attributes of the Book object
+        '''
+        return {}
+
+class Book(MetaInformation):
+    '''
+    A simple class describing a book in the iTunes Books Library.
+    Q's:
+    - Should thumbnail come from calibre if available?
+    - See ebooks.metadata.__init__ for all fields
+    '''
+    def __init__(self,title,author):
+
+        MetaInformation.__init__(self, title, authors=[author])
+
+    @dynamic_property
+    def title_sorter(self):
+        doc = '''String to sort the title. If absent, title is returned'''
+        def fget(self):
+            return re.sub('^\s*A\s+|^\s*The\s+|^\s*An\s+', '', self.title).rstrip()
+        return property(doc=doc, fget=fget)