paulocheque / epub-meta / 39

pending completion

Build # 39

Build Type

Pull #9

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/paulocheque/epub-meta/commit/<a class=hub.com/paulocheque/epub-meta/commit/<a class="double-link" href="https://git"><a class=hub.com/paulocheque/epub-meta/commit/<a class="double-link" href="https://git"><a class=hub.com/paulocheque/epub-meta/commit/<a class="double-link" href="https://git"><a class=hub.com/paulocheque/epub-meta/commit/4cb68f9733d60737183617c2a0148b4a8f8a3c82">4cb68f973">&lt;a href=&quot;https://github.com/paulocheque/epub-meta/commit/</a><a class="double-link" href="https://github.com/paulocheque/epub-meta/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/paulocheque/epub-meta/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/paulocheque/epub-meta/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/paulocheque/epub-meta/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/paulocheque/epub-meta/commit/4cb68f9733d60737183617c2a0148b4a8f8a3c82">4cb68f973</a><a href="https://github.com/paulocheque/epub-meta/commit/4cb68f9733d60737183617c2a0148b4a8f8a3c82">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/paulocheque/epub-meta/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/paulocheque/epub-meta/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/paulocheque/epub-meta/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/paulocheque/epub-meta/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/paulocheque/epub-meta/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/paulocheque/epub-meta/commit/4cb68f9733d60737183617c2a0148b4a8f8a3c82&quot;&gt;4cb68f973&lt;/a&gt;&lt;a href=&quot;https://github.com/paulocheque/epub-meta/commit/4cb68f9733d60737183617c2a0148b4a8f8a3c82&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/paulocheque/epub-meta/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp... (continued)

Pull Request Pull Request #9: Translate two more possible exceptions into EPubException.

Run Details

14 of 14 new or added lines in 1 file covered. (100.0%)

424 of 474 relevant lines covered (89.45%)

0.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.98

/epub_meta/collector.py

import base64
import os
import os.path
from xml.dom import minidom
import zipfile
import sys

from epub_meta.exceptions import EPubException


IS_PY2 = sys.version_info < (3, 0)

if IS_PY2:
    from urllib import unquote
else:
    from urllib.parse import unquote


class odict(dict):
    __setattr__ = dict.__setitem__
    __delattr__ = dict.__delitem__

    def __getattr__(self, attr):
        return self.get(attr)


def iterate_all_tags(root):
    for node in root.childNodes:
        if node.nodeType != node.ELEMENT_NODE:
            continue

        yield node

        for subnode in iterate_all_tags(node):
            yield subnode


def find_tag(xmldoc, tag_name, attr, value):
    # print('Finding tag: <{} {}="{}">'.format(tag_name, attr, value))
    for tag in xmldoc.getElementsByTagName(tag_name):
        if attr in tag.attributes.keys() and tag.attributes[attr].value == value:
            return tag


def find_img_tag(xmldoc, tag_name, attr, value):
    # print('Finding img tag: <{} {}="{}">'.format(tag_name, attr, value))
    for tag in xmldoc.getElementsByTagName(tag_name):
        if attr in tag.attributes.keys() and tag.attributes[attr].value == value:
            if 'href' in tag.attributes.keys():
                filepath = unquote(tag.attributes['href'].value)
                filename, file_extension = os.path.splitext(filepath)
                if file_extension in ('.gif', '.jpg', '.jpeg', '.png', '.svg'):
                    return filepath, file_extension
    return None, None


def _discover_epub_version(opf_xmldoc):
    try:
        return opf_xmldoc.getElementsByTagName('package')[0].attributes['version'].value
    except (KeyError, IndexError):
        return None


def __discover_dc(opf_xmldoc, name, first_only=True):
    value = None
    try:
        if first_only:
            node = opf_xmldoc.getElementsByTagName(name)[0].firstChild
            if node:
                value = node.nodeValue
        else:
            value = [n.firstChild.nodeValue for n in opf_xmldoc.getElementsByTagName(name) if n.firstChild]
    except (KeyError, IndexError):
        pass
    if not value:
        tag_name = 'dc:{}'.format(name)
        try:
            if first_only:
                node = opf_xmldoc.getElementsByTagName(tag_name)[0].firstChild
                if node:
                    value = node.nodeValue
            else:
                value = [n.firstChild.nodeValue for n in opf_xmldoc.getElementsByTagName(tag_name) if n.firstChild]
        except (KeyError, IndexError):
            pass
    if first_only:
        return value.strip() if value else value
    else:
        return [v.strip() for v in value]


