Update get & comp info, add FOOOFDataInfo to consolidate appraoch to data

Author: TomDonoghue

fooof/core/io.py

@@ -89,7 +89,7 @@ def save_fm(fm, file_name, file_path=None, append=False,
     # Set and select which variables to keep. Use a set to drop any potential overlap
     #  Note that results also saves frequency information to be able to recreate freq vector
     attributes = get_obj_desc()
-    keep = set((attributes['results'] + attributes['freq_info'] if save_results else []) + \
+    keep = set((attributes['results'] + attributes['data_info'] if save_results else []) + \
                (attributes['settings'] if save_settings else []) + \
                (attributes['data'] if save_data else []))
     obj_dict = dict_select_keys(obj_dict, keep)

fooof/core/utils.py

@@ -114,7 +114,7 @@ def get_obj_desc():
                   'settings' : ['peak_width_limits', 'max_n_peaks', 'min_peak_amplitude',
                                 'peak_threshold', 'aperiodic_mode'],
                   'data' : ['power_spectrum', 'freq_range', 'freq_res'],
-                  'freq_info' : ['freq_range', 'freq_res'],
+                  'data_info' : ['freq_range', 'freq_res'],
                   'arrays' : ['freqs', 'power_spectrum', 'aperiodic_params_',
                               'peak_params_', '_gaussian_params']}
 

fooof/data.py

@@ -26,6 +26,20 @@
 """
 
 
+FOOOFDataInfo = namedtuple('FOOOFDataInfo', ['freq_range', 'freq_res'])
+
+FOOOFDataInfo.__doc__ = """\
+Data related information for a FOOOF object.
+
+Attributes
+----------
+freq_range : list of [float, float]
+    Frequency range of the power spectrum, as [lowest_freq, highest_freq].
+freq_res : float
+    Frequency resolution of the power spectrum.
+"""
+
+
 FOOOFResults = namedtuple('FOOOFResults', ['aperiodic_params', 'peak_params',
                                            'r_squared', 'error', 'gaussian_params'])
 FOOOFResults.__doc__ = """\

fooof/fit.py

@@ -46,7 +46,7 @@
 
 from fooof.plts.fm import plot_fm
 from fooof.utils import trim_spectrum
-from fooof.data import FOOOFResults, FOOOFSettings
+from fooof.data import FOOOFResults, FOOOFSettings, FOOOFDataInfo
 from fooof.synth.gen import gen_freqs, gen_aperiodic, gen_peaks
 
 ###################################################################################################
@@ -249,11 +249,8 @@ def add_settings(self, fooof_settings):
             An object containing the settings for a FOOOF model.
         """
 
-        self.aperiodic_mode = fooof_settings.aperiodic_mode
-        self.peak_width_limits = fooof_settings.peak_width_limits
-        self.max_n_peaks = fooof_settings.max_n_peaks
-        self.min_peak_amplitude = fooof_settings.min_peak_amplitude
-        self.peak_threshold = fooof_settings.peak_threshold
+        for setting in get_obj_desc()['settings']:
+            setattr(self, setting, getattr(fooof_settings, setting))
 
         self._check_loaded_settings(fooof_settings._asdict())
 
@@ -421,31 +418,40 @@ def print_report_issue(concise=False):
         print(gen_issue_str(concise))
 
 
-    def get_results(self):
-        """Return model fit parameters and goodness of fit metrics.
+    def get_settings(self):
+        """Return user defined settings of the FOOOF object.
 
         Returns
         -------
-        FOOOFResults
-            Object containing the FOOOF model fit results from the current FOOOF object.
+        FOOOFSettings
+            Object containing the settings from the current FOOOF object.
         """
 
-        return FOOOFResults(self.aperiodic_params_, self.peak_params_,
-                            self.r_squared_, self.error_, self._gaussian_params)
+        return FOOOFSettings(**{key : getattr(self, key) for key in get_obj_desc()['settings']})
 
 
-    def get_settings(self):
-        """Return user defined settings of the FOOOF object.
+    def get_data_info(self):
+        """Return data information from the FOOOF object.
 
         Returns
         -------
-        FOOOFSettings
-            Object containing the settings from the current FOOOF object.
+        FOOOFDataInfo
+            Object containing information about the data from the current FOOOF object.
+        """
+
+        return FOOOFDataInfo(**{key : getattr(self, key) for key in get_obj_desc()['data_info']})
+
+
+    def get_results(self):
+        """Return model fit parameters and goodness of fit metrics.
+
+        Returns
+        -------
+        FOOOFResults
+            Object containing the FOOOF model fit results from the current FOOOF object.
         """
 
-        return FOOOFSettings(self.peak_width_limits, self.max_n_peaks,
-                             self.min_peak_amplitude, self.peak_threshold,
-                             self.aperiodic_mode)
+        return FOOOFResults(**{key.strip('_') : getattr(self, key) for key in get_obj_desc()['results']})
 
 
     @copy_doc_func_to_method(plot_fm)

fooof/funcs.py

@@ -4,7 +4,7 @@
 
 from fooof import FOOOFGroup
 from fooof.synth.gen import gen_freqs
-from fooof.utils import get_settings, get_obj_desc, compare_settings, compare_data_info
+from fooof.utils import get_obj_desc, compare_info
 
 ###################################################################################################
 ###################################################################################################
@@ -24,12 +24,12 @@ def combine_fooofs(fooofs):
     """
 
     # Compare settings
-    if not compare_settings(fooofs) or not compare_data_info(fooofs):
+    if not compare_info(fooofs, 'settings') or not compare_info(fooofs, 'data_info'):
         raise ValueError("These objects have incompatible settings or data," \
                          "and so cannot be combined.")
 
     # Initialize FOOOFGroup object, with settings derived from input objects
-    fg = FOOOFGroup(**get_settings(fooofs[0]), verbose=fooofs[0].verbose)
+    fg = FOOOFGroup(*fooofs[0].get_settings(), verbose=fooofs[0].verbose)
     fg.power_spectra = np.empty([0, len(fooofs[0].freqs)])
 
     # Add FOOOF results from each FOOOF object to group
@@ -44,7 +44,7 @@ def combine_fooofs(fooofs):
             fg.power_spectra = np.vstack([fg.power_spectra, f_obj.power_spectrum])
 
     # Add data information information
-    for data_info in get_obj_desc()['freq_info']:
+    for data_info in get_obj_desc()['data_info']:
         setattr(fg, data_info, getattr(fooofs[0], data_info))
     fg.freqs = gen_freqs(fg.freq_range, fg.freq_res)
 

fooof/tests/test_fit.py

@@ -12,7 +12,7 @@
 import pkg_resources as pkg
 
 from fooof import FOOOF
-from fooof.data import FOOOFSettings, FOOOFResults
+from fooof.data import FOOOFSettings, FOOOFDataInfo, FOOOFResults
 from fooof.synth import gen_power_spectrum
 from fooof.core.utils import group_three, get_obj_desc
 
@@ -136,11 +136,13 @@ def test_adds():
 def test_gets(tfm):
     """Tests methods that return FOOOF data objects.
 
-    Checks: get_settings, get_results
+    Checks: get_settings, get_data_info, get_results
     """
 
     settings = tfm.get_settings()
     assert isinstance(settings, FOOOFSettings)
+    data_info = tfm.get_data_info()
+    assert isinstance(data_info, FOOOFDataInfo)
     results = tfm.get_results()
     assert isinstance(results, FOOOFResults)
 
@@ -152,10 +154,11 @@ def test_copy():
 
     assert tfm != ntfm
 
-def test_fooof_prints_get(tfm):
-    """Test methods that print, return results (alias and pass through methods).
+def test_fooof_prints(tfm):
+    """Test methods that print (alias and pass through methods).
 
-    Checks: print_settings, print_results, get_results, get_settings."""
+    Checks: print_settings, print_results.
+    """
 
     tfm.print_settings()
     tfm.print_results()

fooof/tests/test_funcs.py

@@ -4,7 +4,7 @@
 
 import numpy as np
 
-from fooof.utils import compare_settings
+from fooof.utils import compare_info
 from fooof.group import FOOOFGroup
 from fooof.synth import gen_group_power_spectra
 
@@ -23,39 +23,39 @@ def test_combine_fooofs(tfm, tfg):
     fg1 = combine_fooofs([tfm, tfm2])
     assert fg1
     assert len(fg1) == 2
-    assert compare_settings([fg1, tfm])
+    assert compare_info([fg1, tfm], 'settings')
     assert fg1.group_results[0] == tfm.get_results()
     assert fg1.group_results[-1] == tfm2.get_results()
 
     # Check combining 3 FOOOFs
     fg2 = combine_fooofs([tfm, tfm2, tfm3])
     assert fg2
     assert len(fg2) == 3
-    assert compare_settings([fg2, tfm])
+    assert compare_info([fg2, tfm], 'settings')
     assert fg2.group_results[0] == tfm.get_results()
     assert fg2.group_results[-1] == tfm3.get_results()
 
     # Check combining 2 FOOOFGroups
     nfg1 = combine_fooofs([tfg, tfg2])
     assert nfg1
     assert len(nfg1) == len(tfg) + len(tfg2)
-    assert compare_settings([nfg1, tfg, tfg2])
+    assert compare_info([nfg1, tfg, tfg2], 'settings')
     assert nfg1.group_results[0] == tfg.group_results[0]
     assert nfg1.group_results[-1] == tfg2.group_results[-1]
 
     # Check combining 3 FOOOFGroups
     nfg2 = combine_fooofs([tfg, tfg2, tfg3])
     assert nfg2
     assert len(nfg2) == len(tfg) + len(tfg2) + len(tfg3)
-    assert compare_settings([nfg2, tfg, tfg2, tfg3])
+    assert compare_info([nfg2, tfg, tfg2, tfg3], 'settings')
     assert nfg2.group_results[0] == tfg.group_results[0]
     assert nfg2.group_results[-1] == tfg3.group_results[-1]
 
     # Check combining a mixture of FOOOF & FOOOFGroup
     mfg3 = combine_fooofs([tfg, tfm, tfg2, tfm2])
     assert mfg3
     assert len(mfg3) == len(tfg) + 1 + len(tfg2) + 1
-    assert compare_settings([tfg, tfm, tfg2, tfm2])
+    assert compare_info([tfg, tfm, tfg2, tfm2], 'settings')
     assert mfg3.group_results[0] == tfg.group_results[0]
     assert mfg3.group_results[-1] == tfm2.get_results()
 

fooof/tests/test_utils.py

@@ -17,35 +17,23 @@ def test_trim_spectrum():
     assert np.array_equal(f_out, np.array([2., 3., 4.]))
     assert np.array_equal(p_out, np.array([3., 4., 5.]))
 
-def test_get_settings(tfm, tfg):
+def test_get_info(tfm, tfg):
 
     for f_obj in [tfm, tfg]:
-        assert get_settings(f_obj)
+        assert get_info(f_obj, 'settings')
+        assert get_info(f_obj, 'data_info')
 
-def test_get_data_info(tfm, tfg):
+def test_compare_info(tfm, tfg):
 
     for f_obj in [tfm, tfg]:
-        assert get_data_info(f_obj)
 
-def test_compare_settings(tfm, tfg):
-
-    for f_obj in [tfm, tfg]:
         f_obj2 = f_obj.copy()
 
-        assert compare_settings([f_obj, f_obj2])
-
+        assert compare_info([f_obj, f_obj2], 'settings')
         f_obj2.peak_width_limits = [2, 4]
         f_obj2._reset_internal_settings()
+        assert not compare_info([f_obj, f_obj2], 'settings')
 
-        assert not compare_settings([f_obj, f_obj2])
-
-def test_compare_data_info(tfm, tfg):
-
-    for f_obj in [tfm, tfg]:
-        f_obj2 = f_obj.copy()
-
-        assert compare_data_info([f_obj, f_obj2])
-
+        assert compare_info([f_obj, f_obj2], 'data_info')
         f_obj2.freq_range = [5, 25]
-
-        assert not compare_data_info([f_obj, f_obj2])
+        assert not compare_info([f_obj, f_obj2], 'data_info')