Não consigo encontrar um utilitário adequado para indicar apenas o uso do sistema de arquivos (% de espaço livre para partições) no painel.

E não estou ansioso para instalar nenhum tipo ruim de ferramenta de gerenciamento de desktop, mas um simples indicador.

Agradeço todas as suas sugestões.

EDITAR:

1. NOVA RESPOSTA

Embora a resposta na parte inferior desta possa ser usada (consulte [2.]), ela leva a uma ppaversão com opções adicionais, a ser definida em uma janela de preferências.

As opções incluem:

• Definindo todos os aliases em uma janela

• Definindo cores do tema para o ícone do painel:

  

• Definindo limiar para avisos

• Mostrar informações sobre volumes recém-montados / conectados em uma notificação:

  

• Executar ao iniciar

Além disso, o indicador agora inclui um ícone menor (largura) definido para outras distros (como xfce), que serão aplicadas automaticamente, dependendo do gerenciador de janelas.

Para instalar:

sudo add-apt-repository ppa:vlijm/spaceview
sudo apt-get update
sudo apt-get install spaceview

2. RESPOSTA ANTIGA

O script abaixo é um indicador que lista seus dispositivos e mostra seu uso. As informações são atualizadas (se necessário) uma vez a cada dez segundos.

além disso

• Enquanto o indicador estiver em execução, você pode escolher um dispositivo a ser representado no ícone. O dispositivo será lembrado na próxima vez que você executar o indicador:

  

  

  

• Para um ou mais (ou todos) dispositivos, você pode definir um nome alternativo ("nome personalizado"), a ser definido no cabeçalho do script

  Como um exemplo, isto:

  alias = [
      ["sdc1", "stick"],
      ["sdb1", "External"],
      ["sda2", "root"],
      ["sda4", "ntfs1"],
      ["sda5", "ntfs2"],
      ["//192.168.0.104/media", "netwerk media"],
      ["//192.168.0.104/werkmap_documenten", "netwerk docs"],
      ]
  

  Mostrará:

  

• Você pode definir um limiar ; se o espaço livre de qualquer um dos seus dispositivos estiver abaixo desse valor, você receberá um aviso:

  

• Os dispositivos conectados / desconectados serão adicionados / removidos do menulista dentro de 10 segundos.

O script

#!/usr/bin/env python3
import subprocess
import os
import time
import signal
import gi
gi.require_version('Gtk', '3.0')
gi.require_version('AppIndicator3', '0.1')
from gi.repository import Gtk, AppIndicator3, GObject
from threading import Thread

#--- set alias names below in the format [[device1, alias1], [device2, alias2]]
#--- just set alias = [] to have no custom naming
alias = []
#--- set the threshold to show a warning below 
#--- set to 0 to have no warning
threshold = 17
#---
currpath = os.path.dirname(os.path.realpath(__file__))
prefsfile = os.path.join(currpath, "showpreferred")

