コード例 #1
0
 def _delcache():
     p1 = matplotlib.get_configdir() + "/fontList.py3k.cache"
     p2 = matplotlib.get_cachedir() + "/fontList.py3k.cache"
     p3 = matplotlib.get_configdir() + "/fontList.json"
     p4 = matplotlib.get_cachedir() + "/fontList.json"
     for p in [p1, p2, p3, p4]:
         if os.path.isfile(p):
             os.remove(p)
             print("deleted matplotlib font cache:", p)
         else:
             print("path not found:", p)
コード例 #2
0
ファイル: w2vft_util.py プロジェクト: jjeaby/w2v-visual
def plt_show(model, img_name="plt.png"):
    ## Visualize Word Embedding
    from sklearn.decomposition import PCA
    import matplotlib.pyplot as plt
    import matplotlib as mpl
    import matplotlib.font_manager as fm
    print('버전: ', mpl.__version__)
    print('설치 위치: ', mpl.__file__)
    print('설정 위치: ', mpl.get_configdir())
    print('캐시 위치: ', mpl.get_cachedir())
    font_list = fm.findSystemFonts(fontpaths=None, fontext='ttf')
    [
        print((f.name, f.fname)) for f in fm.fontManager.ttflist
        if 'Nanum' in f.name
    ]
    path = '/Users/actmember/Library/Fonts/NanumBarunGothic.otf'
    fontprop = fm.FontProperties(fname=path, size=8)
    mpl.rcParams['axes.unicode_minus'] = False
    X = model[model.wv.vocab]
    pca = PCA(n_components=2)
    result = pca.fit_transform(X)
    # create a scatter plot of the projection
    plt.scatter(result[:, 0], result[:, 1])
    words = list(model.wv.vocab)
    for i, word in enumerate(words):
        plt.annotate(word,
                     xy=(result[i, 0], result[i, 1]),
                     fontproperties=fontprop)
    plt.savefig(img_name, quality=100, dpi=500)
    plt.show()
コード例 #3
0
def install_mpl_style() -> None:
    """
    Will create a `phd.mplstyle` file in the appropriate directories from the `PLOT_PARAMS` defined in this
    module. This enables one to use the style without importing `PLOT_PARAMS` and updating the rcParams,
    but instead simply using `plt.style.use("phd")`.
    Sometimes, matplotlib will not look for the file in its global config directory, but in the activated
    environment's site-packages data. The file is installed in both places.
    """
    logger.info("Installing matplotlib style")
    style_content: str = "\n".join(f"{option} : {setting}"
                                   for option, setting in PLOT_PARAMS.items())
    mpl_config_stylelib = Path(matplotlib.get_configdir()) / "stylelib"
    mpl_env_stylelib = Path(plt.style.core.BASE_LIBRARY_PATH)

    logger.debug("Ensuring matplotlib 'stylelib' directory exists")
    mpl_config_stylelib.mkdir(parents=True, exist_ok=True)
    mpl_env_stylelib.mkdir(parents=True, exist_ok=True)
    config_style_file = mpl_config_stylelib / "phd.mplstyle"
    env_style_file = mpl_env_stylelib / "phd.mplstyle"

    logger.debug(f"Creating style file at '{config_style_file.absolute()}'")
    config_style_file.write_text(
        style_content.replace("(", "").replace(")", ""))
    logger.debug(f"Creating style file at '{env_style_file.absolute()}'")
    env_style_file.write_text(style_content.replace("(", "").replace(")", ""))
    logger.success("You can now use it with 'plt.style.use(\"phd\")'")
コード例 #4
0
ファイル: style.py プロジェクト: morganjwilliams/pyrolite
def _export_mplstyle(src=pyrolite_datafolder("_config") / "pyrolite.mplstyle",
                     refresh=False):
    """
    Export a matplotlib style file to the matplotlib style library such that one can
    use e.g. `matplotlib.style.use("pyrolite")`.

    Parameters
    -----------
    src : :class:`str` | :class:`pathlib.Path`
        File path for the style file to be exported.
    refresh : :class:`bool`
        Whether to re-export a style file (e.g. after updating) even if it
        already exists in the matplotlib style libary.
    """
    src_fn = Path(src)
    dest_dir = Path(matplotlib.get_configdir()) / "stylelib"
    dest_fn = dest_dir / src.name
    if (not dest_fn.exists()) or refresh:
        logger.debug(
            "Exporting pyrolite.mplstyle to matplotlib config folder.")
        if not dest_dir.exists():
            dest_dir.mkdir(parents=True)
        copy_file(src_fn, dest_dir)  # copy to the destination DIR
        logger.debug("Reloading matplotlib")
    matplotlib.style.reload_library()  # needed to load in pyrolite style NOW