def _discover_title(opf_xmldoc):
    return __discover_dc(opf_xmldoc, 'title')


def _discover_language(opf_xmldoc):
    return __discover_dc(opf_xmldoc, 'language')


def _discover_description(opf_xmldoc):
    return __discover_dc(opf_xmldoc, 'description')


def _find_author_from_dom(xmldoc):
    # Only find a single author now with this algorithm but returning a list
    # because that's what caller expects
    authors = []

    # First non-empty child node is author after the author 'tag'
    found_author_tag = False

    for tag in iterate_all_tags(xmldoc):
        if not found_author_tag:
            if tag.nodeName == 'strong' and tag.childNodes and (
               tag.firstChild.nodeType == tag.firstChild.TEXT_NODE) and (
               tag.firstChild.data in ('Author', 'Authors')):

                found_author_tag = True
        else:
            # Find all paragraph tags BEFORE we find another span tag. Those
            # are the author(s).
            if tag.nodeName == 'span':
                break

            if tag.nodeName == 'p' and tag.childNodes and (
               tag.firstChild.nodeType == tag.firstChild.TEXT_NODE):

                data = tag.firstChild.data.strip()
                if data:
                    authors.append(data)

    return authors


def _discover_authors(opf_xmldoc, authors_html=None):
    authors = __discover_dc(opf_xmldoc, 'creator', first_only=False)

    # We've found large portion of books from specific publishers that store
    # the authors in pr02.html in a very specific place.
    if not authors and authors_html is not None:
        authors = _find_author_from_dom(authors_html)

    # Slow and inefficient way to remove duplicates but maintain ordering just
    # in case the author order in epub is significant.
    unique_authors = []
    for author in authors:
        if author not in unique_authors:
            unique_authors.append(author)

    return unique_authors


def _discover_publisher(opf_xmldoc):
    return __discover_dc(opf_xmldoc, 'publisher')


def _find_publish_date_from_dom(xmldoc):
    first_pub = 'First published:'

    for tag in iterate_all_tags(xmldoc):
        if tag.nodeName == 'p' and tag.childNodes and (
           tag.firstChild.nodeType == tag.TEXT_NODE) and (
           tag.firstChild.data.startswith(first_pub)):
            return tag.firstChild.data.split(first_pub)[1].strip()


def _discover_publication_date(opf_xmldoc, date_html=None):
    date = __discover_dc(opf_xmldoc, 'date')

    if not date and date_html is not None:
        date = _find_publish_date_from_dom(date_html)

    return date


def _discover_identifiers(opf_xmldoc):
    # ISBN 10, ISBN 13 etc
    return __discover_dc(opf_xmldoc, 'identifier', first_only=False)


def _discover_subject(opf_xmldoc):
    return __discover_dc(opf_xmldoc, 'subject', first_only=False)


def _discover_cover_image(zf, opf_xmldoc, opf_filepath):
    '''
    Find the cover image path in the OPF file.
    Returns a tuple: (image content in base64, file extension)
    '''
    content = None
    filepath = None
    extension = None

    # Strategies to discover the cover-image path:

    # e.g.: <meta name="cover" content="cover"/>
    tag = find_tag(opf_xmldoc, 'meta', 'name', 'cover')
    if tag and 'content' in tag.attributes.keys():
        item_id = tag.attributes['content'].value
        if item_id:
            # e.g.: <item href="cover.jpg" id="cover" media-type="image/jpeg"/>
            filepath, extension = find_img_tag(opf_xmldoc, 'item', 'id', item_id)
    if not filepath:
        filepath, extension = find_img_tag(opf_xmldoc, 'item', 'id', 'cover-image')
    if not filepath:
        filepath, extension = find_img_tag(opf_xmldoc, 'item', 'id', 'cover')

    # If we have found the cover image path:
    if filepath:
        # The cover image path is relative to the OPF file
        base_dir = os.path.dirname(opf_filepath)
        # Also, normalize the path (ie opfpath/../cover.jpg -> cover.jpg)
        coverpath = os.path.normpath(os.path.join(base_dir, filepath))
        try:
            content = zf.read(coverpath)
        except KeyError:
            raise EPubException("Cannot read {} from EPub file {}".format(
                coverpath, os.path.basename(zf.filename)))
        content = base64.b64encode(content)

    return content, extension


