ebook-convert 4.13.0__py3-none-any.whl

ebook_convert/__init__.py

@@ -0,0 +1,6 @@
+import importlib.resources
+import mimetypes
+
+
+mimetypes.init([str(importlib.resources.
+                files('ebook_convert') / 'data/mime.types')])

ebook_convert/constants.py

@@ -0,0 +1,59 @@
+VERSION = '0.1.0'
+CALIBRE_NS = 'http://calibre.kovidgoyal.net/2009/metadata'
+DC09_NS = 'http://purl.org/metadata/dublin_core'
+DC10_NS = 'http://purl.org/dc/elements/1.0/'
+DC11_NS = 'http://purl.org/dc/elements/1.1/'
+DCTERMS_NS = 'http://purl.org/dc/terms/'
+EPUB_NS = 'http://www.idpf.org/2007/ops'
+MATHML_NS = 'http://www.w3.org/1998/Math/MathML'
+MBP_NS = 'http://www.mobipocket.com'
+NCX_NS = 'http://www.daisy.org/z3986/2005/ncx/'
+OEB_DOC_NS = 'http://openebook.org/namespaces/oeb-document/1.0/'
+OPF1_NS = 'http://openebook.org/namespaces/oeb-package/1.0/'
+OPF2_NS = 'http://www.idpf.org/2007/opf'
+RE_NS = 'http://exslt.org/regular-expressions'
+SVG_NS = 'http://www.w3.org/2000/svg'
+XHTML_NS = 'http://www.w3.org/1999/xhtml'
+XLINK_NS = 'http://www.w3.org/1999/xlink'
+XMLNS_NS = 'http://www.w3.org/2000/xmlns/'
+XML_NS = 'http://www.w3.org/XML/1998/namespace'
+XSI_NS = 'http://www.w3.org/2001/XMLSchema-instance'
+
+DC_NSES = {DC09_NS, DC10_NS, DC11_NS}
+OPF_NAMESPACES = {'opf': OPF2_NS, 'dc': DC11_NS}
+OPF_NSES = {OPF1_NS, OPF2_NS}
+
+XHTML_BLOCK_TAGS = {'{%s}%s' % (XHTML_NS, x)
+                    for x in ('address', 'article', 'aside', 'audio',
+                              'blockquote', 'body', 'canvas', 'col',
+                              'colgroup', 'dd', 'div', 'dl', 'dt', 'fieldset',
+                              'figcaption', 'figure', 'footer', 'form', 'h1',
+                              'h2', 'h3', 'h4', 'h5', 'h6', 'header',
+                              'hgroup', 'hr', 'li', 'noscript', 'ol',
+                              'output', 'p', 'pre', 'script', 'section',
+                              'style', 'svg', 'table', 'tbody', 'td', 'tfoot',
+                              'th', 'thead', 'tr', 'ul', 'video', 'img')}
+
+OPF1_NSMAP = {'dc': DC11_NS,
+              'oebpackage': OPF1_NS}
+OPF2_NSMAP = {'calibre': CALIBRE_NS,
+              'dc': DC11_NS,
+              'dcterms': DCTERMS_NS,
+              'opf': OPF2_NS,
+              'xsi': XSI_NS}
+XPNSMAP = {'calibre': CALIBRE_NS,
+           'd09': DC09_NS,
+           'd10': DC10_NS,
+           'd11': DC11_NS,
+           'dt': DCTERMS_NS,
+           'epub': EPUB_NS,
+           'h': XHTML_NS,
+           'mathml': MATHML_NS,
+           'mbp': MBP_NS,
+           'ncx': NCX_NS,
+           'o1': OPF1_NS,
+           'o2': OPF2_NS,
+           're': RE_NS,
+           'svg': SVG_NS,
+           'xl': XLINK_NS,
+           'xsi': XSI_NS}

ebook_convert/constants_old.py