コード例 #5
0
ファイル: cbook.py プロジェクト: jtomase/matplotlib
def get_sample_data(fname, asfileobj=True):
    """
    Check the cachedirectory ~/.matplotlib/sample_data for a sample_data
    file.  If it does not exist, fetch it with urllib from the mpl svn repo

      http://matplotlib.svn.sourceforge.net/svnroot/matplotlib/trunk/sample_data/

    and store it in the cachedir.

    If asfileobj is True, a file object will be returned.  Else the
    path to the file as a string will be returned

    To add a datafile to this directory, you need to check out
    sample_data from matplotlib svn::

      svn co https://matplotlib.svn.sourceforge.net/svnroot/matplotlib/trunk/sample_data

    and svn add the data file you want to support.  This is primarily
    intended for use in mpl examples that need custom data
    """

    myserver = get_sample_data.myserver
    if myserver is None:
        configdir = matplotlib.get_configdir()
        cachedir = os.path.join(configdir, 'sample_data')
        baseurl = 'http://matplotlib.svn.sourceforge.net/svnroot/matplotlib/trunk/sample_data/'
        myserver = get_sample_data.myserver = ViewVCCachedServer(cachedir, baseurl)

    return myserver.get_sample_data(fname, asfileobj=asfileobj)
コード例 #6
0
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)
            try:
                os.remove(ff)
            except:
                vacumm_warn('Error while trying to clean basemap cache in: '+
                    os.path.dirname(ff))
                return
            if cache_size<=maxsize: break
コード例 #7
0
ファイル: __init__.py プロジェクト: anntzer/mplcustomrc
def _main():
    class MplBackendPathFinder(PathFinder):
        def find_spec(self, fullname, path, target=None):
            if path == __path__ and fullname.startswith(f"{__name__}."):
                _, rest = fullname.split(".", 1)
                for candidate in [f"matplotlib.backends.backend_{rest}", rest]:
                    spec = importlib.util.find_spec(candidate)
                    if spec is not None:

                        def exec_module(module):
                            sys.modules[f"{__name__}.{spec.name}"] = module
                            return type(spec.loader).exec_module(
                                spec.loader, module)

                        spec.loader.exec_module = exec_module
                        return spec
            return super().find_spec(fullname, path, target)

    sys.meta_path.append(MplBackendPathFinder())

    mplrcpy_path = Path(mpl.get_configdir(), "matplotlibrc.py")
    try:
        with tokenize.open(mplrcpy_path) as file:
            mplrcpy = file.read()
    except IOError:
        _log.warning(f"Failed to read {mplrcpy_path}; falling back to "
                     f"automatic backend selection.")
    else:
        exec(mplrcpy, {})
コード例 #8
0
ファイル: test_mplstyles.py プロジェクト: olemke/typhon
    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))
コード例 #9
0
ファイル: inspricehist.py プロジェクト: divieira/covshrink
    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
コード例 #10
0
def copy_styles():
    """Copy rayoptics mpl styles to user's mpl_config dir."""
    pth = Path(__file__).resolve().parent
    styles_dir = Path(pth / 'styles')
    mpl_configdir = Path(matplotlib.get_configdir()) / 'stylelib'
    mpl_configdir.mkdir(exist_ok=True)
    for mpl_style in styles_dir.glob('*.mplstyle'):
        copy2(mpl_style, mpl_configdir)
コード例 #11
0
ファイル: MainFile.py プロジェクト: tutor2019/Project1
def get_matplotlib_info():
    print('버전: ', mpl.__version__)
    print('설치 위치: ', mpl.__file__)
    print('설정 위치: ', mpl.get_configdir())
    print('캐시 위치: ', mpl.get_cachedir())
    print('설정 파일 위치: ', mpl.matplotlib_fname())
    font_list = fm.findSystemFonts(fontpaths=None, fontext='ttf')
    print(len(font_list))
