How to get Linux console window width in Python

Question

Is there a way in python to programmatically determine the width of the console? I mean the number of characters that fits in one line without wrapping, not the pixel width of the window.

Edit

Looking for a solution that works on Linux

Swum

Look this answer for a more extensive solution to have a "columns dependent" printing mechanism. #44130113 – Alcinia

Please consider changing the accepted answer. The one you've selected is really janky, platform dependent, and it's using os.popen which is deprecated. The top-voted answer showing shutil is the best way. – Dulsea

Answer 1

Not sure why it is in the module shutil, but it landed there in Python 3.3. See:

Querying the size of the output terminal

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

A low-level implementation is in the os module. Cross-platform—works under Linux, Mac OS, and Windows, probably other Unix-likes. There's a backport as well, though no longer relevant.

Roussillon

Neat find, but it wasn't ever put into 2.7, it seems. – Aconcagua

That's because you shouldn't be using 2.7 any longer, make the jump to 3.x it's worth it. – Milklivered

This is simply the way it should be done. It even updates as the console width changes. +1 – Shrier

@osirisgothra Many hosting providers do not support python3 yet, so some of us are forced to use python2 for back end development. Though that should have nothing to do with getting terminal size... – Caldarium

I was going to dig this one out of the Python 3 Lib/ source like usual, but it actually relies on an exported c function called os.terminal_size sadly. The backport package is pure python & MIT licensed however and can just be thrown into your own package source. – Photochronograph

@osirisgothra Because there's a lot of Python 2 code that would take too much work to port. Also, Pypy still has rather poor Python 3 support. – Beker

@Caldarium Is there a reason the subscriber can't install Python 3 on a VPS? Or in 2016, are people still using shared hosting whose administrator is unwilling to install Python 3? For example, WebFaction shared hosting has python3.5 installed. – Siphonostele

@Damian Yerrick No, on a VPS where subscriber has control, he can install what he likes. Yes, there are still shared hosting services that do not have and will not install Python 3. Hopefully, that will change soon, but it is still a reality. – Caldarium

+1 for a solution that also works when standard input has been redirected from a file! With other solutions, I was either getting Inappropriate ioctl for device errors/warnings, or getting the defined fallback value of 80. – Paper

"Not sure why it is in the module shutil".. FYI shutil means shell utilities. Getting the terminal size is surely a utility function for dealing with the shell so it's the module you'd expect to have such functionality. Where else do you want to put that? sys? os? they are for more general stuff... – Weltschmerz

@Weltschmerz A shell and terminal are two different things. The basic implementation is in the os module. Perhaps in a "termutils" module, or the full impl in os would have been a good idea. Point is moot however, as decision was already made and not breaking now. – Roussillon

This doesn't appear to work when the python script is executed from a pipe in the terminal (it reverted to the 'fallback' case provided to get_terminal_size()). I'm now using subprocess.check_output(['tput', 'cols']) instead. – Varicose

Cygwin compatible. Confirming. – Endurable

Answer 2

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

uses the 'stty size' command which according to a thread on the python mailing list is reasonably universal on linux. It opens the 'stty size' command as a file, 'reads' from it, and uses a simple string split to separate the coordinates.