class ShowDevs():
    def __init__(self):
        self.default_dev = self.get_showfromfile()
        self.app = 'show_dev'
        iconpath = currpath+"/0.png"
        self.indicator = AppIndicator3.Indicator.new(
            self.app, iconpath,
            AppIndicator3.IndicatorCategory.OTHER)
        self.indicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE)       
        self.indicator.set_menu(self.create_menu())
        self.indicator.set_label("Starting up...", self.app)
        self.update = Thread(target=self.check_changes)
        self.update.setDaemon(True)
        self.update.start()

    def check_changes(self):
        state1 = None
        while True:
            self.state2 = self.read_devices()
            if self.state2 != state1:
                self.update_interface(self.state2)
            state1 = self.state2
            time.sleep(10)

    def update_interface(self, state):
        warning = False; self.newmenu = []
        for dev in state:
            mention = self.create_mention(dev)
            name = mention[0]; deci = mention[2]; n = mention[1]
            if n <= threshold:
                warning = True
            try:
                if self.default_dev in name:
                    newlabel = mention[3]
                    newicon = currpath+"/"+str(10-deci)+".png"
            except TypeError:
                pass
            self.newmenu.append(name+" "+str(n)+"% free")
        if warning:
            newlabel = "Check your disks!"
            newicon = currpath+"/10.png"
        try:
            self.update_indicator(newlabel, newicon)
        except UnboundLocalError:
            labeldata = self.create_mention(state[0])
            newlabel = labeldata[3]
            newicon = currpath+"/"+str(10-labeldata[2])+".png"
            self.update_indicator(newlabel, newicon)
        GObject.idle_add(self.set_new, 
            priority=GObject.PRIORITY_DEFAULT)  

    def update_indicator(self, newlabel, newicon):
        GObject.idle_add(self.indicator.set_label,
            newlabel, self.app,
            priority=GObject.PRIORITY_DEFAULT)   
        GObject.idle_add(self.indicator.set_icon,
            newicon,
            priority=GObject.PRIORITY_DEFAULT)

    def set_new(self):
        for i in self.initmenu.get_children():
            self.initmenu.remove(i)
        for item in self.newmenu:
            add = Gtk.MenuItem(item)
            add.connect('activate', self.change_show)
            self.initmenu.append(add) 
        menu_sep = Gtk.SeparatorMenuItem()
        self.initmenu.append(menu_sep)
        self.item_quit = Gtk.MenuItem('Quit')
        self.item_quit.connect('activate', self.stop)
        self.initmenu.append(self.item_quit)
        self.initmenu.show_all()

    def change_show(self, *args):
        index = self.initmenu.get_children().index(self.initmenu.get_active())
        self.default_dev = self.newmenu[index].split()[0]
        open(prefsfile, "wt").write(self.default_dev)
        self.update_interface(self.read_devices())

    def create_mention(self, dev):
        name = dev[1] if dev[1] else dev[0]
        n = dev[2]; deci = round(dev[2]/10)
        newlabel = name+" "+str(n)+"% free"
        return (name, n, deci, newlabel)        

    def create_menu(self):
        # create initial basic menu
        self.initmenu = Gtk.Menu()
        self.item_quit = Gtk.MenuItem('Quit')
        self.item_quit.connect('activate', self.stop)
        self.initmenu.append(self.item_quit)
        self.initmenu.show_all()
        return self.initmenu

    def read_devices(self):
        # read the devices, look up their alias and the free sapace
        devdata = []
        data = subprocess.check_output(["df", "-h"]).decode("utf-8").splitlines()
        relevant = [l for l in data if all([
                    any([l.startswith("/dev/"), l.startswith("//")]),
                    not "/loop" in l])
                    ]
        for dev in relevant:
            data = dev.split(); name = data[0]; pseudo = None       
            free = 100-int([s.strip("%") for s in data if "%" in s][0])
            for al in alias:
                if al[0] in name:
                    pseudo = al[1]
                    break
            devdata.append((name, pseudo, free)) 
        return devdata

    def get_showfromfile(self):
        # read the preferred default device from file
        try:
            defdev = open(prefsfile).read().strip()
        except FileNotFoundError:
            defdev = None
        return defdev

    def stop(self, source):
        Gtk.main_quit()

ShowDevs()
GObject.threads_init()
signal.signal(signal.SIGINT, signal.SIG_DFL)
Gtk.main()

Os ícones

0.png

1.png

2.png

3.png

4.png

5.png

6.png

7.png

8.png

9.png

10.png

Configurando

A configuração é simples:

• Copie o script em um arquivo vazio, salve-o como showusage.py
• Salve os ícones acima, exatamente nomeados como em seus rótulos , no mesmo diretório do script (clique com o botão direito do mouse em> Salvar como)

