def build_extensions(self):
numpy_incl = pkg_resources.resource_filename('numpy', 'core/include')
for ext in self.extensions:
if hasattr(ext, 'include_dirs') and not numpy_incl in ext.include_dirs:
ext.include_dirs.append(numpy_incl)
_build_ext.build_extensions(self)
def build_extensions(self):
# Detect which modules should be compiled
self.detect_modules()
# Tweak compiler options
if self.compiler.compiler_type in ('unix', 'cygwin', 'mingw32'):
# Tell GCC to compile using the C99 standard.
self.__add_compiler_option("-std=c99")
# Make assert() statements always work
self.__remove_compiler_option("-DNDEBUG")
# Choose our own optimization options
for opt in ["-O", "-O0", "-O1", "-O2", "-O3", "-Os"]:
self.__remove_compiler_option(opt)
if self.debug:
# Basic optimization is still needed when debugging to compile
# the libtomcrypt code.
self.__add_compiler_option("-O")
else:
# Speed up execution by tweaking compiler options. This
# especially helps the DES modules.
self.__add_compiler_option("-O3")
self.__add_compiler_option("-fomit-frame-pointer")
# Don't include debug symbols unless debugging
self.__remove_compiler_option("-g")
# Don't include profiling information (incompatible with -fomit-frame-pointer)
self.__remove_compiler_option("-pg")
if USE_GCOV:
self.__add_compiler_option("-fprofile-arcs")
self.__add_compiler_option("-ftest-coverage")
self.compiler.libraries += ['gcov']
# Call the superclass's build_extensions method
build_ext.build_extensions(self)
def build_extensions(self):
c = self.compiler.compiler_type
if c == "msvc":
# customize the build options for this compilier
for e in self.extensions:
e.extra_link_args.append("/MANIFEST")
if c == "unix":
# customize the build options for this compilier
for e in self.extensions:
e.extra_compile_args.append("-ffast-math")
e.extra_compile_args.append("-O2")
e.extra_compile_args.append("-Wdeclaration-after-statement")
e.extra_compile_args.append("-Wall")
e.extra_compile_args.append("-Werror")
for e in self.extensions:
if self.with_sse:
e.define_macros.append(("ENABLE_CPU_SSE_BACKEND", None))
if self.with_opengl:
e.define_macros.append(("ENABLE_OPENGL_BACKEND", None))
e.libraries.append("X11")
e.libraries.append("GL")
e.libraries.append("GLEW")
# build in place, and in the build/ tree
self.inplace = False
build_ext.build_extensions(self)
self.inplace = True
build_ext.build_extensions(self)
def build_extensions(self):
if self.compiler.compiler_type == 'mingw32':
# Dirty hack to avoid linking with more than one C runtime when using MinGW
# Note that this hack forces the compilation to use the old MSVCT
self.compiler.dll_libraries = [lib for lib in self.compiler.dll_libraries if not lib.startswith('msvcr')]
self.force = self.libuv_force_fetch or self.libuv_clean_compile
if self.compiler.compiler_type == 'msvc':
self.libuv_lib = os.path.join(self.libuv_dir, 'Release', 'lib', 'libuv.lib')
else:
self.libuv_lib = os.path.join(self.libuv_dir, 'libuv.a')
self.get_libuv()
# Set compiler options
if self.compiler.compiler_type == 'mingw32':
self.compiler.add_library_dir(self.libuv_dir)
self.compiler.add_library('uv')
else:
self.extensions[0].extra_objects.extend([self.libuv_lib])
self.compiler.add_include_dir(os.path.join(self.libuv_dir, 'include'))
if sys.platform.startswith('linux'):
self.compiler.add_library('rt')
elif sys.platform == 'darwin':
self.extensions[0].extra_link_args.extend(['-framework', 'CoreServices'])
elif sys.platform == 'win32':
if self.compiler.compiler_type == 'msvc':
self.extensions[0].extra_link_args.extend(['/NODEFAULTLIB:libcmt', '/LTCG'])
self.compiler.add_library('advapi32')
self.compiler.add_library('iphlpapi')
self.compiler.add_library('psapi')
self.compiler.add_library('ws2_32')
build_ext.build_extensions(self)
def build_extensions(self):
self.compiler.define_macro('HAVE_CONFIG_H', 1)
self.compiler.add_include_dir(os.path.join(self.cares_dir, 'src'))
if sys.platform != 'win32':
self.compiler.define_macro('_LARGEFILE_SOURCE', 1)
self.compiler.define_macro('_FILE_OFFSET_BITS', 64)
if sys.platform.startswith('linux'):
self.compiler.add_include_dir(os.path.join(self.cares_dir, 'src/config_linux'))
self.compiler.add_library('dl')
self.compiler.add_library('rt')
elif sys.platform == 'darwin':
self.compiler.add_include_dir(os.path.join(self.cares_dir, 'src/config_darwin'))
self.compiler.define_macro('_DARWIN_USE_64_BIT_INODE', 1)
elif sys.platform.startswith('freebsd'):
self.compiler.add_include_dir(os.path.join(self.cares_dir, 'src/config_freebsd'))
self.compiler.add_library('kvm')
elif sys.platform.startswith('dragonfly'):
self.compiler.add_include_dir(os.path.join(self.cares_dir, 'src/config_freebsd'))
elif sys.platform.startswith('netbsd'):
self.compiler.add_include_dir(os.path.join(self.cares_dir, 'src/config_netbsd'))
elif sys.platform.startswith('openbsd'):
self.compiler.add_include_dir(os.path.join(self.cares_dir, 'src/config_openbsd'))
elif sys.platform.startswith('sunos'):
self.compiler.add_library('socket')
self.compiler.add_library('nsl')
self.compiler.add_library('lkstat')
elif sys.platform == 'win32':
self.compiler.add_include_dir(os.path.join(self.cares_dir, 'src/config_win32'))
self.extensions[0].extra_link_args = ['/NODEFAULTLIB:libcmt']
self.compiler.add_library('advapi32')
self.compiler.add_library('iphlpapi')
self.compiler.add_library('psapi')
self.compiler.add_library('ws2_32')
self.extensions[0].sources += cares_sources
build_ext.build_extensions(self)
def build_extensions(self):
# if builing from c files, don't need to
# generate template output
if cython:
for pxifile in _pxifiles:
# build pxifiles first, template extension must be .pxi.in
assert pxifile.endswith('.pxi.in')
outfile = pxifile[:-3]
if (os.path.exists(outfile) and
os.stat(pxifile).st_mtime < os.stat(outfile).st_mtime):
# if .pxi.in is not updated, no need to output .pxi
continue
with open(pxifile, "r") as f:
tmpl = f.read()
pyxcontent = tempita.sub(tmpl)
with open(outfile, "w") as f:
f.write(pyxcontent)
numpy_incl = pkg_resources.resource_filename('numpy', 'core/include')
for ext in self.extensions:
if (hasattr(ext, 'include_dirs') and
numpy_incl not in ext.include_dirs):
ext.include_dirs.append(numpy_incl)
_build_ext.build_extensions(self)
def build_extensions(self):
# Add a -std=c++11 or similar flag if needed
ct = self.compiler.compiler_type
if ct == 'unix' and not supports_cxx11(self.compiler):
cxx11_flag = None
if supports_cxx11(self.compiler, '-std=c++11'):
cxx11_flag = '-std=c++11'
if cxx11_flag:
for ext in self.extensions:
# gdalconst builds as a .c file
if ext.name != 'osgeo._gdalconst':
ext.extra_compile_args += [cxx11_flag]
# Adding arch flags here if OS X and compiler is clang
if sys.platform == 'darwin' and [int(x) for x in os.uname()[2].split('.')] >= [11, 0, 0]:
# since MacOS X 10.9, clang no longer accepts -mno-fused-madd
# extra_compile_args.append('-Qunused-arguments')
clang_flag = '-Wno-error=unused-command-line-argument-hard-error-in-future'
if has_flag(self.compiler, clang_flag):
ext.extra_compile_args += [clang_flag]
else:
clang_flag = '-Wno-error=unused-command-line-argument'
if has_flag(self.compiler, clang_flag):
ext.extra_compile_args += [clang_flag]
build_ext.build_extensions(self)
def build_extensions(self):
if newer("src/docstrings.h.in", "src/docstrings.h"):
updateDocHeader("src/docstrings.h.in", "src/docstrings.h")
for ext in self.extensions:
ext.include_dirs.append(self.boost_include_dir)
ext.include_dirs.append(self.timbl_include_dir)
ext.include_dirs.append(self.libxml2_include_dir)
ext.library_dirs.append(self.timbl_library_dir)
ext.library_dirs.append(self.boost_library_dir)
ext.library_dirs.append(self.libxml2_library_dir)
compile_args = ["-std=c++11"]
if platform.system() == "Darwin":
compile_args.append("-stdlib=libc++")
ext.extra_compile_args.extend(compile_args)
if isinstance(self.compiler, UnixCCompiler) and self.static_boost_python:
ext.extra_link_args.extend(
"-Wl,-Bstatic -l" + self.boostlib + " -Wl,-Bdynamic".split())
else:
ext.libraries.append(self.boostlib)
build_ext.build_extensions(self)
def build_extensions(self):
for _pxifile in _pxifiles:
# build pxifiles first, template extention must be .pxi.in
assert _pxifile.endswith(".pxi.in")
pxifile = pjoin(_pxipath, _pxifile)
outfile = pxifile[:-3]
if os.path.exists(outfile) and os.stat(pxifile).st_mtime < os.stat(outfile).st_mtime:
# if .pxi.in is not updated, no need to output .pxi
continue
with open(pxifile, "r") as f:
tmpl = f.read()
pyxcontent = tempita.sub(tmpl)
with open(outfile, "w") as f:
f.write(pyxcontent)
numpy_incl = pkg_resources.resource_filename("numpy", "core/include")
for ext in self.extensions:
if hasattr(ext, "include_dirs") and not numpy_incl in ext.include_dirs:
ext.include_dirs.append(numpy_incl)
_build_ext.build_extensions(self)
def build_extensions(self):
# python2.2 doesn't honor these, so we have to sneak them in
cxx = os.environ.get("CXX")
cc = os.environ.get("CC")
print "compiling with", cc
if cc:
self.compiler.preprocessor[0] = cc
self.compiler.compiler_so[0] = cc
self.compiler.compiler[0] = cc
if cc.find("33") > -1:
print "cc is old"
# rpm thinks we should have -mtune, but older gcc doesn't like it
cflags = os.environ.get("CFLAGS")
if cflags != None:
cflags = remove_mtune.sub("",cflags)
print "cflags", cflags
os.environ["CFLAGS"] = cflags
self.compiler.compiler = [
opt for opt in self.compiler.compiler \
if opt.find("-mtune") == -1 ]
self.compiler.compiler_so = [
opt for opt in self.compiler.compiler_so \
if opt.find("-mtune") == -1 ]
if cxx:
if hasattr(self.compiler, "compiler_cxx"):
self.compiler.compiler_cxx[0] = cxx
self.compiler.linker_so[0] = cxx
build_ext.build_extensions(self)
def build_extensions(self):
# Get 64-bitness
c = self.compiler.compiler_type
print "Compiling with %s (64bit=%s)" % (c, str(is_64bits))
# OpenMP build options
if enable_openmp:
if copt.has_key(c):
for e in self.extensions:
e.extra_compile_args = copt[ c ]
if lopt.has_key(c):
for e in self.extensions:
e.extra_link_args = lopt[ c ]
# Platform-specific build options
if platform_lopt.has_key(c):
for e in self.extensions:
e.extra_link_args = platform_lopt[ c ]
if platform_copt.has_key(c):
for e in self.extensions:
e.extra_compile_args = platform_copt[ c ]
build_ext.build_extensions(self)
def build_extensions(self):
global library_dirs, include_dirs, libraries
if WINDOWS:
# Detect the compiler so we can specify the correct command line switches
# and libraries
from distutils.cygwinccompiler import Mingw32CCompiler
extra_cc_args = []
if isinstance(self.compiler, Mingw32CCompiler):
# Compiler is Mingw32
freetds_dir = 'ming'
extra_cc_args = [
'-Wl,-allow-multiple-definition',
'-Wl,-subsystem,windows-mthreads',
'-mwindows',
'-Wl,--strip-all'
]
libraries = [
'libiconv', 'iconv',
'sybdb',
'ws2_32', 'wsock32', 'kernel32',
]
else:
# Assume compiler is Visual Studio
if sys.version_info >= (3, 5):
freetds_dir = 'vs2015'
elif sys.version_info >= (3, 3):
freetds_dir = 'vs2010'
else:
freetds_dir = 'vs2008'
# XXX: Decide and implement if we are going to allow linking in
# FreeTDS statically
if True:
libraries = [
'ct', 'sybdb',
'ws2_32', 'wsock32', 'kernel32', 'shell32',
'libeay32MD', 'ssleay32MD',
]
else:
libraries = [
'db-lib', 'tds',
'ws2_32', 'wsock32', 'kernel32', 'shell32',
'libeay{}MD'.format(BITNESS),
'ssleay{}MD'.format(BITNESS),
]
FREETDS = fpath('freetds', '{0}_{1}'.format(freetds_dir, BITNESS))
suffix = '' if BITNESS == 32 else '64'
OPENSSL = fpath('openssl', 'lib{}'.format(suffix))
for e in self.extensions:
e.extra_compile_args.extend(extra_cc_args)
e.libraries.extend(libraries)
e.include_dirs.append(osp.join(FREETDS, 'include'))
e.library_dirs.append(osp.join(FREETDS, 'lib'))
e.library_dirs.append(OPENSSL)
else:
for e in self.extensions:
e.libraries.extend(libraries)
_build_ext.build_extensions(self)
def build_extensions(self):
# Init self.extra_compile_args
self.init_extra_compile_args()
# Modify default compiler settings
self.modify_compiler()
# Invoke base build_extensions()
build_ext.build_extensions(self)
def build_extensions(self):
numpy_incl = pkg_resources.resource_filename("numpy", "core/include")
for ext in self.extensions:
if hasattr(ext, "include_dirs") and not numpy_incl in ext.include_dirs:
ext.include_dirs.append(numpy_incl)
_build_ext.build_extensions(self)
def build_extensions(self):
if self.compiler.compiler_type == "mingw32":
# Dirty hack to avoid linking with more than one C runtime when using MinGW
self.compiler.dll_libraries = [lib for lib in self.compiler.dll_libraries if not lib.startswith("msvcr")]
self.force = self.libuv_force_fetch or self.libuv_clean_compile
self.get_libuv()
build_ext.build_extensions(self)
def build_extensions(self):
if self.compiler.compiler_type == 'mingw32':
# Dirty hack to avoid linking with more than one C runtime when using MinGW
self.compiler.dll_libraries = [lib for lib in self.compiler.dll_libraries if not lib.startswith('msvcr')]
self.force = self.cares_clean_compile
if self.compiler.compiler_type == 'msvc':
self.cares_lib = os.path.join(self.cares_dir, 'cares.lib')
else:
self.cares_lib = os.path.join(self.cares_dir, 'libcares.a')
self.build_cares()
# Set compiler options
if self.compiler.compiler_type == 'mingw32':
self.compiler.add_library_dir(self.cares_dir)
self.compiler.add_library('cares')
self.extensions[0].extra_objects = [self.cares_lib]
self.compiler.add_include_dir(os.path.join(self.cares_dir, 'src'))
if sys.platform.startswith('linux'):
self.compiler.add_library('rt')
elif sys.platform == 'win32':
if self.compiler.compiler_type == 'msvc':
self.extensions[0].extra_link_args = ['/NODEFAULTLIB:libcmt']
self.compiler.add_library('advapi32')
self.compiler.add_library('iphlpapi')
self.compiler.add_library('psapi')
self.compiler.add_library('ws2_32')
build_ext.build_extensions(self)
def build_extensions(self):
import tempfile
flags = try_to_add_compile_args()
f = tempfile.NamedTemporaryFile(suffix=".cpp", delete=True)
f.name
c = self.compiler
ok_flags = []
with stdout_redirected(), merged_stderr_stdout():
for flag in flags:
try:
c.compile([f.name], extra_postargs=ok_flags + [flag])
except CompileError:
pass
else:
ok_flags.append(flag)
for ext in self.extensions:
ext.extra_compile_args += ok_flags
f.close()
build_ext.build_extensions(self)
def build_extensions(self):
if newer("src/docstrings.h.in", "src/docstrings.h"):
updateDocHeader("src/docstrings.h.in", "src/docstrings.h")
for ext in self.extensions:
ext.include_dirs.append(self.boost_include_dir)
ext.include_dirs.append(self.timbl_include_dir)
ext.include_dirs.append(self.libxml2_include_dir)
ext.library_dirs.append(self.timbl_library_dir)
ext.library_dirs.append(self.boost_library_dir)
ext.library_dirs.append(self.libxml2_library_dir)
pyversion = sys.version[0:3][0] + sys.version[0:3][2] # returns something like 32
if os.path.exists(self.boost_library_dir + "/libboost_python-py" + pyversion + ".so"):
boostlib = "boost_python-py" + pyversion
elif os.path.exists(self.boost_library_dir + "/libboost_python3.so"):
boostlib = "boost_python3"
elif os.path.exists(self.boost_library_dir + "/libboost_python.so"):
# probably goes wrong if this is for python 2!
boostlib = "boost_python"
elif os.path.exists(self.boost_library_dir + "/libboost_python3.dylib"): # Mac OS X
boostlib = "boost_python3"
elif os.path.exists(self.boost_library_dir + "/libboost_python.dylib"): # Mac OS X
# probably goes wrong if this is for python 2!
boostlib = "boost_python"
else:
print("Unable to find boost library", file=sys.stderr)
sys.exit(65)
if isinstance(self.compiler, UnixCCompiler) and self.static_boost_python:
ext.extra_link_args.extend("-Wl,-Bstatic -l" + boostlib + " -Wl,-Bdynamic".split())
else:
ext.libraries.append(boostlib)
build_ext.build_extensions(self)
def build_extensions(self):
if self.compiler.compiler_type == 'mingw32':
# Dirty hack to avoid linking with more than one C runtime when using MinGW
self.compiler.dll_libraries = [lib for lib in self.compiler.dll_libraries if not lib.startswith('msvcr')]
self.force = self.cares_clean_compile
self.build_cares()
build_ext.build_extensions(self)
def build_extensions(self):
# Detect which modules should be compiled
self.detect_modules()
# Tweak compiler options
if self.compiler.compiler_type in ("unix", "cygwin", "mingw32"):
# Make assert() statements always work
self.__remove_compiler_option("-DNDEBUG")
if USE_GCOV: # TODO - move this to configure.ac
self.__add_compiler_option("-fprofile-arcs")
self.__add_compiler_option("-ftest-coverage")
self.compiler.libraries += ["gcov"]
# Python 2.1 and 2.2 don't respect the LDFLAGS environment variable. Hack it.
if sys.version_info < (2, 3, "final", 0):
if os.environ.get("LDFLAGS"): # Set from ./buildenv (ultimately provided by autoconf)
for opt in os.environ["LDFLAGS"].split(" "):
opt = opt.strip()
if not opt:
continue
self.compiler.linker_so.append(opt)
# Call the superclass's build_extensions method
build_ext.build_extensions(self)
def build_extensions(self):
c = self.compiler.compiler_type
if c == "msvc":
# customize the build options for this compilier
for e in self.extensions:
e.extra_link_args.append("/MANIFEST")
build_ext.build_extensions(self)
def build_extensions(self):
if build_concurrency > 1:
self.check_extensions_list(self.extensions)
import multiprocessing.pool
multiprocessing.pool.ThreadPool(processes=build_concurrency).map(self.build_extension, self.extensions)
else:
build_ext.build_extensions(self)
def build_extensions(self):
customize_compiler(self.compiler)
customize_linker(self.compiler)
os.system('swig {0} -o '.format(str.join(' ', config.swig_flags)) + \
'rksolver/rksolver_wrap.cpp rksolver/rksolver.i')
build_ext.build_extensions(self)
def build_extensions(self):
for e in self.extensions:
e.extra_compile_args = compile_options.get(
self.compiler.compiler_type, compile_options['other'])
for e in self.extensions:
e.extra_link_args = link_options.get(
self.compiler.compiler_type, link_options['other'])
build_ext.build_extensions(self)
def build_extensions(self):
CC = sysconfig.get_config_var("CC")
if self.compiler.compiler_type == 'unix' and ( 'gcc' in CC or 'g++' in CC):
for e in self.extensions:
e.extra_compile_args.append( '-Wno-strict-prototypes' )
build_ext.build_extensions(self)
def build_extensions(self):
c = self.compiler.compiler_type
if copt.has_key(c):
for e in self.extensions:
e.extra_compile_args = copt[ c ]
if lopt.has_key(c):
for e in self.extensions:
e.extra_link_args = lopt[ c ]
build_ext.build_extensions(self)
def build_extensions(self):
# Disable any assembly in libtomcrypt files
self.compiler.define_macro("LTC_NO_ASM")
# Detect which modules should be compiled
self.detect_modules()
# Call the superclass's build_extensions method
build_ext.build_extensions(self)
def build_extensions(self):
c = self.compiler.compiler_type
if c in platform_cflags.keys():
for e in self.extensions:
e.extra_compile_args = platform_cflags[c]
if c in platform_ldflags.keys():
for e in self.extensions:
e.extra_link_args = platform_ldflags[c]
build_ext.build_extensions(self)
def build_extensions(self):
c = self.compiler.compiler_type
if c in copt:
for e in self.extensions:
e.extra_compile_args = copt[c]
if c in lopt:
for e in self.extensions:
e.extra_link_args = lopt[c]
build_ext.build_extensions(self)
def build_extensions(self):
cc = self.compiler.compiler_type
if cc == 'mingw32':
for e in self.extensions:
# e.extra_compile_args = []
e.extra_link_args = ['-static-libgcc', '-static-libstdc++']
build_ext.build_extensions(self)
def build_extensions(self):
if not self.use_system_fitsio:
# Use the compiler for building python to build cfitsio
# for maximized compatibility.
# there is some issue with non-aligned data with optimizations
# set to '-O3' on some versions of gcc. It appears to be
# a disagreement between gcc 4 and gcc 5
CCold = self.compiler.compiler
CC = []
for val in CCold:
if val == '-O3':
print("replacing '-O3' with '-O2' to address " "gcc bug")
val = '-O2'
CC.append(val)
self.configure_cfitsio(
CC=CC,
ARCHIVE=self.compiler.archiver,
RANLIB=self.compiler.ranlib,
)
# If configure detected bzlib.h, we have to link to libbz2
if '-DHAVE_BZIP2=1' in open(
os.path.join(self.cfitsio_build_dir, 'Makefile')).read():
self.compiler.add_library('bz2')
if '-DCFITSIO_HAVE_CURL=1' in open(
os.path.join(self.cfitsio_build_dir, 'Makefile')).read():
self.compiler.add_library('curl')
self.compile_cfitsio()
# link against the .a library in cfitsio;
# It should have been a 'static' library of relocatable objects (-fPIC),
# since we use the python compiler flags
link_objects = glob.glob(
os.path.join(self.cfitsio_build_dir, '*.a'))
self.compiler.set_link_objects(link_objects)
# Ultimate hack: append the .a files to the dependency list
# so they will be properly rebuild if cfitsio source is updated.
for ext in self.extensions:
ext.depends += link_objects
else:
self.compiler.add_library('cfitsio')
# Check if system cfitsio was compiled with bzip2 and/or curl
if self.check_system_cfitsio_objects('bzip2'):
self.compiler.add_library('bz2')
if self.check_system_cfitsio_objects('curl_'):
self.compiler.add_library('curl')
# fitsio requires libm as well.
self.compiler.add_library('m')
# call the original build_extensions
build_ext.build_extensions(self)
def build_extensions(self):
global TCL_ROOT
library_dirs = []
include_dirs = []
add_directory(include_dirs, "libImaging")
#
# add platform directories
if sys.platform == "cygwin":
# pythonX.Y.dll.a is in the /usr/lib/pythonX.Y/config directory
add_directory(
library_dirs,
os.path.join("/usr/lib", "python%s" % sys.version[:3],
"config"))
elif sys.platform == "darwin":
# attempt to make sure we pick freetype2 over other versions
add_directory(include_dirs, "/sw/include/freetype2")
add_directory(include_dirs, "/sw/lib/freetype2/include")
# fink installation directories
add_directory(library_dirs, "/sw/lib")
add_directory(include_dirs, "/sw/include")
# darwin ports installation directories
add_directory(library_dirs, "/opt/local/lib")
add_directory(include_dirs, "/opt/local/include")
add_directory(library_dirs, "/usr/local/lib")
# FIXME: check /opt/stuff directories here?
prefix = sysconfig.get_config_var("prefix")
if prefix:
add_directory(library_dirs, os.path.join(prefix, "lib"))
add_directory(include_dirs, os.path.join(prefix, "include"))
#
# locate tkinter libraries
if _tkinter:
TCL_VERSION = _tkinter.TCL_VERSION[:3]
if _tkinter and not TCL_ROOT:
# we have Tkinter but the TCL_ROOT variable was not set;
# try to locate appropriate Tcl/Tk libraries
PYVERSION = sys.version[0] + sys.version[2]
TCLVERSION = TCL_VERSION[0] + TCL_VERSION[2]
roots = [
# common installation directories, mostly for Windows
# (for Unix-style platforms, we'll check in well-known
# locations later)
os.path.join("/py" + PYVERSION, "Tcl"),
os.path.join("/python" + PYVERSION, "Tcl"),
"/Tcl",
"/Tcl" + TCLVERSION,
"/Tcl" + TCL_VERSION,
os.path.join(os.environ.get("ProgramFiles", ""), "Tcl"),
]
for TCL_ROOT in roots:
TCL_ROOT = os.path.abspath(TCL_ROOT)
if os.path.isfile(os.path.join(TCL_ROOT, "include", "tk.h")):
# FIXME: use distutils logging (?)
print "--- using Tcl/Tk libraries at", TCL_ROOT
print "--- using Tcl/Tk version", TCL_VERSION
TCL_ROOT = libinclude(TCL_ROOT)
break
else:
TCL_ROOT = None
#
# add configured kits
for root in [FREETYPE_ROOT, JPEG_ROOT, TCL_ROOT, TIFF_ROOT, ZLIB_ROOT]:
if isinstance(root, type(())):
lib_root, include_root = root
else:
lib_root = include_root = root
add_directory(library_dirs, lib_root)
add_directory(include_dirs, include_root)
#
# add standard directories
add_directory(library_dirs, "/usr/local/lib")
add_directory(include_dirs, "/usr/local/include")
add_directory(library_dirs, "/usr/lib")
add_directory(include_dirs, "/usr/include")
#
# insert new dirs *before* default libs, to avoid conflicts
# between Python PYD stub libs and real libraries
self.compiler.library_dirs = library_dirs + self.compiler.library_dirs
self.compiler.include_dirs = include_dirs + self.compiler.include_dirs
#
# look for available libraries
class feature:
zlib = jpeg = tiff = freetype = tcl = tk = None
feature = feature()
if find_library_file(self, "z"):
feature.zlib = "z"
elif sys.platform == "win32" and find_library_file(self, "zlib"):
feature.zlib = "zlib" # alternative name
if find_library_file(self, "jpeg"):
feature.jpeg = "jpeg"
elif sys.platform == "win32" and find_library_file(self, "libjpeg"):
feature.jpeg = "libjpeg" # alternative name
if find_library_file(self, "tiff"):
feature.tiff = "tiff"
if find_library_file(self, "freetype"):
# look for freetype2 include files
freetype_version = 0
for dir in self.compiler.include_dirs:
if os.path.isfile(os.path.join(dir, "ft2build.h")):
freetype_version = 21
dir = os.path.join(dir, "freetype2")
break
dir = os.path.join(dir, "freetype2")
if os.path.isfile(os.path.join(dir, "ft2build.h")):
freetype_version = 21
break
if os.path.isdir(os.path.join(dir, "freetype")):
freetype_version = 20
break
if freetype_version:
feature.freetype = "freetype"
feature.freetype_version = freetype_version
if dir:
add_directory(self.compiler.include_dirs, dir, 0)
if _tkinter:
# the library names may vary somewhat (e.g. tcl84 or tcl8.4)
version = TCL_VERSION[0] + TCL_VERSION[2]
if find_library_file(self, "tcl" + version):
feature.tcl = "tcl" + version
elif find_library_file(self, "tcl" + TCL_VERSION):
feature.tcl = "tcl" + TCL_VERSION
if find_library_file(self, "tk" + version):
feature.tk = "tk" + version
elif find_library_file(self, "tk" + TCL_VERSION):
feature.tk = "tk" + TCL_VERSION
#
# core library
files = ["_imaging.c"]
for file in IMAGING:
files.append(file + ".c")
for file in LIBIMAGING:
files.append(os.path.join("libImaging", file + ".c"))
libs = []
defs = []
if feature.jpeg:
libs.append(feature.jpeg)
defs.append(("HAVE_LIBJPEG", None))
if feature.zlib:
libs.append(feature.zlib)
defs.append(("HAVE_LIBZ", None))
if sys.platform == "win32":
libs.extend(["kernel32", "user32", "gdi32"])
if struct.unpack("h", "\0\1")[0] == 1:
defs.append(("WORDS_BIGENDIAN", None))
exts = [(Extension("_imaging",
files,
libraries=libs,
define_macros=defs))]
#
# additional libraries
if feature.freetype:
defs = []
if feature.freetype_version == 20:
defs.append(("USE_FREETYPE_2_0", None))
exts.append(
Extension("_imagingft", ["_imagingft.c"],
libraries=["freetype"],
define_macros=defs))
if os.path.isfile("_imagingtiff.c") and feature.tiff:
exts.append(
Extension("_imagingtiff", ["_imagingtiff.c"],
libraries=["tiff"]))
if sys.platform == "darwin":
# locate Tcl/Tk frameworks
frameworks = []
framework_roots = [
"/Library/Frameworks", "/System/Library/Frameworks"
]
for root in framework_roots:
if (os.path.exists(os.path.join(root, "Tcl.framework")) and
os.path.exists(os.path.join(root, "Tk.framework"))):
print "--- using frameworks at", root
frameworks = ["-framework", "Tcl", "-framework", "Tk"]
dir = os.path.join(root, "Tcl.framework", "Headers")
add_directory(self.compiler.include_dirs, dir, 0)
dir = os.path.join(root, "Tk.framework", "Headers")
add_directory(self.compiler.include_dirs, dir, 1)
break
if frameworks:
exts.append(
Extension("_imagingtk", ["_imagingtk.c", "Tk/tkImaging.c"],
extra_compile_args=frameworks,
extra_link_args=frameworks))
feature.tcl = feature.tk = 1 # mark as present
elif feature.tcl and feature.tk:
exts.append(
Extension("_imagingtk", ["_imagingtk.c", "Tk/tkImaging.c"],
libraries=[feature.tcl, feature.tk]))
if os.path.isfile("_imagingmath.c"):
exts.append(Extension("_imagingmath", ["_imagingmath.c"]))
self.extensions[:] = exts
build_ext.build_extensions(self)
#
# sanity and security checks
unsafe_zlib = None
if feature.zlib:
unsafe_zlib = self.check_zlib_version(self.compiler.include_dirs)
self.summary_report(feature, unsafe_zlib)
def build_extensions(self):
# Detect which modules should be compiled
self.detect_modules()
# Remove modules that are present on the disabled list
self.extensions = [
ext for ext in self.extensions
if ext.name not in disabled_module_list
]
# Fix up the autodetected modules, prefixing all the source files
# with Modules/ and adding Python's include directory to the path.
(srcdir, ) = sysconfig.get_config_vars('srcdir')
# Figure out the location of the source code for extension modules
moddir = os.path.join(os.getcwd(), srcdir, 'Modules')
moddir = os.path.normpath(moddir)
srcdir, tail = os.path.split(moddir)
srcdir = os.path.normpath(srcdir)
moddir = os.path.normpath(moddir)
# Fix up the paths for scripts, too
self.distribution.scripts = [
os.path.join(srcdir, filename)
for filename in self.distribution.scripts
]
for ext in self.extensions[:]:
ext.sources = [
os.path.join(moddir, filename) for filename in ext.sources
]
ext.include_dirs.append('.') # to get config.h
ext.include_dirs.append(os.path.join(srcdir, './Include'))
# If a module has already been built statically,
# don't build it here
if ext.name in sys.builtin_module_names:
self.extensions.remove(ext)
# Parse Modules/Setup to figure out which modules are turned
# on in the file.
input = text_file.TextFile('Modules/Setup', join_lines=1)
remove_modules = []
while 1:
line = input.readline()
if not line: break
line = line.split()
remove_modules.append(line[0])
input.close()
for ext in self.extensions[:]:
if ext.name in remove_modules:
self.extensions.remove(ext)
# When you run "make CC=altcc" or something similar, you really want
# those environment variables passed into the setup.py phase. Here's
# a small set of useful ones.
compiler = os.environ.get('CC')
linker_so = os.environ.get('LDSHARED')
args = {}
# unfortunately, distutils doesn't let us provide separate C and C++
# compilers
if compiler is not None:
args['compiler_so'] = compiler
if linker_so is not None:
args['linker_so'] = linker_so + ' -shared'
self.compiler.set_executables(**args)
build_ext.build_extensions(self)
def build_extensions(self):
c = self.compiler
if c.compiler_type == 'unix' and 'gcc' in c.compiler:
for e in self.extensions:
e.extra_compile_args=['-std=c99']
build_ext.build_extensions(self)
def build_extensions(self):
library_dirs = []
include_dirs = []
_add_directory(include_dirs, "src/libImaging")
pkg_config = None
if _cmd_exists('pkg-config'):
pkg_config = _pkg_config
#
# add configured kits
for root_name, lib_name in dict(JPEG_ROOT="libjpeg",
JPEG2K_ROOT="libopenjp2",
TIFF_ROOT=("libtiff-5", "libtiff-4"),
ZLIB_ROOT="zlib",
FREETYPE_ROOT="freetype2",
LCMS_ROOT="lcms2",
IMAGEQUANT_ROOT="libimagequant"
).items():
root = globals()[root_name]
if root is None and pkg_config:
if isinstance(lib_name, tuple):
for lib_name2 in lib_name:
_dbg('Looking for `%s` using pkg-config.' % lib_name2)
root = pkg_config(lib_name2)
if root:
break
else:
_dbg('Looking for `%s` using pkg-config.' % lib_name)
root = pkg_config(lib_name)
if isinstance(root, tuple):
lib_root, include_root = root
else:
lib_root = include_root = root
_add_directory(library_dirs, lib_root)
_add_directory(include_dirs, include_root)
# respect CFLAGS/LDFLAGS
for k in ('CFLAGS', 'LDFLAGS'):
if k in os.environ:
for match in re.finditer(r'-I([^\s]+)', os.environ[k]):
_add_directory(include_dirs, match.group(1))
for match in re.finditer(r'-L([^\s]+)', os.environ[k]):
_add_directory(library_dirs, match.group(1))
# include, rpath, if set as environment variables:
for k in ('C_INCLUDE_PATH', 'CPATH', 'INCLUDE'):
if k in os.environ:
for d in os.environ[k].split(os.path.pathsep):
_add_directory(include_dirs, d)
for k in ('LD_RUN_PATH', 'LIBRARY_PATH', 'LIB'):
if k in os.environ:
for d in os.environ[k].split(os.path.pathsep):
_add_directory(library_dirs, d)
prefix = sysconfig.get_config_var("prefix")
if prefix:
_add_directory(library_dirs, os.path.join(prefix, "lib"))
_add_directory(include_dirs, os.path.join(prefix, "include"))
#
# add platform directories
if self.disable_platform_guessing:
pass
elif sys.platform == "cygwin":
# pythonX.Y.dll.a is in the /usr/lib/pythonX.Y/config directory
_add_directory(library_dirs,
os.path.join("/usr/lib", "python%s" %
sys.version[:3], "config"))
elif sys.platform == "darwin":
# attempt to make sure we pick freetype2 over other versions
_add_directory(include_dirs, "/sw/include/freetype2")
_add_directory(include_dirs, "/sw/lib/freetype2/include")
# fink installation directories
_add_directory(library_dirs, "/sw/lib")
_add_directory(include_dirs, "/sw/include")
# darwin ports installation directories
_add_directory(library_dirs, "/opt/local/lib")
_add_directory(include_dirs, "/opt/local/include")
# if Homebrew is installed, use its lib and include directories
try:
prefix = subprocess.check_output(['brew', '--prefix']).strip(
).decode('latin1')
except Exception:
# Homebrew not installed
prefix = None
ft_prefix = None
if prefix:
# add Homebrew's include and lib directories
_add_directory(library_dirs, os.path.join(prefix, 'lib'))
_add_directory(include_dirs, os.path.join(prefix, 'include'))
ft_prefix = os.path.join(prefix, 'opt', 'freetype')
if ft_prefix and os.path.isdir(ft_prefix):
# freetype might not be linked into Homebrew's prefix
_add_directory(library_dirs, os.path.join(ft_prefix, 'lib'))
_add_directory(include_dirs,
os.path.join(ft_prefix, 'include'))
else:
# fall back to freetype from XQuartz if
# Homebrew's freetype is missing
_add_directory(library_dirs, "/usr/X11/lib")
_add_directory(include_dirs, "/usr/X11/include")
elif sys.platform.startswith("linux"):
arch_tp = (plat.processor(), plat.architecture()[0])
# This should be correct on debian derivatives.
if os.path.exists('/etc/debian_version'):
# If this doesn't work, don't just silently patch
# downstream because it's going to break when people
# try to build pillow from source instead of
# installing from the system packages.
self.add_multiarch_paths()
elif arch_tp == ("x86_64", "32bit"):
# Special Case: 32-bit build on 64-bit machine.
_add_directory(library_dirs, "/usr/lib/i386-linux-gnu")
else:
libdirs = {
'x86_64': ["/lib64", "/usr/lib64",
"/usr/lib/x86_64-linux-gnu"],
'64bit': ["/lib64", "/usr/lib64",
"/usr/lib/x86_64-linux-gnu"],
'i386': ["/usr/lib/i386-linux-gnu"],
'i686': ["/usr/lib/i386-linux-gnu"],
'32bit': ["/usr/lib/i386-linux-gnu"],
'aarch64': ["/usr/lib64", "/usr/lib/aarch64-linux-gnu"],
'arm': ["/usr/lib/arm-linux-gnueabi"],
'armv71': ["/usr/lib/arm-linux-gnueabi"],
'armv7l': ["/usr/lib"],
'ppc64': ["/usr/lib64", "/usr/lib/ppc64-linux-gnu",
"/usr/lib/powerpc64-linux-gnu"],
'ppc64le': ["/usr/lib64"],
'ppc': ["/usr/lib/ppc-linux-gnu",
"/usr/lib/powerpc-linux-gnu"],
's390x': ["/usr/lib64", "/usr/lib/s390x-linux-gnu"],
's390': ["/usr/lib/s390-linux-gnu"],
}
for platform_ in arch_tp:
dirs = libdirs.get(platform_, None)
if not dirs:
continue
for path in dirs:
_add_directory(library_dirs, path)
break
else:
raise ValueError(
"Unable to identify Linux platform: `%s`" % platform_)
# termux support for android.
# system libraries (zlib) are installed in /system/lib
# headers are at $PREFIX/include
# user libs are at $PREFIX/lib
if os.environ.get('ANDROID_ROOT', None):
_add_directory(library_dirs,
os.path.join(os.environ['ANDROID_ROOT'],
'lib'))
elif sys.platform.startswith("gnu"):
self.add_multiarch_paths()
elif sys.platform.startswith("freebsd"):
_add_directory(library_dirs, "/usr/local/lib")
_add_directory(include_dirs, "/usr/local/include")
elif sys.platform.startswith("netbsd"):
_add_directory(library_dirs, "/usr/pkg/lib")
_add_directory(include_dirs, "/usr/pkg/include")
elif sys.platform.startswith("sunos5"):
_add_directory(library_dirs, "/opt/local/lib")
_add_directory(include_dirs, "/opt/local/include")
# FIXME: check /opt/stuff directories here?
# standard locations
if not self.disable_platform_guessing:
_add_directory(library_dirs, "/usr/local/lib")
_add_directory(include_dirs, "/usr/local/include")
_add_directory(library_dirs, "/usr/lib")
_add_directory(include_dirs, "/usr/include")
# alpine, at least
_add_directory(library_dirs, "/lib")
# on Windows, look for the OpenJPEG libraries in the location that
# the official installer puts them
if sys.platform == "win32":
program_files = os.environ.get('ProgramFiles', '')
best_version = (0, 0)
best_path = None
for name in os.listdir(program_files):
if name.startswith('OpenJPEG '):
version = tuple(int(x) for x in
name[9:].strip().split('.'))
if version > best_version:
best_version = version
best_path = os.path.join(program_files, name)
if best_path:
_dbg('Adding %s to search list', best_path)
_add_directory(library_dirs, os.path.join(best_path, 'lib'))
_add_directory(include_dirs,
os.path.join(best_path, 'include'))
#
# insert new dirs *before* default libs, to avoid conflicts
# between Python PYD stub libs and real libraries
self.compiler.library_dirs = library_dirs + self.compiler.library_dirs
self.compiler.include_dirs = include_dirs + self.compiler.include_dirs
#
# look for available libraries
feature = self.feature
if feature.want('zlib'):
_dbg('Looking for zlib')
if _find_include_file(self, "zlib.h"):
if _find_library_file(self, "z"):
feature.zlib = "z"
elif (sys.platform == "win32" and
_find_library_file(self, "zlib")):
feature.zlib = "zlib" # alternative name
if feature.want('jpeg'):
_dbg('Looking for jpeg')
if _find_include_file(self, "jpeglib.h"):
if _find_library_file(self, "jpeg"):
feature.jpeg = "jpeg"
elif (sys.platform == "win32" and
_find_library_file(self, "libjpeg")):
feature.jpeg = "libjpeg" # alternative name
feature.openjpeg_version = None
if feature.want('jpeg2000'):
_dbg('Looking for jpeg2000')
best_version = None
best_path = None
# Find the best version
for directory in self.compiler.include_dirs:
_dbg('Checking for openjpeg-#.# in %s', directory)
try:
listdir = os.listdir(directory)
except Exception:
# WindowsError, FileNotFoundError
continue
for name in listdir:
if name.startswith('openjpeg-') and \
os.path.isfile(os.path.join(directory, name,
'openjpeg.h')):
_dbg('Found openjpeg.h in %s/%s', (directory, name))
version = tuple(int(x) for x in name[9:].split('.'))
if best_version is None or version > best_version:
best_version = version
best_path = os.path.join(directory, name)
_dbg('Best openjpeg version %s so far in %s',
(best_version, best_path))
if best_version and _find_library_file(self, 'openjp2'):
# Add the directory to the include path so we can include
# <openjpeg.h> rather than having to cope with the versioned
# include path
# FIXME (melvyn-sopacua):
# At this point it's possible that best_path is already in
# self.compiler.include_dirs. Should investigate how that is
# possible.
_add_directory(self.compiler.include_dirs, best_path, 0)
feature.jpeg2000 = 'openjp2'
feature.openjpeg_version = '.'.join(str(x) for x in
best_version)
if feature.want('imagequant'):
_dbg('Looking for imagequant')
if _find_include_file(self, 'libimagequant.h'):
if _find_library_file(self, "imagequant"):
feature.imagequant = "imagequant"
elif _find_library_file(self, "libimagequant"):
feature.imagequant = "libimagequant"
if feature.want('tiff'):
_dbg('Looking for tiff')
if _find_include_file(self, 'tiff.h'):
if _find_library_file(self, "tiff"):
feature.tiff = "tiff"
if (sys.platform in ["win32", "darwin"] and
_find_library_file(self, "libtiff")):
feature.tiff = "libtiff"
if feature.want('freetype'):
_dbg('Looking for freetype')
if _find_library_file(self, "freetype"):
# look for freetype2 include files
freetype_version = 0
for subdir in self.compiler.include_dirs:
_dbg('Checking for include file %s in %s',
("ft2build.h", subdir))
if os.path.isfile(os.path.join(subdir, "ft2build.h")):
_dbg('Found %s in %s', ("ft2build.h", subdir))
freetype_version = 21
subdir = os.path.join(subdir, "freetype2")
break
subdir = os.path.join(subdir, "freetype2")
_dbg('Checking for include file %s in %s',
("ft2build.h", subdir))
if os.path.isfile(os.path.join(subdir, "ft2build.h")):
_dbg('Found %s in %s', ("ft2build.h", subdir))
freetype_version = 21
break
if freetype_version:
feature.freetype = "freetype"
if subdir:
_add_directory(self.compiler.include_dirs, subdir, 0)
if feature.want('lcms'):
_dbg('Looking for lcms')
if _find_include_file(self, "lcms2.h"):
if _find_library_file(self, "lcms2"):
feature.lcms = "lcms2"
elif _find_library_file(self, "lcms2_static"):
# alternate Windows name.
feature.lcms = "lcms2_static"
if feature.want('webp'):
_dbg('Looking for webp')
if (_find_include_file(self, "webp/encode.h") and
_find_include_file(self, "webp/decode.h")):
# In Google's precompiled zip it is call "libwebp":
if _find_library_file(self, "webp"):
feature.webp = "webp"
elif _find_library_file(self, "libwebp"):
feature.webp = "libwebp"
if feature.want('webpmux'):
_dbg('Looking for webpmux')
if (_find_include_file(self, "webp/mux.h") and
_find_include_file(self, "webp/demux.h")):
if (_find_library_file(self, "webpmux") and
_find_library_file(self, "webpdemux")):
feature.webpmux = "webpmux"
if (_find_library_file(self, "libwebpmux") and
_find_library_file(self, "libwebpdemux")):
feature.webpmux = "libwebpmux"
for f in feature:
if not getattr(feature, f) and feature.require(f):
if f in ('jpeg', 'zlib'):
raise RequiredDependencyException(f)
raise DependencyException(f)
#
# core library
files = ["src/_imaging.c"]
for src_file in _IMAGING:
files.append("src/" + src_file + ".c")
for src_file in _LIB_IMAGING:
files.append(os.path.join("src/libImaging", src_file + ".c"))
libs = []
defs = []
if feature.jpeg:
libs.append(feature.jpeg)
defs.append(("HAVE_LIBJPEG", None))
if feature.jpeg2000:
libs.append(feature.jpeg2000)
defs.append(("HAVE_OPENJPEG", None))
if sys.platform == "win32":
defs.append(("OPJ_STATIC", None))
if feature.zlib:
libs.append(feature.zlib)
defs.append(("HAVE_LIBZ", None))
if feature.imagequant:
libs.append(feature.imagequant)
defs.append(("HAVE_LIBIMAGEQUANT", None))
if feature.tiff:
libs.append(feature.tiff)
defs.append(("HAVE_LIBTIFF", None))
if sys.platform == "win32":
libs.extend(["kernel32", "user32", "gdi32"])
if struct.unpack("h", "\0\1".encode('ascii'))[0] == 1:
defs.append(("WORDS_BIGENDIAN", None))
if sys.platform == "win32" and not (PLATFORM_PYPY or PLATFORM_MINGW):
defs.append(("PILLOW_VERSION", '"\\"%s\\""' % PILLOW_VERSION))
else:
defs.append(("PILLOW_VERSION", '"%s"' % PILLOW_VERSION))
exts = [(Extension("PIL._imaging",
files,
libraries=libs,
define_macros=defs,
extra_compile_args=['-msse4']))]
#
# additional libraries
if feature.freetype:
libs = ["freetype"]
defs = []
exts.append(Extension(
"PIL._imagingft", ["src/_imagingft.c"], libraries=libs,
define_macros=defs))
if feature.lcms:
extra = []
if sys.platform == "win32":
extra.extend(["user32", "gdi32"])
exts.append(Extension("PIL._imagingcms",
["src/_imagingcms.c"],
libraries=[feature.lcms] + extra))
if feature.webp:
libs = [feature.webp]
defs = []
if feature.webpmux:
defs.append(("HAVE_WEBPMUX", None))
libs.append(feature.webpmux)
libs.append(feature.webpmux.replace('pmux', 'pdemux'))
exts.append(Extension("PIL._webp",
["src/_webp.c"],
libraries=libs,
define_macros=defs))
tk_libs = ['psapi'] if sys.platform == 'win32' else []
exts.append(Extension("PIL._imagingtk",
["src/_imagingtk.c", "src/Tk/tkImaging.c"],
include_dirs=['src/Tk'],
libraries=tk_libs))
exts.append(Extension("PIL._imagingmath", ["src/_imagingmath.c"]))
exts.append(Extension("PIL._imagingmorph", ["src/_imagingmorph.c"]))
self.extensions[:] = exts
build_ext.build_extensions(self)
#
# sanity checks
self.summary_report(feature)
def build_extensions(self):
if self.parallel is None and os.environ.get("SPACY_NUM_BUILD_JOBS") is not None:
self.parallel = int(os.environ.get("SPACY_NUM_BUILD_JOBS"))
build_ext_options.build_options(self)
build_ext.build_extensions(self)
def build_extensions(self):
_build_ext.build_extensions(self)
# lib_name -> ([used for, ...], is present)
libraries = {}
for extension in self.extensions:
if ((hasattr(extension, "library_manifest")
and callable(extension.library_manifest))):
for (library, used_for,
is_present) in extension.library_manifest():
if library in libraries:
libraries[library] = (libraries[library][0] +
[used_for], libraries[library][1]
and is_present)
else:
libraries[library] = ([used_for], is_present)
if ext_audiotools_cdio not in self.extensions:
libraries["libcdio"] = (["CDDA data extraction"], False)
if ext_audiotools_dvdaudio not in self.extensions:
libraries["libdvd-audio"] = (["DVD-Audio extraction"], False)
all_libraries_present = (set([l[1] for l in libraries.values()
]) == set([True]))
table = output_table()
header = table.row()
header.add_column("library", "right")
header.add_column(" ")
header.add_column("present?")
header.add_column(" ")
header.add_column("used for")
if not all_libraries_present:
header.add_column(" ")
header.add_column("download URL")
if not all_libraries_present:
table.divider_row(["-", " ", "-", " ", "-", " ", "-"])
else:
table.divider_row(["-", " ", "-", " ", "-"])
for library in sorted(libraries.keys()):
row = table.row()
row.add_column(library, "right")
row.add_column(" ")
row.add_column("yes" if libraries[library][1] else "no")
row.add_column(" ")
row.add_column(", ".join(libraries[library][0]))
if not all_libraries_present:
row.add_column(" ")
if not libraries[library][1]:
row.add_column(LIBRARY_URLS[library])
else:
row.add_column("")
try:
pkg_config = subprocess.Popen(["pkg-config", "--version"],
stdout=open(os.devnull, "wb"),
stderr=open(os.devnull, "wb"))
pkg_config_found = (pkg_config.wait() == 0)
except OSError:
pkg_config_found = False
print("=" * table.total_width())
print("Python Audio Tools %s Setup" % (VERSION))
print("=" * table.total_width())
if not pkg_config_found:
def add_row(table, text, alignment="left"):
row = table.row()
row.add_column("*")
row.add_column(text, alignment)
row.add_column("*")
table2 = output_table()
row = table2.row()
row.add_column("*")
row.add_column("*" * 60)
row.add_column("*")
add_row(table2, "pkg-config not found", "center")
add_row(table2, "some libraries may not be located automatically",
"center")
add_row(table2, "")
add_row(table2, " download pkg-config from:")
add_row(table2,
" http://www.freedesktop.org/wiki/Software/pkg-config/")
add_row(table2, "")
add_row(
table2, " or specify which libraries are available " +
"in \"setup.cfg\"")
row = table2.row()
row.add_column("*")
row.add_column("*" * 60)
row.add_column("*")
for row in table2.format():
print(row)
for row in table.format():
print(row)
print()
def build_extensions(self):
self.patch_compiler()
for ext in self.extensions:
self.patch_extension(ext)
build_ext.build_extensions(self)
def build_extensions(self):
"""Set up the build extensions."""
# TODO: move build customization here?
build_ext.build_extensions(self)
def build_extensions(self):
library_dirs = []
include_dirs = []
_add_directory(include_dirs, "libImaging")
pkg_config = None
if _cmd_exists('pkg-config'):
pkg_config = _pkg_config
#
# add configured kits
for root_name, lib_name in dict(JPEG_ROOT="libjpeg",
JPEG2K_ROOT="libopenjp2",
TIFF_ROOT=("libtiff-5", "libtiff-4"),
ZLIB_ROOT="zlib",
FREETYPE_ROOT="freetype2",
LCMS_ROOT="lcms2",
IMAGEQUANT_ROOT="libimagequant"
).items():
root = globals()[root_name]
if root is None and pkg_config:
if isinstance(lib_name, tuple):
for lib_name2 in lib_name:
_dbg('Looking for `%s` using pkg-config.' % lib_name2)
root = pkg_config(lib_name2)
if root:
break
else:
_dbg('Looking for `%s` using pkg-config.' % lib_name)
root = pkg_config(lib_name)
if isinstance(root, tuple):
lib_root, include_root = root
else:
lib_root = include_root = root
_add_directory(library_dirs, lib_root)
_add_directory(include_dirs, include_root)
# respect CFLAGS/LDFLAGS
for k in ('CFLAGS', 'LDFLAGS'):
if k in os.environ:
for match in re.finditer(r'-I([^\s]+)', os.environ[k]):
_add_directory(include_dirs, match.group(1))
for match in re.finditer(r'-L([^\s]+)', os.environ[k]):
_add_directory(library_dirs, match.group(1))
# include, rpath, if set as environment variables:
for k in ('C_INCLUDE_PATH', 'CPATH', 'INCLUDE'):
if k in os.environ:
for d in os.environ[k].split(os.path.pathsep):
_add_directory(include_dirs, d)
for k in ('LD_RUN_PATH', 'LIBRARY_PATH', 'LIB'):
if k in os.environ:
for d in os.environ[k].split(os.path.pathsep):
_add_directory(library_dirs, d)
prefix = sysconfig.get_config_var("prefix")
if prefix:
_add_directory(library_dirs, os.path.join(prefix, "lib"))
_add_directory(include_dirs, os.path.join(prefix, "include"))
#
# add platform directories
if self.disable_platform_guessing:
pass
elif sys.platform == "cygwin":
# pythonX.Y.dll.a is in the /usr/lib/pythonX.Y/config directory
_add_directory(library_dirs,
os.path.join("/usr/lib", "python%s" %
sys.version[:3], "config"))
elif sys.platform == "darwin":
# attempt to make sure we pick freetype2 over other versions
_add_directory(include_dirs, "/sw/include/freetype2")
_add_directory(include_dirs, "/sw/lib/freetype2/include")
# fink installation directories
_add_directory(library_dirs, "/sw/lib")
_add_directory(include_dirs, "/sw/include")
# darwin ports installation directories
_add_directory(library_dirs, "/opt/local/lib")
_add_directory(include_dirs, "/opt/local/include")
# if Homebrew is installed, use its lib and include directories
try:
prefix = subprocess.check_output(['brew', '--prefix']).strip(
).decode('latin1')
except:
# Homebrew not installed
prefix = None
ft_prefix = None
if prefix:
# add Homebrew's include and lib directories
_add_directory(library_dirs, os.path.join(prefix, 'lib'))
_add_directory(include_dirs, os.path.join(prefix, 'include'))
ft_prefix = os.path.join(prefix, 'opt', 'freetype')
if ft_prefix and os.path.isdir(ft_prefix):
# freetype might not be linked into Homebrew's prefix
_add_directory(library_dirs, os.path.join(ft_prefix, 'lib'))
_add_directory(include_dirs,
os.path.join(ft_prefix, 'include'))
else:
# fall back to freetype from XQuartz if
# Homebrew's freetype is missing
_add_directory(library_dirs, "/usr/X11/lib")
_add_directory(include_dirs, "/usr/X11/include")
elif sys.platform.startswith("linux"):
arch_tp = (plat.processor(), plat.architecture()[0])
if arch_tp == ("x86_64", "32bit"):
# 32-bit build on 64-bit machine.
_add_directory(library_dirs, "/usr/lib/i386-linux-gnu")
else:
for platform_ in arch_tp:
if not platform_:
continue
if platform_ in ["x86_64", "64bit"]:
_add_directory(library_dirs, "/lib64")
_add_directory(library_dirs, "/usr/lib64")
_add_directory(library_dirs,
"/usr/lib/x86_64-linux-gnu")
break
elif platform_ in ["i386", "i686", "32bit"]:
_add_directory(library_dirs, "/usr/lib/i386-linux-gnu")
break
elif platform_ in ["aarch64"]:
_add_directory(library_dirs, "/usr/lib64")
_add_directory(library_dirs,
"/usr/lib/aarch64-linux-gnu")
break
elif platform_ in ["arm", "armv7l"]:
_add_directory(library_dirs,
"/usr/lib/arm-linux-gnueabi")
break
elif platform_ in ["ppc64"]:
_add_directory(library_dirs, "/usr/lib64")
_add_directory(library_dirs,
"/usr/lib/ppc64-linux-gnu")
_add_directory(library_dirs,
"/usr/lib/powerpc64-linux-gnu")
break
elif platform_ in ["ppc"]:
_add_directory(library_dirs, "/usr/lib/ppc-linux-gnu")
_add_directory(library_dirs,
"/usr/lib/powerpc-linux-gnu")
break
elif platform_ in ["s390x"]:
_add_directory(library_dirs, "/usr/lib64")
_add_directory(library_dirs,
"/usr/lib/s390x-linux-gnu")
break
elif platform_ in ["s390"]:
_add_directory(library_dirs, "/usr/lib/s390-linux-gnu")
break
else:
raise ValueError(
"Unable to identify Linux platform: `%s`" % platform_)
# XXX Kludge. Above /\ we brute force support multiarch. Here we
# try Barry's more general approach. Afterward, something should
# work ;-)
self.add_multiarch_paths()
elif sys.platform.startswith("gnu"):
self.add_multiarch_paths()
elif sys.platform.startswith("freebsd"):
_add_directory(library_dirs, "/usr/local/lib")
_add_directory(include_dirs, "/usr/local/include")
elif sys.platform.startswith("netbsd"):
_add_directory(library_dirs, "/usr/pkg/lib")
_add_directory(include_dirs, "/usr/pkg/include")
elif sys.platform.startswith("sunos5"):
_add_directory(library_dirs, "/opt/local/lib")
_add_directory(include_dirs, "/opt/local/include")
# FIXME: check /opt/stuff directories here?
# standard locations
if not self.disable_platform_guessing:
_add_directory(library_dirs, "/usr/local/lib")
_add_directory(include_dirs, "/usr/local/include")
_add_directory(library_dirs, "/usr/lib")
_add_directory(include_dirs, "/usr/include")
# alpine, at least
_add_directory(library_dirs, "/lib")
# on Windows, look for the OpenJPEG libraries in the location that
# the official installer puts them
if sys.platform == "win32":
program_files = os.environ.get('ProgramFiles', '')
best_version = (0, 0)
best_path = None
for name in os.listdir(program_files):
if name.startswith('OpenJPEG '):
version = tuple(int(x) for x in name[9:].strip().split('.'))
if version > best_version:
best_version = version
best_path = os.path.join(program_files, name)
if best_path:
_dbg('Adding %s to search list', best_path)
_add_directory(library_dirs, os.path.join(best_path, 'lib'))
_add_directory(include_dirs,
os.path.join(best_path, 'include'))
#
# insert new dirs *before* default libs, to avoid conflicts
# between Python PYD stub libs and real libraries
self.compiler.library_dirs = library_dirs + self.compiler.library_dirs
self.compiler.include_dirs = include_dirs + self.compiler.include_dirs
#
# look for available libraries
feature = self.feature
if feature.want('zlib'):
_dbg('Looking for zlib')
if _find_include_file(self, "zlib.h"):
if _find_library_file(self, "z"):
feature.zlib = "z"
elif (sys.platform == "win32" and
_find_library_file(self, "zlib")):
feature.zlib = "zlib" # alternative name
if feature.want('jpeg'):
_dbg('Looking for jpeg')
if _find_include_file(self, "jpeglib.h"):
if _find_library_file(self, "jpeg"):
feature.jpeg = "jpeg"
elif (sys.platform == "win32" and
_find_library_file(self, "libjpeg")):
feature.jpeg = "libjpeg" # alternative name
feature.openjpeg_version = None
if feature.want('jpeg2000'):
_dbg('Looking for jpeg2000')
best_version = None
best_path = None
# Find the best version
for directory in self.compiler.include_dirs:
_dbg('Checking for openjpeg-#.# in %s', directory)
try:
listdir = os.listdir(directory)
except Exception:
# WindowsError, FileNotFoundError
continue
for name in listdir:
if name.startswith('openjpeg-') and \
os.path.isfile(os.path.join(directory, name,
'openjpeg.h')):
_dbg('Found openjpeg.h in %s/%s', (directory, name))
version = tuple(int(x) for x in name[9:].split('.'))
if best_version is None or version > best_version:
best_version = version
best_path = os.path.join(directory, name)
_dbg('Best openjpeg version %s so far in %s',
(best_version, best_path))
if best_version and _find_library_file(self, 'openjp2'):
# Add the directory to the include path so we can include
# <openjpeg.h> rather than having to cope with the versioned
# include path
_add_directory(self.compiler.include_dirs, best_path, 0)
feature.jpeg2000 = 'openjp2'
feature.openjpeg_version = '.'.join(str(x) for x in best_version)
if feature.want('imagequant'):
_dbg('Looking for imagequant')
if _find_include_file(self, 'libimagequant.h'):
if _find_library_file(self, "imagequant"):
feature.imagequant = "imagequant"
elif _find_library_file(self, "libimagequant"):
feature.imagequant = "libimagequant"
if feature.want('tiff'):
_dbg('Looking for tiff')
if _find_include_file(self, 'tiff.h'):
if _find_library_file(self, "tiff"):
feature.tiff = "tiff"
if sys.platform == "win32" and _find_library_file(self, "libtiff"):
feature.tiff = "libtiff"
if (sys.platform == "darwin" and
_find_library_file(self, "libtiff")):
feature.tiff = "libtiff"
if feature.want('freetype'):
_dbg('Looking for freetype')
if _find_library_file(self, "freetype"):
# look for freetype2 include files
freetype_version = 0
for subdir in self.compiler.include_dirs:
_dbg('Checking for include file %s in %s', ("ft2build.h", subdir))
if os.path.isfile(os.path.join(subdir, "ft2build.h")):
_dbg('Found %s in %s', ("ft2build.h", subdir))
freetype_version = 21
subdir = os.path.join(subdir, "freetype2")
break
subdir = os.path.join(subdir, "freetype2")
_dbg('Checking for include file %s in %s', ("ft2build.h", subdir))
if os.path.isfile(os.path.join(subdir, "ft2build.h")):
_dbg('Found %s in %s', ("ft2build.h", subdir))
freetype_version = 21
break
if freetype_version:
feature.freetype = "freetype"
feature.freetype_version = freetype_version
if subdir:
_add_directory(self.compiler.include_dirs, subdir, 0)
if feature.want('lcms'):
_dbg('Looking for lcms')
if _find_include_file(self, "lcms2.h"):
if _find_library_file(self, "lcms2"):
feature.lcms = "lcms2"
elif _find_library_file(self, "lcms2_static"):
# alternate Windows name.
feature.lcms = "lcms2_static"
if feature.want('webp'):
_dbg('Looking for webp')
if (_find_include_file(self, "webp/encode.h") and
_find_include_file(self, "webp/decode.h")):
# In Google's precompiled zip it is call "libwebp":
if _find_library_file(self, "webp"):
feature.webp = "webp"
elif _find_library_file(self, "libwebp"):
feature.webp = "libwebp"
if feature.want('webpmux'):
_dbg('Looking for webpmux')
if (_find_include_file(self, "webp/mux.h") and
_find_include_file(self, "webp/demux.h")):
if (_find_library_file(self, "webpmux") and
_find_library_file(self, "webpdemux")):
feature.webpmux = "webpmux"
if (_find_library_file(self, "libwebpmux") and
_find_library_file(self, "libwebpdemux")):
feature.webpmux = "libwebpmux"
for f in feature:
if not getattr(feature, f) and feature.require(f):
if f in ('jpeg', 'zlib'):
raise ValueError(
'%s is required unless explicitly disabled'
' using --disable-%s, aborting' % (f, f))
raise ValueError(
'--enable-%s requested but %s not found, aborting.' %
(f, f))
#
# core library
files = ["_imaging.c"]
for src_file in _IMAGING:
files.append(src_file + ".c")
for src_file in _LIB_IMAGING:
files.append(os.path.join("libImaging", src_file + ".c"))
libs = []
defs = []
if feature.jpeg:
libs.append(feature.jpeg)
defs.append(("HAVE_LIBJPEG", None))
if feature.jpeg2000:
libs.append(feature.jpeg2000)
defs.append(("HAVE_OPENJPEG", None))
if sys.platform == "win32":
defs.append(("OPJ_STATIC", None))
if feature.zlib:
libs.append(feature.zlib)
defs.append(("HAVE_LIBZ", None))
if feature.imagequant:
libs.append(feature.imagequant)
defs.append(("HAVE_LIBIMAGEQUANT", None))
if feature.tiff:
libs.append(feature.tiff)
defs.append(("HAVE_LIBTIFF", None))
if sys.platform == "win32":
libs.extend(["kernel32", "user32", "gdi32"])
if struct.unpack("h", "\0\1".encode('ascii'))[0] == 1:
defs.append(("WORDS_BIGENDIAN", None))
exts = [(Extension("PIL._imaging",
files,
libraries=libs,
define_macros=defs))]
#
# additional libraries
if feature.freetype:
exts.append(Extension("PIL._imagingft",
["_imagingft.c"],
libraries=["freetype"]))
if feature.lcms:
extra = []
if sys.platform == "win32":
extra.extend(["user32", "gdi32"])
exts.append(Extension("PIL._imagingcms",
["_imagingcms.c"],
libraries=[feature.lcms] + extra))
if feature.webp:
libs = [feature.webp]
defs = []
if feature.webpmux:
defs.append(("HAVE_WEBPMUX", None))
libs.append(feature.webpmux)
libs.append(feature.webpmux.replace('pmux', 'pdemux'))
exts.append(Extension("PIL._webp",
["_webp.c"],
libraries=libs,
define_macros=defs))
tk_libs = ['psapi'] if sys.platform == 'win32' else []
exts.append(Extension("PIL._imagingtk",
["_imagingtk.c", "Tk/tkImaging.c"],
include_dirs=['Tk'],
libraries=tk_libs))
exts.append(Extension("PIL._imagingmath", ["_imagingmath.c"]))
exts.append(Extension("PIL._imagingmorph", ["_imagingmorph.c"]))
self.extensions[:] = exts
build_ext.build_extensions(self)
#
# sanity and security checks
unsafe_zlib = None
if feature.zlib:
unsafe_zlib = self.check_zlib_version(self.compiler.include_dirs)
self.summary_report(feature, unsafe_zlib)
def build_extensions(self):
build_ext_options.build_options(self)
build_ext.build_extensions(self)
def build_extensions(self):
c = self.compiler.compiler_type
if c in copt:
for e in self.extensions:
e.extra_compile_args = copt[c]
build_ext.build_extensions(self)
def build_extensions(self):
customize_compiler_for_nvcc(self.compiler)
build_ext.build_extensions(self)
def build_extensions(self):
global TCL_ROOT
library_dirs = []
include_dirs = []
_add_directory(include_dirs, "libImaging")
#
# add configured kits
for root in (TCL_ROOT, JPEG_ROOT, JPEG2K_ROOT, TIFF_ROOT, ZLIB_ROOT,
FREETYPE_ROOT, LCMS_ROOT):
if isinstance(root, type(())):
lib_root, include_root = root
else:
lib_root = include_root = root
_add_directory(library_dirs, lib_root)
_add_directory(include_dirs, include_root)
# respect CFLAGS/LDFLAGS
for k in ('CFLAGS', 'LDFLAGS'):
if k in os.environ:
for match in re.finditer(r'-I([^\s]+)', os.environ[k]):
_add_directory(include_dirs, match.group(1))
for match in re.finditer(r'-L([^\s]+)', os.environ[k]):
_add_directory(library_dirs, match.group(1))
# include, rpath, if set as environment variables:
for k in ('C_INCLUDE_PATH', 'CPATH', 'INCLUDE'):
if k in os.environ:
for d in os.environ[k].split(os.path.pathsep):
_add_directory(include_dirs, d)
for k in ('LD_RUN_PATH', 'LIBRARY_PATH', 'LIB'):
if k in os.environ:
for d in os.environ[k].split(os.path.pathsep):
_add_directory(library_dirs, d)
prefix = sysconfig.get_config_var("prefix")
if prefix:
_add_directory(library_dirs, os.path.join(prefix, "lib"))
_add_directory(include_dirs, os.path.join(prefix, "include"))
#
# add platform directories
if sys.platform == "cygwin":
# pythonX.Y.dll.a is in the /usr/lib/pythonX.Y/config directory
_add_directory(library_dirs,
os.path.join("/usr/lib", "python%s" %
sys.version[:3], "config"))
elif sys.platform == "darwin":
# attempt to make sure we pick freetype2 over other versions
_add_directory(include_dirs, "/sw/include/freetype2")
_add_directory(include_dirs, "/sw/lib/freetype2/include")
# fink installation directories
_add_directory(library_dirs, "/sw/lib")
_add_directory(include_dirs, "/sw/include")
# darwin ports installation directories
_add_directory(library_dirs, "/opt/local/lib")
_add_directory(include_dirs, "/opt/local/include")
# if Homebrew is installed, use its lib and include directories
import subprocess
try:
prefix = subprocess.check_output(['brew', '--prefix']).strip(
).decode('latin1')
except:
# Homebrew not installed
prefix = None
ft_prefix = None
if prefix:
# add Homebrew's include and lib directories
_add_directory(library_dirs, os.path.join(prefix, 'lib'))
_add_directory(include_dirs, os.path.join(prefix, 'include'))
ft_prefix = os.path.join(prefix, 'opt', 'freetype')
if ft_prefix and os.path.isdir(ft_prefix):
# freetype might not be linked into Homebrew's prefix
_add_directory(library_dirs, os.path.join(ft_prefix, 'lib'))
_add_directory(include_dirs,
os.path.join(ft_prefix, 'include'))
else:
# fall back to freetype from XQuartz if
# Homebrew's freetype is missing
_add_directory(library_dirs, "/usr/X11/lib")
_add_directory(include_dirs, "/usr/X11/include")
elif sys.platform.startswith("linux"):
arch_tp = (plat.processor(), plat.architecture()[0])
if arch_tp == ("x86_64", "32bit"):
# 32-bit build on 64-bit machine.
_add_directory(library_dirs, "/usr/lib/i386-linux-gnu")
else:
for platform_ in arch_tp:
if not platform_:
continue
if platform_ in ["x86_64", "64bit"]:
_add_directory(library_dirs, "/lib64")
_add_directory(library_dirs, "/usr/lib64")
_add_directory(library_dirs,
"/usr/lib/x86_64-linux-gnu")
break
elif platform_ in ["i386", "i686", "32bit"]:
_add_directory(library_dirs, "/usr/lib/i386-linux-gnu")
break
elif platform_ in ["aarch64"]:
_add_directory(library_dirs, "/usr/lib64")
_add_directory(library_dirs,
"/usr/lib/aarch64-linux-gnu")
break
elif platform_ in ["arm", "armv7l"]:
_add_directory(library_dirs,
"/usr/lib/arm-linux-gnueabi")
break
elif platform_ in ["ppc64"]:
_add_directory(library_dirs, "/usr/lib64")
_add_directory(library_dirs,
"/usr/lib/ppc64-linux-gnu")
_add_directory(library_dirs,
"/usr/lib/powerpc64-linux-gnu")
break
elif platform_ in ["ppc"]:
_add_directory(library_dirs, "/usr/lib/ppc-linux-gnu")
_add_directory(library_dirs,
"/usr/lib/powerpc-linux-gnu")
break
elif platform_ in ["s390x"]:
_add_directory(library_dirs, "/usr/lib64")
_add_directory(library_dirs,
"/usr/lib/s390x-linux-gnu")
break
elif platform_ in ["s390"]:
_add_directory(library_dirs, "/usr/lib/s390-linux-gnu")
break
else:
raise ValueError(
"Unable to identify Linux platform: `%s`" % platform_)
# XXX Kludge. Above /\ we brute force support multiarch. Here we
# try Barry's more general approach. Afterward, something should
# work ;-)
self.add_multiarch_paths()
elif sys.platform.startswith("gnu"):
self.add_multiarch_paths()
elif sys.platform.startswith("freebsd"):
_add_directory(library_dirs, "/usr/local/lib")
_add_directory(include_dirs, "/usr/local/include")
elif sys.platform.startswith("netbsd"):
_add_directory(library_dirs, "/usr/pkg/lib")
_add_directory(include_dirs, "/usr/pkg/include")
elif sys.platform.startswith("sunos5"):
_add_directory(library_dirs, "/opt/local/lib")
_add_directory(include_dirs, "/opt/local/include")
# FIXME: check /opt/stuff directories here?
# locate tkinter libraries
if _tkinter:
TCL_VERSION = _tkinter.TCL_VERSION[:3]
_dbg('Tkinter found, will check for Tcl/Tk')
else:
_dbg('Tkinter not found')
if _tkinter and not TCL_ROOT:
# we have Tkinter but the TCL_ROOT variable was not set;
# try to locate appropriate Tcl/Tk libraries
PYVERSION = sys.version[0] + sys.version[2]
TCLVERSION = TCL_VERSION[0] + TCL_VERSION[2]
roots = [
# common installation directories, mostly for Windows
# (for Unix-style platforms, we'll check in well-known
# locations later)
os.path.join("/py" + PYVERSION, "Tcl"),
os.path.join("/python" + PYVERSION, "Tcl"),
"/Tcl",
"/Tcl" + TCLVERSION,
"/Tcl" + TCL_VERSION,
os.path.join(
os.environ.get("ProgramFiles", ""), "Tcl"),
]
for TCL_ROOT in roots:
TCL_ROOT = os.path.abspath(TCL_ROOT)
_dbg('Checking %s for tk.h', TCL_ROOT)
if os.path.isfile(os.path.join(TCL_ROOT, "include", "tk.h")):
# FIXME: use distutils logging (?)
print("--- using Tcl/Tk libraries at", TCL_ROOT)
print("--- using Tcl/Tk version", TCL_VERSION)
TCL_ROOT = _lib_include(TCL_ROOT)
break
else:
TCL_ROOT = None
_dbg('Tcl/tk not found')
# add standard directories
# look for tcl specific subdirectory (e.g debian)
if _tkinter:
tcl_dir = "/usr/include/tcl" + TCL_VERSION
if os.path.isfile(os.path.join(tcl_dir, "tk.h")):
_add_directory(include_dirs, tcl_dir)
# standard locations
_add_directory(library_dirs, "/usr/local/lib")
_add_directory(include_dirs, "/usr/local/include")
_add_directory(library_dirs, "/usr/lib")
_add_directory(include_dirs, "/usr/include")
# on Windows, look for the OpenJPEG libraries in the location that
# the official installer puts them
if sys.platform == "win32":
program_files = os.environ.get('ProgramFiles', '')
best_version = (0, 0)
best_path = None
for name in os.listdir(program_files):
if name.startswith('OpenJPEG '):
version = tuple([int(x) for x in name[9:].strip().split(
'.')])
if version > best_version:
best_version = version
best_path = os.path.join(program_files, name)
if best_path:
_dbg('Adding %s to search list', best_path)
_add_directory(library_dirs, os.path.join(best_path, 'lib'))
_add_directory(include_dirs,
os.path.join(best_path, 'include'))
#
# insert new dirs *before* default libs, to avoid conflicts
# between Python PYD stub libs and real libraries
self.compiler.library_dirs = library_dirs + self.compiler.library_dirs
self.compiler.include_dirs = include_dirs + self.compiler.include_dirs
#
# look for available libraries
feature = self.feature
if feature.want('zlib'):
_dbg('Looking for zlib')
if _find_include_file(self, "zlib.h"):
if _find_library_file(self, "z"):
feature.zlib = "z"
elif (sys.platform == "win32" and
_find_library_file(self, "zlib")):
feature.zlib = "zlib" # alternative name
if feature.want('jpeg'):
_dbg('Looking for jpeg')
if _find_include_file(self, "jpeglib.h"):
if _find_library_file(self, "jpeg"):
feature.jpeg = "jpeg"
elif (sys.platform == "win32" and
_find_library_file(self, "libjpeg")):
feature.jpeg = "libjpeg" # alternative name
feature.openjpeg_version = None
if feature.want('jpeg2000'):
_dbg('Looking for jpeg2000')
best_version = None
best_path = None
# Find the best version
for directory in self.compiler.include_dirs:
_dbg('Checking for openjpeg-#.# in %s', directory)
try:
listdir = os.listdir(directory)
except Exception:
# WindowsError, FileNotFoundError
continue
for name in listdir:
if name.startswith('openjpeg-') and \
os.path.isfile(os.path.join(directory, name,
'openjpeg.h')):
_dbg('Found openjpeg.h in %s/%s', (directory, name))
version = tuple([int(x) for x in name[9:].split('.')])
if best_version is None or version > best_version:
best_version = version
best_path = os.path.join(directory, name)
_dbg('Best openjpeg version %s so far in %s',
(best_version, best_path))
if best_version and _find_library_file(self, 'openjp2'):
# Add the directory to the include path so we can include
# <openjpeg.h> rather than having to cope with the versioned
# include path
_add_directory(self.compiler.include_dirs, best_path, 0)
feature.jpeg2000 = 'openjp2'
feature.openjpeg_version = '.'.join([str(x) for x in
best_version])
if feature.want('tiff'):
_dbg('Looking for tiff')
if _find_include_file(self, 'tiff.h'):
if _find_library_file(self, "tiff"):
feature.tiff = "tiff"
if sys.platform == "win32" and _find_library_file(self, "libtiff"):
feature.tiff = "libtiff"
if (sys.platform == "darwin" and
_find_library_file(self, "libtiff")):
feature.tiff = "libtiff"
if feature.want('freetype'):
_dbg('Looking for freetype')
if _find_library_file(self, "freetype"):
# look for freetype2 include files
freetype_version = 0
for subdir in self.compiler.include_dirs:
_dbg('Checking for include file %s in %s', ("ft2build.h", subdir))
if os.path.isfile(os.path.join(subdir, "ft2build.h")):
_dbg('Found %s in %s', ("ft2build.h", subdir))
freetype_version = 21
subdir = os.path.join(subdir, "freetype2")
break
subdir = os.path.join(subdir, "freetype2")
_dbg('Checking for include file %s in %s', ("ft2build.h", subdir))
if os.path.isfile(os.path.join(subdir, "ft2build.h")):
_dbg('Found %s in %s', ("ft2build.h", subdir))
freetype_version = 21
break
if freetype_version:
feature.freetype = "freetype"
feature.freetype_version = freetype_version
if subdir:
_add_directory(self.compiler.include_dirs, subdir, 0)
if feature.want('lcms'):
_dbg('Looking for lcms')
if _find_include_file(self, "lcms2.h"):
if _find_library_file(self, "lcms2"):
feature.lcms = "lcms2"
elif _find_library_file(self, "lcms2_static"):
# alternate Windows name.
feature.lcms = "lcms2_static"
if _tkinter and _find_include_file(self, "tk.h"):
# the library names may vary somewhat (e.g. tcl85 or tcl8.5)
version = TCL_VERSION[0] + TCL_VERSION[2]
if feature.want('tcl'):
_dbg('Looking for TCL')
if _find_library_file(self, "tcl" + version):
feature.tcl = "tcl" + version
elif _find_library_file(self, "tcl" + TCL_VERSION):
feature.tcl = "tcl" + TCL_VERSION
if feature.want('tk'):
_dbg('Looking for TK')
if _find_library_file(self, "tk" + version):
feature.tk = "tk" + version
elif _find_library_file(self, "tk" + TCL_VERSION):
feature.tk = "tk" + TCL_VERSION
if feature.want('webp'):
_dbg('Looking for webp')
if (_find_include_file(self, "webp/encode.h") and
_find_include_file(self, "webp/decode.h")):
# In Google's precompiled zip it is call "libwebp":
if _find_library_file(self, "webp"):
feature.webp = "webp"
elif _find_library_file(self, "libwebp"):
feature.webp = "libwebp"
if feature.want('webpmux'):
_dbg('Looking for webpmux')
if (_find_include_file(self, "webp/mux.h") and
_find_include_file(self, "webp/demux.h")):
if (_find_library_file(self, "webpmux") and
_find_library_file(self, "webpdemux")):
feature.webpmux = "webpmux"
if (_find_library_file(self, "libwebpmux") and
_find_library_file(self, "libwebpdemux")):
feature.webpmux = "libwebpmux"
for f in feature:
if not getattr(feature, f) and feature.require(f):
if f in ('jpeg', 'zlib'):
raise ValueError(
'%s is required unless explicitly disabled'
' using --disable-%s, aborting' % (f, f))
raise ValueError(
'--enable-%s requested but %s not found, aborting.' %
(f, f))
#
# core library
files = ["_imaging.c"]
for src_file in _IMAGING:
files.append(src_file + ".c")
for src_file in _LIB_IMAGING:
files.append(os.path.join("libImaging", src_file + ".c"))
libs = []
defs = []
if feature.jpeg:
libs.append(feature.jpeg)
defs.append(("HAVE_LIBJPEG", None))
if feature.jpeg2000:
libs.append(feature.jpeg2000)
defs.append(("HAVE_OPENJPEG", None))
if sys.platform == "win32":
defs.append(("OPJ_STATIC", None))
if feature.zlib:
libs.append(feature.zlib)
defs.append(("HAVE_LIBZ", None))
if feature.tiff:
libs.append(feature.tiff)
defs.append(("HAVE_LIBTIFF", None))
if sys.platform == "win32":
libs.extend(["kernel32", "user32", "gdi32"])
if struct.unpack("h", "\0\1".encode('ascii'))[0] == 1:
defs.append(("WORDS_BIGENDIAN", None))
exts = [(Extension("PIL._imaging",
files,
libraries=libs,
define_macros=defs))]
#
# additional libraries
if feature.freetype:
exts.append(Extension("PIL._imagingft",
["_imagingft.c"],
libraries=["freetype"]))
if feature.lcms:
extra = []
if sys.platform == "win32":
extra.extend(["user32", "gdi32"])
exts.append(Extension("PIL._imagingcms",
["_imagingcms.c"],
libraries=[feature.lcms] + extra))
if feature.webp:
libs = [feature.webp]
defs = []
if feature.webpmux:
defs.append(("HAVE_WEBPMUX", None))
libs.append(feature.webpmux)
libs.append(feature.webpmux.replace('pmux', 'pdemux'))
exts.append(Extension("PIL._webp",
["_webp.c"],
libraries=libs,
define_macros=defs))
if feature.tcl and feature.tk:
if sys.platform == "darwin":
# locate Tcl/Tk frameworks
frameworks = []
framework_roots = [
"/Library/Frameworks", "/System/Library/Frameworks"
]
_dbg('Looking for TclTk Framework Build')
for root in framework_roots:
root_tcl = os.path.join(root, "Tcl.framework")
root_tk = os.path.join(root, "Tk.framework")
if (os.path.exists(root_tcl) and os.path.exists(root_tk)):
print("--- using frameworks at %s" % root)
frameworks = ["-framework", "Tcl", "-framework", "Tk"]
subdir = os.path.join(root_tcl, "Headers")
_add_directory(self.compiler.include_dirs, subdir, 0)
subdir = os.path.join(root_tk, "Headers")
_add_directory(self.compiler.include_dirs, subdir, 1)
break
if frameworks:
exts.append(Extension("PIL._imagingtk",
["_imagingtk.c", "Tk/tkImaging.c"],
extra_compile_args=frameworks,
extra_link_args=frameworks))
else:
exts.append(Extension("PIL._imagingtk",
["_imagingtk.c", "Tk/tkImaging.c"],
libraries=[feature.tcl, feature.tk]))
exts.append(Extension("PIL._imagingmath", ["_imagingmath.c"]))
exts.append(Extension("PIL._imagingmorph", ["_imagingmorph.c"]))
self.extensions[:] = exts
build_ext.build_extensions(self)
#
# sanity and security checks
unsafe_zlib = None
if feature.zlib:
unsafe_zlib = self.check_zlib_version(self.compiler.include_dirs)
self.summary_report(feature, unsafe_zlib)
def build_extensions(self, *args, **kargs):
self.PETSC_ARCH_LIST = []
_build_ext.build_extensions(self, *args, **kargs)
if not self.PETSC_ARCH_LIST: return
self.build_configuration(self.PETSC_ARCH_LIST)
def build_extensions(self):
self.compiler.initialize()
self.compiler.compile_options.remove('/MD')
build_ext.build_extensions(self)
def build_extensions(self):
global TCL_ROOT
library_dirs = []
include_dirs = []
_add_directory(include_dirs, "libImaging")
#
# add configured kits
for root in (TCL_ROOT, JPEG_ROOT, TIFF_ROOT, ZLIB_ROOT, FREETYPE_ROOT,
LCMS_ROOT):
if isinstance(root, type(())):
lib_root, include_root = root
else:
lib_root = include_root = root
_add_directory(library_dirs, lib_root)
_add_directory(include_dirs, include_root)
# respect CFLAGS/LDFLAGS
for k in ('CFLAGS', 'LDFLAGS'):
if k in os.environ:
for match in re.finditer(r'-I([^\s]+)', os.environ[k]):
_add_directory(include_dirs, match.group(1))
for match in re.finditer(r'-L([^\s]+)', os.environ[k]):
_add_directory(library_dirs, match.group(1))
# include, rpath, if set as environment variables:
for k in ('C_INCLUDE_PATH', 'CPATH', 'INCLUDE'):
if k in os.environ:
for d in os.environ[k].split(os.path.pathsep):
_add_directory(include_dirs, d)
for k in ('LD_RUN_PATH', 'LIBRARY_PATH', 'LIB'):
if k in os.environ:
for d in os.environ[k].split(os.path.pathsep):
_add_directory(library_dirs, d)
prefix = sysconfig.get_config_var("prefix")
if prefix:
_add_directory(library_dirs, os.path.join(prefix, "lib"))
_add_directory(include_dirs, os.path.join(prefix, "include"))
#
# add platform directories
if sys.platform == "cygwin":
# pythonX.Y.dll.a is in the /usr/lib/pythonX.Y/config directory
_add_directory(
library_dirs,
os.path.join("/usr/lib", "python%s" % sys.version[:3],
"config"))
elif sys.platform == "darwin":
# attempt to make sure we pick freetype2 over other versions
_add_directory(include_dirs, "/sw/include/freetype2")
_add_directory(include_dirs, "/sw/lib/freetype2/include")
# fink installation directories
_add_directory(library_dirs, "/sw/lib")
_add_directory(include_dirs, "/sw/include")
# darwin ports installation directories
_add_directory(library_dirs, "/opt/local/lib")
_add_directory(include_dirs, "/opt/local/include")
# if homebrew is installed, use its lib and include directories
import subprocess
try:
prefix = subprocess.check_output(['brew', '--prefix'])
if prefix:
prefix = prefix.strip()
_add_directory(library_dirs, os.path.join(prefix, 'lib'))
_add_directory(include_dirs,
os.path.join(prefix, 'include'))
# freetype2 is a key-only brew under opt/
_add_directory(
library_dirs,
os.path.join(prefix, 'opt', 'freetype', 'lib'))
_add_directory(
include_dirs,
os.path.join(prefix, 'opt', 'freetype', 'include'))
except:
pass # homebrew not installed
# freetype2 ships with X11 (after homebrew, so that homebrew freetype is preferred)
_add_directory(library_dirs, "/usr/X11/lib")
_add_directory(include_dirs, "/usr/X11/include")
elif sys.platform.startswith("linux"):
for platform_ in (plat.processor(), plat.architecture()[0]):
if not platform_:
continue
if platform_ in ["x86_64", "64bit"]:
_add_directory(library_dirs, "/lib64")
_add_directory(library_dirs, "/usr/lib64")
_add_directory(library_dirs, "/usr/lib/x86_64-linux-gnu")
break
elif platform_ in ["i386", "i686", "32bit"]:
_add_directory(library_dirs, "/usr/lib/i386-linux-gnu")
break
elif platform_ in ["aarch64"]:
_add_directory(library_dirs, "/usr/lib64")
_add_directory(library_dirs, "/usr/lib/aarch64-linux-gnu")
break
elif platform_ in ["arm", "armv7l"]:
_add_directory(library_dirs, "/usr/lib/arm-linux-gnueabi")
break
elif platform_ in ["ppc64"]:
_add_directory(library_dirs, "/usr/lib64")
_add_directory(library_dirs, "/usr/lib/ppc64-linux-gnu")
_add_directory(library_dirs,
"/usr/lib/powerpc64-linux-gnu")
break
elif platform_ in ["ppc"]:
_add_directory(library_dirs, "/usr/lib/ppc-linux-gnu")
_add_directory(library_dirs, "/usr/lib/powerpc-linux-gnu")
break
elif platform_ in ["s390x"]:
_add_directory(library_dirs, "/usr/lib64")
_add_directory(library_dirs, "/usr/lib/s390x-linux-gnu")
break
elif platform_ in ["s390"]:
_add_directory(library_dirs, "/usr/lib/s390-linux-gnu")
break
else:
raise ValueError("Unable to identify Linux platform: `%s`" %
platform_)
# XXX Kludge. Above /\ we brute force support multiarch. Here we
# try Barry's more general approach. Afterward, something should
# work ;-)
self.add_multiarch_paths()
elif sys.platform.startswith("gnu"):
self.add_multiarch_paths()
elif sys.platform.startswith("netbsd"):
_add_directory(library_dirs, "/usr/pkg/lib")
_add_directory(include_dirs, "/usr/pkg/include")
# FIXME: check /opt/stuff directories here?
#
# locate tkinter libraries
if _tkinter:
TCL_VERSION = _tkinter.TCL_VERSION[:3]
if _tkinter and not TCL_ROOT:
# we have Tkinter but the TCL_ROOT variable was not set;
# try to locate appropriate Tcl/Tk libraries
PYVERSION = sys.version[0] + sys.version[2]
TCLVERSION = TCL_VERSION[0] + TCL_VERSION[2]
roots = [
# common installation directories, mostly for Windows
# (for Unix-style platforms, we'll check in well-known
# locations later)
os.path.join("/py" + PYVERSION, "Tcl"),
os.path.join("/python" + PYVERSION, "Tcl"),
"/Tcl",
"/Tcl" + TCLVERSION,
"/Tcl" + TCL_VERSION,
os.path.join(os.environ.get("ProgramFiles", ""), "Tcl"),
]
for TCL_ROOT in roots:
TCL_ROOT = os.path.abspath(TCL_ROOT)
if os.path.isfile(os.path.join(TCL_ROOT, "include", "tk.h")):
# FIXME: use distutils logging (?)
print("--- using Tcl/Tk libraries at", TCL_ROOT)
print("--- using Tcl/Tk version", TCL_VERSION)
TCL_ROOT = _lib_include(TCL_ROOT)
break
else:
TCL_ROOT = None
# add standard directories
# look for tcl specific subdirectory (e.g debian)
if _tkinter:
tcl_dir = "/usr/include/tcl" + TCL_VERSION
if os.path.isfile(os.path.join(tcl_dir, "tk.h")):
_add_directory(include_dirs, tcl_dir)
# standard locations
_add_directory(library_dirs, "/usr/local/lib")
_add_directory(include_dirs, "/usr/local/include")
_add_directory(library_dirs, "/usr/lib")
_add_directory(include_dirs, "/usr/include")
_add_directory(library_dirs, "/usr/lib/i386-linux-gnu")
#
# insert new dirs *before* default libs, to avoid conflicts
# between Python PYD stub libs and real libraries
self.compiler.library_dirs = library_dirs + self.compiler.library_dirs
self.compiler.include_dirs = include_dirs + self.compiler.include_dirs
#
# look for available libraries
feature = self.feature
if feature.want('zlib'):
if _find_include_file(self, "zlib.h"):
if _find_library_file(self, "z"):
feature.zlib = "z"
elif sys.platform == "win32" and _find_library_file(
self, "zlib"):
feature.zlib = "zlib" # alternative name
if feature.want('jpeg'):
if _find_include_file(self, "jpeglib.h"):
if _find_library_file(self, "jpeg"):
feature.jpeg = "jpeg"
elif (sys.platform == "win32"
and _find_library_file(self, "libjpeg")):
feature.jpeg = "libjpeg" # alternative name
if feature.want('tiff'):
if _find_library_file(self, "tiff"):
feature.tiff = "tiff"
if sys.platform == "win32" and _find_library_file(self, "libtiff"):
feature.tiff = "libtiff"
if sys.platform == "darwin" and _find_library_file(
self, "libtiff"):
feature.tiff = "libtiff"
if feature.want('freetype'):
if _find_library_file(self, "freetype"):
# look for freetype2 include files
freetype_version = 0
for dir in self.compiler.include_dirs:
if os.path.isfile(os.path.join(dir, "ft2build.h")):
freetype_version = 21
dir = os.path.join(dir, "freetype2")
break
dir = os.path.join(dir, "freetype2")
if os.path.isfile(os.path.join(dir, "ft2build.h")):
freetype_version = 21
break
if os.path.isdir(os.path.join(dir, "freetype")):
freetype_version = 20
break
if freetype_version:
feature.freetype = "freetype"
feature.freetype_version = freetype_version
if dir:
_add_directory(self.compiler.include_dirs, dir, 0)
if feature.want('lcms'):
if _find_include_file(self, "lcms2.h"):
if _find_library_file(self, "lcms2"):
feature.lcms = "lcms"
if _tkinter and _find_include_file(self, "tk.h"):
# the library names may vary somewhat (e.g. tcl84 or tcl8.4)
version = TCL_VERSION[0] + TCL_VERSION[2]
if feature.want('tcl'):
if _find_library_file(self, "tcl" + version):
feature.tcl = "tcl" + version
elif _find_library_file(self, "tcl" + TCL_VERSION):
feature.tcl = "tcl" + TCL_VERSION
if feature.want('tk'):
if _find_library_file(self, "tk" + version):
feature.tk = "tk" + version
elif _find_library_file(self, "tk" + TCL_VERSION):
feature.tk = "tk" + TCL_VERSION
if feature.want('webp'):
if (_find_include_file(self, "webp/encode.h")
and _find_include_file(self, "webp/decode.h")):
if _find_library_file(
self, "webp"
): # in googles precompiled zip it is call "libwebp"
feature.webp = "webp"
if feature.want('webpmux'):
if (_find_include_file(self, "webp/mux.h")
and _find_include_file(self, "webp/demux.h")):
if _find_library_file(self, "webpmux") and _find_library_file(
self, "webpdemux"):
feature.webpmux = "webpmux"
for f in feature:
if not getattr(feature, f) and feature.require(f):
raise ValueError(
'--enable-%s requested but %s not found, aborting.' %
(f, f))
#
# core library
files = ["_imaging.c"]
for file in _IMAGING:
files.append(file + ".c")
for file in _LIB_IMAGING:
files.append(os.path.join("libImaging", file + ".c"))
libs = []
defs = []
if feature.jpeg:
libs.append(feature.jpeg)
defs.append(("HAVE_LIBJPEG", None))
if feature.zlib:
libs.append(feature.zlib)
defs.append(("HAVE_LIBZ", None))
if feature.tiff:
libs.append(feature.tiff)
defs.append(("HAVE_LIBTIFF", None))
if sys.platform == "win32":
libs.extend(["kernel32", "user32", "gdi32"])
if struct.unpack("h", "\0\1".encode('ascii'))[0] == 1:
defs.append(("WORDS_BIGENDIAN", None))
exts = [(Extension("PIL._imaging",
files,
libraries=libs,
define_macros=defs))]
#
# additional libraries
if feature.freetype:
defs = []
if feature.freetype_version == 20:
defs.append(("USE_FREETYPE_2_0", None))
exts.append(
Extension("PIL._imagingft", ["_imagingft.c"],
libraries=["freetype"],
define_macros=defs))
if os.path.isfile("_imagingtiff.c") and feature.tiff:
exts.append(
Extension("PIL._imagingtiff", ["_imagingtiff.c"],
libraries=["tiff"]))
if os.path.isfile("_imagingcms.c") and feature.lcms:
extra = []
if sys.platform == "win32":
extra.extend(["user32", "gdi32"])
exts.append(
Extension("PIL._imagingcms", ["_imagingcms.c"],
libraries=["lcms2"] + extra))
if os.path.isfile("_webp.c") and feature.webp:
libs = ["webp"]
defs = []
if feature.webpmux:
defs.append(("HAVE_WEBPMUX", None))
libs.append("webpmux")
libs.append("webpdemux")
exts.append(
Extension("PIL._webp", ["_webp.c"],
libraries=libs,
define_macros=defs))
if sys.platform == "darwin":
# locate Tcl/Tk frameworks
frameworks = []
framework_roots = [
"/Library/Frameworks", "/System/Library/Frameworks"
]
for root in framework_roots:
if (os.path.exists(os.path.join(root, "Tcl.framework")) and
os.path.exists(os.path.join(root, "Tk.framework"))):
print("--- using frameworks at %s" % root)
frameworks = ["-framework", "Tcl", "-framework", "Tk"]
dir = os.path.join(root, "Tcl.framework", "Headers")
_add_directory(self.compiler.include_dirs, dir, 0)
dir = os.path.join(root, "Tk.framework", "Headers")
_add_directory(self.compiler.include_dirs, dir, 1)
break
if frameworks:
exts.append(
Extension("PIL._imagingtk",
["_imagingtk.c", "Tk/tkImaging.c"],
extra_compile_args=frameworks,
extra_link_args=frameworks))
feature.tcl = feature.tk = 1 # mark as present
elif feature.tcl and feature.tk:
exts.append(
Extension("PIL._imagingtk", ["_imagingtk.c", "Tk/tkImaging.c"],
libraries=[feature.tcl, feature.tk]))
if os.path.isfile("_imagingmath.c"):
exts.append(Extension("PIL._imagingmath", ["_imagingmath.c"]))
self.extensions[:] = exts
build_ext.build_extensions(self)
#
# sanity and security checks
unsafe_zlib = None
if feature.zlib:
unsafe_zlib = self.check_zlib_version(self.compiler.include_dirs)
self.summary_report(feature, unsafe_zlib)
def build_extensions(self):
build_ext.build_extensions(self)
def build_extensions(self):
"""Compile the python extension module for further installation."""
global final_supported_archs
ext_extra_objects = []
ext_libs = []
ext_libs_dir = []
ext_includes = []
self.platform = CustomBuildExtension.PLATFORMS.get(sys.platform, None)
if self.platform == None:
raise Exception("unsupported platform: %s" % sys.platform)
if self.with_static_binutils: # the user has specified a custom binutils distro.
print "[+] Using specific binutils static distribution"
print "[+] %s" % self.with_static_binutils
self.platform["libs"] = [
os.path.join(self.with_static_binutils, "lib"),
]
self.platform["includes"] = [
os.path.join(self.with_static_binutils, "include"),
]
self.platform["possible-lib-ext"] = [
".a",
] # for all unix platforms.
# check for known includes
for inc in self.platform["includes"]:
if self.check_includes(inc):
self.includes = inc # found a valid include dir with bintuils
break
if self.includes == None:
raise Exception(
"unable to determine correct include path for bfd.h / dis-asm.h"
)
print "[+] Using binutils headers at:"
print "[+] %s" % self.includes
# we'll use this include path for building.
ext_includes = [
self.includes,
]
# Try to guess libopcodes / libbfd libs.
libs_dirs = self.platform["libs"]
print "[+] Searching binutils libraries..."
for libdir in libs_dirs:
for possible_lib_ext in self.platform["possible-lib-ext"]:
libs = self.find_binutils_libs(libdir, possible_lib_ext)
if libs:
self.libs = libdir, libs
break
if self.libs == None:
raise Exception("unable to find binutils libraries.")
for lib in self.libs[1]:
print "[+] %s" % os.path.join(self.libs[0], lib)
#
# check for libopcodes / libbfd
#
libraries_path, libs = self.libs
if not all([
lib.startswith("libopcodes") or lib.startswith("libbfd")
for lib in libs
]):
raise Exception(
"missing expected library (libopcodes / libbfd) in %s." %
libraries_path)
ext_libs_dir.append(libraries_path)
if self.with_static_binutils:
# use libs as extra objects...
ext_extra_objects.extend(
[os.path.join(libraries_path, lib) for lib in libs])
else:
ext_libs = [self.prepare_libs_for_cc(lib) for lib in libs]
# add dependecy to libiberty
if self.with_static_binutils or sys.platform == "darwin": # in OSX we always needs a static lib-iverty.
lib_liberty_partialpath = [
libraries_path,
]
if sys.platform == "darwin": # in osx the lib-iberty is prefixe by "machine" ppc/i386/x86_64
lib_liberty_partialpath.append(self._darwin_current_arch())
lib_liberty_partialpath.append("libiberty.a")
lib_liberty_fullpath = os.path.join(
*lib_liberty_partialpath) # merge the prefix and the path
if not os.path.isfile(lib_liberty_fullpath):
raise Exception("missing expected library (libiberty) in %s." %
libraries_path)
ext_extra_objects.append(lib_liberty_fullpath)
# generate .py / .h files that depends of libopcodes / libbfd currently selected
final_supported_archs = self.generate_source_files()
# final hacks for OSX
if sys.platform == "darwin":
# fix arch value.
os.environ["ARCHFLAGS"] = "-arch %s" % self._darwin_current_arch()
# In OSX we've to link against libintl.
ext_libs.append("intl")
# TODO: we have to improve the detection of gettext/libintl in OSX.. this is a quick fix.
dirs = [
"/usr/local/opt/gettext/lib", # homebrew
"/opt/local/lib" # macports
]
for d in dirs:
if os.path.exists(d):
ext_libs_dir.append(d)
# fix extensions.
for extension in self.extensions:
extension.include_dirs.extend(ext_includes)
extension.extra_objects.extend(ext_extra_objects)
extension.libraries.extend(ext_libs)
extension.library_dirs.extend(ext_libs_dir)
return build_ext.build_extensions(self)
def build_extensions(self):
try:
self.compiler.compiler_so.remove("-Wstrict-prototypes")
except (AttributeError, ValueError):
pass
build_ext.build_extensions(self)
def build_extensions(self):
global library_dirs, include_dirs, libraries
if WINDOWS:
# Detect the compiler so we can specify the correct command line switches
# and libraries
from distutils.cygwinccompiler import Mingw32CCompiler
extra_cc_args = []
if isinstance(self.compiler, Mingw32CCompiler):
# Compiler is Mingw32
freetds_dir = 'ming'
extra_cc_args = [
'-Wl,-allow-multiple-definition',
'-Wl,-subsystem,windows-mthreads', '-mwindows',
'-Wl,--strip-all'
]
libraries = [
'libiconv',
'iconv',
'sybdb',
'ws2_32',
'wsock32',
'kernel32',
]
else:
# Assume compiler is Visual Studio
if sys.version_info >= (3, 5):
freetds_dir = 'vs2015'
elif sys.version_info >= (3, 3):
freetds_dir = 'vs2010'
elif sys.version_info >= (2, 7) and BITNESS == 64:
freetds_dir = 'vs2010'
else:
freetds_dir = 'vs2008'
if LINK_FREETDS_STATICALLY:
libraries = [
'iconv',
'replacements',
'db-lib',
'tds',
'tdsutils',
'ws2_32',
'wsock32',
'kernel32',
'shell32',
]
if LINK_OPENSSL:
libraries.extend([
'libeay{}MD'.format(BITNESS),
'ssleay{}MD'.format(BITNESS)
])
else:
libraries = [
'ct',
'sybdb',
'ws2_32',
'wsock32',
'kernel32',
'shell32',
]
if LINK_OPENSSL:
libraries.extend(['libeay32MD', 'ssleay32MD'])
FREETDS = fpath('freetds', '{0}_{1}'.format(freetds_dir, BITNESS))
suffix = '' if BITNESS == 32 else '64'
OPENSSL = fpath('openssl', 'lib{}'.format(suffix))
for e in self.extensions:
e.extra_compile_args.extend(extra_cc_args)
e.libraries.extend(libraries)
e.include_dirs.append(osp.join(FREETDS, 'include'))
e.include_dirs.append(osp.join(ROOT, 'build', 'include'))
e.library_dirs.append(osp.join(ROOT, 'build', 'lib'))
if LINK_OPENSSL:
freetds_lib_dir = ''
else:
freetds_lib_dir = 'lib'
if LINK_FREETDS_STATICALLY:
e.library_dirs.append(osp.join(FREETDS, freetds_lib_dir))
else:
e.library_dirs.append(osp.join(FREETDS, freetds_lib_dir))
if LINK_OPENSSL:
e.library_dirs.append(OPENSSL)
else:
for e in self.extensions:
e.libraries.extend(libraries)
_build_ext.build_extensions(self)
def build_extensions(self):
self.build_options()
build_ext.build_extensions(self)
def build_extensions(self):
global TCL_ROOT
library_dirs = []
include_dirs = []
_add_directory(include_dirs, "libImaging")
#
# add configured kits
for root in (TCL_ROOT, JPEG_ROOT, TIFF_ROOT, ZLIB_ROOT, FREETYPE_ROOT,
LCMS_ROOT):
if isinstance(root, type(())):
lib_root, include_root = root
else:
lib_root = include_root = root
_add_directory(library_dirs, lib_root)
_add_directory(include_dirs, include_root)
#
# add platform directories
if sys.platform == "cygwin":
# pythonX.Y.dll.a is in the /usr/lib/pythonX.Y/config directory
_add_directory(
library_dirs,
os.path.join("/usr/lib", "python%s" % sys.version[:3],
"config"))
elif sys.platform == "darwin":
# attempt to make sure we pick freetype2 over other versions
_add_directory(include_dirs, "/sw/include/freetype2")
_add_directory(include_dirs, "/sw/lib/freetype2/include")
# fink installation directories
_add_directory(library_dirs, "/sw/lib")
_add_directory(include_dirs, "/sw/include")
# darwin ports installation directories
_add_directory(library_dirs, "/opt/local/lib")
_add_directory(include_dirs, "/opt/local/include")
# freetype2 ships with X11
_add_directory(library_dirs, "/usr/X11/lib")
_add_directory(include_dirs, "/usr/X11/include")
elif sys.platform.startswith("linux"):
for platform_ in (platform.processor(),
platform.architecture()[0]):
if not platform_: continue
if platform_ in ["x86_64", "64bit"]:
_add_directory(library_dirs, "/lib64")
_add_directory(library_dirs, "/usr/lib64")
_add_directory(library_dirs, "/usr/lib/x86_64-linux-gnu")
break
elif platform_ in ["i386", "i686", "32bit"]:
_add_directory(library_dirs, "/usr/lib/i386-linux-gnu")
break
else:
raise ValueError("Unable to identify Linux platform: `%s`" %
platform_)
# XXX Kludge. Above /\ we brute force support multiarch. Here we
# try Barry's more general approach. Afterward, something should
# work ;-)
self.add_multiarch_paths()
_add_directory(library_dirs, "/usr/local/lib")
# FIXME: check /opt/stuff directories here?
prefix = sysconfig.get_config_var("prefix")
if prefix:
_add_directory(library_dirs, os.path.join(prefix, "lib"))
_add_directory(include_dirs, os.path.join(prefix, "include"))
#
# locate tkinter libraries
if _tkinter:
TCL_VERSION = _tkinter.TCL_VERSION[:3]
if _tkinter and not TCL_ROOT:
# we have Tkinter but the TCL_ROOT variable was not set;
# try to locate appropriate Tcl/Tk libraries
PYVERSION = sys.version[0] + sys.version[2]
TCLVERSION = TCL_VERSION[0] + TCL_VERSION[2]
roots = [
# common installation directories, mostly for Windows
# (for Unix-style platforms, we'll check in well-known
# locations later)
os.path.join("/py" + PYVERSION, "Tcl"),
os.path.join("/python" + PYVERSION, "Tcl"),
"/Tcl",
"/Tcl" + TCLVERSION,
"/Tcl" + TCL_VERSION,
os.path.join(os.environ.get("ProgramFiles", ""), "Tcl"),
]
for TCL_ROOT in roots:
TCL_ROOT = os.path.abspath(TCL_ROOT)
if os.path.isfile(os.path.join(TCL_ROOT, "include", "tk.h")):
# FIXME: use distutils logging (?)
print("--- using Tcl/Tk libraries at", TCL_ROOT)
print("--- using Tcl/Tk version", TCL_VERSION)
TCL_ROOT = _lib_include(TCL_ROOT)
break
else:
TCL_ROOT = None
#
# add standard directories
# look for tcl specific subdirectory (e.g debian)
if _tkinter:
tcl_dir = "/usr/include/tcl" + TCL_VERSION
if os.path.isfile(os.path.join(tcl_dir, "tk.h")):
_add_directory(include_dirs, tcl_dir)
# standard locations
_add_directory(library_dirs, "/usr/local/lib")
_add_directory(include_dirs, "/usr/local/include")
_add_directory(library_dirs, "/usr/lib")
_add_directory(include_dirs, "/usr/include")
#
# insert new dirs *before* default libs, to avoid conflicts
# between Python PYD stub libs and real libraries
self.compiler.library_dirs = library_dirs + self.compiler.library_dirs
self.compiler.include_dirs = include_dirs + self.compiler.include_dirs
#
# look for available libraries
class feature:
zlib = jpeg = tiff = freetype = tcl = tk = lcms = webp = None
feature = feature()
if _find_include_file(self, "zlib.h"):
if _find_library_file(self, "z"):
feature.zlib = "z"
elif sys.platform == "win32" and _find_library_file(self, "zlib"):
feature.zlib = "zlib" # alternative name
if _find_include_file(self, "jpeglib.h"):
if _find_library_file(self, "jpeg"):
feature.jpeg = "jpeg"
elif sys.platform == "win32" and _find_library_file(
self, "libjpeg"):
feature.jpeg = "libjpeg" # alternative name
if _find_library_file(self, "tiff"):
feature.tiff = "tiff"
if sys.platform == "win32" and _find_library_file(self, "libtiff"):
feature.tiff = "libtiff"
if sys.platform == "darwin" and _find_library_file(self, "libtiff"):
feature.tiff = "libtiff"
if _find_library_file(self, "freetype"):
# look for freetype2 include files
freetype_version = 0
for dir in self.compiler.include_dirs:
if os.path.isfile(os.path.join(dir, "ft2build.h")):
freetype_version = 21
dir = os.path.join(dir, "freetype2")
break
dir = os.path.join(dir, "freetype2")
if os.path.isfile(os.path.join(dir, "ft2build.h")):
freetype_version = 21
break
if os.path.isdir(os.path.join(dir, "freetype")):
freetype_version = 20
break
if freetype_version:
feature.freetype = "freetype"
feature.freetype_version = freetype_version
if dir:
_add_directory(self.compiler.include_dirs, dir, 0)
if _find_include_file(self, "lcms.h"):
if _find_library_file(self, "lcms"):
feature.lcms = "lcms"
if _tkinter and _find_include_file(self, "tk.h"):
# the library names may vary somewhat (e.g. tcl84 or tcl8.4)
version = TCL_VERSION[0] + TCL_VERSION[2]
if _find_library_file(self, "tcl" + version):
feature.tcl = "tcl" + version
elif _find_library_file(self, "tcl" + TCL_VERSION):
feature.tcl = "tcl" + TCL_VERSION
if _find_library_file(self, "tk" + version):
feature.tk = "tk" + version
elif _find_library_file(self, "tk" + TCL_VERSION):
feature.tk = "tk" + TCL_VERSION
if _find_include_file(self, "webp/encode.h") and _find_include_file(
self, "webp/decode.h"):
if _find_library_file(self, "webp"):
feature.webp = "webp"
#
# core library
files = ["_imaging.c"]
for file in _IMAGING:
files.append(file + ".c")
for file in _LIB_IMAGING:
files.append(os.path.join("libImaging", file + ".c"))
libs = []
defs = []
if feature.jpeg:
libs.append(feature.jpeg)
defs.append(("HAVE_LIBJPEG", None))
if feature.zlib:
libs.append(feature.zlib)
defs.append(("HAVE_LIBZ", None))
if feature.tiff:
libs.append(feature.tiff)
defs.append(("HAVE_LIBTIFF", None))
if sys.platform == "win32":
libs.extend(["kernel32", "user32", "gdi32"])
if struct.unpack("h", "\0\1".encode('ascii'))[0] == 1:
defs.append(("WORDS_BIGENDIAN", None))
exts = [(Extension("_imaging",
files,
libraries=libs,
define_macros=defs))]
#
# additional libraries
if feature.freetype:
defs = []
if feature.freetype_version == 20:
defs.append(("USE_FREETYPE_2_0", None))
exts.append(
Extension("_imagingft", ["_imagingft.c"],
libraries=["freetype"],
define_macros=defs))
if os.path.isfile("_imagingtiff.c") and feature.tiff:
exts.append(
Extension("_imagingtiff", ["_imagingtiff.c"],
libraries=["tiff"]))
if os.path.isfile("_imagingcms.c") and feature.lcms:
extra = []
if sys.platform == "win32":
extra.extend(["user32", "gdi32"])
exts.append(
Extension("_imagingcms", ["_imagingcms.c"],
libraries=["lcms"] + extra))
if os.path.isfile("_webp.c") and feature.webp:
exts.append(Extension("_webp", ["_webp.c"], libraries=["webp"]))
if sys.platform == "darwin":
# locate Tcl/Tk frameworks
frameworks = []
framework_roots = [
"/Library/Frameworks", "/System/Library/Frameworks"
]
for root in framework_roots:
if (os.path.exists(os.path.join(root, "Tcl.framework")) and
os.path.exists(os.path.join(root, "Tk.framework"))):
print("--- using frameworks at %s" % root)
frameworks = ["-framework", "Tcl", "-framework", "Tk"]
dir = os.path.join(root, "Tcl.framework", "Headers")
_add_directory(self.compiler.include_dirs, dir, 0)
dir = os.path.join(root, "Tk.framework", "Headers")
_add_directory(self.compiler.include_dirs, dir, 1)
break
if frameworks:
exts.append(
Extension("_imagingtk", ["_imagingtk.c", "Tk/tkImaging.c"],
extra_compile_args=frameworks,
extra_link_args=frameworks))
feature.tcl = feature.tk = 1 # mark as present
elif feature.tcl and feature.tk:
exts.append(
Extension("_imagingtk", ["_imagingtk.c", "Tk/tkImaging.c"],
libraries=[feature.tcl, feature.tk]))
if os.path.isfile("_imagingmath.c"):
exts.append(Extension("_imagingmath", ["_imagingmath.c"]))
self.extensions[:] = exts
build_ext.build_extensions(self)
#
# sanity and security checks
unsafe_zlib = None
if feature.zlib:
unsafe_zlib = self.check_zlib_version(self.compiler.include_dirs)
self.summary_report(feature, unsafe_zlib)
def build_extensions(self):
#
# add platform directories
if sys.platform == "cygwin":
# pythonX.Y.dll.a is in the /usr/lib/pythonX.Y/config directory
add_directory(library_dirs, os.path.join(
"/usr/lib", "python%s" % sys.version[:3], "config"))
elif sys.platform == "darwin":
# attempt to make sure we pick freetype2 over other versions
add_directory(include_dirs, "/sw/include/freetype2")
add_directory(include_dirs, "/sw/lib/freetype2/include")
# fink installation directories
add_directory(library_dirs, "/sw/lib")
add_directory(include_dirs, "/sw/include")
# darwin ports installation directories
add_directory(library_dirs, "/opt/local/lib")
add_directory(include_dirs, "/opt/local/include")
# freetype2 ships with X11
add_directory(library_dirs, "/usr/X11/lib")
add_directory(include_dirs, "/usr/X11/include")
# if homebrew is installed, use its lib and include directories
import subprocess
try:
prefix = subprocess.check_output(['brew', '--prefix'])
if prefix:
prefix = prefix.strip()
add_directory(library_dirs, os.path.join(prefix, 'lib'))
add_directory(include_dirs, os.path.join(prefix, 'include'))
except:
pass # homebrew not installed
elif sys.platform.startswith("linux"):
for platform_ in (plat.processor(), plat.architecture()[0]):
if not platform_:
continue
if platform_ in ["x86_64", "64bit"]:
add_directory(library_dirs, "/lib64")
add_directory(library_dirs, "/usr/lib64")
add_directory(library_dirs, "/usr/lib/x86_64-linux-gnu")
break
elif platform_ in ["i386", "i686", "32bit"]:
add_directory(library_dirs, "/usr/lib/i386-linux-gnu")
break
else:
raise ValueError(
"Unable to identify Linux platform: `%s`" % platform_)
# XXX Kludge. Above /\ we brute force support multiarch. Here we
# try Barry's more general approach. Afterward, something should
# work ;-)
self.add_multiarch_paths()
add_directory(library_dirs, "/usr/local/lib")
prefix = sysconfig.get_config_var("prefix")
if prefix:
add_directory(library_dirs, os.path.join(prefix, "lib"))
add_directory(include_dirs, os.path.join(prefix, "include"))
#
# add configured kits
if isinstance(FREETYPE_ROOT, tuple):
lib_root, include_root = FREETYPE_ROOT
else:
lib_root = include_root = FREETYPE_ROOT
add_directory(library_dirs, lib_root)
add_directory(include_dirs, include_root)
#
# add standard directories
# standard locations
add_directory(library_dirs, "/usr/local/lib")
add_directory(include_dirs, "/usr/local/include")
add_directory(library_dirs, "/usr/lib")
add_directory(include_dirs, "/usr/include")
#
# insert new dirs *before* default libs, to avoid conflicts
# between Python PYD stub libs and real libraries
self.compiler.library_dirs = library_dirs + self.compiler.library_dirs
self.compiler.include_dirs = include_dirs + self.compiler.include_dirs
#
# look for available libraries
class feature:
freetype = None
feature = feature()
if find_library_file(self, "freetype"):
# look for freetype2 include files
freetype_version = 0
for dir in self.compiler.include_dirs:
if os.path.isfile(os.path.join(dir, "ft2build.h")):
freetype_version = 21
dir = os.path.join(dir, "freetype2")
break
dir = os.path.join(dir, "freetype2")
if os.path.isfile(os.path.join(dir, "ft2build.h")):
freetype_version = 21
break
if os.path.isdir(os.path.join(dir, "freetype")):
freetype_version = 20
break
if freetype_version:
feature.freetype = "freetype"
feature.freetype_version = freetype_version
if dir:
add_directory(self.compiler.include_dirs, dir, 0)
libs = []
if sys.platform == "win32":
libs.extend(["kernel32", "user32", "gdi32"])
if struct.unpack("h", "\0\1")[0] == 1:
defines.append(("WORDS_BIGENDIAN", None))
#
# additional libraries
if feature.freetype:
sources.append("agg2/font_freetype/agg_font_freetype.cpp")
include_dirs.append("agg2/font_freetype")
libraries.append("freetype")
defines.append(("HAVE_FREETYPE2", None))
if feature.freetype_version == 20:
defines.append(("USE_FREETYPE_2_0", None))
build_ext.build_extensions(self)
#
# sanity and security checks
self.summary_report(feature)
def build_extensions(self):
# Detect which modules should be compiled
old_so = self.compiler.shared_lib_extension
# Workaround PEP 3149 stuff
self.compiler.shared_lib_extension = os.environ.get("SO", ".so")
try:
missing = self.detect_modules()
finally:
self.compiler.shared_lib_extension = old_so
# Remove modules that are present on the disabled list
extensions = [
ext for ext in self.extensions
if ext.name not in disabled_module_list
]
# move ctypes to the end, it depends on other modules
ext_map = dict((ext.name, i) for i, ext in enumerate(extensions))
if "_ctypes" in ext_map:
ctypes = extensions.pop(ext_map["_ctypes"])
extensions.append(ctypes)
self.extensions = extensions
# Fix up the autodetected modules, prefixing all the source files
# with Modules/.
srcdir = sysconfig.get_config_var('srcdir')
if not srcdir:
# Maybe running on Windows but not using CYGWIN?
raise ValueError("No source directory; cannot proceed.")
srcdir = os.path.abspath(srcdir)
moddirlist = [os.path.join(srcdir, 'Modules')]
# Fix up the paths for scripts, too
self.distribution.scripts = [
os.path.join(srcdir, filename)
for filename in self.distribution.scripts
]
# Python header files
headers = [sysconfig.get_config_h_filename()]
headers += glob(os.path.join(sysconfig.get_path('include'), "*.h"))
for ext in self.extensions[:]:
ext.sources = [
find_module_file(filename, moddirlist)
for filename in ext.sources
]
if ext.depends is not None:
ext.depends = [
find_module_file(filename, moddirlist)
for filename in ext.depends
]
else:
ext.depends = []
# re-compile extensions if a header file has been changed
ext.depends.extend(headers)
# If a module has already been built statically,
# don't build it here
if ext.name in sys.builtin_module_names:
self.extensions.remove(ext)
# Parse Modules/Setup and Modules/Setup.local to figure out which
# modules are turned on in the file.
remove_modules = []
for filename in ('Modules/Setup', 'Modules/Setup.local'):
input = text_file.TextFile(filename, join_lines=1)
while 1:
line = input.readline()
if not line: break
line = line.split()
remove_modules.append(line[0])
input.close()
for ext in self.extensions[:]:
if ext.name in remove_modules:
self.extensions.remove(ext)
# When you run "make CC=altcc" or something similar, you really want
# those environment variables passed into the setup.py phase. Here's
# a small set of useful ones.
compiler = os.environ.get('CC')
args = {}
# unfortunately, distutils doesn't let us provide separate C and C++
# compilers
if compiler is not None:
(ccshared, cppflags, cflags) = \
sysconfig.get_config_vars('CCSHARED', 'CPPFLAGS', 'CFLAGS')
cppflags = ' '.join(
[f for f in cppflags.split() if not f.startswith('-I')])
args[
'compiler_so'] = compiler + ' ' + ccshared + ' ' + cppflags + ' ' + cflags
self.compiler.set_executables(**args)
build_ext.build_extensions(self)
longest = max([len(e.name) for e in self.extensions])
if self.failed:
longest = max(longest, max([len(name) for name in self.failed]))
def print_three_column(lst):
lst.sort(key=str.lower)
# guarantee zip() doesn't drop anything
while len(lst) % 3:
lst.append("")
for e, f, g in zip(lst[::3], lst[1::3], lst[2::3]):
print("%-*s %-*s %-*s" %
(longest, e, longest, f, longest, g))
if missing:
print()
print("Python build finished, but the necessary bits to build "
"these modules were not found:")
print_three_column(missing)
print("To find the necessary bits, look in setup.py in"
" detect_modules() for the module's name.")
print()
if self.failed:
failed = self.failed[:]
print()
print("Failed to build these modules:")
print_three_column(failed)
print()
def build_extensions(self):
# we're going to need to switch between compilers, so lets save both
self.default_compiler = self.compiler
self.nvcc = NVCC()
build_ext.build_extensions(self)
def build_extensions(self):
library_dirs = []
include_dirs = []
_add_directory(include_dirs, "src/libImaging")
pkg_config = None
if _cmd_exists(os.environ.get("PKG_CONFIG", "pkg-config")):
pkg_config = _pkg_config
#
# add configured kits
for root_name, lib_name in dict(
JPEG_ROOT="libjpeg",
JPEG2K_ROOT="libopenjp2",
TIFF_ROOT=("libtiff-5", "libtiff-4"),
ZLIB_ROOT="zlib",
FREETYPE_ROOT="freetype2",
LCMS_ROOT="lcms2",
IMAGEQUANT_ROOT="libimagequant",
).items():
root = globals()[root_name]
if root is None and root_name in os.environ:
prefix = os.environ[root_name]
root = (os.path.join(prefix,
"lib"), os.path.join(prefix, "include"))
if root is None and pkg_config:
if isinstance(lib_name, tuple):
for lib_name2 in lib_name:
_dbg("Looking for `%s` using pkg-config." % lib_name2)
root = pkg_config(lib_name2)
if root:
break
else:
_dbg("Looking for `%s` using pkg-config." % lib_name)
root = pkg_config(lib_name)
if isinstance(root, tuple):
lib_root, include_root = root
else:
lib_root = include_root = root
_add_directory(library_dirs, lib_root)
_add_directory(include_dirs, include_root)
# respect CFLAGS/CPPFLAGS/LDFLAGS
for k in ("CFLAGS", "CPPFLAGS", "LDFLAGS"):
if k in os.environ:
for match in re.finditer(r"-I([^\s]+)", os.environ[k]):
_add_directory(include_dirs, match.group(1))
for match in re.finditer(r"-L([^\s]+)", os.environ[k]):
_add_directory(library_dirs, match.group(1))
# include, rpath, if set as environment variables:
for k in ("C_INCLUDE_PATH", "CPATH", "INCLUDE"):
if k in os.environ:
for d in os.environ[k].split(os.path.pathsep):
_add_directory(include_dirs, d)
for k in ("LD_RUN_PATH", "LIBRARY_PATH", "LIB"):
if k in os.environ:
for d in os.environ[k].split(os.path.pathsep):
_add_directory(library_dirs, d)
prefix = sysconfig.get_config_var("prefix")
if prefix:
_add_directory(library_dirs, os.path.join(prefix, "lib"))
_add_directory(include_dirs, os.path.join(prefix, "include"))
#
# add platform directories
if self.disable_platform_guessing:
pass
elif sys.platform == "cygwin":
# pythonX.Y.dll.a is in the /usr/lib/pythonX.Y/config directory
_add_directory(
library_dirs,
os.path.join("/usr/lib",
"python{}.{}".format(*sys.version_info),
"config"),
)
elif sys.platform == "darwin":
# attempt to make sure we pick freetype2 over other versions
_add_directory(include_dirs, "/sw/include/freetype2")
_add_directory(include_dirs, "/sw/lib/freetype2/include")
# fink installation directories
_add_directory(library_dirs, "/sw/lib")
_add_directory(include_dirs, "/sw/include")
# darwin ports installation directories
_add_directory(library_dirs, "/opt/local/lib")
_add_directory(include_dirs, "/opt/local/include")
# if Homebrew is installed, use its lib and include directories
try:
prefix = (subprocess.check_output(["brew", "--prefix"
]).strip().decode("latin1"))
except Exception:
# Homebrew not installed
prefix = None
ft_prefix = None
if prefix:
# add Homebrew's include and lib directories
_add_directory(library_dirs, os.path.join(prefix, "lib"))
_add_directory(include_dirs, os.path.join(prefix, "include"))
ft_prefix = os.path.join(prefix, "opt", "freetype")
if ft_prefix and os.path.isdir(ft_prefix):
# freetype might not be linked into Homebrew's prefix
_add_directory(library_dirs, os.path.join(ft_prefix, "lib"))
_add_directory(include_dirs,
os.path.join(ft_prefix, "include"))
else:
# fall back to freetype from XQuartz if
# Homebrew's freetype is missing
_add_directory(library_dirs, "/usr/X11/lib")
_add_directory(include_dirs, "/usr/X11/include")
elif (sys.platform.startswith("linux")
or sys.platform.startswith("gnu")
or sys.platform.startswith("freebsd")):
for dirname in _find_library_dirs_ldconfig():
_add_directory(library_dirs, dirname)
if sys.platform.startswith("linux") and os.environ.get(
"ANDROID_ROOT", None):
# termux support for android.
# system libraries (zlib) are installed in /system/lib
# headers are at $PREFIX/include
# user libs are at $PREFIX/lib
_add_directory(library_dirs,
os.path.join(os.environ["ANDROID_ROOT"], "lib"))
elif sys.platform.startswith("netbsd"):
_add_directory(library_dirs, "/usr/pkg/lib")
_add_directory(include_dirs, "/usr/pkg/include")
elif sys.platform.startswith("sunos5"):
_add_directory(library_dirs, "/opt/local/lib")
_add_directory(include_dirs, "/opt/local/include")
# FIXME: check /opt/stuff directories here?
# standard locations
if not self.disable_platform_guessing:
_add_directory(library_dirs, "/usr/local/lib")
_add_directory(include_dirs, "/usr/local/include")
_add_directory(library_dirs, "/usr/lib")
_add_directory(include_dirs, "/usr/include")
# alpine, at least
_add_directory(library_dirs, "/lib")
if sys.platform == "win32":
if PLATFORM_MINGW:
_add_directory(include_dirs,
"C:\\msys64\\mingw32\\include\\libimagequant")
# on Windows, look for the OpenJPEG libraries in the location that
# the official installer puts them
program_files = os.environ.get("ProgramFiles", "")
best_version = (0, 0)
best_path = None
for name in os.listdir(program_files):
if name.startswith("OpenJPEG "):
version = tuple(
int(x) for x in name[9:].strip().split("."))
if version > best_version:
best_version = version
best_path = os.path.join(program_files, name)
if best_path:
_dbg("Adding %s to search list", best_path)
_add_directory(library_dirs, os.path.join(best_path, "lib"))
_add_directory(include_dirs,
os.path.join(best_path, "include"))
#
# insert new dirs *before* default libs, to avoid conflicts
# between Python PYD stub libs and real libraries
self.compiler.library_dirs = library_dirs + self.compiler.library_dirs
self.compiler.include_dirs = include_dirs + self.compiler.include_dirs
#
# look for available libraries
feature = self.feature
if feature.want("zlib"):
_dbg("Looking for zlib")
if _find_include_file(self, "zlib.h"):
if _find_library_file(self, "z"):
feature.zlib = "z"
elif sys.platform == "win32" and _find_library_file(
self, "zlib"):
feature.zlib = "zlib" # alternative name
if feature.want("jpeg"):
_dbg("Looking for jpeg")
if _find_include_file(self, "jpeglib.h"):
if _find_library_file(self, "jpeg"):
feature.jpeg = "jpeg"
elif sys.platform == "win32" and _find_library_file(
self, "libjpeg"):
feature.jpeg = "libjpeg" # alternative name
feature.openjpeg_version = None
if feature.want("jpeg2000"):
_dbg("Looking for jpeg2000")
best_version = None
best_path = None
# Find the best version
for directory in self.compiler.include_dirs:
_dbg("Checking for openjpeg-#.# in %s", directory)
try:
listdir = os.listdir(directory)
except Exception:
# WindowsError, FileNotFoundError
continue
for name in listdir:
if name.startswith("openjpeg-") and os.path.isfile(
os.path.join(directory, name, "openjpeg.h")):
_dbg("Found openjpeg.h in %s/%s", (directory, name))
version = tuple(int(x) for x in name[9:].split("."))
if best_version is None or version > best_version:
best_version = version
best_path = os.path.join(directory, name)
_dbg(
"Best openjpeg version %s so far in %s",
(best_version, best_path),
)
if best_version and _find_library_file(self, "openjp2"):
# Add the directory to the include path so we can include
# <openjpeg.h> rather than having to cope with the versioned
# include path
# FIXME (melvyn-sopacua):
# At this point it's possible that best_path is already in
# self.compiler.include_dirs. Should investigate how that is
# possible.
_add_directory(self.compiler.include_dirs, best_path, 0)
feature.jpeg2000 = "openjp2"
feature.openjpeg_version = ".".join(
str(x) for x in best_version)
if feature.want("imagequant"):
_dbg("Looking for imagequant")
if _find_include_file(self, "libimagequant.h"):
if _find_library_file(self, "imagequant"):
feature.imagequant = "imagequant"
elif _find_library_file(self, "libimagequant"):
feature.imagequant = "libimagequant"
if feature.want("tiff"):
_dbg("Looking for tiff")
if _find_include_file(self, "tiff.h"):
if _find_library_file(self, "tiff"):
feature.tiff = "tiff"
if sys.platform in ["win32", "darwin"] and _find_library_file(
self, "libtiff"):
feature.tiff = "libtiff"
if feature.want("freetype"):
_dbg("Looking for freetype")
if _find_library_file(self, "freetype"):
# look for freetype2 include files
freetype_version = 0
for subdir in self.compiler.include_dirs:
_dbg("Checking for include file %s in %s",
("ft2build.h", subdir))
if os.path.isfile(os.path.join(subdir, "ft2build.h")):
_dbg("Found %s in %s", ("ft2build.h", subdir))
freetype_version = 21
subdir = os.path.join(subdir, "freetype2")
break
subdir = os.path.join(subdir, "freetype2")
_dbg("Checking for include file %s in %s",
("ft2build.h", subdir))
if os.path.isfile(os.path.join(subdir, "ft2build.h")):
_dbg("Found %s in %s", ("ft2build.h", subdir))
freetype_version = 21
break
if freetype_version:
feature.freetype = "freetype"
if subdir:
_add_directory(self.compiler.include_dirs, subdir, 0)
if feature.want("lcms"):
_dbg("Looking for lcms")
if _find_include_file(self, "lcms2.h"):
if _find_library_file(self, "lcms2"):
feature.lcms = "lcms2"
elif _find_library_file(self, "lcms2_static"):
# alternate Windows name.
feature.lcms = "lcms2_static"
if feature.want("webp"):
_dbg("Looking for webp")
if _find_include_file(self,
"webp/encode.h") and _find_include_file(
self, "webp/decode.h"):
# In Google's precompiled zip it is call "libwebp":
if _find_library_file(self, "webp"):
feature.webp = "webp"
elif _find_library_file(self, "libwebp"):
feature.webp = "libwebp"
if feature.want("webpmux"):
_dbg("Looking for webpmux")
if _find_include_file(self, "webp/mux.h") and _find_include_file(
self, "webp/demux.h"):
if _find_library_file(self, "webpmux") and _find_library_file(
self, "webpdemux"):
feature.webpmux = "webpmux"
if _find_library_file(self,
"libwebpmux") and _find_library_file(
self, "libwebpdemux"):
feature.webpmux = "libwebpmux"
for f in feature:
if not getattr(feature, f) and feature.require(f):
if f in ("jpeg", "zlib"):
raise RequiredDependencyException(f)
raise DependencyException(f)
#
# core library
files = ["src/_imaging.c"]
for src_file in _IMAGING:
files.append("src/" + src_file + ".c")
for src_file in _LIB_IMAGING:
files.append(os.path.join("src/libImaging", src_file + ".c"))
libs = self.add_imaging_libs.split()
defs = []
if feature.jpeg:
libs.append(feature.jpeg)
defs.append(("HAVE_LIBJPEG", None))
if feature.jpeg2000:
libs.append(feature.jpeg2000)
defs.append(("HAVE_OPENJPEG", None))
if sys.platform == "win32":
defs.append(("OPJ_STATIC", None))
if feature.zlib:
libs.append(feature.zlib)
defs.append(("HAVE_LIBZ", None))
if feature.imagequant:
libs.append(feature.imagequant)
defs.append(("HAVE_LIBIMAGEQUANT", None))
if feature.tiff:
libs.append(feature.tiff)
defs.append(("HAVE_LIBTIFF", None))
if sys.platform == "win32":
libs.extend(["kernel32", "user32", "gdi32"])
if struct.unpack("h", "\0\1".encode("ascii"))[0] == 1:
defs.append(("WORDS_BIGENDIAN", None))
if sys.platform == "win32" and not (PLATFORM_PYPY or PLATFORM_MINGW):
defs.append(("PILLOW_VERSION", '"\\"%s\\""' % PILLOW_VERSION))
else:
defs.append(("PILLOW_VERSION", '"%s"' % PILLOW_VERSION))
exts = [(Extension("PIL._imaging",
files,
libraries=libs,
define_macros=defs))]
#
# additional libraries
if feature.freetype:
libs = ["freetype"]
defs = []
exts.append(
Extension(
"PIL._imagingft",
["src/_imagingft.c"],
libraries=libs,
define_macros=defs,
))
if feature.lcms:
extra = []
if sys.platform == "win32":
extra.extend(["user32", "gdi32"])
exts.append(
Extension(
"PIL._imagingcms",
["src/_imagingcms.c"],
libraries=[feature.lcms] + extra,
))
if feature.webp:
libs = [feature.webp]
defs = []
if feature.webpmux:
defs.append(("HAVE_WEBPMUX", None))
libs.append(feature.webpmux)
libs.append(feature.webpmux.replace("pmux", "pdemux"))
exts.append(
Extension("PIL._webp", ["src/_webp.c"],
libraries=libs,
define_macros=defs))
tk_libs = ["psapi"] if sys.platform == "win32" else []
exts.append(
Extension(
"PIL._imagingtk",
["src/_imagingtk.c", "src/Tk/tkImaging.c"],
include_dirs=["src/Tk"],
libraries=tk_libs,
))
exts.append(Extension("PIL._imagingmath", ["src/_imagingmath.c"]))
exts.append(Extension("PIL._imagingmorph", ["src/_imagingmorph.c"]))
self.extensions[:] = exts
build_ext.build_extensions(self)
#
# sanity checks
self.summary_report(feature)
def build_extensions(self):
for ext in self.extensions:
cythonize(ext)
build_ext.build_extensions(self)
def build_extensions(self):
# TODO: move build customization here?
build_ext.build_extensions(self)