Getting rid of six and modifying setup

Author: mikaem

conf/meta.yaml

@@ -1,6 +1,8 @@
+{% set data = load_setup_py_data() %}
+
 package:
   name: mpi4py_fft
-  version: "1.0.1"
+  version: {{ data.get('version') }}
 
 source:
   git_url: ../
@@ -17,7 +19,6 @@ requirements:
     - mpi4py
     - numpy
     - nomkl
-    - six
     - pip
     - fftw
     - setuptools
@@ -28,7 +29,6 @@ requirements:
     - numpy
     - fftw
     - pyfftw
-    - six
     - nomkl
     - scipy >=1.0.0
     - h5py-parallel

docs/source/introduction.rst

@@ -4,9 +4,9 @@ Introduction
 The Python package mpi4py-fft is a tool primarily for working with Fast
 Fourier Transforms (FFTs) of (large) multidimensional arrays. There is really
 no limit as to how large the arrays can be, just as long as there is sufficient
-computing powers available. Also, there are no limits as to how transforms can be
-configured. Just about any combination of transforms from the FFTW library is
-supported. Furthermore, mpi4py-fft can also be used simply to perform global
+computing powers available. Also, there are no limits as to how transforms can
+be configured. Just about any combination of transforms from the FFTW library
+is supported. Furthermore, mpi4py-fft can also be used simply to perform global
 redistributions (distribute and communicate) of large arrays with MPI, without
 any transforms at all.
 

mpi4py_fft/__init__.py

@@ -1,3 +1,24 @@
+"""
+This is the **mpi4py-fft** package
+
+What is **mpi4py-fft**?
+=======================
+
+The Python package **mpi4py-fft** is a tool primarily for working with Fast
+Fourier Transforms (FFTs) of (large) multidimensional arrays. There is really
+no limit as to how large the arrays can be, just as long as there is sufficient
+computing powers available. Also, there are no limits as to how transforms can
+be configured. Just about any combination of transforms from the FFTW library
+is supported. Furthermore, mpi4py-fft can also be used simply to perform global
+redistributions (distribute and communicate) of large arrays with MPI, without
+any transforms at all.
+
+For more information, see `documentation <https://mpi4py-fft.readthedocs.io>`_.
+
+"""
+__version__ = '1.0.1'
+__author__ = 'Lisandro Dalcin and Mikael Mortensen'
+
 from .mpifft import PFFT, Function
 from . import fftw
 from .utilities import HDF5File, NCFile, generate_xdmf

mpi4py_fft/fftw/factory.py

@@ -1,4 +1,5 @@
-import six
+#pylint: disable=no-name-in-module
+
 import numpy as np
 from mpi4py import MPI
 from .utilities import FFTW_FORWARD, FFTW_MEASURE
@@ -40,9 +41,9 @@ def get_fftw_lib(dtype):
 
 fftlib = {}
 for t in 'fdg':
-    lib = get_fftw_lib(t)
-    if lib is not None:
-        fftlib[t.upper()] = lib
+    fftw_lib = get_fftw_lib(t)
+    if fftw_lib is not None:
+        fftlib[t.upper()] = fftw_lib
 
 comm = MPI.COMM_WORLD
 
@@ -126,7 +127,7 @@ def export_wisdom(filename):
     """
     rank = str(comm.Get_rank())
     e = []
-    for key, lib in six.iteritems(fftlib):
+    for key, lib in fftlib.items():
         e.append(lib.export_wisdom(bytearray(key+rank+'_'+filename, 'utf-8')))
     assert np.all(np.array(e) == 1), "Not able to export wisdom {}".format(filename)
 
@@ -155,7 +156,7 @@ def import_wisdom(filename):
     """
     rank = str(comm.Get_rank())
     e = []
-    for key, lib in six.iteritems(fftlib):
+    for key, lib in fftlib.items():
         e.append(lib.import_wisdom(bytearray(key+rank+'_'+filename, 'utf-8')))
     assert np.all(np.array(e) == 1), "Not able to import wisdom {}".format(filename)
 

mpi4py_fft/fftw/xfftn.py

@@ -1,4 +1,4 @@
-import six
+#pylint: disable=no-name-in-module,unused-import
 import numpy as np
 from .factory import get_planned_FFT
 from .utilities import FFTW_FORWARD, FFTW_BACKWARD, FFTW_REDFT00, FFTW_REDFT01, \
@@ -8,7 +8,7 @@
     FFTW_ESTIMATE, FFTW_WISDOM_ONLY, C2C_FORWARD, C2C_BACKWARD, R2C, C2R, \
     FFTW_R2HC, FFTW_HC2R, FFTW_DHT, get_alignment, aligned, aligned_like
 
