setup.py

   1 # Autodetecting setup.py script for building the Python extensions
   2 #
   3
   4 __version__ = "$Revision$"
   5
   6 import sys, os, getopt, imp, re
   7
   8 from distutils import log
   9 from distutils import sysconfig
  10 from distutils import text_file
  11 from distutils.errors import *
  12 from distutils.core import Extension, setup
  13 from distutils.command.build_ext import build_ext
  14 from distutils.command.install import install
  15 from distutils.command.install_lib import install_lib
  16
  17 # This global variable is used to hold the list of modules to be disabled.
  18 disabled_module_list = []
  19
  20 def add_dir_to_list(dirlist, dir):
  21     """Add the directory 'dir' to the list 'dirlist' (at the front) if
  22     1) 'dir' is not already in 'dirlist'
  23     2) 'dir' actually exists, and is a directory."""
  24     if dir is not None and os.path.isdir(dir) and dir not in dirlist:
  25         dirlist.insert(0, dir)
  26
  27 def find_file(filename, std_dirs, paths):
  28     """Searches for the directory where a given file is located,
  29     and returns a possibly-empty list of additional directories, or None
  30     if the file couldn't be found at all.
  31
  32     'filename' is the name of a file, such as readline.h or libcrypto.a.
  33     'std_dirs' is the list of standard system directories; if the
  34         file is found in one of them, no additional directives are needed.
  35     'paths' is a list of additional locations to check; if the file is
  36         found in one of them, the resulting list will contain the directory.
  37     """
  38
  39     # Check the standard locations
  40     for dir in std_dirs:
  41         f = os.path.join(dir, filename)
  42         if os.path.exists(f): return []
  43
  44     # Check the additional directories
  45     for dir in paths:
  46         f = os.path.join(dir, filename)
  47         if os.path.exists(f):
  48             return [dir]
  49
  50     # Not found anywhere
  51     return None
  52
  53 def find_library_file(compiler, libname, std_dirs, paths):
  54     result = compiler.find_library_file(std_dirs + paths, libname)
  55     if result is None:
  56         return None
  57
  58     # Check whether the found file is in one of the standard directories
  59     dirname = os.path.dirname(result)
  60     for p in std_dirs:
  61         # Ensure path doesn't end with path separator
  62         p = p.rstrip(os.sep)
  63         if p == dirname:
  64             return [ ]
  65
  66     # Otherwise, it must have been in one of the additional directories,
  67     # so we have to figure out which one.
  68     for p in paths:
  69         # Ensure path doesn't end with path separator
  70         p = p.rstrip(os.sep)
  71         if p == dirname:
  72             return [p]
  73     else:
  74         assert False, "Internal error: Path not found in std_dirs or paths"
  75
  76 def module_enabled(extlist, modname):
  77     """Returns whether the module 'modname' is present in the list
  78     of extensions 'extlist'."""
  79     extlist = [ext for ext in extlist if ext.name == modname]
  80     return len(extlist)
  81
  82 def find_module_file(module, dirlist):
  83     """Find a module in a set of possible folders. If it is not found
  84     return the unadorned filename"""
  85     list = find_file(module, [], dirlist)
  86     if not list:
  87         return module
  88     if len(list) > 1:
  89         log.info("WARNING: multiple copies of %s found"%module)
  90     return os.path.join(list[0], module)
  91
  92 class PyBuildExt(build_ext):
  93
  94     def build_extensions(self):
  95
  96         # Detect which modules should be compiled
  97         self.detect_modules()
  98
  99         # Remove modules that are present on the disabled list
 100         self.extensions = [ext for ext in self.extensions
 101                            if ext.name not in disabled_module_list]
 102
 103         # Fix up the autodetected modules, prefixing all the source files
 104         # with Modules/ and adding Python's include directory to the path.
 105         (srcdir,) = sysconfig.get_config_vars('srcdir')
 106         if not srcdir:
 107             # Maybe running on Windows but not using CYGWIN?
 108             raise ValueError("No source directory; cannot proceed.")
 109
 110         # Figure out the location of the source code for extension modules
 111         moddir = os.path.join(os.getcwd(), srcdir, 'Modules')
 112         moddir = os.path.normpath(moddir)
 113         srcdir, tail = os.path.split(moddir)
 114         srcdir = os.path.normpath(srcdir)
 115         moddir = os.path.normpath(moddir)
 116
 117         moddirlist = [moddir]
 118         incdirlist = ['./Include']
 119
 120         # Platform-dependent module source and include directories
 121         platform = self.get_platform()
 122         if platform in ('darwin', 'mac') and ("--disable-toolbox-glue" not in
 123             sysconfig.get_config_var("CONFIG_ARGS")):
 124             # Mac OS X also includes some mac-specific modules
 125             macmoddir = os.path.join(os.getcwd(), srcdir, 'Mac/Modules')
 126             moddirlist.append(macmoddir)
 127             incdirlist.append('./Mac/Include')
 128
 129         alldirlist = moddirlist + incdirlist
 130
 131         # Fix up the paths for scripts, too
 132         self.distribution.scripts = [os.path.join(srcdir, filename)
 133                                      for filename in self.distribution.scripts]
 134
 135         for ext in self.extensions[:]:
 136             ext.sources = [ find_module_file(filename, moddirlist)
 137                             for filename in ext.sources ]
 138             if ext.depends is not None:
 139                 ext.depends = [find_module_file(filename, alldirlist)
 140                                for filename in ext.depends]
 141             ext.include_dirs.append( '.' ) # to get config.h
 142             for incdir in incdirlist:
 143                 ext.include_dirs.append( os.path.join(srcdir, incdir) )
 144
 145             # If a module has already been built statically,
 146             # don't build it here
 147             if ext.name in sys.builtin_module_names:
 148                 self.extensions.remove(ext)
 149
 150         if platform != 'mac':
 151             # Parse Modules/Setup to figure out which modules are turned
 152             # on in the file.
 153             input = text_file.TextFile('Modules/Setup', join_lines=1)
 154             remove_modules = []
 155             while 1:
 156                 line = input.readline()
 157                 if not line: break
 158                 line = line.split()
 159                 remove_modules.append( line[0] )
 160             input.close()
 161
 162             for ext in self.extensions[:]:
 163                 if ext.name in remove_modules:
 164                     self.extensions.remove(ext)
 165
 166         # When you run "make CC=altcc" or something similar, you really want
 167         # those environment variables passed into the setup.py phase.  Here's
 168         # a small set of useful ones.
 169         compiler = os.environ.get('CC')
 170         args = {}
 171         # unfortunately, distutils doesn't let us provide separate C and C++
 172         # compilers
 173         if compiler is not None:
 174             (ccshared,opt,base) = sysconfig.get_config_vars('CCSHARED','OPT','BASECFLAGS')
 175             args['compiler_so'] = compiler + ' ' + opt + ' ' + ccshared + ' ' + base
 176         self.compiler.set_executables(**args)
 177
 178         build_ext.build_extensions(self)
 179
 180     def build_extension(self, ext):
 181
 182         try:
 183             build_ext.build_extension(self, ext)
 184         except (CCompilerError, DistutilsError), why:
 185             self.announce('WARNING: building of extension "%s" failed: %s' %
 186                           (ext.name, sys.exc_info()[1]))
 187             return
 188         # Workaround for Mac OS X: The Carbon-based modules cannot be
 189         # reliably imported into a command-line Python
 190         if 'Carbon' in ext.extra_link_args:
 191             self.announce(
 192                 'WARNING: skipping import check for Carbon-based "%s"' %
 193                 ext.name)
 194             return
 195         # Workaround for Cygwin: Cygwin currently has fork issues when many
 196         # modules have been imported
 197         if self.get_platform() == 'cygwin':
 198             self.announce('WARNING: skipping import check for Cygwin-based "%s"'
 199                 % ext.name)
 200             return
 201         ext_filename = os.path.join(
 202             self.build_lib,
 203             self.get_ext_filename(self.get_ext_fullname(ext.name)))
 204         try:
 205             imp.load_dynamic(ext.name, ext_filename)
 206         except ImportError, why:
 207             self.announce('*** WARNING: renaming "%s" since importing it'
 208                           ' failed: %s' % (ext.name, why), level=3)
 209             assert not self.inplace
 210             basename, tail = os.path.splitext(ext_filename)
 211             newname = basename + "_failed" + tail
 212             if os.path.exists(newname):
 213                 os.remove(newname)
 214             os.rename(ext_filename, newname)
 215
 216             # XXX -- This relies on a Vile HACK in
 217             # distutils.command.build_ext.build_extension().  The
 218             # _built_objects attribute is stored there strictly for
 219             # use here.
 220             # If there is a failure, _built_objects may not be there,
 221             # so catch the AttributeError and move on.
 222             try:
 223                 for filename in self._built_objects:
 224                     os.remove(filename)
 225             except AttributeError:
 226                 self.announce('unable to remove files (ignored)')
 227         except:
 228             exc_type, why, tb = sys.exc_info()
 229             self.announce('*** WARNING: importing extension "%s" '
 230                           'failed with %s: %s' % (ext.name, exc_type, why),
 231                           level=3)
 232
 233     def get_platform(self):
 234         # Get value of sys.platform
 235         for platform in ['cygwin', 'beos', 'darwin', 'atheos', 'osf1']:
 236             if sys.platform.startswith(platform):
 237                 return platform
 238         return sys.platform
 239
 240     def detect_modules(self):
 241         # Ensure that /usr/local is always used
 242         add_dir_to_list(self.compiler.library_dirs, '/usr/local/lib')
 243         add_dir_to_list(self.compiler.include_dirs, '/usr/local/include')
 244
 245         # Add paths to popular package managers on OS X/darwin
 246         if sys.platform == "darwin":
 247             # Fink installs into /sw by default
 248             add_dir_to_list(self.compiler.library_dirs, '/sw/lib')
 249             add_dir_to_list(self.compiler.include_dirs, '/sw/include')
 250             # DarwinPorts installs into /opt/local by default
 251             add_dir_to_list(self.compiler.library_dirs, '/opt/local/lib')
 252             add_dir_to_list(self.compiler.include_dirs, '/opt/local/include')
 253
 254         if os.path.normpath(sys.prefix) != '/usr':
 255             add_dir_to_list(self.compiler.library_dirs,
 256                             sysconfig.get_config_var("LIBDIR"))
 257             add_dir_to_list(self.compiler.include_dirs,
 258                             sysconfig.get_config_var("INCLUDEDIR"))
 259
 260         try:
 261             have_unicode = unicode
 262         except NameError:
 263             have_unicode = 0
 264
 265         # lib_dirs and inc_dirs are used to search for files;
 266         # if a file is found in one of those directories, it can
 267         # be assumed that no additional -I,-L directives are needed.
 268         lib_dirs = self.compiler.library_dirs + [
 269             '/lib64', '/usr/lib64',
 270             '/lib', '/usr/lib',
 271             ]
 272         inc_dirs = self.compiler.include_dirs + ['/usr/include']
 273         exts = []
 274
 275         platform = self.get_platform()
 276         (srcdir,) = sysconfig.get_config_vars('srcdir')
 277
 278         # Check for AtheOS which has libraries in non-standard locations
 279         if platform == 'atheos':
 280             lib_dirs += ['/system/libs', '/atheos/autolnk/lib']
 281             lib_dirs += os.getenv('LIBRARY_PATH', '').split(os.pathsep)
 282             inc_dirs += ['/system/include', '/atheos/autolnk/include']
 283             inc_dirs += os.getenv('C_INCLUDE_PATH', '').split(os.pathsep)
 284
 285         # OSF/1 and Unixware have some stuff in /usr/ccs/lib (like -ldb)
 286         if platform in ['osf1', 'unixware7', 'openunix8']:
 287             lib_dirs += ['/usr/ccs/lib']
 288
 289         # Check for MacOS X, which doesn't need libm.a at all
 290         math_libs = ['m']
 291         if platform in ['darwin', 'beos', 'mac']:
 292             math_libs = []
 293
 294         # XXX Omitted modules: gl, pure, dl, SGI-specific modules
 295
 296         #
 297         # The following modules are all pretty straightforward, and compile
 298         # on pretty much any POSIXish platform.
 299         #
 300
 301         # Some modules that are normally always on:
 302         exts.append( Extension('regex', ['regexmodule.c', 'regexpr.c']) )
 303
 304         exts.append( Extension('_hotshot', ['_hotshot.c']) )
 305         exts.append( Extension('_weakref', ['_weakref.c']) )
 306
 307         # array objects
 308         exts.append( Extension('array', ['arraymodule.c']) )
 309         # complex math library functions
 310         exts.append( Extension('cmath', ['cmathmodule.c'],
 311                                libraries=math_libs) )
 312
 313         # math library functions, e.g. sin()
 314         exts.append( Extension('math',  ['mathmodule.c'],
 315                                libraries=math_libs) )
 316         # fast string operations implemented in C
 317         exts.append( Extension('strop', ['stropmodule.c']) )
 318         # time operations and variables
 319         exts.append( Extension('time', ['timemodule.c'],
 320                                libraries=math_libs) )
 321         exts.append( Extension('datetime', ['datetimemodule.c', 'timemodule.c'],
 322                                libraries=math_libs) )
 323         # random number generator implemented in C
 324         exts.append( Extension("_random", ["_randommodule.c"]) )
 325         # fast iterator tools implemented in C
 326         exts.append( Extension("itertools", ["itertoolsmodule.c"]) )
 327         # high-performance collections
 328         exts.append( Extension("collections", ["collectionsmodule.c"]) )
 329         # bisect
 330         exts.append( Extension("_bisect", ["_bisectmodule.c"]) )
 331         # heapq
 332         exts.append( Extension("_heapq", ["_heapqmodule.c"]) )
 333         # operator.add() and similar goodies
 334         exts.append( Extension('operator', ['operator.c']) )
 335         # Python C API test module
 336         exts.append( Extension('_testcapi', ['_testcapimodule.c']) )
 337         # static Unicode character database
 338         if have_unicode:
 339             exts.append( Extension('unicodedata', ['unicodedata.c']) )
 340         # access to ISO C locale support
 341         data = open('pyconfig.h').read()
 342         m = re.search(r"#s*define\s+WITH_LIBINTL\s+1\s*", data)
 343         if m is not None:
 344             locale_libs = ['intl']
 345         else:
 346             locale_libs = []
 347         if platform == 'darwin':
 348             locale_extra_link_args = ['-framework', 'CoreFoundation']
 349         else:
 350             locale_extra_link_args = []
 351
 352
 353         exts.append( Extension('_locale', ['_localemodule.c'],
 354                                libraries=locale_libs,
 355                                extra_link_args=locale_extra_link_args) )
 356
 357         # Modules with some UNIX dependencies -- on by default:
 358         # (If you have a really backward UNIX, select and socket may not be
 359         # supported...)
 360
 361         # fcntl(2) and ioctl(2)
 362         exts.append( Extension('fcntl', ['fcntlmodule.c']) )
 363         if platform not in ['mac']:
 364                 # pwd(3)
 365             exts.append( Extension('pwd', ['pwdmodule.c']) )
 366             # grp(3)
 367             exts.append( Extension('grp', ['grpmodule.c']) )
 368         # select(2); not on ancient System V
 369         exts.append( Extension('select', ['selectmodule.c']) )
 370
 371         # The md5 module implements the RSA Data Security, Inc. MD5
 372         # Message-Digest Algorithm, described in RFC 1321.  The
 373         # necessary files md5c.c and md5.h are included here.
 374         exts.append( Extension('md5', ['md5module.c', 'md5c.c']) )
 375
 376         # The sha module implements the SHA checksum algorithm.
 377         # (NIST's Secure Hash Algorithm.)
 378         exts.append( Extension('sha', ['shamodule.c']) )
 379
 380         # Helper module for various ascii-encoders
 381         exts.append( Extension('binascii', ['binascii.c']) )
 382
 383         # Fred Drake's interface to the Python parser
 384         exts.append( Extension('parser', ['parsermodule.c']) )
 385
 386         # cStringIO and cPickle
 387         exts.append( Extension('cStringIO', ['cStringIO.c']) )
 388         exts.append( Extension('cPickle', ['cPickle.c']) )
 389
 390         # Memory-mapped files (also works on Win32).
 391         if platform not in ['atheos', 'mac']:
 392             exts.append( Extension('mmap', ['mmapmodule.c']) )
 393
 394         # Lance Ellinghaus's syslog module
 395         if platform not in ['mac']:
 396             # syslog daemon interface
 397             exts.append( Extension('syslog', ['syslogmodule.c']) )
 398
 399         # George Neville-Neil's timing module:
 400         exts.append( Extension('timing', ['timingmodule.c']) )
 401
 402         #
 403         # Here ends the simple stuff.  From here on, modules need certain
 404         # libraries, are platform-specific, or present other surprises.
 405         #
 406
 407         # Multimedia modules
 408         # These don't work for 64-bit platforms!!!
 409         # These represent audio samples or images as strings:
 410
 411         # Operations on audio samples
 412         # According to #993173, this one should actually work fine on
 413         # 64-bit platforms.
 414         exts.append( Extension('audioop', ['audioop.c']) )
 415
 416         # Disabled on 64-bit platforms
 417         if sys.maxint != 9223372036854775807L:
 418             # Operations on images
 419             exts.append( Extension('imageop', ['imageop.c']) )
 420             # Read SGI RGB image files (but coded portably)
 421             exts.append( Extension('rgbimg', ['rgbimgmodule.c']) )
 422
 423         # readline
 424         if self.compiler.find_library_file(lib_dirs, 'readline'):
 425             readline_libs = ['readline']
 426             if self.compiler.find_library_file(lib_dirs,
 427                                                  'ncurses'):
 428                 readline_libs.append('ncurses')
 429             elif self.compiler.find_library_file(lib_dirs, 'curses'):
 430                 readline_libs.append('curses')
 431             elif self.compiler.find_library_file(lib_dirs +
 432                                                ['/usr/lib/termcap'],
 433                                                'termcap'):
 434                 readline_libs.append('termcap')
 435             exts.append( Extension('readline', ['readline.c'],
 436                                    library_dirs=['/usr/lib/termcap'],
 437                                    libraries=readline_libs) )
 438         if platform not in ['mac']:
 439             # crypt module.
 440
 441             if self.compiler.find_library_file(lib_dirs, 'crypt'):
 442                 libs = ['crypt']
 443             else:
 444                 libs = []
 445             exts.append( Extension('crypt', ['cryptmodule.c'], libraries=libs) )
 446
 447         # CSV files
 448         exts.append( Extension('_csv', ['_csv.c']) )
 449
 450         # socket(2)
 451         exts.append( Extension('_socket', ['socketmodule.c'],
 452                                depends = ['socketmodule.h']) )
 453         # Detect SSL support for the socket module (via _ssl)
 454         ssl_incs = find_file('openssl/ssl.h', inc_dirs,
 455                              ['/usr/local/ssl/include',
 456                               '/usr/contrib/ssl/include/'
 457                              ]
 458                              )
 459         if ssl_incs is not None:
 460             krb5_h = find_file('krb5.h', inc_dirs,
 461                                ['/usr/kerberos/include'])
 462             if krb5_h:
 463                 ssl_incs += krb5_h
 464         ssl_libs = find_library_file(self.compiler, 'ssl',lib_dirs,
 465                                      ['/usr/local/ssl/lib',
 466                                       '/usr/contrib/ssl/lib/'
 467                                      ] )
 468
 469         if (ssl_incs is not None and
 470             ssl_libs is not None):
 471             exts.append( Extension('_ssl', ['_ssl.c'],
 472                                    include_dirs = ssl_incs,
 473                                    library_dirs = ssl_libs,
 474                                    libraries = ['ssl', 'crypto'],
 475                                    depends = ['socketmodule.h']), )
 476
 477         # Modules that provide persistent dictionary-like semantics.  You will
 478         # probably want to arrange for at least one of them to be available on
 479         # your machine, though none are defined by default because of library
 480         # dependencies.  The Python module anydbm.py provides an
 481         # implementation independent wrapper for these; dumbdbm.py provides
 482         # similar functionality (but slower of course) implemented in Python.
 483
 484         # Sleepycat Berkeley DB interface.  http://www.sleepycat.com
 485         #
 486         # This requires the Sleepycat DB code. The earliest supported version
 487         # of that library is 3.2, the latest supported version is 4.2.  A list
 488         # of available releases can be found at
 489         #
 490         # http://www.sleepycat.com/update/index.html
 491
 492         # when sorted in reverse order, keys for this dict must appear in the
 493         # order you wish to search - e.g., search for db4 before db3
 494         db_try_this = {
 495             'db4': {'libs': ('db-4.2', 'db42', 'db-4.1', 'db41', 'db-4.0', 'db4',),
 496                     'libdirs': ('/usr/local/BerkeleyDB.4.2/lib',
 497                                 '/usr/local/BerkeleyDB.4.1/lib',
 498                                 '/usr/local/BerkeleyDB.4.0/lib',
 499                                 '/usr/local/lib',
 500                                 '/opt/sfw',
 501                                 '/sw/lib',
 502                                 ),
 503                     'incdirs': ('/usr/local/BerkeleyDB.4.2/include',
 504                                 '/usr/local/include/db42',
 505                                 '/usr/local/BerkeleyDB.4.1/include',
 506                                 '/usr/local/include/db41',
 507                                 '/usr/local/BerkeleyDB.4.0/include',
 508                                 '/usr/local/include/db4',
 509                                 '/opt/sfw/include/db4',
 510                                 '/sw/include/db4',
 511                                 '/usr/include/db4',
 512                                 )},
 513             'db3': {'libs': ('db-3.3', 'db-3.2', 'db3',),
 514                     'libdirs': ('/usr/local/BerkeleyDB.3.3/lib',
 515                                 '/usr/local/BerkeleyDB.3.2/lib',
 516                                 '/usr/local/lib',
 517                                 '/opt/sfw/lib',
 518                                 '/sw/lib',
 519                                 ),
 520                     'incdirs': ('/usr/local/BerkeleyDB.3.3/include',
 521                                 '/usr/local/BerkeleyDB.3.2/include',
 522                                 '/usr/local/include/db3',
 523                                 '/opt/sfw/include/db3',
 524                                 '/sw/include/db3',
 525                                 '/usr/include/db3',
 526                                 )},
 527             }
 528
 529         db_search_order = db_try_this.keys()
 530         db_search_order.sort()
 531         db_search_order.reverse()
 532
 533         class found(Exception): pass
 534         try:
 535             # See whether there is a Sleepycat header in the standard
 536             # search path.
 537             std_dbinc = None
 538             for d in inc_dirs:
 539                 f = os.path.join(d, "db.h")
 540                 if os.path.exists(f):
 541                     f = open(f).read()
 542                     m = re.search(r"#define\WDB_VERSION_MAJOR\W([1-9]+)", f)
 543                     if m:
 544                         std_dbinc = 'db' + m.group(1)
 545             for dbkey in db_search_order:
 546                 dbd = db_try_this[dbkey]
 547                 for dblib in dbd['libs']:
 548                     # Prefer version-specific includes over standard
 549                     # include locations.
 550                     db_incs = find_file('db.h', [], dbd['incdirs'])
 551                     dblib_dir = find_library_file(self.compiler,
 552                                                   dblib,
 553                                                   lib_dirs,
 554                                                   list(dbd['libdirs']))
 555                     if (db_incs or dbkey == std_dbinc) and \
 556                            dblib_dir is not None:
 557                         dblibs = [dblib]
 558                         raise found
 559         except found:
 560             dblibs = [dblib]
 561             # A default source build puts Berkeley DB in something like
 562             # /usr/local/Berkeley.3.3 and the lib dir under that isn't
 563             # normally on ld.so's search path, unless the sysadmin has hacked
 564             # /etc/ld.so.conf.  We add the directory to runtime_library_dirs
 565             # so the proper -R/--rpath flags get passed to the linker.  This
 566             # is usually correct and most trouble free, but may cause problems
 567             # in some unusual system configurations (e.g. the directory is on
 568             # an NFS server that goes away).
 569             exts.append(Extension('_bsddb', ['_bsddb.c'],
 570                                   library_dirs=dblib_dir,
 571                                   runtime_library_dirs=dblib_dir,
 572                                   include_dirs=db_incs,
 573                                   libraries=dblibs))
 574         else:
 575             db_incs = None
 576             dblibs = []
 577             dblib_dir = None
 578
 579
 580         # Look for Berkeley db 1.85.   Note that it is built as a different
 581         # module name so it can be included even when later versions are
 582         # available.  A very restrictive search is performed to avoid
 583         # accidentally building this module with a later version of the
 584         # underlying db library.  May BSD-ish Unixes incorporate db 1.85
 585         # symbols into libc and place the include file in /usr/include.
 586         f = "/usr/include/db.h"
 587         if os.path.exists(f):
 588             data = open(f).read()
 589             m = re.search(r"#s*define\s+HASHVERSION\s+2\s*", data)
 590             if m is not None:
 591                 # bingo - old version used hash file format version 2
 592                 ### XXX this should be fixed to not be platform-dependent
 593                 ### but I don't have direct access to an osf1 platform and
 594                 ### seemed to be muffing the search somehow
 595                 libraries = platform == "osf1" and ['db'] or None
 596                 if libraries is not None:
 597                     exts.append(Extension('bsddb185', ['bsddbmodule.c'],
 598                                           libraries=libraries))
 599                 else:
 600                     exts.append(Extension('bsddb185', ['bsddbmodule.c']))
 601
 602         # The standard Unix dbm module:
 603         if platform not in ['cygwin']:
 604             if find_file("ndbm.h", inc_dirs, []) is not None:
 605                 # Some systems have -lndbm, others don't
 606                 if self.compiler.find_library_file(lib_dirs, 'ndbm'):
 607                     ndbm_libs = ['ndbm']
 608                 else:
 609                     ndbm_libs = []
 610                 exts.append( Extension('dbm', ['dbmmodule.c'],
 611                                        define_macros=[('HAVE_NDBM_H',None)],
 612                                        libraries = ndbm_libs ) )
 613             elif (self.compiler.find_library_file(lib_dirs, 'gdbm')
 614                   and find_file("gdbm/ndbm.h", inc_dirs, []) is not None):
 615                 exts.append( Extension('dbm', ['dbmmodule.c'],
 616                                        define_macros=[('HAVE_GDBM_NDBM_H',None)],
 617                                        libraries = ['gdbm'] ) )
 618             elif db_incs is not None:
 619                 exts.append( Extension('dbm', ['dbmmodule.c'],
 620                                        library_dirs=dblib_dir,
 621                                        runtime_library_dirs=dblib_dir,
 622                                        include_dirs=db_incs,
 623                                        define_macros=[('HAVE_BERKDB_H',None),
 624                                                       ('DB_DBM_HSEARCH',None)],
 625                                        libraries=dblibs))
 626
 627         # Anthony Baxter's gdbm module.  GNU dbm(3) will require -lgdbm:
 628         if (self.compiler.find_library_file(lib_dirs, 'gdbm')):
 629             exts.append( Extension('gdbm', ['gdbmmodule.c'],
 630                                    libraries = ['gdbm'] ) )
 631
 632         # Unix-only modules
 633         if platform not in ['mac', 'win32']:
 634             # Steen Lumholt's termios module
 635             exts.append( Extension('termios', ['termios.c']) )
 636             # Jeremy Hylton's rlimit interface
 637             if platform not in ['atheos']:
 638                 exts.append( Extension('resource', ['resource.c']) )
 639
 640             # Sun yellow pages. Some systems have the functions in libc.
 641             if platform not in ['cygwin', 'atheos']:
 642                 if (self.compiler.find_library_file(lib_dirs, 'nsl')):
 643                     libs = ['nsl']
 644                 else:
 645                     libs = []
 646                 exts.append( Extension('nis', ['nismodule.c'],
 647                                        libraries = libs) )
 648
 649         # Curses support, requiring the System V version of curses, often
 650         # provided by the ncurses library.
 651         if (self.compiler.find_library_file(lib_dirs, 'ncurses')):
 652             curses_libs = ['ncurses']
 653             exts.append( Extension('_curses', ['_cursesmodule.c'],
 654                                    libraries = curses_libs) )
 655         elif (self.compiler.find_library_file(lib_dirs, 'curses')
 656               and platform != 'darwin'):
 657                 # OSX has an old Berkeley curses, not good enough for
 658                 # the _curses module.
 659             if (self.compiler.find_library_file(lib_dirs, 'terminfo')):
 660                 curses_libs = ['curses', 'terminfo']
 661             elif (self.compiler.find_library_file(lib_dirs, 'termcap')):
 662                 curses_libs = ['curses', 'termcap']
 663             else:
 664                 curses_libs = ['curses']
 665
 666             exts.append( Extension('_curses', ['_cursesmodule.c'],
 667                                    libraries = curses_libs) )
 668
 669         # If the curses module is enabled, check for the panel module
 670         if (module_enabled(exts, '_curses') and
 671             self.compiler.find_library_file(lib_dirs, 'panel')):
 672             exts.append( Extension('_curses_panel', ['_curses_panel.c'],
 673                                    libraries = ['panel'] + curses_libs) )
 674
 675
 676         # Andrew Kuchling's zlib module.  Note that some versions of zlib
 677         # 1.1.3 have security problems.  See CERT Advisory CA-2002-07:
 678         # http://www.cert.org/advisories/CA-2002-07.html
 679         #
 680         # zlib 1.1.4 is fixed, but at least one vendor (RedHat) has decided to
 681         # patch its zlib 1.1.3 package instead of upgrading to 1.1.4.  For
 682         # now, we still accept 1.1.3, because we think it's difficult to
 683         # exploit this in Python, and we'd rather make it RedHat's problem
 684         # than our problem <wink>.
 685         #
 686         # You can upgrade zlib to version 1.1.4 yourself by going to
 687         # http://www.gzip.org/zlib/
 688         zlib_inc = find_file('zlib.h', [], inc_dirs)
 689         if zlib_inc is not None:
 690             zlib_h = zlib_inc[0] + '/zlib.h'
 691             version = '"0.0.0"'
 692             version_req = '"1.1.3"'
 693             fp = open(zlib_h)
 694             while 1:
 695                 line = fp.readline()
 696                 if not line:
 697                     break
 698                 if line.startswith('#define ZLIB_VERSION'):
 699                     version = line.split()[2]
 700                     break
 701             if version >= version_req:
 702                 if (self.compiler.find_library_file(lib_dirs, 'z')):
 703                     exts.append( Extension('zlib', ['zlibmodule.c'],
 704                                            libraries = ['z']) )
 705
 706         # Gustavo Niemeyer's bz2 module.
 707         if (self.compiler.find_library_file(lib_dirs, 'bz2')):
 708             exts.append( Extension('bz2', ['bz2module.c'],
 709                                    libraries = ['bz2']) )
 710
 711         # Interface to the Expat XML parser
 712         #
 713         # Expat was written by James Clark and is now maintained by a
 714         # group of developers on SourceForge; see www.libexpat.org for
 715         # more information.  The pyexpat module was written by Paul
 716         # Prescod after a prototype by Jack Jansen.  The Expat source
 717         # is included in Modules/expat/.  Usage of a system
 718         # shared libexpat.so/expat.dll is not advised.
 719         #
 720         # More information on Expat can be found at www.libexpat.org.
 721         #
 722         if sys.byteorder == "little":
 723             xmlbo = "1234"
 724         else:
 725             xmlbo = "4321"
 726         expatinc = os.path.join(os.getcwd(), srcdir, 'Modules', 'expat')
 727         define_macros = [
 728             ('XML_NS', '1'),
 729             ('XML_DTD', '1'),
 730             ('BYTEORDER', xmlbo),
 731             ('XML_CONTEXT_BYTES','1024'),
 732             ]
 733         config_h = sysconfig.get_config_h_filename()
 734         config_h_vars = sysconfig.parse_config_h(open(config_h))
 735         for feature_macro in ['HAVE_MEMMOVE', 'HAVE_BCOPY']:
 736             if config_h_vars.has_key(feature_macro):
 737                 define_macros.append((feature_macro, '1'))
 738         exts.append(Extension('pyexpat',
 739                               define_macros = define_macros,
 740                               include_dirs = [expatinc],
 741                               sources = ['pyexpat.c',
 742                                          'expat/xmlparse.c',
 743                                          'expat/xmlrole.c',
 744                                          'expat/xmltok.c',
 745                                          ],
 746                               ))
 747
 748         # Hye-Shik Chang's CJKCodecs modules.
 749         exts.append(Extension('_multibytecodec',
 750                               ['cjkcodecs/multibytecodec.c']))
 751         for loc in ('kr', 'jp', 'cn', 'tw', 'hk', 'iso2022'):
 752             exts.append(Extension('_codecs_' + loc,
 753                                   ['cjkcodecs/_codecs_%s.c' % loc]))
 754
 755         # Dynamic loading module
 756         if sys.maxint == 0x7fffffff:
 757             # This requires sizeof(int) == sizeof(long) == sizeof(char*)
 758             dl_inc = find_file('dlfcn.h', [], inc_dirs)
 759             if (dl_inc is not None) and (platform not in ['atheos', 'darwin']):
 760                 exts.append( Extension('dl', ['dlmodule.c']) )
 761
 762         # Platform-specific libraries
 763         if platform == 'linux2':
 764             # Linux-specific modules
 765             exts.append( Extension('linuxaudiodev', ['linuxaudiodev.c']) )
 766
 767         if platform in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6'):
 768             exts.append( Extension('ossaudiodev', ['ossaudiodev.c']) )
 769
 770         if platform == 'sunos5':
 771             # SunOS specific modules
 772             exts.append( Extension('sunaudiodev', ['sunaudiodev.c']) )
 773
 774         if platform == 'darwin' and ("--disable-toolbox-glue" not in
 775             sysconfig.get_config_var("CONFIG_ARGS")):
 776             # Mac OS X specific modules.
 777             exts.append( Extension('_CF', ['cf/_CFmodule.c', 'cf/pycfbridge.c'],
 778                         extra_link_args=['-framework', 'CoreFoundation']) )
 779
 780             exts.append( Extension('ColorPicker', ['ColorPickermodule.c'],
 781                         extra_link_args=['-framework', 'Carbon']) )
 782             exts.append( Extension('autoGIL', ['autoGIL.c'],
 783                         extra_link_args=['-framework', 'CoreFoundation']) )
 784             exts.append( Extension('gestalt', ['gestaltmodule.c'],
 785                         extra_link_args=['-framework', 'Carbon']) )
 786             exts.append( Extension('MacOS', ['macosmodule.c'],
 787                         extra_link_args=['-framework', 'Carbon']) )
 788             exts.append( Extension('OSATerminology', ['OSATerminology.c'],
 789                         extra_link_args=['-framework', 'Carbon']) )
 790             exts.append( Extension('icglue', ['icgluemodule.c'],
 791                         extra_link_args=['-framework', 'Carbon']) )
 792             exts.append( Extension('_Res', ['res/_Resmodule.c'],
 793                         extra_link_args=['-framework', 'Carbon']) )
 794             exts.append( Extension('_Snd', ['snd/_Sndmodule.c'],
 795                         extra_link_args=['-framework', 'Carbon']) )
 796             exts.append( Extension('Nav', ['Nav.c'],
 797                     extra_link_args=['-framework', 'Carbon']) )
 798             exts.append( Extension('_AE', ['ae/_AEmodule.c'],
 799                     extra_link_args=['-framework', 'Carbon']) )
 800             exts.append( Extension('_AH', ['ah/_AHmodule.c'],
 801                     extra_link_args=['-framework', 'Carbon']) )
 802             exts.append( Extension('_App', ['app/_Appmodule.c'],
 803                     extra_link_args=['-framework', 'Carbon']) )
 804             exts.append( Extension('_CarbonEvt', ['carbonevt/_CarbonEvtmodule.c'],
 805                     extra_link_args=['-framework', 'Carbon']) )
 806             exts.append( Extension('_CG', ['cg/_CGmodule.c'],
 807                     extra_link_args=['-framework', 'ApplicationServices']) )
 808             exts.append( Extension('_Cm', ['cm/_Cmmodule.c'],
 809                     extra_link_args=['-framework', 'Carbon']) )
 810             exts.append( Extension('_Ctl', ['ctl/_Ctlmodule.c'],
 811                     extra_link_args=['-framework', 'Carbon']) )
 812             exts.append( Extension('_Dlg', ['dlg/_Dlgmodule.c'],
 813                     extra_link_args=['-framework', 'Carbon']) )
 814             exts.append( Extension('_Drag', ['drag/_Dragmodule.c'],
 815                     extra_link_args=['-framework', 'Carbon']) )
 816             exts.append( Extension('_Evt', ['evt/_Evtmodule.c'],
 817                     extra_link_args=['-framework', 'Carbon']) )
 818             exts.append( Extension('_File', ['file/_Filemodule.c'],
 819                     extra_link_args=['-framework', 'Carbon']) )
 820             exts.append( Extension('_Folder', ['folder/_Foldermodule.c'],
 821                     extra_link_args=['-framework', 'Carbon']) )
 822             exts.append( Extension('_Fm', ['fm/_Fmmodule.c'],
 823                     extra_link_args=['-framework', 'Carbon']) )
 824             exts.append( Extension('_Help', ['help/_Helpmodule.c'],
 825                     extra_link_args=['-framework', 'Carbon']) )
 826             exts.append( Extension('_Icn', ['icn/_Icnmodule.c'],
 827                     extra_link_args=['-framework', 'Carbon']) )
 828             exts.append( Extension('_IBCarbon', ['ibcarbon/_IBCarbon.c'],
 829                     extra_link_args=['-framework', 'Carbon']) )
 830             exts.append( Extension('_Launch', ['launch/_Launchmodule.c'],
 831                     extra_link_args=['-framework', 'ApplicationServices']) )
 832             exts.append( Extension('_List', ['list/_Listmodule.c'],
 833                     extra_link_args=['-framework', 'Carbon']) )
 834             exts.append( Extension('_Menu', ['menu/_Menumodule.c'],
 835                     extra_link_args=['-framework', 'Carbon']) )
 836             exts.append( Extension('_Mlte', ['mlte/_Mltemodule.c'],
 837                     extra_link_args=['-framework', 'Carbon']) )
 838             exts.append( Extension('_OSA', ['osa/_OSAmodule.c'],
 839                     extra_link_args=['-framework', 'Carbon']) )
 840             exts.append( Extension('_Qd', ['qd/_Qdmodule.c'],
 841                     extra_link_args=['-framework', 'Carbon']) )
 842             exts.append( Extension('_Qdoffs', ['qdoffs/_Qdoffsmodule.c'],
 843                     extra_link_args=['-framework', 'Carbon']) )
 844             exts.append( Extension('_Qt', ['qt/_Qtmodule.c'],
 845                     extra_link_args=['-framework', 'QuickTime',
 846                                      '-framework', 'Carbon']) )
 847             exts.append( Extension('_Scrap', ['scrap/_Scrapmodule.c'],
 848                     extra_link_args=['-framework', 'Carbon']) )
 849             exts.append( Extension('_TE', ['te/_TEmodule.c'],
 850                     extra_link_args=['-framework', 'Carbon']) )
 851             # As there is no standardized place (yet) to put
 852             # user-installed Mac libraries on OSX, we search for "waste"
 853             # in parent directories of the Python source tree. You
 854             # should put a symlink to your Waste installation in the
 855             # same folder as your python source tree.  Or modify the
 856             # next few lines:-)
 857             waste_incs = find_file("WASTE.h", [],
 858                     ['../'*n + 'waste/C_C++ Headers' for n in (0,1,2,3,4)])
 859             waste_libs = find_library_file(self.compiler, "WASTE", [],
 860                     ["../"*n + "waste/Static Libraries" for n in (0,1,2,3,4)])
 861             if waste_incs != None and waste_libs != None:
 862                 (srcdir,) = sysconfig.get_config_vars('srcdir')
 863                 exts.append( Extension('waste',
 864                                ['waste/wastemodule.c'] + [
 865                                 os.path.join(srcdir, d) for d in
 866                                 'Mac/Wastemods/WEObjectHandlers.c',
 867                                 'Mac/Wastemods/WETabHooks.c',
 868                                 'Mac/Wastemods/WETabs.c'
 869                                ],
 870                                include_dirs = waste_incs + [os.path.join(srcdir, 'Mac/Wastemods')],
 871                                library_dirs = waste_libs,
 872                                libraries = ['WASTE'],
 873                                extra_link_args = ['-framework', 'Carbon'],
 874                 ) )
 875             exts.append( Extension('_Win', ['win/_Winmodule.c'],
 876                     extra_link_args=['-framework', 'Carbon']) )
 877
 878         self.extensions.extend(exts)
 879
 880         # Call the method for detecting whether _tkinter can be compiled
 881         self.detect_tkinter(inc_dirs, lib_dirs)
 882
 883     def detect_tkinter_darwin(self, inc_dirs, lib_dirs):
 884         # The _tkinter module, using frameworks. Since frameworks are quite
 885         # different the UNIX search logic is not sharable.
 886         from os.path import join, exists
 887         framework_dirs = [
 888             '/System/Library/Frameworks/',
 889             '/Library/Frameworks',
 890             join(os.getenv('HOME'), '/Library/Frameworks')
 891         ]
 892
 893         # Find the directory that contains the Tcl.framwork and Tk.framework
 894         # bundles.
 895         # XXX distutils should support -F!
 896         for F in framework_dirs:
 897             # both Tcl.framework and Tk.framework should be present
 898             for fw in 'Tcl', 'Tk':
 899                 if not exists(join(F, fw + '.framework')):
 900                     break
 901             else:
 902                 # ok, F is now directory with both frameworks. Continure
 903                 # building
 904                 break
 905         else:
 906             # Tk and Tcl frameworks not found. Normal "unix" tkinter search
 907             # will now resume.
 908             return 0
 909
 910         # For 8.4a2, we must add -I options that point inside the Tcl and Tk
 911         # frameworks. In later release we should hopefully be able to pass
 912         # the -F option to gcc, which specifies a framework lookup path.
 913         #
 914         include_dirs = [
 915             join(F, fw + '.framework', H)
 916             for fw in 'Tcl', 'Tk'
 917             for H in 'Headers', 'Versions/Current/PrivateHeaders'
 918         ]
 919
 920         # For 8.4a2, the X11 headers are not included. Rather than include a
 921         # complicated search, this is a hard-coded path. It could bail out
 922         # if X11 libs are not found...
 923         include_dirs.append('/usr/X11R6/include')
 924         frameworks = ['-framework', 'Tcl', '-framework', 'Tk']
 925
 926         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
 927                         define_macros=[('WITH_APPINIT', 1)],
 928                         include_dirs = include_dirs,
 929                         libraries = [],
 930                         extra_compile_args = frameworks,
 931                         extra_link_args = frameworks,
 932                         )
 933         self.extensions.append(ext)
 934         return 1
 935
 936
 937     def detect_tkinter(self, inc_dirs, lib_dirs):
 938         # The _tkinter module.
 939
 940         # Rather than complicate the code below, detecting and building
 941         # AquaTk is a separate method. Only one Tkinter will be built on
 942         # Darwin - either AquaTk, if it is found, or X11 based Tk.
 943         platform = self.get_platform()
 944         if platform == 'darwin' and \
 945            self.detect_tkinter_darwin(inc_dirs, lib_dirs):
 946             return
 947
 948         # Assume we haven't found any of the libraries or include files
 949         # The versions with dots are used on Unix, and the versions without
 950         # dots on Windows, for detection by cygwin.
 951         tcllib = tklib = tcl_includes = tk_includes = None
 952         for version in ['8.5', '85', '8.4', '84', '8.3', '83', '8.2',
 953                         '82', '8.1', '81', '8.0', '80']:
 954             tklib = self.compiler.find_library_file(lib_dirs, 'tk' + version)
 955             tcllib = self.compiler.find_library_file(lib_dirs, 'tcl' + version)
 956             if tklib and tcllib:
 957                 # Exit the loop when we've found the Tcl/Tk libraries
 958                 break
 959
 960         # Now check for the header files
 961         if tklib and tcllib:
 962             # Check for the include files on Debian and {Free,Open}BSD, where
 963             # they're put in /usr/include/{tcl,tk}X.Y
 964             dotversion = version
 965             if '.' not in dotversion and "bsd" in sys.platform.lower():
 966                 # OpenBSD and FreeBSD use Tcl/Tk library names like libtcl83.a,
 967                 # but the include subdirs are named like .../include/tcl8.3.
 968                 dotversion = dotversion[:-1] + '.' + dotversion[-1]
 969             tcl_include_sub = []
 970             tk_include_sub = []
 971             for dir in inc_dirs:
 972                 tcl_include_sub += [dir + os.sep + "tcl" + dotversion]
 973                 tk_include_sub += [dir + os.sep + "tk" + dotversion]
 974             tk_include_sub += tcl_include_sub
 975             tcl_includes = find_file('tcl.h', inc_dirs, tcl_include_sub)
 976             tk_includes = find_file('tk.h', inc_dirs, tk_include_sub)
 977
 978         if (tcllib is None or tklib is None or
 979             tcl_includes is None or tk_includes is None):
 980             self.announce("INFO: Can't locate Tcl/Tk libs and/or headers", 2)
 981             return
 982
 983         # OK... everything seems to be present for Tcl/Tk.
 984
 985         include_dirs = [] ; libs = [] ; defs = [] ; added_lib_dirs = []
 986         for dir in tcl_includes + tk_includes:
 987             if dir not in include_dirs:
 988                 include_dirs.append(dir)
 989
 990         # Check for various platform-specific directories
 991         if platform == 'sunos5':
 992             include_dirs.append('/usr/openwin/include')
 993             added_lib_dirs.append('/usr/openwin/lib')
 994         elif os.path.exists('/usr/X11R6/include'):
 995             include_dirs.append('/usr/X11R6/include')
 996             added_lib_dirs.append('/usr/X11R6/lib64')
 997             added_lib_dirs.append('/usr/X11R6/lib')
 998         elif os.path.exists('/usr/X11R5/include'):
 999             include_dirs.append('/usr/X11R5/include')
