ebooklib.epub — EbookLib 0.20 documentation

# Source code for ebooklib.epub

    # This file is part of EbookLib.
    # Copyright (c) 2013 Aleksandar Erkalovic <aerkalov@gmail.com>
    #
    # EbookLib is free software: you can redistribute it and/or modify
    # it under the terms of the GNU Affero General Public License as published by
    # the Free Software Foundation, either version 3 of the License, or
    # (at your option) any later version.
    #
    # EbookLib is distributed in the hope that it will be useful,
    # but WITHOUT ANY WARRANTY; without even the implied warranty of
    # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    # GNU Affero General Public License for more details.
    #
    # You should have received a copy of the GNU Affero General Public License
    # along with EbookLib.  If not, see <http://www.gnu.org/licenses/>.

    import logging
    import os.path
    import posixpath as zip_path
    import sys
    import uuid
    import warnings
    import zipfile
    from collections import OrderedDict

    import six

    try:
        from urllib.parse import unquote
    except ImportError:
        from urllib import unquote

    from lxml import etree

    import ebooklib
    from ebooklib.utils import Directory, get_pages_for_items, guess_type, parse_html_string, parse_string

    # Version of EPUB library
    VERSION = (0, 20, 0)

    NAMESPACES = {
        "XML": "http://www.w3.org/XML/1998/namespace",
        "EPUB": "http://www.idpf.org/2007/ops",
        "DAISY": "http://www.daisy.org/z3986/2005/ncx/",
        "OPF": "http://www.idpf.org/2007/opf",
        "CONTAINERNS": "urn:oasis:names:tc:opendocument:xmlns:container",
        "DC": "http://purl.org/dc/elements/1.1/",
        "XHTML": "http://www.w3.org/1999/xhtml",
    }

    # XML Templates

    CONTAINER_PATH = "META-INF/container.xml"

    CONTAINER_XML = """<?xml version="1.0" encoding="utf-8"?>
    <container xmlns="urn:oasis:names:tc:opendocument:xmlns:container" version="1.0">
      <rootfiles>
        <rootfile media-type="application/oebps-package+xml" full-path="%(folder_name)s/content.opf"/>
      </rootfiles>
    </container>
    """

    NCX_XML = six.b("""<!DOCTYPE ncx PUBLIC "-//NISO//DTD ncx 2005-1//EN" "http://www.daisy.org/z3986/2005/ncx-2005-1.dtd">
    <ncx xmlns="http://www.daisy.org/z3986/2005/ncx/" version="2005-1" />""")

    NAV_XML = six.b(
        """<?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"/>"""
    )

    CHAPTER_XML = six.b(
        """<?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" epub:prefix="z3998: """
        """http://www.daisy.org/z3998/2012/vocab/structure/#"></html>"""
    )

    COVER_XML = six.b("""<?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" lang="en" xml:lang="en">
     <head>
      <style>
        body { margin: 0em; padding: 0em; }
        img { max-width: 100%; max-height: 100%; }
      </style>
     </head>
     <body>
       <img src="" alt="" />
     </body>
    </html>""")

    IMAGE_MEDIA_TYPES = ["image/jpeg", "image/jpg", "image/png", "image/svg+xml"]

    # TOC and navigation elements

    class Section(object):  # noqa: UP004
        def __init__(self, title, href=""):
            self.title = title
            self.href = href

    class Link(object):  # noqa: UP004
        def __init__(self, href, title, uid=None):
            self.href = href
            self.title = title
            self.uid = uid

    # Exceptions

    class EpubException(Exception):
        def __init__(self, code, msg):
            self.code = code
            self.msg = msg

        def __str__(self):
            return repr(self.msg)

    # Items

    class EpubItem(object):  # noqa: UP004
        """
        Base class for the items in a book.
        """

        def __init__(self, uid=None, file_name="", media_type="", content=None, manifest=True):
            """
            :Args:
              - uid: Unique identifier for this item (optional)
              - file_name: File name for this item (optional)
              - media_type: Media type for this item (optional)
              - content: Content for this item (optional)
              - manifest: Manifest for this item (optional)
            """
            self.id = uid
            self.file_name = file_name
            self.media_type = media_type
            self.content = content or six.b("")
            self.is_linear = True
            self.manifest = manifest

            self.book = None

        def get_id(self):
            """
            Returns unique identifier for this item.

            :Returns:
              Returns uid number as string.
            """
            return self.id

        def get_name(self):
            """
            Returns name for this item. By default it is always file name but it does not have to be.

            :Returns:
              Returns file name for this item.
            """
            return self.file_name

        def get_type(self):
            """
            Guess type according to the file extension. Might not be the best way how to do it, but it works for now.

            Items can be of type:
              - ITEM_UNKNOWN = 0
              - ITEM_IMAGE = 1
              - ITEM_STYLE = 2
              - ITEM_SCRIPT = 3
              - ITEM_NAVIGATION = 4
              - ITEM_VECTOR = 5
              - ITEM_FONT = 6
              - ITEM_VIDEO = 7
              - ITEM_AUDIO = 8
              - ITEM_DOCUMENT = 9
              - ITEM_COVER = 10

            We map type according to the extensions which are defined in ebooklib.EXTENSIONS.

            :Returns:
              Returns type of the item as number.
            """
            _, ext = zip_path.splitext(self.get_name())
            ext = ext.lower()

            for uid, ext_list in six.iteritems(ebooklib.EXTENSIONS):
                if ext in ext_list:
                    return uid

            return ebooklib.ITEM_UNKNOWN

        def get_content(self, default=None):
            """
            Returns content of the item. Content should be of type 'str' (Python 2) or 'bytes' (Python 3)

            :Args:
              - default: Default value for the content if it is not already defined.

            :Returns:
              Returns content of the item.
            """
            if default is None:
                default = six.b("")
            return self.content or default

        def set_content(self, content):
            """
            Sets content value for this item.

            :Args:
              - content: Content value
            """
            self.content = content

        def __str__(self):
            return "<EpubItem:{id}>".format(id=self.id)  # noqa: UP032

    class EpubNcx(EpubItem):
        "Represents Navigation Control File (NCX) in the EPUB."

        def __init__(self, uid="ncx", file_name="toc.ncx"):
            super(EpubNcx, self).__init__(uid=uid, file_name=file_name, media_type="application/x-dtbncx+xml")  # noqa: UP008

        def __str__(self):
            return "<EpubNcx:{id}>".format(id=self.id)  # noqa: UP032

    class EpubCover(EpubItem):
        """
        Represents Cover image in the EPUB file.
        """

        def __init__(self, uid="cover-img", file_name=""):
            super(EpubCover, self).__init__(uid=uid, file_name=file_name)  # noqa: UP008

        def get_type(self):
            return ebooklib.ITEM_COVER

        def __str__(self):
            return "<EpubCover:{id}:{file_name}>".format(id=self.id, file_name=self.file_name)  # noqa: UP032

    class EpubHtml(EpubItem):
        """
        Represents HTML document in the EPUB file.
        """

        _template_name = "chapter"

        def __init__(
            self,
            uid=None,
            file_name="",
            media_type="",
            content=None,
            title="",
            lang=None,
            direction=None,
            media_overlay=None,
            media_duration=None,
        ):
            super(EpubHtml, self).__init__(uid, file_name, media_type, content)  # noqa: UP008

            self.title = title
            self.lang = lang
            self.direction = direction

            self.media_overlay = media_overlay
            self.media_duration = media_duration

            self.metas = []
            self.links = []
            self.properties = []
            self.pages = []

        def is_chapter(self):
            """
            Returns if this document is chapter or not.

            :Returns:
              Returns book value.
            """
            return True

        def get_type(self):
            """
            Always returns ebooklib.ITEM_DOCUMENT as type of this document.

            :Returns:
              Always returns ebooklib.ITEM_DOCUMENT
            """

            return ebooklib.ITEM_DOCUMENT

        def set_language(self, lang):
            """
            Sets language for this book item. By default it will use language of the book but it
            can be overwritten with this call.
            """
            self.lang = lang

        def get_language(self):
            """
            Get language code for this book item. Language of the book item can be different from
            the language settings defined globaly for book.

            :Returns:
              As string returns language code.
            """
            return self.lang

        def add_meta(self, **kwgs):
            """
            Add additional <meta> to the document.

            >>> add_meta(name='viewport', content='width=device-width, initial-scale=1')
            """
            self.metas.append(kwgs)

        def get_metas(self):
            """
            Returns list of additional metas defined for this document.

            :Returns:
              As tuple return list of metas.
            """
            return (meta for meta in self.metas)

        def add_link(self, **kwgs):
            """
            Add additional link to the document. Links will be embeded only inside of this document.

            >>> add_link(href='styles.css', rel='stylesheet', type='text/css')
            """
            self.links.append(kwgs)
            if kwgs.get("type") == "text/javascript":
                if "scripted" not in self.properties:
                    self.properties.append("scripted")

        def get_links(self):
            """
            Returns list of additional links defined for this document.

            :Returns:
              As tuple return list of links.
            """
            return (link for link in self.links)

        def get_links_of_type(self, link_type):
            """
            Returns list of additional links of specific type.

            :Returns:
              As tuple returns list of links.
            """
            return (link for link in self.links if link.get("type", "") == link_type)

        def add_item(self, item):
            """
            Add other item to this document. It will create additional links according to the item type.

            :Args:
              - item: item we want to add defined as instance of EpubItem
            """
            if item.get_type() == ebooklib.ITEM_STYLE:
                self.add_link(href=item.get_name(), rel="stylesheet", type="text/css")

            if item.get_type() == ebooklib.ITEM_SCRIPT:
                self.add_link(src=item.get_name(), type="text/javascript")

        def get_body_content(self):
            """
            Returns content of BODY element for this HTML document. Content will be of type 'str' (Python 2)
            or 'bytes' (Python 3).

            :Returns:
              Returns content of this document.
            """

            try:
                html_tree = parse_html_string(self.content)
            except Exception:
                return six.b("")

            html_root = html_tree.getroottree()

            if len(html_root.find("body")) != 0:
                body = html_tree.find("body")

                tree_str = etree.tostring(body, pretty_print=True, encoding="utf-8", xml_declaration=False)

                # this is so stupid
                if tree_str.startswith(six.b("<body>")):
                    n = tree_str.rindex(six.b("</body>"))

                    return tree_str[6:n]

                return tree_str

            return six.b("")

        def get_content(self, default=None):
            """
            Returns content for this document as HTML string. Content will be of type 'str' (Python 2)
            or 'bytes' (Python 3).

            :Args:
              - default: Default value for the content if it is not defined.

            :Returns:
              Returns content of this document.
            """

            tree = parse_string(self.book.get_template(self._template_name))
            tree_root = tree.getroot()

            tree_root.set("lang", self.lang or self.book.language)
            tree_root.attrib["{%s}lang" % NAMESPACES["XML"]] = self.lang or self.book.language  # noqa

            # add to the head also
            #  <meta charset="utf-8" />

            try:
                html_tree = parse_html_string(self.content)
            except Exception:
                return six.b("")

            _html_root = html_tree.getroottree()

            # create and populate head

            _head = etree.SubElement(tree_root, "head")

            for meta in self.metas:
                _meta = etree.SubElement(_head, "meta", meta)

            if self.title != "":
                _title = etree.SubElement(_head, "title")
                _title.text = self.title

            for lnk in self.links:
                if lnk.get("type") == "text/javascript":
                    _lnk = etree.SubElement(_head, "script", lnk)
                    # force <script></script>
                    _lnk.text = ""
                else:
                    _lnk = etree.SubElement(_head, "link", lnk)

            # this should not be like this
            # head = html_root.find('head')
            # if head is not None:
            #     for i in head.getchildren():
            #         if i.tag == 'title' and self.title != '':
            #             continue
            #         _head.append(i)

            # create and populate body

            _body = etree.SubElement(tree_root, "body")
            if self.direction:
                _body.set("dir", self.direction)
                tree_root.set("dir", self.direction)

            body = html_tree.find("body")
            if body is not None:
                for i in body.getchildren():
                    _body.append(i)

            tree_str = etree.tostring(tree, pretty_print=True, encoding="utf-8", xml_declaration=True)

            return tree_str

        def __str__(self):
            return "<EpubHtml:{id}:{file_name}>".format(id=self.id, file_name=self.file_name)  # noqa: UP032

    class EpubCoverHtml(EpubHtml):
        """
        Represents Cover page in the EPUB file.
        """

        def __init__(self, uid="cover", file_name="cover.xhtml", image_name="", title="Cover"):
            super(EpubCoverHtml, self).__init__(uid=uid, file_name=file_name, title=title)  # noqa: UP008

            self.image_name = image_name
            self.is_linear = False

        def is_chapter(self):
            """
            Returns if this document is chapter or not.

            :Returns:
              Returns book value.
            """

            return False

        def get_content(self):
            """
            Returns content for cover page as HTML string. Content will be of type 'str' (Python 2) or 'bytes' (Python 3).

            :Returns:
              Returns content of this document.
            """

            self.content = self.book.get_template("cover")

            tree = parse_string(super(EpubCoverHtml, self).get_content())  # noqa: UP008
            tree_root = tree.getroot()

            images = tree_root.xpath("//xhtml:img", namespaces={"xhtml": NAMESPACES["XHTML"]})

            images[0].set("src", self.image_name)
            images[0].set("alt", self.title)

            tree_str = etree.tostring(tree, pretty_print=True, encoding="utf-8", xml_declaration=True)

            return tree_str

        def __str__(self):
            return "<EpubCoverHtml:{id}:{file_name}>".format(id=self.id, file_name=self.file_name)  # noqa: UP032

    class EpubNav(EpubHtml):
        """
        Represents Navigation Document in the EPUB file.
        """

        def __init__(self, uid="nav", file_name="nav.xhtml", media_type="application/xhtml+xml", title="", direction=None):
            super(EpubNav, self).__init__(  # noqa: UP008
                uid=uid, file_name=file_name, media_type=media_type, title=title, direction=direction
            )

        def is_chapter(self):
            """
            Returns if this document is chapter or not.

            :Returns:
              Returns book value.
            """

            return False

        def __str__(self):
            return "<EpubNav:{id}:{file_name}>".format(id=self.id, file_name=self.file_name)  # noqa: UP032

    class EpubImage(EpubItem):
        """
        Represents Image in the EPUB file.
        """

        def __init__(self, *args, **kwargs):
            super(EpubImage, self).__init__(*args, **kwargs)  # noqa: UP008

        def get_type(self):
            return ebooklib.ITEM_IMAGE

        def __str__(self):
            return "<EpubImage:{id}:{file_name}>".format(id=self.id, file_name=self.file_name)  # noqa: UP032

    class EpubSMIL(EpubItem):
        def __init__(self, uid=None, file_name="", content=None):
            super(EpubSMIL, self).__init__(uid=uid, file_name=file_name, media_type="application/smil+xml", content=content)  # noqa: UP008

        def get_type(self):
            return ebooklib.ITEM_SMIL

        def __str__(self):
            return "<EpubSMIL:{id}:{file_name}>".format(id=self.id, file_name=self.file_name)  # noqa: UP032

    # EpubBook

    class EpubBook(object):  # noqa: UP004
        def __init__(self):
            self.EPUB_VERSION = None

            self.reset()

            # we should have options here

        def reset(self):
            "Initialises all needed variables to default values"

            self.metadata = {}
            self.items = []
            self.spine = []
            self.guide = []
            self.pages = []
            self.toc = []
            self.bindings = []

            self.IDENTIFIER_ID = "id"
            self.FOLDER_NAME = "EPUB"

            self._id_html = 0
            self._id_image = 0
            self._id_static = 0

            self.title = ""
            self.language = "en"
            self.direction = None

            self.templates = {"ncx": NCX_XML, "nav": NAV_XML, "chapter": CHAPTER_XML, "cover": COVER_XML}

            self.add_metadata(
                "OPF",
                "generator",
                "",
                {"name": "generator", "content": "Ebook-lib {}".format(".".join([str(s) for s in VERSION]))},
            )

            # default to using a randomly-unique identifier if one is not specified manually
            self.set_identifier(str(uuid.uuid4()))

            # custom prefixes and namespaces to be set to the content.opf doc
            self.prefixes = []
            self.namespaces = {}

        def set_identifier(self, uid):
            """
            Sets unique id for this epub

            :Args:
              - uid: Value of unique identifier for this book
            """

            self.uid = uid

            self.set_unique_metadata("DC", "identifier", self.uid, {"id": self.IDENTIFIER_ID})

        def set_title(self, title):
            """
            Set title. You can set multiple titles.

            :Args:
              - title: Title value
            """

            self.title = title

            self.add_metadata("DC", "title", self.title)

        def set_language(self, lang):
            """
            Set language for this epub. You can set multiple languages. Specific items in the book can have
            different language settings.

            :Args:
              - lang: Language code
            """

            self.language = lang

            self.add_metadata("DC", "language", lang)

        def set_direction(self, direction):
            """
            :Args:
              - direction: Options are "ltr", "rtl" and "default"
            """

            self.direction = direction

        def set_cover(self, file_name, content, create_page=True):
            """
            Set cover and create cover document if needed.

            :Args:
              - file_name: file name of the cover page
              - content: Content for the cover image
              - create_page: Should cover page be defined. Defined as bool value (optional). Default value is True.
            """

            # as it is now, it can only be called once
            c0 = EpubCover(file_name=file_name)
            c0.content = content
            self.add_item(c0)

            if create_page:
                c1 = EpubCoverHtml(image_name=file_name)
                self.add_item(c1)

            self.add_metadata(None, "meta", "", OrderedDict([("name", "cover"), ("content", "cover-img")]))

        def add_author(self, author, file_as=None, role=None, uid="creator"):
            "Add author for this document"

            self.add_metadata("DC", "creator", author, {"id": uid})

            if file_as:
                self.add_metadata(
                    None, "meta", file_as, {"refines": "#" + uid, "property": "file-as", "scheme": "marc:relators"}
                )
            if role:
                self.add_metadata(None, "meta", role, {"refines": "#" + uid, "property": "role", "scheme": "marc:relators"})

        def add_metadata(self, namespace, name, value, others=None):
            "Add metadata"

            if namespace in NAMESPACES:
                namespace = NAMESPACES[namespace]

            if namespace not in self.metadata:
                self.metadata[namespace] = {}

            if name not in self.metadata[namespace]:
                self.metadata[namespace][name] = []

            self.metadata[namespace][name].append((value, others))

        def get_metadata(self, namespace, name):
            "Retrieve metadata"

            if namespace in NAMESPACES:
                namespace = NAMESPACES[namespace]

            return self.metadata[namespace].get(name, [])

        def set_unique_metadata(self, namespace, name, value, others=None):
            "Add metadata if metadata with this identifier does not already exist, otherwise update existing metadata."

            if namespace in NAMESPACES:
                namespace = NAMESPACES[namespace]

            if namespace in self.metadata and name in self.metadata[namespace]:
                self.metadata[namespace][name] = [(value, others)]
            else:
                self.add_metadata(namespace, name, value, others)

        def add_item(self, item):
            """
            Add additional item to the book. If not defined, media type and chapter id will be defined
            for the item.

            :Args:
              - item: Item instance
            """
            if item.media_type == "":
                (has_guessed, media_type) = guess_type(item.get_name().lower())

                if has_guessed:
                    if media_type is not None:
                        item.media_type = media_type
                    else:
                        item.media_type = has_guessed
                else:
                    item.media_type = "application/octet-stream"

            if not item.get_id():
                # make chapter_, image_ and static_ configurable
                if isinstance(item, EpubHtml):
                    item.id = "chapter_{id_html}".format(id_html=self._id_html)  # noqa: UP032
                    self._id_html += 1
                    # If there's a page list, append it to the book's page list
                    self.pages += item.pages
                elif isinstance(item, EpubImage):
                    item.id = "image_{id_image}".format(id_image=self._id_image)  # noqa: UP032
                    self._id_image += 1
                else:
                    item.id = "static_{id_static}".format(id_static=self._id_static)  # noqa: UP032
                    self._id_static += 1

            item.book = self
            self.items.append(item)

            return item

        def get_item_with_id(self, uid):
            """
            Returns item for defined UID.

            >>> book.get_item_with_id('image_001')

            :Args:
              - uid: UID for the item

            :Returns:
              Returns item object. Returns None if nothing was found.
            """
            for item in self.get_items():
                if item.id == uid:
                    return item

            return None

        def get_item_with_href(self, href):
            """
            Returns item for defined HREF.

            >>> book.get_item_with_href('EPUB/document.xhtml')

            :Args:
              - href: HREF for the item we are searching for

            :Returns:
              Returns item object. Returns None if nothing was found.
            """
            for item in self.get_items():
                if item.get_name() == href:
                    return item

            return None

        def get_items(self):
            """
            Returns all items attached to this book.

            :Returns:
              Returns all items as tuple.
            """
            return (item for item in self.items)

        def get_items_of_type(self, item_type):
            """
            Returns all items of specified type.

            >>> book.get_items_of_type(epub.ITEM_IMAGE)

            :Args:
              - item_type: Type for items we are searching for

            :Returns:
              Returns found items as tuple.
            """
            return (item for item in self.items if item.get_type() == item_type)

        def get_items_of_media_type(self, media_type):
            """
            Returns all items of specified media type.

            :Args:
              - media_type: Media type for items we are searching for

            :Returns:
              Returns found items as tuple.
            """
            return (item for item in self.items if item.media_type == media_type)

        def set_template(self, name, value):
            """
            Defines templates which are used to generate certain types of pages. When defining new value for the template
            we have to use content of type 'str' (Python 2) or 'bytes' (Python 3).

            At the moment we use these templates:
              - ncx
              - nav
              - chapter
              - cover

            :Args:
              - name: Name for the template
              - value: Content for the template
            """

            self.templates[name] = value

        def get_template(self, name):
            """
            Returns value for the template.

            :Args:
              - name: template name

            :Returns:
              Value of the template.
            """
            return self.templates.get(name)

        def add_prefix(self, name, uri):
            """
            Appends custom prefix to be added to the content.opf document

            >>> epub_book.add_prefix('bkterms', 'http://booktype.org/')

            :Args:
              - name: namespave name
              - uri: URI for the namespace
            """

            self.prefixes.append("{name}: {uri}".format(name=name, uri=uri))  # noqa: UP032

    class EpubWriter(object):  # noqa: UP004
        DEFAULT_OPTIONS = {
            "epub2_guide": True,
            "epub3_landmark": True,
            "epub3_pages": True,
            "landmark_title": "Guide",
            "pages_title": "Pages",
            "spine_direction": True,
            "package_direction": False,
            "play_order": {"enabled": False, "start_from": 1},
            "raise_exceptions": False,
            "compresslevel": 6,
        }

        def __init__(self, name, book, options=None):
            self.file_name = name
            self.book = book

            self.options = dict(self.DEFAULT_OPTIONS)
            if options:
                self.options.update(options)

            self._init_play_order()

        def _init_play_order(self):
            self._play_order = {"enabled": False, "start_from": 1}

            try:
                self._play_order["enabled"] = self.options["play_order"]["enabled"]
                self._play_order["start_from"] = self.options["play_order"]["start_from"]
            except KeyError:
                pass

        def process(self):
            # should cache this html parsing so we don't do it for every plugin
            for plg in self.options.get("plugins", []):
                if hasattr(plg, "before_write"):
                    plg.before_write(self.book)

            for item in self.book.get_items():
                if isinstance(item, EpubHtml):
                    for plg in self.options.get("plugins", []):
                        if hasattr(plg, "html_before_write"):
                            plg.html_before_write(self.book, item)

        def _write_container(self):
            container_xml = CONTAINER_XML % {"folder_name": self.book.FOLDER_NAME}
            self.out.writestr(CONTAINER_PATH, container_xml)

        def _write_opf_metadata(self, root):
            # This is really not needed
            # problem is uppercase/lowercase
            # for ns_name, values in six.iteritems(self.book.metadata):
            #     if ns_name:
            #         for n_id, ns_url in six.iteritems(NAMESPACES):
            #             if ns_name == ns_url:
            #                 nsmap[n_id.lower()] = NAMESPACES[n_id]

            nsmap = {"dc": NAMESPACES["DC"], "opf": NAMESPACES["OPF"]}
            nsmap.update(self.book.namespaces)

            metadata = etree.SubElement(root, "metadata", nsmap=nsmap)

            el = etree.SubElement(metadata, "meta", {"property": "dcterms:modified"})
            if "mtime" in self.options:
                mtime = self.options["mtime"]
            else:
                import datetime

                mtime = datetime.datetime.now()
            el.text = mtime.strftime("%Y-%m-%dT%H:%M:%SZ")

            for ns_name, values in six.iteritems(self.book.metadata):
                if ns_name == NAMESPACES["OPF"]:
                    for values2 in values.values():
                        for v in values2:
                            if "property" in v[1] and v[1]["property"] == "dcterms:modified":
                                continue
                            try:
                                el = etree.SubElement(metadata, "meta", v[1])
                                if v[0]:
                                    el.text = v[0]
                            except ValueError:
                                logging.error("Could not create metadata.")
                else:
                    for name, values2 in six.iteritems(values):
                        for v in values2:
                            try:
                                if ns_name:
                                    el = etree.SubElement(metadata, "{%s}%s" % (ns_name, name), v[1])  # noqa: UP031
                                else:
                                    el = etree.SubElement(metadata, "{name}".format(name=name), v[1])  # noqa: UP032

                                el.text = v[0]
                            except ValueError:
                                logging.info('Could not create metadata "{name}".'.format(name=name))  # noqa: UP032

        def _write_opf_manifest(self, root):
            manifest = etree.SubElement(root, "manifest")
            _ncx_id = None

            # mathml, scripted, svg, remote-resources, and switch
            # nav
            # cover-image

            for item in self.book.get_items():
                if not item.manifest:
                    continue

                if isinstance(item, EpubNav):
                    etree.SubElement(
                        manifest,
                        "item",
                        {"href": item.get_name(), "id": item.id, "media-type": item.media_type, "properties": "nav"},
                    )
                elif isinstance(item, EpubNcx):
                    _ncx_id = item.id
                    etree.SubElement(
                        manifest, "item", {"href": item.file_name, "id": item.id, "media-type": item.media_type}
                    )

                elif isinstance(item, EpubCover):
                    etree.SubElement(
                        manifest,
                        "item",
                        {"href": item.file_name, "id": item.id, "media-type": item.media_type, "properties": "cover-image"},
                    )
                else:
                    opts = {"href": item.file_name, "id": item.id, "media-type": item.media_type}

                    if hasattr(item, "properties") and len(item.properties) > 0:
                        opts["properties"] = " ".join(item.properties)

                    if hasattr(item, "media_overlay") and item.media_overlay is not None:
                        opts["media-overlay"] = item.media_overlay

                    if hasattr(item, "media_duration") and item.media_duration is not None:
                        opts["duration"] = item.media_duration

                    etree.SubElement(manifest, "item", opts)

            return _ncx_id

        def _write_opf_spine(self, root, ncx_id):
            spine_attributes = {"toc": ncx_id or "ncx"}
            if self.book.direction and self.options["spine_direction"]:
                spine_attributes["page-progression-direction"] = self.book.direction

            spine = etree.SubElement(root, "spine", spine_attributes)

            for _item in self.book.spine:
                # this is for now
                # later we should be able to fetch things from tuple

                is_linear = True

                if isinstance(_item, tuple):
                    item = _item[0]

                    if len(_item) > 1:
                        if _item[1] == "no":
                            is_linear = False
                else:
                    item = _item

                if isinstance(item, EpubHtml):
                    opts = {"idref": item.get_id()}

                    if not item.is_linear or not is_linear:
                        opts["linear"] = "no"
                elif isinstance(item, EpubItem):
                    opts = {"idref": item.get_id()}

                    if not item.is_linear or not is_linear:
                        opts["linear"] = "no"
                else:
                    opts = {"idref": item}

                    try:
                        itm = self.book.get_item_with_id(item)

                        if not itm.is_linear or not is_linear:
                            opts["linear"] = "no"
                    except Exception:
                        pass

                etree.SubElement(spine, "itemref", opts)

        def _write_opf_guide(self, root):
            # - http://www.idpf.org/epub/20/spec/OPF_2.0.1_draft.htm#Section2.6

            if len(self.book.guide) > 0 and self.options.get("epub2_guide"):
                guide = etree.SubElement(root, "guide", {})

                for item in self.book.guide:
                    if "item" in item:
                        chap = item.get("item")
                        if chap:
                            _href = chap.file_name
                            _title = chap.title
                    else:
                        _href = item.get("href", "")
                        _title = item.get("title", "")

                    if _title is None:
                        _title = ""
                    _ref = etree.SubElement(
                        guide, "reference", {"type": item.get("type", ""), "title": _title, "href": _href}
                    )

        def _write_opf_bindings(self, root):
            if len(self.book.bindings) > 0:
                bindings = etree.SubElement(root, "bindings", {})
                for item in self.book.bindings:
                    etree.SubElement(bindings, "mediaType", item)

        def _write_opf_file(self, root):
            tree_str = etree.tostring(root, pretty_print=True, encoding="utf-8", xml_declaration=True)

            self.out.writestr("{FOLDER_NAME}/content.opf".format(FOLDER_NAME=self.book.FOLDER_NAME), tree_str)  # noqa: UP032

        def _write_opf(self):
            package_attributes = {
                "xmlns": NAMESPACES["OPF"],
                "unique-identifier": self.book.IDENTIFIER_ID,
                "version": "3.0",
            }
            if self.book.direction and self.options["package_direction"]:
                package_attributes["dir"] = self.book.direction

            root = etree.Element("package", package_attributes)

            prefixes = ["rendition: http://www.idpf.org/vocab/rendition/#"] + self.book.prefixes
            root.attrib["prefix"] = " ".join(prefixes)

            # METADATA
            self._write_opf_metadata(root)

            # MANIFEST
            _ncx_id = self._write_opf_manifest(root)

            # SPINE
            self._write_opf_spine(root, _ncx_id)

            # GUIDE
            self._write_opf_guide(root)

            # BINDINGS
            self._write_opf_bindings(root)

            # WRITE FILE
            self._write_opf_file(root)

        def _get_nav(self, item):
            # just a basic navigation for now
            nav_xml = parse_string(self.book.get_template("nav"))
            root = nav_xml.getroot()

            root.set("lang", self.book.language)
            root.attrib["{%s}lang" % NAMESPACES["XML"]] = self.book.language  # noqa

            nav_dir_name = os.path.dirname(item.file_name)

            head = etree.SubElement(root, "head")
            title = etree.SubElement(head, "title")
            title.text = item.title or self.book.title

            # for now this just handles css files and ignores others
            for _link in item.links:
                _lnk = etree.SubElement(
                    head, "link", {"href": _link.get("href", ""), "rel": "stylesheet", "type": "text/css"}
                )

            body = etree.SubElement(root, "body")
            if item.direction:
                body.set("dir", item.direction)
            nav = etree.SubElement(
                body,
                "nav",
                {
                    "{%s}type" % NAMESPACES["EPUB"]: "toc",  # noqa
                    "id": "id",
                    "role": "doc-toc",
                },
            )

            content_title = etree.SubElement(nav, "h2")
            content_title.text = item.title or self.book.title

            def _create_section(itm, items):
                ol = etree.SubElement(itm, "ol")
                for item in items:
                    if isinstance(item, tuple) or isinstance(item, list):
                        li = etree.SubElement(ol, "li")
                        if isinstance(item[0], EpubHtml):
                            a = etree.SubElement(li, "a", {"href": zip_path.relpath(item[0].file_name, nav_dir_name)})
                        elif isinstance(item[0], Section) and item[0].href != "":
                            a = etree.SubElement(li, "a", {"href": zip_path.relpath(item[0].href, nav_dir_name)})
                        elif isinstance(item[0], Link):
                            a = etree.SubElement(li, "a", {"href": zip_path.relpath(item[0].href, nav_dir_name)})
                        else:
                            a = etree.SubElement(li, "span")
                        a.text = item[0].title

                        _create_section(li, item[1])

                    elif isinstance(item, Link):
                        li = etree.SubElement(ol, "li")
                        a = etree.SubElement(li, "a", {"href": zip_path.relpath(item.href, nav_dir_name)})
                        a.text = item.title
                    elif isinstance(item, EpubHtml):
                        li = etree.SubElement(ol, "li")
                        a = etree.SubElement(li, "a", {"href": zip_path.relpath(item.file_name, nav_dir_name)})
                        a.text = item.title

            _create_section(nav, self.book.toc)

            # LANDMARKS / GUIDE
            # - http://www.idpf.org/epub/30/spec/epub30-contentdocs.html#sec-xhtml-nav-def-types-landmarks

            if len(self.book.guide) > 0 and self.options.get("epub3_landmark"):
                # Epub2 guide types do not map completely to epub3 landmark types.
                guide_to_landscape_map = {"notes": "rearnotes", "text": "bodymatter"}

                guide_nav = etree.SubElement(body, "nav", {"{%s}type" % NAMESPACES["EPUB"]: "landmarks"})  # noqa: UP031

                guide_content_title = etree.SubElement(guide_nav, "h2")
                guide_content_title.text = self.options.get("landmark_title", "Guide")

                guild_ol = etree.SubElement(guide_nav, "ol")

                for elem in self.book.guide:
                    li_item = etree.SubElement(guild_ol, "li")

                    if "item" in elem:
                        chap = elem.get("item", None)
                        if chap:
                            _href = chap.file_name
                            _title = chap.title
                    else:
                        _href = elem.get("href", "")
                        _title = elem.get("title", "")

                    guide_type = elem.get("type", "")
                    a_item = etree.SubElement(
                        li_item,
                        "a",
                        {
                            "{%s}type" % NAMESPACES["EPUB"]: guide_to_landscape_map.get(guide_type, guide_type),  # noqa: UP031
                            "href": zip_path.relpath(_href, nav_dir_name),
                        },
                    )
                    a_item.text = _title

            # PAGE-LIST
            if self.options.get("epub3_pages"):
                inserted_pages = get_pages_for_items(
                    [item for item in self.book.get_items_of_type(ebooklib.ITEM_DOCUMENT) if not isinstance(item, EpubNav)]
                )

                if len(inserted_pages) > 0:
                    pagelist_nav = etree.SubElement(
                        body,
                        "nav",
                        {
                            "{%s}type" % NAMESPACES["EPUB"]: "page-list",  # noqa: UP031
                            "id": "pages",
                            "hidden": "hidden",
                        },
                    )
                    pagelist_content_title = etree.SubElement(pagelist_nav, "h2")
                    pagelist_content_title.text = self.options.get("pages_title", "Pages")

                    pages_ol = etree.SubElement(pagelist_nav, "ol")

                    for filename, pageref, label in inserted_pages:
                        li_item = etree.SubElement(pages_ol, "li")

                        _href = "{filename}#{pageref}".format(filename=filename, pageref=pageref)  # noqa: UP032
                        _title = label

                        a_item = etree.SubElement(
                            li_item,
                            "a",
                            {
                                "href": zip_path.relpath(_href, nav_dir_name),
                            },
                        )
                        a_item.text = _title

            tree_str = etree.tostring(nav_xml, pretty_print=True, encoding="utf-8", xml_declaration=True)

            return tree_str

        def _get_ncx(self):
            # we should be able to setup language for NCX as also
            ncx = parse_string(self.book.get_template("ncx"))
            root = ncx.getroot()

            head = etree.SubElement(root, "head")

            # get this id
            _uid = etree.SubElement(head, "meta", {"content": self.book.uid, "name": "dtb:uid"})
            _uid = etree.SubElement(head, "meta", {"content": "0", "name": "dtb:depth"})
            _uid = etree.SubElement(head, "meta", {"content": "0", "name": "dtb:totalPageCount"})
            _uid = etree.SubElement(head, "meta", {"content": "0", "name": "dtb:maxPageNumber"})

            doc_title = etree.SubElement(root, "docTitle")
            title = etree.SubElement(doc_title, "text")
            title.text = self.book.title

            #        doc_author = etree.SubElement(root, 'docAuthor')
            #        author = etree.SubElement(doc_author, 'text')
            #        author.text = 'Name of the person'

            # For now just make a very simple navMap
            nav_map = etree.SubElement(root, "navMap")

            def _add_play_order(nav_point):
                nav_point.set("playOrder", str(self._play_order["start_from"]))
                self._play_order["start_from"] += 1

            def _create_section(itm, items, uid):
                for item in items:
                    if isinstance(item, tuple) or isinstance(item, list):
                        section, subsection = item[0], item[1]

                        np = etree.SubElement(
                            itm,
                            "navPoint",
                            {
                                "id": section.get_id() if isinstance(section, EpubHtml) else "sep_{uid}".format(uid=uid)  # noqa: UP032
                            },
                        )

                        if self._play_order["enabled"]:
                            _add_play_order(np)

                        nl = etree.SubElement(np, "navLabel")
                        nt = etree.SubElement(nl, "text")
                        nt.text = section.title

                        # CAN NOT HAVE EMPTY SRC HERE
                        href = ""
                        if isinstance(section, EpubHtml):
                            href = section.file_name
                        elif isinstance(section, Section) and section.href != "":
                            href = section.href
                        elif isinstance(section, Link):
                            href = section.href

                        _nc = etree.SubElement(np, "content", {"src": href})

                        uid = _create_section(np, subsection, uid + 1)
                    elif isinstance(item, Link):
                        _parent = itm
                        _content = _parent.find("content")

                        if _content is not None:
                            if _content.get("src") == "":
                                _content.set("src", item.href)

                        np = etree.SubElement(itm, "navPoint", {"id": item.uid})

                        if self._play_order["enabled"]:
                            _add_play_order(np)

                        nl = etree.SubElement(np, "navLabel")
                        nt = etree.SubElement(nl, "text")
                        nt.text = item.title

                        _nc = etree.SubElement(np, "content", {"src": item.href})
                    elif isinstance(item, EpubHtml):
                        _parent = itm
                        _content = _parent.find("content")

                        if _content is not None:
                            if _content.get("src") == "":
                                _content.set("src", item.file_name)

                        np = etree.SubElement(itm, "navPoint", {"id": item.get_id()})

                        if self._play_order["enabled"]:
                            _add_play_order(np)

                        nl = etree.SubElement(np, "navLabel")
                        nt = etree.SubElement(nl, "text")
                        nt.text = item.title

                        _nc = etree.SubElement(np, "content", {"src": item.file_name})

                return uid

            _create_section(nav_map, self.book.toc, 0)

            tree_str = etree.tostring(root, pretty_print=True, encoding="utf-8", xml_declaration=True)

            return tree_str

        def _write_items(self):
            for item in self.book.get_items():
                if isinstance(item, EpubNcx):
                    self.out.writestr(
                        "{FOLDER_NAME}/{file_name}".format(FOLDER_NAME=self.book.FOLDER_NAME, file_name=item.file_name),  # noqa: UP032
                        self._get_ncx(),
                    )
                elif isinstance(item, EpubNav):
                    self.out.writestr(
                        "{FOLDER_NAME}/{file_name}".format(FOLDER_NAME=self.book.FOLDER_NAME, file_name=item.file_name),  # noqa: UP032
                        self._get_nav(item),
                    )
                elif item.manifest:
                    self.out.writestr(
                        "{FOLDER_NAME}/{file_name}".format(FOLDER_NAME=self.book.FOLDER_NAME, file_name=item.file_name),  # noqa: UP032
                        item.get_content(),
                    )
                else:
                    self.out.writestr("{file_name}".format(file_name=item.file_name), item.get_content())  # noqa: UP032

        def write(self):
            if six.PY2:
                self.out = zipfile.ZipFile(self.file_name, "w", zipfile.ZIP_DEFLATED)
            else:
                self.out = zipfile.ZipFile(
                    self.file_name, "w", zipfile.ZIP_DEFLATED, compresslevel=self.options["compresslevel"]
                )
            self.out.writestr("mimetype", "application/epub+zip", compress_type=zipfile.ZIP_STORED)

            self._write_container()
            self._write_opf()
            self._write_items()

            self.out.close()

    class EpubReader(object):  # noqa: UP004
        DEFAULT_OPTIONS = {"ignore_ncx": True}

        def __init__(self, epub_file_name, options=None):
            self.file_name = epub_file_name
            self.book = EpubBook()
            self.zf = None

            self.opf_file = ""
            self.opf_dir = ""

            self.options = dict(self.DEFAULT_OPTIONS)
            if options:
                self.options.update(options)

            self._check_deprecated()

        def _check_deprecated(self):
            if self.options.get("ignore_ncx") is None:
                warnings.warn("In the future version we will turn default option ignore_ncx to True.", stacklevel=2)

        def process(self):
            # should cache this html parsing so we don't do it for every plugin
            for plg in self.options.get("plugins", []):
                if hasattr(plg, "after_read"):
                    plg.after_read(self.book)

            for item in self.book.get_items():
                if isinstance(item, EpubHtml):
                    for plg in self.options.get("plugins", []):
                        if hasattr(plg, "html_after_read"):
                            plg.html_after_read(self.book, item)

        def load(self):
            self._load()

            return self.book

        def read_file(self, name):
            # Raises KeyError
            name = zip_path.normpath(name)
            return self.zf.read(name)

        def _load_container(self):
            meta_inf = self.read_file("META-INF/container.xml")
            tree = parse_string(meta_inf)

            for root_file in tree.findall(
                ".//xmlns:rootfile[@media-type]", namespaces={"xmlns": NAMESPACES["CONTAINERNS"]}
            ):
                if root_file.get("media-type") == "application/oebps-package+xml":
                    self.opf_file = root_file.get("full-path")
                    self.opf_dir = zip_path.dirname(self.opf_file)

        def _load_metadata(self):
            container_root = self.container.getroot()

            # get epub version
            self.book.version = container_root.get("version", None)

            # get unique-identifier
            if container_root.get("unique-identifier", None):
                self.book.IDENTIFIER_ID = container_root.get("unique-identifier")

            # get xml:lang
            # get metadata
            metadata = self.container.find("{%s}%s" % (NAMESPACES["OPF"], "metadata"))  # noqa: UP031

            nsmap = metadata.nsmap
            nstags = dict(six.iteritems(nsmap))
            default_ns = nstags.get(None, "")

            nsdict = {v: {} for v in nsmap.values()}

            def add_item(ns, tag, value, extra):
                if ns not in nsdict:
                    nsdict[ns] = {}

                values = nsdict[ns].setdefault(tag, [])
                values.append((value, extra))

            for t in metadata:
                if not etree.iselement(t) or t.tag is etree.Comment:
                    continue
                if t.tag == default_ns + "meta":
                    name = t.get("name")
                    others = dict(t.items())

                    if name and ":" in name:
                        prefix, name = name.split(":", 1)
                    else:
                        prefix = None

                    add_item(t.nsmap.get(prefix, prefix), name, t.text, others)
                else:
                    tag = t.tag[t.tag.rfind("}") + 1 :]

                    if (t.prefix and t.prefix.lower() == "dc") and tag == "identifier":
                        _id = t.get("id", None)

                        if _id:
                            self.book.IDENTIFIER_ID = _id

                    others = dict(t.items())
                    add_item(t.nsmap[t.prefix], tag, t.text, others)

            self.book.metadata = nsdict

            titles = self.book.get_metadata("DC", "title")
            if len(titles) > 0:
                self.book.title = titles[0][0]

            for value, others in self.book.get_metadata("DC", "identifier"):
                if others.get("id") == self.book.IDENTIFIER_ID:
                    self.book.uid = value

        def _load_manifest(self):
            for r in self.container.find("{%s}%s" % (NAMESPACES["OPF"], "manifest")):  # noqa: UP031
                if r is not None and r.tag != "{%s}item" % NAMESPACES["OPF"]:  # noqa: UP031
                    continue

                media_type = r.get("media-type")
                _properties = r.get("properties", "")

                if _properties:
                    properties = _properties.split(" ")
                else:
                    properties = []

                # people use wrong content types
                if media_type == "image/jpg":
                    media_type = "image/jpeg"

                if media_type == "application/x-dtbncx+xml":
                    ei = EpubNcx(uid=r.get("id"), file_name=unquote(r.get("href")))

                    ei.content = self.read_file(zip_path.join(self.opf_dir, ei.file_name))
                elif media_type == "application/smil+xml":
                    ei = EpubSMIL(uid=r.get("id"), file_name=unquote(r.get("href")))

                    ei.content = self.read_file(zip_path.join(self.opf_dir, ei.file_name))
                elif media_type == "application/xhtml+xml":
                    if "nav" in properties:
                        ei = EpubNav(uid=r.get("id"), file_name=unquote(r.get("href")))

                        ei.content = self.read_file(zip_path.join(self.opf_dir, r.get("href")))
                    elif "cover" in properties:
                        ei = EpubCoverHtml()

                        ei.content = self.read_file(zip_path.join(self.opf_dir, unquote(r.get("href"))))
                    else:
                        ei = EpubHtml()

                        ei.id = r.get("id")
                        ei.file_name = unquote(r.get("href"))
                        ei.media_type = media_type
                        ei.media_overlay = r.get("media-overlay", None)
                        ei.media_duration = r.get("duration", None)
                        ei.content = self.read_file(zip_path.join(self.opf_dir, ei.get_name()))
                        ei.properties = properties
                elif media_type in IMAGE_MEDIA_TYPES:
                    if "cover-image" in properties:
                        ei = EpubCover(uid=r.get("id"), file_name=unquote(r.get("href")))

                        ei.media_type = media_type
                        ei.content = self.read_file(zip_path.join(self.opf_dir, ei.get_name()))
                    else:
                        ei = EpubImage()

                        ei.id = r.get("id")
                        ei.file_name = unquote(r.get("href"))
                        ei.media_type = media_type
                        ei.content = self.read_file(zip_path.join(self.opf_dir, ei.get_name()))
                else:
                    # different types
                    ei = EpubItem()

                    ei.id = r.get("id")
                    ei.file_name = unquote(r.get("href"))
                    ei.media_type = media_type

                    ei.content = self.read_file(zip_path.join(self.opf_dir, ei.get_name()))

                self.book.add_item(ei)

        def _parse_ncx(self, data):
            tree = parse_string(data)
            tree_root = tree.getroot()

            nav_map = tree_root.find("{%s}navMap" % NAMESPACES["DAISY"])  # noqa: UP031

            def _get_children(elems, n, nid):
                label, content = "", ""
                children = []

                for a in elems.getchildren():
                    if a.tag == "{%s}navLabel" % NAMESPACES["DAISY"]:  # noqa: UP031
                        label = a.getchildren()[0].text
                    if a.tag == "{%s}content" % NAMESPACES["DAISY"]:  # noqa: UP031
                        content = a.get("src", "")
                    if a.tag == "{%s}navPoint" % NAMESPACES["DAISY"]:  # noqa: UP031
                        children.append(_get_children(a, n + 1, a.get("id", "")))

                if len(children) > 0:
                    if n == 0:
                        return children

                    return (Section(label, href=content), children)
                else:
                    return Link(content, label, nid)

            self.book.toc = _get_children(nav_map, 0, "")

        def _parse_nav(self, data, base_path, navtype="toc"):
            html_node = parse_html_string(data)
            if navtype == "toc":
                # parsing the table of contents
                nav_node = html_node.xpath("//nav[@*='toc']")[0]
            else:
                # parsing the list of pages
                _page_list = html_node.xpath("//nav[@*='page-list']")
                if len(_page_list) == 0:
                    return
                nav_node = _page_list[0]

            def parse_list(list_node):
                items = []

                for item_node in list_node.findall("li"):
                    sublist_node = item_node.find("ol")
                    link_node = item_node.find("a")

                    if sublist_node is not None:
                        title = item_node[0].text_content()
                        children = parse_list(sublist_node)

                        if link_node is not None and link_node.get("href"):
                            href = zip_path.normpath(zip_path.join(base_path, link_node.get("href")))
                            items.append((Section(title, href=href), children))
                        else:
                            items.append((Section(title), children))
                    elif link_node is not None and link_node.get("href"):
                        title = link_node.text_content()
                        href = zip_path.normpath(zip_path.join(base_path, link_node.get("href")))

                        items.append(Link(href, title))

                return items

            if navtype == "toc":
                self.book.toc = parse_list(nav_node.find("ol"))
            elif nav_node is not None:
                # generate the pages list if there is one
                self.book.pages = parse_list(nav_node.find("ol"))

                # generate the per-file pages lists
                # because of the order of parsing the files, this can't be done
                # when building the EpubHtml objects
                htmlfiles = {}
                for htmlfile in self.book.items:
                    if isinstance(htmlfile, EpubHtml):
                        htmlfiles[htmlfile.file_name] = htmlfile
                for page in self.book.pages:
                    try:
                        (filename, idref) = page.href.split("#")
                    except ValueError:
                        filename = page.href
                    if filename in htmlfiles:
                        htmlfiles[filename].pages.append(page)

        def _load_spine(self):
            spine = self.container.find("{%s}%s" % (NAMESPACES["OPF"], "spine"))  # noqa: UP031

            self.book.spine = [(t.get("idref"), t.get("linear", "yes")) for t in spine]

            toc = spine.get("toc", "")
            self.book.set_direction(spine.get("page-progression-direction", None))

            # should read ncx or nav file
            nav_item = next((item for item in self.book.items if isinstance(item, EpubNav)), None)
            if toc:
                if not self.options.get("ignore_ncx") or not nav_item:
                    try:
                        ncxFile = self.read_file(zip_path.join(self.opf_dir, self.book.get_item_with_id(toc).get_name()))
                    except KeyError:
                        raise EpubException(-1, "Can not find ncx file.")  # noqa: B904

                    self._parse_ncx(ncxFile)

        def _load_guide(self):
            guide = self.container.find("{%s}%s" % (NAMESPACES["OPF"], "guide"))  # noqa: UP031
            if guide is not None:
                self.book.guide = [{"href": t.get("href"), "title": t.get("title"), "type": t.get("type")} for t in guide]

        def _load_opf_file(self):
            try:
                s = self.read_file(self.opf_file)
            except KeyError:
                raise EpubException(-1, "Can not find container file")  # noqa: B904

            self.container = parse_string(s)

            self._load_metadata()
            self._load_manifest()
            self._load_spine()
            self._load_guide()

            # read nav file if found
            #
            nav_item = next((item for item in self.book.items if isinstance(item, EpubNav)), None)
            if nav_item:
                if self.options.get("ignore_ncx") or not self.book.toc:
                    self._parse_nav(nav_item.content, zip_path.dirname(nav_item.file_name), navtype="toc")
                self._parse_nav(nav_item.content, zip_path.dirname(nav_item.file_name), navtype="pages")

        def _load(self):
            self.zf = None

            if (six.PY3 and isinstance(self.file_name, (str, bytes, os.PathLike))) or (
                six.PY2 and isinstance(self.file_name, (six.string_types))
            ):
                if os.path.isdir(self.file_name):
                    self.zf = Directory(self.file_name)

            if self.zf is None:
                try:
                    self.zf = zipfile.ZipFile(self.file_name, "r", compression=zipfile.ZIP_DEFLATED, allowZip64=True)
                except zipfile.BadZipfile:
                    raise EpubException(0, "Bad Zip file")  # noqa: B904
                except zipfile.LargeZipFile:
                    raise EpubException(1, "Large Zip file")  # noqa: B904

            # 1st check metadata
            self._load_container()
            self._load_opf_file()

            self.zf.close()

    # WRITE

    def write_epub(name, book, options=None):
        """
        Creates epub file with the content defined in EpubBook.

        >>> ebooklib.write_epub('book.epub', book)

        :Args:
          - name: file name for the output file
          - book: instance of EpubBook
          - options: extra opions as dictionary (optional)
        """
        epub = EpubWriter(name, book, options)

        epub.process()

        try:
            epub.write()
        except OSError:
            warnings.warn("In the future throwing exceptions while writing will be default behavior.", stacklevel=2)
            t, v, tb = sys.exc_info()
            if options and options.get("raise_exceptions"):
                six.reraise(t, v, tb)
            else:
                return False

        return True

    # READ

    def read_epub(name, options=None):
        """
        Creates new instance of EpubBook with the content defined in the input file.

        >>> book = ebooklib.read_epub('book.epub')

        :Args:
          - name: full path to the input file
          - options: extra options as dictionary (optional)

        :Returns:
          Instance of EpubBook.
        """
        reader = EpubReader(name, options)

        book = reader.load()
        reader.process()

        return book