Fix MissingOptionalDependency that was always thrown when pyfftw is not installed and also remove redundant utils.fft.get_method

Author: pulkkins

pysteps/cascade/decomposition.py

@@ -23,7 +23,7 @@
 """
 
 import numpy as np
-from .. utils import fft as fft_module
+from .. import utils
 
 def decomposition_fft(X, filter, **kwargs):
     """Decompose a 2d input field into multiple spatial scales by using the Fast
@@ -55,7 +55,7 @@ def decomposition_fft(X, filter, **kwargs):
     """
     fft = kwargs.get("fft_method", "numpy")
     if type(fft) == str:
-        fft,fft_kwargs = fft_module.get_method(fft)
+        fft,fft_kwargs = utils.get_method(fft)
     else:
         fft,fft_kwargs = fft
     MASK = kwargs.get("MASK", None)

pysteps/noise/fftgenerators.py

@@ -32,7 +32,7 @@
 import numpy as np
 from scipy import optimize
 from .. import utils
-from .. utils import fft as fft_module
+from .. import utils
 
 def initialize_param_2d_fft_filter(X, **kwargs):
     """Takes one ore more 2d input fields, fits two spectral slopes, beta1 and beta2,
@@ -88,7 +88,7 @@ def initialize_param_2d_fft_filter(X, **kwargs):
     doplot   = kwargs.get('doplot', False)
     fft = kwargs.get("fft_method", "numpy")
     if type(fft) == str:
-        fft,fft_kwargs = fft_module.get_method(fft)
+        fft,fft_kwargs = utils.get_method(fft)
     else:
         fft,fft_kwargs = fft
 
@@ -216,7 +216,7 @@ def initialize_nonparam_2d_fft_filter(X, **kwargs):
     use_full_fft = kwargs.get('use_full_fft', False)
     fft = kwargs.get("fft_method", "numpy")
     if type(fft) == str:
-        fft,fft_kwargs = fft_module.get_method(fft)
+        fft,fft_kwargs = utils.get_method(fft)
     else:
         fft,fft_kwargs = fft
 
@@ -295,10 +295,10 @@ def generate_noise_2d_fft_filter(F, randstate=np.random, seed=None, fft_method=N
         randstate.seed(seed)
 
     if fft_method is None:
-        fft,fft_kwargs = fft_module.get_method("numpy")
+        fft,fft_kwargs = utils.get_method("numpy")
     else:
         if type(fft_method) == str:
-            fft,fft_kwargs = fft_module.get_method(fft_method)
+            fft,fft_kwargs = utils.get_method(fft_method)
         else:
             fft,fft_kwargs = fft
 
@@ -379,7 +379,7 @@ def initialize_nonparam_2d_ssft_filter(X, **kwargs):
     rm_rdisc = kwargs.get('rm_disc', True)
     fft = kwargs.get("fft_method", "numpy")
     if type(fft) == str:
-        fft,fft_kwargs = fft_module.get_method(fft)
+        fft,fft_kwargs = utils.get_method(fft)
     else:
         fft,fft_kwargs = fft
 
@@ -492,7 +492,7 @@ def initialize_nonparam_2d_nested_filter(X, gridres=1.0, **kwargs):
     rm_rdisc  = kwargs.get('rm_disc', True)
     fft = kwargs.get("fft_method", "numpy")
     if type(fft) == str:
-        fft,fft_kwargs = fft_module.get_method(fft)
+        fft,fft_kwargs = utils.get_method(fft)
     else:
         fft,fft_kwargs = fft
 
@@ -623,7 +623,7 @@ def generate_noise_2d_ssft_filter(F, randstate=np.random, seed=None, **kwargs):
     win_type = kwargs.get('win_type', 'flat-hanning')
     fft = kwargs.get("fft_method", "numpy")
     if type(fft) == str:
-        fft,fft_kwargs = fft_module.get_method(fft)
+        fft,fft_kwargs = utils.get_method(fft)
     else:
         fft,fft_kwargs = fft
 

pysteps/utils/fft.py

@@ -3,46 +3,15 @@
 try:
     import pyfftw.interfaces.numpy_fft as pyfftw_fft
     import pyfftw
-    # TODO: Caching and multithreading are currently disabled because they give 
-    # a segfault with dask.
+    # TODO: Caching is currently disabled because it gives segfault with dask.
     pyfftw.interfaces.cache.disable()
     pyfftw_imported = True
 except ImportError:
     pyfftw_imported = False
 import scipy.fftpack as scipy_fft
 import numpy.fft as numpy_fft
 
-from pysteps.exceptions import MissingOptionalDependency
-
 # use numpy implementation of rfft2/irfft2 because they have not been
 # implemented in scipy.fftpack
 scipy_fft.rfft2  = numpy_fft.rfft2
 scipy_fft.irfft2 = numpy_fft.irfft2
-
-def get_method(name):
-    """Return a callable function for the FFT method corresponding to the given
-    name.
-    
-    Parameters
-    ----------
-    name : str
-        The name of the method. The available options are 'numpy', 'scipy' and 
-        'pyfftw'
-    
-    Returns
-    -------
-    out : tuple
-        A two-element tuple containing the FFT module and a dictionary of 
-        default keyword arguments for calling the FFT method. Each module 
-        implements the numpy.fft interface.
-    """
-    if name == "numpy":
-        return numpy_fft,{}
-    elif name == "scipy":
-        return scipy_fft,{}
-    elif name == "pyfftw":
-        if not pyfftw_imported:
-            raise MissingOptionalDependency("pyfftw is required but it is not installed")
-        return pyfftw_fft,{"threads":1, "planner_effort":"FFTW_ESTIMATE"}
-    else:
-        raise ValueError("unknown method %s, the available methods are 'numpy', 'scipy' and 'pyfftw'" % name)

pysteps/utils/interface.py

@@ -3,6 +3,7 @@
 from . import transformation
 from . import dimension
 from . import fft
+from pysteps.exceptions import MissingOptionalDependency
 
 def get_method(name):
     """Return a callable function for the utility method corresponding to the
@@ -97,13 +98,29 @@ def donothing(R, metadata, *args, **kwargs):
     methods_objects["square"]       = dimension.square_domain
     methods_objects["upscale"]      = dimension.aggregate_fields_space
     # FFT methods
-    methods_objects["numpy_fft"]    = fft.get_method("numpy")
-    methods_objects["scipy_fft"]    = fft.get_method("scipy")
-    methods_objects["pyfftw_fft"]   = fft.get_method("pyfftw")
+    methods_objects["numpy"]        = _get_fft_method("numpy")
+    methods_objects["scipy"]        = _get_fft_method("scipy")
 
     try:
-        return methods_objects[name]
+        if name == "pyfftw":
+            return _get_fft_method("pyfftw")
+        else:
+            return methods_objects[name]
 
     except KeyError as e:
         raise ValueError("Unknown method %s\n" % e +
                          "Supported methods:%s" % str(methods_objects.keys()))
+
+def _get_fft_method(name):
+    if name == "numpy":
+        return fft.numpy_fft,{}
+    elif name == "scipy":
+        return fft.scipy_fft,{}
+    elif name == "pyfftw":
+        if not fft.pyfftw_imported:
+            raise MissingOptionalDependency("pyfftw is required but it is not installed")
+        # TODO: Multithreading is currently disabled because it gives segfault
+        # with dask.
+        return fft.pyfftw_fft,{"threads":1, "planner_effort":"FFTW_ESTIMATE"}
+    else:
+        raise ValueError("unknown method %s, the available methods are 'numpy', 'scipy' and 'pyfftw'" % name)