def test_install_mplstyles(self):
        """Install matplotlib style sheets."""
        config_dir = os.path.join(mpl.get_configdir(), 'stylelib')

        if os.path.isdir(config_dir):
            created_dir = False
        else:
            os.mkdir(config_dir)
            created_dir = True

        typhon_styles = [
            os.path.basename(s)
            for s
            in glob.glob(os.path.join('..', 'stylelib', '*.mplstyle'))
            ]

        before = set(os.listdir(config_dir))

        typhon.plots.install_mplstyles()

        after = set(os.listdir(config_dir))

        for sl in after - before:
            if sl in typhon_styles:
                os.remove(os.path.join(config_dir, sl))

        if created_dir:
            os.rmdir(config_dir)

        assert set(typhon_styles).issubset(set(after))

    def _fetch_historical_yahoo(self, ticker, date1, date2, freq=None, cachename=None):
        """matplotlib's implementation, modified to provide proxy support and frequency
        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
        """
        if freq is None or type(freq) != str:
            raise ValueError('Must enter a frequency as a string, m, w, or d')

        proxy = self._proxy
        ticker = ticker.upper()
        
        configdir = get_configdir()
        cachedir = os.path.join(configdir, 'finance.cache')

        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=%s&ignore=.csv'

        url =  urlFmt % (d1[0], d1[1], d1[2],
                         d2[0], d2[1], d2[2], ticker, freq)

        if proxy:
            proxy_support = urllib2.ProxyHandler(proxy)
            opener = urllib2.build_opener(proxy_support)
            urllib2.install_opener(opener)

        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:
            if not os.path.isdir(cachedir):
                os.mkdir(cachedir)
            urlfh = urllib2.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 _install_matplotlib_styles(self):
     import matplotlib as mpl
     conf_dir = mpl.get_configdir()
     if not os.path.exists(conf_dir):
         os.mkdir(conf_dir)
     style_dir = os.path.join(conf_dir, 'stylelib')
     if not os.path.exists(style_dir):
         os.mkdir(style_dir)
     static_path = os.path.join(self._module_path(), 'static', 'styles')
     for style in os.listdir(static_path):
         target_path = os.path.join(style_dir, style)
         if not os.path.exists(target_path):
             shutil.copyfile(os.path.join(static_path, style), target_path)

def clean_cache(mapdir=None, maxsize=None):
    """Clean cache directory by checking its size

    :Params:

        - **mapdir**, optional: Directory where maps are cached
        - **maxsize**, optional: Maximal size of directory in bytes.
          Default value from :confopt:`[vacumm.misc.grid.basemap]max_cache_size`
          configuration value.
    """
    from ...misc.misc import dirsize
    mapdir = get_map_dir(mapdir)
    if mapdir is None:
        mapdir = os.path.join(get_configdir(), 'basemap', 'cached_maps')
    cache_size = dirsize(mapdir)
    if maxsize is None:
        maxsize = eval(get_config_value('vacumm.misc.grid.basemap', 'max_cache_size'))
    if cache_size>maxsize:
        files = [os.path.join(mapdir, ff) for ff in os.listdir(mapdir)]
        files.sort(cmp=lambda f1, f2: cmp(os.stat(f1)[8], os.stat(f2)[8]))
        for ff in files:
            cache_size -= os.path.getsize(ff)
            os.remove(ff)
            if cache_size<=maxsize: break

import datetime

import numpy as np

from matplotlib import verbose, get_configdir
from matplotlib.dates import date2num
from matplotlib.cbook import iterable, mkdirs
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 will be None if there is no writable directory.
if configdir is not None:
    cachedir = os.path.join(configdir, 'finance.cache')
else:
    # Should only happen in a restricted environment (such as Google App
    # Engine). Deal with this gracefully by not caching finance data.
    cachedir = None


