setup.py

"""
Installation script for the snappy module.

Depends heavily on setuptools.
"""
no_setuptools_message = """
You need to have setuptools installed to build the snappy module. See:

  https://packaging.python.org/installing/

"""

required_cython_version = '0.28'

no_cython_message = """
You need to have Cython (>= %s) installed to build the snappy
module since you're missing the autogenerated C/C++ files, e.g.

  sudo python -m pip install "cython>=%s"

""" % (required_cython_version, required_cython_version)

no_sphinx_message = """
You need to have Sphinx installed to rebuild the
documentation for snappy module, e.g.

  sudo python -m pip install sphinx

"""

no_sphinx_theme_message = """
You need to have Spinx's rtd theme installed to rebuild the
documentation for snappy module, e.g.

  sudo python -m pip install sphinx_rtd_theme

"""

no_wheel_message = """
You need to have wheel installed to install snappy, e.g.,

  sudo python -m pip install "wheel"

"""

# On some python distributions for Mac OS X, one needs to set the environment
# variable MACOSX_DEPLOYMENT_TARGET to, e.g., 10.14.

try:
    import setuptools
except ImportError:
    raise ImportError(no_setuptools_message)

try:
    import wheel
except ImportError:
    raise ImportError(no_wheel_message)

import os, platform, shutil, site, subprocess, sys, sysconfig, re
from os.path import getmtime, exists
from glob import glob
import importlib.metadata

# Remove '.' from the path so that Sphinx doesn't try to load the SnapPy module directly

try:
    sys.path.remove(os.path.realpath(os.curdir))
except ValueError:
    pass

from setuptools.extension import Extension
from setuptools import setup, Command

from setuptools import Distribution
from setuptools.command.build_clib import build_clib

def get_build_temp_dir():
    dist = Distribution()
    dummy_cmd = build_clib(dist)
    dummy_cmd.ensure_finalized()
    return dummy_cmd.build_temp
build_temp_dir = get_build_temp_dir()

cythoned_dir = 'cythoned'

# A real clean

class SnapPyClean(Command):
    user_options = []
    def initialize_options(self):
        pass
    def finalize_options(self):
        pass
    def run(self):
        junkdirs = (glob('build/lib*') +
                    glob('build/bdist*') +
                    glob('build/temp*') +
                    glob('snappy*.egg-info') +
                    glob(cythoned_dir) +
                    ['__pycache__', os.path.join('src', 'snappy', 'doc')]
        )
        for dir in junkdirs:
            try:
                shutil.rmtree(dir)
            except OSError:
                pass
        junkfiles = glob('src/*.so*') + glob('src/*.pyc')
        for file in junkfiles:
            try:
                os.remove(file)
            except OSError:
                pass

class SnapPyBuildDocs(Command):
    user_options = []
    def initialize_options(self):
        pass
    def finalize_options(self):
        pass
    def run(self):
        if not os.path.exists('doc_src'):
            return # Are in an sdist and may not have sphinx
        try:
            import sphinx
        except ImportError:
            raise ImportError(no_sphinx_message)
        try:
            import sphinx_rtd_theme
        except ImportError:
            raise ImportError(no_sphinx_theme_message)
        sphinx_dist = importlib.metadata.Distribution.from_name('sphinx')
        sphinx_cmd = sphinx_dist.entry_points['sphinx-build'].load()
        sphinx_args = ['-a', '-E', '-d', 'doc_src/_build/doctrees',
                       'doc_src', 'src/snappy/doc']
        sys.path.insert(0, build_lib_dir())
        status = sphinx_cmd(sphinx_args)
        if status != 0:
            sys.exit(status)

def distutils_dir_name(dname):
    """Returns the name of a distutils build subdirectory"""
    name = "build/{prefix}.{plat}-{ver[0]}{ver[1]}".format(
        prefix=dname, plat=sysconfig.get_platform(), ver=sys.version_info)
    if dname == 'temp' and sys.platform == 'win32':
        name += os.sep + 'Release'
    return name