コード例 #12
0
def copy_styles():
    sd = os.path.join(get_configdir(), "stylelib")
    source = os.path.dirname(os.path.realpath(__file__))
    lsd = os.path.join(source, 'arviz', 'plots', 'styles')
    styles = [f for f in os.listdir(lsd)]
    if not os.path.isdir(sd):
        os.makedirs(sd)
    for s in styles:
        shutil.copy(os.path.join(lsd, s), os.path.join(sd, s))
コード例 #13
0
def install_style():
    style = 'tp.mplstyle'

    styledir = os.path.join(mpl.get_configdir(), 'stylelib')
    if not os.path.exists(styledir):
        os.makedirs(styledir)

    shutil.copy(os.path.join(os.path.dirname(__file__), style),
                os.path.join(styledir, style))
コード例 #14
0
ファイル: __init__.py プロジェクト: bhuvy2/bhuvy-pydata
def register_style():
    '''
    Write all goose-styles to the relevant matplotlib configuration directory.
    '''

    import os
    import matplotlib

    styles = dict()

    styles['bhuvy.mplstyle'] = '''

# Main Grids  
figure.facecolor: F0F8FF

patch.antialiased: True

# Lines
lines.linewidth: 2.0
lines.solid_capstyle: butt

# Axes
axes.titlesize: 16
axes.labelsize: 12
axes.labelcolor: 000000
axes.facecolor: B2CEE6
axes.edgecolor: 000000
axes.axisbelow: True
axes.prop_cycle: cycler('color', ['268BD2', '2AA198', '859900', 'B58900', 'CB4B16', 'DC322F', 'D33682', '6C71C4'])
axes.spines.top: False
axes.spines.right: False

axes.grid: True
grid.color: FFFFFF

grid.linestyle: -
grid.linewidth: 1

xtick.color: 000000
xtick.direction: out

ytick.color: 000000
ytick.direction: out

# Font

font.family: sans-serif
font.sans-serif: {}
'''.format(find_custom_fonts())

    dirname = os.path.abspath(
        os.path.join(matplotlib.get_configdir(), 'stylelib'))

    if not os.path.isdir(dirname): os.makedirs(dirname)

    for fname, style in styles.items():
        open(os.path.join(dirname, fname), 'w').write(style)
コード例 #15
0
ファイル: setup.py プロジェクト: zhenming-xu/ThermoPlotter
def install_style():
    style = ['tp.mplstyle', 'tp-large.mplstyle']
    styledir = os.path.join(get_configdir(), 'stylelib')
    if not os.path.exists(styledir):
        os.makedirs(styledir)

    for plotting in style:
        copy(os.path.join(os.path.dirname(__file__), plotting),
             os.path.join(styledir, plotting))
コード例 #16
0
ファイル: setup.py プロジェクト: bdtmnk/CMSStylempl
    def run(self):

        import os
        import matplotlib as mpl
        os.system('cp -r mplhep/stylelib/ ' +
                  os.path.join(mpl.get_configdir() + '/'))
        os.system('cp -r mplhep/fonts/ ' +
                  os.path.join(mpl.rcParams['datapath'] + '/'))

        install.run(self)
コード例 #17
0
def plot_tex(tex=False):
    mpl.style.reload_library()
    plt.style.use('zxx')
    print('find zxx: ', os.path.isfile('zxx.mplstyle'))
    if (os.path.isfile('zxx.mplstyle')):
        plt.style.use('zxx.mplstyle')
    if (tex):
        plt.style.use('tex')
    print(plt.style.available)
    print(mpl.get_configdir())
コード例 #18
0
def Abfragen_Matplotlib():
    mpl_version = mpl.__version__
    mpl_ort = mpl.__file__
    mpl_config = mpl.get_configdir()
    mpl_cache = mpl.get_cachedir()

    print("Version von Matplotlib:", mpl_version)
    print("Installationsort von Matplotlib:", mpl_ort)
    print("Die Konfigurationsinformationen befinden sich bei:", mpl_config)
    print("Der Zwischenspeicher / Cache befindet sich bei:", mpl_cache)
