FilesExpand file tree

 master

/

test_pylabtools.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

247 lines (203 loc) · 7.37 KB

 master

/

test_pylabtools.py

Copy path

Top

File metadata and controls

• Code
• Blame

247 lines (203 loc) · 7.37 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

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

"""Tests for pylab tools module.

"""

# Copyright (c) IPython Development Team.

# Distributed under the terms of the Modified BSD License.

from __future__ import print_function

from io import UnsupportedOperation, BytesIO

import matplotlib

matplotlib.use('Agg')

from matplotlib.figure import Figure

from nose import SkipTest

import nose.tools as nt

from matplotlib import pyplot as plt

import numpy as np

from IPython.core.getipython import get_ipython

from IPython.core.interactiveshell import InteractiveShell

from IPython.core.display import _PNG, _JPEG

from .. import pylabtools as pt

from IPython.testing import decorators as dec

def test_figure_to_svg():

# simple empty-figure test

fig = plt.figure()

nt.assert_equal(pt.print_figure(fig, 'svg'), None)

plt.close('all')

# simple check for at least svg-looking output

fig = plt.figure()

ax = fig.add_subplot(1,1,1)

ax.plot([1,2,3])

plt.draw()

svg = pt.print_figure(fig, 'svg')[:100].lower()

nt.assert_in(u'doctype svg', svg)

def _check_pil_jpeg_bytes():

"""Skip if PIL can't write JPEGs to BytesIO objects"""

# PIL's JPEG plugin can't write to BytesIO objects

# Pillow fixes this

from PIL import Image

buf = BytesIO()

img = Image.new("RGB", (4,4))

try:

img.save(buf, 'jpeg')

except Exception as e:

ename = e.__class__.__name__

raise SkipTest("PIL can't write JPEG to BytesIO: %s: %s" % (ename, e))

@dec.skip_without("PIL.Image")

def test_figure_to_jpeg():

_check_pil_jpeg_bytes()

# simple check for at least jpeg-looking output

fig = plt.figure()

ax = fig.add_subplot(1,1,1)

ax.plot([1,2,3])

plt.draw()

jpeg = pt.print_figure(fig, 'jpeg', quality=50)[:100].lower()

assert jpeg.startswith(_JPEG)

def test_retina_figure():

# simple empty-figure test

fig = plt.figure()

nt.assert_equal(pt.retina_figure(fig), None)

plt.close('all')

fig = plt.figure()

ax = fig.add_subplot(1,1,1)

ax.plot([1,2,3])

plt.draw()

png, md = pt.retina_figure(fig)

assert png.startswith(_PNG)

nt.assert_in('width', md)

nt.assert_in('height', md)

_fmt_mime_map = {

'png': 'image/png',

'jpeg': 'image/jpeg',

'pdf': 'application/pdf',

'retina': 'image/png',

'svg': 'image/svg+xml',

}

def test_select_figure_formats_str():

ip = get_ipython()

for fmt, active_mime in _fmt_mime_map.items():

pt.select_figure_formats(ip, fmt)

for mime, f in ip.display_formatter.formatters.items():

if mime == active_mime:

nt.assert_in(Figure, f)

else:

nt.assert_not_in(Figure, f)

def test_select_figure_formats_kwargs():

ip = get_ipython()

kwargs = dict(quality=10, bbox_inches='tight')

pt.select_figure_formats(ip, 'png', **kwargs)

formatter = ip.display_formatter.formatters['image/png']

f = formatter.lookup_by_type(Figure)

cell = f.__closure__[0].cell_contents

nt.assert_equal(cell, kwargs)

# check that the formatter doesn't raise

fig = plt.figure()

ax = fig.add_subplot(1,1,1)

ax.plot([1,2,3])

plt.draw()

formatter.enabled = True

png = formatter(fig)

assert png.startswith(_PNG)

def test_select_figure_formats_set():

ip = get_ipython()

for fmts in [

{'png', 'svg'},

['png'],

('jpeg', 'pdf', 'retina'),

{'svg'},

]:

active_mimes = {_fmt_mime_map[fmt] for fmt in fmts}

pt.select_figure_formats(ip, fmts)

for mime, f in ip.display_formatter.formatters.items():

if mime in active_mimes:

nt.assert_in(Figure, f)

else:

nt.assert_not_in(Figure, f)

def test_select_figure_formats_bad():

ip = get_ipython()

with nt.assert_raises(ValueError):

pt.select_figure_formats(ip, 'foo')

with nt.assert_raises(ValueError):

pt.select_figure_formats(ip, {'png', 'foo'})

with nt.assert_raises(ValueError):

pt.select_figure_formats(ip, ['retina', 'pdf', 'bar', 'bad'])

def test_import_pylab():

ns = {}

pt.import_pylab(ns, import_all=False)

nt.assert_true('plt' in ns)

nt.assert_equal(ns['np'], np)

class TestPylabSwitch(object):

class Shell(InteractiveShell):

def enable_gui(self, gui):

pass

def setup(self):

import matplotlib

def act_mpl(backend):

matplotlib.rcParams['backend'] = backend

# Save rcParams since they get modified

self._saved_rcParams = matplotlib.rcParams

self._saved_rcParamsOrig = matplotlib.rcParamsOrig

matplotlib.rcParams = dict(backend='Qt4Agg')

matplotlib.rcParamsOrig = dict(backend='Qt4Agg')

# Mock out functions

self._save_am = pt.activate_matplotlib

pt.activate_matplotlib = act_mpl

self._save_ip = pt.import_pylab

pt.import_pylab = lambda *a,**kw:None

self._save_cis = pt.configure_inline_support

pt.configure_inline_support = lambda *a,**kw:None

def teardown(self):

pt.activate_matplotlib = self._save_am

pt.import_pylab = self._save_ip

pt.configure_inline_support = self._save_cis

import matplotlib

matplotlib.rcParams = self._saved_rcParams

matplotlib.rcParamsOrig = self._saved_rcParamsOrig

def test_qt(self):

s = self.Shell()

gui, backend = s.enable_matplotlib(None)

nt.assert_equal(gui, 'qt')

nt.assert_equal(s.pylab_gui_select, 'qt')

gui, backend = s.enable_matplotlib('inline')

nt.assert_equal(gui, 'inline')

nt.assert_equal(s.pylab_gui_select, 'qt')

gui, backend = s.enable_matplotlib('qt')

nt.assert_equal(gui, 'qt')

nt.assert_equal(s.pylab_gui_select, 'qt')

gui, backend = s.enable_matplotlib('inline')

nt.assert_equal(gui, 'inline')

nt.assert_equal(s.pylab_gui_select, 'qt')

gui, backend = s.enable_matplotlib()

nt.assert_equal(gui, 'qt')

nt.assert_equal(s.pylab_gui_select, 'qt')

def test_inline(self):

s = self.Shell()

gui, backend = s.enable_matplotlib('inline')

nt.assert_equal(gui, 'inline')

nt.assert_equal(s.pylab_gui_select, None)

gui, backend = s.enable_matplotlib('inline')

nt.assert_equal(gui, 'inline')

nt.assert_equal(s.pylab_gui_select, None)

gui, backend = s.enable_matplotlib('qt')

nt.assert_equal(gui, 'qt')

nt.assert_equal(s.pylab_gui_select, 'qt')

def test_inline_twice(self):

"Using '%matplotlib inline' twice should not reset formatters"

ip = self.Shell()

gui, backend = ip.enable_matplotlib('inline')

nt.assert_equal(gui, 'inline')

fmts = {'png'}

active_mimes = {_fmt_mime_map[fmt] for fmt in fmts}

pt.select_figure_formats(ip, fmts)

gui, backend = ip.enable_matplotlib('inline')

nt.assert_equal(gui, 'inline')

for mime, f in ip.display_formatter.formatters.items():

if mime in active_mimes:

nt.assert_in(Figure, f)

else:

nt.assert_not_in(Figure, f)

def test_qt_gtk(self):

s = self.Shell()

gui, backend = s.enable_matplotlib('qt')

nt.assert_equal(gui, 'qt')

nt.assert_equal(s.pylab_gui_select, 'qt')

gui, backend = s.enable_matplotlib('gtk')

nt.assert_equal(gui, 'qt')

nt.assert_equal(s.pylab_gui_select, 'qt')