"""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,v 1.46 2004/11/10 22:23:15 loewis Exp $"
from distutils
.core
import Command
from distutils
.errors
import *
from distutils
.util
import convert_path
from distutils
import log
class build_py (Command
):
description
= "\"build\" pure Python modules (copy to build directory)"
('build-lib=', 'd', "directory to \"build\" (copy) to"),
('compile', 'c', "compile .py to .pyc"),
('no-compile', None, "don't compile .py files [default]"),
"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
):
def finalize_options (self
):
self
.set_undefined_options('build',
('build_lib', 'build_lib'),
# 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
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
:
self
.optimize
= int(self
.optimize
)
assert 0 <= self
.optimize
<= 2
except (ValueError, AssertionError):
raise DistutilsOptionError
, "optimize must be 0, 1, or 2"
# 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
# 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.
self
.build_package_data()
self
.byte_compile(self
.get_outputs(include_bytecode
=0))
def get_data_files (self
):
"""Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
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
# Strip directory from globbed filenames
file[plen
:] for file in self
.find_data_files(package
, src_dir
)
data
.append((package
, src_dir
, build_dir
, filenames
))
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
, []))
# 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
])
def build_package_data (self
):
"""Copy data files into build directory"""
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 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
, '.')
return apply(os
.path
.join
, path
)
pdir
= self
.package_dir
[string
.join(path
, '.')]
return apply(os
.path
.join
, tail
)
# 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('')
return apply(os
.path
.join
, tail
)
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
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"
init_py
= os
.path
.join(package_dir
, "__init__.py")
if os
.path
.isfile(init_py
):
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.
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
)
def find_package_modules (self
, package
, package_dir
):
self
.check_package(package
, package_dir
)
module_files
= glob(os
.path
.join(package_dir
, "*.py"))
setup_script
= os
.path
.abspath(self
.distribution
.script_name
)
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
))
self
.debug_print("excluding %s" % setup_script
)
"""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
# Map package names to tuples of useful info about the package:
# package_dir - the directory where we'll find source files for
# checked - true if we have checked that the package directory
# is valid (exists, contains __init__.py, ... ?)
# List of (package, module, filename) tuples to return
# 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], '.')
(package_dir
, checked
) = packages
[package
]
package_dir
= self
.get_package_dir(package
)
init_py
= self
.check_package(package
, package_dir
)
packages
[package
] = (package_dir
, 1)
modules
.append((package
, "__init__", init_py
))
# XXX perhaps we should also check for just .pyc files
# (so greedy closed-source bastards can distribute Python
module_file
= os
.path
.join(package_dir
, module_base
+ ".py")
if not self
.check_module(module
, module_file
):
modules
.append((package
, module_base
, module_file
))
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
.extend(self
.find_modules())
for package
in self
.packages
:
package_dir
= self
.get_package_dir(package
)
m
= self
.find_package_modules(package
, package_dir
)
def get_source_files (self
):
modules
= self
.find_all_modules()
filenames
.append(module
[-1])
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()
for (package
, module
, module_file
) in modules
:
package
= string
.split(package
, '.')
filename
= self
.get_module_outfile(self
.build_lib
, package
, module
)
outputs
.append(filename
+ "c")
outputs
.append(filename
+ "o")
os
.path
.join(build_dir
, filename
)
for package
, src_dir
, build_dir
, filenames
in self
.data_files
for filename
in filenames
def build_module (self
, module
, module_file
, package
):
if type(package
) is StringType
:
package
= string
.split(package
, '.')
elif type(package
) not in (ListType
, TupleType
):
"'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
)
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
self
.build_module(module
, module_file
, package
)
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
)
def byte_compile (self
, files
):
from distutils
.util
import byte_compile
# 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.
byte_compile(files
, optimize
=0,
force
=self
.force
, prefix
=prefix
, dry_run
=self
.dry_run
)
byte_compile(files
, optimize
=self
.optimize
,
force
=self
.force
, prefix
=prefix
, dry_run
=self
.dry_run
)