voussoir/epubfile
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
epubfile/epubfile.py

1703 lines
59 KiB
Python
Raw Normal View History

Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
import copy
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
import functools
import io
Initial commit.
2019-08-04 05:13:27 +00:00
import mimetypes
import os
import re
import tempfile
import urllib.parse
import uuid
import zipfile
import bs4
import tinycss2
Use voussoirkit.getpermission.
2020-03-07 21:52:29 +00:00
from voussoirkit import getpermission
Initial commit.
2019-08-04 05:13:27 +00:00
from voussoirkit import pathclass
HTML_LINK_PROPERTIES = {
'a': ['href'],
'audio': ['src'],
'image': ['href', 'xlink:href'],
'img': ['src'],
'link': ['href'],
'script': ['src'],
'source': ['src'],
'track': ['src'],
'video': ['src', 'poster'],
}
EXTENSION_MIMETYPES = {
Add .htm to the mimetype fixer dict.
2019-08-07 06:36:13 +00:00
'htm': 'application/xhtml+xml',
Alphabetize the extension mimetypes and mime directories.
2019-09-06 23:25:57 +00:00
'html': 'application/xhtml+xml',
'otf': 'font/otf',
'pls': 'application/pls+xml',
Initial commit.
2019-08-04 05:13:27 +00:00
'smi': 'application/smil+xml',
'smil': 'application/smil+xml',
'sml': 'application/smil+xml',
Use font/ mimes instead of application/font-
2019-08-19 02:55:05 +00:00
'ttf': 'font/ttf',
'woff': 'font/woff',
Initial commit.
2019-08-04 05:13:27 +00:00
'woff2': 'font/woff2',
Alphabetize the extension mimetypes and mime directories.
2019-09-06 23:25:57 +00:00
'xhtml': 'application/xhtml+xml',
Recognize mimetype for xpgt.
2019-09-06 23:26:16 +00:00
'xpgt': 'application/vnd.adobe-page-template+xml',
Initial commit.
2019-08-04 05:13:27 +00:00
}
MIMETYPE_DIRECTORIES = {
'application/font-sfnt': 'Fonts',
Alphabetize the extension mimetypes and mime directories.
2019-09-06 23:25:57 +00:00
'application/x-dtbncx+xml': '.',
Recognize directory for application/x-font-ttf.
2019-09-06 22:36:51 +00:00
'application/x-font-ttf': 'Fonts',
Initial commit.
2019-08-04 05:13:27 +00:00
'application/xhtml+xml': 'Text',
Alphabetize the extension mimetypes and mime directories.
2019-09-06 23:25:57 +00:00
'audio': 'Audio',
Initial commit.
2019-08-04 05:13:27 +00:00
'font': 'Fonts',
'image': 'Images',
'text/css': 'Styles',
'video': 'Video',
}
MIMETYPE_FILE_TEMPLATE = 'application/epub+zip'
CONTAINER_XML_TEMPLATE = '''
<?xml version="1.0" encoding="UTF-8"?>
<container version="1.0" xmlns="urn:oasis:names:tc:opendocument:xmlns:container">
<rootfiles>
<rootfile full-path="OEBPS/content.opf" media-type="application/oebps-package+xml"/>
</rootfiles>
</container>
'''.strip()
OPF_TEMPLATE = '''
<?xml version="1.0" encoding="utf-8"?>
<package version="3.0" unique-identifier="BookId" xmlns="http://www.idpf.org/2007/opf">
<metadata xmlns:dc="http://purl.org/dc/elements/1.1/">
<dc:identifier id="BookId">{uuid}</dc:identifier>
<dc:creator id="cre">author</dc:creator>
<meta scheme="marc:relators" refines="#cre" property="role">aut</meta>
<dc:title>title</dc:title>
Set default book language to be undetermined (und). Per rfc5646, omitting is preferred where permitted, but in Epub that's not permitted!
2019-08-06 00:54:37 +00:00
<dc:language>und</dc:language>
Initial commit.
2019-08-04 05:13:27 +00:00
</metadata>
<manifest>
<item id="ncx" href="toc.ncx" media-type="application/x-dtbncx+xml"/>
<item id="nav.xhtml" href="Text/nav.xhtml" media-type="application/xhtml+xml" properties="nav"/>
</manifest>
<spine toc="ncx">
<itemref idref="nav.xhtml" linear="no"/>
</spine>
</package>
'''.strip()
NCX_TEMPLATE = '''
<?xml version="1.0" encoding="utf-8"?>
<ncx xmlns="http://www.daisy.org/z3986/2005/ncx/" version="2005-1">
<head>
<meta name="dtb:uid" content="{uuid}" />
</head>
<docTitle>
Add more formatters into NCX_TEMPLATE, NAV_TEMPLATE.
2019-08-29 23:34:54 +00:00
<text>{title}</text>
Initial commit.
2019-08-04 05:13:27 +00:00
</docTitle>
<navMap>
Add more formatters into NCX_TEMPLATE, NAV_TEMPLATE.
2019-08-29 23:34:54 +00:00
{navpoints}
Initial commit.
2019-08-04 05:13:27 +00:00
</navMap>
</ncx>
'''.strip()
NAV_XHTML_TEMPLATE = '''
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:epub="http://www.idpf.org/2007/ops">
<head>
<meta charset="utf-8"/>
</head>
<body epub:type="frontmatter">
<nav epub:type="toc" id="toc">
<h1>Table of Contents</h1>
Add more formatters into NCX_TEMPLATE, NAV_TEMPLATE.
2019-08-29 23:34:54 +00:00
{toc_contents}
Initial commit.
2019-08-04 05:13:27 +00:00
</nav>
</body>
</html>
'''.strip()
TEXT_TEMPLATE = '''
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:epub="http://www.idpf.org/2007/ops">
<head>
{head_content}
</head>
<body>
{body_content}
</body>
</html>
'''.strip()
Add these ### headers above the helper functions. I'm trying to decide if I should create function classes to hold these things, but for now these headers will do.
2020-01-21 01:56:21 +00:00
# EPUB COMPRESSION
################################################################################
Initial commit.
2019-08-04 05:13:27 +00:00
def compress_epub(directory, epub_filepath):
directory = pathclass.Path(directory)
epub_filepath = pathclass.Path(epub_filepath)
if epub_filepath in directory:
raise ValueError('Epub inside its own directory')
if epub_filepath.extension != 'epub':
epub_filepath = epub_filepath.add_extension('epub')
with zipfile.ZipFile(epub_filepath.absolute_path, 'w') as z:
z.write(directory.with_child('mimetype').absolute_path, arcname='mimetype')
for file in directory.walk():
if file in [directory.with_child('mimetype'), directory.with_child('sigil.cfg')]:
continue
z.write(
file.absolute_path,
arcname=file.relative_to(directory),
compress_type=zipfile.ZIP_DEFLATED,
)
return epub_filepath
def extract_epub(epub_filepath, directory):
epub_filepath = pathclass.Path(epub_filepath)
directory = pathclass.Path(directory)
with zipfile.ZipFile(epub_filepath.absolute_path, 'r') as z:
z.extractall(directory.absolute_path)
Add these ### headers above the helper functions. I'm trying to decide if I should create function classes to hold these things, but for now these headers will do.
2020-01-21 01:56:21 +00:00
# XHTML TOOLS
################################################################################
Initial commit.
2019-08-04 05:13:27 +00:00
def fix_xhtml(xhtml, return_soup=False):
if isinstance(xhtml, bs4.BeautifulSoup):
soup = xhtml
else:
# For the text pages, html5lib is the best because html.parser and lxml
# lowercase all attributes, breaking svg's case-sensitive viewBox etc.
# and xml loses all of the namespaces when namespaced elements are nested
# like <html xmlns="..."><svg xmlns:xlink="..."></svg></html>.
# The downside of html5lib is it turns the xml declaration at the top
# into a comment which we must undo manually.
soup = bs4.BeautifulSoup(xhtml, 'html5lib')
if not soup.html:
html = soup.new_tag('html')
for child in list(soup.contents):
html.append(child)
soup.append(html)
if not soup.html.body:
body = soup.new_tag('body')
for child in list(soup.html.contents):
body.append(child)
soup.html.append(body)
if not soup.html.get('xmlns'):
soup.html['xmlns'] = 'http://www.w3.org/1999/xhtml'
try:
doctype = next(i for i in soup.contents if isinstance(i, bs4.Doctype))
except StopIteration:
doctype = bs4.Doctype('html')
soup.html.insert_before(doctype)
# html5lib turns the xml declaration into a comment which we must revert.
try:
if isinstance(soup.contents[0], bs4.Comment):
declaration = bs4.Declaration('xml version="1.0" encoding="utf-8"')
soup.insert(0, declaration)
declaration.next.extract()
except StopIteration:
pass
try:
declaration = next(i for i in soup.contents if isinstance(i, bs4.Declaration))
except StopIteration:
declaration = bs4.Declaration('xml version="1.0" encoding="utf-8"')
doctype.insert_before(declaration)
if return_soup:
return soup
return str(soup)
Add function promote_xhtml_headers. Isn't used anywhere yet but may as well have it to balance out.
2020-01-21 01:55:49 +00:00
def xhtml_replacements(xhtml, replacements, return_soup=False):
if isinstance(xhtml, bs4.BeautifulSoup):
xhtml = str(xhtml)
for (re_from, re_to) in replacements:
xhtml = re.sub(re_from, re_to, xhtml, flags=re.DOTALL)
if return_soup:
soup = bs4.BeautifulSoup(xhtml, 'html5lib')
return soup
return xhtml
def demote_xhtml_headers(xhtml, return_soup=False):
replacements = [
(r'<h5([^>]*?>.*?)</h5>', r'<h6\1</h6>'),
(r'<h4([^>]*?>.*?)</h4>', r'<h5\1</h5>'),
(r'<h3([^>]*?>.*?)</h3>', r'<h4\1</h4>'),
(r'<h2([^>]*?>.*?)</h2>', r'<h3\1</h3>'),
(r'<h1([^>]*?>.*?)</h1>', r'<h2\1</h2>'),
]
return xhtml_replacements(xhtml, replacements, return_soup=return_soup)
def promote_xhtml_headers(xhtml, return_soup=False):
replacements = [
(r'<h2([^>]*?>.*?)</h2>', r'<h1\1</h1>'),
(r'<h3([^>]*?>.*?)</h3>', r'<h2\1</h2>'),
(r'<h4([^>]*?>.*?)</h4>', r'<h3\1</h3>'),
(r'<h5([^>]*?>.*?)</h5>', r'<h4\1</h4>'),
(r'<h6([^>]*?>.*?)</h6>', r'<h5\1</h5>'),
]
return xhtml_replacements(xhtml, replacements, return_soup=return_soup)
Add these ### headers above the helper functions. I'm trying to decide if I should create function classes to hold these things, but for now these headers will do.
2020-01-21 01:56:21 +00:00
# MIMETYPE DECISIONMAKERS
################################################################################
Initial commit.
2019-08-04 05:13:27 +00:00
def get_directory_for_mimetype(mime):
directory = (
MIMETYPE_DIRECTORIES.get(mime) or
MIMETYPE_DIRECTORIES.get(mime.split('/')[0]) or
'Misc'
)
return directory
def get_mimetype_for_basename(basename):
extension = os.path.splitext(basename)[1].strip('.')
mime = (
EXTENSION_MIMETYPES.get(extension) or
mimetypes.guess_type(basename)[0] or
'application/octet-stream'
)
return mime
Add these ### headers above the helper functions. I'm trying to decide if I should create function classes to hold these things, but for now these headers will do.
2020-01-21 01:56:21 +00:00
# OPF ELEMENT GENERATORS
################################################################################
Initial commit.
2019-08-04 05:13:27 +00:00
def make_manifest_item(id, href, mime):
manifest_item = f'<item id="{id}" href="{href}" media-type="{mime}"/>'
# 'html.parser' just for having the simplest output.
manifest_item = bs4.BeautifulSoup(manifest_item, 'html.parser')
return manifest_item.item
def make_meta_item(content=None, attrs=None):
if content:
meta_item = f'<meta>{content}</meta>'
else:
meta_item = f'<meta/>'
Add, improve some comments, docstrings, exception texts.
2020-01-21 01:32:47 +00:00
# 'html.parser' just for having the simplest output.
Initial commit.
2019-08-04 05:13:27 +00:00
meta_item = bs4.BeautifulSoup(meta_item, 'html.parser')
if attrs:
meta_item.attrs.update(attrs)
return meta_item.meta
def make_spine_item(id):
spine_item = f'<itemref idref="{id}"/>'
# 'html.parser' just for having the simplest output.
spine_item = bs4.BeautifulSoup(spine_item, 'html.parser')
return spine_item.itemref
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
# DECORATORS
################################################################################
def writes(method):
@functools.wraps(method)
def wrapped_method(self, *args, **kwargs):
if self.read_only:
raise ReadOnly(method.__qualname__)
return method(self, *args, **kwargs)
return wrapped_method
# CLASSES
################################################################################
Initial commit.
2019-08-04 05:13:27 +00:00
class EpubfileException(Exception):
error_message = ''
def __init__(self, *args, **kwargs):
super().__init__()
self.given_args = args
self.given_kwargs = kwargs
self.error_message = self.error_message.format(*args, **kwargs)
self.args = (self.error_message, args, kwargs)
def __str__(self):
return self.error_message
Add some prototypical validation code.
2019-09-06 22:44:28 +00:00
class InvalidEpub(EpubfileException):
error_message = '{} is invalid: {}'
Initial commit.
2019-08-04 05:13:27 +00:00
class FileExists(EpubfileException):
error_message = 'There is already a file at {}.'
class IDExists(EpubfileException):
error_message = 'There is already a file with id {}.'
class NotInManifest(EpubfileException):
error_message = '{} is not in the manifest.'
class NotInSpine(EpubfileException):
error_message = '{} is not in the spine.'
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
class ReadOnly(EpubfileException):
error_message = 'Can\'t do {} in read-only mode.'
Initial commit.
2019-08-04 05:13:27 +00:00
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
class Epub:
def __init__(self, epub_path, *, read_only=False):
'''
epub_path:
The path to an .epub file, or to a directory that contains unzipped
epub contents.
read_only:
If True, all write operations will be forbidden. The benefit is that
the .epub file will not be extracted. This is recommended if you
only need to read data from a book and don't need to write to it.
'''
epub_path = self._keep_tempdir_reference(epub_path)
epub_path = pathclass.Path(epub_path)
self.original_path = epub_path
self.read_only = read_only
if epub_path.is_dir:
self.__init_from_dir(epub_path)
elif self.read_only:
self.__init_from_file_read_only(epub_path)
else:
self.__init_from_file(epub_path)
Add argument _original_epub_filepath for better messaging later. Printing the tempdir is not very helpful, so if we need to print something about this epub file we can use _original_path to get the epub if it was a .open() or the tempdir if it was .new().
2019-09-06 22:38:51 +00:00
Assign opf, opf_filepath normally instead of mutating in method.
2020-01-21 01:34:51 +00:00
opfs = self.get_opfs()
self.opf_filepath = opfs[0]
self.opf = self.read_opf(self.opf_filepath)
Initial commit.
2019-08-04 05:13:27 +00:00
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
def __init_from_dir(self, directory):
self.is_zip = False
self.root_directory = pathclass.Path(directory)
def __init_from_file_read_only(self, epub_path):
# It may appear that is_zip is a synonym for read_only, but don't forget
# that we can also open a directory in readonly mode. It's just that
# readonly dirs don't need a special init, all they have to do is
# forbid writes.
self.is_zip = True
self.root_directory = pathclass.Path(epub_path)
self.zip = zipfile.ZipFile(self.root_directory.absolute_path)
def __init_from_file(self, epub_path):
extract_to = tempfile.TemporaryDirectory(prefix='epubfile-')
extract_epub(epub_path, extract_to.name)
directory = self._keep_tempdir_reference(extract_to)
self.__init_from_dir(directory)
Initial commit.
2019-08-04 05:13:27 +00:00
def __repr__(self):
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
if self.read_only:
return f'Epub({repr(self.root_directory.absolute_path)}, read_only=True)'
else:
return f'Epub({repr(self.root_directory.absolute_path)})'
def _fopen(self, *args, **kwargs):
'''
Not to be confused with the high level `open_file` method, this method
is the one that actually reads off the disk.
'''
if self.is_zip:
return self._fopen_zip(*args, **kwargs)
else:
return self._fopen_disk(*args, **kwargs)
def _fopen_disk(self, path, mode, *, encoding=None):
'''
If the book was opened as a directory, we can read files off disk with
Python open.
'''
return open(path, mode, encoding=encoding)
def _fopen_zip(self, path, mode, *, encoding=None):
'''
If the book was opened as a read-only zip, we can read files out of
the zip.
'''
p_path = self.root_directory.spawn(path)
if p_path in self.root_directory:
path = p_path.relative_to(self.root_directory, simple=True)
# Zip files always use forward slash internally, even on Windows.
path = path.replace('\\', '/')
if mode == 'rb':
return self.zip.open(path, 'r')
if mode == 'r':
return io.TextIOWrapper(self.zip.open(path, 'r'), encoding)
# At this time ZipFS is only used for read-only epubs anyway.
if mode == 'wb':
return self.zip.open(path, 'w')
if mode == 'w':
return io.TextIOWrapper(self.zip.open(path, 'w'), encoding)
raise ValueError('mode should be r, w, rb, or wb.')
def _keep_tempdir_reference(self, p):
'''
If the given path object is actually a tempfile.TemporaryDirectory,
store that TD reference here so that it does not get cleaned up even
if the caller releases it. Then return the actual filepath.
'''
if isinstance(p, tempfile.TemporaryDirectory):
self._tempdir_reference = p
p = p.name
return p
Initial commit.
2019-08-04 05:13:27 +00:00
def assert_file_not_exists(self, filepath):
if filepath.exists:
existing = filepath.relative_to(self.opf_filepath.parent)
raise FileExists(existing)
Add method assert_id_not_exists for pre-creation checks. At the moment it's only used once but it looks nice to have it paired with the other assert also used in the add_file method.
2019-08-07 06:37:14 +00:00
def assert_id_not_exists(self, id):
if self.opf.manifest.find('item', {'id': id}):
raise IDExists(id)
Add some prototypical validation code.
2019-09-06 22:44:28 +00:00
# VALIDATION
############################################################################
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Add some prototypical validation code.
2019-09-06 22:44:28 +00:00
def auto_correct_and_validate(self):
# Ensure we have a mimetype file.
mimetype_file = self.root_directory.with_child('mimetype')
if not mimetype_file.exists:
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
with self._fopen(mimetype_file.absolute_path, 'w', encoding='utf-8') as handle:
Add some prototypical validation code.
2019-09-06 22:44:28 +00:00
handle.write(MIMETYPE_FILE_TEMPLATE)
# Assert that all manifest items exist on disk.
for item in self.get_manifest_items(soup=True):
filepath = self.get_filepath(item['id'])
if not filepath.exists:
Split this line up for length reasons.
2020-02-03 03:36:57 +00:00
message = f'Manifest item {item["id"]} = {item["href"]} does not exist.'
raise InvalidEpub(self.original_path, message)
Add some prototypical validation code.
2019-09-06 22:44:28 +00:00
Initial commit.
2019-08-04 05:13:27 +00:00
# LOADING AND SAVING
############################################################################
@classmethod
def new(cls):
Improve some docstrings and comments.
2020-03-08 00:36:32 +00:00
'''
Create a new book. It will start as a temporary directory, so don't
forget to call `save` when you are done.
'''
Initial commit.
2019-08-04 05:13:27 +00:00
def writefile(filepath, content):
os.makedirs(filepath.parent.absolute_path, exist_ok=True)
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
# This line uses Python open instead of self._fopen because the epub
# hasn't been instantiated yet! At this time, creating a book with
# Epub.new always creates it as a directory. We do not support
# creating a book directly into a fresh zip file.
Initial commit.
2019-08-04 05:13:27 +00:00
with open(filepath.absolute_path, 'w', encoding='utf-8') as handle:
handle.write(content)
uid = uuid.uuid4().urn
tempdir = tempfile.TemporaryDirectory(prefix='epubfile-')
root = pathclass.Path(tempdir.name)
writefile(root.join('mimetype'), MIMETYPE_FILE_TEMPLATE)
writefile(root.join('META-INF/container.xml'), CONTAINER_XML_TEMPLATE)
writefile(root.join('OEBPS/content.opf'), OPF_TEMPLATE.format(uuid=uid))
Add more formatters into NCX_TEMPLATE, NAV_TEMPLATE.
2019-08-29 23:34:54 +00:00
writefile(root.join('OEBPS/toc.ncx'), NCX_TEMPLATE.format(uuid=uid, title='Unknown', navpoints=''))
writefile(root.join('OEBPS/Text/nav.xhtml'), NAV_XHTML_TEMPLATE.format(toc_contents=''))
Initial commit.
2019-08-04 05:13:27 +00:00
return cls(tempdir)
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Initial commit.
2019-08-04 05:13:27 +00:00
def save(self, epub_filepath):
self.write_opf()
Add some prototypical validation code.
2019-09-06 22:44:28 +00:00
self.auto_correct_and_validate()
Initial commit.
2019-08-04 05:13:27 +00:00
compress_epub(self.root_directory, epub_filepath)
# CONTAINER & OPF
############################################################################
def get_opfs(self):
Improve some docstrings and comments.
2020-03-08 00:36:32 +00:00
'''
Read the container.xml to find all available OPFs (aka rootfiles).
'''
Initial commit.
2019-08-04 05:13:27 +00:00
container = self.read_container_xml()
rootfiles = container.find_all('rootfile')
rootfiles = [x.get('full-path') for x in rootfiles]
rootfiles = [self.root_directory.join(x) for x in rootfiles]
return rootfiles
def read_container_xml(self):
container_xml_path = self.root_directory.join('META-INF/container.xml')
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
container = self._fopen(container_xml_path.absolute_path, 'r', encoding='utf-8')
Add, improve some comments, docstrings, exception texts.
2020-01-21 01:32:47 +00:00
# 'xml' and 'html.parser' seem about even here except that html.parser
# doesn't self-close.
Initial commit.
2019-08-04 05:13:27 +00:00
container = bs4.BeautifulSoup(container, 'xml')
return container
def read_opf(self, rootfile):
rootfile = pathclass.Path(rootfile, force_sep='/')
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
rootfile_xml = self._fopen(rootfile.absolute_path, 'r', encoding='utf-8').read()
Initial commit.
2019-08-04 05:13:27 +00:00
# 'html.parser' preserves namespacing the best, but unfortunately it
# botches the <meta> items because it wants them to be self-closing
# and the string contents come out. We will fix in just a moment.
# This is still preferable to 'xml' which handles the dc: prefixes when
# parsing only the metadata block, but loses all namespaces when parsing
# the whole doc. 'lxml' wraps the content in <html><body> and also
# botches the metas so it's not any better than html.parser.
Assign opf, opf_filepath normally instead of mutating in method.
2020-01-21 01:34:51 +00:00
opf = bs4.BeautifulSoup(rootfile_xml, 'html.parser')
Add, improve some comments, docstrings, exception texts.
2020-01-21 01:32:47 +00:00
Initial commit.
2019-08-04 05:13:27 +00:00
# Let's fix those metas.
Assign opf, opf_filepath normally instead of mutating in method.
2020-01-21 01:34:51 +00:00
metas = opf.select('meta')
Initial commit.
2019-08-04 05:13:27 +00:00
for meta in metas:
neighbor = meta.next
if neighbor.parent != meta.parent:
Add, improve some comments, docstrings, exception texts.
2020-01-21 01:32:47 +00:00
# This happens on the last meta, neighbor is outside of the manifest
Initial commit.
2019-08-04 05:13:27 +00:00
break
if not isinstance(neighbor, bs4.element.NavigableString):
continue
meta.append(neighbor.extract().strip())
Assign opf, opf_filepath normally instead of mutating in method.
2020-01-21 01:34:51 +00:00
return opf
Initial commit.
2019-08-04 05:13:27 +00:00
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Initial commit.
2019-08-04 05:13:27 +00:00
def write_container_xml(self, container):
if isinstance(container, bs4.BeautifulSoup):
container = str(container)
container_xml_path = self.root_directory.join('META-INF/container.xml')
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
container_xml = self._fopen(container_xml_path.absolute_path, 'w', encoding='utf-8')
Initial commit.
2019-08-04 05:13:27 +00:00
container_xml.write(container)
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Initial commit.
2019-08-04 05:13:27 +00:00
def write_opf(self):
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
with self._fopen(self.opf_filepath.absolute_path, 'w', encoding='utf-8') as rootfile:
Initial commit.
2019-08-04 05:13:27 +00:00
rootfile.write(str(self.opf))
# FILE OPERATIONS
############################################################################
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Initial commit.
2019-08-04 05:13:27 +00:00
def add_file(self, id, basename, content):
Add method assert_id_not_exists for pre-creation checks. At the moment it's only used once but it looks nice to have it paired with the other assert also used in the add_file method.
2019-08-07 06:37:14 +00:00
self.assert_id_not_exists(id)
Initial commit.
2019-08-04 05:13:27 +00:00
basename = os.path.basename(basename)
mime = get_mimetype_for_basename(basename)
directory = get_directory_for_mimetype(mime)
directory = self.opf_filepath.parent.with_child(directory)
os.makedirs(directory.absolute_path, exist_ok=True)
filepath = directory.with_child(basename)
self.assert_file_not_exists(filepath)
if mime == 'application/xhtml+xml':
# bs4 converts bytes to str so this must come before the handle choice.
content = fix_xhtml(content)
if isinstance(content, str):
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
handle = self._fopen(filepath.absolute_path, 'w', encoding='utf-8')
Initial commit.
2019-08-04 05:13:27 +00:00
elif isinstance(content, bytes):
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
handle = self._fopen(filepath.absolute_path, 'wb')
Initial commit.
2019-08-04 05:13:27 +00:00
else:
Add, improve some comments, docstrings, exception texts.
2020-01-21 01:32:47 +00:00
raise TypeError(f'content should be str or bytes, not {type(content)}.')
Initial commit.
2019-08-04 05:13:27 +00:00
with handle:
handle.write(content)
href = filepath.relative_to(self.opf_filepath.parent, simple=True)
href = urllib.parse.quote(href)
manifest_item = make_manifest_item(id, href, mime)
self.opf.manifest.append(manifest_item)
if mime == 'application/xhtml+xml':
spine_item = make_spine_item(id)
self.opf.spine.append(spine_item)
return id
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Initial commit.
2019-08-04 05:13:27 +00:00
def easy_add_file(self, filepath):
Improve some docstrings and comments.
2020-03-08 00:36:32 +00:00
'''
Add a file from disk into the book. The manifest ID and href will be
automatically generated.
'''
Initial commit.
2019-08-04 05:13:27 +00:00
filepath = pathclass.Path(filepath)
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
with self._fopen(filepath.absolute_path, 'rb') as handle:
Initial commit.
2019-08-04 05:13:27 +00:00
self.add_file(
id=filepath.basename,
basename=filepath.basename,
content=handle.read(),
)
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Initial commit.
2019-08-04 05:13:27 +00:00
def delete_file(self, id):
Rearrange the lines in delete_file. If anything is going to raise an exception here I expect it to be the item missing from the manifest. In which case let's get that out of the way early and only delete from disk at the very end.
2020-01-21 01:33:58 +00:00
manifest_item = self.opf.manifest.find('item', {'id': id})
manifest_item.extract()
Initial commit.
2019-08-04 05:13:27 +00:00
spine_item = self.opf.spine.find('itemref', {'idref': id})
if spine_item:
spine_item.extract()
Rearrange the lines in delete_file. If anything is going to raise an exception here I expect it to be the item missing from the manifest. In which case let's get that out of the way early and only delete from disk at the very end.
2020-01-21 01:33:58 +00:00
os.remove(self.get_filepath(id).absolute_path)
Initial commit.
2019-08-04 05:13:27 +00:00
def get_filepath(self, id):
href = self.opf.manifest.find('item', {'id': id})['href']
filepath = self.opf_filepath.parent.join(href)
Improve some docstrings and comments.
2020-03-08 00:36:32 +00:00
# TODO: In the case of a read-only zipped epub, this condition will
# definitely fail and we won't be unquoting names that need it.
# Double-check the consequences of this and make a patch for file
# exists inside zip check if needed.
Initial commit.
2019-08-04 05:13:27 +00:00
if not filepath.exists:
href = urllib.parse.unquote(href)
filepath = self.opf_filepath.parent.join(href)
return filepath
def open_file(self, id, mode):
if mode not in ('r', 'w'):
Add, improve some comments, docstrings, exception texts.
2020-01-21 01:32:47 +00:00
raise ValueError(f'mode should be either r or w, not {mode}.')
Initial commit.
2019-08-04 05:13:27 +00:00
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
if mode == 'w' and self.read_only:
raise ReadOnly(self.open_file.__qualname__)
Initial commit.
2019-08-04 05:13:27 +00:00
filepath = self.get_filepath(id)
mime = self.opf.manifest.find('item', {'id': id})['media-type']
is_text = (
mime in ('application/xhtml+xml', 'application/x-dtbncx+xml') or
mime.startswith('text/')
)
if is_text:
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
handle = self._fopen(filepath.absolute_path, mode, encoding='utf-8')
Initial commit.
2019-08-04 05:13:27 +00:00
else:
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
handle = self._fopen(filepath.absolute_path, mode + 'b')
Initial commit.
2019-08-04 05:13:27 +00:00
return handle
def read_file(self, id, *, soup=False):
# text vs binary handled by open_file.
content = self.open_file(id, 'r').read()
if soup and self.get_manifest_item(id)['media-type'] == 'application/xhtml+xml':
return fix_xhtml(content, return_soup=True)
return content
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Initial commit.
2019-08-04 05:13:27 +00:00
def rename_file(self, id, new_basename=None, *, fix_interlinking=True):
if isinstance(id, dict):
basename_map = id
else:
if new_basename is None:
raise TypeError('new_basename can be omitted if id is a dict.')
basename_map = {id: new_basename}
rename_map = {}
for (id, new_basename) in basename_map.items():
old_filepath = self.get_filepath(id)
new_filepath = old_filepath.parent.with_child(new_basename)
if not new_filepath.extension:
new_filepath = new_filepath.add_extension(old_filepath.extension)
self.assert_file_not_exists(new_filepath)
os.rename(old_filepath.absolute_path, new_filepath.absolute_path)
rename_map[old_filepath] = new_filepath
if fix_interlinking:
self.fix_interlinking(rename_map)
else:
self.fix_interlinking_opf(rename_map)
return rename_map
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Initial commit.
2019-08-04 05:13:27 +00:00
def write_file(self, id, content):
# text vs binary handled by open_file.
if isinstance(content, bs4.BeautifulSoup):
content = str(content)
with self.open_file(id, 'w') as handle:
handle.write(content)
# GETTING THINGS
############################################################################
def get_manifest_items(self, filter='', soup=False, spine_order=False):
query = f'item{filter}'
items = self.opf.manifest.select(query)
if spine_order:
items = {x['id']: x for x in items}
ordered_items = []
for spine_id in self.get_spine_order():
ordered_items.append(items.pop(spine_id))
ordered_items.extend(items.values())
items = ordered_items
if soup:
return items
return [x['id'] for x in items]
def get_manifest_item(self, id):
item = self.opf.manifest.find('item', {'id': id})
if not item:
raise NotInManifest(id)
return item
def get_fonts(self, *, soup=False):
return self.get_manifest_items(
filter='[media-type^="application/font"],[media-type^="font/"]',
soup=soup,
)
def get_images(self, *, soup=False):
return self.get_manifest_items(
filter='[media-type^="image/"]',
soup=soup,
)
def get_media(self, *, soup=False):
return self.get_manifest_items(
filter='[media-type^="video/"],[media-type^="audio/"]',
soup=soup,
)
def get_nav(self, *, soup=False):
nav = self.opf.manifest.find('item', {'properties': 'nav'})
if not nav:
return None
if soup:
return nav
return nav['id']
def get_ncx(self, *, soup=False):
ncx = self.opf.manifest.find('item', {'media-type': 'application/x-dtbncx+xml'})
if not ncx:
return None
if soup:
return ncx
return ncx['id']
def get_styles(self, *, soup=False):
return self.get_manifest_items(
filter='[media-type="text/css"]',
soup=soup,
)
def get_texts(self, *, soup=False, skip_nav=False):
texts = self.get_manifest_items(
filter='[media-type="application/xhtml+xml"]',
soup=True,
spine_order=True,
)
if skip_nav:
texts = [x for x in texts if x.get('properties') != 'nav']
if soup:
return texts
return [x['id'] for x in texts]
# COVER
############################################################################
def get_cover_image(self, *, soup=False):
cover = self.opf.manifest.find('item', {'properties': 'cover-image'})
if cover:
return cover if soup else cover['id']
cover = self.opf.metadata.find('meta', {'name': 'cover'})
if cover:
return cover if soup else cover['content']
return None
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Initial commit.
2019-08-04 05:13:27 +00:00
def remove_cover_image(self):
current_cover = self.get_cover_image(soup=True)
if not current_cover:
return
del current_cover['properties']
meta = self.opf.metadata.find('meta', {'name': 'cover'})
if meta:
meta.extract()
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Initial commit.
2019-08-04 05:13:27 +00:00
def set_cover_image(self, id):
if id is None:
self.remove_cover_image()
current_cover = self.get_cover_image(soup=True)
if not current_cover:
pass
elif current_cover['id'] == id:
return
else:
del current_cover['properties']
manifest_item = self.get_manifest_item(id)
manifest_item['properties'] = 'cover-image'
current_meta = self.opf.metadata.find('meta', {'name': 'cover'})
if current_meta:
current_meta[content] = id
else:
meta = make_meta_item(attrs={'name': 'cover', 'content': id})
self.opf.metadata.append(meta)
# SPINE
############################################################################
Rename argument only_linear to linear_only.
2019-08-29 20:45:33 +00:00
def get_spine_order(self, *, linear_only=False):
Initial commit.
2019-08-04 05:13:27 +00:00
items = self.opf.spine.find_all('itemref')
Rename argument only_linear to linear_only.
2019-08-29 20:45:33 +00:00
if linear_only:
Initial commit.
2019-08-04 05:13:27 +00:00
items = [x for x in items if x.get('linear') != 'no']
return [x['idref'] for x in items]
return ids
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Initial commit.
2019-08-04 05:13:27 +00:00
def set_spine_order(self, ids):
manifest_ids = self.get_manifest_items()
# Fetch the existing entries so that we can preserve their attributes
# while rearranging, only creating new spine entries for ids that aren't
# already present.
spine_items = self.opf.spine.select('itemref')
spine_items = {item['idref']: item for item in spine_items}
for id in ids:
if id not in manifest_ids:
raise NotInManifest(id)
if id in spine_items:
self.opf.spine.append(spine_items.pop(id))
else:
self.opf.spine.append(make_spine_item(id))
# The remainder of the current spine items were not used, so pop them out.
for spine_item in spine_items.values():
spine_item.extract()
def get_spine_linear(self, id):
spine_item = self.opf.spine.find('itemref', {'idref': id})
if not spine_item:
raise NotInSpine(id)
linear = spine_item.get('linear')
linear = {None: None, 'yes': True, 'no': False}.get(linear, linear)
return linear
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Initial commit.
2019-08-04 05:13:27 +00:00
def set_spine_linear(self, id, linear):
'''
Set linear to yes or no. Or pass None to remove the property.
'''
spine_item = self.opf.spine.find('itemref', {'idref': id})
if not spine_item:
raise NotInSpine(id)
if linear is None:
del spine_item['linear']
return
if isinstance(linear, str):
if linear not in ('yes', 'no'):
raise ValueError(f'Linear must be yes or no, not {linear}.')
elif isinstance(linear, (bool, int)):
linear = {True: 'yes', False: 'no'}[bool(linear)]
else:
raise TypeError(linear)
spine_item['linear'] = linear
Add some simple getters for authors, languages, and titles.
2019-08-07 06:39:39 +00:00
# METADATA
############################################################################
def get_authors(self):
'''
Thank you double_j for showing how to deal with find_all not working
on namespaced tags.
https://stackoverflow.com/a/44681560
'''
creators = self.opf.metadata.find_all({'dc:creator'})
creators = [str(c.contents[0]) for c in creators if len(c.contents) == 1]
return creators
def get_languages(self):
languages = self.opf.metadata.find_all({'dc:language'})
languages = [str(l.contents[0]) for l in languages if len(l.contents) == 1]
return languages
def get_titles(self):
titles = self.opf.metadata.find_all({'dc:title'})
titles = [str(t.contents[0]) for t in titles if len(t.contents) == 1]
return titles
Add a few metadata methods, just proof-of-concept for now. I know I don't want to create a full-blown metadata editor, but a couple methods for basic metadata types and simple adds/removes could be useful.
2020-03-08 00:37:39 +00:00
@writes
def remove_metadata_of_type(self, tag_name):
for meta in self.opf.metadata.find_all({tag_name}):
if meta.get('id'):
for refines in self.opf.metadata.find_all('meta', {'refines': f'#{meta["id"]}'}):
refines.extract()
meta.extract()
@writes
def set_languages(self, languages):
'''
A list like ['en', 'fr', 'ko'].
'''
self.remove_metadata_of_type('dc:language')
for language in languages:
element = f'<dc:language>{language}</dc:language>'
element = bs4.BeautifulSoup(element, 'html.parser')
self.opf.metadata.append(element)
Initial commit.
2019-08-04 05:13:27 +00:00
# UTILITIES
############################################################################
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Initial commit.
2019-08-04 05:13:27 +00:00
def fix_all_xhtml(self):
for id in self.get_texts():
self.write_file(id, self.read_file(id, soup=True))
@staticmethod
def _fix_interlinking_helper(link, rename_map, relative_to, old_relative_to=None):
Add some docstrings to the interlinking functions.
2019-09-06 23:53:02 +00:00
'''
Given an old link that was found in one of the documents, and the
rename_map, produce a new link that points to the new location.
relative_to controls the relative pathing for the new link.
For example, the links inside a text document usually need to step from
Text/ to ../Images/ to link an image. But the links inside the OPF file
start with Images/ right away.
old_relative_to is needed when, for example, all of the files were in a
single directory together, and now we are splitting them into Text/,
Images/, etc. In this case, recognizing the old link requires that we
understand the old relative location, then we can correct it using the
new relative location.
'''
Initial commit.
2019-08-04 05:13:27 +00:00
if link is None:
return None
link = urllib.parse.urlsplit(link)
if link.scheme:
return None
if old_relative_to is None:
old_relative_to = relative_to
new_filepath = (
rename_map.get(link.path) or
rename_map.get(old_relative_to.join(link.path)) or
rename_map.get(old_relative_to.join(urllib.parse.unquote(link.path))) or
None
)
if new_filepath is None:
return None
link = link._replace(path=new_filepath.relative_to(relative_to, simple=True))
link = link._replace(path=urllib.parse.quote(link.path))
return link.geturl()
@staticmethod
def _fix_interlinking_css_helper(tag):
Add some docstrings to the interlinking functions.
2019-09-06 23:53:02 +00:00
'''
Given a <style> tag or a tag with a style="" attribute, fix interlinking
for things like `background-image: url("");`.
'''
Initial commit.
2019-08-04 05:13:27 +00:00
links = []
commit = lambda: None
if not isinstance(tag, bs4.element.Tag):
pass
elif tag.name == 'style' and tag.contents:
style = tinycss2.parse_stylesheet(tag.contents[0])
links = [
token
for rule in style if isinstance(rule, tinycss2.ast.QualifiedRule)
for token in rule.content if isinstance(token, tinycss2.ast.URLToken)
]
commit = lambda: tag.contents[0].replace_with(tinycss2.serialize(style))
elif tag.get('style'):
style = tinycss2.parse_declaration_list(tag['style'])
links = [
token
for declaration in style if isinstance(declaration, tinycss2.ast.Declaration)
for token in declaration.value if isinstance(token, tinycss2.ast.URLToken)
]
commit = lambda: tag.attrs.update(style=tinycss2.serialize(style))
return (links, commit)
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Initial commit.
2019-08-04 05:13:27 +00:00
def fix_interlinking_text(self, id, rename_map, old_relative_to=None):
Bail early if rename_map is empty.
2019-08-19 05:39:41 +00:00
if not rename_map:
return
Initial commit.
2019-08-04 05:13:27 +00:00
text_parent = self.get_filepath(id).parent
soup = self.read_file(id, soup=True)
for tag in soup.descendants:
for link_property in HTML_LINK_PROPERTIES.get(tag.name, []):
link = tag.get(link_property)
link = self._fix_interlinking_helper(link, rename_map, text_parent, old_relative_to)
if not link:
continue
tag[link_property] = link
(style_links, style_commit) = self._fix_interlinking_css_helper(tag)
for token in style_links:
link = token.value
link = self._fix_interlinking_helper(link, rename_map, text_parent, old_relative_to)
if not link:
continue
token.value = link
style_commit()
text = str(soup)
self.write_file(id, text)
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Initial commit.
2019-08-04 05:13:27 +00:00
def fix_interlinking_ncx(self, rename_map, old_relative_to=None):
Bail early if rename_map is empty.
2019-08-19 05:39:41 +00:00
if not rename_map:
return
Initial commit.
2019-08-04 05:13:27 +00:00
ncx_id = self.get_ncx()
if not ncx_id:
return
ncx_parent = self.get_filepath(ncx_id).parent
ncx = self.read_file(ncx_id)
# 'xml' because 'lxml' and 'html.parser' lowercase the navPoint tag name.
ncx = bs4.BeautifulSoup(ncx, 'xml')
for point in ncx.select('navPoint > content[src]'):
link = point['src']
link = self._fix_interlinking_helper(link, rename_map, ncx_parent, old_relative_to)
if not link:
continue
point['src'] = link
ncx = str(ncx)
self.write_file(ncx_id, ncx)
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Initial commit.
2019-08-04 05:13:27 +00:00
def fix_interlinking_opf(self, rename_map):
Bail early if rename_map is empty.
2019-08-19 05:39:41 +00:00
if not rename_map:
return
Initial commit.
2019-08-04 05:13:27 +00:00
opf_parent = self.opf_filepath.parent
for opf_item in self.opf.select('guide > reference[href], manifest > item[href]'):
link = opf_item['href']
link = self._fix_interlinking_helper(link, rename_map, opf_parent)
if not link:
continue
opf_item['href'] = link
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Initial commit.
2019-08-04 05:13:27 +00:00
def fix_interlinking(self, rename_map):
Bail early if rename_map is empty.
2019-08-19 05:39:41 +00:00
if not rename_map:
return
Initial commit.
2019-08-04 05:13:27 +00:00
self.fix_interlinking_opf(rename_map)
for id in self.get_texts():
self.fix_interlinking_text(id, rename_map)
self.fix_interlinking_ncx(rename_map)
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
def _set_nav_toc(self, nav_id, new_toc):
Add, improve some comments, docstrings, exception texts.
2020-01-21 01:32:47 +00:00
'''
Write the table of contents created by `generate_toc` to the nav file.
'''
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
for li in new_toc.find_all('li'):
href = li['nav_anchor']
atag = new_toc.new_tag('a')
atag.append(li['text'])
atag['href'] = href
li.insert(0, atag)
del li['nav_anchor']
del li['ncx_anchor']
del li['text']
soup = self.read_file(nav_id, soup=True)
toc = soup.find('nav', {'epub:type': 'toc'})
if not toc:
toc = soup.new_tag('nav')
toc['epub:type'] = 'toc'
soup.body.insert(0, toc)
if toc.ol:
toc.ol.extract()
toc.append(new_toc.ol)
self.write_file(nav_id, soup)
def _set_ncx_toc(self, ncx_id, new_toc):
Add, improve some comments, docstrings, exception texts.
2020-01-21 01:32:47 +00:00
'''
Write the table of contents created by `generate_toc` to the ncx file.
'''
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
play_order = 1
def li_to_navpoint(li):
# result:
# <navPoint id="navPoint{X}" playOrder="{X}">
# <navLabel>
# <text>{text}</text>
# </navLabel>
# <content src="{ncx_anchor}" />
# {children}
# </navPoint>
nonlocal play_order
navpoint = new_toc.new_tag('navPoint', id=f'navPoint{play_order}', playOrder=play_order)
play_order += 1
label = new_toc.new_tag('navLabel')
text = new_toc.new_tag('text')
text.append(li['text'])
label.append(text)
navpoint.append(label)
content = new_toc.new_tag('content', src=li['ncx_anchor'])
navpoint.append(content)
children = li.ol.children if li.ol else []
children = [li_to_navpoint(li) for li in children]
for child in children:
navpoint.append(child)
return navpoint
# xml because we have to preserve the casing on navMap.
soup = bs4.BeautifulSoup(self.read_file(ncx_id), 'xml')
navmap = soup.navMap
for child in list(navmap.children):
child.extract()
for li in list(new_toc.ol.children):
navpoint = li_to_navpoint(li)
li.insert_before(navpoint)
li.extract()
for navpoint in list(new_toc.ol.children):
navmap.append(navpoint)
self.write_file(ncx_id, soup)
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
def generate_toc(self, max_level=None, linear_only=True):
'''
Generate the table of contents (toc.nav and nav.xhtml) by collecting
<h1>..<h6> throughout all of the text documents.
Add, improve some comments, docstrings, exception texts.
2020-01-21 01:32:47 +00:00
max_level: If provided, only collect the headers from h1..hX, inclusive.
linear_only: Ignore spine items that are marked as linear=no.
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
'''
def new_list(root=False):
r = bs4.BeautifulSoup('<ol></ol>', 'html.parser')
if root:
return r
return r.ol
Create a regex pattern for exactly needed headers, no postfiltering.
2020-02-04 07:07:02 +00:00
# Official HTML headers only go up to 6.
if max_level is None:
max_level = 6
elif max_level < 1:
raise ValueError('max_level must be >= 1.')
header_pattern = re.compile(rf'^h[1-{max_level}]$')
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
nav_id = self.get_nav()
if nav_id:
nav_filepath = self.get_filepath(nav_id)
ncx_id = self.get_ncx()
if ncx_id:
ncx_filepath = self.get_filepath(ncx_id)
if not nav_id and not ncx_id:
return
Improve comments in generate_toc.
2020-02-04 07:12:36 +00:00
# Note: The toc generated by the upcoming loop is in a sort of agnostic
# format, since it needs to be converted into nav.html and toc.ncx which
# have different structural requirements. The attributes that I'm using
# in this initial toc object DO NOT represent any part of the epub format.
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
toc = new_list(root=True)
Fix toc from climbing too high when going from h2 to h4 to h2 etc. Can you believe there was a bug amidst all these wonderful comments? The code previously assumed that climbing .parent corresponded to climbing from hX to hX-1, but this wasn't true when the headers themselves skipped a level. After creating some toc for h2 then h4, then encountering a new h2, it would try to climb back two levels to go from 4 to 2, but actually there was only ever one level between them.
2020-02-05 00:40:14 +00:00
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
current_list = toc.ol
Fix toc from climbing too high when going from h2 to h4 to h2 etc. Can you believe there was a bug amidst all these wonderful comments? The code previously assumed that climbing .parent corresponded to climbing from hX to hX-1, but this wasn't true when the headers themselves skipped a level. After creating some toc for h2 then h4, then encountering a new h2, it would try to climb back two levels to go from 4 to 2, but actually there was only ever one level between them.
2020-02-05 00:40:14 +00:00
current_list['level'] = None
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
spine = self.get_spine_order(linear_only=linear_only)
spine = [s for s in spine if s != nav_id]
for file_id in spine:
file_path = self.get_filepath(file_id)
soup = self.read_file(file_id, soup=True)
Use enumerate instead of manual counting, now that headers is exact.
2020-02-04 07:11:22 +00:00
headers = soup.find_all(header_pattern)
for (toc_line_index, header) in enumerate(headers, start=1):
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
# 'hX' -> X
level = int(header.name[1])
header['id'] = f'toc_{toc_line_index}'
toc_line = toc.new_tag('li')
toc_line['text'] = header.text
if nav_id:
relative = file_path.relative_to(nav_filepath.parent, simple=True)
toc_line['nav_anchor'] = f'{relative}#{header["id"]}'
if ncx_id:
relative = file_path.relative_to(ncx_filepath.parent, simple=True)
toc_line['ncx_anchor'] = f'{relative}#{header["id"]}'
Fix toc from climbing too high when going from h2 to h4 to h2 etc. Can you believe there was a bug amidst all these wonderful comments? The code previously assumed that climbing .parent corresponded to climbing from hX to hX-1, but this wasn't true when the headers themselves skipped a level. After creating some toc for h2 then h4, then encountering a new h2, it would try to climb back two levels to go from 4 to 2, but actually there was only ever one level between them.
2020-02-05 00:40:14 +00:00
if current_list['level'] is None:
current_list['level'] = level
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
Fix toc from climbing too high when going from h2 to h4 to h2 etc. Can you believe there was a bug amidst all these wonderful comments? The code previously assumed that climbing .parent corresponded to climbing from hX to hX-1, but this wasn't true when the headers themselves skipped a level. After creating some toc for h2 then h4, then encountering a new h2, it would try to climb back two levels to go from 4 to 2, but actually there was only ever one level between them.
2020-02-05 00:40:14 +00:00
while level < current_list['level']:
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
# Because the sub-<ol> are actually a child of the last
# <li> of the previous <ol>, we must .parent twice.
Clarify this comment why the two .parent climbs are separate.
2020-02-04 08:18:25 +00:00
# The second .parent is conditional because if the current
# list is toc.ol, then parent is a Soup document object, and
# parenting again would be a mistake. We'll recover from
# this in just a moment.
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
current_list = current_list.parent
if current_list.name == 'li':
current_list = current_list.parent
Improve comments in generate_toc.
2020-02-04 07:12:36 +00:00
# If the file has headers in a non-ascending order, like the
# first header is an h4 and then an h1 comes later, then
# this while loop would keep attempting to climb the .parent
# which would take us too far, off the top of the tree.
# So, if we reach `current_list == toc.ol` then we've
# reached the root and should stop climbing. At that point
# we can just snap current_level and use the root list again.
# In the resulting toc, that initial h4 would have the same
# toc depth as the later h1 since it never had parents.
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
if current_list == toc:
Fix toc from climbing too high when going from h2 to h4 to h2 etc. Can you believe there was a bug amidst all these wonderful comments? The code previously assumed that climbing .parent corresponded to climbing from hX to hX-1, but this wasn't true when the headers themselves skipped a level. After creating some toc for h2 then h4, then encountering a new h2, it would try to climb back two levels to go from 4 to 2, but actually there was only ever one level between them.
2020-02-05 00:40:14 +00:00
current_list['level'] = level
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
current_list = toc.ol
Fix toc from climbing too high when going from h2 to h4 to h2 etc. Can you believe there was a bug amidst all these wonderful comments? The code previously assumed that climbing .parent corresponded to climbing from hX to hX-1, but this wasn't true when the headers themselves skipped a level. After creating some toc for h2 then h4, then encountering a new h2, it would try to climb back two levels to go from 4 to 2, but actually there was only ever one level between them.
2020-02-05 00:40:14 +00:00
if level > current_list['level']:
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
# In order to properly render nested <ol>, you're supposed
# to make the new <ol> a child of the last <li> of the
Improve comments in generate_toc.
2020-02-04 07:12:36 +00:00
# previous <ol>. NOT a child of the prev <ol> directly.
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
# Don't worry, .children can never be empty because on the
# first <li> this condition can never occur, and new <ol>s
# always receive a child right after being created.
_l = new_list()
Fix toc from climbing too high when going from h2 to h4 to h2 etc. Can you believe there was a bug amidst all these wonderful comments? The code previously assumed that climbing .parent corresponded to climbing from hX to hX-1, but this wasn't true when the headers themselves skipped a level. After creating some toc for h2 then h4, then encountering a new h2, it would try to climb back two levels to go from 4 to 2, but actually there was only ever one level between them.
2020-02-05 00:40:14 +00:00
_l['level'] = level
Improve comments in generate_toc.
2020-02-04 07:12:36 +00:00
final_li = list(current_list.children)[-1]
final_li.append(_l)
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
current_list = _l
current_list.append(toc_line)
# We have to save the id="toc_X" that we gave to all the headers.
self.write_file(file_id, soup)
Fix toc from climbing too high when going from h2 to h4 to h2 etc. Can you believe there was a bug amidst all these wonderful comments? The code previously assumed that climbing .parent corresponded to climbing from hX to hX-1, but this wasn't true when the headers themselves skipped a level. After creating some toc for h2 then h4, then encountering a new h2, it would try to climb back two levels to go from 4 to 2, but actually there was only ever one level between them.
2020-02-05 00:40:14 +00:00
for ol in toc.find_all('ol'):
del ol['level']
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
if nav_id:
self._set_nav_toc(nav_id, copy.copy(toc))
if ncx_id:
self._set_ncx_toc(ncx_id, copy.copy(toc))
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Initial commit.
2019-08-04 05:13:27 +00:00
def move_nav_to_end(self):
'''
Add, improve some comments, docstrings, exception texts.
2020-01-21 01:32:47 +00:00
Move the nav.xhtml file to the end and set its linear=no.
Initial commit.
2019-08-04 05:13:27 +00:00
'''
nav = self.get_nav()
if not nav:
return
spine = self.get_spine_order()
Simplify move_nav_to_end by calling spine.index.
2020-02-03 03:35:46 +00:00
try:
index = spine.index(nav)
spine.append(spine.pop(index))
except ValueError:
In move_nav_to_end, add nav to spine if not present.
2019-08-19 05:38:40 +00:00
spine.append(nav)
Initial commit.
2019-08-04 05:13:27 +00:00
In move_nav_to_end, add nav to spine if not present.
2019-08-19 05:38:40 +00:00
self.set_spine_order(spine)
Initial commit.
2019-08-04 05:13:27 +00:00
self.set_spine_linear(nav, False)
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Initial commit.
2019-08-04 05:13:27 +00:00
def normalize_directory_structure(self):
# This must come before the opf rewrite because that would affect the
# location of all all manifest item hrefs.
manifest_items = self.get_manifest_items(soup=True)
old_filepaths = {item['id']: self.get_filepath(item['id']) for item in manifest_items}
old_ncx = self.get_ncx()
try:
old_ncx_parent = self.get_filepath(self.get_ncx()).parent
except Exception:
old_ncx_parent = None
if self.opf_filepath.parent == self.root_directory:
oebps = self.root_directory.with_child('OEBPS')
When normalizing, OEBPS exist_ok=True. I hadn't considered that the content.opf would be in the root when there is an OEBPS dir present. There's a whole weird world out there.
2019-08-07 06:38:56 +00:00
os.makedirs(oebps.absolute_path, exist_ok=True)
Initial commit.
2019-08-04 05:13:27 +00:00
self.write_opf()
new_opf_path = oebps.with_child(self.opf_filepath.basename)
os.rename(self.opf_filepath.absolute_path, new_opf_path.absolute_path)
container = self.read_container_xml()
rootfile = container.find('rootfile', {'full-path': self.opf_filepath.basename})
rootfile['full-path'] = new_opf_path.relative_to(self.root_directory, simple=True)
self.write_container_xml(container)
self.opf_filepath = new_opf_path
rename_map = {}
for manifest_item in manifest_items:
old_filepath = old_filepaths[manifest_item['id']]
directory = get_directory_for_mimetype(manifest_item['media-type'])
directory = self.opf_filepath.parent.with_child(directory)
Fix relink behavior when subfolder exists with wrong casing.
2019-09-06 23:54:40 +00:00
if directory.exists:
# On Windows, this will fix any incorrect casing.
# On Linux it is inert.
os.rename(directory.absolute_path, directory.absolute_path)
else:
os.makedirs(directory.absolute_path)
Initial commit.
2019-08-04 05:13:27 +00:00
new_filepath = directory.with_child(old_filepath.basename)
Fix relink behavior when subfolder exists with wrong casing.
2019-09-06 23:54:40 +00:00
if new_filepath.absolute_path != old_filepath.absolute_path:
Don't add unchanged paths to the rename_map.
2019-08-19 05:39:02 +00:00
rename_map[old_filepath] = new_filepath
os.rename(old_filepath.absolute_path, new_filepath.absolute_path)
Initial commit.
2019-08-04 05:13:27 +00:00
manifest_item['href'] = new_filepath.relative_to(self.opf_filepath.parent, simple=True)
self.fix_interlinking_opf(rename_map)
for id in self.get_texts():
self.fix_interlinking_text(id, rename_map, old_relative_to=old_filepaths[id].parent)
self.fix_interlinking_ncx(rename_map, old_relative_to=old_ncx_parent)
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
@writes
Add step for normalizing the opf file specifically.
2019-12-30 21:48:06 +00:00
def normalize_opf(self):
for tag in self.opf.descendants:
if tag.name:
tag.name = tag.name.replace('opf:', '')
During opf normalize, ensure ncx mimetype is correct.
2020-01-03 04:12:08 +00:00
for item in self.get_manifest_items(soup=True):
if item['href'] in ['toc.ncx', 'Misc/toc.ncx']:
item['media-type'] = 'application/x-dtbncx+xml'
Add step for normalizing the opf file specifically.
2019-12-30 21:48:06 +00:00
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
# COMMAND LINE TOOLS
################################################################################
import argparse
import html
import random
import string
import sys
from voussoirkit import betterhelp
Replace glob with winglob.
2020-01-21 01:06:27 +00:00
from voussoirkit import winglob
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
DOCSTRING = '''
Use betterhelp to manage docstrings.
2020-01-31 07:41:42 +00:00
Epubfile
The simple python .epub scripting tool.
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
{addfile}
{covercomesfirst}
Add missing exec summary to main docstring.
2020-02-07 23:11:18 +00:00
{exec}
Add missing generate_toc to help text.
2019-12-30 21:48:37 +00:00
{generate_toc}
Add the holdit command.
2019-08-19 02:53:54 +00:00
{holdit}
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
{merge}
{normalize}
Use betterhelp to manage docstrings.
2020-01-31 07:41:42 +00:00
TO SEE DETAILS ON EACH COMMAND, RUN
> epubfile.py <command>
Improve some docstrings and comments.
2020-03-08 00:36:32 +00:00
'''
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
Use betterhelp to manage docstrings.
2020-01-31 07:41:42 +00:00
SUB_DOCSTRINGS = dict(
addfile='''
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
addfile:
Add files into the book.
> epubfile.py addfile book.epub page1.html image.jpg
'''.strip(),
Use betterhelp to manage docstrings.
2020-01-31 07:41:42 +00:00
covercomesfirst='''
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
covercomesfirst:
Rename the cover image file so that it is the alphabetically-first image.
> epubfile.py covercomesfirst book.epub
I use CBXShell to get thumbnails of epub files on Windows, and because it
is generalized for zip files and doesn't read epub metadata, alphabetized
mode works best for getting epub covers as icons.
In my testing, CBXShell considers the image's whole path and not just the
basename, so you may want to consider normalizing the directory structure
first, otherwise some /a/image.jpg will always be before /images/cover.jpg.
'''.strip(),
Use betterhelp to manage docstrings.
2020-01-31 07:41:42 +00:00
exec='''
Add command exec.
2019-09-09 04:25:35 +00:00
exec:
Improve some docstrings and comments.
2020-03-08 00:36:32 +00:00
Execute a snippet of Python code against the book.
Add command exec.
2019-09-09 04:25:35 +00:00
> epubfile.py exec book.epub --command "book._____()"
'''.strip(),
Use betterhelp to manage docstrings.
2020-01-31 07:41:42 +00:00
generate_toc='''
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
generate_toc:
Improve some docstrings and comments.
2020-03-08 00:36:32 +00:00
Regenerate the toc.ncx and nav.xhtml based on html <hX> headers in the text.
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
Add command exec.
2019-09-09 04:25:35 +00:00
> epubfile.py generate_toc book.epub <flags>
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
flags:
--max_level X:
Only generate toc entries for headers up to level X.
That is, h1, h2, ... hX.
Add missing generate_toc to help text.
2019-12-30 21:48:37 +00:00
'''.strip(),
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
Use betterhelp to manage docstrings.
2020-01-31 07:41:42 +00:00
holdit='''
Add the holdit command.
2019-08-19 02:53:54 +00:00
holdit:
Improve some docstrings and comments.
2020-03-08 00:36:32 +00:00
Extract the book so that you can manually edit the files on disk, then save
the changes back into the original file.
Add the holdit command.
2019-08-19 02:53:54 +00:00
> epubfile.py holdit book.epub
Add missing generate_toc to help text.
2019-12-30 21:48:37 +00:00
'''.strip(),
Add the holdit command.
2019-08-19 02:53:54 +00:00
Use betterhelp to manage docstrings.
2020-01-31 07:41:42 +00:00
merge='''
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
merge:
Merge multiple books into one.
> epubfile.py merge book1.epub book2.epub --output final.epub <flags>
flags:
Add missing exec summary to main docstring.
2020-02-07 23:11:18 +00:00
--demote_headers:
Add helptext for merge --demote_headers.
2020-02-03 03:36:16 +00:00
All h1 in the book will be demoted to h2, and so forth. So that the
headerfiles are the only h1s and the table of contents will generate
with a good hierarchy.
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
--headerfile:
Add a file before each book with an <h1> containing its title.
Add argument number_headerfile to get index in the h1.
2019-12-30 21:53:12 +00:00
--number_headerfile:
In the headerfile, the <h1> will start with the book's index, like
"01. First Book"
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
-y | --autoyes:
Overwrite the output file without prompting.
'''.strip(),
Use betterhelp to manage docstrings.
2020-01-31 07:41:42 +00:00
normalize='''
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
normalize:
Rename files and directories in the book to match a common structure.
Moves all book content from / into /OEBPS and sorts files into
subdirectories by type: Text, Images, Styles, etc.
> epubfile.py normalize book.epub
Use betterhelp to manage docstrings.
2020-01-31 07:41:42 +00:00
'''.strip(),
)
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
DOCSTRING = betterhelp.add_previews(DOCSTRING, SUB_DOCSTRINGS)
def random_string(length, characters=string.ascii_lowercase):
return ''.join(random.choice(characters) for x in range(length))
def addfile_argparse(args):
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
book = Epub(args.epub)
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
Treat addfile arguments as glob patterns.
2019-12-30 21:50:05 +00:00
for pattern in args.files:
Replace glob with winglob.
2020-01-21 01:06:27 +00:00
for file in winglob.glob(pattern):
Treat addfile arguments as glob patterns.
2019-12-30 21:50:05 +00:00
print(f'Adding file {file}.')
file = pathclass.Path(file)
try:
book.easy_add_file(file)
except (IDExists, FileExists) as exc:
rand_suffix = random_string(3, string.digits)
base = file.replace_extension('').basename
id = f'{base}_{rand_suffix}'
Apply new pathclass.Extension with_dot.
2020-02-03 03:38:24 +00:00
basename = f'{base}_{rand_suffix}{file.extension.with_dot}'
Treat addfile arguments as glob patterns.
2019-12-30 21:50:05 +00:00
content = open(file.absolute_path, 'rb').read()
book.add_file(id, basename, content)
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
book.move_nav_to_end()
book.save(args.epub)
Let covercomesfirst and normalize take many books via glob.
2019-08-19 02:55:41 +00:00
def covercomesfirst(book):
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
basenames = {i: book.get_filepath(i).basename for i in book.get_images()}
if len(basenames) <= 1:
return
cover_image = book.get_cover_image()
if not cover_image:
return
cover_basename = book.get_filepath(cover_image).basename
cover_index = sorted(basenames.values()).index(cover_basename)
if cover_index == 0:
return
rename_map = basenames.copy()
if not cover_basename.startswith('!'):
cover_basename = '!' + cover_basename
rename_map[cover_image] = cover_basename
else:
rename_map.pop(cover_image)
for (id, basename) in rename_map.copy().items():
if id == cover_image:
continue
if basename > cover_basename:
rename_map.pop(id)
continue
if basename < cover_basename and basename.startswith('!'):
basename = basename.lstrip('!')
rename_map[id] = basename
if basename < cover_basename or basename.startswith('.'):
basename = '_' + basename
rename_map[id] = basename
book.rename_file(rename_map)
Let covercomesfirst and normalize take many books via glob.
2019-08-19 02:55:41 +00:00
def covercomesfirst_argparse(args):
Replace glob with winglob.
2020-01-21 01:06:27 +00:00
epubs = [epub for pattern in args.epubs for epub in winglob.glob(pattern)]
Let covercomesfirst and normalize take many books via glob.
2019-08-19 02:55:41 +00:00
for epub in epubs:
print(epub)
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
book = Epub(epub)
Let covercomesfirst and normalize take many books via glob.
2019-08-19 02:55:41 +00:00
covercomesfirst(book)
Move covercomesfirst's save line back to the argparse func. Because args doesn't exist in the other function. oops.
2020-01-03 04:13:09 +00:00
book.save(args.epub)
Let covercomesfirst and normalize take many books via glob.
2019-08-19 02:55:41 +00:00
Add command exec.
2019-09-09 04:25:35 +00:00
def exec_argparse(args):
Replace glob with winglob.
2020-01-21 01:06:27 +00:00
epubs = [epub for pattern in args.epubs for epub in winglob.glob(pattern)]
Add command exec.
2019-09-09 04:25:35 +00:00
for epub in epubs:
print(epub)
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
book = Epub(epub)
Add command exec.
2019-09-09 04:25:35 +00:00
exec(args.command)
book.save(epub)
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
def generate_toc_argparse(args):
Replace glob with winglob.
2020-01-21 01:06:27 +00:00
epubs = [epub for pattern in args.epubs for epub in winglob.glob(pattern)]
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
books = []
for epub in epubs:
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
book = Epub(epub)
Add method generate_toc and commandline command.
2019-08-29 23:44:57 +00:00
book.generate_toc(max_level=int(args.max_level) if args.max_level else None)
book.save(epub)
Add the holdit command.
2019-08-19 02:53:54 +00:00
def holdit_argparse(args):
Replace glob with winglob.
2020-01-21 01:06:27 +00:00
epubs = [epub for pattern in args.epubs for epub in winglob.glob(pattern)]
Let holdit take many books.
2019-08-29 20:46:34 +00:00
books = []
for epub in epubs:
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
book = Epub(epub)
Let holdit take many books.
2019-08-29 20:46:34 +00:00
print(f'{epub} = {book.root_directory.absolute_path}')
books.append((epub, book))
Add the holdit command.
2019-08-19 02:53:54 +00:00
input('Press Enter when ready.')
Let holdit take many books.
2019-08-29 20:46:34 +00:00
for (epub, book) in books:
# Saving re-writes the opf from memory, which might undo any manual changes.
# So let's re-read it first.
book.read_opf(book.opf_filepath)
book.save(epub)
Add the holdit command.
2019-08-19 02:53:54 +00:00
Add argument demote_headers to merge.
2020-01-21 01:10:22 +00:00
def merge(
input_filepaths,
output_filename,
demote_headers=False,
do_headerfile=False,
number_headerfile=False,
):
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
book = Epub.new()
Replace glob with winglob.
2020-01-21 01:06:27 +00:00
input_filepaths = [pathclass.Path(p) for pattern in input_filepaths for p in winglob.glob(pattern)]
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
index_length = len(str(len(input_filepaths)))
rand_prefix = random_string(3, string.digits)
Use enumerate(start=1) instead of index += 1.
2020-03-07 21:50:39 +00:00
# Number books from 1 for human sanity.
for (index, input_filepath) in enumerate(input_filepaths, start=1):
Let merge take glob patterns.
2019-09-06 22:39:26 +00:00
print(f'Merging {input_filepath.absolute_path}.')
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
prefix = f'{rand_prefix}_{index:>0{index_length}}_{{}}'
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
input_book = Epub(input_filepath)
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
input_book.normalize_directory_structure()
input_ncx = input_book.get_ncx()
input_nav = input_book.get_nav()
manifest_ids = input_book.get_manifest_items(spine_order=True)
manifest_ids = [x for x in manifest_ids if x not in (input_ncx, input_nav)]
basename_map = {}
for id in manifest_ids:
old_basename = input_book.get_filepath(id).basename
new_basename = prefix.format(old_basename)
basename_map[id] = new_basename
Add command exec.
2019-09-09 04:25:35 +00:00
# Don't worry, we're not going to save over the input book!
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
input_book.rename_file(basename_map)
if do_headerfile:
content = ''
try:
title = input_book.get_titles()[0]
except IndexError:
title = input_filepath.replace_extension('').basename
Add argument number_headerfile to get index in the h1.
2019-12-30 21:53:12 +00:00
if number_headerfile:
title = f'{index:>0{index_length}}. {title}'
content += f'<h1>{html.escape(title)}</h1>'
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
try:
author = input_book.get_authors()[0]
content += f'<p>{html.escape(author)}</p>'
except IndexError:
pass
headerfile_id = prefix.format('headerfile')
headerfile_basename = prefix.format('headerfile.html')
book.add_file(headerfile_id, headerfile_basename, content)
for id in manifest_ids:
When merging, start indices at 1 instead of 0. When going through the resulting merged book in sigil, it's confusing to remember that the index prefix on every file is not actually the number of the book that you're working on, especially if it's a numbered series of books.
2019-12-30 21:52:08 +00:00
new_id = prefix.format(id)
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
new_basename = basename_map[id]
Add argument demote_headers to merge.
2020-01-21 01:10:22 +00:00
if demote_headers:
content = input_book.read_file(id, soup=True)
if isinstance(content, bs4.BeautifulSoup):
content = demote_xhtml_headers(content)
else:
content = input_book.read_file(id)
book.add_file(new_id, new_basename, content)
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
book.move_nav_to_end()
book.save(output_filename)
def merge_argparse(args):
if os.path.exists(args.output):
Use voussoirkit.getpermission.
2020-03-07 21:52:29 +00:00
if not (args.autoyes or getpermission.getpermission(f'Overwrite {args.output}?')):
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
raise ValueError(f'{args.output} exists.')
Add argument number_headerfile to get index in the h1.
2019-12-30 21:53:12 +00:00
return merge(
input_filepaths=args.epubs,
output_filename=args.output,
Add argument demote_headers to merge.
2020-01-21 01:10:22 +00:00
demote_headers=args.demote_headers,
Add argument number_headerfile to get index in the h1.
2019-12-30 21:53:12 +00:00
do_headerfile=args.headerfile,
number_headerfile=args.number_headerfile,
)
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
def normalize_argparse(args):
Replace glob with winglob.
2020-01-21 01:06:27 +00:00
epubs = [epub for pattern in args.epubs for epub in winglob.glob(pattern)]
Let covercomesfirst and normalize take many books via glob.
2019-08-19 02:55:41 +00:00
for epub in epubs:
print(epub)
Remove Epub.open, use Epub('path'); support read-only mode. Instead of Epub.open('path'), now use Epub('path'). This makes the class more intuitive to use. This also removes the need for the _original_epub_filepath argument which was simply awkward. We now support read-only books with the read_only argument. The main benefit is that we don't need to unzip the epub file, so if you are going to be reading from epubs but don't need to write, setting read_only can significately improve speed.
2020-03-08 00:18:53 +00:00
book = Epub(epub)
Add step for normalizing the opf file specifically.
2019-12-30 21:48:06 +00:00
book.normalize_opf()
Let covercomesfirst and normalize take many books via glob.
2019-08-19 02:55:41 +00:00
book.normalize_directory_structure()
book.move_nav_to_end()
book.save(epub)
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
Use betterhelp to manage docstrings.
2020-01-31 07:41:42 +00:00
parser = argparse.ArgumentParser(description=__doc__)
subparsers = parser.add_subparsers()
p_addfile = subparsers.add_parser('addfile')
p_addfile.add_argument('epub')
p_addfile.add_argument('files', nargs='+', default=[])
p_addfile.set_defaults(func=addfile_argparse)
p_covercomesfirst = subparsers.add_parser('covercomesfirst')
p_covercomesfirst.add_argument('epubs', nargs='+', default=[])
p_covercomesfirst.set_defaults(func=covercomesfirst_argparse)
p_exec = subparsers.add_parser('exec')
p_exec.add_argument('epubs', nargs='+', default=[])
p_exec.add_argument('--command', dest='command', default=None, required=True)
p_exec.set_defaults(func=exec_argparse)
p_generate_toc = subparsers.add_parser('generate_toc')
p_generate_toc.add_argument('epubs', nargs='+', default=[])
p_generate_toc.add_argument('--max_level', dest='max_level', default=None)
p_generate_toc.set_defaults(func=generate_toc_argparse)
p_holdit = subparsers.add_parser('holdit')
p_holdit.add_argument('epubs', nargs='+', default=[])
p_holdit.set_defaults(func=holdit_argparse)
p_merge = subparsers.add_parser('merge')
p_merge.add_argument('epubs', nargs='+', default=[])
p_merge.add_argument('--output', dest='output', default=None, required=True)
p_merge.add_argument('--headerfile', dest='headerfile', action='store_true')
p_merge.add_argument('--demote_headers', dest='demote_headers', action='store_true')
p_merge.add_argument('--number_headerfile', dest='number_headerfile', action='store_true')
p_merge.add_argument('-y', '--autoyes', dest='autoyes', action='store_true')
p_merge.set_defaults(func=merge_argparse)
p_normalize = subparsers.add_parser('normalize')
p_normalize.add_argument('epubs', nargs='+', default=[])
p_normalize.set_defaults(func=normalize_argparse)
@betterhelp.subparser_betterhelp(parser, main_docstring=DOCSTRING, sub_docstrings=SUB_DOCSTRINGS)
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
def main(argv):
args = parser.parse_args(argv)
main should return args.func(args) value.
2020-02-09 00:19:58 +00:00
return args.func(args)
Initial commandline utilities.
2019-08-07 06:49:47 +00:00
if __name__ == '__main__':
raise SystemExit(main(sys.argv[1:]))
Reference in a new issue Copy permalink