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"))