"""Containers for configuration parameters of SPR-KKR tasks."""
from __future__ import annotations
import io
import os
from collections.abc import Mapping
from . import definitions, tasks
from .task_definition import InputParametersRegistry, TaskRegistry
from ..sprkkr.configuration import (
ConfigurationFile,
ConfigurationSection,
ConfigurationValue,
)
from ..common.configuration_containers import BaseConfigurationContainer
from ..common.repeated_configuration_containers import RepeatedConfigurationContainer
from ..common.decorators import cached_class_property
from ..common.module_registry import RegistryEntryNotFound
from ..potentials.potentials import Potential
class InputParameters(ConfigurationFile):
"""Concrete values of an SPR-KKR input file."""
input_parameters_registry = InputParametersRegistry(definitions)
task_registry = TaskRegistry(input_parameters_registry, tasks)
def __init__(
self,
definition,
inputfile=None,
outputfile=False,
*,
requested_task_name=None,
):
super().__init__(definition)
self._requested_task_name = (
None
if requested_task_name is None
else str(requested_task_name).upper()
)
self._inputfile = inputfile
self._outputfile = inputfile if outputfile is False else outputfile
self._directory = None
@property
def directory(self):
return self._directory
@directory.setter
def directory(self, value):
self._directory = value
@property
def task_name(self):
"""Return the ASE2SPRKKR task represented by the current values."""
name = self._definition.task_definition_name(self)
if name is None:
return None
return str(name).strip().upper()
@property
def task_definition(self):
"""Return the task represented by the current values, if any."""
name = self.task_name
return None if name is None else self.task_registry[name]
def task_definition_required(self):
"""Return the task represented by the current values, failing if detached."""
task = self.task_definition
if task is None:
raise RuntimeError(
"These input parameters are not associated with an SPR-KKR task definition"
)
expected = self.input_parameters_registry.definition_for_task(task)
if (expected is not self._definition
and expected.name.upper() != self._definition.derived_from_name.upper()):
raise RuntimeError(
f"Task {task.name} uses a different input schema; "
"use change_task() to switch schemas explicitly."
)
return task
@property
def requested_task_name(self):
"""Task requested when these parameters were created or last retargeted.
Shared input schemas may use this only as context for callable defaults.
Concrete parameter values remain authoritative for :attr:`task_name`.
"""
return self._requested_task_name
@property
def definition_name(self):
"""Return the normalized registered input-parameter schema name."""
return self.input_parameters_registry.normalize_name(self._definition.name)
@property
def potential(self):
pot = getattr(self, "_potential", None)
potfil = self.CONTROL.POTFIL.result
if pot:
if potfil == pot[0]:
return pot[1]
out = Potential.from_file(potfil) if potfil else None
self._potential = potfil, out
return out
@staticmethod
def _has_instance_defaults(source):
if isinstance(source, InputValue):
return hasattr(source, "_default_override")
if isinstance(source, RepeatedConfigurationContainer):
return any(
InputParameters._has_instance_defaults(member)
for member in source._raw_values()
)
if isinstance(source, BaseConfigurationContainer):
return any(
InputParameters._has_instance_defaults(member)
for member in source._members.values()
)
return False
@staticmethod
def _copy_instance_defaults(source, target, copy_values):
if isinstance(source, RepeatedConfigurationContainer):
for key, source_member in source._raw_items():
try:
target_member = target[key]
except (IndexError, KeyError, TypeError):
if not InputParameters._has_instance_defaults(source_member):
continue
if isinstance(target._values, list):
while len(target._values) <= key:
target._add()
else:
target._add(key)
target_member = target[key]
InputParameters._copy_instance_defaults(
source_member, target_member, copy_values
)
return
if isinstance(source, BaseConfigurationContainer):
for name, source_member in source._members.items():
target_member = target._members.get(name)
if target_member is None:
continue
InputParameters._copy_instance_defaults(
source_member, target_member, copy_values
)
return
if not isinstance(source, InputValue):
return
if not hasattr(source, "_default_override"):
return
value = source._default_override
if copy_values and value is not None:
value = source._definition.copy_value(value, all_values=True)
target._default_override = value
def copy(self, copy_values: bool = False):
"""Copy parameters, including instance-specific defaults."""
values = self.as_dict(copy=copy_values, only_changed="explicit")
out = self.__class__(
definition=self._definition,
requested_task_name=self.requested_task_name,
)
out.set(values, unknown="add", retain_invalid="all", report_invalid="ignore")
self._copy_instance_defaults(self, out, copy_values)
return out
def uses_separate_single_site_contour(self):
switches = (
("ENERGY", "SPLITSS"),
("CONTROL", "SPLITSS"),
("CONTROL", "FSOHFF"),
)
for section, name in switches:
try:
if self[section][name]():
return True
except (KeyError, AttributeError):
pass
task = self.task_definition
return task is not None and task.name == "COMPTON"
def _task_files(self, directory, kind):
task = self.task_definition_required()
return self.input_parameters_registry.files_for_task(
task, self, directory, kind
)
def input_files(self, directory):
return self._task_files(directory, "input")
def output_files(self, directory):
return self._task_files(directory, "output")
def cache_files(self, directory):
return self._task_files(directory, "cache")
def output_reader(self, calculator=None, print_info=False, directory=None):
"""Create the reader for the effective task represented by these values."""
return self.task_definition_required().output_reader(
input_parameters=self,
calculator=calculator,
print_info=print_info,
directory=directory,
)
def read_output_from_file(self, filename, directory=None):
"""Read a completed output through the effective task's registered reader."""
return self.task_definition_required().read_output_from_file(
filename,
input_parameters=self,
directory=directory,
)
def __str__(self):
return f"<Configuration container {self._get_path()}>"
def set_option(self, name, value):
try:
option = self.get_member(name, is_option=True)
except KeyError:
raise KeyError(f"No option with name {name} in any of the members") from None
option.set(value)
@classmethod
def definition(cls, name):
normalized = cls.input_parameters_registry.normalize_name(name)
if normalized in cls.input_parameters_registry:
return cls.input_parameters_registry[normalized]
task = cls.task_registry[normalized]
return cls.input_parameters_registry.definition_for_task(task)
@cached_class_property
def definitions(cls):
return _LazyInputParametersDefinitions(cls.input_parameters_registry)
@classmethod
def is_task_name(cls, name):
"""Return the normalized task name when *name* identifies a task."""
name = cls.task_registry.normalize_name(name)
return name if name in cls.task_registry else False
@classmethod
def for_definition(cls, name):
"""Create input parameters using a named input-parameter definition.
Unlike :meth:`for_task`, this also accepts shared schemas such
as BSF and user-defined presets.
"""
return cls.input_parameters_registry[name].create_object()
@classmethod
def for_task(cls, name):
"""Create input parameters for a registered SPR-KKR task."""
task = cls.task_registry[name]
return cls.input_parameters_registry.create_for_task(task)
@classmethod
def create(cls, arg):
"""Create or obtain input parameters from a task, schema, or file.
Strings naming both a task and a schema are resolved as tasks.
Unknown strings are treated as filenames. Existing input parameters
instances are returned unchanged.
"""
if isinstance(arg, str):
name = cls.task_registry.normalize_name(arg)
if name in cls.task_registry:
return cls.for_task(name)
if name in cls.input_parameters_registry:
return cls.for_definition(name)
if os.path.exists(arg):
return cls.from_file(arg)
if isinstance(arg, io.IOBase):
return cls.from_file(arg)
if isinstance(arg, cls):
return arg
raise ValueError(f"InputParameters can not be created from {arg}")
@classmethod
def default_parameters(cls):
return cls.for_task("SCF")
@classmethod
def from_file(cls, filename, allow_dangerous: bool = False, *,
allow_incomplete: bool = False, report_invalid=None):
"""Read with the IPD class-level selector autodetection."""
from .input_parameters_definitions import InputParametersDefinition
return InputParametersDefinition.from_file(
filename, allow_dangerous=allow_dangerous,
allow_incomplete=allow_incomplete, report_invalid=report_invalid,
)
def __repr__(self):
definition = self._definition
name = definition.display_name
out = f"{definition.configuration_type_name} for {name}"
task = self.task_name
if task is None:
return out + " (detached schema)"
if task != name:
out += f" (task: {task})"
return out
def change_task(self, task, retain_values=False):
if retain_values:
vals = self.to_dict(only_changed="explicit")
requested = self.task_registry.normalize_name(task)
task_definition = self.task_registry[requested]
self._definition = self.input_parameters_registry.definition_for_task(
task_definition
)
self._requested_task_name = requested
self._init_members_from_the_definition()
if retain_values:
self.set(
vals,
unknown="ignore",
retain_invalid="none",
report_invalid="ignore",
)
# Explicit TASK.TASK may select a different canonical schema.
# Preserve requested provenance while keeping the effective task
# and its input definition consistent.
effective = self.task_definition
if effective is not None:
canonical = self.input_parameters_registry.definition_for_task(effective)
if canonical is not self._definition:
values = self.to_dict(only_changed="explicit")
self._definition = canonical
self._init_members_from_the_definition()
self.set(
values,
unknown="ignore",
retain_invalid="none",
report_invalid="ignore",
)