def check_solidity_version(url):
"""Check if a repository is a fix repository by checking if it contains atleast one file with version >=0.4.19
:param url: URL of repository
:return: True if repository is a fix repo else False
"""
# clone repo
path = os.getcwd() + '/data'
if not os.path.exists(path):
os.mkdir('data')
# check if repo has .sol files or not
response = make_request(url + '/search?q=extension%3Asol', HEADER)
parsed = BeautifulSoup(response.content, 'html.parser')
try:
parsed.find('div', class_='code-list').find('a')['href']
except Exception as e:
logging.exception(e)
logging.info('Does not contains .sol files')
return False, '0'
if not clone_repo(url, path):
return False, '0'
sol_files = get_sol_files(path + '/' + url.split('/')[-1])
for sol_file in sol_files:
try:
parsed = parser.parse_file(sol_file)
ver = None
for child in parsed['children']:
if child['type'] == 'PragmaDirective':
ver = child['value']
break
# ver = parsed['children'][0]['value'].replace('^','')
if not ver:
logging.error('File version not found in file ' +
str(sol_file))
continue
ver = ver.replace('^', '')
if '<' in ver:
ver = ver.split('<')[0]
file_sol_ver = semantic_version.SimpleSpec(ver)
# checking if version >= 0.4.19
req_sol_ver = semantic_version.SimpleSpec('>=0.4.19')
if req_sol_ver.match(file_sol_ver.clause.target):
shutil.rmtree(path + '/' + url.split('/')[-1])
return True, len(sol_files)
except Exception as e:
logging.exception(e)
continue
# delete cloned copy of repo
shutil.rmtree(path + '/' + url.split('/')[-1])
return False, '0'
def get_filename(datapackage="cord19_cdcs"):
"""get endpoint to download `datapackage`"""
constraint = __compatible__.get(datapackage)
assert (
constraint
is not None), f"`{datapackage}` is not a supported datapackage name!"
spec = sv.SimpleSpec(constraint)
if datapackage == "cord19_cdcs":
repo = "usnistgov/cord19-cdcs-nist"
v = spec.select(get_release_versions(repo))
fname = (
f"https://github.com/{repo}/releases/download/v{v}/cord19-cdcs-{v}.tar.gz"
)
return fname
elif datapackage in [ # Sci-spaCy
"en_core_sci_sm",
"en_core_sci_md",
"en_core_sci_lg",
"en_ner_craft_md",
"en_ner_jnlpba_md",
"en_ner_bc5cdr_md",
"en_ner_bionlp13cg_md",
]:
fname = (
f"https://s3-us-west-2.amazonaws.com/ai2-s2-scispacy/releases/v0.2.4/{datapackage}-0.2.4.tar.gz"
)
return fname
else: # TODO other resources sources?
raise NotImplementedError
def _filter_unsupported_templates(self):
"""Remove template descriptors which is not supported."""
# No need to filter templates if CSE is configured in legacy mode.
if self.legacy_mode:
msg = "Skipping filtering templates as CSE is being" \
" executed in legacy mode"
self.filtered_cookbook = self.unfiltered_cookbook
self.logger.debug(msg)
self.msg_update_callback.general(msg)
return
# Fetch current CSE version
current_cse_version = server_utils.get_installed_cse_version()
supported_templates = []
for template_description in self.unfiltered_cookbook['templates']:
# only include the template if the current CSE version
# supports it
# template is supported if current CSE version is between
# min_cse_version and max_cse_version of the template
template_supported_cse_versions = semantic_version.SimpleSpec(
f">={template_description[RemoteTemplateKey.MIN_CSE_VERSION]},"
f"<={template_description[RemoteTemplateKey.MAX_CSE_VERSION]}")
msg = f"Template {template_description['name']}"
if template_supported_cse_versions.match(current_cse_version):
msg += " is supported"
supported_templates.append(template_description)
else:
msg += " is not supported"
msg += f" by CSE {current_cse_version}"
self.logger.debug(msg)
self.msg_update_callback.general(msg)
self.filtered_cookbook = {'templates': supported_templates}
msg = "Successfully filtered unsupported templates."
self.logger.debug(msg)
self.msg_update_callback.general(msg)
def get_package(self, name, requirements=None, url=None):
pkg_id = int(name[3:]) if name.startswith("id=") else 0
best = None
for manifest in self.get_installed():
if url:
if manifest.get("__src_url") != url:
continue
elif pkg_id and manifest.get("id") != pkg_id:
continue
elif not pkg_id and manifest["name"] != name:
continue
elif not PkgRepoMixin.is_system_compatible(manifest.get("system")):
continue
# strict version or VCS HASH
if requirements and requirements == manifest["version"]:
return manifest
try:
if requirements and not semantic_version.SimpleSpec(
requirements).match(
self.parse_semver_version(manifest["version"],
raise_exception=True)):
continue
if not best or (self.parse_semver_version(manifest["version"],
raise_exception=True)
> self.parse_semver_version(
best["version"], raise_exception=True)):
best = manifest
except ValueError:
pass
return best
def constraints_fulfilled(constraints, stackhead_config):
extractFromConstraint = re.compile(r"^([\w.]+)([+><=\s]+(.*))?$")
for constraint in constraints:
match = extractFromConstraint.match(constraint)
(constraint_name, constraint_range) = match.group(1, 2)
if constraint_name != "stackhead": # for now only support stackhead
continue
if constraint_range is None:
# todo when extending this for module constraints: check if package exists
continue
# remove whitespace
# @see https://stackoverflow.com/questions/8270092/remove-all-whitespace-in-a-string
constraint_range = re.sub(r"\s+",
"",
constraint_range,
flags=re.UNICODE)
constraint_version = ""
if constraint_name == "stackhead":
constraint_version = stackhead_config["version"]["current"]
if semantic_version.Version(
constraint_version) not in semantic_version.SimpleSpec(
constraint_range):
return False
return True
def check_package(strategy, pkg, level=Level.STANDARD):
whitelisted = (pkg['name'] in strategy.AUTHORIZED_PACKAGES
and (semantic_version.SimpleSpec(
strategy.AUTHORIZED_PACKAGES[pkg['name']]).match(
semantic_version.Version.coerce(pkg['version'])) or
(level == Level.STANDARD
and strategy.AUTHORIZED_PACKAGES[pkg['name']] == '')))
if whitelisted:
return Reason.OK
at_least_one_unauthorized = False
count_authorized = 0
for license in pkg['licenses']:
lower = license.lower()
if lower in strategy.UNAUTHORIZED_LICENSES:
at_least_one_unauthorized = True
if lower in strategy.AUTHORIZED_LICENSES:
count_authorized += 1
if (count_authorized and level is Level.STANDARD) \
or (count_authorized and not at_least_one_unauthorized
and level is Level.CAUTIOUS) \
or (count_authorized and count_authorized == len(pkg['licenses'])
and level is Level.PARANOID):
return Reason.OK
# if not OK and at least one unauthorized
if at_least_one_unauthorized:
return Reason.UNAUTHORIZED
return Reason.UNKNOWN
def requirements(self, value):
if not value:
self._requirements = None
return
self._requirements = (value
if isinstance(value, semantic_version.SimpleSpec)
else semantic_version.SimpleSpec(str(value)))
def max_satisfying_repo_version(self, versions, requirements=None):
def _cmp_dates(datestr1, datestr2):
date1 = util.parse_date(datestr1)
date2 = util.parse_date(datestr2)
if date1 == date2:
return 0
return -1 if date1 < date2 else 1
semver_spec = None
try:
semver_spec = (semantic_version.SimpleSpec(requirements)
if requirements else None)
except ValueError:
pass
item = {}
for v in versions:
semver_new = self.parse_semver_version(v["name"])
if semver_spec:
if not semver_new or semver_new not in semver_spec:
continue
if not item or self.parse_semver_version(
item["name"]) < semver_new:
item = v
elif requirements:
if requirements == v["name"]:
return v
else:
if not item or _cmp_dates(item["released"],
v["released"]) == -1:
item = v
return item
async def get_latest_matching_version(self,
collection: str,
version_spec: str,
pre: bool = False) -> semver.Version:
"""
Get the latest version of a collection that matches a specification.
:arg collection: Namespace.collection identifying a collection.
:arg version_spec: String specifying the allowable versions.
:kwarg pre: If True, allow prereleases (versions which have the form X.Y.Z.SOMETHING).
This is **not** for excluding 0.Y.Z versions. The default is False.
:returns: :obj:`semantic_version.Version` of the latest collection version that satisfied
the specification.
.. seealso:: For the format of the version_spec, see the documentation
of :obj:`semantic_version.SimpleSpec`
"""
versions = await self.get_versions(collection)
versions = [semver.Version(v) for v in versions]
versions.sort(reverse=True)
spec = semver.SimpleSpec(version_spec)
for version in (v for v in versions if v in spec):
# If we're excluding prereleases and this is a prerelease, then skip it.
if not pre and version.prerelease:
continue
return version
# No matching versions were found
raise NoSuchVersion(
f'{version_spec} did not match with any version of {collection}.')
async def main(
args: argparse.Namespace,
log: logging.Logger,
) -> int:
version_specs = [semver.SimpleSpec(spec) for spec in args.version_spec]
output_dir_path = args.output_dir_path.absolute()
output_dir_path.mkdir(parents=True, exist_ok=True)
log.debug(
"args: version_specs=%s, download_zip=%s, download_exe=%s, output_dir_path=%s",
list(map(str, version_specs)),
args.download_zip,
args.download_exe,
output_dir_path,
)
if not args.download_zip and not args.download_exe:
log.error(
"both EXE and ZIP are disabled: at least one of them must be enabled"
)
return -1
async with aiohttp.ClientSession() as session:
await run(
http_session=session,
version_specs=version_specs,
download_zip=args.download_zip,
download_exe=args.download_exe,
output_dir_path=output_dir_path,
log=log,
)
return 0
def _check_dependencies_format(self, attribute, dependencies):
"""Check type and format of dependencies collection and version."""
for collection, version_spec in dependencies.items():
if not isinstance(collection, str):
self.value_error("Expecting depencency to be string")
if not isinstance(version_spec, str):
self.value_error("Expecting depencency version to be string")
try:
namespace, name = collection.split('.')
except ValueError:
self.value_error(f"Invalid dependency format: '{collection}'")
for value in [namespace, name]:
if not re.match(constants.NAME_REGEXP, value):
self.value_error(
f"Invalid dependency format: '{value}' "
f"in '{namespace}.{name}'")
if namespace == self.namespace and name == self.name:
self.value_error("Cannot have self dependency")
try:
semantic_version.SimpleSpec(version_spec)
except ValueError:
self.value_error(
"Dependency version spec range invalid: "
f"{collection} {version_spec}")
def _is_compatible(self, has, needs):
"""Is a provider and consumer specification compatible.
Args:
has: a tuple (pair) of strings. The first string is a
string naming the service provided. The second is a
string giving the version of the provided service.
needs: a tuple (pair) of strings. The first string is a
string naming an acceptable services type. The second is a
string specifying acceptable versions for the service
type. The version specification can be in any format that is
compatible with the
`semver <https://pypi.org/project/semver/>`_ Python package.
Returns:
bool: True if the provider and consumer specification are
compatible.
"""
# if consumer has no constraints
# compatibility is true by default
if not needs:
return True
# if consumer has constraints but provider
# has no specification compatibility can not
# be determined and is hence false by default
if not has and needs:
return False
# By now we know both consumer and provider have a
# constraint specification so we check if the
# constraint type is the same
has_type = self._normalized_type(has)
needs_type = self._normalized_type(needs)
if has_type != needs_type:
return False
# By now we know consumer and provider have the
# same constraint type so we check if the constraints
# are further qualified by version specifications
# If consumer is not qualified, provider and
# consumer are compatible by default
if not self._has_version(needs):
return True
# If consumer is qualified but provider is not there
# is no way to determine compatibility so it is False
# by default
if not self._has_version(has):
return False
# Both consumer and provider are qualified so we
# check compatibility of version
spec = semver.SimpleSpec(self._normalized_version(needs))
got = semver.Version.coerce(self._normalized_version(has))
return spec.match(got)
async def _get_latest_matching_version(self, collection, version_spec):
versions = await self.galaxy_client.get_versions(collection)
versions = [semver.Version(v) for v in versions]
versions.sort(reverse=True)
spec = semver.SimpleSpec(version_spec)
for version in (v for v in versions if v in spec):
return version
# No matching versions were found
return None
def version(requirement: str,
current: str = __version__,
package_name="gdsfactory") -> None:
"""Raises error if current version does not match requirement."""
s = semantic_version.SimpleSpec(requirement)
if not s.match(semantic_version.Version(current)):
raise ValueError(
f"{package_name} requirement {requirement}\n"
f"not compatible your current installed version {current}\n"
"you can run:\n"
f"pip install {package_name} {requirement}\n")
def MatchVersionSpecification(versionSpec: list,
version: semantic_version.Version):
versionSpecStr = ''
for versionTuple in versionSpec:
if len(versionSpecStr) > 0:
versionSpecStr += ','
versionSpecStr += versionTuple[0] + versionTuple[1]
if len(versionSpecStr) > 0:
s = semantic_version.SimpleSpec(versionSpecStr)
return s.match(version)
else:
return True
def main(node_modules, include_unspecified):
'''
Node ES6 matrix: https://node.green/#ES2016
'''
n_packages = 0
n_engines = 0
n_no_engines = 0
to_transpile = []
for package_config in glob.glob(
os.path.join(node_modules, '*', 'package.json')):
n_packages += 1
with open(package_config, 'r') as f:
package = json.load(f)
try:
engines = package['engines']
except KeyError:
n_no_engines += 1
if include_unspecified:
to_transpile.append(package_config)
except:
continue
else:
print('{0}: {1}'.format(package_config, engines))
max_node_version = semantic_version.Version('0.12.18')
package_node_version = get_formatted_node_version(engines)
if max_node_version in semantic_version.SimpleSpec(
package_node_version):
print('{} includes max version'.format(package_config))
else:
print('{} exceeds max version'.format(package_config))
to_transpile.append(package_config)
n_engines += 1
print('Found {0} packages, {1} with engines, {2} without engines'.format(
n_packages, n_engines, n_no_engines))
print('Recommend transpiling {} packages'.format(len(to_transpile)))
pprint.pprint([os.path.dirname(package) for package in to_transpile])
def test_convert_caret_specification():
spec = ">=1.1.2"
assert et_micc.utils.convert_caret_specification(spec) == spec
spec = "^1.1.2"
spec_new = et_micc.utils.convert_caret_specification(spec)
assert spec_new == ">=1.1.2,<2.0.0"
assert sv.SimpleSpec("1.1.2").match(sv.Version("1.1.2"))
assert not sv.Version("1.1.1") in sv.SimpleSpec(spec_new)
assert sv.Version("1.1.2") in sv.SimpleSpec(spec_new)
assert sv.Version("1.1.2") in sv.SimpleSpec(spec_new)
assert sv.Version("1.2.2") in sv.SimpleSpec(spec_new)
assert not sv.Version("2.0.0") in sv.SimpleSpec(spec_new)
assert not sv.Version("2.2.2") in sv.SimpleSpec(spec_new)
def _filter_unsupported_templates(self):
"""Remove template descriptors which is not supported."""
# No need to filter templates if CSE is configured in legacy mode.
if self.legacy_mode:
msg = "Skipping filtering templates as CSE is being" \
" executed in legacy mode"
self.filtered_cookbook = self.unfiltered_cookbook
self.logger.debug(msg)
self.msg_update_callback.general(msg)
return
# Cookbook version 1.0 doesn't have supported version information.
if self.cookbook_version < \
RemoteTemplateCookbookVersion.Version2.value:
msg = "Skipping filtering templates as cookbook version " \
f"{self.cookbook_version} doesn't have supported " \
"CSE version information."
self.logger.debug(msg)
self.msg_update_callback.general(msg)
return
# Fetch current CSE version
current_cse_version = server_utils.get_installed_cse_version()
supported_templates = []
remote_template_key = server_utils.get_template_descriptor_keys(
self.cookbook_version) # noqa: E501
for template_description in self.unfiltered_cookbook['templates']:
# only include the template if the current CSE version
# supports it
# template is supported if current CSE version is between
# min_cse_version and max_cse_version of the template
template_supported_cse_versions = semantic_version.SimpleSpec(
f">={template_description[remote_template_key.MIN_CSE_VERSION]}," # noqa: E501
f"<={template_description[remote_template_key.MAX_CSE_VERSION]}"
) # noqa: E501
msg = f"Template {template_description['name']}"
if template_supported_cse_versions.match(current_cse_version):
msg += " is supported"
supported_templates.append(template_description)
else:
msg += " is not supported"
msg += f" by CSE {current_cse_version}"
self.logger.debug(msg)
self.msg_update_callback.general(msg)
self.filtered_cookbook = self.unfiltered_cookbook
# update templates list with only supported templates
self.filtered_cookbook['templates'] = supported_templates
msg = "Successfully filtered unsupported templates."
self.logger.debug(msg)
self.msg_update_callback.general(msg)
def verify_required_version(self):
"""Verify that the required version for the pod is met."""
if self.pod.grow_version is None:
return
sem_current = semantic_version.Version(self.current_version)
grow_version_pattern = '{}'.format(self.pod.grow_version)
# Include pre-releases in the version check.
if '-' not in grow_version_pattern:
grow_version_pattern = '{}-'.format(grow_version_pattern)
spec_required = semantic_version.SimpleSpec(grow_version_pattern)
if sem_current not in spec_required:
text = 'ERROR! Pod requires Grow SDK version: {}'.format(
self.pod.grow_version)
logging.error(colors.stylize(text, colors.ERROR))
raise LatestVersionCheckError(text)
def check_package(pkg_name, spec='*', is_optional=False):
try:
spec_pattern = semantic_version.SimpleSpec(spec)
pkg_version = pkg_resources.get_distribution(pkg_name).version
version = semantic_version.Version(pkg_version)
if not spec_pattern.match(version):
raise Exception('Package "{0}" version ({1}) does not match "{2}" '.format(pkg_name, version, spec) +
'Please run: pip install -U {0}'.format(pkg_name))
except pkg_resources.DistributionNotFound:
if is_optional:
raise Exception('Optional package "{0}" is not installed. '.format(pkg_name) +
'Please run: pip install {0}'.format(pkg_name))
else:
raise Exception('Package "{0}" is not installed. '.format(pkg_name) +
'Please run: pip install {0}'.format(pkg_name))
async def get_latest_matching_version(self,
collection: str,
version_spec: str,
pre: bool = False) -> semver.Version:
"""
Get the latest version of a collection that matches a specification.
:arg collection: Namespace.collection identifying a collection.
:arg version_spec: String specifying the allowable versions.
:kwarg pre: If True, allow prereleases (versions which have the form X.Y.Z.SOMETHING).
This is **not** for excluding 0.Y.Z versions. non-pre-releases are still
preferred over pre-releases (for instance, with version_spec='>2.0.0-a1,<3.0.0'
and pre=True, if the available versions are 2.0.0-a1 and 2.0.0-a2, then 2.0.0-a2
will be returned. If the available versions are 2.0.0 and 2.1.0-b2, 2.0.0 will be
returned since non-pre-releases are preferred. The default is False
:returns: :obj:`semantic_version.Version` of the latest collection version that satisfied
the specification.
.. seealso:: For the format of the version_spec, see the documentation
of :obj:`semantic_version.SimpleSpec`
.. versionchanged:: 0.37.0
Giving True to the ``pre`` parameter now means that prereleases will be
*allowed* but stable releases will still be *preferred*. Previously, the
latest release, whether stable or prerelease was returned when pre was True.
"""
versions = await self.get_versions(collection)
versions = [semver.Version(v) for v in versions]
versions.sort(reverse=True)
spec = semver.SimpleSpec(version_spec)
prereleases = []
for version in (v for v in versions if v in spec):
# If this is a pre-release, first check if there's a non-pre-release that
# will satisfy the version_spec.
if version.prerelease:
prereleases.append(version)
continue
return version
# We did not find a stable version that satisies the version_spec. If we
# allow prereleases, return the latest of those here.
if pre and prereleases:
return prereleases[0]
# No matching versions were found
raise NoSuchVersion(
f'{version_spec} did not match with any version of {collection}.')
def version(self, version: Optional[str]) -> Optional[ChartVersionInfo]:
"""
Returns a chart version info.
:param version: version to locate. If None, returns the latest version. Can be a semver SimpleSpec.
:return: the chart version information, or None if not found
"""
if version is None or version == "":
return self.latest
versionspec = semantic_version.SimpleSpec(version)
for r in self.versions:
if versionspec.match(r.version_info):
return r
return None
def பதிப்பு_கண்டறி(தன், நிரல்மொழி, பதிப்பு):
பதிப்புகள் = தன்.பதிப்புகள்(நிரல்மொழி)
if not பதிப்புகள்:
return
பதிப்புகள் = [semantic_version.Version(ப) for ப in பதிப்புகள்]
if not பதிப்புகள்:
return None
if பதிப்பு is None:
return str(பதிப்புகள்[-1])
_பதிப்பு = semantic_version.Version.coerce(str(பதிப்பு))
try:
return next(str(ப) for ப in பதிப்புகள்[::-1] if semantic_version.SimpleSpec(f'<={_பதிப்பு}').match(ப))
except StopIteration:
return str(பதிப்புகள்[-1])
def check_appcast(self) -> Optional[EDMCVersion]:
"""
Manually (no Sparkle or WinSparkle) check the update_feed appcast file
to see if any listed version is semantically greater than the current
running version.
:return: EDMCVersion or None if no newer version found
"""
import requests
from xml.etree import ElementTree
newversion = None
items = {}
try:
r = requests.get(update_feed, timeout=10)
except requests.RequestException as ex:
print('Error retrieving update_feed file: {}'.format(str(ex)),
file=sys.stderr)
return None
try:
feed = ElementTree.fromstring(r.text)
except SyntaxError as ex:
print('Syntax error in update_feed file: {}'.format(str(ex)),
file=sys.stderr)
return None
for item in feed.findall('channel/item'):
ver = item.find('enclosure').attrib.get(
'{http://www.andymatuschak.org/xml-namespaces/sparkle}version')
# This will change A.B.C.D to A.B.C+D
sv = semantic_version.Version.coerce(ver)
items[sv] = EDMCVersion(
version=ver, # sv might have mangled version
title=item.find('title').text,
sv=sv)
# Look for any remaining version greater than appversion
simple_spec = semantic_version.SimpleSpec('>' + appversion)
newversion = simple_spec.select(items.keys())
if newversion:
return items[newversion]
return None
def test_spec_requirements():
assert PackageSpec("[email protected]") == PackageSpec(name="foo",
requirements="1.2.3")
assert PackageSpec(
name="foo",
requirements=semantic_version.Version("1.2.3")) == PackageSpec(
name="foo", requirements="1.2.3")
assert PackageSpec("bar @ ^1.2.3") == PackageSpec(name="bar",
requirements="^1.2.3")
assert PackageSpec("13 @ ~2.0") == PackageSpec(id=13, requirements="~2.0")
assert PackageSpec(
name="hello",
requirements=semantic_version.SimpleSpec("~1.2.3")) == PackageSpec(
name="hello", requirements="~1.2.3")
spec = PackageSpec("id=20 @ !=1.2.3,<2.0")
assert not spec.external
assert isinstance(spec.requirements, semantic_version.SimpleSpec)
assert semantic_version.Version("1.3.0-beta.1") in spec.requirements
assert spec == PackageSpec(id=20, requirements="!=1.2.3,<2.0")
def main(args):
input_file = open(args.file, 'r')
try:
constraint = hcl.load(input_file)['terraform']['required_version']
except:
# Using the latest version
constraint = '>= 0.1.0'
token = get_token(args.username, args.password)
all_versions = sorted(get_versions(args.repository, token),
key=LooseVersion)
# Get the required versions range
valid_versions = semantic_version.SimpleSpec(format_constraint(constraint))
while all_versions:
match = all_versions.pop()
if semantic_version.validate(match) \
and not(semantic_version.Version(match).prerelease) \
and semantic_version.Version(match) in valid_versions:
# Valid x.y.z & release & in the required versions range
break
match = 'No match'
print(match)