component implementation

[maxjeblick]

Hi, I'm wondering why component is implemented as a decorator + metaclass rather than using a Component base class that defines __canals_input__ and __canals_output__ as a property, (+ potentially has additional methods) explicitly?
Any insights appreciated!

[vblagoje]

@silvanocerza please help

[silvanocerza]

We didn't want to use inheritance too much in Haystack 2.x to avoid creating a huge inheritance tree like we had in Haystack 1.x.

There are some benefits that make the code easier to understand too.
As of now @component doesn't take any arguments but in the future it will, so we write something like this.

@component(greedy=True)
class MyComponent:
    ...

This makes it clear right away that is something related to the Haystack logic of the Component and/or Pipeline. Using inheritance you'd have to set that either in the class definition or in __init__, that might not made it clear to maintainers what is it about.

Same thing can be said for the @component.input_types() decorator and component.set_input_types() and component.set_output_types() functions. With a inheritance approach we could have gone with self.set_input_types() and self.set_output_types() instead. That would have meant ditching the decorator to set input types though as @self.input_types() is not valid code in the body of class.

Also the code to create a Component looks cleaner and much more elegant in my opinion.

In any case we debated quite a bit on the benefit of one or the other and decided to settle on this approach. At certain points we almost switched to inheritance. Just to show how it wasn't a decision made on overwhelming benefits from one side. Inheritance still has some benefits.

[maxjeblick]

Thanks a lot for the detailed answer! The first point (being able to add arguments to component) is certainly an advantage.