-flag_dict = {key: val for key, val in six.iteritems(locals())
+flag_dict = {key: val for key, val in locals().items()
              if key.startswith('FFTW_')}
 
 dct_type = {
@@ -835,4 +835,3 @@ def get_normalization(kind, shape, axes):
     hfftn: ihfftn,
     ihfftn: hfftn
 }
-

mpi4py_fft/utilities/file_base.py

@@ -1,4 +1,3 @@
-import six
 import numpy as np
 
 class FileBase(object):
@@ -34,7 +33,7 @@ def write(self, step, fields, **kw):
             arrays to be stored, whereas 2-tuples are arrays with associated
             *global* slices.
         """
-        for group, list_of_fields in six.iteritems(fields):
+        for group, list_of_fields in fields.items():
             assert isinstance(list_of_fields, (tuple, list))
             assert isinstance(group, str)
 

mpi4py_fft/utilities/generate_xdmf.py

@@ -1,14 +1,7 @@
 # pylint: disable=line-too-long
 import copy
 import re
-import six
 from numpy import dtype, array, invert, take
-try:
-    import h5py
-except ImportError: #pragma: no cover
-    import warnings
-    warnings.warn('h5py not installed')
-
 
 __all__ = ('generate_xdmf',)
 
@@ -120,6 +113,7 @@ def generate_xdmf(h5filename, periodic=True, order='paraview'):
             opposite order in the XDMF-file for 2D slices. Make choice of
             order here.
     """
+    import h5py
     f = h5py.File(h5filename)
     keys = []
     f.visit(keys.append)
@@ -148,7 +142,7 @@ def generate_xdmf(h5filename, periodic=True, order='paraview'):
         periodic = list(array(invert(periodic), int))
 
     coor = ['x0', 'x1', 'x2', 'x3', 'x4']
-    for ndim, dsets in six.iteritems(datasets):
+    for ndim, dsets in datasets.items():
         timesteps = list(dsets.keys())
         per = copy.copy(periodic)
         if not timesteps:
@@ -272,7 +266,7 @@ def generate_xdmf(h5filename, periodic=True, order='paraview'):
                 grid[slices] += get_grid(geometry[slices], topology[slices],
                                          attrs[slices].rstrip())
                 attrs[slices] = ''
-        for slices, ff in six.iteritems(xff):
+        for slices, ff in xff.items():
             if 'slice' in slices:
                 fname = h5filename[:-3]+"_"+slices+".xdmf"
             else:

requirements.txt

@@ -1,4 +1,3 @@
 numpy
 cython
 mpi4py
-six

setup.py

@@ -1,9 +1,10 @@
 #!/usr/bin/env python
 
-import os, sys
+import os
+import sys
+import re
 import shutil
 from distutils import ccompiler
-import six
 from setuptools import setup
 from setuptools.extension import Extension
 from numpy import get_include
@@ -19,49 +20,66 @@
         include_dirs.append(os.path.join(os.environ[f], 'include'))
 
 prec_map = {'float': 'f', 'double': '', 'long double': 'l'}
-compiler = ccompiler.new_compiler()
 
-libs = {}
-for d in ('float', 'double', 'long double'):
-    lib = 'fftw3'+prec_map[d]
-    if compiler.find_library_file(library_dirs, lib):
-        libs[d] = [lib]
-        tlib = '_'.join((lib, 'threads'))
-        if compiler.find_library_file(library_dirs, tlib):
-            libs[d].append(tlib)
-        if sys.platform in ('unix', 'darwin'):
-            libs[d].append('m')
+def get_fftw_libs():
+    """Return FFTW libraries"""
+    compiler = ccompiler.new_compiler()
+    libs = {}
+    for d in ('float', 'double', 'long double'):
+        lib = 'fftw3'+prec_map[d]
+        if compiler.find_library_file(library_dirs, lib):
+            libs[d] = [lib]
+            tlib = '_'.join((lib, 'threads'))
+            if compiler.find_library_file(library_dirs, tlib):
+                libs[d].append(tlib)
+            if sys.platform in ('unix', 'darwin'):
+                libs[d].append('m')
+    return libs
 
-# Generate files with float and long double if needed
-for d in ('float', 'long double'):
-    p = 'fftw'+prec_map[d]+'_'
-    for fl in ('fftw_planxfftn.h', 'fftw_planxfftn.c', 'fftw_xfftn.pyx', 'fftw_xfftn.pxd'):
-        fp = fl.replace('fftw_', p)
-        shutil.copy(os.path.join(fftwdir, fl), os.path.join(fftwdir, fp))
-        sedcmd = "sed -i ''" if sys.platform == 'darwin' else "sed -i''"
-        os.system(sedcmd + " 's/fftw_/{0}/g' {1}".format(p, os.path.join(fftwdir, fp)))
-        os.system(sedcmd + " 's/double/{0}/g' {1}".format(d, os.path.join(fftwdir, fp)))
+def generate_extensions(fftwlibs):
+    """Generate files with float and long double"""
+    for d in fftwlibs:
+        if d == 'double':
+            continue
+        p = 'fftw'+prec_map[d]+'_'
+        for fl in ('fftw_planxfftn.h', 'fftw_planxfftn.c', 'fftw_xfftn.pyx', 'fftw_xfftn.pxd'):
+            fp = fl.replace('fftw_', p)
+            shutil.copy(os.path.join(fftwdir, fl), os.path.join(fftwdir, fp))
+            sedcmd = "sed -i ''" if sys.platform == 'darwin' else "sed -i''"
+            os.system(sedcmd + " 's/fftw_/{0}/g' {1}".format(p, os.path.join(fftwdir, fp)))
+            os.system(sedcmd + " 's/double/{0}/g' {1}".format(d, os.path.join(fftwdir, fp)))
 
-ext = [Extension("mpi4py_fft.fftw.utilities",
-                 sources=[os.path.join(fftwdir, "utilities.pyx")],
-                 include_dirs=[get_include(),
-                               os.path.join(sys.prefix, 'include')])]
+def get_extensions(fftwlibs):
+    """Return list of extension modules"""
+    ext = [Extension("mpi4py_fft.fftw.utilities",
+                     sources=[os.path.join(fftwdir, "utilities.pyx")],
+                     include_dirs=include_dirs)]
 
-for d, v in six.iteritems(libs):
-    p = 'fftw'+prec_map[d]+'_'
-    ext.append(Extension("mpi4py_fft.fftw.{}xfftn".format(p),
-                         sources=[os.path.join(fftwdir, "{}xfftn.pyx".format(p)),
-                                  os.path.join(fftwdir, "{}planxfftn.c".format(p))],
-                         #define_macros=[('NPY_NO_DEPRECATED_API', 'NPY_1_7_API_VERSION')],
-                         libraries=v,
-                         include_dirs=include_dirs,
-                         library_dirs=library_dirs))
+    for d, libs in fftwlibs.items():
+        p = 'fftw'+prec_map[d]+'_'
+        ext.append(Extension("mpi4py_fft.fftw.{}xfftn".format(p),
+                             sources=[os.path.join(fftwdir, "{}xfftn.pyx".format(p)),
+                                      os.path.join(fftwdir, "{}planxfftn.c".format(p))],
+                             #define_macros=[('NPY_NO_DEPRECATED_API', 'NPY_1_7_API_VERSION')],
+                             libraries=libs,
+                             include_dirs=include_dirs,
+                             library_dirs=library_dirs))
+    return ext
 
+def version():
+    srcdir = os.path.join(cwd, 'mpi4py_fft')
+    with open(os.path.join(srcdir, '__init__.py')) as f:
+        m = re.search(r"__version__\s*=\s*'(.*)'", f.read())
+        return m.groups()[0]
+
+fftw_libs = get_fftw_libs()
+assert len(fftw_libs) > 0, "No FFTW libraries found!"
+generate_extensions(fftw_libs)
 with open("README.rst", "r") as fh:
     long_description = fh.read()
 
 setup(name="mpi4py-fft",
-      version="1.0.1",
+      version=version(),
       description="mpi4py-fft -- FFT with MPI",
       long_description=long_description,
       author="Lisandro Dalcin and Mikael Mortensen",
@@ -82,7 +100,7 @@
           'Topic :: Scientific/Engineering :: Mathematics',
           'Topic :: Software Development :: Libraries :: Python Modules',
           ],
-      ext_modules=ext,
-      install_requires=["mpi4py", "numpy", "six"],
-      setup_requires=["setuptools>=18.0", "cython>=0.25", "six"]
+      ext_modules=get_extensions(fftw_libs),
+      install_requires=["mpi4py", "numpy"],
+      setup_requires=["setuptools>=18.0", "cython>=0.25"]
       )

