vispy 0.15.0__cp313-cp313-macosx_10_13_x86_64.whl

vispy/util/fetching.py

@@ -0,0 +1,276 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+"""Data downloading and reading functions"""
+
+from math import log
+import os
+from os import path as op
+import sys
+import shutil
+import time
+
+import urllib.request
+
+from ..util.config import config
+
+
+###############################################################################
+# Vispy data directory
+
+def load_data_file(fname, directory=None, force_download=False):
+    """Get a standard vispy demo data file
+
+    Parameters
+    ----------
+    fname : str
+        The filename on the remote ``demo-data`` repository to download,
+        e.g. ``'molecular_viewer/micelle.npy'``. These correspond to paths
+        on ``https://github.com/vispy/demo-data/``.
+    directory : str | None
+        Directory to use to save the file. By default, the vispy
+        configuration directory is used.
+    force_download : bool | str
+        If True, the file will be downloaded even if a local copy exists
+        (and this copy will be overwritten). Can also be a YYYY-MM-DD date
+        to ensure a file is up-to-date (modified date of a file on disk,
+        if present, is checked).
+
+    Returns
+    -------
+    fname : str
+        The path to the file on the local system.
+    """
+    _url_root = 'https://raw.githubusercontent.com/vispy/demo-data/main/'
+    url = _url_root + fname
+    if directory is None:
+        directory = config['data_path']
+        if directory is None:
+            raise ValueError('config["data_path"] is not defined, '
+                             'so directory must be supplied')
+
+    fname = op.join(directory, op.normcase(fname))  # convert to native
+    if op.isfile(fname):
+        if not force_download:  # we're done
+            return fname
+        if isinstance(force_download, str):
+            ntime = time.strptime(force_download, '%Y-%m-%d')
+            ftime = time.gmtime(op.getctime(fname))
+            if ftime >= ntime:
+                return fname
+            else:
+                print('File older than %s, updating...' % force_download)
+    if not op.isdir(op.dirname(fname)):
+        os.makedirs(op.abspath(op.dirname(fname)))
+    # let's go get the file
+    _fetch_file(url, fname)
+    return fname
+
+
+###############################################################################
+# File downloading (most adapted from mne-python)
+
+
+class ProgressBar(object):
+    """Class for generating a command-line progressbar
+
+    Parameters
+    ----------
+    max_value : int
+        Maximum value of process (e.g. number of samples to process, bytes to
+        download, etc.).
+    initial_value : int
+        Initial value of process, useful when resuming process from a specific
+        value, defaults to 0.
+    mesg : str
+        Message to include at end of progress bar.
+    max_chars : int
+        Number of characters to use for progress bar (be sure to save some room
+        for the message and % complete as well).
+    progress_character : char
+        Character in the progress bar that indicates the portion completed.
+    spinner : bool
+        Show a spinner.  Useful for long-running processes that may not
+        increment the progress bar very often.  This provides the user with
+        feedback that the progress has not stalled.
+    """
+
+    spinner_symbols = ['|', '/', '-', '\\']
+    template = '\r[{0}{1}] {2:.05f} {3} {4}   '
+
+    def __init__(self, max_value, initial_value=0, mesg='', max_chars=40,
+                 progress_character='.', spinner=False):
+        self.cur_value = initial_value
+        self.max_value = float(max_value)
+        self.mesg = mesg
+        self.max_chars = max_chars
+        self.progress_character = progress_character
+        self.spinner = spinner
+        self.spinner_index = 0
+        self.n_spinner = len(self.spinner_symbols)
+
+    def update(self, cur_value, mesg=None):
+        """Update progressbar with current value of process
+
+        Parameters
+        ----------
+        cur_value : number
+            Current value of process.  Should be <= max_value (but this is not
+            enforced).  The percent of the progressbar will be computed as
+            (cur_value / max_value) * 100
+        mesg : str
+            Message to display to the right of the progressbar.  If None, the
+            last message provided will be used.  To clear the current message,
+            pass a null string, ''.
+        """
+        # Ensure floating-point division so we can get fractions of a percent
+        # for the progressbar.
+        self.cur_value = cur_value
+        progress = float(self.cur_value) / self.max_value
+        num_chars = int(progress * self.max_chars)
+        num_left = self.max_chars - num_chars
+
+        # Update the message
+        if mesg is not None:
+            self.mesg = mesg
+
+        # The \r tells the cursor to return to the beginning of the line rather
+        # than starting a new line.  This allows us to have a progressbar-style
+        # display in the console window.
+        bar = self.template.format(self.progress_character * num_chars,
+                                   ' ' * num_left,
+                                   progress * 100,
+                                   self.spinner_symbols[self.spinner_index],
+                                   self.mesg)
+        sys.stdout.write(bar)
+        # Increament the spinner
+        if self.spinner:
+            self.spinner_index = (self.spinner_index + 1) % self.n_spinner
+
+        # Force a flush because sometimes when using bash scripts and pipes,
+        # the output is not printed until after the program exits.
+        sys.stdout.flush()
+
+    def update_with_increment_value(self, increment_value, mesg=None):
+        """Update progressbar with the value of the increment instead of the
+        current value of process as in update()
+
+        Parameters
+        ----------
+        increment_value : int
+            Value of the increment of process.  The percent of the progressbar
+            will be computed as
+            (self.cur_value + increment_value / max_value) * 100
+        mesg : str
+            Message to display to the right of the progressbar.  If None, the
+            last message provided will be used.  To clear the current message,
+            pass a null string, ''.
+        """
+        self.cur_value += increment_value
+        self.update(self.cur_value, mesg)
+
+
+def _chunk_read(response, local_file, chunk_size=65536, initial_size=0):
+    """Download a file chunk by chunk and show advancement
+
+    Can also be used when resuming downloads over http.
+
+    Parameters
+    ----------
+    response: urllib.response.addinfourl
+        Response to the download request in order to get file size.
+    local_file: file
+        Hard disk file where data should be written.
+    chunk_size: integer, optional
+        Size of downloaded chunks. Default: 8192
+    initial_size: int, optional
+        If resuming, indicate the initial size of the file.
+    """
+    # Adapted from NISL:
+    # https://github.com/nisl/tutorial/blob/master/nisl/datasets.py
+
+    bytes_so_far = initial_size
+    # Returns only amount left to download when resuming, not the size of the
+    # entire file
+    total_size = int(response.headers['Content-Length'].strip())
+    total_size += initial_size
+
+    progress = ProgressBar(total_size, initial_value=bytes_so_far,
+                           max_chars=40, spinner=True, mesg='downloading')
+    while True:
+        chunk = response.read(chunk_size)
+        bytes_so_far += len(chunk)
+        if not chunk:
+            sys.stderr.write('\n')
+            break
+        _chunk_write(chunk, local_file, progress)
+
+
+def _chunk_write(chunk, local_file, progress):
+    """Write a chunk to file and update the progress bar"""
+    local_file.write(chunk)
+    progress.update_with_increment_value(len(chunk))
+
+
+def _fetch_file(url, file_name, print_destination=True):
+    """Load requested file, downloading it if needed or requested
+
+    Parameters
+    ----------
+    url: string
+        The url of file to be downloaded.
+    file_name: string
+        Name, along with the path, of where downloaded file will be saved.
+    print_destination: bool, optional
+        If true, destination of where file was saved will be printed after
+        download finishes.
+    """
+    # Adapted from NISL:
+    # https://github.com/nisl/tutorial/blob/master/nisl/datasets.py
+
+    temp_file_name = file_name + ".part"
+    local_file = None
+    initial_size = 0
+    # Checking file size and displaying it alongside the download url
+    n_try = 3
+    for ii in range(n_try):
+        try:
+            data = urllib.request.urlopen(url, timeout=15.)
+        except Exception as e:
+            if ii == n_try - 1:
+                raise RuntimeError('Error while fetching file %s.\n'
+                                   'Dataset fetching aborted (%s)' % (url, e))
+    try:
+        file_size = int(data.headers['Content-Length'].strip())
+        print('Downloading data from %s (%s)' % (url, sizeof_fmt(file_size)))
+        local_file = open(temp_file_name, "wb")
+        _chunk_read(data, local_file, initial_size=initial_size)
+        # temp file must be closed prior to the move
+        if not local_file.closed:
+            local_file.close()
+        shutil.move(temp_file_name, file_name)
+        if print_destination is True:
+            sys.stdout.write('File saved as %s.\n' % file_name)
+    except Exception as e:
+        raise RuntimeError('Error while fetching file %s.\n'
+                           'Dataset fetching aborted (%s)' % (url, e))
+    finally:
+        if local_file is not None:
+            if not local_file.closed:
+                local_file.close()
+
+
+def sizeof_fmt(num):
+    """Turn number of bytes into human-readable str"""
+    units = ['bytes', 'kB', 'MB', 'GB', 'TB', 'PB']
+    decimals = [0, 0, 1, 2, 2, 2]
+    """Human friendly file size"""
+    if num > 1:
+        exponent = min(int(log(num, 1024)), len(units) - 1)
+        quotient = float(num) / 1024 ** exponent
+        unit = units[exponent]
+        num_decimals = decimals[exponent]
+        format_string = '{0:.%sf} {1}' % (num_decimals)
+        return format_string.format(quotient, unit)
+    return '0 bytes' if num == 0 else '1 byte'

