pvlib 0.11.1__py3-none-any.whl → 0.12.0__py3-none-any.whl

pvlib/tests/iotools/test_sodapro.py

@@ -1,298 +0,0 @@
-"""
-test iotools for sodapro
-"""
-
-import pandas as pd
-import numpy as np
-import requests
-import pytest
-
-from pvlib.iotools import sodapro
-from ..conftest import DATA_DIR, assert_frame_equal
-
-
-testfile_mcclear_verbose = DATA_DIR / 'cams_mcclear_1min_verbose.csv'
-testfile_mcclear_monthly = DATA_DIR / 'cams_mcclear_monthly.csv'
-testfile_radiation_verbose = DATA_DIR / 'cams_radiation_1min_verbose.csv'
-testfile_radiation_monthly = DATA_DIR / 'cams_radiation_monthly.csv'
-
-
-index_verbose = pd.date_range('2020-06-01 12', periods=4, freq='1min',
-                              tz='UTC')
-index_monthly = pd.date_range('2020-01-01', periods=4, freq='1M')
-
-
-dtypes_mcclear_verbose = [
-    'object', 'float64', 'float64', 'float64', 'float64', 'float64', 'float64',
-    'float64', 'float64', 'float64', 'float64', 'float64', 'float64',
-    'float64', 'float64', 'float64', 'float64', 'float64', 'int64', 'float64',
-    'float64', 'float64', 'float64']
-
-dtypes_mcclear = [
-    'object', 'float64', 'float64', 'float64', 'float64', 'float64']
-
-dtypes_radiation_verbose = [
-    'object', 'float64', 'float64', 'float64', 'float64', 'float64', 'float64',
-    'float64', 'float64', 'float64', 'float64', 'float64', 'float64',
-    'float64', 'float64', 'float64', 'float64', 'float64', 'float64',
-    'float64', 'float64', 'float64', 'float64', 'int64', 'float64', 'float64',
-    'float64', 'float64', 'float64', 'int64', 'int64', 'float64', 'float64',
-    'float64', 'float64']
-
-dtypes_radiation = [
-    'object', 'float64', 'float64', 'float64', 'float64', 'float64', 'float64',
-    'float64', 'float64', 'float64', 'float64']
-
-
-columns_mcclear_verbose = [
-    'Observation period', 'ghi_extra', 'ghi_clear', 'bhi_clear',
-    'dhi_clear', 'dni_clear', 'solar_zenith', 'summer/winter split', 'tco3',
-    'tcwv', 'AOD BC', 'AOD DU', 'AOD SS', 'AOD OR', 'AOD SU', 'AOD NI',
-    'AOD AM', 'alpha', 'Aerosol type', 'fiso', 'fvol', 'fgeo', 'albedo']
-
-columns_mcclear = [
-    'Observation period', 'ghi_extra', 'ghi_clear', 'bhi_clear', 'dhi_clear',
-    'dni_clear']
-
-columns_radiation_verbose = [
-    'Observation period', 'ghi_extra', 'ghi_clear', 'bhi_clear', 'dhi_clear',
-    'dni_clear', 'ghi', 'bhi', 'dhi', 'dni', 'Reliability', 'solar_zenith',
-    'summer/winter split', 'tco3', 'tcwv', 'AOD BC', 'AOD DU', 'AOD SS',
-    'AOD OR', 'AOD SU', 'AOD NI', 'AOD AM', 'alpha', 'Aerosol type', 'fiso',
-    'fvol', 'fgeo', 'albedo', 'Cloud optical depth', 'Cloud coverage',
-    'Cloud type', 'GHI no corr', 'BHI no corr', 'DHI no corr', 'BNI no corr']
-
-columns_radiation_verbose_unmapped = [
-    'Observation period', 'TOA', 'Clear sky GHI', 'Clear sky BHI',
-    'Clear sky DHI', 'Clear sky BNI', 'GHI', 'BHI', 'DHI', 'BNI',
-    'Reliability', 'sza', 'summer/winter split', 'tco3', 'tcwv', 'AOD BC',
-    'AOD DU', 'AOD SS', 'AOD OR', 'AOD SU', 'AOD NI', 'AOD AM', 'alpha',
-    'Aerosol type', 'fiso', 'fvol', 'fgeo', 'albedo', 'Cloud optical depth',
-    'Cloud coverage', 'Cloud type', 'GHI no corr', 'BHI no corr',
-    'DHI no corr', 'BNI no corr']
-
-columns_radiation = [
-    'Observation period', 'ghi_extra', 'ghi_clear', 'bhi_clear', 'dhi_clear',
-    'dni_clear', 'ghi', 'bhi', 'dhi', 'dni', 'Reliability']
-
-
-values_mcclear_verbose = np.array([
-    ['2020-06-01T12:00:00.0/2020-06-01T12:01:00.0', 1084.194, 848.5020,
-     753.564, 94.938, 920.28, 35.0308, 0.9723, 341.0221, 17.7962, 0.0065,
-     0.0067, 0.0008, 0.0215, 0.0252, 0.0087, 0.0022, np.nan, -1, 0.1668,
-     0.0912, 0.0267, 0.1359],
-    ['2020-06-01T12:01:00.0/2020-06-01T12:02:00.0', 1083.504, 847.866, 752.904,
-     94.962, 920.058, 35.0828, 0.9723, 341.0223, 17.802, 0.0065, 0.0067,
-     0.0008, 0.0215, 0.0253, 0.0087, 0.0022, np.nan, -1, 0.1668, 0.0912,
-     0.0267, 0.1359],
-    ['2020-06-01T12:02:00.0/2020-06-01T12:03:00.0', 1082.802, 847.224, 752.232,
-     94.986, 919.836, 35.1357, 0.9723, 341.0224, 17.8079, 0.0065, 0.0067,
-     0.0008, 0.0216, 0.0253, 0.0087, 0.0022, np.nan, -1, 0.1668, 0.0912,
-     0.0267, 0.1359],
-    ['2020-06-01T12:03:00.0/2020-06-01T12:04:00.0', 1082.088, 846.564, 751.554,
-     95.01, 919.614, 35.1896, 0.9723, 341.0226, 17.8137, 0.0065, 0.0067,
-     0.0008, 0.0217, 0.0253, 0.0087, 0.0022, np.nan, -1, 0.1668, 0.0912,
-     0.0267, 0.1359]])
-
-values_mcclear_monthly = np.array([
-    ['2020-01-01T00:00:00.0/2020-02-01T00:00:00.0', 67.4314, 39.5494,
-     26.1998, 13.3496, 142.1562],
-    ['2020-02-01T00:00:00.0/2020-03-01T00:00:00.0', 131.2335, 84.7849,
-     58.3855, 26.3994, 202.4865],
-    ['2020-03-01T00:00:00.0/2020-04-01T00:00:00.0', 232.3323, 163.176,
-     125.1675, 38.0085, 307.5254],
-    ['2020-04-01T00:00:00.0/2020-05-01T00:00:00.0', 344.7431, 250.7585,
-     197.8757, 52.8829, 387.6707]])
-
-values_radiation_verbose = np.array([
-    ['2020-06-01T12:00:00.0/2020-06-01T12:01:00.0', 1084.194, 848.502, 753.564,
-     94.938, 920.28, 815.358, 702.342, 113.022, 857.724, 1.0, 35.0308, 0.9723,
-     341.0221, 17.7962, 0.0065, 0.0067, 0.0008, 0.0215, 0.0252, 0.0087, 0.0022,
-     np.nan, -1, 0.1668, 0.0912, 0.0267, 0.1359, 0.0, 0, 5, 848.502, 753.564,
-     94.938, 920.28],
-    ['2020-06-01T12:01:00.0/2020-06-01T12:02:00.0', 1083.504, 847.866, 752.904,
-     94.962, 920.058, 814.806, 701.73, 113.076, 857.52, 1.0, 35.0828, 0.9723,
-     341.0223, 17.802, 0.0065, 0.0067, 0.0008, 0.0215, 0.0253, 0.0087, 0.0022,
-     np.nan, -1, 0.1668, 0.0912, 0.0267, 0.1359, 0.0, 0, 5, 847.866, 752.904,
-     94.962, 920.058],
-    ['2020-06-01T12:02:00.0/2020-06-01T12:03:00.0', 1082.802, 847.224, 752.232,
-     94.986, 919.836, 814.182, 701.094, 113.088, 857.298, 1.0, 35.1357, 0.9723,
-     341.0224, 17.8079, 0.0065, 0.0067, 0.0008, 0.0216, 0.0253, 0.0087, 0.0022,
-     np.nan, -1, 0.1668, 0.0912, 0.0267, 0.1359, 0.0, 0, 5, 847.224, 752.232,
-     94.986, 919.836],
-    ['2020-06-01T12:03:00.0/2020-06-01T12:04:00.0', 1082.088, 846.564, 751.554,
-     95.01, 919.614, 813.612, 700.464, 113.148, 857.094, 1.0, 35.1896, 0.9723,
-     341.0226, 17.8137, 0.0065, 0.0067, 0.0008, 0.0217, 0.0253, 0.0087, 0.0022,
-     np.nan, -1, 0.1668, 0.0912, 0.0267, 0.1359, 0.0, 0, 5, 846.564, 751.554,
-     95.01, 919.614]])
-
-values_radiation_verbose_integrated = np.copy(values_radiation_verbose)
-values_radiation_verbose_integrated[:, 1:10] = \
-    values_radiation_verbose_integrated[:, 1:10].astype(float)/60
-values_radiation_verbose_integrated[:, 31:35] = \
-    values_radiation_verbose_integrated[:, 31:35].astype(float)/60
-
-values_radiation_monthly = np.array([
-    ['2020-01-01T00:00:00.0/2020-02-01T00:00:00.0', 67.4317, 39.5496,
-     26.2, 13.3496, 142.1567, 20.8763, 3.4526, 17.4357, 16.7595, 0.997],
-    ['2020-02-01T00:00:00.0/2020-03-01T00:00:00.0', 131.2338, 84.7852,
-     58.3858, 26.3994, 202.4871, 47.5197, 13.984, 33.5512, 47.8541, 0.9956],
-    ['2020-03-01T00:00:00.0/2020-04-01T00:00:00.0', 232.3325, 163.1762,
-     125.1677, 38.0085, 307.5256, 120.1659, 69.6217, 50.5653, 159.576, 0.9949],
-    ['2020-04-01T00:00:00.0/2020-05-01T00:00:00.0', 344.7433, 250.7587,
-     197.8758, 52.8829, 387.6709, 196.7015, 123.2593, 73.5152, 233.9675,
-     0.9897]])
-
-
-# @pytest.fixture
-def generate_expected_dataframe(values, columns, index, dtypes):
-    """Create dataframe from arrays of values, columns and index, in order to
-    use this dataframe to compare to.
-    """
-    expected = pd.DataFrame(values, columns=columns, index=index)
-    expected.index.freq = None
-    for (col, _dtype) in zip(expected.columns, dtypes):
-        expected[col] = expected[col].astype(_dtype)
-    return expected
-
-
-@pytest.mark.parametrize('testfile,index,columns,values,dtypes', [
-    (testfile_mcclear_verbose, index_verbose, columns_mcclear_verbose,
-     values_mcclear_verbose, dtypes_mcclear_verbose),
-    (testfile_mcclear_monthly, index_monthly, columns_mcclear,
-     values_mcclear_monthly, dtypes_mcclear),
-    (testfile_radiation_verbose, index_verbose, columns_radiation_verbose,
-     values_radiation_verbose, dtypes_radiation_verbose),
-    (testfile_radiation_monthly, index_monthly, columns_radiation,
-     values_radiation_monthly, dtypes_radiation)])
-def test_read_cams(testfile, index, columns, values, dtypes):
-    expected = generate_expected_dataframe(values, columns, index, dtypes)
-    out, metadata = sodapro.read_cams(testfile, integrated=False,
-                                      map_variables=True)
-    assert_frame_equal(out, expected, check_less_precise=True)
-
-
-def test_read_cams_integrated_unmapped_label():
-    # Default label is 'left' for 1 minute time resolution, hence 1 minute is
-    # added for label='right'
-    expected = generate_expected_dataframe(
-        values_radiation_verbose_integrated,
-        columns_radiation_verbose_unmapped,
-        index_verbose+pd.Timedelta(minutes=1), dtypes=dtypes_radiation_verbose)
-    out, metadata = sodapro.read_cams(testfile_radiation_verbose,
-                                      integrated=True, label='right',
-                                      map_variables=False)
-    assert_frame_equal(out, expected, check_less_precise=True)
-
-
-def test_read_cams_metadata():
-    _, metadata = sodapro.read_cams(testfile_mcclear_monthly, integrated=False)
-    assert metadata['Time reference'] == 'Universal time (UT)'
-    assert metadata['noValue'] == 'nan'
-    assert metadata['latitude'] == 55.7906
-    assert metadata['longitude'] == 12.5251
-    assert metadata['altitude'] == 39.0
-    assert metadata['radiation_unit'] == 'W/m^2'
-    assert metadata['time_step'] == '1M'
-
-
-@pytest.mark.parametrize('testfile,index,columns,values,dtypes,identifier', [
-    (testfile_mcclear_monthly, index_monthly, columns_mcclear,
-     values_mcclear_monthly, dtypes_mcclear, 'mcclear'),
-    (testfile_radiation_monthly, index_monthly, columns_radiation,
-     values_radiation_monthly, dtypes_radiation, 'cams_radiation')])
-def test_get_cams(requests_mock, testfile, index, columns, values, dtypes,
-                  identifier):
-    """Test that get_cams generates the correct URI request and that parse_cams
-    is being called correctly"""
-    # Open local test file containing McClear mothly data
-    with open(testfile, 'r') as test_file:
-        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://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'})
-
-    # Make API call - an error is raised if requested URI does not match
-    out, metadata = sodapro.get_cams(
-        start=pd.Timestamp('2020-01-01'),
-        end=pd.Timestamp('2020-05-04'),
-        latitude=55.7906,
-        longitude=12.5251,
-        email='pvlib-admin@googlegroups.com',
-        identifier=identifier,
-        altitude=80,
-        time_step='1M',
-        verbose=False,
-        integrated=False)
-    expected = generate_expected_dataframe(values, columns, index, dtypes)
-    assert_frame_equal(out, expected, check_less_precise=True)
-
-    # Test if Warning is raised if verbose mode is True and time_step != '1min'
-    with pytest.warns(UserWarning, match='Verbose mode only supports'):
-        _ = sodapro.get_cams(
-            start=pd.Timestamp('2020-01-01'),
-            end=pd.Timestamp('2020-05-04'),
-            latitude=55.7906,
-            longitude=12.5251,
-            email='pvlib-admin@googlegroups.com',
-            identifier=identifier,
-            altitude=80,
-            time_step='1M',
-            verbose=True)
-
-
-def test_get_cams_bad_request(requests_mock):
-    """Test that a the correct errors/warnings ares raised for invalid
-    requests inputs. Also tests if the specified server url gets used"""
-
-    # Subset of an xml file returned for errornous requests
-    mock_response_bad_text = """<?xml version="1.0" encoding="utf-8"?>
-    <ows:Exception exceptionCode="NoApplicableCode" locator="None">
-    <ows:ExceptionText>Failed to execute WPS process [get_mcclear]:
-        Please, register yourself at www.soda-pro.com
-    </ows:ExceptionText>"""
-
-    url_cams_bad_request = 'https://pro.soda-is.com/service/wps?DataInputs=latitude=55.7906;longitude=12.5251;altitude=-999;date_begin=2020-01-01;date_end=2020-05-04;time_ref=TST;summarization=PT01H;username=test%2540test.com;verbose=false&Service=WPS&Request=Execute&Identifier=get_mcclear&version=1.0.0&RawDataOutput=irradiation'  # noqa: E501
-
-    requests_mock.get(url_cams_bad_request, status_code=400,
-                      text=mock_response_bad_text)
-
-    # Test if HTTPError is raised if incorrect input is specified
-    # In the below example a non-registrered email is specified
-    with pytest.raises(requests.exceptions.HTTPError,
-                       match='Failed to execute WPS process'):
-        _ = sodapro.get_cams(
-            start=pd.Timestamp('2020-01-01'),
-            end=pd.Timestamp('2020-05-04'),
-            latitude=55.7906,
-            longitude=12.5251,
-            email='test@test.com',  # a non-registrered email
-            identifier='mcclear',
-            time_ref='TST',
-            verbose=False,
-            time_step='1h',
-            server='pro.soda-is.com')
-    # Test if value error is raised if incorrect identifier is specified
-    with pytest.raises(ValueError, match='Identifier must be either'):
-        _ = sodapro.get_cams(
-            start=pd.Timestamp('2020-01-01'),
-            end=pd.Timestamp('2020-05-04'),
-            latitude=55.7906,
-            longitude=12.5251,
-            email='test@test.com',
-            identifier='test',  # incorrect identifier
-            server='pro.soda-is.com')
-    # Test if value error is raised if incorrect time step is specified
-    with pytest.raises(ValueError, match='Time step not recognized'):
-        _ = sodapro.get_cams(
-            start=pd.Timestamp('2020-01-01'),
-            end=pd.Timestamp('2020-05-04'),
-            latitude=55.7906,
-            longitude=12.5251,
-            email='test@test.com',
-            identifier='mcclear',
-            time_step='test',  # incorrect time step
-            server='pro.soda-is.com')

