pvlib 0.9.5__py3-none-any.whl → 0.10.0__py3-none-any.whl

pvlib/tests/iotools/test_acis.py

@@ -0,0 +1,213 @@
+"""
+tests for :mod:`pvlib.iotools.acis`
+"""
+
+import pandas as pd
+import numpy as np
+import pytest
+from pvlib.iotools import (
+    get_acis_prism, get_acis_nrcc, get_acis_mpe,
+    get_acis_station_data, get_acis_available_stations
+)
+from ..conftest import RERUNS, RERUNS_DELAY, assert_frame_equal
+from requests import HTTPError
+
+
+@pytest.mark.remote_data
+@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
+def test_get_acis_prism():
+    # map_variables=True
+    df, meta = get_acis_prism(40.001, -80.001, '2020-01-01', '2020-01-02')
+    expected = pd.DataFrame(
+        [
+            [0.5, 5, 0, 2.5, 0, 62, 0],
+            [0, 5, -3, 1, 0, 64, 0]
+        ],
+        columns=['precipitation', 'temp_air_max', 'temp_air_min',
+                 'temp_air_average', 'cooling_degree_days',
+                 'heating_degree_days', 'growing_degree_days'],
+        index=pd.to_datetime(['2020-01-01', '2020-01-02']),
+    )
+    assert_frame_equal(df, expected)
+    expected_meta = {'latitude': 40, 'longitude': -80, 'altitude': 298.0944}
+    assert meta == expected_meta
+
+    # map_variables=False
+    df, meta = get_acis_prism(40.001, -80.001, '2020-01-01', '2020-01-02',
+                              map_variables=False)
+    expected.columns = ['pcpn', 'maxt', 'mint', 'avgt', 'cdd', 'hdd', 'gdd']
+    assert_frame_equal(df, expected)
+    expected_meta = {'lat': 40, 'lon': -80, 'elev': 298.0944}
+    assert meta == expected_meta
+
+
+@pytest.mark.remote_data
+@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
+@pytest.mark.parametrize('grid, expected', [
+    (1, [[0.51, 5, 0, 2.5, 0, 62, 0]]),
+    (3, [[0.51, 5, -1, 2.0, 0, 63, 0]])
+])
+def test_get_acis_nrcc(grid, expected):
+    # map_variables=True
+    df, meta = get_acis_nrcc(40.001, -80.001, '2020-01-01', '2020-01-01', grid)
+    expected = pd.DataFrame(
+        expected,
+        columns=['precipitation', 'temp_air_max', 'temp_air_min',
+                 'temp_air_average', 'cooling_degree_days',
+                 'heating_degree_days', 'growing_degree_days'],
+        index=pd.to_datetime(['2020-01-01']),
+    )
+    assert_frame_equal(df, expected)
+    expected_meta = {'latitude': 40., 'longitude': -80., 'altitude': 356.9208}
+    assert meta == pytest.approx(expected_meta)
+
+    # map_variables=False
+    df, meta = get_acis_nrcc(40.001, -80.001, '2020-01-01', '2020-01-01', grid,
+                             map_variables=False)
+    expected.columns = ['pcpn', 'maxt', 'mint', 'avgt', 'cdd', 'hdd', 'gdd']
+    assert_frame_equal(df, expected)
+    expected_meta = {'lat': 40., 'lon': -80., 'elev': 356.9208}
+    assert meta == pytest.approx(expected_meta)
+
+
+@pytest.mark.remote_data
+@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
+def test_get_acis_nrcc_error():
+    with pytest.raises(HTTPError, match='invalid grid'):
+        # 50 is not a valid dataset (or "grid", in ACIS lingo)
+        _ = get_acis_nrcc(40, -80, '2012-01-01', '2012-01-01', 50)
+
+
+@pytest.mark.remote_data
+@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
+def test_get_acis_mpe():
+    # map_variables=True
+    df, meta = get_acis_mpe(40.001, -80.001, '2020-01-01', '2020-01-02')
+    expected = pd.DataFrame(
+        {'precipitation': [0.4, 0.0]},
+        index=pd.to_datetime(['2020-01-01', '2020-01-02']),
+    )
+    assert_frame_equal(df, expected)
+    expected_meta = {'latitude': 40.0083, 'longitude': -79.9653}
+    assert meta == expected_meta
+
+    # map_variables=False
+    df, meta = get_acis_mpe(40.001, -80.001, '2020-01-01', '2020-01-02',
+                            map_variables=False)
+    expected.columns = ['pcpn']
+    assert_frame_equal(df, expected)
+    expected_meta = {'lat': 40.0083, 'lon': -79.9653}
+    assert meta == expected_meta
+
+
+@pytest.mark.remote_data
+@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
+def test_get_acis_station_data():
+    # map_variables=True
+    df, meta = get_acis_station_data('ORD', '2020-01-10', '2020-01-12',
+                                     trace_val=-99)
+    expected = pd.DataFrame(
+        [[10., 2., 6., np.nan, 21.34, 0., 0., 0., 59., 0.],
+         [3., -4., -0.5, np.nan, 9.4, 5.3, 0., 0., 65., 0.],
+         [-1., -5., -3., np.nan, -99, -99, 5., 0., 68., 0.]],
+        columns=['temp_air_max', 'temp_air_min', 'temp_air_average',
+                 'temp_air_observation', 'precipitation', 'snowfall',
+                 'snowdepth', 'cooling_degree_days',
+                 'heating_degree_days', 'growing_degree_days'],
+        index=pd.to_datetime(['2020-01-10', '2020-01-11', '2020-01-12']),
+    )
+    assert_frame_equal(df, expected)
+    expected_meta = {
+        'uid': 48,
+        'state': 'IL',
+        'name': 'CHICAGO OHARE INTL AP',
+        'altitude': 204.8256,
+        'latitude': 41.96017,
+        'longitude': -87.93164
+    }
+    expected_meta = {
+        'valid_daterange': [
+            ['1958-11-01', '2023-06-15'],
+            ['1958-11-01', '2023-06-15'],
+            ['1958-11-01', '2023-06-15'],
+            [],
+            ['1958-11-01', '2023-06-15'],
+            ['1958-11-01', '2023-06-15'],
+            ['1958-11-01', '2023-06-15'],
+            ['1958-11-01', '2023-06-15'],
+            ['1958-11-01', '2023-06-15'],
+            ['1958-11-01', '2023-06-15']
+        ],
+        'name': 'CHICAGO OHARE INTL AP',
+        'sids': ['94846 1', '111549 2', 'ORD 3', '72530 4', 'KORD 5',
+                 'USW00094846 6', 'ORD 7', 'USW00094846 32'],
+        'county': '17031',
+        'state': 'IL',
+        'climdiv': 'IL02',
+        'uid': 48,
+        'tzo': -6.0,
+        'sid_dates': [
+            ['94846 1', '1989-01-19', '9999-12-31'],
+            ['94846 1', '1958-10-30', '1989-01-01'],
+            ['111549 2', '1989-01-19', '9999-12-31'],
+            ['111549 2', '1958-10-30', '1989-01-01'],
+            ['ORD 3', '1989-01-19', '9999-12-31'],
+            ['ORD 3', '1958-10-30', '1989-01-01'],
+            ['72530 4', '1989-01-19', '9999-12-31'],
+            ['72530 4', '1958-10-30', '1989-01-01'],
+            ['KORD 5', '1989-01-19', '9999-12-31'],
+            ['KORD 5', '1958-10-30', '1989-01-01'],
+            ['USW00094846 6', '1989-01-19', '9999-12-31'],
+            ['USW00094846 6', '1958-10-30', '1989-01-01'],
+            ['ORD 7', '1989-01-19', '9999-12-31'],
+            ['ORD 7', '1958-10-30', '1989-01-01'],
+            ['USW00094846 32', '1989-01-19', '9999-12-31'],
+            ['USW00094846 32', '1958-10-30', '1989-01-01']],
+        'altitude': 204.8256,
+        'longitude': -87.93164,
+        'latitude': 41.96017
+    }
+    # don't check valid dates since they get extended every day
+    meta.pop("valid_daterange")
+    expected_meta.pop("valid_daterange")
+    assert meta == expected_meta
+
+    # map_variables=False
+    df, meta = get_acis_station_data('ORD', '2020-01-10', '2020-01-12',
+                                     trace_val=-99, map_variables=False)
+    expected.columns = ['maxt', 'mint', 'avgt', 'obst', 'pcpn', 'snow',
+                        'snwd', 'cdd', 'hdd', 'gdd']
+    assert_frame_equal(df, expected)
+    expected_meta['lat'] = expected_meta.pop('latitude')
+    expected_meta['lon'] = expected_meta.pop('longitude')
+    expected_meta['elev'] = expected_meta.pop('altitude')
+    meta.pop("valid_daterange")
+    assert meta == expected_meta
+
+
+@pytest.mark.remote_data
+@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
+def test_get_acis_available_stations():
+    # use a very narrow bounding box to hopefully make this test less likely
+    # to fail due to new stations being added in the future
+    lat, lon = 39.8986, -80.1656
+    stations = get_acis_available_stations([lat - 0.0001, lat + 0.0001],
+                                           [lon - 0.0001, lon + 0.0001])
+    assert len(stations) == 1
+    station = stations.iloc[0]
+
+    # test the more relevant values
+    assert station['name'] == 'WAYNESBURG 1 E'
+    assert station['sids'] == ['369367 2', 'USC00369367 6', 'WYNP1 7']
+    assert station['state'] == 'PA'
+    assert station['altitude'] == 940.
+    assert station['tzo'] == -5.0
+    assert station['latitude'] == lat
+    assert station['longitude'] == lon
+
+    # check that start/end work as filters
+    stations = get_acis_available_stations([lat - 0.0001, lat + 0.0001],
+                                           [lon - 0.0001, lon + 0.0001],
+                                           start='1900-01-01',
+                                           end='1900-01-02')
+    assert stations.empty

