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