@@ -0,0 +1,109 @@
+import atexit
+import collections
+import importlib
+import locale
+import os
+import shutil
+import sys
+import tempfile
+
+
+__appname__ = 'ebook-convert'
+numeric_version = (4, 13, 0)
+__version__ = '.'.join([str(x) for x in numeric_version])
+__author__ = "foobar"
+
+"""
+Various run time constants.
+"""
+
+
+FAKE_PROTOCOL = 'ebco'
+preferred_encoding = locale.getpreferredencoding()
+filesystem_encoding = sys.getfilesystemencoding() or 'utf-8'
+DEBUG = os.getenv('CALIBRE_DEBUG') is not None
+
+
+def debug():
+    global DEBUG
+    DEBUG = True
+
+
+# plugins {{{
+
+
+class Plugins(collections.abc.Mapping):
+
+    def __init__(self):
+        self._plugins = {}
+        self.plugins = frozenset([])
+
+    def load_plugin(self, name):
+        if name in self._plugins:
+            return
+        # sys.path.insert(0, plugins_loc)
+        try:
+            del sys.modules[name]
+        except KeyError:
+            pass
+        plugin_err = ''
+        try:
+            p = importlib.import_module(name)
+        except Exception as err:
+            p = None
+            plugin_err = str(err)
+        self._plugins[name] = p, plugin_err
+
+    def __iter__(self):
+        return iter(self.plugins)
+
+    def __len__(self):
+        return len(self.plugins)
+
+    def __contains__(self, name):
+        return name in self.plugins
+
+    def __getitem__(self, name):
+        if name not in self.plugins:
+            raise KeyError('No plugin named %r' % name)
+        self.load_plugin(name)
+        return self._plugins[name]
+
+
+plugins = Plugins()
+# }}}
+
+# config_dir {{{
+
+CONFIG_DIR_MODE = 0o700
+
+bdir = os.path.abspath(os.path.expanduser(os.getenv('XDG_CONFIG_HOME',
+                                                    '~/.config')))
+config_dir = os.path.join(bdir, 'ebook-convert')
+try:
+    os.makedirs(config_dir, mode=CONFIG_DIR_MODE)
+except IOError:
+    pass
+
+if not os.path.exists(config_dir) or \
+        not os.access(config_dir, os.W_OK) or not \
+        os.access(config_dir, os.X_OK):
+    print('No write acces to', config_dir, 'using a temporary dir instead')
+    config_dir = tempfile.mkdtemp(prefix='ec-config-')
+
+    def cleanup_cdir():
+        try:
+            shutil.rmtree(config_dir)
+        except OSError:
+            pass
+    atexit.register(cleanup_cdir)
+# }}}
+
+
+def get_version():
+    '''Return version string for display to user '''
+    v = __version__
+    if numeric_version[-1] == 0:
+        v = v[:-2]
+
+    return v

ebook_convert/css_selectors/__init__.py

@@ -0,0 +1,8 @@
+from ebook_convert.css_selectors.parser import parse
+from ebook_convert.css_selectors.select import Select, INAPPROPRIATE_PSEUDO_CLASSES
+from ebook_convert.css_selectors.errors import SelectorError, SelectorSyntaxError, ExpressionError
+
+
+__license__ = 'GPL v3'
+__copyright__ = '2015, Kovid Goyal <kovid at kovidgoyal.net>'
+__all__ = ['parse', 'Select', 'INAPPROPRIATE_PSEUDO_CLASSES', 'SelectorError', 'SelectorSyntaxError', 'ExpressionError']

ebook_convert/css_selectors/errors.py

@@ -0,0 +1,17 @@
+__license__ = 'GPL v3'
+__copyright__ = '2015, Kovid Goyal <kovid at kovidgoyal.net>'
+
+
+class SelectorError(ValueError):
+
+    """Common parent for SelectorSyntaxError and ExpressionError"""
+
+
+class SelectorSyntaxError(SelectorError):
+
+    """Parsing a selector that does not match the grammar."""
+
+
+class ExpressionError(SelectorError):
+
+    """Unknown or unsupported selector (eg. pseudo-class)."""