pvlib/tests/iotools/test_midc.py

@@ -27,9 +27,9 @@ MIDC_RAW_SHORT_HEADER_TESTFILE = (
 #                          '?site=UAT&begin=20181018&end=20181019')
 
 
-def test_midc_format_index():
+def test_midc__format_index():
     data = pd.read_csv(MIDC_TESTFILE)
-    data = midc.format_index(data)
+    data = midc._format_index(data)
     start = pd.Timestamp("20181014 00:00")
     start = start.tz_localize("MST")
     end = pd.Timestamp("20181014 23:59")
@@ -39,16 +39,16 @@ def test_midc_format_index():
     assert data.index[-1] == end
 
 
-def test_midc_format_index_tz_conversion():
+def test_midc__format_index_tz_conversion():
     data = pd.read_csv(MIDC_TESTFILE)
     data = data.rename(columns={'MST': 'PST'})
-    data = midc.format_index(data)
+    data = midc._format_index(data)
     assert data.index[0].tz == pytz.timezone('Etc/GMT+8')
 
 
-def test_midc_format_index_raw():
+def test_midc__format_index_raw():
     data = pd.read_csv(MIDC_RAW_TESTFILE)
-    data = midc.format_index_raw(data)
+    data = midc._format_index_raw(data)
     start = pd.Timestamp('20181018 00:00')
     start = start.tz_localize('MST')
     end = pd.Timestamp('20181018 23:59')

pvlib/tests/iotools/test_psm3.py

@@ -170,11 +170,11 @@ def test_read_psm3():
 def test_read_psm3_map_variables():
     """test read_psm3 map_variables=True"""
     data, metadata = psm3.read_psm3(MANUAL_TEST_DATA, map_variables=True)
-    columns_mapped = ['Year', 'Month', 'Day', 'Hour', 'Minute', 'dhi', 'dni',
-                      'ghi', 'dhi_clear', 'dni_clear', 'ghi_clear',
+    columns_mapped = ['Year', 'Month', 'Day', 'Hour', 'Minute', 'dhi', 'ghi',
+                      'dni', 'ghi_clear', 'dhi_clear', 'dni_clear',
                       'Cloud Type', 'Dew Point', 'solar_zenith',
                       'Fill Flag', 'albedo', 'wind_speed',
-                      'precipitable_water', 'wind_direction',
+                      'wind_direction', 'precipitable_water',
                       'relative_humidity', 'temp_air', 'pressure']
     data, metadata = psm3.read_psm3(MANUAL_TEST_DATA, map_variables=True)
     assert_index_equal(data.columns, pd.Index(columns_mapped))

pvlib/tests/iotools/test_pvgis.py

@@ -9,8 +9,9 @@ import pytest
 import requests
 from pvlib.iotools import get_pvgis_tmy, read_pvgis_tmy
 from pvlib.iotools import get_pvgis_hourly, read_pvgis_hourly
+from pvlib.iotools import get_pvgis_horizon
 from ..conftest import (DATA_DIR, RERUNS, RERUNS_DELAY, assert_frame_equal,
-                        fail_on_pvlib_version)
+                        fail_on_pvlib_version, assert_series_equal)
 from pvlib._deprecation import pvlibDeprecationWarning
 
 
@@ -206,14 +207,14 @@ def test_read_pvgis_hourly_bad_extension():
 
 
 args_radiation_csv = {
-    'surface_tilt': 30, 'surface_azimuth': 0, 'outputformat': 'csv',
+    'surface_tilt': 30, 'surface_azimuth': 180, 'outputformat': 'csv',
     'usehorizon': False, 'userhorizon': None, 'raddatabase': 'PVGIS-SARAH',
     'start': 2016, 'end': 2016, 'pvcalculation': False, 'components': True}
 
 url_hourly_radiation_csv = 'https://re.jrc.ec.europa.eu/api/seriescalc?lat=45&lon=8&outputformat=csv&angle=30&aspect=0&usehorizon=0&pvtechchoice=crystSi&mountingplace=free&trackingtype=0&components=1&raddatabase=PVGIS-SARAH&startyear=2016&endyear=2016'  # noqa: E501
 
 args_pv_json = {
-    'surface_tilt': 30, 'surface_azimuth': 0, 'outputformat': 'json',
+    'surface_tilt': 30, 'surface_azimuth': 180, 'outputformat': 'json',
     'usehorizon': True, 'userhorizon': None, 'raddatabase': 'PVGIS-SARAH2',
     'start': pd.Timestamp(2013, 1, 1), 'end': pd.Timestamp(2014, 5, 1),
     'pvcalculation': True, 'peakpower': 10, 'pvtechchoice': 'CIS', 'loss': 5,
@@ -364,17 +365,6 @@ def pvgis_tmy_mapped_columns():
             'wind_speed', 'wind_direction', 'pressure']
 
 
-@fail_on_pvlib_version('0.10')
-@pytest.mark.remote_data
-@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
-def test_pvgis_tmy_variable_map_deprecating_warning_0_10():
-    with pytest.warns(pvlibDeprecationWarning, match='names will be renamed'):
-        _ = get_pvgis_tmy(45, 8)
-    with pytest.warns(pvlibDeprecationWarning, match='names will be renamed'):
-        fn = DATA_DIR / 'tmy_45.000_8.000_2005_2016.epw'
-        _ = read_pvgis_tmy(fn)
-
-
 @pytest.mark.remote_data
 @pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
 def test_get_pvgis_tmy(expected, month_year_expected, inputs_expected,
@@ -509,6 +499,23 @@ def test_get_pvgis_map_variables(pvgis_tmy_mapped_columns):
     assert all([c in pvgis_tmy_mapped_columns for c in actual.columns])
 
 
+@pytest.mark.remote_data
+@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
+def test_read_pvgis_horizon():
+    pvgis_data, _ = get_pvgis_horizon(35.171051, -106.465158)
+    horizon_data = pd.read_csv(DATA_DIR / 'test_read_pvgis_horizon.csv',
+                               index_col=0)
+    horizon_data = horizon_data['horizon_elevation']
+    assert_series_equal(pvgis_data, horizon_data)
+
+
+@pytest.mark.remote_data
+@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
+def test_read_pvgis_horizon_invalid_coords():
+    with pytest.raises(requests.HTTPError, match='lat: Incorrect value'):
+        _, _ = get_pvgis_horizon(100, 50)  # unfeasible latitude
+
+
 def test_read_pvgis_tmy_map_variables(pvgis_tmy_mapped_columns):
     fn = DATA_DIR / 'tmy_45.000_8.000_2005_2016.json'
     actual, _, _, _ = read_pvgis_tmy(fn, map_variables=True)

pvlib/tests/iotools/test_sodapro.py

@@ -209,7 +209,7 @@ def test_get_cams(requests_mock, testfile, index, columns, values, dtypes,
         mock_response = test_file.read()
     # Specify the full URI of a specific example, this ensures that all of the
     # inputs are passing on correctly
-    url_test_cams = f'https://www.soda-is.com/service/wps?DataInputs=latitude=55.7906;longitude=12.5251;altitude=80;date_begin=2020-01-01;date_end=2020-05-04;time_ref=UT;summarization=P01M;username=pvlib-admin%2540googlegroups.com;verbose=false&Service=WPS&Request=Execute&Identifier=get_{identifier}&version=1.0.0&RawDataOutput=irradiation'  # noqa: E501
+    url_test_cams = f'https://api.soda-solardata.com/service/wps?DataInputs=latitude=55.7906;longitude=12.5251;altitude=80;date_begin=2020-01-01;date_end=2020-05-04;time_ref=UT;summarization=P01M;username=pvlib-admin%2540googlegroups.com;verbose=false&Service=WPS&Request=Execute&Identifier=get_{identifier}&version=1.0.0&RawDataOutput=irradiation'  # noqa: E501
 
     requests_mock.get(url_test_cams, text=mock_response,
                       headers={'Content-Type': 'application/csv'})

pvlib/tests/iotools/test_srml.py

@@ -3,7 +3,9 @@ import pandas as pd
 import pytest
 
 from pvlib.iotools import srml
-from ..conftest import DATA_DIR, RERUNS, RERUNS_DELAY
+from ..conftest import (DATA_DIR, RERUNS, RERUNS_DELAY, assert_index_equal,
+                        assert_frame_equal, fail_on_pvlib_version)
+from pvlib._deprecation import pvlibDeprecationWarning
 
 srml_testfile = DATA_DIR / 'SRML-day-EUPO1801.txt'
 
@@ -28,6 +30,16 @@ def test_read_srml_columns_exist():
     assert '7008_flag' in data.columns
 
 
+def test_read_srml_map_variables_false():
+    data = srml.read_srml(srml_testfile, map_variables=False)
+    assert '1000' in data.columns
+    assert '1000_flag' in data.columns
+    assert '2010' in data.columns
+    assert '2010_flag' in data.columns
+    assert '7008' in data.columns
+    assert '7008_flag' in data.columns
+
+
 def test_read_srml_nans_exist():
     data = srml.read_srml(srml_testfile)
     assert isnan(data['dni_0'][1119])
@@ -60,23 +72,37 @@ def test_read_srml_dt_index(url, year, month):
     ('2001', '2001'),
     ('2017', 'dni_7')
 ])
-def test_map_columns(column, expected):
-    assert srml.map_columns(column) == expected
+def test__map_columns(column, expected):
+    assert srml._map_columns(column) == expected
 
 
+@pytest.mark.remote_data
+@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
+def test_get_srml():
+    url = 'http://solardat.uoregon.edu/download/Archive/EUPO1801.txt'
+    file_data = srml.read_srml(url)
+    requested, _ = srml.get_srml(station='EU', start='2018-01-01',
+                                 end='2018-01-31')
+    assert_frame_equal(file_data, requested)
+
+
+@fail_on_pvlib_version('0.11')
 @pytest.mark.remote_data
 @pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
 def test_read_srml_month_from_solardat():
     url = 'http://solardat.uoregon.edu/download/Archive/EUPO1801.txt'
     file_data = srml.read_srml(url)
-    requested = srml.read_srml_month_from_solardat('EU', 2018, 1)
+    with pytest.warns(pvlibDeprecationWarning, match='get_srml instead'):
+        requested = srml.read_srml_month_from_solardat('EU', 2018, 1)
     assert file_data.equals(requested)
 
 
+@fail_on_pvlib_version('0.11')
 @pytest.mark.remote_data
 @pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
 def test_15_minute_dt_index():
-    data = srml.read_srml_month_from_solardat('TW', 2019, 4, 'RQ')
+    with pytest.warns(pvlibDeprecationWarning, match='get_srml instead'):
+        data = srml.read_srml_month_from_solardat('TW', 2019, 4, 'RQ')
     start = pd.Timestamp('20190401 00:00')
     start = start.tz_localize('Etc/GMT+8')
     end = pd.Timestamp('20190430 23:45')
@@ -86,10 +112,12 @@ def test_15_minute_dt_index():
     assert (data.index[3::4].minute == 45).all()
 
 
+@fail_on_pvlib_version('0.11')
 @pytest.mark.remote_data
 @pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
 def test_hourly_dt_index():
-    data = srml.read_srml_month_from_solardat('CD', 1986, 4, 'PH')
+    with pytest.warns(pvlibDeprecationWarning, match='get_srml instead'):
+        data = srml.read_srml_month_from_solardat('CD', 1986, 4, 'PH')
     start = pd.Timestamp('19860401 00:00')
     start = start.tz_localize('Etc/GMT+8')
     end = pd.Timestamp('19860430 23:00')
@@ -97,3 +125,40 @@ def test_hourly_dt_index():
     assert data.index[0] == start
     assert data.index[-1] == end
     assert (data.index.minute == 0).all()
+
+
+@pytest.mark.remote_data
+@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
+def test_get_srml_hourly():
+    data, meta = data, meta = srml.get_srml(station='CD', start='1986-04-01',
+                                            end='1986-05-31', filetype='PH')
+    expected_index = pd.date_range(start='1986-04-01', end='1986-05-31 23:59',
+                                   freq='1h', tz='Etc/GMT+8')
+    assert_index_equal(data.index, expected_index)
+
+
+@pytest.mark.remote_data
+@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
+def test_get_srml_minute():
+    data_read = srml.read_srml(srml_testfile)
+    data_get, meta = srml.get_srml(station='EU', start='2018-01-01',
+                                   end='2018-01-31', filetype='PO')
+    expected_index = pd.date_range(start='2018-01-01', end='2018-01-31 23:59',
+                                   freq='1min', tz='Etc/GMT+8')
+    assert_index_equal(data_get.index, expected_index)
+    assert all([c in data_get.columns for c in data_read.columns])
+    # Check that all indices in example file are present in remote file
+    assert data_read.index.isin(data_get.index).all()
+    assert meta['station'] == 'EU'
+    assert meta['filetype'] == 'PO'
+    assert meta['filenames'] == ['EUPO1801.txt']
+
+
+@pytest.mark.remote_data
+@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
+def test_get_srml_nonexisting_month_warning():
+    with pytest.warns(UserWarning, match='file was not found: EUPO0912.txt'):
+        # Request data for a period where not all files exist
+        # Eugene (EU) station started reporting 1-minute data in January 2010
+        data, meta = data, meta = srml.get_srml(
+            station='EU', start='2009-12-01', end='2010-01-31', filetype='PO')

pvlib/tests/iotools/test_tmy.py

@@ -1,8 +1,10 @@
 import numpy as np
 import pandas as pd
 from pvlib.iotools import tmy
+from pvlib._deprecation import pvlibDeprecationWarning
 from ..conftest import DATA_DIR
 import pytest
+import warnings
 
 # test the API works
 from pvlib.iotools import read_tmy3
@@ -16,29 +18,60 @@ TMY3_SOLARANYWHERE = DATA_DIR / 'Burlington, United States SolarAnywhere Time Se
 
 
 def test_read_tmy3():
-    tmy.read_tmy3(TMY3_TESTFILE)
+    tmy.read_tmy3(TMY3_TESTFILE, map_variables=False)
 
 
 def test_read_tmy3_recolumn():
-    data, meta = tmy.read_tmy3(TMY3_TESTFILE)
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        data, meta = tmy.read_tmy3(TMY3_TESTFILE, recolumn=True)
     assert 'GHISource' in data.columns
 
 
 def test_read_tmy3_norecolumn():
-    data, _ = tmy.read_tmy3(TMY3_TESTFILE, recolumn=False)
+    data, _ = tmy.read_tmy3(TMY3_TESTFILE, map_variables=False)
     assert 'GHI source' in data.columns
 
 
+def test_read_tmy3_raise_valueerror():
+    with pytest.raises(ValueError, match='`map_variables` and `recolumn`'):
+        _ = tmy.read_tmy3(TMY3_TESTFILE, recolumn=True, map_variables=True)
+
+
+def test_read_tmy3_map_variables():
+    data, meta = tmy.read_tmy3(TMY3_TESTFILE, map_variables=True)
+    assert 'ghi' in data.columns
+    assert 'dni' in data.columns
+    assert 'dhi' in data.columns
+    assert 'pressure' in data.columns
+    assert 'wind_direction' in data.columns
+    assert 'wind_speed' in data.columns
+    assert 'temp_air' in data.columns
+    assert 'temp_dew' in data.columns
+    assert 'relative_humidity' in data.columns
+    assert 'albedo' in data.columns
+    assert 'ghi_extra' in data.columns
+    assert 'dni_extra' in data.columns
+    assert 'precipitable_water' in data.columns
+
+
+def test_read_tmy3_map_variables_deprecating_warning():
+    with pytest.warns(pvlibDeprecationWarning, match='names will be renamed'):
+        data, meta = tmy.read_tmy3(TMY3_TESTFILE)
+
+
 def test_read_tmy3_coerce_year():
     coerce_year = 1987
-    data, _ = tmy.read_tmy3(TMY3_TESTFILE, coerce_year=coerce_year)
+    data, _ = tmy.read_tmy3(TMY3_TESTFILE, coerce_year=coerce_year,
+                            map_variables=False)
     assert (data.index[:-1].year == 1987).all()
     assert data.index[-1].year == 1988
 
 
 def test_read_tmy3_no_coerce_year():
     coerce_year = None
-    data, _ = tmy.read_tmy3(TMY3_TESTFILE, coerce_year=coerce_year)
+    data, _ = tmy.read_tmy3(TMY3_TESTFILE, coerce_year=coerce_year,
+                            map_variables=False)
     assert 1997 and 1999 in data.index.year
     assert data.index[-2] == pd.Timestamp('1998-12-31 23:00:00-09:00')
     assert data.index[-1] == pd.Timestamp('1999-01-01 00:00:00-09:00')
@@ -50,7 +83,7 @@ def test_read_tmy2():
 
 def test_gh865_read_tmy3_feb_leapyear_hr24():
     """correctly parse the 24th hour if the tmy3 file has a leap year in feb"""
-    data, meta = read_tmy3(TMY3_FEB_LEAPYEAR)
+    data, meta = read_tmy3(TMY3_FEB_LEAPYEAR, map_variables=False)
     # just to be safe, make sure this _IS_ the Greensboro file
     greensboro = {
         'USAF': 723170,
@@ -66,7 +99,8 @@ def test_gh865_read_tmy3_feb_leapyear_hr24():
     assert data.index[1414] == pd.Timestamp('1996-02-28 23:00:00-0500')
     assert data.index[1415] == pd.Timestamp('1996-03-01 00:00:00-0500')
     # now check if it parses correctly when we try to coerce the year
-    data, _ = read_tmy3(TMY3_FEB_LEAPYEAR, coerce_year=1990)
+    data, _ = read_tmy3(TMY3_FEB_LEAPYEAR, coerce_year=1990,
+                        map_variables=False)
     # if get's here w/o an error, then gh865 is fixed, but let's check anyway
     assert all(data.index[:-1].year == 1990)
     assert data.index[-1].year == 1991
@@ -87,7 +121,8 @@ def test_solaranywhere_tmy3(solaranywhere_index):
     # The SolarAnywhere TMY3 format specifies midnight as 00:00 whereas the
     # NREL TMY3 format utilizes 24:00. The SolarAnywhere file is therefore
     # included to test files with  00:00 timestamps are parsed correctly
-    data, meta = tmy.read_tmy3(TMY3_SOLARANYWHERE)
+    data, meta = tmy.read_tmy3(TMY3_SOLARANYWHERE, encoding='iso-8859-1',
+                               map_variables=False)
     pd.testing.assert_index_equal(data.index, solaranywhere_index)
     assert meta['USAF'] == 0
     assert meta['Name'] == 'Burlington  United States'

pvlib/tests/ivtools/test_sde.py

@@ -2,6 +2,7 @@ import numpy as np
 import pytest
 from pvlib import pvsystem
 from pvlib.ivtools import sde
+from pvlib._deprecation import pvlibDeprecationWarning
 
 
 @pytest.fixture
@@ -11,31 +12,32 @@ def get_test_iv_params():
 
 def test_fit_sandia_simple(get_test_iv_params, get_bad_iv_curves):
     test_params = get_test_iv_params
-    testcurve = pvsystem.singlediode(photocurrent=test_params['IL'],
-                                     saturation_current=test_params['I0'],
-                                     resistance_shunt=test_params['Rsh'],
-                                     resistance_series=test_params['Rs'],
-                                     nNsVth=test_params['nNsVth'],
-                                     ivcurve_pnts=300)
-    expected = tuple(test_params[k] for k in ['IL', 'I0', 'Rs', 'Rsh',
-                     'nNsVth'])
-    result = sde.fit_sandia_simple(voltage=testcurve['v'],
-                                   current=testcurve['i'])
+    test_params = dict(photocurrent=test_params['IL'],
+                       saturation_current=test_params['I0'],
+                       resistance_series=test_params['Rs'],
+                       resistance_shunt=test_params['Rsh'],
+                       nNsVth=test_params['nNsVth'])
+    testcurve = pvsystem.singlediode(**test_params)
+    v = np.linspace(0., testcurve['v_oc'], 300)
+    i = pvsystem.i_from_v(voltage=v, **test_params)
+    expected = tuple(test_params.values())
+
+    result = sde.fit_sandia_simple(voltage=v, current=i)
     assert np.allclose(result, expected, rtol=5e-5)
-    result = sde.fit_sandia_simple(voltage=testcurve['v'],
-                                   current=testcurve['i'],
+
+    result = sde.fit_sandia_simple(voltage=v, current=i,
                                    v_oc=testcurve['v_oc'],
                                    i_sc=testcurve['i_sc'])
     assert np.allclose(result, expected, rtol=5e-5)
-    result = sde.fit_sandia_simple(voltage=testcurve['v'],
-                                   current=testcurve['i'],
+
+    result = sde.fit_sandia_simple(voltage=v, current=i,
                                    v_oc=testcurve['v_oc'],
                                    i_sc=testcurve['i_sc'],
                                    v_mp_i_mp=(testcurve['v_mp'],
-                                   testcurve['i_mp']))
+                                              testcurve['i_mp']))
     assert np.allclose(result, expected, rtol=5e-5)
-    result = sde.fit_sandia_simple(voltage=testcurve['v'],
-                                   current=testcurve['i'], vlim=0.1)
+
+    result = sde.fit_sandia_simple(voltage=v, current=i, vlim=0.1)
     assert np.allclose(result, expected, rtol=5e-5)
 
 

pvlib/tests/ivtools/test_sdm.py

@@ -6,6 +6,7 @@ from numpy.testing import assert_allclose
 
 from pvlib.ivtools import sdm
 from pvlib import pvsystem
+from pvlib._deprecation import pvlibDeprecationWarning
 
 from pvlib.tests.conftest import requires_pysam, requires_statsmodels
 
@@ -100,11 +101,15 @@ def test_fit_desoto_sandia(cec_params_cansol_cs5p_220p):
     temp_cell = np.array([15., 25., 35., 45.])
     ee = np.tile(effective_irradiance, len(temp_cell))
     tc = np.repeat(temp_cell, len(effective_irradiance))
-    iph, io, rs, rsh, nnsvth = pvsystem.calcparams_desoto(
+    IL, I0, Rs, Rsh, nNsVth = pvsystem.calcparams_desoto(
         ee, tc, alpha_sc=specs['alpha_sc'], **params)
-    sim_ivcurves = pvsystem.singlediode(iph, io, rs, rsh, nnsvth, 300)
-    sim_ivcurves['ee'] = ee
-    sim_ivcurves['tc'] = tc
+    ivcurve_params = dict(photocurrent=IL, saturation_current=I0,
+                          resistance_series=Rs, resistance_shunt=Rsh,
+                          nNsVth=nNsVth)
+    sim_ivcurves = pvsystem.singlediode(**ivcurve_params).to_dict('series')
+    v = np.linspace(0., sim_ivcurves['v_oc'], 300)
+    i = pvsystem.i_from_v(voltage=v, **ivcurve_params)
+    sim_ivcurves.update(v=v.T, i=i.T, ee=ee, tc=tc)
 
     result = sdm.fit_desoto_sandia(sim_ivcurves, specs)
     modeled = pd.Series(index=params.keys(), data=np.nan)