예제 #1
0
class MemoryChart(QAbstractItemModel):
    def __init__(self, memType, parent=None):
        super(MemoryChart, self).__init__(parent)
        self._type = "virt" if memType == "virt" else "swap"

        # fetch initial memory data
        if self._type == "virt":
            memUsage = psutil.virtual_memory().percent
        else:
            memUsage = psutil.swap_memory().percent
        self._data = [memUsage] * 10

        self.timer = QTimer(self)
        self.timer.timeout.connect(self._refresh)
        self.timer.start(1000)

        self._refresh()

    def _refresh(self):
        if self._type == "virt":
            newMemUsage = psutil.virtual_memory().percent
        else:
            newMemUsage = psutil.swap_memory().percent

        self._data.pop(0)
        self._data.append(newMemUsage)

        self.dataChanged.emit(0, 0)
        print("Memory chart refresh called")

    def data(self, index, role=QtCore.Qt.DisplayRole):
        return self._data
예제 #2
0
class MemoryInfo(QAbstractItemModel):
    
    totalChanged = Signal(str)
    availableChanged = Signal(str)
    percentChanged = Signal(str)
    usedChanged = Signal(str)
    freeChanged = Signal(str)

    def __init__(self, memType, parent=None):
        super(MemoryInfo, self).__init__(parent)
        self._type = 'virt' if memType == 'virt' else 'swap'

        self._total = None
        self._available = None
        self._percent = None
        self._used = None
        self._free = None

        self._firstRun = True

        self.timer = QTimer(self)
        self.timer.timeout.connect(self._refresh)
        self.timer.start(1000)

    def _refresh(self):
        if self._type == 'virt':
            memUsage = psutil.virtual_memory()
        else:
            memUsage = psutil.swap_memory()

        if self._total != humanize_bytes(memUsage.total, 2):
            self._total = humanize_bytes(memUsage.total, 2)
            self.totalChanged.emit(self._total)

        if self._type == 'virt':
            if self._available != humanize_bytes(memUsage.available, 2):
                self._available = humanize_bytes(memUsage.available, 2)
                self.availableChanged.emit(self._available)

        if self._percent != str(memUsage.percent) + '%':
            self._percent = str(memUsage.percent) + '%'
            self.percentChanged.emit(self._percent)

        if self._used != humanize_bytes(memUsage.used, 2):
            self._used = humanize_bytes(memUsage.used, 2)
            self.usedChanged.emit(self._used)

        if self._free != humanize_bytes(memUsage.free, 2):
            self._free = humanize_bytes(memUsage.free, 2)
            self.freeChanged.emit(self._free)

    def getCounters(self, *args):
        return {
            'total': self._total,
            'available': self._available,
            'percent': self._percent,
            'used': self._used,
            'free': self._free}
예제 #3
0
    def __init__(self, parent=None):
        super(Process, self).__init__(parent)

        self._refresh()

        self.timer = QTimer(self)
        self.timer.timeout.connect(self._refresh)
        self.timer.start(3000)
예제 #4
0
class CpuChart(QAbstractItemModel):
    """
    Model class for monitoring CPU usage

    Can be used as a data source for app.chart view.
    Stores CPU usage values for the last 10 seconds
    and updates CPU info every second
    """
    def __init__(self, cpuNum, parent=None):
        super(CpuChart, self).__init__(parent)

        self._cpuNum = cpuNum
        cpuUsage = psutil.cpu_percent(interval=None, percpu=True)[self._cpuNum]

        self._data = [cpuUsage] * 10

        # update CPU usage values every second
        self.timer = QTimer(self)
        self.timer.timeout.connect(self._refresh)
        self.timer.start(1000)

        self._refresh()

    def _refresh(self):
        """
        Get CPU usage values and emit dataChanged signal

        Protected method
        """
        cpuUsage = psutil.cpu_percent(interval=None, percpu=True)[self._cpuNum]        

        if self._cpuNum == 1:
            print cpuUsage
        self._data.pop(0)
        self._data.append(cpuUsage)

        self.dataChanged.emit(0, 0)

    def data(self, index=None, role=QtCore.Qt.DisplayRole):
        """
        Return list of CPU usage values
        """
        return self._data