1000             added_lib_dirs.append('/usr/X11R5/lib')
1001         else:
1002             # Assume default location for X11
1003             include_dirs.append('/usr/X11/include')
1004             added_lib_dirs.append('/usr/X11/lib')
1005
1006         # If Cygwin, then verify that X is installed before proceeding
1007         if platform == 'cygwin':
1008             x11_inc = find_file('X11/Xlib.h', [], include_dirs)
1009             if x11_inc is None:
1010                 return
1011
1012         # Check for BLT extension
1013         if self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1014                                            'BLT8.0'):
1015             defs.append( ('WITH_BLT', 1) )
1016             libs.append('BLT8.0')
1017         elif self.compiler.find_library_file(lib_dirs + added_lib_dirs,
1018                                            'BLT'):
1019             defs.append( ('WITH_BLT', 1) )
1020             libs.append('BLT')
1021
1022         # Add the Tcl/Tk libraries
1023         libs.append('tk'+ version)
1024         libs.append('tcl'+ version)
1025
1026         if platform in ['aix3', 'aix4']:
1027             libs.append('ld')
1028
1029         # Finally, link with the X11 libraries (not appropriate on cygwin)
1030         if platform != "cygwin":
1031             libs.append('X11')
1032
1033         ext = Extension('_tkinter', ['_tkinter.c', 'tkappinit.c'],
1034                         define_macros=[('WITH_APPINIT', 1)] + defs,
1035                         include_dirs = include_dirs,
1036                         libraries = libs,
1037                         library_dirs = added_lib_dirs,
1038                         )
1039         self.extensions.append(ext)
1040
1041 ##         # Uncomment these lines if you want to play with xxmodule.c
1042 ##         ext = Extension('xx', ['xxmodule.c'])
1043 ##         self.extensions.append(ext)
1044
1045         # XXX handle these, but how to detect?
1046         # *** Uncomment and edit for PIL (TkImaging) extension only:
1047         #       -DWITH_PIL -I../Extensions/Imaging/libImaging  tkImaging.c \
1048         # *** Uncomment and edit for TOGL extension only:
1049         #       -DWITH_TOGL togl.c \
1050         # *** Uncomment these for TOGL extension only:
1051         #       -lGL -lGLU -lXext -lXmu \
1052
1053 class PyBuildInstall(install):
1054     # Suppress the warning about installation into the lib_dynload
1055     # directory, which is not in sys.path when running Python during
1056     # installation:
1057     def initialize_options (self):
1058         install.initialize_options(self)
1059         self.warn_dir=0
1060
1061 class PyBuildInstallLib(install_lib):
1062     # Do exactly what install_lib does but make sure correct access modes get
1063     # set on installed directories and files. All installed files with get
1064     # mode 644 unless they are a shared library in which case they will get
1065     # mode 755. All installed directories will get mode 755.
1066
1067     so_ext = sysconfig.get_config_var("SO")
1068
1069     def install(self):
1070         outfiles = install_lib.install(self)
1071         self.set_file_modes(outfiles, 0644, 0755)
1072         self.set_dir_modes(self.install_dir, 0755)
1073         return outfiles
1074
1075     def set_file_modes(self, files, defaultMode, sharedLibMode):
1076         if not self.is_chmod_supported(): return
1077         if not files: return
1078
1079         for filename in files:
1080             if os.path.islink(filename): continue
1081             mode = defaultMode
1082             if filename.endswith(self.so_ext): mode = sharedLibMode
1083             log.info("changing mode of %s to %o", filename, mode)
1084             if not self.dry_run: os.chmod(filename, mode)
1085
1086     def set_dir_modes(self, dirname, mode):
1087         if not self.is_chmod_supported(): return
1088         os.path.walk(dirname, self.set_dir_modes_visitor, mode)
1089
1090     def set_dir_modes_visitor(self, mode, dirname, names):
1091         if os.path.islink(dirname): return
1092         log.info("changing mode of %s to %o", dirname, mode)
1093         if not self.dry_run: os.chmod(dirname, mode)
1094
1095     def is_chmod_supported(self):
1096         return hasattr(os, 'chmod')
1097
1098 SUMMARY = """
1099 Python is an interpreted, interactive, object-oriented programming
1100 language. It is often compared to Tcl, Perl, Scheme or Java.
1101
1102 Python combines remarkable power with very clear syntax. It has
1103 modules, classes, exceptions, very high level dynamic data types, and
1104 dynamic typing. There are interfaces to many system calls and
1105 libraries, as well as to various windowing systems (X11, Motif, Tk,
1106 Mac, MFC). New built-in modules are easily written in C or C++. Python
1107 is also usable as an extension language for applications that need a
1108 programmable interface.
1109
1110 The Python implementation is portable: it runs on many brands of UNIX,
1111 on Windows, DOS, OS/2, Mac, Amiga... If your favorite system isn't
1112 listed here, it may still be supported, if there's a C compiler for
1113 it. Ask around on comp.lang.python -- or just try compiling Python
1114 yourself.
1115 """
1116
1117 CLASSIFIERS = """
1118 Development Status :: 3 - Alpha
1119 Development Status :: 6 - Mature
1120 License :: OSI Approved :: Python Software Foundation License
1121 Natural Language :: English
1122 Programming Language :: C
1123 Programming Language :: Python
1124 Topic :: Software Development
1125 """
1126
1127 def main():
1128     # turn off warnings when deprecated modules are imported
1129     import warnings
1130     warnings.filterwarnings("ignore",category=DeprecationWarning)
1131     setup(# PyPI Metadata (PEP 301)
1132           name = "Python",
1133           version = sys.version.split()[0],
1134           url = "http://www.python.org/%s" % sys.version[:3],
1135           maintainer = "Guido van Rossum and the Python community",
1136           maintainer_email = "python-dev@python.org",
1137           description = "A high-level object-oriented programming language",
1138           long_description = SUMMARY.strip(),
1139           license = "PSF license",
1140           classifiers = filter(None, CLASSIFIERS.split("\n")),
1141           platforms = ["Many"],
1142
1143           # Build info
1144           cmdclass = {'build_ext':PyBuildExt, 'install':PyBuildInstall,
1145                       'install_lib':PyBuildInstallLib},
1146           # The struct module is defined here, because build_ext won't be
1147           # called unless there's at least one extension module defined.
1148           ext_modules=[Extension('struct', ['structmodule.c'])],
1149
1150           # Scripts to install
1151           scripts = ['Tools/scripts/pydoc', 'Tools/scripts/idle',
1152                      'Lib/smtpd.py']
1153         )
1154
1155 # --install-platlib
1156 if __name__ == '__main__':
1157     main()