"""
lxml based OPF parser.
"""
import copy
import functools
import glob
import io
import json
import mimetypes
import os
import re
import sys
import textwrap
import traceback
import unittest
import urllib.parse
import uuid
from lxml import etree
from lxml.builder import ElementMaker
from ebook_converter.ebooks.oeb import base
from ebook_converter import constants as const
from ebook_converter.ebooks import escape_xpath_attr
from ebook_converter.constants_old import __appname__, __version__, \
filesystem_encoding
from ebook_converter.ebooks.metadata.toc import TOC
from ebook_converter.ebooks.metadata.utils import parse_opf, \
pretty_print_opf as _pretty_print
from ebook_converter.ebooks.metadata import string_to_authors, \
MetaInformation, check_isbn
from ebook_converter.ebooks.metadata.book.base import Metadata
from ebook_converter.utils.date import parse_date, isoformat
from ebook_converter.utils.localization import get_lang, canonicalize_lang
from ebook_converter import prints
from ebook_converter.utils.cleantext import clean_ascii_chars, clean_xml_chars
from ebook_converter.utils.config import tweaks
from ebook_converter.polyglot.urllib import unquote
pretty_print_opf = False
class PrettyPrint(object):
def __enter__(self):
global pretty_print_opf
pretty_print_opf = True
def __exit__(self, *args):
global pretty_print_opf
pretty_print_opf = False
pretty_print = PrettyPrint()
class Resource(object): # {{{
'''
Represents a resource (usually a file on the filesystem or a URL pointing
to the web. Such resources are commonly referred to in OPF files.
They have the interface:
:member:`path`
:member:`mime_type`
:method:`href`
'''
def __init__(self, href_or_path, basedir=os.getcwd(), is_path=True):
self.orig = href_or_path
self._href = None
self._basedir = basedir
self.path = None
self.fragment = ''
try:
self.mime_type = mimetypes.guess_type(href_or_path)[0]
except Exception:
self.mime_type = None
if self.mime_type is None:
self.mime_type = 'application/octet-stream'
if is_path:
path = href_or_path
if not os.path.isabs(path):
path = os.path.abspath(os.path.join(basedir, path))
if isinstance(path, bytes):
path = path.decode(filesystem_encoding)
self.path = path
else:
href_or_path = href_or_path
url = urllib.parse.urlparse(href_or_path)
if url[0] not in ('', 'file'):
self._href = href_or_path
else:
pc = url[2]
if isinstance(pc, str):
pc = pc.encode('utf-8')
pc = pc.decode('utf-8')
self.path = os.path.abspath(os.path.join(basedir,
pc.replace('/',
os.sep)))
self.fragment = url[-1]
def href(self, basedir=None):
"""
Return a URL pointing to this resource. If it is a file on the
filesystem the URL is relative to `basedir`.
`basedir`: If None, the basedir of this resource is used (see
:method:`set_basedir`).
If this resource has no basedir, then the current working directory is
used as the basedir.
"""
if basedir is None:
if self._basedir:
basedir = self._basedir
else:
basedir = os.getcwd()
if self.path is None:
return self._href
frag = ('#' + self.fragment) if self.fragment else ''
if self.path == basedir:
return frag
try:
rpath = os.path.relpath(self.path, basedir)
except ValueError:
# On windows path and basedir could be on different drives
rpath = self.path
if isinstance(rpath, bytes):
rpath = rpath.decode(filesystem_encoding)
return rpath.replace(os.sep, '/')+frag
def set_basedir(self, path):
self._basedir = path
def basedir(self):
return self._basedir
def __repr__(self):
return 'Resource(%s, %s)' % (repr(self.path), repr(self.href()))
# }}}
class ResourceCollection(object): # {{{
def __init__(self):
self._resources = []
def __iter__(self):
for r in self._resources:
yield r
def __len__(self):
return len(self._resources)
def __getitem__(self, index):
return self._resources[index]
def __bool__(self):
return len(self._resources) > 0
def __str__(self):
resources = map(repr, self)
return '[%s]' % ', '.join(resources)
__unicode__ = __str__
def __repr__(self):
return str(self)
def append(self, resource):
if not isinstance(resource, Resource):
raise ValueError('Can only append objects of type Resource')
self._resources.append(resource)
def remove(self, resource):
self._resources.remove(resource)
def replace(self, start, end, items):
'Same as list[start:end] = items'
self._resources[start:end] = items
@staticmethod
def from_directory_contents(top, topdown=True):
collection = ResourceCollection()
for spec in os.walk(top, topdown=topdown):
path = os.path.abspath(os.path.join(spec[0], spec[1]))
res = Resource.from_path(path)
res.set_basedir(top)
collection.append(res)
return collection
def set_basedir(self, path):
for res in self:
res.set_basedir(path)
# }}}
class ManifestItem(Resource): # {{{
@staticmethod
def from_opf_manifest_item(item, basedir):
href = item.get('href', None)
if href:
res = ManifestItem(href, basedir=basedir, is_path=True)
mt = item.get('media-type', '').strip()
if mt:
res.mime_type = mt
return res
@property
def media_type(self):
return self.mime_type
@media_type.setter
def media_type(self, val):
self.mime_type = val
def __unicode__representation__(self):
return (u'