]> git.saurik.com Git - wxWidgets.git/blame - wxPython/distutils/dist.py
Remove use of m_bestSize
[wxWidgets.git] / wxPython / distutils / dist.py
CommitLineData
1e4a197e
RD
1"""distutils.dist
2
3Provides the Distribution class, which represents the module distribution
4being built/installed/distributed.
5"""
6
7# This module should be kept compatible with Python 1.5.2.
8
9__revision__ = "$Id$"
10
11import sys, os, string, re
12from types import *
13from copy import copy
14
15try:
16 import warnings
17except ImportError:
18 warnings = None
19
20from distutils.errors import *
21from distutils.fancy_getopt import FancyGetopt, translate_longopt
22from distutils.util import check_environ, strtobool, rfc822_escape
23from distutils import log
24from distutils.debug import DEBUG
25
26# Regex to define acceptable Distutils command names. This is not *quite*
27# the same as a Python NAME -- I don't allow leading underscores. The fact
28# that they're very similar is no coincidence; the default naming scheme is
29# to look for a Python module named after the command.
30command_re = re.compile (r'^[a-zA-Z]([a-zA-Z0-9_]*)$')
31
32
33class Distribution:
34 """The core of the Distutils. Most of the work hiding behind 'setup'
35 is really done within a Distribution instance, which farms the work out
36 to the Distutils commands specified on the command line.
37
38 Setup scripts will almost never instantiate Distribution directly,
39 unless the 'setup()' function is totally inadequate to their needs.
40 However, it is conceivable that a setup script might wish to subclass
41 Distribution for some specialized purpose, and then pass the subclass
42 to 'setup()' as the 'distclass' keyword argument. If so, it is
43 necessary to respect the expectations that 'setup' has of Distribution.
44 See the code for 'setup()', in core.py, for details.
45 """
46
47
48 # 'global_options' describes the command-line options that may be
49 # supplied to the setup script prior to any actual commands.
50 # Eg. "./setup.py -n" or "./setup.py --quiet" both take advantage of
51 # these global options. This list should be kept to a bare minimum,
52 # since every global option is also valid as a command option -- and we
53 # don't want to pollute the commands with too many options that they
54 # have minimal control over.
55 # The fourth entry for verbose means that it can be repeated.
56 global_options = [('verbose', 'v', "run verbosely (default)", 1),
57 ('quiet', 'q', "run quietly (turns verbosity off)"),
58 ('dry-run', 'n', "don't actually do anything"),
59 ('help', 'h', "show detailed help message"),
60 ]
61
62 # options that are not propagated to the commands
63 display_options = [
64 ('help-commands', None,
65 "list all available commands"),
66 ('name', None,
67 "print package name"),
68 ('version', 'V',
69 "print package version"),
70 ('fullname', None,
71 "print <package name>-<version>"),
72 ('author', None,
73 "print the author's name"),
74 ('author-email', None,
75 "print the author's email address"),
76 ('maintainer', None,
77 "print the maintainer's name"),
78 ('maintainer-email', None,
79 "print the maintainer's email address"),
80 ('contact', None,
81 "print the maintainer's name if known, else the author's"),
82 ('contact-email', None,
83 "print the maintainer's email address if known, else the author's"),
84 ('url', None,
85 "print the URL for this package"),
86 ('license', None,
87 "print the license of the package"),
88 ('licence', None,
89 "alias for --license"),
90 ('description', None,
91 "print the package description"),
92 ('long-description', None,
93 "print the long package description"),
94 ('platforms', None,
95 "print the list of platforms"),
96 ('classifiers', None,
97 "print the list of classifiers"),
98 ('keywords', None,
99 "print the list of keywords"),
100 ]
101 display_option_names = map(lambda x: translate_longopt(x[0]),
102 display_options)
103
104 # negative options are options that exclude other options
105 negative_opt = {'quiet': 'verbose'}
106
107
108 # -- Creation/initialization methods -------------------------------
109
110 def __init__ (self, attrs=None):
111 """Construct a new Distribution instance: initialize all the
112 attributes of a Distribution, and then use 'attrs' (a dictionary
113 mapping attribute names to values) to assign some of those
114 attributes their "real" values. (Any attributes not mentioned in
115 'attrs' will be assigned to some null value: 0, None, an empty list
116 or dictionary, etc.) Most importantly, initialize the
117 'command_obj' attribute to the empty dictionary; this will be
118 filled in with real command objects by 'parse_command_line()'.
119 """
120
121 # Default values for our command-line options
122 self.verbose = 1
123 self.dry_run = 0
124 self.help = 0
125 for attr in self.display_option_names:
126 setattr(self, attr, 0)
127
128 # Store the distribution meta-data (name, version, author, and so
129 # forth) in a separate object -- we're getting to have enough
130 # information here (and enough command-line options) that it's
131 # worth it. Also delegate 'get_XXX()' methods to the 'metadata'
132 # object in a sneaky and underhanded (but efficient!) way.
133 self.metadata = DistributionMetadata()
134 for basename in self.metadata._METHOD_BASENAMES:
135 method_name = "get_" + basename
136 setattr(self, method_name, getattr(self.metadata, method_name))
137
138 # 'cmdclass' maps command names to class objects, so we
139 # can 1) quickly figure out which class to instantiate when
140 # we need to create a new command object, and 2) have a way
141 # for the setup script to override command classes
142 self.cmdclass = {}
143
144 # 'script_name' and 'script_args' are usually set to sys.argv[0]
145 # and sys.argv[1:], but they can be overridden when the caller is
146 # not necessarily a setup script run from the command-line.
147 self.script_name = None
148 self.script_args = None
149
150 # 'command_options' is where we store command options between
151 # parsing them (from config files, the command-line, etc.) and when
152 # they are actually needed -- ie. when the command in question is
153 # instantiated. It is a dictionary of dictionaries of 2-tuples:
154 # command_options = { command_name : { option : (source, value) } }
155 self.command_options = {}
156
157 # These options are really the business of various commands, rather
158 # than of the Distribution itself. We provide aliases for them in
159 # Distribution as a convenience to the developer.
160 self.packages = None
161 self.package_dir = None
162 self.py_modules = None
163 self.libraries = None
164 self.headers = None
165 self.ext_modules = None
166 self.ext_package = None
167 self.include_dirs = None
168 self.extra_path = None
169 self.scripts = None
170 self.data_files = None
171
172 # And now initialize bookkeeping stuff that can't be supplied by
173 # the caller at all. 'command_obj' maps command names to
174 # Command instances -- that's how we enforce that every command
175 # class is a singleton.
176 self.command_obj = {}
177
178 # 'have_run' maps command names to boolean values; it keeps track
179 # of whether we have actually run a particular command, to make it
180 # cheap to "run" a command whenever we think we might need to -- if
181 # it's already been done, no need for expensive filesystem
182 # operations, we just check the 'have_run' dictionary and carry on.
183 # It's only safe to query 'have_run' for a command class that has
184 # been instantiated -- a false value will be inserted when the
185 # command object is created, and replaced with a true value when
186 # the command is successfully run. Thus it's probably best to use
187 # '.get()' rather than a straight lookup.
188 self.have_run = {}
189
190 # Now we'll use the attrs dictionary (ultimately, keyword args from
191 # the setup script) to possibly override any or all of these
192 # distribution options.
193
194 if attrs:
195
196 # Pull out the set of command options and work on them
197 # specifically. Note that this order guarantees that aliased
198 # command options will override any supplied redundantly
199 # through the general options dictionary.
200 options = attrs.get('options')
201 if options:
202 del attrs['options']
203 for (command, cmd_options) in options.items():
204 opt_dict = self.get_option_dict(command)
205 for (opt, val) in cmd_options.items():
206 opt_dict[opt] = ("setup script", val)
207
e55c4dd1
RD
208 if attrs.has_key('licence'):
209 attrs['license'] = attrs['licence']
210 del attrs['licence']
211 msg = "'licence' distribution option is deprecated; use 'license'"
212 if warnings is not None:
213 warnings.warn(msg)
214 else:
215 sys.stderr.write(msg + "\n")
216
1e4a197e
RD
217 # Now work on the rest of the attributes. Any attribute that's
218 # not already defined is invalid!
219 for (key,val) in attrs.items():
220 if hasattr(self.metadata, key):
221 setattr(self.metadata, key, val)
222 elif hasattr(self, key):
223 setattr(self, key, val)
224 else:
225 msg = "Unknown distribution option: %s" % repr(key)
226 if warnings is not None:
227 warnings.warn(msg)
228 else:
229 sys.stderr.write(msg + "\n")
230
231 self.finalize_options()
232
233 # __init__ ()
234
235
236 def get_option_dict (self, command):
237 """Get the option dictionary for a given command. If that
238 command's option dictionary hasn't been created yet, then create it
239 and return the new dictionary; otherwise, return the existing
240 option dictionary.
241 """
242
243 dict = self.command_options.get(command)
244 if dict is None:
245 dict = self.command_options[command] = {}
246 return dict
247
248
249 def dump_option_dicts (self, header=None, commands=None, indent=""):
250 from pprint import pformat
251
252 if commands is None: # dump all command option dicts
253 commands = self.command_options.keys()
254 commands.sort()
255
256 if header is not None:
257 print indent + header
258 indent = indent + " "
259
260 if not commands:
261 print indent + "no commands known yet"
262 return
263
264 for cmd_name in commands:
265 opt_dict = self.command_options.get(cmd_name)
266 if opt_dict is None:
267 print indent + "no option dict for '%s' command" % cmd_name
268 else:
269 print indent + "option dict for '%s' command:" % cmd_name
270 out = pformat(opt_dict)
271 for line in string.split(out, "\n"):
272 print indent + " " + line
273
274 # dump_option_dicts ()
275
276
277
278 # -- Config file finding/parsing methods ---------------------------
279
280 def find_config_files (self):
281 """Find as many configuration files as should be processed for this
282 platform, and return a list of filenames in the order in which they
283 should be parsed. The filenames returned are guaranteed to exist
284 (modulo nasty race conditions).
285
286 There are three possible config files: distutils.cfg in the
287 Distutils installation directory (ie. where the top-level
288 Distutils __inst__.py file lives), a file in the user's home
289 directory named .pydistutils.cfg on Unix and pydistutils.cfg
290 on Windows/Mac, and setup.cfg in the current directory.
291 """
292 files = []
293 check_environ()
294
295 # Where to look for the system-wide Distutils config file
296 sys_dir = os.path.dirname(sys.modules['distutils'].__file__)
297
298 # Look for the system config file
299 sys_file = os.path.join(sys_dir, "distutils.cfg")
300 if os.path.isfile(sys_file):
301 files.append(sys_file)
302
303 # What to call the per-user config file
304 if os.name == 'posix':
305 user_filename = ".pydistutils.cfg"
306 else:
307 user_filename = "pydistutils.cfg"
308
309 # And look for the user config file
310 if os.environ.has_key('HOME'):
311 user_file = os.path.join(os.environ.get('HOME'), user_filename)
312 if os.path.isfile(user_file):
313 files.append(user_file)
314
315 # All platforms support local setup.cfg
316 local_file = "setup.cfg"
317 if os.path.isfile(local_file):
318 files.append(local_file)
319
320 return files
321
322 # find_config_files ()
323
324
325 def parse_config_files (self, filenames=None):
326
327 from ConfigParser import ConfigParser
328
329 if filenames is None:
330 filenames = self.find_config_files()
331
332 if DEBUG: print "Distribution.parse_config_files():"
333
334 parser = ConfigParser()
335 for filename in filenames:
336 if DEBUG: print " reading", filename
337 parser.read(filename)
338 for section in parser.sections():
339 options = parser.options(section)
340 opt_dict = self.get_option_dict(section)
341
342 for opt in options:
343 if opt != '__name__':
344 val = parser.get(section,opt)
345 opt = string.replace(opt, '-', '_')
346 opt_dict[opt] = (filename, val)
347
348 # Make the ConfigParser forget everything (so we retain
349 # the original filenames that options come from) -- gag,
350 # retch, puke -- another good reason for a distutils-
351 # specific config parser (sigh...)
352 parser.__init__()
353
354 # If there was a "global" section in the config file, use it
355 # to set Distribution options.
356
357 if self.command_options.has_key('global'):
358 for (opt, (src, val)) in self.command_options['global'].items():
359 alias = self.negative_opt.get(opt)
360 try:
361 if alias:
362 setattr(self, alias, not strtobool(val))
363 elif opt in ('verbose', 'dry_run'): # ugh!
364 setattr(self, opt, strtobool(val))
365 except ValueError, msg:
366 raise DistutilsOptionError, msg
367
368 # parse_config_files ()
369
370
371 # -- Command-line parsing methods ----------------------------------
372
373 def parse_command_line (self):
374 """Parse the setup script's command line, taken from the
375 'script_args' instance attribute (which defaults to 'sys.argv[1:]'
376 -- see 'setup()' in core.py). This list is first processed for
377 "global options" -- options that set attributes of the Distribution
378 instance. Then, it is alternately scanned for Distutils commands
379 and options for that command. Each new command terminates the
380 options for the previous command. The allowed options for a
381 command are determined by the 'user_options' attribute of the
382 command class -- thus, we have to be able to load command classes
383 in order to parse the command line. Any error in that 'options'
384 attribute raises DistutilsGetoptError; any error on the
385 command-line raises DistutilsArgError. If no Distutils commands
386 were found on the command line, raises DistutilsArgError. Return
387 true if command-line was successfully parsed and we should carry
388 on with executing commands; false if no errors but we shouldn't
389 execute commands (currently, this only happens if user asks for
390 help).
391 """
392 #
393 # We now have enough information to show the Macintosh dialog
394 # that allows the user to interactively specify the "command line".
395 #
396 if sys.platform == 'mac':
397 import EasyDialogs
398 cmdlist = self.get_command_list()
399 self.script_args = EasyDialogs.GetArgv(
400 self.global_options + self.display_options, cmdlist)
401
402 # We have to parse the command line a bit at a time -- global
403 # options, then the first command, then its options, and so on --
404 # because each command will be handled by a different class, and
405 # the options that are valid for a particular class aren't known
406 # until we have loaded the command class, which doesn't happen
407 # until we know what the command is.
408
409 self.commands = []
410 parser = FancyGetopt(self.global_options + self.display_options)
411 parser.set_negative_aliases(self.negative_opt)
412 parser.set_aliases({'licence': 'license'})
413 args = parser.getopt(args=self.script_args, object=self)
414 option_order = parser.get_option_order()
415 log.set_verbosity(self.verbose)
416
417 # for display options we return immediately
418 if self.handle_display_options(option_order):
419 return
420
421 while args:
422 args = self._parse_command_opts(parser, args)
423 if args is None: # user asked for help (and got it)
424 return
425
426 # Handle the cases of --help as a "global" option, ie.
427 # "setup.py --help" and "setup.py --help command ...". For the
428 # former, we show global options (--verbose, --dry-run, etc.)
429 # and display-only options (--name, --version, etc.); for the
430 # latter, we omit the display-only options and show help for
431 # each command listed on the command line.
432 if self.help:
433 self._show_help(parser,
434 display_options=len(self.commands) == 0,
435 commands=self.commands)
436 return
437
438 # Oops, no commands found -- an end-user error
439 if not self.commands:
440 raise DistutilsArgError, "no commands supplied"
441
442 # All is well: return true
443 return 1
444
445 # parse_command_line()
446
447 def _parse_command_opts (self, parser, args):
448 """Parse the command-line options for a single command.
449 'parser' must be a FancyGetopt instance; 'args' must be the list
450 of arguments, starting with the current command (whose options
451 we are about to parse). Returns a new version of 'args' with
452 the next command at the front of the list; will be the empty
453 list if there are no more commands on the command line. Returns
454 None if the user asked for help on this command.
455 """
456 # late import because of mutual dependence between these modules
457 from distutils.cmd import Command
458
459 # Pull the current command from the head of the command line
460 command = args[0]
461 if not command_re.match(command):
462 raise SystemExit, "invalid command name '%s'" % command
463 self.commands.append(command)
464
465 # Dig up the command class that implements this command, so we
466 # 1) know that it's a valid command, and 2) know which options
467 # it takes.
468 try:
469 cmd_class = self.get_command_class(command)
470 except DistutilsModuleError, msg:
471 raise DistutilsArgError, msg
472
473 # Require that the command class be derived from Command -- want
474 # to be sure that the basic "command" interface is implemented.
475 if not issubclass(cmd_class, Command):
476 raise DistutilsClassError, \
477 "command class %s must subclass Command" % cmd_class
478
479 # Also make sure that the command object provides a list of its
480 # known options.
481 if not (hasattr(cmd_class, 'user_options') and
482 type(cmd_class.user_options) is ListType):
483 raise DistutilsClassError, \
484 ("command class %s must provide " +
485 "'user_options' attribute (a list of tuples)") % \
486 cmd_class
487
488 # If the command class has a list of negative alias options,
489 # merge it in with the global negative aliases.
490 negative_opt = self.negative_opt
491 if hasattr(cmd_class, 'negative_opt'):
492 negative_opt = copy(negative_opt)
493 negative_opt.update(cmd_class.negative_opt)
494
495 # Check for help_options in command class. They have a different
496 # format (tuple of four) so we need to preprocess them here.
497 if (hasattr(cmd_class, 'help_options') and
498 type(cmd_class.help_options) is ListType):
499 help_options = fix_help_options(cmd_class.help_options)
500 else:
501 help_options = []
502
503
504 # All commands support the global options too, just by adding
505 # in 'global_options'.
506 parser.set_option_table(self.global_options +
507 cmd_class.user_options +
508 help_options)
509 parser.set_negative_aliases(negative_opt)
510 (args, opts) = parser.getopt(args[1:])
511 if hasattr(opts, 'help') and opts.help:
512 self._show_help(parser, display_options=0, commands=[cmd_class])
513 return
514
515 if (hasattr(cmd_class, 'help_options') and
516 type(cmd_class.help_options) is ListType):
517 help_option_found=0
518 for (help_option, short, desc, func) in cmd_class.help_options:
519 if hasattr(opts, parser.get_attr_name(help_option)):
520 help_option_found=1
521 #print "showing help for option %s of command %s" % \
522 # (help_option[0],cmd_class)
523
524 if callable(func):
525 func()
526 else:
527 raise DistutilsClassError(
528 "invalid help function %s for help option '%s': "
529 "must be a callable object (function, etc.)"
530 % (`func`, help_option))
531
532 if help_option_found:
533 return
534
535 # Put the options from the command-line into their official
536 # holding pen, the 'command_options' dictionary.
537 opt_dict = self.get_option_dict(command)
538 for (name, value) in vars(opts).items():
539 opt_dict[name] = ("command line", value)
540
541 return args
542
543 # _parse_command_opts ()
544
545
546 def finalize_options (self):
547 """Set final values for all the options on the Distribution
548 instance, analogous to the .finalize_options() method of Command
549 objects.
550 """
551
552 keywords = self.metadata.keywords
553 if keywords is not None:
554 if type(keywords) is StringType:
555 keywordlist = string.split(keywords, ',')
556 self.metadata.keywords = map(string.strip, keywordlist)
557
558 platforms = self.metadata.platforms
559 if platforms is not None:
560 if type(platforms) is StringType:
561 platformlist = string.split(platforms, ',')
562 self.metadata.platforms = map(string.strip, platformlist)
563
564 def _show_help (self,
565 parser,
566 global_options=1,
567 display_options=1,
568 commands=[]):
569 """Show help for the setup script command-line in the form of
570 several lists of command-line options. 'parser' should be a
571 FancyGetopt instance; do not expect it to be returned in the
572 same state, as its option table will be reset to make it
573 generate the correct help text.
574
575 If 'global_options' is true, lists the global options:
576 --verbose, --dry-run, etc. If 'display_options' is true, lists
577 the "display-only" options: --name, --version, etc. Finally,
578 lists per-command help for every command name or command class
579 in 'commands'.
580 """
581 # late import because of mutual dependence between these modules
582 from distutils.core import gen_usage
583 from distutils.cmd import Command
584
585 if global_options:
586 parser.set_option_table(self.global_options)
587 parser.print_help("Global options:")
588 print
589
590 if display_options:
591 parser.set_option_table(self.display_options)
592 parser.print_help(
593 "Information display options (just display " +
594 "information, ignore any commands)")
595 print
596
597 for command in self.commands:
598 if type(command) is ClassType and issubclass(command, Command):
599 klass = command
600 else:
601 klass = self.get_command_class(command)
602 if (hasattr(klass, 'help_options') and
603 type(klass.help_options) is ListType):
604 parser.set_option_table(klass.user_options +
605 fix_help_options(klass.help_options))
606 else:
607 parser.set_option_table(klass.user_options)
608 parser.print_help("Options for '%s' command:" % klass.__name__)
609 print
610
611 print gen_usage(self.script_name)
612 return
613
614 # _show_help ()
615
616
617 def handle_display_options (self, option_order):
618 """If there were any non-global "display-only" options
619 (--help-commands or the metadata display options) on the command
620 line, display the requested info and return true; else return
621 false.
622 """
623 from distutils.core import gen_usage
624
625 # User just wants a list of commands -- we'll print it out and stop
626 # processing now (ie. if they ran "setup --help-commands foo bar",
627 # we ignore "foo bar").
628 if self.help_commands:
629 self.print_commands()
630 print
631 print gen_usage(self.script_name)
632 return 1
633
634 # If user supplied any of the "display metadata" options, then
635 # display that metadata in the order in which the user supplied the
636 # metadata options.
637 any_display_options = 0
638 is_display_option = {}
639 for option in self.display_options:
640 is_display_option[option[0]] = 1
641
642 for (opt, val) in option_order:
643 if val and is_display_option.get(opt):
644 opt = translate_longopt(opt)
645 value = getattr(self.metadata, "get_"+opt)()
646 if opt in ['keywords', 'platforms']:
647 print string.join(value, ',')
648 elif opt == 'classifiers':
649 print string.join(value, '\n')
650 else:
651 print value
652 any_display_options = 1
653
654 return any_display_options
655
656 # handle_display_options()
657
658 def print_command_list (self, commands, header, max_length):
659 """Print a subset of the list of all commands -- used by
660 'print_commands()'.
661 """
662
663 print header + ":"
664
665 for cmd in commands:
666 klass = self.cmdclass.get(cmd)
667 if not klass:
668 klass = self.get_command_class(cmd)
669 try:
670 description = klass.description
671 except AttributeError:
672 description = "(no description available)"
673
674 print " %-*s %s" % (max_length, cmd, description)
675
676 # print_command_list ()
677
678
679 def print_commands (self):
680 """Print out a help message listing all available commands with a
681 description of each. The list is divided into "standard commands"
682 (listed in distutils.command.__all__) and "extra commands"
683 (mentioned in self.cmdclass, but not a standard command). The
684 descriptions come from the command class attribute
685 'description'.
686 """
687
688 import distutils.command
689 std_commands = distutils.command.__all__
690 is_std = {}
691 for cmd in std_commands:
692 is_std[cmd] = 1
693
694 extra_commands = []
695 for cmd in self.cmdclass.keys():
696 if not is_std.get(cmd):
697 extra_commands.append(cmd)
698
699 max_length = 0
700 for cmd in (std_commands + extra_commands):
701 if len(cmd) > max_length:
702 max_length = len(cmd)
703
704 self.print_command_list(std_commands,
705 "Standard commands",
706 max_length)
707 if extra_commands:
708 print
709 self.print_command_list(extra_commands,
710 "Extra commands",
711 max_length)
712
713 # print_commands ()
714
715 def get_command_list (self):
716 """Get a list of (command, description) tuples.
717 The list is divided into "standard commands" (listed in
718 distutils.command.__all__) and "extra commands" (mentioned in
719 self.cmdclass, but not a standard command). The descriptions come
720 from the command class attribute 'description'.
721 """
722 # Currently this is only used on Mac OS, for the Mac-only GUI
723 # Distutils interface (by Jack Jansen)
724
725 import distutils.command
726 std_commands = distutils.command.__all__
727 is_std = {}
728 for cmd in std_commands:
729 is_std[cmd] = 1
730
731 extra_commands = []
732 for cmd in self.cmdclass.keys():
733 if not is_std.get(cmd):
734 extra_commands.append(cmd)
735
736 rv = []
737 for cmd in (std_commands + extra_commands):
738 klass = self.cmdclass.get(cmd)
739 if not klass:
740 klass = self.get_command_class(cmd)
741 try:
742 description = klass.description
743 except AttributeError:
744 description = "(no description available)"
745 rv.append((cmd, description))
746 return rv
747
748 # -- Command class/object methods ----------------------------------
749
750 def get_command_class (self, command):
751 """Return the class that implements the Distutils command named by
752 'command'. First we check the 'cmdclass' dictionary; if the
753 command is mentioned there, we fetch the class object from the
754 dictionary and return it. Otherwise we load the command module
755 ("distutils.command." + command) and fetch the command class from
756 the module. The loaded class is also stored in 'cmdclass'
757 to speed future calls to 'get_command_class()'.
758
759 Raises DistutilsModuleError if the expected module could not be
760 found, or if that module does not define the expected class.
761 """
762 klass = self.cmdclass.get(command)
763 if klass:
764 return klass
765
766 module_name = 'distutils.command.' + command
767 klass_name = command
768
769 try:
770 __import__ (module_name)
771 module = sys.modules[module_name]
772 except ImportError:
773 raise DistutilsModuleError, \
774 "invalid command '%s' (no module named '%s')" % \
775 (command, module_name)
776
777 try:
778 klass = getattr(module, klass_name)
779 except AttributeError:
780 raise DistutilsModuleError, \
781 "invalid command '%s' (no class '%s' in module '%s')" \
782 % (command, klass_name, module_name)
783
784 self.cmdclass[command] = klass
785 return klass
786
787 # get_command_class ()
788
789 def get_command_obj (self, command, create=1):
790 """Return the command object for 'command'. Normally this object
791 is cached on a previous call to 'get_command_obj()'; if no command
792 object for 'command' is in the cache, then we either create and
793 return it (if 'create' is true) or return None.
794 """
795 cmd_obj = self.command_obj.get(command)
796 if not cmd_obj and create:
797 if DEBUG:
798 print "Distribution.get_command_obj(): " \
799 "creating '%s' command object" % command
800
801 klass = self.get_command_class(command)
802 cmd_obj = self.command_obj[command] = klass(self)
803 self.have_run[command] = 0
804
805 # Set any options that were supplied in config files
806 # or on the command line. (NB. support for error
807 # reporting is lame here: any errors aren't reported
808 # until 'finalize_options()' is called, which means
809 # we won't report the source of the error.)
810 options = self.command_options.get(command)
811 if options:
812 self._set_command_options(cmd_obj, options)
813
814 return cmd_obj
815
816 def _set_command_options (self, command_obj, option_dict=None):
817 """Set the options for 'command_obj' from 'option_dict'. Basically
818 this means copying elements of a dictionary ('option_dict') to
819 attributes of an instance ('command').
820
821 'command_obj' must be a Command instance. If 'option_dict' is not
822 supplied, uses the standard option dictionary for this command
823 (from 'self.command_options').
824 """
825 command_name = command_obj.get_command_name()
826 if option_dict is None:
827 option_dict = self.get_option_dict(command_name)
828
829 if DEBUG: print " setting options for '%s' command:" % command_name
830 for (option, (source, value)) in option_dict.items():
831 if DEBUG: print " %s = %s (from %s)" % (option, value, source)
832 try:
833 bool_opts = map(translate_longopt, command_obj.boolean_options)
834 except AttributeError:
835 bool_opts = []
836 try:
837 neg_opt = command_obj.negative_opt
838 except AttributeError:
839 neg_opt = {}
840
841 try:
842 is_string = type(value) is StringType
843 if neg_opt.has_key(option) and is_string:
844 setattr(command_obj, neg_opt[option], not strtobool(value))
845 elif option in bool_opts and is_string:
846 setattr(command_obj, option, strtobool(value))
847 elif hasattr(command_obj, option):
848 setattr(command_obj, option, value)
849 else:
850 raise DistutilsOptionError, \
851 ("error in %s: command '%s' has no such option '%s'"
852 % (source, command_name, option))
853 except ValueError, msg:
854 raise DistutilsOptionError, msg
855
856 def reinitialize_command (self, command, reinit_subcommands=0):
857 """Reinitializes a command to the state it was in when first
858 returned by 'get_command_obj()': ie., initialized but not yet
859 finalized. This provides the opportunity to sneak option
860 values in programmatically, overriding or supplementing
861 user-supplied values from the config files and command line.
862 You'll have to re-finalize the command object (by calling
863 'finalize_options()' or 'ensure_finalized()') before using it for
864 real.
865
866 'command' should be a command name (string) or command object. If
867 'reinit_subcommands' is true, also reinitializes the command's
868 sub-commands, as declared by the 'sub_commands' class attribute (if
869 it has one). See the "install" command for an example. Only
870 reinitializes the sub-commands that actually matter, ie. those
871 whose test predicates return true.
872
873 Returns the reinitialized command object.
874 """
875 from distutils.cmd import Command
876 if not isinstance(command, Command):
877 command_name = command
878 command = self.get_command_obj(command_name)
879 else:
880 command_name = command.get_command_name()
881
882 if not command.finalized:
883 return command
884 command.initialize_options()
885 command.finalized = 0
886 self.have_run[command_name] = 0
887 self._set_command_options(command)
888
889 if reinit_subcommands:
890 for sub in command.get_sub_commands():
891 self.reinitialize_command(sub, reinit_subcommands)
892
893 return command
894
895
896 # -- Methods that operate on the Distribution ----------------------
897
898 def announce (self, msg, level=1):
899 log.debug(msg)
900
901 def run_commands (self):
902 """Run each command that was seen on the setup script command line.
903 Uses the list of commands found and cache of command objects
904 created by 'get_command_obj()'.
905 """
906 for cmd in self.commands:
907 self.run_command(cmd)
908
909
910 # -- Methods that operate on its Commands --------------------------
911
912 def run_command (self, command):
913 """Do whatever it takes to run a command (including nothing at all,
914 if the command has already been run). Specifically: if we have
915 already created and run the command named by 'command', return
916 silently without doing anything. If the command named by 'command'
917 doesn't even have a command object yet, create one. Then invoke
918 'run()' on that command object (or an existing one).
919 """
920 # Already been here, done that? then return silently.
921 if self.have_run.get(command):
922 return
923
924 log.info("running %s", command)
925 cmd_obj = self.get_command_obj(command)
926 cmd_obj.ensure_finalized()
927 cmd_obj.run()
928 self.have_run[command] = 1
929
930
931 # -- Distribution query methods ------------------------------------
932
933 def has_pure_modules (self):
934 return len(self.packages or self.py_modules or []) > 0
935
936 def has_ext_modules (self):
937 return self.ext_modules and len(self.ext_modules) > 0
938
939 def has_c_libraries (self):
940 return self.libraries and len(self.libraries) > 0
941
942 def has_modules (self):
943 return self.has_pure_modules() or self.has_ext_modules()
944
945 def has_headers (self):
946 return self.headers and len(self.headers) > 0
947
948 def has_scripts (self):
949 return self.scripts and len(self.scripts) > 0
950
951 def has_data_files (self):
952 return self.data_files and len(self.data_files) > 0
953
954 def is_pure (self):
955 return (self.has_pure_modules() and
956 not self.has_ext_modules() and
957 not self.has_c_libraries())
958
959 # -- Metadata query methods ----------------------------------------
960
961 # If you're looking for 'get_name()', 'get_version()', and so forth,
962 # they are defined in a sneaky way: the constructor binds self.get_XXX
963 # to self.metadata.get_XXX. The actual code is in the
964 # DistributionMetadata class, below.
965
966# class Distribution
967
968
969class DistributionMetadata:
970 """Dummy class to hold the distribution meta-data: name, version,
971 author, and so forth.
972 """
973
974 _METHOD_BASENAMES = ("name", "version", "author", "author_email",
975 "maintainer", "maintainer_email", "url",
976 "license", "description", "long_description",
977 "keywords", "platforms", "fullname", "contact",
e55c4dd1 978 "contact_email", "license", "classifiers",
1e4a197e
RD
979 "download_url")
980
981 def __init__ (self):
982 self.name = None
983 self.version = None
984 self.author = None
985 self.author_email = None
986 self.maintainer = None
987 self.maintainer_email = None
988 self.url = None
989 self.license = None
990 self.description = None
991 self.long_description = None
992 self.keywords = None
993 self.platforms = None
994 self.classifiers = None
995 self.download_url = None
996
997 def write_pkg_info (self, base_dir):
998 """Write the PKG-INFO file into the release tree.
999 """
1000
1001 pkg_info = open( os.path.join(base_dir, 'PKG-INFO'), 'w')
1002
1003 pkg_info.write('Metadata-Version: 1.0\n')
1004 pkg_info.write('Name: %s\n' % self.get_name() )
1005 pkg_info.write('Version: %s\n' % self.get_version() )
1006 pkg_info.write('Summary: %s\n' % self.get_description() )
1007 pkg_info.write('Home-page: %s\n' % self.get_url() )
1008 pkg_info.write('Author: %s\n' % self.get_contact() )
1009 pkg_info.write('Author-email: %s\n' % self.get_contact_email() )
1010 pkg_info.write('License: %s\n' % self.get_license() )
1011 if self.download_url:
1012 pkg_info.write('Download-URL: %s\n' % self.download_url)
1013
1014 long_desc = rfc822_escape( self.get_long_description() )
1015 pkg_info.write('Description: %s\n' % long_desc)
1016
1017 keywords = string.join( self.get_keywords(), ',')
1018 if keywords:
1019 pkg_info.write('Keywords: %s\n' % keywords )
1020
1021 for platform in self.get_platforms():
1022 pkg_info.write('Platform: %s\n' % platform )
1023
1024 for classifier in self.get_classifiers():
1025 pkg_info.write('Classifier: %s\n' % classifier )
1026
1027 pkg_info.close()
1028
1029 # write_pkg_info ()
1030
1031 # -- Metadata query methods ----------------------------------------
1032
1033 def get_name (self):
1034 return self.name or "UNKNOWN"
1035
1036 def get_version(self):
1037 return self.version or "0.0.0"
1038
1039 def get_fullname (self):
1040 return "%s-%s" % (self.get_name(), self.get_version())
1041
1042 def get_author(self):
1043 return self.author or "UNKNOWN"
1044
1045 def get_author_email(self):
1046 return self.author_email or "UNKNOWN"
1047
1048 def get_maintainer(self):
1049 return self.maintainer or "UNKNOWN"
1050
1051 def get_maintainer_email(self):
1052 return self.maintainer_email or "UNKNOWN"
1053
1054 def get_contact(self):
1055 return (self.maintainer or
1056 self.author or
1057 "UNKNOWN")
1058
1059 def get_contact_email(self):
1060 return (self.maintainer_email or
1061 self.author_email or
1062 "UNKNOWN")
1063
1064 def get_url(self):
1065 return self.url or "UNKNOWN"
1066
1067 def get_license(self):
1068 return self.license or "UNKNOWN"
1069 get_licence = get_license
1070
1071 def get_description(self):
1072 return self.description or "UNKNOWN"
1073
1074 def get_long_description(self):
1075 return self.long_description or "UNKNOWN"
1076
1077 def get_keywords(self):
1078 return self.keywords or []
1079
1080 def get_platforms(self):
1081 return self.platforms or ["UNKNOWN"]
1082
1083 def get_classifiers(self):
1084 return self.classifiers or []
1085
1086 def get_download_url(self):
1087 return self.download_url or "UNKNOWN"
1088
1089# class DistributionMetadata
1090
1091
1092def fix_help_options (options):
1093 """Convert a 4-tuple 'help_options' list as found in various command
1094 classes to the 3-tuple form required by FancyGetopt.
1095 """
1096 new_options = []
1097 for help_tuple in options:
1098 new_options.append(help_tuple[0:3])
1099 return new_options
1100
1101
1102if __name__ == "__main__":
1103 dist = Distribution()
1104 print "ok"