old_contents: from __future__ import print_function, division, absolute_import
  import contextlib
  import numpy as np
  from sklearn.externals.joblib import load
  from sklearn.externals.joblib import dump as _dump
  
  __all__ = ['printoptions', 'verbosedump', 'verboseload', 'dump', 'load']
  
  
  @contextlib.contextmanager
  def printoptions(*args, **kwargs):
      original = np.get_printoptions()
      np.set_printoptions(*args, **kwargs)
      yield
      np.set_printoptions(**original)
  
  
  def dump(value, filename, compress=1, cache_size=100):
      """Fast persistence of an arbitrary Python object into a files, with
      dedicated storage for numpy arrays.
  
      Parameters
      -----------
      value: any Python object
          The object to store to disk
      filename: string
          The name of the file in which it is to be stored
      compress: integer for 0 to 9, optional
          Optional compression level for the data. 0 is no compression.
          Higher means more compression, but also slower read and
          write times. Using a value of 3 is often a good compromise.
          See the notes for more details.
      cache_size: positive number, optional
          Fixes the order of magnitude (in megabytes) of the cache used
          for in-memory compression. Note that this is just an order of
          magnitude estimate and that for big arrays, the code will go
          over this value at dump and at load time.
  
      Returns
      -------
      filenames: list of strings
          The list of file names in which the data is stored. If
          compress is false, each array is stored in a different file.
  
      See Also
      --------
      load : corresponding loader
      """
      _dump(value, filename, compress=compress, cache_size=cache_size)
  
  
  def verbosedump(value, fn, compress=1):
      """verbose wrapper around dump"""
      print('Saving "%s"... (%s)' % (fn, type(value)))
      dump(value, fn, compress=compress)
  
  
  def verboseload(fn):
      """verbose wrapper around joblib.load"""
      print('loading "%s"...' % fn)
      return load(fn)
  
new_contents: from __future__ import print_function, division, absolute_import
  import contextlib
  import numpy as np
  import warnings
  import pickle
  from sklearn.externals.joblib import load as jl_load
  
  __all__ = ['printoptions', 'verbosedump', 'verboseload', 'dump', 'load']
  
  
  @contextlib.contextmanager
  def printoptions(*args, **kwargs):
      original = np.get_printoptions()
      np.set_printoptions(*args, **kwargs)
      yield
      np.set_printoptions(**original)
  
  
  def dump(value, filename, compress=None, cache_size=None):
      """Save an arbitrary python object using pickle.
  
      Parameters
      -----------
      value : any Python object
          The object to store to disk using pickle.
      filename : string
          The name of the file in which it is to be stored
      compress : None
          No longer used
      cache_size : positive number, optional
          No longer used
  
      See Also
      --------
      load : corresponding loader
      """
      if compress is not None or cache_size is not None:
          warnings.warn("compress and cache_size are no longer valid options")
  
      with open(filename, 'wb') as f:
          pickle.dump(value, f)
  
  
  def load(filename):
      """Load an object that has been saved with dump.
  
      We try to open it using the pickle protocol. As a fallback, we
      use joblib.load. Joblib was the default prior to msmbuilder v3.2
  
      Parameters
      ----------
      filename : string
          The name of the file to load.
      """
      try:
          with open(filename, 'rb') as f:
              return pickle.load(f)
      except Exception as e1:
          try:
              return jl_load(filename)
          except Exception as e2:
              raise IOError(
                  "Unable to load {} using the pickle or joblib protocol.\n"
                  "Pickle: {}\n"
                  "Joblib: {}".format(e1, e2)
              )
  
  
  def verbosedump(value, fn, compress=None):
      """Verbose wrapper around dump"""
      print('Saving "%s"... (%s)' % (fn, type(value)))
      dump(value, fn, compress=compress)
  
  
  def verboseload(fn):
      """Verbose wrapper around load.
  
      Try to use pickle. If that fails, try to use joblib.
      """
      print('loading "%s"...' % fn)
      return load(fn)
  
subject: Use pickle to save output