def convert(self, oeb_book, output, input_plugin, opts, log): if input_plugin.name != "Kindle Comics Input": log.prints(INFO, "Executing default mobi plugin.") from calibre.ebooks.conversion.plugins.mobi_output import MOBIOutput plugin_path = os.path.join( sys.modules[MOBIOutput.__module__].__file__) mobi_output_plugin = MOBIOutput(plugin_path) mobi_output_plugin.convert(oeb_book, output, input_plugin, opts, log) else: log.prints(INFO, "Executing Kindle Comic Output plugin.") from calibre_plugins.kindle_comics_output.build_file \ import build_meta_inf, make_zip, make_mobi, write_metadata_to_opf # convert oebbook to epub metadata = oeb_book.metadata path = os.path.join(oeb_book.container.rootdir, "..") write_metadata_to_opf(os.path.join(path, "OEBPS", "content.opf"), metadata) build_meta_inf(path) log.prints(INFO, "Make epub file...") zip_path = os.path.join(PersistentTemporaryDirectory("_epub"), "comic") zip_path = make_zip(zip_path, path) # convert epub to mobi with kindlegen mobi_output = make_mobi(zip_path) mobi_path = mobi_output[2] log.prints(INFO, "Created mobi.") # move mobi file to destination # todo what if output is directory move(mobi_path, output)
def get_work_folder(comic_file): from calibre.ebooks.comic.input import extract_comic target_dir = extract_comic(comic_file) _log.prints(INFO, "Extracted images into " + target_dir) # move file structure up subdirectories = os.listdir(target_dir) # delete all not-images for file in os.listdir(target_dir): if os.path.isdir(os.path.join(target_dir, file)) \ or file.lower().endswith('.png') \ or file.lower().endswith('.jpg') \ or file.lower().endswith('.jpeg') \ or file.lower().endswith('.tif') \ or file.lower().endswith('.tiff'): continue os.remove(os.path.join(target_dir, file)) if len(subdirectories) == 1 and os.path.isdir( os.path.join(target_dir, subdirectories[0])): for f in os.listdir(os.path.join(target_dir, subdirectories[0])): move(os.path.join(target_dir, subdirectories[0], f), target_dir) os.rmdir(os.path.join(target_dir, subdirectories[0])) new_path = PersistentTemporaryDirectory(suffix='_oebps') copytree(target_dir, os.path.join(new_path, 'OEBPS', 'Images')) rmtree(target_dir) _log.prints(INFO, "Moved images to structure in " + new_path) return new_path
def run(self, yvesfile): from calibre.ebooks.html.to_zip import HTML2ZIP html2zip = HTML2ZIP(None) yves_temp_directory = PersistentTemporaryDirectory('yves_input') bibleName = yvesDir2HTML(yvesfile,yves_temp_directory) return html2zip.run(os.path.join( yves_temp_directory, bibleName ))
def unpack(self, book_id, fmt): ''' Unpack the book in a temporary directory :param book_id: The book identifier :param fmt: The format to unpack ''' from calibre.constants import DEBUG from calibre.ptempfile import PersistentTemporaryDirectory from calibre.ebooks.tweak import get_tools from calibre.ebooks.oeb.base import OEBBook from calibre.ebooks.oeb.reader import OEBReader from calibre.utils.logging import default_log from calibre_plugins.prince_pdf.dummy_preprocessor import dummy_preprocessor book_file = self.db.format(book_id, fmt, index_is_id=True, as_path=True) if DEBUG: print(_('Unpacking book...')) tdir = PersistentTemporaryDirectory('_unpack') exploder = get_tools(fmt)[0] if (exploder == None): return (None, None) opf = exploder(book_file, tdir) html_preprocessor = dummy_preprocessor() css_preprocessor = dummy_preprocessor() oeb = OEBBook(default_log, html_preprocessor, css_preprocessor) OEBReader()(oeb, opf) return (opf, oeb)
def __init__(self, *args): QNetworkAccessManager.__init__(self, *args) self.cache = QNetworkDiskCache(self) self.setCache(self.cache) self.cache.setCacheDirectory( PersistentTemporaryDirectory(prefix='disk_cache_')) self.cache.setMaximumCacheSize(0)
def __init__(self, pdfpath, parent=None): QDialog.__init__(self, parent) self.pdfpath = pdfpath self.stack = WaitLayout(_('Rendering PDF pages, please wait...'), parent=self) self.container = self.stack.after self.container.l = l = QVBoxLayout(self.container) self.la = la = QLabel(_('Choose a cover from the list of PDF pages below')) l.addWidget(la) self.covers = c = QListWidget(self) l.addWidget(c) self.item_delegate = CoverDelegate(self) c.setItemDelegate(self.item_delegate) c.setIconSize(QSize(120, 160)) c.setSelectionMode(c.SingleSelection) c.setViewMode(c.IconMode) c.setUniformItemSizes(True) c.setResizeMode(c.Adjust) c.itemDoubleClicked.connect(self.accept, type=Qt.ConnectionType.QueuedConnection) self.bb = bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok|QDialogButtonBox.StandardButton.Cancel) bb.accepted.connect(self.accept) bb.rejected.connect(self.reject) self.more_pages = b = bb.addButton(_('&More pages'), QDialogButtonBox.ButtonRole.ActionRole) b.clicked.connect(self.start_rendering) l.addWidget(bb) self.rendering_done.connect(self.show_pages, type=Qt.ConnectionType.QueuedConnection) self.first = 1 self.setWindowTitle(_('Choose cover from PDF')) self.setWindowIcon(file_icon_provider().icon_from_ext('pdf')) self.resize(QSize(800, 600)) self.tdir = PersistentTemporaryDirectory('_pdf_covers') self.start_rendering()
def get_comics_from_collection(self, stream): from calibre.libunzip import extract as zipextract tdir = PersistentTemporaryDirectory('_comic_collection') zipextract(stream, tdir) comics = [] with CurrentDir(tdir): if not os.path.exists('comics.txt'): raise ValueError( ('%s is not a valid comic collection' ' no comics.txt was found in the file') % stream.name) with open('comics.txt', 'rb') as f: raw = f.read() if raw.startswith(codecs.BOM_UTF16_BE): raw = raw.decode('utf-16-be')[1:] elif raw.startswith(codecs.BOM_UTF16_LE): raw = raw.decode('utf-16-le')[1:] elif raw.startswith(codecs.BOM_UTF8): raw = raw.decode('utf-8')[1:] else: raw = raw.decode('utf-8') for line in raw.splitlines(): line = line.strip() if not line: continue fname, title = line.partition(':')[0], line.partition(':')[-1] fname = fname.replace('#', '_') fname = os.path.join(tdir, *fname.split('/')) if not title: title = os.path.basename(fname).rpartition('.')[0] if os.access(fname, os.R_OK): comics.append([title, fname]) if not comics: raise ValueError('%s has no comics' % stream.name) return comics
def __init__(self, pdfpath, parent=None): QDialog.__init__(self, parent) self.pdfpath = pdfpath self.l = l = QGridLayout() self.setLayout(l) self.la = la = QLabel(_('Choose a cover from the list of PDF pages below')) l.addWidget(la) self.loading = la = QLabel('<b>'+_('Rendering PDF pages, please wait...')) l.addWidget(la) self.covers = c = QListWidget(self) l.addWidget(c) self.item_delegate = CoverDelegate(self) c.setItemDelegate(self.item_delegate) c.setIconSize(QSize(120, 160)) c.setSelectionMode(c.SingleSelection) c.setViewMode(c.IconMode) c.setUniformItemSizes(True) c.setResizeMode(c.Adjust) c.itemDoubleClicked.connect(self.accept) self.bb = bb = QDialogButtonBox(QDialogButtonBox.Ok|QDialogButtonBox.Cancel) bb.accepted.connect(self.accept) bb.rejected.connect(self.reject) l.addWidget(bb) self.rendering_done.connect(self.show_pages, type=Qt.QueuedConnection) self.tdir = PersistentTemporaryDirectory('_pdf_covers') self.thread = Thread(target=self.render) self.thread.daemon = True self.thread.start() self.setWindowTitle(_('Choose cover from PDF')) self.setWindowIcon(file_icon_provider().icon_from_ext('pdf')) self.resize(QSize(800, 600))
def setUp(self): self.tdir = PersistentTemporaryDirectory('_calibre_dbtest') self.db = LibraryDatabase2(self.tdir) f = open(os.path.join(self.tdir, 'test.txt'), 'w+b') f.write('test') paths = list(repeat(f, 3)) formats = list(repeat('txt', 3)) m1 = MetaInformation('Test Ebook 1', ['Test Author 1']) m1.tags = ['tag1', 'tag2'] m1.publisher = 'Test Publisher 1' m1.rating = 2 m1.series = 'Test Series 1' m1.series_index = 3 m1.author_sort = 'as1' m1.isbn = 'isbn1' m1.cover_data = ('jpg', self.img) m2 = MetaInformation('Test Ebook 2', ['Test Author 2']) m2.tags = ['tag3', 'tag4'] m2.publisher = 'Test Publisher 2' m2.rating = 3 m2.series = 'Test Series 2' m2.series_index = 1 m2.author_sort = 'as1' m2.isbn = 'isbn1' self.db.add_books(paths, formats, [m1, m2, m2], add_duplicates=True) self.m1, self.m2 = m1, m2
def _start_webserver(self): ''' setup bibi and start web server ''' self.htmlroot = PersistentTemporaryDirectory() print(self.htmlroot) zipfile = os.path.join(self.htmlroot, 'bibi.zip') with open(zipfile, 'wb') as f: f.write( self.load_resources(['bibi-0.999.9-r7.zip' ]).itervalues().next()) extract(zipfile, self.htmlroot) handler = RootedHTTPRequestHandler self.htmlroot = self.htmlroot + '/bibi-0.999.9-r7/bib' handler.base_path = self.htmlroot self.httpd = ThreadedTCPServer(('localhost', 0), handler) self.ip, self.port = self.httpd.server_address print('server started at: ', self.ip, str(self.port)) # Start a thread with the server -- that thread will then start one # more thread for each request server_thread = threading.Thread(target=self.httpd.serve_forever) # Exit the server thread when the main thread terminates server_thread.daemon = True server_thread.start() print("Server loop running in thread: ", server_thread.name)
def getTemporaryFile(self): if (self.getfilenameprefs['file_name'] == "") or (not (os.path.exists( self.getfilenameprefs['file_name']))): aux = PersistentTemporaryDirectory("GetFileName") self.getfilenameprefs['file_name'] = os.path.join(aux, 'Dict.txt') return self.getfilenameprefs['file_name']
def plugin_button(self): self.t = time.time() if len(self.gui.library_view.get_selected_ids()) < 2: d = error_dialog(self.gui, _('Cannot Merge Epubs'), _('Less than 2 books selected.'), show_copy_button=False) d.exec_() else: db=self.gui.current_db logger.debug("1:%s"%(time.time()-self.t)) self.t = time.time() book_list = [ self._convert_id_to_book(x, good=False) for x in self.gui.library_view.get_selected_ids() ] # book_ids = self.gui.library_view.get_selected_ids() # put all temp epubs in a temp dir for convenience of # deleting and not needing to keep track of temp input # epubs vs using library epub. tdir = PersistentTemporaryDirectory(prefix='epubmerge_') LoopProgressDialog(self.gui, book_list, partial(self._populate_book_from_calibre_id, db=self.gui.current_db, tdir=tdir), partial(self._start_merge,tdir=tdir), init_label=_("Collecting EPUBs for merger..."), win_title=_("Get EPUBs for merge"), status_prefix=_("EPUBs collected"))
def extract_comic(path_to_comic_file): ''' Un-archive the comic file. ''' tdir = PersistentTemporaryDirectory(suffix='_comic_extract') if not isinstance(tdir, unicode): # Needed in case the zip file has wrongly encoded unicode file/dir # names tdir = tdir.decode(filesystem_encoding) extract(path_to_comic_file, tdir) for x in walk(tdir): bn = os.path.basename(x) nbn = bn.replace('#', '_') if nbn != bn: os.rename(x, os.path.join(os.path.dirname(x), nbn)) return tdir
def _download(self, cookie_file, url, filename, save_loc, add_to_lib): dfilename = '' if not url: raise Exception(_('No file specified to download.')) if not save_loc and not add_to_lib: # Nothing to do. return dfilename if not filename: filename = get_download_filename(url, cookie_file) filename, ext = os.path.splitext(filename) filename = filename[:60] + ext filename = ascii_filename(filename) br = browser() if cookie_file: cj = MozillaCookieJar() cj.load(cookie_file) br.set_cookiejar(cj) with closing(br.open(url)) as r: temp_path = os.path.join(PersistentTemporaryDirectory(), filename) tf = open(temp_path, 'w+b') tf.write(r.read()) dfilename = tf.name return dfilename
def setUp(self): tdir = PersistentTemporaryDirectory() path_to_dictionary.cache_dir = tdir dictionary_name_for_locale.cache_clear() dictionary_for_locale.cache_clear() get_cache_path.cache_clear() is_cache_up_to_date.updated = False
def __init__(self, book_ids, db, opts, root, parent=None, pool=None): QObject.__init__(self, parent) self.db = db.new_api self.plugboards = self.db.pref('plugboards', {}) self.template_functions = self.db.pref('user_template_functions', []) load_user_template_functions('', self.template_functions) self.collected_data = {} self.errors = defaultdict(list) self._book_id_data = {} self.all_book_ids = frozenset(book_ids) self.pd = ProgressDialog(_('Saving %d books...') % len(self.all_book_ids), _('Collecting metadata...'), min=0, max=0, parent=parent, icon='save.png') self.do_one_signal.connect(self.tick, type=Qt.QueuedConnection) self.do_one = self.do_one_collect self.ids_to_collect = iter(self.all_book_ids) self.tdir = PersistentTemporaryDirectory('_save_to_disk') self.pool = pool self.pd.show() self.root, self.opts, self.path_length = sanitize_args(root, opts) self.do_one_signal.emit() if DEBUG: self.start_time = time.time()
def initialize(self): ''' If plugin is not a built-in, copy the plugin's .ui and .py files from the ZIP file to $TMPDIR. Tab will be dynamically generated and added to the Catalog Options dialog in calibre.gui2.dialogs.catalog.py:Catalog ''' from calibre.customize.builtins import plugins as builtin_plugins from calibre.customize.ui import config from calibre.ptempfile import PersistentTemporaryDirectory if not type(self) in builtin_plugins and self.name not in config[ 'disabled_plugins']: files_to_copy = [ f"{self.name.lower()}.{ext}" for ext in ["ui", "py"] ] resources = zipfile.ZipFile(self.plugin_path, 'r') if self.resources_path is None: self.resources_path = PersistentTemporaryDirectory( '_plugin_resources', prefix='') for file in files_to_copy: try: resources.extract(file, self.resources_path) except: print( f" customize:__init__.initialize(): {file} not found in {os.path.basename(self.plugin_path)}" ) continue resources.close()
def __init__(self, opts, log, cover_data=None, toc=None): from calibre.gui2 import must_use_qt from calibre.utils.podofo import get_podofo must_use_qt() QObject.__init__(self) self.logger = self.log = log self.podofo = get_podofo() self.doc = self.podofo.PDFDoc() self.loop = QEventLoop() self.view = QWebView() self.page = Page(opts, self.log) self.view.setPage(self.page) self.view.setRenderHints(QPainter.Antialiasing | QPainter.TextAntialiasing | QPainter.SmoothPixmapTransform) self.view.loadFinished.connect(self._render_html, type=Qt.QueuedConnection) for x in (Qt.Horizontal, Qt.Vertical): self.view.page().mainFrame().setScrollBarPolicy( x, Qt.ScrollBarAlwaysOff) self.render_queue = [] self.combine_queue = [] self.tmp_path = PersistentTemporaryDirectory(u'_pdf_output_parts') self.opts = opts self.cover_data = cover_data self.paged_js = None self.toc = toc
def __init__(self, opts, log, cover_data=None): from calibre.gui2 import is_ok_to_use_qt if not is_ok_to_use_qt(): raise Exception('Not OK to use Qt') QObject.__init__(self) self.logger = log self.loop = QEventLoop() self.view = QWebView() self.view.setRenderHints(QPainter.Antialiasing | QPainter.TextAntialiasing | QPainter.SmoothPixmapTransform) self.view.loadFinished.connect(self._render_html, type=Qt.QueuedConnection) for x in (Qt.Horizontal, Qt.Vertical): self.view.page().mainFrame().setScrollBarPolicy( x, Qt.ScrollBarAlwaysOff) self.render_queue = [] self.combine_queue = [] self.tmp_path = PersistentTemporaryDirectory(u'_pdf_output_parts') self.opts = opts self.cover_data = cover_data self.paged_js = None
def __init__(self, source, single_book_per_directory=True, db=None, parent=None, callback=None, pool=None, list_of_archives=False): if not validate_source(source, parent): return QObject.__init__(self, parent) self.single_book_per_directory = single_book_per_directory self.ignore_opf = False self.list_of_archives = list_of_archives self.callback = callback self.add_formats_to_existing = prefs['add_formats_to_existing'] self.do_one_signal.connect(self.tick, type=Qt.QueuedConnection) self.pool = pool self.pd = ProgressDialog(_('Adding books...'), _('Scanning for files...'), min=0, max=0, parent=parent, icon='add_book.png') self.db = getattr(db, 'new_api', None) if self.db is not None: self.dbref = weakref.ref(db) self.source = source self.tdir = PersistentTemporaryDirectory('_add_books') self.scan_error = None self.file_groups = OrderedDict() self.abort_scan = False self.duplicates = [] self.report = [] self.items = [] self.added_book_ids = set() self.merged_books = set() self.added_duplicate_info = set() self.pd.show() self.scan_thread = Thread(target=self.scan, name='ScanBooks') self.scan_thread.daemon = True self.scan_thread.start() self.do_one = self.monitor_scan self.do_one_signal.emit() if DEBUG: self.start_time = time.time()
def __init__(self, max_downloaded: int, db, reporter: Callable = None) -> None: self._max_downloaded = max_downloaded self._dir = PersistentTemporaryDirectory() self._db = db self._reporter = reporter
def __init__(self, tasks, result_queue, spare_server=None): self.tasks, self.result_queue = tasks, result_queue self.spare_server = spare_server self.canceled = False Thread.__init__(self) self.daemon = True self.failure_details = {} self.tdir = PersistentTemporaryDirectory('_rm_worker')
def __init__(self, pathtoazw3, log, clone_data=None, tdir=None): if clone_data is not None: super(AZW3Container, self).__init__(None, None, log, clone_data=clone_data) for x in ('pathtoazw3', 'obfuscated_fonts'): setattr(self, x, clone_data[x]) return self.pathtoazw3 = pathtoazw3 if tdir is None: tdir = PersistentTemporaryDirectory('_azw3_container') tdir = os.path.abspath(os.path.realpath(tdir)) self.root = tdir with open(pathtoazw3, 'rb') as stream: raw = stream.read(3) if raw == b'TPZ': raise InvalidMobi( _('This is not a MOBI file. It is a Topaz file.')) try: header = MetadataHeader(stream, default_log) except MobiError: raise InvalidMobi(_('This is not a MOBI file.')) if header.encryption_type != 0: raise DRMError() kf8_type = header.kf8_type if kf8_type is None: raise InvalidMobi( _('This MOBI file does not contain a KF8 format ' 'book. KF8 is the new format from Amazon. calibre can ' 'only edit MOBI files that contain KF8 books. Older ' 'MOBI files without KF8 are not editable.')) if kf8_type == 'joint': raise InvalidMobi( _('This MOBI file contains both KF8 and ' 'older Mobi6 data. calibre can only edit MOBI files ' 'that contain only KF8 data.')) try: opf_path, obfuscated_fonts = fork_job( 'calibre.ebooks.oeb.polish.container', 'do_explode', args=(pathtoazw3, tdir), no_output=True)['result'] except WorkerError as e: log(e.orig_tb) raise InvalidMobi('Failed to explode MOBI') super(AZW3Container, self).__init__(tdir, opf_path, log) self.obfuscated_fonts = { x.replace(os.sep, '/') for x in obfuscated_fonts }
def __init__(self, path): tmpdir = PersistentTemporaryDirectory("_kobo-driver-extended") zf = zipfile.ZipFile(path) zf.extractall(tmpdir) self.root = os.path.abspath(tmpdir) self.log = logging.Log(level=logging.DEBUG if DEBUG else logging.WARN) self.dirtied = set([]) self.cache = {} self.mime_map = {} print("Container:__init__:Got container path {0}".format(self.root)) if os.path.exists(os.path.join(self.root, 'mimetype')): os.remove(os.path.join(self.root, 'mimetype')) container_path = os.path.join(self.root, 'META-INF', 'container.xml') if not os.path.exists(container_path): raise InvalidEpub('No META-INF/container.xml in epub') self.container = etree.fromstring(open(container_path, 'rb').read()) opf_files = self.container.xpath(( r'child::ocf:rootfiles/ocf:rootfile[@media-type="{0}" and @full-path]' .format(guess_type('a.opf')[0])), namespaces=self.namespaces) if not opf_files: raise InvalidEpub( 'META-INF/container.xml contains no link to OPF file') opf_path = os.path.join(self.root, *opf_files[0].get('full-path').split('/')) if not os.path.exists(opf_path): raise InvalidEpub( 'OPF file does not exist at location pointed to by META-INF/container.xml' ) # Map of relative paths with / separators to absolute # paths on filesystem with os separators self.name_map = {} for dirpath, dirnames, filenames in os.walk(self.root): for f in filenames: path = os.path.join(dirpath, f) name = os.path.relpath(path, self.root).replace(os.sep, '/') self.name_map[name] = path self.mime_map[name] = guess_type(f)[0] if path == opf_path: self.opf_name = name self.mime_map[name] = guess_type('a.opf')[0] opf = self.opf for item in opf.xpath('//opf:manifest/opf:item[@href and @media-type]', namespaces=self.namespaces): href = unquote(item.get('href')) item.set("href", href) self.mime_map[self.href_to_name( href, os.path.dirname(self.opf_name).replace( os.sep, '/'))] = item.get('media-type') self.set(self.opf_name, opf)
def open_book(self, path=None, edit_file=None, clear_notify_data=True): if self.gui.action_save.isEnabled(): if not question_dialog( self.gui, _('Unsaved changes'), _('The current book has unsaved changes. If you open a new book, they will be lost' ' are you sure you want to proceed?')): return if self.save_manager.has_tasks: return info_dialog( self.gui, _('Cannot open'), _('The current book is being saved, you cannot open a new book until' ' the saving is completed'), show=True) if not hasattr(path, 'rpartition'): path = choose_files(self.gui, 'open-book-for-tweaking', _('Choose book'), [(_('Books'), [x.lower() for x in SUPPORTED])], all_files=False, select_only_single_file=True) if not path: return path = path[0] ext = path.rpartition('.')[-1].upper() if ext not in SUPPORTED: return error_dialog( self.gui, _('Unsupported format'), _('Tweaking is only supported for books in the %s formats.' ' Convert your book to one of these formats first.') % _(' and ').join(sorted(SUPPORTED)), show=True) if not os.path.exists(path): return error_dialog(self.gui, _('File not found'), _('The file %s does not exist.') % path, show=True) for name in tuple(editors): self.close_editor(name) self.gui.preview.clear() self.container_count = -1 if self.tdir: shutil.rmtree(self.tdir, ignore_errors=True) self.tdir = PersistentTemporaryDirectory() self._edit_file_on_open = edit_file self._clear_notify_data = clear_notify_data self.gui.blocking_job('open_book', _('Opening book, please wait...'), self.book_opened, get_container, path, tdir=self.mkdtemp())
def __init__(self, pathtoepub, log, clone_data=None, tdir=None): if clone_data is not None: super(EpubContainer, self).__init__(None, None, log, clone_data=clone_data) for x in ('pathtoepub', 'obfuscated_fonts'): setattr(self, x, clone_data[x]) return self.pathtoepub = pathtoepub if tdir is None: tdir = PersistentTemporaryDirectory('_epub_container') tdir = os.path.abspath(os.path.realpath(tdir)) self.root = tdir with open(self.pathtoepub, 'rb') as stream: try: zf = ZipFile(stream) zf.extractall(tdir) except: log.exception('EPUB appears to be invalid ZIP file, trying a' ' more forgiving ZIP parser') from calibre.utils.localunzip import extractall stream.seek(0) extractall(stream) try: os.remove(join(tdir, 'mimetype')) except EnvironmentError: pass container_path = join(self.root, 'META-INF', 'container.xml') if not exists(container_path): raise InvalidEpub('No META-INF/container.xml in epub') container = etree.fromstring(open(container_path, 'rb').read()) opf_files = container.xpath( (r'child::ocf:rootfiles/ocf:rootfile' '[@media-type="%s" and @full-path]' % guess_type('a.opf')), namespaces={'ocf': OCF_NS}) if not opf_files: raise InvalidEpub( 'META-INF/container.xml contains no link to OPF file') opf_path = os.path.join( self.root, *(urlunquote(opf_files[0].get('full-path')).split('/'))) if not exists(opf_path): raise InvalidEpub('OPF file does not exist at location pointed to' ' by META-INF/container.xml') super(EpubContainer, self).__init__(tdir, opf_path, log) self.obfuscated_fonts = {} if 'META-INF/encryption.xml' in self.name_path_map: self.process_encryption() self.parsed_cache['META-INF/container.xml'] = container
def run(self): self.tdir = PersistentTemporaryDirectory('_auto_adder') while self.keep_running: self.wake_up.wait() self.wake_up.clear() if not self.keep_running: break try: self.auto_add() except: import traceback traceback.print_exc()
def queue_files(self): self.tdir = PersistentTemporaryDirectory('_queue_polish') self.jobs = [] if len(self.book_id_map) <= 5: for i, (book_id, formats) in enumerate(self.book_id_map.iteritems()): self.do_book(i+1, book_id, formats) else: self.queue = [(i+1, id_) for i, id_ in enumerate(self.book_id_map)] self.pd = ProgressDialog(_('Queueing books for polishing'), max=len(self.queue), parent=self) QTimer.singleShot(0, self.do_one) self.pd.exec_()
def download_requested(self, download_item): path = download_item.path() fname = os.path.basename(path) download_id = download_item.id() tdir = PersistentTemporaryDirectory() self.download_data[download_id] = download_item path = os.path.join(tdir, fname) download_item.setPath(path) connect_lambda(download_item.downloadProgress, self, lambda self, done, total: self.download_progress(download_id, done, total)) connect_lambda(download_item.finished, self, lambda self: self.download_finished(download_id)) download_item.accept() self.central.download_progress.add_item(download_id, fname)
def get_kindlegen(): # copy kindlegen to destination plugin_path = os.path.join(__file__, "..") plugin_zip = ZipFile(plugin_path) kindlegen_path = PersistentTemporaryDirectory("_kindlegen") if os.name == 'nt': # Windows kindlegen_filename = 'kindlegen.exe' else: # Linux or macOS kindlegen_filename = 'kindlegen' plugin_zip.extract(kindlegen_filename, kindlegen_path) return os.path.join(kindlegen_path, kindlegen_filename)