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