예제 #5
0
    def __init__(self, cpuNum, parent=None):
        super(CpuChart, self).__init__(parent)

        self._cpuNum = cpuNum
        cpuUsage = psutil.cpu_percent(interval=None, percpu=True)[self._cpuNum]

        self._data = [cpuUsage] * 10

        # update CPU usage values every second
        self.timer = QTimer(self)
        self.timer.timeout.connect(self._refresh)
        self.timer.start(1000)

        self._refresh()
예제 #6
0
    def __init__(self, memType, parent=None):
        super(MemoryInfo, self).__init__(parent)
        self._type = 'virt' if memType == 'virt' else 'swap'

        self._total = None
        self._available = None
        self._percent = None
        self._used = None
        self._free = None

        self._firstRun = True

        self.timer = QTimer(self)
        self.timer.timeout.connect(self._refresh)
        self.timer.start(1000)
예제 #7
0
    def __init__(self, memType, parent=None):
        super(MemoryChart, self).__init__(parent)
        self._type = "virt" if memType == "virt" else "swap"

        # fetch initial memory data
        if self._type == "virt":
            memUsage = psutil.virtual_memory().percent
        else:
            memUsage = psutil.swap_memory().percent
        self._data = [memUsage] * 10

        self.timer = QTimer(self)
        self.timer.timeout.connect(self._refresh)
        self.timer.start(1000)

        self._refresh()
예제 #8
0
    def __init__(self, iface, refreshRate = 1, parent=None):
        super(NetworkInfo, self).__init__(parent)

        self._iface = iface
        self._refreshRate = refreshRate

        self._bytesSent = None
        self._bytesReceived = None
        self._packetsSent = None
        self._packetsReceived = None

        self._bytesSentSpeed = None
        self._bytesReceivedSpeed = None
        self._packetsSentSpeed = None
        self._packetsReceivedSpeed = None

        self._firstRun = True

        self.timer = QTimer(self)
        self.timer.timeout.connect(self._refresh)
        self.timer.start(self._refreshRate * 1000)