vispy/util/filter.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+import numpy as np
+
+
+def gaussian_filter(data, sigma):
+    """
+    Drop-in replacement for scipy.ndimage.gaussian_filter.
+
+    (note: results are only approximately equal to the output of
+     gaussian_filter)
+    """
+    if np.isscalar(sigma):
+        sigma = (sigma,) * data.ndim
+
+    baseline = data.mean()
+    filtered = data - baseline
+    for ax in range(data.ndim):
+        s = float(sigma[ax])
+        if s == 0:
+            continue
+
+        # generate 1D gaussian kernel
+        ksize = int(s * 6)
+        x = np.arange(-ksize, ksize)
+        kernel = np.exp(-x**2 / (2*s**2))
+        kshape = [1, ] * data.ndim
+        kshape[ax] = len(kernel)
+        kernel = kernel.reshape(kshape)
+
+        # convolve as product of FFTs
+        shape = data.shape[ax] + ksize
+        scale = 1.0 / (abs(s) * (2*np.pi)**0.5)
+        filtered = scale * np.fft.irfft(np.fft.rfft(filtered, shape, axis=ax) *
+                                        np.fft.rfft(kernel, shape, axis=ax),
+                                        axis=ax)
+
+        # clip off extra data
+        sl = [slice(None)] * data.ndim
+        sl[ax] = slice(filtered.shape[ax]-data.shape[ax], None, None)
+        filtered = filtered[tuple(sl)]
+    return filtered + baseline

