home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1347 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  32.2 KB  |  739 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __license__ = 'GPL v3'
  5. __copyright__ = '2008, Kovid Goyal kovid@kovidgoyal.net'
  6. __docformat__ = 'restructuredtext en'
  7. import sys
  8. import os
  9. import cStringIO
  10. import re
  11. from textwrap import TextWrapper
  12. from calibre import terminal_controller, preferred_encoding, prints
  13. from calibre.utils.config import OptionParser, prefs, tweaks
  14. from calibre.ebooks.metadata.meta import get_metadata
  15. from calibre.library.database2 import LibraryDatabase2
  16. from calibre.ebooks.metadata.opf2 import OPFCreator, OPF
  17. from calibre.utils.date import isoformat
  18. FIELDS = set([
  19.     'title',
  20.     'authors',
  21.     'author_sort',
  22.     'publisher',
  23.     'rating',
  24.     'timestamp',
  25.     'size',
  26.     'tags',
  27.     'comments',
  28.     'series',
  29.     'series_index',
  30.     'formats',
  31.     'isbn',
  32.     'uuid',
  33.     'pubdate',
  34.     'cover'])
  35.  
  36. def send_message(msg = ''):
  37.     prints('Notifying calibre of the change')
  38.     RC = RC
  39.     import calibre.utils.ipc
  40.     import time
  41.     t = RC(print_error = False)
  42.     t.start()
  43.     time.sleep(3)
  44.     if t.done:
  45.         t.conn.send('refreshdb:' + msg)
  46.         t.conn.close()
  47.     
  48.  
  49.  
  50. def get_parser(usage):
  51.     parser = OptionParser(usage)
  52.     go = parser.add_option_group('GLOBAL OPTIONS')
  53.     go.add_option('--library-path', '--with-library', default = None, help = _('Path to the calibre library. Default is to use the path stored in the settings.'))
  54.     return parser
  55.  
  56.  
  57. def get_db(dbpath, options):
  58.     if options.library_path is not None:
  59.         dbpath = options.library_path
  60.     
  61.     dbpath = os.path.abspath(dbpath)
  62.     return LibraryDatabase2(dbpath)
  63.  
  64.  
  65. def do_list(db, fields, afields, sort_by, ascending, search_text, line_width, separator, prefix, subtitle = 'Books in the calibre database'):
  66.     if sort_by:
  67.         db.sort(sort_by, ascending)
  68.     
  69.     if search_text:
  70.         db.search(search_text)
  71.     
  72.     data = db.get_data_as_dict(prefix, authors_as_string = True)
  73.     fields = [
  74.         'id'] + fields
  75.     title_fields = fields
  76.     fields = [ _[1] if x[0] == '*' else x for x in fields ]
  77.     for f in data:
  78.         fmts = _[2]
  79.         f['formats'] = u'[%s]' % u','.join(fmts)
  80.     
  81.     widths = list(map((lambda x: 0), fields))
  82.     for record in data:
  83.         for f in record.keys():
  84.             record[f] = record[f].replace('\n', ' ')
  85.         
  86.     
  87.     for i in data:
  88.         for j, field in enumerate(fields):
  89.             widths[j] = max(widths[j], len(unicode(i[field])))
  90.         
  91.     
  92.     screen_width = [] if hasattr(record[f], 'isoformat') else [] if line_width < 0 else line_width
  93.     if not screen_width:
  94.         screen_width = 80
  95.     
  96.     field_width = screen_width // len(fields)
  97.     base_widths = (map,)((lambda x: min(x + 1, field_width)), widths)
  98.     while sum(base_widths) < screen_width:
  99.         adjusted = False
  100.         for i in range(len(widths)):
  101.             if base_widths[i] < widths[i]:
  102.                 base_widths[i] += min(screen_width - sum(base_widths), widths[i] - base_widths[i])
  103.                 adjusted = True
  104.                 break
  105.                 continue
  106.         
  107.         if not adjusted:
  108.             break
  109.             continue
  110.     widths = list(base_widths)
  111.     titles = (map,)((lambda x, y: '%-*s%s' % (x - len(separator), y, separator)), widths, title_fields)
  112.     print terminal_controller.GREEN + ''.join(titles) + terminal_controller.NORMAL
  113.     wrappers = map((lambda x: TextWrapper(x - 1)), widths)
  114.     o = cStringIO.StringIO()
  115.     for record in data:
  116.         text = [ wrappers[i].wrap(unicode(record[field]).encode('utf-8')) for i, field in enumerate(fields) ]
  117.         lines = max(map(len, text))
  118.         for l in range(lines):
  119.             for i, field in enumerate(text):
  120.                 ft = [] if l < len(text[i]) else ''
  121.                 filler = '%*s' % (widths[i] - len(ft) - 1, '')
  122.                 o.write(ft)
  123.                 o.write(filler + separator)
  124.             
  125.             print >>o
  126.         
  127.     
  128.     return o.getvalue()
  129.  
  130.  
  131. def list_option_parser(db = None):
  132.     fields = set(FIELDS)
  133.     if db is not None:
  134.         for f in db.custom_column_label_map:
  135.             fields.add('*' + f)
  136.         
  137.     
  138.     parser = get_parser(_('%prog list [options]\n\nList the books available in the calibre database.\n'))
  139.     parser.add_option('-f', '--fields', default = 'title,authors', help = _('The fields to display when listing books in the database. Should be a comma separated list of fields.\nAvailable fields: %s\nDefault: %%default. The special field "all" can be used to select all fields. Only has effect in the text output format.') % ','.join(sorted(fields)))
  140.     parser.add_option('--sort-by', default = None, help = _('The field by which to sort the results.\nAvailable fields: %s\nDefault: %%default') % ','.join(FIELDS))
  141.     parser.add_option('--ascending', default = False, action = 'store_true', help = _('Sort results in ascending order'))
  142.     parser.add_option('-s', '--search', default = None, help = _('Filter the results by the search query. For the format of the search query, please see the search related documentation in the User Manual. Default is to do no filtering.'))
  143.     parser.add_option('-w', '--line-width', default = -1, type = int, help = _('The maximum width of a single line in the output. Defaults to detecting screen size.'))
  144.     parser.add_option('--separator', default = ' ', help = _('The string used to separate fields. Default is a space.'))
  145.     parser.add_option('--prefix', default = None, help = _('The prefix for all file paths. Default is the absolute path to the library folder.'))
  146.     return parser
  147.  
  148.  
  149. def command_list(args, dbpath):
  150.     pre = get_parser('')
  151.     pargs = _[1]
  152.     opts = pre.parse_args(sys.argv[:1] + pargs)[0]
  153.     db = get_db(dbpath, opts)
  154.     parser = list_option_parser(db = db)
  155.     (opts, args) = parser.parse_args(sys.argv[:1] + args)
  156.     afields = set(FIELDS)
  157.     fields = [ str(f.strip().lower()) for f in opts.fields.split(',') ]
  158.     if not set(fields).issubset(afields):
  159.         parser.print_help()
  160.         print 
  161.         prints(_('Invalid fields. Available fields:'), ','.join(sorted(afields)), file = sys.stderr)
  162.         return 1
  163.     if opts.sort_by not in afields and opts.sort_by is not None:
  164.         parser.print_help()
  165.         print 
  166.         prints(_('Invalid sort field. Available fields:'), ','.join(afields), file = sys.stderr)
  167.         return 1
  168.     print do_list(db, fields, afields, opts.sort_by, opts.ascending, opts.search, opts.line_width, opts.separator, opts.prefix)
  169.     return 0
  170.  
  171.  
  172. class DevNull(object):
  173.     
  174.     def write(self, msg):
  175.         pass
  176.  
  177.  
  178. NULL = DevNull()
  179.  
  180. def do_add(db, paths, one_book_per_directory, recurse, add_duplicates):
  181.     orig = sys.stdout
  182.     
  183.     try:
  184.         files = []
  185.         dirs = []
  186.         for path in paths:
  187.             path = os.path.abspath(path)
  188.             if os.path.isdir(path):
  189.                 dirs.append(path)
  190.                 continue
  191.             if os.path.exists(path):
  192.                 files.append(path)
  193.                 continue
  194.             print path, 'not found'
  195.         
  196.         formats = []
  197.         metadata = []
  198.         for book in files:
  199.             format = os.path.splitext(book)[1]
  200.             format = None if format else None
  201.             if not format:
  202.                 continue
  203.             
  204.             stream = open(book, 'rb')
  205.             mi = get_metadata(stream, stream_type = format, use_libprs_metadata = True)
  206.             if not mi.title:
  207.                 mi.title = os.path.splitext(os.path.basename(book))[0]
  208.             
  209.             if not mi.authors:
  210.                 mi.authors = [
  211.                     _('Unknown')]
  212.             
  213.             formats.append(format)
  214.             metadata.append(mi)
  215.         
  216.         file_duplicates = []
  217.         if files:
  218.             file_duplicates = db.add_books(files, formats, metadata, add_duplicates = add_duplicates)
  219.             if file_duplicates:
  220.                 file_duplicates = file_duplicates[0]
  221.             
  222.         
  223.         dir_dups = []
  224.         for dir in dirs:
  225.             if recurse:
  226.                 dir_dups.extend(db.recursive_import(dir, single_book_per_directory = one_book_per_directory))
  227.                 continue
  228.             func = None if one_book_per_directory else db.import_book_directory_multiple
  229.             dups = func(dir)
  230.             if not dups:
  231.                 dups = []
  232.             
  233.             dir_dups.extend(dups)
  234.         
  235.         sys.stdout = sys.__stdout__
  236.         if add_duplicates:
  237.             for mi, formats in dir_dups:
  238.                 db.import_book(mi, formats)
  239.             
  240.         elif dir_dups or file_duplicates:
  241.             print >>sys.stderr, _('The following books were not added as they already exist in the database (see --duplicates option):')
  242.         
  243.         for mi, formats in dir_dups:
  244.             title = mi.title
  245.             if isinstance(title, unicode):
  246.                 title = title.encode(preferred_encoding)
  247.             
  248.             print >>sys.stderr, '\t', title + ':'
  249.             for path in formats:
  250.                 print >>sys.stderr, '\t\t ', path
  251.             
  252.         
  253.         if file_duplicates:
  254.             for path, mi in zip(file_duplicates[0], file_duplicates[2]):
  255.                 title = mi.title
  256.                 if isinstance(title, unicode):
  257.                     title = title.encode(preferred_encoding)
  258.                 
  259.                 print >>sys.stderr, '\t', title + ':'
  260.                 print >>sys.stderr, '\t\t ', path
  261.             
  262.         
  263.         send_message()
  264.     finally:
  265.         sys.stdout = orig
  266.  
  267.  
  268.  
  269. def add_option_parser():
  270.     parser = get_parser(_('%prog add [options] file1 file2 file3 ...\n\nAdd the specified files as books to the database. You can also specify directories, see\nthe directory related options below.\n'))
  271.     parser.add_option('-1', '--one-book-per-directory', action = 'store_true', default = False, help = _('Assume that each directory has only a single logical book and that all files in it are different e-book formats of that book'))
  272.     parser.add_option('-r', '--recurse', action = 'store_true', default = False, help = _('Process directories recursively'))
  273.     parser.add_option('-d', '--duplicates', action = 'store_true', default = False, help = _('Add books to database even if they already exist. Comparison is done based on book titles.'))
  274.     parser.add_option('-e', '--empty', action = 'store_true', default = False, help = _('Add an empty book (a book with no formats)'))
  275.     parser.add_option('-t', '--title', default = None, help = _('Set the title of the added empty book'))
  276.     parser.add_option('-a', '--authors', default = None, help = _('Set the authors of the added empty book'))
  277.     parser.add_option('-i', '--isbn', default = None, help = _('Set the ISBN of the added empty book'))
  278.     return parser
  279.  
  280.  
  281. def do_add_empty(db, title, authors, isbn):
  282.     MetaInformation = MetaInformation
  283.     string_to_authors = string_to_authors
  284.     import calibre.ebooks.metadata
  285.     mi = MetaInformation(None)
  286.     if title is not None:
  287.         mi.title = title
  288.     
  289.     if authors:
  290.         mi.authors = string_to_authors(authors)
  291.     
  292.     if isbn:
  293.         mi.isbn = isbn
  294.     
  295.     db.import_book(mi, [])
  296.     send_message()
  297.  
  298.  
  299. def command_add(args, dbpath):
  300.     parser = add_option_parser()
  301.     (opts, args) = parser.parse_args(sys.argv[:1] + args)
  302.     if opts.empty:
  303.         do_add_empty(get_db(dbpath, opts), opts.title, opts.authors, opts.isbn)
  304.         return 0
  305.     if len(args) < 2:
  306.         parser.print_help()
  307.         print 
  308.         print >>sys.stderr, _('You must specify at least one file to add')
  309.         return 1
  310.     do_add(get_db(dbpath, opts), args[1:], opts.one_book_per_directory, opts.recurse, opts.duplicates)
  311.     return 0
  312.  
  313.  
  314. def do_remove(db, ids):
  315.     for x in ids:
  316.         if isinstance(x, int):
  317.             db.delete_book(x)
  318.         else:
  319.             for y in x:
  320.                 db.delete_book(y)
  321.             
  322.         send_message()
  323.     
  324.  
  325.  
  326. def remove_option_parser():
  327.     return get_parser(_('%prog remove ids\n\nRemove the books identified by ids from the database. ids should be a comma separated list of id numbers (you can get id numbers by using the list command). For example, 23,34,57-85\n'))
  328.  
  329.  
  330. def command_remove(args, dbpath):
  331.     parser = remove_option_parser()
  332.     (opts, args) = parser.parse_args(sys.argv[:1] + args)
  333.     if len(args) < 2:
  334.         parser.print_help()
  335.         print 
  336.         print >>sys.stderr, _('You must specify at least one book to remove')
  337.         return 1
  338.     ids = []
  339.     for x in args[1].split(','):
  340.         y = x.split('-')
  341.         if len(y) > 1:
  342.             ids.append(range(int(y[0], int(y[1]))))
  343.             continue
  344.         len(args) < 2
  345.         ids.append(int(y[0]))
  346.     
  347.     do_remove(get_db(dbpath, opts), set(ids))
  348.     return 0
  349.  
  350.  
  351. def do_add_format(db, id, fmt, path):
  352.     db.add_format_with_hooks(id, fmt.upper(), path, index_is_id = True)
  353.  
  354.  
  355. def add_format_option_parser():
  356.     return get_parser(_('%prog add_format [options] id ebook_file\n\nAdd the ebook in ebook_file to the available formats for the logical book identified by id. You can get id by using the list command. If the format already exists, it is replaced.\n'))
  357.  
  358.  
  359. def command_add_format(args, dbpath):
  360.     parser = add_format_option_parser()
  361.     (opts, args) = parser.parse_args(sys.argv[:1] + args)
  362.     if len(args) < 3:
  363.         parser.print_help()
  364.         print 
  365.         print >>sys.stderr, _('You must specify an id and an ebook file')
  366.         return 1
  367.     id = int(args[1])
  368.     path = args[2]
  369.     fmt = os.path.splitext(args[2])[-1]
  370.     do_add_format(get_db(dbpath, opts), id, fmt[1:], path)
  371.     return 0
  372.  
  373.  
  374. def do_remove_format(db, id, fmt):
  375.     db.remove_format(id, fmt, index_is_id = True)
  376.  
  377.  
  378. def remove_format_option_parser():
  379.     return get_parser(_('\n%prog remove_format [options] id fmt\n\nRemove the format fmt from the logical book identified by id. You can get id by using the list command. fmt should be a file extension like LRF or TXT or EPUB. If the logical book does not have fmt available, do nothing.\n'))
  380.  
  381.  
  382. def command_remove_format(args, dbpath):
  383.     parser = remove_format_option_parser()
  384.     (opts, args) = parser.parse_args(sys.argv[:1] + args)
  385.     if len(args) < 3:
  386.         parser.print_help()
  387.         print 
  388.         print >>sys.stderr, _('You must specify an id and a format')
  389.         return 1
  390.     id = int(args[1])
  391.     fmt = args[2].upper()
  392.     do_remove_format(get_db(dbpath, opts), id, fmt)
  393.     return 0
  394.  
  395.  
  396. def do_show_metadata(db, id, as_opf):
  397.     if not db.has_id(id):
  398.         raise ValueError('Id #%d is not present in database.' % id)
  399.     db.has_id(id)
  400.     mi = db.get_metadata(id, index_is_id = True)
  401.     if as_opf:
  402.         mi = OPFCreator(os.getcwd(), mi)
  403.         mi.render(sys.stdout)
  404.     else:
  405.         print unicode(mi).encode(preferred_encoding)
  406.  
  407.  
  408. def show_metadata_option_parser():
  409.     parser = get_parser(_('\n%prog show_metadata [options] id\n\nShow the metadata stored in the calibre database for the book identified by id.\nid is an id number from the list command.\n'))
  410.     parser.add_option('--as-opf', default = False, action = 'store_true', help = _('Print metadata in OPF form (XML)'))
  411.     return parser
  412.  
  413.  
  414. def command_show_metadata(args, dbpath):
  415.     parser = show_metadata_option_parser()
  416.     (opts, args) = parser.parse_args(sys.argv[1:] + args)
  417.     if len(args) < 2:
  418.         parser.print_help()
  419.         print 
  420.         print >>sys.stderr, _('You must specify an id')
  421.         return 1
  422.     id = int(args[1])
  423.     do_show_metadata(get_db(dbpath, opts), id, opts.as_opf)
  424.     return 0
  425.  
  426.  
  427. def do_set_metadata(db, id, stream):
  428.     mi = OPF(stream)
  429.     db.set_metadata(id, mi)
  430.     do_show_metadata(db, id, False)
  431.     send_message()
  432.  
  433.  
  434. def set_metadata_option_parser():
  435.     return get_parser(_('\n%prog set_metadata [options] id /path/to/metadata.opf\n\nSet the metadata stored in the calibre database for the book identified by id\nfrom the OPF file metadata.opf. id is an id number from the list command. You\ncan get a quick feel for the OPF format by using the --as-opf switch to the\nshow_metadata command.\n'))
  436.  
  437.  
  438. def command_set_metadata(args, dbpath):
  439.     parser = set_metadata_option_parser()
  440.     (opts, args) = parser.parse_args(sys.argv[1:] + args)
  441.     if len(args) < 3:
  442.         parser.print_help()
  443.         print 
  444.         print >>sys.stderr, _('You must specify an id and a metadata file')
  445.         return 1
  446.     id = int(args[1])
  447.     opf = open(args[2], 'rb')
  448.     do_set_metadata(get_db(dbpath, opts), id, opf)
  449.     return 0
  450.  
  451.  
  452. def do_export(db, ids, dir, opts):
  453.     if ids is None:
  454.         ids = list(db.all_ids())
  455.     
  456.     save_to_disk = save_to_disk
  457.     import calibre.library.save_to_disk
  458.     failures = save_to_disk(db, ids, dir, opts = opts)
  459.     if failures:
  460.         prints('Failed to save the following books:')
  461.         for id, title, tb in failures:
  462.             prints(str(id) + ':', title)
  463.             prints('\t' + '\n\t'.join(tb.splitlines()))
  464.             prints(' ')
  465.         
  466.     
  467.  
  468.  
  469. def export_option_parser():
  470.     parser = get_parser(_('%prog export [options] ids\n\nExport the books specified by ids (a comma separated list) to the filesystem.\nThe export operation saves all formats of the book, its cover and metadata (in\nan opf file). You can get id numbers from the list command.\n'))
  471.     parser.add_option('--all', default = False, action = 'store_true', help = _('Export all books in database, ignoring the list of ids.'))
  472.     parser.add_option('--to-dir', default = '.', help = _('Export books to the specified directory. Default is') + ' %default')
  473.     parser.add_option('--single-dir', default = False, action = 'store_true', help = _('Export all books into a single directory'))
  474.     config = config
  475.     import calibre.library.save_to_disk
  476.     c = config()
  477.     for pref in [
  478.         'asciiize',
  479.         'update_metadata',
  480.         'write_opf',
  481.         'save_cover']:
  482.         opt = c.get_option(pref)
  483.         switch = '--dont-' + pref.replace('_', '-')
  484.         parser.add_option(switch, default = True, action = 'store_false', help = opt.help + ' ' + _('Specifying this switch will turn this behavior off.'), dest = pref)
  485.     
  486.     for pref in [
  487.         'timefmt',
  488.         'template',
  489.         'formats']:
  490.         opt = c.get_option(pref)
  491.         switch = '--' + pref
  492.         parser.add_option(switch, default = opt.default, help = opt.help, dest = pref)
  493.     
  494.     for pref in ('replace_whitespace', 'to_lowercase'):
  495.         opt = c.get_option(pref)
  496.         switch = '--' + pref.replace('_', '-')
  497.         parser.add_option(switch, default = False, action = 'store_true', help = opt.help)
  498.     
  499.     return parser
  500.  
  501.  
  502. def command_export(args, dbpath):
  503.     parser = export_option_parser()
  504.     (opts, args) = parser.parse_args(sys.argv[1:] + args)
  505.     if len(args) < 2 and not (opts.all):
  506.         parser.print_help()
  507.         print 
  508.         print >>sys.stderr, _('You must specify some ids or the %s option') % '--all'
  509.         return 1
  510.     ids = not (opts.all) if opts.all else map(int, args[1].split(','))
  511.     dir = os.path.abspath(os.path.expanduser(opts.to_dir))
  512.     do_export(get_db(dbpath, opts), ids, dir, opts)
  513.     return 0
  514.  
  515.  
  516. def do_add_custom_column(db, label, name, datatype, is_multiple, display):
  517.     num = db.create_custom_column(label, name, datatype, is_multiple, display = display)
  518.     prints('Custom column created with id: %d' % num)
  519.  
  520.  
  521. def add_custom_column_option_parser():
  522.     CustomColumns = CustomColumns
  523.     import calibre.library.custom_columns
  524.     parser = get_parser(_('%prog add_custom_column [options] label name datatype\n\nCreate a custom column. label is the machine friendly name of the column. Should\nnot contain spaces or colons. name is the human friendly name of the column.\ndatatype is one of: {0}\n').format(', '.join(CustomColumns.CUSTOM_DATA_TYPES)))
  525.     parser.add_option('--is-multiple', default = False, action = 'store_true', help = _('This column stores tag like data (i.e. multiple comma separated values). Only applies if datatype is text.'))
  526.     parser.add_option('--display', default = '{}', help = _('A dictionary of options to customize how the data in this column will be interpreted.'))
  527.     return parser
  528.  
  529.  
  530. def command_add_custom_column(args, dbpath):
  531.     import json
  532.     parser = add_custom_column_option_parser()
  533.     (opts, args) = parser.parse_args(args)
  534.     if len(args) < 3:
  535.         parser.print_help()
  536.         print 
  537.         print >>sys.stderr, _('You must specify label, name and datatype')
  538.         return 1
  539.     do_add_custom_column(get_db(dbpath, opts), args[0], args[1], args[2], opts.is_multiple, json.loads(opts.display))
  540.     return 0
  541.  
  542.  
  543. def catalog_option_parser(args):
  544.     available_catalog_formats = available_catalog_formats
  545.     plugin_for_catalog_format = plugin_for_catalog_format
  546.     import calibre.customize.ui
  547.     Log = Log
  548.     import calibre.utils.logging
  549.     
  550.     def add_plugin_parser_options(fmt, parser, log):
  551.         plugin = plugin_for_catalog_format(fmt)
  552.         for option in plugin.cli_options:
  553.             if option.action:
  554.                 parser.add_option(option.option, default = option.default, dest = option.dest, action = option.action, help = option.help)
  555.                 continue
  556.             parser.add_option(option.option, default = option.default, dest = option.dest, help = option.help)
  557.         
  558.         return plugin
  559.  
  560.     
  561.     def print_help(parser, log):
  562.         help = parser.format_help().encode(preferred_encoding, 'replace')
  563.         log(help)
  564.  
  565.     
  566.     def validate_command_line(parser, args, log):
  567.         if not len(args) or args[0].startswith('-'):
  568.             print_help(parser, log)
  569.             log.error("\n\nYou must specify a catalog output file of the form 'path/to/destination.extension'\nTo review options for an output format, type 'calibredb catalog <.extension> --help'\nFor example, 'calibredb catalog .xml --help'\n")
  570.             raise SystemExit(1)
  571.         args[0].startswith('-')
  572.         output = os.path.abspath(args[0])
  573.         file_extension = output[output.rfind('.') + 1:].lower()
  574.         if file_extension not in available_catalog_formats():
  575.             print_help(parser, log)
  576.             log.error("No catalog plugin available for extension '%s'.\n" % file_extension + 'Catalog plugins available for %s\n' % ', '.join(available_catalog_formats()))
  577.             raise SystemExit(1)
  578.         file_extension not in available_catalog_formats()
  579.         return (output, file_extension)
  580.  
  581.     log = Log()
  582.     parser = get_parser(_('\n    %prog catalog /path/to/destination.(csv|epub|mobi|xml ...) [options]\n\n    Export a catalog in format specified by path/to/destination extension.\n    Options control how entries are displayed in the generated catalog ouput.\n    '))
  583.     (output, fmt) = validate_command_line(parser, args, log)
  584.     parser.add_option('-i', '--ids', default = None, dest = 'ids', help = _('Comma-separated list of database IDs to catalog.\nIf declared, --search is ignored.\nDefault: all'))
  585.     parser.add_option('-s', '--search', default = None, dest = 'search_text', help = _('Filter the results by the search query. For the format of the search query, please see the search-related documentation in the User Manual.\nDefault: no filtering'))
  586.     parser.add_option('-v', '--verbose', default = False, action = 'store_true', dest = 'verbose', help = _('Show detailed output information. Useful for debugging'))
  587.     plugin = add_plugin_parser_options(fmt, parser, log)
  588.     return (parser, plugin, log)
  589.  
  590.  
  591. def command_catalog(args, dbpath):
  592.     (parser, plugin, log) = catalog_option_parser(args)
  593.     (opts, args) = parser.parse_args(sys.argv[1:])
  594.     if len(args) < 2:
  595.         parser.print_help()
  596.         print 
  597.         print >>sys.stderr, _('Error: You must specify a catalog output file')
  598.         return 1
  599.     opts.connected_device = {
  600.         'storage': None,
  601.         'serial': None,
  602.         'save_template': None,
  603.         'name': None }
  604.     plugin.__enter__()
  605.     
  606.     try:
  607.         plugin.run(args[1], opts, get_db(dbpath, opts))
  608.     finally:
  609.         pass
  610.  
  611.     return 0
  612.  
  613.  
  614. def parse_series_string(db, label, value):
  615.     val = unicode(value).strip()
  616.     s_index = None
  617.     pat = re.compile('\\[([.0-9]+)\\]')
  618.     match = pat.search(val)
  619.     if match is not None:
  620.         val = pat.sub('', val).strip()
  621.         s_index = float(match.group(1))
  622.     elif val:
  623.         if tweaks['series_index_auto_increment'] == 'next':
  624.             s_index = db.get_next_cc_series_num_for(val, label = label)
  625.         else:
  626.             s_index = 1
  627.     
  628.     return (val, s_index)
  629.  
  630.  
  631. def do_set_custom(db, col, id_, val, append):
  632.     if db.custom_column_label_map[col]['datatype'] == 'series':
  633.         (val, s_index) = parse_series_string(db, col, val)
  634.         db.set_custom(id_, val, extra = s_index, label = col, append = append)
  635.         prints('Data set to: %r[%4.2f]' % (db.get_custom(id_, label = col, index_is_id = True), db.get_custom_extra(id_, label = col, index_is_id = True)))
  636.     else:
  637.         db.set_custom(id_, val, label = col, append = append)
  638.         prints('Data set to: %r' % db.get_custom(id_, label = col, index_is_id = True))
  639.  
  640.  
  641. def set_custom_option_parser():
  642.     parser = get_parser(_('\n    %prog set_custom [options] column id value\n\n    Set the value of a custom column for the book identified by id.\n    You can get a list of ids using the list command.\n    You can get a list of custom column names using the custom_columns\n    command.\n    '))
  643.     parser.add_option('-a', '--append', default = False, action = 'store_true', help = _('If the column stores multiple values, append the specified values to the existing ones, instead of replacing them.'))
  644.     return parser
  645.  
  646.  
  647. def command_set_custom(args, dbpath):
  648.     parser = set_custom_option_parser()
  649.     (opts, args) = parser.parse_args(args)
  650.     if len(args) < 3:
  651.         parser.print_help()
  652.         print 
  653.         print >>sys.stderr, _('Error: You must specify a field name, id and value')
  654.         return 1
  655.     do_set_custom(get_db(dbpath, opts), args[0], int(args[1]), args[2], opts.append)
  656.     return 0
  657.  
  658.  
  659. def do_custom_columns(db, details):
  660.     pformat = pformat
  661.     import pprint
  662.     cols = db.custom_column_label_map
  663.     for col, data in cols.items():
  664.         if details:
  665.             prints(col)
  666.             print 
  667.             prints(pformat(data))
  668.             print '\n'
  669.             continue
  670.         prints(col, '(%d)' % data['num'])
  671.     
  672.  
  673.  
  674. def custom_columns_option_parser():
  675.     parser = get_parser(_('\n    %prog custom_columns [options]\n\n    List available custom columns. Shows column labels and ids.\n    '))
  676.     parser.add_option('-d', '--details', default = False, action = 'store_true', help = _('Show details for each column.'))
  677.     return parser
  678.  
  679.  
  680. def command_custom_columns(args, dbpath):
  681.     parser = custom_columns_option_parser()
  682.     (opts, args) = parser.parse_args(args)
  683.     do_custom_columns(get_db(dbpath, opts), opts.details)
  684.     return 0
  685.  
  686.  
  687. def do_remove_custom_column(db, label, force):
  688.     if not force:
  689.         q = raw_input(_('You will lose all data in the column: %r. Are you sure (y/n)? ') % label)
  690.         if q.lower().strip() != _('y'):
  691.             return None
  692.     
  693.     db.delete_custom_column(label = label)
  694.     prints('Column %r removed.' % label)
  695.  
  696.  
  697. def remove_custom_column_option_parser():
  698.     parser = get_parser(_('\n    %prog remove_custom_column [options] label\n\n    Remove the custom column identified by label. You can see available\n    columns with the custom_columns command.\n    '))
  699.     parser.add_option('-f', '--force', default = False, action = 'store_true', help = _('Do not ask for confirmation'))
  700.     return parser
  701.  
  702.  
  703. def command_remove_custom_column(args, dbpath):
  704.     parser = remove_custom_column_option_parser()
  705.     (opts, args) = parser.parse_args(args)
  706.     if len(args) < 1:
  707.         parser.print_help()
  708.         print 
  709.         prints(_('Error: You must specify a column label'), file = sys.stderr)
  710.         return 1
  711.     do_remove_custom_column(get_db(dbpath, opts), args[0], opts.force)
  712.     return 0
  713.  
  714. COMMANDS = ('list', 'add', 'remove', 'add_format', 'remove_format', 'show_metadata', 'set_metadata', 'export', 'catalog', 'add_custom_column', 'custom_columns', 'remove_custom_column', 'set_custom')
  715.  
  716. def option_parser():
  717.     parser = OptionParser(_('%%prog command [options] [arguments]\n\n%%prog is the command line interface to the calibre books database.\n\ncommand is one of:\n  %s\n\nFor help on an individual command: %%prog command --help\n') % '\n  '.join(COMMANDS))
  718.     return parser
  719.  
  720.  
  721. def main(args = sys.argv):
  722.     parser = option_parser()
  723.     if len(args) < 2:
  724.         parser.print_help()
  725.         return 1
  726.     if args[1] not in COMMANDS:
  727.         if args[1] == '--version':
  728.             parser.print_version()
  729.             return 0
  730.         parser.print_help()
  731.         return 1
  732.     command = eval('command_' + args[1])
  733.     dbpath = prefs['library_path']
  734.     return command(args[2:], dbpath)
  735.  
  736. if __name__ == '__main__':
  737.     sys.exit(main())
  738.  
  739.