예제 #9
0
class NetworkInfo(QAbstractItemModel):

    bytesSentChanged = Signal(str)
    bytesReceivedChanged = Signal(str)
    packetsSentChanged = Signal(str)
    packetsReceivedChanged = Signal(str)

    bytesSentSpeedChanged = Signal(str)
    bytesReceivedSpeedChanged = Signal(str)
    packetsSentSpeedChanged = Signal(str)
    packetsReceivedSpeedChanged = Signal(str)

    def __init__(self, iface, refreshRate = 1, parent=None):
        super(NetworkInfo, self).__init__(parent)

        self._iface = iface
        self._refreshRate = refreshRate

        self._bytesSent = None
        self._bytesReceived = None
        self._packetsSent = None
        self._packetsReceived = None

        self._bytesSentSpeed = None
        self._bytesReceivedSpeed = None
        self._packetsSentSpeed = None
        self._packetsReceivedSpeed = None

        self._firstRun = True

        self.timer = QTimer(self)
        self.timer.timeout.connect(self._refresh)
        self.timer.start(self._refreshRate * 1000)

    def _refresh(self):
        if self._iface != 'total':
            netinfo = psutil.network_io_counters(pernic=True)[self._iface]
        else:
            netinfo = psutil.network_io_counters()    
        
        
        if self._firstRun:
            self._bytesSentSpeed = '0 bytes/s'
            self._bytesReceivedSpeed = '0 bytes/s'
            self._packetsSentSpeed = '0 packets/s'
            self._packetsReceivedSpeed = '0 packets/s'

            self.bytesSentSpeedChanged.emit(self._bytesSentSpeed)
            self.bytesReceivedSpeedChanged.emit(self._bytesReceivedSpeed)
            self.packetsSentSpeedChanged.emit(self._packetsSentSpeed)
            self.packetsReceivedSpeedChanged.emit(self._packetsReceivedSpeed)

            self._bytesSent = netinfo.bytes_sent
            self._bytesReceived = netinfo.bytes_recv
            self._packetsSent = netinfo.packets_sent
            self._packetsReceived = netinfo.packets_recv

            self.bytesSentChanged.emit(humanize_bytes(self._bytesSent, 2))
            self.bytesReceivedChanged.emit(humanize_bytes(self._bytesReceived, 2))
            self.packetsSentChanged.emit(str(self._packetsSent))
            self.packetsReceivedChanged.emit(str(self._packetsReceived))

            self._firstRun = False

        else:
            # calculate data transmision speeds per minute
            speed = humanize_bytes((netinfo.bytes_sent - self._bytesSent) / self._refreshRate, 2) + '/s'
            if speed != self._bytesSentSpeed:
                self._bytesSentSpeed = speed
                self.bytesSentSpeedChanged.emit(self._bytesSentSpeed)

            speed = humanize_bytes((netinfo.bytes_recv - self._bytesReceived) / self._refreshRate, 2) + '/s'
            if speed != self._bytesReceivedSpeed:
                self._bytesReceivedSpeed = speed
                self.bytesReceivedSpeedChanged.emit(self._bytesReceivedSpeed)

            speed = str(netinfo.packets_sent - self._packetsSent) + ' packets/s'
            if speed != self._packetsSentSpeed:
                self._packetsSentSpeed = speed
                self.packetsSentSpeedChanged.emit(self._packetsSentSpeed)

            speed = str(netinfo.packets_recv - self._packetsReceived) + ' packets/s'
            if speed != self._packetsReceivedSpeed:
                self._packetsReceivedSpeed = speed
                self.packetsReceivedSpeedChanged.emit(self._packetsReceivedSpeed)


            # calculate total data transfered
            if (netinfo.bytes_sent != self._bytesSent):
                self._bytesSent = netinfo.bytes_sent
                #print(self._iface + ': Bytes sent: ' + str(self._bytesSent))
                self.bytesSentChanged.emit(humanize_bytes(self._bytesSent, 2))

            if (netinfo.bytes_recv != self._bytesReceived):
                self._bytesReceived = netinfo.bytes_recv
                #print(self._iface + ': Bytes received' + str(self._bytesReceived))
                self.bytesReceivedChanged.emit(humanize_bytes(self._bytesReceived, 2))

            if (netinfo.packets_sent != self._packetsSent):
                self._packetsSent = netinfo.packets_sent
                self.packetsSentChanged.emit(str(self._packetsSent))

            if (netinfo.packets_recv != self._packetsReceived):
                self._packetsReceived = netinfo.packets_recv
                self.packetsReceivedChanged.emit(str(self._packetsReceived))
예제 #10
0
class Process(QAbstractTableModel):
    def __init__(self, parent=None):
        super(Process, self).__init__(parent)

        self._refresh()

        self.timer = QTimer(self)
        self.timer.timeout.connect(self._refresh)
        self.timer.start(3000)

    def _refresh(self):
        self._data = []

        for p in psutil.process_iter():
            mem = p.get_memory_info()

            self._data.append([
                p.pid,
                p.name,
                p.username,
                str(p.status),
                humanize_bytes(mem.vms),
                humanize_bytes(mem.rss),
                str(round(p.get_memory_percent(), 2)) + "%",
                str(p.get_cpu_percent(interval=None)) + "%"
            ])

        self._data = sorted(self._data, key=lambda p: float(p[-1][:-1]), reverse=True)
        #self.reset()
        self.dataChanged.emit(self.index(0, 0), self.index(self.rowCount() - 1, self.columnCount() - 1))

    def rowCount(self, parent=QtCore.QModelIndex()):
        return len(self._data)

    def columnCount(self, parent=QtCore.QModelIndex()):
        return len(self._data[0])

    def data(self, index, role=QtCore.Qt.DisplayRole):
        if role != QtCore.Qt.DisplayRole:
            return None

        row = index.row()
        column = index.column()

        return self._data[row][column]

    def headerData(self, section, orientation = None, role=QtCore.Qt.DisplayRole):
        if role != QtCore.Qt.DisplayRole:
            return None

        if section == 0:
            return 'Id'
        elif section == 1:
            return 'Name'
        elif section == 2:
            return 'Owner'
        elif section == 3:
            return 'Status'
        elif section == 4:
            return 'Memory (virtual)'
        elif section == 5:
            return 'Memory (resident)'
        elif section == 6:
            return 'Memory usage'
        elif section == 7:
            return 'CPU usage'

        print section

    def allData(self):
        return self._data