コード例 #19
0
def main():
    fname = "robertsons_rules.mplstyle"

    config_dir = mpl.get_configdir()
    style_dir = os.path.join(config_dir, "stylelib")
    if not "stylelib" in os.listdir(config_dir):
        os.mkdir(style_dir)

    dest = os.path.join(style_dir, fname)
    shutil.copyfile(fname, dest)
    print(f"Copied {fname} to {style_dir}")
コード例 #20
0
ファイル: ndplot.py プロジェクト: fernandezc/spectrochempy
    def makestyle(self, filename='mydefault', to_mpl=False):

        if filename.startswith('scpy'):
            error_('`scpy` is READ-ONLY. Please use an another style name.')
            return

        txt = ""
        sline = ""

        for key in mpl.rcParams.keys():
            if key in ['animation.avconv_args', 'animation.avconv_path', 'animation.html_args', 'keymap.all_axes',
                       'mathtext.fallback_to_cm', 'validate_bool_maybe_none', 'savefig.jpeg_quality',
                       'text.latex.preview', 'backend', 'backend_fallback', 'date.epoch', 'docstring.hardcopy',
                       'figure.max_open_warning', 'figure.raise_window', 'interactive', 'savefig.directory', 'timezone',
                       'tk.window_focus', 'toolbar', 'webagg.address', 'webagg.open_in_browser', 'webagg.port',
                       'webagg.port_retries']:
                continue
            val = str(mpl.rcParams[key])
            sav = ''
            while val != sav:
                sav = val
                val = val.replace('  ', ' ')
            line = f'{key:40s} : {val}\n'
            if line[0] != sline:
                txt += '\n'
                sline = line[0]
            if key not in ['axes.prop_cycle']:
                line = line.replace('[', '').replace(']', "").replace('\'', '').replace('"', '')
            if key == 'savefig.bbox':
                line = f'{key:40s} : standard\n'
            txt += line.replace("#", '')

        # Non matplotlib parameters,
        # some parameters are not saved in matplotlib style sheets so we willa dd them here
        nonmplpars = ['method_1D', 'method_2D', 'method_3D', 'colorbar', 'show_projections', 'show_projection_x',
                      'show_projection_y', 'colormap', 'max_lines_in_stack', 'simplify', 'number_of_x_labels',
                      'number_of_y_labels', 'number_of_z_labels', 'number_of_contours', 'contour_alpha',
                      'contour_start', 'antialiased', 'rcount', 'ccount']
        txt += '\n\n##\n## ADDITIONAL PARAMETERS FOR SPECTROCHEMPY\n##\n'
        for par in nonmplpars:
            txt += f"##@{par:37s} : {getattr(self, par)}\n"

        stylesheet = (pathclean(self.stylesheets) / filename).with_suffix('.mplstyle')
        stylesheet.write_text(txt)

        if to_mpl:
            # make it also accessible to pyplot
            stylelib = (pathclean(mpl.get_configdir()) / 'stylelib' / filename).with_suffix('.mplstyle')
            stylelib.write_text(txt)

        # plot_preferences.traits()['style'].trait_types = plot_preferences.traits()['style'].trait_types +\
        #                                                       (Unicode(filename),)
        self.style = filename
        return self.style
コード例 #21
0
def creating_new_style():
    import matplotlib
    import os
    from shutil import copy2
    style_path = matplotlib.get_configdir()
    style_path = os.path.join(style_path, 'stylelib')

    if not os.path.exists(style_path):
        os.makedirs(style_path)

    copy2('presentation.mplstyle', style_path)
コード例 #22
0
def install_styles():
    style_files = glob.glob('styles/*.mplstyle', recursive=True)

    # find stylelib directory, where the *.mplstyle file goes
    mpl_stylelib_dir = os.path.join(matplotlib.get_configdir(), "stylelib")
    if not os.path.exists(mpl_stylelib_dir):
        os.makedirs(mpl_stylelib_dir)

    # copy files over
    for style_file in style_files:
        shutil.copy(style_file, mpl_stylelib_dir)
