adjusted pylint hints; extended testing; adjusted workflows

Author: btschwertfeger

.github/workflows/python-package.yml

@@ -15,7 +15,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.7", "3.8", "3.9", "3.10"]
+        python-version: ["3.8", "3.9", "3.10"]
 
     steps:
       - uses: actions/checkout@v3
@@ -26,7 +26,7 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          python -m pip install flake8 pytest
+          python -m pip install flake8 pytest scikit-learn scipy
           if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
       - name: Lint with flake8
         run: |
@@ -36,4 +36,4 @@ jobs:
           flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
       - name: Test with pytest
         run: |
-          pytest
+          pytest cmethods/tests/testing.py

README.md

@@ -3,13 +3,16 @@
 <div align="center">
 
 [![GitHub](https://badgen.net/badge/icon/github?icon=github&label)](https://github.com/btschwertfeger/Bias-Adjustment-Python)
-[![Generic badge](https://img.shields.io/badge/python-3.7+-green.svg)](https://shields.io/)
+[![Generic badge](https://img.shields.io/badge/python-3.8+-green.svg)](https://shields.io/)
 [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-orange.svg)](https://www.gnu.org/licenses/gpl-3.0)
 [![Downloads](https://pepy.tech/badge/python-cmethods)](https://pepy.tech/project/python-cmethods)
 
+![ql-workflow](https://github.com/btschwertfeger/Bias-Adjustment-Python/actions/workflows/codeql.yml/badge.svg)
+![python-package](https://github.com/btschwertfeger/Bias-Adjustment-Python/actions/workflows/python-package.yml/badge.svg)
+
 </div>
 
-This Python module contains a collection of different scale- and distribution-based bias adjustment techniques for climatic research (see `examples.ipynb` for help).
+This Python module contains a collection of different scale- and distribution-based bias adjustment techniques for climatic research (see `/examples/examples.ipynb` for help).
 
 Since the Python programming language is very slow and bias adjustments are complex statistical transformations, it is recommended to use the C++ implementation on large data sets. This can be found [here](https://github.com/btschwertfeger/Bias-Adjustment-Cpp).
 
@@ -96,7 +99,7 @@ ls_result = cm.linear_scaling(
     obs = obsh['tas'][:,0,0],
     simh = simh['tas'][:,0,0],
     simp = simp['tas'][:,0,0],
-    kind = '+' # *
+    kind = '+'
 )
 
 qdm_result = cm.adjust_3d( # 3d = 2 spatial and 1 time dimension

cmethods/CMethods.py

@@ -1,2 +1,3 @@
+'''version of this module'''
 VERSION = (0,5,4,2)
 __version__ = '.'.join(map(str, VERSION))

cmethods/__version__.py

@@ -1,128 +1,204 @@
+'''Module to to test the bias adjustment methods'''
+import sys
+import logging
+from typing import List
 import numpy as np
 import xarray as xr
-import random
-
-import logging
-
-import sys
-sys.path.append('../../')
-from cmethods.CMethods import CMethods
-
-if True: # local space
-    import cmethods
-    print(cmethods.__file__)
-
-formatter = logging.Formatter(
-        fmt='%(asctime)s %(module)s,line: %(lineno)d %(levelname)8s | %(message)s',
-        datefmt='%Y-%m-%d %H:%M:%S' # %I:%M:%S %p AM|PM format
-    )
-
-logging.getLogger().setLevel(logging.INFO)
-screen_handler = logging.StreamHandler(stream=sys.stdout)
-screen_handler.setFormatter(formatter)
-logging.getLogger().addHandler(screen_handler)
-logging.getLogger().setLevel(logging.INFO)
-logging.getLogger('requests').setLevel(logging.WARNING)
-logging.getLogger('urllib3').setLevel(logging.WARNING)
-
-def main() -> None:
-    np.random.seed(0)
-    random.seed(0)
-
-    logging.info('Prepare data sets.')
+from sklearn.metrics import mean_squared_error
+
+try:
+    from cmethods.CMethods import CMethods
+except ModuleNotFoundError:
+    print('Using local module')
+    sys.path.append('/Users/benjamin/repositories/awi-workspace/Bias-Adjustment-Python')
+    from cmethods.CMethods import CMethods
+
+logging.basicConfig(
+    format='%(asctime)s %(module)s,line: %(lineno)d %(levelname)8s | %(message)s',
+    datefmt='%Y/%m/%d %H:%M:%S',
+    level=logging.INFO
+)
+
+def get_datasets():
     historical_time = xr.cftime_range('1971-01-01', '2000-12-31', freq='D', calendar='noleap')
     future_time = xr.cftime_range('2001-01-01', '2030-12-31', freq='D', calendar='noleap')
 
-    get_hist_temp_for_lat = lambda val: 273.15 - (val * np.cos(2 * np.pi * historical_time.dayofyear / 365) + 2 * np.random.random_sample((historical_time.size,)) + 273.15 + .1 * (historical_time - historical_time[0]).days / 365)
-    get_rand = lambda: np.random.rand() if np.random.rand() > .5 else  -np.random.rand()
+    def get_hist_temp_for_lat(lat: int) -> List[float]:
+        '''Returns a fake time seires by latitude value'''
+        return 273.15 - (
+            lat * np.cos(
+                2 * np.pi * historical_time.dayofyear / 365
+            ) + 2 * np.random.random_sample(
+                (historical_time.size,)
+            ) + 273.15 + .1 * (
+                historical_time - historical_time[0]
+            ).days / 365
+        )
+
     latitudes = np.arange(23,27,1)
     some_data = [get_hist_temp_for_lat(val) for val in latitudes]
     data = np.array([some_data, np.array(some_data)+1])
 
-    def get_dataset(data) -> xr.Dataset:
+    def get_dataset(data, time):
+        '''Returns a data set by data and time'''
         return xr.DataArray(
             data,
             dims=('lon', 'lat', 'time'),
-            coords={'time': historical_time, 'lat': latitudes, 'lon': [0,1]},
+            coords={'time': time, 'lat': latitudes, 'lon': [0,1]},
             attrs={'units': '°C'},
         ).transpose('time','lat','lon').to_dataset(name='tas')
 
 
-    obsh = get_dataset(data)
-    simh = get_dataset(data-2)
-    simp = get_dataset(data-1)
+    obsh = get_dataset(data, historical_time)
+    obsp = get_dataset(data+1, historical_time)
+    simh = get_dataset(data-2, historical_time)
+    simp = get_dataset(data-1, future_time)
+    return obsh, obsp, simh, simp
 
-    cm = CMethods()
 
+def test_linear_scaling() -> None:
+    '''Tests the linear scaling method'''
+    obsh, obsp, simh, simp = get_datasets()
     logging.info('Testing 1d-methods ...')
-    assert type(cm.linear_scaling(
+    ls_result = CMethods().linear_scaling(
         obs = obsh['tas'][:,0,0],
         simh = simh['tas'][:,0,0],
         simp = simp['tas'][:,0,0],
         kind = '+'
-    )) == xr.DataArray, 'Invalid return type!'
+    )
+    assert isinstance(ls_result, xr.core.dataarray.DataArray)
+    assert mean_squared_error(ls_result, obsp['tas'][:,0,0], squared=False) < mean_squared_error(simp['tas'][:,0,0], obsp['tas'][:,0,0], squared=False)
     logging.info('Linear Scaling done!')
-    assert type(cm.variance_scaling(
+
+
+def test_variance_scaling() -> None:
+    '''Tests the variance scaling method'''
+    obsh, obsp, simh, simp = get_datasets()
+    vs_result = CMethods().variance_scaling(
         obs = obsh['tas'][:,0,0],
         simh = simh['tas'][:,0,0],
         simp = simp['tas'][:,0,0],
         kind = '+'
-    )) == xr.DataArray, 'Invalid return type!'
+    )
+    assert isinstance(vs_result, xr.core.dataarray.DataArray)
+    assert mean_squared_error(
+            vs_result, obsp['tas'][:,0,0], squared=False
+        ) < mean_squared_error(
+            simp['tas'][:,0,0], obsp['tas'][:,0,0], squared=False
+        )
     logging.info('Variance Scaling done!')
 
-    assert type(cm.delta_method(
+def test_delta_method() -> None:
+    '''Tests the delta method'''
+    obsh, obsp, simh, simp = get_datasets()
+    dm_result = CMethods().delta_method(
         obs = obsh['tas'][:,0,0],
         simh = simh['tas'][:,0,0],
         simp = simp['tas'][:,0,0],
         kind = '+'
-    )) == xr.DataArray, 'Invalid return type!'
+    )
+    assert isinstance(dm_result, xr.core.dataarray.DataArray)
+    assert mean_squared_error(
+            dm_result, obsp['tas'][:,0,0], squared=False
+        ) < mean_squared_error(
+            simp['tas'][:,0,0], obsp['tas'][:,0,0], squared=False
+        )
     logging.info('Delta Method done!')
 
-    assert type(cm.quantile_mapping(
+def test_quantile_mapping() -> None:
+    '''Tests the quantile mapping method'''
+    obsh, obsp, simh, simp = get_datasets()
+    qm_result = CMethods().quantile_mapping(
         obs = obsh['tas'][:,0,0],
         simh = simh['tas'][:,0,0],
         simp = simp['tas'][:,0,0],
         n_quantiles=100,
         kind='+'
-    )) == xr.DataArray, 'Invalid return type!'
-
-    assert type(cm.quantile_delta_mapping(
+    )
+    assert isinstance(qm_result, xr.core.dataarray.DataArray)
+    assert mean_squared_error(
+            qm_result, obsp['tas'][:,0,0], squared=False
+        ) < mean_squared_error(
+            simp['tas'][:,0,0], obsp['tas'][:,0,0], squared=False
+        )
+    logging.info('Quantile Mapping done!')
+
+def test_quantile_delta_mapping() -> None:
+    '''Tests the quantile delta mapping method'''
+    obsh, obsp, simh, simp = get_datasets()
+    qdm_result = CMethods().quantile_delta_mapping(
         obs = obsh['tas'][:,0,0],
         simh = simh['tas'][:,0,0],
         simp = simp['tas'][:,0,0],
-         n_quantiles=100,
-         kind='+'
-    )) == xr.DataArray, 'Invalid return type!'
-    logging.info('Quantile Delta Mapping done!')
+        n_quantiles=100,
+        kind='+'
+    )
 
+    assert isinstance(qdm_result, xr.core.dataarray.DataArray)
+    assert mean_squared_error(
+            qdm_result, obsp['tas'][:,0,0], squared=False
+        ) < mean_squared_error(
+            simp['tas'][:,0,0], obsp['tas'][:,0,0], squared=False
+        )
+    logging.info('Quantile Delta Mapping done!')
 
-    logging.info('Testing 3d-methods')
 
-    for method in cm.SCALING_METHODS:
-        logging.info(f'Testing {method} ...') 
-        assert type(cm.adjust_3d(
-            method = method, 
-            obs = obsh['tas'], 
-            simh = simh['tas'], 
+def test_3d_sclaing_methods() -> None:
+    '''Tests the scaling based methods for 3-dimentsional data sets'''
+    obsh, obsp, simh, simp = get_datasets()
+    for method in CMethods().SCALING_METHODS:
+        logging.info(f'Testing {method} ...')
+        result = CMethods().adjust_3d(
+            method = method,
+            obs = obsh['tas'],
+            simh = simh['tas'],
             simp = simp['tas'],
             kind='+',
             goup='time.month'
-        )) == xr.DataArray
-        logging.info(f'{method} - success!') 
-
-    for method in cm.DISTRIBUTION_METHODS:
-        logging.info(f'Testing {method} ...') 
-        assert type(cm.adjust_3d(
-            method = method, 
-            obs = obsh['tas'], 
-            simh = simh['tas'], 
+        )
+        assert isinstance(result, xr.core.dataarray.DataArray)
+        for lat in range(len(obsh.lat)):
+            for lon in range(len(obsh.lon)):
+                assert mean_squared_error(
+                    result[:,lat,lon], obsp['tas'][:,lat,lon], squared=False
+                ) < mean_squared_error(
+                    simp['tas'][:,lat,lon], obsp['tas'][:,lat,lon], squared=False
+                )
+        logging.info(f'3d {method} - success!')
+
+def test_3d_distribution_methods() -> None:
+    '''Tests the distribution based methods for 3-dimentsional data sets'''
+    obsh, obsp, simh, simp = get_datasets()
+    for method in CMethods().DISTRIBUTION_METHODS:
+        logging.info(f'Testing {method} ...')
+        result = CMethods().adjust_3d(
+            method = method,
+            obs = obsh['tas'],
+            simh = simh['tas'],
             simp = simp['tas'],
             n_quantiles=100
-        )) == xr.DataArray
-        logging.info(f'{method} - success!') 
-    
+        )
+        assert isinstance(result, xr.core.dataarray.DataArray)
+        for lat in range(len(obsh.lat)):
+            for lon in range(len(obsh.lon)):
+                assert mean_squared_error(
+                    result[:,lat,lon], obsp['tas'][:,lat,lon], squared=False
+                ) < mean_squared_error(
+                    simp['tas'][:,lat,lon], obsp['tas'][:,lat,lon], squared=False
+                )
+        logging.info(f'3d {method} - success!')
+
+def main() -> None:
+    '''Main'''
 
+    test_linear_scaling()
+    test_variance_scaling()
+    test_delta_method()
+    test_quantile_mapping()
+    test_quantile_delta_mapping()
+    test_3d_sclaing_methods()
+    test_3d_distribution_methods()
 
 if __name__ == '__main__':
     main()
-    logging.info('Everything passed!')
+    logging.info('Everything passed!')

cmethods/requirements.txt

@@ -7,14 +7,14 @@ flake8 . --select=E9,F63,F7,F82 --show-source --statistics
 if [ $? -eq 0 ]; then 
     echo "flake 8 success"
 
-    pytest .
+    # pytest cmethods/tests/testing.py
 
-    if [ $? -eq 0 ]; then 
-        echo "pytest success"
+    # if [ $? -eq 0 ]; then 
+    #     echo "pytest success"
         exit 0
-    else 
-        exit 1
-    fi
+    # else 
+    #     exit 1
+    # fi
 else
     exit 1
 fi

cmethods/tests/testing.py

@@ -12,7 +12,7 @@
 URL = 'https://github.com/btschwertfeger/Bias-Adjustment-Python'
 EMAIL = 'development@b-schwertfeger.de'
 AUTHOR = 'Benjamin Thomas Schwertfeger'
-REQUIRES_PYTHON = '>=3.7.0'
+REQUIRES_PYTHON = '>=3.8.0'
 VERSION = None
 
 # What packages are required for this module to be executed?
@@ -23,6 +23,7 @@
 # What packages are optional?
 EXTRAS = {
     'working examples notebook': ['matplotlib'],
+    'tests': ['scikit-learn', 'scipy']
 }
 
 here = os.path.abspath(os.path.dirname(__file__))
@@ -124,7 +125,10 @@ def run(self):
         # Full list: https://pypi.python.org/pypi?%3Aaction=list_classifiers
         'License :: OSI Approved :: GNU General Public License v3 (GPLv3)',
         'Programming Language :: Python',
-        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Natural Language :: English',
+        'Operating System :: MacOS',
+        'Operating System :: Unix'
     ],
     cmdclass={
         'upload': UploadCommand,