def build_lib_dir():
    return os.path.abspath(distutils_dir_name('lib'))


class SnapPyTest(Command):
    user_options = []
    def initialize_options(self):
        pass
    def finalize_options(self):
        pass
    def run(self):
        sys.path.insert(0, build_lib_dir())
        from snappy.test import runtests
        print('Running tests ...')
        sys.exit(runtests())


class SnapPyApp(Command):
    user_options = []
    def initialize_options(self):
        pass
    def finalize_options(self):
        pass
    def run(self):
        sys.path.insert(0, build_lib_dir())
        import snappy.app
        snappy.app.main()


def check_call(args):
    try:
        subprocess.check_call(args)
    except subprocess.CalledProcessError:
        executable = args[0]
        command = [a for a in args if not a.startswith('-')][-1]
        raise RuntimeError(command + ' failed for ' + executable)


from setuptools.command.sdist import sdist
class SnapPySdist(sdist):
    def run(self):
        python = sys.executable
        check_call([python, 'setup.py', 'build_docs'])
        sdist.run(self)


class SnapPyPipInstall(Command):
    user_options = []
    def initialize_options(self):
        pass
    def finalize_options(self):
        pass
    def run(self):
        python = sys.executable
        check_call([python, 'setup.py', 'bdist_wheel'])
        egginfo = 'snappy.egg-info'
        if os.path.exists(egginfo):
            shutil.rmtree(egginfo)
        wheels = glob('dist' + os.sep + '*.whl')
        new_wheel = max(wheels, key=os.path.getmtime)
        check_call([python, '-m', 'pip', 'uninstall', '-y', 'snappy'])
        check_call([python, '-m', 'pip', 'install', '--upgrade',
                    '--upgrade-strategy', 'only-if-needed',
                    new_wheel])

def replace_ext(file, new_ext):
    root, ext = os.path.splitext(file)
    return root + '.' + new_ext

# We check manually which object files need to be rebuilt; distutils
# is overly cautious and always rebuilds everything, which makes
# development painful.


def modtime(file):
    if os.path.exists(file):
        return os.path.getmtime(file)
    else:
        return 0.0

class SourceAndObjectFiles():
    def __init__(self):
        self.sources_to_build, self.up_to_date_objects = [], []
        self.obj_ext = 'obj' if sys.platform.startswith('win') else 'o'
        self.cython_file = None
        self.mod_time_dependencies = None

    def set_headers(self, files):
        """
        Call before anything else.
        If set_headers is called, an object file older than any header is forced to
        be rebuild.
        """
        self.mod_time_dependencies = max(modtime(file) for file in files)

    def set_cython_file_language_and_dependencies(
            self, cython_file, language, dependencies = []):
        """
        Sets the cython file. Populates cythoned_file. Forces the object file
        to be rebuild if cython_file or any file in dependencies is newer.
        language is the file extension of the cythoned file.
        """
        self.cython_file = cython_file
        self.cythoned_file = replace_ext(cythoned_dir + '/' + cython_file, language)
        self.add(self.cythoned_file, [cython_file] + dependencies)

    def add(self, source_file, dependencies = []):
        """
        Add source file. Forces object file to be rebuild if source file or any
        file in dependencies is newer.
        """

        object_file = build_temp_dir + os.sep + replace_ext(source_file, self.obj_ext)
        t = modtime(object_file)

        if (t < modtime(source_file) or
            any(t < modtime(file) for file in dependencies) or
            (self.mod_time_dependencies is not None and t < self.mod_time_dependencies)):
            self.sources_to_build.append(source_file)
        else:
            self.up_to_date_objects.append(object_file)

###############################################################################
# SourceAndObjectFiles for SnapPy and SnapPyHP extension

snappy_ext_files = SourceAndObjectFiles()
hp_snappy_ext_files = SourceAndObjectFiles()

SnapPy_path = os.path.join('src', 'snappy', 'extensions', 'SnapPy')
kernel_path = os.path.join(SnapPy_path, 'kernel')

