| 1 | """distutils.command.build_py
|
|---|
| 2 |
|
|---|
| 3 | Implements the Distutils 'build_py' command."""
|
|---|
| 4 |
|
|---|
| 5 | __revision__ = "$Id$"
|
|---|
| 6 |
|
|---|
| 7 | import os
|
|---|
| 8 | import sys
|
|---|
| 9 | from glob import glob
|
|---|
| 10 |
|
|---|
| 11 | from distutils.core import Command
|
|---|
| 12 | from distutils.errors import DistutilsOptionError, DistutilsFileError
|
|---|
| 13 | from distutils.util import convert_path
|
|---|
| 14 | from distutils import log
|
|---|
| 15 |
|
|---|
| 16 | class build_py(Command):
|
|---|
| 17 |
|
|---|
| 18 | description = "\"build\" pure Python modules (copy to build directory)"
|
|---|
| 19 |
|
|---|
| 20 | user_options = [
|
|---|
| 21 | ('build-lib=', 'd', "directory to \"build\" (copy) to"),
|
|---|
| 22 | ('compile', 'c', "compile .py to .pyc"),
|
|---|
| 23 | ('no-compile', None, "don't compile .py files [default]"),
|
|---|
| 24 | ('optimize=', 'O',
|
|---|
| 25 | "also compile with optimization: -O1 for \"python -O\", "
|
|---|
| 26 | "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
|
|---|
| 27 | ('force', 'f', "forcibly build everything (ignore file timestamps)"),
|
|---|
| 28 | ]
|
|---|
| 29 |
|
|---|
| 30 | boolean_options = ['compile', 'force']
|
|---|
| 31 | negative_opt = {'no-compile' : 'compile'}
|
|---|
| 32 |
|
|---|
| 33 | def initialize_options(self):
|
|---|
| 34 | self.build_lib = None
|
|---|
| 35 | self.py_modules = None
|
|---|
| 36 | self.package = None
|
|---|
| 37 | self.package_data = None
|
|---|
| 38 | self.package_dir = None
|
|---|
| 39 | self.compile = 0
|
|---|
| 40 | self.optimize = 0
|
|---|
| 41 | self.force = None
|
|---|
| 42 |
|
|---|
| 43 | def finalize_options(self):
|
|---|
| 44 | self.set_undefined_options('build',
|
|---|
| 45 | ('build_lib', 'build_lib'),
|
|---|
| 46 | ('force', 'force'))
|
|---|
| 47 |
|
|---|
| 48 | # Get the distribution options that are aliases for build_py
|
|---|
| 49 | # options -- list of packages and list of modules.
|
|---|
| 50 | self.packages = self.distribution.packages
|
|---|
| 51 | self.py_modules = self.distribution.py_modules
|
|---|
| 52 | self.package_data = self.distribution.package_data
|
|---|
| 53 | self.package_dir = {}
|
|---|
| 54 | if self.distribution.package_dir:
|
|---|
| 55 | for name, path in self.distribution.package_dir.items():
|
|---|
| 56 | self.package_dir[name] = convert_path(path)
|
|---|
| 57 | self.data_files = self.get_data_files()
|
|---|
| 58 |
|
|---|
| 59 | # Ick, copied straight from install_lib.py (fancy_getopt needs a
|
|---|
| 60 | # type system! Hell, *everything* needs a type system!!!)
|
|---|
| 61 | if not isinstance(self.optimize, int):
|
|---|
| 62 | try:
|
|---|
| 63 | self.optimize = int(self.optimize)
|
|---|
| 64 | assert 0 <= self.optimize <= 2
|
|---|
| 65 | except (ValueError, AssertionError):
|
|---|
| 66 | raise DistutilsOptionError("optimize must be 0, 1, or 2")
|
|---|
| 67 |
|
|---|
| 68 | def run(self):
|
|---|
| 69 | # XXX copy_file by default preserves atime and mtime. IMHO this is
|
|---|
| 70 | # the right thing to do, but perhaps it should be an option -- in
|
|---|
| 71 | # particular, a site administrator might want installed files to
|
|---|
| 72 | # reflect the time of installation rather than the last
|
|---|
| 73 | # modification time before the installed release.
|
|---|
| 74 |
|
|---|
| 75 | # XXX copy_file by default preserves mode, which appears to be the
|
|---|
| 76 | # wrong thing to do: if a file is read-only in the working
|
|---|
| 77 | # directory, we want it to be installed read/write so that the next
|
|---|
| 78 | # installation of the same module distribution can overwrite it
|
|---|
| 79 | # without problems. (This might be a Unix-specific issue.) Thus
|
|---|
| 80 | # we turn off 'preserve_mode' when copying to the build directory,
|
|---|
| 81 | # since the build directory is supposed to be exactly what the
|
|---|
| 82 | # installation will look like (ie. we preserve mode when
|
|---|
| 83 | # installing).
|
|---|
| 84 |
|
|---|
| 85 | # Two options control which modules will be installed: 'packages'
|
|---|
| 86 | # and 'py_modules'. The former lets us work with whole packages, not
|
|---|
| 87 | # specifying individual modules at all; the latter is for
|
|---|
| 88 | # specifying modules one-at-a-time.
|
|---|
| 89 |
|
|---|
| 90 | if self.py_modules:
|
|---|
| 91 | self.build_modules()
|
|---|
| 92 | if self.packages:
|
|---|
| 93 | self.build_packages()
|
|---|
| 94 | self.build_package_data()
|
|---|
| 95 |
|
|---|
| 96 | self.byte_compile(self.get_outputs(include_bytecode=0))
|
|---|
| 97 |
|
|---|
| 98 | def get_data_files(self):
|
|---|
| 99 | """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
|
|---|
| 100 | data = []
|
|---|
| 101 | if not self.packages:
|
|---|
| 102 | return data
|
|---|
| 103 | for package in self.packages:
|
|---|
| 104 | # Locate package source directory
|
|---|
| 105 | src_dir = self.get_package_dir(package)
|
|---|
| 106 |
|
|---|
| 107 | # Compute package build directory
|
|---|
| 108 | build_dir = os.path.join(*([self.build_lib] + package.split('.')))
|
|---|
| 109 |
|
|---|
| 110 | # Length of path to strip from found files
|
|---|
| 111 | plen = 0
|
|---|
| 112 | if src_dir:
|
|---|
| 113 | plen = len(src_dir)+1
|
|---|
| 114 |
|
|---|
| 115 | # Strip directory from globbed filenames
|
|---|
| 116 | filenames = [
|
|---|
| 117 | file[plen:] for file in self.find_data_files(package, src_dir)
|
|---|
| 118 | ]
|
|---|
| 119 | data.append((package, src_dir, build_dir, filenames))
|
|---|
| 120 | return data
|
|---|
| 121 |
|
|---|
| 122 | def find_data_files(self, package, src_dir):
|
|---|
| 123 | """Return filenames for package's data files in 'src_dir'"""
|
|---|
| 124 | globs = (self.package_data.get('', [])
|
|---|
| 125 | + self.package_data.get(package, []))
|
|---|
| 126 | files = []
|
|---|
| 127 | for pattern in globs:
|
|---|
| 128 | # Each pattern has to be converted to a platform-specific path
|
|---|
| 129 | filelist = glob(os.path.join(src_dir, convert_path(pattern)))
|
|---|
| 130 | # Files that match more than one pattern are only added once
|
|---|
| 131 | files.extend([fn for fn in filelist if fn not in files])
|
|---|
| 132 | return files
|
|---|
| 133 |
|
|---|
| 134 | def build_package_data(self):
|
|---|
| 135 | """Copy data files into build directory"""
|
|---|
| 136 | for package, src_dir, build_dir, filenames in self.data_files:
|
|---|
| 137 | for filename in filenames:
|
|---|
| 138 | target = os.path.join(build_dir, filename)
|
|---|
| 139 | self.mkpath(os.path.dirname(target))
|
|---|
| 140 | self.copy_file(os.path.join(src_dir, filename), target,
|
|---|
| 141 | preserve_mode=False)
|
|---|
| 142 |
|
|---|
| 143 | def get_package_dir(self, package):
|
|---|
| 144 | """Return the directory, relative to the top of the source
|
|---|
| 145 | distribution, where package 'package' should be found
|
|---|
| 146 | (at least according to the 'package_dir' option, if any)."""
|
|---|
| 147 |
|
|---|
| 148 | path = package.split('.')
|
|---|
| 149 |
|
|---|
| 150 | if not self.package_dir:
|
|---|
| 151 | if path:
|
|---|
| 152 | return os.path.join(*path)
|
|---|
| 153 | else:
|
|---|
| 154 | return ''
|
|---|
| 155 | else:
|
|---|
| 156 | tail = []
|
|---|
| 157 | while path:
|
|---|
| 158 | try:
|
|---|
| 159 | pdir = self.package_dir['.'.join(path)]
|
|---|
| 160 | except KeyError:
|
|---|
| 161 | tail.insert(0, path[-1])
|
|---|
| 162 | del path[-1]
|
|---|
| 163 | else:
|
|---|
| 164 | tail.insert(0, pdir)
|
|---|
| 165 | return os.path.join(*tail)
|
|---|
| 166 | else:
|
|---|
| 167 | # Oops, got all the way through 'path' without finding a
|
|---|
| 168 | # match in package_dir. If package_dir defines a directory
|
|---|
| 169 | # for the root (nameless) package, then fallback on it;
|
|---|
| 170 | # otherwise, we might as well have not consulted
|
|---|
| 171 | # package_dir at all, as we just use the directory implied
|
|---|
| 172 | # by 'tail' (which should be the same as the original value
|
|---|
| 173 | # of 'path' at this point).
|
|---|
| 174 | pdir = self.package_dir.get('')
|
|---|
| 175 | if pdir is not None:
|
|---|
| 176 | tail.insert(0, pdir)
|
|---|
| 177 |
|
|---|
| 178 | if tail:
|
|---|
| 179 | return os.path.join(*tail)
|
|---|
| 180 | else:
|
|---|
| 181 | return ''
|
|---|
| 182 |
|
|---|
| 183 | def check_package(self, package, package_dir):
|
|---|
| 184 | # Empty dir name means current directory, which we can probably
|
|---|
| 185 | # assume exists. Also, os.path.exists and isdir don't know about
|
|---|
| 186 | # my "empty string means current dir" convention, so we have to
|
|---|
| 187 | # circumvent them.
|
|---|
| 188 | if package_dir != "":
|
|---|
| 189 | if not os.path.exists(package_dir):
|
|---|
| 190 | raise DistutilsFileError(
|
|---|
| 191 | "package directory '%s' does not exist" % package_dir)
|
|---|
| 192 | if not os.path.isdir(package_dir):
|
|---|
| 193 | raise DistutilsFileError(
|
|---|
| 194 | "supposed package directory '%s' exists, "
|
|---|
| 195 | "but is not a directory" % package_dir)
|
|---|
| 196 |
|
|---|
| 197 | # Require __init__.py for all but the "root package"
|
|---|
| 198 | if package:
|
|---|
| 199 | init_py = os.path.join(package_dir, "__init__.py")
|
|---|
| 200 | if os.path.isfile(init_py):
|
|---|
| 201 | return init_py
|
|---|
| 202 | else:
|
|---|
| 203 | log.warn(("package init file '%s' not found " +
|
|---|
| 204 | "(or not a regular file)"), init_py)
|
|---|
| 205 |
|
|---|
| 206 | # Either not in a package at all (__init__.py not expected), or
|
|---|
| 207 | # __init__.py doesn't exist -- so don't return the filename.
|
|---|
| 208 | return None
|
|---|
| 209 |
|
|---|
| 210 | def check_module(self, module, module_file):
|
|---|
| 211 | if not os.path.isfile(module_file):
|
|---|
| 212 | log.warn("file %s (for module %s) not found", module_file, module)
|
|---|
| 213 | return False
|
|---|
| 214 | else:
|
|---|
| 215 | return True
|
|---|
| 216 |
|
|---|
| 217 | def find_package_modules(self, package, package_dir):
|
|---|
| 218 | self.check_package(package, package_dir)
|
|---|
| 219 | module_files = glob(os.path.join(package_dir, "*.py"))
|
|---|
| 220 | modules = []
|
|---|
| 221 | setup_script = os.path.abspath(self.distribution.script_name)
|
|---|
| 222 |
|
|---|
| 223 | for f in module_files:
|
|---|
| 224 | abs_f = os.path.abspath(f)
|
|---|
| 225 | if abs_f != setup_script:
|
|---|
| 226 | module = os.path.splitext(os.path.basename(f))[0]
|
|---|
| 227 | modules.append((package, module, f))
|
|---|
| 228 | else:
|
|---|
| 229 | self.debug_print("excluding %s" % setup_script)
|
|---|
| 230 | return modules
|
|---|
| 231 |
|
|---|
| 232 | def find_modules(self):
|
|---|
| 233 | """Finds individually-specified Python modules, ie. those listed by
|
|---|
| 234 | module name in 'self.py_modules'. Returns a list of tuples (package,
|
|---|
| 235 | module_base, filename): 'package' is a tuple of the path through
|
|---|
| 236 | package-space to the module; 'module_base' is the bare (no
|
|---|
| 237 | packages, no dots) module name, and 'filename' is the path to the
|
|---|
| 238 | ".py" file (relative to the distribution root) that implements the
|
|---|
| 239 | module.
|
|---|
| 240 | """
|
|---|
| 241 | # Map package names to tuples of useful info about the package:
|
|---|
| 242 | # (package_dir, checked)
|
|---|
| 243 | # package_dir - the directory where we'll find source files for
|
|---|
| 244 | # this package
|
|---|
| 245 | # checked - true if we have checked that the package directory
|
|---|
| 246 | # is valid (exists, contains __init__.py, ... ?)
|
|---|
| 247 | packages = {}
|
|---|
| 248 |
|
|---|
| 249 | # List of (package, module, filename) tuples to return
|
|---|
| 250 | modules = []
|
|---|
| 251 |
|
|---|
| 252 | # We treat modules-in-packages almost the same as toplevel modules,
|
|---|
| 253 | # just the "package" for a toplevel is empty (either an empty
|
|---|
| 254 | # string or empty list, depending on context). Differences:
|
|---|
| 255 | # - don't check for __init__.py in directory for empty package
|
|---|
| 256 | for module in self.py_modules:
|
|---|
| 257 | path = module.split('.')
|
|---|
| 258 | package = '.'.join(path[0:-1])
|
|---|
| 259 | module_base = path[-1]
|
|---|
| 260 |
|
|---|
| 261 | try:
|
|---|
| 262 | (package_dir, checked) = packages[package]
|
|---|
| 263 | except KeyError:
|
|---|
| 264 | package_dir = self.get_package_dir(package)
|
|---|
| 265 | checked = 0
|
|---|
| 266 |
|
|---|
| 267 | if not checked:
|
|---|
| 268 | init_py = self.check_package(package, package_dir)
|
|---|
| 269 | packages[package] = (package_dir, 1)
|
|---|
| 270 | if init_py:
|
|---|
| 271 | modules.append((package, "__init__", init_py))
|
|---|
| 272 |
|
|---|
| 273 | # XXX perhaps we should also check for just .pyc files
|
|---|
| 274 | # (so greedy closed-source bastards can distribute Python
|
|---|
| 275 | # modules too)
|
|---|
| 276 | module_file = os.path.join(package_dir, module_base + ".py")
|
|---|
| 277 | if not self.check_module(module, module_file):
|
|---|
| 278 | continue
|
|---|
| 279 |
|
|---|
| 280 | modules.append((package, module_base, module_file))
|
|---|
| 281 |
|
|---|
| 282 | return modules
|
|---|
| 283 |
|
|---|
| 284 | def find_all_modules(self):
|
|---|
| 285 | """Compute the list of all modules that will be built, whether
|
|---|
| 286 | they are specified one-module-at-a-time ('self.py_modules') or
|
|---|
| 287 | by whole packages ('self.packages'). Return a list of tuples
|
|---|
| 288 | (package, module, module_file), just like 'find_modules()' and
|
|---|
| 289 | 'find_package_modules()' do."""
|
|---|
| 290 | modules = []
|
|---|
| 291 | if self.py_modules:
|
|---|
| 292 | modules.extend(self.find_modules())
|
|---|
| 293 | if self.packages:
|
|---|
| 294 | for package in self.packages:
|
|---|
| 295 | package_dir = self.get_package_dir(package)
|
|---|
| 296 | m = self.find_package_modules(package, package_dir)
|
|---|
| 297 | modules.extend(m)
|
|---|
| 298 | return modules
|
|---|
| 299 |
|
|---|
| 300 | def get_source_files(self):
|
|---|
| 301 | return [module[-1] for module in self.find_all_modules()]
|
|---|
| 302 |
|
|---|
| 303 | def get_module_outfile(self, build_dir, package, module):
|
|---|
| 304 | outfile_path = [build_dir] + list(package) + [module + ".py"]
|
|---|
| 305 | return os.path.join(*outfile_path)
|
|---|
| 306 |
|
|---|
| 307 | def get_outputs(self, include_bytecode=1):
|
|---|
| 308 | modules = self.find_all_modules()
|
|---|
| 309 | outputs = []
|
|---|
| 310 | for (package, module, module_file) in modules:
|
|---|
| 311 | package = package.split('.')
|
|---|
| 312 | filename = self.get_module_outfile(self.build_lib, package, module)
|
|---|
| 313 | outputs.append(filename)
|
|---|
| 314 | if include_bytecode:
|
|---|
| 315 | if self.compile:
|
|---|
| 316 | outputs.append(filename + "c")
|
|---|
| 317 | if self.optimize > 0:
|
|---|
| 318 | outputs.append(filename + "o")
|
|---|
| 319 |
|
|---|
| 320 | outputs += [
|
|---|
| 321 | os.path.join(build_dir, filename)
|
|---|
| 322 | for package, src_dir, build_dir, filenames in self.data_files
|
|---|
| 323 | for filename in filenames
|
|---|
| 324 | ]
|
|---|
| 325 |
|
|---|
| 326 | return outputs
|
|---|
| 327 |
|
|---|
| 328 | def build_module(self, module, module_file, package):
|
|---|
| 329 | if isinstance(package, str):
|
|---|
| 330 | package = package.split('.')
|
|---|
| 331 | elif not isinstance(package, (list, tuple)):
|
|---|
| 332 | raise TypeError(
|
|---|
| 333 | "'package' must be a string (dot-separated), list, or tuple")
|
|---|
| 334 |
|
|---|
| 335 | # Now put the module source file into the "build" area -- this is
|
|---|
| 336 | # easy, we just copy it somewhere under self.build_lib (the build
|
|---|
| 337 | # directory for Python source).
|
|---|
| 338 | outfile = self.get_module_outfile(self.build_lib, package, module)
|
|---|
| 339 | dir = os.path.dirname(outfile)
|
|---|
| 340 | self.mkpath(dir)
|
|---|
| 341 | return self.copy_file(module_file, outfile, preserve_mode=0)
|
|---|
| 342 |
|
|---|
| 343 | def build_modules(self):
|
|---|
| 344 | modules = self.find_modules()
|
|---|
| 345 | for (package, module, module_file) in modules:
|
|---|
| 346 |
|
|---|
| 347 | # Now "build" the module -- ie. copy the source file to
|
|---|
| 348 | # self.build_lib (the build directory for Python source).
|
|---|
| 349 | # (Actually, it gets copied to the directory for this package
|
|---|
| 350 | # under self.build_lib.)
|
|---|
| 351 | self.build_module(module, module_file, package)
|
|---|
| 352 |
|
|---|
| 353 | def build_packages(self):
|
|---|
| 354 | for package in self.packages:
|
|---|
| 355 |
|
|---|
| 356 | # Get list of (package, module, module_file) tuples based on
|
|---|
| 357 | # scanning the package directory. 'package' is only included
|
|---|
| 358 | # in the tuple so that 'find_modules()' and
|
|---|
| 359 | # 'find_package_tuples()' have a consistent interface; it's
|
|---|
| 360 | # ignored here (apart from a sanity check). Also, 'module' is
|
|---|
| 361 | # the *unqualified* module name (ie. no dots, no package -- we
|
|---|
| 362 | # already know its package!), and 'module_file' is the path to
|
|---|
| 363 | # the .py file, relative to the current directory
|
|---|
| 364 | # (ie. including 'package_dir').
|
|---|
| 365 | package_dir = self.get_package_dir(package)
|
|---|
| 366 | modules = self.find_package_modules(package, package_dir)
|
|---|
| 367 |
|
|---|
| 368 | # Now loop over the modules we found, "building" each one (just
|
|---|
| 369 | # copy it to self.build_lib).
|
|---|
| 370 | for (package_, module, module_file) in modules:
|
|---|
| 371 | assert package == package_
|
|---|
| 372 | self.build_module(module, module_file, package)
|
|---|
| 373 |
|
|---|
| 374 | def byte_compile(self, files):
|
|---|
| 375 | if sys.dont_write_bytecode:
|
|---|
| 376 | self.warn('byte-compiling is disabled, skipping.')
|
|---|
| 377 | return
|
|---|
| 378 |
|
|---|
| 379 | from distutils.util import byte_compile
|
|---|
| 380 | prefix = self.build_lib
|
|---|
| 381 | if prefix[-1] != os.sep:
|
|---|
| 382 | prefix = prefix + os.sep
|
|---|
| 383 |
|
|---|
| 384 | # XXX this code is essentially the same as the 'byte_compile()
|
|---|
| 385 | # method of the "install_lib" command, except for the determination
|
|---|
| 386 | # of the 'prefix' string. Hmmm.
|
|---|
| 387 |
|
|---|
| 388 | if self.compile:
|
|---|
| 389 | byte_compile(files, optimize=0,
|
|---|
| 390 | force=self.force, prefix=prefix, dry_run=self.dry_run)
|
|---|
| 391 | if self.optimize > 0:
|
|---|
| 392 | byte_compile(files, optimize=self.optimize,
|
|---|
| 393 | force=self.force, prefix=prefix, dry_run=self.dry_run)
|
|---|
