content_offset, block_text, state, state_machine):

"""Implementation of the ``.. plot::`` directive.

if not arg or not arg.strip():

# no argument given, assume used as a flag

return True

elif arg.strip().lower() in ('no', '0', 'false'):

return False

elif arg.strip().lower() in ('yes', '1', 'true'):

return True

else:

"""

for name, explicit in document.nametypes.items():

if not explicit:

continue

labelid = document.nameids[name]

if labelid is None:

continue

node = document.ids[labelid]

if node.tagname in ('html_only', 'latex_only'):

for n in node:

if n.tagname == 'figure':

sectname = name

for c in n:

if c.tagname == 'caption':

sectname = c.astext()

break

node['ids'].remove(labelid)

node['names'].remove(name)

n['ids'].append(labelid)

n['names'].append(name)

document.settings.env.labels[name] = \

document.settings.env.docname, labelid, sectname

"""Implementation of the ``.. plot::`` directive.

has_content = True

required_arguments = 0

optional_arguments = 2

final_argument_whitespace = False

option_spec = {

'alt': directives.unchanged,

'height': directives.length_or_unitless,

'width': directives.length_or_percentage_or_unitless,

'scale': directives.nonnegative_int,

'align': _option_align,

'class': directives.class_option,

'include-source': _option_boolean,

'format': _option_format,

'context': _option_context,

'nofigs': directives.flag,

'encoding': directives.encoding,

}

def run(self):

"""Run the plot directive."""

return run(self.arguments, self.content, self.options,

import matplotlib

setup.app = app

setup.config = app.config

setup.confdir = app.confdir

app.add_directive('plot', PlotDirective)

app.add_config_value('plot_pre_code', None, True)

app.add_config_value('plot_include_source', False, True)

app.add_config_value('plot_html_show_source_link', True, True)

app.add_config_value('plot_formats', ['png', 'hires.png', 'pdf'], True)

app.add_config_value('plot_basedir', None, True)

app.add_config_value('plot_html_show_formats', True, True)

app.add_config_value('plot_rcparams', {}, True)

app.add_config_value('plot_apply_rcparams', False, True)

app.add_config_value('plot_working_directory', None, True)

app.add_config_value('plot_template', None, True)

app.connect('doctree-read', mark_plot_labels)

metadata = {'parallel_read_safe': True, 'parallel_write_safe': True,

'version': matplotlib.__version__}

try:

# check if it's valid Python as-is

compile(text, '<string>', 'exec')

return False

except SyntaxError:

pass

r = re.compile(r'^\s*>>>', re.M)

m = r.search(text)

"""

if not contains_doctest(text):

return text

code = ""

for line in text.split("\n"):

m = re.match(r'^\s*(>>>|\.\.\.) (.*)$', line)

if m:

code += m.group(2) + "\n"

elif line.strip():

code += "# " + line.strip() + "\n"

else:

code += "\n"

"""Split code at plt.show()."""

parts = []

is_doctest = contains_doctest(text)

part = []

for line in text.split("\n"):

if (not is_doctest and line.strip() == 'plt.show()') or \

(is_doctest and line.strip() == '>>> plt.show()'):

part.append(line)

parts.append("\n".join(part))

part = []

else:

part.append(line)

if "\n".join(part).strip():

parts.append("\n".join(part))

def __init__(self, basename, dirname):

self.basename = basename

self.dirname = dirname

self.formats = []

def filename(self, format):

return os.path.join(self.dirname, "%s.%s" % (self.basename, format))

def filenames(self):

"""

return (not os.path.exists(derived) or

(os.path.exists(original) and

"""

# Change the working directory to the directory of the example, so

# it can get at its data files, if any. Add its path to sys.path

# so it can import any helper modules sitting beside it.

pwd = os.getcwd()

if setup.config.plot_working_directory is not None:

try:

os.chdir(setup.config.plot_working_directory)

except OSError as err:

raise OSError(str(err) + '\n`plot_working_directory` option in'

'Sphinx configuration file must be a valid '

'directory path')

except TypeError as err:

raise TypeError(str(err) + '\n`plot_working_directory` option in '

'Sphinx configuration file must be a string or '

'None')

elif code_path is not None:

dirname = os.path.abspath(os.path.dirname(code_path))

os.chdir(dirname)

with cbook._setattr_cm(

sys, argv=[code_path], path=[os.getcwd(), *sys.path]), \

contextlib.redirect_stdout(StringIO()):

try:

code = unescape_doctest(code)

if ns is None:

ns = {}

if not ns:

if setup.config.plot_pre_code is None:

exec('import numpy as np\n'

'from matplotlib import pyplot as plt\n', ns)

else:

exec(str(setup.config.plot_pre_code), ns)

if "__main__" in code:

ns['__name__'] = '__main__'

# Patch out non-interactive show() to avoid triggering a warning.

with cbook._setattr_cm(FigureManagerBase, show=lambda self: None):

exec(code, ns)

if function_name is not None:

exec(function_name + "()", ns)

except (Exception, SystemExit):

raise PlotError(traceback.format_exc())

finally:

os.chdir(pwd)

if close:

plt.close('all')

matplotlib.rc_file_defaults()

default_dpi = {'png': 80, 'hires.png': 200, 'pdf': 200}

formats = []

plot_formats = config.plot_formats

for fmt in plot_formats:

if isinstance(fmt, str):

if ':' in fmt:

suffix, dpi = fmt.split(':')

formats.append((str(suffix), int(dpi)))

else:

formats.append((fmt, default_dpi.get(fmt, 80)))

elif isinstance(fmt, (tuple, list)) and len(fmt) == 2:

formats.append((str(fmt[0]), int(fmt[1])))

else:

raise PlotError('invalid image format "%r" in plot_formats' % fmt)

function_name, config, context_reset=False,

close_figs=False):