Unlike the os.environ["COLUMNS"] value (which I can't access in spite of using bash as my standard shell) the data will also be up-to-date whereas I believe the os.environ["COLUMNS"] value would only be valid for the time of the launch of the python interpreter (suppose the user resized the window since then).

(See answer by @GringoSuave on how to do this on python 3.3+)

Breccia

You can get this to work on Solaris as well if instead of "size" you pass "-a". There will be "rows = Y; columns = X" in the semicolon delimited output. – Lorenza

Testing on Ubuntu, it appears -a works on Linux as well but the output is formatted slightly differently -- there's no '=' between rows/columns and the number. – Lorenza

COLUMNS isn't exported by default in Bash, that's why os.environ["COLUMNS"] doesn't work. – Pressurecook

Order is wrong. It should be: columns, rows = os.popen('stty size', 'r').read().split() – Hagiology

stty size works under solaris 5.8 (no need to parse -a).You may want to use rows, columns = [int(i) for i in os.popen('stty size', 'r').read().split()] to get integers directly – Stevana

rows, columns = subprocess.check_output(['stty', 'size']).split() is a little shorter, plus subprocess is the future – Revet

tput is better than stty, as stty cannot work with PIPE. – Latterly

I used this for a long time, but it's actually not a very good solution. For starters if you want to put it in a loop (to continually check screen size for changes), you're going to have a bad time spawning all those processes. Furthermore, sometimes the popen() returns nothing, which will raise an error if you do something like "width, height = ...." I've now gone with pascal's answer, and it seems to work so far. – Phlebosclerosis

rows, columns = subprocess.check_output(['stty', 'size']).decode().split() If you want unicode strings for py2/3 compatibility – Photochronograph

If I run it under nohup it gives following error: ValueError: not enough values to unpack (expected 2, got 0) @Breccia – Correctitude

Do not use a process (especially from the deprecated os.popen), for this except as a last resort. – Roussillon

Cygwin compatible. Confirming. However, creating a new process is costly. I prefer to use the shutil.get_terminal_size() solution of @GringoSuave – Endurable

This generates following error: stty: 'standard input': Inappropriate ioctl for device – Correctitude

This is a terrible answer that shows why "it's working" is not a high enough bar for anything. Use the right tool for the job, not your grandma's favourite bash trick. – Interferometer

Answer 3

use

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

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

EDIT: oh, I'm sorry. That's not a python standard lib one, here's the source of console.py (I don't know where it's from).

The module seems to work like that: It checks if termcap is available, when yes. It uses that; if no it checks whether the terminal supports a special ioctl call and that does not work, too, it checks for the environment variables some shells export for that. This will probably work on UNIX only.

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])

Icj

Thanks for quick reply, but here (effbot.org/zone/console-handbook.htm) it says that "The Console module is currently only available for Windows 95, 98, NT, and 2000." I am looking for a solution that works on Linux. It probably wasn't clear from the tag, I will edit the question accordingly. – Swum

since this "console" module you're using is not on the standard python library, you should provide its source code or at least a link to it. – Binder

I'm so sorry about that. In fact, I didn't know that module. I tryied import console and it worked, I used console.<tab><tab> and getTerminalSize() showed up. Instead of looking where it's from I already posted an answer because I was so lucky of the simplicity g – Icj

I might be looking at a different "console" module, could you please provide a link for the one you have? – Swum

umnik, the code I posted is the complete console "module". Just put the code in console.py and it will work as in my first sample – Icj

Works both Windows and Linux, Thank you! – Swum

Actually, I see on Windows it goes to the exception handler and returns the hardcoded (80,25). Anyways, I was looking for a solution that works on Linux, and it does quite well. – Swum

And, this will not work if you pipe your Python program output to, say, less. You would get the exception: IOError: [Errno 25] Inappropriate ioctl for device – Postmillennialism

.. to fix that: return 80 if not sys.stdout.isatty() – Postmillennialism

Hey Johannes, if you incorporate the stty answer below and Sridhar's idea from these comments I'll upvote ;) – Lorenza

I'd like to know where is this console.py from. I want a link to the project. – Approachable

This function's started to appear all over the interweb (making it near impossible to figure out where it first originated). Yet has no-one noticed that 'env' is not defined before the last try-except block? So it'll always fail, returning (25,80)... An env=os.environ line beforehand should fix that. Also, the os import is out of scope... – Crystallize

Another one: os.environ contains strings, so that should be something like try: width = int(os.environ['COLUMNS']) / except (KeyError,ValueError): width = 80 – Exserviceman

Oh, and not to pile on the code, but "cr" is a confusing name because it implies the tuple is (cols, rows). In reality, it is the reverse. – Exserviceman

I wondered whether this snippet comes from github.com/nvie/rq/commit/… Thanks for your answer – Matroclinous

@Matroclinous no, possibly the other way around though :). This answer is from 2009 and the code you linked is from 2011. The code is from the open-source code base of my former company. – Icj

module 'console' has no attribute 'getTerminalSize' – Correctitude