vispy/util/fonts/__init__.py

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+"""
+The fonts module implements some helpful functions for dealing with system
+fonts.
+"""
+
+__all__ = ['list_fonts']
+
+from ._triage import _load_glyph, list_fonts  # noqa, analysis:ignore
+from ._vispy_fonts import _vispy_fonts  # noqa, analysis:ignore

vispy/util/fonts/_freetype.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+
+# Use freetype to get glyph bitmaps
+
+import sys
+import numpy as np
+
+
+# Convert face to filename
+from ._vispy_fonts import _vispy_fonts, _get_vispy_font_filename
+if sys.platform.startswith('linux'):
+    from ...ext.fontconfig import find_font
+elif sys.platform.startswith('win'):
+    from ._win32 import find_font  # noqa, analysis:ignore
+else:
+    raise NotImplementedError
+
+_font_dict = {}
+
+
+# Nest freetype imports in case someone doesn't have freetype on their system
+# and isn't using fonts (Windows)
+
+def _load_font(face, bold, italic):
+    from freetype import Face, FT_FACE_FLAG_SCALABLE
+    key = '%s-%s-%s' % (face, bold, italic)
+    if key in _font_dict:
+        return _font_dict[key]
+    if face in _vispy_fonts:
+        fname = _get_vispy_font_filename(face, bold, italic)
+    else:
+        fname = find_font(face, bold, italic)
+    font = Face(fname)
+    if (FT_FACE_FLAG_SCALABLE & font.face_flags) == 0:
+        raise RuntimeError('Font %s is not scalable, so cannot be loaded'
+                           % face)
+    _font_dict[key] = font
+    return font
+
+
+def _load_glyph(f, char, glyphs_dict):
+    """Load glyph from font into dict"""
+    from freetype import (FT_LOAD_RENDER, FT_LOAD_NO_HINTING,
+                          FT_LOAD_NO_AUTOHINT)
+    flags = FT_LOAD_RENDER | FT_LOAD_NO_HINTING | FT_LOAD_NO_AUTOHINT
+    face = _load_font(f['face'], f['bold'], f['italic'])
+    face.set_char_size(f['size'] * 64)
+    # get the character of interest
+    face.load_char(char, flags)
+    bitmap = face.glyph.bitmap
+    width = face.glyph.bitmap.width
+    height = face.glyph.bitmap.rows
+    bitmap = np.array(bitmap.buffer)
+    w0 = bitmap.size // height if bitmap.size > 0 else 0
+    bitmap.shape = (height, w0)
+    bitmap = bitmap[:, :width].astype(np.ubyte)
+
+    left = face.glyph.bitmap_left
+    top = face.glyph.bitmap_top
+    advance = face.glyph.advance.x / 64.
+    glyph = dict(char=char, offset=(left, top), bitmap=bitmap,
+                 advance=advance, kerning={})
+    glyphs_dict[char] = glyph
+    # Generate kerning
+    for other_char, other_glyph in glyphs_dict.items():
+        kerning = face.get_kerning(other_char, char)
+        glyph['kerning'][other_char] = kerning.x / 64.
+        kerning = face.get_kerning(char, other_char)
+        other_glyph['kerning'][char] = kerning.x / 64.