snappy_headers = (
    glob(os.path.join(kernel_path, 'headers', '*.h')) +
    glob(os.path.join(kernel_path, 'addl_code', '*.h')) +
    glob(os.path.join(kernel_path, 'unix_kit', '*.h')))
snappy_ext_files.set_headers(snappy_headers)
hp_snappy_ext_files.set_headers(snappy_headers)

snappy_cython_deps = [
    os.path.join(SnapPy_path, 'cython_src', 'SnapPycore.pxi'),
    os.path.join(SnapPy_path, 'cython_src', 'SnapPy.pxi') ]
snappy_cython_deps += glob(os.path.join(SnapPy_path, 'cython_src','core', '*.pyx'))

snappy_ext_files.set_cython_file_language_and_dependencies(
    os.path.join(SnapPy_path, 'cython_src', 'SnapPy.pyx'), 'c', snappy_cython_deps)

SnapPyHP_path = os.path.join('src', 'snappy', 'extensions', 'SnapPyHP')

hp_snappy_ext_files.set_cython_file_language_and_dependencies(
    os.path.join(SnapPyHP_path, 'cython_src', 'SnapPyHP.pyx'), 'cpp', snappy_cython_deps)

unused_unix_files = ['unix_UI.c', 'decode_new_DT.c']
base_code = glob(os.path.join(kernel_path, 'kernel_code','*.c'))
unix_code = [
    file
    for file in glob(os.path.join(kernel_path, 'unix_kit','*.c'))
    if os.path.basename(file) not in unused_unix_files ]
addl_code = glob(os.path.join(kernel_path, 'addl_code', '*.c'))

hp_kernel_path = os.path.join(SnapPyHP_path, 'kernel')

for file in base_code + unix_code + addl_code:
    snappy_ext_files.add(file)
    hp_file = replace_ext(file.replace(kernel_path, hp_kernel_path), 'cpp')
    assert os.path.exists(hp_file), hp_file
    hp_snappy_ext_files.add(hp_file, [file])

for file in glob(os.path.join(SnapPyHP_path, 'qd', 'src', '*.cpp')):
    hp_snappy_ext_files.add(file)

###############################################################################
# SourceAndObjectFiles for CyOpenGL

orb_ext_files = SourceAndObjectFiles()

Orb_path = os.path.join('src', 'snappy', 'extensions', 'Orb')
OrbKernel_path = os.path.join(Orb_path, 'kernel')

orb_headers = (
    glob(os.path.join(OrbKernel_path, 'headers', '*.h')) +
    glob(os.path.join(OrbKernel_path, 'unix_kit', '*.h')))
orb_ext_files.set_headers(orb_headers)

orb_cython_deps = [os.path.join(Orb_path, 'cython_src', 'Orb.pxi')]
orb_cython_deps += glob(os.path.join(Orb_path, 'cython_src', '*pyx'))

orb_ext_files.set_cython_file_language_and_dependencies(
    os.path.join(Orb_path, 'cython_src', 'Orb.pyx'), 'c', orb_cython_deps)

orb_base_code = glob(os.path.join(OrbKernel_path, 'code', '*.c'))
orb_unix_code = glob(os.path.join(OrbKernel_path, 'unix_kit', '*.c'))

for file in orb_base_code + orb_unix_code:
    orb_ext_files.add(file)

###############################################################################
# SourceAndObjectFiles for CyOpenGL

cy_opengl_path = os.path.join('src', 'snappy', 'extensions', 'CyOpenGL')

cy_opengl_ext_files = SourceAndObjectFiles()
cy_opengl_ext_files.set_cython_file_language_and_dependencies(
    os.path.join(cy_opengl_path, 'CyOpenGL.pyx'), 'c', [])

###############################################################################
# Cythonize

# If we have Cython, regenerate .c files as needed:
try:
    from Cython.Build import cythonize
    from Cython import __version__ as cython_version
    have_cython = True
