"""distutils.command.build_py Implements the Distutils 'build_py' command.""" # This module should be kept compatible with Python 2.1. __revision__ = "$Id: build_py.py 37828 2004-11-10 22:23:15Z loewis $" import sys, string, osfrom types import *from glob import glob from distutils.core import Commandfrom distutils.errors import *from distutils.util import convert_pathfrom distutils import log class build_py (Command):     description = "\"build\" pure Python modules (copy to build directory)"     user_options = [        ('build-lib=', 'd', "directory to \"build\" (copy) to"),        ('compile', 'c', "compile .py to .pyc"),        ('no-compile', None, "don't compile .py files [default]"),        ('optimize=', 'O',         "also compile with optimization: -O1 for \"python -O\", "         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),        ('force', 'f', "forcibly build everything (ignore file timestamps)"),        ]     boolean_options = ['compile', 'force']    negative_opt = {'no-compile' : 'compile'}      def initialize_options (self):        self.build_lib = None        self.py_modules = None        self.package = None        self.package_data = None        self.package_dir = None        self.compile = 0        self.optimize = 0        self.force = None     def finalize_options (self):        self.set_undefined_options('build',                                   ('build_lib', 'build_lib'),                                   ('force', 'force'))         # Get the distribution options that are aliases for build_py        # options -- list of packages and list of modules.        self.packages = self.distribution.packages        self.py_modules = self.distribution.py_modules        self.package_data = self.distribution.package_data        self.package_dir = {}        if self.distribution.package_dir:            for name, path in self.distribution.package_dir.items():                self.package_dir[name] = convert_path(path)        self.data_files = self.get_data_files()         # Ick, copied straight from install_lib.py (fancy_getopt needs a        # type system!  Hell, *everything* needs a type system!!!)        if type(self.optimize) is not IntType:            try:                self.optimize = int(self.optimize)                assert 0 <= self.optimize <= 2            except (ValueError, AssertionError):                raise DistutilsOptionError, "optimize must be 0, 1, or 2"     def run (self):         # XXX copy_file by default preserves atime and mtime.  IMHO this is        # the right thing to do, but perhaps it should be an option -- in        # particular, a site administrator might want installed files to        # reflect the time of installation rather than the last        # modification time before the installed release.         # XXX copy_file by default preserves mode, which appears to be the        # wrong thing to do: if a file is read-only in the working        # directory, we want it to be installed read/write so that the next        # installation of the same module distribution can overwrite it        # without problems.  (This might be a Unix-specific issue.)  Thus        # we turn off 'preserve_mode' when copying to the build directory,        # since the build directory is supposed to be exactly what the        # installation will look like (ie. we preserve mode when        # installing).         # Two options control which modules will be installed: 'packages'        # and 'py_modules'.  The former lets us work with whole packages, not        # specifying individual modules at all; the latter is for        # specifying modules one-at-a-time.         if self.py_modules:            self.build_modules()        if self.packages:            self.build_packages()            self.build_package_data()         self.byte_compile(self.get_outputs(include_bytecode=0))     # run ()     def get_data_files (self):        """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""        data = []        if not self.packages:            return data        for package in self.packages:            # Locate package source directory            src_dir = self.get_package_dir(package)             # Compute package build directory            build_dir = os.path.join(*([self.build_lib] + package.split('.')))             # Length of path to strip from found files            plen = len(src_dir)+1             # Strip directory from globbed filenames            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):        """Return filenames for package's data files in 'src_dir'"""        globs = (self.package_data.get('', [])                 + self.package_data.get(package, []))        files = []        for pattern in globs:            # Each pattern has to be converted to a platform-specific path            filelist = glob(os.path.join(src_dir, convert_path(pattern)))            # Files that match more than one pattern are only added once            files.extend([fn for fn in filelist if fn not in files])        return files     def build_package_data (self):        """Copy data files into build directory"""        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,                               preserve_mode=False)     def get_package_dir (self, package):        """Return the directory, relative to the top of the source           distribution, where package 'package' should be found           (at least according to the 'package_dir' option, if any)."""         path = string.split(package, '.')         if not self.package_dir:            if path:                return apply(os.path.join, path)            else:                return ''        else:            tail = []            while path:                try:                    pdir = self.package_dir[string.join(path, '.')]                except KeyError:                    tail.insert(0, path[-1])                    del path[-1]                else:                    tail.insert(0, pdir)                    return apply(os.path.join, tail)            else:                # Oops, got all the way through 'path' without finding a                # match in package_dir.  If package_dir defines a directory                # for the root (nameless) package, then fallback on it;                # otherwise, we might as well have not consulted                # package_dir at all, as we just use the directory implied                # by 'tail' (which should be the same as the original value                # of 'path' at this point).                pdir = self.package_dir.get('')                if pdir is not None:                    tail.insert(0, pdir)                 if tail:                    return apply(os.path.join, tail)                else:                    return ''     # get_package_dir ()      def check_package (self, package, package_dir):         # Empty dir name means current directory, which we can probably        # assume exists.  Also, os.path.exists and isdir don't know about        # my "empty string means current dir" convention, so we have to        # circumvent them.        if package_dir != "":            if not os.path.exists(package_dir):                raise DistutilsFileError, \                      "package directory '%s' does not exist" % package_dir            if not os.path.isdir(package_dir):                raise DistutilsFileError, \                      ("supposed package directory '%s' exists, " +                       "but is not a directory") % package_dir         # Require __init__.py for all but the "root package"        if package:            init_py = os.path.join(package_dir, "__init__.py")            if os.path.isfile(init_py):                return init_py            else:                log.warn(("package init file '%s' not found " +                          "(or not a regular file)"), init_py)         # Either not in a package at all (__init__.py not expected), or        # __init__.py doesn't exist -- so don't return the filename.        return None     # check_package ()      def check_module (self, module, module_file):        if not os.path.isfile(module_file):            log.warn("file %s (for module %s) not found", module_file, module)            return 0        else:            return 1     # check_module ()      def find_package_modules (self, package, package_dir):        self.check_package(package, package_dir)        module_files = glob(os.path.join(package_dir, "*.py"))        modules = []        setup_script = os.path.abspath(self.distribution.script_name)         for f in module_files:            abs_f = os.path.abspath(f)            if abs_f != setup_script:                module = os.path.splitext(os.path.basename(f))[0]                modules.append((package, module, f))            else:                self.debug_print("excluding %s" % setup_script)        return modules      def find_modules (self):        """Finds individually-specified Python modules, ie. those listed by        module name in 'self.py_modules'.  Returns a list of tuples (package,        module_base, filename): 'package' is a tuple of the path through        package-space to the module; 'module_base' is the bare (no        packages, no dots) module name, and 'filename' is the path to the        ".py" file (relative to the distribution root) that implements the        module.        """         # Map package names to tuples of useful info about the package:        #    (package_dir, checked)        # package_dir - the directory where we'll find source files for        #   this package        # checked - true if we have checked that the package directory        #   is valid (exists, contains __init__.py, ... ?)        packages = {}         # List of (package, module, filename) tuples to return        modules = []         # We treat modules-in-packages almost the same as toplevel modules,        # just the "package" for a toplevel is empty (either an empty        # string or empty list, depending on context).  Differences:        #   - don't check for __init__.py in directory for empty package         for module in self.py_modules:            path = string.split(module, '.')            package = string.join(path[0:-1], '.')            module_base = path[-1]             try:                (package_dir, checked) = packages[package]            except KeyError:                package_dir = self.get_package_dir(package)                checked = 0             if not checked:                init_py = self.check_package(package, package_dir)                packages[package] = (package_dir, 1)                if init_py:                    modules.append((package, "__init__", init_py))             # XXX perhaps we should also check for just .pyc files            # (so greedy closed-source bastards can distribute Python            # modules too)            module_file = os.path.join(package_dir, module_base + ".py")            if not self.check_module(module, module_file):                continue             modules.append((package, module_base, module_file))         return modules     # find_modules ()      def find_all_modules (self):        """Compute the list of all modules that will be built, whether        they are specified one-module-at-a-time ('self.py_modules') or        by whole packages ('self.packages').  Return a list of tuples        (package, module, module_file), just like 'find_modules()' and        'find_package_modules()' do."""         modules = []        if self.py_modules:            modules.extend(self.find_modules())        if self.packages:            for package in self.packages:                package_dir = self.get_package_dir(package)                m = self.find_package_modules(package, package_dir)                modules.extend(m)         return modules     # find_all_modules ()      def get_source_files (self):         modules = self.find_all_modules()        filenames = []        for module in modules:            filenames.append(module[-1])         return filenames      def get_module_outfile (self, build_dir, package, module):        outfile_path = [build_dir] + list(package) + [module + ".py"]        return apply(os.path.join, outfile_path)      def get_outputs (self, include_bytecode=1):        modules = self.find_all_modules()        outputs = []        for (package, module, module_file) in modules:            package = string.split(package, '.')            filename = self.get_module_outfile(self.build_lib, package, module)            outputs.append(filename)            if include_bytecode:                if self.compile:                    outputs.append(filename + "c")                if self.optimize > 0:                    outputs.append(filename + "o")         outputs += [            os.path.join(build_dir, filename)            for package, src_dir, build_dir, filenames in self.data_files            for filename in filenames            ]         return outputs      def build_module (self, module, module_file, package):        if type(package) is StringType:            package = string.split(package, '.')        elif type(package) not in (ListType, TupleType):            raise TypeError, \                  "'package' must be a string (dot-separated), list, or tuple"         # Now put the module source file into the "build" area -- this is        # easy, we just copy it somewhere under self.build_lib (the build        # directory for Python source).        outfile = self.get_module_outfile(self.build_lib, package, module)        dir = os.path.dirname(outfile)        self.mkpath(dir)        return self.copy_file(module_file, outfile, preserve_mode=0)      def build_modules (self):         modules = self.find_modules()        for (package, module, module_file) in modules:             # Now "build" the module -- ie. copy the source file to            # self.build_lib (the build directory for Python source).            # (Actually, it gets copied to the directory for this package            # under self.build_lib.)            self.build_module(module, module_file, package)     # build_modules ()      def build_packages (self):         for package in self.packages:             # Get list of (package, module, module_file) tuples based on            # scanning the package directory.  'package' is only included            # in the tuple so that 'find_modules()' and            # 'find_package_tuples()' have a consistent interface; it's            # ignored here (apart from a sanity check).  Also, 'module' is            # the *unqualified* module name (ie. no dots, no package -- we            # already know its package!), and 'module_file' is the path to            # the .py file, relative to the current directory            # (ie. including 'package_dir').            package_dir = self.get_package_dir(package)            modules = self.find_package_modules(package, package_dir)             # Now loop over the modules we found, "building" each one (just            # copy it to self.build_lib).            for (package_, module, module_file) in modules:                assert package == package_                self.build_module(module, module_file, package)     # build_packages ()      def byte_compile (self, files):        from distutils.util import byte_compile        prefix = self.build_lib        if prefix[-1] != os.sep:            prefix = prefix + os.sep         # XXX this code is essentially the same as the 'byte_compile()        # method of the "install_lib" command, except for the determination        # of the 'prefix' string.  Hmmm.         if self.compile:            byte_compile(files, optimize=0,                         force=self.force, prefix=prefix, dry_run=self.dry_run)        if self.optimize > 0:            byte_compile(files, optimize=self.optimize,                         force=self.force, prefix=prefix, dry_run=self.dry_run) # class build_py