home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 January / maximum-cd-2011-01.iso / DiscContents / calibre-0.7.26.msi / file_960 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-10-31  |  7.4 KB  |  269 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. from __future__ import with_statement
  5. __license__ = 'GPL v3'
  6. __copyright__ = '2008, Kovid Goyal <kovid at kovidgoyal.net>'
  7. import os
  8. import re
  9. import collections
  10. from calibre.utils.config import prefs
  11. from calibre.constants import filesystem_encoding
  12. from calibre.ebooks.metadata.opf2 import OPF
  13. from calibre import isbytestring
  14. from calibre.customize.ui import get_file_type_metadata, set_file_type_metadata
  15. from calibre.ebooks.metadata import MetaInformation, string_to_authors
  16. _METADATA_PRIORITIES = [
  17.     'html',
  18.     'htm',
  19.     'xhtml',
  20.     'xhtm',
  21.     'rtf',
  22.     'fb2',
  23.     'pdf',
  24.     'prc',
  25.     'odt',
  26.     'epub',
  27.     'lit',
  28.     'lrx',
  29.     'lrf',
  30.     'mobi',
  31.     'rb',
  32.     'imp',
  33.     'azw',
  34.     'snb']
  35. METADATA_PRIORITIES = collections.defaultdict((lambda : 0))
  36. for i, ext in enumerate(_METADATA_PRIORITIES):
  37.     METADATA_PRIORITIES[ext] = i
  38.  
  39.  
  40. def path_to_ext(path):
  41.     return os.path.splitext(path)[1][1:].lower()
  42.  
  43.  
  44. def metadata_from_formats(formats, force_read_metadata = False, pattern = None):
  45.     
  46.     try:
  47.         return _metadata_from_formats(formats, force_read_metadata, pattern)
  48.     except:
  49.         mi = metadata_from_filename(list(iter(formats), pattern)[0])
  50.         if not mi.authors:
  51.             mi.authors = [
  52.                 _('Unknown')]
  53.         
  54.         return mi
  55.  
  56.  
  57.  
  58. def _metadata_from_formats(formats, force_read_metadata = False, pattern = None):
  59.     mi = MetaInformation(None, None)
  60.     formats.sort(cmp = (lambda x, y: cmp(METADATA_PRIORITIES[path_to_ext(x)], METADATA_PRIORITIES[path_to_ext(y)])))
  61.     extensions = list(map(path_to_ext, formats))
  62.     if 'opf' in extensions:
  63.         opf = formats[extensions.index('opf')]
  64.         mi2 = opf_metadata(opf)
  65.         if mi2 is not None and mi2.title:
  66.             return mi2
  67.     
  68.     for path, ext in zip(formats, extensions):
  69.         
  70.         try:
  71.             stream = _[1]
  72.             
  73.             try:
  74.                 newmi = get_metadata(stream, stream_type = ext, use_libprs_metadata = True, force_read_metadata = force_read_metadata, pattern = pattern)
  75.                 mi.smart_update(newmi)
  76.             except:
  77.                 open(path, 'rb').__exit__
  78.                 open(path, 'rb')
  79.                 continue
  80.  
  81.             if getattr(mi, 'application_id', None) is not None:
  82.                 return mi
  83.         finally:
  84.             pass
  85.  
  86.     
  87.     if not mi.authors:
  88.         mi.authors = [
  89.             _('Unknown')]
  90.     
  91.     return mi
  92.  
  93.  
  94. def is_recipe(filename):
  95.     if filename.startswith('calibre'):
  96.         pass
  97.     return filename.rpartition('.')[0].endswith('_recipe_out')
  98.  
  99.  
  100. def get_metadata(stream, stream_type = 'lrf', use_libprs_metadata = False, force_read_metadata = False, pattern = None):
  101.     pos = 0
  102.     if hasattr(stream, 'tell'):
  103.         pos = stream.tell()
  104.     
  105.     
  106.     try:
  107.         return _get_metadata(stream, stream_type, use_libprs_metadata, force_read_metadata, pattern)
  108.     finally:
  109.         if hasattr(stream, 'seek'):
  110.             stream.seek(pos)
  111.         
  112.  
  113.  
  114.  
  115. def _get_metadata(stream, stream_type, use_libprs_metadata, force_read_metadata = False, pattern = None):
  116.     if stream_type:
  117.         stream_type = stream_type.lower()
  118.     
  119.     if stream_type in ('html', 'html', 'xhtml', 'xhtm', 'xml'):
  120.         stream_type = 'html'
  121.     
  122.     if stream_type in ('mobi', 'prc', 'azw'):
  123.         stream_type = 'mobi'
  124.     
  125.     if stream_type in ('odt', 'ods', 'odp', 'odg', 'odf'):
  126.         stream_type = 'odt'
  127.     
  128.     opf = None
  129.     if hasattr(stream, 'name'):
  130.         c = os.path.splitext(stream.name)[0] + '.opf'
  131.         if os.access(c, os.R_OK):
  132.             opf = opf_metadata(os.path.abspath(c))
  133.         
  134.     
  135.     if use_libprs_metadata and getattr(opf, 'application_id', None) is not None:
  136.         return opf
  137.     mi = MetaInformation(None, None)
  138.     name = os.path.basename(getattr(stream, 'name', ''))
  139.     base = metadata_from_filename(name, pat = pattern)
  140.     if force_read_metadata and is_recipe(name) or prefs['read_file_metadata']:
  141.         mi = get_file_type_metadata(stream, stream_type)
  142.     
  143.     if base.title == os.path.splitext(name)[0] and base.is_null('authors') and base.is_null('isbn'):
  144.         base.smart_update(metadata_from_filename(name, re.compile('^(?P<title>[ \\S]+?)[ _]-[ _](?P<author>[ \\S]+?)_+\\d+')))
  145.         if base.title:
  146.             base.title = base.title.replace('_', ' ')
  147.         
  148.         if base.authors:
  149.             base.authors = [ a.replace('_', ' ').strip() for a in base.authors ]
  150.         
  151.     
  152.     if not base.authors:
  153.         base.authors = [
  154.             _('Unknown')]
  155.     
  156.     if not base.title:
  157.         base.title = _('Unknown')
  158.     
  159.     base.smart_update(mi)
  160.     if opf is not None:
  161.         base.smart_update(opf)
  162.     
  163.     return base
  164.  
  165.  
  166. def set_metadata(stream, mi, stream_type = 'lrf'):
  167.     if stream_type:
  168.         stream_type = stream_type.lower()
  169.     
  170.     set_file_type_metadata(stream, mi, stream_type)
  171.  
  172.  
  173. def metadata_from_filename(name, pat = None):
  174.     if isbytestring(name):
  175.         name = name.decode(filesystem_encoding, 'replace')
  176.     
  177.     name = name.rpartition('.')[0]
  178.     mi = MetaInformation(None, None)
  179.     if pat is None:
  180.         pat = re.compile(prefs.get('filename_pattern'))
  181.     
  182.     name = name.replace('_', ' ')
  183.     match = pat.search(name)
  184.     if match is not None:
  185.         
  186.         try:
  187.             mi.title = match.group('title')
  188.         except IndexError:
  189.             pass
  190.  
  191.         
  192.         try:
  193.             au = match.group('author')
  194.             aus = string_to_authors(au)
  195.             mi.authors = aus
  196.             if prefs['swap_author_names'] and mi.authors:
  197.                 
  198.                 def swap(a):
  199.                     if ',' in a:
  200.                         parts = a.split(',', 1)
  201.                     else:
  202.                         parts = a.split(None, 1)
  203.                     if len(parts) > 1:
  204.                         t = parts[-1]
  205.                         parts = parts[:-1]
  206.                         parts.insert(0, t)
  207.                     
  208.                     return ' '.join(parts)
  209.  
  210.                 mi.authors = [ swap(x) for x in mi.authors ]
  211.         except (IndexError, ValueError):
  212.             pass
  213.  
  214.         
  215.         try:
  216.             mi.series = match.group('series')
  217.         except IndexError:
  218.             pass
  219.  
  220.         
  221.         try:
  222.             si = match.group('series_index')
  223.             mi.series_index = float(si)
  224.         except (IndexError, ValueError, TypeError):
  225.             pass
  226.  
  227.         
  228.         try:
  229.             si = match.group('isbn')
  230.             mi.isbn = si
  231.         except (IndexError, ValueError):
  232.             pass
  233.         except:
  234.             None<EXCEPTION MATCH>(IndexError, ValueError)
  235.         
  236.  
  237.     None<EXCEPTION MATCH>(IndexError, ValueError)
  238.     if mi.is_null('title'):
  239.         mi.title = name
  240.     
  241.     return mi
  242.  
  243.  
  244. def opf_metadata(opfpath):
  245.     if hasattr(opfpath, 'read'):
  246.         f = opfpath
  247.         opfpath = getattr(f, 'name', os.getcwd())
  248.     else:
  249.         f = open(opfpath, 'rb')
  250.     
  251.     try:
  252.         opf = OPF(f, os.path.dirname(opfpath))
  253.         if opf.application_id is not None:
  254.             mi = opf.to_book_metadata()
  255.             if hasattr(opf, 'cover') and opf.cover:
  256.                 cpath = os.path.join(os.path.dirname(opfpath), opf.cover)
  257.                 if os.access(cpath, os.R_OK):
  258.                     fmt = cpath.rpartition('.')[-1]
  259.                     data = open(cpath, 'rb').read()
  260.                     mi.cover_data = (fmt, data)
  261.                 
  262.             
  263.             return mi
  264.     except:
  265.         import traceback
  266.         traceback.print_exc()
  267.  
  268.  
  269.