tests/test_fftw.py

@@ -1,6 +1,5 @@
 from __future__ import print_function
 from time import time
-import six
 import numpy as np
 from scipy.fftpack import dctn as scipy_dctn
 from scipy.fftpack import dstn as scipy_dstn
@@ -24,7 +23,7 @@
          'dct1': fftw.FFTW_REDFT00,
          'dst1': fftw.FFTW_RODFT00}
 
-rkinds = {val: key for key, val in six.iteritems(kinds)}
+rkinds = {val: key for key, val in kinds.items()}
 
 def allclose(a, b):
     atol = abstol[a.dtype.char.lower()]
@@ -123,11 +122,11 @@ def test_fftw():
                             kds = np.random.randint(3, 11, size=naxes) # get naxes random transforms
                             tsf = [rkinds[k] for k in kds]
                             T = fftw.get_planned_FFT(input_array, input_array.copy(), axes=axes,
-                                         kind=kds, threads=threads, flags=fflags)
+                                                     kind=kds, threads=threads, flags=fflags)
                             C = T(A)
                             TI = fftw.get_planned_FFT(input_array.copy(), input_array.copy(), axes=axes,
-                                          kind=list([fftw.inverse[kd] for kd in kds]),
-                                          threads=threads, flags=iflags)
+                                                      kind=list([fftw.inverse[kd] for kd in kds]),
+                                                      threads=threads, flags=iflags)
 
                             C2 = TI(C)
                             M = fftw.get_normalization(kds, input_array.shape, axes)