代码拉取完成，页面将自动刷新
同步操作将从 openKylin/pyqt5 强制同步，此操作会覆盖自 Fork 仓库以来所做的任何修改，且无法恢复！！！
确定后同步将在后台操作，完成时将刷新页面，请耐心等待。
# This script generates the Makefiles for building PyQt5.
#
# Copyright (c) 2020 Riverbank Computing Limited <info@riverbankcomputing.com>
#
# This file is part of PyQt5.
#
# This file may be used under the terms of the GNU General Public License
# version 3.0 as published by the Free Software Foundation and appearing in
# the file LICENSE included in the packaging of this file. Please review the
# following information to ensure the GNU General Public License version 3.0
# requirements will be met: http://www.gnu.org/copyleft/gpl.html.
#
# If you do not wish to use this file under the terms of the GPL version 3.0
# then you may purchase a commercial license. For more information contact
# info@riverbankcomputing.com.
#
# This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
# WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
from distutils import sysconfig
import glob
import optparse
import os
import shutil
import stat
import sys
# Initialise the constants.
PYQT_VERSION_STR = "5.14.1"
SIP_MIN_VERSION = '4.19.20'
class ModuleMetadata:
""" This class encapsulates the meta-data about a PyQt5 module. """
def __init__(self, qmake_QT=None, qmake_TARGET='', qpy_lib=False, cpp11=False, public=True):
""" Initialise the meta-data. """
# The values to update qmake's QT variable.
self.qmake_QT = [] if qmake_QT is None else qmake_QT
# The value to set qmake's TARGET variable to. It defaults to the name
# of the module.
self.qmake_TARGET = qmake_TARGET
# Set if there is a qpy support library.
self.qpy_lib = qpy_lib
# Set if C++11 support is required.
self.cpp11 = cpp11
# Set if the module is public.
self.public = public
# The module meta-data.
MODULE_METADATA = {
'dbus': ModuleMetadata(qmake_QT=['-gui'],
qmake_TARGET='pyqt5'),
'QAxContainer': ModuleMetadata(qmake_QT=['axcontainer']),
'Qt': ModuleMetadata(qmake_QT=['-core', '-gui']),
'QtAndroidExtras': ModuleMetadata(qmake_QT=['androidextras']),
'QtBluetooth': ModuleMetadata(qmake_QT=['bluetooth']),
'QtCore': ModuleMetadata(qmake_QT=['-gui'], qpy_lib=True),
'QtDBus': ModuleMetadata(qmake_QT=['dbus', '-gui'],
qpy_lib=True),
'QtDesigner': ModuleMetadata(qmake_QT=['designer'],
qpy_lib=True),
'Enginio': ModuleMetadata(qmake_QT=['enginio']),
'QtGui': ModuleMetadata(qpy_lib=True),
'QtHelp': ModuleMetadata(qmake_QT=['help']),
'QtLocation': ModuleMetadata(qmake_QT=['location']),
'QtMacExtras': ModuleMetadata(qmake_QT=['macextras']),
'QtMultimedia': ModuleMetadata(qmake_QT=['multimedia']),
'QtMultimediaWidgets': ModuleMetadata(
qmake_QT=['multimediawidgets',
'multimedia']),
'QtNetwork': ModuleMetadata(qmake_QT=['network', '-gui']),
'QtNetworkAuth': ModuleMetadata(
qmake_QT=['network', 'networkauth',
'-gui'],
cpp11=True),
'QtNfc': ModuleMetadata(qmake_QT=['nfc', '-gui']),
'QtOpenGL': ModuleMetadata(qmake_QT=['opengl']),
'QtPositioning': ModuleMetadata(qmake_QT=['positioning']),
'QtPrintSupport': ModuleMetadata(qmake_QT=['printsupport']),
'QtQml': ModuleMetadata(qmake_QT=['qml'], qpy_lib=True),
'QtQuick': ModuleMetadata(qmake_QT=['quick'], qpy_lib=True),
'QtQuickWidgets': ModuleMetadata(qmake_QT=['quickwidgets']),
'QtRemoteObjects': ModuleMetadata(qmake_QT=['remoteobjects', '-gui']),
'QtSensors': ModuleMetadata(qmake_QT=['sensors']),
'QtSerialPort': ModuleMetadata(qmake_QT=['serialport']),
'QtSql': ModuleMetadata(qmake_QT=['sql', 'widgets']),
'QtSvg': ModuleMetadata(qmake_QT=['svg']),
'QtTest': ModuleMetadata(qmake_QT=['testlib', 'widgets']),
'QtWebChannel': ModuleMetadata(
qmake_QT=['webchannel', 'network',
'-gui']),
'QtWebKit': ModuleMetadata(qmake_QT=['webkit', 'network']),
'QtWebKitWidgets': ModuleMetadata(
qmake_QT=['webkitwidgets',
'printsupport']),
'QtWebSockets': ModuleMetadata(qmake_QT=['websockets', '-gui']),
'QtWidgets': ModuleMetadata(qmake_QT=['widgets'], qpy_lib=True),
'QtWinExtras': ModuleMetadata(qmake_QT=['winextras', 'widgets']),
'QtX11Extras': ModuleMetadata(qmake_QT=['x11extras']),
'QtXml': ModuleMetadata(qmake_QT=['xml', '-gui']),
'QtXmlPatterns': ModuleMetadata(
qmake_QT=['xmlpatterns', '-gui',
'network']),
# The OpenGL wrappers.
'_QOpenGLFunctions_1_0': ModuleMetadata(public=False),
'_QOpenGLFunctions_1_1': ModuleMetadata(public=False),
'_QOpenGLFunctions_1_2': ModuleMetadata(public=False),
'_QOpenGLFunctions_1_3': ModuleMetadata(public=False),
'_QOpenGLFunctions_1_4': ModuleMetadata(public=False),
'_QOpenGLFunctions_1_5': ModuleMetadata(public=False),
'_QOpenGLFunctions_2_0': ModuleMetadata(public=False),
'_QOpenGLFunctions_2_1': ModuleMetadata(public=False),
'_QOpenGLFunctions_3_0': ModuleMetadata(public=False),
'_QOpenGLFunctions_3_1': ModuleMetadata(public=False),
'_QOpenGLFunctions_3_2_Compatibility': ModuleMetadata(public=False),
'_QOpenGLFunctions_3_2_Core': ModuleMetadata(public=False),
'_QOpenGLFunctions_3_3_Compatibility': ModuleMetadata(public=False),
'_QOpenGLFunctions_3_3_Core': ModuleMetadata(public=False),
'_QOpenGLFunctions_4_0_Compatibility': ModuleMetadata(public=False),
'_QOpenGLFunctions_4_0_Core': ModuleMetadata(public=False),
'_QOpenGLFunctions_4_1_Compatibility': ModuleMetadata(public=False),
'_QOpenGLFunctions_4_1_Core': ModuleMetadata(public=False),
'_QOpenGLFunctions_4_2_Compatibility': ModuleMetadata(public=False),
'_QOpenGLFunctions_4_2_Core': ModuleMetadata(public=False),
'_QOpenGLFunctions_4_3_Compatibility': ModuleMetadata(public=False),
'_QOpenGLFunctions_4_3_Core': ModuleMetadata(public=False),
'_QOpenGLFunctions_4_4_Compatibility': ModuleMetadata(public=False),
'_QOpenGLFunctions_4_4_Core': ModuleMetadata(public=False),
'_QOpenGLFunctions_4_5_Compatibility': ModuleMetadata(public=False),
'_QOpenGLFunctions_4_5_Core': ModuleMetadata(public=False),
'_QOpenGLFunctions_ES2': ModuleMetadata(public=False),
# Internal modules.
'pylupdate': ModuleMetadata(qmake_QT=['xml', '-gui'],
qpy_lib=True, public=False),
'pyrcc': ModuleMetadata(qmake_QT=['xml', '-gui'],
qpy_lib=True, public=False),
}
# The component modules that make up the composite Qt module. SIP is broken in
# its handling of composite module in that a component module must be %Included
# before it is first %Imported. In other words, a module must appear before
# any modules that depend on it.
COMPOSITE_COMPONENTS = (
'QtCore',
'QtAndroidExtras', 'QtDBus', 'QtGui', 'QtNetwork', 'QtNetworkAuth',
'QtSensors', 'QtSerialPort', 'QtMultimedia', 'QtQml', 'QtWebKit',
'QtWidgets', 'QtXml', 'QtXmlPatterns', 'QtAxContainer', 'QtDesigner',
'QtHelp', 'QtMultimediaWidgets', 'QtOpenGL',
'QtPrintSupport', 'QtQuick', 'QtSql', 'QtSvg', 'QtTest',
'QtWebKitWidgets', 'QtBluetooth', 'QtMacExtras', 'QtPositioning',
'QtWinExtras', 'QtX11Extras', 'QtQuickWidgets', 'QtWebSockets',
'Enginio', 'QtWebChannel',
'QtLocation', 'QtNfc', 'QtRemoteObjects'
)
def error(msg):
""" Display an error message and terminate. msg is the text of the error
message.
"""
sys.stderr.write(format("Error: " + msg) + "\n")
sys.exit(1)
def inform(msg):
""" Display an information message. msg is the text of the error message.
"""
sys.stdout.write(format(msg) + "\n")
def format(msg, left_margin=0, right_margin=78):
""" Format a message by inserting line breaks at appropriate places. msg
is the text of the message. left_margin is the position of the left
margin. right_margin is the position of the right margin. Returns the
formatted message.
"""
curs = left_margin
fmsg = " " * left_margin
for w in msg.split():
l = len(w)
if curs != left_margin and curs + l > right_margin:
fmsg = fmsg + "\n" + (" " * left_margin)
curs = left_margin
if curs > left_margin:
fmsg = fmsg + " "
curs = curs + 1
fmsg = fmsg + w
curs = curs + l
return fmsg
def version_to_sip_tag(version):
""" Convert a version number to a SIP tag. version is the version number.
"""
# Anything after Qt v5 is assumed to be Qt v6.0.
if version > 0x060000:
version = 0x060000
major = (version >> 16) & 0xff
minor = (version >> 8) & 0xff
patch = version & 0xff
# Qt v5.12.4 was the last release where we updated for a patch version.
if (major, minor) >= (5, 13):
patch = 0
elif (major, minor) == (5, 12):
if patch > 4:
patch = 4
return 'Qt_%d_%d_%d' % (major, minor, patch)
def version_to_string(version, parts=3):
""" Convert an n-part version number encoded as a hexadecimal value to a
string. version is the version number. Returns the string.
"""
part_list = [str((version >> 16) & 0xff)]
if parts > 1:
part_list.append(str((version >> 8) & 0xff))
if parts > 2:
part_list.append(str(version & 0xff))
return '.'.join(part_list)
class ConfigurationFileParser:
""" A parser for configuration files. """
def __init__(self, config_file):
""" Read and parse a configuration file. """
self._config = {}
self._extrapolating = []
cfg = open(config_file)
line_nr = 0
last_name = None
section = ''
section_config = {}
self._config[section] = section_config
for l in cfg:
line_nr += 1
# Strip comments.
l = l.split('#')[0]
# See if this might be part of a multi-line.
multiline = (last_name is not None and len(l) != 0 and l[0] == ' ')
l = l.strip()
if l == '':
last_name = None
continue
# See if this is a new section.
if l[0] == '[' and l[-1] == ']':
section = l[1:-1].strip()
if section == '':
error(
"%s:%d: Empty section name." % (
config_file, line_nr))
if section in self._config:
error(
"%s:%d: Section '%s' defined more than once." % (
config_file, line_nr, section))
section_config = {}
self._config[section] = section_config
last_name = None
continue
parts = l.split('=', 1)
if len(parts) == 2:
name = parts[0].strip()
value = parts[1].strip()
elif multiline:
name = last_name
value = section_config[last_name]
value += ' ' + l
else:
name = value = ''
if name == '' or value == '':
error("%s:%d: Invalid line." % (config_file, line_nr))
section_config[name] = value
last_name = name
cfg.close()
def sections(self):
""" Return the list of sections, excluding the default one. """
return [s for s in self._config.keys() if s != '']
def preset(self, name, value):
""" Add a preset value to the configuration. """
self._config[''][name] = value
def get(self, section, name, default=None):
""" Get a configuration value while extrapolating. """
# Get the name from the section, or the default section.
value = self._config[section].get(name)
if value is None:
value = self._config[''].get(name)
if value is None:
if default is None:
error(
"Configuration file references non-existent name "
"'%s'." % name)
return default
# Handle any extrapolations.
parts = value.split('%(', 1)
while len(parts) == 2:
prefix, tail = parts
parts = tail.split(')', 1)
if len(parts) != 2:
error(
"Configuration file contains unterminated "
"extrapolated name '%s'." % tail)
xtra_name, suffix = parts
if xtra_name in self._extrapolating:
error(
"Configuration file contains a recursive reference to "
"'%s'." % xtra_name)
self._extrapolating.append(xtra_name)
xtra_value = self.get(section, xtra_name)
self._extrapolating.pop()
value = prefix + xtra_value + suffix
parts = value.split('%(', 1)
return value
def getboolean(self, section, name, default):
""" Get a boolean configuration value while extrapolating. """
value = self.get(section, name, default)
# In case the default was returned.
if isinstance(value, bool):
return value
if value in ('True', 'true', '1'):
return True
if value in ('False', 'false', '0'):
return False
error(
"Configuration file contains invalid boolean value for "
"'%s'." % name)
def getlist(self, section, name, default):
""" Get a list configuration value while extrapolating. """
value = self.get(section, name, default)
# In case the default was returned.
if isinstance(value, list):
return value
return value.split()
class HostPythonConfiguration:
""" A container for the host Python configuration. """
def __init__(self):
""" Initialise the configuration. """
self.platform = sys.platform
self.version = sys.hexversion >> 8
self.inc_dir = sysconfig.get_python_inc()
self.venv_inc_dir = sysconfig.get_python_inc(prefix=sys.prefix)
self.module_dir = sysconfig.get_python_lib(plat_specific=1)
self.debug = hasattr(sys, 'gettotalrefcount')
if sys.platform == 'win32':
bin_dir = sys.exec_prefix
try:
# Python v3.3 and later.
base_prefix = sys.base_prefix
if sys.exec_prefix != sys.base_exec_prefix:
bin_dir += '\\Scripts'
except AttributeError:
try:
# virtualenv for Python v2.
base_prefix = sys.real_prefix
bin_dir += '\\Scripts'
except AttributeError:
# We can't detect the base prefix in Python v3 prior to
# v3.3.
base_prefix = sys.prefix
self.bin_dir = bin_dir
self.data_dir = sys.prefix
self.lib_dir = base_prefix + '\\libs'
else:
self.bin_dir = sys.exec_prefix + '/bin'
self.data_dir = sys.prefix + '/share'
self.lib_dir = sys.prefix + '/lib'
# The name of the interpreter used by the pyuic5 wrapper.
if sys.platform == 'darwin':
# The installation of MacOS's python is a mess that changes from
# version to version and where sys.executable is useless.
py_major = self.version >> 16
py_minor = (self.version >> 8) & 0xff
# In Python v3.4 and later there is no pythonw.
if (py_major == 3 and py_minor >= 4) or py_major >= 4:
exe = "python"
else:
exe = "pythonw"
self.pyuic_interpreter = '%s%d.%d' % (exe, py_major, py_minor)
else:
self.pyuic_interpreter = sys.executable
class TargetQtConfiguration:
""" A container for the target Qt configuration. """
def __init__(self, qmake):
""" Initialise the configuration. qmake is the full pathname of the
qmake executable that will provide the configuration.
"""
inform("Querying qmake about your Qt installation...")
pipe = os.popen(' '.join([qmake, '-query']))
for l in pipe:
l = l.strip()
tokens = l.split(':', 1)
if isinstance(tokens, list):
if len(tokens) != 2:
error("Unexpected output from qmake: '%s'\n" % l)
name, value = tokens
else:
name = tokens
value = None
name = name.replace('/', '_')
setattr(self, name, value)
pipe.close()
class TargetConfiguration:
""" A container for configuration information about the target. """
def __init__(self):
""" Initialise the configuration with default values. """
# Values based on the host Python configuration.
py_config = HostPythonConfiguration()
self.py_debug = py_config.debug
self.py_inc_dir = py_config.inc_dir
self.py_venv_inc_dir = py_config.venv_inc_dir
self.py_lib_dir = py_config.lib_dir
self.py_platform = py_config.platform
self.py_version = py_config.version
self.pyqt_bin_dir = py_config.bin_dir
self.pyqt_module_dir = py_config.module_dir
self.pyqt_stubs_dir = os.path.join(py_config.module_dir, 'PyQt5')
self.pyqt_sip_dir = os.path.join(py_config.data_dir, 'sip', 'PyQt5')
self.pyuic_interpreter = py_config.pyuic_interpreter
# Remaining values.
self.abi_version = None
self.dbus_inc_dirs = []
self.dbus_lib_dirs = []
self.dbus_libs = []
self.debug = False
self.designer_plugin_dir = ''
self.license_dir = source_path('sip')
self.link_full_dll = False
self.no_designer_plugin = False
self.no_docstrings = False
self.no_pydbus = False
self.no_qml_plugin = False
self.no_tools = False
self.prot_is_public = (self.py_platform.startswith('linux') or self.py_platform == 'darwin')
self.qmake = self._find_exe('qmake')
self.qmake_spec = ''
self.qmake_spec_default = ''
self.qmake_variables = []
self.qml_debug = False
self.py_pylib_dir = ''
self.py_pylib_lib = ''
self.py_pyshlib = ''
self.pydbus_inc_dir = ''
self.pydbus_module_dir = ''
self.pyqt_disabled_features = []
self.pyqt_modules = []
self.qml_plugin_dir = ''
self.qsci_api = False
self.qsci_api_dir = ''
self.qt_shared = False
self.qt_version = 0
self.sip = self._find_exe('sip5', 'sip')
self.sip_inc_dir = None
self.static = False
self.sysroot = ''
self.vend_enabled = False
self.vend_inc_dir = ''
self.vend_lib_dir = ''
def from_configuration_file(self, config_file):
""" Initialise the configuration with values from a file. config_file
is the name of the configuration file.
"""
inform("Reading configuration from %s..." % config_file)
parser = ConfigurationFileParser(config_file)
# Populate some presets from the command line.
version = version_to_string(self.py_version).split('.')
parser.preset('py_major', version[0])
parser.preset('py_minor', version[1])
parser.preset('sysroot', self.sysroot)
# Find the section corresponding to the version of Qt.
qt_major = self.qt_version >> 16
section = None
latest_section = -1
for name in parser.sections():
parts = name.split()
if len(parts) != 2 or parts[0] != 'Qt':
continue
section_qt_version = version_from_string(parts[1])
if section_qt_version is None:
continue
# Major versions must match.
if section_qt_version >> 16 != self.qt_version >> 16:
continue
# It must be no later that the version of Qt.
if section_qt_version > self.qt_version:
continue
# Save it if it is the latest so far.
if section_qt_version > latest_section:
section = name
latest_section = section_qt_version
if section is None:
error("%s does not define a section that covers Qt v%s." % (config_file, version_to_string(self.qt_version)))
self.py_platform = parser.get(section, 'py_platform', self.py_platform)
self.py_debug = parser.get(section, 'py_debug', self.py_debug)
self.py_inc_dir = parser.get(section, 'py_inc_dir', self.py_inc_dir)
self.py_venv_inc_dir = self.py_inc_dir
self.py_pylib_dir = parser.get(section, 'py_pylib_dir',
self.py_pylib_dir)
self.py_pylib_lib = parser.get(section, 'py_pylib_lib',
self.py_pylib_lib)
self.py_pyshlib = parser.get(section, 'py_pyshlib', self.py_pyshlib)
self.qt_shared = parser.getboolean(section, 'qt_shared',
self.qt_shared)
self.pyqt_disabled_features = parser.getlist(section,
'pyqt_disabled_features', self.pyqt_disabled_features)
self.pyqt_modules = parser.getlist(section, 'pyqt_modules',
self.pyqt_modules)
self.pyqt_module_dir = parser.get(section, 'pyqt_module_dir',
self.pyqt_module_dir)
self.pyqt_bin_dir = parser.get(section, 'pyqt_bin_dir',
self.pyqt_bin_dir)
self.pyqt_stubs_dir = parser.get(section, 'pyqt_stubs_dir',
self.pyqt_stubs_dir)
self.pyqt_sip_dir = parser.get(section, 'pyqt_sip_dir',
self.pyqt_sip_dir)
self.pyuic_interpreter = parser.get(section, 'pyuic_interpreter',
self.pyuic_interpreter)
def from_introspection(self, verbose, debug):
""" Initialise the configuration by introspecting the system. """
# Check that the enum module is available.
try:
import enum
except ImportError:
error(
"Unable to import enum. Please install the enum34 "
"package from PyPI.")
# Get the details of the Python interpreter library.
py_major = self.py_version >> 16
py_minor = (self.py_version >> 8) & 0x0ff
if sys.platform == 'win32':
debug_suffix = self.get_win32_debug_suffix()
# See if we are using the limited API.
limited = (py_major == 3 and py_minor >= 4)
if self.py_debug or self.link_full_dll:
limited = False
if limited:
pylib_lib = 'python%d%s' % (py_major, debug_suffix)
else:
pylib_lib = 'python%d%d%s' % (py_major, py_minor, debug_suffix)
pylib_dir = self.py_lib_dir
# Assume Python is a DLL on Windows.
pyshlib = pylib_lib
else:
abi = getattr(sys, 'abiflags', '')
pylib_lib = 'python%d.%d%s' % (py_major, py_minor, abi)
pylib_dir = pyshlib = ''
# Use distutils to get the additional configuration.
ducfg = sysconfig.get_config_vars()
config_args = ducfg.get('CONFIG_ARGS', '')
dynamic_pylib = '--enable-shared' in config_args
if not dynamic_pylib:
dynamic_pylib = '--enable-framework' in config_args
if dynamic_pylib:
pyshlib = ducfg.get('LDLIBRARY', '')
exec_prefix = ducfg['exec_prefix']
multiarch = ducfg.get('MULTIARCH', '')
libdir = ducfg['LIBDIR']
if glob.glob('%s/lib/libpython%d.%d*' % (exec_prefix, py_major, py_minor)):
pylib_dir = exec_prefix + '/lib'
elif multiarch != '' and glob.glob('%s/lib/%s/libpython%d.%d*' % (exec_prefix, multiarch, py_major, py_minor)):
pylib_dir = exec_prefix + '/lib/' + multiarch
elif glob.glob('%s/libpython%d.%d*' % (libdir, py_major, py_minor)):
pylib_dir = libdir
self.py_pylib_dir = pylib_dir
self.py_pylib_lib = pylib_lib
self.py_pyshlib = pyshlib
# Apply sysroot where necessary.
if self.sysroot != '':
self.py_inc_dir = self._apply_sysroot(self.py_inc_dir)
self.py_venv_inc_dir = self._apply_sysroot(self.py_venv_inc_dir)
self.py_pylib_dir = self._apply_sysroot(self.py_pylib_dir)
self.pyqt_bin_dir = self._apply_sysroot(self.pyqt_bin_dir)
self.pyqt_module_dir = self._apply_sysroot(self.pyqt_module_dir)
self.pyqt_stubs_dir = self._apply_sysroot(self.pyqt_stubs_dir)
self.pyqt_sip_dir = self._apply_sysroot(self.pyqt_sip_dir)
inform("Determining the details of your Qt installation...")
# Compile and run the QtCore test program.
test = compile_test_program(self, verbose, 'QtCore', debug=debug)
if test is None:
error("Failed to determine the detail of your Qt installation. Try again using the --verbose flag to see more detail about the problem.")
lines = run_test_program('QtCore', test, verbose)
self.qt_shared = (lines[0] == 'shared')
self.pyqt_disabled_features = lines[1:]
if self.pyqt_disabled_features:
inform("Disabled QtCore features: %s" % ', '.join(
self.pyqt_disabled_features))
def _apply_sysroot(self, dir_name):
""" Replace any leading sys.prefix of a directory name with sysroot.
"""
if dir_name.startswith(sys.prefix):
dir_name = self.sysroot + dir_name[len(sys.prefix):]
return dir_name
def get_win32_debug_suffix(self):
""" Return the debug-dependent suffix appended to the name of Windows
libraries.
"""
return '_d' if self.py_debug else ''
def get_qt_configuration(self):
""" Get the Qt configuration that can be extracted from qmake. """
# Query qmake.
qt_config = TargetQtConfiguration(self.qmake)
self.qt_version = 0
try:
qt_version_str = qt_config.QT_VERSION
for v in qt_version_str.split('.'):
self.qt_version *= 256
self.qt_version += int(v)
except AttributeError:
qt_version_str = "3"
# Check the Qt version number as soon as possible.
if self.qt_version < 0x050000:
error(
"PyQt5 requires Qt v5.0 or later. You seem to be using "
"v%s. Use the --qmake flag to specify the correct version "
"of qmake." % qt_version_str)
self.designer_plugin_dir = qt_config.QT_INSTALL_PLUGINS + '/designer'
self.qml_plugin_dir = qt_config.QT_INSTALL_PLUGINS + '/PyQt5'
if self.sysroot == '':
self.sysroot = qt_config.QT_SYSROOT
# By default, install the API file if QScintilla seems to be installed
# in the default location.
self.qsci_api_dir = os.path.join(qt_config.QT_INSTALL_DATA, 'qsci')
self.qsci_api = os.path.isdir(self.qsci_api_dir)
# Save the default qmake spec. and finalise the value we want to use.
self.qmake_spec_default = qt_config.QMAKE_SPEC
# On Windows for Qt versions prior to v5.9.0 we need to be explicit
# about the qmake spec.
if self.qt_version < 0x050900 and self.py_platform == 'win32':
if self.py_version >= 0x030500:
self.qmake_spec = 'win32-msvc2015'
elif self.py_version >= 0x030300:
self.qmake_spec = 'win32-msvc2010'
elif self.py_version >= 0x020600:
self.qmake_spec = 'win32-msvc2008'
elif self.py_version >= 0x020400:
self.qmake_spec = 'win32-msvc.net'
else:
self.qmake_spec = 'win32-msvc'
else:
# Otherwise use the default.
self.qmake_spec = self.qmake_spec_default
# The binary OS/X Qt installer used to default to XCode. If so then
# use macx-clang.
if self.qmake_spec == 'macx-xcode':
# This will exist (and we can't check anyway).
self.qmake_spec = 'macx-clang'
def post_configuration(self):
""" Handle any remaining default configuration after having read a
configuration file or introspected the system.
"""
# The platform may have changed so update the default.
if self.py_platform.startswith('linux') or self.py_platform == 'darwin':
self.prot_is_public = True
self.vend_inc_dir = self.py_venv_inc_dir
self.vend_lib_dir = self.py_lib_dir
def apply_pre_options(self, opts):
""" Apply options from the command line that influence subsequent
configuration. opts are the command line options.
"""
# On Windows the interpreter must be a debug build if a debug version
# is to be built and vice versa.
if sys.platform == 'win32':
if opts.debug:
if not self.py_debug:
error(
"A debug version of Python must be used when "
"--debug is specified.")
elif self.py_debug:
error(
"--debug must be specified when a debug version of "
"Python is used.")
self.debug = opts.debug
# Get the target Python version.
if opts.target_py_version is not None:
self.py_version = opts.target_py_version
# Get the system root.
if opts.sysroot is not None:
self.sysroot = opts.sysroot
# Determine how to run qmake.
if opts.qmake is not None:
self.qmake = opts.qmake
# On Windows add the directory that probably contains the Qt DLLs
# to PATH.
if sys.platform == 'win32':
path = os.environ['PATH']
path = os.path.dirname(self.qmake) + ';' + path
os.environ['PATH'] = path
if self.qmake is None:
error(
"Use the --qmake argument to explicitly specify a working "
"Qt qmake.")
if opts.qmakespec is not None:
self.qmake_spec = opts.qmakespec
if opts.sipincdir is not None:
self.sip_inc_dir = opts.sipincdir
def apply_post_options(self, opts):
""" Apply options from the command line that override the previous
configuration. opts are the command line options.
"""
self.pyqt_disabled_features.extend(opts.disabled_features)
if opts.assumeshared:
self.qt_shared = True
if opts.bindir is not None:
self.pyqt_bin_dir = opts.bindir
if opts.licensedir is not None:
self.license_dir = opts.licensedir
if opts.link_full_dll:
self.link_full_dll = True
if opts.designerplugindir is not None:
self.designer_plugin_dir = opts.designerplugindir
if opts.qmlplugindir is not None:
self.qml_plugin_dir = opts.qmlplugindir
if opts.destdir is not None:
self.pyqt_module_dir = opts.destdir
if len(opts.modules) > 0:
self.pyqt_modules = opts.modules
if opts.nodesignerplugin:
self.no_designer_plugin = True
if opts.nodocstrings:
self.no_docstrings = True
if opts.nopydbus:
self.no_pydbus = True
if opts.noqmlplugin:
self.no_qml_plugin = True
if opts.notools:
self.no_tools = True
if opts.protispublic is not None:
self.prot_is_public = opts.protispublic
if opts.pydbusincdir is not None:
self.pydbus_inc_dir = opts.pydbusincdir
if opts.pyuicinterpreter is not None:
self.pyuic_interpreter = opts.pyuicinterpreter
if opts.qml_debug:
self.qml_debug = True
if opts.qsciapidir is not None:
self.qsci_api_dir = opts.qsciapidir
# Assume we want to install the API file if we have provided an
# installation directory.
self.qsci_api = True
if opts.qsciapi is not None:
self.qsci_api = opts.qsciapi
if opts.qsciapidir is not None:
self.qsci_api_dir = opts.qsciapidir
if opts.stubsdir is not None:
self.pyqt_stubs_dir = opts.stubsdir
elif not opts.install_stubs:
self.pyqt_stubs_dir = ''
if opts.sip is not None:
self.sip = opts.sip
if opts.abi_version is not None:
if not self.using_sip5():
error("The --abi-version argument can only be used with sip5.")
self.abi_version = opts.abi_version
if opts.sipdir is not None:
self.pyqt_sip_dir = opts.sipdir
elif not opts.install_sipfiles:
self.pyqt_sip_dir = ''
if opts.static:
self.static = True
if opts.vendenabled:
self.vend_enabled = True
if opts.vendincdir is not None:
self.vend_inc_dir = opts.vendincdir
if opts.vendlibdir is not None:
self.vend_lib_dir = opts.vendlibdir
# Handle any conflicts.
if not self.qt_shared:
if not self.static:
error(
"Qt has been built as static libraries so the "
"--static argument should be used.")
if self.vend_enabled and self.static:
error(
"Using the VendorID package when building static "
"libraries makes no sense.")
def get_pylib_link_arguments(self, name=True):
""" Return a string to append to qmake's LIBS macro to link against the
Python interpreter library.
"""
args = qmake_quote('-L' + self.py_pylib_dir)
if name:
args += ' -l' + self.py_pylib_lib
return args
def add_sip_h_directives(self, pro_lines):
""" Add the directives required by sip.h to a sequence of .pro file
lines.
"""
# Make sure the include directory is searched before the Python include
# directory if they are different.
pro_lines.append('INCLUDEPATH += %s' % qmake_quote(self.sip_inc_dir))
if self.py_inc_dir != self.sip_inc_dir:
pro_lines.append('INCLUDEPATH += %s' % qmake_quote(self.py_inc_dir))
# Python.h on Windows seems to embed the need for pythonXY.lib, so tell
# it where it is.
if not self.static:
pro_lines.extend(['win32 {',
' LIBS += ' + self.get_pylib_link_arguments(name=False),
'}'])
def using_sip5(self):
""" Return True if sip5 is being used. """
return os.path.basename(self.sip).startswith('sip5')
@staticmethod
def _find_exe(*exes):
""" Find an executable, ie. the first on the path. """
path_dirs = os.environ.get('PATH', '').split(os.pathsep)
for exe in exes:
# Strip any surrounding quotes.
if exe.startswith('"') and exe.endswith('"'):
exe = exe[1:-1]
if sys.platform == 'win32':
exe = exe + '.exe'
for d in path_dirs:
exe_path = os.path.join(d, exe)
if os.access(exe_path, os.X_OK):
return exe_path
return None
def create_optparser(target_config):
""" Create the parser for the command line. target_config is the target
configuration containing default values.
"""
def store_abspath(option, opt_str, value, parser):
setattr(parser.values, option.dest, os.path.abspath(value))
def store_abspath_dir(option, opt_str, value, parser):
if not os.path.isdir(value):
raise optparse.OptionValueError("'%s' is not a directory" % value)
setattr(parser.values, option.dest, os.path.abspath(value))
def store_abspath_exe(option, opt_str, value, parser):
if not os.access(value, os.X_OK):
raise optparse.OptionValueError("'%s' is not an executable" % value)
setattr(parser.values, option.dest, os.path.abspath(value))
def store_abspath_file(option, opt_str, value, parser):
if not os.path.isfile(value):
raise optparse.OptionValueError("'%s' is not a file" % value)
setattr(parser.values, option.dest, os.path.abspath(value))
def store_version(option, opt_str, value, parser):
version = version_from_string(value)
if version is None:
raise optparse.OptionValueError(
"'%s' is not a valid version number" % value)
setattr(parser.values, option.dest, version)
p = optparse.OptionParser(usage="python %prog [opts] [name=value] "
"[name+=value]", version=PYQT_VERSION_STR)
# Note: we don't use %default to be compatible with Python 2.3.
p.add_option("--abi-version", dest='abi_version', default=None,
metavar="VERSION",
help="the SIP ABI version to use (sip5 only)")
p.add_option("--static", "-k", dest='static', default=False,
action='store_true',
help="build modules as static libraries")
p.add_option("--no-docstrings", dest='nodocstrings', default=False,
action='store_true',
help="disable the generation of docstrings")
p.add_option("--trace", "-r", dest='tracing', default=False,
action='store_true',
help="build modules with tracing enabled")
p.add_option("--debug", "-u", dest='debug', default=False,
action='store_true',
help="build modules with debugging symbols")
p.add_option("--qml-debug", dest='qml_debug', default=False,
action='store_true',
help="enable the QML debugging infrastructure")
p.add_option("--verbose", "-w", dest='verbose', default=False,
action='store_true',
help="enable verbose output during configuration")
p.add_option("--concatenate", "-c", dest='concat', default=False,
action='store_true',
help="concatenate each module's C++ source files")
p.add_option("--concatenate-split", "-j", dest='split', type='int',
default=1, metavar="N",
help="split the concatenated C++ source files into N pieces "
"[default: 1]")
# Configuration.
g = optparse.OptionGroup(p, title="Configuration")
g.add_option("--confirm-license", dest='license_confirmed', default=False,
action='store_true',
help="confirm acceptance of the license")
g.add_option("--license-dir", dest='licensedir', type='string',
default=None, action='callback', callback=store_abspath,
metavar="DIR",
help="the license file can be found in DIR [default: "
"%s]" % target_config.license_dir)
g.add_option("--target-py-version", dest='target_py_version',
type='string', action='callback', callback=store_version,
metavar="VERSION",
help="the major.minor version of the target Python [default: "
"%s]" % version_to_string(target_config.py_version,
parts=2))
g.add_option("--link-full-dll", dest='link_full_dll',
default=False, action='store_true',
help="on Windows link against the full Python DLL rather than the "
"limited API DLL")
g.add_option("--sysroot", dest='sysroot', type='string', action='callback',
callback=store_abspath_dir, metavar="DIR",
help="DIR is the target system root directory")
g.add_option("--spec", dest='qmakespec', default=None, action='store',
metavar="SPEC",
help="pass -spec SPEC to qmake")
g.add_option("--disable", dest='disabled_modules', default=[],
action='append', metavar="MODULE",
help="disable the specified MODULE [default: checks for all "
"modules will be enabled]")
g.add_option("--disable-feature", dest='disabled_features', default=[],
action='append', metavar="FEATURE",
help="disable the specified FEATURE")
g.add_option("--enable", "-e", dest='modules', default=[], action='append',
metavar="MODULE",
help="enable checks for the specified MODULE [default: checks for "
"all modules will be enabled]")
g.add_option("--no-designer-plugin", dest='nodesignerplugin',
default=False, action='store_true',
help="disable the building of the Python plugin for Qt Designer "
"[default: enabled]")
g.add_option("--no-qml-plugin", dest='noqmlplugin', default=False,
action='store_true',
help="disable the building of the Python plugin for qmlscene "
"[default: enabled]")
g.add_option("--assume-shared", dest='assumeshared', default=False,
action='store_true',
help="assume that the Qt libraries have been built as shared "
"libraries [default: check]")
g.add_option("--no-timestamp", "-T", dest='notimestamp', default=False,
action='store_true',
help="suppress timestamps in the header comments of generated "
"code [default: include timestamps]")
g.add_option("--configuration", dest='config_file', type='string',
action='callback', callback=store_abspath_file, metavar="FILE",
help="FILE contains the target configuration")
g.add_option("--protected-is-public", dest='protispublic', default=None,
action='store_true',
help="enable building with 'protected' redefined as 'public' "
"[default: %s]" %
"enabled" if target_config.prot_is_public
else "disabled")
g.add_option("--protected-not-public", dest='protispublic', default=None,
action='store_false',
help="disable building with 'protected' redefined as 'public'")
g.add_option("--pyuic5-interpreter", dest='pyuicinterpreter',
type='string', default=None, action='callback',
callback=store_abspath_exe, metavar="FILE",
help="the name of the Python interpreter to run the pylupdate5, "
"pyrcc5 and pyuic5 wrappers is FILE [default: %s]" %
target_config.pyuic_interpreter)
g.add_option("--qmake", "-q", dest='qmake', type='string', default=None,
action='callback', callback=store_abspath_exe, metavar="FILE",
help="the pathname of qmake is FILE [default: "
"%s]" % (target_config.qmake or "search PATH"))
g.add_option("--sip", dest='sip', type='string', default=None,
action='callback', callback=store_abspath_exe, metavar="FILE",
help="the pathname of sip is FILE [default: "
"%s]" % (target_config.sip or "None"))
g.add_option("--sip-incdir", dest='sipincdir', type='string',
default=None, action='callback', callback=store_abspath_dir,
metavar="DIR",
help="the directory containing the sip.h header file is DIR "
"[default: %s]" % target_config.sip_inc_dir)
g.add_option("--allow-sip-warnings", dest='fatal_warnings',
default=True, action='store_false',
help="allow sip to issue non-fatal warning messages "
"[default: warning messages are treated as errors]")
g.add_option("--no-python-dbus", dest='nopydbus',
default=False, action='store_true',
help="disable the Qt support for the standard Python DBus "
"bindings [default: enabled]")
g.add_option("--dbus", "-s", dest='pydbusincdir', type='string',
default=None, action='callback', callback=store_abspath_dir,
metavar="DIR",
help="the directory containing the dbus/dbus-python.h header is "
"DIR [default: supplied by pkg-config]")
p.add_option_group(g)
# Installation.
g = optparse.OptionGroup(p, title="Installation")
g.add_option("--bindir", "-b", dest='bindir', type='string', default=None,
action='callback', callback=store_abspath, metavar="DIR",
help="install pyuic5, pyrcc5 and pylupdate5 in DIR [default: "
"%s]" % target_config.pyqt_bin_dir)
g.add_option("--destdir", "-d", dest='destdir', type='string',
default=None, action='callback', callback=store_abspath,
metavar="DIR",
help="install the PyQt5 Python package in DIR [default: "
"%s]" % target_config.pyqt_module_dir)
g.add_option("--designer-plugindir", dest='designerplugindir',
type='string', default=None, action='callback',
callback=store_abspath, metavar="DIR",
help="install the Python plugin for Qt Designer in DIR "
"[default: QT_INSTALL_PLUGINS/designer]")
g.add_option("--qml-plugindir", dest='qmlplugindir', type='string',
default=None, action='callback', callback=store_abspath,
metavar="DIR",
help="install the Python plugin for qmlscene in DIR "
"[default: QT_INSTALL_PLUGINS/PyQt5]")
g.add_option("--no-sip-files", action="store_false", default=True,
dest="install_sipfiles", help="disable the installation of the "
".sip files [default: enabled]")
g.add_option("--sipdir", "-v", dest='sipdir', type='string', default=None,
action='callback', callback=store_abspath, metavar="DIR",
help="install the PyQt5 .sip files in DIR [default: %s]" %
target_config.pyqt_sip_dir)
g.add_option("--no-dist-info", action="store_false", default=True,
dest="distinfo",
help="do not install the dist-info directory")
g.add_option("--no-stubs", action="store_false", default=True,
dest="install_stubs", help="disable the installation of the PEP "
"484 stub files [default: enabled]")
g.add_option("--stubsdir", dest='stubsdir', type='string', default=None,
action='callback', callback=store_abspath, metavar="DIR",
help="install the PEP 484 stub files in DIR [default: "
"%s]" % target_config.pyqt_stubs_dir)
g.add_option("--no-tools", action="store_true", default=False,
dest="notools",
help="disable the building of pyuic5, pyrcc5 and pylupdate5 "
"[default: enabled]")
p.add_option_group(g)
# Vendor ID.
g = optparse.OptionGroup(p, title="VendorID support")
g.add_option("--vendorid", "-i", dest='vendenabled', default=False,
action='store_true',
help="enable checking of signed interpreters using the VendorID "
"package [default: %s]" %
"enabled" if target_config.vend_enabled else "disabled")
g.add_option("--vendorid-incdir", "-l", dest='vendincdir', type='string',
default=None, action='callback', callback=store_abspath_dir,
metavar="DIR",
help="the VendorID header file is installed in DIR [default: "
"%s]" % target_config.vend_inc_dir)
g.add_option("--vendorid-libdir", "-m", dest='vendlibdir', type='string',
default=None, action='callback', callback=store_abspath_dir,
metavar="DIR",
help="the VendorID library is installed in DIR [default: "
"%s]" % target_config.vend_lib_dir)
p.add_option_group(g)
# QScintilla.
g = optparse.OptionGroup(p, title="QScintilla support")
g.add_option("--qsci-api", "-a", dest='qsciapi', default=None,
action='store_true',
help="always install the PyQt API file for QScintilla [default: "
"install only if QScintilla installed]")
g.add_option("--no-qsci-api", dest='qsciapi', default=None,
action='store_false',
help="do not install the PyQt API file for QScintilla [default: "
"install only if QScintilla installed]")
g.add_option("--qsci-api-destdir", "-n", dest='qsciapidir', type='string',
default=None, action='callback', callback=store_abspath,
metavar="DIR",
help="install the PyQt5 API file for QScintilla in DIR [default: "
"QT_INSTALL_DATA/qsci]")
p.add_option_group(g)
return p
def check_modules(target_config, disabled_modules, verbose):
""" Check which modules can be built and update the target configuration
accordingly. target_config is the target configuration. disabled_modules
is the list of modules that have been explicitly disabled. verbose is set
if the output is to be displayed.
"""
target_config.pyqt_modules.append('QtCore')
check_module(target_config, disabled_modules, verbose, 'QtGui')
check_module(target_config, disabled_modules, verbose, 'QtHelp',
'qhelpengine.h', 'new QHelpEngine("foo")')
check_module(target_config, disabled_modules, verbose, 'QtMultimedia',
'QAudioDeviceInfo', 'new QAudioDeviceInfo()')
check_module(target_config, disabled_modules, verbose,
'QtMultimediaWidgets', 'QVideoWidget', 'new QVideoWidget()')
check_module(target_config, disabled_modules, verbose, 'QtNetwork')
check_module(target_config, disabled_modules, verbose, 'QtOpenGL', 'qgl.h',
'new QGLWidget()')
check_module(target_config, disabled_modules, verbose, 'QtPrintSupport')
check_module(target_config, disabled_modules, verbose, 'QtQml',
'qjsengine.h', 'new QJSEngine()')
check_module(target_config, disabled_modules, verbose, 'QtQuick',
'qquickwindow.h', 'new QQuickWindow()')
check_module(target_config, disabled_modules, verbose, 'QtSql',
'qsqldatabase.h', 'new QSqlDatabase()')
check_module(target_config, disabled_modules, verbose, 'QtSvg',
'qsvgwidget.h', 'new QSvgWidget()')
check_module(target_config, disabled_modules, verbose, 'QtTest', 'QtTest',
'QTest::qSleep(0)')
check_module(target_config, disabled_modules, verbose, 'QtWebKit',
'qwebkitglobal.h', 'qWebKitVersion()')
check_module(target_config, disabled_modules, verbose, 'QtWebKitWidgets',
'qwebpage.h', 'new QWebPage()')
check_module(target_config, disabled_modules, verbose, 'QtWidgets',
'qwidget.h', 'new QWidget()')
check_module(target_config, disabled_modules, verbose, 'QtXml', 'qdom.h',
'new QDomDocument()')
check_module(target_config, disabled_modules, verbose, 'QtXmlPatterns',
'qxmlname.h', 'new QXmlName()')
if target_config.qt_shared:
check_module(target_config, disabled_modules, verbose, 'QtDesigner',
('QExtensionFactory', 'customwidget.h'),
'new QExtensionFactory()')
else:
inform("QtDesigner module disabled with static Qt libraries.")
check_module(target_config, disabled_modules, verbose, 'QAxContainer',
'qaxobject.h', 'new QAxObject()')
check_module(target_config, disabled_modules, verbose, 'QtDBus',
'qdbusconnection.h', 'QDBusConnection::systemBus()')
if target_config.qt_version >= 0x050100:
check_5_1_modules(target_config, disabled_modules, verbose)
if target_config.qt_version >= 0x050200:
check_5_2_modules(target_config, disabled_modules, verbose)
if target_config.qt_version >= 0x050300:
check_5_3_modules(target_config, disabled_modules, verbose)
if target_config.qt_version >= 0x050400:
check_5_4_modules(target_config, disabled_modules, verbose)
if target_config.qt_version >= 0x050500:
check_5_5_modules(target_config, disabled_modules, verbose)
if target_config.qt_version >= 0x050a00:
check_5_10_modules(target_config, disabled_modules, verbose)
if target_config.qt_version >= 0x050c00:
check_5_12_modules(target_config, disabled_modules, verbose)
# QtWebEngine needs to know if QtWebChannel is available.
if 'QtWebChannel' not in target_config.pyqt_modules:
target_config.pyqt_disabled_features.append('PyQt_WebChannel')
def check_5_1_modules(target_config, disabled_modules, verbose):
""" Check which modules introduced in Qt v5.1 can be built and update the
target configuration accordingly. target_config is the target
configuration. disabled_modules is the list of modules that have been
explicitly disabled. verbose is set if the output is to be displayed.
"""
# Check the OpenGL functions.
if 'PyQt_OpenGL' in target_config.pyqt_disabled_features:
pass
elif 'PyQt_Desktop_OpenGL' in target_config.pyqt_disabled_features:
check_module(target_config, disabled_modules, verbose,
'_QOpenGLFunctions_ES2', 'qopenglfunctions_es2.h',
'new QOpenGLFunctions_ES2()')
else:
desktop_versions = (
'1_0', '1_1', '1_2', '1_3', '1_4', '1_5',
'2_0', '2_1',
'3_0', '3_1',
'3_2_Compatibility', '3_2_Core',
'3_3_Compatibility', '3_3_Core',
'4_0_Compatibility', '4_0_Core',
'4_1_Compatibility', '4_1_Core',
'4_2_Compatibility', '4_2_Core',
'4_3_Compatibility', '4_3_Core',
'4_4_Compatibility', '4_4_Core',
'4_5_Compatibility', '4_5_Core')
for ogl in desktop_versions:
ogl_module = '_QOpenGLFunctions_' + ogl
ogl_h = 'qopenglfunctions_' + ogl.lower() + '.h'
ogl_ctor = 'new QOpenGLFunctions_' + ogl + '()'
check_module(target_config, disabled_modules, verbose, ogl_module,
ogl_h, ogl_ctor)
check_module(target_config, disabled_modules, verbose, 'QtSensors',
'qsensor.h', 'new QSensor(QByteArray())')
check_module(target_config, disabled_modules, verbose, 'QtSerialPort',
'qserialport.h', 'new QSerialPort()')
check_module(target_config, disabled_modules, verbose, 'QtX11Extras',
'QX11Info', 'QX11Info::display()')
def check_5_2_modules(target_config, disabled_modules, verbose):
""" Check which modules introduced in Qt v5.2 can be built and update the
target configuration accordingly. target_config is the target
configuration. disabled_modules is the list of modules that have been
explicitly disabled. verbose is set if the output is to be displayed.
"""
check_module(target_config, disabled_modules, verbose, 'QtBluetooth',
'qbluetoothaddress.h', 'new QBluetoothAddress()')
check_module(target_config, disabled_modules, verbose, 'QtMacExtras',
'qmacpasteboardmime.h', 'class Foo : public QMacPasteboardMime {}')
check_module(target_config, disabled_modules, verbose, 'QtPositioning',
'qgeoaddress.h', 'new QGeoAddress()')
check_module(target_config, disabled_modules, verbose, 'QtWinExtras',
'QtWin', 'QtWin::isCompositionEnabled()')
def check_5_3_modules(target_config, disabled_modules, verbose):
""" Check which modules introduced in Qt v5.3 can be built and update the
target configuration accordingly. target_config is the target
configuration. disabled_modules is the list of modules that have been
explicitly disabled. verbose is set if the output is to be displayed.
"""
check_module(target_config, disabled_modules, verbose, 'QtQuickWidgets',
'qquickwidget.h', 'new QQuickWidget()')
check_module(target_config, disabled_modules, verbose, 'QtWebSockets',
'qwebsocket.h', 'new QWebSocket()')
check_module(target_config, disabled_modules, verbose, 'Enginio',
'enginioclient.h', 'new EnginioClient()')
def check_5_4_modules(target_config, disabled_modules, verbose):
""" Check which modules introduced in Qt v5.4 can be built and update the
target configuration accordingly. target_config is the target
configuration. disabled_modules is the list of modules that have been
explicitly disabled. verbose is set if the output is to be displayed.
"""
check_module(target_config, disabled_modules, verbose, 'QtWebChannel',
'qwebchannel.h', 'new QWebChannel()')
def check_5_5_modules(target_config, disabled_modules, verbose):
""" Check which modules introduced in Qt v5.5 can be built and update the
target configuration accordingly. target_config is the target
configuration. disabled_modules is the list of modules that have been
explicitly disabled. verbose is set if the output is to be displayed.
"""
check_module(target_config, disabled_modules, verbose, 'QtLocation',
'qplace.h', 'new QPlace()')
check_module(target_config, disabled_modules, verbose, 'QtNfc',
'qnearfieldmanager.h', 'new QNearFieldManager()')
def check_5_10_modules(target_config, disabled_modules, verbose):
""" Check which modules introduced in Qt v5.10 can be built and update the
target configuration accordingly. target_config is the target
configuration. disabled_modules is the list of modules that have been
explicitly disabled. verbose is set if the output is to be displayed.
"""
check_module(target_config, disabled_modules, verbose, 'QtNetworkAuth',
'qtnetworkauthversion.h',
'const char *v = QTNETWORKAUTH_VERSION_STR')
def check_5_12_modules(target_config, disabled_modules, verbose):
""" Check which modules introduced in Qt v5.12 can be built and update the
target configuration accordingly. target_config is the target
configuration. disabled_modules is the list of modules that have been
explicitly disabled. verbose is set if the output is to be displayed.
"""
check_module(target_config, disabled_modules, verbose, 'QtRemoteObjects',
'qtremoteobjectsversion.h',
'const char *v = QTREMOTEOBJECTS_VERSION_STR')
def generate_makefiles(target_config, verbose, parts, tracing, fatal_warnings, distinfo):
""" Generate the makefiles to build everything. target_config is the
target configuration. verbose is set if the output is to be displayed.
parts is the number of parts the generated code should be split into.
tracing is set if the generated code should include tracing calls.
fatal_warnings is set if warnings are fatal. distinfo is set if a
.dist-info directory should be created.
"""
# For the top-level .pro file.
toplevel_pro = 'PyQt5.pro'
subdirs = []
# Set the SIP platform, version and feature flags.
sip_flags = get_sip_flags(target_config)
# Go through the modules.
pyqt_modules = list(target_config.pyqt_modules)
# Add the internal modules if they are required.
if not target_config.no_tools:
pyqt_modules.append('pylupdate')
pyqt_modules.append('pyrcc')
for mname in pyqt_modules:
metadata = MODULE_METADATA[mname]
if metadata.qpy_lib:
sp_qpy_dir = source_path('qpy', mname)
qpy_c_sources = [os.path.relpath(f, mname)
for f in matching_files(os.path.join(sp_qpy_dir, '*.c'))]
qpy_cpp_sources = [os.path.relpath(f, mname)
for f in matching_files(os.path.join(sp_qpy_dir, '*.cpp'))]
qpy_headers = [os.path.relpath(f, mname)
for f in matching_files(os.path.join(sp_qpy_dir, '*.h'))]
qpy_sources = qpy_c_sources + qpy_cpp_sources
else:
qpy_sources = []
qpy_headers = []
generate_sip_module_code(target_config, verbose, parts, tracing, mname,
fatal_warnings, sip_flags, metadata.public, qpy_sources,
qpy_headers)
subdirs.append(mname)
# Generate the composite module.
qtmod_sipdir = os.path.join('sip', 'Qt')
mk_clean_dir(qtmod_sipdir)
qtmod_sipfile = os.path.join(qtmod_sipdir, 'Qtmod.sip')
f = open_for_writing(qtmod_sipfile)
f.write('''%CompositeModule PyQt5.Qt
''')
for mname in COMPOSITE_COMPONENTS:
if mname in target_config.pyqt_modules:
f.write('%%Include %s/%smod.sip\n' % (mname, mname))
f.close()
generate_sip_module_code(target_config, verbose, parts, tracing, 'Qt',
fatal_warnings, sip_flags, False)
subdirs.append('Qt')
# Generate the top-level __init__.py.
inf = open(source_path('__init__.py'))
contents = inf.read()
inf.close()
inf = open_for_writing('__init__.py')
inf.write(contents)
if target_config.py_platform == 'win32':
# On Windows we try and make sure the Qt DLLs can be found, either any
# bundled copies or an existing installation (using the traditional
# Windows DLL search). We don't raise an exception in case the
# application has already taken steps to resolve this which we don't
# know about.
inf.write("""
def find_qt():
import os, sys
qtcore_dll = '\\\\Qt5Core.dll'
dll_dir = os.path.dirname(sys.executable)
if not os.path.isfile(dll_dir + qtcore_dll):
path = os.environ['PATH']
dll_dir = os.path.dirname(__file__) + '\\\\Qt\\\\bin'
if os.path.isfile(dll_dir + qtcore_dll):
path = dll_dir + ';' + path
os.environ['PATH'] = path
else:
for dll_dir in path.split(';'):
if os.path.isfile(dll_dir + qtcore_dll):
break
else:
return
try:
os.add_dll_directory(dll_dir)
except AttributeError:
pass
find_qt()
del find_qt
""")
inf.close()
# Generate any executable wrappers.
wrappers = []
if not target_config.no_tools:
# Generate the pylupdate5 and pyrcc5 wrappers.
for tool in ('pylupdate', 'pyrcc'):
wrappers.append((tool,
generate_tool_wrapper(target_config, tool + '5',
'PyQt5.%s_main' % tool)))
# Generate the pyuic5 wrapper.
wrappers.append(('pyuic',
generate_tool_wrapper(target_config, 'pyuic5',
'PyQt5.uic.pyuic')))
# Generate the Qt Designer plugin.
if not target_config.no_designer_plugin and 'QtDesigner' in target_config.pyqt_modules:
if generate_plugin_makefile(target_config, verbose, 'designer', target_config.designer_plugin_dir, "Qt Designer"):
subdirs.append('designer')
# Generate the qmlscene plugin.
if not target_config.no_qml_plugin and 'QtQml' in target_config.pyqt_modules:
if generate_plugin_makefile(target_config, verbose, 'qmlscene', target_config.qml_plugin_dir, "qmlscene"):
subdirs.append('qmlscene')
rewrite_qmldir(target_config, 'Charts',
source_path('examples', 'quick', 'tutorials', 'extending',
'chapter6-plugins'))
# Generate the QScintilla API file.
if target_config.qsci_api:
inform("Generating the QScintilla API file...")
f = open_for_writing('PyQt5.api')
for mname in target_config.pyqt_modules:
if MODULE_METADATA[mname].public:
api = open(mname + '.api')
for l in api:
f.write('PyQt5.' + l)
api.close()
os.remove(mname + '.api')
f.close()
# Generate the Python dbus module.
if target_config.pydbus_module_dir != '':
mname = 'dbus'
mk_dir(mname)
sp_src_dir = source_path(mname)
lib_dirs = ['-L' + l for l in target_config.dbus_lib_dirs]
lib_names = ['-l' + l for l in target_config.dbus_libs]
libs = ' '.join(lib_dirs + lib_names)
generate_module_makefile(target_config, verbose, mname,
include_paths=target_config.dbus_inc_dirs, libs=libs,
install_path=target_config.pydbus_module_dir,
src_dir=sp_src_dir)
subdirs.append(mname)
# Generate the top-level .pro file.
all_installs = []
inform("Generating the top-level .pro file...")
out_f = open_for_writing(toplevel_pro)
root_dir = qmake_quote(target_config.pyqt_module_dir + '/PyQt5')
for mname in pyqt_modules:
all_installs.append(
root_dir + '/' + module_file_name(target_config, mname))
all_installs.append(root_dir + '/' + module_file_name(target_config, 'Qt'))
out_f.write('''TEMPLATE = subdirs
CONFIG += ordered nostrip
SUBDIRS = %s
init_py.files = __init__.py
init_py.path = %s
INSTALLS += init_py
''' % (' '.join(subdirs), root_dir))
all_installs.append(root_dir + '/__init__.py')
# Install the uic module.
out_f.write('''
uic_package.files = %s
uic_package.path = %s
INSTALLS += uic_package
''' % (source_path('pyuic', 'uic'), root_dir))
all_installs.append(root_dir + '/uic')
# Install the tool main scripts and wrappers.
if wrappers:
wrapper_exes = []
for tool, wrapper in wrappers:
if tool != 'pyuic':
tool_main = tool + '_main.py'
out_f.write('''
%s.files = %s
%s.path = %s
INSTALLS += %s
''' % (tool, source_path('sip', tool, tool_main), tool, root_dir, tool))
all_installs.append(root_dir + '/' + tool_main)
wrapper_exes.append(wrapper)
all_installs.append(target_config.pyqt_bin_dir + '/' + wrapper)
out_f.write('''
tools.files = %s
tools.path = %s
INSTALLS += tools
''' % (' '.join(wrapper_exes), qmake_quote(target_config.pyqt_bin_dir)))
# Install the .sip files.
if target_config.pyqt_sip_dir:
for mname, metadata in MODULE_METADATA.items():
if metadata.public and mname != 'Qt':
sip_files = matching_files(source_path('sip', mname, '*.sip'))
if len(sip_files) != 0:
mdir = target_config.pyqt_sip_dir + '/' + mname
out_f.write('''
sip%s.path = %s
sip%s.files = %s
INSTALLS += sip%s
''' % (
mname, qmake_quote(mdir),
mname, ' '.join([qmake_quote(s) for s in sip_files]),
mname
))
all_installs.append(mdir)
# Install the stub files.
if target_config.py_version >= 0x030500 and target_config.pyqt_stubs_dir:
pyi_names = [mname + '.pyi'
for mname in target_config.pyqt_modules if mname[0] != '_']
out_f.write('''
pep484_stubs.files = %s
pep484_stubs.path = %s
INSTALLS += pep484_stubs
''' % (' '.join(pyi_names),
qmake_quote(target_config.pyqt_stubs_dir)))
all_installs.extend(
[target_config.pyqt_stubs_dir + '/' + pyi
for pyi in pyi_names])
# Install the QScintilla .api file.
if target_config.qsci_api:
api_dir = target_config.qsci_api_dir + '/api/python'
out_f.write('''
qscintilla_api.files = PyQt5.api
qscintilla_api.path = %s
INSTALLS += qscintilla_api
''' % qmake_quote(api_dir))
all_installs.append(api_dir + '/PyQt5.api')
if distinfo:
# The command to run to generate the .dist-info directory.
distinfo_dir = os.path.join(target_config.pyqt_module_dir,
'PyQt5-' + PYQT_VERSION_STR + '.dist-info')
run_mk_distinfo = '%s %s \\"$(INSTALL_ROOT)\\" %s installed.txt' % (
sys.executable, source_path('mk_distinfo.py'), distinfo_dir)
out_f.write('''
distinfo.extra = %s
distinfo.path = %s
INSTALLS += distinfo
''' % (run_mk_distinfo, root_dir))
# Create the file containing all installed files.
installed = open('installed.txt', 'w')
for install in all_installs:
installed.write(install + '\n')
installed.close()
out_f.close()
# Make the wrappers executable on platforms that support it. If we did it
# after running qmake then (on Linux) the execute bits would be stripped on
# installation.
if target_config.py_platform != 'win32':
for tool, wrapper in wrappers:
inform("Making the %s wrapper executable..." % wrapper)
sbuf = os.stat(wrapper)
mode = sbuf.st_mode
mode |= (stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
os.chmod(wrapper, mode)
# Generate the makefiles.
inform("Generating the Makefiles...")
run_qmake(target_config, verbose, toplevel_pro, recursive=True)
def generate_plugin_makefile(target_config, verbose, plugin_dir, install_dir, plugin_name):
""" Generate the makefile for a plugin that embeds the Python interpreter.
target_config is the target configuration. verbose is set if the output is
to be displayed. plugin_dir is the name of the directory containing the
plugin implementation. install_dir is the name of the directory that the
plugin will be installed in. plugin_name is a descriptive name of the
plugin to be used in user messages. Returns True if the makefile could be
generated.
"""
# Check we have a shared interpreter library.
if target_config.py_pyshlib == '':
inform("The %s plugin was disabled because a dynamic Python library couldn't be found." % plugin_name)
return False
# Create the qmake project file.
inform("Generating the %s plugin .pro file..." % plugin_name)
sp_plugin_dir = source_path(plugin_dir)
fin = open(os.path.join(sp_plugin_dir, '%s.pro-in' % plugin_dir))
prj = fin.read()
fin.close()
prj = prj.replace('@QTCONFIG@',
'debug' if target_config.debug else 'release')
prj = prj.replace('@PYINCDIR@', qmake_quote(target_config.py_inc_dir))
prj = prj.replace('@SIPINCDIR@', qmake_quote(target_config.sip_inc_dir))
prj = prj.replace('@PYLINK@', target_config.get_pylib_link_arguments())
prj = prj.replace('@PYSHLIB@', target_config.py_pyshlib)
prj = prj.replace('@QTPLUGINDIR@', qmake_quote(install_dir))
pro_name = os.path.join(plugin_dir, '%s.pro' % plugin_dir)
mk_dir(plugin_dir)
fout = open_for_writing(pro_name)
fout.write(prj)
if sp_plugin_dir != plugin_dir:
fout.write('''
INCLUDEPATH += %s
VPATH = %s
''' % (qmake_quote(sp_plugin_dir), qmake_quote(sp_plugin_dir)))
fout.write('\n'.join(target_config.qmake_variables) + '\n')
fout.close()
return True
def pro_sources(src_dir, other_headers=None, other_sources=None):
""" Return the HEADERS, SOURCES and OBJECTIVE_SOURCES variables for a .pro
file by introspecting a directory. src_dir is the name of the directory.
other_headers is an optional list of other header files. other_sources is
an optional list of other source files.
"""
pro_lines = []
headers = [os.path.basename(f) for f in matching_files('%s/*.h' % src_dir)]
if other_headers is not None:
headers += other_headers
if len(headers) != 0:
pro_lines.append('HEADERS = %s' % ' '.join(headers))
sources = [os.path.basename(f) for f in matching_files('%s/*.c' % src_dir)]
for f in matching_files('%s/*.cpp' % src_dir):
f = os.path.basename(f)
# Exclude any moc generated C++ files that might be around from a
# previous build.
if not f.startswith('moc_'):
sources.append(f)
if other_sources is not None:
sources += other_sources
if len(sources) != 0:
pro_lines.append('SOURCES = %s' % ' '.join([qmake_quote(s) for s in sources]))
objective_sources = [
os.path.basename(f) for f in matching_files('%s/*.mm' % src_dir)]
if len(objective_sources) != 0:
pro_lines.append('OBJECTIVE_SOURCES = %s' % ' '.join([qmake_quote(s) for s in objective_sources]))
return pro_lines
def module_file_name(target_config, name):
""" Return the name of a file implementing a module. """
if sys.platform == 'win32':
fs = '{}.lib' if target_config.static else '{}.pyd'
else:
fs = 'lib{}.a' if target_config.static else '{}.so'
return fs.format(name)
def generate_tool_wrapper(target_config, wrapper, module):
""" Create a platform dependent executable wrapper for a tool module.
target_config is the target configuration. wrapper is the name of the
wrapper without any extension. module is the tool module. Returns the
platform specific name of the wrapper.
"""
if target_config.py_platform == 'win32':
wrapper += '.bat'
inform("Generating the %s wrapper..." % wrapper)
exe = quote(target_config.pyuic_interpreter)
wf = open_for_writing(wrapper)
if target_config.py_platform == 'win32':
wf.write('@%s -m %s %%1 %%2 %%3 %%4 %%5 %%6 %%7 %%8 %%9\n' % (exe, module))
else:
wf.write('#!/bin/sh\n')
wf.write('exec %s -m %s ${1+"$@"}\n' % (exe, module))
wf.close()
return wrapper
def rewrite_qmldir(target_config, module, module_dir):
""" Re-write a qmldir file for a module that used the qmlscene plugin.
target_config is the target configuration. module is the name of the QML
module. module_dir is the name of the directory containing the QML module.
"""
qmldir_fn = os.path.join(module_dir, module, 'qmldir')
inform("Re-writing %s..." % qmldir_fn)
qmldir = open_for_writing(qmldir_fn)
qmldir.write('module %s\nplugin pyqt5qmlplugin %s\n' % (module, target_config.qml_plugin_dir))
qmldir.close()
def quote(path):
""" Return a path with quotes added if it contains spaces. path is the
path.
"""
if ' ' in path:
path = '"%s"' % path
return path
def qmake_quote(path):
""" Return a path quoted for qmake if it contains spaces. path is the
path.
"""
if ' ' in path:
path = '$$quote(%s)' % path
return path
def inform_user(target_config, sip_version):
""" Tell the user the values that are going to be used. target_config is
the target configuration. sip_version is the SIP version string.
"""
inform("Qt v%s is being used." %
version_to_string(target_config.qt_version))
inform("The qmake executable is %s." % target_config.qmake)
inform(
"Qt is built as a %s library." % (
"shared" if target_config.qt_shared else "static"))
if target_config.sysroot != '':
inform("The system root directory is %s." % target_config.sysroot)
inform("SIP %s is being used." % sip_version)
inform("The sip executable is %s." % target_config.sip)
inform("These PyQt5 modules will be built: %s." % ', '.join(target_config.pyqt_modules))
inform("The PyQt5 Python package will be installed in %s." % target_config.pyqt_module_dir)
if target_config.debug:
inform("A debug version of PyQt5 will be built.")
if target_config.py_debug:
inform("A debug build of Python is being used.")
if target_config.no_docstrings:
inform("PyQt5 is being built without generated docstrings.")
else:
inform("PyQt5 is being built with generated docstrings.")
if target_config.prot_is_public:
inform("PyQt5 is being built with 'protected' redefined as 'public'.")
if target_config.no_designer_plugin:
inform("The Designer plugin will not be built.")
else:
inform("The Designer plugin will be installed in %s." %
target_config.designer_plugin_dir)
if target_config.no_qml_plugin:
inform("The qmlscene plugin will not be built.")
else:
inform("The qmlscene plugin will be installed in %s." %
target_config.qml_plugin_dir)
if target_config.qsci_api:
inform(
"The QScintilla API file will be installed in %s." %
os.path.join(
target_config.qsci_api_dir, 'api', 'python'))
if target_config.py_version >= 0x030500 and target_config.pyqt_stubs_dir:
inform("The PyQt5 PEP 484 stub files will be installed in %s." %
target_config.pyqt_stubs_dir)
if target_config.pydbus_module_dir:
inform(
"The dbus support module will be installed in %s." %
target_config.pydbus_module_dir)
if target_config.pyqt_sip_dir:
inform("The PyQt5 .sip files will be installed in %s." %
target_config.pyqt_sip_dir)
if target_config.no_tools:
inform("pyuic5, pyrcc5 and pylupdate5 will not be built.")
else:
inform("pyuic5, pyrcc5 and pylupdate5 will be installed in %s." %
target_config.pyqt_bin_dir)
inform("The interpreter used by pyuic5 is %s." %
target_config.pyuic_interpreter)
if target_config.vend_enabled:
inform("PyQt5 will only be usable with signed interpreters.")
def run_qmake(target_config, verbose, pro_name, makefile_name='', fatal=True, recursive=False):
""" Run qmake against a .pro file. target_config is the target
configuration. verbose is set if the output is to be displayed. pro_name
is the name of the .pro file. makefile_name is the name of the makefile
to generate (and defaults to Makefile). fatal is set if a qmake failure is
considered a fatal error, otherwise False is returned if qmake fails.
recursive is set to use the -recursive flag.
"""
# qmake doesn't behave consistently if it is not run from the directory
# containing the .pro file - so make sure it is.
pro_dir, pro_file = os.path.split(pro_name)
if pro_dir != '':
cwd = os.getcwd()
os.chdir(pro_dir)
else:
cwd = None
mf = makefile_name if makefile_name != '' else 'Makefile'
remove_file(mf)
args = [quote(target_config.qmake)]
if target_config.qmake_spec != target_config.qmake_spec_default:
args.append('-spec')
args.append(target_config.qmake_spec)
if makefile_name != '':
args.append('-o')
args.append(makefile_name)
if recursive:
args.append('-recursive')
args.append(pro_file)
run_command(' '.join(args), verbose)
if not os.access(mf, os.F_OK):
if fatal:
error(
"%s failed to create a makefile from %s." %
(target_config.qmake, pro_name))
return False
# Restore the current directory.
if cwd is not None:
os.chdir(cwd)
return True
def run_make(target_config, verbose, exe, makefile_name):
""" Run make against a makefile to create an executable. target_config is
the target configuration. verbose is set if the output is to be displayed.
exe is the platform independent name of the executable that will be
created. makefile_name is the name of the makefile. Returns the platform
specific name of the executable, or None if an executable wasn't created.
"""
# Guess the name of make and set the default target and platform specific
# name of the executable.
if target_config.py_platform == 'win32':
if target_config.qmake_spec == 'win32-g++':
make = 'mingw32-make'
else:
make = 'nmake'
if target_config.debug:
makefile_target = 'debug'
platform_exe = os.path.join('debug', exe + '.exe')
else:
makefile_target = 'release'
platform_exe = os.path.join('release', exe + '.exe')
else:
make = 'make'
makefile_target = ''
if target_config.py_platform == 'darwin':
platform_exe = os.path.join(exe + '.app', 'Contents', 'MacOS', exe)
else:
platform_exe = os.path.join('.', exe)
remove_file(platform_exe)
args = [make, '-f', makefile_name]
if makefile_target != '':
args.append(makefile_target)
run_command(' '.join(args), verbose)
return platform_exe if os.access(platform_exe, os.X_OK) else None
def run_command(cmd, verbose):
""" Run a command and display the output if requested. cmd is the command
to run. verbose is set if the output is to be displayed.
"""
if verbose:
sys.stdout.write(cmd + "\n")
fout = get_command_output(cmd, and_stderr=True)
# Read stdout and stderr until there is no more output.
lout = fout.readline()
while lout:
if verbose:
if sys.hexversion >= 0x03000000:
sys.stdout.write(str(lout, encoding=sys.stdout.encoding))
else:
sys.stdout.write(lout)
lout = fout.readline()
close_command_pipe(fout)
def remove_file(fname):
""" Remove a file which may or may not exist. fname is the name of the
file.
"""
try:
os.remove(fname)
except OSError:
pass
def check_vendorid(target_config):
""" See if the VendorID library and include file can be found.
target_config is the target configuration.
"""
if target_config.py_version >= 0x030000:
# VendorID doesn't support Python v3.
target_config.vend_enabled = False
elif target_config.vend_enabled:
if os.access(os.path.join(target_config.vend_inc_dir, 'vendorid.h'), os.F_OK):
if glob.glob(os.path.join(target_config.vend_lib_dir, '*vendorid*')):
inform("The VendorID package was found.")
else:
target_config.vend_enabled = False
inform(
"The VendorID library could not be found in %s and so "
"signed interpreter checking will be disabled. If the "
"VendorID package is installed then use the "
"--vendorid-libdir argument to explicitly specify the "
"correct directory." % target_config.vend_lib_dir)
else:
target_config.vend_enabled = False
inform(
"vendorid.h could not be found in %s and so signed "
"interpreter checking will be disabled. If the VendorID "
"package is installed then use the --vendorid-incdir "
"argument to explicitly specify the correct directory." %
target_config.vend_inc_dir)
def get_command_output(cmd, and_stderr=False):
""" Return a pipe from which a command's output can be read. cmd is the
command. and_stderr is set if the output should include stderr as well as
stdout.
"""
try:
import subprocess
except ImportError:
if and_stderr:
_, sout = os.popen4(cmd)
else:
_, sout, _ = os.popen3(cmd)
return sout
if and_stderr:
stderr = subprocess.STDOUT
else:
stderr = subprocess.PIPE
p = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=stderr)
return p.stdout
def close_command_pipe(pipe):
""" Close the pipe returned by get_command_output(). """
pipe.close()
try:
os.wait()
except:
pass
def source_path(*names):
""" Return the native path for a list of components rooted at the directory
containing this script. names is the sequence of component names.
"""
path = [os.path.dirname(os.path.abspath(__file__))] + list(names)
return os.path.join(*path)
def check_dbus(target_config, verbose):
""" See if the DBus support module should be built and update the target
configuration accordingly. target_config is the target configuration.
verbose is set if the output is to be displayed.
"""
if target_config.no_pydbus or not os.path.isdir(source_path('dbus')):
return
inform("Checking to see if the dbus support module should be built...")
cmd = 'pkg-config --cflags-only-I --libs dbus-1'
if verbose:
sys.stdout.write(cmd + "\n")
sout = get_command_output(cmd)
iflags = sout.read().strip()
close_command_pipe(sout)
if not iflags:
inform("DBus v1 does not seem to be installed.")
return
if sys.hexversion >= 0x03000000:
iflags = iflags.decode()
for f in iflags.split():
if f.startswith('-I'):
target_config.dbus_inc_dirs.append(f[2:])
elif f.startswith('-L'):
target_config.dbus_lib_dirs.append(f[2:])
elif f.startswith('-l'):
target_config.dbus_libs.append(f[2:])
try:
import dbus.mainloop
except:
inform("The Python dbus module doesn't seem to be installed.")
return
target_config.pydbus_module_dir = dbus.mainloop.__path__[0]
# Try and find dbus-python.h. We don't use pkg-config because it is broken
# for dbus-python (at least for versions up to and including v0.81.0).
# Instead we look where DBus itself is installed - which in most cases will
# be where dbus-python is also installed.
if target_config.pydbus_inc_dir != '':
target_config.dbus_inc_dirs = [target_config.pydbus_inc_dir]
for d in target_config.dbus_inc_dirs:
if os.access(os.path.join(d, 'dbus', 'dbus-python.h'), os.F_OK):
break
else:
inform(
"dbus/dbus-python.h could not be found and so the DBus "
"support module will be disabled. If dbus-python v0.80 or "
"later is installed then use the --dbus argument to "
"explicitly specify the directory containing "
"dbus/dbus-python.h.")
target_config.pydbus_module_dir = ''
def check_module(target_config, disabled_modules, verbose, mname, incfile=None, test=None):
""" See if a module can be built and, if so, add it to the target
configurations list of modules. target_config is the target configuration.
disabled_modules is the list of modules that have been explicitly disabled.
verbose is set if the output is to be displayed. mname is the name of the
module. incfile is the name of the include file (or sequence of multiple
include files) needed for the test. test is a C++ statement being used for
the test. If either incfile or test are None then there is a test program
that needs to be run and its output captured.
"""
if mname in disabled_modules:
return
# Check the module's main .sip file exists.
if not os.access(source_path('sip', mname, mname + 'mod.sip'), os.F_OK):
return
if verbose:
sys.stdout.write('\n')
inform("Checking to see if the %s module should be built..." % mname)
if incfile is None or test is None:
source = None
else:
if isinstance(incfile, str):
incfile = [incfile]
incfile = ['#include<%s>' % i for i in incfile]
source = '''%s
int main(int, char **)
{
%s;
}
''' % ('\n'.join(incfile), test)
test = compile_test_program(target_config, verbose, mname, source)
if test is None:
return
# If there was an explicit test program then run it to get the disabled
# features.
if source is None:
for disabled in run_test_program(mname, test, verbose):
if disabled:
inform("Disabled %s feature: %s" % (mname, disabled))
target_config.pyqt_disabled_features.append(disabled)
# Include the module in the build.
target_config.pyqt_modules.append(mname)
def compile_test_program(target_config, verbose, mname, source=None, debug=None):
""" Compile the source of a Qt program and return the name of the
executable or None if it couldn't be created. target_config is the target
configuration. verbose is set if the output is to be displayed. mname is
the name of the PyQt module being tested. source is the C++ source of the
program. If it is None then the source is expected to be found in the
config-tests directory. debug is set if debug, rather than release, mode
is to be used. If it is None then the mode is taken from the target
configuration.
"""
metadata = MODULE_METADATA[mname]
# The derived file names.
name = 'cfgtest_' + mname
name_pro = name + '.pro'
name_makefile = name + '.mk'
name_source = name + '.cpp'
# Create the source file if necessary.
if source is None:
name_source = source_path('config-tests', name_source)
else:
f = open_for_writing(name_source)
f.write(source)
f.close()
# Create the .pro file.
pro_lines = []
pro_add_qt_dependencies(target_config, metadata, pro_lines, debug)
pro_lines.append('TARGET = %s' % name)
pro_lines.append('SOURCES = %s' % qmake_quote(name_source))
f = open_for_writing(name_pro)
f.write('\n'.join(pro_lines))
f.close()
if not run_qmake(target_config, verbose, name_pro, name_makefile, fatal=False):
return None
return run_make(target_config, verbose, name, name_makefile)
def run_test_program(mname, test, verbose):
""" Run a test program and return the output as a list of lines. mname is
the name of the PyQt module being tested. test is the name of the test
executable. verbose is set if the output is to be displayed.
"""
out_file = 'cfgtest_' + mname + '.out'
# Create the output file, first making sure it doesn't exist.
remove_file(out_file)
run_command(test + ' ' + out_file, verbose)
if not os.access(out_file, os.F_OK):
error("%s failed to create %s. Make sure your Qt installation is correct." % (test, out_file))
# Read the details.
f = open(out_file)
lines = f.read().strip()
f.close()
return lines.split('\n') if lines else []
def pro_add_qt_dependencies(target_config, metadata, pro_lines, debug=None):
""" Add the Qt dependencies of a module to a .pro file. target_config is
the target configuration. metadata is the module's meta-data. pro_lines
is the list of lines making up the .pro file that is updated. debug is set
if debug, rather than release, mode is to be used. If it is None then the
mode is taken from the target configuration.
"""
if debug is None:
debug = target_config.debug
add = []
remove = []
for qt in metadata.qmake_QT:
if qt.startswith('-'):
remove.append(qt[1:])
else:
add.append(qt)
if len(remove) != 0:
pro_lines.append('QT -= %s' % ' '.join(remove))
if len(add) != 0:
pro_lines.append('QT += %s' % ' '.join(add))
pro_lines.append(
'CONFIG += %s' % ('debug' if debug else 'release'))
if metadata.cpp11:
pro_lines.append('CONFIG += c++11')
pro_lines.extend(target_config.qmake_variables)
def get_sip_flags(target_config):
""" Return the SIP platform, version and feature flags. target_config is
the target configuration.
"""
sip_flags = ['-n', 'sip']
# If we don't check for signed interpreters, we exclude the 'VendorID'
# feature
if target_config.py_version < 0x030000 and not target_config.vend_enabled:
sip_flags.append('-x')
sip_flags.append('VendorID')
# Handle Python debug builds.
if target_config.py_debug:
sip_flags.append('-D')
# Handle the platform tag. (Allow for win32-g++.)
if target_config.py_platform.startswith('win32'):
plattag = 'WS_WIN'
elif target_config.py_platform == 'darwin':
plattag = 'WS_MACX'
else:
plattag = 'WS_X11'
sip_flags.append('-t')
sip_flags.append(plattag)
# Handle the Qt version tag.
sip_flags.append('-t')
sip_flags.append(version_to_sip_tag(target_config.qt_version))
# Handle any feature flags.
for xf in target_config.pyqt_disabled_features:
sip_flags.append('-x')
sip_flags.append(xf)
# Handle the version specific Python features.
if target_config.py_version < 0x030000:
sip_flags.append('-x')
sip_flags.append('Py_v3')
return sip_flags
def mk_clean_dir(name):
""" Create a clean (ie. empty) directory. name is the name of the
directory.
"""
try:
shutil.rmtree(name)
except:
pass
try:
os.makedirs(name)
except:
error("Unable to create the %s directory." % name)
def mk_dir(name):
""" Ensure a directory exists, creating it if necessary. name is the name
of the directory.
"""
try:
os.makedirs(name)
except:
pass
def generate_sip_module_code(target_config, verbose, parts, tracing, mname, fatal_warnings, sip_flags, doc_support, qpy_sources=None, qpy_headers=None):
""" Generate the code for a module. target_config is the target
configuration. verbose is set if the output is to be displayed. parts is
the number of parts the generated code should be split into. tracing is
set if the generated code should include tracing calls. mname is the name
of the module to generate the code for. fatal_warnings is set if warnings
are fatal. sip_flags is the list of flags to pass to sip. doc_support
is set if documentation support is to be generated for the module.
qpy_sources is the optional list of QPy support code source files.
qpy_headers is the optional list of QPy support code header files.
"""
inform("Generating the C++ source for the %s module..." % mname)
mk_clean_dir(mname)
# Build the SIP command line.
argv = [target_config.sip, '-w']
if target_config.abi_version:
argv.append('--abi-version')
argv.append(target_config.abi_version)
argv.extend(sip_flags)
if fatal_warnings:
argv.append('-f')
if target_config.prot_is_public:
argv.append('-P');
if parts != 0:
argv.append('-j')
argv.append(str(parts))
if tracing:
argv.append('-r')
if doc_support:
if not target_config.no_docstrings:
argv.append('-o');
if target_config.qsci_api:
argv.append('-a')
argv.append(mname + '.api')
if target_config.py_version >= 0x030500 and target_config.pyqt_stubs_dir:
argv.append('-y')
argv.append(mname + '.pyi')
# Pass the absolute pathname so that #line files are absolute.
argv.append('-c')
argv.append(os.path.abspath(mname))
argv.append('-I')
argv.append('sip')
sp_sip_dir = source_path('sip')
if sp_sip_dir != 'sip':
# SIP assumes POSIX style separators.
sp_sip_dir = sp_sip_dir.replace('\\', '/')
argv.append('-I')
argv.append(sp_sip_dir)
# The .sip files for the Qt modules will be in the out-of-tree directory.
if mname == 'Qt':
sip_dir = 'sip'
else:
sip_dir = sp_sip_dir
# Add the name of the .sip file.
argv.append('%s/%s/%smod.sip' % (sip_dir, mname, mname))
run_command(' '.join([quote(a) for a in argv]), verbose)
# Check the result.
if mname == 'Qt':
file_check = 'sip%scmodule.c' % mname
else:
file_check = 'sipAPI%s.h' % mname
if not os.access(os.path.join(mname, file_check), os.F_OK):
error("Unable to create the C++ code.")
# Embed the sip flags.
if mname == 'QtCore':
inform("Embedding sip flags...")
in_f = open(source_path('qpy', 'QtCore', 'qpycore_post_init.cpp.in'))
out_f = open_for_writing(
os.path.join('QtCore', 'qpycore_post_init.cpp'))
for line in in_f:
line = line.replace('@@PYQT_SIP_FLAGS@@', ' '.join(sip_flags))
out_f.write(line)
in_f.close()
out_f.close()
# Generate the makefile.
include_paths = []
libs = ''
if target_config.vend_enabled:
if mname == 'QtCore':
include_paths.append(target_config.vend_inc_dir)
libs = '-L%s -lvendorid' % target_config.vend_lib_dir
generate_module_makefile(target_config, verbose, mname,
include_paths=include_paths, libs=libs, qpy_sources=qpy_sources,
qpy_headers=qpy_headers)
def generate_module_makefile(target_config, verbose, mname, include_paths=None, libs='', install_path='', src_dir='', qpy_sources=None, qpy_headers=None):
""" Generate the makefile for a module. target_config is the target
configuration. verbose is set if the output is to be displayed. mname is
the name of the module. include_paths is an optional list of values of
INCLUDEPATH. libs is an optional additional value of LIBS. install_path
is the optional name of the directory that the module will be installed in.
src_dir is the optional source directory (by default the sources are
assumed to be in the module directory). qpy_sources is the optional list
of QPy support code source files. qpy_headers is the optional list of QPy
support code header files.
"""
if verbose:
sys.stdout.write('\n')
inform("Generating the .pro file for the %s module..." % mname)
if src_dir == '':
src_dir = mname
target_name = mname
metadata = MODULE_METADATA[mname]
if metadata.qmake_TARGET != '':
target_name = metadata.qmake_TARGET
pro_lines = ['TEMPLATE = lib']
# Note some version of Qt5 (probably incorrectly) implements
# 'plugin_bundle' instead of 'plugin' so we specify both.
pro_lines.append('CONFIG += warn_on exceptions_off %s' % ('staticlib hide_symbols' if target_config.static else 'plugin plugin_bundle'))
pro_add_qt_dependencies(target_config, metadata, pro_lines)
if target_config.qml_debug:
pro_lines.append('CONFIG += qml_debug')
# Work around QTBUG-39300.
pro_lines.append('CONFIG -= android_install')
pro_lines.append('TARGET = %s' % target_name)
if not target_config.static:
debug_suffix = target_config.get_win32_debug_suffix()
# For Qt v5.5 make sure these frameworks are already loaded by the time
# the libqcocoa.dylib plugin gets loaded. This problem seems to be
# fixed in Qt v5.6.
extra_lflags = ''
if mname == 'QtGui':
# Note that this workaround is flawed because it looks at the PyQt
# configuration rather than the Qt configuration. It will fail if
# the user is building a PyQt without the QtDBus module against a
# Qt with the QtDBus library. However it will be fine for the
# common case where the PyQt configuration reflects the Qt
# configuration.
fwks = []
for m in ('QtPrintSupport', 'QtDBus', 'QtWidgets'):
if m in target_config.pyqt_modules:
fwks.append('-framework ' + m)
if len(fwks) != 0:
extra_lflags = 'QMAKE_LFLAGS += "%s"\n ' % ' '.join(fwks)
# Without the 'no_check_exist' magic the target.files must exist when
# qmake is run otherwise the install and uninstall targets are not
# generated.
shared = '''
win32 {
PY_MODULE = %s%s.pyd
PY_MODULE_SRC = $(DESTDIR_TARGET)
} else {
PY_MODULE = %s.so
macx {
PY_MODULE_SRC = $(TARGET).plugin/Contents/MacOS/$(TARGET)
QMAKE_LFLAGS += "-undefined dynamic_lookup"
equals(QT_MINOR_VERSION, 5) {
%sQMAKE_RPATHDIR += $$[QT_INSTALL_LIBS]
}
} else {
PY_MODULE_SRC = $(TARGET)
}
}
QMAKE_POST_LINK = $(COPY_FILE) $$PY_MODULE_SRC $$PY_MODULE
target.CONFIG = no_check_exist
target.files = $$PY_MODULE
''' % (target_name, debug_suffix, target_name, extra_lflags)
pro_lines.extend(shared.split('\n'))
if install_path == '':
install_path = target_config.pyqt_module_dir + '/PyQt5'
install_path = install_path.replace('\\', '/')
pro_lines.append('target.path = %s' % install_path)
pro_lines.append('INSTALLS += target')
# This optimisation could apply to other platforms.
if 'linux' in target_config.qmake_spec and not target_config.static:
if target_config.py_version >= 0x030000:
entry_point = 'PyInit_%s' % target_name
else:
entry_point = 'init%s' % target_name
exp = open_for_writing(os.path.join(mname, target_name + '.exp'))
exp.write('{ global: %s; local: *; };' % entry_point)
exp.close()
pro_lines.append('QMAKE_LFLAGS += -Wl,--version-script=%s.exp' % target_name)
if target_config.prot_is_public:
pro_lines.append('DEFINES += SIP_PROTECTED_IS_PUBLIC protected=public')
# This is needed for Windows.
pro_lines.append('INCLUDEPATH += .')
target_config.add_sip_h_directives(pro_lines)
if metadata.qpy_lib:
# This is the easiest way to make sure it is set for handwritten code.
if not target_config.py_debug:
pro_lines.append('DEFINES += Py_LIMITED_API=0x03040000')
pro_lines.append('INCLUDEPATH += %s' %
qmake_quote(os.path.relpath(source_path('qpy', mname), mname)))
if include_paths:
pro_lines.append(
'INCLUDEPATH += ' + ' '.join(
[qmake_quote(p) for p in include_paths]))
if libs != '':
pro_lines.append('LIBS += %s' % libs)
if src_dir != mname:
pro_lines.append('INCLUDEPATH += %s' % qmake_quote(src_dir))
pro_lines.append('VPATH = %s' % qmake_quote(src_dir))
pro_lines.extend(pro_sources(src_dir, qpy_headers, qpy_sources))
pro_name = os.path.join(mname, mname + '.pro')
pro = open_for_writing(pro_name)
pro.write('\n'.join(pro_lines))
pro.write('\n')
pro.close()
def fix_license(src_lfile, dst_lfile):
""" Fix the license file, if there is one, so that it conforms to the SIP
v5 syntax. src_lfile is the name of the license file. dst_lfile is the
name of the fixed license file.
"""
f = open(src_lfile)
f5 = open_for_writing(dst_lfile)
for line in f:
if line.startswith('%License'):
anno_start = line.find('/')
anno_end = line.rfind('/')
if anno_start < 0 or anno_end < 0 or anno_start == anno_end:
error("%s has missing annotations." % name)
annos = line[anno_start + 1:anno_end].split(', ')
annos5 = [anno[0].lower() + anno[1:] for anno in annos]
f5.write('%License(')
f5.write(', '.join(annos5))
f5.write(')\n')
else:
f5.write(line)
f5.close()
f.close()
def check_license(target_config, license_confirmed):
""" Handle the validation of the PyQt5 license. target_config is the
target configuration. license_confirmed is set if the user has already
accepted the license.
"""
try:
import license
ltype = license.LicenseType
lname = license.LicenseName
try:
lfile = license.LicenseFile
except AttributeError:
lfile = None
except ImportError:
ltype = None
if ltype is None:
ltype = 'GPL'
lname = "GNU General Public License"
lfile = 'pyqt-gpl.sip'
inform(
"This is the %s version of PyQt %s (licensed under the %s) for "
"Python %s on %s." %
(ltype, PYQT_VERSION_STR, lname, sys.version.split()[0],
sys.platform))
# Confirm the license if not already done.
if not license_confirmed:
loptions = """
Type 'L' to view the license.
"""
sys.stdout.write(loptions)
sys.stdout.write("""Type 'yes' to accept the terms of the license.
Type 'no' to decline the terms of the license.
""")
while 1:
sys.stdout.write("Do you accept the terms of the license? ")
sys.stdout.flush()
try:
resp = sys.stdin.readline()
except KeyboardInterrupt:
raise SystemExit
except:
resp = ""
resp = resp.strip().lower()
if resp == "yes":
break
if resp == "no":
sys.exit(0)
if resp == 'l':
os.system('more LICENSE')
# Check that the license file exists and fix its syntax.
sip_dir = 'sip'
mk_dir(sip_dir)
src_lfile = os.path.join(target_config.license_dir, lfile)
if os.access(src_lfile, os.F_OK):
inform("Found the license file %s." % lfile)
fix_license(src_lfile, os.path.join(sip_dir, lfile + '5'))
else:
error(
"Please copy the license file %s to %s." % (lfile,
target_config.license_dir))
def check_qt(target_config):
""" Check the Qt installation. target_config is the target configuration.
"""
# Starting with v4.7, Qt (when built with MinGW) assumes that stack frames
# are 16 byte aligned because it uses SSE. However the Python Windows
# installers are built with 4 byte aligned stack frames. We therefore need
# to tweak the g++ flags to deal with it.
if target_config.qmake_spec == 'win32-g++':
target_config.qmake_variables.append('QMAKE_CFLAGS += -mstackrealign')
target_config.qmake_variables.append('QMAKE_CXXFLAGS += -mstackrealign')
def check_python(target_config):
""" Check the Python installation. target_config is the target
configuration.
"""
# Check the Python version number. This allows us to assume relative
# imports and ElemenTree are available.
if target_config.py_version < 0x020600:
error("PyQt5 requires Python v2.6 or later.")
def check_sip(target_config, verbose):
""" Check that the version of sip is good enough and return its version.
target_config is the target configuration.
"""
if target_config.sip is None:
error(
"Make sure you have a working sip on your PATH or use the "
"--sip argument to explicitly specify a working sip.")
pipe = os.popen(' '.join([quote(target_config.sip), '-V']))
for l in pipe:
version_str = l.strip()
break
else:
error("'%s -V' did not generate any output." % target_config.sip)
pipe.close()
if '.dev' in version_str or 'snapshot' in version_str:
# We only need to distinguish between sip v4 and sip v5.
if target_config.using_sip5():
version = 0x050000
else:
version = 0x040000
else:
version = version_from_string(version_str)
if version is None:
error(
"'%s -V' generated unexpected output: '%s'." % (
target_config.sip, version_str))
min_version = version_from_string(SIP_MIN_VERSION)
if version < min_version:
error(
"This version of PyQt5 requires sip %s or later." %
SIP_MIN_VERSION)
if version >= 0x050000:
# Install the sip.h file for the private sip module.
if target_config.sip_inc_dir is None:
target_config.sip_inc_dir = os.path.join(
os.path.abspath(os.getcwd()), 'include')
inform("Installing sip.h in %s..." % target_config.sip_inc_dir)
os.makedirs(target_config.sip_inc_dir, exist_ok=True)
argv = ['sip-module', '--sip-h']
if target_config.abi_version:
argv.append('--abi-version')
argv.append(target_config.abi_version)
argv.append('--target-dir')
argv.append(quote(target_config.sip_inc_dir)),
argv.append('PyQt5.sip')
run_command(' '.join(argv), verbose)
if not os.access(os.path.join(target_config.sip_inc_dir, 'sip.h'), os.F_OK):
error(
"sip-module failed to install sip.h in %s." %
target_config.sip_inc_dir)
else:
if target_config.sip_inc_dir is None:
target_config.sip_inc_dir = target_config.py_venv_inc_dir
return version_str
def version_from_string(version_str):
""" Convert a version string of the form m.n or m.n.o to an encoded version
number (or None if it was an invalid format). version_str is the version
string.
"""
parts = version_str.split('.')
if not isinstance(parts, list):
return None
if len(parts) == 2:
parts.append('0')
if len(parts) != 3:
return None
version = 0
for part in parts:
try:
v = int(part)
except ValueError:
return None
version = (version << 8) + v
return version
def open_for_writing(fname):
""" Return a file opened for writing while handling the most common problem
of not having write permission on the directory. fname is the name of the
file to open.
"""
try:
return open(fname, 'w')
except IOError:
error(
"There was an error creating %s. Make sure you have write "
"permission on the parent directory." % fname)
def matching_files(pattern):
""" Return a reproducable list of files that match a pattern. """
return sorted(glob.glob(pattern))
def main(argv):
""" Create the configuration module module. argv is the list of command
line arguments.
"""
# Create the default target configuration.
target_config = TargetConfiguration()
# Parse the command line.
parser = create_optparser(target_config)
opts, target_config.qmake_variables = parser.parse_args()
target_config.apply_pre_options(opts)
# Query qmake for the basic configuration information.
target_config.get_qt_configuration()
# Update the target configuration.
if opts.config_file is not None:
target_config.from_configuration_file(opts.config_file)
else:
target_config.from_introspection(opts.verbose, opts.debug)
target_config.post_configuration()
target_config.apply_post_options(opts)
# Check the licenses are compatible.
check_license(target_config, opts.license_confirmed)
# Check Python is what we need.
check_python(target_config)
# Check SIP is what we need.
sip_version = check_sip(target_config, opts.verbose)
# Check Qt is what we need.
check_qt(target_config)
# Check for the VendorID package.
check_vendorid(target_config)
# Check which modules to build if we haven't been told.
if len(target_config.pyqt_modules) == 0:
check_modules(target_config, opts.disabled_modules, opts.verbose)
else:
# Check that the user supplied module names are valid.
for mname in target_config.pyqt_modules:
if mname not in MODULE_METADATA:
error("'%s' is not a valid module name." % mname)
check_dbus(target_config, opts.verbose)
# Tell the user what's been found.
inform_user(target_config, sip_version)
# Generate the makefiles.
generate_makefiles(target_config, opts.verbose,
opts.split if opts.concat else 0, opts.tracing,
opts.fatal_warnings, opts.distinfo)
###############################################################################
# The script starts here.
###############################################################################
if __name__ == '__main__':
try:
main(sys.argv)
except SystemExit:
raise
except:
sys.stderr.write(
"""An internal error occured. Please report all the output from the program,
including the following traceback, to support@riverbankcomputing.com.
""")
raise
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。