You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
pytdeextensions/setup.py

324 lines
14 KiB

#!/usr/bin/python
###########################################################################
# setup - description #
# ------------------------------ #
# begin : Thu Apr 21 2005 #
# copyright : (C) 2005 by Simon Edwards #
# email : simon@simonzone.com #
# #
###########################################################################
# #
# This program is free software; you can redistribute it and/or modify #
# it under the terms of the GNU Library General Public License as #
# published by the Free Software Foundation; either version 2 of the #
# License, or (at your option) any later version. #
# #
###########################################################################
from distutils.cmd import Command
from distutils import sysconfig
from distutils.spawn import find_executable,spawn
from distutils import dir_util
import sys
import os
import glob
sys.path.insert(0,"src") # We need this for the import statement below.
import tdedistutils
def main():
tdedistutils.setup(name="pytdeextensions",
version="0.4.0",
author="Simon Edwards",
author_email="simon@simonzone.com",
12 years ago
url="http://www.simonzone.com/software/pykdeextensions/",
min_kde_version = "3.0.0",
min_tqt_version = "3.0.0",
license = "LGPL",
package_dir = {'': 'src'},
py_modules = ["tdedistutils","tqtuicompiler","tqtdesigner","tdedesigner"],
application_data = ["app_templates","AUTHORS","ChangeLog","COPYING","INSTALL","NEWS"],
docbooks = [ ('doc/en','en') ],
cmdclass = {
'install' : InstallPyKDEExtensions,
'build_libpythonize' : BuildLibpythonize,
'install_libpythonize' : InstallLibpythonize
}
)
###########################################################################
class InstallPyKDEExtensions(tdedistutils.InstallKDE):
sub_commands = tdedistutils.InstallKDE.sub_commands[:]
sub_commands.append( ('install_libpythonize',None) )
user_options = tdedistutils.InstallKDE.user_options
user_options.append( ('install-clib=', None, "installation directory for shared libraries") )
user_options.append( ('install-cheaders=', None, "installation directory for C header files") )
def initialize_options(self):
self.install_clib = None
self.install_cheaders = None
tdedistutils.InstallKDE.initialize_options(self)
def finalize_options(self):
if self.install_clib is None:
if self.prefix is not None:
self.install_clib = os.path.join(self.prefix,'lib')
else:
self.announce("Detecting KDE library directory...")
self.install_clib = tdedistutils.ask_kde_config('--install lib --expandvars').strip()
self.announce(" ...KDE library directory is %s" % self.install_clib)
if self.install_cheaders is None:
if self.prefix is not None:
self.install_cheaders = os.path.join(self.prefix,'include')
else:
self.announce("Detecting KDE headers directory...")
self.install_cheaders = os.path.normpath(os.path.join(tdedistutils.ask_kde_config('--install lib --expandvars').strip(),"../include"))
self.announce(" ...KDE library headers is %s" % self.install_cheaders)
tdedistutils.InstallKDE.finalize_options(self)
if self.root is not None:
self.change_roots('clib','cheaders')
###########################################################################
class BuildLibpythonize(Command):
description = "Build libpythonize"
user_options = [
('install-dir=', 'd',"Directory for the libpythonize shared library."),
('no-libpythonize',None,"Don't build libpythonize"),
('build-dir=','b', "build directory (where to install from)"),
('python-dir=',None,'Directory containing the Python installation'),
('python-inc-dir=',None,'Directory containing C Header files for Python'),
('clib=',None,'gcc library and path'),
]
def initialize_options(self):
self.build_dir = None
self.install_dir = None
self.no_libpythonize = 0
self.python_inc_dir = None
self.python_dir = None
self.clib = None
def finalize_options(self):
if self.no_libpythonize==0:
own_install_dir = self.install_dir is not None
self.set_undefined_options('install',\
('build_base', 'build_dir'),
('install_clib', 'install_dir') )
install = self.get_finalized_command('install')
self.install_prefix = install.prefix
# Python dir
if self.python_dir is None:
self.python_dir = os.path.split(sysconfig.get_config_var("LIBPL"))[0]
self.announce("Using %s for the python directory" % self.python_dir)
# Python include dir.
if self.python_inc_dir is None:
# Find the Python include directory.
self.python_inc_dir = sysconfig.get_config_var("INCLUDEPY")
self.announce("Using %s for Python header files" % self.python_inc_dir)
# Find the C library (libgcc, libgcc_s or some other variation).
if self.clib is None:
canidatepaths = ["/usr/"+tdedistutils.get_libdir_name(), "/usr/local/"+tdedistutils.get_libdir_name(), "/usr/lib" ]
self.clib = tdedistutils.FindFileInPaths("libgcc*.so",canidatepaths)
if self.clib!=None:
self.clib = glob.glob(os.path.join(self.clib,'libgcc*.so'))[0]
else:
self.clib = tdedistutils.FindFileInPaths("libgcc*.a",canidatepaths)
if self.clib!=None:
self.clib = glob.glob(os.path.join(self.clib,'libgcc*.a'))[0]
if self.clib is None:
raise SystemExit("setup.py: Failed to find a suitable libgcc library")
self.announce("Using %s for clib" % self.clib)
# Make a list of places to look for python .so modules
self.python_sub_dirs = sysconfig.get_config_var("LIBSUBDIRS").split()
base = sysconfig.get_config_var("LIBPL")
self.python_sub_dirs = [ os.path.join(base,item) for item in self.python_sub_dirs ]
self.python_sub_dirs.append(base)
def get_command_name(self):
return 'build_libpythonize'
def run(self):
if self.no_libpythonize:
self.announce("Skipping libpythonize")
return
self.announce("Building libpythonize.")
cppfile = "src/pythonize.cpp"
# Compile the library.
cmdlist = ['libtool']
# Couldn't get it to pass without this ...
cmdlist.append("--mode=compile")
cmdlist.append("--tag=CXX")
# Find the compiler flags and options
# CXX is empty on some Systems, let's do it 'the hard way'.
# FIXME :: get CXX from make.conf for Gentoo.
if len(sysconfig.get_config_var("CXX").split()) >= 2:
cmdlist.extend(sysconfig.get_config_var("CXX").split())
else:
cmdlist.extend(['g++', '-pthread'])
# cc_flags
cmdlist.append("-c")
cmdlist.append("-g")
# The 4 is randomly chosen!
# FIXME :: get CFLAGS from make.conf for Gentoo.
if len(sysconfig.get_config_var("CFLAGS").split()) >=4:
cmdlist.extend(sysconfig.get_config_var("CFLAGS").split())
else:
# On Gentoo systems, CFLAGS are not in the environment.
raw = os.popen('emerge info 2> /dev/null|grep CFLAGS')
lines = raw.readlines()
if len(lines):
cflags = lines[0].split('"')[1].split()
print("Got CFLAGS from emerge info.")
cmdlist.extend(cflags)
else:
# Still no CFLAGS found, use these ...
cmdlist.extend(['-fno-strict-aliasing', '-DNDEBUG', '-g', '-O3', '-Wall', '-Wstrict-prototypes'])
# includes
cmdlist.append("-I" + sysconfig.get_config_var("INCLUDEDIR"))
cmdlist.append("-I" + sysconfig.get_config_var("INCLUDEPY"))
cmdlist.append("-I" + self.python_inc_dir)
cmdlist.append("-Isrc")
# input
cmdlist.append(cppfile)
# output
outputfile = os.path.join(self.build_dir,'libpythonize.lo')
cmdlist.append("-o")
cmdlist.append(outputfile)
spawn(cmdlist) # Execute!!!
print()
# Link the resulting object file to create a shared library.
cmdlist = ['libtool']
cmdlist.append("--mode=link")
cmdlist.append("--tag=LD")
# Grab the linker command name
cmdlist.append(sysconfig.get_config_var("LDSHARED").split()[0])
# link_flags
cmdlist.append("-module")
cmdlist.append("-export-dynamic")
# object
cmdlist.append(outputfile)
cmdlist.append("-rpath"); cmdlist.append(self.install_dir)
cmdlist.append("-o"); cmdlist.append(os.path.join(self.build_dir,'libpythonize.la'))
# Link libs
linklist = []
linklist.append("-lpython%i.%i%s" % (sys.version_info[0], sys.version_info[1], sys.abiflags) )
linklist.extend(sysconfig.get_config_var("LIBS").split())
linklist.append("-lm")
linklist.append("-lc")
linklist.append(self.clib)
linklist.append("-R"); linklist.append(self.python_dir)
cmdlist.extend(linklist)
spawn(cmdlist) # Execute!!
print()
###########################################################################
class InstallLibpythonize(Command):
description = "Install libpythonize"
user_options = [
('install-dir=', 'd',"Directory for the libpythonize shared library."),
('build-dir=','b', "build directory (where to install from)"),
('cheader-dir=', 'h',"Directory for the pythonize.h C header file."),
('install-cmd=', None, "Command to use to install the files"),
('root=', None, "install everything relative to this alternate root directory"),
('force', 'f', "force installation (overwrite existing files)"),
('skip-build', None, "skip the build steps"),
]
boolean_options = ['force', 'skip-build']
def initialize_options(self):
self.install_dir = None
self.build_dir = None
self.install_cmd = None
self.cheader_dir = None
self.outfiles = []
self.root = None
self.force = 0
self.warn_dir = 1
self.skip_build = None
def finalize_options(self):
own_install_dir = self.install_dir is not None
own_cheader_dir = self.cheader_dir is not None
self.set_undefined_options('install',
('build_base','build_dir'),
('install_clib', 'install_dir'),
('install_cheaders', 'cheader_dir'),
('install_cmd', 'install_cmd'),
('root', 'root'),
('force', 'force'),
('skip_build', 'skip_build')
)
if own_install_dir and self.root is not None:
self.install_dir = change_root(self.root,self.install_dir)
if own_cheader_dir and self.root is not None:
self.cheader_dir = change_root(self.root,self.cheader_dir)
def get_command_name(self):
return 'install_libpythonize'
def run(self):
if not self.skip_build:
self.run_command('build_libpythonize')
self.announce("Installing libpythonize...")
self.outfiles.extend(self.mkpath(self.install_dir))
# Install the library.
cmdlist = ['libtool']
cmdlist.append("--mode=install")
cmdlist.append(self.install_cmd)
cmdlist.append("-c")
cmdlist.append(os.path.join(self.build_dir,"libpythonize.la"))
cmdlist.append(os.path.join(self.install_dir,"libpythonize.la"))
spawn(cmdlist) # Execute!!
print()
# Work the names of the files that were installed.
self.outfiles = []
for file in glob.glob(os.path.join(self.build_dir,'.libs/libpythonize*')):
self.outfiles.append(os.path.join(self.install_dir,os.path.basename(file)))
# Create a directory for the C header file.
self.outfiles.extend(self.mkpath(self.cheader_dir))
# Install the header file.
(out, _) = self.copy_file("src/pythonize.h", os.path.join(self.cheader_dir,'pythonize.h'))
self.outfiles.append(out)
self.announce("Done installing libpythonize.")
def get_outputs(self):
return self.outfiles
def mkpath(self, name, mode=0o777):
return dir_util.mkpath(name, mode, dry_run=self.dry_run)
main()