def check_source(self):
"""Check the source field in meta.yaml for proper formatting."""
sources = ensure_list(self.meta.get('source', {}))
for source in sources:
url = source.get('url')
if url is not None:
if self.url_pat.match(url):
for hash_algorithm in ['md5', 'sha1', 'sha256']:
hexdigest = source.get(hash_algorithm)
if hexdigest is not None and not self.hash_pat[
hash_algorithm].match(hexdigest):
return Error(
self.recipe_dir, 'C2119',
u'Found invalid hash "{}" in meta.yaml'.format(
hexdigest))
else:
return Error(
self.recipe_dir, 'C2120',
u'Found invalid URL "{}" in meta.yaml'.format(url))
git_url = source.get('git_url')
if git_url and (source.get('git_tag')
and source.get('git_branch')):
return Error(
self.recipe_dir, 'C2121',
'Found both git_branch and git_tag in meta.yaml source field'
)
def verify_recipe(rendered_meta=None,
recipe_dir=None,
checks_to_ignore=None,
exit_on_error=False,
**kw):
"""Run all recipe checks in order to verify a conda recipe.
checks_to_ignore should be a list, tuple, or set of codes, such as ['C2102', 'C2104'].
Codes are listed in readme.md. Package codes follow 1xxx, recipe codes follow 2xxx."""
recipe_check = CondaRecipeCheck(rendered_meta, recipe_dir)
if (('ignore_scripts' in kw and kw['ignore_scripts'])
or ('run_scripts' in kw and kw['run_scripts'])):
getLogger(__name__).warn(
'Ignoring legacy ignore_scripts or run_scripts. These have '
'been replaced by the checks_to_ignore argument, which takes a'
'list of codes, documented at https://github.com/conda/conda-verify#checks'
)
checks_to_display = []
for method in dir(recipe_check):
if method.startswith('check'):
check = getattr(recipe_check, method)()
if check is not None and check.code not in ensure_list(
checks_to_ignore):
checks_to_display.append(check)
for check in sorted(checks_to_display):
try:
print(check, file=sys.stderr)
except UnicodeEncodeError:
print(str(check).encode('utf-8', 'ignore'), file=sys.stderr)
if checks_to_display and exit_on_error:
raise RecipeError(check)
def verify_recipe(rendered_meta=None,
recipe_dir=None,
checks_to_ignore=None,
exit_on_error=False,
**kw):
"""Run all recipe checks in order to verify a conda recipe.
checks_to_ignore should be a list, tuple, or set of codes, such as ['C2102', 'C2104'].
Codes are listed in readme.md. Package codes follow 1xxx, recipe codes follow 2xxx."""
recipe_check = CondaRecipeCheck(rendered_meta, recipe_dir)
if ("ignore_scripts" in kw
and kw["ignore_scripts"]) or ("run_scripts" in kw
and kw["run_scripts"]):
getLogger(__name__).warn(
"Ignoring legacy ignore_scripts or run_scripts. These have "
"been replaced by the checks_to_ignore argument, which takes a"
"list of codes, documented at https://github.com/conda/conda-verify#checks"
)
checks_to_display = []
for method in (_ for _ in dir(recipe_check) if _.startswith("check_")):
check = getattr(recipe_check, method)()
if check and check.code not in ensure_list(checks_to_ignore):
checks_to_display.append(check)
if checks_to_display and exit_on_error:
raise RecipeError(checks_to_display[0])
return (
recipe_dir,
sorted(["[{}] {}".format(*c[1:]) for c in checks_to_display]),
)
def check_for_valid_files(self):
"""Check that the files listed in meta.yaml exist."""
test_files = self.meta.get("test", {}).get("files", [])
test_source_files = self.meta.get("test", {}).get("source_files", [])
sources = ensure_list(self.meta.get("source", {}))
source_patches = []
for source in sources:
source_patches.extend(source.get("patches", []))
for filename in test_files + test_source_files + source_patches:
filepath = os.path.join(self.recipe_dir, filename)
if filename.startswith(".."):
return Error(
self.recipe_dir,
"C2123",
u'Found file "{}" listed outside recipe directory'.format(
filename),
)
if not os.path.exists(filepath):
return Error(
self.recipe_dir,
"C2124",
u'Found file "{}" in meta.yaml that doesn\'t exist'.format(
filename),
)
def check_source(self):
"""Check the source field in meta.yaml for proper formatting."""
sources = ensure_list(self.meta.get("source", {}))
for source in sources:
url = source.get("url")
if url is not None:
if self.url_pat.match(url):
for hash_algorithm in ["md5", "sha1", "sha256"]:
hexdigest = source.get(hash_algorithm)
if hexdigest is not None and not self.hash_pat[
hash_algorithm].match(hexdigest):
return Error(
self.recipe_dir,
"C2119",
u'Found invalid hash "{}" in meta.yaml'.format(
hexdigest),
)
else:
return Error(
self.recipe_dir,
"C2120",
u'Found invalid URL "{}" in meta.yaml'.format(url),
)
git_url = source.get("git_url")
if git_url and (source.get("git_tag")
and source.get("git_branch")):
return Error(
self.recipe_dir,
"C2121",
"Found both git_branch and git_tag in meta.yaml source field",
)
def check_index_dependencies_specs(self):
"""Check that the dependencies in info/index.json are properly formatted."""
dependencies = ensure_list(self.info.get('depends'))
if dependencies != [None]:
for dependency in dependencies:
dependency_parts = dependency.split()
if len(dependency_parts) == 0:
return Error(self.path, 'C1113', 'Found empty dependencies in info/index.json')
elif len(dependency_parts) == 2 and not self.ver_spec_pat.match(dependency_parts[1]) or len(dependency_parts) > 3:
return Error(self.path, 'C1114', 'Found invalid dependency "{}" in info/index.json' .format(dependency))
def verify_package(path_to_package=None,
checks_to_ignore=None,
exit_on_error=False,
**kw):
"""Run all package checks in order to verify a conda package.
checks_to_ignore should be a list, tuple, or set of codes, such as ['C1102', 'C1104'].
Codes are listed in readme.md. Package codes follow 1xxx, recipe codes follow 2xxx."""
package_check = CondaPackageCheck(path_to_package)
if (('ignore_scripts' in kw and kw['ignore_scripts'])
or ('run_scripts' in kw and kw['run_scripts'])):
getLogger(__name__).warn(
'Ignoring legacy ignore_scripts or run_scripts. These have '
'been replaced by the checks_to_ignore argument, which takes a'
'list of codes, documented at https://github.com/conda/conda-verify#checks'
)
# collect all CondaPackageCheck methods that start with the word 'check'
# this should later be a decorator that is placed on each check
checks_to_display = []
for method in dir(package_check):
if method.startswith('check'):
# runs the check
# TODO: should have a way to skip checks if a check's codes are all ignored
check = getattr(package_check, method)()
if check is not None and check.code not in ensure_list(
checks_to_ignore):
checks_to_display.append(check)
if checks_to_display:
print("Package verification results:")
print("-----------------------------")
for check in sorted(checks_to_display):
try:
print(check, file=sys.stderr)
except UnicodeEncodeError:
print(
"Could not print message for error code {} due to unicode error"
.format(check.code),
file=sys.stderr)
if checks_to_display and exit_on_error:
raise PackageError(check)
def verify_recipe(rendered_meta=None,
recipe_dir=None,
checks_to_ignore=None,
exit_on_error=False,
**kw):
"""Run all recipe checks in order to verify a conda recipe.
checks_to_ignore should be a list, tuple, or set of codes, such as ['C2102', 'C2104'].
Codes are listed in readme.md"""
recipe_check = CondaRecipeCheck(rendered_meta, recipe_dir)
if (('ignore_scripts' in kw and kw['ignore_scripts'])
or ('run_scripts' in kw and kw['run_scripts'])):
getLogger(__name__).warn(
'Ignoring legacy ignore_scripts or run_scripts. These have '
'been replaced by the checks_to_ignore argument, which takes a'
'list of codes, documented at https://github.com/conda/conda-verify#checks'
)
# collect all CondaRecipeCheck methods that start with the word 'check'
# this should later be a decorator that is placed on each check
checks_to_display = [
getattr(recipe_check, method)() for method in dir(recipe_check)
if method.startswith('check') and getattr(recipe_check, method)
() is not None
]
return_code = 0
if len(checks_to_display) > 0:
for check in sorted(checks_to_display):
if check.code not in ensure_list(checks_to_ignore):
if exit_on_error:
raise RecipeError(check)
else:
print(check, file=sys.stderr)
return_code = 1
# by exiting at a return code greater than 0 we can assure failures
# in logs or continuous integration services
if return_code > 0:
sys.exit(return_code)
def check_index_dependencies_specs(self):
"""Check that the dependencies in info/index.json are properly formatted."""
dependencies = ensure_list(self.info.get("depends"))
if dependencies != [None]:
for dependency in dependencies:
dependency_parts = dependency.split()
if len(dependency_parts) == 0:
return Error(
self.path,
"C1113",
"Found empty dependencies in info/index.json",
)
elif (len(dependency_parts) == 2
and not fullmatch(ver_spec_pat, dependency_parts[1])
or len(dependency_parts) > 3):
return Error(
self.path,
"C1114",
'Found invalid dependency "{}" in info/index.json'.
format(dependency),
)
def verify_package(path_to_package=None,
checks_to_ignore=None,
exit_on_error=False,
**kw):
"""Run all package checks in order to verify a conda package."""
package_check = CondaPackageCheck(path_to_package)
if (('ignore_scripts' in kw and kw['ignore_scripts'])
or ('run_scripts' in kw and kw['run_scripts'])):
getLogger(__name__).warn(
'Ignoring legacy ignore_scripts or run_scripts. These have '
'been replaced by the checks_to_ignore argument, which takes a'
'list of codes, documented at https://github.com/conda/conda-verify#checks'
)
# collect all CondaPackageCheck methods that start with the word 'check'
# this should later be a decorator that is placed on each check
checks_to_display = [
getattr(package_check, method)() for method in dir(package_check)
if method.startswith('check') and getattr(package_check, method)
() is not None
]
return_code = 0
if len(checks_to_display) > 0:
for check in sorted(checks_to_display):
if check.code not in ensure_list(checks_to_ignore):
check = u'{}'.format(check)
if exit_on_error:
raise PackageError(check)
else:
print(check, file=sys.stderr)
return_code = 1
# by exiting at a return code greater than 0 we can assure failures
# in logs or continuous integration services
if return_code > 0:
sys.exit(return_code)
def verify_package(path_to_package=None,
checks_to_ignore=None,
exit_on_error=False,
**kw):
"""Run all package checks in order to verify a conda package.
checks_to_ignore should be a list, tuple, or set of codes, such as ['C1102', 'C1104'].
Codes are listed in readme.md. Package codes follow 1xxx, recipe codes follow 2xxx."""
package_check = CondaPackageCheck(path_to_package)
if ("ignore_scripts" in kw
and kw["ignore_scripts"]) or ("run_scripts" in kw
and kw["run_scripts"]):
getLogger(__name__).warn(
"Ignoring legacy ignore_scripts or run_scripts. These have "
"been replaced by the checks_to_ignore argument, which takes a"
"list of codes, documented at https://github.com/conda/conda-verify#checks"
)
# collect all CondaPackageCheck methods that start with the word 'check'
# this should later be a decorator that is placed on each check
checks_to_display = []
for method in dir(package_check):
if method.startswith("check"):
# runs the check
# TODO: should have a way to skip checks if a check's codes are all ignored
check = getattr(package_check, method)()
if check is not None and check.code not in ensure_list(
checks_to_ignore):
checks_to_display.append(check)
if checks_to_display and exit_on_error:
raise PackageError(check)
return (
path_to_package,
sorted(["[{}] {}".format(*c[1:]) for c in checks_to_display]),
)