コード例 #23
0
ファイル: tool.py プロジェクト: LucksLab/spats
 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)
コード例 #24
0
ファイル: utils.py プロジェクト: matoken78/python
def adapt_japanese_font(plt):
    dest_font_path = Path(
        mpl.matplotlib_fname()).parent / 'fonts' / 'ttf' / 'ipaexg.ttf'
    source_font_path = Path(__file__).parent / 'font' / 'ipaexg.ttf'
    shutil.copy(str(source_font_path), str(dest_font_path))

    config_dir = Path(mpl.get_configdir())
    for f in config_dir.glob('**/*'):
        if f.is_file():
            f.unlink()
        else:
            f.rmdir()
    plt.rcParams['font.family'] = 'IPAexGothic'
コード例 #25
0
ファイル: setup.py プロジェクト: mcekwonu/ExtensysPlots
def install_styles():
    style_files = glob.glob('styles/**/*.mplstyle', recursive=True)

    # find stylelib directory, where the *.mplstyle file goes
    mpl_stylelib_dir = os.path.join(matplotlib.get_configdir(), "stylelib")
    if not os.path.exists(mpl_stylelib_dir):
        os.makedirs(mpl_stylelib_dir)

    # copy files over
    print(f"Installing styles into {mpl_stylelib_dir}")
    for style_file in style_files:
        shutil.copy(style_file,
                    os.path.join(mpl_stylelib_dir, os.path.basename(style_file)))
コード例 #26
0
ファイル: setup.py プロジェクト: xhuang-1121/SciencePlots
def install_styles():
    # Find all style files
    stylefiles = glob.glob('styles/**/*.mplstyle', recursive=True)
    # Find stylelib directory (where the *.mplstyle files go)
    mpl_stylelib_dir = os.path.join(matplotlib.get_configdir(), "stylelib")
    if not os.path.exists(mpl_stylelib_dir):
        os.makedirs(mpl_stylelib_dir)
    # Copy files over
    print("Installing styles into", mpl_stylelib_dir)
    for stylefile in stylefiles:
        print(os.path.basename(stylefile))
        shutil.copy(
            stylefile,
            os.path.join(mpl_stylelib_dir, os.path.basename(stylefile)))
コード例 #27
0
def main():
    """Put a copy of the matplotlib style spec in the expected location."""

    this_dir = os.path.dirname(os.path.realpath(__file__))
    style_path = os.path.join(this_dir, 'civis.mplstyle')
    with open(style_path) as f:
        style_doc = f.read()

    mpl_style_dir = os.path.join(mpl.get_configdir(), 'stylelib')
    if not os.path.exists(mpl_style_dir):
        os.makedirs(mpl_style_dir)
    path = os.path.join(mpl_style_dir, 'civis.mplstyle')
    with open(path, 'w') as new_style:
        new_style.write(style_doc)
    print("The Civis matplotlib style was installed at %s" % path)
コード例 #28
0
def copy_style():

    import os
    import matplotlib

    from pkg_resources import resource_string

    files = [
        'styles/notebook_mplstyle',
    ]

    for fname in files:
        path = os.path.join(matplotlib.get_configdir(), fname)
        text = resource_string(__name__, fname).decode()
        open(path, 'w').write(text)
コード例 #29
0
def copy_style():

    import os
    import matplotlib

    from pkg_resources import resource_string

    files = [
        "college_track.mplstyle",
    ]

    for fname in files:
        path = os.path.join(matplotlib.get_configdir(), fname)
        text = resource_string(__name__, fname).decode()
        open(path, "w").write(text)
コード例 #30
0
def install_stylesheet():
    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

    try:
        filepath = resource_filename('gpviz', 'styles/gpviz.mplstyle')
    except ModuleNotFoundError:
        filepath = resource_filename(__name__, 'styles/gpviz.mplstyle')

    shutil.copy(filepath, stylelib)
