Maximum CD 2011 January/maximum-cd-2011-01.iso/DiscContents/calibre-0.7.26.msi/file_1453

Python Compiled Bytecode | 2010-10-31 | 33.3 KB | 908 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.6)

from __future__ import with_statement
__license__ = 'GPL v3'
__copyright__ = '2008, Kovid Goyal [e-mail]'
__docformat__ = 'restructuredtext en'
import os
import re
import cPickle
import textwrap
import traceback
import plistlib
import json
import base64
import datetime
from copy import deepcopy
from functools import partial
from optparse import OptionParser as _OptionParser
from optparse import IndentedHelpFormatter
from collections import defaultdict
from calibre.constants import terminal_controller, config_dir, CONFIG_DIR_MODE, __appname__, __version__, __author__
from calibre.utils.lock import LockError, ExclusiveFile
plugin_dir = os.path.join(config_dir, 'plugins')

def make_config_dir():
    if not os.path.exists(plugin_dir):
        os.makedirs(plugin_dir, mode = CONFIG_DIR_MODE)



def check_config_write_access():
    if os.access(config_dir, os.W_OK):
        pass
    return os.access(config_dir, os.X_OK)


class CustomHelpFormatter(IndentedHelpFormatter):

    def format_usage(self, usage):
        return _('%sUsage%s: %s\n') % (terminal_controller.BLUE, terminal_controller.NORMAL, usage)


    def format_heading(self, heading):
        return '%*s%s%s%s:\n' % (self.current_indent, terminal_controller.BLUE, '', heading, terminal_controller.NORMAL)


    def format_option(self, option):
        result = []
        opts = self.option_strings[option]
        opt_width = self.help_position - self.current_indent - 2
        if len(opts) > opt_width:
            opts = '%*s%s\n' % (self.current_indent, '', terminal_controller.GREEN + opts + terminal_controller.NORMAL)
            indent_first = self.help_position
        else:
            opts = '%*s%-*s  ' % (self.current_indent, '', opt_width + len(terminal_controller.GREEN + terminal_controller.NORMAL), terminal_controller.GREEN + opts + terminal_controller.NORMAL)
            indent_first = 0
        result.append(opts)
        if option.help:
            help_text = self.expand_default(option).split('\n')
            help_lines = []
            for line in help_text:
                help_lines.extend(textwrap.wrap(line, self.help_width))

            result.append('%*s%s\n' % (indent_first, '', help_lines[0]))
            []([ '%*s%s\n' % (self.help_position, '', line) for line in help_lines[1:] ])
        elif opts[-1] != '\n':
            result.append('\n')

        return ''.join(result) + '\n'



class OptionParser(_OptionParser):

    def __init__(self, usage = '%prog [options] filename', version = '%%prog (%s %s)' % (__appname__, __version__), epilog = None, gui_mode = False, conflict_handler = 'resolve', **kwds):
        usage = textwrap.dedent(usage)
        if epilog is None:
            epilog = _('Created by ') + terminal_controller.RED + __author__ + terminal_controller.NORMAL

        usage += '\n\n' + _('Whenever you pass arguments to %prog that have spaces in them, enclose the arguments in quotation marks.')
        _OptionParser.__init__(self, usage = usage, version = version, epilog = epilog, formatter = CustomHelpFormatter(), conflict_handler = conflict_handler, **kwds)
        self.gui_mode = gui_mode


    def error(self, msg):
        if self.gui_mode:
            raise Exception(msg)
        self.gui_mode
        _OptionParser.error(self, msg)


    def merge(self, parser):
        opts = list(parser.option_list)
        groups = list(parser.option_groups)

        def merge_options(options, container):
            for opt in deepcopy(options):
                if not self.has_option(opt.get_opt_string()):
                    container.add_option(opt)
                    continue


        merge_options(opts, self)
        for group in groups:
            g = self.add_option_group(group.title)
            merge_options(group.option_list, g)



    def subsume(self, group_name, msg = ''):
        opts = _[1]
        self.option_groups = []
        subgroup = self.add_option_group(group_name, msg)
        for opt in opts:
            self.remove_option(opt.get_opt_string())
            subgroup.add_option(opt)



    def options_iter(self):
        for opt in self.option_list:
            if str(opt).strip():
                yield opt
                continue

        for gr in self.option_groups:
            for opt in gr.option_list:
                if str(opt).strip():
                    yield opt
                    continue




    def option_by_dest(self, dest):
        for opt in self.options_iter():
            if opt.dest == dest:
                return opt



    def merge_options(self, lower, upper):
        for dest in lower.__dict__.keys():
            if not upper.__dict__.has_key(dest):
                continue

            opt = self.option_by_dest(dest)
            if lower.__dict__[dest] != opt.default and upper.__dict__[dest] == opt.default:
                upper.__dict__[dest] = lower.__dict__[dest]
                continue