vispy/util/fonts/_quartz.py

@@ -0,0 +1,192 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+
+# Use OSX cocoa/quartz to get glyph bitmaps
+
+import numpy as np
+from ctypes import byref, c_int32, c_byte
+
+from ...ext.cocoapy import cf, ct, quartz, CFRange, CFSTR, CGGlyph, UniChar, \
+    kCTFontFamilyNameAttribute, kCTFontBoldTrait, kCTFontItalicTrait, \
+    kCTFontSymbolicTrait, kCTFontTraitsAttribute, kCTFontAttributeName, \
+    kCGImageAlphaPremultipliedLast, kCFNumberSInt32Type, ObjCClass
+from ._vispy_fonts import _vispy_fonts, _get_vispy_font_filename
+
+_font_dict = {}
+
+
+def _load_vispy_font(face, bold, italic):
+    # http://stackoverflow.com/questions/2703085/
+    # how-can-you-load-a-font-ttf-from-a-file-using-core-text
+    fname = _get_vispy_font_filename(face, bold, italic)
+    url = cf.CFURLCreateWithFileSystemPath(None, CFSTR(fname), 0, False)
+    # data_provider = quartz.CGDataProviderCreateWithURL(url)
+    # cg_font = quartz.CGFontCreateWithDataProvider(data_provider)
+    # font = ct.CTFontCreateWithGraphicsFont(cg_font, 12., None, None)
+    array = ct.CTFontManagerCreateFontDescriptorsFromURL(url)
+    desc = cf.CFArrayGetValueAtIndex(array, 0)
+    font = ct.CTFontCreateWithFontDescriptor(desc, 12., None)
+    cf.CFRelease(array)
+    cf.CFRelease(url)
+    if not font:
+        raise RuntimeError("Couldn't load font: %s" % face)
+    key = '%s-%s-%s' % (face, bold, italic)
+    _font_dict[key] = font
+    return font
+
+
+def _load_font(face, bold, italic):
+    key = '%s-%s-%s' % (face, bold, italic)
+    if key in _font_dict:
+        return _font_dict[key]
+    if face in _vispy_fonts:
+        return _load_vispy_font(face, bold, italic)
+    traits = 0
+    traits |= kCTFontBoldTrait if bold else 0
+    traits |= kCTFontItalicTrait if italic else 0
+
+    # Create an attribute dictionary.
+    args = [None, 0, cf.kCFTypeDictionaryKeyCallBacks,
+            cf.kCFTypeDictionaryValueCallBacks]
+    attributes = cf.CFDictionaryCreateMutable(*args)
+    # Add family name to attributes.
+    cfname = CFSTR(face)
+    cf.CFDictionaryAddValue(attributes, kCTFontFamilyNameAttribute, cfname)
+    cf.CFRelease(cfname)
+    # Construct a CFNumber to represent the traits.
+    itraits = c_int32(traits)
+    sym_traits = cf.CFNumberCreate(None, kCFNumberSInt32Type, byref(itraits))
+    if sym_traits:
+        # Construct a dictionary to hold the traits values.
+        args = [None, 0, cf.kCFTypeDictionaryKeyCallBacks,
+                cf.kCFTypeDictionaryValueCallBacks]
+        traits_dict = cf.CFDictionaryCreateMutable(*args)
+        if traits_dict:
+            # Add CFNumber traits to traits dictionary.
+            cf.CFDictionaryAddValue(traits_dict, kCTFontSymbolicTrait,
+                                    sym_traits)
+            # Add traits dictionary to attributes.
+            cf.CFDictionaryAddValue(attributes, kCTFontTraitsAttribute,
+                                    traits_dict)
+            cf.CFRelease(traits_dict)
+        cf.CFRelease(sym_traits)
+    # Create font descriptor with attributes.
+    desc = ct.CTFontDescriptorCreateWithAttributes(attributes)
+    cf.CFRelease(attributes)
+    font = ct.CTFontCreateWithFontDescriptor(desc, 12., None)
+    if not font:
+        raise RuntimeError("Couldn't load font: %s" % face)
+    _font_dict[key] = font
+    return font
+
+
+def _load_glyph(f, char, glyphs_dict):
+    font = _load_font(f['face'], f['bold'], f['italic'])
+    # resize loaded font
+    args = [None, 0, cf.kCFTypeDictionaryKeyCallBacks,
+            cf.kCFTypeDictionaryValueCallBacks]
+    attributes = cf.CFDictionaryCreateMutable(*args)
+    desc = ct.CTFontDescriptorCreateWithAttributes(attributes)
+    cf.CFRelease(attributes)
+    font = ct.CTFontCreateCopyWithAttributes(font, f['size'], None, desc)
+    cf.CFRelease(desc)
+    if not font:
+        raise RuntimeError("Couldn't load font")
+    # Create an attributed string using text and font.
+    args = [None, 1, cf.kCFTypeDictionaryKeyCallBacks,
+            cf.kCFTypeDictionaryValueCallBacks]
+    attributes = cf.CFDictionaryCreateMutable(*args)
+    cf.CFDictionaryAddValue(attributes, kCTFontAttributeName, font)
+    string = cf.CFAttributedStringCreate(None, CFSTR(char), attributes)
+    # Create a CTLine object to render the string.
+    line = ct.CTLineCreateWithAttributedString(string)
+    cf.CFRelease(string)
+    cf.CFRelease(attributes)
+    # Get a bounding rectangle for glyphs in string.
+    chars = (UniChar * 1)(*map(ord, char))
+    glyphs = (CGGlyph * 1)()
+    ct.CTFontGetGlyphsForCharacters(font, chars, glyphs, 1)
+    rect = ct.CTFontGetBoundingRectsForGlyphs(font, 0, glyphs, None, 1)
+    # Get advance for all glyphs in string.
+    advance = ct.CTFontGetAdvancesForGlyphs(font, 1, glyphs, None, 1)
+    width = max(int(np.ceil(rect.size.width) + 1), 1)
+    height = max(int(np.ceil(rect.size.height) + 1), 1)
+
+    left = rect.origin.x
+    baseline = -rect.origin.y
+    top = height - baseline
+
+    bits_per_component = 8
+    bytes_per_row = 4*width
+    color_space = quartz.CGColorSpaceCreateDeviceRGB()
+    args = [None, width, height, bits_per_component, bytes_per_row,
+            color_space, kCGImageAlphaPremultipliedLast]
+    bitmap = quartz.CGBitmapContextCreate(*args)
+    # Draw text to bitmap context.
+    quartz.CGContextSetShouldAntialias(bitmap, True)
+    quartz.CGContextSetTextPosition(bitmap, -left, baseline)
+    ct.CTLineDraw(line, bitmap)
+    cf.CFRelease(line)
+    # Create an image to get the data out.
+    image_ref = quartz.CGBitmapContextCreateImage(bitmap)
+    assert quartz.CGImageGetBytesPerRow(image_ref) == bytes_per_row
+    data_provider = quartz.CGImageGetDataProvider(image_ref)
+    image_data = quartz.CGDataProviderCopyData(data_provider)
+    buffer_size = cf.CFDataGetLength(image_data)
+    assert buffer_size == width * height * 4
+    buffer = (c_byte * buffer_size)()
+    byte_range = CFRange(0, buffer_size)
+    cf.CFDataGetBytes(image_data, byte_range, buffer)
+    quartz.CGImageRelease(image_ref)
+    quartz.CGDataProviderRelease(image_data)
+    cf.CFRelease(bitmap)
+    cf.CFRelease(color_space)
+
+    # reshape bitmap (don't know why it's only alpha on OSX...)
+    bitmap = np.array(buffer, np.ubyte)
+    bitmap.shape = (height, width, 4)
+    bitmap = bitmap[:, :, 3].copy()
+    glyph = dict(char=char, offset=(left, top), bitmap=bitmap,
+                 advance=advance, kerning={})
+    glyphs_dict[char] = glyph
+    # Generate kerning
+    for other_char, other_glyph in glyphs_dict.items():
+        glyph['kerning'][other_char] = (_get_k_p_a(font, other_char, char) -
+                                        other_glyph['advance'])
+        other_glyph['kerning'][char] = (_get_k_p_a(font, char, other_char) -
+                                        glyph['advance'])
+    cf.CFRelease(font)
+
+
+def _get_k_p_a(font, left, right):
+    """This actually calculates the kerning + advance"""
+    # http://lists.apple.com/archives/coretext-dev/2010/Dec/msg00020.html
+    # 1) set up a CTTypesetter
+    chars = left + right
+    args = [None, 1, cf.kCFTypeDictionaryKeyCallBacks,
+            cf.kCFTypeDictionaryValueCallBacks]
+    attributes = cf.CFDictionaryCreateMutable(*args)
+    cf.CFDictionaryAddValue(attributes, kCTFontAttributeName, font)
+    string = cf.CFAttributedStringCreate(None, CFSTR(chars), attributes)
+    typesetter = ct.CTTypesetterCreateWithAttributedString(string)
+    cf.CFRelease(string)
+    cf.CFRelease(attributes)
+    # 2) extract a CTLine from it
+    range = CFRange(0, 1)
+    line = ct.CTTypesetterCreateLine(typesetter, range)
+    # 3) use CTLineGetOffsetForStringIndex to get the character positions
+    offset = ct.CTLineGetOffsetForStringIndex(line, 1, None)
+    cf.CFRelease(line)
+    cf.CFRelease(typesetter)
+    return offset
+
+
+def _list_fonts():
+    manager = ObjCClass('NSFontManager').sharedFontManager()
+    avail = manager.availableFontFamilies()
+    fonts = [avail.objectAtIndex_(ii).UTF8String().decode('utf-8')
+             for ii in range(avail.count())]
+    return fonts

