580 lines
18 KiB
Python
Executable file
580 lines
18 KiB
Python
Executable file
#!/usr/bin/env python
|
||
# -*- coding: utf-8 -*-
|
||
#
|
||
# Vrac d'outils pour avoir un affichage sympathique.
|
||
# Auteur : Pierre-Elliott Bécue <becue@crans.org>
|
||
# Licence : GPLv3
|
||
#
|
||
# Contenu :
|
||
# ---------
|
||
#
|
||
# Décorateur :
|
||
# static_var([(name, val)]), un décorateur pour créer des variables
|
||
# statiques dans une fonction
|
||
#
|
||
# Fonctions :
|
||
# getTerminalSize(), une fonction qui récupère le couple
|
||
# largeur, hauteur du terminal courant.
|
||
# cap_text(data, length, dialog=False), un raccourci pour couper un texte
|
||
# trop long en mettant *
|
||
# format_percent(percent), un raccourci qui fait en sorte
|
||
# qu'un pourcentage prenne toujours autant de caractères
|
||
# en ajoutant des espaces (c'est pour les prints dynamiques)
|
||
# rojv(percent, seuils, couls), une méthode qui affiche une couleur
|
||
# pour un pourcentage en fonction de la valeur de celui-ci, des
|
||
# seuils définis, et des couleurs disponibles.
|
||
# style(texte, what), une méthode qui applique un ensemble de styles
|
||
# contenus dans what au texte texte.
|
||
# dialogStyle(texte, what), pareil, mais dans dialog
|
||
# prettyDoin(what, status), une méthode qui affiche des messages "service"-
|
||
# like, en mettant le status en fonction de l'accomplissement de la tâche.
|
||
#
|
||
# Classes :
|
||
# Animation, une classe générant les animations type "progress bar".
|
||
|
||
from __future__ import unicode_literals
|
||
|
||
import sys
|
||
import os
|
||
import fcntl
|
||
import termios
|
||
import struct
|
||
import functools
|
||
import time
|
||
import re
|
||
|
||
from locale import getpreferredencoding
|
||
|
||
OCT_NAMES = ["Pio", "Tio", "Gio", "Mio", "Kio"]
|
||
OCT_SIZES = [1024**(len(OCT_NAMES) - i) for i in xrange(0, len(OCT_NAMES))]
|
||
TERM_FORMAT = '\x1b\[[0-1];([0-9]|[0-9][0-9])m'
|
||
DIALOG_FORMAT = '\\\Z.'
|
||
SEP_COL = "|"
|
||
|
||
def try_decode(string):
|
||
"""Essaye de décoder dans les deux formats plausibles qu'on peut
|
||
avoir en réception.
|
||
|
||
"""
|
||
unicode_str = ""
|
||
try:
|
||
return string.decode("UTF-8")
|
||
except UnicodeDecodeError:
|
||
pass
|
||
|
||
try:
|
||
return string.decode("ISO-8859-15")
|
||
except:
|
||
pass
|
||
|
||
def guess_preferred_encoding():
|
||
"""On essaye de deviner l'encodage favori de l'utilisateur.
|
||
C'est inspiré d'affich_tools.
|
||
|
||
Il faudrait l'améliorer si nécessaire.
|
||
|
||
"""
|
||
encoding = None
|
||
try:
|
||
encoding = getpreferredencoding()
|
||
except:
|
||
pass
|
||
|
||
if not encoding:
|
||
encoding = sys.stdin.encoding or 'UTF-8'
|
||
|
||
if encoding == "ANSI_X3.4-1968":
|
||
encoding = 'UTF-8'
|
||
|
||
return encoding
|
||
|
||
def static_var(couples):
|
||
"""Decorator setting static variable
|
||
to a function.
|
||
|
||
"""
|
||
# Using setattr magic, we set static
|
||
# variable on function. This avoid
|
||
# computing stuff again.
|
||
def decorate(fun):
|
||
functools.wraps(fun)
|
||
for (name, val) in couples:
|
||
setattr(fun, name, val)
|
||
return fun
|
||
return decorate
|
||
|
||
def getTerminalSize():
|
||
"""Dummy function to get term dimensions.
|
||
Thanks to http://stackoverflow.com/questions/566746/how-to-get-console-window-width-in-python
|
||
|
||
Could be done using only env variables or thing like stty size, but would be less
|
||
portable.
|
||
|
||
"""
|
||
|
||
def ioctl_GWINSZ(fd):
|
||
try:
|
||
# unpack C structure, the first argument says that we will get two short
|
||
# integers (h).
|
||
# ioctl is a C function which do an operation on a file descriptor, the operation
|
||
# here is termios.TIOCGWINSZ which will get the return to be term size. The third
|
||
# argument is a buffer passed to ioctl. Its size is used to define the size of the
|
||
# the return
|
||
cr = struct.unpack(b'hh', fcntl.ioctl(fd, termios.TIOCGWINSZ, b'1234'))
|
||
except:
|
||
return
|
||
return cr
|
||
|
||
# First, we use this magic function on stdin/stdout/stderr.
|
||
cr = ioctl_GWINSZ(0) or ioctl_GWINSZ(1) or ioctl_GWINSZ(2)
|
||
|
||
# If that didn't work, we try to do this on a custom file descriptor.
|
||
if not cr:
|
||
try:
|
||
fd = os.open(os.ctermid(), os.O_RDONLY)
|
||
cr = ioctl_GWINSZ(fd)
|
||
os.close(fd)
|
||
except:
|
||
pass
|
||
|
||
# If that failed, we use os.environ, and if that fails, we set default values.
|
||
if not cr:
|
||
cr = (os.environ.get('LINES', 25), os.environ.get('COLUMNS', 80))
|
||
return int(cr[1]), int(cr[0])
|
||
|
||
def format_percent(percent):
|
||
"""Formatte les pourcentages en ajoutant des espaces si
|
||
nécessaire.
|
||
|
||
"""
|
||
|
||
if percent < 10:
|
||
return " %s" % (percent,)
|
||
elif percent < 100:
|
||
return " %s" % (percent,)
|
||
else:
|
||
return str(percent)
|
||
|
||
def rojv(percent, seuils=(100, 75, 50, 25), couls=("cyan", "vert", "jaune", "orange", "rouge")):
|
||
"""Retourne la couleur qui va bien avec le pourcentage
|
||
|
||
Les pourcentages seuil, et les couleurs associées, doivent être
|
||
rangés en ordre décroissant.
|
||
|
||
"""
|
||
lens = len(seuils)
|
||
lenc = len(couls)
|
||
if lens + 1 == lenc:
|
||
coul = couls[0]
|
||
for i in range(lens):
|
||
if percent < seuils[i]:
|
||
coul = couls[i + 1]
|
||
else:
|
||
raise EnvironmentError("Seuils doit contenir une variable de moins par rapport à couls")
|
||
return coul
|
||
|
||
class Animation(object):
|
||
"""Propose une animation lors de la mise à jour ou de
|
||
l'évolution d'une tâche.
|
||
|
||
Si le nombre de cycles est défini, affiche un pourcentage
|
||
d'évolution.
|
||
|
||
Si l'option kikoo est définit, met une jauge en plus.
|
||
|
||
Sinon, affiche un truc qui tourne.
|
||
|
||
"""
|
||
|
||
def __init__(self, texte, nb_cycles=0, couleur=True, kikoo=True, timer=True):
|
||
"""__init__
|
||
|
||
"""
|
||
self.texte = texte
|
||
self.nb_cycles = nb_cycles
|
||
self._kikoo = kikoo
|
||
self.step = 0
|
||
self.couleur = couleur
|
||
self.timer = timer
|
||
self.beginTime = 0
|
||
|
||
def kikoo(self, kikoo):
|
||
"""Switch pour la valeur kikoo"""
|
||
self._kikoo = kikoo
|
||
|
||
def new_step(self):
|
||
"""Effectue une étape dans l'affichage
|
||
|
||
"""
|
||
if self.step == 0 and self.timer:
|
||
self.beginTime = time.time()
|
||
cols, _ = getTerminalSize()
|
||
|
||
# La seule façon efficace de faire de l'affichage de barres de chargement ou autres dynamiquement
|
||
# est d'utiliser sys.stdout. C'est pas super propre, mais de toute façon, les trucs kikoo c'est
|
||
# rarement propre, d'abord.
|
||
|
||
# Si le nombre de cycles est indéfini, on affiche une "barre de chargement" non bornée.
|
||
if not self.nb_cycles > 0:
|
||
proceeding = "\r%s ..... %s" % (cap_text(self.texte, cols - 10), "\|/-"[self.step % 4])
|
||
sys.stdout.write(proceeding.encode(guess_preferred_encoding()))
|
||
|
||
# Sinon, on affiche un truc avec une progression/un pourcentage
|
||
else:
|
||
percent = int((self.step + 1.0)/self.nb_cycles * 100)
|
||
|
||
# Quand on manque de colonnes, on évite les trucs trop verbeux, idem si la kikooness
|
||
# n'est pas demandée.
|
||
if not self._kikoo or cols <= 55:
|
||
if self.couleur:
|
||
# Avec de la couleur.
|
||
percent = style("%s %%" % (format_percent(percent),), rojv(percent))
|
||
else:
|
||
# Sans couleur (so sad)
|
||
percent = "%s %%" % (format_percent(percent),)
|
||
proceeding = "\r%s : %s" % (cap_text(self.texte, cols - 10), percent)
|
||
sys.stdout.write(proceeding.encode(guess_preferred_encoding()))
|
||
|
||
# Du kikoo ! Du kikoo !
|
||
else:
|
||
# La kikoo bar est une barre de la forme [======> ]
|
||
# Nombre de =
|
||
amount = percent/4
|
||
|
||
if self.couleur:
|
||
# kikoo_print contient la barre et le pourcentage, colorés en fonction du pourcentage
|
||
kikoo_print = style("[%s%s%s] %s %%" % (amount * '=',
|
||
">",
|
||
(25-amount) * ' ',
|
||
format_percent(percent)),
|
||
rojv(percent))
|
||
|
||
else:
|
||
kikoo_print = "[%s%s%s] %s %%" % (amount * '=',
|
||
">",
|
||
(25-amount) * ' ',
|
||
format_percent(percent))
|
||
proceeding = "\r%s %s" % (cap_text(self.texte, cols - 45), kikoo_print)
|
||
sys.stdout.write(proceeding.encode(guess_preferred_encoding()))
|
||
|
||
# What if we add more kikoo?
|
||
if self.timer:
|
||
self.elapsedTime = time.time() - self.beginTime
|
||
proceeding = " (temps écoulé : %ds)" % (self.elapsedTime)
|
||
sys.stdout.write(proceeding.encode(guess_preferred_encoding()))
|
||
sys.stdout.flush()
|
||
self.step += 1
|
||
|
||
def end(self):
|
||
"""Prints a line return"""
|
||
sys.stdout.write("\n".encode(guess_preferred_encoding()))
|
||
sys.stdout.flush()
|
||
|
||
def nostyle(dialog=False):
|
||
"""Annule tout style précédent."""
|
||
if dialog:
|
||
return "\Zn"
|
||
return "\033[1;0m"
|
||
|
||
@static_var([("styles", {})])
|
||
def style(texte, what=None, dialog=False):
|
||
"""Pretty text is pretty
|
||
On peut appliquer plusieurs styles d'affilée, ils seront alors traités
|
||
de gauche à droite (les plus à droite sont donc ceux appliqués en dernier,
|
||
et les plus à gauche en premier, ce qui veut dire que les plus à droite
|
||
viennent après, et non avant, de fait, comme ils arrivent après, ils
|
||
n'arrivent pas avant, et du coup, ceux qui arrivent avant peuvent être
|
||
écrasés par ceux qui arrivent après…
|
||
|
||
Tout ça pour dire que style(texte, ['vert', 'blanc', 'bleu', 'kaki']) est
|
||
équivalent à style(texte, ['kaki']) qui équivaut à
|
||
KeyError Traceback (most recent call last)
|
||
<ipython-input-2-d9c32f2123f0> in <module>()
|
||
----> 1 styles['kaki']
|
||
|
||
KeyError: 'kaki'
|
||
Sinon, il est possible de changer la couleur de fond grace aux couleur
|
||
f_<couleur>, et de mettre du GRAS (je songe encore à un module qui fasse du
|
||
UPPER, parce que c'est inutile, donc kewl.
|
||
|
||
"""
|
||
if what is None:
|
||
what = []
|
||
|
||
if dialog:
|
||
return dialogStyle(texte, what)
|
||
|
||
if isinstance(what, unicode):
|
||
what = [what]
|
||
if isinstance(what, str):
|
||
what = [try_decode(what)]
|
||
|
||
if not what:
|
||
return texte
|
||
|
||
# Si la variable statique styles n'est pas peuplée…
|
||
if style.styles == {}:
|
||
zeros = {
|
||
'noir' : 30,
|
||
'rougefonce': 31,
|
||
'vertfonce' : 32,
|
||
'orange' : 33,
|
||
'bleufonce' : 34,
|
||
'violet' : 35,
|
||
'cyanfonce' : 36,
|
||
'grisclair' : 37,
|
||
}
|
||
|
||
# Méthode "automatisée" pour remplir la version "background" des codes
|
||
# couleur du shell.
|
||
f_zeros = { "f_"+coul : val+10 for (coul, val) in zeros.iteritems() }
|
||
zeros.update(f_zeros)
|
||
zeros = { coul: "0;%s" % (val,) for (coul, val) in zeros.items() }
|
||
|
||
# Plus de couleurs (les codes sont de la forme \033[0;blah ou \033[1;blah, donc
|
||
# ici on remplit la partie 1;.
|
||
ones = {
|
||
'gris': 30,
|
||
'rouge': 31,
|
||
'vert': 32,
|
||
'jaune': 33,
|
||
'bleu': 34,
|
||
'magenta': 35,
|
||
'cyan': 36,
|
||
'blanc': 37,
|
||
'gras': 50,
|
||
}
|
||
|
||
f_ones = { "f_"+coul : val+10 for (coul, val) in ones.iteritems() }
|
||
ones.update(f_ones)
|
||
ones = { coul: "1;%s" % (val,) for (coul, val) in ones.items() }
|
||
|
||
style.styles.update(zeros)
|
||
style.styles.update(ones)
|
||
style.styles["none"] = "1;0"
|
||
|
||
for element in what:
|
||
texte = "\033[%sm%s\033[1;0m" % (style.styles[element], texte)
|
||
return texte
|
||
|
||
OK = style('Ok', 'vert')
|
||
WARNING = style('Warning', 'jaune')
|
||
ERREUR = style('Erreur', 'rouge')
|
||
|
||
def dialogStyle(texte, what):
|
||
"""Fournit du texte coloré pour dialog.
|
||
|
||
Séparé volontairement de style pour une meilleure
|
||
utilisation.
|
||
|
||
"""
|
||
|
||
if isinstance(what, str):
|
||
what = [what]
|
||
|
||
dialog_styles = {
|
||
'rouge': 1,
|
||
'orange': 1,
|
||
'vert': 2,
|
||
'jaune': 3,
|
||
'bleu': 4,
|
||
'violet': 5,
|
||
'cyan': 6,
|
||
'gris': 0,
|
||
'gras': 'b',
|
||
}
|
||
|
||
for elem in what:
|
||
texte = "\Z%s%s\Zn" % (dialog_styles[elem], texte)
|
||
return texte
|
||
|
||
def prettyDoin(what, status):
|
||
"""Affiche une opération en cours et met son statut à jour
|
||
|
||
"""
|
||
if status == "...":
|
||
sys.stdout.write("\r[%s] %s" % (style(status, "jaune"), what))
|
||
elif status == "Ok":
|
||
sys.stdout.write("\r[%s] %s\n" % (OK, what))
|
||
elif status == "Warning":
|
||
sys.stdout.write("\r[%s] %s\n" % (WARNING, what))
|
||
else:
|
||
sys.stdout.write("\r[%s] %s\n" % (ERREUR, what))
|
||
sys.stdout.flush()
|
||
|
||
def cap_text(data, length, dialog=False):
|
||
"""Tronque une chaîne à une certaine longueur en excluant
|
||
les commandes de style.
|
||
|
||
"""
|
||
# découpage d'une chaine trop longue
|
||
regexp = re.compile(DIALOG_FORMAT if dialog else TERM_FORMAT)
|
||
new_data = ''
|
||
new_len = 0
|
||
|
||
# On laisse la mise en forme et on coupe les caratères affichés
|
||
while True :
|
||
s = regexp.search(data)
|
||
if s:
|
||
if s.start() + new_len > length:
|
||
new_data += data[:length - new_len - 1] + nostyle() + '*'
|
||
break
|
||
else:
|
||
new_data += data[:s.end()]
|
||
data = data[s.end():]
|
||
new_len += s.start()
|
||
else:
|
||
if new_len + len(data) > length:
|
||
new_data += data[:length - new_len - 1] + '*'
|
||
data = ""
|
||
else:
|
||
new_data += data
|
||
data = ""
|
||
|
||
if not data:
|
||
break
|
||
return new_data
|
||
|
||
def aligne(data, alignement, largeur, dialog) :
|
||
# Longeur sans les chaines de formatage
|
||
longueur = len(re.sub(DIALOG_FORMAT if dialog else TERM_FORMAT, '', data))
|
||
|
||
# Alignement
|
||
if longueur > largeur:
|
||
return cap_text(data, largeur, dialog)
|
||
|
||
elif longueur == largeur :
|
||
return data
|
||
|
||
elif alignement == 'g':
|
||
return ' ' + data + ' '*(largeur-longueur-1)
|
||
|
||
elif alignement == 'd':
|
||
return ' '*(largeur-longueur-1) + data + ' '
|
||
|
||
else:
|
||
return ' '*((largeur-longueur)/2) + data + ' '*((largeur-longueur+1)/2)
|
||
|
||
def format_data(data, format):
|
||
if format == 's':
|
||
return unicode(data)
|
||
|
||
elif format == 'o':
|
||
data = float(data)
|
||
for i in xrange(0, len(OCT_NAMES)):
|
||
if data > OCT_SIZES[i]:
|
||
return "%.2f %s" % (data/OCT_SIZES[i], OCT_NAMES[i])
|
||
return "%.0f o" % (data)
|
||
|
||
def tableau(data, titre=None, largeur=None, alignement=None, format=None, dialog=False, width=None, styles=None, swap=None):
|
||
"""
|
||
Retourne une chaine formatée repésentant un tableau.
|
||
|
||
data : liste de listes, chacune contenant les valeurs d'une ligne
|
||
|
||
titre : liste des titres
|
||
Si none, n'affiche pas de ligne de titre
|
||
|
||
largeur : liste des largeurs des colonnes, '*' met la plus grande
|
||
largeur possible.
|
||
Si None, réduit aux max chaque colonne
|
||
|
||
alignement : liste des alignements : c = centrer
|
||
g = gauche
|
||
d = droit
|
||
Si None, met c pour chaque colonne
|
||
|
||
format : liste des formats : s = string
|
||
o = octet
|
||
Si None, s pour chaque colonne
|
||
width : force la largeur
|
||
|
||
styles : applique une liste de styles, un à chaque colonne.
|
||
|
||
swap : Met styles à None et alterne une ligne sur deux niveau couleurs.
|
||
"""
|
||
|
||
if swap is None:
|
||
swap = []
|
||
|
||
if data and isinstance(data, list):
|
||
nb_cols = len(data[0])
|
||
else:
|
||
return ""
|
||
|
||
if format is None:
|
||
format = ['s'] * nb_cols
|
||
|
||
if swap != []:
|
||
styles = None
|
||
else:
|
||
swap = [None]
|
||
|
||
if styles is None:
|
||
styles = [None] * nb_cols
|
||
|
||
data = [[format_data(ligne[i], format[i]) for i in xrange(nb_cols)] for ligne in data]
|
||
|
||
if not largeur:
|
||
largeur = [max([len(re.sub(DIALOG_FORMAT if dialog else TERM_FORMAT, '', ligne[i])) for ligne in data]) for i in range(nb_cols)]
|
||
elif '*' in largeur or -1 in largeur:
|
||
for i in xrange(0, len(largeur)):
|
||
if largeur[i] is not None:
|
||
continue
|
||
largeur[i] = max(len(ligne[i]) for ligne in data)
|
||
sum_larg = sum([l for l in largeur if l != '*'])
|
||
if width:
|
||
cols = width
|
||
else:
|
||
cols, rows = getTerminalSize()
|
||
if dialog:
|
||
cols = cols - 6
|
||
stars = largeur.count('*') + largeur.count(-1)
|
||
for i in range(nb_cols):
|
||
if largeur[i] in ['*', -1] :
|
||
largeur[i] = max(cols - sum_larg - nb_cols - 1, 3)/stars
|
||
|
||
if alignement is None:
|
||
alignement = ['c'] * nb_cols
|
||
|
||
data = [[aligne(ligne[i], alignement[i], largeur[i], dialog) for i in range(nb_cols)] for ligne in data]
|
||
|
||
# Le titre
|
||
##########
|
||
if titre :
|
||
# ligne de titre
|
||
chaine = SEP_COL + SEP_COL.join([style(aligne(titre[i], 'c', largeur[i], dialog), styles[i]) for i in range(nb_cols)]) + SEP_COL + '\n'
|
||
# ligne de séparation
|
||
chaine += SEP_COL + '+'.join(['-'*largeur[i] for i in range(nb_cols)]) + SEP_COL + '\n'
|
||
else :
|
||
chaine = ''
|
||
|
||
# Les données
|
||
#############
|
||
j = 0
|
||
for ligne in data:
|
||
chaine += "%s" % (SEP_COL,)
|
||
if swap:
|
||
chaine += SEP_COL.join([style(ligne[i], swap[j]) for i in range(nb_cols)])
|
||
else:
|
||
chaine += SEP_COL.join([style(ligne[i], styles[i]) for i in range(nb_cols)])
|
||
chaine += "%s\n" % (SEP_COL,)
|
||
j = (j + 1) % len(swap)
|
||
|
||
return chaine
|
||
|
||
if __name__ == "__main__":
|
||
import time
|
||
a = Animation(texte="Test de l'animation", nb_cycles=10000, couleur=True, kikoo=True)
|
||
for i in range(0, a.nb_cycles):
|
||
time.sleep(0.0001)
|
||
a.new_step()
|
||
a.end()
|
||
prettyDoin("Je cuis des carottes.", "...")
|
||
time.sleep(1)
|
||
prettyDoin("Les carottes sont cuites." , "Ok")
|
||
|
||
data = [[style("Durand", "rouge"), "Toto", "40", "50 rue Döp"], ["Dupont", "Robert", "50", "42" + style(" avenue ", "vert") + style("dumotel", 'rouge')], [style("znvuzbvzruobouzb", ["gras", "vert"]), "pppoe", "1", "poiodur 50 pepe"]]
|
||
titres = ("Nom", "Prénom", "Âge", "Adresse")
|
||
longueurs = [25, 25, '*', '*']
|
||
print tableau(data, titres, longueurs).encode(guess_preferred_encoding())
|