#-----------------------------------------------------------------------------
RT_ICON = 3
RT_GROUP_ICON = 14
LOAD_LIBRARY_AS_DATAFILE = 2
import struct
import types
try:
StringTypes = types.StringTypes
except AttributeError:
StringTypes = [ type("") ]
import PyInstaller.log as logging
logger = logging.getLogger('PyInstaller.icon')
class Structure:
def __init__(self):
size = self._sizeInBytes = struct.calcsize(self._format_)
self._fields_ = list(struct.unpack(self._format_, '\000' * size))
indexes = self._indexes_ = {}
for i, nm in enumerate(self._names_):
indexes[nm] = i
def dump(self):
logger.info("DUMP of %s", self)
for name in self._names_:
if not name.startswith('_'):
logger.info("%20s = %s", name, getattr(self, name))
logger.info("")
Manipulating with dynamic libraries.
"""
__all__ = ["exclude_list", "include_list", "include_library"]
import os
import re
from PyInstaller import is_win, is_unix, is_aix, is_darwin
from PyInstaller.compat import set
import PyInstaller.log as logging
logger = logging.getLogger("PyInstaller.build.dylib")
_BOOTLOADER_FNAMES = set(["run", "run_d", "runw", "runw_d"])
# Regex excludes
# Ignoring some system libraries speeds up packaging process
_excludes = {}
# Regex includes - overrides excludes.
# Include list is used only to override specific libraries
# from exclude list.
_includes = {}
_win_excludes = {
#-----------------------------------------------------------------------------
# Copyright (c) 2015-2016, PyInstaller Development Team.
#
# Distributed under the terms of the GNU General Public License with exception
# for distributing bootloader.
#
# The full license is in the file COPYING.txt, distributed with this software.
#-----------------------------------------------------------------------------
from PyInstaller.utils.hooks import is_module_satisfies
from PyInstaller import log as logging
if is_module_satisfies('kivy >= 1.9.1'):
from kivy.tools.packaging.pyinstaller_hooks import (
add_dep_paths, excludedimports, datas, get_deps_all,
get_factory_modules, kivy_modules)
add_dep_paths()
hiddenimports = get_deps_all()['hiddenimports']
hiddenimports = list(set(get_factory_modules() + kivy_modules +
hiddenimports))
else:
logger = logging.getLogger(__name__)
logger.warn('Hook disabled because of Kivy version < 1.9.1')
# Windows gets one for modules gotten from the Registry
# There should be one for Frozen modules
# Mac would have them for PY_RESOURCE modules etc.
# A generalization of Owner - their concept of "turf" is broader
import os
import sys
import imp
import marshal
from PyInstaller import depend
import PyInstaller.depend.owner
import PyInstaller.log as logging
logger = logging.getLogger('PyInstaller.build.mf')
def getDescr(fnm):
ext = os.path.splitext(fnm)[1]
for (suffix, mode, typ) in imp.get_suffixes():
if suffix == ext:
return (suffix, mode, typ)
class ImportDirector(PyInstaller.depend.owner.Owner):
pass
class BuiltinImportDirector(ImportDirector):
def __init__(self):
Manipulating with dynamic libraries.
"""
__all__ = ['exclude_list', 'include_list', 'include_library']
import os
import re
from PyInstaller.compat import is_win, is_unix, is_aix, is_darwin
import PyInstaller.log as logging
logger = logging.getLogger(__name__)
_BOOTLOADER_FNAMES = set(['run', 'run_d', 'runw', 'runw_d'])
# Regex excludes
# Ignoring some system libraries speeds up packaging process
_excludes = {}
# Regex includes - overrides excludes.
# Include list is used only to override specific libraries
# from exclude list.
_includes = {}
_win_includes = {
# DLLs are from 'Microsoft Visual C++ 2010 Redistributable Package'.
"""
Manipulating with dynamic libraries.
"""
__all__ = ['exclude_list', 'include_list', 'include_library']
import os
import re
from PyInstaller import is_win, is_unix, is_aix, is_darwin
from PyInstaller.compat import set
import PyInstaller.log as logging
logger = logging.getLogger('PyInstaller.build.dylib')
_BOOTLOADER_FNAMES = set(['run', 'run_d', 'runw', 'runw_d'])
# Regex excludes
# Ignoring some system libraries speeds up packaging process
_excludes = {}
# Regex includes - overrides excludes.
# Include list is used only to override specific libraries
# from exclude list.
_includes = {}
_win_excludes = {
def main():
try:
parser = optparse.OptionParser(usage='%prog [options] [TEST-NAME ...]',
epilog='TEST-NAME can be the name of the .py-file, '
'the .spec-file or only the basename.')
except TypeError:
parser = optparse.OptionParser(usage='%prog [options] [TEST-NAME ...]')
parser.add_option('-a', '--all-with-crypto', action='store_true',
help='Run the whole test suite with bytecode encryption enabled.')
parser.add_option('-c', '--clean', action='store_true',
help='Clean up generated files')
parser.add_option('-i', '--interactive-tests', action='store_true',
help='Run interactive tests (default: run normal tests)')
parser.add_option('-v', '--verbose',
action='store_true',
default=False,
help='Verbose mode (default: %default)')
parser.add_option('--known-fails', action='store_true',
dest='run_known_fails',
help='Run tests known to fail, too.')
opts, args = parser.parse_args()
# Do only cleanup.
if opts.clean:
clean()
raise SystemExit() # Exit code is 0 in this case.
# Run only specified tests.
if args:
if opts.interactive_tests:
parser.error('Must not specify -i/--interactive-tests when passing test names.')
suite = unittest.TestSuite()
for arg in args:
test_list = glob.glob(arg)
if not test_list:
test_list = [arg]
else:
test_list = [x for x in test_list
if os.path.splitext(x)[1] in (".py", ".spec")]
# Sort tests aplhabetically. For example test
# basic/test_nested_launch1 depends on the executable from
# basic/test_nested_launch0, which it runs.
test_list.sort()
for t in test_list:
test_dir = os.path.dirname(t)
test_script = os.path.basename(os.path.splitext(t)[0])
suite.addTest(GenericTestCase(test_script, test_dir=test_dir,
run_known_fails=opts.run_known_fails))
print('Running test: ', (test_dir + '/' + test_script))
# Run all tests or all interactive tests.
else:
if opts.interactive_tests:
print('Running interactive tests...')
test_classes = [InteractiveTestCase]
elif opts.all_with_crypto:
print('Running normal tests with bytecode encryption...')
# Make sure to exclude CryptoTestCase here since we are building
# everything else with crypto enabled.
test_classes = [BasicTestCase, ImportTestCase,
LibrariesTestCase, MultipackageTestCase]
else:
print('Running normal tests (-i for interactive tests)...')
test_classes = [BasicTestCase, CryptoTestCase, ImportTestCase,
LibrariesTestCase, MultipackageTestCase]
# Create test suite.
generator = TestCaseGenerator()
suite = generator.create_suite(test_classes, opts.all_with_crypto,
opts.run_known_fails)
# Set global options
global VERBOSE, REPORT, PYI_CONFIG
VERBOSE = opts.verbose
# The function called by configure.get_config uses logging. So, we need to
# set a logging level now, in addition to passing it as a "log-level=XXXX"
# option in test_building (see the OPTS dict), in order for the logging
# level to be consistent. Otherwise, the default logging level of INFO will
# produce messages, then be overriden by runtest's default (when the -v /
# --verbose option isn't specificed on runtest's command line) of ERROR
# (again, see the OPTS dict in test_building).
if VERBOSE:
# logging's default of INFO is fine.
pass
else:
# Set the logging level to ERROR.
logger = logging.getLogger('PyInstaller')
logger.setLevel(logging.ERROR)
PYI_CONFIG = configure.get_config(upx_dir=None) # Run configure phase only once.
# Run created test suite.
clean()
result = run_tests(suite)
sys.exit(int(bool(result.failures or result.errors)))
import shutil
import re
import time
import inspect
from PyInstaller import HOMEPATH, PLATFORM
from PyInstaller import is_win, is_unix, is_darwin, is_py24, get_version
import PyInstaller.build as build
import PyInstaller.compat as compat
import PyInstaller.log as logging
import PyInstaller.depend.modules
import PyInstaller.depend.imptracker
logger = logging.getLogger("PyInstaller.configure")
def test_Crypt(config):
# TODO: disabled for now
config["useCrypt"] = 0
return
# Crypt support. We need to build the AES module and we'll use distutils
# for that. FIXME: the day we'll use distutils for everything this will be
# a solved problem.
logger.info("trying to build crypt support...")
from distutils.core import run_setup
cwd = os.getcwd()
args = sys.argv[:]
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
# Scan the code object for imports, __all__ and wierd stuff
import dis
import os
from PyInstaller import compat
from PyInstaller.compat import set, ctypes
from PyInstaller import is_unix, is_darwin, is_py25, is_py27
import PyInstaller.depend.utils
import PyInstaller.log as logging
logger = logging.getLogger('PyInstaller.build.mf')
IMPORT_NAME = dis.opname.index('IMPORT_NAME')
IMPORT_FROM = dis.opname.index('IMPORT_FROM')
try:
IMPORT_STAR = dis.opname.index('IMPORT_STAR')
except:
IMPORT_STAR = None
STORE_NAME = dis.opname.index('STORE_NAME')
STORE_FAST = dis.opname.index('STORE_FAST')
STORE_GLOBAL = dis.opname.index('STORE_GLOBAL')
try:
STORE_MAP = dis.opname.index('STORE_MAP')
except:
STORE_MAP = None
LOAD_GLOBAL = dis.opname.index('LOAD_GLOBAL')
import shutil
import re
import time
import inspect
from PyInstaller import HOMEPATH, PLATFORM
from PyInstaller import is_win, is_unix, is_darwin, is_py24, get_version
import PyInstaller.build as build
import PyInstaller.compat as compat
import PyInstaller.log as logging
import PyInstaller.depend.modules
import PyInstaller.depend.imptracker
logger = logging.getLogger('PyInstaller.configure')
def test_Crypt(config):
# TODO: disabled for now
config["useCrypt"] = 0
return
#Crypt support. We need to build the AES module and we'll use distutils
# for that. FIXME: the day we'll use distutils for everything this will be
# a solved problem.
logger.info("trying to build crypt support...")
from distutils.core import run_setup
cwd = os.getcwd()
args = sys.argv[:]
try:
# under "excludes" below; add to this list as necessary (or use the
# "excludes" option in the INSTALL section of the config file).
"""
Manipulating with dynamic libraries.
"""
__all__ = ['exclude_list', 'include_list', 'include_library']
import os
import re
from PyInstaller import is_win, is_unix, is_aix, is_darwin
from PyInstaller.compat import set
import PyInstaller.log as logging
logger = logging.getLogger('PyInstaller.build.dylib')
_BOOTLOADER_FNAMES = set(['run', 'run_d', 'runw', 'runw_d'])
# Regex excludes
# Ignoring some system libraries speeds up packaging process
_excludes = {}
# Regex includes - overrides excludes.
# Include list is used only to override specific libraries
# from exclude list.
_includes = {}
_win_excludes = {
# MS assembly excludes
r'^Microsoft\.Windows\.Common-Controls$': 1,
}
# Note that they replace the string in sys.path,
# but str(sys.path[n]) should yield the original string.
import imp
import marshal
import os
from PyInstaller import depend
from PyInstaller.compat import PYCO, caseOk
from PyInstaller.loader import archive
import PyInstaller.log as logging
logger = logging.getLogger("PyInstaller.build.mf")
class OwnerError(Exception):
pass
class Owner:
"""
Base class for loading Python bytecode from different places.
"""
def __init__(self, path):
self.path = path
def __str__(self):
Commandline usage:
winresource.py <dstpath> <srcpath>
Updates or adds resources from file <srcpath> in file <dstpath>.
2009-03 Florian Hoech
"""
import os.path
import pywintypes
import win32api
import PyInstaller.log as logging
logger = logging.getLogger('PyInstaller.build.winresource')
from PyInstaller.compat import set
LOAD_LIBRARY_AS_DATAFILE = 2
ERROR_BAD_EXE_FORMAT = 193
ERROR_RESOURCE_DATA_NOT_FOUND = 1812
ERROR_RESOURCE_TYPE_NOT_FOUND = 1813
ERROR_RESOURCE_NAME_NOT_FOUND = 1814
ERROR_RESOURCE_LANG_NOT_FOUND = 1815
class File(object):
""" Win32 PE file class. """
def __init__(self, filename):
self.filename = filename
#!/usr/bin/env python
import os
import sys
import PyInstaller
import PyInstaller.compat as compat
from PyInstaller.compat import set
from PyInstaller.utils import misc
import PyInstaller.log as logging
logger = logging.getLogger('PyInstaller.build.hooks')
def __exec_python_cmd(cmd):
"""
Executes an externally spawned Python interpreter and returns
anything that was emitted in the standard output as a single
string.
"""
# Prepend PYTHONPATH with pathex
pp = os.pathsep.join(PyInstaller.__pathex__)
old_pp = compat.getenv('PYTHONPATH')
if old_pp:
pp = os.pathsep.join([pp, old_pp])
compat.setenv("PYTHONPATH", pp)
try:
try:
txt = compat.exec_python(*cmd)
except OSError, e:
raise SystemExit("Execution failed: %s" % e)
finally:
#!/usr/bin/env python
import os
import sys
import PyInstaller
import PyInstaller.compat as compat
from PyInstaller.compat import set
from PyInstaller.utils import misc
import PyInstaller.log as logging
logger = logging.getLogger('PyInstaller.build.hooks')
def __exec_python_cmd(cmd):
"""
Executes an externally spawned Python interpreter and returns
anything that was emitted in the standard output as a single
string.
"""
# Prepend PYTHONPATH with pathex
pp = os.pathsep.join(PyInstaller.__pathex__)
old_pp = compat.getenv('PYTHONPATH')
if old_pp:
pp = os.pathsep.join([pp, old_pp])
compat.setenv("PYTHONPATH", pp)
try:
try:
txt = compat.exec_python(*cmd)
except OSError, e:
raise SystemExit("Execution failed: %s" % e)
finally:
def main():
try:
parser = optparse.OptionParser(
usage='%prog [options] [TEST-NAME ...]',
epilog='TEST-NAME can be the name of the .py-file, '
'the .spec-file or only the basename.')
except TypeError:
parser = optparse.OptionParser(usage='%prog [options] [TEST-NAME ...]')
parser.add_option(
'-a',
'--all-with-crypto',
action='store_true',
help='Run the whole test suite with bytecode encryption enabled.')
parser.add_option('-c',
'--clean',
action='store_true',
help='Clean up generated files')
parser.add_option('-i',
'--interactive-tests',
action='store_true',
help='Run interactive tests (default: run normal tests)')
parser.add_option('-v',
'--verbose',
action='store_true',
default=False,
help='Verbose mode (default: %default)')
parser.add_option('--known-fails',
action='store_true',
dest='run_known_fails',
help='Run tests known to fail, too.')
opts, args = parser.parse_args()
# Do only cleanup.
if opts.clean:
clean()
raise SystemExit() # Exit code is 0 in this case.
# Run only specified tests.
if args:
if opts.interactive_tests:
parser.error(
'Must not specify -i/--interactive-tests when passing test names.'
)
suite = unittest.TestSuite()
for arg in args:
test_list = glob.glob(arg)
if not test_list:
test_list = [arg]
else:
test_list = [
x for x in test_list
if os.path.splitext(x)[1] in (".py", ".spec")
]
# Sort tests aplhabetically. For example test
# basic/test_nested_launch1 depends on the executable from
# basic/test_nested_launch0, which it runs.
test_list.sort()
for t in test_list:
test_dir = os.path.dirname(t)
test_script = os.path.basename(os.path.splitext(t)[0])
suite.addTest(
GenericTestCase(test_script,
test_dir=test_dir,
run_known_fails=opts.run_known_fails))
print('Running test: ', (test_dir + '/' + test_script))
# Run all tests or all interactive tests.
else:
if opts.interactive_tests:
print('Running interactive tests...')
test_classes = [InteractiveTestCase]
elif opts.all_with_crypto:
print('Running normal tests with bytecode encryption...')
# Make sure to exclude CryptoTestCase here since we are building
# everything else with crypto enabled.
test_classes = [
BasicTestCase, ImportTestCase, LibrariesTestCase,
MultipackageTestCase
]
else:
print('Running normal tests (-i for interactive tests)...')
test_classes = [
BasicTestCase, CryptoTestCase, ImportTestCase,
LibrariesTestCase, MultipackageTestCase
]
# Create test suite.
generator = TestCaseGenerator()
suite = generator.create_suite(test_classes, opts.all_with_crypto,
opts.run_known_fails)
# Set global options
global VERBOSE, REPORT, PYI_CONFIG
VERBOSE = opts.verbose
# The function called by configure.get_config uses logging. So, we need to
# set a logging level now, in addition to passing it as a "log-level=XXXX"
# option in test_building (see the OPTS dict), in order for the logging
# level to be consistent. Otherwise, the default logging level of INFO will
# produce messages, then be overriden by runtest's default (when the -v /
# --verbose option isn't specificed on runtest's command line) of ERROR
# (again, see the OPTS dict in test_building).
if VERBOSE:
# logging's default of INFO is fine.
pass
else:
# Set the logging level to ERROR.
logger = logging.getLogger('PyInstaller')
logger.setLevel(logging.ERROR)
PYI_CONFIG = configure.get_config(
upx_dir=None) # Run configure phase only once.
# Run created test suite.
clean()
result = run_tests(suite)
sys.exit(int(bool(result.failures or result.errors)))
import re
import time
import inspect
from PyInstaller import HOMEPATH, CONFIGDIR, DEFAULT_CONFIGFILE, PLATFORM
from PyInstaller import is_win, is_unix, is_darwin, is_py24, get_version
import PyInstaller.mf as mf
import PyInstaller.bindepend as bindepend
import PyInstaller.build as build
import PyInstaller.compat as compat
from PyInstaller.depend import dylib
import PyInstaller.log as logging
logger = logging.getLogger('PyInstaller.configure')
def _write_textfile(filename, text):
"""
Write `text` into file `filename`. If the target directory does
not exist, create it.
"""
dirname = os.path.dirname(filename)
if not os.path.exists(dirname):
os.makedirs(dirname)
outf = open(filename, 'w')
outf.write(text)
outf.close()
def add_qt5_dependencies(hook_file):
logger = logging.getLogger(__name__)
# Accumulate all dependencies in a set to avoid duplicates.
hiddenimports = set()
translations_base = set()
plugins = set()
# Find the module underlying this Qt hook: change
# ``/path/to/hook-PyQt5.blah.py`` to ``PyQt5.blah``.
hook_name, hook_ext = os.path.splitext(os.path.basename(hook_file))
assert hook_ext.startswith('.py')
assert hook_name.startswith('hook-')
module_name = hook_name[5:]
namespace = module_name.split('.')[0]
if namespace != 'PyQt5':
raise Exception('Invalid namespace: {0}'.format(namespace))
# Look up the module returned by this import.
module = get_module_file_attribute(module_name)
logger.debug('add_qt5_dependencies: Examining %s, based on hook of %s.',
module, hook_file)
# Walk through all the static dependencies of a dynamically-linked library
# (``.so``/``.dll``/``.dylib``).
imports = set(getImports(module))
while imports:
imp = imports.pop()
# On Windows, find this library; other platforms already provide the
# full path.
if is_win:
imp = getfullnameof(imp)
# Strip off the extension and ``lib`` prefix (Linux/Mac) to give the raw
# name. Lowercase (since Windows always normalized names to lowercase).
lib_name = os.path.splitext(os.path.basename(imp))[0].lower()
# Linux libraries sometimes have a dotted version number --
# ``libfoo.so.3``. It's now ''libfoo.so``, but the ``.so`` must also be
# removed.
if is_linux and os.path.splitext(lib_name)[1] == '.so':
lib_name = os.path.splitext(lib_name)[0]
if lib_name.startswith('lib'):
lib_name = lib_name[3:]
# Mac: rename from ``qt`` to ``qt5`` to match names in Windows/Linux.
if is_darwin and lib_name.startswith(
'qt') and not lib_name.startswith('qt5'):
lib_name = 'qt5' + lib_name[2:]
elif is_darwin and lib_name.startswith('qt5'):
lib_name = 'qt5' + lib_name[3:]
if is_darwin and len(os.path.splitext(lib_name)) > 1:
lib_name = os.path.splitext(lib_name)[0]
logger.debug('add_qt5_dependencies: raw lib %s -> parsed lib %s', imp,
lib_name)
# Follow only Qt dependencies.
if lib_name in _qt_dynamic_dependencies_dict:
# Follow these to find additional dependencies.
logger.debug('add_qt5_dependencies: Import of %s.', imp)
imports.update(getImports(imp))
# Look up which plugins and translations are needed. Avoid Python
# 3-only syntax, since the Python 2.7 parser will raise an
# exception. The original statment was:
## (lib_name_hiddenimports, lib_name_translations_base,
## *lib_name_plugins) = _qt_dynamic_dependencies_dict[lib_name]
dd = _qt_dynamic_dependencies_dict[lib_name]
lib_name_hiddenimports, lib_name_translations_base = dd[:2]
lib_name_plugins = dd[2:]
# Add them in.
if lib_name_hiddenimports:
hiddenimports.update([lib_name_hiddenimports])
plugins.update(lib_name_plugins)
if lib_name_translations_base:
translations_base.update([lib_name_translations_base])
# Change plugins into binaries.
binaries = []
for plugin in plugins:
more_binaries = qt_plugins_binaries(plugin, namespace=namespace)
binaries.extend(more_binaries)
# Change translation_base to datas.
tp = pyqt5_library_info.location['TranslationsPath']
datas = []
for tb in translations_base:
src = os.path.join(tp, tb + '_*.qm')
# Not all PyQt5 installations include translations. See
# https://github.com/pyinstaller/pyinstaller/pull/3229#issuecomment-359479893
# and
# https://github.com/pyinstaller/pyinstaller/issues/2857#issuecomment-368744341.
if glob.glob(src):
datas.append((src, os.path.join(namespace, 'Qt', 'translations')))
else:
logger.warning(
'Unable to find Qt5 translations %s. These '
'translations were not packaged.', src)
# Change hiddenimports to a list.
hiddenimports = list(hiddenimports)
logger.debug(
'add_qt5_dependencies: imports from %s:\n'
' hiddenimports = %s\n'
' binaries = %s\n'
' datas = %s', hook_name, hiddenimports, binaries, datas)
return hiddenimports, binaries, datas
import sys
import re
from glob import glob
# Required for extracting eggs.
import zipfile
from PyInstaller.compat import is_win, is_unix, is_aix, is_cygwin, is_darwin, is_py26
from PyInstaller.depend import dylib
from PyInstaller.utils import winutils
import PyInstaller.compat as compat
import PyInstaller.log as logging
logger = logging.getLogger(__file__)
seen = {}
if is_win:
if is_py26:
try:
# For Portable Python it is required to import pywintypes before
# win32api module. See for details:
# http://www.voidspace.org.uk/python/movpy/reference/win32ext.html#problems-with-win32api
import pywintypes
import win32api
except ImportError:
raise SystemExit("Error: PyInstaller for Python 2.6+ on Windows "
"needs pywin32.\r\nPlease install from "
"http://sourceforge.net/projects/pywin32/")
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
Utils for Windows platform.
"""
__all__ = ['get_windows_dir']
import os
from PyInstaller import is_win
import PyInstaller.log as logging
logger = logging.getLogger('PyInstaller.build.bindepend')
def get_windows_dir():
"""Return the Windows directory e.g. C:\\Windows"""
try:
import win32api
except ImportError:
windir = os.getenv('SystemRoot', os.getenv('WINDIR'))
else:
windir = win32api.GetWindowsDirectory()
if not windir:
raise SystemExit("Error: Can not determine your Windows directory")
return windir
Commandline usage:
winresource.py <dstpath> <srcpath>
Updates or adds resources from file <srcpath> in file <dstpath>.
2009-03 Florian Hoech
"""
import os.path
import pywintypes
import win32api
import PyInstaller.log as logging
logger = logging.getLogger("PyInstaller.build.winresource")
from PyInstaller.compat import set
LOAD_LIBRARY_AS_DATAFILE = 2
ERROR_BAD_EXE_FORMAT = 193
ERROR_RESOURCE_DATA_NOT_FOUND = 1812
ERROR_RESOURCE_TYPE_NOT_FOUND = 1813
ERROR_RESOURCE_NAME_NOT_FOUND = 1814
ERROR_RESOURCE_LANG_NOT_FOUND = 1815
class File(object):
""" Win32 PE file class. """
import os
import sys
import re
from glob import glob
# Required for extracting eggs.
import zipfile
from PyInstaller.compat import is_win, is_unix, is_aix, is_cygwin, is_darwin, is_py26
from PyInstaller.depend import dylib
from PyInstaller.utils import winutils
import PyInstaller.compat as compat
import PyInstaller.log as logging
logger = logging.getLogger(__file__)
seen = {}
if is_win:
if is_py26:
try:
# For Portable Python it is required to import pywintypes before
# win32api module. See for details:
# http://www.voidspace.org.uk/python/movpy/reference/win32ext.html#problems-with-win32api
import pywintypes
import win32api
except ImportError:
raise SystemExit("Error: PyInstaller for Python 2.6+ on Windows "
"needs pywin32.\r\nPlease install from "
"http://sourceforge.net/projects/pywin32/")
"""
import os
from glob import glob
import re
import sys
import xml
from xml.dom import Node, minidom
from xml.dom.minidom import Document, Element
from PyInstaller import compat
from PyInstaller.compat import hashlib, architecture
from PyInstaller import log as logging
logger = logging.getLogger("PyInstaller.build.winmanifest")
try:
from PyInstaller.utils import winresource
except ImportError, detail:
winresource = None
logger.warn(detail)
logger.warn("Cannot check for assembly dependencies - resource access ")
logger.warn("unavailable. To enable resource access, please install ")
logger.warn("http://sourceforge.net/projects/pywin32/")
LANGUAGE_NEUTRAL_NT5 = "x-ww"
LANGUAGE_NEUTRAL_NT6 = "none"
RT_MANIFEST = 24
winmanifest.py <dstpath> <xmlpath>
Updates or adds manifest <xmlpath> as resource in Win32 PE file <dstpath>.
"""
import os
from glob import glob
import re
import sys
import xml
from xml.dom import Node, minidom
from xml.dom.minidom import Document, Element
from PyInstaller import compat
from PyInstaller.compat import hashlib, architecture
from PyInstaller import log as logging
logger = logging.getLogger('PyInstaller.build.winmanifest')
try:
from PyInstaller.utils import winresource
except ImportError, detail:
winresource = None
logger.warn(detail)
logger.warn("Cannot check for assembly dependencies - resource access ")
logger.warn("unavailable. To enable resource access, please install ")
logger.warn("http://sourceforge.net/projects/pywin32/")
LANGUAGE_NEUTRAL_NT5 = "x-ww"
LANGUAGE_NEUTRAL_NT6 = "none"
RT_MANIFEST = 24
Document.aChild = Document.appendChild
import os
import sys
import re
from glob import glob
# Required for extracting eggs.
import zipfile
from PyInstaller import is_win, is_unix, is_aix, is_cygwin, is_darwin, is_py26
from PyInstaller.depend import dylib
from PyInstaller.utils import winutils
import PyInstaller.compat as compat
from PyInstaller.compat import set
import PyInstaller.log as logging
logger = logging.getLogger('PyInstaller.build.bindepend')
seen = {}
if is_win:
if is_py26:
try:
import win32api
import pywintypes
except ImportError:
raise SystemExit("Error: PyInstaller for Python 2.6+ on Windows "
"needs pywin32.\r\nPlease install from "
"http://sourceforge.net/projects/pywin32/")
from PyInstaller.utils.winmanifest import RT_MANIFEST
from PyInstaller.utils.winmanifest import GetManifestResources
# This code is courtesy of Thomas Heller, who
# has kindly donated it to this project.
RT_ICON = 3
RT_GROUP_ICON = 14
LOAD_LIBRARY_AS_DATAFILE = 2
import struct
import types
try:
StringTypes = types.StringTypes
except AttributeError:
StringTypes = [ type("") ]
import PyInstaller.log as logging
logger = logging.getLogger('PyInstaller.icon')
class Structure:
def __init__(self):
size = self._sizeInBytes = struct.calcsize(self._format_)
self._fields_ = list(struct.unpack(self._format_, '\000' * size))
indexes = self._indexes_ = {}
for i in range(len(self._names_)):
indexes[self._names_[i]] = i
def dump(self):
logger.info("DUMP of %s", self)
for name in self._names_:
if not name.startswith('_'):
logger.info("%20s = %s", name, getattr(self, name))
logger.info("")