コード例 #31
0
ファイル: plot_utils.py プロジェクト: xcidar/sample-factory
def copy_plot_themes():
    stylelib_path = os.path.join(matplotlib.get_configdir(), 'stylelib')
    curr_dir = os.path.dirname(os.path.abspath(__file__))
    file_list = glob.glob(os.path.join(curr_dir, '*.mplstyle'))

    try:
        if not os.path.exists(stylelib_path):
            os.makedirs(stylelib_path)
        for f in file_list:
            fname = os.path.basename(f)
            shutil.copy2(f, os.path.join(stylelib_path, fname))
        print('Themes copied to %s' % stylelib_path)
    except:
        print(
            'An error occured! Try to manually copy the *.mplstyle files. E.g.:\nmkdir -p %s && cp *.mplstyle %s'
            % (stylelib_path, stylelib_path), )
コード例 #32
0
def copy_style():

    import os
    import matplotlib

    from pkg_resources import resource_string

    files = [
        'stylelib/goose-latex.mplstyle',
        'stylelib/goose-tick-in.mplstyle',
        'stylelib/goose-tick-lower.mplstyle',
        'stylelib/goose.mplstyle',
    ]

    for fname in files:
        path = os.path.join(matplotlib.get_configdir(), fname)
        text = resource_string(__name__, fname).decode()
        open(path, 'w').write(text)
コード例 #33
0
ファイル: styles.py プロジェクト: cdeimert/qncmbe
def write_style_file(name):

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

    os.makedirs(local_stylelib_dir, exist_ok=True)

    local_file = os.path.join(local_stylelib_dir, f'{name}.mplstyle')

    package_file = os.path.join(get_qncmbe_stylelib_dir(), f'{name}.mplstyle')

    with open(local_file, 'w') as lf:
        lf.write(get_header() + '\n')

        with open(package_file, 'r') as pf:
            lf.write(pf.read())

    logger.info(f'Wrote to style file "{local_file}"')
    plt.style.reload_library()
コード例 #34
0
def get_sample_data(fname, asfileobj=True):
    """
    Check the cachedirectory ~/.matplotlib/sample_data for a sample_data
    file.  If it does not exist, fetch it with urllib from the mpl svn repo
      http://matplotlib.svn.sourceforge.net/svnroot/matplotlib/trunk/sample_data/
    and store it in the cachedir.
    If asfileobj is True, a file object will be returned.  Else the
    path to the file as a string will be returned
    To add a datafile to this directory, you need to check out
    sample_data from matplotlib svn::
      svn co https://matplotlib.svn.sourceforge.net/svnroot/matplotlib/trunk/sample_data
    and svn add the data file you want to support.  This is primarily
    intended for use in mpl examples that need custom data
    """
    myserver = get_sample_data.myserver
    if myserver is None:
        configdir = matplotlib.get_configdir()
        cachedir = os.path.join(configdir, 'sample_data')
        baseurl = 'http://matplotlib.svn.sourceforge.net/svnroot/matplotlib/trunk/sample_data/'
        get_sample_data.myserver = ViewVCCachedServer(cachedir, baseurl)
        myserver = get_sample_data.myserver
    return myserver.get_sample_data(fname, asfileobj=asfileobj)
コード例 #35
0
ファイル: basemap.py プロジェクト: VACUMM/vacumm
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
コード例 #36
0
    def findfont(self, prop, fontext='ttf'):

        """Search the font dictionary for a font that exactly or closely
matches the specified font properties.  See the FontProperties class
for a description.

The properties are searched in the following order: name, style,
variant, weight, stretch, and size.  The font weight always matches
returning the closest weight, and the font size always matches for
scalable fonts.  An oblique style font will be used inplace of a
missing italic style font if present.  See the W3C Cascading Style
Sheet, Level 1 (CSS1; http://www.w3.org/TR/1998/REC-CSS2-19980512/)
documentation for a description of the font finding algorithm.
"""
        cache_message = \
