1 | """distutils.command.install_lib |
---|
2 | |
---|
3 | Implements the Distutils 'install_lib' command |
---|
4 | (install all Python modules).""" |
---|
5 | |
---|
6 | __revision__ = "$Id$" |
---|
7 | |
---|
8 | import os |
---|
9 | import sys |
---|
10 | |
---|
11 | from distutils.core import Command |
---|
12 | from distutils.errors import DistutilsOptionError |
---|
13 | |
---|
14 | |
---|
15 | # Extension for Python source files. |
---|
16 | if hasattr(os, 'extsep'): |
---|
17 | PYTHON_SOURCE_EXTENSION = os.extsep + "py" |
---|
18 | else: |
---|
19 | PYTHON_SOURCE_EXTENSION = ".py" |
---|
20 | |
---|
21 | class 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 |
---|