def fix_entry_points(*distribution_names): """Re-make all entry_points for the given distributions. This is a workaround for the fact that conda doesn't support GUI scripts. The filenames on disk remain the same, so conda can still uninstall cleanly - we're just fixing the files in-place""" # There are many places scripts can go, but we're in conda so the main scripts dir # at sysconfig.get_path('scripts') is the only possibility for us: maker = ScriptMaker(None, sysconfig.get_path('scripts')) maker.clobber = True # Overwrite existing scripts maker.variants = {''} # Don't make variants with Python major.minor suffixes for name in distribution_names: # Get the script specs and format them how Scriptmaker wants them distribution = importlib_metadata.Distribution.from_name(name) # I've seen enough bugs with entry_points in conda that I feel the need to # clobber its console_scripts too, even though they are officially supported: console_scripts = [ f'{e.name} = {e.value}' for e in distribution.entry_points if e.group == 'console_scripts' ] gui_scripts = [ f'{e.name} = {e.value}' for e in distribution.entry_points if e.group == 'gui_scripts' ] # Make 'em: maker.make_multiple(console_scripts) maker.make_multiple(gui_scripts, {'gui': True})
def _create_console_entry_point(self, name, value, to_folder): result = [] from distlib.scripts import ScriptMaker maker = ScriptMaker(None, str(to_folder)) maker.clobber = True # overwrite maker.variants = {"", "X", "X.Y"} # create all variants maker.set_mode = True # ensure they are executable maker.executable = str(self._creator.exe) specification = "{} = {}".format(name, value) new_files = maker.make(specification) result.extend(Path(i) for i in new_files) return result
def _create_console_entry_point(self, name, value, to_folder, version_info): result = [] maker = ScriptMaker(None, str(to_folder)) maker.clobber = True # overwrite maker.variants = {""} # set within patch_distlib_correct_variants maker.set_mode = True # ensure they are executable # calling private until https://bitbucket.org/pypa/distlib/issues/135/expose-_enquote_executable-as-public maker.executable = _enquote_executable(str(self._creator.exe)) specification = "{} = {}".format(name, value) with self.patch_distlib_correct_variants(version_info, maker): new_files = maker.make(specification) result.extend(Path(i) for i in new_files) return result
def _create_console_entry_point(self, name, value, to_folder): result = [] if IS_WIN: # windows doesn't support simple script files, so fallback to more complicated exe generator from distlib.scripts import ScriptMaker maker = ScriptMaker(None, str(to_folder)) maker.clobber = True # overwrite maker.variants = {"", "X", "X.Y"} # create all variants maker.set_mode = True # ensure they are executable maker.executable = str(self._creator.exe) specification = "{} = {}".format(name, value) new_files = maker.make(specification) result.extend(Path(i) for i in new_files) else: module, func = value.split(":") content = ( dedent( """ #!{0} # -*- coding: utf-8 -*- import re import sys from {1} import {2} if __name__ == "__main__": sys.argv[0] = re.sub(r"(-script.pyw?|.exe)?$", "", sys.argv[0]) sys.exit({2}()) """ ) .lstrip() .format(self._creator.exe, module, func) ) version = self._creator.interpreter.version_info for new_name in ( name, "{}{}".format(name, version.major), "{}-{}.{}".format(name, version.major, version.minor), ): exe = to_folder / new_name exe.write_text(content, encoding="utf-8") make_exe(exe) result.append(exe) return result
def create_production_scripts(self, tool, venv_session): """Create Rez production used binary scripts The binary script will be executed with Python interpreter flag -E, which will ignore all PYTHON* env vars, e.g. PYTHONPATH and PYTHONHOME. """ _log.info("Generating production scripts..") site_packages = venv_session.creator.purelib bin_path = venv_session.creator.bin_dir if tool.edit: egg_link = site_packages / ("%s.egg-link" % tool.name) if not egg_link.is_file(): _log.error("Tool %r installed in edit mode, but unable " "to find egg-link for generating production " "scripts from source. File not exists: %s" % (tool.name, egg_link)) return with open(str(egg_link), "r") as f: package_location = f.readline().strip() path = [str(package_location)] else: path = [str(site_packages)] dists = Distribution.discover(name=tool.name, path=path) specifications = { ep.name: "{ep.name} = {ep.value}".format(ep=ep) for dist in dists for ep in dist.entry_points if ep.group == "console_scripts" } # delete bin files written into virtualenv # this also avoided naming conflict between script 'rez' and dir 'rez' for script_name in specifications.keys(): script_path = bin_path / script_name if script_path.is_file(): os.remove(str(script_path)) venv_name = tool.name if tool.isolation else "rez" prod_bin_path = self._revision.production_bin_dir(venv_name) makedirs(prod_bin_path) maker = ScriptMaker(source_dir=None, target_dir=str(prod_bin_path)) maker.executable = str(venv_session.creator.exe) # Align with wheel # # Ensure we don't generate any variants for scripts because this is # almost never what somebody wants. # See https://bitbucket.org/pypa/distlib/issue/35/ maker.variants = {""} # Ensure old scripts are overwritten. # See https://github.com/pypa/pip/issues/1800 maker.clobber = True # This is required because otherwise distlib creates scripts that are # not executable. # See https://bitbucket.org/pypa/distlib/issue/32/ maker.set_mode = True if self._rez_in_edit: # Allow pre-caching rez_bin_path on script entry if environ var # `REZUP_EDIT_IN_PRODUCTION` is set with non-empty value. # See https://github.com/davidlatwe/rezup/pull/56 maker.script_template = r'''# -*- coding: utf-8 -*- import re import os import sys from %(module)s import %(import_name)s if os.getenv("REZUP_EDIT_IN_PRODUCTION"): from rez.system import system setattr(system, 'rez_bin_path', r'{rez_bin_path}') if __name__ == '__main__': sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) sys.exit(%(func)s()) '''.format(rez_bin_path=str(prod_bin_path)) scripts = maker.make_multiple( specifications=specifications.values(), options=dict(interpreter_args=list(tool.flags))) return scripts
def move_wheel_files(name, req, wheeldir, scheme, pycompile=True): """Install a wheel extracted in wheeldir according to the provided scheme""" if root_is_purelib(name, wheeldir): lib_dir = scheme['purelib'] else: lib_dir = scheme['platlib'] info_dir = [] data_dirs = [] source = wheeldir.rstrip(os.path.sep) + os.path.sep # Record details of the files moved # installed = files copied from the wheel to the destination # changed = files changed while installing (scripts #! line typically) # generated = files newly generated during the install (script wrappers) installed = {} changed = set() generated = [] # Compile all of the pyc files that we're going to be installing if pycompile: with captured_output('stdout') as stdout: with warnings.catch_warnings(): warnings.filterwarnings('ignore') compileall.compile_dir(source, force=True, quiet=True) logger.debug(stdout.getvalue()) def normpath(src, p): return os.path.relpath(src, p).replace(os.path.sep, '/') def record_installed(srcfile, destfile, modified=False): """Map archive RECORD paths to installation RECORD paths.""" oldpath = normpath(srcfile, wheeldir) newpath = normpath(destfile, lib_dir) installed[oldpath] = newpath if modified: changed.add(destfile) def clobber(source, dest, is_base, fixer=None, filter=None): ensure_dir(dest) # common for the 'include' path for dir, subdirs, files in os.walk(source): basedir = dir[len(source):].lstrip(os.path.sep) destdir = os.path.join(dest, basedir) if is_base and basedir.split(os.path.sep, 1)[0].endswith('.data'): continue for s in subdirs: destsubdir = os.path.join(dest, basedir, s) if is_base and basedir == '' and destsubdir.endswith('.data'): data_dirs.append(s) continue elif (is_base and s.endswith('.dist-info') and canonicalize_name(s).startswith( canonicalize_name(req.name))): assert not info_dir, ('Multiple .dist-info directories: ' + destsubdir + ', ' + ', '.join(info_dir)) info_dir.append(destsubdir) for f in files: # Skip unwanted files if filter and filter(f): continue srcfile = os.path.join(dir, f) destfile = os.path.join(dest, basedir, f) # directory creation is lazy and after the file filtering above # to ensure we don't install empty dirs; empty dirs can't be # uninstalled. ensure_dir(destdir) # We use copyfile (not move, copy, or copy2) to be extra sure # that we are not moving directories over (copyfile fails for # directories) as well as to ensure that we are not copying # over any metadata because we want more control over what # metadata we actually copy over. shutil.copyfile(srcfile, destfile) # Copy over the metadata for the file, currently this only # includes the atime and mtime. st = os.stat(srcfile) if hasattr(os, "utime"): os.utime(destfile, (st.st_atime, st.st_mtime)) # If our file is executable, then make our destination file # executable. if os.access(srcfile, os.X_OK): st = os.stat(srcfile) permissions = ( st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH ) os.chmod(destfile, permissions) changed = False if fixer: changed = fixer(destfile) record_installed(srcfile, destfile, changed) clobber(source, lib_dir, True) assert info_dir, "%s .dist-info directory not found" % req # Get the defined entry points ep_file = os.path.join(info_dir[0], 'entry_points.txt') console, gui = get_entrypoints(ep_file) def is_entrypoint_wrapper(name): # EP, EP.exe and EP-script.py are scripts generated for # entry point EP by setuptools if name.lower().endswith('.exe'): matchname = name[:-4] elif name.lower().endswith('-script.py'): matchname = name[:-10] elif name.lower().endswith(".pya"): matchname = name[:-4] else: matchname = name # Ignore setuptools-generated scripts return (matchname in console or matchname in gui) for datadir in data_dirs: fixer = None filter = None for subdir in os.listdir(os.path.join(wheeldir, datadir)): fixer = None if subdir == 'scripts': fixer = fix_script filter = is_entrypoint_wrapper source = os.path.join(wheeldir, datadir, subdir) dest = scheme[subdir] clobber(source, dest, False, fixer=fixer, filter=filter) maker = ScriptMaker(None, scheme['scripts']) # Ensure old scripts are overwritten. # See https://github.com/pypa/pip/issues/1800 maker.clobber = True # Ensure we don't generate any variants for scripts because this is almost # never what somebody wants. # See https://bitbucket.org/pypa/distlib/issue/35/ maker.variants = set(('', )) # This is required because otherwise distlib creates scripts that are not # executable. # See https://bitbucket.org/pypa/distlib/issue/32/ maker.set_mode = True # Simplify the script and fix the fact that the default script swallows # every single stack trace. # See https://bitbucket.org/pypa/distlib/issue/34/ # See https://bitbucket.org/pypa/distlib/issue/33/ def _get_script_text(entry): if entry.suffix is None: raise CricError( "Invalid script entry point: %s for req: %s - A callable " "suffix is required. Cf https://packaging.python.org/en/" "latest/distributing.html#console-scripts for more " "information." % (entry, req) ) return maker.script_template % { "module": entry.prefix, "import_name": entry.suffix.split(".")[0], "func": entry.suffix, } maker._get_script_text = _get_script_text maker.script_template = """# -*- 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()) """ # Special case pip and setuptools to generate versioned wrappers # # The issue is that some projects (specifically, pip and setuptools) use # code in setup.py to create "versioned" entry points - pip2.7 on Python # 2.7, pip3.3 on Python 3.3, etc. But these entry points are baked into # the wheel metadata at build time, and so if the wheel is installed with # a *different* version of Python the entry points will be wrong. The # correct fix for this is to enhance the metadata to be able to describe # such versioned entry points, but that won't happen till Metadata 2.0 is # available. # In the meantime, projects using versioned entry points will either have # incorrect versioned entry points, or they will not be able to distribute # "universal" wheels (i.e., they will need a wheel per Python version). # # Because setuptools and pip are bundled with _ensurepip and virtualenv, # we need to use universal wheels. So, as a stopgap until Metadata 2.0, we # override the versioned entry points in the wheel and generate the # correct ones. This code is purely a short-term measure until Metadata 2.0 # is available. # # To add the level of hack in this section of code, in order to support # ensurepip this code will look for an ``ENSUREPIP_OPTIONS`` environment # variable which will control which version scripts get installed. # # ENSUREPIP_OPTIONS=altinstall # - Only pipX.Y and easy_install-X.Y will be generated and installed # ENSUREPIP_OPTIONS=install # - pipX.Y, pipX, easy_install-X.Y will be generated and installed. Note # that this option is technically if ENSUREPIP_OPTIONS is set and is # not altinstall # DEFAULT # - The default behavior is to install pip, pipX, pipX.Y, easy_install # and easy_install-X.Y. pip_script = console.pop('pip', None) if pip_script: if "ENSUREPIP_OPTIONS" not in os.environ: spec = 'pip = ' + pip_script generated.extend(maker.make(spec)) if os.environ.get("ENSUREPIP_OPTIONS", "") != "altinstall": spec = 'pip%s = %s' % (sys.version[:1], pip_script) generated.extend(maker.make(spec)) spec = 'pip%s = %s' % (sys.version[:3], pip_script) generated.extend(maker.make(spec)) # Delete any other versioned pip entry points pip_ep = [k for k in console if re.match(r'pip(\d(\.\d)?)?$', k)] for k in pip_ep: del console[k] easy_install_script = console.pop('easy_install', None) if easy_install_script: if "ENSUREPIP_OPTIONS" not in os.environ: spec = 'easy_install = ' + easy_install_script generated.extend(maker.make(spec)) spec = 'easy_install-%s = %s' % (sys.version[:3], easy_install_script) generated.extend(maker.make(spec)) # Delete any other versioned easy_install entry points easy_install_ep = [ k for k in console if re.match(r'easy_install(-\d\.\d)?$', k) ] for k in easy_install_ep: del console[k] # Generate the console and GUI entry points specified in the wheel if len(console) > 0: generated.extend( maker.make_multiple(['%s = %s' % kv for kv in console.items()]) ) if len(gui) > 0: generated.extend( maker.make_multiple( ['%s = %s' % kv for kv in gui.items()], {'gui': True} ) ) # Record pip as the installer installer = os.path.join(info_dir[0], 'INSTALLER') temp_installer = os.path.join(info_dir[0], 'INSTALLER.pip') with open(temp_installer, 'wb') as installer_file: installer_file.write(b'pip\n') shutil.move(temp_installer, installer) generated.append(installer) # Record details of all files installed record = os.path.join(info_dir[0], 'RECORD') temp_record = os.path.join(info_dir[0], 'RECORD.pip') with open_for_csv(record, 'r') as record_in: with open_for_csv(temp_record, 'w+') as record_out: reader = csv.reader(record_in) writer = csv.writer(record_out) for row in reader: row[0] = installed.pop(row[0], row[0]) if row[0] in changed: row[1], row[2] = rehash(row[0]) writer.writerow(row) for f in generated: h, l = rehash(f) writer.writerow((normpath(f, lib_dir), h, l)) for f in installed: writer.writerow((installed[f], '', '')) shutil.move(temp_record, record)