def check(self, raise_=True): """Check that all requirements are available (importable) and their versions match (using pkg.__version__). :param raise_: Raise DistributionNotFound if ImportError or VersionConflict if version doesn't match? If false just return None. """ for req in self: try: mod = __import__(req.modname) except ImportError: if raise_: raise DistributionNotFound(str(req)) return False if not req.specs: # No version constraints continue try: version = mod.__version__ except AttributeError as e: raise AttributeError("%s: %s" % (e, mod)) if version not in req: if raise_: raise VersionConflict( "Need %s. Found %s" % (str(req), version)) return False return True
def check_libraries_requirements(): """Check if the required dependencies are met. Calling this function at the program start will allow the program to terminate gracefully in case of an unmet dependency instead of crashing while performing important tasks.""" file_path = paths.get_base_path('requirements.txt') try: # Skip the check if we are running in a |PyInstaller| bundle. Assume everything is all right. if not paths.is_pyinstaller_bundle(): with file(file_path) as req_file: requirements = req_file.readlines() require(requirements) # Libtorrent requirements try: # Workaround for libtorrent version (not available on pip so it cannot # be written inside requirements.txt). import libtorrent if LooseVersion(libtorrent.version) < LooseVersion( libtorrent_least_required_version): raise VersionConflict( 'libtorrent {}'.format(libtorrent.version), 'libtorrent >= {}'.format( libtorrent_least_required_version)) except ImportError: raise DistributionNotFound('libtorrent') # Kivy requirements try: import multiprocessing multiprocessing.freeze_support() import kivy kivy.require(kivy_least_required_version) except ImportError: raise DistributionNotFound('kivy') except Exception: # Kivy raises an Exception with a not-so-nicely formatted message # Just print it and exit msg = "".join(_format_exc_info(*sys.exc_info())) + \ "\nAvast DeepScreen is known to fail here." MessageBox(msg, 'Kivy error') sys.exit(1) except VersionConflict as ex: message = 'Wrong library version. Installed: {}. Required: {}'.format( ex.args[0], ex.args[1]) MessageBox(message, 'Error') sys.exit(1) except DistributionNotFound as ex: message = 'Missing python library. Required: {}'.format(ex.args[0]) MessageBox(message, 'Error') sys.exit(1)
def test_get_exitcode(self): self.assertEqual(get_exitcode(KeyboardInterrupt()), 130) self.assertEqual(get_exitcode(AssertionError()), 255) self.assertEqual(get_exitcode(SystemExit(999)), 999) self.assertEqual(get_exitcode(VersionConflict( 'version 1.0', 'version 2.0')), 13) self.assertEqual(get_exitcode(EOFError()), 0) self.assertEqual(get_exitcode(None), 0)
def init(self): """ Init module """ log.info('Initializing module Market') Plugin.directory = Path( self.context.settings['development']['modules']) me = Plugin(self.name) me._register_in_global() self.check_updates() plugins_to_download = self.plugin_list try: plugins_to_download.extend(self.settings['preordered_plugins']) except (KeyError, TypeError): ... try: plugins_to_download.extend(getenv('PREORDERED_PLUGINS').split(',')) except AttributeError: ... # self.download_plugins(set(plugins_to_download)) GitManagerMixin.git_manager = self.context.git_manager GitManagerMixin.git_config = self.settings['git_config'] self.clone_plugins(set(plugins_to_download)) req_status = self.check_requirements() if req_status['attention']: if self.settings['requirements']['raise_on_attention']: raise VersionConflict(req_status['attention']) else: for i in req_status['attention'].values(): for plugin, requirement in map( lambda y: (y['plugin'], y['requirement']), i): plugin.installer(package=requirement) if req_status['conflict']: raise VersionConflict(req_status['conflict']) for i in req_status['safe'].values(): for plugin, requirement in map( lambda y: (y['plugin'], y['requirement']), i): plugin.installer(package=requirement) self.copy_configs()
def test_get_exitcode(self): self.assertEqual(get_exitcode(KeyboardInterrupt()), 130) self.assertEqual(get_exitcode(AssertionError()), 255) self.assertEqual(get_exitcode(SystemExit(999)), 999) self.assertEqual(get_exitcode(VersionConflict( "libclang-py3 0.3", "libclang-py3==0.2")), 13) self.assertEqual(get_exitcode(EOFError()), 0) self.assertEqual(get_exitcode(None), 0)
def test_version_conflict_in_collecting_bears(self, import_fn, _): with bear_test_module(): import_fn.side_effect = VersionConflict("msg1", "msg2") retval, output = execute_coala(coala.main, "coala", "-A") self.assertEqual(retval, 13) self.assertIn(("There is a conflict in the version of a " "dependency you have installed"), output) self.assertIn("pip install msg2", output) # Check recommendation
def test_version_conflict_in_collecting_bears(self, import_fn, _): with bear_test_module(): import_fn.side_effect = VersionConflict('msg1', 'msg2') retval, output = execute_coala(coala.main, 'coala', '-B') self.assertEqual(retval, 13) self.assertIn(('There is a conflict in the version of a ' 'dependency you have installed'), output) self.assertIn('pip install "msg2"', output)
def test_version_conflict_in_collecting_bears(self, import_fn): with bear_test_module(): import_fn.side_effect = VersionConflict('msg1', 'msg2') retval, stdout, stderr = execute_coala(coala.main, 'coala', '-B') self.assertEqual(retval, 13) self.assertIn(('There is a conflict in the version of a ' 'dependency you have installed'), stderr) self.assertIn('pip3 install "msg2"', stderr) self.assertFalse(stdout) self.assertNotEqual( retval, 0, 'coala must return nonzero when errors occured')
def find(self, modpath, raise_=True): """Try to find the distribution and check version. - Also checks if distribution is in the same directory as given `modpath`. - Automatically reinstalls zetup in develop mode on distribution version mismatch if handling zetup's own config from zetup's project src. :param raise_: Raise a ``VersionConflict`` if version doesn't match the given one? If ``False`` just return ``None``. """ # If no version is given (for whatever reason), just do nothing: if not self.version: return None try: dist = get_distribution(self) except DistributionNotFound: return None # check if distribution path matches package path if os.path.normcase(os.path.realpath(dist.location)) \ != os.path.normcase(os.path.dirname(os.path.realpath(modpath))): return None if dist.parsed_version != self.version.parsed: message = ( "Version of distribution %s " "doesn't match version %s from %s. " % (repr(dist), self.version, repr(self.zfg))) # are we handling zetup's own config? if self == 'zetup': from zetup.zetup import Zetup # and was it loaded from zetup's project src? if isinstance(self.zfg, Zetup): print('zetup:', message) # then automatically reinstall zetup in develop mode print('zetup: Reinstalling in develop mode...') import zetup.commands.dev self.zfg.dev() # reset setuptools distribution cache pkg_resources.working_set = pkg_resources.WorkingSet( pkg_resources.working_set.entries) # and return updated dist return get_distribution(self) elif raise_: raise VersionConflict( message + "Please reinstall %s." % str.__repr__(self)) return None return dist
def resolve_requirement(requirement: Requirement): dist = best.get(requirement.key) if dist is None: # Find the best distribution and add it to the map dist = self.by_key.get(requirement.key) if dist is None or (dist not in requirement and replace_conflicting): ws = self with lock: if env[0] is None: if dist is None: env[0] = Environment(self.entries) else: # Use an empty environment and workingset to avoid # any further conflicts with the conflicting # distribution env[0] = Environment([]) ws = WorkingSet([]) dist = best[requirement.key] = env[0].best_match( requirement, ws, installer, replace_conflicting=replace_conflicting, ) if dist is None: requirers = required_by.get(requirement, None) raise DistributionNotFound(requirement, requirers) resolved.append(dist) if dist not in requirement: # Oops, the "best" so far conflicts with a dependency dependent_requirement = required_by[requirement] raise VersionConflict( dist, requirement).with_context(dependent_requirement) with lock: # push the new requirements onto the stack new_requirements = [ requirement for requirement in dist.requires(requirement.extras)[::-1] if requirement.key not in self.excludes ] req_stack.extend(new_requirements) # Register the new requirements needed by requirement for new_requirement in new_requirements: required_by[new_requirement].add(requirement.project_name) requirement_extras[new_requirement] = requirement.extras processed[requirement] = True
def test_unimportable_bear(self, import_fn): with bear_test_module(): import_fn.side_effect = SyntaxError retval, output = execute_coala(coala.main, "coala", "-A") self.assertEqual(retval, 0) self.assertIn("Unable to collect bears from", output) import_fn.side_effect = VersionConflict("msg1", "msg2") retval, output = execute_coala(coala.main, "coala", "-A") # Note that bear version conflicts don't give exitcode=13, # they just give a warning with traceback in log_level debug. self.assertEqual(retval, 0) self.assertRegex( output, "Unable to collect bears from .* because there " "is a conflict with the version of a dependency " "you have installed") self.assertIn("pip install msg2", output) # Check recommendation
def test_unimportable_bear(self, import_fn): with bear_test_module(): import_fn.side_effect = SyntaxError retval, output = execute_coala(coala.main, 'coala', '-B') self.assertEqual(retval, 0) self.assertIn('Unable to collect bears from', output) import_fn.side_effect = VersionConflict('msg1', 'msg2') retval, output = execute_coala(coala.main, 'coala', '-B') # Note that bear version conflicts don't give exitcode=13, # they just give a warning with traceback in log_level debug. self.assertEqual(retval, 0) self.assertRegex( output, 'Unable to collect bears from .* because there ' 'is a conflict with the version of a dependency ' 'you have installed') self.assertIn('pip install "msg2"', output)
def find(self, modpath, raise_=True): """Try to find the distribution and check version. :param raise_: Raise a VersionConflict if version doesn't match the given one? If false just return None. """ try: dist = get_distribution(self) except DistributionNotFound: return None if os.path.realpath(dist.location) \ != os.path.realpath(os.path.dirname(modpath)): return None if dist.parsed_version != self.version.parsed: if raise_: raise VersionConflict( "Version of distribution %s" " doesn't match %s.__version__ %s." % (dist, self.pkg, self.version)) return None return dist
import sys import platform from pkg_resources import VersionConflict from .about import (__author__, __author_email__, __description__, __name__, __url__, __version__) if sys.version_info <= (3, 0): raise VersionConflict("ORES requires Python '>=3' but your Python version is " + platform.python_version()) __all__ = [__name__, __version__, __author__, __author_email__, __description__, __url__]
from .. import ClusterExpansion from ..core.local_orbit_list_generator import LocalOrbitListGenerator from ..core.structure import Structure from .variable_transformation import transform_parameters from ..input_output.logging_tools import logger from pkg_resources import VersionConflict try: import mip from mip.constants import BINARY, INTEGER from distutils.version import LooseVersion try: if LooseVersion(mip.constants.VERSION) < '1.6.3': raise VersionConflict( 'Python-MIP version 1.6.3 or later is required in order ' 'to use the ground state finder.') except AttributeError: # This will happen with recent versions of MIP since mip.constants.VERSION # has moved to mip.VERSION, but that is fine. pass except ImportError: raise ImportError( 'Python-MIP (https://python-mip.readthedocs.io/en/latest/) is required in ' 'order to use the ground state finder.') class GroundStateFinder: """ This class provides functionality for determining the ground states using a binary cluster expansion. This is efficiently achieved through the
def test_version_conflict_in_collecting_bears(self, import_fn, _): with bear_test_module(): import_fn.side_effect = VersionConflict('msg1', 'msg2') retval, _ = execute_coala(coala.main, 'coala', '--json', '-B') self.assertEqual(retval, 13)
def resolve( self, requirements: Sequence[Requirement], env: Optional[Environment] = None, installer: Optional[Callable[[str], Distribution]] = None, replace_conflicting: Optional[bool] = False, extras: List[str] = None, ) -> List[Distribution]: """List all distributions needed to (recursively) meet `requirements` `requirements` must be a sequence of ``Requirement`` objects. `env`, if supplied, should be an ``Environment`` instance. If not supplied, it defaults to all distributions available within any entry or distribution in the working set. `installer`, if supplied, will be invoked with each requirement that cannot be met by an already-installed distribution; it should return a ``Distribution`` or ``None``. Unless `replace_conflicting=True`, raises a VersionConflict exception if any requirements are found on the path that have the correct name but the wrong version. Otherwise, if an `installer` is supplied it will be invoked to obtain the correct version of the requirement and activate it. `extras` is a list of the extras to be used with these requirements. This is important because extra requirements may look like `my_req; extra = "my_extra"`, which would otherwise be interpreted as a purely optional requirement. Instead, we want to be able to assert that these requirements are truly required. """ # set up the stack requirements = list(requirements)[::-1] # set of processed requirements processed = {} # key -> dist best = {} resolved = [] requirement_extras = _ReqExtras() # Mapping of requirement to set of distributions that required it; # useful for reporting info about conflicts. required_by = defaultdict(set) while requirements: # process dependencies breadth-first requirement = requirements.pop(0) if requirement in processed: # Ignore cyclic or redundant dependencies continue if not requirement_extras.markers_pass(requirement, extras): continue dist = best.get(requirement.key) if dist is None: # Find the best distribution and add it to the map dist = self.by_key.get(requirement.key) if dist is None or (dist not in requirement and replace_conflicting): ws = self if env is None: if dist is None: env = Environment(self.entries) else: # Use an empty environment and workingset to avoid # any further conflicts with the conflicting # distribution env = Environment([]) ws = WorkingSet([]) dist = best[requirement.key] = env.best_match( requirement, ws, installer, replace_conflicting=replace_conflicting, ) if dist is None: requirers = required_by.get(requirement, None) raise DistributionNotFound(requirement, requirers) resolved.append(dist) if dist not in requirement: # Oops, the "best" so far conflicts with a dependency dependent_requirement = required_by[requirement] raise VersionConflict(dist, requirement).with_context( dependent_requirement ) # push the new requirements onto the stack new_requirements = [ requirement for requirement in dist.requires(requirement.extras)[::-1] if requirement.key not in self.excludes ] requirements.extend(new_requirements) # Register the new requirements needed by requirement for new_requirement in new_requirements: required_by[new_requirement].add(requirement.project_name) requirement_extras[new_requirement] = requirement.extras processed[requirement] = True # return list of distros to activate return resolved
>>> for feature, value in zip(features, values): ... print("\t{0}: {1}".format(feature, repr(value))) ... <len(<english.informals.revision.matches>)>: 2 <len(<spanish.informals.revision.matches>)>: 0 """ # noqa import platform import sys from pkg_resources import VersionConflict from .about import (__author__, __author_email__, __description__, __name__, __url__, __version__) from .datasources import Datasource from .dependencies import Dependent, DependentSet from .extractors import Extractor from .features import Feature from .score_processor import ScoreProcessor from .scoring import Model if sys.version_info <= (3, 0): raise VersionConflict("Revscoring requires Python '>=3' " + "but your Python version is " + platform.python_version()) __all__ = [ Datasource, Dependent, DependentSet, Extractor, Feature, Model, ScoreProcessor, __name__, __version__, __author__, __author_email__, __description__, __url__ ]