pvlib/tests/iotools/test_solaranywhere.py

@@ -1,287 +0,0 @@
-import pandas as pd
-import pytest
-import pvlib
-import os
-from ..conftest import (DATA_DIR, RERUNS, RERUNS_DELAY,
-                        requires_solaranywhere_credentials)
-
-# High spatial resolution and 5-min data, true dynamics enabled
-TESTFILE_HIGH_RESOLUTION = DATA_DIR / 'Burlington, United States SolarAnywhere Time Series 20210101 to 20210103 Lat_44_4675 Lon_-73_2075 SA format.csv'  # noqa: E501
-# TGY test file (v3.6) containing GHI/DHI and temperature.
-# Note, the test file only contains the first three days.
-TESTFILE_TMY = DATA_DIR / 'Burlington, United States SolarAnywhere Typical GHI Year Lat_44_465 Lon_-73_205 SA format.csv'  # noqa: E501
-
-
-@pytest.fixture(scope="module")
-def solaranywhere_api_key():
-    """Supplies the pvlib's SolarAnywhere API key for testing purposes.
-    Users can freely register for an API key."""
-    solaranywhere_api_key = os.environ["SOLARANYWHERE_API_KEY"]
-    return solaranywhere_api_key
-
-
-@pytest.fixture
-def high_resolution_index():
-    index = pd.date_range(start='2021-01-01 00:05-0500',
-                          end='2021-01-03 00:00-0500', freq='5min')
-    index.name = 'ObservationTime'
-    return index
-
-
-@pytest.fixture
-def tmy_index():
-    index = pd.date_range(
-        start='2000-01-01 01:00-0500', periods=3*24, freq='1h')
-    index.name = 'ObservationTime'
-    index.freq = None
-    return index
-
-
-@pytest.fixture
-def tmy_ghi_series(tmy_index):
-    ghi = [
-        0, 0, 0, 0, 0, 0, 0, 3, 50, 171, 234, 220, 202, 122, 141, 65, 2, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 48, 105, 161, 135, 108, 72, 58,
-        33, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 47, 124, 99, 116,
-        130, 165, 110, 36, 1, 0, 0, 0, 0, 0, 0, 0
-    ]
-    return pd.Series(data=ghi, index=tmy_index, name='ghi')
-
-
-def test_read_solaranywhere_high_resolution(high_resolution_index):
-    data, meta = pvlib.iotools.read_solaranywhere(TESTFILE_HIGH_RESOLUTION,
-                                                  map_variables=False)
-    # Check that metadata is parsed correctly
-    assert meta['latitude'] == 44.4675
-    assert meta['longitude'] == -73.2075
-    assert meta['altitude'] == 41.0
-    assert meta['name'] == 'Burlington  United States'
-    assert meta['TZ'] == -5.0
-    assert meta['Data Version'] == '3.6'
-    assert meta['LatLon Resolution'] == 0.005
-    # Check that columns are parsed correctly
-    assert 'Albedo' in data.columns
-    assert 'Global Horizontal Irradiance (GHI) W/m2' in data.columns
-    assert 'Direct Normal Irradiance (DNI) W/m2' in data.columns
-    assert 'WindSpeed (m/s)' in data.columns
-    assert 'WindSpeedObservationType' in data.columns
-    assert 'Particulate Matter 10 (µg/m3)' in data.columns
-    # Check that data is parsed correctly
-    assert data.loc['2021-01-01 07:00:00-05:00', 'Albedo'] == 0.6
-    assert data.loc['2021-01-01 07:00:00-05:00', 'WindSpeed (m/s)'] == 0
-    # Assert that the index is parsed correctly
-    pd.testing.assert_index_equal(data.index, high_resolution_index)
-
-
-def test_read_solaranywhere_map_variables():
-    # Check that variables are mapped by default to pvlib names
-    data, meta = pvlib.iotools.read_solaranywhere(TESTFILE_HIGH_RESOLUTION)
-    mapped_column_names = ['ghi', 'dni', 'dhi', 'temp_air', 'wind_speed',
-                           'relative_humidity', 'ghi_clear', 'dni_clear',
-                           'dhi_clear', 'albedo']
-    for c in mapped_column_names:
-        assert c in data.columns
-    assert meta['latitude'] == 44.4675
-    assert meta['longitude'] == -73.2075
-    assert meta['altitude'] == 41.0
-
-
-def test_read_solaranywhere_tmy(tmy_index, tmy_ghi_series):
-    # Check that TMY files are correctly parsed
-    data, meta = pvlib.iotools.read_solaranywhere(TESTFILE_TMY)
-    # Check that columns names are correct and mapped to pvlib names
-    assert 'ghi' in data.columns
-    assert 'dni' in data.columns
-    assert 'dhi' in data.columns
-    assert 'temp_air' in data.columns
-    # Check that metadata is parsed correctly
-    assert meta['latitude'] == 44.465
-    assert meta['longitude'] == -73.205
-    assert meta['altitude'] == 41.0
-    assert meta['name'] == 'Burlington  United States'
-    assert meta['TZ'] == -5.0
-    assert meta['Data Version'] == '3.6'
-    assert meta['LatLon Resolution'] == 0.010
-    assert meta['Time Resolution'] == '60 minutes'
-    # Assert that the index is parsed correctly
-    pd.testing.assert_index_equal(data.index, tmy_index)
-    # Test one column
-    pd.testing.assert_series_equal(data['ghi'], tmy_ghi_series)
-
-
-@pytest.mark.remote_data
-@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
-def test_get_solaranywhere_bad_probability_of_exceedance():
-    # Test if ValueError is raised if probability_of_exceedance is not integer
-    with pytest.raises(ValueError, match="must be an integer"):
-        pvlib.iotools.get_solaranywhere(
-            latitude=44, longitude=-73, api_key='empty',
-            source='SolarAnywherePOELatest', probability_of_exceedance=0.5)
-
-
-@pytest.mark.remote_data
-@requires_solaranywhere_credentials
-@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
-def test_get_solaranywhere_missing_start_end(solaranywhere_api_key):
-    # Test if ValueError is raised if start/end is missing for non-TMY request
-    with pytest.raises(ValueError, match="simulation start and end time"):
-        pvlib.iotools.get_solaranywhere(
-            latitude=44, longitude=-73, api_key=solaranywhere_api_key,
-            source='SolarAnywhereLatest')
-
-
-@pytest.fixture
-def time_series_index():
-    index = pd.date_range(start='2019-12-31 19:02:30-05:00', periods=288,
-                          freq='5min')
-    index.name = 'ObservationTime'
-    index.freq = None
-    return index
-
-
-@pytest.fixture
-def timeseries_temp_air(time_series_index):
-    temp_air = [
-        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
-        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-        1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
-        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2,
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
-    ]
-    return pd.Series(data=temp_air, index=time_series_index, name='temp_air')
-
-
-@requires_solaranywhere_credentials
-@pytest.mark.remote_data
-@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
-def test_get_solaranywhere_no_timezone(
-        solaranywhere_api_key, time_series_index, timeseries_temp_air):
-    # Test if data can be retrieved. This test only retrieves one day of data
-    # to minimize the request time.
-    data, meta = pvlib.iotools.get_solaranywhere(
-        latitude=44.4675, longitude=-73.2075, api_key=solaranywhere_api_key,
-        # specify start/end without timezone information
-        start=pd.Timestamp(2020, 1, 1), end=pd.Timestamp(2020, 1, 2),
-        # test specific version of SolarAnywhere
-        source='SolarAnywhere3_6',
-        spatial_resolution=0.005, time_resolution=5, true_dynamics=True)
-
-    # Check metadata, including that true-dynamics is set
-    assert meta['WeatherSiteName'] == 'SolarAnywhere3_6'
-    assert meta['ApplyTrueDynamics'] is True
-    assert meta['time_resolution'] == 5
-    assert meta['spatial_resolution'] == 0.005
-    assert meta['latitude'] == 44.4675
-    assert meta['longitude'] == -73.2075
-    assert meta['altitude'] == 41.0
-
-    # Check that variables have been mapped (default convention)
-    assert 'StartTime' in data.columns
-    assert 'ObservationTime' in data.columns
-    assert 'EndTime' in data.columns
-    assert 'ghi' in data.columns
-    assert 'dni' in data.columns
-    assert 'dhi' in data.columns
-    assert 'temp_air' in data.columns
-    assert 'wind_speed' in data.columns
-    assert 'albedo' in data.columns
-    assert 'DataVersion' in data.columns
-
-    # Assert index (checks that time resolution is 5 min)
-    pd.testing.assert_index_equal(data.index, time_series_index)
-    # Test one column
-    pd.testing.assert_series_equal(data['temp_air'], timeseries_temp_air)
-
-
-@requires_solaranywhere_credentials
-@pytest.mark.remote_data
-@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
-def test_get_solaranywhere_other_options(
-        solaranywhere_api_key, time_series_index, timeseries_temp_air):
-    # Test if data can be retrieved. This test only retrieves one day of data
-    # to minimize the request time.
-    data, meta = pvlib.iotools.get_solaranywhere(
-        latitude=44.4675, longitude=-73.2075, api_key=solaranywhere_api_key,
-        # specify start/end as str with timezone information
-        start='2020-01-01 00:00:00+0000',
-        end='2020-01-02 00:00:00+0000',
-        # test specific version of SolarAnywhere
-        source='SolarAnywhere3_7',
-        # test fewer variables
-        variables=[
-            'ObservationTime',
-            'GlobalHorizontalIrradiance_WattsPerMeterSquared',
-        ],
-        map_variables=False)
-
-    # Check metadata
-    assert meta['WeatherSiteName'] == 'SolarAnywhere3_7'
-    assert meta['ApplyTrueDynamics'] is False  # default setting
-    assert meta['time_resolution'] == 60  # default resolution
-    assert meta['spatial_resolution'] == 0.01  # default resolution
-    assert meta['latitude'] == 44.4675
-    assert meta['longitude'] == -73.2075
-    assert meta['altitude'] == 41.0
-
-    # Check that variables have been mapped (default convention)
-    assert 'StartTime' not in data.columns
-    assert 'ObservationTime' in data.columns
-    assert 'EndTime' not in data.columns
-    # Check that ghi is not mapped
-    assert 'ghi' not in data.columns
-    assert 'GlobalHorizontalIrradiance_WattsPerMeterSquared' in data.columns
-    assert 'dni' not in data.columns
-    assert 'dhi' not in data.columns
-    assert 'temp_air' not in data.columns
-    assert 'wind_speed' not in data.columns
-    assert 'albedo' not in data.columns
-    assert 'DataVersion' not in data.columns
-
-
-@requires_solaranywhere_credentials
-@pytest.mark.remote_data
-@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
-def test_get_solaranywhere_probability_exceedance_error(solaranywhere_api_key):
-    # Test if ValueError is raised when passing start/end to typical year
-    with pytest.raises(ValueError, match="start and end time must be null"):
-        data, meta = pvlib.iotools.get_solaranywhere(
-            latitude=44.4675, longitude=-73.2075,
-            api_key=solaranywhere_api_key,
-            # Probabiliy of exceedance year should not have start/end specified
-            start=pd.Timestamp('2020-01-01 00:00:00+0000'),
-            end=pd.Timestamp('2020-01-05 12:00:00+0000'),
-            source='SolarAnywherePOELatest',
-            probability_of_exceedance=20)
-
-
-@requires_solaranywhere_credentials
-@pytest.mark.remote_data
-@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
-def test_get_solaranywhere_timeout_tgy(solaranywhere_api_key):
-    # Test if the service times out when the timeout parameter is close to zero
-    with pytest.raises(TimeoutError, match="Time exceeded"):
-        pvlib.iotools.get_solaranywhere(
-            latitude=44.4675, longitude=-73.2075,
-            api_key=solaranywhere_api_key,
-            source='SolarAnywhereTGYLatest',
-            timeout=0.00001)
-
-
-@requires_solaranywhere_credentials
-@pytest.mark.remote_data
-@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
-def test_get_solaranywhere_not_available(solaranywhere_api_key):
-    # Test if RuntimeError is raised if location in the ocean is requested
-    with pytest.raises(RuntimeError, match="Tile is outside of our coverage"):
-        pvlib.iotools.get_solaranywhere(
-            latitude=40, longitude=-70,
-            api_key=solaranywhere_api_key,
-            start=pd.Timestamp('2020-01-01 00:00:00+0000'),
-            end=pd.Timestamp('2020-01-05 12:00:00+0000'))