except ImportError as e:
    have_cython = False
    cython_import_error = e

def split_version(s : str):
    return [int(x) for x in s.split('.')]

exts = [ snappy_ext_files,
         hp_snappy_ext_files,
         orb_ext_files,
         cy_opengl_ext_files ]

if not any(  (non_build in sys.argv)
             for non_build in [ 'clean', 'egg_info', 'dist_info' ]):
    if have_cython:
        if split_version(cython_version) < split_version(required_cython_version):
            raise ImportError(
                'Wrong cython version installed. '
                'Required version: %s. Installed version: %s.' % (
                    required_cython_version, cython_version))

        cythonize([ext.cython_file for ext in exts],
                  compiler_directives={'embedsignature': True},
                  build_dir=cythoned_dir)
    else:  # No Cython, likely building an sdist
        for ext in exts:
            if not exists(ext.cythoned_file):
                raise ImportError(
                    no_cython_message +
                    'Missing Cythoned file: ' + ext.cythoned_file +
                    '\n[Cython import error: %r]' % cython_import_error +
                    '\n[Command line arguments: %r]' % sys.argv)

###############################################################################
# Common ompiler option

if sys.platform == 'win32':
    # For Windows, check the compiler we will be using.
    cc = 'msvc'
    for arg in sys.argv:
        if arg.startswith('--compiler='):
            cc = arg.split('=')[1]

if sys.platform == 'darwin':
    # On macOS, the C and C++ code generated by Cython produces lots of these.
    # Since we cannot do anything about them, the warnings are just noise.
    # The kernel code does not generate any of them.
    macOS_quiet_cython = [
        '-Wno-unreachable-code']
    macOS_link_args = []
    macos_arch = sysconfig.get_platform().split('-')[-1]
    macos_targets = {'x86_64':'10.9', 'arm64': '11', 'universal2': '10.9'}
    os.environ['MACOSX_DEPLOYMENT_TARGET'] = macos_targets[macos_arch]

###############################################################################
# The SnapPy extension

snappy_extra_compile_args = []
snappy_extra_link_args = []
if sys.platform == 'win32':
    if cc == 'msvc':
        snappy_extra_compile_args.append('/EHsc')
        # Uncomment to get debugging symbols for msvc.
        # snappy_extra_compile_args += ['/DDEBUG', '/Zi',
        #                              '/FdSnapPy.cp37-win_amd64.pdb']
    else:
        if sys.version_info == (3, 4):
            snappy_extra_link_args.append('-lmsvcr100')

if sys.platform == 'darwin':
    snappy_extra_compile_args += macOS_quiet_cython
    snappy_extra_link_args += macOS_link_args

SnapPyC = Extension(
    name = 'snappy.extensions.SnapPy',
    sources = snappy_ext_files.sources_to_build,
    include_dirs = [
        os.path.join(kernel_path, 'headers'),
        os.path.join(kernel_path, 'headers', 'precision', 'double'),
        os.path.join(kernel_path, 'unix_kit'),
        os.path.join(kernel_path, 'addl_code') ],
    language='c++',
    extra_compile_args = snappy_extra_compile_args,
    extra_link_args = snappy_extra_link_args,
    extra_objects = snappy_ext_files.up_to_date_objects)


###############################################################################
# The high precision SnapPyHP extension

hp_extra_link_args = []
hp_extra_compile_args = []
if sys.platform == 'win32' and cc == 'msvc':
    if platform.architecture()[0] == '32bit':
        hp_extra_compile_args.append('/arch:SSE2')
    hp_extra_compile_args += ['/EHsc', '/MT']
    # Uncomment to get debugging symbols for msvc.
    # hp_extra_compile_args += ['/DDEBUG', '/Zi',
    #                           '/FdSnapPyHP.cp37-win_amd64.pdb']
elif sys.platform == 'darwin':
        if macos_arch == 'x86_64':
            hp_extra_compile_args = ['-mfpmath=sse', '-msse2', '-mieee-fp']
