Get current terminal size on Linux, Mac, and Windows

terminalsize.py

#!/usr/bin/env python
import os
import shlex
import struct
import platform
import subprocess
 
 
def get_terminal_size():
    """ getTerminalSize()
     - get width and height of console
     - works on linux,os x,windows,cygwin(windows)
     originally retrieved from:
     http://stackoverflow.com/questions/566746/how-to-get-console-window-width-in-python
    """
    current_os = platform.system()
    tuple_xy = None
    if current_os == 'Windows':
        tuple_xy = _get_terminal_size_windows()
        if tuple_xy is None:
            tuple_xy = _get_terminal_size_tput()
            # needed for window's python in cygwin's xterm!
    if current_os in ['Linux', 'Darwin'] or current_os.startswith('CYGWIN'):
        tuple_xy = _get_terminal_size_linux()
    if tuple_xy is None:
        print "default"
        tuple_xy = (80, 25)      # default value
    return tuple_xy
 
 
def _get_terminal_size_windows():
    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)
        if res:
            (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
    except:
        pass
 

def _get_terminal_size_tput():
    # get terminal width
    # src: http://stackoverflow.com/questions/263890/how-do-i-find-the-width-height-of-a-terminal-window
    try:
        cols = int(subprocess.check_call(shlex.split('tput cols')))
        rows = int(subprocess.check_call(shlex.split('tput lines')))
        return (cols, rows)
    except:
        pass
 
 
def _get_terminal_size_linux():
    def ioctl_GWINSZ(fd):
        try:
            import fcntl
            import termios
            cr = struct.unpack('hh',
                               fcntl.ioctl(fd, termios.TIOCGWINSZ, '1234'))
            return cr
        except:
            pass
    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 = (os.environ['LINES'], os.environ['COLUMNS'])
        except:
            return None
    return int(cr[1]), int(cr[0])
 
if __name__ == "__main__":
    sizex, sizey = get_terminal_size()
    print  'width =', sizex, 'height =', sizey

This works in Windows 8.. Thanks!

Thank you :) I'm using this for http://mio-lang.org/ as part of it's tab completer function

I thought about using it for some stuff I'm writing it (thanks for providing it btw),
I forked it and added some 'caching' so it does not run all the tests again over and over:
https://gist.github.com/Captank/7912710
It boosts it just a bit, 100k calls of the original get_terminal_size() took ~2.4 seconds, now it's just 1.8 seconds
(I'm not sure if that would be the pythonic way, I've just started learning python :'D)

Nice. License?

@maxbane I'm not sure how a license would work here, it was adapted from the script at http://stackoverflow.com/a/6550596/23998 which was adapted from http://code.activestate.com/recipes/440694-determine-size-of-console-window-on-windows/

Hi jtriley I want to thank you for this script. I do a minor changes to it and using it for my own downloader script which is in github. I want to ask if it's ok for you.

Here is the script.

Great! I'll try to use this in my ffunenga/pipgh repo

Sweet, I'll be using a rendition of this in https://github.com/catb0t/input_constrain

For _get_terminal_size_tput, the subprocess calls should use subprocess.check_output, not subprocess.check_call.

The current code causes the size to be printed to the terminal, but the returned size will be (0,0) (that is, if tput successfully exits on each call).