class Option(object):

    def __init__(self, name, switches = [], help = '', type = None, choices = None, check = None, group = None, default = None, action = None, metavar = None):
        if choices:
            type = 'choice'

        self.name = name
        self.switches = switches
        self.help = None if help else None
        self.type = type
        if self.type is None and action is None and choices is None:
            if isinstance(default, float):
                self.type = 'float'
            elif isinstance(default, int) and not isinstance(default, bool):
                self.type = 'int'


        self.choices = choices
        self.check = check
        self.group = group
        self.default = default
        self.action = action
        self.metavar = metavar


    def __eq__(self, other):
        return self.name == getattr(other, 'name', other)


    def __repr__(self):
        return 'Option: ' + self.name


    def __str__(self):
        return repr(self)



class OptionValues(object):

    def copy(self):
        return deepcopy(self)



class OptionSet(object):
    OVERRIDE_PAT = re.compile('#{3,100} Override Options #{15}(.*?)#{3,100} End Override #{3,100}', re.DOTALL | re.IGNORECASE)

    def __init__(self, description = ''):
        self.description = description
        self.defaults = { }
        self.preferences = []
        self.group_list = []
        self.groups = { }
        self.set_buffer = { }


    def has_option(self, name_or_option_object):
        if name_or_option_object in self.preferences:
            return True
        for p in self.preferences:
            if p.name == name_or_option_object:
                return True

        return False


    def get_option(self, name_or_option_object):
        idx = self.preferences.index(name_or_option_object)
        if idx > -1:
            return self.preferences[idx]
        for p in self.preferences:
            if p.name == name_or_option_object:
                return p



    def add_group(self, name, description = ''):
        if name in self.group_list:
            raise ValueError('A group by the name %s already exists in this set' % name)
        name in self.group_list
        self.groups[name] = description
        self.group_list.append(name)
        return partial(self.add_opt, group = name)


    def update(self, other):
        for name in other.groups.keys():
            self.groups[name] = other.groups[name]
            if name not in self.group_list:
                self.group_list.append(name)
                continue

        for pref in other.preferences:
            if pref in self.preferences:
                self.preferences.remove(pref)

            self.preferences.append(pref)



    def smart_update(self, opts1, opts2):
        for pref in self.preferences:
            new = getattr(opts2, pref.name, pref.default)
            if new != pref.default:
                setattr(opts1, pref.name, new)
                continue



    def remove_opt(self, name):
        if name in self.preferences:
            self.preferences.remove(name)



    def add_opt(self, name, switches = [], help = None, type = None, choices = None, group = None, default = None, action = None, metavar = None):
        pref = Option(name, switches = switches, help = help, type = type, choices = choices, group = group, default = default, action = action, metavar = None)
        if group is not None and group not in self.groups.keys():
            raise ValueError('Group %s has not been added to this section' % group)
        group not in self.groups.keys()
        if pref in self.preferences:
            raise ValueError('An option with the name %s already exists in this set.' % name)
        pref in self.preferences
        self.preferences.append(pref)
        self.defaults[name] = default


    def option_parser(self, user_defaults = None, usage = '', gui_mode = False):
        parser = OptionParser(usage, gui_mode = gui_mode)
        groups = (defaultdict,)((lambda : parser))
        for group, desc in self.groups.items():
            groups[group] = parser.add_option_group(group.upper(), desc)

        for pref in self.preferences:
            if not pref.switches:
                continue

            g = groups[pref.group]
            action = pref.action
            if action is None:
                action = 'store'
                if pref.default is True or pref.default is False:
                    action = None + 'store_' if pref.default else 'true'


            args = dict(dest = pref.name, help = pref.help, metavar = pref.metavar, type = pref.type, choices = pref.choices, default = getattr(user_defaults, pref.name, pref.default), action = action)
            g.add_option(*pref.switches, **args)

        return parser


    def get_override_section(self, src):
        match = self.OVERRIDE_PAT.search(src)
        if match:
            return match.group()
        return ''


    def parse_string(self, src):
        options = {
            'cPickle': cPickle }
        if src is not None:

            try:
                if not isinstance(src, unicode):
                    src = src.decode('utf-8')

                exec src in options
            print 'Failed to parse options string:'
            print repr(src)
            traceback.print_exc()


        opts = OptionValues()
        for pref in self.preferences:
            val = options.get(pref.name, pref.default)
            formatter = __builtins__.get(pref.type, None)
            if callable(formatter):
                val = formatter(val)

            setattr(opts, pref.name, val)

        return opts


    def render_group(self, name, desc, opts):
        prefs = _[1]
        lines = [
            [] % '### Begin group: %s' if name else 'DEFAULT']
        if desc:
            lines += map((lambda x: '# ' + x), desc.split('\n'))

        lines.append(' ')
        for pref in prefs:
            lines.append('# ' + pref.name.replace('_', ' '))
            if pref.help:
                lines += map((lambda x: '# ' + x), pref.help.split('\n'))

            lines.append('%s = %s' % (pref.name, self.serialize_opt(getattr(opts, pref.name, pref.default))))
            lines.append(' ')

        return '\n'.join(lines)


    def serialize_opt(self, val):
        if val is val:
            pass
        elif val is True and val is False and val is None or isinstance(val, (int, float, long, basestring)):
            return repr(val)
        QString = QString
        import PyQt4.QtCore
        if isinstance(val, QString):
            return repr(unicode(val))
        pickle = cPickle.dumps(val, -1)
        return 'cPickle.loads(%s)' % repr(pickle)


    def serialize(self, opts):
        src = '# %s\n\n' % self.description.replace('\n', '\n# ')
        groups = [ self.render_group(name, self.groups.get(name, ''), opts) for name in [
            None] + self.group_list ]
        return src + '\n\n'.join(groups)



class ConfigInterface(object):

    def __init__(self, description):
        self.option_set = OptionSet(description = description)
        self.add_opt = self.option_set.add_opt
        self.add_group = self.option_set.add_group
        self.remove_opt = self.remove = self.option_set.remove_opt
        self.parse_string = self.option_set.parse_string
        self.get_option = self.option_set.get_option
        self.preferences = self.option_set.preferences


    def update(self, other):
        self.option_set.update(other.option_set)


    def option_parser(self, usage = '', gui_mode = False):
        return self.option_set.option_parser(user_defaults = self.parse(), usage = usage, gui_mode = gui_mode)


    def smart_update(self, opts1, opts2):
        self.option_set.smart_update(opts1, opts2)



class Config(ConfigInterface):

    def __init__(self, basename, description = ''):
        ConfigInterface.__init__(self, description)
        self.config_file_path = os.path.join(config_dir, basename + '.py')


    def parse(self):
        src = ''
        if os.path.exists(self.config_file_path):

            try:

                try:
                    f = _[1]

                    try:
                        src = f.read().decode('utf-8')
                    except ValueError:
                        ExclusiveFile(self.config_file_path).__exit__
                        ExclusiveFile(self.config_file_path).__exit__
                        ExclusiveFile(self.config_file_path)
                        print 'Failed to parse', self.config_file_path
                        traceback.print_exc()
                    except:
                        ExclusiveFile(self.config_file_path).__exit__

                finally:
                    pass

            except LockError:
                raise IOError('Could not lock config file: %s' % self.config_file_path)
            except:
                None<EXCEPTION MATCH>LockError


        None<EXCEPTION MATCH>LockError
        return self.option_set.parse_string(src)


    def as_string(self):
        if not os.path.exists(self.config_file_path):
            return ''

        try:

            try:
                f = _[1]
                return f.read().decode('utf-8')
            finally:
                pass

        except LockError:
            os.path.exists(self.config_file_path)
            os.path.exists(self.config_file_path)
            raise IOError('Could not lock config file: %s' % self.config_file_path)
        except:
            os.path.exists(self.config_file_path)



    def set(self, name, val):
        if not self.option_set.has_option(name):
            raise ValueError('The option %s is not defined.' % name)
        self.option_set.has_option(name)

        try:
            if not os.path.exists(config_dir):
                make_config_dir()


            try:
                f = _[1]
                src = f.read()
                opts = self.option_set.parse_string(src)
                setattr(opts, name, val)
                footer = self.option_set.get_override_section(src)
                src = self.option_set.serialize(opts) + '\n\n' + footer + '\n'
                f.seek(0)
                f.truncate()
                f.write(src)
            finally:
                pass

        except LockError:
            raise IOError('Could not lock config file: %s' % self.config_file_path)




