def dependencies(self,
extras_requested: Optional[Set[str]] = None) -> Set[str]:
dependency_set = set()
for wheel_req in self.metadata.requires_dist:
req = pkg_resources.Requirement(wheel_req) # type: ignore
if req.marker is None or any(
req.marker.evaluate({"extra": extra})
for extra in extras_requested or [""]):
dependency_set.add(req.name) # type: ignore
return dependency_set
def _check_ibmqe_version():
"""Check if the available IBMQuantumExperience version is the required one.
Check that the version of the available "IBMQuantumExperience" package
matches the version required by the package, emitting a warning if it is
not present.
"""
try:
# Use a local import, as in very specific environments setuptools
# might not be available or updated (conda with specific setup).
import pkg_resources
except ImportError:
return
working_set = pkg_resources.working_set
# Find if qiskit is installed and the current execution is using the
# installed package; or if it is a local environment.
qiskit_local = True
try:
qiskit_pkg = working_set.by_key['qiskit']
if __file__.startswith(qiskit_pkg.location):
qiskit_local = False
except KeyError:
pass
# Find the IBMQuantumExperience version specified in qiskit.
if qiskit_local:
try:
# Mock setuptools.setup, as it would be executed during the import.
with patch('setuptools.setup'):
# Use a local import to fall back gracefully if not present.
from setup import requirements
ibmqe_require_line = next(
r for r in requirements
if r.startswith('IBMQuantumExperience'))
ibmqe_require = pkg_resources.Requirement(ibmqe_require_line)
except (ImportError, pkg_resources.RequirementParseError):
return
else:
# Retrieve the requirement line from pkg_resources
ibmqe_require = next(r for r in qiskit_pkg.requires()
if r.name == 'IBMQuantumExperience')
# Finally, check the requirement.
try:
working_set.require(str(ibmqe_require))
except pkg_resources.ResolutionError:
logger.warning(
'The installed IBMQuantumExperience package does '
'not match the required version - some features might '
'not work as intended. Please install %s.', str(ibmqe_require))
def build(config, session):
build_info = get_build_info(config.setupdir)
package_venv = session.getvenv(config.isolated_build_env)
package_venv.envconfig.deps_matches_subset = True
# we allow user specified dependencies so the users can write extensions to
# install additional type of dependencies (e.g. binary)
user_specified_deps = package_venv.envconfig.deps
package_venv.envconfig.deps = [
DepConfig(r, None) for r in build_info.requires
]
package_venv.envconfig.deps.extend(user_specified_deps)
if package_venv.setupenv():
package_venv.finishvenv()
if isinstance(package_venv.status, Exception):
raise package_venv.status
build_requires = get_build_requires(build_info, package_venv,
config.setupdir)
# we need to filter out requirements already specified in pyproject.toml or user deps
base_build_deps = {
pkg_resources.Requirement(r.name).key
for r in package_venv.envconfig.deps
}
build_requires_dep = [
DepConfig(r, None) for r in build_requires
if pkg_resources.Requirement(r).key not in base_build_deps
]
if build_requires_dep:
with package_venv.newaction("build_requires",
package_venv.envconfig.envdir) as action:
package_venv.run_install_command(packages=build_requires_dep,
action=action)
package_venv.finishvenv(package_venv)
return perform_isolated_build(build_info, package_venv, config.distdir,
config.setupdir)
def test_fetch_in_order():
"""Verify both repos are attempted"""
repo1 = FakeRepository("1")
repo2 = FakeRepository("2")
repo3 = FakeRepository("3")
repo3.get_candidates.side_effect = lambda req: [
Candidate("nonsense", ".", pkg_resources.parse_version("1.0"), None,
None, "any", "")
]
multi = MultiRepository(repo1, repo2, repo3)
result, cached = multi.get_candidate(pkg_resources.Requirement("nonsense"))
assert repo1.get_candidates.called
assert repo2.get_candidates.called
assert repo3.get_candidates.called
assert result.version == pkg_resources.parse_version("1.0")
candidates = multi.get_candidates(pkg_resources.Requirement("nonsense"))
assert len(candidates) == 1
assert candidates[0].name == "nonsense"
assert candidates[0].version == pkg_resources.parse_version("1.0")
def _install_dependencies(self, ep):
"""
Given an entry point, ensure that any declared extras for
its distribution are installed.
"""
reqs = {
req
for req in map(requirements.Requirement, always_iterable(ep.dist.requires))
for extra in ep.extras
if extra in req.extras
}
missing = itertools.filterfalse(self._is_installed, reqs)
for req in missing:
# fetch_build_egg expects pkg_resources.Requirement
self.fetch_build_egg(pkg_resources.Requirement(str(req)))
def dependencies(self, extras_requested=None):
if not extras_requested:
# Provide an extra to safely evaluate the markers
# without matching any extra
extras_requested = [""]
dependency_set = set()
for req in self.metadata().requires_dist:
r = pkg_resources.Requirement(req)
if r.marker is None or any(
r.marker.evaluate({"extra": extra})
for extra in extras_requested):
dependency_set.add(r.name)
return dependency_set
def plot_d3(plot_datas):
env = Environment(loader=PackageLoader('volmdlr', 'templates'),
autoescape=select_autoescape(['html', 'xml']))
template = env.get_template('plot_data.html')
volmdlr_path = pkg_resources.resource_filename(pkg_resources.Requirement('volmdlr'),
'volmdlr/templates')
s = template.render(
volmdlr_path=volmdlr_path,
D3Data=json.dumps(plot_datas))
temp_file = tempfile.mkstemp(suffix='.html')[1]
with open(temp_file, 'wb') as file:
file.write(s.encode('utf-8'))
webbrowser.open('file://' + temp_file)
print('file://' + temp_file)
def app():
parser = argparse.ArgumentParser(description='Loads a plugin')
parser.add_argument('action',
choices=['run', 'list'],
help='action to be performed')
parser.add_argument('-p', '--plugin', help='plugin to be loaded')
args = parser.parse_args()
if args.action == 'list':
full_env = pkg_resources.Environment()
dists, errors = pkg_resources.WorkingSet().find_plugins(full_env)
for dist in dists:
if 'plugin_system' in dist.get_entry_map():
print(' %s (%s)' % (dist.project_name, dist.version))
elif args.action == 'run':
requirement = pkg_resources.Requirement(args.plugin)
plugin = pkg_resources.WorkingSet().find(requirement)
main = plugin.load_entry_point('plugin_system', 'main')
main()
def get_version(modulename):
"Return a string containing the module name and the library version."
version = '?'
# Get the root module name (in case we have something like `recipy.open`
# or `matplotlib.pyplot`)
modulename = modulename.split('.')[0]
if modulename in sys.modules:
ws = pkg_resources.working_set
package = ws.find(pkg_resources.Requirement(modulename))
version = package.version
else:
warnings.warn('requesting version of a module that has not been '
'imported ({})'.format(modulename))
# If we get some kind of crazy object (ie. not a string or a number)
# then ignore it
if not isinstance(version, (six.string_types, numbers.Number)):
version = '?'
return '{} v{}'.format(modulename, version)
def install_plugin(plugin_name):
print('installing requirement %s' % plugin_name)
if isinstance(plugin_name, str):
requirement = pkg_resources.Requirement(plugin_name)
pargs = [sys.executable, '-m', 'pip', '--disable-pip-version-check',
'install', str(plugin_name), '--target', './plugins']
env = os.environ.copy()
pip_stdout = open('pip.log', 'wb')
p = subprocess.Popen(pargs, stdout=pip_stdout, stderr=subprocess.PIPE,
env=env,
encoding='UTF8')
try:
ret = p.wait(timeout=60)
if pip_stdout and pip_stdout.readable():
output = pip_stdout.read()
else:
output = ''
err_output = p.stderr.read()
new_env = pkg_resources.Environment('plugins')
new_env.scan(['plugins'])
dists = new_env[str(plugin_name)]
if ret != 0:
sys.stderr.write('Pip install error\n')
sys.stderr.write(err_output)
if dists:
print('%s installed' % dists)
pkg_resources.working_set.add(dists[0])
sys.stdout.flush()
return dists[0]
else:
print('dist not found')
return None
except subprocess.TimeoutExpired:
sys.stderr.write('pip install process timeout.')
return None
def add_dist(self, dist_name):
dist = pkg_resources.get_distribution(pkg_resources.Requirement(dist_name))
self.extend_dists(dist)
def add_dist(self, dist_name):
dist = pkg_resources.get_distribution(
pkg_resources.Requirement(dist_name))
extras = self.resolve_dist(dist, self.base_working_set)
if extras:
self.extra_dists.extend(extras)
def _get_root(path):
try:
return pkg_resources.resource_filename(
pkg_resources.Requirement('bruv'), path)
except pkg_resources.DistributionNotFound:
return '../{}/'.format(path)
def _check_ibmqe_version():
"""Check if the available IBMQuantumExperience version is the required one.
Check that the version of the available "IBMQuantumExperience" package
matches the version required by the package, emitting a warning if it is
not present.
"""
try:
# Use a local import, as in very specific environments setuptools
# might not be available or updated (conda with specific setup).
import pkg_resources
except ImportError:
return
working_set = pkg_resources.working_set
# Find if qiskit is installed and the current execution is using the
# installed package; or if it is a local environment.
qiskit_local = True
try:
qiskit_pkg = working_set.by_key['qiskit']
if __file__.startswith(qiskit_pkg.location):
qiskit_local = False
except KeyError:
pass
# Find the IBMQuantumExperience version specified in qiskit.
if qiskit_local:
try:
with open('requirements.txt') as reqfile:
ibmqe_require_line = next(line for line in reqfile
if line.startswith(API_NAME))
ibmqe_require = pkg_resources.Requirement(ibmqe_require_line)
except (FileNotFoundError, StopIteration,
pkg_resources.RequirementParseError):
logger.warning(
'Could not find %s in requirements.txt or the requirements.txt \
file was not found or unparsable', API_NAME)
return
else:
# Retrieve the requirement line from pkg_resources
ibmqe_require = next(r for r in qiskit_pkg.requires()
if r.name == API_NAME)
# Finally, compare the versions.
try:
# First try to use IBMQuantumExperience.__version__ directly.
from IBMQuantumExperience import __version__ as ibmqe_version
if ibmqe_version in ibmqe_require:
return
except ImportError:
# __version__ was not available, so try to compare using the
# working_set. This assumes IBMQuantumExperience is installed as a
# library (using pip, etc).
try:
working_set.require(str(ibmqe_require))
return
except pkg_resources.DistributionNotFound:
# IBMQuantumExperience was not found among the installed libraries.
# The warning is not printed, assuming the user is using a local
# version and takes responsability of handling the versions.
return
except pkg_resources.VersionConflict:
pass
logger.warning(
'The installed IBMQuantumExperience package does '
'not match the required version - some features might '
'not work as intended. Please install %s.', str(ibmqe_require))
def ensure_plugin(plugin_name):
logger.debug('ensure_plugin: %s', plugin_name)
d = working_set.resolve([pkg_resources.Requirement(plugin_name)],
plugin_env,
install_plugin)
logger.debug(d)
def test_ctor_pkgr_req(self):
req = pkg_resources.Requirement('django==2.0')
dep = Dependency(req)
self.assertEqual(dep.name, 'django')
self.assertTrue(dep.matches_version('2.0'))
self.assertFalse(dep.matches_version('2.1'))
import pkg_resources
import distutils.core
setup = distutils.core.run_setup("setup.py")
requirements = [
pkg_resources.Requirement(pkg) for pkg in setup.install_requires
]
oldest_dependencies = []
for requirement in requirements:
dependency = requirement.project_name
if requirement.extras:
dependency += "[" + ",".join(requirement.extras) + "]"
for comparator, version in requirement.specs:
if comparator == "==":
if len(requirement.specs) != 1:
raise ValueError("Invalid dependency: {requirement}".format(
requirement=requirement))
dependency += "==" + version
elif comparator == "<=":
if len(requirement.specs) != 2:
raise ValueError("Invalid dependency: {requirement}".format(
requirement=requirement))
elif comparator == ">=":
dependency += "==" + version
elif comparator == "~=":
dependency += "==" + version
oldest_dependencies.append(dependency)
for dependency in oldest_dependencies:
padding: 0;
}
#renderCanvas {
width: 100%;
height: 100%;
touch-action: none;
}
</style>
<script>
'''
for filename in [
'babylon.js', 'babylonjs.loaders.min.js', 'earcut.min.js', 'pep.js'
]:
with pkg_resources.resource_stream(
pkg_resources.Requirement('volmdlr'),
os.path.join('volmdlr/assets/js/', filename)) as fjs:
babylon_unpacker_embedded_header += fjs.read().decode('utf-8')
babylon_unpacker_embedded_header += '''
</script>
</head>
'''
babylon_unpacker_body_template = Template('''
<body>
<canvas id="renderCanvas"></canvas>
<script type="text/javascript">
// Get the canvas element from our HTML below
var canvas = document.querySelector("#renderCanvas");
// Load the BABYLON 3D engine
def get_updatable(modules=[], strategy='consensus'):
if strategy not in ('consensus', 'force', 'skip'):
raise ValueError('Unknown strategy "{}"'.format(strategy))
if not modules:
modules = list_local()
reqs_by_dep = defaultdict(dict)
all_versions = {}
for mname in list_local():
local_info = get_local_module_info(mname)
remote_info = get_remote_module_info(mname)
if remote_info:
all_versions[mname] = sorted(remote_info.versions,
key=LooseVersion)
req_strings = local_info.conf.get('requires', [])
reqs = [pkg_resources.Requirement(s) for s in req_strings]
for req in reqs:
dep = req.name
reqs_by_dep[dep][mname] = req
update_vers = {}
resolution_applied = {}
resolution_failed = {}
for mname in modules:
if mname not in list_local():
continue
local_info = get_local_module_info(mname)
remote_info = get_remote_module_info(mname)
reqs = reqs_by_dep[mname]
versions = all_versions.get(mname, [])
if not versions:
continue
selected_version = versions[-1]
if LooseVersion(selected_version) <= LooseVersion(local_info.version):
continue
if reqs:
resolution_applied[mname] = reqs
if strategy == 'force':
pass
elif strategy == 'skip':
selected_version = None
elif strategy == 'consensus':
passing_versions = []
for version in versions:
version_passes = True
for requester, requirement in reqs.items():
version_passes = version in requirement
if not version_passes:
break
if version_passes:
passing_versions.append(version)
selected_version = passing_versions[
-1] if passing_versions else None
if selected_version and LooseVersion(selected_version) > LooseVersion(
local_info.version):
update_data_version = get_remote_data_version(
mname, selected_version)
installed_data_version = get_remote_data_version(
mname, local_info.version)
if update_data_version is not None and update_data_version != installed_data_version:
update_size = remote_info.size
else:
update_size = remote_info.code_size
update_vers[mname] = SimpleNamespace(version=selected_version,
size=update_size)
else:
resolution_failed[mname] = reqs
return update_vers, resolution_applied, resolution_failed
def test_not_found():
"""Verify that if not found, NoCandidateException is raised"""
repo1 = FakeRepository("1")
multi1 = MultiRepository(repo1)
with pytest.raises(NoCandidateException):
multi1.get_candidate(pkg_resources.Requirement("nonsense"))
