Get upload/download kbps speed

Question

I'm using the library called psutil to get system/network stats, but I can only get the total uploaded/downloaded bytes on my script.

What would be the way to natively get the network speed using Python?

Answer 1

The answer provided by Steinar Lima is correct. But it can be done without threading also:

import time
import psutil
import os

count = 0
qry = ""

ul = 0.00
dl = 0.00
t0 = time.time()
upload = psutil.net_io_counters(pernic=True)["Wireless Network Connection"][0]
download = psutil.net_io_counters(pernic=True)["Wireless Network Connection"][1]
up_down = (upload, download)


while True:
    last_up_down = up_down
    upload = psutil.net_io_counters(pernic=True)["Wireless Network Connection"][0]
    download = psutil.net_io_counters(pernic=True)["Wireless Network Connection"][1]
    t1 = time.time()
    up_down = (upload, download)
    try:
        ul, dl = [
            (now - last) / (t1 - t0) / 1024.0
            for now, last in zip(up_down, last_up_down)
        ]
        t0 = time.time()
    except:
        pass
    if dl > 0.1 or ul >= 0.1:
        time.sleep(0.75)
        os.system("cls")
        print("UL: {:0.2f} kB/s \n".format(ul) + "DL: {:0.2f} kB/s".format(dl))

v = input()

Simple and easy ;)

Answer 2

I added an LCD mod for this code if you want to test it on a raspberry pi but you need to add the psutil and the lcddriver to your project code!!!!

import time
import psutil
import os
import lcddriver

count=0
qry=''

ul=0.00
dl=0.00
t0 = time.time()
upload=psutil.net_io_counters(pernic=True)['wlan0'][0]
download=psutil.net_io_counters(pernic=True)['wlan0'][1]
up_down=(upload,download)
display = lcddriver.lcd()

while True:
    last_up_down = up_down
    upload=psutil.net_io_counters(pernic=True)['wlan0'][0]
    download=psutil.net_io_counters(pernic=True)['wlan0'][1]
    t1 = time.time()
    up_down = (upload,download)
    try:
        ul, dl = [(now - last) / (t1 - t0) / 1024.0
                 for now,last in zip(up_down, last_up_down)]             
        t0 = time.time()
        #display.lcd_display_string(str(datetime.datetime.now().time()), 1)
    except:
        pass
        
    if dl>0.1 or ul>=0.1:
       time.sleep(0.75) 
       os.system('cls')
       print('UL: {:0.2f} kB/s \n'.format(ul)+'DL:{:0.2f} kB/s'.format(dl))
       display.lcd_display_string(str('DL:{:0.2f} KB/s      '.format(dl)), 1)
       display.lcd_display_string(str('UL:{:0.2f} KB/s      '.format(ul)), 2)
       
    # if KeyboardInterrupt: # If there is a KeyboardInterrupt (when you press ctrl+c), exit the program and cleanup
    #     print("Cleaning up!")
    #     display.lcd_clear()   
    
v=input()

Answer 3

The (effective) network speed is simply bytes transferred in a given time interval, divided by the length of the interval. Obviously there are different ways to aggregate / average the times and they give you different "measures" ... but it all basically boils down to division.

Answer 4

If you need to know the transfer rate immediately, you should create a thread that does the calculations continuously. I'm not an expert on the subject, but I tried writing a simple program that does what you need:

import threading
import time
from collections import deque

import psutil


def calc_ul_dl(rate, dt=3, interface="WiFi"):
    t0 = time.time()
    counter = psutil.net_io_counters(pernic=True)[interface]
    tot = (counter.bytes_sent, counter.bytes_recv)

    while True:
        last_tot = tot
        time.sleep(dt)
        counter = psutil.net_io_counters(pernic=True)[interface]
        t1 = time.time()
        tot = (counter.bytes_sent, counter.bytes_recv)
        ul, dl = [
            (now - last) / (t1 - t0) / 1000.0
            for now, last in zip(tot, last_tot)
        ]
        rate.append((ul, dl))
        t0 = time.time()


def print_rate(rate):
    try:
        print("UL: {0:.0f} kB/s / DL: {1:.0f} kB/s".format(*rate[-1]))
    except IndexError:
        "UL: - kB/s/ DL: - kB/s"


# Create the ul/dl thread and a deque of length 1 to hold the ul/dl- values
transfer_rate = deque(maxlen=1)
t = threading.Thread(target=calc_ul_dl, args=(transfer_rate,))

# The program will exit if there are only daemonic threads left.
t.daemon = True
t.start()

# The rest of your program, emulated by me using a while True loop
while True:
    print_rate(transfer_rate)
    time.sleep(5)

Here you should set the dt argument to whatever seams reasonable for you. I tried using 3 seconds, and this is my output while runnning an online speedtest:

UL: 2 kB/s / DL: 8 kB/s
UL: 3 kB/s / DL: 45 kB/s
UL: 24 kB/s / DL: 1306 kB/s
UL: 79 kB/s / DL: 4 kB/s
UL: 121 kB/s / DL: 3 kB/s
UL: 116 kB/s / DL: 4 kB/s
UL: 0 kB/s / DL: 0 kB/s

The values seems reasonable since my result from the speedtest were DL: 1258 kB/s and UL: 111 kB/s.