class StringConfig(ConfigInterface):

    def __init__(self, src, description = ''):
        ConfigInterface.__init__(self, description)
        self.src = src


    def parse(self):
        return self.option_set.parse_string(self.src)


    def set(self, name, val):
        if not self.option_set.has_option(name):
            raise ValueError('The option %s is not defined.' % name)
        self.option_set.has_option(name)
        opts = self.option_set.parse_string(self.src)
        setattr(opts, name, val)
        footer = self.option_set.get_override_section(self.src)
        self.src = self.option_set.serialize(opts) + '\n\n' + footer + '\n'



class ConfigProxy(object):

    def __init__(self, config):
        self._ConfigProxy__config = config
        self._ConfigProxy__opts = None


    def defaults(self):
        return self._ConfigProxy__config.option_set.defaults

    defaults = property(defaults)

    def refresh(self):
        self._ConfigProxy__opts = self._ConfigProxy__config.parse()


    def __getitem__(self, key):
        return self.get(key)


    def __setitem__(self, key, val):
        return self.set(key, val)


    def get(self, key):
        if self._ConfigProxy__opts is None:
            self.refresh()

        return getattr(self._ConfigProxy__opts, key)


    def set(self, key, val):
        if self._ConfigProxy__opts is None:
            self.refresh()

        setattr(self._ConfigProxy__opts, key, val)
        return self._ConfigProxy__config.set(key, val)


    def help(self, key):
        return self._ConfigProxy__config.get_option(key).help



class DynamicConfig(dict):

    def __init__(self, name = 'dynamic'):
        dict.__init__(self, { })
        self.name = name
        self.defaults = { }
        self.file_path = os.path.join(config_dir, name + '.pickle')
        self.refresh()


    def refresh(self):
        d = { }
        self.clear()
        self.update(d)


    def __getitem__(self, key):

        try:
            return dict.__getitem__(self, key)
        except KeyError:
            return self.defaults.get(key, None)



    def get(self, key, default = None):

        try:
            return dict.__getitem__(self, key)
        except KeyError:
            return self.defaults.get(key, default)



    def __setitem__(self, key, val):
        dict.__setitem__(self, key, val)
        self.commit()


    def set(self, key, val):
        self.__setitem__(key, val)


    def commit(self):
        pass


dynamic = DynamicConfig()

