def one_wire_version(self, data): self.sm.data_ready.disconnect() self.watchdog_pbar.setRange(0, 1) self.watchdog_pbar.setValue(1) self.watchdog_pbar_lbl.setText("Complete") pattern = r"([0-9]+\.[0-9]+[a-z])" if re.search(pattern, data): one_wire_ver = re.search(pattern, data).group() else: one_wire_ver = None if (LegacyVersion(self.one_wire_file_version) > LegacyVersion(one_wire_ver) or not one_wire_ver): self.one_wire_pbar_lbl.setText("Erasing flash. . .") self.sm.data_ready.connect(self.send_hex_file) self.reprogram_one_wire.emit() else: QMessageBox.warning(self, "Warning!", "File version is not newer " "than board version; skipping...") self.report.write_data("one_wire_ver", one_wire_ver, "PASS") self.tu.one_wire_prog_status.setText("1-Wire Programming: PASS") self.tu.one_wire_prog_status.setStyleSheet( self.threadlink.status_style_pass) self.one_wire_pbar_lbl.setText("Complete.") self.one_wire_pbar.setRange(0, 1) self.one_wire_pbar.setValue(1) self.is_complete = True self.complete_signal.emit()
def msvc14_gen_lib_options(*args, **kwargs): """ Patched "distutils._msvccompiler.gen_lib_options" for fix compatibility between "numpy.distutils" and "distutils._msvccompiler" (for Numpy < 1.11.2) """ if "numpy.distutils" in sys.modules: import numpy as np if LegacyVersion(np.__version__) < LegacyVersion('1.11.2'): return np.distutils.ccompiler.gen_lib_options(*args, **kwargs) return get_unpatched(msvc14_gen_lib_options)(*args, **kwargs)
def test_specifiers(self, version, spec, expected): spec = LegacySpecifier(spec, prereleases=True) if expected: # Test that the plain string form works assert spec.contains(version) # Test that the version instance form works assert spec.contains(LegacyVersion(version)) else: # Test that the plain string form works assert not spec.contains(version) # Test that the version instance form works assert not spec.contains(LegacyVersion(version))
def sort_cpe_matches(cpe_matches: list, requested_version: str) -> namedtuple: if requested_version.isdigit() or is_valid_dotted_version( requested_version): version_numbers = get_version_numbers(target_values=cpe_matches) if requested_version in version_numbers: return [ product for product in cpe_matches if product.version_number == requested_version ][0] else: version_numbers.append(requested_version) version_numbers.sort(key=lambda v: LegacyVersion(parse(v))) closest_match = get_closest_matches( target_values=version_numbers, search_word=requested_version)[0] return [ product for product in cpe_matches if product.version_number == closest_match ][0] else: warn( 'Warning: Version returned from CPE match has invalid type. Returned CPE might not contain relevant version number' ) return cpe_matches[0]
def splitcondaname(cname): xx = cname.split('-') variant = xx.pop().split('.')[0] ver = xx.pop() base = '-'.join(xx) try: pver = Version(ver) except InvalidVersion: tver = LegacyVersion(ver) pp = [] for v in tver._key[1]: try: pp.append(str(int(v))) except ValueError: break pver = Version('.'.join(pp)) if pp else tver print("WARNING: Pack {} LegacyVersion {} resolved as {}".format( cname, ver, pver)) except Exception: print("FAILED version parsing!") raise if re.match('py\d\d\.*', variant): pyver = variant[:4] hashvar = variant[4:] else: pyver = None hashvar = variant return base, pver, pyver, hashvar
def parse_other(self, other): if other is None: other = LegacyVersion('') elif not isinstance(other, (Version, LegacyVersion)): other = parse_version(other) return other
def compare_version(self, version: str): """Compare main app file version and board version using packaging.version LegacyVersion and flash the board with the file if the file version is higher than the board version.""" if LegacyVersion(self.main_app_file_version) > LegacyVersion(version): self.start_flash() else: QMessageBox.warning(self, "Warning!", "File version is not newer " "than board version; skipping...") self.tu.xmega_prog_status.setStyleSheet( self.threadlink.status_style_pass) self.tu.xmega_prog_status.setText("XMega Programming: PASS") self.batch_pbar_lbl.setText("Complete.") self.batch_pbar.setRange(0, 1) self.batch_pbar.setValue(1) self.start_watchdog_reset()
def normalize_version(version: str) -> LegacyVersion: final_version = version.strip() if not RE_VERSION_WITH_EPOCH.match(final_version): final_version = f'0:{final_version}' if not RE_VERSION_WITH_RELEASE.match(final_version): final_version = f'{final_version}-1' return LegacyVersion(final_version)
def get_history(self, pkg: AppImage) -> PackageHistory: history = [] res = PackageHistory(pkg, history, -1) app_con = self._get_db_connection(DATABASE_APPS_FILE) if not app_con: return res try: cursor = app_con.cursor() cursor.execute(query.FIND_APP_ID_BY_NAME_AND_GITHUB.format(pkg.name.lower(), pkg.github.lower() if pkg.github else '')) app_tuple = cursor.fetchone() if not app_tuple: self.logger.warning(f"Could not retrieve {pkg} from the database '{DATABASE_APPS_FILE}'") return res except: self.logger.error(f"An exception happened while querying the database file '{DATABASE_APPS_FILE}'") traceback.print_exc() app_con.close() return res app_con.close() releases_con = self._get_db_connection(DATABASE_RELEASES_FILE) if not releases_con: return res try: cursor = releases_con.cursor() releases = cursor.execute(query.FIND_RELEASES_BY_APP_ID.format(app_tuple[0])) if releases: treated_releases = [(LegacyVersion(r[0]), *r[1:]) for r in releases] treated_releases.sort(key=self._sort_release, reverse=True) for idx, tup in enumerate(treated_releases): ver = str(tup[0]) history.append({'0_version': ver, '1_published_at': datetime.strptime(tup[2], '%Y-%m-%dT%H:%M:%SZ') if tup[ 2] else '', '2_url_download': tup[1]}) if res.pkg_status_idx == -1 and pkg.version == ver: res.pkg_status_idx = idx return res except: self.logger.error(f"An exception happened while querying the database file '{DATABASE_RELEASES_FILE}'") traceback.print_exc() finally: releases_con.close()
def get_latest_version(filenames: list) -> (str, str): current_version = None current_filename = None for name in filenames: p = r"([0-9]+\.[0-9]+[a-z])" try: version = re.search(p, str(name)).group() except AttributeError: continue if not current_version: current_version = version current_filename = name if LegacyVersion(version) > LegacyVersion(current_version): current_version = version current_filename = name return (current_filename, current_version)
def cython_chk(VERSION, verbose=True): from mpidistutils import log if verbose: warn = lambda msg='': sys.stderr.write(msg+'\n') else: warn = lambda msg='': None # try: import Cython except ImportError: warn("*"*80) warn() warn(" You need Cython to generate C source files.\n") warn(" $ python -m pip install cython") warn() warn("*"*80) return False # REQUIRED = VERSION CYTHON_VERSION = Cython.__version__ if VERSION is not None: m = re.match(r"(\d+\.\d+(?:\.\d+)?).*", CYTHON_VERSION) if m: REQUIRED = Version(VERSION) AVAILABLE = Version(m.groups()[0]) else: REQUIRED = LegacyVersion(VERSION) AVAILABLE = LegacyVersion(CYTHON_VERSION) if AVAILABLE < REQUIRED: warn("*"*80) warn() warn(" You need Cython >= {0} (you have version {1}).\n" .format(REQUIRED, CYTHON_VERSION)) warn(" $ python -m pip install --upgrade cython") warn() warn("*"*80) return False # if verbose: log.info("using Cython version %s" % CYTHON_VERSION) return True
def version(env=os.environ): with open(os.devnull, 'wb') as devnull: try: ninja = which(env.get('NINJA', ['ninja', 'ninja-build']), env) output = subprocess.check_output('{} --version'.format(ninja), shell=True, universal_newlines=True, stderr=devnull) return LegacyVersion(output.strip()) except IOError: pass return None
def test_nucleus_sampling(self): vocab = text_utils.VocabFromText(self.VOCAB_EXAMPLE_SENTENCES) model_config = self.config.model_config.butd model = TestDecoderModel(model_config, vocab) model.build() model.eval() sample = Sample() sample.dataset_name = "coco" sample.dataset_type = "test" sample.image_feature_0 = torch.randn(100, 2048) sample.answers = torch.zeros((5, 10), dtype=torch.long) sample_list = SampleList([sample]) tokens = model(sample_list)["captions"] # these are expected tokens for sum_threshold = 0.5 # Because of a bug fix in https://github.com/pytorch/pytorch/pull/47386 # the torch.Tensor.multinomail will generate different random sequence. # TODO: Remove this hack after OSS uses later version of PyTorch. if LegacyVersion(torch.__version__) > LegacyVersion("1.7.1"): expected_tokens = [1.0, 23.0, 38.0, 30.0, 5.0, 11.0, 2.0] else: expected_tokens = [ 1.0, 29.0, 11.0, 11.0, 39.0, 10.0, 31.0, 4.0, 19.0, 39.0, 2.0, ] self.assertEqual(tokens[0].tolist(), expected_tokens)
def find_matching_cpe_product(cpe_matches: List[Product], requested_version: str) -> Product: if requested_version.isdigit() or is_valid_dotted_version(requested_version): version_numbers = [t.version_number for t in cpe_matches] if requested_version in version_numbers: return find_cpe_product_with_version(cpe_matches, requested_version) version_numbers.append(requested_version) version_numbers.sort(key=lambda v: LegacyVersion(parse(v))) next_closest_version = find_next_closest_version(version_numbers, requested_version) return find_cpe_product_with_version(cpe_matches, next_closest_version) if requested_version == 'ANY': return find_cpe_product_with_version(cpe_matches, 'ANY') logging.warning('Version returned from CPE match has invalid type. Returned CPE might not contain relevant version number') return cpe_matches[0]
def version(env=os.environ): with open(os.devnull, 'wb') as devnull: try: make = which(env.get('MAKE', ['make', 'gmake']), env) output = subprocess.check_output('{} --version'.format(make), shell=True, universal_newlines=True, stderr=devnull) m = re.match(r'GNU Make ([\d\.]+)', output) if m: return LegacyVersion(m.group(1)) except IOError: pass return None
def version(env=os.environ): with open(os.devnull, 'wb') as devnull: try: msbuild = which(env.get('MSBUILD', ['msbuild', 'xbuild']), env) output = subprocess.check_output( '{} /version'.format(msbuild), shell=True, universal_newlines=True, stderr=devnull ) m = re.search(r'([\d\.]+)$', output) if m: return LegacyVersion(m.group(1)) except IOError: pass return None
def match_required_version(current_version: str, operator: str, required_version: str) -> bool: final_required, final_current = required_version.strip( ), current_version.strip() required_has_epoch = bool(RE_VERSION_WITH_EPOCH.match(final_required)) current_no_epoch = RE_VERSION_WITH_EPOCH.split(final_current) current_has_epoch = len(current_no_epoch) > 1 if required_has_epoch and not current_has_epoch: final_current = f'0:{final_current}' elif current_has_epoch and not required_has_epoch: final_current = current_no_epoch[1] required_has_release = bool(RE_VERSION_WITH_RELEASE.match(final_required)) current_no_release = RE_VERSION_WITH_RELEASE.split(final_current) current_has_release = len(current_no_release) > 1 if required_has_release and not current_has_release: final_current = f'{final_current}-1' elif current_has_release and not required_has_release: final_current = current_no_release[1] final_required, final_current = LegacyVersion( final_required), LegacyVersion(final_current) if operator == '==' or operator == '=': return final_current == final_required elif operator == '>': return final_current > final_required elif operator == '>=': return final_current >= final_required elif operator == '<': return final_current < final_required elif operator == '<=': return final_current <= final_required
def load(cls, path): with open(os.path.join(path, cls.envfile)) as inp: state = json.load(inp) version, data = state['version'], state['data'] if version > cls.version: raise EnvVersionError('saved version exceeds expected version') # Upgrade from older versions of the Environment if necessary. # v5 converts srcdir and builddir to Path objects internally. if version < 5: for i in ('srcdir', 'builddir'): data[i] = Path(data[i]).to_json() # v6 adds persistence for the backend's version and converts bfgpath to # a Path object internally. if version < 6: backend = list_backends()[data['backend']] data['backend_version'] = str(backend.version()) data['bfgpath'] = Path(data['bfgpath']).to_json() # v7 replaces bfgpath with bfgdir. if version < 7: bfgdir = Path.from_json(data['bfgpath']).parent() data['bfgdir'] = bfgdir.to_json() del data['bfgpath'] # Now that we've upgraded, initialize the Environment object. env = Environment.__new__(Environment) for i in ['backend', 'variables']: setattr(env, i, data[i]) setattr(env, 'backend_version', LegacyVersion(data['backend_version'])) for i in ('bfgdir', 'srcdir', 'builddir'): setattr(env, i, Path.from_json(data[i])) env.platform = platforms.platform_info(data['platform']) env.install_dirs = { InstallRoot[k]: Path.from_json(v) for k, v in iteritems(data['install_dirs']) } return env
def _check_version(self, version) -> bool: """ https://www.python.org/dev/peps/pep-0440/ """ if isinstance(version, str): version = parse(version) # if both semver if self._semver is not None: if not isinstance(version, LegacyVersion): return version in self._semver # otherwise compare both as legacy if self._legacy is not None: version = LegacyVersion(str(version)) return version in self._legacy # lovely case, isn't it? return False
def command_build(buildfile, env, output, inputs=None, implicit=None, order_only=None, commands=None, environ=None, console=True): if console: rule_name = 'console_command' extra_implicit = ['PHONY'] if not buildfile.has_rule('console_command'): # XXX: Can't use SpecifierSet here yet, since those don't work well # with LegacyVersions. extra_kwargs = {} if (env.backend_version and env.backend_version >= LegacyVersion('1.5')): extra_kwargs['pool'] = 'console' buildfile.rule(name='console_command', command=[[var('cmd')]], **extra_kwargs) if not buildfile.has_build('PHONY'): buildfile.build(output='PHONY', rule='phony') else: rule_name = 'command' extra_implicit = [] if not buildfile.has_rule('command'): buildfile.rule(name='command', command=var('cmd')) buildfile.build(output=output, rule=rule_name, inputs=inputs, implicit=iterutils.listify(implicit) + extra_implicit, order_only=order_only, variables={'cmd': Commands(commands, environ)})
def check_match(self, **kwargs: Any) -> bool: """ Check if the package name and version matches against a blacklisted package version specifier. Parameters ========== name: str Package name version: str Package version Returns ======= bool: True if it matches, False otherwise. """ name = safe_name(kwargs['name']).lower() if name not in self.safety_db.keys(): return False version = kwargs['version'] try: version = Version(version) except InvalidVersion: # pragma: no cover try: version = LegacyVersion(version) logger.debug(f'Package {name}=={version} is not a valid PEP 440 version, trying Legacy versioning') except InvalidVersion: logger.debug(f"Package {name}=={version} has an invalid version") return False for requirement in self.safety_db[name]: if version in requirement.specifier: logger.debug(f"Safety DB MATCH: Release {name}=={version} matches specifier {requirement.specifier}") return True return False
import sys, site # do standard skbuild setup from packaging.version import LegacyVersion from skbuild.exceptions import SKBuildError from skbuild.cmaker import get_cmake_version from skbuild import setup # This line replaces 'from setuptools import setup' # Add CMake as a build requirement if cmake is not installed or too old setup_requires = [] try: if LegacyVersion(get_cmake_version()) < LegacyVersion("3.10"): setup_requires.append('cmake>=3.10') except SKBuildError: setup_requires.append('cmake>=3.10') setup_requires.append('numpy>=1.10') with open('README.md', 'r') as fh: readme_file = fh.readlines() long_description = "" for line in readme_file[3:]: if line.rstrip() == "Quick Install": break else: long_description += line long_description += "### Quick Install\n Tasmanian supports `--user` and venv install only, see the on-line documentation for details.\n" # find out whether this is a virtual environment, real_prefix is an older test, base_refix is the newer one if hasattr(sys, 'real_prefix') or (hasattr(sys, 'base_prefix')
try: from skbuild import setup except ImportError: print('scikit-build is required to build from source.', file=sys.stderr) print('Please run:', file=sys.stderr) print('', file=sys.stderr) print(' python -m pip install scikit-build') sys.exit(1) # Add CMake as a build requirement if cmake is not installed or is too low a # version CMAKE_MINIMUM = "3.4" SETUP_REQUIRES = [] try: if LegacyVersion(get_cmake_version()) < LegacyVersion(CMAKE_MINIMUM): SETUP_REQUIRES.append('cmake') except SKBuildError: SETUP_REQUIRES.append('cmake') DATA_FILES = [ ('pycompwa/', [ './ComPWA/Physics/particle_list.xml', ]), ] setup( name='pycompwa', version='0.1-alpha6', author='The ComPWA team', maintainer_email="*****@*****.**",
def test_specifier_explicit_leacy(self): Specifier("==1.0").contains(LegacyVersion("1.0"))
import setuptools import os import sys from skbuild import setup from skbuild.constants import CMAKE_INSTALL_DIR, skbuild_plat_name from packaging.version import LegacyVersion from skbuild.exceptions import SKBuildError from skbuild.cmaker import get_cmake_version # Add CMake as a build requirement if cmake is not installed or is too low a version setup_requires = [] try: cmake_version = LegacyVersion(get_cmake_version()) if cmake_version < LegacyVersion("3.5") or cmake_version >= LegacyVersion( "3.15"): setup_requires.append('cmake<3.15') except SKBuildError: setup_requires.append('cmake<3.15') # If you want to re-build the cython cpp file (DracoPy.cpp), run: # cython --cplus -3 -I./_skbuild/linux-x86_64-3.7/cmake-install/include/draco/ ./src/TrakoDracoPy.pyx # Replace "linux-x86_64-3.6" with the directory under _skbuild in your system # Draco must already be built/setup.py already be run before running the above command src_dir = './src' lib_dir = os.path.abspath(os.path.join(CMAKE_INSTALL_DIR(), 'lib/')) cmake_args = [] if sys.platform == 'darwin': plat_name = skbuild_plat_name() sep = [pos for pos, char in enumerate(plat_name) if char == '-'] assert len(sep) == 2
def test_compare_other(self, op, expected): other = pretend.stub( **{"__{0}__".format(op): lambda other: NotImplemented}) assert getattr(operator, op)(LegacyVersion("1"), other) is expected
def test_dunder_op_returns_notimplemented(self, op): method = getattr(LegacyVersion, "__{0}__".format(op)) assert method(LegacyVersion("1"), 1) is NotImplemented
def test_comparison_false(self, left, right, op): assert not op(LegacyVersion(left), LegacyVersion(right))
def test_legacy_version_is_postrelease(self, version): assert not LegacyVersion(version).is_postrelease
def test_legacy_version_post(self, version): assert LegacyVersion(version).post is None