elif platform.machine() == 'x86_64':
    hp_extra_compile_args = ['-mfpmath=sse', '-msse2', '-mieee-fp']

if have_cython:
    if [int(x) for x in cython_version.split('.')[:2]] < [3, 0]:
        if sys.platform == 'win32':
            hp_extra_compile_args.append('/DFORCE_C_LINKAGE')
        else:
            hp_extra_compile_args.append('-DFORCE_C_LINKAGE')

if sys.platform == 'darwin':
    hp_extra_compile_args += macOS_quiet_cython

SnapPyHP = Extension(
    name = 'snappy.extensions.SnapPyHP',
    sources = hp_snappy_ext_files.sources_to_build,
    include_dirs = [
        os.path.join(kernel_path, 'headers'),
        os.path.join(kernel_path, 'headers', 'precision', 'qd'),
        os.path.join(kernel_path, 'unix_kit'),
        os.path.join(kernel_path, 'addl_code'),
        os.path.join(kernel_path, 'kernel_code'),
        os.path.join(SnapPyHP_path, 'qd', 'include') ],
    language='c++',
    extra_compile_args = hp_extra_compile_args,
    extra_link_args = hp_extra_link_args,
    extra_objects = hp_snappy_ext_files.up_to_date_objects)

OrbC = Extension(
    name = 'snappy.extensions.Orb',
    sources = orb_ext_files.sources_to_build,
    include_dirs = [os.path.join(OrbKernel_path, 'headers'),
                    os.path.join(OrbKernel_path, 'unix_kit'),
                    os.path.join('src', 'snappy', 'extensions')],
    language = 'c',
    extra_compile_args = snappy_extra_compile_args,
    extra_link_args = snappy_extra_link_args,
    extra_objects = orb_ext_files.up_to_date_objects)

###############################################################################
# The CyOpenGL extension
CyOpenGL_includes = []
CyOpenGL_libs = []
CyOpenGL_extras = []
CyOpenGL_extra_compile_args = []
CyOpenGL_extra_link_args = []
CyOpenGL_has_headers = False

if sys.platform == 'darwin':
    OS_X_ver = int(platform.mac_ver()[0].split('.')[1])
    sdk_roots = [
        '/Library/Developer/CommandLineTools/SDKs',
        '/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs'
         ]
    version_strings = [ 'MacOSX10.%d.sdk' % OS_X_ver, 'MacOSX.sdk' ]
    poss_roots = [ '' ] + [
        '%s/%s' % (sdk_root, version_string)
        for sdk_root in sdk_roots
        for version_string in version_strings ]
    header_dir = '/System/Library/Frameworks/OpenGL.framework/Versions/Current/Headers/'
    poss_includes = [ root + header_dir for root in poss_roots ]
    CyOpenGL_includes += [ path for path in poss_includes if os.path.exists(path)][:1]
    CyOpenGL_has_headers = any(
        exists(os.path.join(path, 'gl.h'))
        for path in CyOpenGL_includes)
    if not CyOpenGL_has_headers:
        print("***WARNING***: Not Building CyOpenGL so many graphics features "
              "will not be availble.")
        print("This is because the OpenGL header gl.h were not found at: %s" %(
            ', '.join(CyOpenGL_includes)))

    CyOpenGL_extra_compile_args += macOS_quiet_cython
    CyOpenGL_extra_link_args = ['-framework', 'OpenGL']
    CyOpenGL_extra_link_args += macOS_link_args

elif sys.platform == 'linux2' or sys.platform == 'linux':
    CyOpenGL_libs += ['GL']

    gl_header_path = '/usr/include/GL/gl.h'
    CyOpenGL_has_headers = exists(gl_header_path)

    if not CyOpenGL_has_headers:
        print("***WARNING***: Not Building CyOpenGL so many graphics features "
              "will not be availble.")
        print("This is because the OpenGL header %s was not found." % gl_header_path)

