Maximum CD 2010 November/maximum-cd-2010-11.iso/DiscContents/calibre-0.7.13.msi/file_2408

Python Compiled Bytecode | 2010-08-06 | 6.6 KB | 167 lines

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

import os.path as os
import sys
import fnmatch
from distutils.command.build_py import build_py as _build_py
from distutils.util import convert_path
from glob import glob

class build_py(_build_py):

    def finalize_options(self):
        _build_py.finalize_options(self)
        self.package_data = self.distribution.package_data
        if not self.distribution.exclude_package_data:
            pass
        self.exclude_package_data = { }
        if 'data_files' in self.__dict__:
            del self.__dict__['data_files']



    def run(self):
        if not (self.py_modules) and not (self.packages):
            return None
        if self.py_modules:
            self.build_modules()

        if self.packages:
            self.build_packages()
            self.build_package_data()

        self.byte_compile(_build_py.get_outputs(self, include_bytecode = 0))


    def __getattr__(self, attr):
        if attr == 'data_files':
            self.data_files = files = self._get_data_files()
            return files
        return _build_py.__getattr__(self, attr)


    def _get_data_files(self):
        self.analyze_manifest()
        data = []
        for package in ():
            src_dir = self.get_package_dir(package)
            build_dir = os.path.join(*[
                self.build_lib] + package.split('.'))
            plen = len(src_dir) + 1
            filenames = [ file[plen:] for file in self.find_data_files(package, src_dir) ]
            data.append((package, src_dir, build_dir, filenames))
        return data


    def find_data_files(self, package, src_dir):
        globs = self.package_data.get('', []) + self.package_data.get(package, [])
        files = self.manifest_files.get(package, [])[:]
        for pattern in globs:
            files.extend(glob(os.path.join(src_dir, convert_path(pattern))))

        return self.exclude_data_files(package, src_dir, files)


    def build_package_data(self):
        lastdir = None
        for package, src_dir, build_dir, filenames in self.data_files:
            for filename in filenames:
                target = os.path.join(build_dir, filename)
                self.mkpath(os.path.dirname(target))
                self.copy_file(os.path.join(src_dir, filename), target)




    def analyze_manifest(self):
        self.manifest_files = mf = { }
        if not self.distribution.include_package_data:
            return None
        src_dirs = { }
        for package in ():
            src_dirs[assert_relative(self.get_package_dir(package))] = package
        self.run_command('egg_info')
        ei_cmd = self.get_finalized_command('egg_info')
        for path in ei_cmd.filelist.files:
            (d, f) = os.path.split(assert_relative(path))
            prev = None
            oldf = f
            while d and d != prev and d not in src_dirs:
                prev = d
                (d, df) = os.path.split(d)
                f = os.path.join(df, f)
                continue
                self.distribution.include_package_data
            if d in src_dirs:
                if path.endswith('.py') and f == oldf:
                    continue

                mf.setdefault(src_dirs[d], []).append(path)
                continue



    def get_data_files(self):
        pass

    if sys.version < '2.4':

        def get_outputs(self, include_bytecode = 1):
            return [] + [ os.path.join(build_dir, filename) for package, src_dir, build_dir, filenames in self.data_files for filename in filenames ]



    def check_package(self, package, package_dir):

        try:
            return self.packages_checked[package]
        except KeyError:
            pass

        init_py = _build_py.check_package(self, package, package_dir)
        self.packages_checked[package] = init_py
        if not init_py or not (self.distribution.namespace_packages):
            return init_py
        for pkg in self.distribution.namespace_packages:
            if pkg == package or pkg.startswith(package + '.'):
                break
                continue
            not (self.distribution.namespace_packages)
        else:
            return init_py
        f = None(init_py, 'rU')
        if 'declare_namespace' not in f.read():
            log = log
            import distutils
            log.warn('WARNING: %s is a namespace package, but its __init__.py does\nnot declare_namespace(); setuptools 0.7 will REQUIRE this!\n(See the setuptools manual under "Namespace Packages" for details.)\n', package)

        f.close()
        return init_py


    def initialize_options(self):
        self.packages_checked = { }
        _build_py.initialize_options(self)


    def exclude_data_files(self, package, src_dir, files):
        globs = self.exclude_package_data.get('', []) + self.exclude_package_data.get(package, [])
        bad = []
        for pattern in globs:
            bad.extend(fnmatch.filter(files, os.path.join(src_dir, convert_path(pattern))))

        bad = dict.fromkeys(bad)
        seen = { }
        return _[1]



def assert_relative(path):
    if not os.path.isabs(path):
        return path
    DistutilsSetupError = DistutilsSetupError
    import distutils.errors
    raise DistutilsSetupError('Error: setup script specifies an absolute path:\n\n    %s\n\nsetup() arguments must *always* be /-separated paths relative to the\nsetup.py directory, *never* absolute paths.\n' % path)