Spaces:
Runtime error
Runtime error
| # -*- coding: utf-8 -*- | |
| # | |
| # Copyright (C) 2013-2015 Vinay Sajip. | |
| # Licensed to the Python Software Foundation under a contributor agreement. | |
| # See LICENSE.txt and CONTRIBUTORS.txt. | |
| # | |
| from io import BytesIO | |
| import logging | |
| import os | |
| import re | |
| import struct | |
| import sys | |
| import time | |
| from zipfile import ZipInfo | |
| from .compat import sysconfig, detect_encoding, ZipFile | |
| from .resources import finder | |
| from .util import (FileOperator, get_export_entry, convert_path, | |
| get_executable, get_platform, in_venv) | |
| logger = logging.getLogger(__name__) | |
| _DEFAULT_MANIFEST = ''' | |
| <?xml version="1.0" encoding="UTF-8" standalone="yes"?> | |
| <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> | |
| <assemblyIdentity version="1.0.0.0" | |
| processorArchitecture="X86" | |
| name="%s" | |
| type="win32"/> | |
| <!-- Identify the application security requirements. --> | |
| <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3"> | |
| <security> | |
| <requestedPrivileges> | |
| <requestedExecutionLevel level="asInvoker" uiAccess="false"/> | |
| </requestedPrivileges> | |
| </security> | |
| </trustInfo> | |
| </assembly>'''.strip() | |
| # check if Python is called on the first line with this expression | |
| FIRST_LINE_RE = re.compile(b'^#!.*pythonw?[0-9.]*([ \t].*)?$') | |
| SCRIPT_TEMPLATE = r'''# -*- coding: utf-8 -*- | |
| import re | |
| import sys | |
| from %(module)s import %(import_name)s | |
| if __name__ == '__main__': | |
| sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) | |
| sys.exit(%(func)s()) | |
| ''' | |
| def enquote_executable(executable): | |
| if ' ' in executable: | |
| # make sure we quote only the executable in case of env | |
| # for example /usr/bin/env "/dir with spaces/bin/jython" | |
| # instead of "/usr/bin/env /dir with spaces/bin/jython" | |
| # otherwise whole | |
| if executable.startswith('/usr/bin/env '): | |
| env, _executable = executable.split(' ', 1) | |
| if ' ' in _executable and not _executable.startswith('"'): | |
| executable = '%s "%s"' % (env, _executable) | |
| else: | |
| if not executable.startswith('"'): | |
| executable = '"%s"' % executable | |
| return executable | |
| # Keep the old name around (for now), as there is at least one project using it! | |
| _enquote_executable = enquote_executable | |
| class ScriptMaker(object): | |
| """ | |
| A class to copy or create scripts from source scripts or callable | |
| specifications. | |
| """ | |
| script_template = SCRIPT_TEMPLATE | |
| executable = None # for shebangs | |
| def __init__(self, source_dir, target_dir, add_launchers=True, | |
| dry_run=False, fileop=None): | |
| self.source_dir = source_dir | |
| self.target_dir = target_dir | |
| self.add_launchers = add_launchers | |
| self.force = False | |
| self.clobber = False | |
| # It only makes sense to set mode bits on POSIX. | |
| self.set_mode = (os.name == 'posix') or (os.name == 'java' and | |
| os._name == 'posix') | |
| self.variants = set(('', 'X.Y')) | |
| self._fileop = fileop or FileOperator(dry_run) | |
| self._is_nt = os.name == 'nt' or ( | |
| os.name == 'java' and os._name == 'nt') | |
| self.version_info = sys.version_info | |
| def _get_alternate_executable(self, executable, options): | |
| if options.get('gui', False) and self._is_nt: # pragma: no cover | |
| dn, fn = os.path.split(executable) | |
| fn = fn.replace('python', 'pythonw') | |
| executable = os.path.join(dn, fn) | |
| return executable | |
| if sys.platform.startswith('java'): # pragma: no cover | |
| def _is_shell(self, executable): | |
| """ | |
| Determine if the specified executable is a script | |
| (contains a #! line) | |
| """ | |
| try: | |
| with open(executable) as fp: | |
| return fp.read(2) == '#!' | |
| except (OSError, IOError): | |
| logger.warning('Failed to open %s', executable) | |
| return False | |
| def _fix_jython_executable(self, executable): | |
| if self._is_shell(executable): | |
| # Workaround for Jython is not needed on Linux systems. | |
| import java | |
| if java.lang.System.getProperty('os.name') == 'Linux': | |
| return executable | |
| elif executable.lower().endswith('jython.exe'): | |
| # Use wrapper exe for Jython on Windows | |
| return executable | |
| return '/usr/bin/env %s' % executable | |
| def _build_shebang(self, executable, post_interp): | |
| """ | |
| Build a shebang line. In the simple case (on Windows, or a shebang line | |
| which is not too long or contains spaces) use a simple formulation for | |
| the shebang. Otherwise, use /bin/sh as the executable, with a contrived | |
| shebang which allows the script to run either under Python or sh, using | |
| suitable quoting. Thanks to Harald Nordgren for his input. | |
| See also: http://www.in-ulm.de/~mascheck/various/shebang/#length | |
| https://hg.mozilla.org/mozilla-central/file/tip/mach | |
| """ | |
| if os.name != 'posix': | |
| simple_shebang = True | |
| else: | |
| # Add 3 for '#!' prefix and newline suffix. | |
| shebang_length = len(executable) + len(post_interp) + 3 | |
| if sys.platform == 'darwin': | |
| max_shebang_length = 512 | |
| else: | |
| max_shebang_length = 127 | |
| simple_shebang = ((b' ' not in executable) and | |
| (shebang_length <= max_shebang_length)) | |
| if simple_shebang: | |
| result = b'#!' + executable + post_interp + b'\n' | |
| else: | |
| result = b'#!/bin/sh\n' | |
| result += b"'''exec' " + executable + post_interp + b' "$0" "$@"\n' | |
| result += b"' '''" | |
| return result | |
| def _get_shebang(self, encoding, post_interp=b'', options=None): | |
| enquote = True | |
| if self.executable: | |
| executable = self.executable | |
| enquote = False # assume this will be taken care of | |
| elif not sysconfig.is_python_build(): | |
| executable = get_executable() | |
| elif in_venv(): # pragma: no cover | |
| executable = os.path.join(sysconfig.get_path('scripts'), | |
| 'python%s' % sysconfig.get_config_var('EXE')) | |
| else: # pragma: no cover | |
| executable = os.path.join( | |
| sysconfig.get_config_var('BINDIR'), | |
| 'python%s%s' % (sysconfig.get_config_var('VERSION'), | |
| sysconfig.get_config_var('EXE'))) | |
| if not os.path.isfile(executable): | |
| # for Python builds from source on Windows, no Python executables with | |
| # a version suffix are created, so we use python.exe | |
| executable = os.path.join(sysconfig.get_config_var('BINDIR'), | |
| 'python%s' % (sysconfig.get_config_var('EXE'))) | |
| if options: | |
| executable = self._get_alternate_executable(executable, options) | |
| if sys.platform.startswith('java'): # pragma: no cover | |
| executable = self._fix_jython_executable(executable) | |
| # Normalise case for Windows - COMMENTED OUT | |
| # executable = os.path.normcase(executable) | |
| # N.B. The normalising operation above has been commented out: See | |
| # issue #124. Although paths in Windows are generally case-insensitive, | |
| # they aren't always. For example, a path containing a ẞ (which is a | |
| # LATIN CAPITAL LETTER SHARP S - U+1E9E) is normcased to ß (which is a | |
| # LATIN SMALL LETTER SHARP S' - U+00DF). The two are not considered by | |
| # Windows as equivalent in path names. | |
| # If the user didn't specify an executable, it may be necessary to | |
| # cater for executable paths with spaces (not uncommon on Windows) | |
| if enquote: | |
| executable = enquote_executable(executable) | |
| # Issue #51: don't use fsencode, since we later try to | |
| # check that the shebang is decodable using utf-8. | |
| executable = executable.encode('utf-8') | |
| # in case of IronPython, play safe and enable frames support | |
| if (sys.platform == 'cli' and '-X:Frames' not in post_interp | |
| and '-X:FullFrames' not in post_interp): # pragma: no cover | |
| post_interp += b' -X:Frames' | |
| shebang = self._build_shebang(executable, post_interp) | |
| # Python parser starts to read a script using UTF-8 until | |
| # it gets a #coding:xxx cookie. The shebang has to be the | |
| # first line of a file, the #coding:xxx cookie cannot be | |
| # written before. So the shebang has to be decodable from | |
| # UTF-8. | |
| try: | |
| shebang.decode('utf-8') | |
| except UnicodeDecodeError: # pragma: no cover | |
| raise ValueError( | |
| 'The shebang (%r) is not decodable from utf-8' % shebang) | |
| # If the script is encoded to a custom encoding (use a | |
| # #coding:xxx cookie), the shebang has to be decodable from | |
| # the script encoding too. | |
| if encoding != 'utf-8': | |
| try: | |
| shebang.decode(encoding) | |
| except UnicodeDecodeError: # pragma: no cover | |
| raise ValueError( | |
| 'The shebang (%r) is not decodable ' | |
| 'from the script encoding (%r)' % (shebang, encoding)) | |
| return shebang | |
| def _get_script_text(self, entry): | |
| return self.script_template % dict(module=entry.prefix, | |
| import_name=entry.suffix.split('.')[0], | |
| func=entry.suffix) | |
| manifest = _DEFAULT_MANIFEST | |
| def get_manifest(self, exename): | |
| base = os.path.basename(exename) | |
| return self.manifest % base | |
| def _write_script(self, names, shebang, script_bytes, filenames, ext): | |
| use_launcher = self.add_launchers and self._is_nt | |
| linesep = os.linesep.encode('utf-8') | |
| if not shebang.endswith(linesep): | |
| shebang += linesep | |
| if not use_launcher: | |
| script_bytes = shebang + script_bytes | |
| else: # pragma: no cover | |
| if ext == 'py': | |
| launcher = self._get_launcher('t') | |
| else: | |
| launcher = self._get_launcher('w') | |
| stream = BytesIO() | |
| with ZipFile(stream, 'w') as zf: | |
| source_date_epoch = os.environ.get('SOURCE_DATE_EPOCH') | |
| if source_date_epoch: | |
| date_time = time.gmtime(int(source_date_epoch))[:6] | |
| zinfo = ZipInfo(filename='__main__.py', date_time=date_time) | |
| zf.writestr(zinfo, script_bytes) | |
| else: | |
| zf.writestr('__main__.py', script_bytes) | |
| zip_data = stream.getvalue() | |
| script_bytes = launcher + shebang + zip_data | |
| for name in names: | |
| outname = os.path.join(self.target_dir, name) | |
| if use_launcher: # pragma: no cover | |
| n, e = os.path.splitext(outname) | |
| if e.startswith('.py'): | |
| outname = n | |
| outname = '%s.exe' % outname | |
| try: | |
| self._fileop.write_binary_file(outname, script_bytes) | |
| except Exception: | |
| # Failed writing an executable - it might be in use. | |
| logger.warning('Failed to write executable - trying to ' | |
| 'use .deleteme logic') | |
| dfname = '%s.deleteme' % outname | |
| if os.path.exists(dfname): | |
| os.remove(dfname) # Not allowed to fail here | |
| os.rename(outname, dfname) # nor here | |
| self._fileop.write_binary_file(outname, script_bytes) | |
| logger.debug('Able to replace executable using ' | |
| '.deleteme logic') | |
| try: | |
| os.remove(dfname) | |
| except Exception: | |
| pass # still in use - ignore error | |
| else: | |
| if self._is_nt and not outname.endswith('.' + ext): # pragma: no cover | |
| outname = '%s.%s' % (outname, ext) | |
| if os.path.exists(outname) and not self.clobber: | |
| logger.warning('Skipping existing file %s', outname) | |
| continue | |
| self._fileop.write_binary_file(outname, script_bytes) | |
| if self.set_mode: | |
| self._fileop.set_executable_mode([outname]) | |
| filenames.append(outname) | |
| variant_separator = '-' | |
| def get_script_filenames(self, name): | |
| result = set() | |
| if '' in self.variants: | |
| result.add(name) | |
| if 'X' in self.variants: | |
| result.add('%s%s' % (name, self.version_info[0])) | |
| if 'X.Y' in self.variants: | |
| result.add('%s%s%s.%s' % (name, self.variant_separator, | |
| self.version_info[0], self.version_info[1])) | |
| return result | |
| def _make_script(self, entry, filenames, options=None): | |
| post_interp = b'' | |
| if options: | |
| args = options.get('interpreter_args', []) | |
| if args: | |
| args = ' %s' % ' '.join(args) | |
| post_interp = args.encode('utf-8') | |
| shebang = self._get_shebang('utf-8', post_interp, options=options) | |
| script = self._get_script_text(entry).encode('utf-8') | |
| scriptnames = self.get_script_filenames(entry.name) | |
| if options and options.get('gui', False): | |
| ext = 'pyw' | |
| else: | |
| ext = 'py' | |
| self._write_script(scriptnames, shebang, script, filenames, ext) | |
| def _copy_script(self, script, filenames): | |
| adjust = False | |
| script = os.path.join(self.source_dir, convert_path(script)) | |
| outname = os.path.join(self.target_dir, os.path.basename(script)) | |
| if not self.force and not self._fileop.newer(script, outname): | |
| logger.debug('not copying %s (up-to-date)', script) | |
| return | |
| # Always open the file, but ignore failures in dry-run mode -- | |
| # that way, we'll get accurate feedback if we can read the | |
| # script. | |
| try: | |
| f = open(script, 'rb') | |
| except IOError: # pragma: no cover | |
| if not self.dry_run: | |
| raise | |
| f = None | |
| else: | |
| first_line = f.readline() | |
| if not first_line: # pragma: no cover | |
| logger.warning('%s is an empty file (skipping)', script) | |
| return | |
| match = FIRST_LINE_RE.match(first_line.replace(b'\r\n', b'\n')) | |
| if match: | |
| adjust = True | |
| post_interp = match.group(1) or b'' | |
| if not adjust: | |
| if f: | |
| f.close() | |
| self._fileop.copy_file(script, outname) | |
| if self.set_mode: | |
| self._fileop.set_executable_mode([outname]) | |
| filenames.append(outname) | |
| else: | |
| logger.info('copying and adjusting %s -> %s', script, | |
| self.target_dir) | |
| if not self._fileop.dry_run: | |
| encoding, lines = detect_encoding(f.readline) | |
| f.seek(0) | |
| shebang = self._get_shebang(encoding, post_interp) | |
| if b'pythonw' in first_line: # pragma: no cover | |
| ext = 'pyw' | |
| else: | |
| ext = 'py' | |
| n = os.path.basename(outname) | |
| self._write_script([n], shebang, f.read(), filenames, ext) | |
| if f: | |
| f.close() | |
| def dry_run(self): | |
| return self._fileop.dry_run | |
| def dry_run(self, value): | |
| self._fileop.dry_run = value | |
| if os.name == 'nt' or (os.name == 'java' and os._name == 'nt'): # pragma: no cover | |
| # Executable launcher support. | |
| # Launchers are from https://bitbucket.org/vinay.sajip/simple_launcher/ | |
| def _get_launcher(self, kind): | |
| if struct.calcsize('P') == 8: # 64-bit | |
| bits = '64' | |
| else: | |
| bits = '32' | |
| platform_suffix = '-arm' if get_platform() == 'win-arm64' else '' | |
| name = '%s%s%s.exe' % (kind, bits, platform_suffix) | |
| # Issue 31: don't hardcode an absolute package name, but | |
| # determine it relative to the current package | |
| distlib_package = __name__.rsplit('.', 1)[0] | |
| resource = finder(distlib_package).find(name) | |
| if not resource: | |
| msg = ('Unable to find resource %s in package %s' % (name, | |
| distlib_package)) | |
| raise ValueError(msg) | |
| return resource.bytes | |
| # Public API follows | |
| def make(self, specification, options=None): | |
| """ | |
| Make a script. | |
| :param specification: The specification, which is either a valid export | |
| entry specification (to make a script from a | |
| callable) or a filename (to make a script by | |
| copying from a source location). | |
| :param options: A dictionary of options controlling script generation. | |
| :return: A list of all absolute pathnames written to. | |
| """ | |
| filenames = [] | |
| entry = get_export_entry(specification) | |
| if entry is None: | |
| self._copy_script(specification, filenames) | |
| else: | |
| self._make_script(entry, filenames, options=options) | |
| return filenames | |
| def make_multiple(self, specifications, options=None): | |
| """ | |
| Take a list of specifications and make scripts from them, | |
| :param specifications: A list of specifications. | |
| :return: A list of all absolute pathnames written to, | |
| """ | |
| filenames = [] | |
| for specification in specifications: | |
| filenames.extend(self.make(specification, options)) | |
| return filenames | |