"""

formats = get_plot_formats(config)

# -- Try to determine if all images already exist

code_pieces = split_code_at_show(code)

# Look for single-figure output files first

all_exists = True

img = ImageFile(output_base, output_dir)

for format, dpi in formats:

if out_of_date(code_path, img.filename(format)):

all_exists = False

break

img.formats.append(format)

if all_exists:

return [(code, [img])]

# Then look for multi-figure output files

results = []

all_exists = True

for i, code_piece in enumerate(code_pieces):

images = []

for j in itertools.count():

if len(code_pieces) > 1:

img = ImageFile('%s_%02d_%02d' % (output_base, i, j),

output_dir)

else:

img = ImageFile('%s_%02d' % (output_base, j), output_dir)

for fmt, dpi in formats:

if out_of_date(code_path, img.filename(fmt)):

all_exists = False

break

img.formats.append(fmt)

# assume that if we have one, we have them all

if not all_exists:

all_exists = (j > 0)

break

images.append(img)

if not all_exists:

break

results.append((code_piece, images))

if all_exists:

return results

# We didn't find the files, so build them

results = []

if context:

ns = plot_context

else:

ns = {}

if context_reset:

clear_state(config.plot_rcparams)

plot_context.clear()

close_figs = not context or close_figs

for i, code_piece in enumerate(code_pieces):

if not context or config.plot_apply_rcparams:

clear_state(config.plot_rcparams, close_figs)

elif close_figs:

plt.close('all')

run_code(code_piece, code_path, ns, function_name)

images = []

fig_managers = _pylab_helpers.Gcf.get_all_fig_managers()

for j, figman in enumerate(fig_managers):

if len(fig_managers) == 1 and len(code_pieces) == 1:

img = ImageFile(output_base, output_dir)

elif len(code_pieces) == 1:

img = ImageFile("%s_%02d" % (output_base, j), output_dir)

else:

img = ImageFile("%s_%02d_%02d" % (output_base, i, j),

output_dir)

images.append(img)

for fmt, dpi in formats:

try:

figman.canvas.figure.savefig(img.filename(fmt), dpi=dpi)

except Exception:

raise PlotError(traceback.format_exc())

img.formats.append(fmt)

results.append((code_piece, images))

if not context or config.plot_apply_rcparams:

clear_state(config.plot_rcparams, close=not context)

document = state_machine.document

config = document.settings.env.config

nofigs = 'nofigs' in options

formats = get_plot_formats(config)

default_fmt = formats[0][0]

options.setdefault('include-source', config.plot_include_source)

keep_context = 'context' in options

context_opt = None if not keep_context else options['context']

rst_file = document.attributes['source']

rst_dir = os.path.dirname(rst_file)

if len(arguments):

if not config.plot_basedir:

source_file_name = os.path.join(setup.app.builder.srcdir,

directives.uri(arguments[0]))

else:

source_file_name = os.path.join(setup.confdir, config.plot_basedir,

directives.uri(arguments[0]))

# If there is content, it will be passed as a caption.

caption = '\n'.join(content)

# If the optional function name is provided, use it

if len(arguments) == 2:

function_name = arguments[1]

else:

function_name = None

code = Path(source_file_name).read_text(encoding='utf-8')

output_base = os.path.basename(source_file_name)

else:

source_file_name = rst_file

code = textwrap.dedent("\n".join(map(str, content)))

counter = document.attributes.get('_plot_counter', 0) + 1

document.attributes['_plot_counter'] = counter

base, ext = os.path.splitext(os.path.basename(source_file_name))

output_base = '%s-%d.py' % (base, counter)

function_name = None

caption = ''

base, source_ext = os.path.splitext(output_base)

if source_ext in ('.py', '.rst', '.txt'):

output_base = base

else:

source_ext = ''

# ensure that LaTeX includegraphics doesn't choke in foo.bar.pdf filenames

output_base = output_base.replace('.', '-')

# is it in doctest format?

is_doctest = contains_doctest(code)

if 'format' in options:

if options['format'] == 'python':

is_doctest = False

else:

is_doctest = True

# determine output directory name fragment

source_rel_name = relpath(source_file_name, setup.confdir)

source_rel_dir = os.path.dirname(source_rel_name)

while source_rel_dir.startswith(os.path.sep):

source_rel_dir = source_rel_dir[1:]

# build_dir: where to place output files (temporarily)

build_dir = os.path.join(os.path.dirname(setup.app.doctreedir),

'plot_directive',

source_rel_dir)

# get rid of .. in paths, also changes pathsep

# see note in Python docs for warning about symbolic links on Windows.

# need to compare source and dest paths at end

build_dir = os.path.normpath(build_dir)

if not os.path.exists(build_dir):

os.makedirs(build_dir)

# output_dir: final location in the builder's directory

dest_dir = os.path.abspath(os.path.join(setup.app.builder.outdir,

source_rel_dir))

if not os.path.exists(dest_dir):

os.makedirs(dest_dir) # no problem here for me, but just use built-ins

# how to link to files from the RST file

dest_dir_link = os.path.join(relpath(setup.confdir, rst_dir),

source_rel_dir).replace(os.path.sep, '/')

try:

build_dir_link = relpath(build_dir, rst_dir).replace(os.path.sep, '/')

except ValueError:

# on Windows, relpath raises ValueError when path and start are on

# different mounts/drives

build_dir_link = build_dir

source_link = dest_dir_link + '/' + output_base + source_ext

# make figures

try:

results = render_figures(code,

source_file_name,

build_dir,

output_base,

keep_context,

function_name,

config,

context_reset=context_opt == 'reset',

close_figs=context_opt == 'close-figs')

errors = []

except PlotError as err:

reporter = state.memo.reporter

sm = reporter.system_message(

2, "Exception occurred in plotting {}\n from {}:\n{}".format(

output_base, source_file_name, err),

line=lineno)

results = [(code, [])]

errors = [sm]

# Properly indent the caption

caption = '\n'.join(' ' + line.strip()

for line in caption.split('\n'))

# generate output restructuredtext

total_lines = []

for j, (code_piece, images) in enumerate(results):

if options['include-source']:

if is_doctest:

lines = ['', *code_piece.splitlines()]

else:

lines = ['.. code-block:: python', '',

*textwrap.indent(code_piece, ' ').splitlines()]

source_code = "\n".join(lines)

else:

source_code = ""

if nofigs:

images = []

opts = [

':%s: %s' % (key, val) for key, val in options.items()

if key in ('alt', 'height', 'width', 'scale', 'align', 'class')]

# Not-None src_link signals the need for a source link in the generated

# html

if j == 0 and config.plot_html_show_source_link:

src_link = source_link

else:

src_link = None

result = jinja2.Template(config.plot_template or TEMPLATE).render(

default_fmt=default_fmt,

dest_dir=dest_dir_link,

build_dir=build_dir_link,

source_link=src_link,

multi_image=len(images) > 1,

options=opts,

images=images,

source_code=source_code,

html_show_formats=config.plot_html_show_formats and len(images),

caption=caption)

total_lines.extend(result.split("\n"))

total_lines.extend("\n")

if total_lines:

state_machine.insert_input(total_lines, source=source_file_name)

# copy image files to builder's output directory, if necessary

Path(dest_dir).mkdir(parents=True, exist_ok=True)

for code_piece, images in results:

for img in images:

for fn in img.filenames():

destimg = os.path.join(dest_dir, os.path.basename(fn))

if fn != destimg:

shutil.copyfile(fn, destimg)

# copy script (if necessary)

Path(dest_dir, output_base + source_ext).write_text(

unescape_doctest(code) if source_file_name == rst_file else code,

encoding='utf-8')