Backport importlib to at least Python 2.5 by getting rid of use of str.format.
[python.git] / setup.py
blob1aa14d127dab81d1b95068c3b56c15b10a97056f
1 # Autodetecting setup.py script for building the Python extensions
4 __version__ = "$Revision$"
6 import sys, os, imp, re, optparse
7 from glob import glob
8 from platform import machine as platform_machine
10 from distutils import log
11 from distutils import sysconfig
12 from distutils import text_file
13 from distutils.errors import *
14 from distutils.core import Extension, setup
15 from distutils.command.build_ext import build_ext
16 from distutils.command.install import install
17 from distutils.command.install_lib import install_lib
19 # This global variable is used to hold the list of modules to be disabled.
20 disabled_module_list = []
22 def add_dir_to_list(dirlist, dir):
23 """Add the directory 'dir' to the list 'dirlist' (at the front) if
24 1) 'dir' is not already in 'dirlist'
25 2) 'dir' actually exists, and is a directory."""
26 if dir is not None and os.path.isdir(dir) and dir not in dirlist:
27 dirlist.insert(0, dir)
29 def find_file(filename, std_dirs, paths):
30 """Searches for the directory where a given file is located,
31 and returns a possibly-empty list of additional directories, or None
32 if the file couldn't be found at all.
34 'filename' is the name of a file, such as readline.h or libcrypto.a.
35 'std_dirs' is the list of standard system directories; if the
36 file is found in one of them, no additional directives are needed.
37 'paths' is a list of additional locations to check; if the file is
38 found in one of them, the resulting list will contain the directory.
39 """
41 # Check the standard locations
42 for dir in std_dirs:
43 f = os.path.join(dir, filename)
44 if os.path.exists(f): return []
46 # Check the additional directories
47 for dir in paths:
48 f = os.path.join(dir, filename)
49 if os.path.exists(f):
50 return [dir]
52 # Not found anywhere
53 return None
55 def find_library_file(compiler, libname, std_dirs, paths):
56 result = compiler.find_library_file(std_dirs + paths, libname)
57 if result is None:
58 return None
60 # Check whether the found file is in one of the standard directories
61 dirname = os.path.dirname(result)
62 for p in std_dirs:
63 # Ensure path doesn't end with path separator
64 p = p.rstrip(os.sep)
65 if p == dirname:
66 return [ ]
68 # Otherwise, it must have been in one of the additional directories,
69 # so we have to figure out which one.
70 for p in paths:
71 # Ensure path doesn't end with path separator
72 p = p.rstrip(os.sep)
73 if p == dirname:
74 return [p]
75 else:
76 assert False, "Internal error: Path not found in std_dirs or paths"
78 def module_enabled(extlist, modname):
79 """Returns whether the module 'modname' is present in the list
80 of extensions 'extlist'."""
81 extlist = [ext for ext in extlist if ext.name == modname]
82 return len(extlist)
84 def find_module_file(module, dirlist):
85 """Find a module in a set of possible folders. If it is not found
86 return the unadorned filename"""
87 list = find_file(module, [], dirlist)
88 if not list:
89 return module
90 if len(list) > 1:
91 log.info("WARNING: multiple copies of %s found"%module)
92 return os.path.join(list[0], module)
94 class PyBuildExt(build_ext):
96 def __init__(self, dist):
97 build_ext.__init__(self, dist)
98 self.failed = []
100 def build_extensions(self):
102 # Detect which modules should be compiled
103 missing = self.detect_modules()
105 # Remove modules that are present on the disabled list
106 extensions = [ext for ext in self.extensions
107 if ext.name not in disabled_module_list]
108 # move ctypes to the end, it depends on other modules
109 ext_map = dict((ext.name, i) for i, ext in enumerate(extensions))
110 if "_ctypes" in ext_map:
111 ctypes = extensions.pop(ext_map["_ctypes"])
112 extensions.append(ctypes)
113 self.extensions = extensions
115 # Fix up the autodetected modules, prefixing all the source files
116 # with Modules/ and adding Python's include directory to the path.
117 (srcdir,) = sysconfig.get_config_vars('srcdir')
118 if not srcdir:
119 # Maybe running on Windows but not using CYGWIN?
120 raise ValueError("No source directory; cannot proceed.")
122 # Figure out the location of the source code for extension modules
123 # (This logic is copied in distutils.test.test_sysconfig,
124 # so building in a separate directory does not break test_distutils.)
125 moddir = os.path.join(os.getcwd(), srcdir, 'Modules')
126 moddir = os.path.normpath(moddir)
127 srcdir, tail = os.path.split(moddir)
128 srcdir = os.path.normpath(srcdir)
129 moddir = os.path.normpath(moddir)
131 moddirlist = [moddir]
132 incdirlist = ['./Include']
134 # Platform-dependent module source and include directories
135 platform = self.get_platform()
136 if platform in ('darwin', 'mac') and ("--disable-toolbox-glue" not in
137 sysconfig.get_config_var("CONFIG_ARGS")):
138 # Mac OS X also includes some mac-specific modules
139 macmoddir = os.path.join(os.getcwd(), srcdir, 'Mac/Modules')
140 moddirlist.append(macmoddir)
141 incdirlist.append('./Mac/Include')
143 alldirlist = moddirlist + incdirlist
145 # Fix up the paths for scripts, too
146 self.distribution.scripts = [os.path.join(srcdir, filename)
147 for filename in self.distribution.scripts]
149 # Python header files
150 headers = glob("Include/*.h") + ["pyconfig.h"]
152 for ext in self.extensions[:]:
153 ext.sources = [ find_module_file(filename, moddirlist)
154 for filename in ext.sources ]
155 if ext.depends is not None:
156 ext.depends = [find_module_file(filename, alldirlist)
157 for filename in ext.depends]
158 else:
159 ext.depends = []
160 # re-compile extensions if a header file has been changed
161 ext.depends.extend(headers)
163 ext.include_dirs.append( '.' ) # to get config.h
164 for incdir in incdirlist:
165 ext.include_dirs.append( os.path.join(srcdir, incdir) )
167 # If a module has already been built statically,
168 # don't build it here
169 if ext.name in sys.builtin_module_names:
170 self.extensions.remove(ext)
172 if platform != 'mac':
173 # Parse Modules/Setup and Modules/Setup.local to figure out which
174 # modules are turned on in the file.
175 remove_modules = []
176 for filename in ('Modules/Setup', 'Modules/Setup.local'):
177 input = text_file.TextFile(filename, join_lines=1)
178 while 1:
179 line = input.readline()
180 if not line: break
181 line = line.split()
182 remove_modules.append(line[0])
183 input.close()
185 for ext in self.extensions[:]:
186 if ext.name in remove_modules:
187 self.extensions.remove(ext)
189 # When you run "make CC=altcc" or something similar, you really want
190 # those environment variables passed into the setup.py phase. Here's
191 # a small set of useful ones.
192 compiler = os.environ.get('CC')
193 args = {}
194 # unfortunately, distutils doesn't let us provide separate C and C++
195 # compilers
196 if compiler is not None:
197 (ccshared,cflags) = sysconfig.get_config_vars('CCSHARED','CFLAGS')
198 args['compiler_so'] = compiler + ' ' + ccshared + ' ' + cflags
199 self.compiler.set_executables(**args)
201 build_ext.build_extensions(self)
203 longest = max([len(e.name) for e in self.extensions])
204 if self.failed:
205 longest = max(longest, max([len(name) for name in self.failed]))
207 def print_three_column(lst):
208 lst.sort(key=str.lower)
209 # guarantee zip() doesn't drop anything
210 while len(lst) % 3:
211 lst.append("")
212 for e, f, g in zip(lst[::3], lst[1::3], lst[2::3]):
213 print "%-*s %-*s %-*s" % (longest, e, longest, f,
214 longest, g)
216 if missing:
217 print
218 print ("Python build finished, but the necessary bits to build "
219 "these modules were not found:")
220 print_three_column(missing)
221 print ("To find the necessary bits, look in setup.py in"
222 " detect_modules() for the module's name.")
223 print
225 if self.failed:
226 failed = self.failed[:]
227 print
228 print "Failed to build these modules:"
229 print_three_column(failed)
230 print
232 def build_extension(self, ext):
234 if ext.name == '_ctypes':
235 if not self.configure_ctypes(ext):
236 return
238 try:
239 build_ext.build_extension(self, ext)
240 except (CCompilerError, DistutilsError), why:
241 self.announce('WARNING: building of extension "%s" failed: %s' %
242 (ext.name, sys.exc_info()[1]))
243 self.failed.append(ext.name)
244 return
245 # Workaround for Mac OS X: The Carbon-based modules cannot be
246 # reliably imported into a command-line Python
247 if 'Carbon' in ext.extra_link_args:
248 self.announce(
249 'WARNING: skipping import check for Carbon-based "%s"' %
250 ext.name)
251 return
253 if self.get_platform() == 'darwin' and (
254 sys.maxint > 2**32 and '-arch' in ext.extra_link_args):
255 # Don't bother doing an import check when an extension was
256 # build with an explicit '-arch' flag on OSX. That's currently
257 # only used to build 32-bit only extensions in a 4-way
258 # universal build and loading 32-bit code into a 64-bit
259 # process will fail.
260 self.announce(
261 'WARNING: skipping import check for "%s"' %
262 ext.name)
263 return
265 # Workaround for Cygwin: Cygwin currently has fork issues when many
266 # modules have been imported
267 if self.get_platform() == 'cygwin':
268 self.announce('WARNING: skipping import check for Cygwin-based "%s"'
269 % ext.name)
270 return
271 ext_filename = os.path.join(
272 self.build_lib,
273 self.get_ext_filename(self.get_ext_fullname(ext.name)))
274 try:
275 imp.load_dynamic(ext.name, ext_filename)
276 except ImportError, why:
277 self.failed.append(ext.name)
278 self.announce('*** WARNING: renaming "%s" since importing it'
279 ' failed: %s' % (ext.name, why), level=3)
280 assert not self.inplace
281 basename, tail = os.path.splitext(ext_filename)
282 newname = basename + "_failed" + tail
283 if os.path.exists(newname):
284 os.remove(newname)
285 os.rename(ext_filename, newname)
287 # XXX -- This relies on a Vile HACK in
288 # distutils.command.build_ext.build_extension(). The
289 # _built_objects attribute is stored there strictly for
290 # use here.
291 # If there is a failure, _built_objects may not be there,
292 # so catch the AttributeError and move on.
293 try:
294 for filename in self._built_objects:
295 os.remove(filename)
296 except AttributeError:
297 self.announce('unable to remove files (ignored)')
298 except:
299 exc_type, why, tb = sys.exc_info()
300 self.announce('*** WARNING: importing extension "%s" '
301 'failed with %s: %s' % (ext.name, exc_type, why),
302 level=3)
303 self.failed.append(ext.name)
305 def get_platform(self):
306 # Get value of sys.platform
307 for platform in ['cygwin', 'beos', 'darwin', 'atheos', 'osf1']:
308 if sys.platform.startswith(platform):
309 return platform
310 return sys.platform
312 def detect_modules(self):
313 # Ensure that /usr/local is always used
314 add_dir_to_list(self.compiler.library_dirs, '/usr/local/lib')
315 add_dir_to_list(self.compiler.include_dirs, '/usr/local/include')
317 # Add paths specified in the environment variables LDFLAGS and
318 # CPPFLAGS for header and library files.
319 # We must get the values from the Makefile and not the environment
320 # directly since an inconsistently reproducible issue comes up where
321 # the environment variable is not set even though the value were passed
322 # into configure and stored in the Makefile (issue found on OS X 10.3).
323 for env_var, arg_name, dir_list in (
324 ('LDFLAGS', '-R', self.compiler.runtime_library_dirs),
325 ('LDFLAGS', '-L', self.compiler.library_dirs),
326 ('CPPFLAGS', '-I', self.compiler.include_dirs)):
327 env_val = sysconfig.get_config_var(env_var)
328 if env_val:
329 # To prevent optparse from raising an exception about any
330 # options in env_val that it doesn't know about we strip out
331 # all double dashes and any dashes followed by a character
332 # that is not for the option we are dealing with.
334 # Please note that order of the regex is important! We must
335 # strip out double-dashes first so that we don't end up with
336 # substituting "--Long" to "-Long" and thus lead to "ong" being
337 # used for a library directory.
338 env_val = re.sub(r'(^|\s+)-(-|(?!%s))' % arg_name[1],
339 ' ', env_val)
340 parser = optparse.OptionParser()
341 # Make sure that allowing args interspersed with options is
342 # allowed
343 parser.allow_interspersed_args = True
344 parser.error = lambda msg: None
345 parser.add_option(arg_name, dest="dirs", action="append")
346 options = parser.parse_args(env_val.split())[0]
347 if options.dirs:
348 for directory in reversed(options.dirs):
349 add_dir_to_list(dir_list, directory)
351 if os.path.normpath(sys.prefix) != '/usr':
352 add_dir_to_list(self.compiler.library_dirs,
353 sysconfig.get_config_var("LIBDIR"))
354 add_dir_to_list(self.compiler.include_dirs,
355 sysconfig.get_config_var("INCLUDEDIR"))
357 try:
358 have_unicode = unicode
359 except NameError:
360 have_unicode = 0
362 # lib_dirs and inc_dirs are used to search for files;
363 # if a file is found in one of those directories, it can
364 # be assumed that no additional -I,-L directives are needed.
365 lib_dirs = self.compiler.library_dirs + [
366 '/lib64', '/usr/lib64',
367 '/lib', '/usr/lib',
369 inc_dirs = self.compiler.include_dirs + ['/usr/include']
370 exts = []
371 missing = []
373 config_h = sysconfig.get_config_h_filename()
374 config_h_vars = sysconfig.parse_config_h(open(config_h))
376 platform = self.get_platform()
377 (srcdir,) = sysconfig.get_config_vars('srcdir')
379 # Check for AtheOS which has libraries in non-standard locations
380 if platform == 'atheos':
381 lib_dirs += ['/system/libs', '/atheos/autolnk/lib']
382 lib_dirs += os.getenv('LIBRARY_PATH', '').split(os.pathsep)
383 inc_dirs += ['/system/include', '/atheos/autolnk/include']
384 inc_dirs += os.getenv('C_INCLUDE_PATH', '').split(os.pathsep)
386 # OSF/1 and Unixware have some stuff in /usr/ccs/lib (like -ldb)
387 if platform in ['osf1', 'unixware7', 'openunix8']:
388 lib_dirs += ['/usr/ccs/lib']
390 if platform == 'darwin':
391 # This should work on any unixy platform ;-)
392 # If the user has bothered specifying additional -I and -L flags
393 # in OPT and LDFLAGS we might as well use them here.
394 # NOTE: using shlex.split would technically be more correct, but
395 # also gives a bootstrap problem. Let's hope nobody uses directories
396 # with whitespace in the name to store libraries.
397 cflags, ldflags = sysconfig.get_config_vars(
398 'CFLAGS', 'LDFLAGS')
399 for item in cflags.split():
400 if item.startswith('-I'):
401 inc_dirs.append(item[2:])
403 for item in ldflags.split():
404 if item.startswith('-L'):
405 lib_dirs.append(item[2:])
407 # Check for MacOS X, which doesn't need libm.a at all
408 math_libs = ['m']
409 if platform in ['darwin', 'beos', 'mac']:
410 math_libs = []
412 # XXX Omitted modules: gl, pure, dl, SGI-specific modules
415 # The following modules are all pretty straightforward, and compile
416 # on pretty much any POSIXish platform.
419 # Some modules that are normally always on:
420 exts.append( Extension('_weakref', ['_weakref.c']) )
422 # array objects
423 exts.append( Extension('array', ['arraymodule.c']) )
424 # complex math library functions
425 exts.append( Extension('cmath', ['cmathmodule.c'],
426 libraries=math_libs) )
428 # math library functions, e.g. sin()
429 exts.append( Extension('math', ['mathmodule.c'],
430 libraries=math_libs) )
431 # fast string operations implemented in C
432 exts.append( Extension('strop', ['stropmodule.c']) )
433 # time operations and variables
434 exts.append( Extension('time', ['timemodule.c'],
435 libraries=math_libs) )
436 exts.append( Extension('datetime', ['datetimemodule.c', 'timemodule.c'],
437 libraries=math_libs) )
438 # fast iterator tools implemented in C
439 exts.append( Extension("itertools", ["itertoolsmodule.c"]) )
440 # code that will be builtins in the future, but conflict with the
441 # current builtins
442 exts.append( Extension('future_builtins', ['future_builtins.c']) )
443 # random number generator implemented in C
444 exts.append( Extension("_random", ["_randommodule.c"]) )
445 # high-performance collections
446 exts.append( Extension("_collections", ["_collectionsmodule.c"]) )
447 # bisect
448 exts.append( Extension("_bisect", ["_bisectmodule.c"]) )
449 # heapq
450 exts.append( Extension("_heapq", ["_heapqmodule.c"]) )
451 # operator.add() and similar goodies
452 exts.append( Extension('operator', ['operator.c']) )
453 # Python 3.0 _fileio module
454 exts.append( Extension("_fileio", ["_fileio.c"]) )
455 # Python 3.0 _bytesio module
456 exts.append( Extension("_bytesio", ["_bytesio.c"]) )
457 # _functools
458 exts.append( Extension("_functools", ["_functoolsmodule.c"]) )
459 # _json speedups
460 exts.append( Extension("_json", ["_json.c"]) )
461 # Python C API test module
462 exts.append( Extension('_testcapi', ['_testcapimodule.c']) )
463 # profilers (_lsprof is for cProfile.py)
464 exts.append( Extension('_hotshot', ['_hotshot.c']) )
465 exts.append( Extension('_lsprof', ['_lsprof.c', 'rotatingtree.c']) )
466 # static Unicode character database
467 if have_unicode:
468 exts.append( Extension('unicodedata', ['unicodedata.c']) )
469 else:
470 missing.append('unicodedata')
471 # access to ISO C locale support
472 data = open('pyconfig.h').read()
473 m = re.search(r"#s*define\s+WITH_LIBINTL\s+1\s*", data)
474 if m is not None:
475 locale_libs = ['intl']
476 else:
477 locale_libs = []
478 if platform == 'darwin':
479 locale_extra_link_args = ['-framework', 'CoreFoundation']
480 else:
481 locale_extra_link_args = []
484 exts.append( Extension('_locale', ['_localemodule.c'],
485 libraries=locale_libs,
486 extra_link_args=locale_extra_link_args) )
488 # Modules with some UNIX dependencies -- on by default:
489 # (If you have a really backward UNIX, select and socket may not be
490 # supported...)
492 # fcntl(2) and ioctl(2)
493 exts.append( Extension('fcntl', ['fcntlmodule.c']) )
494 if platform not in ['mac']:
495 # pwd(3)
496 exts.append( Extension('pwd', ['pwdmodule.c']) )
497 # grp(3)
498 exts.append( Extension('grp', ['grpmodule.c']) )
499 # spwd, shadow passwords
500 if (config_h_vars.get('HAVE_GETSPNAM', False) or
501 config_h_vars.get('HAVE_GETSPENT', False)):
502 exts.append( Extension('spwd', ['spwdmodule.c']) )
503 else:
504 missing.append('spwd')
505 else:
506 missing.extend(['pwd', 'grp', 'spwd'])
508 # select(2); not on ancient System V
509 exts.append( Extension('select', ['selectmodule.c']) )
511 # Fred Drake's interface to the Python parser
512 exts.append( Extension('parser', ['parsermodule.c']) )
514 # cStringIO and cPickle
515 exts.append( Extension('cStringIO', ['cStringIO.c']) )
516 exts.append( Extension('cPickle', ['cPickle.c']) )
518 # Memory-mapped files (also works on Win32).
519 if platform not in ['atheos', 'mac']:
520 exts.append( Extension('mmap', ['mmapmodule.c']) )
521 else:
522 missing.append('mmap')
524 # Lance Ellinghaus's syslog module
525 if platform not in ['mac']:
526 # syslog daemon interface
527 exts.append( Extension('syslog', ['syslogmodule.c']) )
528 else:
529 missing.append('syslog')
531 # George Neville-Neil's timing module:
532 # Deprecated in PEP 4 http://www.python.org/peps/pep-0004.html
533 # http://mail.python.org/pipermail/python-dev/2006-January/060023.html
534 #exts.append( Extension('timing', ['timingmodule.c']) )
537 # Here ends the simple stuff. From here on, modules need certain
538 # libraries, are platform-specific, or present other surprises.
541 # Multimedia modules
542 # These don't work for 64-bit platforms!!!
543 # These represent audio samples or images as strings:
545 # Operations on audio samples
546 # According to #993173, this one should actually work fine on
547 # 64-bit platforms.
548 exts.append( Extension('audioop', ['audioop.c']) )
550 # Disabled on 64-bit platforms
551 if sys.maxint != 9223372036854775807L:
552 # Operations on images
553 exts.append( Extension('imageop', ['imageop.c']) )
554 else:
555 missing.extend(['imageop'])
557 # readline
558 do_readline = self.compiler.find_library_file(lib_dirs, 'readline')
559 if platform == 'darwin': # and os.uname()[2] < '9.':
560 # MacOSX 10.4 has a broken readline. Don't try to build
561 # the readline module unless the user has installed a fixed
562 # readline package
563 # FIXME: The readline emulation on 10.5 is better, but the
564 # readline module doesn't compile out of the box.
565 if find_file('readline/rlconf.h', inc_dirs, []) is None:
566 do_readline = False
567 if do_readline:
568 if sys.platform == 'darwin':
569 # In every directory on the search path search for a dynamic
570 # library and then a static library, instead of first looking
571 # for dynamic libraries on the entiry path.
572 # This way a staticly linked custom readline gets picked up
573 # before the (broken) dynamic library in /usr/lib.
574 readline_extra_link_args = ('-Wl,-search_paths_first',)
575 else:
576 readline_extra_link_args = ()
578 readline_libs = ['readline']
579 if self.compiler.find_library_file(lib_dirs,
580 'ncursesw'):
581 readline_libs.append('ncursesw')
582 elif self.compiler.find_library_file(lib_dirs,
583 'ncurses'):
584 readline_libs.append('ncurses')
585 elif self.compiler.find_library_file(lib_dirs, 'curses'):
586 readline_libs.append('curses')
587 elif self.compiler.find_library_file(lib_dirs +
588 ['/usr/lib/termcap'],
589 'termcap'):
590 readline_libs.append('termcap')
591 exts.append( Extension('readline', ['readline.c'],
592 library_dirs=['/usr/lib/termcap'],
593 extra_link_args=readline_extra_link_args,
594 libraries=readline_libs) )
595 else:
596 missing.append('readline')
598 if platform not in ['mac']:
599 # crypt module.
601 if self.compiler.find_library_file(lib_dirs, 'crypt'):
602 libs = ['crypt']
603 else:
604 libs = []
605 exts.append( Extension('crypt', ['cryptmodule.c'], libraries=libs) )
606 else:
607 missing.append('crypt')
609 # CSV files
610 exts.append( Extension('_csv', ['_csv.c']) )
612 # socket(2)
613 exts.append( Extension('_socket', ['socketmodule.c'],
614 depends = ['socketmodule.h']) )
615 # Detect SSL support for the socket module (via _ssl)
616 search_for_ssl_incs_in = [
617 '/usr/local/ssl/include',
618 '/usr/contrib/ssl/include/'
620 ssl_incs = find_file('openssl/ssl.h', inc_dirs,
621 search_for_ssl_incs_in
623 if ssl_incs is not None:
624 krb5_h = find_file('krb5.h', inc_dirs,
625 ['/usr/kerberos/include'])
626 if krb5_h:
627 ssl_incs += krb5_h
628 ssl_libs = find_library_file(self.compiler, 'ssl',lib_dirs,
629 ['/usr/local/ssl/lib',
630 '/usr/contrib/ssl/lib/'
633 if (ssl_incs is not None and
634 ssl_libs is not None):
635 exts.append( Extension('_ssl', ['_ssl.c'],
636 include_dirs = ssl_incs,
637 library_dirs = ssl_libs,
638 libraries = ['ssl', 'crypto'],
639 depends = ['socketmodule.h']), )
640 else:
641 missing.append('_ssl')
643 # find out which version of OpenSSL we have
644 openssl_ver = 0
645 openssl_ver_re = re.compile(
646 '^\s*#\s*define\s+OPENSSL_VERSION_NUMBER\s+(0x[0-9a-fA-F]+)' )
647 for ssl_inc_dir in inc_dirs + search_for_ssl_incs_in:
648 name = os.path.join(ssl_inc_dir, 'openssl', 'opensslv.h')
649 if os.path.isfile(name):
650 try:
651 incfile = open(name, 'r')
652 for line in incfile:
653 m = openssl_ver_re.match(line)
654 if m:
655 openssl_ver = eval(m.group(1))
656 break
657 except IOError:
658 pass
660 # first version found is what we'll use (as the compiler should)
661 if openssl_ver:
662 break
664 #print 'openssl_ver = 0x%08x' % openssl_ver
666 if (ssl_incs is not None and
667 ssl_libs is not None and
668 openssl_ver >= 0x00907000):
669 # The _hashlib module wraps optimized implementations
670 # of hash functions from the OpenSSL library.
671 exts.append( Extension('_hashlib', ['_hashopenssl.c'],
672 include_dirs = ssl_incs,
673 library_dirs = ssl_libs,
674 libraries = ['ssl', 'crypto']) )
675 # these aren't strictly missing since they are unneeded.
676 #missing.extend(['_sha', '_md5'])
677 else:
678 # The _sha module implements the SHA1 hash algorithm.
679 exts.append( Extension('_sha', ['shamodule.c']) )
680 # The _md5 module implements the RSA Data Security, Inc. MD5
681 # Message-Digest Algorithm, described in RFC 1321. The
682 # necessary files md5.c and md5.h are included here.
683 exts.append( Extension('_md5',
684 sources = ['md5module.c', 'md5.c'],
685 depends = ['md5.h']) )
686 missing.append('_hashlib')
688 if (openssl_ver < 0x00908000):
689 # OpenSSL doesn't do these until 0.9.8 so we'll bring our own hash
690 exts.append( Extension('_sha256', ['sha256module.c']) )
691 exts.append( Extension('_sha512', ['sha512module.c']) )
693 # Modules that provide persistent dictionary-like semantics. You will
694 # probably want to arrange for at least one of them to be available on
695 # your machine, though none are defined by default because of library
696 # dependencies. The Python module anydbm.py provides an
697 # implementation independent wrapper for these; dumbdbm.py provides
698 # similar functionality (but slower of course) implemented in Python.
700 # Sleepycat^WOracle Berkeley DB interface.
701 # http://www.oracle.com/database/berkeley-db/db/index.html
703 # This requires the Sleepycat^WOracle DB code. The supported versions
704 # are set below. Visit the URL above to download
705 # a release. Most open source OSes come with one or more
706 # versions of BerkeleyDB already installed.
708 max_db_ver = (4, 7)
709 min_db_ver = (3, 3)
710 db_setup_debug = False # verbose debug prints from this script?
712 def allow_db_ver(db_ver):
713 """Returns a boolean if the given BerkeleyDB version is acceptable.
715 Args:
716 db_ver: A tuple of the version to verify.
718 if not (min_db_ver <= db_ver <= max_db_ver):
719 return False
720 # Use this function to filter out known bad configurations.
721 if (4, 6) == db_ver[:2]:
722 # BerkeleyDB 4.6.x is not stable on many architectures.
723 arch = platform_machine()
724 if arch not in ('i386', 'i486', 'i586', 'i686',
725 'x86_64', 'ia64'):
726 return False
727 return True
729 def gen_db_minor_ver_nums(major):
730 if major == 4:
731 for x in range(max_db_ver[1]+1):
732 if allow_db_ver((4, x)):
733 yield x
734 elif major == 3:
735 for x in (3,):
736 if allow_db_ver((3, x)):
737 yield x
738 else:
739 raise ValueError("unknown major BerkeleyDB version", major)
741 # construct a list of paths to look for the header file in on
742 # top of the normal inc_dirs.
743 db_inc_paths = [
744 '/usr/include/db4',
745 '/usr/local/include/db4',
746 '/opt/sfw/include/db4',
747 '/usr/include/db3',
748 '/usr/local/include/db3',
749 '/opt/sfw/include/db3',
750 # Fink defaults (http://fink.sourceforge.net/)
751 '/sw/include/db4',
752 '/sw/include/db3',
754 # 4.x minor number specific paths
755 for x in gen_db_minor_ver_nums(4):
756 db_inc_paths.append('/usr/include/db4%d' % x)
757 db_inc_paths.append('/usr/include/db4.%d' % x)
758 db_inc_paths.append('/usr/local/BerkeleyDB.4.%d/include' % x)
759 db_inc_paths.append('/usr/local/include/db4%d' % x)
760 db_inc_paths.append('/pkg/db-4.%d/include' % x)
761 db_inc_paths.append('/opt/db-4.%d/include' % x)
762 # MacPorts default (http://www.macports.org/)
763 db_inc_paths.append('/opt/local/include/db4%d' % x)
764 # 3.x minor number specific paths
765 for x in gen_db_minor_ver_nums(3):
766 db_inc_paths.append('/usr/include/db3%d' % x)
767 db_inc_paths.append('/usr/local/BerkeleyDB.3.%d/include' % x)
768 db_inc_paths.append('/usr/local/include/db3%d' % x)
769 db_inc_paths.append('/pkg/db-3.%d/include' % x)
770 db_inc_paths.append('/opt/db-3.%d/include' % x)
772 # Add some common subdirectories for Sleepycat DB to the list,
773 # based on the standard include directories. This way DB3/4 gets
774 # picked up when it is installed in a non-standard prefix and
775 # the user has added that prefix into inc_dirs.
776 std_variants = []
777 for dn in inc_dirs:
778 std_variants.append(os.path.join(dn, 'db3'))
779 std_variants.append(os.path.join(dn, 'db4'))
780 for x in gen_db_minor_ver_nums(4):
781 std_variants.append(os.path.join(dn, "db4%d"%x))
782 std_variants.append(os.path.join(dn, "db4.%d"%x))
783 for x in gen_db_minor_ver_nums(3):
784 std_variants.append(os.path.join(dn, "db3%d"%x))
785 std_variants.append(os.path.join(dn, "db3.%d"%x))
787 db_inc_paths = std_variants + db_inc_paths
788 db_inc_paths = [p for p in db_inc_paths if os.path.exists(p)]
790 db_ver_inc_map = {}
792 class db_found(Exception): pass
793 try:
794 # See whether there is a Sleepycat header in the standard
795 # search path.
796 for d in inc_dirs + db_inc_paths:
797 f = os.path.join(d, "db.h")
798 if db_setup_debug: print "db: looking for db.h in", f
799 if os.path.exists(f):
800 f = open(f).read()
801 m = re.search(r"#define\WDB_VERSION_MAJOR\W(\d+)", f)
802 if m:
803 db_major = int(m.group(1))
804 m = re.search(r"#define\WDB_VERSION_MINOR\W(\d+)", f)
805 db_minor = int(m.group(1))
806 db_ver = (db_major, db_minor)
808 # Avoid 4.6 prior to 4.6.21 due to a BerkeleyDB bug
809 if db_ver == (4, 6):
810 m = re.search(r"#define\WDB_VERSION_PATCH\W(\d+)", f)
811 db_patch = int(m.group(1))
812 if db_patch < 21:
813 print "db.h:", db_ver, "patch", db_patch,
814 print "being ignored (4.6.x must be >= 4.6.21)"
815 continue
817 if ( (not db_ver_inc_map.has_key(db_ver)) and
818 allow_db_ver(db_ver) ):
819 # save the include directory with the db.h version
820 # (first occurrence only)
821 db_ver_inc_map[db_ver] = d
822 if db_setup_debug:
823 print "db.h: found", db_ver, "in", d
824 else:
825 # we already found a header for this library version
826 if db_setup_debug: print "db.h: ignoring", d
827 else:
828 # ignore this header, it didn't contain a version number
829 if db_setup_debug:
830 print "db.h: no version number version in", d
832 db_found_vers = db_ver_inc_map.keys()
833 db_found_vers.sort()
835 while db_found_vers:
836 db_ver = db_found_vers.pop()
837 db_incdir = db_ver_inc_map[db_ver]
839 # check lib directories parallel to the location of the header
840 db_dirs_to_check = [
841 db_incdir.replace("include", 'lib64'),
842 db_incdir.replace("include", 'lib'),
844 db_dirs_to_check = filter(os.path.isdir, db_dirs_to_check)
846 # Look for a version specific db-X.Y before an ambiguoius dbX
847 # XXX should we -ever- look for a dbX name? Do any
848 # systems really not name their library by version and
849 # symlink to more general names?
850 for dblib in (('db-%d.%d' % db_ver),
851 ('db%d%d' % db_ver),
852 ('db%d' % db_ver[0])):
853 dblib_file = self.compiler.find_library_file(
854 db_dirs_to_check + lib_dirs, dblib )
855 if dblib_file:
856 dblib_dir = [ os.path.abspath(os.path.dirname(dblib_file)) ]
857 raise db_found
858 else:
859 if db_setup_debug: print "db lib: ", dblib, "not found"
861 except db_found:
862 if db_setup_debug:
863 print "bsddb using BerkeleyDB lib:", db_ver, dblib
864 print "bsddb lib dir:", dblib_dir, " inc dir:", db_incdir
865 db_incs = [db_incdir]
866 dblibs = [dblib]
867 # We add the runtime_library_dirs argument because the
868 # BerkeleyDB lib we're linking against often isn't in the
869 # system dynamic library search path. This is usually
870 # correct and most trouble free, but may cause problems in
871 # some unusual system configurations (e.g. the directory
872 # is on an NFS server that goes away).
873 exts.append(Extension('_bsddb', ['_bsddb.c'],
874 depends = ['bsddb.h'],
875 library_dirs=dblib_dir,
876 runtime_library_dirs=dblib_dir,
877 include_dirs=db_incs,
878 libraries=dblibs))
879 else:
880 if db_setup_debug: print "db: no appropriate library found"
881 db_incs = None
882 dblibs = []
883 dblib_dir = None
884 missing.append('_bsddb')
886 # The sqlite interface
887 sqlite_setup_debug = False # verbose debug prints from this script?
889 # We hunt for #define SQLITE_VERSION "n.n.n"
890 # We need to find >= sqlite version 3.0.8
891 sqlite_incdir = sqlite_libdir = None
892 sqlite_inc_paths = [ '/usr/include',
893 '/usr/include/sqlite',
894 '/usr/include/sqlite3',
895 '/usr/local/include',
896 '/usr/local/include/sqlite',
897 '/usr/local/include/sqlite3',
899 MIN_SQLITE_VERSION_NUMBER = (3, 0, 8)
900 MIN_SQLITE_VERSION = ".".join([str(x)
901 for x in MIN_SQLITE_VERSION_NUMBER])
903 # Scan the default include directories before the SQLite specific
904 # ones. This allows one to override the copy of sqlite on OSX,
905 # where /usr/include contains an old version of sqlite.
906 for d in inc_dirs + sqlite_inc_paths:
907 f = os.path.join(d, "sqlite3.h")
908 if os.path.exists(f):
909 if sqlite_setup_debug: print "sqlite: found %s"%f
910 incf = open(f).read()
911 m = re.search(
912 r'\s*.*#\s*.*define\s.*SQLITE_VERSION\W*"(.*)"', incf)
913 if m:
914 sqlite_version = m.group(1)
915 sqlite_version_tuple = tuple([int(x)
916 for x in sqlite_version.split(".")])
917 if sqlite_version_tuple >= MIN_SQLITE_VERSION_NUMBER:
918 # we win!
919 if sqlite_setup_debug:
920 print "%s/sqlite3.h: version %s"%(d, sqlite_version)
921 sqlite_incdir = d
922 break
923 else:
924 if sqlite_setup_debug:
925 print "%s: version %d is too old, need >= %s"%(d,
926 sqlite_version, MIN_SQLITE_VERSION)
927 elif sqlite_setup_debug:
928 print "sqlite: %s had no SQLITE_VERSION"%(f,)
930 if sqlite_incdir:
931 sqlite_dirs_to_check = [
932 os.path.join(sqlite_incdir, '..', 'lib64'),
933 os.path.join(sqlite_incdir, '..', 'lib'),
934 os.path.join(sqlite_incdir, '..', '..', 'lib64'),
935 os.path.join(sqlite_incdir, '..', '..', 'lib'),
937 sqlite_libfile = self.compiler.find_library_file(
938 sqlite_dirs_to_check + lib_dirs, 'sqlite3')
939 if sqlite_libfile:
940 sqlite_libdir = [os.path.abspath(os.path.dirname(sqlite_libfile))]
942 if sqlite_incdir and sqlite_libdir:
943 sqlite_srcs = ['_sqlite/cache.c',
944 '_sqlite/connection.c',
945 '_sqlite/cursor.c',
946 '_sqlite/microprotocols.c',
947 '_sqlite/module.c',
948 '_sqlite/prepare_protocol.c',
949 '_sqlite/row.c',
950 '_sqlite/statement.c',
951 '_sqlite/util.c', ]
953 sqlite_defines = []
954 if sys.platform != "win32":
955 sqlite_defines.append(('MODULE_NAME', '"sqlite3"'))
956 else:
957 sqlite_defines.append(('MODULE_NAME', '\\"sqlite3\\"'))
960 if sys.platform == 'darwin':
961 # In every directory on the search path search for a dynamic
962 # library and then a static library, instead of first looking
963 # for dynamic libraries on the entiry path.
964 # This way a staticly linked custom sqlite gets picked up
965 # before the dynamic library in /usr/lib.
966 sqlite_extra_link_args = ('-Wl,-search_paths_first',)
967 else:
968 sqlite_extra_link_args = ()
970 exts.append(Extension('_sqlite3', sqlite_srcs,
971 define_macros=sqlite_defines,
972 include_dirs=["Modules/_sqlite",
973 sqlite_incdir],
974 library_dirs=sqlite_libdir,
975 runtime_library_dirs=sqlite_libdir,
976 extra_link_args=sqlite_extra_link_args,
977 libraries=["sqlite3",]))
978 else:
979 missing.append('_sqlite3')
981 # Look for Berkeley db 1.85. Note that it is built as a different
982 # module name so it can be included even when later versions are
983 # available. A very restrictive search is performed to avoid
984 # accidentally building this module with a later version of the
985 # underlying db library. May BSD-ish Unixes incorporate db 1.85
986 # symbols into libc and place the include file in /usr/include.
988 # If the better bsddb library can be built (db_incs is defined)
989 # we do not build this one. Otherwise this build will pick up
990 # the more recent berkeleydb's db.h file first in the include path
991 # when attempting to compile and it will fail.
992 f = "/usr/include/db.h"
993 if os.path.exists(f) and not db_incs:
994 data = open(f).read()
995 m = re.search(r"#s*define\s+HASHVERSION\s+2\s*", data)
996 if m is not None:
997 # bingo - old version used hash file format version 2
998 ### XXX this should be fixed to not be platform-dependent
999 ### but I don't have direct access to an osf1 platform and
1000 ### seemed to be muffing the search somehow
1001 libraries = platform == "osf1" and ['db'] or None
1002 if libraries is not None:
1003 exts.append(Extension('bsddb185', ['bsddbmodule.c'],
1004 libraries=libraries))
1005 else:
1006 exts.append(Extension('bsddb185', ['bsddbmodule.c']))
1007 else:
1008 missing.append('bsddb185')
1009 else:
1010 missing.append('bsddb185')
1012 # The standard Unix dbm module:
1013 if platform not in ['cygwin']:
1014 if find_file("ndbm.h", inc_dirs, []) is not None:
1015 # Some systems have -lndbm, others don't
1016 if self.compiler.find_library_file(lib_dirs, 'ndbm'):
1017 ndbm_libs = ['ndbm']
1018 else:
1019 ndbm_libs = []
1020 exts.append( Extension('dbm', ['dbmmodule.c'],
1021 define_macros=[('HAVE_NDBM_H',None)],
1022 libraries = ndbm_libs ) )
1023 elif self.compiler.find_library_file(lib_dirs, 'gdbm'):
1024 gdbm_libs = ['gdbm']
1025 if self.compiler.find_library_file(lib_dirs, 'gdbm_compat'):
1026 gdbm_libs.append('gdbm_compat')
1027 if find_file("gdbm/ndbm.h", inc_dirs, []) is not None:
1028 exts.append( Extension(
1029 'dbm', ['dbmmodule.c'],
1030 define_macros=[('HAVE_GDBM_NDBM_H',None)],
1031 libraries = gdbm_libs ) )
1032 elif find_file("gdbm-ndbm.h", inc_dirs, []) is not None:
1033 exts.append( Extension(
1034 'dbm', ['dbmmodule.c'],
1035 define_macros=[('HAVE_GDBM_DASH_NDBM_H',None)],
1036 libraries = gdbm_libs ) )
1037 else:
1038 missing.append('dbm')
1039 elif db_incs is not None:
1040 exts.append( Extension('dbm', ['dbmmodule.c'],
1041 library_dirs=dblib_dir,
1042 runtime_library_dirs=dblib_dir,
1043 include_dirs=db_incs,
1044 define_macros=[('HAVE_BERKDB_H',None),
1045 ('DB_DBM_HSEARCH',None)],
1046 libraries=dblibs))
1047 else:
1048 missing.append('dbm')
1050 # Anthony Baxter's gdbm module. GNU dbm(3) will require -lgdbm:
1051 if (self.compiler.find_library_file(lib_dirs, 'gdbm')):
1052 exts.append( Extension('gdbm', ['gdbmmodule.c'],
1053 libraries = ['gdbm'] ) )
1054 else:
1055 missing.append('gdbm')
1057 # Unix-only modules
1058 if platform not in ['mac', 'win32']:
1059 # Steen Lumholt's termios module
1060 exts.append( Extension('termios', ['termios.c']) )
1061 # Jeremy Hylton's rlimit interface
1062 if platform not in ['atheos']:
1063 exts.append( Extension('resource', ['resource.c']) )
1064 else:
1065 missing.append('resource')
1067 # Sun yellow pages. Some systems have the functions in libc.
1068 if platform not in ['cygwin', 'atheos', 'qnx6']:
1069 if (self.compiler.find_library_file(lib_dirs, 'nsl')):
1070 libs = ['nsl']
1071 else:
1072 libs = []
1073 exts.append( Extension('nis', ['nismodule.c'],
1074 libraries = libs) )
1075 else:
1076 missing.append('nis')
1077 else:
1078 missing.extend(['nis', 'resource', 'termios'])
1080 # Curses support, requiring the System V version of curses, often
1081 # provided by the ncurses library.
1082 panel_library = 'panel'
1083 if (self.compiler.find_library_file(lib_dirs, 'ncursesw')):
1084 curses_libs = ['ncursesw']
1085 # Bug 1464056: If _curses.so links with ncursesw,
1086 # _curses_panel.so must link with panelw.
1087 panel_library = 'panelw'
1088 exts.append( Extension('_curses', ['_cursesmodule.c'],
1089 libraries = curses_libs) )
1090 elif (self.compiler.find_library_file(lib_dirs, 'ncurses')):
1091 curses_libs = ['ncurses']
1092 exts.append( Extension('_curses', ['_cursesmodule.c'],
1093 libraries = curses_libs) )
1094 elif (self.compiler.find_library_file(lib_dirs, 'curses')
1095 and platform != 'darwin'):
1096 # OSX has an old Berkeley curses, not good enough for
1097 # the _curses module.
1098 if (self.compiler.find_library_file(lib_dirs, 'terminfo')):
1099 curses_libs = ['curses', 'terminfo']
1100 elif (self.compiler.find_library_file(lib_dirs, 'termcap')):
1101 curses_libs = ['curses', 'termcap']
1102 else:
1103 curses_libs = ['curses']
1105 exts.append( Extension('_curses', ['_cursesmodule.c'],
1106 libraries = curses_libs) )
1107 else:
1108 missing.append('_curses')
1110 # If the curses module is enabled, check for the panel module
1111 if (module_enabled(exts, '_curses') and
1112 self.compiler.find_library_file(lib_dirs, panel_library)):
1113 exts.append( Extension('_curses_panel', ['_curses_panel.c'],
1114 libraries = [panel_library] + curses_libs) )
1115 else:
1116 missing.append('_curses_panel')
1118 # Andrew Kuchling's zlib module. Note that some versions of zlib
1119 # 1.1.3 have security problems. See CERT Advisory CA-2002-07:
1120 # http://www.cert.org/advisories/CA-2002-07.html
1122 # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
1123 # patch its zlib 1.1.3 package instead of upgrading to 1.1.4. For
1124 # now, we still accept 1.1.3, because we think it's difficult to
1125 # exploit this in Python, and we'd rather make it RedHat's problem
1126 # than our problem <wink>.
1128 # You can upgrade zlib to version 1.1.4 yourself by going to
1129 # http://www.gzip.org/zlib/
1130 zlib_inc = find_file('zlib.h', [], inc_dirs)
1131 have_zlib = False
1132 if zlib_inc is not None:
1133 zlib_h = zlib_inc[0] + '/zlib.h'
1134 version = '"0.0.0"'
1135 version_req = '"1.1.3"'
1136 fp = open(zlib_h)
1137 while 1:
1138 line = fp.readline()
1139 if not line:
1140 break
1141 if line.startswith('#define ZLIB_VERSION'):
1142 version = line.split()[2]
1143 break
1144 if version >= version_req:
1145 if (self.compiler.find_library_file(lib_dirs, 'z')):
1146 if sys.platform == "darwin":
1147 zlib_extra_link_args = ('-Wl,-search_paths_first',)
1148 else:
1149 zlib_extra_link_args = ()
1150 exts.append( Extension('zlib', ['zlibmodule.c'],
1151 libraries = ['z'],
1152 extra_link_args = zlib_extra_link_args))
1153 have_zlib = True
1154 else:
1155 missing.append('zlib')
1156 else:
1157 missing.append('zlib')
1158 else:
1159 missing.append('zlib')
1161 # Helper module for various ascii-encoders. Uses zlib for an optimized
1162 # crc32 if we have it. Otherwise binascii uses its own.
1163 if have_zlib:
1164 extra_compile_args = ['-DUSE_ZLIB_CRC32']
1165 libraries = ['z']
1166 extra_link_args = zlib_extra_link_args
1167 else:
1168 extra_compile_args = []
1169 libraries = []
1170 extra_link_args = []
1171 exts.append( Extension('binascii', ['binascii.c'],
1172 extra_compile_args = extra_compile_args,
1173 libraries = libraries,
1174 extra_link_args = extra_link_args) )
1176 # Gustavo Niemeyer's bz2 module.
1177 if (self.compiler.find_library_file(lib_dirs, 'bz2')):
1178 if sys.platform == "darwin":
1179 bz2_extra_link_args = ('-Wl,-search_paths_first',)
1180 else:
1181 bz2_extra_link_args = ()
1182 exts.append( Extension('bz2', ['bz2module.c'],
1183 libraries = ['bz2'],
1184 extra_link_args = bz2_extra_link_args) )
1185 else:
1186 missing.append('bz2')
1188 # Interface to the Expat XML parser
1190 # Expat was written by James Clark and is now maintained by a
1191 # group of developers on SourceForge; see www.libexpat.org for
1192 # more information. The pyexpat module was written by Paul
1193 # Prescod after a prototype by Jack Jansen. The Expat source
1194 # is included in Modules/expat/. Usage of a system
1195 # shared libexpat.so/expat.dll is not advised.
1197 # More information on Expat can be found at www.libexpat.org.
1199 expatinc = os.path.join(os.getcwd(), srcdir, 'Modules', 'expat')
1200 define_macros = [
1201 ('HAVE_EXPAT_CONFIG_H', '1'),
1204 exts.append(Extension('pyexpat',
1205 define_macros = define_macros,
1206 include_dirs = [expatinc],
1207 sources = ['pyexpat.c',
1208 'expat/xmlparse.c',
1209 'expat/xmlrole.c',
1210 'expat/xmltok.c',
1214 # Fredrik Lundh's cElementTree module. Note that this also
1215 # uses expat (via the CAPI hook in pyexpat).
1217 if os.path.isfile(os.path.join(srcdir, 'Modules', '_elementtree.c')):
1218 define_macros.append(('USE_PYEXPAT_CAPI', None))
1219 exts.append(Extension('_elementtree',
1220 define_macros = define_macros,
1221 include_dirs = [expatinc],
1222 sources = ['_elementtree.c'],
1224 else:
1225 missing.append('_elementtree')
1227 # Hye-Shik Chang's CJKCodecs modules.
1228 if have_unicode:
1229 exts.append(Extension('_multibytecodec',
1230 ['cjkcodecs/multibytecodec.c']))
1231 for loc in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1232 exts.append(Extension('_codecs_%s' % loc,
1233 ['cjkcodecs/_codecs_%s.c' % loc]))
1234 else:
1235 missing.append('_multibytecodec')
1236 for loc in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
1237 missing.append('_codecs_%s' % loc)
1239 # Dynamic loading module
1240 if sys.maxint == 0x7fffffff:
1241 # This requires sizeof(int) == sizeof(long) == sizeof(char*)
1242 dl_inc = find_file('dlfcn.h', [], inc_dirs)
1243 if (dl_inc is not None) and (platform not in ['atheos']):
1244 exts.append( Extension('dl', ['dlmodule.c']) )
1245 else:
1246 missing.append('dl')
1247 else:
1248 missing.append('dl')
1250 # Thomas Heller's _ctypes module
1251 self.detect_ctypes(inc_dirs, lib_dirs)
1253 # Richard Oudkerk's multiprocessing module
1254 if platform == 'win32': # Windows
1255 macros = dict()
1256 libraries = ['ws2_32']
1258 elif platform == 'darwin': # Mac OSX
1259 macros = dict(
1260 HAVE_SEM_OPEN=1,
1261 HAVE_SEM_TIMEDWAIT=0,
1262 HAVE_FD_TRANSFER=1,
1263 HAVE_BROKEN_SEM_GETVALUE=1
1265 libraries = []
1267 elif platform == 'cygwin': # Cygwin
1268 macros = dict(
1269 HAVE_SEM_OPEN=1,
1270 HAVE_SEM_TIMEDWAIT=1,
1271 HAVE_FD_TRANSFER=0,
1272 HAVE_BROKEN_SEM_UNLINK=1
1274 libraries = []
1276 elif platform in ('freebsd4', 'freebsd5', 'freebsd6', 'freebsd7', 'freebsd8'):
1277 # FreeBSD's P1003.1b semaphore support is very experimental
1278 # and has many known problems. (as of June 2008)
1279 macros = dict( # FreeBSD
1280 HAVE_SEM_OPEN=0,
1281 HAVE_SEM_TIMEDWAIT=0,
1282 HAVE_FD_TRANSFER=1,
1284 libraries = []
1286 elif platform.startswith('openbsd'):
1287 macros = dict( # OpenBSD
1288 HAVE_SEM_OPEN=0, # Not implemented
1289 HAVE_SEM_TIMEDWAIT=0,
1290 HAVE_FD_TRANSFER=1,
1292 libraries = []
1294 else: # Linux and other unices
1295 macros = dict(
1296 HAVE_SEM_OPEN=1,
1297 HAVE_SEM_TIMEDWAIT=1,
1298 HAVE_FD_TRANSFER=1
1300 libraries = ['rt']
1302 if platform == 'win32':
1303 multiprocessing_srcs = [ '_multiprocessing/multiprocessing.c',
1304 '_multiprocessing/semaphore.c',
1305 '_multiprocessing/pipe_connection.c',
1306 '_multiprocessing/socket_connection.c',
1307 '_multiprocessing/win32_functions.c'
1310 else:
1311 multiprocessing_srcs = [ '_multiprocessing/multiprocessing.c',
1312 '_multiprocessing/socket_connection.c'
1315 if macros.get('HAVE_SEM_OPEN', False):
1316 multiprocessing_srcs.append('_multiprocessing/semaphore.c')
1318 if sysconfig.get_config_var('WITH_THREAD'):
1319 exts.append ( Extension('_multiprocessing', multiprocessing_srcs,
1320 define_macros=macros.items(),
1321 include_dirs=["Modules/_multiprocessing"]))
1322 else:
1323 missing.append('_multiprocessing')
1325 # End multiprocessing
1328 # Platform-specific libraries
1329 if platform == 'linux2':
1330 # Linux-specific modules
1331 exts.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
1332 else:
1333 missing.append('linuxaudiodev')
1335 if platform in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
1336 'freebsd7', 'freebsd8'):
1337 exts.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
1338 else:
1339 missing.append('ossaudiodev')
1341 if platform == 'sunos5':
1342 # SunOS specific modules
1343 exts.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
1344 else:
1345 missing.append('sunaudiodev')
1347 if platform == 'darwin' and ("--disable-toolbox-glue" not in
1348 sysconfig.get_config_var("CONFIG_ARGS")):
1350 if os.uname()[2] > '8.':
1351 # We're on Mac OS X 10.4 or later, the compiler should
1352 # support '-Wno-deprecated-declarations'. This will
1353 # surpress deprecation warnings for the Carbon extensions,
1354 # these extensions wrap the Carbon APIs and even those
1355 # parts that are deprecated.
1356 carbon_extra_compile_args = ['-Wno-deprecated-declarations']
1357 else:
1358 carbon_extra_compile_args = []
1360 # Mac OS X specific modules.
1361 def macSrcExists(name1, name2=''):
1362 if not name1:
1363 return None
1364 names = (name1,)
1365 if name2:
1366 names = (name1, name2)
1367 path = os.path.join(srcdir, 'Mac', 'Modules', *names)
1368 return os.path.exists(path)
1370 def addMacExtension(name, kwds, extra_srcs=[]):
1371 dirname = ''
1372 if name[0] == '_':
1373 dirname = name[1:].lower()
1374 cname = name + '.c'
1375 cmodulename = name + 'module.c'
1376 # Check for NNN.c, NNNmodule.c, _nnn/NNN.c, _nnn/NNNmodule.c
1377 if macSrcExists(cname):
1378 srcs = [cname]
1379 elif macSrcExists(cmodulename):
1380 srcs = [cmodulename]
1381 elif macSrcExists(dirname, cname):
1382 # XXX(nnorwitz): If all the names ended with module, we
1383 # wouldn't need this condition. ibcarbon is the only one.
1384 srcs = [os.path.join(dirname, cname)]
1385 elif macSrcExists(dirname, cmodulename):
1386 srcs = [os.path.join(dirname, cmodulename)]
1387 else:
1388 raise RuntimeError("%s not found" % name)
1390 # Here's the whole point: add the extension with sources
1391 exts.append(Extension(name, srcs + extra_srcs, **kwds))
1393 # Core Foundation
1394 core_kwds = {'extra_compile_args': carbon_extra_compile_args,
1395 'extra_link_args': ['-framework', 'CoreFoundation'],
1397 addMacExtension('_CF', core_kwds, ['cf/pycfbridge.c'])
1398 addMacExtension('autoGIL', core_kwds)
1400 # Carbon
1401 carbon_kwds = {'extra_compile_args': carbon_extra_compile_args,
1402 'extra_link_args': ['-framework', 'Carbon'],
1404 CARBON_EXTS = ['ColorPicker', 'gestalt', 'MacOS', 'Nav',
1405 'OSATerminology', 'icglue',
1406 # All these are in subdirs
1407 '_AE', '_AH', '_App', '_CarbonEvt', '_Cm', '_Ctl',
1408 '_Dlg', '_Drag', '_Evt', '_File', '_Folder', '_Fm',
1409 '_Help', '_Icn', '_IBCarbon', '_List',
1410 '_Menu', '_Mlte', '_OSA', '_Res', '_Qd', '_Qdoffs',
1411 '_Scrap', '_Snd', '_TE',
1413 for name in CARBON_EXTS:
1414 addMacExtension(name, carbon_kwds)
1416 # Workaround for a bug in the version of gcc shipped with Xcode 3.
1417 # The _Win extension should build just like the other Carbon extensions, but
1418 # this actually results in a hard crash of the linker.
1420 if '-arch ppc64' in cflags and '-arch ppc' in cflags:
1421 win_kwds = {'extra_compile_args': carbon_extra_compile_args + ['-arch', 'i386', '-arch', 'ppc'],
1422 'extra_link_args': ['-framework', 'Carbon', '-arch', 'i386', '-arch', 'ppc'],
1424 addMacExtension('_Win', win_kwds)
1425 else:
1426 addMacExtension('_Win', carbon_kwds)
1429 # Application Services & QuickTime
1430 app_kwds = {'extra_compile_args': carbon_extra_compile_args,
1431 'extra_link_args': ['-framework','ApplicationServices'],
1433 addMacExtension('_Launch', app_kwds)
1434 addMacExtension('_CG', app_kwds)
1436 exts.append( Extension('_Qt', ['qt/_Qtmodule.c'],
1437 extra_compile_args=carbon_extra_compile_args,
1438 extra_link_args=['-framework', 'QuickTime',
1439 '-framework', 'Carbon']) )
1442 self.extensions.extend(exts)
1444 # Call the method for detecting whether _tkinter can be compiled
1445 self.detect_tkinter(inc_dirs, lib_dirs)
1447 if '_tkinter' not in [e.name for e in self.extensions]:
1448 missing.append('_tkinter')
1450 return missing
1452 def detect_tkinter_darwin(self, inc_dirs, lib_dirs):
1453 # The _tkinter module, using frameworks. Since frameworks are quite
1454 # different the UNIX search logic is not sharable.
1455 from os.path import join, exists
1456 framework_dirs = [
1457 '/System/Library/Frameworks/',
1458 '/Library/Frameworks',
1459 join(os.getenv('HOME'), '/Library/Frameworks')
1462 # Find the directory that contains the Tcl.framework and Tk.framework
1463 # bundles.
1464 # XXX distutils should support -F!
1465 for F in framework_dirs:
1466 # both Tcl.framework and Tk.framework should be present
1467 for fw in 'Tcl', 'Tk':
1468 if not exists(join(F, fw + '.framework')):
1469 break
1470 else:
1471 # ok, F is now directory with both frameworks. Continure
1472 # building
1473 break
1474 else:
1475 # Tk and Tcl frameworks not found. Normal "unix" tkinter search
1476 # will now resume.
1477 return 0
1479 # For 8.4a2, we must add -I options that point inside the Tcl and Tk
1480 # frameworks. In later release we should hopefully be able to pass
1481 # the -F option to gcc, which specifies a framework lookup path.
1483 include_dirs = [
1484 join(F, fw + '.framework', H)
1485 for fw in 'Tcl', 'Tk'
1486 for H in 'Headers', 'Versions/Current/PrivateHeaders'
1489 # For 8.4a2, the X11 headers are not included. Rather than include a
1490 # complicated search, this is a hard-coded path. It could bail out
1491 # if X11 libs are not found...
1492 include_dirs.append('/usr/X11R6/include')
1493 frameworks = ['-framework', 'Tcl', '-framework', 'Tk']
1495 # All existing framework builds of Tcl/Tk don't support 64-bit
1496 # architectures.
1497 cflags = sysconfig.get_config_vars('CFLAGS')[0]
1498 archs = re.findall('-arch\s+(\w+)', cflags)
1499 if 'x86_64' in archs or 'ppc64' in archs:
1500 try:
1501 archs.remove('x86_64')
1502 except ValueError:
1503 pass
1504 try:
1505 archs.remove('ppc64')
1506 except ValueError:
1507 pass
1509 for a in archs:
1510 frameworks.append('-arch')
1511 frameworks.append(a)
1513 ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1514 define_macros=[('WITH_APPINIT', 1)],
1515 include_dirs = include_dirs,
1516 libraries = [],
1517 extra_compile_args = frameworks[2:],
1518 extra_link_args = frameworks,
1520 self.extensions.append(ext)
1521 return 1
1524 def detect_tkinter(self, inc_dirs, lib_dirs):
1525 # The _tkinter module.
1527 # Rather than complicate the code below, detecting and building
1528 # AquaTk is a separate method. Only one Tkinter will be built on
1529 # Darwin - either AquaTk, if it is found, or X11 based Tk.
1530 platform = self.get_platform()
1531 if (platform == 'darwin' and
1532 self.detect_tkinter_darwin(inc_dirs, lib_dirs)):
1533 return
1535 # Assume we haven't found any of the libraries or include files
1536 # The versions with dots are used on Unix, and the versions without
1537 # dots on Windows, for detection by cygwin.
1538 tcllib = tklib = tcl_includes = tk_includes = None
1539 for version in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
1540 '82', '8.1', '81', '8.0', '80']:
1541 tklib = self.compiler.find_library_file(lib_dirs, 'tk' + version)
1542 tcllib = self.compiler.find_library_file(lib_dirs, 'tcl' + version)
1543 if tklib and tcllib:
1544 # Exit the loop when we've found the Tcl/Tk libraries
1545 break
1547 # Now check for the header files
1548 if tklib and tcllib:
1549 # Check for the include files on Debian and {Free,Open}BSD, where
1550 # they're put in /usr/include/{tcl,tk}X.Y
1551 dotversion = version
1552 if '.' not in dotversion and "bsd" in sys.platform.lower():
1553 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
1554 # but the include subdirs are named like .../include/tcl8.3.
1555 dotversion = dotversion[:-1] + '.' + dotversion[-1]
1556 tcl_include_sub = []
1557 tk_include_sub = []
1558 for dir in inc_dirs:
1559 tcl_include_sub += [dir + os.sep + "tcl" + dotversion]
1560 tk_include_sub += [dir + os.sep + "tk" + dotversion]
1561 tk_include_sub += tcl_include_sub
1562 tcl_includes = find_file('tcl.h', inc_dirs, tcl_include_sub)
1563 tk_includes = find_file('tk.h', inc_dirs, tk_include_sub)
1565 if (tcllib is None or tklib is None or
1566 tcl_includes is None or tk_includes is None):
1567 self.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
1568 return
1570 # OK... everything seems to be present for Tcl/Tk.
1572 include_dirs = [] ; libs = [] ; defs = [] ; added_lib_dirs = []
1573 for dir in tcl_includes + tk_includes:
1574 if dir not in include_dirs:
1575 include_dirs.append(dir)
1577 # Check for various platform-specific directories
1578 if platform == 'sunos5':
1579 include_dirs.append('/usr/openwin/include')
1580 added_lib_dirs.append('/usr/openwin/lib')
1581 elif os.path.exists('/usr/X11R6/include'):
1582 include_dirs.append('/usr/X11R6/include')
1583 added_lib_dirs.append('/usr/X11R6/lib64')
1584 added_lib_dirs.append('/usr/X11R6/lib')
1585 elif os.path.exists('/usr/X11R5/include'):
1586 include_dirs.append('/usr/X11R5/include')
1587 added_lib_dirs.append('/usr/X11R5/lib')
1588 else:
1589 # Assume default location for X11
1590 include_dirs.append('/usr/X11/include')
1591 added_lib_dirs.append('/usr/X11/lib')
1593 # If Cygwin, then verify that X is installed before proceeding
1594 if platform == 'cygwin':
1595 x11_inc = find_file('X11/Xlib.h', [], include_dirs)
1596 if x11_inc is None:
1597 return
1599 # Check for BLT extension
1600 if self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1601 'BLT8.0'):
1602 defs.append( ('WITH_BLT', 1) )
1603 libs.append('BLT8.0')
1604 elif self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1605 'BLT'):
1606 defs.append( ('WITH_BLT', 1) )
1607 libs.append('BLT')
1609 # Add the Tcl/Tk libraries
1610 libs.append('tk'+ version)
1611 libs.append('tcl'+ version)
1613 if platform in ['aix3', 'aix4']:
1614 libs.append('ld')
1616 # Finally, link with the X11 libraries (not appropriate on cygwin)
1617 if platform != "cygwin":
1618 libs.append('X11')
1620 ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1621 define_macros=[('WITH_APPINIT', 1)] + defs,
1622 include_dirs = include_dirs,
1623 libraries = libs,
1624 library_dirs = added_lib_dirs,
1626 self.extensions.append(ext)
1628 ## # Uncomment these lines if you want to play with xxmodule.c
1629 ## ext = Extension('xx', ['xxmodule.c'])
1630 ## self.extensions.append(ext)
1632 # XXX handle these, but how to detect?
1633 # *** Uncomment and edit for PIL (TkImaging) extension only:
1634 # -DWITH_PIL -I../Extensions/Imaging/libImaging tkImaging.c \
1635 # *** Uncomment and edit for TOGL extension only:
1636 # -DWITH_TOGL togl.c \
1637 # *** Uncomment these for TOGL extension only:
1638 # -lGL -lGLU -lXext -lXmu \
1640 def configure_ctypes_darwin(self, ext):
1641 # Darwin (OS X) uses preconfigured files, in
1642 # the Modules/_ctypes/libffi_osx directory.
1643 (srcdir,) = sysconfig.get_config_vars('srcdir')
1644 ffi_srcdir = os.path.abspath(os.path.join(srcdir, 'Modules',
1645 '_ctypes', 'libffi_osx'))
1646 sources = [os.path.join(ffi_srcdir, p)
1647 for p in ['ffi.c',
1648 'x86/darwin64.S',
1649 'x86/x86-darwin.S',
1650 'x86/x86-ffi_darwin.c',
1651 'x86/x86-ffi64.c',
1652 'powerpc/ppc-darwin.S',
1653 'powerpc/ppc-darwin_closure.S',
1654 'powerpc/ppc-ffi_darwin.c',
1655 'powerpc/ppc64-darwin_closure.S',
1658 # Add .S (preprocessed assembly) to C compiler source extensions.
1659 self.compiler.src_extensions.append('.S')
1661 include_dirs = [os.path.join(ffi_srcdir, 'include'),
1662 os.path.join(ffi_srcdir, 'powerpc')]
1663 ext.include_dirs.extend(include_dirs)
1664 ext.sources.extend(sources)
1665 return True
1667 def configure_ctypes(self, ext):
1668 if not self.use_system_libffi:
1669 if sys.platform == 'darwin':
1670 return self.configure_ctypes_darwin(ext)
1672 (srcdir,) = sysconfig.get_config_vars('srcdir')
1673 ffi_builddir = os.path.join(self.build_temp, 'libffi')
1674 ffi_srcdir = os.path.abspath(os.path.join(srcdir, 'Modules',
1675 '_ctypes', 'libffi'))
1676 ffi_configfile = os.path.join(ffi_builddir, 'fficonfig.py')
1678 from distutils.dep_util import newer_group
1680 config_sources = [os.path.join(ffi_srcdir, fname)
1681 for fname in os.listdir(ffi_srcdir)
1682 if os.path.isfile(os.path.join(ffi_srcdir, fname))]
1683 if self.force or newer_group(config_sources,
1684 ffi_configfile):
1685 from distutils.dir_util import mkpath
1686 mkpath(ffi_builddir)
1687 config_args = []
1689 # Pass empty CFLAGS because we'll just append the resulting
1690 # CFLAGS to Python's; -g or -O2 is to be avoided.
1691 cmd = "cd %s && env CFLAGS='' '%s/configure' %s" \
1692 % (ffi_builddir, ffi_srcdir, " ".join(config_args))
1694 res = os.system(cmd)
1695 if res or not os.path.exists(ffi_configfile):
1696 print "Failed to configure _ctypes module"
1697 return False
1699 fficonfig = {}
1700 execfile(ffi_configfile, globals(), fficonfig)
1701 ffi_srcdir = os.path.join(fficonfig['ffi_srcdir'], 'src')
1703 # Add .S (preprocessed assembly) to C compiler source extensions.
1704 self.compiler.src_extensions.append('.S')
1706 include_dirs = [os.path.join(ffi_builddir, 'include'),
1707 ffi_builddir, ffi_srcdir]
1708 extra_compile_args = fficonfig['ffi_cflags'].split()
1710 ext.sources.extend(fficonfig['ffi_sources'])
1711 ext.include_dirs.extend(include_dirs)
1712 ext.extra_compile_args.extend(extra_compile_args)
1713 return True
1715 def detect_ctypes(self, inc_dirs, lib_dirs):
1716 self.use_system_libffi = False
1717 include_dirs = []
1718 extra_compile_args = []
1719 extra_link_args = []
1720 sources = ['_ctypes/_ctypes.c',
1721 '_ctypes/callbacks.c',
1722 '_ctypes/callproc.c',
1723 '_ctypes/stgdict.c',
1724 '_ctypes/cfield.c',
1725 '_ctypes/malloc_closure.c']
1726 depends = ['_ctypes/ctypes.h']
1728 if sys.platform == 'darwin':
1729 sources.append('_ctypes/darwin/dlfcn_simple.c')
1730 extra_compile_args.append('-DMACOSX')
1731 include_dirs.append('_ctypes/darwin')
1732 # XXX Is this still needed?
1733 ## extra_link_args.extend(['-read_only_relocs', 'warning'])
1735 elif sys.platform == 'sunos5':
1736 # XXX This shouldn't be necessary; it appears that some
1737 # of the assembler code is non-PIC (i.e. it has relocations
1738 # when it shouldn't. The proper fix would be to rewrite
1739 # the assembler code to be PIC.
1740 # This only works with GCC; the Sun compiler likely refuses
1741 # this option. If you want to compile ctypes with the Sun
1742 # compiler, please research a proper solution, instead of
1743 # finding some -z option for the Sun compiler.
1744 extra_link_args.append('-mimpure-text')
1746 elif sys.platform.startswith('hp-ux'):
1747 extra_link_args.append('-fPIC')
1749 ext = Extension('_ctypes',
1750 include_dirs=include_dirs,
1751 extra_compile_args=extra_compile_args,
1752 extra_link_args=extra_link_args,
1753 libraries=[],
1754 sources=sources,
1755 depends=depends)
1756 ext_test = Extension('_ctypes_test',
1757 sources=['_ctypes/_ctypes_test.c'])
1758 self.extensions.extend([ext, ext_test])
1760 if not '--with-system-ffi' in sysconfig.get_config_var("CONFIG_ARGS"):
1761 return
1763 if sys.platform == 'darwin':
1764 # OS X 10.5 comes with libffi.dylib; the include files are
1765 # in /usr/include/ffi
1766 inc_dirs.append('/usr/include/ffi')
1768 ffi_inc = find_file('ffi.h', [], inc_dirs)
1769 if ffi_inc is not None:
1770 ffi_h = ffi_inc[0] + '/ffi.h'
1771 fp = open(ffi_h)
1772 while 1:
1773 line = fp.readline()
1774 if not line:
1775 ffi_inc = None
1776 break
1777 if line.startswith('#define LIBFFI_H'):
1778 break
1779 ffi_lib = None
1780 if ffi_inc is not None:
1781 for lib_name in ('ffi_convenience', 'ffi_pic', 'ffi'):
1782 if (self.compiler.find_library_file(lib_dirs, lib_name)):
1783 ffi_lib = lib_name
1784 break
1786 if ffi_inc and ffi_lib:
1787 ext.include_dirs.extend(ffi_inc)
1788 ext.libraries.append(ffi_lib)
1789 self.use_system_libffi = True
1792 class PyBuildInstall(install):
1793 # Suppress the warning about installation into the lib_dynload
1794 # directory, which is not in sys.path when running Python during
1795 # installation:
1796 def initialize_options (self):
1797 install.initialize_options(self)
1798 self.warn_dir=0
1800 class PyBuildInstallLib(install_lib):
1801 # Do exactly what install_lib does but make sure correct access modes get
1802 # set on installed directories and files. All installed files with get
1803 # mode 644 unless they are a shared library in which case they will get
1804 # mode 755. All installed directories will get mode 755.
1806 so_ext = sysconfig.get_config_var("SO")
1808 def install(self):
1809 outfiles = install_lib.install(self)
1810 self.set_file_modes(outfiles, 0644, 0755)
1811 self.set_dir_modes(self.install_dir, 0755)
1812 return outfiles
1814 def set_file_modes(self, files, defaultMode, sharedLibMode):
1815 if not self.is_chmod_supported(): return
1816 if not files: return
1818 for filename in files:
1819 if os.path.islink(filename): continue
1820 mode = defaultMode
1821 if filename.endswith(self.so_ext): mode = sharedLibMode
1822 log.info("changing mode of %s to %o", filename, mode)
1823 if not self.dry_run: os.chmod(filename, mode)
1825 def set_dir_modes(self, dirname, mode):
1826 if not self.is_chmod_supported(): return
1827 os.path.walk(dirname, self.set_dir_modes_visitor, mode)
1829 def set_dir_modes_visitor(self, mode, dirname, names):
1830 if os.path.islink(dirname): return
1831 log.info("changing mode of %s to %o", dirname, mode)
1832 if not self.dry_run: os.chmod(dirname, mode)
1834 def is_chmod_supported(self):
1835 return hasattr(os, 'chmod')
1837 SUMMARY = """
1838 Python is an interpreted, interactive, object-oriented programming
1839 language. It is often compared to Tcl, Perl, Scheme or Java.
1841 Python combines remarkable power with very clear syntax. It has
1842 modules, classes, exceptions, very high level dynamic data types, and
1843 dynamic typing. There are interfaces to many system calls and
1844 libraries, as well as to various windowing systems (X11, Motif, Tk,
1845 Mac, MFC). New built-in modules are easily written in C or C++. Python
1846 is also usable as an extension language for applications that need a
1847 programmable interface.
1849 The Python implementation is portable: it runs on many brands of UNIX,
1850 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1851 listed here, it may still be supported, if there's a C compiler for
1852 it. Ask around on comp.lang.python -- or just try compiling Python
1853 yourself.
1856 CLASSIFIERS = """
1857 Development Status :: 6 - Mature
1858 License :: OSI Approved :: Python Software Foundation License
1859 Natural Language :: English
1860 Programming Language :: C
1861 Programming Language :: Python
1862 Topic :: Software Development
1865 def main():
1866 # turn off warnings when deprecated modules are imported
1867 import warnings
1868 warnings.filterwarnings("ignore",category=DeprecationWarning)
1869 setup(# PyPI Metadata (PEP 301)
1870 name = "Python",
1871 version = sys.version.split()[0],
1872 url = "http://www.python.org/%s" % sys.version[:3],
1873 maintainer = "Guido van Rossum and the Python community",
1874 maintainer_email = "python-dev@python.org",
1875 description = "A high-level object-oriented programming language",
1876 long_description = SUMMARY.strip(),
1877 license = "PSF license",
1878 classifiers = filter(None, CLASSIFIERS.split("\n")),
1879 platforms = ["Many"],
1881 # Build info
1882 cmdclass = {'build_ext':PyBuildExt, 'install':PyBuildInstall,
1883 'install_lib':PyBuildInstallLib},
1884 # The struct module is defined here, because build_ext won't be
1885 # called unless there's at least one extension module defined.
1886 ext_modules=[Extension('_struct', ['_struct.c'])],
1888 # Scripts to install
1889 scripts = ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1890 'Tools/scripts/2to3',
1891 'Lib/smtpd.py']
1894 # --install-platlib
1895 if __name__ == '__main__':
1896 main()