Ticket #10159: trac_10159-matplotlib.patch

SPKG.txt

@@ -2 +2 @@
 
 == Description ==
 
-From the Matplotlib website: matplotlib is a python 2D plotting library which produces publication quality figures in a variety of hardcopy formats and interactive environments across platforms. matplotlib can be used in python scripts, the python and ipython shell (ala matlab or mathematica), web application servers, and six graphical user interface toolkits.
+From the Matplotlib website: matplotlib is a python 2D plotting
+library which produces publication quality figures in a variety of
+hardcopy formats and interactive environments across
+platforms. matplotlib can be used in python scripts, the python and
+ipython shell (ala matlab or mathematica), web application servers,
+and six graphical user interface toolkits. 
 
 == License ==
 
-The Matplotlib license - see http://matplotlib.sourceforge.net/users/license.html: Matplotlib only uses BSD compatible code, and its license is based on the PSF license. See the Open Source Initiative licenses page for details on individual licenses. Non-BSD compatible licenses (eg LGPL) are acceptable in matplotlib Toolkits. For a discussion of the motivations behind the licencing choice, see Licenses.
+The Matplotlib license - see
+http://matplotlib.sourceforge.net/users/license.html: Matplotlib only
+uses BSD compatible code, and its license is based on the PSF
+license. See the Open Source Initiative licenses page for details on
+individual licenses. Non-BSD compatible licenses (eg LGPL) are
+acceptable in matplotlib Toolkits. For a discussion of the motivations
+behind the licencing choice, see Licenses.
 
 == SPKG Maintainers ==
 
@@ -28 +39 @@
 
 * setupext.py: link to libpng12 instead of libpng to apparently avoid
   some name clashes on OSX.
-* WrapPython.h: delete unnecessary kludges to compile on Solaris.  A version of this is committed upstream as SVN version #8707, so this patch should be removed when upgrading to the next matplotlib release.
-* font_manager.py: rebuild the font cache when a font file is missing.  This is from the upstream commit SVN version #8712, so this patch should be removed when upgrading to the next matplotlib release.
+* WrapPython.h: delete unnecessary kludges to compile on Solaris.  A
+  version of this is committed upstream as SVN version #8707, so this
+  patch should be removed when upgrading to the next matplotlib
+  release. 
+* font_manager.py: rebuild the font cache when a font file is missing.
+  This is from the upstream commit SVN version #8712, so this patch
+  should be removed when upgrading to the next matplotlib release. 
+* __init__.py, finance.py, texmanager.py: instead of "if
+  not.os.path.exists(DIR): os.mkdir(DIR)", do "try os.mkdir(DIR)" and
+  then catch the error if the directory already exists.  This is safer
+  in general, and should avoid problems if two doctests try to create
+  the directory at the same time.
+
+* NOTE: as of matplotlib 1.0.0 and Sage 4.6, Sage does not use
+  $HOME/.matplotlib (or whatever the user has set in MPLCONFIGDIR).
+  Instead, it sets MPLCONFIGDIR to $DOT_SAGE/matplotlib-VER, where VER
+  is the matplotlib version number.  This is because of
+  incompatibilities between the contents of .matplotlib between
+  matplotlib versions 0.99.3 and 1.0.0.  Sage reads the version number
+  VER by searching through
+  SAGE_ROOT/local/lib/python/site-packages/matplotlib/__init__.py,
+  looking for a line of the form
+
+    __version__ = '1.0.0'
+
+  So when updating matplotlib, make sure that
+  src/lib/matplotlib/__init__.py has a line of this form.  Extra white
+  spaces shouldn't matter, but if the single quotes change to double
+  quotes, for example, we either need to patch that file or patch the
+  sage-env script.  See
+  http://trac.sagemath.org/sage_trac/ticket/6235.  Also, at the end of
+  the install process for matplotlib, the spkg-install file prints a
+  message showing what MPLCONFIGDIR will be set to, using the command
+  from sage-env, so this should provide a check.
 
 == Changelog ==
 
+=== matplotlib 1.0.0.p0 (John Palmieri, 23 Oct 2010) ===
+ * Patch __init__.py, finance.py, and texmanager.py to avoid race
+   conditions when creating directories.
+
 === matplotlib 1.0.0 (Jason Grout, 01 Oct 2010) ===