stock_dt = np.dtype([('date', object),
                     ('year', np.int16),
                     ('month', np.int8),
                     ('day', np.int8),
                     ('d', np.float),     # mpl datenum
                     ('open', np.float),

import contextlib
import os
import re
import warnings

import matplotlib as mpl
from matplotlib import rc_params_from_file, rcParamsDefault
from matplotlib.cbook import MatplotlibDeprecationWarning


__all__ = ['use', 'context', 'available', 'library', 'reload_library']


BASE_LIBRARY_PATH = os.path.join(mpl.get_data_path(), 'stylelib')
# Users may want multiple library paths, so store a list of paths.
USER_LIBRARY_PATHS = [os.path.join(mpl.get_configdir(), 'stylelib')]
STYLE_EXTENSION = 'mplstyle'
STYLE_FILE_PATTERN = re.compile(r'([\S]+).%s$' % STYLE_EXTENSION)


# A list of rcParams that should not be applied from styles
STYLE_BLACKLIST = {
    'interactive', 'backend', 'backend.qt4', 'webagg.port', 'webagg.address',
    'webagg.port_retries', 'webagg.open_in_browser', 'backend_fallback',
    'toolbar', 'timezone', 'datapath', 'figure.max_open_warning',
    'savefig.directory', 'tk.window_focus', 'docstring.hardcopy'}


def _remove_blacklisted_style_params(d, warn=True):
    o = {}
    for key, val in d.items():

from numpy import *
import scipy.constants as con
from scipy.ndimage.filters import median_filter

from matplotlib.pyplot import *
import matplotlib.patches as patches
import matplotlib.image as mpimg

import profile

from matplotlib import rc

import dm3lib_v099 as dm3

print matplotlib.get_configdir()


print args, fullpath
# with file('log.txt', 'w') as outfile:
#    outfile.write('# Args\n')
#    outfile.write(str(args))


rc("savefig", dpi=600)
rc("xtick", direction="out")
rc("ytick", direction="out")
rc("lines", markeredgewidth=1)

print "Welcome to Diffraction Ring Profiler. This program will measure electron diffraction rings"
print " and extract intensity profiles from the diffraction pattern."

from numpy.random import *
from matplotlib import pyplot as plt
import matplotlib as mpl
import matplotlib.font_manager as fm

print(mpl.get_configdir())
print(fm.findSystemFonts())

# 乱数生成
rand_nums = randn(100)

# 追加部分 フォントを指定する。
plt.rcParams["font.family"] = "IPAexGothic"

# ヒストグラム表示
plt.hist(rand_nums)
plt.xlabel("X軸と表示したい")
plt.ylabel("Y軸と表示したい")
plt.show()

# https://www.datacamp.com/community/tutorials/machine-learning-python
import numpy as np
from sklearn import datasets
digits = datasets.load_digits()
#print(digits)
import matplotlib
from sklearn.decomposition import RandomizedPCA
from sklearn.decomposition import PCA

print "config dir=", matplotlib.get_configdir()
matplotlib.use('TkAgg')
# the same dataset as above but from another location
#import pandas as pd
#digits = pd.read_csv("http://archive.ics.uci.edu/ml/machine-learning-databases/optdigits/optdigits.tra", header=None)
print " ---- KEYS ------"
print digits.keys()

print " ----  DATA  ----"
print digits.data

print "  == DESCR ==="
#print digits.DESCR

# Isolate the `digits` data
digits_data = digits.data

print "there are 1797 samples and that there are 64 features "
# Inspect the shape
print(digits_data.shape)

# Isolate the target values with `target`

import jupyter_core.paths
import matplotlib as mpl


# Root directory of repository (where this file is located)
root_dir = os.path.realpath(os.path.dirname(__file__))

# Get IPython configuration directory
ipython_dir = IPython.paths.get_ipython_dir()

# Destination directories for each source directory
# (except IPython, which depends on the profile to be used...)
dest_dirs = {
	'.ipython': ipython_dir,
	'.jupyter': jupyter_core.paths.jupyter_config_dir(),
	'.matplotlib': mpl.get_configdir(),
}


# Proper function to get raw input from user in Python 2 or 3
if sys.version_info.major == 2:
	get_input = raw_input
else:
	get_input = input


# Symbolic link function for unix vs windows
try:
	symlink = os.symlink

except AttributeError:

import os
import shutil
import matplotlib as mpl

stylelib = os.path.join(mpl.get_configdir(), 'stylelib')

# in case you don't have a stylelib directory yet
try:
    os.mkdir(stylelib)

except FileExistsError:
    pass

# copy the files into the stylelib directory
[shutil.copy(f, stylelib) for f in os.listdir('.') if f.endswith('.mplstyle')]

from __future__ import division

import numpy as np
import pandas as pd
import matplotlib
matplotlib.get_configdir()
matplotlib.use('Agg') # Must be before importing matplotlib.pyplot or pylab!
import matplotlib.pyplot as plt

from pylab import *
from matplotlib import rcParams
from scipy import integrate

# Getting SVN number 
GIT=

# Help to find the fonts properly!
# You can find the list of fonts installed on the system with:
#fonts = "\n".join(matplotlib.font_manager.findSystemFonts(fontpaths=None, fontext="ttf"))
#print fonts
# If Times New Roman is listed in the system, check if it is listed in python:
#print [f.name for f in matplotlib.font_manager.fontManager.ttflist]
# Maybe the python package have its own fonts folder, find it and add the file times.ttf
# Then, you need to remove the fontmanager cache so the code will read the new file
# Find the cache location with:
#print matplotlib.get_cachedir()

# Defining fonts to be used in plots
rcParams.update({'figure.autolayout': True})
rcParams.update({'font.family':'Times New Roman'})
rcParams.update({'font.size':20})

# -*- coding:utf8 -*-
import matplotlib as mpl

print mpl.rcParams
print len(mpl.rcParams)
mpl.rc('lines', linewidth=2, color='r')
print mpl.get_configdir()

def get_map_dir(mapdir=None):
    """Get the directory where cqched maps are stored"""
    if mapdir is None:
        mapdir = os.path.join(get_configdir(), 'basemap', 'cached_maps')
    return mapdir

import os
import sys
from os.path import join, exists, expanduser
import matplotlib as mpl
mplrc_dir   = mpl.get_configdir()

if sys.platform.startswith('linux'):
    mplrc_dir = expanduser('~/.config/matplotlib')

# To conform with the XDG base directory standard,
# this configuration location has been deprecated on Linux,
# and the new location is now '/home/joncrall/.config'/matplotlib/.
# Please move your configuration there to ensure that matplotlib will
# continue to find it in the future.
mplrc_fpath = join(mplrc_dir, 'matplotlibrc')

mplrc_text = '''
backend      : qt4agg

'''

if not exists(mplrc_dir):
    os.makedirs(mplrc_dir)

with open(mplrc_fpath, 'w') as file_:
    file_.write(mplrc_text)

print('wrote %r' % mplrc_fpath)

if __name__=='__main__':
    referenceLabel='Delivered'#from which label,lumi unit should be calculated
    labels=['Delivered','Recorded']#default label order
    allowedActions = ['run','time','fill','perday','instpeakperday']
    beamChoices=['PROTPHYS','IONPHYS','PAPHYS']
    allowedscales=['linear','log','both']
    beamModeChoices = [ "stable", "quiet", "either"]
    amodetagChoices = [ "PROTPHYS","IONPHYS",'PAPHYS' ]
    actiontofilebasemap={'time':'lumivstime','run':'lumivsrun','fill':'lumivsfill','perday':'lumiperday','instpeakperday':'lumipeak'}
    #
    # parse figure configuration if found
    #  
    currentdir=os.getcwd()
    rcparamfile='.lumiplotrc'
    mplrcdir=matplotlib.get_configdir()
    mpllumiconfig=os.path.join(mplrcdir,rcparamfile)
    locallumiconfig=os.path.join(currentdir,rcparamfile)
    figureparams={'sizex':7.5,'sizey':5.7,'dpi':135}
    if os.path.exists(locallumiconfig):
        import ConfigParser
        try:
            config=ConfigParser.RawConfigParser()
            config.read(locallumiconfig)
            figureparams['sizex']=config.getfloat('sizex')
            figureparams['sizey']=config.getfloat('sizey')
            figureparams['dpi']=config.getint('dpi')
        except ConfigParser.NoOptionError:
            pass
    elif os.path.exists(mpllumiconfig):
        import ConfigParser

"""
Created on Jun 12, 2015
precisa colocar o argumento py2exe
@author: Paloschi
"""
import matplotlib

matplotlib.use("Agg")  # overrule configuration

print(matplotlib.get_configdir())

from distutils.core import setup
import py2exe

Mydata_files = [("images", ["images/icons/icon_trator.png"])]

setup(
    windows=["CyMP.py"],
    data_files=(matplotlib.get_py2exe_datafiles()),
    options={
        "py2exe": {
            # "dll_excludes" : [],
            "dll_excludes": [
                "MSVCP90.dll",
                "HID.DLL",
                "api-ms-win-core-processthreads-l1-1-2.dll",
                "api-ms-win-core-delayload-l1-1-1.dll",
                "api-ms-win-core-errorhandling-l1-1-1.dll",
                "api-ms-win-core-sysinfo-l1-2-1.dll",
                "api-ms-win-core-heap-l2-1-0.dll",
                "api-ms-win-core-profile-l1-1-0.dll",