Add lazy evaluation support for non-incremental feature observers

[Pabloo22]

Some feature observers don't implement the update() method. For these observers, it would be highly beneficial if they only compute the initialize_features() method once the user calls it.

Observers that would benefit from lazy evaluation are:

• CompositeFeatureObserver
• IsCompletedObserver
• IsReadyObserver

Implementation suggestion:

For lazy evaluation, these observers could:

1. Mark features as "dirty" when update() is called
2. Only recompute features in initialize_features() when they're accessed and marked as dirty
3. Clear the dirty flag after recomputation

This probably should be the FeatureObserver default behavior, since it already implements the update() method as simply calling initialize_features(). In other words, we should change this class instead of the mentioned ones directly. For IsCompletedObserver we should remove the unnecessary definition of its update() method.

Tasks

• Implement lazy evaluation in FeatureObserver class
• Remove IsCompletedObserver'supdate() method

[notchickrees]

Hey there @Pabloo22,

I just came across this project and I am very interested in contributing. I do understand the essense of what your project does for now. I am very new to doing open source contributions. I am having a bit of difficulty understanding this issue. If you could somehow help me out and walk me through it I might be able to solve it I am sure. TIA.

[Pabloo22]

Hi,

Thanks for your interest in contributing! I just realized that the class we need to change is the FeatureObserver class, not the DispatcherObserver, sorry. I'm editing my original comment. Here is an expanded explanation:

The problem is in the base FeatureObserver class. Currently:

def update(self, scheduled_operation: ScheduledOperation):
    """Updates the features based on the scheduled operation.
    By default, this method just calls :meth:`initialize_features`.
    """
    self.initialize_features()

Every time update() is called, it immediately recalculates all features. This is inefficient when multiple updates happen before anyone actually needs the feature data.

The Solution

Implement lazy evaluation by:

1. In FeatureObserver.__init__: Add an attribute (self._features_dirty = False). I think it can be a private attribute because it's an internal implementation detail for managing when to recalculate features. Users of the class shouldn't need to access it directly; they should simply access the features and let lazy evaluation occur transparently.
2. In FeatureObserver.update(): Just mark features as dirty instead of recalculating
3. Add a property: Check dirty flag and recalculate only when needed. The features attribute is currently a direct dictionary, so we'd need to make it a property (using @property decorator) that checks the dirty flag. We must also add a setter decorator to keep backward compatibility.
4. In IsCompletedObserver: Remove the redundant update() method since it just calls initialize_features() anyway

Key files to modify:

• _feature_observer.py (main implementation)
• _is_completed_observer.py (remove unnecessary update() method)

Does this help clarify what needs to be done technically? You should also see CONTRIBUTING.md for setting up the environment and for additional context.

[Pabloo22]

Hi @notchickrees, are you still working on this issue?