- * Update to matplotlib 1.0.0.  Include two upstream fixes that were committed since 1.0.0.
+ * Update to matplotlib 1.0.0.  Include two upstream fixes that were
+   committed since 1.0.0. 
 
 === matplotlib-0.99.3-svn8415 (Jason Grout, 11 Jun 2010) ===
  * Update to SVN revision 8415 (which is 0.99.3 + some bugfixes we
@@ -52 +100 @@
  * Re-implemented hideous temporary hack (trac 7865).
 
 === matplotlib-0.99.1.p2 (William Stein, 29 Sep 2009) ===
- * Implemented hideous temporary hack to get around issue with pyCXX crashing on OS X 10.6
+ * Implemented hideous temporary hack to get around issue with pyCXX
+   crashing on OS X 10.6
 
 === matplotlib-0.99.1 (Jason Grout, 22 Sep 2009) ===
- * Update to matplotlib 0.99.1.  Several of our patches were incorporated upstream, so deleted those and updated the others.
+ * Update to matplotlib 0.99.1.  Several of our patches were
+   incorporated upstream, so deleted those and updated the others. 
 
 === matplotlib-0.99.0 (Jason Grout, August 9th, 2009) ===
  * Update to matplotlib 0.99.0
 
 === matplotlib-0.98.5.3rc0-svn6910.p3 (Michael Abshoff, February 20th, 2009) ===
- * Turn off GUI backend unconditionally since they cause trouble on systems without X, ie. sage.math, too. This might be a bug in Matplotlib, but until this is resolved it stays off.
+ * Turn off GUI backend unconditionally since they cause trouble on
+   systems without X, ie. sage.math, too. This might be a bug in
+   Matplotlib, but until this is resolved it stays off. 
 
 === matplotlib-0.98.5.3rc0-svn6910.p2 (William Stein, February 20th, 2009) ===
- * Don't build GUI backends on OS X by default.  See trac #5301. This is really a problem with libpng, so this is temporary.
+ * Don't build GUI backends on OS X by default.  See trac #5301. This
+   is really a problem with libpng, so this is temporary. 
 
 === matplotlib-0.98.5.3rc0-svn6910.p1 (Jason Grout, February 14, 2009) ===
- * Add a patch for patches.py, which ignores the errors generated when trying to draw arrows that are "too short".
+ * Add a patch for patches.py, which ignores the errors generated when
+   trying to draw arrows that are "too short". 
 
 === matplotlib-0.98.5.3rc0-svn6910.p0 (Michael Abshoff, February 14, 2009) ===
  * link against libpng12 instead of libpng (#4774)
  * disable tkagg on all machines since it causes too much trouble
 
 === matplotlib-0.98.5.3rc0-svn6910 (Jason Grout, February 13, 2009) ===
- * Update to the latest SVN version (6910) of Matplotlib and update patches.  Two patches disappear because one patch was just updating quiver.py to a mid-release version and arrow_line.py is now subsumed by much nicer functionality in Matplotlib.
- * removed the two images src/doc/_static/eeg* and src/doc/pyplots/(plotmap.png|tex_demo.pdf|plotmap.hires.png|plotmap.pdf) to save space
+ * Update to the latest SVN version (6910) of Matplotlib and update
+   patches.  Two patches disappear because one patch was just updating
+   quiver.py to a mid-release version and arrow_line.py is now subsumed
+   by much nicer functionality in Matplotlib. 
+ * removed the two images src/doc/_static/eeg* and
+   src/doc/pyplots/(plotmap.png|tex_demo.pdf|plotmap.hires.png|plotmap.pdf)
+   to save space 
 
 === matplotlib-0.98.3.p5 (Michael Abshoff, January 19th, 2009) ===
- * Work around Solaris 10 with gcc 4.3.2 problem in ttconv/pprdrv_tt2.cpp (#5008)
+ * Work around Solaris 10 with gcc 4.3.2 problem in
+   ttconv/pprdrv_tt2.cpp (#5008)
 
 === matplotlib-0.98.3.p4 (Michael Abshoff, December 12th, 2008) ===
  * apply Craig Citro's OSX build fix (#4680)
  
 === matplotlib-0.98.3.p3 (William Stein, 25 Nov 2008) ===
- * fix so matplotlib may build in a fallback case (there is a stupid bug in upstreams setupext.py)
+ * fix so matplotlib may build in a fallback case (there is a stupid
+   bug in upstreams setupext.py) 
 
 == matplotlib-0.98.3.p2 (Jason Grout, 20 Sep 2008) ===
- * Update quiver.py to the SVN version 6115 to make the vector field plots respect aspect ratio.
+ * Update quiver.py to the SVN version 6115 to make the vector field
+   plots respect aspect ratio. 
 
 == matplotlib-0.98.3.p1 (Jason Grout, 03 Sep 2008) ===
  * Add an arrow_line.py file as a patch for "nice" arrows in matplotlib

new file patches/__init__.py

@@ +1 @@
+"""
+This is an object-orient plotting library.
+
+A procedural interface is provided by the companion pyplot module,
+which may be imported directly, e.g::
+
+    from matplotlib.pyplot import *
+
+To include numpy functions too, use::
+
+    from pylab import *
+
+or using ipython::
+
+    ipython -pylab
+
+For the most part, direct use of the object-oriented library is
+encouraged when programming; pyplot is primarily for working
+interactively.  The
+exceptions are the pyplot commands :func:`~matplotlib.pyplot.figure`,
+:func:`~matplotlib.pyplot.subplot`,
+:func:`~matplotlib.pyplot.subplots`,
+:func:`~matplotlib.backends.backend_qt4agg.show`, and
+:func:`~pyplot.savefig`, which can greatly simplify scripting.
+
+Modules include:
+
+    :mod:`matplotlib.axes`
+        defines the :class:`~matplotlib.axes.Axes` class.  Most pylab
+        commands are wrappers for :class:`~matplotlib.axes.Axes`
+        methods.  The axes module is the highest level of OO access to
+        the library.
+
+    :mod:`matplotlib.figure`
+        defines the :class:`~matplotlib.figure.Figure` class.
+
+    :mod:`matplotlib.artist`
+        defines the :class:`~matplotlib.artist.Artist` base class for
+        all classes that draw things.
+
+    :mod:`matplotlib.lines`
+        defines the :class:`~matplotlib.lines.Line2D` class for
+        drawing lines and markers
+
+    :mod:`matplotlib.patches`
+        defines classes for drawing polygons
+
+    :mod:`matplotlib.text`
+        defines the :class:`~matplotlib.text.Text`,
+        :class:`~matplotlib.text.TextWithDash`, and
+        :class:`~matplotlib.text.Annotate` classes
+
+    :mod:`matplotlib.image`
+        defines the :class:`~matplotlib.image.AxesImage` and
+        :class:`~matplotlib.image.FigureImage` classes
+
+    :mod:`matplotlib.collections`
+        classes for efficient drawing of groups of lines or polygons
+
+    :mod:`matplotlib.colors`
+        classes for interpreting color specifications and for making
+        colormaps
+
+    :mod:`matplotlib.cm`
+        colormaps and the :class:`~matplotlib.image.ScalarMappable`
+        mixin class for providing color mapping functionality to other
+        classes
+
+    :mod:`matplotlib.ticker`
+        classes for calculating tick mark locations and for formatting
+        tick labels
+
+    :mod:`matplotlib.backends`
+        a subpackage with modules for various gui libraries and output
+        formats
+
+The base matplotlib namespace includes:
+
+    :data:`~matplotlib.rcParams`
+        a global dictionary of default configuration settings.  It is
+        initialized by code which may be overridded by a matplotlibrc
+        file.
+
+    :func:`~matplotlib.rc`
+        a function for setting groups of rcParams values
+
+    :func:`~matplotlib.use`
+        a function for setting the matplotlib backend.  If used, this
+        function must be called immediately after importing matplotlib
+        for the first time.  In particular, it must be called
+        **before** importing pylab (if pylab is imported).
+
+matplotlib was initially written by John D. Hunter (jdh2358 at
+gmail.com) and is now developed and maintained by a host of others.
+
+Occasionally the internal documentation (python docstrings) will refer
+to MATLAB®, a registered trademark of The MathWorks, Inc.
+
+"""
+from __future__ import generators
+
+__version__  = '1.0.0'
+__revision__ = '$Revision: 8503 $'
+__date__     = '$Date: 2010-07-06 08:56:31 -0500 (Tue, 06 Jul 2010) $'
+
+import os, re, shutil, subprocess, sys, warnings, errno
+import distutils.sysconfig
+import distutils.version
+
+# Needed for toolkit setuptools support
+if 0:
+    try:
+        __import__('pkg_resources').declare_namespace(__name__)
+    except ImportError:
+        pass # must not have setuptools
+
+if not hasattr(sys, 'argv'):  # for modpython
+    sys.argv = ['modpython']
+
+"""
+Manage user customizations through a rc file.
+
+The default file location is given in the following order
+
+  - environment variable MATPLOTLIBRC
+
+  - HOME/.matplotlib/matplotlibrc if HOME is defined
+
+  - PATH/matplotlibrc where PATH is the return value of
+    get_data_path()
+"""
+
+import sys, os, tempfile
+
+from matplotlib.rcsetup import (defaultParams,
+                                validate_backend,
+                                validate_toolbar,
+                                validate_cairo_format)
+
+major, minor1, minor2, s, tmp = sys.version_info
+_python24 = major>=2 and minor1>=4
+
+# the havedate check was a legacy from old matplotlib which preceeded
+# datetime support
+_havedate = True
+
+#try:
+#    import pkg_resources # pkg_resources is part of setuptools
+#except ImportError: _have_pkg_resources = False
+#else: _have_pkg_resources = True
+
+if not _python24:
+    raise ImportError('matplotlib requires Python 2.4 or later')
+
+import numpy
+nmajor, nminor = [int(n) for n in numpy.__version__.split('.')[:2]]
+if not (nmajor > 1 or (nmajor == 1 and nminor >= 1)):
+    raise ImportError(
+            'numpy 1.1 or later is required; you have %s' % numpy.__version__)
+
+def is_string_like(obj):
+    if hasattr(obj, 'shape'): return 0
+    try: obj + ''
+    except (TypeError, ValueError): return 0
+    return 1
+
+
+def _is_writable_dir(p):
+    """
+    p is a string pointing to a putative writable dir -- return True p
+    is such a string, else False
+    """
+    try: p + ''  # test is string like
+    except TypeError: return False
+    try:
+        t = tempfile.TemporaryFile(dir=p)
+        t.write('1')
+        t.close()
+    except OSError: return False
+    else: return True
+
+class Verbose:
+    """
+    A class to handle reporting.  Set the fileo attribute to any file
+    instance to handle the output.  Default is sys.stdout
+    """
+    levels = ('silent', 'helpful', 'debug', 'debug-annoying')
+    vald = dict( [(level, i) for i,level in enumerate(levels)])
+
+    # parse the verbosity from the command line; flags look like
+    # --verbose-silent or --verbose-helpful
+    _commandLineVerbose = None
+
+    for arg in sys.argv[1:]:
+        if not arg.startswith('--verbose-'): continue
+        _commandLineVerbose = arg[10:]
+
+    def __init__(self):
+        self.set_level('silent')
+        self.fileo = sys.stdout
+
+    def set_level(self, level):
+        'set the verbosity to one of the Verbose.levels strings'
+
+        if self._commandLineVerbose is not None:
+            level = self._commandLineVerbose
+        if level not in self.levels:
+            raise ValueError('Illegal verbose string "%s".  Legal values are %s'%(level, self.levels))
+        self.level = level
+
+    def set_fileo(self, fname):
+        std = {
+            'sys.stdout': sys.stdout,
+            'sys.stderr': sys.stderr,
+        }
+        if fname in std:
+            self.fileo = std[fname]
+        else:
+            try:
+                fileo = file(fname, 'w')
+            except IOError:
+                raise ValueError('Verbose object could not open log file "%s" for writing.\nCheck your matplotlibrc verbose.fileo setting'%fname)
+            else:
+                self.fileo = fileo
+
+    def report(self, s, level='helpful'):
+        """
+        print message s to self.fileo if self.level>=level.  Return
+        value indicates whether a message was issued
+
+        """
+        if self.ge(level):
+            print >>self.fileo, s
+            return True
+        return False
+
+    def wrap(self, fmt, func, level='helpful', always=True):
+        """
+        return a callable function that wraps func and reports it
+        output through the verbose handler if current verbosity level
+        is higher than level
+
+        if always is True, the report will occur on every function
+        call; otherwise only on the first time the function is called
+        """
+        assert callable(func)
+        def wrapper(*args, **kwargs):
+            ret = func(*args, **kwargs)
+
+            if (always or not wrapper._spoke):
+                spoke = self.report(fmt%ret, level)
+                if not wrapper._spoke: wrapper._spoke = spoke
+            return ret
+        wrapper._spoke = False
+        wrapper.__doc__ = func.__doc__
+        return wrapper
+
+    def ge(self, level):
+        'return true if self.level is >= level'
+        return self.vald[self.level]>=self.vald[level]
+
+
+verbose=Verbose()
+
+
+def checkdep_dvipng():
+    try:
+        s = subprocess.Popen(['dvipng','-version'], stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE)
+        line = s.stdout.readlines()[1]
+        v = line.split()[-1]
+        return v
+    except (IndexError, ValueError, OSError):
+        return None
+
+def checkdep_ghostscript():
+    try:
+        if sys.platform == 'win32':
+            command_args = ['gswin32c', '--version']
+        else:
+            command_args = ['gs', '--version']
+        s = subprocess.Popen(command_args, stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE)
+        v = s.stdout.read()[:-1]
+        return v
+    except (IndexError, ValueError, OSError):
+        return None
+
+def checkdep_tex():
+    try:
+        s = subprocess.Popen(['tex','-version'], stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE)
+        line = s.stdout.readlines()[0]
+        pattern = '3\.1\d+'
+        match = re.search(pattern, line)
+        v = match.group(0)
+        return v
+    except (IndexError, ValueError, AttributeError, OSError):
+        return None
+
+def checkdep_pdftops():
+    try:
+        s = subprocess.Popen(['pdftops','-v'], stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE)
+        for line in s.stderr:
+            if 'version' in line:
+                v = line.split()[-1]
+        return v
+    except (IndexError, ValueError, UnboundLocalError, OSError):
+        return None
+
+def checkdep_inkscape():
+    try:
+        s = subprocess.Popen(['inkscape','-V'], stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE)
+        for line in s.stdout:
+            if 'Inkscape' in line:
+                v = line.split()[1]
+                break
+        return v
+    except (IndexError, ValueError, UnboundLocalError, OSError):
+        return None
+
+def checkdep_xmllint():
+    try:
+        s = subprocess.Popen(['xmllint','--version'], stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE)
+        for line in s.stderr:
+            if 'version' in line:
+                v = line.split()[-1]
+                break
+        return v
+    except (IndexError, ValueError, UnboundLocalError, OSError):
+        return None
+
+def compare_versions(a, b):
+    "return True if a is greater than or equal to b"
+    if a:
+        a = distutils.version.LooseVersion(a)
+        b = distutils.version.LooseVersion(b)
+        if a>=b: return True
+        else: return False
+    else: return False
+
+def checkdep_ps_distiller(s):
+    if not s:
+        return False
+
+    flag = True
+    gs_req = '7.07'
+    gs_sugg = '7.07'
+    gs_v = checkdep_ghostscript()
+    if compare_versions(gs_v, gs_sugg): pass
+    elif compare_versions(gs_v, gs_req):
+        verbose.report(('ghostscript-%s found. ghostscript-%s or later '
+                        'is recommended to use the ps.usedistiller option.') % (gs_v, gs_sugg))
+    else:
+        flag = False
+        warnings.warn(('matplotlibrc ps.usedistiller option can not be used '
+                       'unless ghostscript-%s or later is installed on your system') % gs_req)
+
+    if s == 'xpdf':
+        pdftops_req = '3.0'
+        pdftops_req_alt = '0.9' # poppler version numbers, ugh
+        pdftops_v = checkdep_pdftops()
+        if compare_versions(pdftops_v, pdftops_req):
+            pass
+        elif compare_versions(pdftops_v, pdftops_req_alt) and not \
+            compare_versions(pdftops_v, '1.0'):
+            pass
+        else:
+            flag = False
+            warnings.warn(('matplotlibrc ps.usedistiller can not be set to '
+                           'xpdf unless xpdf-%s or later is installed on your system') % pdftops_req)
+
+    if flag:
+        return s
+    else:
+        return False
+
+def checkdep_usetex(s):
+    if not s:
+        return False
+
+    tex_req = '3.1415'
+    gs_req = '7.07'
+    gs_sugg = '7.07'
+    dvipng_req = '1.5'
+    flag = True
+
+    tex_v = checkdep_tex()
+    if compare_versions(tex_v, tex_req): pass
+    else:
+        flag = False
+        warnings.warn(('matplotlibrc text.usetex option can not be used '
+                       'unless TeX-%s or later is '
+                       'installed on your system') % tex_req)
+
+    dvipng_v = checkdep_dvipng()
+    if compare_versions(dvipng_v, dvipng_req): pass
+    else:
+        flag = False
+        warnings.warn( 'matplotlibrc text.usetex can not be used with *Agg '
+                       'backend unless dvipng-1.5 or later is '
+                       'installed on your system')
+
+    gs_v = checkdep_ghostscript()
+    if compare_versions(gs_v, gs_sugg): pass
+    elif compare_versions(gs_v, gs_req):
+        verbose.report(('ghostscript-%s found. ghostscript-%s or later is '
+                        'recommended for use with the text.usetex '
+                        'option.') % (gs_v, gs_sugg))
+    else:
+        flag = False
+        warnings.warn(('matplotlibrc text.usetex can not be used '
+                       'unless ghostscript-%s or later is '
+                       'installed on your system') % gs_req)
+
+    return flag
+
+
+def _get_home():
+    """Find user's home directory if possible.
+    Otherwise raise error.
+
+    :see:  http://mail.python.org/pipermail/python-list/2005-February/263921.html
+    """
+    path=''
+    try:
+        path=os.path.expanduser("~")
+    except:
+        pass
+    if not os.path.isdir(path):
+        for evar in ('HOME', 'USERPROFILE', 'TMP'):
+            try:
+                path = os.environ[evar]
+                if os.path.isdir(path):
+                    break
+            except: pass
+    if path:
+        return path
+    else:
+        raise RuntimeError('please define environment variable $HOME')
+
+
+
+get_home = verbose.wrap('$HOME=%s', _get_home, always=False)
+
+def _get_configdir():
+    """
+    Return the string representing the configuration dir.
+
+    default is HOME/.matplotlib.  you can override this with the
+    MPLCONFIGDIR environment variable
+    """
+
+    configdir = os.environ.get('MPLCONFIGDIR')
+    if configdir is not None:
+        if not _is_writable_dir(configdir):
+            raise RuntimeError('Could not write to MPLCONFIGDIR="%s"'%configdir)
+        return configdir
+
+    h = get_home()
+    p = os.path.join(get_home(), '.matplotlib')
+
+    if os.path.exists(p):
+        if not _is_writable_dir(p):
+            raise RuntimeError("'%s' is not a writable dir; you must set %s/.matplotlib to be a writable dir.  You can also set environment variable MPLCONFIGDIR to any writable directory where you want matplotlib data stored "% (h, h))
+    else:
+        if not _is_writable_dir(h):
+            raise RuntimeError("Failed to create %s/.matplotlib; consider setting MPLCONFIGDIR to a writable directory for matplotlib configuration data"%h)
+
+        try:
+            os.mkdir(p)
+        except OSError, e:
+            if e.errno == errno.EEXIST:
+                pass
+            else:
+                raise
+
+    return p
+get_configdir = verbose.wrap('CONFIGDIR=%s', _get_configdir, always=False)
+
+
+def _get_data_path():
+    'get the path to matplotlib data'
+
+    if 'MATPLOTLIBDATA' in os.environ:
+        path = os.environ['MATPLOTLIBDATA']
+        if not os.path.isdir(path):
+            raise RuntimeError('Path in environment MATPLOTLIBDATA not a directory')
+        return path
+
+    path = os.sep.join([os.path.dirname(__file__), 'mpl-data'])
+    if os.path.isdir(path):
+        return path
+
+    # setuptools' namespace_packages may highjack this init file
+    # so need to try something known to be in matplotlib, not basemap
+    import matplotlib.afm
+    path = os.sep.join([os.path.dirname(matplotlib.afm.__file__), 'mpl-data'])
+    if os.path.isdir(path):
+        return path
+
+    # py2exe zips pure python, so still need special check
+    if getattr(sys,'frozen',None):
+        exe_path = os.path.dirname(sys.executable)
+        path = os.path.join(exe_path, 'mpl-data')
+        if os.path.isdir(path):
+            return path
+
+        # Try again assuming we need to step up one more directory
+        path = os.path.join(os.path.split(exe_path)[0], 'mpl-data')
+        if os.path.isdir(path):
+            return path
+
+        # Try again assuming sys.path[0] is a dir not a exe
+        path = os.path.join(sys.path[0], 'mpl-data')
+        if os.path.isdir(path):
+            return path
+
+    raise RuntimeError('Could not find the matplotlib data files')
+
+def _get_data_path_cached():
+    if defaultParams['datapath'][0] is None:
+        defaultParams['datapath'][0] = _get_data_path()
+    return defaultParams['datapath'][0]
+
+get_data_path = verbose.wrap('matplotlib data path %s', _get_data_path_cached,
+                             always=False)
+
+
+
+def get_example_data(fname):
+    """
+    get_example_data is deprecated -- use matplotlib.cbook.get_sample_data instead
+    """
+    raise NotImplementedError('get_example_data is deprecated -- use matplotlib.cbook.get_sample_data instead')
+
+
+def get_py2exe_datafiles():
+    datapath = get_data_path()
+    head, tail = os.path.split(datapath)
+    d = {}
+    for root, dirs, files in os.walk(datapath):
+        # Need to explicitly remove cocoa_agg files or py2exe complains
+        # NOTE I dont know why, but do as previous version
+        if 'Matplotlib.nib' in files:
+            files.remove('Matplotlib.nib')
+        files = [os.path.join(root, filename) for filename in files]
+        root = root.replace(tail, 'mpl-data')
+        root = root[root.index('mpl-data'):]
+        d[root] = files
+    return d.items()
+
+
+def matplotlib_fname():
+    """
+    Return the path to the rc file
+
+    Search order:
+
+     * current working dir
+     * environ var MATPLOTLIBRC
+     * HOME/.matplotlib/matplotlibrc
+     * MATPLOTLIBDATA/matplotlibrc
+
+
+    """
+
+    oldname = os.path.join( os.getcwd(), '.matplotlibrc')
+    if os.path.exists(oldname):
+        print >> sys.stderr, """\
+WARNING: Old rc filename ".matplotlibrc" found in working dir
+  and and renamed to new default rc file name "matplotlibrc"
+  (no leading"dot"). """
+        shutil.move('.matplotlibrc', 'matplotlibrc')
+
+    home = get_home()
+    oldname = os.path.join( home, '.matplotlibrc')
+    if os.path.exists(oldname):
+        configdir = get_configdir()
+        newname = os.path.join(configdir, 'matplotlibrc')
+        print >> sys.stderr, """\
+WARNING: Old rc filename "%s" found and renamed to
+  new default rc file name "%s"."""%(oldname, newname)
+
+        shutil.move(oldname, newname)
+
+
+    fname = os.path.join( os.getcwd(), 'matplotlibrc')
+    if os.path.exists(fname): return fname
+
+    if 'MATPLOTLIBRC' in os.environ:
+        path =  os.environ['MATPLOTLIBRC']
+        if os.path.exists(path):
+            fname = os.path.join(path, 'matplotlibrc')
+            if os.path.exists(fname):
+                return fname
+
+    fname = os.path.join(get_configdir(), 'matplotlibrc')
+    if os.path.exists(fname): return fname
+
+
+    path =  get_data_path() # guaranteed to exist or raise
+    fname = os.path.join(path, 'matplotlibrc')
+    if not os.path.exists(fname):
+        warnings.warn('Could not find matplotlibrc; using defaults')
+    return fname
+
+
+_deprecated_map = {
+    'text.fontstyle':   'font.style',
+    'text.fontangle':   'font.style',
+    'text.fontvariant': 'font.variant',
+    'text.fontweight':  'font.weight',
+    'text.fontsize':    'font.size',
+    'tick.size' :       'tick.major.size',
+    }
+
+_deprecated_ignore_map = {
+    'legend.pad' :       'legend.borderpad',
+    'legend.labelsep' :       'legend.labelspacing',
+    'legend.handlelen' :       'legend.handlelength',
+    'legend.handletextsep' :       'legend.handletextpad',
+    'legend.axespad' :       'legend.borderaxespad',
+    }
+
+
+class RcParams(dict):
+
+    """
+    A dictionary object including validation
+
+    validating functions are defined and associated with rc parameters in
+    :mod:`matplotlib.rcsetup`
+    """
+
+    validate = dict([ (key, converter) for key, (default, converter) in \
+                     defaultParams.iteritems() ])
+
+    def __setitem__(self, key, val):
+        try:
+            if key in _deprecated_map.keys():
+                alt = _deprecated_map[key]
+                warnings.warn('%s is deprecated in matplotlibrc. Use %s \
+instead.'% (key, alt))
+                key = alt
+            elif key in _deprecated_ignore_map:
+                alt = _deprecated_ignore_map[key]
+                warnings.warn('%s is deprecated. Use %s instead.'% (key, alt))
+                return
+            cval = self.validate[key](val)
+            dict.__setitem__(self, key, cval)
+        except KeyError:
+            raise KeyError('%s is not a valid rc parameter.\
+See rcParams.keys() for a list of valid parameters.'%key)
+
+
+def rc_params(fail_on_error=False):
+    'Return the default params updated from the values in the rc file'
+
+    fname = matplotlib_fname()
+    if not os.path.exists(fname):
+        # this should never happen, default in mpl-data should always be found
+        message = 'could not find rc file; returning defaults'
+        ret = RcParams([ (key, default) for key, (default, converter) in \
+                        defaultParams.iteritems() ])
+        warnings.warn(message)
+        return ret
+
+    cnt = 0
+    rc_temp = {}
+    for line in file(fname):
+        cnt += 1
+        strippedline = line.split('#',1)[0].strip()
+        if not strippedline: continue
+        tup = strippedline.split(':',1)
+        if len(tup) !=2:
+            warnings.warn('Illegal line #%d\n\t%s\n\tin file "%s"'%\
+                          (cnt, line, fname))
+            continue
+        key, val = tup
+        key = key.strip()
+        val = val.strip()
+        if key in rc_temp:
+            warnings.warn('Duplicate key in file "%s", line #%d'%(fname,cnt))
+        rc_temp[key] = (val, line, cnt)
+
+    ret = RcParams([ (key, default) for key, (default, converter) in \
+                    defaultParams.iteritems() ])
+
+    for key in ('verbose.level', 'verbose.fileo'):
+        if key in rc_temp:
+            val, line, cnt = rc_temp.pop(key)
+            if fail_on_error:
+                ret[key] = val # try to convert to proper type or raise
+            else:
+                try: ret[key] = val # try to convert to proper type or skip
+                except Exception, msg:
+                    warnings.warn('Bad val "%s" on line #%d\n\t"%s"\n\tin file \
+"%s"\n\t%s' % (val, cnt, line, fname, msg))
+
+    verbose.set_level(ret['verbose.level'])
+    verbose.set_fileo(ret['verbose.fileo'])
+
+    for key, (val, line, cnt) in rc_temp.iteritems():
+        if key in defaultParams:
+            if fail_on_error:
+                ret[key] = val # try to convert to proper type or raise
+            else:
+                try: ret[key] = val # try to convert to proper type or skip
+                except Exception, msg:
+                    warnings.warn('Bad val "%s" on line #%d\n\t"%s"\n\tin file \
+"%s"\n\t%s' % (val, cnt, line, fname, msg))
+        elif key in _deprecated_ignore_map:
+            warnings.warn('%s is deprecated. Update your matplotlibrc to use %s instead.'% (key, _deprecated_ignore_map[key]))
+
+        else:
+            print >> sys.stderr, """
+Bad key "%s" on line %d in
+%s.
+You probably need to get an updated matplotlibrc file from
+http://matplotlib.sf.net/_static/matplotlibrc or from the matplotlib source
+distribution""" % (key, cnt, fname)
+
+    if ret['datapath'] is None:
+        ret['datapath'] = get_data_path()
+
+    if not ret['text.latex.preamble'] == ['']:
+        verbose.report("""
+*****************************************************************
+You have the following UNSUPPORTED LaTeX preamble customizations:
+%s
+Please do not ask for support with these customizations active.
+*****************************************************************
+"""% '\n'.join(ret['text.latex.preamble']), 'helpful')
+
+    verbose.report('loaded rc file %s'%fname)
+
+    return ret
+
+
+# this is the instance used by the matplotlib classes
+rcParams = rc_params()
+
+rcParamsDefault = RcParams([ (key, default) for key, (default, converter) in \
+                    defaultParams.iteritems() ])
+
+rcParams['ps.usedistiller'] = checkdep_ps_distiller(rcParams['ps.usedistiller'])
+rcParams['text.usetex'] = checkdep_usetex(rcParams['text.usetex'])
+
+def rc(group, **kwargs):
+    """
+    Set the current rc params.  Group is the grouping for the rc, eg.
+    for ``lines.linewidth`` the group is ``lines``, for
+    ``axes.facecolor``, the group is ``axes``, and so on.  Group may
+    also be a list or tuple of group names, eg. (*xtick*, *ytick*).
+    *kwargs* is a dictionary attribute name/value pairs, eg::
+
+      rc('lines', linewidth=2, color='r')
+
+    sets the current rc params and is equivalent to::
+
+      rcParams['lines.linewidth'] = 2
+      rcParams['lines.color'] = 'r'
+
+    The following aliases are available to save typing for interactive
+    users:
+
+    =====   =================
+    Alias   Property
+    =====   =================
+    'lw'    'linewidth'
+    'ls'    'linestyle'
+    'c'     'color'
+    'fc'    'facecolor'
+    'ec'    'edgecolor'
+    'mew'   'markeredgewidth'
+    'aa'    'antialiased'
+    =====   =================
+
+    Thus you could abbreviate the above rc command as::
+
+          rc('lines', lw=2, c='r')
+
+
+    Note you can use python's kwargs dictionary facility to store
+    dictionaries of default parameters.  Eg, you can customize the
+    font rc as follows::
+
+      font = {'family' : 'monospace',
+              'weight' : 'bold',
+              'size'   : 'larger'}
+
+      rc('font', **font)  # pass in the font dict as kwargs
+
+    This enables you to easily switch between several configurations.
+    Use :func:`~matplotlib.pyplot.rcdefaults` to restore the default
+    rc params after changes.
+    """
+
+    aliases = {
+        'lw'  : 'linewidth',
+        'ls'  : 'linestyle',
+        'c'   : 'color',
+        'fc'  : 'facecolor',
+        'ec'  : 'edgecolor',
+        'mew' : 'markeredgewidth',
+        'aa'  : 'antialiased',
+        }
+
+    if is_string_like(group):
+        group = (group,)
+    for g in group:
+        for k,v in kwargs.items():
+            name = aliases.get(k) or k
+            key = '%s.%s' % (g, name)
+            if key not in rcParams:
+                raise KeyError('Unrecognized key "%s" for group "%s" and name "%s"' %
+                               (key, g, name))
+
+            rcParams[key] = v
+
+def rcdefaults():
+    """
+    Restore the default rc params - the ones that were created at
+    matplotlib load time.
+    """
+    rcParams.update(rcParamsDefault)
+
+_use_error_msg = """ This call to matplotlib.use() has no effect
+because the the backend has already been chosen;
+matplotlib.use() must be called *before* pylab, matplotlib.pyplot,
+or matplotlib.backends is imported for the first time.
+"""
+
+def use(arg, warn=True):
+    """
+    Set the matplotlib backend to one of the known backends.
+
+    The argument is case-insensitive.  For the Cairo backend,
+    the argument can have an extension to indicate the type of
+    output.  Example:
+
+        use('cairo.pdf')
+
+    will specify a default of pdf output generated by Cairo.
+
+    Note: this function must be called *before* importing pylab for
+    the first time; or, if you are not using pylab, it must be called
+    before importing matplotlib.backends.  If warn is True, a warning
+    is issued if you try and callthis after pylab or pyplot have been
+    loaded.  In certain black magic use cases, eg
+    pyplot.switch_backends, we are doing the reloading necessary to
+    make the backend switch work (in some cases, eg pure image
+    backends) so one can set warn=False to supporess the warnings
+    """
+    if 'matplotlib.backends' in sys.modules:
+        if warn: warnings.warn(_use_error_msg)
+        return
+    arg = arg.lower()
+    if arg.startswith('module://'):
+        name = arg
+    else:
+        be_parts = arg.split('.')
+        name = validate_backend(be_parts[0])
+        if len(be_parts) > 1:
+            if name == 'cairo':
+                rcParams['cairo.format'] = validate_cairo_format(be_parts[1])
+            else:
+                raise ValueError('Only cairo backend has a format option')
+    rcParams['backend'] = name
+
+def get_backend():
+    "Returns the current backend"
+    return rcParams['backend']
+
+def interactive(b):
+    """
+    Set interactive mode to boolean b.
+
+    If b is True, then draw after every plotting command, eg, after xlabel
+    """
+    rcParams['interactive'] = b
+
+def is_interactive():
+    'Return true if plot mode is interactive'
+    b = rcParams['interactive']
+    return b
+
+def tk_window_focus():
+    """Return true if focus maintenance under TkAgg on win32 is on.
+     This currently works only for python.exe and IPython.exe.
+     Both IDLE and Pythonwin.exe fail badly when tk_window_focus is on."""
+    if rcParams['backend'] != 'TkAgg':
+        return False
+    return rcParams['tk.window_focus']
+
+# Now allow command line to override
+
+# Allow command line access to the backend with -d (MATLAB compatible
+# flag)
+
+for s in sys.argv[1:]:
+    if s.startswith('-d') and len(s) > 2:  # look for a -d flag
+        try:
+            use(s[2:])
+        except (KeyError, ValueError):
+            pass
+        # we don't want to assume all -d flags are backends, eg -debug
+
+default_test_modules = [
+    'matplotlib.tests.test_agg',
+    'matplotlib.tests.test_backend_svg',
+    'matplotlib.tests.test_basic',
+    'matplotlib.tests.test_cbook',
+    'matplotlib.tests.test_mlab',
+    'matplotlib.tests.test_transforms',
+    'matplotlib.tests.test_axes',
+    'matplotlib.tests.test_dates',
+    'matplotlib.tests.test_spines',
+    'matplotlib.tests.test_image',
+    'matplotlib.tests.test_simplification',
+    'matplotlib.tests.test_mathtext'
+    ]
+
+def test(verbosity=0):
+    """run the matplotlib test suite"""
+    import nose
+    import nose.plugins.builtin
+    from testing.noseclasses import KnownFailure
+    from nose.plugins.manager import PluginManager
+
+    # store the old values before overriding
+    plugins = []
+    plugins.append( KnownFailure() )
+    plugins.extend( [plugin() for plugin in nose.plugins.builtin.plugins] )
+
+    manager = PluginManager(plugins=plugins)
+    config = nose.config.Config(verbosity=verbosity, plugins=manager)
+
+    success = nose.run( defaultTest=default_test_modules,
+                        config=config,
+                        )
+
+    return success
+
+test.__test__ = False # nose: this function is not a test
+
+verbose.report('matplotlib version %s'%__version__)
+verbose.report('verbose.level %s'%verbose.level)
+verbose.report('interactive is %s'%rcParams['interactive'])
+verbose.report('units is %s'%rcParams['units'])
+verbose.report('platform is %s'%sys.platform)
+verbose.report('loaded modules: %s'%sys.modules.keys(), 'debug')

new file patches/__init__.py.patch

@@ +1 @@
+--- ../src/lib/matplotlib/__init__.py   2010-07-06 07:43:34.000000000 -0700
++++ __init__.py 2010-10-23 15:00:19.000000000 -0700
+@@ -103,7 +103,7 @@
+ __revision__ = '$Revision: 8503 $'
+ __date__     = '$Date: 2010-07-06 08:56:31 -0500 (Tue, 06 Jul 2010) $'
+ 
+-import os, re, shutil, subprocess, sys, warnings
++import os, re, shutil, subprocess, sys, warnings, errno
+ import distutils.sysconfig
+ import distutils.version
+ 
+@@ -470,7 +470,13 @@
+         if not _is_writable_dir(h):
+             raise RuntimeError("Failed to create %s/.matplotlib; consider setting MPLCONFIGDIR to a writable directory for matplotlib configuration data"%h)
+ 
+-        os.mkdir(p)
++        try:
++            os.mkdir(p)
++        except OSError, e:
++            if e.errno == errno.EEXIST:
++                pass
++            else:
++                raise
+ 
+     return p
+ get_configdir = verbose.wrap('CONFIGDIR=%s', _get_configdir, always=False)

new file patches/finance.py

@@ +1 @@
+"""
+A collection of modules for collecting, analyzing and plotting
+financial data.   User contributions welcome!
+
+"""
+#from __future__ import division
+import os, time, warnings, errno
+from urllib2 import urlopen
+
+try:
+    from hashlib import md5
+except ImportError:
+    from md5 import md5 #Deprecated in 2.5
+import datetime
+
+import numpy as np
+
+from matplotlib import verbose, get_configdir
+from matplotlib.dates import date2num
+from matplotlib.cbook import iterable, is_string_like
+from matplotlib.collections import LineCollection, PolyCollection
+from matplotlib.colors import colorConverter
+from matplotlib.lines import Line2D, TICKLEFT, TICKRIGHT
+from matplotlib.patches import Rectangle
+from matplotlib.transforms import Affine2D
+
+
+configdir = get_configdir()
+cachedir = os.path.join(configdir, 'finance.cache')
+
+
+stock_dt = np.dtype([('date', object),
+                     ('year', np.int16),
+                     ('month', np.int8),
+                     ('day', np.int8),
+                     ('d', np.float),     # mpl datenum
+                     ('open', np.float),
+                     ('close', np.float),
+                     ('high', np.float),
+                     ('low', np.float),
+                     ('volume', np.int),
+                     ('aclose', np.float)])
+
+
+def parse_yahoo_historical(fh, adjusted=True, asobject=False):
+    """
+    Parse the historical data in file handle fh from yahoo finance.
+
+    *adjusted*
+      If True (default) replace open, close, high, low, and volume with
+      their adjusted values.
+      The adjustment is by a scale factor, S = adjusted_close/close.
+      Adjusted volume is actual volume divided by S;
+      Adjusted prices are actual prices multiplied by S.  Hence,
+      the product of price and volume is unchanged by the adjustment.
+
+    *asobject*
+      If False (default for compatibility with earlier versions)
+      return a list of tuples containing
+
+        d, open, close, high, low, volume
+
+      If None (preferred alternative to False), return
+      a 2-D ndarray corresponding to the list of tuples.
+
+      Otherwise return a numpy recarray with
+
+        date, year, month, day, d, open, close, high, low,
+        volume, adjusted_close
+
+      where d is a floating poing representation of date,
+      as returned by date2num, and date is a python standard
+      library datetime.date instance.
+
+      The name of this kwarg is a historical artifact.  Formerly,
+      True returned a cbook Bunch
+      holding 1-D ndarrays.  The behavior of a numpy recarray is
+      very similar to the Bunch.
+
+    """
+
+    lines = fh.readlines()
+
+    results = []
+
+    datefmt = '%Y-%m-%d'
+
+    for line in lines[1:]:
+
+        vals = line.split(',')
+        if len(vals)!=7:
+            continue      # add warning?
+        datestr = vals[0]
+        #dt = datetime.date(*time.strptime(datestr, datefmt)[:3])
+        # Using strptime doubles the runtime. With the present
+        # format, we don't need it.
+        dt = datetime.date(*[int(val) for val in datestr.split('-')])
+        dnum = date2num(dt)
+        open, high, low, close =  [float(val) for val in vals[1:5]]
+        volume = int(vals[5])
+        aclose = float(vals[6])
+
+        results.append((dt, dt.year, dt.month, dt.day,
+                        dnum, open, close, high, low, volume, aclose))
+    results.reverse()
+    d = np.array(results, dtype=stock_dt)
+    if adjusted:
+        scale = d['aclose'] / d['close']
+        scale[np.isinf(scale)] = np.nan
+        d['open'] *= scale
+        d['close'] *= scale
+        d['high'] *= scale
+        d['low'] *= scale
+
+    if not asobject:
+        # 2-D sequence; formerly list of tuples, now ndarray
+        ret = np.zeros((len(d), 6), dtype=np.float)
+        ret[:,0] = d['d']
+        ret[:,1] = d['open']
+        ret[:,2] = d['close']
+        ret[:,3] = d['high']
+        ret[:,4] = d['low']
+        ret[:,5] = d['volume']
+        if asobject is None:
+            return ret
+        return [tuple(row) for row in ret]
+
+    return d.view(np.recarray)  # Close enough to former Bunch return
+
+
+def fetch_historical_yahoo(ticker, date1, date2, cachename=None):
+    """
+    Fetch historical data for ticker between date1 and date2.  date1 and
+    date2 are date or datetime instances, or (year, month, day) sequences.
+
+    Ex:
+    fh = fetch_historical_yahoo('^GSPC', (2000, 1, 1), (2001, 12, 31))
+
+    cachename is the name of the local file cache.  If None, will
+    default to the md5 hash or the url (which incorporates the ticker
+    and date range)
+
+    a file handle is returned
+    """
+
+    ticker = ticker.upper()
+
+
+    if iterable(date1):
+        d1 = (date1[1]-1, date1[2], date1[0])
+    else:
+        d1 = (date1.month-1, date1.day, date1.year)
+    if iterable(date2):
+        d2 = (date2[1]-1, date2[2], date2[0])
+    else:
+        d2 = (date2.month-1, date2.day, date2.year)
+
+
+    urlFmt = 'http://table.finance.yahoo.com/table.csv?a=%d&b=%d&c=%d&d=%d&e=%d&f=%d&s=%s&y=0&g=d&ignore=.csv'
+
+
+    url =  urlFmt % (d1[0], d1[1], d1[2],
+                     d2[0], d2[1], d2[2], ticker)
+
+
+    if cachename is None:
+        cachename = os.path.join(cachedir, md5(url).hexdigest())
+    if os.path.exists(cachename):
+        fh = file(cachename)
+        verbose.report('Using cachefile %s for %s'%(cachename, ticker))
+    else:
+        try: 
+            os.mkdir(cachedir)
+        except OSError, e:
+            if e.errno == errno.EEXIST:
+                pass
+            else:
+                raise
+        urlfh = urlopen(url)
+
+        fh = file(cachename, 'w')
+        fh.write(urlfh.read())
+        fh.close()
+        verbose.report('Saved %s data to cache file %s'%(ticker, cachename))
+        fh = file(cachename, 'r')
+
+    return fh
+
+
+def quotes_historical_yahoo(ticker, date1, date2, asobject=False,
+                                        adjusted=True, cachename=None):
+    """
+    Get historical data for ticker between date1 and date2.  date1 and
+    date2 are datetime instances or (year, month, day) sequences.
+
+    See :func:`parse_yahoo_historical` for explanation of output formats
+    and the *asobject* and *adjusted* kwargs.
+
+    Ex:
+    sp = f.quotes_historical_yahoo('^GSPC', d1, d2,
+                                asobject=True, adjusted=True)
+    returns = (sp.open[1:] - sp.open[:-1])/sp.open[1:]
+    [n,bins,patches] = hist(returns, 100)
+    mu = mean(returns)
+    sigma = std(returns)
+    x = normpdf(bins, mu, sigma)
+    plot(bins, x, color='red', lw=2)
+
+    cachename is the name of the local file cache.  If None, will
+    default to the md5 hash or the url (which incorporates the ticker
+    and date range)
+    """
+    # Maybe enable a warning later as part of a slow transition
+    # to using None instead of False.
+    #if asobject is False:
+    #    warnings.warn("Recommend changing to asobject=None")
+
+    fh = fetch_historical_yahoo(ticker, date1, date2, cachename)
+
+    try:
+        ret = parse_yahoo_historical(fh, asobject=asobject,
+                                            adjusted=adjusted)
+        if len(ret) == 0:
+            return None
+    except IOError, exc:
+        warnings.warn('urlopen() failure\n' + url + '\n' + exc.strerror[1])
+        return None
+
+    return ret
+
+def plot_day_summary(ax, quotes, ticksize=3,
+                     colorup='k', colordown='r',
+                     ):
+    """
+    quotes is a sequence of (time, open, close, high, low, ...) sequences
+
+    Represent the time, open, close, high, low as a vertical line
+    ranging from low to high.  The left tick is the open and the right
+    tick is the close.
+
+    time must be in float date format - see date2num
+
+    ax          : an Axes instance to plot to
+    ticksize    : open/close tick marker in points
+    colorup     : the color of the lines where close >= open
+    colordown   : the color of the lines where close <  open
+    return value is a list of lines added
+    """
+
+    lines = []
+    for q in quotes:
+
+        t, open, close, high, low = q[:5]
+
+        if close>=open : color = colorup
+        else           : color = colordown
+
+        vline = Line2D(
+            xdata=(t, t), ydata=(low, high),
+            color=color,
+            antialiased=False,   # no need to antialias vert lines
+            )
+
+        oline = Line2D(
+            xdata=(t, t), ydata=(open, open),
+            color=color,
+            antialiased=False,
+            marker=TICKLEFT,
+            markersize=ticksize,
+            )
+
+        cline = Line2D(
+            xdata=(t, t), ydata=(close, close),
+            color=color,
+            antialiased=False,
+            markersize=ticksize,
+            marker=TICKRIGHT)
+
+        lines.extend((vline, oline, cline))
+        ax.add_line(vline)
+        ax.add_line(oline)
+        ax.add_line(cline)
+
+
+    ax.autoscale_view()
+
+    return lines
+
+
+def candlestick(ax, quotes, width=0.2, colorup='k', colordown='r',
+                alpha=1.0):
+
+    """
+
+    quotes is a sequence of (time, open, close, high, low, ...) sequences.
+    As long as the first 5 elements are these values,
+    the record can be as long as you want (eg it may store volume).
+
+    time must be in float days format - see date2num
+
+    Plot the time, open, close, high, low as a vertical line ranging
+    from low to high.  Use a rectangular bar to represent the
+    open-close span.  If close >= open, use colorup to color the bar,
+    otherwise use colordown
+
+    ax          : an Axes instance to plot to
+    width       : fraction of a day for the rectangle width
+    colorup     : the color of the rectangle where close >= open
+    colordown   : the color of the rectangle where close <  open
+    alpha       : the rectangle alpha level
+
+    return value is lines, patches where lines is a list of lines
+    added and patches is a list of the rectangle patches added
+
+    """
+
+    OFFSET = width/2.0
+
+    lines = []
+    patches = []
+    for q in quotes:
+        t, open, close, high, low = q[:5]
+
+        if close>=open :
+            color = colorup
+            lower = open
+            height = close-open
+        else           :
+            color = colordown
+            lower = close
+            height = open-close
+
+        vline = Line2D(
+            xdata=(t, t), ydata=(low, high),
+            color='k',
+            linewidth=0.5,
+            antialiased=True,
+            )
+
+        rect = Rectangle(
+            xy    = (t-OFFSET, lower),
+            width = width,
+            height = height,
+            facecolor = color,
+            edgecolor = color,
+            )
+        rect.set_alpha(alpha)
+
+
+        lines.append(vline)
+        patches.append(rect)
+        ax.add_line(vline)
+        ax.add_patch(rect)
+    ax.autoscale_view()
+
+    return lines, patches
+
+
+def plot_day_summary2(ax, opens, closes, highs, lows, ticksize=4,
+                      colorup='k', colordown='r',
+                     ):
+    """
+
+    Represent the time, open, close, high, low as a vertical line
+    ranging from low to high.  The left tick is the open and the right
+    tick is the close.
+
+    ax          : an Axes instance to plot to
+    ticksize    : size of open and close ticks in points
+    colorup     : the color of the lines where close >= open
+    colordown   : the color of the lines where close <  open
+
+    return value is a list of lines added
+    """
+
+    # note this code assumes if any value open, close, low, high is
+    # missing they all are missing
+
+    rangeSegments = [ ((i, low), (i, high)) for i, low, high in zip(xrange(len(lows)), lows, highs) if low != -1 ]
+
+    # the ticks will be from ticksize to 0 in points at the origin and
+    # we'll translate these to the i, close location
+    openSegments = [  ((-ticksize, 0), (0, 0)) ]
+
+    # the ticks will be from 0 to ticksize in points at the origin and
+    # we'll translate these to the i, close location
+    closeSegments = [ ((0, 0), (ticksize, 0)) ]
+
+
+    offsetsOpen = [ (i, open) for i, open in zip(xrange(len(opens)), opens) if open != -1 ]
+
+    offsetsClose = [ (i, close) for i, close in zip(xrange(len(closes)), closes) if close != -1 ]
+
+
+    scale = ax.figure.dpi * (1.0/72.0)
+
+    tickTransform = Affine2D().scale(scale, 0.0)
+
+    r,g,b = colorConverter.to_rgb(colorup)
+    colorup = r,g,b,1
+    r,g,b = colorConverter.to_rgb(colordown)
+    colordown = r,g,b,1
+    colord = { True : colorup,
+               False : colordown,
+               }
+    colors = [colord[open<close] for open, close in zip(opens, closes) if open!=-1 and close !=-1]
+
+    assert(len(rangeSegments)==len(offsetsOpen))
+    assert(len(offsetsOpen)==len(offsetsClose))
+    assert(len(offsetsClose)==len(colors))
+
+    useAA = 0,   # use tuple here
+    lw = 1,      # and here
+    rangeCollection = LineCollection(rangeSegments,
+                                     colors       = colors,
+                                     linewidths   = lw,
+                                     antialiaseds = useAA,
+                                     )
+
+    openCollection = LineCollection(openSegments,
+                                    colors       = colors,
+                                    antialiaseds = useAA,
+                                    linewidths   = lw,
+                                    offsets      = offsetsOpen,
+                                    transOffset  = ax.transData,
+                                   )
+    openCollection.set_transform(tickTransform)
+
+    closeCollection = LineCollection(closeSegments,
+                                     colors       = colors,
+                                     antialiaseds = useAA,
+                                     linewidths   = lw,
+                                     offsets      = offsetsClose,
+                                     transOffset  = ax.transData,
+                                     )
+    closeCollection.set_transform(tickTransform)
+
+    minpy, maxx = (0, len(rangeSegments))
+    miny = min([low for low in lows if low !=-1])
+    maxy = max([high for high in highs if high != -1])
+    corners = (minpy, miny), (maxx, maxy)
+    ax.update_datalim(corners)
+    ax.autoscale_view()
+
+    # add these last
+    ax.add_collection(rangeCollection)
+    ax.add_collection(openCollection)
+    ax.add_collection(closeCollection)
+    return rangeCollection, openCollection, closeCollection
+
+
+def candlestick2(ax, opens, closes, highs, lows, width=4,
+                 colorup='k', colordown='r',
+                 alpha=0.75,
+                ):
+    """
+
+    Represent the open, close as a bar line and high low range as a
+    vertical line.
+
+
+    ax          : an Axes instance to plot to
+    width       : the bar width in points
+    colorup     : the color of the lines where close >= open
+    colordown   : the color of the lines where close <  open
+    alpha       : bar transparency
+
+    return value is lineCollection, barCollection
+    """
+
+    # note this code assumes if any value open, close, low, high is
+    # missing they all are missing
+
+    delta = width/2.
+    barVerts = [ ( (i-delta, open), (i-delta, close), (i+delta, close), (i+delta, open) ) for i, open, close in zip(xrange(len(opens)), opens, closes) if open != -1 and close!=-1 ]
+
+    rangeSegments = [ ((i, low), (i, high)) for i, low, high in zip(xrange(len(lows)), lows, highs) if low != -1 ]
+
+
+
+    r,g,b = colorConverter.to_rgb(colorup)
+    colorup = r,g,b,alpha
+    r,g,b = colorConverter.to_rgb(colordown)
+    colordown = r,g,b,alpha
+    colord = { True : colorup,
+               False : colordown,
+               }
+    colors = [colord[open<close] for open, close in zip(opens, closes) if open!=-1 and close !=-1]
+
+
+    assert(len(barVerts)==len(rangeSegments))
+
+    useAA = 0,  # use tuple here
+    lw = 0.5,   # and here
+    rangeCollection = LineCollection(rangeSegments,
+                                     colors       = ( (0,0,0,1), ),
+                                     linewidths   = lw,
+                                     antialiaseds = useAA,
+                                     )
+
+
+    barCollection = PolyCollection(barVerts,
+                                   facecolors   = colors,
+                                   edgecolors   = ( (0,0,0,1), ),
+                                   antialiaseds = useAA,
+                                   linewidths   = lw,
+                                   )
+
+    minx, maxx = 0, len(rangeSegments)
+    miny = min([low for low in lows if low !=-1])
+    maxy = max([high for high in highs if high != -1])
+
+    corners = (minx, miny), (maxx, maxy)
+    ax.update_datalim(corners)
+    ax.autoscale_view()
+
+    # add these last
+    ax.add_collection(barCollection)
+    ax.add_collection(rangeCollection)
+    return rangeCollection, barCollection
+
+def volume_overlay(ax, opens, closes, volumes,
+                   colorup='k', colordown='r',
+                   width=4, alpha=1.0):
+    """
+    Add a volume overlay to the current axes.  The opens and closes
+    are used to determine the color of the bar.  -1 is missing.  If a
+    value is missing on one it must be missing on all
+
+    ax          : an Axes instance to plot to
+    width       : the bar width in points
+    colorup     : the color of the lines where close >= open
+    colordown   : the color of the lines where close <  open
+    alpha       : bar transparency
+
+
+    """
+
+    r,g,b = colorConverter.to_rgb(colorup)
+    colorup = r,g,b,alpha
+    r,g,b = colorConverter.to_rgb(colordown)
+    colordown = r,g,b,alpha
+    colord = { True : colorup,
+               False : colordown,
+               }
+    colors = [colord[open<close] for open, close in zip(opens, closes) if open!=-1 and close !=-1]
+
+    delta = width/2.
+    bars = [ ( (i-delta, 0), (i-delta, v), (i+delta, v), (i+delta, 0)) for i, v in enumerate(volumes) if v != -1 ]
+
+    barCollection = PolyCollection(bars,
+                                   facecolors   = colors,
+                                   edgecolors   = ( (0,0,0,1), ),
+                                   antialiaseds = (0,),
+                                   linewidths   = (0.5,),
+                                   )
+
+    corners = (0, 0), (len(bars), max(volumes))
+    ax.update_datalim(corners)
+    ax.autoscale_view()
+
+    # add these last
+    return barCollection
+
+
+def volume_overlay2(ax, closes, volumes,
+                   colorup='k', colordown='r',
+                   width=4, alpha=1.0):
+    """
+    Add a volume overlay to the current axes.  The closes are used to
+    determine the color of the bar.  -1 is missing.  If a value is
+    missing on one it must be missing on all
+
+    ax          : an Axes instance to plot to
+    width       : the bar width in points
+    colorup     : the color of the lines where close >= open
+    colordown   : the color of the lines where close <  open
+    alpha       : bar transparency
+
+    nb: first point is not displayed - it is used only for choosing the
+    right color
+
+    """
+
+    return volume_overlay(ax,closes[:-1],closes[1:],volumes[1:],colorup,colordown,width,alpha)
+
+
+def volume_overlay3(ax, quotes,
+                   colorup='k', colordown='r',
+                   width=4, alpha=1.0):
+    """
+    Add a volume overlay to the current axes.  quotes is a list of (d,
+    open, close, high, low, volume) and close-open is used to
+    determine the color of the bar
+
+    kwarg
+    width       : the bar width in points
+    colorup     : the color of the lines where close1 >= close0
+    colordown   : the color of the lines where close1 <  close0
+    alpha       : bar transparency
+
+
+    """
+
+    r,g,b = colorConverter.to_rgb(colorup)
+    colorup = r,g,b,alpha
+    r,g,b = colorConverter.to_rgb(colordown)
+    colordown = r,g,b,alpha
+    colord = { True : colorup,
+               False : colordown,
+               }
+
+    dates, opens, closes, highs, lows, volumes = zip(*quotes)
+    colors = [colord[close1>=close0] for close0, close1 in zip(closes[:-1], closes[1:]) if close0!=-1 and close1 !=-1]
+    colors.insert(0,colord[closes[0]>=opens[0]])
+
+    right = width/2.0
+    left = -width/2.0
+
+
+    bars = [ ( (left, 0), (left, volume), (right, volume), (right, 0)) for d, open, close, high, low, volume in quotes]
+
+    sx = ax.figure.dpi * (1.0/72.0)  # scale for points
+    sy = ax.bbox.height / ax.viewLim.height
+
+    barTransform = Affine2D().scale(sx,sy)
+
+    dates = [d for d, open, close, high, low, volume in quotes]
+    offsetsBars = [(d, 0) for d in dates]
+
+    useAA = 0,  # use tuple here
+    lw = 0.5,   # and here
+    barCollection = PolyCollection(bars,
+                                   facecolors   = colors,
+                                   edgecolors   = ( (0,0,0,1), ),
+                                   antialiaseds = useAA,
+                                   linewidths   = lw,
+                                   offsets      = offsetsBars,
+                                   transOffset  = ax.transData,
+                                   )
+    barCollection.set_transform(barTransform)
+
+
+
+
+
+
+    minpy, maxx = (min(dates), max(dates))
+    miny = 0
+    maxy = max([volume for d, open, close, high, low, volume in quotes])
+    corners = (minpy, miny), (maxx, maxy)
+    ax.update_datalim(corners)
+    #print 'datalim', ax.dataLim.bounds
+    #print 'viewlim', ax.viewLim.bounds
+
+    ax.add_collection(barCollection)
+    ax.autoscale_view()
+
+    return barCollection
+
+def index_bar(ax, vals,
+              facecolor='b', edgecolor='l',
+              width=4, alpha=1.0, ):
+    """
+    Add a bar collection graph with height vals (-1 is missing).
+
+    ax          : an Axes instance to plot to
+    width       : the bar width in points
+    alpha       : bar transparency
+
+
+    """
+
+    facecolors = (colorConverter.to_rgba(facecolor, alpha),)
+    edgecolors = (colorConverter.to_rgba(edgecolor, alpha),)
+
+    right = width/2.0
+    left = -width/2.0
+
+
+    bars = [ ( (left, 0), (left, v), (right, v), (right, 0)) for v in vals if v != -1 ]
+
+    sx = ax.figure.dpi * (1.0/72.0)  # scale for points
+    sy = ax.bbox.height / ax.viewLim.height
+
+    barTransform = Affine2D().scale(sx,sy)
+
+    offsetsBars = [ (i, 0) for i,v in enumerate(vals) if v != -1 ]
+
+    barCollection = PolyCollection(bars,
+                                   facecolors   = facecolors,
+                                   edgecolors   = edgecolors,
+                                   antialiaseds = (0,),
+                                   linewidths   = (0.5,),
+                                   offsets      = offsetsBars,
+                                   transOffset  = ax.transData,
+                                   )
+    barCollection.set_transform(barTransform)
+
+
+
+
+
+
+    minpy, maxx = (0, len(offsetsBars))
+    miny = 0
+    maxy = max([v for v in vals if v!=-1])
+    corners = (minpy, miny), (maxx, maxy)
+    ax.update_datalim(corners)
+    ax.autoscale_view()
+
+    # add these last
+    ax.add_collection(barCollection)
+    return barCollection

new file patches/finance.py.patch

@@ +1 @@
+--- ../src/lib/matplotlib/finance.py    2010-07-06 07:43:34.000000000 -0700
++++ finance.py  2010-10-23 15:01:12.000000000 -0700
+@@ -4,7 +4,7 @@
+ 
+ """
+ #from __future__ import division
+-import os, time, warnings
++import os, time, warnings, errno
+ from urllib2 import urlopen
+ 
+ try:
+@@ -169,8 +169,13 @@
+         fh = file(cachename)
+         verbose.report('Using cachefile %s for %s'%(cachename, ticker))
+     else:
+-        if not os.path.isdir(cachedir):
++        try: 
+             os.mkdir(cachedir)
++        except OSError, e:
++            if e.errno == errno.EEXIST:
++                pass
++            else:
++                raise
+         urlfh = urlopen(url)
+ 
+         fh = file(cachename, 'w')

new file patches/texmanager.py

@@ +1 @@
+"""
+This module supports embedded TeX expressions in matplotlib via dvipng
+and dvips for the raster and postscript backends.  The tex and
+dvipng/dvips information is cached in ~/.matplotlib/tex.cache for reuse between
+sessions
+
+Requirements:
+
+* latex
+* \*Agg backends: dvipng
+* PS backend: latex w/ psfrag, dvips, and Ghostscript 8.51
+  (older versions do not work properly)
+
+Backends:
+
+* \*Agg
+* PS
+* PDF
+
+For raster output, you can get RGBA numpy arrays from TeX expressions
+as follows::
+
+  texmanager = TexManager()
+  s = '\\TeX\\ is Number $\\displaystyle\\sum_{n=1}^\\infty\\frac{-e^{i\pi}}{2^n}$!'
+  Z = self.texmanager.get_rgba(s, size=12, dpi=80, rgb=(1,0,0))
+
+To enable tex rendering of all text in your matplotlib figure, set
+text.usetex in your matplotlibrc file (http://matplotlib.sf.net/matplotlibrc)
+or include these two lines in your script::
+
+  from matplotlib import rc
+  rc('text', usetex=True)
+
+"""
+
+import copy, glob, os, shutil, sys, warnings, errno
+from subprocess import Popen, PIPE, STDOUT
+
+try:
+    from hashlib import md5
+except ImportError:
+    from md5 import md5 #Deprecated in 2.5
+
+import distutils.version
+import numpy as np
+import matplotlib as mpl
+from matplotlib import rcParams
+from matplotlib._png import read_png
+import matplotlib.dviread as dviread
+import re
+
+DEBUG = False
+
+if sys.platform.startswith('win'): cmd_split = '&'
+else: cmd_split = ';'
+
+def dvipng_hack_alpha():
+    p = Popen('dvipng -version', shell=True, stdin=PIPE, stdout=PIPE,
+        stderr=STDOUT, close_fds=(sys.platform!='win32'))
+    stdin, stdout = p.stdin, p.stdout
+    for line in stdout:
+        if line.startswith('dvipng '):
+            version = line.split()[-1]
+            mpl.verbose.report('Found dvipng version %s'% version,
+                'helpful')
+            version = distutils.version.LooseVersion(version)
+            return version < distutils.version.LooseVersion('1.6')
+    mpl.verbose.report('No dvipng was found', 'helpful')
+    return False
+
+
+class TexManager:
+
+    """
+    Convert strings to dvi files using TeX, caching the results to a
+    working dir
+    """
+
+    oldpath = mpl.get_home()
+    if oldpath is None: oldpath = mpl.get_data_path()
+    oldcache = os.path.join(oldpath, '.tex.cache')
+
+    configdir = mpl.get_configdir()
+    texcache = os.path.join(configdir, 'tex.cache')
+
+    if os.path.exists(oldcache):
+        print >> sys.stderr, """\
+WARNING: found a TeX cache dir in the deprecated location "%s".
+  Moving it to the new default location "%s"."""%(oldcache, texcache)
+        shutil.move(oldcache, texcache)
+    try:
+        os.mkdir(texcache)
+    except OSError, e:
+        if e.errno == errno.EEXIST:
+            pass
+        else:
+            raise
+
+    _dvipng_hack_alpha = None
+    #_dvipng_hack_alpha = dvipng_hack_alpha()
+    # mappable cache of
+    rgba_arrayd = {}
+    grey_arrayd = {}
+    postscriptd = {}
+    pscnt = 0
+
+    serif = ('cmr', '')
+    sans_serif = ('cmss', '')
+    monospace = ('cmtt', '')
+    cursive = ('pzc', r'\usepackage{chancery}')
+    font_family = 'serif'
+    font_families = ('serif', 'sans-serif', 'cursive', 'monospace')
+
+    font_info = {'new century schoolbook': ('pnc',
+                                            r'\renewcommand{\rmdefault}{pnc}'),
+                'bookman': ('pbk', r'\renewcommand{\rmdefault}{pbk}'),
+                'times': ('ptm', r'\usepackage{mathptmx}'),
+                'palatino': ('ppl', r'\usepackage{mathpazo}'),
+                'zapf chancery': ('pzc', r'\usepackage{chancery}'),
+                'cursive': ('pzc', r'\usepackage{chancery}'),
+                'charter': ('pch', r'\usepackage{charter}'),
+                'serif': ('cmr', ''),
+                'sans-serif': ('cmss', ''),
+                'helvetica': ('phv', r'\usepackage{helvet}'),
+                'avant garde': ('pag', r'\usepackage{avant}'),
+                'courier': ('pcr', r'\usepackage{courier}'),
+                'monospace': ('cmtt', ''),
+                'computer modern roman': ('cmr', ''),
+                'computer modern sans serif': ('cmss', ''),
+                'computer modern typewriter': ('cmtt', '')}
+
+    _rc_cache = None
+    _rc_cache_keys = ('text.latex.preamble', )\
+                     + tuple(['font.'+n for n in ('family', ) + font_families])
+
+    def __init__(self):
+
+        try:
+            os.mkdir(self.texcache)
+        except OSError, e:
+            if e.errno == errno.EEXIST:
+                pass
+            else:
+                raise
+            
+        ff = rcParams['font.family'].lower()
+        if ff in self.font_families:
+            self.font_family = ff
+        else:
+            mpl.verbose.report('The %s font family is not compatible with LaTeX. serif will be used by default.' % ff, 'helpful')
+            self.font_family = 'serif'
+
+        fontconfig = [self.font_family]
+        for font_family, font_family_attr in \
+            [(ff, ff.replace('-', '_')) for ff in self.font_families]:
+            for font in rcParams['font.'+font_family]:
+                if font.lower() in self.font_info:
+                    found_font = self.font_info[font.lower()]
+                    setattr(self, font_family_attr,
+                            self.font_info[font.lower()])
+                    if DEBUG:
+                        print 'family: %s, font: %s, info: %s'%(font_family,
+                                    font, self.font_info[font.lower()])
+                    break
+                else:
+                    if DEBUG: print '$s font is not compatible with usetex'
+            else:
+                mpl.verbose.report('No LaTeX-compatible font found for the %s font family in rcParams. Using default.' % ff, 'helpful')
+                setattr(self, font_family_attr, self.font_info[font_family])
+            fontconfig.append(getattr(self, font_family_attr)[0])
+        self._fontconfig = ''.join(fontconfig)
+
+        # The following packages and commands need to be included in the latex
+        # file's preamble:
+        cmd = [self.serif[1], self.sans_serif[1], self.monospace[1]]
+        if self.font_family == 'cursive': cmd.append(self.cursive[1])
+        while r'\usepackage{type1cm}' in cmd:
+            cmd.remove(r'\usepackage{type1cm}')
+        cmd = '\n'.join(cmd)
+        self._font_preamble = '\n'.join([r'\usepackage{type1cm}', cmd,
+                                         r'\usepackage{textcomp}'])
+
+    def get_basefile(self, tex, fontsize, dpi=None):
+        """
+        returns a filename based on a hash of the string, fontsize, and dpi
+        """
+        s = ''.join([tex, self.get_font_config(), '%f'%fontsize,
+                     self.get_custom_preamble(), str(dpi or '')])
+        # make sure hash is consistent for all strings, regardless of encoding:
+        bytes = unicode(s).encode('utf-8')
+        return os.path.join(self.texcache, md5(bytes).hexdigest())
+
+    def get_font_config(self):
+        """Reinitializes self if relevant rcParams on have changed."""
+        if self._rc_cache is None:
+            self._rc_cache = dict([(k,None) for k in self._rc_cache_keys])
+        changed = [par for par in self._rc_cache_keys if rcParams[par] != \
+                   self._rc_cache[par]]
+        if changed:
+            if DEBUG: print 'DEBUG following keys changed:', changed
+            for k in changed:
+                if DEBUG:
+                    print 'DEBUG %-20s: %-10s -> %-10s' % \
+                            (k, self._rc_cache[k], rcParams[k])
+                # deepcopy may not be necessary, but feels more future-proof
+                self._rc_cache[k] = copy.deepcopy(rcParams[k])
+            if DEBUG: print 'DEBUG RE-INIT\nold fontconfig:', self._fontconfig
+            self.__init__()
+        if DEBUG: print 'DEBUG fontconfig:', self._fontconfig
+        return self._fontconfig
+
+    def get_font_preamble(self):
+        """
+        returns a string containing font configuration for the tex preamble
+        """
+        return self._font_preamble
+
+    def get_custom_preamble(self):
+        """returns a string containing user additions to the tex preamble"""
+        return '\n'.join(rcParams['text.latex.preamble'])
+
+    def _get_shell_cmd(self, *args):
+        """
+        On windows, changing directories can be complicated by the presence of
+        multiple drives. get_shell_cmd deals with this issue.
+        """
+        if sys.platform == 'win32':
+            command = ['%s'% os.path.splitdrive(self.texcache)[0]]
+        else:
+            command = []
+        command.extend(args)
+        return ' && '.join(command)
+
+    def make_tex(self, tex, fontsize):
+        """
+        Generate a tex file to render the tex string at a specific font size
+
+        returns the file name
+        """
+        basefile = self.get_basefile(tex, fontsize)
+        texfile = '%s.tex'%basefile
+        fh = file(texfile, 'w')
+        custom_preamble = self.get_custom_preamble()
+        fontcmd = {'sans-serif' : r'{\sffamily %s}',
+                   'monospace'  : r'{\ttfamily %s}'}.get(self.font_family,
+                                                         r'{\rmfamily %s}')
+        tex = fontcmd % tex
+
+        if rcParams['text.latex.unicode']:
+            unicode_preamble = """\usepackage{ucs}
+\usepackage[utf8x]{inputenc}"""
+        else:
+            unicode_preamble = ''
+
+        s = r"""\documentclass{article}
+%s
+%s
+%s
+\usepackage[papersize={72in,72in}, body={70in,70in}, margin={1in,1in}]{geometry}
+\pagestyle{empty}
+\begin{document}
+\fontsize{%f}{%f}%s
+\end{document}
+""" % (self._font_preamble, unicode_preamble, custom_preamble,
+       fontsize, fontsize*1.25, tex)
+        if rcParams['text.latex.unicode']:
+            fh.write(s.encode('utf8'))
+        else:
+            try:
+                fh.write(s)
+            except UnicodeEncodeError, err:
+                mpl.verbose.report("You are using unicode and latex, but have "
+                            "not enabled the matplotlib 'text.latex.unicode' "
+                            "rcParam.", 'helpful')
+                raise
+
+        fh.close()
+
+        return texfile
+
+
+    _re_vbox = re.compile(r"MatplotlibBox:\(([\d.]+)pt\+([\d.]+)pt\)x([\d.]+)pt")
+
+    def make_tex_preview(self, tex, fontsize):
+        """
+        Generate a tex file to render the tex string at a specific
+        font size.  It uses the preview.sty to determin the dimension
+        (width, height, descent) of the output.
+
+        returns the file name
+        """
+        basefile = self.get_basefile(tex, fontsize)
+        texfile = '%s.tex'%basefile
+        fh = file(texfile, 'w')
+        custom_preamble = self.get_custom_preamble()
+        fontcmd = {'sans-serif' : r'{\sffamily %s}',
+                   'monospace'  : r'{\ttfamily %s}'}.get(self.font_family,
+                                                         r'{\rmfamily %s}')
+        tex = fontcmd % tex
+
+        if rcParams['text.latex.unicode']:
+            unicode_preamble = """\usepackage{ucs}
+\usepackage[utf8x]{inputenc}"""
+        else:
+            unicode_preamble = ''
+
+
+
+        # newbox, setbox, immediate, etc. are used to find the box
+        # extent of the rendered text.
+
+
+        s = r"""\documentclass{article}
+%s
+%s
+%s
+\usepackage[active,showbox,tightpage]{preview}
+\usepackage[papersize={72in,72in}, body={70in,70in}, margin={1in,1in}]{geometry}
+
+%% we override the default showbox as it is treated as an error and makes
+%% the exit status not zero
+\def\showbox#1{\immediate\write16{MatplotlibBox:(\the\ht#1+\the\dp#1)x\the\wd#1}}
+
+\begin{document}
+\begin{preview}
+{\fontsize{%f}{%f}%s}
+\end{preview}
+\end{document}
+""" % (self._font_preamble, unicode_preamble, custom_preamble,
+       fontsize, fontsize*1.25, tex)
+        if rcParams['text.latex.unicode']:
+            fh.write(s.encode('utf8'))
+        else:
+            try:
+                fh.write(s)
+            except UnicodeEncodeError, err:
+                mpl.verbose.report("You are using unicode and latex, but have "
+                            "not enabled the matplotlib 'text.latex.unicode' "
+                            "rcParam.", 'helpful')
+                raise
+
+        fh.close()
+
+        return texfile
+
+
+    def make_dvi(self, tex, fontsize):
+        """
+        generates a dvi file containing latex's layout of tex string
+
+        returns the file name
+        """
+
+
+        if rcParams['text.latex.preview']:
+            return self.make_dvi_preview(tex, fontsize)
+
+        basefile = self.get_basefile(tex, fontsize)
+        dvifile = '%s.dvi'% basefile
+
+        if DEBUG or not os.path.exists(dvifile):
+            texfile = self.make_tex(tex, fontsize)
+            outfile = basefile+'.output'
+            command = self._get_shell_cmd('cd "%s"'% self.texcache,
+                            'latex -interaction=nonstopmode %s > "%s"'\
+                            %(os.path.split(texfile)[-1], outfile))
+            mpl.verbose.report(command, 'debug')
+            exit_status = os.system(command)
+            try:
+                fh = file(outfile)
+                report = fh.read()
+                fh.close()
+            except IOError:
+                report = 'No latex error report available.'
+            try:
+                os.stat(dvifile)
+                exists = True
+            except OSError:
+                exists = False
+            if exit_status or not exists:
+                raise RuntimeError(('LaTeX was not able to process the following \
+string:\n%s\nHere is the full report generated by LaTeX: \n\n'% repr(tex)) + report)
+            else: mpl.verbose.report(report, 'debug')
+            for fname in glob.glob(basefile+'*'):
+                if fname.endswith('dvi'): pass
+                elif fname.endswith('tex'): pass
+                else:
+                    try: os.remove(fname)
+                    except OSError: pass
+
+        return dvifile
+
+
+    def make_dvi_preview(self, tex, fontsize):
+        """
+        generates a dvi file containing latex's layout of tex
+        string. It calls make_tex_preview() method and store the size
+        information (width, height, descent) in a separte file.
+
+        returns the file name
+        """
+        basefile = self.get_basefile(tex, fontsize)
+        dvifile = '%s.dvi'% basefile
+        baselinefile = '%s.baseline'% basefile
+
+        if DEBUG or not os.path.exists(dvifile) or \
+               not os.path.exists(baselinefile):
+            texfile = self.make_tex_preview(tex, fontsize)
+            outfile = basefile+'.output'
+            command = self._get_shell_cmd('cd "%s"'% self.texcache,
+                            'latex -interaction=nonstopmode %s > "%s"'\
+                            %(os.path.split(texfile)[-1], outfile))
+            mpl.verbose.report(command, 'debug')
+            exit_status = os.system(command)
+            try:
+                fh = file(outfile)
+                report = fh.read()
+                fh.close()
+
+            except IOError:
+                report = 'No latex error report available.'
+            if exit_status:
+                raise RuntimeError(('LaTeX was not able to process the following \
+string:\n%s\nHere is the full report generated by LaTeX: \n\n'% repr(tex)) + report)
+            else: mpl.verbose.report(report, 'debug')
+
+            # find the box extent information in the latex output
+            # file and store them in ".baseline" file
+            m = TexManager._re_vbox.search(report)
+            open(basefile+'.baseline',"w").write(" ".join(m.groups()))
+
+            for fname in glob.glob(basefile+'*'):
+                if fname.endswith('dvi'): pass
+                elif fname.endswith('tex'): pass
+                elif fname.endswith('baseline'): pass
+                else:
+                    try: os.remove(fname)
+                    except OSError: pass
+
+        return dvifile
+
+    def make_png(self, tex, fontsize, dpi):
+        """
+        generates a png file containing latex's rendering of tex string
+
+        returns the filename
+        """
+        basefile = self.get_basefile(tex, fontsize, dpi)
+        pngfile = '%s.png'% basefile
+
+        # see get_rgba for a discussion of the background
+        if DEBUG or not os.path.exists(pngfile):
+            dvifile = self.make_dvi(tex, fontsize)
+            outfile = basefile+'.output'
+            command = self._get_shell_cmd('cd "%s"' % self.texcache,
+                        'dvipng -bg Transparent -D %s -T tight -o \
+                        "%s" "%s" > "%s"'%(dpi, os.path.split(pngfile)[-1],
+                        os.path.split(dvifile)[-1], outfile))
+            mpl.verbose.report(command, 'debug')
+            exit_status = os.system(command)
+            try:
+                fh = file(outfile)
+                report = fh.read()
+                fh.close()
+            except IOError:
+                report = 'No dvipng error report available.'
+            if exit_status:
+                raise RuntimeError('dvipng was not able to \
+process the following file:\n%s\nHere is the full report generated by dvipng: \
+\n\n'% dvifile + report)
+            else: mpl.verbose.report(report, 'debug')
+            try: os.remove(outfile)
+            except OSError: pass
+
+        return pngfile
+
+    def make_ps(self, tex, fontsize):
+        """
+        generates a postscript file containing latex's rendering of tex string
+
+        returns the file name
+        """
+        basefile = self.get_basefile(tex, fontsize)
+        psfile = '%s.epsf'% basefile
+
+        if DEBUG or not os.path.exists(psfile):
+            dvifile = self.make_dvi(tex, fontsize)
+            outfile = basefile+'.output'
+            command = self._get_shell_cmd('cd "%s"'% self.texcache,
+                        'dvips -q -E -o "%s" "%s" > "%s"'\
+                        %(os.path.split(psfile)[-1],
+                          os.path.split(dvifile)[-1], outfile))
+            mpl.verbose.report(command, 'debug')
+            exit_status = os.system(command)
+            fh = file(outfile)
+            if exit_status:
+                raise RuntimeError('dvipng was not able to \
+process the flowing file:\n%s\nHere is the full report generated by dvipng: \
+\n\n'% dvifile + fh.read())
+            else: mpl.verbose.report(fh.read(), 'debug')
+            fh.close()
+            os.remove(outfile)
+
+        return psfile
+
+    def get_ps_bbox(self, tex, fontsize):
+        """
+        returns a list containing the postscript bounding box for latex's
+        rendering of the tex string
+        """
+        psfile = self.make_ps(tex, fontsize)
+        ps = file(psfile)
+        for line in ps:
+            if line.startswith('%%BoundingBox:'):
+                return [int(val) for val in line.split()[1:]]
+        raise RuntimeError('Could not parse %s'%psfile)
+
+    def get_grey(self, tex, fontsize=None, dpi=None):
+        """returns the alpha channel"""
+        key = tex, self.get_font_config(), fontsize, dpi
+        alpha = self.grey_arrayd.get(key)
+
+        if alpha is None:
+            pngfile = self.make_png(tex, fontsize, dpi)
+            X = read_png(os.path.join(self.texcache, pngfile))
+
+            if rcParams['text.dvipnghack'] is not None:
+                hack = rcParams['text.dvipnghack']
+            else:
+                if TexManager._dvipng_hack_alpha is None:
+                    TexManager._dvipng_hack_alpha = dvipng_hack_alpha()
+                hack = TexManager._dvipng_hack_alpha
+
+
+            if hack:
+                # hack the alpha channel
+                # dvipng assumed a constant background, whereas we want to
+                # overlay these rasters with antialiasing over arbitrary
+                # backgrounds that may have other figure elements under them.
+                # When you set dvipng -bg Transparent, it actually makes the
+                # alpha channel 1 and does the background compositing and
+                # antialiasing itself and puts the blended data in the rgb
+                # channels.  So what we do is extract the alpha information
+                # from the red channel, which is a blend of the default dvipng
+                # background (white) and foreground (black).  So the amount of
+                # red (or green or blue for that matter since white and black
+                # blend to a grayscale) is the alpha intensity.  Once we
+                # extract the correct alpha information, we assign it to the
+                # alpha channel properly and let the users pick their rgb.  In
+                # this way, we can overlay tex strings on arbitrary
+                # backgrounds with antialiasing
+                #
+                # red = alpha*red_foreground + (1-alpha)*red_background
+                #
+                # Since the foreground is black (0) and the background is
+                # white (1) this reduces to red = 1-alpha or alpha = 1-red
+                #alpha = npy.sqrt(1-X[:,:,0]) # should this be sqrt here?
+                alpha = 1-X[:,:,0]
+            else:
+                alpha = X[:,:,-1]
+
+            self.grey_arrayd[key] = alpha
+        return alpha
+
+
+    def get_rgba(self, tex, fontsize=None, dpi=None, rgb=(0,0,0)):
+        """
+        Returns latex's rendering of the tex string as an rgba array
+        """
+        if not fontsize: fontsize = rcParams['font.size']
+        if not dpi: dpi = rcParams['savefig.dpi']
+        r,g,b = rgb
+        key = tex, self.get_font_config(), fontsize, dpi, tuple(rgb)
+        Z = self.rgba_arrayd.get(key)
+
+        if Z is None:
+            alpha = self.get_grey(tex, fontsize, dpi)
+
+            Z = np.zeros((alpha.shape[0], alpha.shape[1], 4), np.float)
+
+            Z[:,:,0] = r
+            Z[:,:,1] = g
+            Z[:,:,2] = b
+            Z[:,:,3] = alpha
+            self.rgba_arrayd[key] = Z
+
+        return Z
+
+
+    def get_text_width_height_descent(self, tex, fontsize, renderer=None):
+        """
+        return width, heigth and descent of the text.
+        """
+        if tex.strip() == '':
+            return 0, 0, 0
+
+        if renderer:
+            dpi_fraction = renderer.points_to_pixels(1.)
+        else:
+            dpi_fraction = 1.
+
+        if rcParams['text.latex.preview']:
+            # use preview.sty
+            basefile = self.get_basefile(tex, fontsize)
+            baselinefile = '%s.baseline'% basefile
+
+
+            if DEBUG or not os.path.exists(baselinefile):
+                dvifile = self.make_dvi_preview(tex, fontsize)
+
+            l = open(baselinefile).read().split()
+            height, depth, width = [float(l1)*dpi_fraction for l1 in l]
+            return width, height+depth, depth
+
+        else:
+            # use dviread. It sometimes returns a wrong descent.
+            dvifile = self.make_dvi(tex, fontsize)
+            dvi = dviread.Dvi(dvifile, 72*dpi_fraction)
+            page = iter(dvi).next()
+            dvi.close()
+            # A total height (including the descent) needs to be returned.
+            return page.width, page.height+page.descent, page.descent

new file patches/texmanager.py.patch

@@ +1 @@
+--- ../src/lib/matplotlib/texmanager.py 2010-07-06 07:43:35.000000000 -0700
++++ texmanager.py       2010-10-23 15:05:17.000000000 -0700
+@@ -33,7 +33,7 @@
+ 
+ """
+ 
+-import copy, glob, os, shutil, sys, warnings
++import copy, glob, os, shutil, sys, warnings, errno
+ from subprocess import Popen, PIPE, STDOUT
+ 
+ try:
+@@ -88,8 +88,13 @@
+ WARNING: found a TeX cache dir in the deprecated location "%s".
+   Moving it to the new default location "%s"."""%(oldcache, texcache)
+         shutil.move(oldcache, texcache)
+-    if not os.path.exists(texcache):
++    try:
+         os.mkdir(texcache)
++    except OSError, e:
++        if e.errno == errno.EEXIST:
++            pass
++        else:
++            raise
+ 
+     _dvipng_hack_alpha = None
+     #_dvipng_hack_alpha = dvipng_hack_alpha()
+@@ -130,8 +135,14 @@
+ 
+     def __init__(self):
+ 
+-        if not os.path.isdir(self.texcache):
++        try:
+             os.mkdir(self.texcache)
++        except OSError, e:
++            if e.errno == errno.EEXIST:
++                pass
++            else:
++                raise
++            
+         ff = rcParams['font.family'].lower()
+         if ff in self.font_families:
+             self.font_family = ff

spkg-install

@@ -19 +19 @@
 $CP patches/setupext.py src
 $CP patches/WrapPython.h src/CXX
 $CP patches/font_manager.py src/lib/matplotlib
+$CP patches/__init__.py src/lib/matplotlib
+$CP patches/finance.py src/lib/matplotlib
+$CP patches/texmanager.py src/lib/matplotlib
 cd src
 
 # Now build 
@@ -33 +36 @@
 
 # Finally install
 python setup.py install
+
+MPLINITFILE="$SAGE_LOCAL/lib/python/site-packages/matplotlib/__init__.py"
+if [ -f "$MPLINITFILE" ]; then
+    MPLVERSION=`sed -n "/^__version__[ ]*=/s/[^']*'\([^']*\)'.*$/\1/p" "$MPLINITFILE"`
+    echo
+    echo "When Sage runs, MPLCONFIGDIR will be set to '\$DOT_SAGE/matplotlib-$MPLVERSION'."
+    echo
+else
+    echo "$MPLINITFILE not found.  What happened?"
+    exit 1
+fi