Answer 4

Code above didn't return correct result on my linux because winsize-struct has 4 unsigned shorts, not 2 signed shorts:

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 and hp should contain pixel width and height, but don't.

Luz

This is how it should be done; note that if you intend to print to the terminal, you should use '1' as the file descriptor (first argument of ioctl), as stdin might be a pipe or some different tty. – Dachau

Perhaps the 0 should be replaced with fcntl.ioctl(sys.stdin.fileno(), ... – Voluptuous

this is the best answer - your users will be happy that there's not a surprise subprocess happening just to get term width – Stimulate

this is indeed the cleanest answer. I think you should use stdout or stderr instead of stdin, though. stdin might very well be a pipe. You might also want to add a line such as if not os.isatty(0): return float("inf"). – Dachau

this somehow works on a chromebook terminal which has like no functionality. +1 – Brinn

@Luz @Voluptuous I have found, actually, the best luck is had by replacing the 0 with a call to os.ctermid(), which returns the name of the terminal device for the current process – like e.g. /dev/tty – Bluster

I am getting following error: ` OSError: [Errno 25] Inappropriate ioctl for device ` – Correctitude

Answer 5

It's either:

import os
columns, rows = os.get_terminal_size(0)
# or
import shutil
columns, rows = shutil.get_terminal_size()

The shutil function is just a wrapper around os one that catches some errors and set up a fallback, however it has one huge caveat - it breaks when piping!, which is a pretty huge deal.
To get terminal size when piping use os.get_terminal_size(0) instead.

First argument 0 is an argument indicating that stdin file descriptor should be used instead of default stdout. We want to use stdin because stdout detaches itself when it is being piped which in this case raises an error.

I've tried to figure out when would it makes sense to use stdout instead of stdin argument and have no idea why it's a default here.

Breastwork

os.get_terminal_size() was introduced in Python 3.3 – Swaim

I tried shutil at first, and it worked the first try. I'm using Python 3.6+. – Stinky

Using os.get_terminal_size(0) will crash if you pipe to stdin. Try: echo x | python3 -c 'import os; print(os.get_terminal_size(0))' – Tortuosity

This answer was given four years earlier. ;-) – Roussillon

Answer 6

I searched around and found a solution for windows at :

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

and a solution for linux here.

So here is a version which works both on linux, os x and 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: https://mcmap.net/q/86025/-how-do-i-find-the-width-amp-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

Spraddle

You saved me the time of doing this myself. Works on Linux. Should work on Windows as well. Thanks! – Breakwater

Answer 7

Starting at Python 3.3 it is straight forward: https://docs.python.org/3/library/os.html#querying-the-size-of-a-terminal

>>> import os
>>> ts = os.get_terminal_size()
>>> ts.lines
24
>>> ts.columns
80

Roam

shutil.get_terminal_size() is the high-level function which should normally be used, os.get_terminal_size is the low-level implementation. – Heilner

This is a near copy of a year-older answer given above. – Roussillon

Any detailed reason, why os.get_terminal_size() not be used? – Lucila

@KarthikKumar It is stated by the docs here – Brickle

Answer 8

It looks like there are some problems with that code, Johannes:

• getTerminalSize needs to import os
• what is env? looks like os.environ.

Also, why switch lines and cols before returning? If TIOCGWINSZ and stty both say lines then cols, I say leave it that way. This confused me for a good 10 minutes before I noticed the inconsistency.

Sridhar, I didn't get that error when I piped output. I'm pretty sure it's being caught properly in the try-except.

pascal, "HHHH" doesn't work on my machine, but "hh" does. I had trouble finding documentation for that function. It looks like it's platform dependent.

chochem, incorporated.

Here's my version:

