home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 January / maximum-cd-2011-01.iso / DiscContents / calibre-0.7.26.msi / file_974 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-10-31  |  10.3 KB  |  353 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__ = '2009, Kovid Goyal <kovid@kovidgoyal.net>'
  7. __docformat__ = 'restructuredtext en'
  8. from threading import Thread
  9. from Queue import Empty
  10. import os
  11. import time
  12. import sys
  13. import shutil
  14. from calibre.utils.ipc.job import ParallelJob
  15. from calibre.utils.ipc.server import Server
  16. from calibre.ptempfile import PersistentTemporaryDirectory, TemporaryDirectory
  17. from calibre import prints
  18. from calibre.constants import filesystem_encoding
  19.  
  20. def debug(*args):
  21.     prints(*args)
  22.     sys.stdout.flush()
  23.  
  24.  
  25. def serialize_metadata_for(formats, tdir, id_):
  26.     metadata_from_formats = metadata_from_formats
  27.     import calibre.ebooks.metadata.meta
  28.     metadata_to_opf = metadata_to_opf
  29.     import calibre.ebooks.metadata.opf2
  30.     mi = metadata_from_formats(formats)
  31.     mi.cover = None
  32.     cdata = None
  33.     if mi.cover_data:
  34.         cdata = mi.cover_data[-1]
  35.     
  36.     mi.cover_data = None
  37.     if not mi.application_id:
  38.         mi.application_id = '__calibre_dummy__'
  39.     
  40.     
  41.     try:
  42.         f = _[1]
  43.         f.write(metadata_to_opf(mi))
  44.     finally:
  45.         pass
  46.  
  47.  
  48.  
  49. def read_metadata_(task, tdir, notification = (lambda x, y: x)):
  50.     
  51.     try:
  52.         mdir = _[1]
  53.         do_read_metadata(task, tdir, mdir, notification)
  54.     finally:
  55.         pass
  56.  
  57.  
  58.  
  59. def do_read_metadata(task, tdir, mdir, notification):
  60.     run_plugins_on_import = run_plugins_on_import
  61.     import calibre.customize.ui
  62.     for x in task:
  63.         
  64.         try:
  65.             (id_, formats) = x
  66.         except:
  67.             continue
  68.  
  69.         
  70.         try:
  71.             if isinstance(formats, basestring):
  72.                 formats = [
  73.                     formats]
  74.             
  75.             import_map = { }
  76.             fmts = []
  77.             metadata_fmts = []
  78.             for format in formats:
  79.                 mfmt = format
  80.                 (name, ext) = os.path.splitext(os.path.basename(format))
  81.                 nfp = run_plugins_on_import(format)
  82.                 if not nfp and nfp == format or not os.access(nfp, os.R_OK):
  83.                     nfp = None
  84.                 else:
  85.                     nfp = os.path.abspath(nfp)
  86.                     nfext = os.path.splitext(nfp)[1]
  87.                     mfmt = os.path.join(mdir, name + nfext)
  88.                     shutil.copyfile(nfp, mfmt)
  89.                 metadata_fmts.append(mfmt)
  90.                 fmts.append(nfp)
  91.             
  92.             serialize_metadata_for(metadata_fmts, tdir, id_)
  93.             for format, nfp in zip(formats, fmts):
  94.                 if not nfp:
  95.                     continue
  96.                 
  97.                 if isinstance(nfp, unicode):
  98.                     nfp.encode(filesystem_encoding)
  99.                 
  100.                 
  101.                 x = lambda j: os.path.abspath(os.path.normpath(os.path.normcase(j)))
  102.                 if x(nfp) != x(format) and os.access(nfp, os.R_OK | os.W_OK):
  103.                     fmt = os.path.splitext(format)[1].replace('.', '').lower()
  104.                     nfmt = os.path.splitext(nfp)[1].replace('.', '').lower()
  105.                     dest = os.path.join(tdir, '%s.%s' % (id_, nfmt))
  106.                     shutil.copyfile(nfp, dest)
  107.                     import_map[fmt] = dest
  108.                     continue
  109.             
  110.             notification(0.5, id_)
  111.         continue
  112.         import traceback
  113.         
  114.         try:
  115.             f = _[2]
  116.             f.write(traceback.format_exc())
  117.         finally:
  118.             pass
  119.  
  120.         continue
  121.  
  122.     
  123.  
  124.  
  125. class Progress(object):
  126.     
  127.     def __init__(self, result_queue, tdir):
  128.         self.result_queue = result_queue
  129.         self.tdir = tdir
  130.  
  131.     
  132.     def __call__(self, id):
  133.         cover = os.path.join(self.tdir, str(id))
  134.         if not os.path.exists(cover):
  135.             cover = None
  136.         
  137.         res = os.path.join(self.tdir, '%s.error' % id)
  138.         if not os.path.exists(res):
  139.             res = res.replace('.error', '.opf')
  140.         
  141.         self.result_queue.put((id, res, cover))
  142.  
  143.  
  144.  
  145. class ReadMetadata(Thread):
  146.     
  147.     def __init__(self, tasks, result_queue, spare_server = None):
  148.         self.tasks = tasks
  149.         self.result_queue = result_queue
  150.         self.spare_server = spare_server
  151.         self.canceled = False
  152.         Thread.__init__(self)
  153.         self.daemon = True
  154.         self.failure_details = { }
  155.         self.tdir = PersistentTemporaryDirectory('_rm_worker')
  156.  
  157.     
  158.     def run(self):
  159.         jobs = set([])
  160.         ids = set([])
  161.         for t in self.tasks:
  162.             for b in t:
  163.                 ids.add(b[0])
  164.             
  165.         
  166.         progress = Progress(self.result_queue, self.tdir)
  167.         server = None if self.spare_server is None else self.spare_server
  168.         
  169.         try:
  170.             for i, task in enumerate(self.tasks):
  171.                 job = ParallelJob('read_metadata', 'Read metadata (%d of %d)' % (i, len(self.tasks)), (lambda x, y: x), args = [
  172.                     task,
  173.                     self.tdir])
  174.                 jobs.add(job)
  175.                 server.add_job(job)
  176.             
  177.             while not self.canceled:
  178.                 time.sleep(0.2)
  179.                 running = False
  180.                 for job in jobs:
  181.                     while True:
  182.                         
  183.                         try:
  184.                             id = job.notifications.get_nowait()[-1]
  185.                             if id in ids:
  186.                                 progress(id)
  187.                                 ids.remove(id)
  188.                         continue
  189.                         except Empty:
  190.                             break
  191.                             continue
  192.                         
  193.  
  194.                         None<EXCEPTION MATCH>Empty
  195.                     job.update(consume_notifications = False)
  196.                     if not job.is_finished:
  197.                         running = True
  198.                         continue
  199.                 
  200.                 if not running:
  201.                     break
  202.                     continue
  203.         finally:
  204.             server.close()
  205.  
  206.         time.sleep(1)
  207.         if self.canceled:
  208.             return None
  209.         for id in ids:
  210.             progress(id)
  211.         
  212.         for job in jobs:
  213.             if job.failed:
  214.                 prints(job.details)
  215.             
  216.             if os.path.exists(job.log_path):
  217.                 
  218.                 try:
  219.                     os.remove(job.log_path)
  220.  
  221.                 continue
  222.         
  223.  
  224.  
  225.  
  226. def read_metadata(paths, result_queue, chunk = 50, spare_server = None):
  227.     tasks = []
  228.     pos = 0
  229.     while pos < len(paths):
  230.         tasks.append(paths[pos:pos + chunk])
  231.         pos += chunk
  232.     t = ReadMetadata(tasks, result_queue, spare_server = spare_server)
  233.     t.start()
  234.     return t
  235.  
  236.  
  237. class SaveWorker(Thread):
  238.     
  239.     def __init__(self, result_queue, db, ids, path, opts, spare_server = None):
  240.         Thread.__init__(self)
  241.         self.daemon = True
  242.         self.path = path
  243.         self.opts = opts
  244.         self.ids = ids
  245.         self.library_path = db.library_path
  246.         self.canceled = False
  247.         self.result_queue = result_queue
  248.         self.error = None
  249.         self.spare_server = spare_server
  250.         self.start()
  251.  
  252.     
  253.     def run(self):
  254.         config = config
  255.         import calibre.library.save_to_disk
  256.         server = None if self.spare_server is None else self.spare_server
  257.         ids = set(self.ids)
  258.         tasks = server.split(list(ids))
  259.         jobs = set([])
  260.         c = config()
  261.         recs = { }
  262.         for pref in c.preferences:
  263.             recs[pref.name] = getattr(self.opts, pref.name)
  264.         
  265.         for i, task in enumerate(tasks):
  266.             tids = [ x[-1] for x in task ]
  267.             job = ParallelJob('save_book', 'Save books (%d of %d)' % (i, len(tasks)), (lambda x, y: x), args = [
  268.                 tids,
  269.                 self.library_path,
  270.                 self.path,
  271.                 recs])
  272.             jobs.add(job)
  273.             server.add_job(job)
  274.         
  275.         while not self.canceled:
  276.             time.sleep(0.2)
  277.             running = False
  278.             for job in jobs:
  279.                 job.update(consume_notifications = False)
  280.                 while True:
  281.                     
  282.                     try:
  283.                         (id, title, ok, tb) = job.notifications.get_nowait()[0]
  284.                         if id in ids:
  285.                             self.result_queue.put((id, title, ok, tb))
  286.                             ids.remove(id)
  287.                     continue
  288.                     except Empty:
  289.                         []
  290.                         []
  291.                         []
  292.                         break
  293.                         continue
  294.                     
  295.  
  296.                     []<EXCEPTION MATCH>Empty
  297.                 if not job.is_finished:
  298.                     running = True
  299.                     continue
  300.                 []
  301.             
  302.             if not running:
  303.                 break
  304.                 continue
  305.             []
  306.             continue
  307.             []
  308.         server.close()
  309.         time.sleep(1)
  310.         if self.canceled:
  311.             return None
  312.         for job in jobs:
  313.             if job.failed:
  314.                 prints(job.details)
  315.                 self.error = job.details
  316.             
  317.             if os.path.exists(job.log_path):
  318.                 
  319.                 try:
  320.                     os.remove(job.log_path)
  321.  
  322.                 continue
  323.         
  324.  
  325.  
  326.  
  327. def save_book(task, library_path, path, recs, notification = (lambda x, y: x)):
  328.     LibraryDatabase2 = LibraryDatabase2
  329.     import calibre.library.database2
  330.     db = LibraryDatabase2(library_path)
  331.     config = config
  332.     save_to_disk = save_to_disk
  333.     import calibre.library.save_to_disk
  334.     apply_null_metadata = apply_null_metadata
  335.     import calibre.customize.ui
  336.     opts = config().parse()
  337.     for name in recs:
  338.         setattr(opts, name, recs[name])
  339.     
  340.     
  341.     def callback(id, title, failed, tb):
  342.         notification((id, title, not failed, tb))
  343.         return True
  344.  
  345.     apply_null_metadata.__enter__()
  346.     
  347.     try:
  348.         save_to_disk(db, task, path, opts, callback)
  349.     finally:
  350.         pass
  351.  
  352.  
  353.