class XMLConfig(dict):
    EXTENSION = '.plist'

    def __init__(self, rel_path_to_cf_file):
        dict.__init__(self)
        self.defaults = { }
        self.file_path = os.path.join(config_dir, *rel_path_to_cf_file.split('/'))
        self.file_path = os.path.abspath(self.file_path)
        if not self.file_path.endswith(self.EXTENSION):
            self.file_path += self.EXTENSION

        self.refresh()


    def raw_to_object(self, raw):
        return plistlib.readPlistFromString(raw)


    def to_raw(self):
        return plistlib.writePlistToString(self)


    def refresh(self):
        d = { }
        self.clear()
        self.update(d)


    def __getitem__(self, key):

        try:
            ans = dict.__getitem__(self, key)
            if isinstance(ans, plistlib.Data):
                ans = ans.data

            return ans
        except KeyError:
            return self.defaults.get(key, None)



    def get(self, key, default = None):

        try:
            ans = dict.__getitem__(self, key)
            if isinstance(ans, plistlib.Data):
                ans = ans.data

            return ans
        except KeyError:
            return self.defaults.get(key, default)



    def __setitem__(self, key, val):
        if isinstance(val, (bytes, str)):
            val = plistlib.Data(val)

        dict.__setitem__(self, key, val)
        self.commit()


    def set(self, key, val):
        self.__setitem__(key, val)


    def __delitem__(self, key):
        if dict.has_key(self, key):
            dict.__delitem__(self, key)
            self.commit()



    def commit(self):
        pass



def to_json(obj):
    if isinstance(obj, bytearray):
        return {
            '__class__': 'bytearray',
            '__value__': base64.standard_b64encode(bytes(obj)) }
    if isinstance(obj, datetime.datetime):
        isoformat = isoformat
        import calibre.utils.date
        return {
            '__class__': 'datetime.datetime',
            '__value__': isoformat(obj, as_utc = True) }
    raise TypeError(repr(obj) + ' is not JSON serializable')


def from_json(obj):
    return obj


class JSONConfig(XMLConfig):
    EXTENSION = '.json'

    def raw_to_object(self, raw):
        return json.loads(raw.decode('utf-8'), object_hook = from_json)


    def to_raw(self):
        return json.dumps(self, indent = 2, default = to_json)


    def __getitem__(self, key):

        try:
            return dict.__getitem__(self, key)
        except KeyError:
            return self.defaults[key]



    def get(self, key, default = None):

        try:
            return dict.__getitem__(self, key)
        except KeyError:
            return self.defaults.get(key, default)



    def __setitem__(self, key, val):
        dict.__setitem__(self, key, val)
        self.commit()



def _prefs():
    c = Config('global', 'calibre wide preferences')
    c.add_opt('database_path', default = os.path.expanduser('~/library1.db'), help = _('Path to the database in which books are stored'))
    c.add_opt('filename_pattern', default = u'(?P<title>.+) - (?P<author>[^_]+)', help = _('Pattern to guess metadata from filenames'))
    c.add_opt('isbndb_com_key', default = '', help = _('Access key for isbndb.com'))
    c.add_opt('network_timeout', default = 5, help = _('Default timeout for network operations (seconds)'))
    c.add_opt('library_path', default = None, help = _('Path to directory in which your library of books is stored'))
    c.add_opt('language', default = None, help = _('The language in which to display the user interface'))
    c.add_opt('output_format', default = 'EPUB', help = _('The default output format for ebook conversions.'))
    c.add_opt('input_format_order', default = [
        'EPUB',
        'MOBI',
        'LIT',
        'PRC',
        'FB2',
        'HTML',
        'HTM',
        'XHTM',
        'SHTML',
        'XHTML',
        'ZIP',
        'ODT',
        'RTF',
        'PDF',
        'TXT'], help = _('Ordered list of formats to prefer for input.'))
    c.add_opt('read_file_metadata', default = True, help = _('Read metadata from files'))
    c.add_opt('worker_process_priority', default = 'normal', help = _('The priority of worker processes'))
    c.add_opt('swap_author_names', default = False, help = _('Swap author first and last names when reading metadata'))
    c.add_opt('add_formats_to_existing', default = False, help = _('Add new formats to existing book records'))
    c.add_opt('installation_uuid', default = None, help = 'Installation UUID')
    c.add_opt('new_book_tags', default = [], help = _('Tags to apply to books added to the library'))
    c.add_opt('saved_searches', default = { }, help = _('List of named saved searches'))
    c.add_opt('user_categories', default = { }, help = _('User-created tag browser categories'))
    c.add_opt('manage_device_metadata', default = 'manual', help = _('How and when calibre updates metadata on the device.'))
    c.add_opt('migrated', default = False, help = "For Internal use. Don't modify.")
    return c

