pyhs3.base.Evaluable

class pyhs3.base.Evaluable(**data)

Base class for HS3 distributions and functions with automatic parameter preprocessing.

This class provides automatic parameter processing that eliminates the need for manual @model_validator methods in subclasses. It automatically converts field values into parameter names and generates constants for numeric values.

The class automatically processes all field annotations during initialization:

• String fields (str) → Direct parameter mapping

• Numeric fields (float, int) → Generate unique constant names

• Union fields (str | float, int | str, etc.) → Runtime type detection

• List fields (list[str], list[str | float]) → Indexed parameter mapping

• Boolean fields (bool) → Automatically excluded from processing

• Excluded fields → Fields marked with json_schema_extra={"preprocess": False}

Examples

Basic usage with string and numeric parameters:

from typing import Literal

class MyDistribution(Evaluable):
    type: Literal["gaussian"] = "gaussian"
    mean: str | float  # Can be parameter name or numeric value
    sigma: str | float

# With parameter references
dist1 = MyDistribution(name="gauss1", mean="mu_param", sigma="sigma_param")
print(dist1.parameters)  # {'mu_param', 'sigma_param'}
print(dist1.constants)   # {}

# With numeric values - constants are generated automatically
dist2 = MyDistribution(name="gauss2", mean=1.5, sigma=0.5)
print(dist2.parameters)  # {'constant_gauss2_mean', 'constant_gauss2_sigma'}
print(list(dist2.constants.keys()))  # ['constant_gauss2_mean', 'constant_gauss2_sigma']

List parameter processing:

class ProductFunction(Evaluable):
    type: Literal["product"] = "product"
    factors: list[str | float]  # Mixed list of names and values

func = ProductFunction(name="prod", factors=["param1", 2.0, "param2", 1.5])
print(sorted(func.parameters))
# ['constant_prod_factors[1]', 'constant_prod_factors[3]', 'param1', 'param2']

# Reconstruct parameter list in context
context = {
    "param1": "tensor1",
    "constant_prod_factors[1]": "tensor2",
    "param2": "tensor3",
    "constant_prod_factors[3]": "tensor4"
}
func.get_parameter_list(context, "factors")  # ['tensor1', 'tensor2', 'tensor3', 'tensor4']

Excluding fields from preprocessing:

from pydantic import Field

class ConfigurableDistribution(Evaluable):
    type: Literal["configurable"] = "configurable"
    param: str | float                    # Will be processed
    enabled: bool                         # Automatically excluded
    config_val: float = Field(           # Explicitly excluded
        default=1.0,
        json_schema_extra={"preprocess": False}
    )

dist = ConfigurableDistribution(name="test", param="alpha", enabled=True, config_val=2.0)
print(dist.parameters)  # {'alpha'} - Only param is processed

Note

If you need custom parameter processing, set _parameters manually before the auto-processing runs, or provide a custom @model_validator.

Unsupported field types raise RuntimeError with helpful guidance about using json_schema_extra={"preprocess": False} for non-parameter fields.

name

Name of the component.

Type:

str

type

Type identifier for the component.

Type:

str

parameters

Set of parameter names this component depends on.

Type:

set[str]

constants

Generated PyTensor constants for numeric values.

Type:

dict[str, TensorVar]

Parameters:

data (Any)

__init__(**data)

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Parameters:

data (Any)

Methods

__init__(**data)	Create a new model by parsing and validating input data from keyword arguments.
construct([_fields_set])
copy(*[, include, exclude, update, deep])	Returns a copy of the model.
dict(*[, include, exclude, by_alias, ...])
expression(_)	Base expression method - should be overridden by subclasses.
from_orm(obj)
get_parameter_list(context, param_key)	Reconstruct a parameter list from flattened indexed keys.
json(*[, include, exclude, by_alias, ...])
model_construct([_fields_set])	Creates a new instance of the Model class with validated data.
model_copy(*[, update, deep])	!!! abstract "Usage Documentation"
model_dump(*[, mode, include, exclude, ...])	!!! abstract "Usage Documentation"
model_dump_json(*[, indent, include, ...])	!!! abstract "Usage Documentation"
model_json_schema([by_alias, ref_template, ...])	Generates a JSON schema for a model class.
model_parametrized_name(params)	Compute the class name for parametrizations of generic classes.
model_post_init(context, /)	This function is meant to behave like a BaseModel method to initialise private attributes.
model_rebuild(*[, force, raise_errors, ...])	Try to rebuild the pydantic-core schema for the model.
model_validate(obj, *[, strict, ...])	Validate a pydantic model instance.
model_validate_json(json_data, *[, strict, ...])	!!! abstract "Usage Documentation"
model_validate_strings(obj, *[, strict, ...])	Validate the given object with string data against the Pydantic model.
parse_file(path, *[, content_type, ...])
parse_obj(obj)
parse_raw(b, *[, content_type, encoding, ...])
process_parameter(param_key)	Process a single parameter that can be either a string reference or numeric value.
process_parameter_list(param_key)	Process a list parameter containing mixed string references and numeric values.
schema([by_alias, ref_template])
schema_json(*[, by_alias, ref_template])
update_forward_refs(**localns)
validate(value)

Attributes

constants	Dictionary of PyTensor constants generated from numeric field values.
model_computed_fields
model_config	Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
model_extra	Get extra fields set during validation.
model_fields
model_fields_set	Returns the set of fields that have been explicitly set on this model instance.
parameters	Set of parameter names this component depends on.
name
type