import time
import random
import threading
import queue

class MetricStream:
    def __init__(self, metrics, interval=1):
        self.metrics = metrics  # Dictionary of metric names and their initial values
        self.interval = interval  # Time between metric updates in seconds
        self.running = False
        self.data_queue = queue.Queue()
        self.thread = None

    def start(self):
        self.running = True
        self.thread = threading.Thread(target=self._run)
        self.thread.daemon = True  # Allow main thread to exit even if this is running
        self.thread.start()

    def stop(self):
        self.running = False
        if self.thread:
            self.thread.join()

    def _run(self):
        while self.running:
            data = {}
            for metric_name, initial_value in self.metrics.items():
                # Simulate metric changes (replace with actual data source)
                change = random.uniform(-0.5, 0.5)  # Small random change
                new_value = initial_value + change
                data[metric_name] = new_value
                self.metrics[metric_name] = new_value #update for next iteration

            self.data_queue.put(data)
            time.sleep(self.interval)

    def get_data(self):
        try:
            return self.data_queue.get(timeout=0.1)  # Non-blocking get
        except queue.Empty:
            return None


if __name__ == '__main__':
    # Example usage
    metrics = {
        'cpu_usage': 50.0,
        'memory_usage': 70.0,
        'network_latency': 0.1
    }

    stream = MetricStream(metrics, interval=0.5)
    stream.start()

    try:
        for _ in range(10):
            data = stream.get_data()
            if data:
                print(f"Received data: {data}")
            else:
                print("No data received.")
            time.sleep(0.2)
    except KeyboardInterrupt:
        print("Stopping the stream...")
    finally:
        stream.stop()
        print("Stream stopped.")