~ubuntu-branches/debian/experimental/calibre/experimental

from calibre.utils.recycle_bin import delete_file, delete_tree

from calibre.utils.formatter_functions import load_user_template_functions

from calibre.db.errors import NoSuchFormat

from calibre.utils.localization import (canonicalize_lang,

        calibre_langcode_to_name)

 

    def __repr__(self):

        return str(self)

 

class LibraryDatabase2(LibraryDatabase, SchemaUpgrade, CustomColumns):

    '''

    An ebook metadata database that stores references to ebook files on disk.

        except:

            traceback.print_exc()

        self.field_metadata = FieldMetadata()

        self._library_id_ = None

        # Create the lock to be used to guard access to the metadata writer

        # queues. This must be an RLock, not a Lock

        if not self.is_second_db:

            load_user_template_functions(self.prefs.get('user_template_functions', []))

 

        self.conn.executescript('''

        DROP TRIGGER IF EXISTS author_insert_trg;

        CREATE TEMP TRIGGER author_insert_trg

        self.refresh_ondevice = functools.partial(self.data.refresh_ondevice, self)

        self.refresh()

        self.last_update_check = self.last_modified()

 

    def break_cycles(self):

        self.data.break_cycles()

        ''' Return last modified time as a UTC datetime object'''

        return utcfromtimestamp(os.stat(self.dbpath).st_mtime)

 

 

    def check_if_modified(self):

        if self.last_modified() > self.last_update_check:

        authors = self.authors(id, index_is_id=True)

        if not authors:

            authors = _('Unknown')

                    )[:self.PATH_LIMIT].decode('ascii', 'replace')

        title  = ascii_filename(self.title(id, index_is_id=True)

                    )[:self.PATH_LIMIT].decode('ascii', 'replace')

        authors = self.authors(id, index_is_id=True)

        if not authors:

            authors = _('Unknown')

                    )[:self.PATH_LIMIT].decode('ascii', 'replace')

        title  = ascii_filename(self.title(id, index_is_id=True)

                    )[:self.PATH_LIMIT].decode('ascii', 'replace')

        fname = self.construct_file_name(id)

        changed = False

        for format in formats:

            if name and name != fname:

                changed = True

                break

        aum = []

        aus = {}

        aul = {}

        mi.title       = row[fm['title']]

        mi.authors     = aum

        mi.author_sort = row[fm['author_sort']]

            good_formats = None

        else:

            formats = sorted(formats.split(','))

        mi.formats = good_formats

        tags = row[fm['tags']]

        if tags:

 

    def format_files(self, index, index_is_id=False):

        id = index if index_is_id else self.id(index)

 

    def formats(self, index, index_is_id=False, verify_formats=True):

        ''' Return available formats as a comma separated list or None if there are no available formats '''

        '''

        id = index if index_is_id else self.id(index)

        try:

        except:

            return None

        if name:

    def add_format(self, index, format, stream, index_is_id=False, path=None,

            notify=True, replace=True):

        id = index if index_is_id else self.id(index)

        if path is None:

            path = os.path.join(self.library_path, self.path(id, index_is_id=True))

        if name and not replace:

            return False

        name = self.construct_file_name(id)

        self.conn.execute('INSERT OR REPLACE INTO data (book,format,uncompressed_size,name) VALUES (?,?,?,?)',

                          (id, format.upper(), size, name))

        self.conn.commit()

        self.refresh_ids([id])

        if notify:

            self.notify('metadata', [id])

    def remove_format(self, index, format, index_is_id=False, notify=True,

                      commit=True, db_only=False):

        id = index if index_is_id else self.id(index)

        if name:

            if not db_only:

                try:

                        delete_file(path)

                except:

                    traceback.print_exc()

            self.conn.execute('DELETE FROM data WHERE book=? AND format=?', (id, format.upper()))

            if commit:

                self.conn.commit()

 

    ############# End get_categories

 

        '''

        Return the ids of all books having the tag ``tag`` that are older than

        than the specified time. tag comparison is case insensitive.

        the tag are returned.

        :param must_have_tag: If not None the list of matches will be

        restricted to books that have this tag

        '''

        tag = tag.lower().strip()

        mht = must_have_tag.lower().strip() if must_have_tag else None

        tindex = self.FIELD_MAP['timestamp']

        gindex = self.FIELD_MAP['tags']

        iindex = self.FIELD_MAP['id']

        for r in self.data._data:

            if r is not None:

                if delta is None or (now - r[tindex]) > delta:

                    tags = r[gindex]

                    if tags:

                        tags = [x.strip() for x in tags.lower().split(',')]

        stream.seek(0)

        mi = get_metadata(stream, format, use_libprs_metadata=False,

                force_read_metadata=True)

        stream.seek(0)

        if mi.series_index is None:

            mi.series_index = self.get_next_series_num_for(mi.series)

 

    def create_book_entry(self, mi, cover=None, add_duplicates=True,

            force_id=None):

        self._add_newbook_tag(mi)

        if not add_duplicates and self.has_book(mi):

            return None