def _discover_toc(zf, opf_xmldoc, opf_filepath):
    '''
    Returns a list of objects: {title: str, src: str, level: int, index: int}
    '''
    toc = None

    # ePub 3.x
    tag = find_tag(opf_xmldoc, 'item', 'properties', 'nav')
    if tag and 'href' in tag.attributes.keys():
        filepath = unquote(tag.attributes['href'].value)
        # The xhtml file path is relative to the OPF file
        base_dir = os.path.dirname(opf_filepath)
        # print('- Reading Nav file: {}/{}'.format(base_dir, filepath))
        npath = os.path.normpath(os.path.join(base_dir, filepath))
        nav_content = zf.read(npath)
        toc_xmldoc = minidom.parseString(nav_content)

        _toc = []

        for n in toc_xmldoc.getElementsByTagName('a'):
            if n.firstChild and ('href' in n.attributes.keys()):
                href = unquote(n.attributes['href'].value)
                # Discarding CFI links
                if '.html' in href or '.xhtml' in href:
                    title = n.firstChild.nodeValue
                    # try the second node too (maybe the first child is an empty span)
                    if not title and n.firstChild.firstChild:
                        title = n.firstChild.firstChild.nodeValue

                    title = title.strip() if title else None

                    if title:
                        level = -1
                        parentNode = n.parentNode
                        avoid_infinite_loop = 0 # simple security issue to avoid infinite loop for bad epub files
                        while parentNode and parentNode.nodeName != 'nav' and avoid_infinite_loop < 50:
                            if parentNode.nodeName == 'ol': # count the depth of the a link related to ol items
                                level += 1
                            parentNode = parentNode.parentNode
                            avoid_infinite_loop += 1
                        level = max(level, 0) # root level is 0, not -1

                        _toc.append({'title': title, 'src': href, 'level': level})
        if _toc:
            toc = _toc

    if not toc:
        # ePub 2.x
        tag = find_tag(opf_xmldoc, 'item', 'id', 'ncx')
        if not tag:
            tag = find_tag(opf_xmldoc, 'item', 'id', 'ncxtoc')
        if tag and 'href' in tag.attributes.keys():
            filepath = unquote(tag.attributes['href'].value)
            # The ncx file path is relative to the OPF file
            base_dir = os.path.dirname(opf_filepath)
            # print('- Reading NCX file: {}/{}'.format(base_dir, filepath))
            npath = os.path.normpath(os.path.join(base_dir, filepath))
            ncx_content = zf.read(npath)

            toc_xmldoc = minidom.parseString(ncx_content)

            def read_nav_point(nav_point_node, level = 0):
                items = []
                item = {'title': None, 'src': None, 'level': level}
                children_points = []
                for item_node in nav_point_node.childNodes:
                    if item_node.nodeName in ('navLabel', 'ncx:navLabel'):
                        try:
                            text = item_node.getElementsByTagName('text')[0].firstChild
                        except IndexError:
                            try:
                                text = item_node.getElementsByTagName('ncx:text')[0].firstChild
                            except IndexError:
                                text = None

                        item['title'] = text.nodeValue.strip() if text and text.nodeValue else None
                    elif item_node.nodeName in ('content', 'ncx:content'):
                        if item_node.hasAttribute('src'):
                            item['src'] = item_node.attributes['src'].value
                    elif item_node.nodeName in ('navPoint', 'ncx:navPoint'):
                        children_points.append(item_node)

                if item['title']:
                    items.append(item)
                    for child_node in children_points:
                        subitems = read_nav_point(child_node, level=level + 1)
                        items.extend(subitems)
                return items

            def read_nav_map(toc_xmldoc, level=0):
                items = []
                try:
                    nav_map_node = toc_xmldoc.getElementsByTagName('navMap')[0]
                except IndexError:
                    # Some ebooks use the ncx: namespace so try that too
                    try:
                        nav_map_node = toc_xmldoc.getElementsByTagName('ncx:navMap')[0]
                    except IndexError:
                        print('Failed reading TOC')
                        return items

                for nav_point in nav_map_node.childNodes:
                    if nav_point.nodeName in ('navPoint', 'ncx:navPoint'):
                        subitems = read_nav_point(nav_point, level=level)
                        items.extend(subitems)
                return items

            toc = read_nav_map(toc_xmldoc)

    # add indexes
    if toc:
        for i, t in enumerate(toc):
            t['index'] = i

    return toc


