chatExcel

import os from pathlib import Path import platform import re import shutil import subprocess import sys import weakref import numpy as np import pytest import matplotlib as mpl from matplotlib import pyplot as plt from matplotlib import animation from matplotlib.testing.decorators import check_figures_equal @pytest.fixture() def anim(request): """Create a simple animation (with options).""" fig, ax = plt.subplots() line, = ax.plot([], []) ax.set_xlim(0, 10) ax.set_ylim(-1, 1) def init(): line.set_data([], []) return line, def animate(i): x = np.linspace(0, 10, 100) y = np.sin(x + i) line.set_data(x, y) return line, # "klass" can be passed to determine the class returned by the fixture kwargs = dict(getattr(request, 'param', {})) # make a copy klass = kwargs.pop('klass', animation.FuncAnimation) if 'frames' not in kwargs: kwargs['frames'] = 5 return klass(fig=fig, func=animate, init_func=init, **kwargs) class NullMovieWriter(animation.AbstractMovieWriter): """ A minimal MovieWriter. It doesn't actually write anything. It just saves the arguments that were given to the setup() and grab_frame() methods as attributes, and counts how many times grab_frame() is called. This class doesn't have an __init__ method with the appropriate signature, and it doesn't define an isAvailable() method, so it cannot be added to the 'writers' registry. """ def setup(self, fig, outfile, dpi, *args): self.fig = fig self.outfile = outfile self.dpi = dpi self.args = args self._count = 0 def grab_frame(self, **savefig_kwargs): from matplotlib.animation import _validate_grabframe_kwargs _validate_grabframe_kwargs(savefig_kwargs) self.savefig_kwargs = savefig_kwargs self._count += 1 def finish(self): pass def test_null_movie_writer(anim): # Test running an animation with NullMovieWriter. plt.rcParams["savefig.facecolor"] = "auto" filename = "unused.null" dpi = 50 savefig_kwargs = dict(foo=0) writer = NullMovieWriter() anim.save(filename, dpi=dpi, writer=writer, savefig_kwargs=savefig_kwargs) assert writer.fig == plt.figure(1) # The figure used by anim fixture assert writer.outfile == filename assert writer.dpi == dpi assert writer.args == () # we enrich the savefig kwargs to ensure we composite transparent # output to an opaque background for k, v in savefig_kwargs.items(): assert writer.savefig_kwargs[k] == v assert writer._count == anim._save_count @pytest.mark.parametrize('anim', [dict(klass=dict)], indirect=['anim']) def test_animation_delete(anim): if platform.python_implementation() == 'PyPy': # Something in the test setup fixture lingers around into the test and # breaks pytest.warns on PyPy. This garbage collection fixes it. # https://foss.heptapod.net/pypy/pypy/-/issues/3536 np.testing.break_cycles() anim = animation.FuncAnimation(**anim) with pytest.warns(Warning, match='Animation was deleted'): del anim np.testing.break_cycles() def test_movie_writer_dpi_default(): class DummyMovieWriter(animation.MovieWriter): def _run(self): pass # Test setting up movie writer with figure.dpi default. fig = plt.figure() filename = "unused.null" fps = 5 codec = "unused" bitrate = 1 extra_args = ["unused"] writer = DummyMovieWriter(fps, codec, bitrate, extra_args) writer.setup(fig, filename) assert writer.dpi == fig.dpi @animation.writers.register('null') class RegisteredNullMovieWriter(NullMovieWriter): # To be able to add NullMovieWriter to the 'writers' registry, # we must define an __init__ method with a specific signature, # and we must define the class method isAvailable(). # (These methods are not actually required to use an instance # of this class as the 'writer' argument of Animation.save().) def __init__(self, fps=None, codec=None, bitrate=None, extra_args=None, metadata=None): pass @classmethod def isAvailable(cls): return True WRITER_OUTPUT = [ ('ffmpeg', 'movie.mp4'), ('ffmpeg_file', 'movie.mp4'), ('imagemagick', 'movie.gif'), ('imagemagick_file', 'movie.gif'), ('pillow', 'movie.gif'), ('html', 'movie.html'), ('null', 'movie.null') ] def gen_writers(): for writer, output in WRITER_OUTPUT: if not animation.writers.is_available(writer): mark = pytest.mark.skip( f"writer '{writer}' not available on this system") yield pytest.param(writer, None, output, marks=[mark]) yield pytest.param(writer, None, Path(output), marks=[mark]) continue writer_class = animation.writers[writer] for frame_format in getattr(writer_class, 'supported_formats', [None]): yield writer, frame_format, output yield writer, frame_format, Path(output) # Smoke test for saving animations. In the future, we should probably # design more sophisticated tests which compare resulting frames a-la # matplotlib.testing.image_comparison @pytest.mark.parametrize('writer, frame_format, output', gen_writers()) @pytest.mark.parametrize('anim', [dict(klass=dict)], indirect=['anim']) def test_save_animation_smoketest(tmpdir, writer, frame_format, output, anim): if frame_format is not None: plt.rcParams["animation.frame_format"] = frame_format anim = animation.FuncAnimation(**anim) dpi = None codec = None if writer == 'ffmpeg': # Issue #8253 anim._fig.set_size_inches((10.85, 9.21)) dpi = 100. codec = 'h264' # Use temporary directory for the file-based writers, which produce a file # per frame with known names. with tmpdir.as_cwd(): anim.save(output, fps=30, writer=writer, bitrate=500, dpi=dpi, codec=codec) del anim @pytest.mark.parametrize('writer, frame_format, output', gen_writers()) def test_grabframe(tmpdir, writer, frame_format, output): WriterClass = animation.writers[writer] if frame_format is not None: plt.rcParams["animation.frame_format"] = frame_format fig, ax = plt.subplots() dpi = None codec = None if writer == 'ffmpeg': # Issue #8253 fig.set_size_inches((10.85, 9.21)) dpi = 100. codec = 'h264' test_writer = WriterClass() # Use temporary directory for the file-based writers, which produce a file # per frame with known names. with tmpdir.as_cwd(): with test_writer.saving(fig, output, dpi): # smoke test it works test_writer.grab_frame() for k in {'dpi', 'bbox_inches', 'format'}: with pytest.raises( TypeError, match=f"grab_frame got an unexpected keyword argument {k!r}" ): test_writer.grab_frame(**{k: object()}) @pytest.mark.parametrize('writer', [ pytest.param( 'ffmpeg', marks=pytest.mark.skipif( not animation.FFMpegWriter.isAvailable(), reason='Requires FFMpeg')), pytest.param( 'imagemagick', marks=pytest.mark.skipif( not animation.ImageMagickWriter.isAvailable(), reason='Requires ImageMagick')), ]) @pytest.mark.parametrize('html, want', [ ('none', None), ('html5', '<video width'), ('jshtml', '<script ') ]) @pytest.mark.parametrize('anim', [dict(klass=dict)], indirect=['anim']) def test_animation_repr_html(writer, html, want, anim): if platform.python_implementation() == 'PyPy': # Something in the test setup fixture lingers around into the test and # breaks pytest.warns on PyPy. This garbage collection fixes it. # https://foss.heptapod.net/pypy/pypy/-/issues/3536 np.testing.break_cycles() if (writer == 'imagemagick' and html == 'html5' # ImageMagick delegates to ffmpeg for this format. and not animation.FFMpegWriter.isAvailable()): pytest.skip('Requires FFMpeg') # create here rather than in the fixture otherwise we get __del__ warnings # about producing no output anim = animation.FuncAnimation(**anim) with plt.rc_context({'animation.writer': writer, 'animation.html': html}): html = anim._repr_html_() if want is None: assert html is None with pytest.warns(UserWarning): del anim # Animation was never run, so will warn on cleanup. np.testing.break_cycles() else: assert want in html @pytest.mark.parametrize( 'anim', [{'save_count': 10, 'frames': iter(range(5))}], indirect=['anim'] ) def test_no_length_frames(anim): anim.save('unused.null', writer=NullMovieWriter()) def test_movie_writer_registry(): assert len(animation.writers._registered) > 0 mpl.rcParams['animation.ffmpeg_path'] = "not_available_ever_xxxx" assert not animation.writers.is_available("ffmpeg") # something guaranteed to be available in path and exits immediately bin = "true" if sys.platform != 'win32' else "where" mpl.rcParams['animation.ffmpeg_path'] = bin assert animation.writers.is_available("ffmpeg") @pytest.mark.parametrize( "method_name", [pytest.param("to_html5_video", marks=pytest.mark.skipif( not animation.writers.is_available(mpl.rcParams["animation.writer"]), reason="animation writer not installed")), "to_jshtml"]) @pytest.mark.parametrize('anim', [dict(frames=1)], indirect=['anim']) def test_embed_limit(method_name, caplog, tmpdir, anim): caplog.set_level("WARNING") with tmpdir.as_cwd(): with mpl.rc_context({"animation.embed_limit": 1e-6}): # ~1 byte. getattr(anim, method_name)() assert len(caplog.records) == 1 record, = caplog.records assert (record.name == "matplotlib.animation" and record.levelname == "WARNING") @pytest.mark.parametrize( "method_name", [pytest.param("to_html5_video", marks=pytest.mark.skipif( not animation.writers.is_available(mpl.rcParams["animation.writer"]), reason="animation writer not installed")), "to_jshtml"]) @pytest.mark.parametrize('anim', [dict(frames=1)], indirect=['anim']) def test_cleanup_temporaries(method_name, tmpdir, anim): with tmpdir.as_cwd(): getattr(anim, method_name)() assert list(Path(str(tmpdir)).iterdir()) == [] @pytest.mark.skipif(shutil.which("/bin/sh") is None, reason="requires a POSIX OS") def test_failing_ffmpeg(tmpdir, monkeypatch, anim): """ Test that we correctly raise a CalledProcessError when ffmpeg fails. To do so, mock ffmpeg using a simple executable shell script that succeeds when called with no arguments (so that it gets registered by `isAvailable`), but fails otherwise, and add it to the $PATH. """ with tmpdir.as_cwd(): monkeypatch.setenv("PATH", ".:" + os.environ["PATH"]) exe_path = Path(str(tmpdir), "ffmpeg") exe_path.write_bytes(b"#!/bin/sh\n[[ $@ -eq 0 ]]\n") os.chmod(exe_path, 0o755) with pytest.raises(subprocess.CalledProcessError): anim.save("test.mpeg") @pytest.mark.parametrize("cache_frame_data", [False, True]) def test_funcanimation_cache_frame_data(cache_frame_data): fig, ax = plt.subplots() line, = ax.plot([], []) class Frame(dict): # this subclassing enables to use weakref.ref() pass def init(): line.set_data([], []) return line, def animate(frame): line.set_data(frame['x'], frame['y']) return line, frames_generated = [] def frames_generator(): for _ in range(5): x = np.linspace(0, 10, 100) y = np.random.rand(100) frame = Frame(x=x, y=y) # collect weak references to frames # to validate their references later frames_generated.append(weakref.ref(frame)) yield frame MAX_FRAMES = 100 anim = animation.FuncAnimation(fig, animate, init_func=init, frames=frames_generator, cache_frame_data=cache_frame_data, save_count=MAX_FRAMES) writer = NullMovieWriter() anim.save('unused.null', writer=writer) assert len(frames_generated) == 5 np.testing.break_cycles() for f in frames_generated: # If cache_frame_data is True, then the weakref should be alive; # if cache_frame_data is False, then the weakref should be dead (None). assert (f() is None) != cache_frame_data @pytest.mark.parametrize('return_value', [ # User forgot to return (returns None). None, # User returned a string. 'string', # User returned an int. 1, # User returns a sequence of other objects, e.g., string instead of Artist. ('string', ), # User forgot to return a sequence (handled in `animate` below.) 'artist', ]) def test_draw_frame(return_value): # test _draw_frame method fig, ax = plt.subplots() line, = ax.plot([]) def animate(i): # general update func line.set_data([0, 1], [0, i]) if return_value == 'artist': # *not* a sequence return line else: return return_value with pytest.raises(RuntimeError): animation.FuncAnimation( fig, animate, blit=True, cache_frame_data=False ) def test_exhausted_animation(tmpdir): fig, ax = plt.subplots() def update(frame): return [] anim = animation.FuncAnimation( fig, update, frames=iter(range(10)), repeat=False, cache_frame_data=False ) with tmpdir.as_cwd(): anim.save("test.gif", writer='pillow') with pytest.warns(UserWarning, match="exhausted"): anim._start() def test_no_frame_warning(tmpdir): fig, ax = plt.subplots() def update(frame): return [] anim = animation.FuncAnimation( fig, update, frames=[], repeat=False, cache_frame_data=False ) with pytest.warns(UserWarning, match="exhausted"): anim._start() @check_figures_equal(extensions=["png"]) def test_animation_frame(tmpdir, fig_test, fig_ref): # Test the expected image after iterating through a few frames # we save the animation to get the iteration because we are not # in an interactive framework. ax = fig_test.add_subplot() ax.set_xlim(0, 2 * np.pi) ax.set_ylim(-1, 1) x = np.linspace(0, 2 * np.pi, 100) line, = ax.plot([], []) def init(): line.set_data([], []) return line, def animate(i): line.set_data(x, np.sin(x + i / 100)) return line, anim = animation.FuncAnimation( fig_test, animate, init_func=init, frames=5, blit=True, repeat=False) with tmpdir.as_cwd(): anim.save("test.gif") # Reference figure without animation ax = fig_ref.add_subplot() ax.set_xlim(0, 2 * np.pi) ax.set_ylim(-1, 1) # 5th frame's data ax.plot(x, np.sin(x + 4 / 100)) @pytest.mark.parametrize('anim', [dict(klass=dict)], indirect=['anim']) def test_save_count_override_warnings_has_length(anim): save_count = 5 frames = list(range(2)) match_target = ( f'You passed in an explicit {save_count=} ' "which is being ignored in favor of " f"{len(frames)=}." ) with pytest.warns(UserWarning, match=re.escape(match_target)): anim = animation.FuncAnimation( **{**anim, 'frames': frames, 'save_count': save_count} ) assert anim._save_count == len(frames) anim._init_draw() @pytest.mark.parametrize('anim', [dict(klass=dict)], indirect=['anim']) def test_save_count_override_warnings_scaler(anim): save_count = 5 frames = 7 match_target = ( f'You passed in an explicit {save_count=} ' + "which is being ignored in favor of " + f"{frames=}." ) with pytest.warns(UserWarning, match=re.escape(match_target)): anim = animation.FuncAnimation( **{**anim, 'frames': frames, 'save_count': save_count} ) assert anim._save_count == frames anim._init_draw() @pytest.mark.parametrize('anim', [dict(klass=dict)], indirect=['anim']) def test_disable_cache_warning(anim): cache_frame_data = True frames = iter(range(5)) match_target = ( f"{frames=!r} which we can infer the length of, " "did not pass an explicit *save_count* " f"and passed {cache_frame_data=}. To avoid a possibly " "unbounded cache, frame data caching has been disabled. " "To suppress this warning either pass " "`cache_frame_data=False` or `save_count=MAX_FRAMES`." ) with pytest.warns(UserWarning, match=re.escape(match_target)): anim = animation.FuncAnimation( **{**anim, 'cache_frame_data': cache_frame_data, 'frames': frames} ) assert anim._cache_frame_data is False anim._init_draw() def test_movie_writer_invalid_path(anim): if sys.platform == "win32": match_str = r"\[WinError 3] .*'\\\\foo\\\\bar\\\\aardvark'" else: match_str = r"\[Errno 2] .*'/foo" with pytest.raises(FileNotFoundError, match=match_str): anim.save("/foo/bar/aardvark/thiscannotreallyexist.mp4", writer=animation.FFMpegFileWriter())