1 """distutils.command.build_py

     2 

     3 Implements the Distutils 'build_py' command."""

     4 

     5 # This module should be kept compatible with Python 2.1.

     6 

     7 __revision__ = "$Id: build_py.py 65742 2008-08-17 04:16:04Z brett.cannon $"

     8 

     9 import string, os

    10 from types import *

    11 from glob import glob

    12 

    13 from distutils.core import Command

    14 from distutils.errors import *

    15 from distutils.util import convert_path

    16 from distutils import log

    17 

    18 class build_py (Command):

    19 

    20     description = "\"build\" pure Python modules (copy to build directory)"

    21 

    22     user_options = [

    23         ('build-lib=', 'd', "directory to \"build\" (copy) to"),

    24         ('compile', 'c', "compile .py to .pyc"),

    25         ('no-compile', None, "don't compile .py files [default]"),

    26         ('optimize=', 'O',

    27          "also compile with optimization: -O1 for \"python -O\", "

    28          "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),

    29         ('force', 'f', "forcibly build everything (ignore file timestamps)"),

    30         ]

    31 

    32     boolean_options = ['compile', 'force']

    33     negative_opt = {'no-compile' : 'compile'}

    34 

    35 

    36     def initialize_options (self):

    37         self.build_lib = None

    38         self.py_modules = None

    39         self.package = None

    40         self.package_data = None

    41         self.package_dir = None

    42         self.compile = 0

    43         self.optimize = 0

    44         self.force = None

    45 

    46     def finalize_options (self):

    47         self.set_undefined_options('build',

    48                                    ('build_lib', 'build_lib'),

    49                                    ('force', 'force'))

    50 

    51         # Get the distribution options that are aliases for build_py

    52         # options -- list of packages and list of modules.

    53         self.packages = self.distribution.packages

    54         self.py_modules = self.distribution.py_modules

    55         self.package_data = self.distribution.package_data

    56         self.package_dir = {}

    57         if self.distribution.package_dir:

    58             for name, path in self.distribution.package_dir.items():

    59                 self.package_dir[name] = convert_path(path)

    60         self.data_files = self.get_data_files()

    61 

    62         # Ick, copied straight from install_lib.py (fancy_getopt needs a

    63         # type system!  Hell, *everything* needs a type system!!!)

    64         if type(self.optimize) is not IntType:

    65             try:

    66                 self.optimize = int(self.optimize)

    67                 assert 0 <= self.optimize <= 2

    68             except (ValueError, AssertionError):

    69                 raise DistutilsOptionError, "optimize must be 0, 1, or 2"

    70 

    71     def run (self):

    72 

    73         # XXX copy_file by default preserves atime and mtime.  IMHO this is

    74         # the right thing to do, but perhaps it should be an option -- in

    75         # particular, a site administrator might want installed files to

    76         # reflect the time of installation rather than the last

    77         # modification time before the installed release.

    78 

    79         # XXX copy_file by default preserves mode, which appears to be the

    80         # wrong thing to do: if a file is read-only in the working

    81         # directory, we want it to be installed read/write so that the next

    82         # installation of the same module distribution can overwrite it

    83         # without problems.  (This might be a Unix-specific issue.)  Thus

    84         # we turn off 'preserve_mode' when copying to the build directory,

    85         # since the build directory is supposed to be exactly what the

    86         # installation will look like (ie. we preserve mode when

    87         # installing).

    88 

    89         # Two options control which modules will be installed: 'packages'

    90         # and 'py_modules'.  The former lets us work with whole packages, not

    91         # specifying individual modules at all; the latter is for

    92         # specifying modules one-at-a-time.

    93 

    94         if self.py_modules:

    95             self.build_modules()

    96         if self.packages:

    97             self.build_packages()

    98             self.build_package_data()

    99 

   100         self.byte_compile(self.get_outputs(include_bytecode=0))

   101 

   102     # run ()

   103 

   104     def get_data_files (self):

   105         """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""

   106         data = []

   107         if not self.packages:

   108             return data

   109         for package in self.packages:

   110             # Locate package source directory

   111             src_dir = self.get_package_dir(package)

   112 

   113             # Compute package build directory

   114             build_dir = os.path.join(*([self.build_lib] + package.split('.')))

   115 

   116             # Length of path to strip from found files

   117             plen = 0

   118             if src_dir:

   119                 plen = len(src_dir)+1

   120 

   121             # Strip directory from globbed filenames

   122             filenames = [

   123                 file[plen:] for file in self.find_data_files(package, src_dir)

   124                 ]

   125             data.append((package, src_dir, build_dir, filenames))

   126         return data

   127 

   128     def find_data_files (self, package, src_dir):

   129         """Return filenames for package's data files in 'src_dir'"""

   130         globs = (self.package_data.get('', [])

   131                  + self.package_data.get(package, []))

   132         files = []

   133         for pattern in globs:

   134             # Each pattern has to be converted to a platform-specific path

   135             filelist = glob(os.path.join(src_dir, convert_path(pattern)))

   136             # Files that match more than one pattern are only added once

   137             files.extend([fn for fn in filelist if fn not in files])

   138         return files

   139 

   140     def build_package_data (self):

   141         """Copy data files into build directory"""

   142         lastdir = None

   143         for package, src_dir, build_dir, filenames in self.data_files:

   144             for filename in filenames:

   145                 target = os.path.join(build_dir, filename)

   146                 self.mkpath(os.path.dirname(target))

   147                 self.copy_file(os.path.join(src_dir, filename), target,

   148                                preserve_mode=False)

   149 

   150     def get_package_dir (self, package):

   151         """Return the directory, relative to the top of the source

   152            distribution, where package 'package' should be found

   153            (at least according to the 'package_dir' option, if any)."""

   154 

   155         path = string.split(package, '.')

   156 

   157         if not self.package_dir:

   158             if path:

   159                 return apply(os.path.join, path)

   160             else:

   161                 return ''

   162         else:

   163             tail = []

   164             while path:

   165                 try:

   166                     pdir = self.package_dir[string.join(path, '.')]

   167                 except KeyError:

   168                     tail.insert(0, path[-1])

   169                     del path[-1]

   170                 else:

   171                     tail.insert(0, pdir)

   172                     return os.path.join(*tail)

   173             else:

   174                 # Oops, got all the way through 'path' without finding a

   175                 # match in package_dir.  If package_dir defines a directory

   176                 # for the root (nameless) package, then fallback on it;

   177                 # otherwise, we might as well have not consulted

   178                 # package_dir at all, as we just use the directory implied

   179                 # by 'tail' (which should be the same as the original value

   180                 # of 'path' at this point).

   181                 pdir = self.package_dir.get('')

   182                 if pdir is not None:

   183                     tail.insert(0, pdir)

   184 

   185                 if tail:

   186                     return apply(os.path.join, tail)

   187                 else:

   188                     return ''

   189 

   190     # get_package_dir ()

   191 

   192 

   193     def check_package (self, package, package_dir):

   194 

   195         # Empty dir name means current directory, which we can probably

   196         # assume exists.  Also, os.path.exists and isdir don't know about

   197         # my "empty string means current dir" convention, so we have to

   198         # circumvent them.

   199         if package_dir != "":

   200             if not os.path.exists(package_dir):

   201                 raise DistutilsFileError, \

   202                       "package directory '%s' does not exist" % package_dir

   203             if not os.path.isdir(package_dir):

   204                 raise DistutilsFileError, \

   205                       ("supposed package directory '%s' exists, " +

   206                        "but is not a directory") % package_dir

   207 

   208         # Require __init__.py for all but the "root package"

   209         if package:

   210             init_py = os.path.join(package_dir, "__init__.py")

   211             if os.path.isfile(init_py):

   212                 return init_py

   213             else:

   214                 log.warn(("package init file '%s' not found " +

   215                           "(or not a regular file)"), init_py)

   216 

   217         # Either not in a package at all (__init__.py not expected), or

   218         # __init__.py doesn't exist -- so don't return the filename.

   219         return None

   220 

   221     # check_package ()

   222 

   223 

   224     def check_module (self, module, module_file):

   225         if not os.path.isfile(module_file):

   226             log.warn("file %s (for module %s) not found", module_file, module)

   227             return 0

   228         else:

   229             return 1

   230 

   231     # check_module ()

   232 

   233 

   234     def find_package_modules (self, package, package_dir):

   235         self.check_package(package, package_dir)

   236         module_files = glob(os.path.join(package_dir, "*.py"))

   237         modules = []

   238         setup_script = os.path.abspath(self.distribution.script_name)

   239 

   240         for f in module_files:

   241             abs_f = os.path.abspath(f)

   242             if abs_f != setup_script:

   243                 module = os.path.splitext(os.path.basename(f))[0]

   244                 modules.append((package, module, f))

   245             else:

   246                 self.debug_print("excluding %s" % setup_script)

   247         return modules

   248 

   249 

   250     def find_modules (self):

   251         """Finds individually-specified Python modules, ie. those listed by

   252         module name in 'self.py_modules'.  Returns a list of tuples (package,

   253         module_base, filename): 'package' is a tuple of the path through

   254         package-space to the module; 'module_base' is the bare (no

   255         packages, no dots) module name, and 'filename' is the path to the

   256         ".py" file (relative to the distribution root) that implements the

   257         module.

   258         """

   259 

   260         # Map package names to tuples of useful info about the package:

   261         #    (package_dir, checked)

   262         # package_dir - the directory where we'll find source files for

   263         #   this package

   264         # checked - true if we have checked that the package directory

   265         #   is valid (exists, contains __init__.py, ... ?)

   266         packages = {}

   267 

   268         # List of (package, module, filename) tuples to return

   269         modules = []

   270 

   271         # We treat modules-in-packages almost the same as toplevel modules,

   272         # just the "package" for a toplevel is empty (either an empty

   273         # string or empty list, depending on context).  Differences:

   274         #   - don't check for __init__.py in directory for empty package

   275 

   276         for module in self.py_modules:

   277             path = string.split(module, '.')

   278             package = string.join(path[0:-1], '.')

   279             module_base = path[-1]

   280 

   281             try:

   282                 (package_dir, checked) = packages[package]

   283             except KeyError:

   284                 package_dir = self.get_package_dir(package)

   285                 checked = 0

   286 

   287             if not checked:

   288                 init_py = self.check_package(package, package_dir)

   289                 packages[package] = (package_dir, 1)

   290                 if init_py:

   291                     modules.append((package, "__init__", init_py))

   292 

   293             # XXX perhaps we should also check for just .pyc files

   294             # (so greedy closed-source bastards can distribute Python

   295             # modules too)

   296             module_file = os.path.join(package_dir, module_base + ".py")

   297             if not self.check_module(module, module_file):

   298                 continue

   299 

   300             modules.append((package, module_base, module_file))

   301 

   302         return modules

   303 

   304     # find_modules ()

   305 

   306 

   307     def find_all_modules (self):

   308         """Compute the list of all modules that will be built, whether

   309         they are specified one-module-at-a-time ('self.py_modules') or

   310         by whole packages ('self.packages').  Return a list of tuples

   311         (package, module, module_file), just like 'find_modules()' and

   312         'find_package_modules()' do."""

   313 

   314         modules = []

   315         if self.py_modules:

   316             modules.extend(self.find_modules())

   317         if self.packages:

   318             for package in self.packages:

   319                 package_dir = self.get_package_dir(package)

   320                 m = self.find_package_modules(package, package_dir)

   321                 modules.extend(m)

   322 

   323         return modules

   324 

   325     # find_all_modules ()

   326 

   327 

   328     def get_source_files (self):

   329 

   330         modules = self.find_all_modules()

   331         filenames = []

   332         for module in modules:

   333             filenames.append(module[-1])

   334 

   335         return filenames

   336 

   337 

   338     def get_module_outfile (self, build_dir, package, module):

   339         outfile_path = [build_dir] + list(package) + [module + ".py"]

   340         return os.path.join(*outfile_path)

   341 

   342 

   343     def get_outputs (self, include_bytecode=1):

   344         modules = self.find_all_modules()

   345         outputs = []

   346         for (package, module, module_file) in modules:

   347             package = string.split(package, '.')

   348             filename = self.get_module_outfile(self.build_lib, package, module)

   349             outputs.append(filename)

   350             if include_bytecode:

   351                 if self.compile:

   352                     outputs.append(filename + "c")

   353                 if self.optimize > 0:

   354                     outputs.append(filename + "o")

   355 

   356         outputs += [

   357             os.path.join(build_dir, filename)

   358             for package, src_dir, build_dir, filenames in self.data_files

   359             for filename in filenames

   360             ]

   361 

   362         return outputs

   363 

   364 

   365     def build_module (self, module, module_file, package):

   366         if type(package) is StringType:

   367             package = string.split(package, '.')

   368         elif type(package) not in (ListType, TupleType):

   369             raise TypeError, \

   370                   "'package' must be a string (dot-separated), list, or tuple"

   371 

   372         # Now put the module source file into the "build" area -- this is

   373         # easy, we just copy it somewhere under self.build_lib (the build

   374         # directory for Python source).

   375         outfile = self.get_module_outfile(self.build_lib, package, module)

   376         dir = os.path.dirname(outfile)

   377         self.mkpath(dir)

   378         return self.copy_file(module_file, outfile, preserve_mode=0)

   379 

   380 

   381     def build_modules (self):

   382 

   383         modules = self.find_modules()

   384         for (package, module, module_file) in modules:

   385 

   386             # Now "build" the module -- ie. copy the source file to

   387             # self.build_lib (the build directory for Python source).

   388             # (Actually, it gets copied to the directory for this package

   389             # under self.build_lib.)

   390             self.build_module(module, module_file, package)

   391 

   392     # build_modules ()

   393 

   394 

   395     def build_packages (self):

   396 

   397         for package in self.packages:

   398 

   399             # Get list of (package, module, module_file) tuples based on

   400             # scanning the package directory.  'package' is only included

   401             # in the tuple so that 'find_modules()' and

   402             # 'find_package_tuples()' have a consistent interface; it's

   403             # ignored here (apart from a sanity check).  Also, 'module' is

   404             # the *unqualified* module name (ie. no dots, no package -- we

   405             # already know its package!), and 'module_file' is the path to

   406             # the .py file, relative to the current directory

   407             # (ie. including 'package_dir').

   408             package_dir = self.get_package_dir(package)

   409             modules = self.find_package_modules(package, package_dir)

   410 

   411             # Now loop over the modules we found, "building" each one (just

   412             # copy it to self.build_lib).

   413             for (package_, module, module_file) in modules:

   414                 assert package == package_

   415                 self.build_module(module, module_file, package)

   416 

   417     # build_packages ()

   418 

   419 

   420     def byte_compile (self, files):

   421         from distutils.util import byte_compile

   422         prefix = self.build_lib

   423         if prefix[-1] != os.sep:

   424             prefix = prefix + os.sep

   425 

   426         # XXX this code is essentially the same as the 'byte_compile()

   427         # method of the "install_lib" command, except for the determination

   428         # of the 'prefix' string.  Hmmm.

   429 

   430         if self.compile:

   431             byte_compile(files, optimize=0,

   432                          force=self.force, prefix=prefix, dry_run=self.dry_run)

   433         if self.optimize > 0:

   434             byte_compile(files, optimize=self.optimize,

   435                          force=self.force, prefix=prefix, dry_run=self.dry_run)

   436 

   437 # class build_py