pvlib/tests/iotools/test_solargis.py

@@ -1,68 +0,0 @@
-import pandas as pd
-import pytest
-import pvlib
-import requests
-from ..conftest import (RERUNS, RERUNS_DELAY, assert_frame_equal,
-                        assert_index_equal)
-
-
-@pytest.fixture
-def hourly_index():
-    hourly_index = pd.date_range(start='2022-01-01 00:30+01:00', freq='60min',
-                                 periods=24, name='dateTime')
-    hourly_index.freq = None
-    return hourly_index
-
-
-@pytest.fixture
-def hourly_index_start_utc():
-    hourly_index_left_utc = pd.date_range(
-        start='2023-01-01 00:00+00:00', freq='30min', periods=24*2,
-        name='dateTime')
-    hourly_index_left_utc.freq = None
-    return hourly_index_left_utc
-
-
-@pytest.fixture
-def hourly_dataframe(hourly_index):
-    ghi = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 5.0, 73.0, 152.0, 141.0, 105.0,
-           62.0, 65.0, 62.0, 11.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
-    dni = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 30.0, 233.0, 301.0, 136.0, 32.0,
-           0.0, 3.0, 77.0, 5.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
-    return pd.DataFrame(data={'ghi': ghi, 'dni': dni}, index=hourly_index)
-
-
-@pytest.mark.remote_data
-@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
-def test_get_solargis(hourly_dataframe):
-    data, meta = pvlib.iotools.get_solargis(
-        latitude=48.61259, longitude=20.827079,
-        start='2022-01-01', end='2022-01-01',
-        tz='GMT+01', variables=['GHI', 'DNI'],
-        time_resolution='HOURLY', api_key='demo')
-    assert_frame_equal(data, hourly_dataframe)
-
-
-@pytest.mark.remote_data
-@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
-def test_get_solargis_utc_start_timestamp(hourly_index_start_utc):
-    data, meta = pvlib.iotools.get_solargis(
-        latitude=48.61259, longitude=20.827079,
-        start='2023-01-01', end='2023-01-01',
-        variables=['GTI'],
-        timestamp_type='start',
-        time_resolution='MIN_30',
-        map_variables=False, api_key='demo')
-    assert 'GTI' in data.columns  # assert that variables aren't mapped
-    assert_index_equal(data.index, hourly_index_start_utc)
-
-
-@pytest.mark.remote_data
-@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
-def test_get_solargis_http_error():
-    # Test if HTTPError is raised if date outside range is specified
-    with pytest.raises(requests.HTTPError, match="data coverage"):
-        _, _ = pvlib.iotools.get_solargis(
-            latitude=48.61259, longitude=20.827079,
-            start='1920-01-01', end='1920-01-01',  # date outside range
-            variables=['GHI', 'DNI'], time_resolution='HOURLY', api_key='demo')