| | |
| | |
| | |
| |
|
| | import builtins |
| | import sys |
| | from importlib import import_module |
| | from typing import Any, Callable, Dict, Optional |
| |
|
| | from haystack.core.component import component |
| | from haystack.core.errors import ComponentDeserializationError |
| | from haystack.core.serialization import default_to_dict |
| |
|
| |
|
| | def _default_function(first: int, second: int) -> int: |
| | return first + second |
| |
|
| |
|
| | @component |
| | class Accumulate: |
| | """ |
| | Accumulates the value flowing through the connection into an internal attribute. |
| | |
| | The sum function can be customized. Example of how to deal with serialization when some of the parameters |
| | are not directly serializable. |
| | """ |
| |
|
| | def __init__(self, function: Optional[Callable] = None): |
| | """ |
| | Class constructor |
| | |
| | :param function: |
| | the function to use to accumulate the values. |
| | The function must take exactly two values. |
| | If it's a callable, it's used as it is. |
| | If it's a string, the component will look for it in sys.modules and |
| | import it at need. This is also a parameter. |
| | """ |
| | self.state = 0 |
| | self.function: Callable = _default_function if function is None else function |
| |
|
| | def to_dict(self) -> Dict[str, Any]: |
| | """Converts the component to a dictionary""" |
| | module = sys.modules.get(self.function.__module__) |
| | if not module: |
| | raise ValueError("Could not locate the import module.") |
| | if module == builtins: |
| | function_name = self.function.__name__ |
| | else: |
| | function_name = f"{module.__name__}.{self.function.__name__}" |
| |
|
| | return default_to_dict(self, function=function_name) |
| |
|
| | @classmethod |
| | def from_dict(cls, data: Dict[str, Any]) -> "Accumulate": |
| | """Loads the component from a dictionary""" |
| | if "type" not in data: |
| | raise ComponentDeserializationError("Missing 'type' in component serialization data") |
| | if data["type"] != f"{cls.__module__}.{cls.__name__}": |
| | raise ComponentDeserializationError(f"Class '{data['type']}' can't be deserialized as '{cls.__name__}'") |
| |
|
| | init_params = data.get("init_parameters", {}) |
| |
|
| | accumulator_function = None |
| | if "function" in init_params: |
| | parts = init_params["function"].split(".") |
| | module_name = ".".join(parts[:-1]) |
| | function_name = parts[-1] |
| | module = import_module(module_name) |
| | accumulator_function = getattr(module, function_name) |
| |
|
| | return cls(function=accumulator_function) |
| |
|
| | @component.output_types(value=int) |
| | def run(self, value: int): |
| | """ |
| | Accumulates the value flowing through the connection into an internal attribute. |
| | |
| | The sum function can be customized. |
| | """ |
| | self.state = self.function(self.state, value) |
| | return {"value": self.state} |
| |
|
