1"""distutils.command.install_lib 2 3Implements the Distutils 'install_lib' command 4(install all Python modules).""" 5 6__revision__ = "$Id$" 7 8import os 9import sys 10 11from distutils.core import Command 12from distutils.errors import DistutilsOptionError 13 14 15# Extension for Python source files. 16if hasattr(os, 'extsep'): 17 PYTHON_SOURCE_EXTENSION = os.extsep + "py" 18else: 19 PYTHON_SOURCE_EXTENSION = ".py" 20 21class install_lib(Command): 22 23 description = "install all Python modules (extensions and pure Python)" 24 25 # The byte-compilation options are a tad confusing. Here are the 26 # possible scenarios: 27 # 1) no compilation at all (--no-compile --no-optimize) 28 # 2) compile .pyc only (--compile --no-optimize; default) 29 # 3) compile .pyc and "level 1" .pyo (--compile --optimize) 30 # 4) compile "level 1" .pyo only (--no-compile --optimize) 31 # 5) compile .pyc and "level 2" .pyo (--compile --optimize-more) 32 # 6) compile "level 2" .pyo only (--no-compile --optimize-more) 33 # 34 # The UI for this is two option, 'compile' and 'optimize'. 35 # 'compile' is strictly boolean, and only decides whether to 36 # generate .pyc files. 'optimize' is three-way (0, 1, or 2), and 37 # decides both whether to generate .pyo files and what level of 38 # optimization to use. 39 40 user_options = [ 41 ('install-dir=', 'd', "directory to install to"), 42 ('build-dir=','b', "build directory (where to install from)"), 43 ('force', 'f', "force installation (overwrite existing files)"), 44 ('compile', 'c', "compile .py to .pyc [default]"), 45 ('no-compile', None, "don't compile .py files"), 46 ('optimize=', 'O', 47 "also compile with optimization: -O1 for \"python -O\", " 48 "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"), 49 ('skip-build', None, "skip the build steps"), 50 ] 51 52 boolean_options = ['force', 'compile', 'skip-build'] 53 negative_opt = {'no-compile' : 'compile'} 54 55 def initialize_options(self): 56 # let the 'install' command dictate our installation directory 57 self.install_dir = None 58 self.build_dir = None 59 self.force = 0 60 self.compile = None 61 self.optimize = None 62 self.skip_build = None 63 64 def finalize_options(self): 65 # Get all the information we need to install pure Python modules 66 # from the umbrella 'install' command -- build (source) directory, 67 # install (target) directory, and whether to compile .py files. 68 self.set_undefined_options('install', 69 ('build_lib', 'build_dir'), 70 ('install_lib', 'install_dir'), 71 ('force', 'force'), 72 ('compile', 'compile'), 73 ('optimize', 'optimize'), 74 ('skip_build', 'skip_build'), 75 ) 76 77 if self.compile is None: 78 self.compile = 1 79 if self.optimize is None: 80 self.optimize = 0 81 82 if not isinstance(self.optimize, int): 83 try: 84 self.optimize = int(self.optimize) 85 if self.optimize not in (0, 1, 2): 86 raise AssertionError 87 except (ValueError, AssertionError): 88 raise DistutilsOptionError, "optimize must be 0, 1, or 2" 89 90 def run(self): 91 # Make sure we have built everything we need first 92 self.build() 93 94 # Install everything: simply dump the entire contents of the build 95 # directory to the installation directory (that's the beauty of 96 # having a build directory!) 97 outfiles = self.install() 98 99 # (Optionally) compile .py to .pyc 100 if outfiles is not None and self.distribution.has_pure_modules(): 101 self.byte_compile(outfiles) 102 103 # -- Top-level worker functions ------------------------------------ 104 # (called from 'run()') 105 106 def build(self): 107 if not self.skip_build: 108 if self.distribution.has_pure_modules(): 109 self.run_command('build_py') 110 if self.distribution.has_ext_modules(): 111 self.run_command('build_ext') 112 113 def install(self): 114 if os.path.isdir(self.build_dir): 115 outfiles = self.copy_tree(self.build_dir, self.install_dir) 116 else: 117 self.warn("'%s' does not exist -- no Python modules to install" % 118 self.build_dir) 119 return 120 return outfiles 121 122 def byte_compile(self, files): 123 if sys.dont_write_bytecode: 124 self.warn('byte-compiling is disabled, skipping.') 125 return 126 127 from distutils.util import byte_compile 128 129 # Get the "--root" directory supplied to the "install" command, 130 # and use it as a prefix to strip off the purported filename 131 # encoded in bytecode files. This is far from complete, but it 132 # should at least generate usable bytecode in RPM distributions. 133 install_root = self.get_finalized_command('install').root 134 135 if self.compile: 136 byte_compile(files, optimize=0, 137 force=self.force, prefix=install_root, 138 dry_run=self.dry_run) 139 if self.optimize > 0: 140 byte_compile(files, optimize=self.optimize, 141 force=self.force, prefix=install_root, 142 verbose=self.verbose, dry_run=self.dry_run) 143 144 145 # -- Utility methods ----------------------------------------------- 146 147 def _mutate_outputs(self, has_any, build_cmd, cmd_option, output_dir): 148 if not has_any: 149 return [] 150 151 build_cmd = self.get_finalized_command(build_cmd) 152 build_files = build_cmd.get_outputs() 153 build_dir = getattr(build_cmd, cmd_option) 154 155 prefix_len = len(build_dir) + len(os.sep) 156 outputs = [] 157 for file in build_files: 158 outputs.append(os.path.join(output_dir, file[prefix_len:])) 159 160 return outputs 161 162 def _bytecode_filenames(self, py_filenames): 163 bytecode_files = [] 164 for py_file in py_filenames: 165 # Since build_py handles package data installation, the 166 # list of outputs can contain more than just .py files. 167 # Make sure we only report bytecode for the .py files. 168 ext = os.path.splitext(os.path.normcase(py_file))[1] 169 if ext != PYTHON_SOURCE_EXTENSION: 170 continue 171 if self.compile: 172 bytecode_files.append(py_file + "c") 173 if self.optimize > 0: 174 bytecode_files.append(py_file + "o") 175 176 return bytecode_files 177 178 179 # -- External interface -------------------------------------------- 180 # (called by outsiders) 181 182 def get_outputs(self): 183 """Return the list of files that would be installed if this command 184 were actually run. Not affected by the "dry-run" flag or whether 185 modules have actually been built yet. 186 """ 187 pure_outputs = \ 188 self._mutate_outputs(self.distribution.has_pure_modules(), 189 'build_py', 'build_lib', 190 self.install_dir) 191 if self.compile: 192 bytecode_outputs = self._bytecode_filenames(pure_outputs) 193 else: 194 bytecode_outputs = [] 195 196 ext_outputs = \ 197 self._mutate_outputs(self.distribution.has_ext_modules(), 198 'build_ext', 'build_lib', 199 self.install_dir) 200 201 return pure_outputs + bytecode_outputs + ext_outputs 202 203 def get_inputs(self): 204 """Get the list of files that are input to this command, ie. the 205 files that get installed as they are named in the build tree. 206 The files in this list correspond one-to-one to the output 207 filenames returned by 'get_outputs()'. 208 """ 209 inputs = [] 210 211 if self.distribution.has_pure_modules(): 212 build_py = self.get_finalized_command('build_py') 213 inputs.extend(build_py.get_outputs()) 214 215 if self.distribution.has_ext_modules(): 216 build_ext = self.get_finalized_command('build_ext') 217 inputs.extend(build_ext.get_outputs()) 218 219 return inputs 220