vispy/util/fonts/_triage.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+
+import sys
+
+from ._vispy_fonts import _vispy_fonts
+if sys.platform.startswith('linux'):
+    from ._freetype import _load_glyph
+    from ...ext.fontconfig import _list_fonts
+elif sys.platform == 'darwin':
+    from ._quartz import _load_glyph, _list_fonts
+elif sys.platform.startswith('win'):
+    from ._freetype import _load_glyph  # noqa, analysis:ignore
+    from ._win32 import _list_fonts  # noqa, analysis:ignore
+else:
+    raise NotImplementedError('unknown system %s' % sys.platform)
+
+_fonts = {}
+
+
+def list_fonts():
+    """List system fonts
+
+    Returns
+    -------
+    fonts : list of str
+        List of system fonts.
+    """
+    vals = _list_fonts()
+    for font in _vispy_fonts:
+        vals += [font] if font not in vals else []
+    vals = sorted(vals, key=lambda s: s.lower())
+    return vals

vispy/util/fonts/_vispy_fonts.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+
+import os.path as op
+
+# List the vispy fonts made available online
+_vispy_fonts = ('OpenSans',)
+
+
+def _get_vispy_font_filename(face, bold, italic):
+    """Fetch a remote vispy font"""
+    name = face + '-'
+    name += 'Regular' if not bold and not italic else ''
+    name += 'Bold' if bold else ''
+    name += 'Italic' if italic else ''
+    name += '.ttf'
+    return op.join(op.dirname(__file__), 'data', name)