• No cabeçalho do script, defina (possíveis) nomes alternativos ( aliasses). Abaixo um exemplo:

  alias = [
      ["sda2", "root"],
      ["sdb1", "External"]
      ]

  Se você deseja exibir os dispositivos inalterados, use:

  alias = []

  ... e se desejar, altere o limite para mostrar um aviso:

  #--- set the threshold to show a warning below (% free, in steps of 10%)
  #--- set to 0 to have no warning
  threshold = 10

  É isso aí

Executando

Para usar o indicador, execute o comando:

python3 /path/to/showusage.py

Para adicioná-lo aos aplicativos de inicialização, use o comando:

/bin/bash -c "sleep 10 && python3 /path/to/showusage.py"

Escolha Aplicativos: Dash> Startup Applications> Add, adicione o comando acima.

_{isenção de responsabilidade: sou autor deste indicador e está escrito para esta pergunta específica}

Atualização Oct 23,2018

O indicador agora suporta a listagem de compartilhamentos de rede . Graças a mihaigalos

Atualização 29 de outubro de 2016

O indicador agora tem funcionalidade de desmontagem e os aliases foram diferenciados ao se referir ao UUID de cada partição, em vez do nome do dispositivo do bloco, como sda1. Veja o relatório de bug relacionado

Atualização, 8 de outubro de 2016

O indicador está agora na versão 2.0, adicionou alguns recursos e possui seu próprio PPA.

Para instalar a partir do PPA, siga as seguintes etapas no terminal:

1. sudo apt-add-repository ppa:udisks-indicator-team/ppa
2. sudo bash -c 'apt-get update && apt-get install udisks-indicator'

Conforme mencionado nas notas de versão, os recursos incluem:

• Ícones para entradas do menu: cada partição / dispositivo possui um ícone apropriado anexado. Se o dispositivo for um disco USB, é usado o ícone de mídia removível, se for uma imagem iso - o ícone do disco óptico é usado e, obviamente, as partições do disco rígido / SSD têm ícones de unidade.
• O uso agora é mostrado em porcentagem e valores legíveis por humanos (potências de 1024).
• Representação gráfica do uso via barra de uso (muito obrigado a Mateo Salta pela ideia)
• Caixa de diálogo Preferências: os usuários podem desativar determinados campos que não desejam ver em cada entrada do menu. Isso permite manter o menu do indicador limpo se houver uma grande quantidade de partições conectadas. (Graças ao pedido de Zacharee)
• Espaçamento de texto: com a fonte Ubuntu padrão e as fontes Monospace, as entradas de texto são bem espaçadas para ter uma aparência mais limpa e melhorar a legibilidade das informações.
• Bolhas de notificação caso a partição não possa ser montada

Abaixo está a captura de tela com o tema padrão do ícone Ubuntu:

Tema de ícone do Ubuntu Kylin

Com todos os campos opcionais desativados

Opções de design e pensamentos adicionais:

Na elaboração desse indicador, esperava obter um utilitário adequado para usuários avançados e casuais. Tentei resolver alguns dos problemas que percebi que os novos usuários podem ter ao lidar com ferramentas de linha de comando. Além disso, o utilitário procura ser multiuso.

A caixa de diálogo Preferências permite tornar o indicador tão complexo e / ou simples quanto o usuário desejar. Também foi uma decisão de design específica evitar rótulos no painel superior para não ocupar muito espaço no painel superior do usuário. Além disso, este indicador se esforça para ser um utilitário multiuso que permite montar partições e abrir seus respectivos diretórios. Isso pode ser usado não apenas como utilitário de uso do disco, mas também como utilitário de navegação para abrir rapidamente os diretórios.

Também é conveniente para os usuários saberem qual partição habita em qual disco, evitando assim confusão frequente com a montagem por meio de utilitários de linha de comando como mount. Em vez disso, emprega udisksctlpara esse fim (além de obter as informações do UDisks2daemon, daí a nomeação). A única tarefa que ele não executa é desmontar e / ou é por isso que a Open Disks Utilityentrada do menu está incluída.