prefs = ConfigProxy(_prefs())
if prefs['installation_uuid'] is None:
    import uuid
    prefs['installation_uuid'] = str(uuid.uuid4())


def read_raw_tweaks():
    make_config_dir()
    default_tweaks = P('default_tweaks.py', data = True, allow_user_override = False)
    tweaks_file = os.path.join(config_dir, 'tweaks.py')

    try:
        f = _[2]
        return (default_tweaks, f.read())
    finally:
        pass



def read_tweaks():
    (default_tweaks, tweaks) = read_raw_tweaks()
    l = { }
    g = { }

    try:
        exec tweaks in g, l
    except:
        print 'Failed to load custom tweaks file'
        traceback.print_exc()

    dl = { }
    dg = { }
    exec default_tweaks in dg, dl
    dl.update(l)
    return dl


def write_tweaks(raw):
    make_config_dir()
    tweaks_file = os.path.join(config_dir, 'tweaks.py')

    try:
        f = _[1]
        f.write(raw)
    finally:
        pass


tweaks = read_tweaks()

def migrate():
    if hasattr(os, 'geteuid') and os.geteuid() == 0:
        return None
    p = prefs
    if p.get('migrated'):
        return None
    QSettings = QSettings
    QVariant = QVariant
    import PyQt4.QtCore

    class Settings('Settings', (QSettings,)):

        def __init__(self, name = ('calibre2',)):
            QSettings.__init__(self, QSettings.IniFormat, QSettings.UserScope, 'kovidgoyal.net', name)


        def get(self, key, default = (None,)):

            try:
                key = str(key)
                if not self.contains(key):
                    return default
                val = str(self.value(key, QVariant()).toByteArray())
                if not val:
                    return None
                return cPickle.loads(val)
            except:
                return default



    s = Settings()
    migrated = set([])
    all_keys = set(map(unicode, s.allKeys()))
    config = config
    dynamic = dynamic
    import calibre.gui2

    def _migrate(key, safe = None, from_qvariant = os.geteuid() == 0, p = (None, None, config)):

        try:
            if key not in all_keys:
                return None
            if safe is None:
                safe = re.sub('[^0-9a-zA-Z]', '_', key)

            val = s.get(key)
            if from_qvariant is not None:
                val = getattr(s.value(key), from_qvariant)()

            p.set(safe, val)
        except:
            pass
        finally:
            migrated.add(key)


    _migrate('database path', p = prefs)
    _migrate('filename pattern', p = prefs)
    _migrate('network timeout', p = prefs)
    _migrate('isbndb.com key', p = prefs)
    _migrate('frequently used directories')
    _migrate('send to device by default')
    _migrate('save to disk single format')
    _migrate('confirm delete')
    _migrate('show text in toolbar')
    _migrate('new version notification')
    _migrate('use roman numerals for series number')
    _migrate('cover flow queue length')
    _migrate('LRF conversion defaults')
    _migrate('LRF ebook viewer options')
    for key in all_keys - migrated:
        if key.endswith(': un') or key.endswith(': pw'):
            _migrate(key, p = dynamic)
            continue

    p.set('migrated', True)