feat: Refactor bandwidth and latency range definitions for improved...

    Values vary by ±1% between consecutive samples for temporal continuity.

    """

    connection_count : int             = field(default = 0)     # Current connection count

    link_capacity    : float           = field(default = 100.0) # Link capacity in Gbps

    prev_bw          : Optional[float] = field(default = None)  # Previous BW percentage

    prev_latency     : Optional[float] = field(default = None)  # Previous latency (ms)

    connection_count : int             = field(default = 0)

    link_capacity    : float           = field(default = 100.0)

    prev_bw          : Optional[float] = field(default = None)

    prev_latency     : Optional[float] = field(default = None)

    # Connection count to (avg, min, max) percentage mapping

    # Latency uses same ranges divided by 10 (0-10ms range)

    BW_RANGES = {

        0: (3,  1,  10),

        1: (25, 15, 30),

        2: (45, 35, 55),

        3: (65, 60, 80),

        4: (85, 80, 95),

        0: (3,  1,  10),    1: (25, 15, 30),    2: (45, 35, 55),    3: (65, 60, 80),    4: (85, 80, 95),

    }

    LAT_RANGES = {

        0: (0.5, 0.0, 1.0),

        1: (1.5, 1.0, 2.0),

        2: (2.5, 2.0, 3.0),

        3: (3.5, 3.0, 4.0),

        4: (4.5, 4.0, 5.0),

        0: (0.5, 0.0, 1.0), 1: (1.5, 1.0, 2.0), 2: (2.5, 2.0, 3.0), 3: (3.5, 3.0, 4.0), 4: (4.5, 4.0, 5.0),

    }

    @classmethod

            Tuple of (bandwidth_sample, latency_sample)

        """

        timestamp = datetime.now().timestamp()

        # Determine range based on connection count (cap at 4+)

        conn_key  = min(self.connection_count, 4)

        avg, min_bw, max_bw = self.BW_RANGES[conn_key]

        # Generate bandwidth percentage

        avg, min_bw, max_bw = self.BW_RANGES[conn_key]

        if self.prev_bw is None:

            # First sample: start at average for this connection count

            bw_utilization = avg

        else:

            # Add ±1% noise to previous value for temporal continuity

            noise_factor   = random.uniform(-0.01, 0.01)

            bw_utilization = self.prev_bw * (1.0 + noise_factor)

        # Clamp to current range (handles "jump" when connection count changes)

        bw_utilization = max(min_bw, min(max_bw, bw_utilization))

        self.prev_bw   = bw_utilization

        # Generate latency using same connection count key

        avg_lat, min_lat, max_lat = self.LAT_RANGES[conn_key]

        if self.prev_latency is None:

            # First sample: start at average for this connection count

            latency = avg_lat

        else:

            # Add ±5% noise to previous latency for temporal continuity

            noise_factor = random.uniform(-0.05, 0.05)

            noise_factor = random.uniform(-0.0, 0.0)

            latency      = self.prev_latency * (1.0 + noise_factor)

        # Clamp to current range (handles "jump" when connection count changes)

        latency           = max(min_lat, min(max_lat, latency))

        self.prev_latency = latency

        # Convert percentage to actual utilization (Gbps)

        actual_bw_utilization = (bw_utilization / 100.0) * self.link_capacity

        # actual_bw_utilization = (bw_utilization / 100.0) * self.link_capacity

        return (Sample(timestamp, 0, actual_bw_utilization), Sample(timestamp, 0, latency))

        return (Sample(timestamp, 0, bw_utilization), Sample(timestamp, 0, latency))

class SyntheticSamplers: