'legal': (8.5, 14),

'ledger': (11, 17),

'a0': (33.11, 46.81),

'a1': (23.39, 33.11),

'a2': (16.54, 23.39),

'a3': (11.69, 16.54),

'a4': (8.27, 11.69),

'a5': (5.83, 8.27),

'a6': (4.13, 5.83),

'a7': (2.91, 4.13),

'a8': (2.07, 2.91),

'a9': (1.457, 2.05),

'a10': (1.02, 1.457),

'b0': (40.55, 57.32),

'b1': (28.66, 40.55),

'b2': (20.27, 28.66),

'b3': (14.33, 20.27),

'b4': (10.11, 14.33),

'b5': (7.16, 10.11),

'b6': (5.04, 7.16),

'b7': (3.58, 5.04),

'b8': (2.51, 3.58),

'b9': (1.76, 2.51),

for key, (pw, ph) in sorted(papersize.items(), reverse=True):

if key.startswith('l'):

continue

if w < pw and h < ph:

return key

if isinstance(val, str):

return val

ival = int(val)

if val == ival:

return str(ival)

s = "%1.3f" % val

s = s.rstrip("0")

s = s.rstrip(".")

"""

s = s.replace(b"\\", b"\\\\")

s = s.replace(b"(", b"\\(")

s = s.replace(b")", b"\\)")

s = s.replace(b"'", b"\\251")

s = s.replace(b"`", b"\\301")

s = re.sub(br"[^ -~\n]", lambda x: br"\%03o" % ord(x.group()), s)

"""

if is_writable_file_like(dst):

fh = (open(src, 'r', encoding='latin-1')

if file_requires_unicode(dst)

else open(src, 'rb'))

with fh:

shutil.copyfileobj(fh, dst)

else:

"""

_afm_font_dir = cbook._get_data_path("fonts/afm")

_use_afm_rc_name = "ps.useafm"

def __init__(self, width, height, pswriter, imagedpi=72):

# Although postscript itself is dpi independent, we need to inform the

# image code about a requested dpi to generate high resolution images

# and them scale them before embedding them.

super().__init__(width, height)

self._pswriter = pswriter

if mpl.rcParams['text.usetex']:

self.textcnt = 0

self.psfrag = []

self.imagedpi = imagedpi

# current renderer state (None=uninitialised)

self.color = None

self.linewidth = None

self.linejoin = None

self.linecap = None

self.linedash = None

self.fontname = None

self.fontsize = None

self._hatches = {}

self.image_magnification = imagedpi / 72

self._clip_paths = {}

self._path_collection_id = 0

self._character_tracker = _backend_pdf_ps.CharacterTracker()

self.mathtext_parser = MathTextParser("PS")

@cbook.deprecated("3.3")

@property

def used_characters(self):

return self._character_tracker.used_characters

@cbook.deprecated("3.3")

def track_characters(self, *args, **kwargs):

"""Keep track of which characters are required from each font."""

self._character_tracker.track(*args, **kwargs)

@cbook.deprecated("3.3")

def merge_used_characters(self, *args, **kwargs):

self._character_tracker.merge(*args, **kwargs)

def set_color(self, r, g, b, store=True):

if (r, g, b) != self.color:

if r == g and r == b:

self._pswriter.write("%1.3f setgray\n" % r)

else:

self._pswriter.write(

"%1.3f %1.3f %1.3f setrgbcolor\n" % (r, g, b))

if store:

self.color = (r, g, b)

def set_linewidth(self, linewidth, store=True):

linewidth = float(linewidth)

if linewidth != self.linewidth:

self._pswriter.write("%1.3f setlinewidth\n" % linewidth)

if store:

self.linewidth = linewidth

def set_linejoin(self, linejoin, store=True):

if linejoin != self.linejoin:

self._pswriter.write("%d setlinejoin\n" % linejoin)

if store:

self.linejoin = linejoin

def set_linecap(self, linecap, store=True):

if linecap != self.linecap:

self._pswriter.write("%d setlinecap\n" % linecap)

if store:

self.linecap = linecap

def set_linedash(self, offset, seq, store=True):

if self.linedash is not None:

oldo, oldseq = self.linedash

if np.array_equal(seq, oldseq) and oldo == offset:

return

if seq is not None and len(seq):

s = "[%s] %d setdash\n" % (_nums_to_str(*seq), offset)

self._pswriter.write(s)

else:

self._pswriter.write("[] 0 setdash\n")

if store:

self.linedash = (offset, seq)

def set_font(self, fontname, fontsize, store=True):

if mpl.rcParams['ps.useafm']:

return

if (fontname, fontsize) != (self.fontname, self.fontsize):

out = ("/%s findfont\n"

"%1.3f scalefont\n"

"setfont\n" % (fontname, fontsize))

self._pswriter.write(out)

if store:

self.fontname = fontname

self.fontsize = fontsize

def create_hatch(self, hatch):

sidelen = 72

if hatch in self._hatches:

return self._hatches[hatch]

name = 'H%d' % len(self._hatches)

linewidth = mpl.rcParams['hatch.linewidth']

pageheight = self.height * 72

self._pswriter.write(f"""\

""")

self._hatches[hatch] = name

return name

def get_image_magnification(self):

"""

return self.image_magnification

def draw_image(self, gc, x, y, im, transform=None):

# docstring inherited

h, w = im.shape[:2]

imagecmd = "false 3 colorimage"

data = im[::-1, :, :3] # Vertically flipped rgb values.

# data.tobytes().hex() has no spaces, so can be linewrapped by simply

# splitting data every nchars. It's equivalent to textwrap.fill only

# much faster.

nchars = 128

data = data.tobytes().hex()

hexlines = "\n".join(

[

data[n * nchars:(n + 1) * nchars]

for n in range(math.ceil(len(data) / nchars))

]

)

if transform is None:

matrix = "1 0 0 1 0 0"

xscale = w / self.image_magnification

yscale = h / self.image_magnification

else:

matrix = " ".join(map(str, transform.frozen().to_values()))

xscale = 1.0

yscale = 1.0

bbox = gc.get_clip_rectangle()

clippath, clippath_trans = gc.get_clip_path()

clip = []

if bbox is not None:

clip.append('%s clipbox' % _nums_to_str(*bbox.size, *bbox.p0))

if clippath is not None:

id = self._get_clip_path(clippath, clippath_trans)

clip.append('%s' % id)

clip = '\n'.join(clip)

self._pswriter.write(f"""\

""")

def _convert_path(self, path, transform, clip=False, simplify=None):

if clip:

clip = (0.0, 0.0, self.width * 72.0, self.height * 72.0)

else:

clip = None

return _path.convert_to_string(

path, transform, clip, simplify, None,

6, [b'm', b'l', b'', b'c', b'cl'], True).decode('ascii')

def _get_clip_path(self, clippath, clippath_transform):

key = (clippath, id(clippath_transform))

pid = self._clip_paths.get(key)

if pid is None:

pid = 'c%x' % len(self._clip_paths)

clippath_bytes = self._convert_path(

clippath, clippath_transform, simplify=False)

self._pswriter.write(f"""\

""")

self._clip_paths[key] = pid

return pid

def draw_path(self, gc, path, transform, rgbFace=None):

# docstring inherited

clip = rgbFace is None and gc.get_hatch_path() is None

simplify = path.should_simplify and clip

ps = self._convert_path(path, transform, clip=clip, simplify=simplify)

self._draw_ps(ps, gc, rgbFace)

def draw_markers(

self, gc, marker_path, marker_trans, path, trans, rgbFace=None):

# docstring inherited

if debugPS:

self._pswriter.write('% draw_markers \n')

ps_color = (

None

if _is_transparent(rgbFace)

else '%1.3f setgray' % rgbFace[0]

if rgbFace[0] == rgbFace[1] == rgbFace[2]

else '%1.3f %1.3f %1.3f setrgbcolor' % rgbFace[:3])

# construct the generic marker command:

# don't want the translate to be global

ps_cmd = ['/o {', 'gsave', 'newpath', 'translate']

lw = gc.get_linewidth()

alpha = (gc.get_alpha()

if gc.get_forced_alpha() or len(gc.get_rgb()) == 3

else gc.get_rgb()[3])

stroke = lw > 0 and alpha > 0

if stroke:

ps_cmd.append('%.1f setlinewidth' % lw)

jint = gc.get_joinstyle()

ps_cmd.append('%d setlinejoin' % jint)

cint = gc.get_capstyle()

ps_cmd.append('%d setlinecap' % cint)

ps_cmd.append(self._convert_path(marker_path, marker_trans,

simplify=False))

if rgbFace:

if stroke:

ps_cmd.append('gsave')

if ps_color:

ps_cmd.extend([ps_color, 'fill'])

if stroke:

ps_cmd.append('grestore')

if stroke:

ps_cmd.append('stroke')

ps_cmd.extend(['grestore', '} bind def'])

for vertices, code in path.iter_segments(

trans,

clip=(0, 0, self.width*72, self.height*72),

simplify=False):

if len(vertices):

x, y = vertices[-2:]

ps_cmd.append("%g %g o" % (x, y))

ps = '\n'.join(ps_cmd)

self._draw_ps(ps, gc, rgbFace, fill=False, stroke=False)

def draw_path_collection(self, gc, master_transform, paths, all_transforms,

offsets, offsetTrans, facecolors, edgecolors,

linewidths, linestyles, antialiaseds, urls,

offset_position):

# Is the optimization worth it? Rough calculation:

# cost of emitting a path in-line is

# (len_path + 2) * uses_per_path

# cost of definition+use is

# (len_path + 3) + 3 * uses_per_path

len_path = len(paths[0].vertices) if len(paths) > 0 else 0

uses_per_path = self._iter_collection_uses_per_path(

paths, all_transforms, offsets, facecolors, edgecolors)

should_do_optimization = \

len_path + 3 * uses_per_path + 3 < (len_path + 2) * uses_per_path

if not should_do_optimization:

return RendererBase.draw_path_collection(

self, gc, master_transform, paths, all_transforms,

offsets, offsetTrans, facecolors, edgecolors,

linewidths, linestyles, antialiaseds, urls,

offset_position)

path_codes = []

for i, (path, transform) in enumerate(self._iter_collection_raw_paths(

master_transform, paths, all_transforms)):

name = 'p%x_%x' % (self._path_collection_id, i)

path_bytes = self._convert_path(path, transform, simplify=False)

self._pswriter.write(f"""\

""")

path_codes.append(name)

for xo, yo, path_id, gc0, rgbFace in self._iter_collection(

gc, master_transform, all_transforms, path_codes, offsets,

offsetTrans, facecolors, edgecolors, linewidths, linestyles,

antialiaseds, urls, offset_position):

ps = "%g %g %s" % (xo, yo, path_id)

self._draw_ps(ps, gc0, rgbFace)

self._path_collection_id += 1

def draw_tex(self, gc, x, y, s, prop, angle, ismath='TeX!', mtext=None):

# docstring inherited

if not hasattr(self, "psfrag"):

_log.warning(

"The PS backend determines usetex status solely based on "

"rcParams['text.usetex'] and does not support having "

"usetex=True only for some elements; this element will thus "

"be rendered as if usetex=False.")

self.draw_text(gc, x, y, s, prop, angle, ismath, mtext)

return

w, h, bl = self.get_text_width_height_descent(s, prop, ismath)

fontsize = prop.get_size_in_points()

thetext = 'psmarker%d' % self.textcnt

color = '%1.3f,%1.3f,%1.3f' % gc.get_rgb()[:3]

fontcmd = {'sans-serif': r'{\sffamily %s}',

'monospace': r'{\ttfamily %s}'}.get(

mpl.rcParams['font.family'][0], r'{\rmfamily %s}')

s = fontcmd % s

tex = r'\color[rgb]{%s} %s' % (color, s)

corr = 0 # w/2*(fontsize-10)/10

if dict.__getitem__(mpl.rcParams, 'text.latex.preview'):

# use baseline alignment!

pos = _nums_to_str(x-corr, y)

self.psfrag.append(

r'\psfrag{%s}[Bl][Bl][1][%f]{\fontsize{%f}{%f}%s}' % (

thetext, angle, fontsize, fontsize*1.25, tex))

else:

# Stick to the bottom alignment.

pos = _nums_to_str(x-corr, y-bl)

self.psfrag.append(

r'\psfrag{%s}[bl][bl][1][%f]{\fontsize{%f}{%f}%s}' % (

thetext, angle, fontsize, fontsize*1.25, tex))

self._pswriter.write(f"""\

""")

self.textcnt += 1

def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):

# docstring inherited

if debugPS:

self._pswriter.write("% text\n")

if _is_transparent(gc.get_rgb()):

return # Special handling for fully transparent.

if ismath == 'TeX':

return self.draw_tex(gc, x, y, s, prop, angle)

elif ismath:

return self.draw_mathtext(gc, x, y, s, prop, angle)

elif mpl.rcParams['ps.useafm']:

self.set_color(*gc.get_rgb())

font = self._get_font_afm(prop)

fontname = font.get_fontname()

fontsize = prop.get_size_in_points()

scale = 0.001 * fontsize

thisx = 0

thisy = font.get_str_bbox_and_descent(s)[4] * scale

last_name = None

lines = []

for c in s:

name = uni2type1.get(ord(c), f"uni{ord(c):04X}")

try:

width = font.get_width_from_char_name(name)

except KeyError:

name = 'question'

width = font.get_width_char('?')

if last_name is not None:

kern = font.get_kern_dist_from_name(last_name, name)

else:

kern = 0

last_name = name

thisx += kern * scale

lines.append('%f %f m /%s glyphshow' % (thisx, thisy, name))

thisx += width * scale

thetext = "\n".join(lines)

self._pswriter.write(f"""\

""")

else:

font = self._get_font_ttf(prop)

font.set_text(s, 0, flags=LOAD_NO_HINTING)

self._character_tracker.track(font, s)

self.set_color(*gc.get_rgb())

ps_name = (font.postscript_name

.encode('ascii', 'replace').decode('ascii'))

self.set_font(ps_name, prop.get_size_in_points())

thetext = '\n'.join(

'%f 0 m /%s glyphshow' % (x, font.get_glyph_name(glyph_idx))

for glyph_idx, x in _text_layout.layout(s, font))

self._pswriter.write(f"""\

""")

def new_gc(self):

# docstring inherited

return GraphicsContextPS()

def draw_mathtext(self, gc, x, y, s, prop, angle):

"""Draw the math text using matplotlib.mathtext."""

if debugPS:

self._pswriter.write("% mathtext\n")

width, height, descent, pswriter, used_characters = \

self.mathtext_parser.parse(s, 72, prop)

self._character_tracker.merge(used_characters)

self.set_color(*gc.get_rgb())

thetext = pswriter.getvalue()

self._pswriter.write(f"""\

""")

def draw_gouraud_triangle(self, gc, points, colors, trans):

self.draw_gouraud_triangles(gc, points.reshape((1, 3, 2)),

colors.reshape((1, 3, 4)), trans)

def draw_gouraud_triangles(self, gc, points, colors, trans):

assert len(points) == len(colors)

assert points.ndim == 3

assert points.shape[1] == 3

assert points.shape[2] == 2

assert colors.ndim == 3

assert colors.shape[1] == 3

assert colors.shape[2] == 4

shape = points.shape

flat_points = points.reshape((shape[0] * shape[1], 2))

flat_points = trans.transform(flat_points)

flat_colors = colors.reshape((shape[0] * shape[1], 4))

points_min = np.min(flat_points, axis=0) - (1 << 12)

points_max = np.max(flat_points, axis=0) + (1 << 12)

factor = np.ceil((2 ** 32 - 1) / (points_max - points_min))

xmin, ymin = points_min

xmax, ymax = points_max

streamarr = np.empty(

shape[0] * shape[1],

dtype=[('flags', 'u1'), ('points', '2>u4'), ('colors', '3u1')])

streamarr['flags'] = 0

streamarr['points'] = (flat_points - points_min) * factor

streamarr['colors'] = flat_colors[:, :3] * 255.0

stream = quote_ps_string(streamarr.tobytes())

self._pswriter.write(f"""\

""")

def _draw_ps(self, ps, gc, rgbFace, fill=True, stroke=True, command=None):

"""

# local variable eliminates all repeated attribute lookups

write = self._pswriter.write

if debugPS and command:

write("% "+command+"\n")

mightstroke = (gc.get_linewidth() > 0

and not _is_transparent(gc.get_rgb()))

if not mightstroke:

stroke = False

if _is_transparent(rgbFace):

fill = False

hatch = gc.get_hatch()

if mightstroke:

self.set_linewidth(gc.get_linewidth())

jint = gc.get_joinstyle()

self.set_linejoin(jint)

cint = gc.get_capstyle()

self.set_linecap(cint)

self.set_linedash(*gc.get_dashes())

self.set_color(*gc.get_rgb()[:3])

write('gsave\n')

cliprect = gc.get_clip_rectangle()

if cliprect:

write('%1.4g %1.4g %1.4g %1.4g clipbox\n'

% (*cliprect.size, *cliprect.p0))

clippath, clippath_trans = gc.get_clip_path()

if clippath:

id = self._get_clip_path(clippath, clippath_trans)

write('%s\n' % id)

# Jochen, is the strip necessary? - this could be a honking big string

write(ps.strip())

write("\n")

if fill:

if stroke or hatch:

write("gsave\n")

self.set_color(*rgbFace[:3], store=False)

write("fill\n")

if stroke or hatch:

write("grestore\n")

if hatch:

hatch_name = self.create_hatch(hatch)

write("gsave\n")

write("%f %f %f " % gc.get_hatch_color()[:3])

write("%s setpattern fill grestore\n" % hatch_name)

if stroke:

write("stroke\n")

if rgb_or_rgba is None:

return True # Consistent with rgbFace semantics.

elif len(rgb_or_rgba) == 4:

if rgb_or_rgba[3] == 0:

return True

if rgb_or_rgba[3] != 1:

_log.warning(

"The PostScript backend does not support transparency; "

"partially transparent artists will be rendered opaque.")

return False

else: # len() == 3.

def get_capstyle(self):

return {'butt': 0, 'round': 1, 'projecting': 2}[

GraphicsContextBase.get_capstyle(self)]

def get_joinstyle(self):

return {'miter': 0, 'round': 1, 'bevel': 2}[

portrait, landscape = range(2)

def swap_if_landscape(self, shape):

fixed_dpi = 72

filetypes = {'ps': 'Postscript',

'eps': 'Encapsulated Postscript'}

def get_default_filetype(self):

return 'ps'

def print_ps(self, outfile, *args, **kwargs):

return self._print_ps(outfile, 'ps', *args, **kwargs)

def print_eps(self, outfile, *args, **kwargs):

return self._print_ps(outfile, 'eps', *args, **kwargs)

def _print_ps(

self, outfile, format, *args,

dpi=72, metadata=None, papertype=None, orientation='portrait',

**kwargs):

self.figure.set_dpi(72) # Override the dpi kwarg

dsc_comments = {}

if isinstance(outfile, (str, os.PathLike)):

dsc_comments["Title"] = \

os.fspath(outfile).encode("ascii", "replace").decode("ascii")

dsc_comments["Creator"] = (metadata or {}).get(

"Creator",

f"matplotlib version {mpl.__version__}, http://matplotlib.org/")

# See https://reproducible-builds.org/specs/source-date-epoch/

source_date_epoch = os.getenv("SOURCE_DATE_EPOCH")

dsc_comments["CreationDate"] = (

datetime.datetime.utcfromtimestamp(

int(source_date_epoch)).strftime("%a %b %d %H:%M:%S %Y")

if source_date_epoch

else time.ctime())

dsc_comments = "\n".join(

f"%%{k}: {v}" for k, v in dsc_comments.items())

if papertype is None:

papertype = mpl.rcParams['ps.papersize']

papertype = papertype.lower()

cbook._check_in_list(['auto', *papersize], papertype=papertype)

orientation = cbook._check_getitem(

_Orientation, orientation=orientation.lower())

printer = (self._print_figure_tex

if mpl.rcParams['text.usetex'] else

self._print_figure)

printer(outfile, format, dpi=dpi, dsc_comments=dsc_comments,

orientation=orientation, papertype=papertype, **kwargs)

@cbook._delete_parameter("3.2", "dryrun")

def _print_figure(

self, outfile, format, *,

dpi, dsc_comments, orientation, papertype,

dryrun=False, bbox_inches_restore=None, **kwargs):

"""

is_eps = format == 'eps'

if isinstance(outfile, (str, os.PathLike)):

outfile = os.fspath(outfile)

passed_in_file_object = False

elif is_writable_file_like(outfile):

passed_in_file_object = True

else:

raise ValueError("outfile must be a path or a file-like object")

# find the appropriate papertype

width, height = self.figure.get_size_inches()

if papertype == 'auto':

papertype = _get_papertype(

*orientation.swap_if_landscape((width, height)))

paper_width, paper_height = orientation.swap_if_landscape(

papersize[papertype])

if mpl.rcParams['ps.usedistiller']:

# distillers improperly clip eps files if pagesize is too small

if width > paper_width or height > paper_height:

papertype = _get_papertype(

*orientation.swap_if_landscape(width, height))

paper_width, paper_height = orientation.swap_if_landscape(

papersize[papertype])

# center the figure on the paper

xo = 72 * 0.5 * (paper_width - width)

yo = 72 * 0.5 * (paper_height - height)

llx = xo

lly = yo

urx = llx + self.figure.bbox.width

ury = lly + self.figure.bbox.height

rotation = 0

if orientation is _Orientation.landscape:

llx, lly, urx, ury = lly, llx, ury, urx

xo, yo = 72 * paper_height - yo, xo

rotation = 90

bbox = (llx, lly, urx, ury)

if dryrun:

class NullWriter:

def write(self, *args, **kwargs):

pass

self._pswriter = NullWriter()

else:

self._pswriter = StringIO()

# mixed mode rendering

ps_renderer = RendererPS(width, height, self._pswriter, imagedpi=dpi)

renderer = MixedModeRenderer(

self.figure, width, height, dpi, ps_renderer,

bbox_inches_restore=bbox_inches_restore)

self.figure.draw(renderer)

if dryrun: # return immediately if dryrun (tightbbox=True)

return

def print_figure_impl(fh):

# write the PostScript headers

if is_eps:

print("%!PS-Adobe-3.0 EPSF-3.0", file=fh)

else:

print(f"%!PS-Adobe-3.0\n"

f"%%DocumentPaperSizes: {papertype}\n"

f"%%Pages: 1\n",

end="", file=fh)

print(f"{dsc_comments}\n"

f"%%Orientation: {orientation.name}\n"

f"%%BoundingBox: {bbox[0]} {bbox[1]} {bbox[2]} {bbox[3]}\n"

f"%%EndComments\n",

end="", file=fh)

Ndict = len(psDefs)

print("%%BeginProlog", file=fh)

if not mpl.rcParams['ps.useafm']:

Ndict += len(ps_renderer._character_tracker.used)

print("/mpldict %d dict def" % Ndict, file=fh)

print("mpldict begin", file=fh)

print("\n".join(psDefs), file=fh)

if not mpl.rcParams['ps.useafm']:

for font_path, chars \

in ps_renderer._character_tracker.used.items():

if not chars:

continue

font = get_font(font_path)

glyph_ids = [font.get_char_index(c) for c in chars]

fonttype = mpl.rcParams['ps.fonttype']

# Can't use more than 255 chars from a single Type 3 font.

if len(glyph_ids) > 255:

fonttype = 42

# The ttf to ps (subsetting) support doesn't work for

# OpenType fonts that are Postscript inside (like the STIX

# fonts). This will simply turn that off to avoid errors.

if is_opentype_cff_font(font_path):

raise RuntimeError(

"OpenType CFF fonts can not be saved using "

"the internal Postscript backend at this "

"time; consider using the Cairo backend")

fh.flush()

try:

convert_ttf_to_ps(os.fsencode(font_path),

fh, fonttype, glyph_ids)

except RuntimeError:

_log.warning("The PostScript backend does not "

"currently support the selected font.")

raise

print("end", file=fh)

print("%%EndProlog", file=fh)

if not is_eps:

print("%%Page: 1 1", file=fh)

print("mpldict begin", file=fh)

print("%s translate" % _nums_to_str(xo, yo), file=fh)

if rotation:

print("%d rotate" % rotation, file=fh)

print("%s clipbox" % _nums_to_str(width*72, height*72, 0, 0),

file=fh)

# write the figure

print(self._pswriter.getvalue(), file=fh)

# write the trailer

print("end", file=fh)

print("showpage", file=fh)

if not is_eps:

print("%%EOF", file=fh)

fh.flush()

if mpl.rcParams['ps.usedistiller']:

# We are going to use an external program to process the output.

# Write to a temporary file.

with TemporaryDirectory() as tmpdir:

tmpfile = os.path.join(tmpdir, "tmp.ps")

with open(tmpfile, 'w', encoding='latin-1') as fh:

print_figure_impl(fh)

if mpl.rcParams['ps.usedistiller'] == 'ghostscript':

_try_distill(gs_distill,

tmpfile, is_eps, ptype=papertype, bbox=bbox)

elif mpl.rcParams['ps.usedistiller'] == 'xpdf':

_try_distill(xpdf_distill,

tmpfile, is_eps, ptype=papertype, bbox=bbox)

_move_path_to_path_or_stream(tmpfile, outfile)

else:

# Write directly to outfile.

if passed_in_file_object:

requires_unicode = file_requires_unicode(outfile)

if not requires_unicode:

fh = TextIOWrapper(outfile, encoding="latin-1")

# Prevent the TextIOWrapper from closing the underlying

# file.

fh.close = lambda: None

else:

fh = outfile

print_figure_impl(fh)

else:

with open(outfile, 'w', encoding='latin-1') as fh:

print_figure_impl(fh)

@cbook._delete_parameter("3.2", "dryrun")

def _print_figure_tex(

self, outfile, format, *,

dpi, dsc_comments, orientation, papertype,

dryrun=False, bbox_inches_restore=None, **kwargs):

"""

is_eps = format == 'eps'