"""Saving AFM font cache for PS backend to %s.
Delete this file to have matplotlib rebuild the cache."""

        debug = False
        if prop.fname is not None:
            fname = prop.fname
            verbose.report('findfont returning %s'%fname, 'debug')
            return fname

        if fontext == 'afm':
            if len(self.afmdict) == 0:
                afmcache = os.path.join(get_configdir(), '.afmfont.cache')
                try:
                    import cPickle as pickle
                except ImportError:
                    import pickle
                try:
                    self.afmdict = pickle.load(file(afmcache))
                except:
                    self.afmdict = createFontDict(self.afmfiles, fontext='afm')
                    pickle.dump(self.afmdict, file(afmcache, 'w'))
                    verbose.report(cache_message % afmcache)
            fontdict = self.afmdict
        else:
            fontdict = self.ttfdict

        name    = prop.get_family()[0]
        style   = prop.get_style()
        variant = prop.get_variant()
        weight  = weight_as_number(prop.get_weight())
        stretch = prop.get_stretch()
        size    = str(prop.get_size_in_points())


        try:
            fname = fontdict[name][style][variant][weight][stretch][size]
            verbose.report('\tfindfont cached %(name)s, %(style)s, %(variant)s, %(weight)s, %(stretch)s, %(size)s'%locals(), 'debug')
            verbose.report('findfont returning %s'%fname, 'debug')
            return fname
        except KeyError:
            pass

        for name in prop.get_family():
            font = fontdict
            if font.has_key(name):
                font = font[name]
            else:
                verbose.report('\tfindfont failed %(name)s'%locals(), 'debug')
                continue

            if font.has_key(style):
                font = font[style]
            elif style == 'italics' and font.has_key('oblique'):
                font = font['oblique']
            else:
                verbose.report('\tfindfont failed %(name)s, %(style)s'%locals(), 'debug')
                continue

            if font.has_key(variant):
                font = font[variant]
            else:
                verbose.report('\tfindfont failed %(name)s, %(style)s, %(variant)s'%locals(), 'debug')
                continue

            if not font.has_key(weight):
                setWeights(font)
            font = font[weight]

            # !!!!  need improvement
            if font.has_key(stretch):
                font = font[stretch]
            else:
                verbose.report('\tfindfont failed %(name)s, %(style)s, %(variant)s %(weight)s, %(stretch)s'%locals(), 'debug')
                continue

            if font.has_key('scalable'):
                fname = font['scalable']
            elif font.has_key(size):
                fname = font[size]
            else:
                verbose.report('\tfindfont failed %(name)s, %(style)s, %(variant)s %(weight)s, %(stretch)s, %(size)s'%locals(), 'debug')
                continue

            fontkey = FontKey(name, style, variant, weight, stretch, size)
            add_filename(fontdict, fontkey, fname)
            verbose.report('\tfindfont found %(name)s, %(style)s, %(variant)s %(weight)s, %(stretch)s, %(size)s'%locals(), 'debug')
            verbose.report('findfont returning %s'%fname, 'debug')

            return fname

        fontkey = FontKey(name, style, variant, weight, stretch, size)
        add_filename(fontdict, fontkey, self.defaultFont)
        warnings.warn('Could not match %s, %s, %s.  Returning %s' % (name, style, variant, self.defaultFont))

        return self.defaultFont
コード例 #37
0
    def __init__(self, size=12.0, weight='normal'):

        self.__default_size = size
        self.__default_weight = weight

        paths = [rcParams['datapath']]

        #  Create list of font paths

        for pathname in ['TTFPATH', 'AFMPATH']:
            if os.environ.has_key(pathname):
                ttfpath = os.environ[pathname]
                if ttfpath.find(';') >= 0: #win32 style
                    paths.extend(ttfpath.split(';'))
                elif ttfpath.find(':') >= 0: # unix style
                    paths.extend(ttfpath.split(':'))
                else:
                    paths.append(ttfpath)

        verbose.report('font search path %s'%(str(paths)))
        #  Load TrueType fonts and create font dictionary.

        self.ttffiles = findSystemFonts(paths) + findSystemFonts()

        for fname in self.ttffiles:
            verbose.report('trying fontname %s' % fname, 'debug')
            if fname.lower().find('vera.ttf')>=0:
                self.defaultFont = fname
                break
        else:
            # use anything
            self.defaultFont = self.ttffiles[0]

        cache_message = \
