def with_project_on_sys_path(self, func):
# Ensure metadata is up-to-date
self.reinitialize_command('build_py', inplace=0)
self.run_command('build_py')
bpy_cmd = self.get_finalized_command("build_py")
build_path = normalize_path(bpy_cmd.build_lib)
# Build extensions
self.reinitialize_command('egg_info', egg_base=build_path)
self.run_command('egg_info')
self.reinitialize_command('build_ext', inplace=0)
self.run_command('build_ext')
ei_cmd = self.get_finalized_command("egg_info")
old_path = sys.path[:]
old_modules = sys.modules.copy()
try:
sys.path.insert(0, normalize_path(ei_cmd.egg_base))
working_set.__init__()
add_activation_listener(lambda dist: dist.activate())
require('%s==%s' % (ei_cmd.egg_name, ei_cmd.egg_version))
func()
finally:
sys.path[:] = old_path
sys.modules.clear()
sys.modules.update(old_modules)
working_set.__init__()
def test_normalize_path_trailing_sep(self, unnormalized, normalized):
"""Ensure the trailing slash is cleaned for path comparison.
See pypa/setuptools#1519.
"""
result_from_unnormalized = pkg_resources.normalize_path(unnormalized)
result_from_normalized = pkg_resources.normalize_path(normalized)
assert result_from_unnormalized == result_from_normalized
def _resolve_setup_path(egg_base, install_dir, egg_path):
"""
Generate a path from egg_base back to '.' where the
setup script resides and ensure that path points to the
setup path from $install_dir/$egg_path.
"""
path_to_setup = egg_base.replace(os.sep, '/').rstrip('/')
if path_to_setup != os.curdir:
path_to_setup = '../' * (path_to_setup.count('/') + 1)
resolved = normalize_path(os.path.join(install_dir, egg_path, path_to_setup))
if resolved != normalize_path(os.curdir):
raise DistutilsOptionError(
"Can't get a consistent path to setup script from"
" installation directory", resolved, normalize_path(os.curdir))
return path_to_setup
def run_tests(self):
from pkg_resources import _namespace_packages
import pytest
# Purge modules under test from sys.modules. The test loader will
# re-import them from the build location. Required when 2to3 is used
# with namespace packages.
if sys.version_info >= (3,) and \
getattr(self.distribution, 'use_2to3', False):
module = self.test_args[-1].split('.')[0]
if module in _namespace_packages:
del_modules = []
if module in sys.modules:
del_modules.append(module)
module += '.'
for name in sys.modules:
if name.startswith(module):
del_modules.append(name)
map(sys.modules.__delitem__, del_modules)
## Run on the build directory for 2to3-built code..
ei_cmd = self.get_finalized_command("egg_info")
self.test_args = [normalize_path(ei_cmd.egg_base)]
errno = pytest.main(self.test_args)
sys.exit(errno)
def run_tests(self):
import pytest
from pkg_resources import normalize_path, _namespace_packages
# Purge modules under test from sys.modules. The test loader will
# re-import them from the build location. Required when 2to3 is used
# with namespace packages.
if sys.version_info >= (3,) and getattr(self.distribution, 'use_2to3', False):
#module = self.test_args[-1].split('.')[0]
module = self.test_package_name
if module in _namespace_packages:
del_modules = []
if module in sys.modules:
del_modules.append(module)
module += '.'
for name in sys.modules:
if name.startswith(module):
del_modules.append(name)
map(sys.modules.__delitem__, del_modules)
## Run on the build directory for 2to3-built code
## This will prevent the old 2.x code from being found
## by py.test discovery mechanism, that apparently
## ignores sys.path..
ei_cmd = self.get_finalized_command("egg_info")
## Replace the module name with normalized path
#self.test_args[-1] = normalize_path(ei_cmd.egg_base)
self.test_args.append(normalize_path(ei_cmd.egg_base))
errno = pytest.main(self.test_args)
sys.exit(errno)
def run(self, wininst=False):
# import bbfreeze only thenabout to run the command
from bbfreeze import Freezer
# get information from egg_info
ei = self.get_finalized_command("egg_info")
target = normalize_path(self.bdist_base)
dist = Distribution(
target,
PathMetadata(target, os.path.abspath(ei.egg_info)),
project_name=ei.egg_name)
# install wrapper_Scripts into self.bdist_base == self.script_dir
self.install_wrapper_scripts(dist)
# now get a Freezer()
f = Freezer(os.path.join(self.dist_dir,
"%s-%s" % (ei.egg_name, ei.egg_version)))
f.include_py = self.include_py
# freeze each of the scripts
for args in get_script_args(dist, wininst=wininst):
name = args[0]
if name.endswith('.exe') or name.endswith(".exe.manifest"):
# skip .exes
continue
log.info('bbfreezing %s', os.path.join(self.script_dir, name))
f.addScript(os.path.join(self.script_dir, name),
gui_only=name.endswith('.pyw'))
# starts the freezing process
f()
def add_project_to_sys_path(self):
from pkg_resources import normalize_path, add_activation_listener
from pkg_resources import working_set, require
self.reinitialize_command('egg_info')
self.run_command('egg_info')
self.reinitialize_command('build_ext', inplace=1)
self.run_command('build_ext')
# Check if this distribution is already on sys.path
# and remove that version, this ensures that the right
# copy of the package gets tested.
self.__old_path = sys.path[:]
self.__old_modules = sys.modules.copy()
ei_cmd = self.get_finalized_command('egg_info')
sys.path.insert(0, normalize_path(ei_cmd.egg_base))
sys.path.insert(1, os.path.dirname(__file__))
# Strip the namespace packages defined in this distribution
# from sys.modules, needed to reset the search path for
# those modules.
nspkgs = getattr(self.distribution, 'namespace_packages')
if nspkgs is not None:
for nm in nspkgs:
del sys.modules[nm]
# Reset pkg_resources state:
add_activation_listener(lambda dist: dist.activate())
working_set.__init__()
require('%s==%s'%(ei_cmd.egg_name, ei_cmd.egg_version))
def find_distributions(path_item, only=False): # @UnusedVariable
d = [d for d in dists
if normalize_path(os.path.join(base_d, d.location)) == path_item]
assert len(d) == 1, ("Distribution on path [%s] should not have "
"been added to '.pth' file" % str(path_item))
dists.remove(d[0])
return []
def finalize_options(self):
ei = self.get_finalized_command("egg_info")
if ei.broken_egg_info:
raise DistutilsError(
"Please rename %r to %r before using 'develop'"
% (ei.egg_info, ei.broken_egg_info)
)
self.args = [ei.egg_name]
easy_install.finalize_options(self)
self.expand_basedirs()
self.expand_dirs()
# pick up setup-dir .egg files only: no .egg-info
self.package_index.scan(glob.glob('*.egg'))
self.egg_link = os.path.join(self.install_dir, ei.egg_name+'.egg-link')
self.egg_base = ei.egg_base
if self.egg_path is None:
self.egg_path = os.path.abspath(ei.egg_base)
target = normalize_path(self.egg_base)
if normalize_path(os.path.join(self.install_dir, self.egg_path)) != target:
raise DistutilsOptionError(
"--egg-path must be a relative path from the install"
" directory to "+target
)
# Make a distribution for the package's source
self.dist = Distribution(
target,
PathMetadata(target, os.path.abspath(ei.egg_info)),
project_name = ei.egg_name
)
p = self.egg_base.replace(os.sep,'/')
if p!= os.curdir:
p = '../' * (p.count('/')+1)
self.setup_path = p
p = normalize_path(os.path.join(self.install_dir, self.egg_path, p))
if p != normalize_path(os.curdir):
raise DistutilsOptionError(
"Can't get a consistent path to setup script from"
" installation directory", p, normalize_path(os.curdir))
def test_add_from_site_is_ignored(self):
location = '/test/location/does-not-have-to-exist'
# PthDistributions expects all locations to be normalized
location = pkg_resources.normalize_path(location)
pth = PthDistributions('does-not_exist', [location, ])
assert not pth.dirty
pth.add(PRDistribution(location))
assert not pth.dirty
def main(path):
patch_stdout_stderr()
path = pkg_resources.normalize_path(path)
moduleInstallationPrefix=path+os.sep+"inst"
localSitePackages=localSitePackageFolder(moduleInstallationPrefix)
addLocalSitePackageToPythonPath(moduleInstallationPrefix)
os.makedirs(localSitePackages)
# The preferred approach to install a package is to use pip...
call_pip('pandas==0.22', localSitePackages)
# # check that the installation worked
# addLocalSitePackageToPythonPath(moduleInstallationPrefix)
# import pandas# This fails intermittently
# ...but - for some reason - pip breaks when we install the python synapse client
# So we use 'setup' directly
packageName = "synapseclient-1.9.2"
if 'PYTHON_CLIENT_GITHUB_USERNAME' in os.environ and 'PYTHON_CLIENT_GITHUB_BRANCH' in os.environ:
pythonClientGithubUsername = os.environ['PYTHON_CLIENT_GITHUB_USERNAME']
pythonClientGithubBranch = os.environ['PYTHON_CLIENT_GITHUB_BRANCH']
archivePrefix="synapsePythonClient-"+pythonClientGithubBranch
archiveSuffix=".zip"
url="https://github.com/"+pythonClientGithubUsername+"/synapsePythonClient/archive/"+pythonClientGithubBranch+archiveSuffix
else:
archivePrefix=packageName
urlPrefix = "https://files.pythonhosted.org/packages/ed/fb/67055be256b6b0906d5627f3f39f5ba8db5737162ce619c04e8f9c2c2848/"
archiveSuffix = ".tar.gz"
url = urlPrefix+archivePrefix+archiveSuffix
installPackage(packageName, url, archivePrefix, archiveSuffix, path, moduleInstallationPrefix)
# check that the installation worked
addLocalSitePackageToPythonPath(moduleInstallationPrefix)
import synapseclient
# When trying to 'synStore' a table we get the error:
# pandas.Styler requires jinja2. Please install with `conda install Jinja2`
# So let's install Jinja2 here:
# https://stackoverflow.com/questions/43163201/pyinstaller-syntax-error-yield-inside-async-function-python-3-5-1
# Jinja2 depends on MarkupSafe
packageName = "MarkupSafe-1.0"
linkPrefix = "https://pypi.python.org/packages/4d/de/32d741db316d8fdb7680822dd37001ef7a448255de9699ab4bfcbdf4172b/"
installedPackageFolderName="markupsafe"
simplePackageInstall(packageName, installedPackageFolderName, linkPrefix, path, localSitePackages)
addLocalSitePackageToPythonPath(moduleInstallationPrefix)
#import markupsafe # This fails intermittently
packageName = "Jinja2-2.8.1"
linkPrefix = "https://pypi.python.org/packages/5f/bd/5815d4d925a2b8cbbb4b4960f018441b0c65f24ba29f3bdcfb3c8218a307/"
installedPackageFolderName="jinja2"
simplePackageInstall(packageName, installedPackageFolderName, linkPrefix, path, localSitePackages)
addLocalSitePackageToPythonPath(moduleInstallationPrefix)
def add_project_to_sys_path(self):
from pkg_resources import normalize_path, add_activation_listener
from pkg_resources import working_set, require
if getattr(self.distribution, 'use_2to3', False):
# Using 2to3, cannot do this inplace:
self.reinitialize_command('build_py', inplace=0)
self.run_command('build_py')
bpy_cmd = self.get_finalized_command("build_py")
build_path = normalize_path(bpy_cmd.build_lib)
self.reinitialize_command('egg_info', egg_base=build_path)
self.run_command('egg_info')
self.reinitialize_command('build_ext', inplace=0)
self.run_command('build_ext')
else:
self.reinitialize_command('egg_info')
self.run_command('egg_info')
self.reinitialize_command('build_ext', inplace=1)
self.run_command('build_ext')
self.__old_path = sys.path[:]
self.__old_modules = sys.modules.copy()
if 'PyObjCTools' in sys.modules:
del sys.modules['PyObjCTools']
ei_cmd = self.get_finalized_command('egg_info')
sys.path.insert(0, normalize_path(ei_cmd.egg_base))
sys.path.insert(1, os.path.dirname(__file__))
add_activation_listener(lambda dist: dist.activate())
working_set.__init__()
require('%s==%s'%(ei_cmd.egg_name, ei_cmd.egg_version))
from PyObjCTools import TestSupport
if os.path.realpath(os.path.dirname(TestSupport.__file__)) != os.path.realpath('Lib/PyObjCTools'):
raise DistutilsError("Setting up test environment failed for 'PyObjCTools.TestSupport'")
import objc
if os.path.realpath(os.path.dirname(objc.__file__)) != os.path.realpath('Lib/objc'):
raise DistutilsError("Setting up test environment failed for 'objc'")
def test_all_site_dirs(self, monkeypatch):
"""
get_site_dirs should always return site dirs reported by
site.getsitepackages.
"""
path = normalize_path('/setuptools/test/site-packages')
mock_gsp = lambda: [path]
monkeypatch.setattr(site, 'getsitepackages', mock_gsp, raising=False)
assert path in ei.get_site_dirs()
def __init__(self, *args, **kwargs):
ext_dir = pkg_resources.normalize_path('build_ext')
dist = pkg_resources.Distribution(
ext_dir,
project_name='build_ext',
metadata=pkg_resources.PathMetadata(ext_dir, ext_dir)
)
pkg_resources.working_set.add(dist)
Flake8.__init__(self, *args, **kwargs)
def project_on_sys_path(self, include_dists=[]):
with_2to3 = getattr(self.distribution, 'use_2to3', False)
if with_2to3:
# If we run 2to3 we can not do this inplace:
# Ensure metadata is up-to-date
self.reinitialize_command('build_py', inplace=0)
self.run_command('build_py')
bpy_cmd = self.get_finalized_command("build_py")
build_path = normalize_path(bpy_cmd.build_lib)
# Build extensions
self.reinitialize_command('egg_info', egg_base=build_path)
self.run_command('egg_info')
self.reinitialize_command('build_ext', inplace=0)
self.run_command('build_ext')
else:
# Without 2to3 inplace works fine:
self.run_command('egg_info')
# Build extensions in-place
self.reinitialize_command('build_ext', inplace=1)
self.run_command('build_ext')
ei_cmd = self.get_finalized_command("egg_info")
old_path = sys.path[:]
old_modules = sys.modules.copy()
try:
project_path = normalize_path(ei_cmd.egg_base)
sys.path.insert(0, project_path)
working_set.__init__()
add_activation_listener(lambda dist: dist.activate())
require('%s==%s' % (ei_cmd.egg_name, ei_cmd.egg_version))
with self.paths_on_pythonpath([project_path]):
yield
finally:
sys.path[:] = old_path
sys.modules.clear()
sys.modules.update(old_modules)
working_set.__init__()
def with_project_on_sys_path(self, func):
with_2to3 = (
sys.version_info >= (3,)
and getattr(self.distribution, 'use_2to3', False)
)
if with_2to3:
# If we run 2to3 we can not do this inplace:
# Ensure metadata is up-to-date
self.reinitialize_command('build_py', inplace=0)
self.run_command('build_py')
bpy_cmd = self.get_finalized_command("build_py")
build_path = normalize_path(bpy_cmd.build_lib)
# Build extensions
self.reinitialize_command('egg_info', egg_base=build_path)
self.run_command('egg_info')
self.reinitialize_command('build_ext', inplace=0)
self.run_command('build_ext')
else:
# Without 2to3 inplace works fine:
self.run_command('egg_info')
# Build extensions in-place
self.reinitialize_command('build_ext', inplace=1)
self.run_command('build_ext')
ei_cmd = self.get_finalized_command("egg_info")
old_path = sys.path[:]
old_modules = sys.modules.copy()
try:
sys.path.insert(0, normalize_path(ei_cmd.egg_base))
working_set.__init__()
add_activation_listener(lambda dist: dist.activate())
require('%s==%s' % (ei_cmd.egg_name, ei_cmd.egg_version))
func()
finally:
sys.path[:] = old_path
sys.modules.clear()
sys.modules.update(old_modules)
working_set.__init__()
def _resolve_setup_path(egg_base, install_dir, egg_path):
"""
Generate a path from egg_base back to '.' where the
setup script resides and ensure that path points to the
setup path from $install_dir/$egg_path.
"""
path_to_setup = egg_base.replace(os.sep, "/").rstrip("/")
if path_to_setup != os.curdir:
path_to_setup = "../" * (path_to_setup.count("/") + 1)
resolved = pkg_resources.normalize_path(
os.path.join(install_dir, egg_path, path_to_setup))
if resolved != pkg_resources.normalize_path(os.curdir):
raise DistutilsOptionError(
"Can't get a consistent path to setup script from"
" installation directory",
resolved,
pkg_resources.normalize_path(os.curdir),
)
return path_to_setup
def test_add_from_site_is_ignored(self):
location = '/test/location/does-not-have-to-exist'
# PthDistributions expects all locations to be normalized
location = pkg_resources.normalize_path(location)
pth = PthDistributions('does-not_exist', [
location,
])
assert not pth.dirty
pth.add(PRDistribution(location))
assert not pth.dirty
def _add_eggs_to_path(self):
"""Adds all egg files under .eggs to sys.path"""
# TODO(jtattemusch): there has to be a cleaner way to do this
import pkg_resources
eggs_dir = os.path.join(PYTHON_STEM, '../../../.eggs')
eggs = [os.path.join(eggs_dir, filename)
for filename in os.listdir(eggs_dir)
if filename.endswith('.egg')]
for egg in eggs:
sys.path.insert(0, pkg_resources.normalize_path(egg))
def finalize_options(self):
ei = self.get_finalized_command("egg_info")
if ei.broken_egg_info:
template = "Please rename %r to %r before using 'develop'"
args = ei.egg_info, ei.broken_egg_info
raise DistutilsError(template % args)
self.args = [ei.egg_name]
easy_install.finalize_options(self)
self.expand_basedirs()
self.expand_dirs()
# pick up setup-dir .egg files only: no .egg-info
self.package_index.scan(glob.glob('*.egg'))
self.egg_link = os.path.join(self.install_dir,
ei.egg_name + '.egg-link')
self.egg_base = ei.egg_base
if self.egg_path is None:
self.egg_path = os.path.abspath(ei.egg_base)
target = normalize_path(self.egg_base)
egg_path = normalize_path(os.path.join(self.install_dir,
self.egg_path))
if egg_path != target:
raise DistutilsOptionError(
"--egg-path must be a relative path from the install"
" directory to " + target)
# Make a distribution for the package's source
self.dist = Distribution(target,
PathMetadata(target,
os.path.abspath(ei.egg_info)),
project_name=ei.egg_name)
p = self.egg_base.replace(os.sep, '/')
if p != os.curdir:
p = '../' * (p.count('/') + 1)
self.setup_path = p
p = normalize_path(os.path.join(self.install_dir, self.egg_path, p))
if p != normalize_path(os.curdir):
raise DistutilsOptionError(
"Can't get a consistent path to setup script from"
" installation directory", p, normalize_path(os.curdir))
def finalize_options(self):
ei = self.get_finalized_command("egg_info")
if ei.broken_egg_info:
template = "Please rename %r to %r before using 'develop'"
args = ei.egg_info, ei.broken_egg_info
raise DistutilsError(template % args)
self.args = [ei.egg_name]
easy_install.finalize_options(self)
self.expand_basedirs()
self.expand_dirs()
# pick up setup-dir .egg files only: no .egg-info
self.package_index.scan(glob.glob("*.egg"))
egg_link_fn = ei.egg_name + ".egg-link"
self.egg_link = os.path.join(self.install_dir, egg_link_fn)
self.egg_base = ei.egg_base
if self.egg_path is None:
self.egg_path = os.path.abspath(ei.egg_base)
target = pkg_resources.normalize_path(self.egg_base)
egg_path = pkg_resources.normalize_path(
os.path.join(self.install_dir, self.egg_path)
)
if egg_path != target:
raise DistutilsOptionError(
"--egg-path must be a relative path from the install"
" directory to " + target
)
# Make a distribution for the package's source
self.dist = pkg_resources.Distribution(
target,
pkg_resources.PathMetadata(target, os.path.abspath(ei.egg_info)),
project_name=ei.egg_name,
)
self.setup_path = self._resolve_setup_path(
self.egg_base,
self.install_dir,
self.egg_path,
)
def _add_eggs_to_path(self):
"""Adds all egg files under .eggs to sys.path"""
# TODO(jtattemusch): there has to be a cleaner way to do this
import pkg_resources
eggs_dir = os.path.join(PYTHON_STEM, '../../../.eggs')
eggs = [
os.path.join(eggs_dir, filename)
for filename in os.listdir(eggs_dir) if filename.endswith('.egg')
]
for egg in eggs:
sys.path.insert(0, pkg_resources.normalize_path(egg))
def get_project_path(self):
self.run_command('egg_info')
# Build extensions in-place
self.reinitialize_command('build_ext', inplace=1)
self.run_command('build_ext')
ei_cmd = self.get_finalized_command("egg_info")
project_path = normalize_path(ei_cmd.egg_base)
return os.path.join(project_path, to_filename(ei_cmd.egg_name))
def test_all_site_dirs(self, monkeypatch):
"""
get_site_dirs should always return site dirs reported by
site.getsitepackages.
"""
path = normalize_path('/setuptools/test/site-packages')
def mock_gsp():
return [path]
monkeypatch.setattr(site, 'getsitepackages', mock_gsp, raising=False)
assert path in ei.get_site_dirs()
def finalize_options(self):
ei = self.get_finalized_command("egg_info")
if ei.broken_egg_info:
template = "Please rename %r to %r before using 'develop'"
args = ei.egg_info, ei.broken_egg_info
raise DistutilsError(template % args)
self.args = [ei.egg_name]
easy_install.finalize_options(self)
self.expand_basedirs()
self.expand_dirs()
# pick up setup-dir .egg files only: no .egg-info
self.package_index.scan(glob.glob('*.egg'))
egg_link_fn = ei.egg_name + '.egg-link'
self.egg_link = os.path.join(self.install_dir, egg_link_fn)
self.egg_base = ei.egg_base
if self.egg_path is None:
self.egg_path = os.path.abspath(ei.egg_base)
target = normalize_path(self.egg_base)
egg_path = normalize_path(os.path.join(self.install_dir,
self.egg_path))
if egg_path != target:
raise DistutilsOptionError(
"--egg-path must be a relative path from the install"
" directory to " + target
)
# Make a distribution for the package's source
self.dist = Distribution(
target,
PathMetadata(target, os.path.abspath(ei.egg_info)),
project_name=ei.egg_name
)
self.setup_path = self._resolve_setup_path(
self.egg_base,
self.install_dir,
self.egg_path,
)
def _run_tests(self):
old_path = sys.path[:]
ei_cmd = self.get_finalized_command("egg_info")
path_item = normalize_path(ei_cmd.egg_base)
metadata = PathMetadata(path_item, normalize_path(ei_cmd.egg_info))
dist = Distribution(path_item, metadata, project_name=ei_cmd.egg_name)
working_set.add(dist)
require(str(dist.as_requirement()))
loader_ep = EntryPoint.parse("x=" + self.test_loader)
loader_class = loader_ep.load(require=False)
try:
import unittest
unittest.main(None,
None, [unittest.__file__] + self.test_args,
testRunner=XMLTestRunner(
stream=sys.stdout,
xml_stream=self.xml_output_file),
testLoader=loader_class())
except SystemExit, e:
return e.code
def install_item(self, spec, download, tmpdir, deps, install_needed=False):
""" The only difference between this and the standard implementation is that it doesn't copy
eggs from the egg cache but links to them in place.
"""
# Installation is also needed if file in tmpdir or is not an egg
install_needed = install_needed or self.always_copy
install_needed = install_needed or os.path.dirname(download) == tmpdir
install_needed = install_needed or not download.endswith('.egg')
install_needed = install_needed or (
self.always_copy_from is not None and
os.path.dirname(pkg_resources.normalize_path(download)) ==
pkg_resources.normalize_path(self.always_copy_from)
)
# This is the only bit that is different:
# <---------- here ----------------->
if not egg_cache.is_from_egg_cache(download) and spec and not install_needed:
# at this point, we know it's a local .egg, we just don't know if
# it's already installed.
for dist in self.local_index[spec.project_name]:
if dist.location == download:
break
else:
install_needed = True # it's not in the local index
log.info("Processing %s", os.path.basename(download))
if install_needed:
dists = self.install_eggs(spec, download, tmpdir)
for dist in dists:
self.process_distribution(spec, dist, deps)
else:
dists = [self.egg_distribution(download)]
self.process_distribution(spec, dists[0], deps, "Using")
if spec is not None:
for dist in dists:
if dist in spec:
return dist
def install_item(self, spec, download, tmpdir, deps, install_needed=False):
""" The only difference between this and the standard implementation is that it doesn't copy
eggs from the egg cache but links to them in place.
"""
# Installation is also needed if file in tmpdir or is not an egg
install_needed = install_needed or self.always_copy
install_needed = install_needed or os.path.dirname(download) == tmpdir
install_needed = install_needed or not download.endswith('.egg')
install_needed = install_needed or (
self.always_copy_from is not None
and os.path.dirname(pkg_resources.normalize_path(download))
== pkg_resources.normalize_path(self.always_copy_from))
# This is the only bit that is different:
# <---------- here ----------------->
if not egg_cache.is_from_egg_cache(
download) and spec and not install_needed:
# at this point, we know it's a local .egg, we just don't know if
# it's already installed.
for dist in self.local_index[spec.project_name]:
if dist.location == download:
break
else:
install_needed = True # it's not in the local index
log.info("Processing %s", os.path.basename(download))
if install_needed:
dists = self.install_eggs(spec, download, tmpdir)
for dist in dists:
self.process_distribution(spec, dist, deps)
else:
dists = [self.egg_distribution(download)]
self.process_distribution(spec, dists[0], deps, "Using")
if spec is not None:
for dist in dists:
if dist in spec:
return dist
def add_project_to_sys_path(self):
from pkg_resources import normalize_path, add_activation_listener
from pkg_resources import working_set, require
if getattr(self.distribution, 'use_2to3', False):
# Using 2to3, cannot do this inplace:
self.reinitialize_command('build_py', inplace=0)
self.run_command('build_py')
bpy_cmd = self.get_finalized_command("build_py")
build_path = normalize_path(bpy_cmd.build_lib)
self.reinitialize_command('egg_info', egg_base=build_path)
self.run_command('egg_info')
self.reinitialize_command('build_ext', inplace=0)
self.run_command('build_ext')
else:
self.reinitialize_command('egg_info')
self.run_command('egg_info')
self.reinitialize_command('build_ext', inplace=1)
self.run_command('build_ext')
self.__old_path = sys.path[:]
self.__old_modules = sys.modules.copy()
if 'PyObjCTools' in sys.modules:
del sys.modules['PyObjCTools']
ei_cmd = self.get_finalized_command('egg_info')
sys.path.insert(0, normalize_path(ei_cmd.egg_base))
sys.path.insert(1, os.path.dirname(__file__))
add_activation_listener(lambda dist: dist.activate())
working_set.__init__()
require('%s==%s'%(ei_cmd.egg_name, ei_cmd.egg_version))
def add_project_to_sys_path(self):
from pkg_resources import normalize_path, add_activation_listener
from pkg_resources import working_set, require
if getattr(self.distribution, 'use_2to3', False):
# Using 2to3, cannot do this inplace:
self.reinitialize_command('build_py', inplace=0)
self.run_command('build_py')
bpy_cmd = self.get_finalized_command("build_py")
build_path = normalize_path(bpy_cmd.build_lib)
self.reinitialize_command('egg_info', egg_base=build_path)
self.run_command('egg_info')
self.reinitialize_command('build_ext', inplace=0)
self.run_command('build_ext')
else:
self.reinitialize_command('egg_info')
self.run_command('egg_info')
self.reinitialize_command('build_ext', inplace=1)
self.run_command('build_ext')
self.__old_path = sys.path[:]
self.__old_modules = sys.modules.copy()
if 'PyObjCTools' in sys.modules:
del sys.modules['PyObjCTools']
ei_cmd = self.get_finalized_command('egg_info')
sys.path.insert(0, normalize_path(ei_cmd.egg_base))
sys.path.insert(1, os.path.dirname(__file__))
add_activation_listener(lambda dist: dist.activate())
working_set.__init__()
require('%s==%s'%(ei_cmd.egg_name, ei_cmd.egg_version))
def _run_tests(self):
old_path = sys.path[:]
ei_cmd = self.get_finalized_command("egg_info")
path_item = normalize_path(ei_cmd.egg_base)
metadata = PathMetadata(
path_item, normalize_path(ei_cmd.egg_info)
)
dist = Distribution(path_item, metadata, project_name=ei_cmd.egg_name)
working_set.add(dist)
require(str(dist.as_requirement()))
loader_ep = EntryPoint.parse("x=" + self.test_loader)
loader_class = loader_ep.load(require=False)
try:
import unittest
unittest.main(
None, None, [unittest.__file__] + self.test_args,
testRunner=XMLTestRunner(stream=sys.stdout,
xml_stream=self.xml_output_file),
testLoader=loader_class()
)
except SystemExit, e:
return e.code
def install_for_development(self):
if not six.PY2 and getattr(self.distribution, "use_2to3", False):
# If we run 2to3 we can not do this inplace:
# Ensure metadata is up-to-date
self.reinitialize_command("build_py", inplace=0)
self.run_command("build_py")
bpy_cmd = self.get_finalized_command("build_py")
build_path = pkg_resources.normalize_path(bpy_cmd.build_lib)
# Build extensions
self.reinitialize_command("egg_info", egg_base=build_path)
self.run_command("egg_info")
self.reinitialize_command("build_ext", inplace=0)
self.run_command("build_ext")
# Fixup egg-link and easy-install.pth
ei_cmd = self.get_finalized_command("egg_info")
self.egg_path = build_path
self.dist.location = build_path
# XXX
self.dist._provider = pkg_resources.PathMetadata(
build_path, ei_cmd.egg_info
)
else:
# Without 2to3 inplace works fine:
self.run_command("egg_info")
# Build extensions in-place
self.reinitialize_command("build_ext", inplace=1)
self.run_command("build_ext")
self.install_site_py() # ensure that target dir is site-safe
if setuptools.bootstrap_install_from:
self.easy_install(setuptools.bootstrap_install_from)
setuptools.bootstrap_install_from = None
self.install_namespaces()
# create an .egg-link in the installation dir, pointing to our egg
log.info("Creating %s (link to %s)", self.egg_link, self.egg_base)
if not self.dry_run:
with open(self.egg_link, "w") as f:
f.write(self.egg_path + "\n" + self.setup_path)
# postprocess the installed distro, fixing up .pth, installing scripts,
# and handling requirements
self.process_distribution(None, self.dist, not self.no_deps)
def project_on_sys_path(self):
self.build_in_place()
ei_cmd = self.get_finalized_command("egg_info")
old_path = sys.path[:]
old_modules = sys.modules.copy()
try:
sys.path.insert(0, pkg_resources.normalize_path(ei_cmd.egg_base))
pkg_resources.working_set.__init__()
pkg_resources.add_activation_listener(lambda dist: dist.activate())
pkg_resources.require('%s==%s' % (ei_cmd.egg_name, ei_cmd.egg_version))
yield
finally:
sys.path[:] = old_path
sys.modules.clear()
sys.modules.update(old_modules)
pkg_resources.working_set.__init__()
def project_on_sys_path(self):
self.build_in_place()
ei_cmd = self.get_finalized_command("egg_info")
old_path = sys.path[:]
old_modules = sys.modules.copy()
try:
sys.path.insert(0, pkg_resources.normalize_path(ei_cmd.egg_base))
pkg_resources.working_set.__init__()
pkg_resources.add_activation_listener(lambda dist: dist.activate())
pkg_resources.require('%s==%s' % (ei_cmd.egg_name, ei_cmd.egg_version))
yield
finally:
sys.path[:] = old_path
sys.modules.clear()
sys.modules.update(old_modules)
pkg_resources.working_set.__init__()
def install_for_development(self):
if six.PY3 and getattr(self.distribution, 'use_2to3', False):
# If we run 2to3 we can not do this inplace:
# Ensure metadata is up-to-date
self.reinitialize_command('build_py', inplace=0)
self.run_command('build_py')
bpy_cmd = self.get_finalized_command("build_py")
build_path = pkg_resources.normalize_path(bpy_cmd.build_lib)
# Build extensions
self.reinitialize_command('egg_info', egg_base=build_path)
self.run_command('egg_info')
self.reinitialize_command('build_ext', inplace=0)
self.run_command('build_ext')
# Fixup egg-link and easy-install.pth
ei_cmd = self.get_finalized_command("egg_info")
self.egg_path = build_path
self.dist.location = build_path
# XXX
self.dist._provider = pkg_resources.PathMetadata(
build_path, ei_cmd.egg_info)
else:
# Without 2to3 inplace works fine:
self.run_command('egg_info')
# Build extensions in-place
self.reinitialize_command('build_ext', inplace=1)
self.run_command('build_ext')
self.install_site_py() # ensure that target dir is site-safe
if setuptools.bootstrap_install_from:
self.easy_install(setuptools.bootstrap_install_from)
setuptools.bootstrap_install_from = None
self.install_namespaces()
# create an .egg-link in the installation dir, pointing to our egg
log.info("Creating %s (link to %s)", self.egg_link, self.egg_base)
if not self.dry_run:
with open(self.egg_link, "w") as f:
f.write(self.egg_path + "\n" + self.setup_path)
# postprocess the installed distro, fixing up .pth, installing scripts,
# and handling requirements
self.process_distribution(None, self.dist, not self.no_deps)
def run_tests(self):
import pytest
# Purge modules under test from sys.modules. The test loader will
# re-import them from the build location. Required when 2to3 is used
# with namespace packages.
if sys.version_info >= (3,) and \
getattr(self.distribution, 'use_2to3', False):
sys.modules.__delitem__('nobel')
sys.modules.__delitem__('nobel.api')
## Run on the build directory for 2to3-built code.
ei_cmd = self.get_finalized_command("egg_info")
self.test_args = [normalize_path(ei_cmd.egg_base)]
errno = pytest.main(self.test_args)
sys.exit(errno)
def main(command, path):
path = pkg_resources.normalize_path(path)
moduleInstallationPrefix = path + os.sep + "inst"
localSitePackages = localSitePackageFolder(moduleInstallationPrefix)
addLocalSitePackageToPythonPath(moduleInstallationPrefix)
if not os.path.exists(localSitePackages):
os.makedirs(localSitePackages)
if command == 'install':
call_pip('pandas', localSitePackages, PANDAS_VERSION)
elif command == 'uninstall':
remove_dirs('pandas', localSitePackages)
else:
raise Exception("command not supported: " + command)
def run_tests(self):
import pytest
# Purge modules under test from sys.modules. The test loader will
# re-import them from the build location. Required when 2to3 is used
# with namespace packages.
if sys.version_info >= (3,) and \
getattr(self.distribution, 'use_2to3', False):
sys.modules.__delitem__('nobel')
sys.modules.__delitem__('nobel.api')
## Run on the build directory for 2to3-built code.
ei_cmd = self.get_finalized_command("egg_info")
self.test_args = [normalize_path(ei_cmd.egg_base)]
errno = pytest.main(self.test_args)
sys.exit(errno)
def finalize_options(self):
ei = self.get_finalized_command("egg_info")
if ei.broken_egg_info:
raise DistutilsError(
"Please rename %r to %r before using 'develop'" %
(ei.egg_info, ei.broken_egg_info))
self.args = [ei.egg_name]
easy_install.finalize_options(self)
self.egg_link = os.path.join(self.install_dir,
ei.egg_name + '.egg-link')
self.egg_base = ei.egg_base
self.egg_path = os.path.abspath(ei.egg_base)
# Make a distribution for the package's source
self.dist = Distribution(normalize_path(self.egg_path),
PathMetadata(self.egg_path,
os.path.abspath(ei.egg_info)),
project_name=ei.egg_name)
def run(self):
use_2to3 = getattr(self.distribution, 'use_2to3', False)
test_dirs = getattr(self.distribution, 'test_dirs', [])
test_base = self.test_base
bpy_cmd = self.get_finalized_command("build_py")
lib_base = normalize_path(bpy_cmd.build_lib)
modified = []
py_modified = []
doc_modified = []
dir_util.mkpath(test_base)
for testdir in test_dirs:
for srcdir, dirnames, filenames in os.walk(testdir):
destdir = os.path.join(test_base, srcdir)
dir_util.mkpath(destdir)
for fn in filenames:
if fn.startswith("."):
# Skip .svn folders and such
continue
dstfile, copied = file_util.copy_file(
os.path.join(srcdir, fn),
os.path.join(destdir, fn),
update=True)
if copied:
modified.append(dstfile)
if fn.endswith('.py'):
py_modified.append(dstfile)
for ext in self.distribution.doctest_exts:
if fn.endswith(ext):
doc_modified.append(dstfile)
break
if use_2to3:
self.run_2to3(py_modified)
self.run_2to3(doc_modified, True)
if self.distribution.pyversion_patching:
if patch is not None:
for file in modified:
pyversion_patch(file)
else:
log.warn(
"Warning: pyversion_patching specified in setup config but patch module not found. Patching will not be performed."
)
dir_util.mkpath(lib_base)
self.reinitialize_command('egg_info', egg_base=lib_base)
self.run_command('egg_info')
def run(self):
use_2to3 = getattr(self.distribution, 'use_2to3', False)
test_dirs = getattr(self.distribution, 'test_dirs', [])
test_base = self.test_base
bpy_cmd = self.get_finalized_command("build_py")
lib_base = normalize_path(bpy_cmd.build_lib)
modified = []
py_modified = []
doc_modified = []
dir_util.mkpath(test_base)
for testdir in test_dirs:
for srcdir, dirnames, filenames in os.walk(testdir):
destdir = os.path.join(test_base, srcdir)
dir_util.mkpath(destdir)
for fn in filenames:
if fn.startswith("."):
# Skip .svn folders and such
continue
dstfile, copied = file_util.copy_file(
os.path.join(srcdir, fn),
os.path.join(destdir, fn),
update=True)
if copied:
modified.append(dstfile)
if fn.endswith('.py'):
py_modified.append(dstfile)
for ext in self.distribution.doctest_exts:
if fn.endswith(ext):
doc_modified.append(dstfile)
break
if use_2to3:
self.run_2to3(py_modified)
self.run_2to3(doc_modified, True)
if self.distribution.pyversion_patching:
if patch is not None:
for file in modified:
pyversion_patch(file)
else:
log.warn("Warning: pyversion_patching specified in setup config but patch module not found. Patching will not be performed.")
dir_util.mkpath(lib_base)
self.reinitialize_command('egg_info', egg_base=lib_base)
self.run_command('egg_info')
def patch_UninstallPathSet(egg_caches, install_dir):
# pip uninstall doesn't realise that you can remove an entry from the virtualenv
# easy-install.pth file even if the egg itself is outside the virtualenv i.e. in
# the egg cache. Fix it by adjusting the pth file and entry.
from pip import req
ei_pth_file = os.path.join(normalize_path(install_dir), 'easy-install.pth')
class UninstallPathSet(req.UninstallPathSet):
def _can_uninstall(self):
return True
def add_pth(self, pth_file, entry):
if any(pth_file.startswith(egg_cache) for egg_cache in egg_caches):
pth_file, entry = ei_pth_file, self.dist.location
super(UninstallPathSet, self).add_pth(pth_file, entry)
req.UninstallPathSet, old_UninstallPathSet = UninstallPathSet, req.UninstallPathSet
try:
yield None
finally:
req.UninstallPathSet = old_UninstallPathSet
def patch_UninstallPathSet(egg_caches, install_dir):
# pip uninstall doesn't realise that you can remove an entry from the virtualenv
# easy-install.pth file even if the egg itself is outside the virtualenv i.e. in
# the egg cache. Fix it by adjusting the pth file and entry.
from pip import req
ei_pth_file = os.path.join(normalize_path(install_dir), 'easy-install.pth')
class UninstallPathSet(req.UninstallPathSet):
def _can_uninstall(self):
return True
def add_pth(self, pth_file, entry):
if any(pth_file.startswith(egg_cache) for egg_cache in egg_caches):
pth_file, entry = ei_pth_file, self.dist.location
super(UninstallPathSet, self).add_pth(pth_file, entry)
req.UninstallPathSet, old_UninstallPathSet = UninstallPathSet, req.UninstallPathSet
try:
yield None
finally:
req.UninstallPathSet = old_UninstallPathSet
def add_project_to_sys_path(self):
from pkg_resources import normalize_path, add_activation_listener
from pkg_resources import working_set, require
self.reinitialize_command("egg_info")
self.run_command("egg_info")
self.reinitialize_command("build_ext", inplace=1)
self.run_command("build_ext")
self.__old_path = sys.path[:]
self.__old_modules = sys.modules.copy()
if "PyObjCTools" in sys.modules:
del sys.modules["PyObjCTools"]
ei_cmd = self.get_finalized_command("egg_info")
sys.path.insert(0, normalize_path(ei_cmd.egg_base))
sys.path.insert(1, os.path.dirname(__file__))
add_activation_listener(lambda dist: dist.activate())
working_set.__init__()
require("%s==%s" % (ei_cmd.egg_name, ei_cmd.egg_version))
def add_project_to_sys_path(self):
from pkg_resources import normalize_path, add_activation_listener
from pkg_resources import working_set, require
self.reinitialize_command('egg_info')
self.run_command('egg_info')
self.reinitialize_command('build_ext', inplace=1)
self.run_command('build_ext')
self.__old_path = sys.path[:]
self.__old_modules = sys.modules.copy()
if 'PyObjCTools' in sys.modules:
del sys.modules['PyObjCTools']
ei_cmd = self.get_finalized_command('egg_info')
sys.path.insert(0, normalize_path(ei_cmd.egg_base))
sys.path.insert(1, os.path.dirname(__file__))
add_activation_listener(lambda dist: dist.activate())
working_set.__init__()
require('%s==%s' % (ei_cmd.egg_name, ei_cmd.egg_version))
def run_tests(self):
import pytest
from pkg_resources import normalize_path, _namespace_packages
if sys.version_info >= (3, ) and getattr(self.distribution, 'use_2to3',
False):
module = self.test_package_name
if module in _namespace_packages:
del_modules = []
if module in sys.modules:
del_modules.append(module)
module += '.'
for name in sys.modules:
if name.startswith(module):
del_modules.append(name)
map(sys.modules.__delitem__, del_modules)
ei_cmd = self.get_finalized_command('egg_info')
self.test_args.append(normalize_path(ei_cmd.egg_base))
errno = pytest.main(self.test_args)
sys.exit(errno)
def add_project_to_sys_path(self):
from pkg_resources import normalize_path, add_activation_listener
from pkg_resources import working_set, require
self.reinitialize_command("egg_info")
self.run_command("egg_info")
self.reinitialize_command("build_ext", inplace=1)
self.run_command("build_ext")
self.__old_path = sys.path[:]
self.__old_modules = sys.modules.copy()
if "PyObjCTools" in sys.modules:
del sys.modules["PyObjCTools"]
ei_cmd = self.get_finalized_command("egg_info")
sys.path.insert(0, normalize_path(ei_cmd.egg_base))
sys.path.insert(1, os.path.dirname(__file__))
add_activation_listener(lambda dist: dist.activate())
working_set.__init__()
require("%s==%s" % (ei_cmd.egg_name, ei_cmd.egg_version))
from PyObjCTools import TestSupport
if os.path.realpath(os.path.dirname(
TestSupport.__file__)) != os.path.realpath("Lib/PyObjCTools"):
raise DistutilsError(
"Setting up test environment failed for 'PyObjCTools.TestSupport'"
)
import objc
if os.path.realpath(os.path.dirname(
objc.__file__)) != os.path.realpath("Lib/objc"):
raise DistutilsError(
"Setting up test environment failed for 'objc'")
def add_project_to_sys_path(self):
from pkg_resources import (
add_activation_listener,
normalize_path,
require,
working_set,
)
self.reinitialize_command("egg_info")
self.run_command("egg_info")
self.reinitialize_command("build_ext", inplace=1)
self.run_command("build_ext")
# Check if this distribution is already on sys.path
# and remove that version, this ensures that the right
# copy of the package gets tested.
self.__old_path = sys.path[:]
self.__old_modules = sys.modules.copy()
ei_cmd = self.get_finalized_command("egg_info")
sys.path.insert(0, normalize_path(ei_cmd.egg_base))
sys.path.insert(1, os.path.dirname(__file__))
# Strip the namespace packages defined in this distribution
# from sys.modules, needed to reset the search path for
# those modules.
nspkgs = getattr(self.distribution, "namespace_packages", None)
if nspkgs is not None:
for nm in nspkgs:
del sys.modules[nm]
# Reset pkg_resources state:
add_activation_listener(lambda dist: dist.activate())
working_set.__init__()
require("%s==%s" % (ei_cmd.egg_name, ei_cmd.egg_version))
def assert_dists_in_pth(mocks, *dists):
# Check that only the required distributions were added to "*.pth" file
pth_file = [f for n, f in
mocks[_easy_install_mocks][_written_pth_files].items()
if os.path.basename(n) == "easy-install.pth"]
pth_file = pth_file[0] if pth_file else io.BytesIO()
dists = list(dists)
pth_filename = "/<pth_file>"
base_d = normalize_path(os.path.dirname(pth_filename))
def find_distributions(path_item, only=False): # @UnusedVariable
d = [d for d in dists
if normalize_path(os.path.join(base_d, d.location)) == path_item]
assert len(d) == 1, ("Distribution on path [%s] should not have "
"been added to '.pth' file" % str(path_item))
dists.remove(d[0])
return []
pth_file_dict = {pth_filename: pth_file}
pth_file.seek(0)
with ExitStack() as stack:
ec = stack.enter_context
ec(_patch_open(pth_file_dict))
ec(patch("os.path.exists", new=lambda _: True))
ec(patch("os.path.isfile", new=lambda f: f == pth_filename))
ec(patch(_ei_find_distributions, new=find_distributions))
PthDistributions(pth_filename)
assert not dists, ("[%d] distributions were not added to the '.pth' "
"file: %s" % (len(dists), str(dists)))
pkg_resources.normalize_path(os.curdir))
return path_to_setup
def install_for_development(self):
<<<<<<< HEAD
if not six.PY2 and getattr(self.distribution, 'use_2to3', False):
=======
if getattr(self.distribution, 'use_2to3', False):
>>>>>>> 7e5c5fbd6c824de4d4c2b62da3f7cae87d462119
# If we run 2to3 we can not do this inplace:
# Ensure metadata is up-to-date
self.reinitialize_command('build_py', inplace=0)
self.run_command('build_py')
bpy_cmd = self.get_finalized_command("build_py")
build_path = pkg_resources.normalize_path(bpy_cmd.build_lib)
# Build extensions
self.reinitialize_command('egg_info', egg_base=build_path)
self.run_command('egg_info')
self.reinitialize_command('build_ext', inplace=0)
self.run_command('build_ext')
# Fixup egg-link and easy-install.pth
ei_cmd = self.get_finalized_command("egg_info")
self.egg_path = build_path
self.dist.location = build_path
# XXX
self.dist._provider = pkg_resources.PathMetadata(
build_path, ei_cmd.egg_info)
def distros_for_filename(filename, metadata=None):
"""Yield possible egg or source distribution objects based on a filename"""
return distros_for_location(normalize_path(filename),
os.path.basename(filename), metadata)
def run(self):
"""A command's raison d'etre: carry out the action it exists to perform, controlled by the options initialized
in 'initialize_options()', customized by other commands, the setup script, the command-line, and config files,
and finalized in 'finalize_options()'. All terminal output and filesystem interaction should be done by
'run()'.
"""
if not self.skip_build:
# Make sure install requirements are actually installed
if self.distribution.install_requires:
self.announce('Installing *install_requires* packages')
subprocess.check_call(
[sys.executable, '-m', 'pip', 'install', '--user', '-q'] +
self.distribution.install_requires)
# Ensure metadata is up-to-date
self.reinitialize_command('build_py', inplace=0)
self.run_command('build_py')
bpy_cmd = self.get_finalized_command("build_py")
build_path = normalize_path(bpy_cmd.build_lib)
# Build extensions
self.reinitialize_command('egg_info', egg_base=build_path)
self.run_command('egg_info')
self.reinitialize_command('build_ext', inplace=0)
self.run_command('build_ext')
# Make sure test requirements are actually installed
if self.distribution.tests_require:
self.announce('Installing *test_require* packages')
subprocess.check_call(
[sys.executable, '-m', 'pip', 'install', '--user', '-q'] +
self.distribution.tests_require)
ei_cmd = self.get_finalized_command("egg_info")
# Get actual package location
if self.skip_build:
# Retrieve installation directory
package_path = normalize_path(
get_distribution(PACKAGE_NAME).location)
else:
# Package was just built...
package_path = normalize_path(ei_cmd.egg_base)
old_path = sys.path[:]
old_modules = sys.modules.copy()
try:
if self.skip_build:
sys.path.pop(0)
else:
sys.path.insert(0, package_path)
working_set.__init__()
add_activation_listener(lambda dist: dist.activate())
require('%s==%s' % (ei_cmd.egg_name, ei_cmd.egg_version))
if not self._run_tests(package_path):
raise DistutilsError("Tests failed!")
finally:
sys.path[:] = old_path
sys.modules.clear()
sys.modules.update(old_modules)
working_set.__init__()
def finalize_options(self):
if self.with_httpd is not None:
self.with_httpd = normalize_path(expanduser(self.with_httpd))
def finalize_options(self):
ei = self.get_finalized_command("egg_info")
if ei.broken_egg_info:
raise DistutilsError(
"Please rename %r to %r before using 'develop'"
% (ei.egg_info, ei.broken_egg_info)
)
self.args = [ei.egg_name]
py_version = sys.version.split()[0]
prefix, exec_prefix = get_config_vars('prefix', 'exec_prefix')
self.config_vars = {'dist_name': self.distribution.get_name(),
'dist_version': self.distribution.get_version(),
'dist_fullname': self.distribution.get_fullname(),
'py_version': py_version,
'py_version_short': py_version[0:3],
'py_version_nodot': py_version[0] + py_version[2],
'sys_prefix': prefix,
'prefix': prefix,
'sys_exec_prefix': exec_prefix,
'exec_prefix': exec_prefix,
}
if HAS_USER_SITE:
self.config_vars['userbase'] = self.install_userbase
self.config_vars['usersite'] = self.install_usersite
# fix the install_dir if "--user" was used
if self.user:
self.create_home_path()
if self.install_userbase is None:
raise DistutilsPlatformError(
"User base directory is not specified")
self.install_base = self.install_platbase = self.install_userbase
if os.name == 'posix':
self.select_scheme("unix_user")
else:
self.select_scheme(os.name + "_user")
self.expand_basedirs()
self.expand_dirs()
if self.user and self.install_purelib:
self.install_dir = self.install_purelib
self.script_dir = self.install_scripts
easy_install.finalize_options(self)
# pick up setup-dir .egg files only: no .egg-info
self.package_index.scan(glob.glob('*.egg'))
self.egg_link = os.path.join(self.install_dir, ei.egg_name+'.egg-link')
self.egg_base = ei.egg_base
if self.egg_path is None:
self.egg_path = os.path.abspath(ei.egg_base)
target = normalize_path(self.egg_base)
if normalize_path(os.path.join(self.install_dir, self.egg_path)) != target:
raise DistutilsOptionError(
"--egg-path must be a relative path from the install"
" directory to "+target
)
# Make a distribution for the package's source
self.dist = Distribution(
target,
PathMetadata(target, os.path.abspath(ei.egg_info)),
project_name = ei.egg_name
)
p = self.egg_base.replace(os.sep,'/')
if p!= os.curdir:
p = '../' * (p.count('/')+1)
self.setup_path = p
p = normalize_path(os.path.join(self.install_dir, self.egg_path, p))
if p != normalize_path(os.curdir):
raise DistutilsOptionError(
"Can't get a consistent path to setup script from"
" installation directory", p, normalize_path(os.curdir))
def test_normalize_path_normcase(self, unnormalized, normalized):
"""Ensure mixed case is normalized on case-insensitive filesystems.
"""
result_from_unnormalized = pkg_resources.normalize_path(unnormalized)
result_from_normalized = pkg_resources.normalize_path(normalized)
assert result_from_unnormalized == result_from_normalized
def distros_for_filename(filename, metadata=None):
"""Yield possible egg or source distribution objects based on a filename"""
return distros_for_location(
normalize_path(filename), os.path.basename(filename), metadata
)
def test_normalize_path_backslash_sep(self, unnormalized, expected):
"""Ensure path seps are cleaned on backslash path sep systems.
"""
result = pkg_resources.normalize_path(unnormalized)
assert result.endswith(expected)
def project_on_sys_path(self, include_dists=[]):
<<<<<<< HEAD
with_2to3 = not six.PY2 and getattr(
self.distribution, 'use_2to3', False)
=======
with_2to3 = getattr(self.distribution, 'use_2to3', False)
>>>>>>> 7e5c5fbd6c824de4d4c2b62da3f7cae87d462119
if with_2to3:
# If we run 2to3 we can not do this inplace:
# Ensure metadata is up-to-date
self.reinitialize_command('build_py', inplace=0)
self.run_command('build_py')
bpy_cmd = self.get_finalized_command("build_py")
build_path = normalize_path(bpy_cmd.build_lib)
# Build extensions
self.reinitialize_command('egg_info', egg_base=build_path)
self.run_command('egg_info')
self.reinitialize_command('build_ext', inplace=0)
self.run_command('build_ext')
else:
# Without 2to3 inplace works fine:
self.run_command('egg_info')
# Build extensions in-place
self.reinitialize_command('build_ext', inplace=1)
self.run_command('build_ext')