def get_epub_metadata(filepath, read_cover_image=True, read_toc=True):
    '''
    References: http://idpf.org/epub/201 and http://idpf.org/epub/301
    1. Parse META-INF/container.xml file and find the .OPF file path.
    2. In the .OPF file, find the metadata
    '''
    if not zipfile.is_zipfile(filepath):
        raise EPubException('Unknown file')

    try:
        # print('Reading ePub file: {}'.format(filepath))
        zf = zipfile.ZipFile(filepath, 'r', compression=zipfile.ZIP_DEFLATED, allowZip64=True)
        container = zf.read('META-INF/container.xml')
        container_xmldoc = minidom.parseString(container)
        # e.g.: <rootfile full-path="content.opf" media-type="application/oebps-package+xml"/>
        opf_filepath = container_xmldoc.getElementsByTagName('rootfile')[0].attributes['full-path'].value

        opf = zf.read(os.path.normpath(opf_filepath))
        opf_xmldoc = minidom.parseString(opf)
    except IndexError:
        raise EPubException("Cannot parse raw metadata from {}".format(
            os.path.basename(filepath)))

    # This file is specific to the authors if it exists.
    authors_html = None
    try:
        authors_html = minidom.parseString(zf.read('OEBPS/pr02.html'))
    except KeyError:
        # Most books store authors using epub tags, so no worries.
        pass

    # This file is specific to the publish date if it exists.
    publish_date_html = None
    try:
        publish_date_html = minidom.parseString(zf.read('OEBPS/pr01.html'))
    except KeyError:
        # Most books store authors using epub tags, so no worries.
        pass


    file_size_in_bytes = os.path.getsize(filepath)

    data = odict({
        'epub_version': _discover_epub_version(opf_xmldoc),
        'title': _discover_title(opf_xmldoc),
        'language': _discover_language(opf_xmldoc),
        'description': _discover_description(opf_xmldoc),
        'authors': _discover_authors(opf_xmldoc, authors_html=authors_html),
        'publisher': _discover_publisher(opf_xmldoc),
        'publication_date': _discover_publication_date(opf_xmldoc,
                                                       date_html=publish_date_html),
        'identifiers': _discover_identifiers(opf_xmldoc),
        'subject': _discover_subject(opf_xmldoc),
        'file_size_in_bytes': file_size_in_bytes,
    })

    if read_cover_image:
        cover_image_content, cover_image_extension = _discover_cover_image(zf, opf_xmldoc, opf_filepath)
        data.cover_image_content = cover_image_content
        data.cover_image_extension = cover_image_extension

    if read_toc:
        data.toc = _discover_toc(zf, opf_xmldoc, opf_filepath)

    return data


def get_epub_opf_xml(filepath):
    '''
    Returns the file.OPF contents of the ePub file
    '''
    if not zipfile.is_zipfile(filepath):
        raise EPubException('Unknown file')

    # print('Reading ePub file: {}'.format(filepath))
    zf = zipfile.ZipFile(filepath, 'r', compression=zipfile.ZIP_DEFLATED, allowZip64=True)
    container = zf.read('META-INF/container.xml')
    container_xmldoc = minidom.parseString(container)
    # e.g.: <rootfile full-path="content.opf" media-type="application/oebps-package+xml"/>
    opf_filepath = container_xmldoc.getElementsByTagName('rootfile')[0].attributes['full-path'].value
    return zf.read(opf_filepath)