"""Saving TTF font cache for non-PS backends to %s.
Delete this file to have matplotlib rebuild the cache."""



        oldcache = os.path.join(get_home(), 'ttffont.cache')
        ttfcache = os.path.join(get_configdir(), 'ttffont.cache')
        if os.path.exists(oldcache):
            print >> sys.stderr, 'Moving old ttfcache location "%s" to new location "%s"'%(oldcache, ttfcache)
            shutil.move(oldcache, ttfcache)



        try:
            import cPickle as pickle
        except ImportError:
            import pickle


        def rebuild():
            self.ttfdict = createFontDict(self.ttffiles)
            pickle.dump(self.ttfdict, file(ttfcache, 'w'))
            verbose.report(cache_message % ttfcache)

        try:
            self.ttfdict = pickle.load(file(ttfcache))
        except:
            rebuild()
        else:
            # verify all the cached fnames still exist; if not rebuild
            for fname in ttfdict_to_fnames(self.ttfdict):
                if not os.path.exists(fname):
                    rebuild()
                    break
            verbose.report('loaded ttfcache file %s'%ttfcache)



        #self.ttfdict = createFontDict(self.ttffiles)

        #  Load AFM fonts for PostScript
        #  Only load file names at this stage, the font dictionary will be
        #  created when needed.

        self.afmfiles = findSystemFonts(paths, fontext='afm') + \
                        findSystemFonts(fontext='afm')
        self.afmdict = {}
コード例 #38
0
ファイル: finance.py プロジェクト: mgiuca-google/matplotlib
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),
コード例 #39
0
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
コード例 #40
0
ファイル: install.py プロジェクト: jlumpe/ipython-config
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:
コード例 #41
0
# 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`
コード例 #42
0
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."
コード例 #43
0
ファイル: init_matplotlib.py プロジェクト: Erotemic/local
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)
コード例 #44
0
ファイル: params.py プロジェクト: felit/python-study
# -*- coding:utf8 -*-
import matplotlib as mpl

print mpl.rcParams
print len(mpl.rcParams)
mpl.rc('lines', linewidth=2, color='r')
print mpl.get_configdir()
コード例 #45
0
ファイル: basemap.py プロジェクト: VACUMM/vacumm
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
コード例 #46
0
    def findfont(prop, fontext='ttf'):
        if not is_string_like(prop):
            prop = prop.get_fontconfig_pattern()
        cached = _fc_match_cache.get(prop)
        if cached is not None:
            return cached

        result = fc_match(prop, fontext)
        if result is None:
            result = fc_match(':', fontext)

        _fc_match_cache[prop] = result
        return result

else:
    _fmcache = os.path.join(get_configdir(), 'fontManager.cache')

    fontManager = None

    def _rebuild():
        global fontManager
        fontManager = FontManager()
        pickle_dump(fontManager, _fmcache)
        verbose.report("generated new fontManager")

    try:
        fontManager = pickle_load(_fmcache)
        fontManager.default_size = None
        verbose.report("Using fontManager instance from %s" % _fmcache)
    except:
        _rebuild()
コード例 #47
0
        return None
    _fc_match_regex = re.compile(r'\sfile:\s+"([^"]*)"')
    _fc_match_cache = {}
    def findfont(prop, fontext='ttf'):
        if not is_string_like(prop):
            prop = prop.get_fontconfig_pattern()
        cached = _fc_match_cache.get(prop)
        if cached is not None:
            return cached
        result = fc_match(prop, fontext)
        if result is None:
            result = fc_match(':', fontext)
        _fc_match_cache[prop] = result
        return result
else:
    _fmcache = os.path.join(get_configdir(), 'fontList.cache')
    fontManager = None
    def _rebuild():
        global fontManager
        fontManager = FontManager()
        pickle_dump(fontManager, _fmcache)
        verbose.report("generated new fontManager")
    try:
        fontManager = pickle_load(_fmcache)
        if (not hasattr(fontManager, '_version') or
            fontManager._version != FontManager.__version__):
            _rebuild()
        else:
            fontManager.default_size = None
            verbose.report("Using fontManager instance from %s" % _fmcache)
    except:
コード例 #48
0
ファイル: core.py プロジェクト: dopplershift/matplotlib
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():
コード例 #49
0
ファイル: mpl_font_test2.py プロジェクト: hujuu/py-test
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()
コード例 #50
0
ファイル: install.py プロジェクト: nirum/mplstyle
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')]
コード例 #51
0
ファイル: pyexe.py プロジェクト: Paloschi/Gafanhoto
"""
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",
コード例 #52
0
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})