Comment obtenir la largeur de la fenêtre de la console Linux en Python

Question

Existe-t-il un moyen en python de déterminer de manière programmatique la largeur de la console ? Je veux dire le nombre de caractères qui tiennent sur une ligne sans s'enrouler, pas la largeur en pixels de la fenêtre.

Editar

Recherche d'une solution qui fonctionne sous Linux

Answer 1

Je ne sais pas pourquoi il est dans le module shutil mais il a atterri là dans Python 3.3, Interrogation de la taille de la borne de sortie :

>>> import shutil
>>> shutil.get_terminal_size((80, 20))  # pass fallback
os.terminal_size(columns=87, lines=23)  # returns a named-tuple

Une implémentation de bas niveau se trouve dans le module os. Fonctionne également sous Windows.

Un backport est maintenant disponible pour Python 3.2 et inférieur :

• https://pypi.python.org/pypi/backports.shutil_get_terminal_size

Answer 2

import os
rows, columns = os.popen('stty size', 'r').read().split()

utilise la commande 'stty size' qui, selon la norme un fil de discussion sur la liste de diffusion python est raisonnablement universel sous linux. Il ouvre la commande 'stty size' comme un fichier, le 'lit', et utilise une simple séparation de chaîne pour séparer les coordonnées.

Contrairement à la valeur os.environ["COLUMNS"] (à laquelle je ne peux pas accéder malgré l'utilisation de bash comme shell standard), les données seront également à jour alors que je pense que la valeur os.environ["COLUMNS"] ne serait valable que pour le moment du lancement de l'interpréteur python (supposons que l'utilisateur ait redimensionné la fenêtre depuis).

(Voir la réponse de @GringoSuave sur la façon de faire cela sur python 3.3+)

Answer 3

Utiliser

import console
(width, height) = console.getTerminalSize()

print "Your terminal's width is: %d" % width

EDITAR : oh, je suis désolé. Ce n'est pas une librairie standard de python, voici la source de console.py (je ne sais pas d'où elle vient).

Le module semble fonctionner ainsi : Il vérifie si termcap est disponible, si oui. Il l'utilise ; si non, il vérifie si le terminal supporte une option spéciale de l'interface utilisateur. ioctl et cela ne fonctionne pas non plus, il vérifie les variables d'environnement que certains shells exportent pour cela. Cela ne fonctionnera probablement que sur UNIX.

def getTerminalSize():
    import os
    env = os.environ
    def ioctl_GWINSZ(fd):
        try:
            import fcntl, termios, struct, os
            cr = struct.unpack('hh', fcntl.ioctl(fd, termios.TIOCGWINSZ,
        '1234'))
        except:
            return
        return cr
    cr = ioctl_GWINSZ(0) or ioctl_GWINSZ(1) or ioctl_GWINSZ(2)
    if not cr:
        try:
            fd = os.open(os.ctermid(), os.O_RDONLY)
            cr = ioctl_GWINSZ(fd)
            os.close(fd)
        except:
            pass
    if not cr:
        cr = (env.get('LINES', 25), env.get('COLUMNS', 80))

        ### Use get(key[, default]) instead of a try/catch
        #try:
        #    cr = (env['LINES'], env['COLUMNS'])
        #except:
        #    cr = (25, 80)
    return int(cr[1]), int(cr[0])

Answer 4

Le code ci-dessus n'a pas retourné le bon résultat sur mon linux parce que la structure winsize a 4 shorts non signés, et non 2 shorts signés :

def terminal_size():
    import fcntl, termios, struct
    h, w, hp, wp = struct.unpack('HHHH',
        fcntl.ioctl(0, termios.TIOCGWINSZ,
        struct.pack('HHHH', 0, 0, 0, 0)))
    return w, h

hp et hp devraient contenir la largeur et la hauteur des pixels, mais ne le font pas.

Answer 5

J'ai cherché et trouvé une solution pour Windows à :

http://code.activestate.com/recipes/440694-determine-size-of-console-window-on-Windows/

et une solution pour linux ici.

Voici donc une version qui fonctionne à la fois sur linux, os x et Windows/cygwin :

""" getTerminalSize()
 - get width and height of console
 - works on linux,os x,windows,cygwin(windows)
"""

__all__=['getTerminalSize']

def getTerminalSize():
   import platform
   current_os = platform.system()
   tuple_xy=None
   if current_os == 'Windows':
       tuple_xy = _getTerminalSize_windows()
       if tuple_xy is None:
          tuple_xy = _getTerminalSize_tput()
          # needed for window's python in cygwin's xterm!
   if current_os == 'Linux' or current_os == 'Darwin' or  current_os.startswith('CYGWIN'):
       tuple_xy = _getTerminalSize_linux()
   if tuple_xy is None:
       print "default"
       tuple_xy = (80, 25)      # default value
   return tuple_xy

def _getTerminalSize_windows():
    res=None
    try:
        from ctypes import windll, create_string_buffer

        # stdin handle is -10
        # stdout handle is -11
        # stderr handle is -12

        h = windll.kernel32.GetStdHandle(-12)
        csbi = create_string_buffer(22)
        res = windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
    except:
        return None
    if res:
        import struct
        (bufx, bufy, curx, cury, wattr,
         left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
        sizex = right - left + 1
        sizey = bottom - top + 1
        return sizex, sizey
    else:
        return None

def _getTerminalSize_tput():
    # get terminal width
    # src: http://stackoverflow.com/questions/263890/how-do-i-find-the-width-height-of-a-terminal-window
    try:
       import subprocess
       proc=subprocess.Popen(["tput", "cols"],stdin=subprocess.PIPE,stdout=subprocess.PIPE)
       output=proc.communicate(input=None)
       cols=int(output[0])
       proc=subprocess.Popen(["tput", "lines"],stdin=subprocess.PIPE,stdout=subprocess.PIPE)
       output=proc.communicate(input=None)
       rows=int(output[0])
       return (cols,rows)
    except:
       return None

def _getTerminalSize_linux():
    def ioctl_GWINSZ(fd):
        try:
            import fcntl, termios, struct, os
            cr = struct.unpack('hh', fcntl.ioctl(fd, termios.TIOCGWINSZ,'1234'))
        except:
            return None
        return cr
    cr = ioctl_GWINSZ(0) or ioctl_GWINSZ(1) or ioctl_GWINSZ(2)
    if not cr:
        try:
            fd = os.open(os.ctermid(), os.O_RDONLY)
            cr = ioctl_GWINSZ(fd)
            os.close(fd)
        except:
            pass
    if not cr:
        try:
            cr = (env['LINES'], env['COLUMNS'])
        except:
            return None
    return int(cr[1]), int(cr[0])

if __name__ == "__main__":
    sizex,sizey=getTerminalSize()
    print  'width =',sizex,'height =',sizey