1	import base64	1✔
2	import os	1✔
3	import os.path	1✔
4	from xml.dom import minidom	1✔
5	import zipfile	1✔
6	import sys	1✔
7
8	from epub_meta.exceptions import EPubException	1✔
9
10
11	IS_PY2 = sys.version_info < (3, 0)	1✔
12
13	if IS_PY2:	1✔
14	from urllib import unquote	×
15	else:
16	from urllib.parse import unquote	1✔
17
18
19	class odict(dict):	1✔
20	__setattr__ = dict.__setitem__	1✔
21	__delattr__ = dict.__delitem__	1✔
22
23	def __getattr__(self, attr):	1✔
24	return self.get(attr)	1✔
25
26
27	def iterate_all_tags(root):	1✔
28	for node in root.childNodes:	×
29	if node.nodeType != node.ELEMENT_NODE:	×
30	continue	×
31
32	yield node	×
33
34	for subnode in iterate_all_tags(node):	×
35	yield subnode	×
36
37
38	def find_tag(xmldoc, tag_name, attr, value):	1✔
39	# print('Finding tag: <{} {}="{}">'.format(tag_name, attr, value))
40	for tag in xmldoc.getElementsByTagName(tag_name):	1✔
41	if attr in tag.attributes.keys() and tag.attributes[attr].value == value:	1✔
42	return tag	1✔
43
44
45	def find_img_tag(xmldoc, tag_name, attr, value):	1✔
46	# print('Finding img tag: <{} {}="{}">'.format(tag_name, attr, value))
47	for tag in xmldoc.getElementsByTagName(tag_name):	1✔
48	if attr in tag.attributes.keys() and tag.attributes[attr].value == value:	1✔
49	if 'href' in tag.attributes.keys():	1✔
50	filepath = unquote(tag.attributes['href'].value)	1✔
51	filename, file_extension = os.path.splitext(filepath)	1✔
52	if file_extension in ('.gif', '.jpg', '.jpeg', '.png', '.svg'):	1✔
53	return filepath, file_extension	1✔
54	return None, None	1✔
55
56
57	def _discover_epub_version(opf_xmldoc):	1✔
58	try:	1✔
59	return opf_xmldoc.getElementsByTagName('package')[0].attributes['version'].value	1✔
60	except (KeyError, IndexError):	×
61	return None	×
62
63
64	def __discover_dc(opf_xmldoc, name, first_only=True):	1✔
65	value = None	1✔
66	try:	1✔
67	if first_only:	1✔
68	node = opf_xmldoc.getElementsByTagName(name)[0].firstChild	1✔
69	if node:	×
70	value = node.nodeValue	×
71	else:
72	value = [n.firstChild.nodeValue for n in opf_xmldoc.getElementsByTagName(name) if n.firstChild]	1✔
73	except (KeyError, IndexError):	1✔
74	pass	1✔
75	if not value:	1✔
76	tag_name = 'dc:{}'.format(name)	1✔
77	try:	1✔
78	if first_only:	1✔
79	node = opf_xmldoc.getElementsByTagName(tag_name)[0].firstChild	1✔
80	if node:	1✔
81	value = node.nodeValue	1✔
82	else:
83	value = [n.firstChild.nodeValue for n in opf_xmldoc.getElementsByTagName(tag_name) if n.firstChild]	1✔
84	except (KeyError, IndexError):	1✔
85	pass	1✔
86	if first_only:	1✔
87	return value.strip() if value else value	1✔
88	else:
89	return [v.strip() for v in value]	1✔
90
91
92	def _discover_title(opf_xmldoc):	1✔
93	return __discover_dc(opf_xmldoc, 'title')	1✔
94
95
96	def _discover_language(opf_xmldoc):	1✔
97	return __discover_dc(opf_xmldoc, 'language')	1✔
98
99
100	def _discover_description(opf_xmldoc):	1✔
101	return __discover_dc(opf_xmldoc, 'description')	1✔
102
103
104	def _find_author_from_dom(xmldoc):	1✔
105	# Only find a single author now with this algorithm but returning a list
106	# because that's what caller expects
107	authors = []	×
108
109	# First non-empty child node is author after the author 'tag'
110	found_author_tag = False	×
111
112	for tag in iterate_all_tags(xmldoc):	×
113	if not found_author_tag:	×
114	if tag.nodeName == 'strong' and tag.childNodes and (	×
115	tag.firstChild.nodeType == tag.firstChild.TEXT_NODE) and (
116	tag.firstChild.data in ('Author', 'Authors')):
117
118	found_author_tag = True	×
119	else:
120	# Find all paragraph tags BEFORE we find another span tag. Those
121	# are the author(s).
122	if tag.nodeName == 'span':	×
123	break	×
124
125	if tag.nodeName == 'p' and tag.childNodes and (	×
126	tag.firstChild.nodeType == tag.firstChild.TEXT_NODE):
127
128	data = tag.firstChild.data.strip()	×
129	if data:	×
130	authors.append(data)	×
131
132	return authors	×
133
134
135	def _discover_authors(opf_xmldoc, authors_html=None):	1✔
136	authors = __discover_dc(opf_xmldoc, 'creator', first_only=False)	1✔
137
138	# We've found large portion of books from specific publishers that store
139	# the authors in pr02.html in a very specific place.
140	if not authors and authors_html is not None:	1✔
141	authors = _find_author_from_dom(authors_html)	×
142
143	# Slow and inefficient way to remove duplicates but maintain ordering just
144	# in case the author order in epub is significant.
145	unique_authors = []	1✔
146	for author in authors:	1✔
147	if author not in unique_authors:	1✔
148	unique_authors.append(author)	1✔
149
150	return unique_authors	1✔
151
152
153	def _discover_publisher(opf_xmldoc):	1✔
154	return __discover_dc(opf_xmldoc, 'publisher')	1✔
155
156
157	def _find_publish_date_from_dom(xmldoc):	1✔
158	first_pub = 'First published:'	×
159
160	for tag in iterate_all_tags(xmldoc):	×
161	if tag.nodeName == 'p' and tag.childNodes and (	×
162	tag.firstChild.nodeType == tag.TEXT_NODE) and (
163	tag.firstChild.data.startswith(first_pub)):
164	return tag.firstChild.data.split(first_pub)[1].strip()	×
165
166
167	def _discover_publication_date(opf_xmldoc, date_html=None):	1✔
168	date = __discover_dc(opf_xmldoc, 'date')	1✔
169
170	if not date and date_html is not None:	1✔
171	date = _find_publish_date_from_dom(date_html)	×
172
173	return date	1✔
174
175
176	def _discover_identifiers(opf_xmldoc):	1✔
177	# ISBN 10, ISBN 13 etc
178	return __discover_dc(opf_xmldoc, 'identifier', first_only=False)	1✔
179
180
181	def _discover_subject(opf_xmldoc):	1✔
182	return __discover_dc(opf_xmldoc, 'subject', first_only=False)	1✔
183
184
185	def _discover_cover_image(zf, opf_xmldoc, opf_filepath):	1✔
186	'''
187	Find the cover image path in the OPF file.
188	Returns a tuple: (image content in base64, file extension)
189	'''
190	content = None	1✔
191	filepath = None	1✔
192	extension = None	1✔
193
194	# Strategies to discover the cover-image path:
195
196	# e.g.: <meta name="cover" content="cover"/>
197	tag = find_tag(opf_xmldoc, 'meta', 'name', 'cover')	1✔
198	if tag and 'content' in tag.attributes.keys():	1✔
199	item_id = tag.attributes['content'].value	1✔
200	if item_id:	1✔
201	# e.g.: <item href="cover.jpg" id="cover" media-type="image/jpeg"/>
202	filepath, extension = find_img_tag(opf_xmldoc, 'item', 'id', item_id)	1✔
203	if not filepath:	1✔
204	filepath, extension = find_img_tag(opf_xmldoc, 'item', 'id', 'cover-image')	1✔
205	if not filepath:	1✔
206	filepath, extension = find_img_tag(opf_xmldoc, 'item', 'id', 'cover')	1✔
207
208	# If we have found the cover image path:
209	if filepath:	1✔
210	# The cover image path is relative to the OPF file
211	base_dir = os.path.dirname(opf_filepath)	1✔
212	# Also, normalize the path (ie opfpath/../cover.jpg -> cover.jpg)
213	coverpath = os.path.normpath(os.path.join(base_dir, filepath))	1✔
214	try:	1✔
215	content = zf.read(coverpath)	1✔
216	except KeyError:	×
217	raise EPubException("Cannot read {} from EPub file {}".format(	×
218	coverpath, os.path.basename(zf.filename)))
219	content = base64.b64encode(content)	1✔
220
221	return content, extension	1✔
222
223
224	def _discover_toc(zf, opf_xmldoc, opf_filepath):	1✔
225	'''
226	Returns a list of objects: {title: str, src: str, level: int, index: int}
227	'''
228	toc = None	1✔
229
230	# ePub 3.x
231	tag = find_tag(opf_xmldoc, 'item', 'properties', 'nav')	1✔
232	if tag and 'href' in tag.attributes.keys():	1✔
233	filepath = unquote(tag.attributes['href'].value)	1✔
234	# The xhtml file path is relative to the OPF file
235	base_dir = os.path.dirname(opf_filepath)	1✔
236	# print('- Reading Nav file: {}/{}'.format(base_dir, filepath))
237	npath = os.path.normpath(os.path.join(base_dir, filepath))	1✔
238	nav_content = zf.read(npath)	1✔
239	toc_xmldoc = minidom.parseString(nav_content)	1✔
240
241	_toc = []	1✔
242
243	for n in toc_xmldoc.getElementsByTagName('a'):	1✔
244	if n.firstChild and ('href' in n.attributes.keys()):	1✔
245	href = unquote(n.attributes['href'].value)	1✔
246	# Discarding CFI links
247	if '.html' in href or '.xhtml' in href:	1✔
248	title = n.firstChild.nodeValue	1✔
249	# try the second node too (maybe the first child is an empty span)
250	if not title and n.firstChild.firstChild:	1✔
251	title = n.firstChild.firstChild.nodeValue	×
252
253	title = title.strip() if title else None	1✔
254
255	if title:	1✔
256	level = -1	1✔
257	parentNode = n.parentNode	1✔
258	avoid_infinite_loop = 0 # simple security issue to avoid infinite loop for bad epub files	1✔
259	while parentNode and parentNode.nodeName != 'nav' and avoid_infinite_loop < 50:	1✔
260	if parentNode.nodeName == 'ol': # count the depth of the a link related to ol items	1✔
261	level += 1	1✔
262	parentNode = parentNode.parentNode	1✔
263	avoid_infinite_loop += 1	1✔
264	level = max(level, 0) # root level is 0, not -1	1✔
265
266	_toc.append({'title': title, 'src': href, 'level': level})	1✔
267	if _toc:	1✔
268	toc = _toc	1✔
269
270	if not toc:	1✔
271	# ePub 2.x
272	tag = find_tag(opf_xmldoc, 'item', 'id', 'ncx')	1✔
273	if not tag:	1✔
274	tag = find_tag(opf_xmldoc, 'item', 'id', 'ncxtoc')	1✔
275	if tag and 'href' in tag.attributes.keys():	1✔
276	filepath = unquote(tag.attributes['href'].value)	1✔
277	# The ncx file path is relative to the OPF file
278	base_dir = os.path.dirname(opf_filepath)	1✔
279	# print('- Reading NCX file: {}/{}'.format(base_dir, filepath))
280	npath = os.path.normpath(os.path.join(base_dir, filepath))	1✔
281	ncx_content = zf.read(npath)	1✔
282
283	toc_xmldoc = minidom.parseString(ncx_content)	1✔
284
285	def read_nav_point(nav_point_node, level = 0):	1✔
286	items = []	1✔
287	item = {'title': None, 'src': None, 'level': level}	1✔
288	children_points = []	1✔
289	for item_node in nav_point_node.childNodes:	1✔
290	if item_node.nodeName in ('navLabel', 'ncx:navLabel'):	1✔
291	try:	1✔
292	text = item_node.getElementsByTagName('text')[0].firstChild	1✔
293	except IndexError:	1✔
294	try:	1✔
295	text = item_node.getElementsByTagName('ncx:text')[0].firstChild	1✔
296	except IndexError:	×
297	text = None	×
298
299	item['title'] = text.nodeValue.strip() if text and text.nodeValue else None	1✔
300	elif item_node.nodeName in ('content', 'ncx:content'):	1✔
301	if item_node.hasAttribute('src'):	1✔
302	item['src'] = item_node.attributes['src'].value	1✔
303	elif item_node.nodeName in ('navPoint', 'ncx:navPoint'):	1✔
304	children_points.append(item_node)	1✔
305
306	if item['title']:	1✔
307	items.append(item)	1✔
308	for child_node in children_points:	1✔
309	subitems = read_nav_point(child_node, level=level + 1)	1✔
310	items.extend(subitems)	1✔
311	return items	1✔
312
313	def read_nav_map(toc_xmldoc, level=0):	1✔
314	items = []	1✔
315	try:	1✔
316	nav_map_node = toc_xmldoc.getElementsByTagName('navMap')[0]	1✔
317	except IndexError:	1✔
318	# Some ebooks use the ncx: namespace so try that too
319	try:	1✔
320	nav_map_node = toc_xmldoc.getElementsByTagName('ncx:navMap')[0]	1✔
321	except IndexError:	×
322	print('Failed reading TOC')	×
323	return items	×
324
325	for nav_point in nav_map_node.childNodes:	1✔
326	if nav_point.nodeName in ('navPoint', 'ncx:navPoint'):	1✔
327	subitems = read_nav_point(nav_point, level=level)	1✔
328	items.extend(subitems)	1✔
329	return items	1✔
330
331	toc = read_nav_map(toc_xmldoc)	1✔
332
333	# add indexes
334	if toc:	1✔
335	for i, t in enumerate(toc):	1✔
336	t['index'] = i	1✔
337
338	return toc	1✔
339
340
341	def get_epub_metadata(filepath, read_cover_image=True, read_toc=True):	1✔
342	'''
343	References: http://idpf.org/epub/201 and http://idpf.org/epub/301
344	1. Parse META-INF/container.xml file and find the .OPF file path.
345	2. In the .OPF file, find the metadata
346	'''
347	if not zipfile.is_zipfile(filepath):	1✔
348	raise EPubException('Unknown file')	1✔
349
350	try:	1✔
351	# print('Reading ePub file: {}'.format(filepath))
352	zf = zipfile.ZipFile(filepath, 'r', compression=zipfile.ZIP_DEFLATED, allowZip64=True)	1✔
353	container = zf.read('META-INF/container.xml')	1✔
354	container_xmldoc = minidom.parseString(container)	1✔
355	# e.g.: <rootfile full-path="content.opf" media-type="application/oebps-package+xml"/>
356	opf_filepath = container_xmldoc.getElementsByTagName('rootfile')[0].attributes['full-path'].value	1✔
357
358	opf = zf.read(os.path.normpath(opf_filepath))	1✔
359	opf_xmldoc = minidom.parseString(opf)	1✔
360	except IndexError:	×
361	raise EPubException("Cannot parse raw metadata from {}".format(	×
362	os.path.basename(filepath)))
363
364	# This file is specific to the authors if it exists.
365	authors_html = None	1✔
366	try:	1✔
367	authors_html = minidom.parseString(zf.read('OEBPS/pr02.html'))	1✔
368	except KeyError:	1✔
369	# Most books store authors using epub tags, so no worries.
370	pass	1✔
371
372	# This file is specific to the publish date if it exists.
373	publish_date_html = None	1✔
374	try:	1✔
375	publish_date_html = minidom.parseString(zf.read('OEBPS/pr01.html'))	1✔
376	except KeyError:	1✔
377	# Most books store authors using epub tags, so no worries.
378	pass	1✔
379
380
381	file_size_in_bytes = os.path.getsize(filepath)	1✔
382
383	data = odict({	1✔
384	'epub_version': _discover_epub_version(opf_xmldoc),
385	'title': _discover_title(opf_xmldoc),
386	'language': _discover_language(opf_xmldoc),
387	'description': _discover_description(opf_xmldoc),
388	'authors': _discover_authors(opf_xmldoc, authors_html=authors_html),
389	'publisher': _discover_publisher(opf_xmldoc),
390	'publication_date': _discover_publication_date(opf_xmldoc,
391	date_html=publish_date_html),
392	'identifiers': _discover_identifiers(opf_xmldoc),
393	'subject': _discover_subject(opf_xmldoc),
394	'file_size_in_bytes': file_size_in_bytes,
395	})
396
397	if read_cover_image:	1✔
398	cover_image_content, cover_image_extension = _discover_cover_image(zf, opf_xmldoc, opf_filepath)	1✔
399	data.cover_image_content = cover_image_content	1✔
400	data.cover_image_extension = cover_image_extension	1✔
401
402	if read_toc:	1✔
403	data.toc = _discover_toc(zf, opf_xmldoc, opf_filepath)	1✔
404
405	return data	1✔
406
407
408	def get_epub_opf_xml(filepath):	1✔
409	'''
410	Returns the file.OPF contents of the ePub file
411	'''
412	if not zipfile.is_zipfile(filepath):	1✔
413	raise EPubException('Unknown file')	×
414
415	# print('Reading ePub file: {}'.format(filepath))
416	zf = zipfile.ZipFile(filepath, 'r', compression=zipfile.ZIP_DEFLATED, allowZip64=True)	1✔
417	container = zf.read('META-INF/container.xml')	1✔
418	container_xmldoc = minidom.parseString(container)	1✔
419	# e.g.: <rootfile full-path="content.opf" media-type="application/oebps-package+xml"/>
420	opf_filepath = container_xmldoc.getElementsByTagName('rootfile')[0].attributes['full-path'].value	1✔
421	return zf.read(opf_filepath)	1✔

paulocheque / epub-meta / 39

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous