FilesExpand file tree

 develop

/

terminal.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

181 lines (148 loc) · 5.34 KB

 develop

/

terminal.py

Copy path

Top

File metadata and controls

• Code
• Blame

181 lines (148 loc) · 5.34 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

"""

This module provides functions to get the terminal size across different

platforms.

Functions:

get_terminal_size: Get the current size of the terminal.

_get_terminal_size_windows: Get terminal size on Windows.

_get_terminal_size_tput: Get terminal size using `tput`.

_get_terminal_size_linux: Get terminal size on Linux.

Usage example:

>>> width, height = get_terminal_size()

"""

from __future__ import annotations

import contextlib

import os

import typing

from . import converters

Dimensions = tuple[int, int]

OptionalDimensions = Dimensions | None

_StrDimensions = tuple[str, str]

_OptionalStrDimensions = _StrDimensions | None

def get_terminal_size() -> Dimensions: # pragma: no cover

"""Get the current size of your terminal.

Multiple returns are not always a good idea, but in this case it greatly

simplifies the code so I believe it's justified. It's not the prettiest

function but that's never really possible with cross-platform code.

Returns:

width, height: Two integers containing width and height

"""

w: int | None

h: int | None

with contextlib.suppress(Exception):

# Default to 79 characters for IPython notebooks

import IPython # type: ignore[import-not-found]

ipython = IPython.get_ipython() # type: ignore[no-untyped-call]

from ipykernel import zmqshell # type: ignore[import-not-found]

if isinstance(ipython, zmqshell.ZMQInteractiveShell):

return 79, 24

with contextlib.suppress(Exception):

# This works for Python 3, but not Pypy3. Probably the best method if

# it's supported so let's always try

import shutil

w, h = shutil.get_terminal_size()

if w and h:

# The off by one is needed due to progressbars in some cases, for

# safety we'll always subtract it.

return w - 1, h

with contextlib.suppress(Exception):

w = converters.to_int(os.environ.get('COLUMNS'))

h = converters.to_int(os.environ.get('LINES'))

if w and h:

return w, h

with contextlib.suppress(Exception):

import blessings # type: ignore[import-untyped]

terminal = blessings.Terminal()

w = terminal.width

h = terminal.height

if w and h:

return w, h

with contextlib.suppress(Exception):

# The method can return None so we don't unpack it

wh = _get_terminal_size_linux()

if wh is not None and all(wh):

return wh

with contextlib.suppress(Exception):

# Windows detection doesn't always work, let's try anyhow

wh = _get_terminal_size_windows()

if wh is not None and all(wh):

return wh

with contextlib.suppress(Exception):

# needed for window's python in cygwin's xterm!

wh = _get_terminal_size_tput()

if wh is not None and all(wh):

return wh

return 79, 24

def _get_terminal_size_windows() -> OptionalDimensions: # pragma: no cover

res = None

try:

import ctypes

# stdin handle is -10

# stdout handle is -11

# stderr handle is -12

h = ctypes.windll.kernel32.GetStdHandle(-12) # type: ignore[attr-defined]

csbi = ctypes.create_string_buffer(22)

res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi) # type: ignore[attr-defined]

except Exception:

return None

if res:

import struct

(_, _, _, _, _, left, top, right, bottom, _, _) = struct.unpack(

'hhhhHhhhhhh', csbi.raw

)

w = right - left

h = bottom - top

return w, h

else:

return None

def _get_terminal_size_tput() -> OptionalDimensions: # pragma: no cover

# get terminal width src: http://stackoverflow.com/questions/263890/

try:

import subprocess

proc = subprocess.Popen(

['tput', 'cols'],

stdin=subprocess.PIPE,

stdout=subprocess.PIPE,

stderr=subprocess.PIPE,

)

output = proc.communicate(input=None)

w = int(output[0])

proc = subprocess.Popen(

['tput', 'lines'],

stdin=subprocess.PIPE,

stdout=subprocess.PIPE,

stderr=subprocess.PIPE,

)

output = proc.communicate(input=None)

h = int(output[0])

except Exception:

return None

else:

return w, h

def _get_terminal_size_linux() -> OptionalDimensions: # pragma: no cover

def ioctl_gwinsz(fd: int) -> tuple[str, str] | None:

try:

import fcntl

import struct

import termios

return typing.cast(

_OptionalStrDimensions,

struct.unpack(

'hh',

fcntl.ioctl(fd, termios.TIOCGWINSZ, '1234'), # type: ignore[call-overload]

),

)

except Exception:

return None

size: _OptionalStrDimensions

size = ioctl_gwinsz(0) or ioctl_gwinsz(1) or ioctl_gwinsz(2)

if not size:

with contextlib.suppress(Exception):

fd = os.open(os.ctermid(), os.O_RDONLY)

size = ioctl_gwinsz(fd)

os.close(fd)

if not size:

try:

size = os.environ['LINES'], os.environ['COLUMNS']

except Exception:

return None

return int(size[1]), int(size[0])