Embora originalmente eu tenha me esforçado para torná-lo semelhante ao menulet iStat, o projeto divergiu desse objetivo - o indicador é único em seu design e propósito. Espero que seja útil para muitos usuários e torne a experiência do Ubuntu muito mais agradável.

indicador de udiscos (resposta original)

Indicador para o Ubuntu com área de trabalho do Unity para mostrar o uso do disco

Visão geral

Este indicador para o Ubuntu com Unity permite visualizar facilmente informações sobre suas partições montadas. Ele se esforça para ser visualmente semelhante ao menu iStat Menu 3 do OS X.

As entradas são organizadas em ordem:

• Partição
• Alias ​​(se definido pelo usuário)
• Unidade de disco à qual a partição pertence
• Ponto de montagem da partição (diretório)
• % De uso

Clicar em cada entrada da partição abrirá o ponto de montagem da partição no gerenciador de arquivos padrão

O menu "Partições desmontadas" lista todas as partições atualmente não montadas pelo sistema. Ao clicar em qualquer entrada desse submenu, a partição será montada automaticamente, normalmente na /media/username/drive-idpasta

O indicador usa ícones padrão fornecidos com o sistema; portanto, o ícone deve mudar conforme você altera o tema do ícone usando a Unity Tweak Tool ou outros métodos

NOTA : se você deseja adicionar vários aliases ao mesmo tempo, em vez de um por um através da opção "Criar alias", pode fazê-lo editando o ~/.partition_aliases.jsonarquivo de configuração. O formato é o seguinte:

{
    "sda1": "Alias 1",
    "sda2": "Alias 2",
    "sdb1": "Alias 3"
}

Instalação

O PPA para facilitar a instalação está disponível em breve. . .

Enquanto isso, aqui estão as etapas alternativas:

1. cd /tmp
2. wget https://github.com/SergKolo/udisks-indicator/archive/master.zip
3. unzip master.zip
4. sudo install udisks-indicator-master/udisks-indicator /usr/bin/udisks-indicator
5. sudo install udisks-indicator-master/udisks-indicator.desktop /usr/share/applications/udisks-indicator.desktop

Todas estas etapas podem ser colocadas em um pequeno e agradável script de instalação:

#!/bin/bash

cd /tmp
rm master.zip*
wget https://github.com/SergKolo/udisks-indicator/archive/master.zip
unzip master.zip
install udisks-indicator-master/udisks-indicator /usr/bin/udisks-indicator
install udisks-indicator-master/udisks-indicator.desktop /usr/share/applications/udisks-indicator.desktop

Código fonte

O código fonte original (versão v1.0) com a funcionalidade básica deste indicador pode ser encontrado abaixo. Para novos recursos, consulte o repositório GitHub para este projeto . Por favor, relate quaisquer solicitações de recursos, bem como erros no GitHub.

O /usr/bin/udisks-indicator:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

#
# Author: Serg Kolo , contact: [email protected]
# Date: September 27 , 2016
# Purpose: appindicator for displaying mounted filesystem usage
# Tested on: Ubuntu 16.04 LTS
#
#
# Licensed under The MIT License (MIT).
# See included LICENSE file or the notice below.
#
# Copyright © 2016 Sergiy Kolodyazhnyy
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import gi
gi.require_version('AppIndicator3', '0.1')
from gi.repository import GLib as glib
from gi.repository import AppIndicator3 as appindicator
from gi.repository import Gtk as gtk
from os import statvfs
#from collections import OrderedDict
import subprocess
import shutil
import dbus
import json
import os

class UdisksIndicator(object):

    def __init__(self):
        self.app = appindicator.Indicator.new(
            'udisks-indicator', "drive-harddisk-symbolic.svg",
            appindicator.IndicatorCategory.HARDWARE
            )

        if not self.app.get_icon():
           self.app.set_icon("drive-harddisk-symbolic")

        self.app.set_status(appindicator.IndicatorStatus.ACTIVE)

        filename = '.partition_aliases.json'
        user_home = os.path.expanduser('~')
        self.config_file = os.path.join(user_home,filename)
        self.cache = self.get_partitions()
        self.make_menu()
        self.update()


    def update(self):
        timeout = 5
        glib.timeout_add_seconds(timeout,self.callback)

    def callback(self):
        if self.cache != self.get_partitions():
            self.make_menu()
        self.update()        

    def make_menu(self,*args):
        """ generates entries in the indicator"""
        if hasattr(self, 'app_menu'):
            for item in self.app_menu.get_children():
                self.app_menu.remove(item)

        self.app_menu = gtk.Menu()

        partitions = self.get_partitions()
        for i in partitions:

            part = "Partition: " + i[0]
            alias = self.find_alias(i[0])
            drive = "\nDrive: " + i[1]
            mount = "\nMountPoint: " + i[2]
            usage = "\n%Usage: " + i[3]

            item = part + drive + mount + usage
            if alias:
                alias = "\nAlias: " + alias
                item = part + alias + drive + mount + usage

            self.menu_item = gtk.MenuItem(item)
            self.menu_item.connect('activate',self.open_mountpoint,i[2])
            self.app_menu.append(self.menu_item)
            self.menu_item.show()

            self.separator = gtk.SeparatorMenuItem()
            self.app_menu.append(self.separator)
            self.separator.show()

        self.unmounted = gtk.MenuItem('Unmounted Partitions')
        self.unmounted_submenu = gtk.Menu()
        self.unmounted.set_submenu(self.unmounted_submenu)

        for i in self.get_unmounted_partitions():

            # TODO: add type checking, prevent swap

            part = "Partition: " + i[0]
            alias = self.find_alias(i[0])
            drive = "\nDrive: " + i[1]
            label = part + drive
            if alias: 
               alias = "\nAlias: " + alias
               label = part + alias + drive

            self.menu_item = gtk.MenuItem(label)
            self.menu_item.connect('activate',self.mount_partition,i[0])
            self.unmounted_submenu.append(self.menu_item)
            self.menu_item.show()

            self.separator = gtk.SeparatorMenuItem()
            self.unmounted_submenu.append(self.separator)
            self.separator.show()

        self.app_menu.append(self.unmounted)
        self.unmounted.show()


        self.separator = gtk.SeparatorMenuItem()
        self.app_menu.append(self.separator)
        self.separator.show()

        self.make_part_alias = gtk.MenuItem('Make Alias')
        self.make_part_alias.connect('activate',self.make_alias)
        self.app_menu.append(self.make_part_alias)
        self.make_part_alias.show()

        user_home = os.path.expanduser('~')
        desktop_file = '.config/autostart/udisks-indicator.desktop'
        full_path = os.path.join(user_home,desktop_file)

        label = 'Start Automatically' 
        if os.path.exists(full_path):
           label = label + ' \u2714'
        self.autostart = gtk.MenuItem(label)
        self.autostart.connect('activate',self.toggle_auto_startup)
        self.app_menu.append(self.autostart)
        self.autostart.show()

        self.open_gnome_disks = gtk.MenuItem('Open Disks Utility')
        self.open_gnome_disks.connect('activate',self.open_disks_utility)
        self.app_menu.append(self.open_gnome_disks)
        self.open_gnome_disks.show()

        self.quit_app = gtk.MenuItem('Quit')
        self.quit_app.connect('activate', self.quit)
        self.app_menu.append(self.quit_app)
        self.quit_app.show()

        self.app.set_menu(self.app_menu)

    def mount_partition(self,*args):
        # TODO: implement error checking for mounting
        return self.run_cmd(['udisksctl','mount','-b','/dev/' + args[-1]])

    def get_mountpoint_usage(self,mountpoint):
        fs = statvfs(mountpoint)
        usage = 100*(float(fs.f_blocks)-float(fs.f_bfree))/float(fs.f_blocks)
        return str("{0:.2f}".format(usage))

    def get_partitions(self):
        objects = self.get_dbus('system', 
                           'org.freedesktop.UDisks2', 
                           '/org/freedesktop/UDisks2', 
                           'org.freedesktop.DBus.ObjectManager',
                           'GetManagedObjects',
                           None)


        partitions = []
        for item in objects:
            try:
                if 'block_devices'  in str(item):


                       drive = self.get_dbus_property('system',
                                        'org.freedesktop.UDisks2',
                                        item,
                                        'org.freedesktop.UDisks2.Block',
                                        'Drive')
                       if drive == '/': continue

                       mountpoint = self.get_mountpoint(item)
                       if not mountpoint: continue
                       mountpoint = mountpoint.replace('\x00','')

                       drive = str(drive).split('/')[-1]
                       usage = self.get_mountpoint_usage(mountpoint)

                       part = str(item.split('/')[-1])
                       partitions.append((part,drive,mountpoint,usage))                       

            except Exception as e:
                #print(e)
                pass

        # returning list of tuples
        partitions.sort()
        return partitions

    def get_mountpoint(self,dev_path):
        try:
            data = self.get_dbus_property(
                             'system',
                             'org.freedesktop.UDisks2',
                             dev_path,
                             'org.freedesktop.UDisks2.Filesystem',
                             'MountPoints')[0]

        except Exception as e:
            #print(e)
            return None
        else:
            if len(data) > 0:
                return ''.join([ chr(byte) for byte in data])


    def get_unmounted_partitions(self):
        objects = self.get_dbus('system', 
                           'org.freedesktop.UDisks2', 
                           '/org/freedesktop/UDisks2', 
                           'org.freedesktop.DBus.ObjectManager',
                           'GetManagedObjects',
                           None)


        partitions = []
        for item in objects:
            try:
                if 'block_devices'  in str(item):
                       drive = self.get_dbus_property('system',
                                        'org.freedesktop.UDisks2',
                                        item,
                                        'org.freedesktop.UDisks2.Block',
                                        'Drive')
                       if drive == '/': continue

                       mountpoint = self.get_mountpoint(item)
                       if  mountpoint: continue

                       drive = str(drive).split('/')[-1]
                       part = str(item.split('/')[-1])
                       if not part[-1].isdigit(): continue
                       partitions.append((part,drive))                       
                       #print(partitions)

            except Exception as e:
                #print(e)
                pass

        partitions.sort()
        return partitions

    def get_dbus(self,bus_type,obj,path,interface,method,arg):
        if bus_type == "session":
            bus = dbus.SessionBus() 
        if bus_type == "system":
            bus = dbus.SystemBus()
        proxy = bus.get_object(obj,path)
        method = proxy.get_dbus_method(method,interface)
        if arg:
            return method(arg)
        else:
            return method()

    def get_dbus_property(self,bus_type,obj,path,iface,prop):

        if bus_type == "session":
           bus = dbus.SessionBus()
        if bus_type == "system":
           bus = dbus.SystemBus()
        proxy = bus.get_object(obj,path)
        aux = 'org.freedesktop.DBus.Properties'
        props_iface = dbus.Interface(proxy,aux)
        props = props_iface.Get(iface,prop)
        return props

    def make_alias(self,*args):
        partitions = [ i[0] for i in self.get_partitions() ]

        combo_values = '|'.join(partitions)
        #print(combo_values)
        command=[ 'zenity','--forms','--title','Make Alias',
                  '--add-combo','Partition','--combo-values',
                  combo_values,'--add-entry','Alias'    ]        
        user_input = self.run_cmd(command)
        if not user_input: return

        alias = user_input.decode().strip().split('|')

        existing_values = None

        if os.path.isfile(self.config_file):
            with open(self.config_file) as conf_file:
                try:
                    existing_values = json.load(conf_file)
                except ValueError:
                    pass


        with open(self.config_file,'w') as conf_file:
             if existing_values:
                 existing_values[alias[0]] = alias[1]
             else:
                 existing_values = {alias[0]:alias[1]}

             #print(existing_values)
             json.dump(existing_values,conf_file,indent=4,sort_keys=True)


    def find_alias(self,part):
        if os.path.isfile(self.config_file):
            with open(self.config_file) as conf_file:
                try:
                    aliases = json.load(conf_file)
                except ValueError:
                    pass
                else:
                    if part in aliases:
                       return aliases[part]
                    else:
                       return None

    def toggle_auto_startup(self,*args):
        user_home = os.path.expanduser('~')
        desktop_file = '.config/autostart/udisks-indicator.desktop'
        full_path = os.path.join(user_home,desktop_file)

        if os.path.exists(full_path):
           os.unlink(full_path)
        else:
           original = '/usr/share/applications/udisks-indicator.desktop'
           if os.path.exists(original):
               shutil.copyfile(original,full_path)

        self.make_menu()


    def open_mountpoint(self,*args):
        pid = subprocess.Popen(['xdg-open',args[-1]]).pid

    def open_disks_utility(self,*args):
        pid = subprocess.Popen(['gnome-disks']).pid

    def run_cmd(self, cmdlist):
        """ Reusable function for running external commands """
        new_env = dict(os.environ)
        new_env['LC_ALL'] = 'C'
        try:
            stdout = subprocess.check_output(cmdlist, env=new_env)
        except subprocess.CalledProcessError:
            pass
        else:
            if stdout:
                return stdout

    def run(self):
        """ Launches the indicator """
        try:
            gtk.main()
        except KeyboardInterrupt:
            pass

    def quit(self, data=None):
        """ closes indicator """
        gtk.main_quit()

