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

Python Compiled Bytecode | 2010-10-31 | 7.7 KB | 181 lines

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

import re
import os
import shutil
from calibre import CurrentDir
from calibre.customize import Plugin

class ConversionOption(object):

    def __init__(self, name = None, help = None, long_switch = None, short_switch = None, choices = None):
        self.name = name
        self.help = help
        self.long_switch = long_switch
        self.short_switch = short_switch
        self.choices = choices
        if self.long_switch is None:
            self.long_switch = self.name.replace('_', '-')

        self.validate_parameters()


    def validate_parameters(self):
        if re.match('[a-zA-Z_]([a-zA-Z0-9_])*', self.name) is None:
            raise ValueError(self.name + ' is not a valid Python identifier')
        re.match('[a-zA-Z_]([a-zA-Z0-9_])*', self.name) is None
        if not self.help:
            raise ValueError('You must set the help text')
        self.help


    def __hash__(self):
        return hash(self.name)


    def __eq__(self, other):
        return hash(self) == hash(other)


    def clone(self):
        return ConversionOption(name = self.name, help = self.help, long_switch = self.long_switch, short_switch = self.short_switch, choices = self.choices)



class OptionRecommendation(object):
    LOW = 1
    MED = 2
    HIGH = 3

    def __init__(self, recommended_value = None, level = LOW, **kwargs):
        self.level = level
        self.recommended_value = recommended_value
        self.option = kwargs.pop('option', None)
        if self.option is None:
            self.option = ConversionOption(**kwargs)

        self.validate_parameters()


    def help(self):
        return self.option.help

    help = property(help)

    def clone(self):
        return OptionRecommendation(recommended_value = self.recommended_value, level = self.level, option = self.option.clone())


    def validate_parameters(self):
        if self.option.choices and self.recommended_value not in self.option.choices:
            raise ValueError('OpRec: %s: Recommended value not in choices' % self.option.name)
        self.recommended_value not in self.option.choices
        if not isinstance(self.recommended_value, (int, float, str, unicode)) or self.recommended_value is None:
            raise ValueError('OpRec: %s:' % self.option.name + repr(self.recommended_value) + ' is not a string or a number')
        self.recommended_value is None



class DummyReporter(object):

    def __init__(self):
        self.cancel_requested = False


    def __call__(self, percent, msg = ''):
        pass



class InputFormatPlugin(Plugin):
    type = _('Conversion Input')
    can_be_disabled = False
    supported_platforms = [
        'windows',
        'osx',
        'linux']
    file_types = set([])
    is_image_collection = False
    core_usage = 1
    for_viewer = False
    output_encoding = 'utf-8'
    common_options = set([
        OptionRecommendation(name = 'input_encoding', recommended_value = None, level = OptionRecommendation.LOW, help = _('Specify the character encoding of the input document. If set this option will override any encoding declared by the document itself. Particularly useful for documents that do not declare an encoding or that have erroneous encoding declarations.'))])
    options = set([])
    recommendations = set([])

    def __init__(self, *args):
        Plugin.__init__(self, *args)
        self.report_progress = DummyReporter()


    def get_images(self):
        raise NotImplementedError()


    def preprocess_html(self, opts, html):
        return html


    def convert(self, stream, options, file_ext, log, accelerators):
        raise NotImplementedError


    def __call__(self, stream, options, file_ext, log, accelerators, output_dir):
        log('InputFormatPlugin: %s running' % self.name)
        if hasattr(stream, 'name'):
            log('on', stream.name)

        CurrentDir(output_dir).__enter__()

        try:
            for x in os.listdir('.'):
                CurrentDir(output_dir).__exit__ if os.path.isdir(x) else os.remove(x)

            ret = self.convert(stream, options, file_ext, log, accelerators)
        finally:
            pass

        return ret


    def postprocess_book(self, oeb, opts, log):
        pass


    def specialize(self, oeb, opts, log, output_fmt):
        pass



class OutputFormatPlugin(Plugin):
    type = _('Conversion Output')
    can_be_disabled = False
    supported_platforms = [
        'windows',
        'osx',
        'linux']
    file_type = None
    common_options = set([
        OptionRecommendation(name = 'pretty_print', recommended_value = False, level = OptionRecommendation.LOW, help = _('If specified, the output plugin will try to create output that is as human readable as possible. May not have any effect for some output plugins.'))])
    options = set([])
    recommendations = set([])

    def __init__(self, *args):
        Plugin.__init__(self, *args)
        self.report_progress = DummyReporter()


    def convert(self, oeb_book, output, input_plugin, opts, log):
        raise NotImplementedError


    def is_periodical(self):
        if self.oeb.metadata.publication_type:
            pass
        return unicode(self.oeb.metadata.publication_type[0]).startswith('periodical:')

    is_periodical = property(is_periodical)