PageRenderTime 139ms CodeModel.GetById 60ms app.highlight 51ms RepoModel.GetById 20ms app.codeStats 0ms

/Lib/distutils/command/install.py

http://unladen-swallow.googlecode.com/
Python | 686 lines | 556 code | 74 blank | 56 comment | 85 complexity | 84300044a107e42905c9a649551219f7 MD5 | raw file
  1"""distutils.command.install
  2
  3Implements the Distutils 'install' command."""
  4
  5from distutils import log
  6
  7# This module should be kept compatible with Python 2.1.
  8
  9__revision__ = "$Id: install.py 62788 2008-05-06 22:41:46Z christian.heimes $"
 10
 11import sys, os, string
 12from types import *
 13from distutils.core import Command
 14from distutils.debug import DEBUG
 15from distutils.sysconfig import get_config_vars
 16from distutils.errors import DistutilsPlatformError
 17from distutils.file_util import write_file
 18from distutils.util import convert_path, subst_vars, change_root
 19from distutils.util import get_platform
 20from distutils.errors import DistutilsOptionError
 21from site import USER_BASE
 22from site import USER_SITE
 23
 24
 25if sys.version < "2.2":
 26    WINDOWS_SCHEME = {
 27        'purelib': '$base',
 28        'platlib': '$base',
 29        'headers': '$base/Include/$dist_name',
 30        'scripts': '$base/Scripts',
 31        'data'   : '$base',
 32    }
 33else:
 34    WINDOWS_SCHEME = {
 35        'purelib': '$base/Lib/site-packages',
 36        'platlib': '$base/Lib/site-packages',
 37        'headers': '$base/Include/$dist_name',
 38        'scripts': '$base/Scripts',
 39        'data'   : '$base',
 40    }
 41
 42INSTALL_SCHEMES = {
 43    'unix_prefix': {
 44        'purelib': '$base/lib/python$py_version_short/site-packages',
 45        'platlib': '$platbase/lib/python$py_version_short/site-packages',
 46        'headers': '$base/include/python$py_version_short/$dist_name',
 47        'scripts': '$base/bin',
 48        'data'   : '$base',
 49        },
 50    'unix_home': {
 51        'purelib': '$base/lib/python',
 52        'platlib': '$base/lib/python',
 53        'headers': '$base/include/python/$dist_name',
 54        'scripts': '$base/bin',
 55        'data'   : '$base',
 56        },
 57    'unix_user': {
 58        'purelib': '$usersite',
 59        'platlib': '$usersite',
 60        'headers': '$userbase/include/python$py_version_short/$dist_name',
 61        'scripts': '$userbase/bin',
 62        'data'   : '$userbase',
 63        },
 64    'nt': WINDOWS_SCHEME,
 65    'nt_user': {
 66        'purelib': '$usersite',
 67        'platlib': '$usersite',
 68        'headers': '$userbase/Python$py_version_nodot/Include/$dist_name',
 69        'scripts': '$userbase/Scripts',
 70        'data'   : '$userbase',
 71        },
 72    'mac': {
 73        'purelib': '$base/Lib/site-packages',
 74        'platlib': '$base/Lib/site-packages',
 75        'headers': '$base/Include/$dist_name',
 76        'scripts': '$base/Scripts',
 77        'data'   : '$base',
 78        },
 79    'mac_user': {
 80        'purelib': '$usersite',
 81        'platlib': '$usersite',
 82        'headers': '$userbase/$py_version_short/include/$dist_name',
 83        'scripts': '$userbase/bin',
 84        'data'   : '$userbase',
 85        },
 86    'os2': {
 87        'purelib': '$base/Lib/site-packages',
 88        'platlib': '$base/Lib/site-packages',
 89        'headers': '$base/Include/$dist_name',
 90        'scripts': '$base/Scripts',
 91        'data'   : '$base',
 92        },
 93    'os2_home': {
 94        'purelib': '$usersite',
 95        'platlib': '$usersite',
 96        'headers': '$userbase/include/python$py_version_short/$dist_name',
 97        'scripts': '$userbase/bin',
 98        'data'   : '$userbase',
 99        },
100    }
101
102# The keys to an installation scheme; if any new types of files are to be
103# installed, be sure to add an entry to every installation scheme above,
104# and to SCHEME_KEYS here.
105SCHEME_KEYS = ('purelib', 'platlib', 'headers', 'scripts', 'data')
106
107
108class install (Command):
109
110    description = "install everything from build directory"
111
112    user_options = [
113        # Select installation scheme and set base director(y|ies)
114        ('prefix=', None,
115         "installation prefix"),
116        ('exec-prefix=', None,
117         "(Unix only) prefix for platform-specific files"),
118        ('home=', None,
119         "(Unix only) home directory to install under"),
120        ('user', None,
121         "install in user site-package '%s'" % USER_SITE),
122
123        # Or, just set the base director(y|ies)
124        ('install-base=', None,
125         "base installation directory (instead of --prefix or --home)"),
126        ('install-platbase=', None,
127         "base installation directory for platform-specific files " +
128         "(instead of --exec-prefix or --home)"),
129        ('root=', None,
130         "install everything relative to this alternate root directory"),
131
132        # Or, explicitly set the installation scheme
133        ('install-purelib=', None,
134         "installation directory for pure Python module distributions"),
135        ('install-platlib=', None,
136         "installation directory for non-pure module distributions"),
137        ('install-lib=', None,
138         "installation directory for all module distributions " +
139         "(overrides --install-purelib and --install-platlib)"),
140
141        ('install-headers=', None,
142         "installation directory for C/C++ headers"),
143        ('install-scripts=', None,
144         "installation directory for Python scripts"),
145        ('install-data=', None,
146         "installation directory for data files"),
147
148        # Byte-compilation options -- see install_lib.py for details, as
149        # these are duplicated from there (but only install_lib does
150        # anything with them).
151        ('compile', 'c', "compile .py to .pyc [default]"),
152        ('no-compile', None, "don't compile .py files"),
153        ('optimize=', 'O',
154         "also compile with optimization: -O1 for \"python -O\", "
155         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
156
157        # Miscellaneous control options
158        ('force', 'f',
159         "force installation (overwrite any existing files)"),
160        ('skip-build', None,
161         "skip rebuilding everything (for testing/debugging)"),
162
163        # Where to install documentation (eventually!)
164        #('doc-format=', None, "format of documentation to generate"),
165        #('install-man=', None, "directory for Unix man pages"),
166        #('install-html=', None, "directory for HTML documentation"),
167        #('install-info=', None, "directory for GNU info files"),
168
169        ('record=', None,
170         "filename in which to record list of installed files"),
171        ]
172
173    boolean_options = ['compile', 'force', 'skip-build', 'user']
174    negative_opt = {'no-compile' : 'compile'}
175
176
177    def initialize_options (self):
178
179        # High-level options: these select both an installation base
180        # and scheme.
181        self.prefix = None
182        self.exec_prefix = None
183        self.home = None
184        self.user = 0
185
186        # These select only the installation base; it's up to the user to
187        # specify the installation scheme (currently, that means supplying
188        # the --install-{platlib,purelib,scripts,data} options).
189        self.install_base = None
190        self.install_platbase = None
191        self.root = None
192
193        # These options are the actual installation directories; if not
194        # supplied by the user, they are filled in using the installation
195        # scheme implied by prefix/exec-prefix/home and the contents of
196        # that installation scheme.
197        self.install_purelib = None     # for pure module distributions
198        self.install_platlib = None     # non-pure (dists w/ extensions)
199        self.install_headers = None     # for C/C++ headers
200        self.install_lib = None         # set to either purelib or platlib
201        self.install_scripts = None
202        self.install_data = None
203        self.install_userbase = USER_BASE
204        self.install_usersite = USER_SITE
205
206        self.compile = None
207        self.optimize = None
208
209        # These two are for putting non-packagized distributions into their
210        # own directory and creating a .pth file if it makes sense.
211        # 'extra_path' comes from the setup file; 'install_path_file' can
212        # be turned off if it makes no sense to install a .pth file.  (But
213        # better to install it uselessly than to guess wrong and not
214        # install it when it's necessary and would be used!)  Currently,
215        # 'install_path_file' is always true unless some outsider meddles
216        # with it.
217        self.extra_path = None
218        self.install_path_file = 1
219
220        # 'force' forces installation, even if target files are not
221        # out-of-date.  'skip_build' skips running the "build" command,
222        # handy if you know it's not necessary.  'warn_dir' (which is *not*
223        # a user option, it's just there so the bdist_* commands can turn
224        # it off) determines whether we warn about installing to a
225        # directory not in sys.path.
226        self.force = 0
227        self.skip_build = 0
228        self.warn_dir = 1
229
230        # These are only here as a conduit from the 'build' command to the
231        # 'install_*' commands that do the real work.  ('build_base' isn't
232        # actually used anywhere, but it might be useful in future.)  They
233        # are not user options, because if the user told the install
234        # command where the build directory is, that wouldn't affect the
235        # build command.
236        self.build_base = None
237        self.build_lib = None
238
239        # Not defined yet because we don't know anything about
240        # documentation yet.
241        #self.install_man = None
242        #self.install_html = None
243        #self.install_info = None
244
245        self.record = None
246
247
248    # -- Option finalizing methods -------------------------------------
249    # (This is rather more involved than for most commands,
250    # because this is where the policy for installing third-
251    # party Python modules on various platforms given a wide
252    # array of user input is decided.  Yes, it's quite complex!)
253
254    def finalize_options (self):
255
256        # This method (and its pliant slaves, like 'finalize_unix()',
257        # 'finalize_other()', and 'select_scheme()') is where the default
258        # installation directories for modules, extension modules, and
259        # anything else we care to install from a Python module
260        # distribution.  Thus, this code makes a pretty important policy
261        # statement about how third-party stuff is added to a Python
262        # installation!  Note that the actual work of installation is done
263        # by the relatively simple 'install_*' commands; they just take
264        # their orders from the installation directory options determined
265        # here.
266
267        # Check for errors/inconsistencies in the options; first, stuff
268        # that's wrong on any platform.
269
270        if ((self.prefix or self.exec_prefix or self.home) and
271            (self.install_base or self.install_platbase)):
272            raise DistutilsOptionError, \
273                  ("must supply either prefix/exec-prefix/home or " +
274                   "install-base/install-platbase -- not both")
275
276        if self.home and (self.prefix or self.exec_prefix):
277            raise DistutilsOptionError, \
278                  "must supply either home or prefix/exec-prefix -- not both"
279
280        if self.user and (self.prefix or self.exec_prefix or self.home or
281                self.install_base or self.install_platbase):
282            raise DistutilsOptionError("can't combine user with with prefix/"
283                                       "exec_prefix/home or install_(plat)base")
284
285        # Next, stuff that's wrong (or dubious) only on certain platforms.
286        if os.name != "posix":
287            if self.exec_prefix:
288                self.warn("exec-prefix option ignored on this platform")
289                self.exec_prefix = None
290
291        # Now the interesting logic -- so interesting that we farm it out
292        # to other methods.  The goal of these methods is to set the final
293        # values for the install_{lib,scripts,data,...}  options, using as
294        # input a heady brew of prefix, exec_prefix, home, install_base,
295        # install_platbase, user-supplied versions of
296        # install_{purelib,platlib,lib,scripts,data,...}, and the
297        # INSTALL_SCHEME dictionary above.  Phew!
298
299        self.dump_dirs("pre-finalize_{unix,other}")
300
301        if os.name == 'posix':
302            self.finalize_unix()
303        else:
304            self.finalize_other()
305
306        self.dump_dirs("post-finalize_{unix,other}()")
307
308        # Expand configuration variables, tilde, etc. in self.install_base
309        # and self.install_platbase -- that way, we can use $base or
310        # $platbase in the other installation directories and not worry
311        # about needing recursive variable expansion (shudder).
312
313        py_version = (string.split(sys.version))[0]
314        (prefix, exec_prefix) = get_config_vars('prefix', 'exec_prefix')
315        self.config_vars = {'dist_name': self.distribution.get_name(),
316                            'dist_version': self.distribution.get_version(),
317                            'dist_fullname': self.distribution.get_fullname(),
318                            'py_version': py_version,
319                            'py_version_short': py_version[0:3],
320                            'py_version_nodot': py_version[0] + py_version[2],
321                            'sys_prefix': prefix,
322                            'prefix': prefix,
323                            'sys_exec_prefix': exec_prefix,
324                            'exec_prefix': exec_prefix,
325                            'userbase': self.install_userbase,
326                            'usersite': self.install_usersite,
327                           }
328        self.expand_basedirs()
329
330        self.dump_dirs("post-expand_basedirs()")
331
332        # Now define config vars for the base directories so we can expand
333        # everything else.
334        self.config_vars['base'] = self.install_base
335        self.config_vars['platbase'] = self.install_platbase
336
337        if DEBUG:
338            from pprint import pprint
339            print "config vars:"
340            pprint(self.config_vars)
341
342        # Expand "~" and configuration variables in the installation
343        # directories.
344        self.expand_dirs()
345
346        self.dump_dirs("post-expand_dirs()")
347
348        # Create directories in the home dir:
349        if self.user:
350            self.create_home_path()
351
352        # Pick the actual directory to install all modules to: either
353        # install_purelib or install_platlib, depending on whether this
354        # module distribution is pure or not.  Of course, if the user
355        # already specified install_lib, use their selection.
356        if self.install_lib is None:
357            if self.distribution.ext_modules: # has extensions: non-pure
358                self.install_lib = self.install_platlib
359            else:
360                self.install_lib = self.install_purelib
361
362
363        # Convert directories from Unix /-separated syntax to the local
364        # convention.
365        self.convert_paths('lib', 'purelib', 'platlib',
366                           'scripts', 'data', 'headers',
367                           'userbase', 'usersite')
368
369        # Well, we're not actually fully completely finalized yet: we still
370        # have to deal with 'extra_path', which is the hack for allowing
371        # non-packagized module distributions (hello, Numerical Python!) to
372        # get their own directories.
373        self.handle_extra_path()
374        self.install_libbase = self.install_lib # needed for .pth file
375        self.install_lib = os.path.join(self.install_lib, self.extra_dirs)
376
377        # If a new root directory was supplied, make all the installation
378        # dirs relative to it.
379        if self.root is not None:
380            self.change_roots('libbase', 'lib', 'purelib', 'platlib',
381                              'scripts', 'data', 'headers')
382
383        self.dump_dirs("after prepending root")
384
385        # Find out the build directories, ie. where to install from.
386        self.set_undefined_options('build',
387                                   ('build_base', 'build_base'),
388                                   ('build_lib', 'build_lib'))
389
390        # Punt on doc directories for now -- after all, we're punting on
391        # documentation completely!
392
393    # finalize_options ()
394
395
396    def dump_dirs (self, msg):
397        if DEBUG:
398            from distutils.fancy_getopt import longopt_xlate
399            print msg + ":"
400            for opt in self.user_options:
401                opt_name = opt[0]
402                if opt_name[-1] == "=":
403                    opt_name = opt_name[0:-1]
404                if opt_name in self.negative_opt:
405                    opt_name = string.translate(self.negative_opt[opt_name],
406                                                longopt_xlate)
407                    val = not getattr(self, opt_name)
408                else:
409                    opt_name = string.translate(opt_name, longopt_xlate)
410                    val = getattr(self, opt_name)
411                print "  %s: %s" % (opt_name, val)
412
413
414    def finalize_unix (self):
415
416        if self.install_base is not None or self.install_platbase is not None:
417            if ((self.install_lib is None and
418                 self.install_purelib is None and
419                 self.install_platlib is None) or
420                self.install_headers is None or
421                self.install_scripts is None or
422                self.install_data is None):
423                raise DistutilsOptionError, \
424                      ("install-base or install-platbase supplied, but "
425                      "installation scheme is incomplete")
426            return
427
428        if self.user:
429            if self.install_userbase is None:
430                raise DistutilsPlatformError(
431                    "User base directory is not specified")
432            self.install_base = self.install_platbase = self.install_userbase
433            self.select_scheme("unix_user")
434        elif self.home is not None:
435            self.install_base = self.install_platbase = self.home
436            self.select_scheme("unix_home")
437        else:
438            if self.prefix is None:
439                if self.exec_prefix is not None:
440                    raise DistutilsOptionError, \
441                          "must not supply exec-prefix without prefix"
442
443                self.prefix = os.path.normpath(sys.prefix)
444                self.exec_prefix = os.path.normpath(sys.exec_prefix)
445
446            else:
447                if self.exec_prefix is None:
448                    self.exec_prefix = self.prefix
449
450            self.install_base = self.prefix
451            self.install_platbase = self.exec_prefix
452            self.select_scheme("unix_prefix")
453
454    # finalize_unix ()
455
456
457    def finalize_other (self):          # Windows and Mac OS for now
458
459        if self.user:
460            if self.install_userbase is None:
461                raise DistutilsPlatformError(
462                    "User base directory is not specified")
463            self.install_base = self.install_platbase = self.install_userbase
464            self.select_scheme(os.name + "_user")
465        elif self.home is not None:
466            self.install_base = self.install_platbase = self.home
467            self.select_scheme("unix_home")
468        else:
469            if self.prefix is None:
470                self.prefix = os.path.normpath(sys.prefix)
471
472            self.install_base = self.install_platbase = self.prefix
473            try:
474                self.select_scheme(os.name)
475            except KeyError:
476                raise DistutilsPlatformError, \
477                      "I don't know how to install stuff on '%s'" % os.name
478
479    # finalize_other ()
480
481
482    def select_scheme (self, name):
483        # it's the caller's problem if they supply a bad name!
484        scheme = INSTALL_SCHEMES[name]
485        for key in SCHEME_KEYS:
486            attrname = 'install_' + key
487            if getattr(self, attrname) is None:
488                setattr(self, attrname, scheme[key])
489
490
491    def _expand_attrs (self, attrs):
492        for attr in attrs:
493            val = getattr(self, attr)
494            if val is not None:
495                if os.name == 'posix' or os.name == 'nt':
496                    val = os.path.expanduser(val)
497                val = subst_vars(val, self.config_vars)
498                setattr(self, attr, val)
499
500
501    def expand_basedirs (self):
502        self._expand_attrs(['install_base',
503                            'install_platbase',
504                            'root'])
505
506    def expand_dirs (self):
507        self._expand_attrs(['install_purelib',
508                            'install_platlib',
509                            'install_lib',
510                            'install_headers',
511                            'install_scripts',
512                            'install_data',])
513
514
515    def convert_paths (self, *names):
516        for name in names:
517            attr = "install_" + name
518            setattr(self, attr, convert_path(getattr(self, attr)))
519
520
521    def handle_extra_path (self):
522
523        if self.extra_path is None:
524            self.extra_path = self.distribution.extra_path
525
526        if self.extra_path is not None:
527            if type(self.extra_path) is StringType:
528                self.extra_path = string.split(self.extra_path, ',')
529
530            if len(self.extra_path) == 1:
531                path_file = extra_dirs = self.extra_path[0]
532            elif len(self.extra_path) == 2:
533                (path_file, extra_dirs) = self.extra_path
534            else:
535                raise DistutilsOptionError, \
536                      ("'extra_path' option must be a list, tuple, or "
537                      "comma-separated string with 1 or 2 elements")
538
539            # convert to local form in case Unix notation used (as it
540            # should be in setup scripts)
541            extra_dirs = convert_path(extra_dirs)
542
543        else:
544            path_file = None
545            extra_dirs = ''
546
547        # XXX should we warn if path_file and not extra_dirs? (in which
548        # case the path file would be harmless but pointless)
549        self.path_file = path_file
550        self.extra_dirs = extra_dirs
551
552    # handle_extra_path ()
553
554
555    def change_roots (self, *names):
556        for name in names:
557            attr = "install_" + name
558            setattr(self, attr, change_root(self.root, getattr(self, attr)))
559
560    def create_home_path(self):
561        """Create directories under ~
562        """
563        if not self.user:
564            return
565        home = convert_path(os.path.expanduser("~"))
566        for name, path in self.config_vars.iteritems():
567            if path.startswith(home) and not os.path.isdir(path):
568                self.debug_print("os.makedirs('%s', 0700)" % path)
569                os.makedirs(path, 0700)
570
571    # -- Command execution methods -------------------------------------
572
573    def run (self):
574
575        # Obviously have to build before we can install
576        if not self.skip_build:
577            self.run_command('build')
578            # If we built for any other platform, we can't install.
579            build_plat = self.distribution.get_command_obj('build').plat_name
580            # check warn_dir - it is a clue that the 'install' is happening
581            # internally, and not to sys.path, so we don't check the platform
582            # matches what we are running.
583            if self.warn_dir and build_plat != get_platform():
584                raise DistutilsPlatformError("Can't install when "
585                                             "cross-compiling")
586
587        # Run all sub-commands (at least those that need to be run)
588        for cmd_name in self.get_sub_commands():
589            self.run_command(cmd_name)
590
591        if self.path_file:
592            self.create_path_file()
593
594        # write list of installed files, if requested.
595        if self.record:
596            outputs = self.get_outputs()
597            if self.root:               # strip any package prefix
598                root_len = len(self.root)
599                for counter in xrange(len(outputs)):
600                    outputs[counter] = outputs[counter][root_len:]
601            self.execute(write_file,
602                         (self.record, outputs),
603                         "writing list of installed files to '%s'" %
604                         self.record)
605
606        sys_path = map(os.path.normpath, sys.path)
607        sys_path = map(os.path.normcase, sys_path)
608        install_lib = os.path.normcase(os.path.normpath(self.install_lib))
609        if (self.warn_dir and
610            not (self.path_file and self.install_path_file) and
611            install_lib not in sys_path):
612            log.debug(("modules installed to '%s', which is not in "
613                       "Python's module search path (sys.path) -- "
614                       "you'll have to change the search path yourself"),
615                       self.install_lib)
616
617    # run ()
618
619    def create_path_file (self):
620        filename = os.path.join(self.install_libbase,
621                                self.path_file + ".pth")
622        if self.install_path_file:
623            self.execute(write_file,
624                         (filename, [self.extra_dirs]),
625                         "creating %s" % filename)
626        else:
627            self.warn("path file '%s' not created" % filename)
628
629
630    # -- Reporting methods ---------------------------------------------
631
632    def get_outputs (self):
633        # Assemble the outputs of all the sub-commands.
634        outputs = []
635        for cmd_name in self.get_sub_commands():
636            cmd = self.get_finalized_command(cmd_name)
637            # Add the contents of cmd.get_outputs(), ensuring
638            # that outputs doesn't contain duplicate entries
639            for filename in cmd.get_outputs():
640                if filename not in outputs:
641                    outputs.append(filename)
642
643        if self.path_file and self.install_path_file:
644            outputs.append(os.path.join(self.install_libbase,
645                                        self.path_file + ".pth"))
646
647        return outputs
648
649    def get_inputs (self):
650        # XXX gee, this looks familiar ;-(
651        inputs = []
652        for cmd_name in self.get_sub_commands():
653            cmd = self.get_finalized_command(cmd_name)
654            inputs.extend(cmd.get_inputs())
655
656        return inputs
657
658
659    # -- Predicates for sub-command list -------------------------------
660
661    def has_lib (self):
662        """Return true if the current distribution has any Python
663        modules to install."""
664        return (self.distribution.has_pure_modules() or
665                self.distribution.has_ext_modules())
666
667    def has_headers (self):
668        return self.distribution.has_headers()
669
670    def has_scripts (self):
671        return self.distribution.has_scripts()
672
673    def has_data (self):
674        return self.distribution.has_data_files()
675
676
677    # 'sub_commands': a list of commands this command might have to run to
678    # get its work done.  See cmd.py for more info.
679    sub_commands = [('install_lib',     has_lib),
680                    ('install_headers', has_headers),
681                    ('install_scripts', has_scripts),
682                    ('install_data',    has_data),
683                    ('install_egg_info', lambda self:True),
684                   ]
685
686# class install