def get_bib_component(component, kind):
cls = get_class(component, kind, None_if_not_found=True)
if cls:
lines = cls.get_bibtex() or "[no bibliography information found]"
else:
lines = "[Component '%s.%s' not known.]" % (kind, component)
return lines + "\n"
def get_desc_component(component, kind, info=None):
cls = get_class(component, kind, None_if_not_found=True)
if cls:
lines = cleandoc(cls.get_desc(info))
else:
lines = "[no description found]"
return lines + "\n"
def get_bib_module(module, kind):
cls = get_class(module, kind, None_if_not_found=True)
if cls:
filename = cls.get_bibtex_file()
if filename:
with open(filename, "r") as f:
lines = "".join(f.readlines())
else:
lines = "[no bibliography information found]"
else:
lines = "[Module '%s.%s' not known.]" % (kind, module)
return lines + "\n"
def check_and_dump_info(self,
input_info,
updated_info,
check_compatible=True,
cache_old=False,
use_cache_old=False,
ignore_blocks=()):
"""
Saves the info in the chain folder twice:
- the input info.
- idem, populated with the components' defaults.
If resuming a sample, checks first that old and new infos and versions are
consistent.
"""
# trim known params of each likelihood: for internal use only
updated_info_trimmed = deepcopy_where_possible(updated_info)
updated_info_trimmed[_version] = __version__
for like_info in updated_info_trimmed.get(kinds.likelihood,
{}).values():
(like_info or {}).pop(_params, None)
if check_compatible:
# We will test the old info against the dumped+loaded new info.
# This is because we can't actually check if python objects do change
old_info = self.reload_updated_info(cache=cache_old,
use_cache=use_cache_old)
if old_info:
new_info = yaml_load(yaml_dump(updated_info_trimmed))
if not is_equal_info(
old_info,
new_info,
strict=False,
ignore_blocks=list(ignore_blocks) + [_output_prefix]):
raise LoggedError(
self.log,
"Old and new run information not compatible! "
"Resuming not possible!")
# Deal with version comparison separately:
# - If not specified now, take the one used in resume info
# - If specified both now and before, check new older than old one
# (For Cobaya's own version, prefer new one always)
old_version = old_info.get(_version, None)
new_version = new_info.get(_version, None)
if old_version:
if version.parse(old_version) > version.parse(new_version):
raise LoggedError(
self.log,
"You are trying to resume a run performed with a "
"newer version of Cobaya: %r (you are using %r). "
"Please, update your Cobaya installation.",
old_version, new_version)
for k in (kind for kind in kinds if kind in updated_info):
if k in ignore_blocks:
continue
for c in updated_info[k]:
new_version = updated_info[k][c].get(_version)
old_version = old_info[k][c].get(_version)
if new_version is None:
updated_info[k][c][_version] = old_version
updated_info_trimmed[k][c][_version] = old_version
elif old_version is not None:
cls = get_class(c, k, None_if_not_found=True)
if cls and cls.compare_versions(
old_version, new_version, equal=False):
raise LoggedError(
self.log,
"You have requested version %r for "
"%s:%s, but you are trying to resume a "
"run that used a newer version: %r.",
new_version, k, c, old_version)
# If resuming, we don't want to to *partial* dumps
if ignore_blocks and self.is_resuming():
return
# Work on a copy of the input info, since we are updating the prefix
# (the updated one is already a copy)
if input_info is not None:
input_info = deepcopy_where_possible(input_info)
# Write the new one
for f, info in [(self.file_input, input_info),
(self.file_updated, updated_info_trimmed)]:
if info:
for k in ignore_blocks:
info.pop(k, None)
info.pop(_debug, None)
info.pop(_force, None)
info.pop(_resume, None)
# make sure the dumped output_prefix does only contain the file prefix,
# not the folder, since it's already been placed inside it
info[_output_prefix] = self.updated_prefix()
with open(f, "w", encoding="utf-8") as f_out:
try:
f_out.write(yaml_dump(sort_cosmetic(info)))
except OutputError as e:
raise LoggedError(self.log, str(e))