def consider_callable(value):
if callable(value) and value.__class__ in (types.MethodType,
types.FunctionType):
if value.__class__ == types.MethodType and _findclass(
value) is not None:
return with_signature(value,
value.__name__,
obj_module=_findclass(value))
return with_signature(value, value.__name__)
return value
def make_prior(self, attribute_name):
"""
Returns a prior for an attribute of a class with a given name. The prior is
created by searching the default prior config for the attribute.
Entries in configuration with a u become uniform priors; with a g become
gaussian priors; with a c become instances.
If prior configuration for a given attribute is not specified in the
configuration for a class then the configuration corresponding to the parents
of that class is searched. If no configuration can be found then a prior
exception is raised.
Parameters
----------
attribute_name: str
The name of the attribute for which a prior is created
Returns
-------
prior: p.Prior
A prior
Raises
------
exc.PriorException
If no configuration can be found
"""
cls = self.cls
if not inspect.isclass(cls):
# noinspection PyProtectedMember
cls = inspect._findclass(cls)
return Prior.for_class_and_attribute_name(cls, attribute_name)
def _instance_for_arguments(self, arguments: {ModelObject: object}):
"""
Returns an instance of the associated class for a set of arguments
Parameters
----------
arguments: {Prior: float}
Dictionary mapping_matrix priors to attribute analysis_path and value pairs
Returns
-------
An instance of the class
"""
model_arguments = dict()
attribute_arguments = {
key: value
for key, value in self.__dict__.items()
if key in self.constructor_argument_names
}
for tuple_prior in self.tuple_prior_tuples:
model_arguments[
tuple_prior.name] = tuple_prior.prior.value_for_arguments(
arguments)
for prior_model_tuple in self.direct_prior_model_tuples:
prior_model = prior_model_tuple.prior_model
model_arguments[
prior_model_tuple.name] = prior_model.instance_for_arguments(
arguments)
prior_arguments = dict()
for name, prior in self.direct_prior_tuples:
try:
prior_arguments[name] = arguments[prior]
except KeyError as e:
raise KeyError(f"No argument given for prior {name}") from e
constructor_arguments = {
**attribute_arguments,
**model_arguments,
**prior_arguments,
}
if self.is_deferred_arguments:
return DeferredInstance(self.cls, constructor_arguments)
if not inspect.isclass(self.cls):
result = object.__new__(inspect._findclass(self.cls))
cls = self.cls
cls(result, **constructor_arguments)
else:
result = self.cls(**constructor_arguments)
for key, value in self.__dict__.items():
if (not hasattr(result, key) and not isinstance(value, Prior)
and not key == "cls"):
if isinstance(value, PriorModel):
value = value.instance_for_arguments(arguments)
elif isinstance(value, Prior):
value = arguments[value]
try:
setattr(result, key, value)
except AttributeError:
pass
return result