elif sys.platform == 'win32':
    # Pick up glew
    CyOpenGL_includes = [cy_opengl_path]
    CyOpenGL_has_headers = True

    if platform.architecture()[0] == '32bit':
        CyOpenGL_extras += [os.path.join(cy_opengl_path, 'glew/lib/Release/Win32/glew32s.lib')]
    else:
        CyOpenGL_extras += [os.path.join(cy_opengl_path, 'glew/lib/Release/x64/glew32s.lib')]

    if cc == 'msvc':
        CyOpenGL_extras += ['opengl32.lib']
    else:
        CyOpenGL_extras += ['/mingw/lib/libopengl32.a']

else:
    print("***WARNING***: Not Building CyOpenGL so many graphics features "
          "will not be availble.")
    print("This is because we have an unsupported platform %s." % sys.platform)


CyOpenGL = Extension(
    name = 'snappy.extensions.CyOpenGL',
    sources = cy_opengl_ext_files.sources_to_build,
    include_dirs = CyOpenGL_includes,
    libraries = CyOpenGL_libs,
    extra_objects = cy_opengl_ext_files.up_to_date_objects + CyOpenGL_extras,
    extra_compile_args = CyOpenGL_extra_compile_args,
    extra_link_args = CyOpenGL_extra_link_args,
    language='c++'
)

###############################################################################
# Twister extension

twister_main_path = os.path.join('src', 'snappy', 'twister', 'lib')
twister_kernel_path = os.path.join(twister_main_path, 'kernel')

twister_ext_files = SourceAndObjectFiles()
twister_ext_files.add(os.path.join(twister_main_path, 'py_wrapper.cpp'))
for file in ['twister.cpp', 'manifold.cpp', 'parsing.cpp', 'global.cpp']:
    twister_ext_files.add(os.path.join(twister_kernel_path, file))

twister_extra_compile_args = []
twister_extra_link_args = []
if sys.platform == 'win32' and cc == 'msvc':
    twister_extra_compile_args += ['/EHsc', '/MT']

TwisterCore = Extension(
    name = 'snappy.twister.twister_core',
    sources = twister_ext_files.sources_to_build,
    include_dirs=[twister_kernel_path],
    extra_compile_args=twister_extra_compile_args,
    extra_link_args=twister_extra_link_args,
    language='c++',
    extra_objects = twister_ext_files.up_to_date_objects)

###############################################################################
# snappy

ext_modules = [SnapPyC, SnapPyHP, OrbC, TwisterCore]
if CyOpenGL_has_headers:
    ext_modules.append(CyOpenGL)
elif (os.environ.get('SNAPPY_ALWAYS_BUILD_CYOPENGL', 'False')
      not in ['0', 'false', 'False']):
    raise RuntimeError('Could not find CyOpenGL requirements but '
                       'SNAPPY_ALWAYS_BUILD_CYOPENGL is set.')

install_requires = ['FXrays>=1.3',
                    'plink>=2.4.9',
                    'spherogram>=2.4.1',
                    'snappy_manifolds>=1.4',
                    'low_index>=1.2.1',
                    'tkinter-gl>=1.0',
                    'decorator',
                    'packaging',
                    'pypng', # Used to save OpenGL images.
                    'PyX', # Used to save PDF images of links.
                    'pickleshare', # To avoid https://github.com/ipython/ipython/issues/14416
                    ]
try:
    import sage
except ImportError:
    install_requires.append('cypari>=2.3')
    install_requires.append('ipython>=5.0')

# Get version number:
exec(open('src/snappy/version.py').read())

# Get long description from README
long_description = open('README.rst').read()
long_description = long_description.split('Downloads')[0]