ebook_convert/css_selectors/ordered_set.py

@@ -0,0 +1,129 @@
+import collections
+
+
+__license__ = 'GPL v3'
+__copyright__ = '2015, Kovid Goyal <kovid at kovidgoyal.net>'
+
+SLICE_ALL = slice(None)
+
+
+def is_iterable(obj):
+    """
+    Are we being asked to look up a list of things, instead of a single thing?
+    We check for the `__iter__` attribute so that this can cover types that
+    don't have to be known by this module, such as NumPy arrays.
+
+    Strings, however, should be considered as atomic values to look up, not
+    iterables.
+    """
+    return hasattr(obj, '__iter__') and not isinstance(obj, (str, bytes))
+
+
+class OrderedSet(collections.abc.MutableSet):
+    """
+    An OrderedSet is a custom MutableSet that remembers its order, so that
+    every entry has an index that can be looked up.
+    """
+    def __init__(self, iterable=None):
+        self.items = []
+        self.map = {}
+        if iterable is not None:
+            for item in iterable:
+                idx = self.map.get(item)
+                if idx is None:
+                    self.map[item] = len(self.items)
+                    self.items.append(item)
+
+    def __len__(self):
+        return len(self.items)
+
+    def __getitem__(self, index):
+        """
+        Get the item at a given index.
+
+        If `index` is a slice, you will get back that slice of items. If it's
+        the slice [:], exactly the same object is returned. (If you want an
+        independent copy of an OrderedSet, use `OrderedSet.copy()`.)
+
+        If `index` is an iterable, you'll get the OrderedSet of items
+        corresponding to those indices. This is similar to NumPy's
+        "fancy indexing".
+        """
+        if index == SLICE_ALL:
+            return self
+        elif hasattr(index, '__index__') or isinstance(index, slice):
+            result = self.items[index]
+            if isinstance(result, list):
+                return OrderedSet(result)
+            else:
+                return result
+        elif is_iterable(index):
+            return OrderedSet([self.items[i] for i in index])
+        else:
+            raise TypeError("Don't know how to index an OrderedSet by %r" %
+                    index)
+
+    def copy(self):
+        return OrderedSet(self)
+
+    def __getstate__(self):
+        return tuple(self)
+
+    def __setstate__(self, state):
+        self.__init__(state)
+
+    def __contains__(self, key):
+        return key in self.map
+
+    def add(self, key):
+        """
+        Add `key` as an item to this OrderedSet, then return its index.
+
+        If `key` is already in the OrderedSet, return the index it already
+        had.
+        """
+        index = self.map.get(key)
+        if index is None:
+            self.map[key] = index = len(self.items)
+            self.items.append(key)
+        return index
+
+    def index(self, key):
+        """
+        Get the index of a given entry, raising an IndexError if it's not
+        present.
+
+        `key` can be an iterable of entries that is not a string, in which case
+        this returns a list of indices.
+        """
+        if is_iterable(key):
+            return [self.index(subkey) for subkey in key]
+        return self.map[key]
+
+    def discard(self, key):
+        index = self.map.get(key)
+        if index is not None:
+            self.items.pop(index)
+            for item in self.items[index:]:
+                self.map[item] -= 1
+            return True
+        return False
+
+    def __iter__(self):
+        return iter(self.items)
+
+    def __reversed__(self):
+        return reversed(self.items)
+
+    def __repr__(self):
+        if not self:
+            return '%s()' % (self.__class__.__name__,)
+        return '%s(%r)' % (self.__class__.__name__, list(self))
+
+    def __eq__(self, other):
+        if isinstance(other, OrderedSet):
+            return len(self) == len(other) and self.items == other.items
+        try:
+            return type(other)(self.map) == other
+        except TypeError:
+            return False