def test_versions_condaforge(self):
self.assertSetEqual({Version('1.0'), Version('1.2'), Version('2.0')}, self.pkg_a.versions_condaforge)
self.assertSetEqual(set(), self.pkg_bad.versions_condaforge)
python类Version()的实例源码
def test__external_versions(self):
self.assertSetEqual({Version('1.0'), Version('1.2'), Version('2.0')}, set(self.pkg_a._external_versions))
self.assertSetEqual(set(), set(self.pkg_bad._external_versions))
def test__external_upgradeable_versions(self):
class Patch(Package):
versions_condaforge = {Version('1.0'), Version('1.2')} # missing 2.0
self.pkg_a.__class__ = Patch
self.assertSetEqual({Version('2.0')}, set(self.pkg_a._external_upgradeable_versions))
# TODO: test other cases, including dev versions
def test_latest_feedstock_version(self):
self.assertEqual(Version('2.0'), self.pkg_a.latest_feedstock_version)
self.assertIsNone(self.pkg_bad.latest_feedstock_version)
def test_latest_external_version(self):
self.assertEqual(Version('2.0'), self.pkg_a.latest_external_version)
self.assertIsNone(self.pkg_bad.latest_external_version)
def test_add_repositories(self):
repositories_good = [
Repository(None, None, {"name": "package_a-feedstock", "owner": {"login": "conda-forge"}}, True),
Repository(None, None, {"name": "package_b-feedstock", "owner": {"login": "conda-forge"}}, True),
]
repositories_bad_owner = [
Repository(None, None, {"name": "package_a-feedstock", "owner": {"login": "johnsmith"}}, True),
Repository(None, None, {"name": "package_c-feedstock", "owner": {"login": "joesmith"}}, True),
]
repositories_bad_name = [
Repository(None, None, {"name": "package_d", "owner": {"login": "conda-forge"}}, True),
]
repositories_bad_name_owner = [
Repository(None, None, {"name": "package_e", "owner": {"login": "conda-forge"}}, True),
]
repositories = repositories_good + repositories_bad_owner + repositories_bad_name + repositories_bad_name_owner
package_names = {'package_a', 'package_b', 'package_c', 'package_d', 'package_e'}
with Mocker(CondaforgeRepoMock(*package_names), PypiMock().expected_missing(2)):
self.rot.add_repositories(repositories)
rot_packages = self.rot.packages.copy()
self.assertEqual(len(repositories_good), len(rot_packages))
for pkg in rot_packages: # type: Package
if pkg.get_name() == 'package_a':
self.assertEqual(Version('2.0'), pkg.latest_feedstock_version)
self.assertIsNone(pkg.latest_external_version) # we're responding with a 404 to pypi
self.assertIsNone(pkg.latest_external_upgradeable_version)
elif pkg.get_name() == 'package_b':
self.assertEqual(Version('1.0'), pkg.latest_feedstock_version)
self.assertIsNone(pkg.latest_external_version) # we're responding with a 404 to pypi
self.assertIsNone(pkg.latest_external_upgradeable_version)
else:
self.assertIsNone(pkg.get_name())
def test_versions(self):
pkg = Package('package_a')
with Mocker(PypiMock(pkg.name)):
src = Pypi(pkg)
result = src.versions
self.assertSetEqual({Version('1.0'), Version('1.2'), Version('2.0')}, result)
pkg = Package('package_z')
with Mocker(PypiMock(pkg.name)):
src = Pypi(pkg)
result = src.versions
self.assertSetEqual({Version('0.1')}, result)
def test_versions(self):
pkg = PackageInfoFake('package_g', ['https://github.com/package_g/package_g'])
with Mocker(GithubMock(pkg.name)):
src = Github(pkg)
result = src.versions
self.assertSetEqual({Version('1.0'), Version('1.5')}, result)
pkg = PackageInfoFake('package_z', ['https://github.com/package_z/package_z'])
with Mocker(GithubMock(pkg.name)):
src = Github(pkg)
result = src.versions
self.assertSetEqual({Version('0.1')}, result)
def normalized_version(self):
"""
Return a PEP 440 compatible version.
:rtype: str
"""
return str(PackageVersion(self._version))
def setup(self):
super(PyScss, self).setup()
import scss
self.scss = scss
if self.style:
try:
from packaging.version import Version
except ImportError:
from distutils.version import LooseVersion as Version
assert Version(scss.__version__) >= Version('1.2.0'), \
'PYSCSS_STYLE only supported in pyScss>=1.2.0'
# Initialize various settings:
# Why are these module-level, not instance-level ?!
# TODO: It appears that in the current dev version, the
# settings can finally passed to a constructor. We'll need
# to support this.
# Only the dev version appears to support a list
if self.load_paths:
scss.config.LOAD_PATHS = ','.join(self.load_paths)
# These are needed for various helpers (working with images
# etc.). Similar to the compass filter, we require the user
# to specify such paths relative to the media directory.
try:
scss.config.STATIC_ROOT = self.static_root or self.ctx.directory
scss.config.STATIC_URL = self.static_url or self.ctx.url
except EnvironmentError:
raise EnvironmentError('Because Environment.url and/or '
'Environment.directory are not set, you need to '
'provide values for the PYSCSS_STATIC_URL and/or '
'PYSCSS_STATIC_ROOT settings.')
# This directory PyScss will use when generating new files,
# like a spritemap. Maybe we should REQUIRE this to be set.
scss.config.ASSETS_ROOT = self.assets_root or scss.config.STATIC_ROOT
scss.config.ASSETS_URL = self.assets_url or scss.config.STATIC_URL
def main():
if not HAS_AZURE:
sys.exit("The Azure python sdk is not installed (try `pip install 'azure>=2.0.0rc5' --upgrade`) - {0}".format(HAS_AZURE_EXC))
if Version(azure_compute_version) < Version(AZURE_MIN_VERSION):
sys.exit("Expecting azure.mgmt.compute.__version__ to be {0}. Found version {1} "
"Do you have Azure >= 2.0.0rc5 installed? (try `pip install 'azure>=2.0.0rc5' --upgrade`)".format(AZURE_MIN_VERSION, azure_compute_version))
AzureInventory()
def _get_cass_version_from_dse(dse_version):
if dse_version.startswith('4.6') or dse_version.startswith('4.5'):
raise Exception("Cassandra Version 2.0 not supported anymore")
elif dse_version.startswith('4.7') or dse_version.startswith('4.8'):
cass_ver = "2.1"
elif dse_version.startswith('5.0'):
cass_ver = "3.0"
elif dse_version.startswith('5.1'):
cass_ver = "3.1"
else:
log.error("Uknown dse version found {0}, defaulting to 2.1".format(dse_version))
cass_ver = "2.1"
return cass_ver
def get_default_protocol():
if Version(CASSANDRA_VERSION) >= Version('3.10'):
return ProtocolVersion.DSE_V1
if Version(CASSANDRA_VERSION) >= Version('2.2'):
return 4
elif Version(CASSANDRA_VERSION) >= Version('2.1'):
return 3
elif Version(CASSANDRA_VERSION) >= Version('2.0'):
raise Exception("Cassandra Version 2.0 not supported anymore")
else:
raise Exception("Running tests with an unsupported Cassandra version: {0}".format(CASSANDRA_VERSION))
def is_protocol_beta(protocol):
if Version(CASSANDRA_VERSION) >= Version('3.10') and protocol == 5:
return True
else:
return False
def get_unsupported_upper_protocol():
"""
This is used to determine the highest protocol version that is NOT
supported by the version of C* running
"""
if Version(CASSANDRA_VERSION) >= Version('2.2'):
return None
if Version(CASSANDRA_VERSION) >= Version('2.1'):
return 4
elif Version(CASSANDRA_VERSION) >= Version('2.0'):
raise Exception("Cassandra Version 2.0 not supported anymore")
else:
return None
def detect_available_upgrades(self, options):
self._prerelease = options.get('--prerelease', False)
explicit_packages_lower = None
if options['-p'] and options['-p'] != ['all']:
explicit_packages_lower = [pack_name.lower() for pack_name in options['-p']]
for i, package in enumerate(self.packages):
try:
package_name, pinned_version = self._expand_package(package)
if not package_name or not pinned_version: # pragma: nocover
# todo: treat <= or >= instead of ==
continue
if explicit_packages_lower and package_name.lower() not in explicit_packages_lower:
# skip if explicit and not chosen
continue
current_version = version.parse(pinned_version)
if pinned_version and isinstance(current_version, version.Version): # version parsing is correct
package_status, reason = self._fetch_index_package_info(package_name, current_version)
if not package_status: # pragma: nocover
print(package, reason)
continue
print('{}/{}: {} ... '.format(i + 1, len(self.packages), package_name), end='')
sys.stdout.flush()
# compare versions
if current_version < package_status['latest_version']:
print('upgrade available: {} ==> {} (uploaded on {})'.format(current_version,
package_status['latest_version'],
package_status['upload_time']))
else:
print('up to date: {}'.format(current_version))
sys.stdout.flush()
self.packages_status_map[package_name] = package_status
except Exception as e: # noqa # pragma: nocover
print('Error while parsing package {} (skipping). \nException: '.format(package), e)
return self.packages_status_map