# Off we go ...
setup( name = 'snappy',
       version = version,
       zip_safe = False,
       force = True,
       python_requires = '>=3.8',
       install_requires = install_requires,
       packages = ['snappy',
                   'snappy/manifolds',
                   'snappy/twister',
                   'snappy/snap',
                   'snappy/snap/t3mlite',
                   'snappy/snap/peripheral',
                   'snappy/snap/slice_obs_HKL',
                   'snappy/ptolemy',
                   'snappy/hyperboloid',
                   'snappy/geometric_structure',
                   'snappy/geometric_structure/geodesic',
                   'snappy/geometric_structure/cusp_neighborhood',
                   'snappy/upper_halfspace',
                   'snappy/verify',
                   'snappy/verify/complex_volume',
                   'snappy/tiling',
                   'snappy/drilling',
                   'snappy/cusps',
                   'snappy/len_spec',
                   'snappy/margulis',
                   'snappy/exterior_to_link',
                   'snappy/raytracing',
                   'snappy/raytracing/shaders',
                   'snappy/raytracing/zoom_slider',
                   'snappy/dev',
                   'snappy/dev/extended_ptolemy',
                   'snappy/dev/vericlosed',
                   'snappy/dev/vericlosed/orb',
       ],
       package_data = {
           'snappy' : ['info_icon.gif', 'SnapPy.ico', 'SnapPy.png',
                       'doc/*.*',
                       'doc/_images/*',
                       'doc/_sources/*',
                       'doc/_static/*',
                       'doc/_static/js/*',
                       'doc/_static/css/*',
                       'doc/_static/css/fonts/*'],
           'snappy/manifolds' : ['HTWKnots/*.gz'],
           'snappy/twister' : ['surfaces/*'],
           'snappy/ptolemy':['magma/*.magma_template',
                             'testing_files/*magma_out.bz2',
                             'testing_files/data/pgl2/OrientableCuspedCensus/03_tetrahedra/*magma_out',
                             'regina_testing_files/*magma_out.bz2',
                             'testing_files_generalized/*magma_out.bz2',
                             'regina_testing_files_generalized/*magma_out.bz2',
                             'testing_files_rur/*rur.bz2'],
           'snappy/exterior_to_link': ['geodesic_map.json'],
           'snappy/raytracing/shaders' : ['*.glsl', '*.png'],
           'snappy/raytracing/zoom_slider': ['*.png', '*.gif'],
           'snappy/raytracing/zoom_slider': ['*.png'],
           'snappy/dev/vericlosed/orb' : ['orb_solution_for_snappea_finite_triangulation_mac'],
       },
       package_dir = {
           '': 'src',
           'snappy/twister':'src/snappy/twister/lib',
           'snappy/dev':'dev/python',
           'snappy/dev/extended_ptolemy':'dev/extended_ptolemy',
           'snappy/dev/vericlosed':'dev/vericlosed',
           'snappy/dev/vericlosed/orb':'dev/vericlosed/orb',
       },
       ext_modules = ext_modules,
       cmdclass =  {'clean' : SnapPyClean,
                    'build_docs': SnapPyBuildDocs,
                    'test': SnapPyTest,
                    'app': SnapPyApp,
                    'sdist':SnapPySdist,
                    'pip_install':SnapPyPipInstall,
       },
       entry_points = {'console_scripts': ['SnapPy = snappy.app:main']},
       description= 'Studying the topology and geometry of 3-manifolds, with a focus on hyperbolic structures.',
       long_description = long_description,
       long_description_content_type = 'text/x-rst',
       author = 'Marc Culler and Nathan M. Dunfield',
       author_email = 'culler@uic.edu, nathan@dunfield.info',
       license='GPLv2+',
       url = 'http://snappy.computop.org',
       classifiers = [
           'Development Status :: 5 - Production/Stable',
           'Intended Audience :: Science/Research',
           'License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)',
           'Operating System :: OS Independent',
           'Programming Language :: C',
           'Programming Language :: C++',
           'Programming Language :: Python',
           'Programming Language :: Cython',
           'Topic :: Scientific/Engineering :: Mathematics',
        ],
        keywords = '3-manifolds, topology, hyperbolic geometry',
        options={
            "build_ext": {
                "force": any(
                    len(ext.sources_to_build) > 0
                    for ext in exts)
            }
        }
)