feat: Enhance aggregation logic to reuse last valid data when no samples are available

import logging, threading

from dataclasses import dataclass, field

from datetime import datetime

from typing import Dict, Set, Tuple

from datetime import datetime, timezone

from typing import Dict, Optional, Set, Tuple

LOGGER = logging.getLogger(__name__)

    def __init__(self) -> None:

        self._lock = threading.Lock()

        self._samples : Dict[Tuple[str, str], LinkSample] = dict()

        self._last_valid_aggregation : Optional[AggregatedLinkSample] = None

    def update(self, link_sample : LinkSample) -> None:

                MSG = '[aggregate] Aggregating {:d} supporting link(s)'

                LOGGER.info(MSG.format(num_samples))

            agg = AggregatedLinkSample(timestamp=datetime.utcnow())

            if num_samples == 0:

                if self._last_valid_aggregation is not None:

                    MSG = '[aggregate] No samples available, reusing last valid aggregation: BW={:.2f}%, Latency={:.3f}ms'

                    LOGGER.warning(MSG.format(

                        self._last_valid_aggregation.bandwidth_utilization,

                        self._last_valid_aggregation.latency

                    ))

                    # Return a copy with updated timestamp

                    return AggregatedLinkSample(

                        timestamp=datetime.now(timezone.utc).isoformat(),

                        bandwidth_utilization=self._last_valid_aggregation.bandwidth_utilization,

                        latency=self._last_valid_aggregation.latency,

                        related_service_ids=self._last_valid_aggregation.related_service_ids.copy()

                    )

                else:

                    MSG = '[aggregate] No samples available and no cached data, returning zeros'

                    LOGGER.warning(MSG)

                    return AggregatedLinkSample(timestamp=datetime.now(timezone.utc).isoformat())

            agg = AggregatedLinkSample(timestamp=datetime.now(timezone.utc).isoformat())

            for link_key, sample in self._samples.items():

                network_id, link_id = link_key

                    agg.bandwidth_utilization, agg.latency,

                    str(agg.related_service_ids)

                ))

                # Cache this valid aggregation for future use

                self._last_valid_aggregation = agg

            return agg