Reset the available animation movie writer on rcParam change

jankatins · jankatins · commit e3e2be95ce8a · 2016-02-06T20:40:30.000+01:00
If one of the rcParams for a path to a program, which was called by a
movie writer, is changed, the the available movie writer in the
registry should be reevaluated if they are (still/became) available.

This also fixes the problem that you have to set the path to a movie
writer before importing mpl.animation, as before the state was
fixed on import time.
diff --git a/lib/matplotlib/animation.py b/lib/matplotlib/animation.py
@@ -64,6 +64,12 @@
 class MovieWriterRegistry(object):
     def __init__(self):
         self.avail = dict()
+        self._registered = dict()
+        self._dirty = False
+
+    def set_dirty(self):
+        """Sets a flag to re-setup the writers"""
+        self._dirty = True
 
     # Returns a decorator that can be used on classes to register them under
     # a name. As in:
@@ -72,19 +78,36 @@ def __init__(self):
     #    pass
     def register(self, name):
         def wrapper(writerClass):
+            self._registered[name] = writerClass
             if writerClass.isAvailable():
                 self.avail[name] = writerClass
             return writerClass
         return wrapper
 
+    def ensure_not_dirty(self):
+        """If dirty, reasks the writers if they are available"""
+        if self._dirty:
+            self.reset_available_writers()
+
+    def reset_available_writers(self):
+        """Reset the available state of all registered writers"""
+        self.avail = {}
+        for name, writerClass in self._registered.items():
+            if writerClass.isAvailable():
+                self.avail[name] = writerClass
+        self._dirty = False
+
     def list(self):
         ''' Get a list of available MovieWriters.'''
+        self.ensure_not_dirty()
         return list(self.avail.keys())
 
     def is_available(self, name):
+        self.ensure_not_dirty()
         return name in self.avail
 
     def __getitem__(self, name):
+        self.ensure_not_dirty()
         if not self.avail:
             raise RuntimeError("No MovieWriters available!")
         return self.avail[name]
diff --git a/lib/matplotlib/rcsetup.py b/lib/matplotlib/rcsetup.py
@@ -802,6 +802,21 @@ def validate_hist_bins(s):
     raise ValueError("'hist.bins' must be 'auto', an int or " +
                      "a sequence of floats")
 
+def validate_animation_writer_path(p):
+    # Make sure it's a string and then figure out if the animations
+    # are already loaded and reset the writers (which will validate
+    # the path on next call)
+    if not isinstance(p, six.text_type):
+        raise ValueError("path must be a (unicode) string")
+    from sys import modules
+    # set dirty, so that the next call to the registry will re-evaluate
+    # the state.
+    # only set dirty if already loaded. If not loaded, the load will
+    # trigger the checks.
+    if "matplotlib.animation" in modules:
+        modules["matplotlib.animation"].writers.set_dirty()
+    return p
+
 
 # a map from key -> value, converter
 defaultParams = {
@@ -1222,20 +1237,20 @@ def validate_hist_bins(s):
     # Controls image format when frames are written to disk
     'animation.frame_format': ['png', validate_movie_frame_fmt],
     # Path to FFMPEG binary. If just binary name, subprocess uses $PATH.
-    'animation.ffmpeg_path':  ['ffmpeg', six.text_type],
+    'animation.ffmpeg_path':  ['ffmpeg', validate_animation_writer_path],
 
     # Additional arguments for ffmpeg movie writer (using pipes)
     'animation.ffmpeg_args':   [[], validate_stringlist],
     # Path to AVConv binary. If just binary name, subprocess uses $PATH.
-    'animation.avconv_path':   ['avconv', six.text_type],
+    'animation.avconv_path':   ['avconv', validate_animation_writer_path],
     # Additional arguments for avconv movie writer (using pipes)
     'animation.avconv_args':   [[], validate_stringlist],
     # Path to MENCODER binary. If just binary name, subprocess uses $PATH.
-    'animation.mencoder_path': ['mencoder', six.text_type],
+    'animation.mencoder_path': ['mencoder', validate_animation_writer_path],
     # Additional arguments for mencoder movie writer (using pipes)
     'animation.mencoder_args': [[], validate_stringlist],
      # Path to convert binary. If just binary name, subprocess uses $PATH
-    'animation.convert_path':  ['convert', six.text_type],
+    'animation.convert_path':  ['convert', validate_animation_writer_path],
      # Additional arguments for mencoder movie writer (using pipes)
 
     'animation.convert_args':  [[], validate_stringlist],
diff --git a/lib/matplotlib/tests/test_animation.py b/lib/matplotlib/tests/test_animation.py
@@ -4,10 +4,13 @@
 from matplotlib.externals import six
 
 import os
+import sys
 import tempfile
 import numpy as np
 from numpy.testing import assert_equal
 from nose import with_setup
+from nose.tools import assert_false, assert_true
+import matplotlib as mpl
 from matplotlib import pyplot as plt
 from matplotlib import animation
 from matplotlib.testing.noseclasses import KnownFailureTest
@@ -163,6 +166,29 @@ def animate(i):
                                    frames=iter(range(5)))
 
 
+def test_movie_writer_registry():
+    ffmpeg_path = mpl.rcParams['animation.ffmpeg_path']
+    # Not sure about the first state as there could be some writer
+    # which set rcparams
+    #assert_false(animation.writers._dirty)
+    assert_true(len(animation.writers._registered) > 0)
+    animation.writers.list()  # resets dirty state
+    assert_false(animation.writers._dirty)
+    mpl.rcParams['animation.ffmpeg_path'] = u"not_available_ever_xxxx"
+    assert_true(animation.writers._dirty)
+    animation.writers.list()  # resets
+    assert_false(animation.writers._dirty)
+    assert_false(animation.writers.is_available("ffmpeg"))
+    # something which is garanteered to be available in path
+    bin = u"python"
+    mpl.rcParams['animation.ffmpeg_path'] = bin
+    assert_true(animation.writers._dirty)
+    animation.writers.list()  # resets
+    assert_false(animation.writers._dirty)
+    assert_true(animation.writers.is_available("ffmpeg"))
+    mpl.rcParams['animation.ffmpeg_path'] = ffmpeg_path
+
+
 if __name__ == "__main__":
     import nose
     nose.runmodule(argv=['-s', '--with-doctest'], exit=False)