def main():
    """ defines program entry point """
    indicator = UdisksIndicator()
    indicator.run()

if __name__ == '__main__':
    main()

o /usr/share/applications/udisks-indicator.desktop

[Desktop Entry]
Version=1.0
Name=Udisks Indicator
Comment=Indicator for reporting partition information
Exec=udisks-indicator
Type=Application
Icon=drive-harddisk-symbolic.svg
Terminal=false

Informação adicional:

Teste do Ubuntu Mate 16.04:

Os usuários do Gnome precisam de uma extensão (suporte do KStatusNotifierItem / AppIndicator) para fazer o indicador se comportar corretamente:

Instale o indicador Sysmonitor :

sudo add-apt-repository ppa:fossfreedom/indicator-sysmonitor
sudo apt-get update
sudo apt-get install indicator-sysmonitor

e possui a opção "Espaço disponível no sistema de arquivos".

Há outra resposta usando o Indicador básico do Sysmonitor, mas você pode criar seu próprio painel personalizado com as informações que desejar.

Google (pelo menos procure bem) é seu amigo

O primeiro passo é descobrir como calcular a porcentagem de uso da partição :

$ percentage=($(df -k --output=pcent /dev/sda1))
$ echo "${percentage[1]}"
13%

Criar script bash para ecoar no painel

Aqui está um script bash para usar como opção "personalizada" no Sysmonitor Indicator . Ele mostrará a porcentagem usada nas três primeiras partições em /dev/sda:

#!/bin/bash
echo "sda1: "
percentage=($(df -k --output=pcent /dev/sda1))
echo "${percentage[1]}"
echo " | sda2: "
percentage=($(df -k --output=pcent /dev/sda2))
echo "${percentage[1]}"
echo " | sda3: "
percentage=($(df -k --output=pcent /dev/sda3))
echo "${percentage[1]}"

Saída de amostra

Ao executar, ficará assim:

Instale e configure scripts personalizados no Sysmonitor Indicator

Para obter instruções detalhadas sobre a instalação do Sysmonitor Indicator e a atribuição de um script personalizado, consulte esta resposta: O BASH pode ser exibido em systray como indicador de aplicativo?