def getTerminalSize():
    """
    returns (lines:int, cols:int)
    """
    import os, struct
    def ioctl_GWINSZ(fd):
        import fcntl, termios
        return struct.unpack("hh", fcntl.ioctl(fd, termios.TIOCGWINSZ, "1234"))
    # try stdin, stdout, stderr
    for fd in (0, 1, 2):
        try:
            return ioctl_GWINSZ(fd)
        except:
            pass
    # try os.ctermid()
    try:
        fd = os.open(os.ctermid(), os.O_RDONLY)
        try:
            return ioctl_GWINSZ(fd)
        finally:
            os.close(fd)
    except:
        pass
    # try `stty size`
    try:
        return tuple(int(x) for x in os.popen("stty size", "r").read().split())
    except:
        pass
    # try environment variables
    try:
        return tuple(int(os.getenv(var)) for var in ("LINES", "COLUMNS"))
    except:
        pass
    # i give up. return default.
    return (25, 80)

Titulary

I was wandering about the env too, and it is indeed env = os.environ, from accepted answer. – Holotype

Answer 9

Many of the Python 2 implementations here will fail if there is no controlling terminal when you call this script. You can check sys.stdout.isatty() to determine if this is in fact a terminal, but that will exclude a bunch of cases, so I believe the most pythonic way to figure out the terminal size is to use the builtin curses package.

import curses
w = curses.initscr()
height, width = w.getmaxyx()

Surd

Answer 10

Try "blessings"

I was looking for the very same thing. It is very easy to use and offers tools for coloring, styling and positioning in the terminal. What you need is as easy as:

from blessings import Terminal

t = Terminal()

w = t.width
h = t.height

Works like a charm in Linux. (I'm not sure about MacOSX and Windows)

Download and documentation here

or you can install it with pip:

pip install blessings

Ashien

Nowadays I'd say try "blessed" which is a currently maintained fork (and enhancement) of "blessings". – Cetology

Answer 11

I was trying the solution from here that calls out to stty size:

columns = int(subprocess.check_output(['stty', 'size']).split()[1])

However this failed for me because I was working on a script that expects redirected input on stdin, and stty would complain that "stdin isn't a terminal" in that case.

I was able to make it work like this:

with open('/dev/tty') as tty:
    height, width = subprocess.check_output(['stty', 'size'], stdin=tty).split()

Paleontology

Answer 12

If you're using Python 3.3 or above, I'd recommend the built-in get_terminal_size() as already recommended. However if you are stuck with an older version and want a simple, cross-platform way of doing this, you could use asciimatics. This package supports versions of Python back to 2.7 and uses similar options to those suggested above to get the current terminal/console size.

Simply construct your Screen class and use the dimensions property to get the height and width. This has been proven to work on Linux, OSX and Windows.

Oh - and full disclosure here: I am the author, so please feel free to open a new issue if you have any problems getting this to work.

Arriviste

size = os.get_terminal_size() -> OSError: [Errno 25] Inappropriate ioctl for device – Tobi

@RuiMartins Please raise the issue on github (with extra details of the system) and I'll take a look. – Arriviste

Answer 13

Use subprocess, it is the most convenient way of doing it:

Import:

import subprocess

Example of Use:

print(subprocess.check_output(['stty', 'size']).split())

Note: This function returns bytes but you can cast it to Integer with the int() function.

Note: this function returns an array, being: array[0]=rows and array[1]=columns.

Output:

[b'46', b'188']

For instance if you need to compare whether the width of your console is larger than W, you can do something like this:

if int(subprocess.check_output(['stty', 'size']).split()[1]) > W:
    ...

Anjaanjali

Answer 14

@reannual's answer works well, but there's an issue with it: os.popen is now deprecated. The subprocess module should be used instead, so here's a version of @reannual's code that uses subprocess and directly answers the question (by giving the column width directly as an int:

import subprocess

columns = int(subprocess.check_output(['stty', 'size']).split()[1])

Tested on OS X 10.9

Instigate

Answer 15

Here is an version that should be Linux and Solaris compatible. Based on the posts and commments from madchine. Requires the subprocess module.

def termsize():
    import shlex, subprocess, re
    output = subprocess.check_output(shlex.split('/bin/stty -a'))
    m = re.search('rows\D+(?P\d+); columns\D+(?P\d+);', output)
    if m:
        return m.group('rows'), m.group('columns')
    raise OSError('Bad response: %s' % (output))

>>> termsize()
('40', '100')

Anomaly