pvlib 0.11.0a1__py3-none-any.whl → 0.11.2__py3-none-any.whl

pvlib/tests/test_conftest.py

@@ -1,50 +1,6 @@
 import pytest
-import pandas
 
 from pvlib.tests import conftest
-from pvlib.tests.conftest import fail_on_pvlib_version
-
-from pvlib._deprecation import pvlibDeprecationWarning, deprecated
-
-@pytest.mark.xfail(strict=True,
-                   reason='fail_on_pvlib_version should cause test to fail')
-@fail_on_pvlib_version('0.0')
-def test_fail_on_pvlib_version():
-    pass
-
-
-@fail_on_pvlib_version('100000.0')
-def test_fail_on_pvlib_version_pass():
-    pass
-
-
-@pytest.mark.xfail(strict=True, reason='ensure that the test is called')
-@fail_on_pvlib_version('100000.0')
-def test_fail_on_pvlib_version_fail_in_test():
-    raise Exception
-
-
-# set up to test using fixtures with function decorated with
-# conftest.fail_on_pvlib_version
-@pytest.fixture()
-def some_data():
-    return "some data"
-
-
-def alt_func(*args):
-    return args
-
-
-deprec_func = deprecated('350.8', alternative='alt_func',
-                         name='deprec_func', removal='350.9')(alt_func)
-
-
-@fail_on_pvlib_version('350.9')
-def test_use_fixture_with_decorator(some_data):
-    # test that the correct data is returned by the some_data fixture
-    assert some_data == "some data"
-    with pytest.warns(pvlibDeprecationWarning):  # test for deprecation warning
-        deprec_func(some_data)
 
 
 @pytest.mark.parametrize('function_name', ['assert_index_equal',

pvlib/tests/test_irradiance.py

@@ -15,7 +15,8 @@ from .conftest import (
     assert_frame_equal,
     assert_series_equal,
     requires_ephem,
-    requires_numba
+    requires_numba,
+    fail_on_pvlib_version,
 )
 
 from pvlib._deprecation import pvlibDeprecationWarning
@@ -59,7 +60,7 @@ def ephem_data(times):
 
 
 @pytest.fixture
-def dni_et(times):
+def dni_et():
     return np.array(
         [1321.1655834833093, 1321.1655834833093, 1321.1655834833093,
          1321.1655834833093])
@@ -106,7 +107,7 @@ def test_get_extra_radiation_epoch_year():
 @requires_numba
 def test_get_extra_radiation_nrel_numba(times):
     with warnings.catch_warnings():
-        # don't warn on method reload or num threads
+        # don't warn on method reload
         warnings.simplefilter("ignore")
         result = irradiance.get_extra_radiation(
             times, method='nrel', how='numba', numthreads=4)
@@ -603,11 +604,11 @@ def test_poa_components(irrad_data, ephem_data, dni_et, relative_airmass):
 
 @pytest.mark.parametrize('pressure,expected', [
     (93193,  [[830.46567,   0.79742,   0.93505],
-              [676.09497,   0.63776,   3.02102]]),
+              [676.18340,   0.63782,   3.02102]]),
     (None,   [[868.72425,   0.79742,   1.01664],
-              [680.66679,   0.63776,   3.28463]]),
+              [680.73800,   0.63782,   3.28463]]),
     (101325, [[868.72425,   0.79742,   1.01664],
-              [680.66679,   0.63776,   3.28463]])
+              [680.73800,   0.63782,   3.28463]])
 ])
 def test_disc_value(pressure, expected):
     # see GH 449 for pressure=None vs. 101325.
@@ -1063,7 +1064,7 @@ def test_dirindex(times):
         np.array([0., 79.73860422, 1042.48031487, 257.20751138]),
         index=times
     )
-    dni_clearsky = pd.Series(
+    dni_clear = pd.Series(
         np.array([0., 316.1949056, 939.95469881, 646.22886049]),
         index=times
     )
@@ -1073,14 +1074,14 @@ def test_dirindex(times):
     )
     pressure = 93193.
     tdew = 10.
-    out = irradiance.dirindex(ghi, ghi_clearsky, dni_clearsky,
+    out = irradiance.dirindex(ghi, ghi_clearsky, dni_clear,
                               zenith, times, pressure=pressure,
                               temp_dew=tdew)
     dirint_close_values = irradiance.dirint(ghi, zenith, times,
                                             pressure=pressure,
                                             use_delta_kt_prime=True,
                                             temp_dew=tdew).values
-    expected_out = np.array([np.nan, 0., 748.31562753, 630.72592644])
+    expected_out = np.array([np.nan, 0., 748.31562800, 630.73752100])
 
     tolerance = 1e-8
     assert np.allclose(out, expected_out, rtol=tolerance, atol=0,
@@ -1094,6 +1095,20 @@ def test_dirindex(times):
         equal_nan=True)
 
 
+@fail_on_pvlib_version("0.13")
+def test_dirindex_ghi_clearsky_deprecation():
+    times = pd.DatetimeIndex(['2014-06-24T18-1200'])
+    ghi = pd.Series([1038.62], index=times)
+    ghi_clearsky = pd.Series([1042.48031487], index=times)
+    dni_clearsky = pd.Series([939.95469881], index=times)
+    zenith = pd.Series([10.56413562], index=times)
+    pressure, tdew = 93193, 10
+    with pytest.warns(pvlibDeprecationWarning, match='ghi_clear'):
+        irradiance.dirindex(
+            ghi=ghi, ghi_clearsky=ghi_clearsky, dni_clear=dni_clearsky,
+            zenith=zenith, times=times, pressure=pressure, temp_dew=tdew)
+
+
 def test_dirindex_min_cos_zenith_max_zenith():
     # map out behavior under difficult conditions with various
     # limiting kwargs settings
@@ -1101,38 +1116,51 @@ def test_dirindex_min_cos_zenith_max_zenith():
     times = pd.DatetimeIndex(['2014-06-24T12-0700', '2014-06-24T18-0700'])
     ghi = pd.Series([0, 1], index=times)
     ghi_clearsky = pd.Series([0, 1], index=times)
-    dni_clearsky = pd.Series([0, 5], index=times)
+    dni_clear = pd.Series([0, 5], index=times)
     solar_zenith = pd.Series([90, 89.99], index=times)
 
-    out = irradiance.dirindex(ghi, ghi_clearsky, dni_clearsky, solar_zenith,
+    out = irradiance.dirindex(ghi, ghi_clearsky, dni_clear, solar_zenith,
                               times)
     expected = pd.Series([nan, nan], index=times)
     assert_series_equal(out, expected)
 
-    out = irradiance.dirindex(ghi, ghi_clearsky, dni_clearsky, solar_zenith,
+    out = irradiance.dirindex(ghi, ghi_clearsky, dni_clear, solar_zenith,
                               times, min_cos_zenith=0)
     expected = pd.Series([nan, nan], index=times)
     assert_series_equal(out, expected)
 
-    out = irradiance.dirindex(ghi, ghi_clearsky, dni_clearsky, solar_zenith,
+    out = irradiance.dirindex(ghi, ghi_clearsky, dni_clear, solar_zenith,
                               times, max_zenith=90)
     expected = pd.Series([nan, nan], index=times)
     assert_series_equal(out, expected)
 
-    out = irradiance.dirindex(ghi, ghi_clearsky, dni_clearsky, solar_zenith,
+    out = irradiance.dirindex(ghi, ghi_clearsky, dni_clear, solar_zenith,
                               times, min_cos_zenith=0, max_zenith=100)
     expected = pd.Series([nan, 5.], index=times)
     assert_series_equal(out, expected)
 
 
+@fail_on_pvlib_version("0.13")
+def test_dirindex_dni_clearsky_deprecation():
+    times = pd.DatetimeIndex(['2014-06-24T12-0700', '2014-06-24T18-0700'])
+    ghi = pd.Series([0, 1], index=times)
+    ghi_clearsky = pd.Series([0, 1], index=times)
+    dni_clear = pd.Series([0, 5], index=times)
+    solar_zenith = pd.Series([90, 89.99], index=times)
+    with pytest.warns(pvlibDeprecationWarning, match='dni_clear'):
+        irradiance.dirindex(ghi, ghi_clearsky, dni_clearsky=dni_clear,
+                            zenith=solar_zenith, times=times,
+                            min_cos_zenith=0)
+
+
 def test_dni():
     ghi = pd.Series([90, 100, 100, 100, 100])
     dhi = pd.Series([100, 90, 50, 50, 50])
     zenith = pd.Series([80, 100, 85, 70, 85])
-    clearsky_dni = pd.Series([50, 50, 200, 50, 300])
+    dni_clear = pd.Series([50, 50, 200, 50, 300])
 
     dni = irradiance.dni(ghi, dhi, zenith,
-                         clearsky_dni=clearsky_dni, clearsky_tolerance=2)
+                         dni_clear=dni_clear, clearsky_tolerance=2)
     assert_series_equal(dni,
                         pd.Series([float('nan'), float('nan'), 400,
                                    146.190220008, 573.685662283]))
@@ -1143,6 +1171,17 @@ def test_dni():
                                    146.190220008, 573.685662283]))
 
 
+@fail_on_pvlib_version("0.13")
+def test_dni_dni_clearsky_deprecation():
+    ghi = pd.Series([90, 100, 100, 100, 100])
+    dhi = pd.Series([100, 90, 50, 50, 50])
+    zenith = pd.Series([80, 100, 85, 70, 85])
+    dni_clear = pd.Series([50, 50, 200, 50, 300])
+    with pytest.warns(pvlibDeprecationWarning, match='dni_clear'):
+        irradiance.dni(ghi, dhi, zenith,
+                       clearsky_dni=dni_clear, clearsky_tolerance=2)
+
+
 @pytest.mark.parametrize(
     'surface_tilt,surface_azimuth,solar_zenith,' +
     'solar_azimuth,aoi_expected,aoi_proj_expected',
@@ -1235,6 +1274,13 @@ def test_clearsky_index():
     assert_series_equal(out, expected)
 
 
+@fail_on_pvlib_version("0.13")
+def test_clearsky_index_clearsky_ghi_deprecation():
+    with pytest.warns(pvlibDeprecationWarning, match='ghi_clear'):
+        ghi, clearsky_ghi = 200, 300
+        irradiance.clearsky_index(ghi, clearsky_ghi=clearsky_ghi)
+
+
 def test_clearness_index():
     ghi = np.array([-1, 0, 1, 1000])
     solar_zenith = np.array([180, 90, 89.999, 0])

pvlib/tests/test_pvsystem.py

@@ -1870,7 +1870,6 @@ def test_PVSystem_get_irradiance(solar_pos):
                                        irrads['dni'],
                                        irrads['ghi'],
                                        irrads['dhi'])
-
     expected = pd.DataFrame(data=np.array(
         [[883.65494055, 745.86141676, 137.79352379, 126.397131, 11.39639279],
          [0., -0., 0., 0., 0.]]),
@@ -1881,6 +1880,23 @@ def test_PVSystem_get_irradiance(solar_pos):
     assert_frame_equal(irradiance, expected, check_less_precise=2)
 
 
+def test_PVSystem_get_irradiance_float():
+    system = pvsystem.PVSystem(surface_tilt=32, surface_azimuth=135)
+    irrads = {'dni': 900., 'ghi': 600., 'dhi': 100.}
+    zenith = 55.366831
+    azimuth = 172.320038
+    irradiance = system.get_irradiance(zenith,
+                                       azimuth,
+                                       irrads['dni'],
+                                       irrads['ghi'],
+                                       irrads['dhi'])
+    expected = {'poa_global': 884.80903423, 'poa_direct': 745.84258835,
+                'poa_diffuse': 138.96644588, 'poa_sky_diffuse': 127.57005309,
+                'poa_ground_diffuse': 11.39639279}
+    for k, v in irradiance.items():
+        assert np.isclose(v, expected[k], rtol=1e-6)
+
+
 def test_PVSystem_get_irradiance_albedo(solar_pos):
     system = pvsystem.PVSystem(surface_tilt=32, surface_azimuth=135)
     irrads = pd.DataFrame({'dni': [900, 0], 'ghi': [600, 0], 'dhi': [100, 0],

pvlib/tests/test_solarposition.py

@@ -8,6 +8,7 @@ import pandas as pd
 from .conftest import assert_frame_equal, assert_series_equal
 from numpy.testing import assert_allclose
 import pytest
+import pytz
 
 from pvlib.location import Location
 from pvlib import solarposition, spa
@@ -139,7 +140,8 @@ def test_spa_python_numpy_physical_dst(expected_solpos, golden):
     assert_frame_equal(expected_solpos, ephem_data[expected_solpos.columns])
 
 
-def test_sun_rise_set_transit_spa(expected_rise_set_spa, golden):
+@pytest.mark.parametrize('delta_t', [65.0, None, np.array([65, 65])])
+def test_sun_rise_set_transit_spa(expected_rise_set_spa, golden, delta_t):
     # solution from NREL SAP web calculator
     south = Location(-35.0, 0.0, tz='UTC')
     times = pd.DatetimeIndex([datetime.datetime(1996, 7, 5, 0),
@@ -160,7 +162,7 @@ def test_sun_rise_set_transit_spa(expected_rise_set_spa, golden):
 
     result = solarposition.sun_rise_set_transit_spa(times, south.latitude,
                                                     south.longitude,
-                                                    delta_t=65.0)
+                                                    delta_t=delta_t)
     result_rounded = pd.DataFrame(index=result.index)
     # need to iterate because to_datetime does not accept 2D data
     # the rounding fails on pandas < 0.17
@@ -172,7 +174,7 @@ def test_sun_rise_set_transit_spa(expected_rise_set_spa, golden):
     # test for Golden, CO compare to NREL SPA
     result = solarposition.sun_rise_set_transit_spa(
         expected_rise_set_spa.index, golden.latitude, golden.longitude,
-        delta_t=65.0)
+        delta_t=delta_t)
 
     # round to nearest minute
     result_rounded = pd.DataFrame(index=result.index)
@@ -477,20 +479,20 @@ def test_get_solarposition_altitude(
 
 
 @pytest.mark.parametrize("delta_t, method", [
-    (None, 'nrel_numpy'),
-    pytest.param(
-        None, 'nrel_numba',
-        marks=[pytest.mark.xfail(
-            reason='spa.calculate_deltat not implemented for numba yet')]),
+    (None, 'nrel_numba'),
     (67.0, 'nrel_numba'),
+    (np.array([67.0, 67.0]), 'nrel_numba'),
+    # minimize reloads, with numpy being last
+    (None, 'nrel_numpy'),
     (67.0, 'nrel_numpy'),
-    ])
+    (np.array([67.0, 67.0]), 'nrel_numpy'),
+])
 def test_get_solarposition_deltat(delta_t, method, expected_solpos_multi,
                                   golden):
     times = pd.date_range(datetime.datetime(2003, 10, 17, 13, 30, 30),
                           periods=2, freq='D', tz=golden.tz)
     with warnings.catch_warnings():
-        # don't warn on method reload or num threads
+        # don't warn on method reload
         warnings.simplefilter("ignore")
         ephem_data = solarposition.get_solarposition(times, golden.latitude,
                                                      golden.longitude,
@@ -505,6 +507,21 @@ def test_get_solarposition_deltat(delta_t, method, expected_solpos_multi,
     assert_frame_equal(this_expected, ephem_data[this_expected.columns])
 
 
+@pytest.mark.parametrize("method", ['nrel_numba', 'nrel_numpy'])
+def test_spa_array_delta_t(method):
+    # make sure that time-varying delta_t produces different answers
+    times = pd.to_datetime(["2019-01-01", "2019-01-01"]).tz_localize("UTC")
+    expected = pd.Series([257.26969492, 257.2701359], index=times)
+    with warnings.catch_warnings():
+        # don't warn on method reload
+        warnings.simplefilter("ignore")
+        ephem_data = solarposition.get_solarposition(times, 40, -80,
+                                                     delta_t=np.array([67, 0]),
+                                                     method=method)
+
+    assert_series_equal(ephem_data['azimuth'], expected, check_names=False)
+
+
 def test_get_solarposition_no_kwargs(expected_solpos, golden):
     times = pd.date_range(datetime.datetime(2003, 10, 17, 13, 30, 30),
                           periods=1, freq='D', tz=golden.tz)
@@ -529,20 +546,22 @@ def test_get_solarposition_method_pyephem(expected_solpos, golden):
     assert_frame_equal(expected_solpos, ephem_data[expected_solpos.columns])
 
 
-def test_nrel_earthsun_distance():
+@pytest.mark.parametrize('delta_t', [64.0, None, np.array([64, 64])])
+def test_nrel_earthsun_distance(delta_t):
     times = pd.DatetimeIndex([datetime.datetime(2015, 1, 2),
                               datetime.datetime(2015, 8, 2)]
                              ).tz_localize('MST')
-    result = solarposition.nrel_earthsun_distance(times, delta_t=64.0)
+    result = solarposition.nrel_earthsun_distance(times, delta_t=delta_t)
     expected = pd.Series(np.array([0.983289204601, 1.01486146446]),
                          index=times)
     assert_series_equal(expected, result)
 
-    times = datetime.datetime(2015, 1, 2)
-    result = solarposition.nrel_earthsun_distance(times, delta_t=64.0)
-    expected = pd.Series(np.array([0.983289204601]),
-                         index=pd.DatetimeIndex([times, ]))
-    assert_series_equal(expected, result)
+    if np.size(delta_t) == 1:  # skip the array delta_t
+        times = datetime.datetime(2015, 1, 2)
+        result = solarposition.nrel_earthsun_distance(times, delta_t=delta_t)
+        expected = pd.Series(np.array([0.983289204601]),
+                             index=pd.DatetimeIndex([times, ]))
+        assert_series_equal(expected, result)
 
 
 def test_equation_of_time():
@@ -579,19 +598,20 @@ def test_declination():
 def test_analytical_zenith():
     times = pd.date_range(start="1/1/2015 0:00", end="12/31/2015 23:00",
                           freq="h").tz_localize('Etc/GMT+8')
+    times_utc = times.tz_convert('UTC')
     lat, lon = 37.8, -122.25
     lat_rad = np.deg2rad(lat)
     output = solarposition.spa_python(times, lat, lon, 100)
     solar_zenith = np.deg2rad(output['zenith'])  # spa
     # spencer
-    eot = solarposition.equation_of_time_spencer71(times.dayofyear)
+    eot = solarposition.equation_of_time_spencer71(times_utc.dayofyear)
     hour_angle = np.deg2rad(solarposition.hour_angle(times, lon, eot))
-    decl = solarposition.declination_spencer71(times.dayofyear)
+    decl = solarposition.declination_spencer71(times_utc.dayofyear)
     zenith_1 = solarposition.solar_zenith_analytical(lat_rad, hour_angle, decl)
     # pvcdrom and cooper
-    eot = solarposition.equation_of_time_pvcdrom(times.dayofyear)
+    eot = solarposition.equation_of_time_pvcdrom(times_utc.dayofyear)
     hour_angle = np.deg2rad(solarposition.hour_angle(times, lon, eot))
-    decl = solarposition.declination_cooper69(times.dayofyear)
+    decl = solarposition.declination_cooper69(times_utc.dayofyear)
     zenith_2 = solarposition.solar_zenith_analytical(lat_rad, hour_angle, decl)
     assert np.allclose(zenith_1, solar_zenith, atol=0.015)
     assert np.allclose(zenith_2, solar_zenith, atol=0.025)
@@ -600,22 +620,23 @@ def test_analytical_zenith():
 def test_analytical_azimuth():
     times = pd.date_range(start="1/1/2015 0:00", end="12/31/2015 23:00",
                           freq="h").tz_localize('Etc/GMT+8')
+    times_utc = times.tz_convert('UTC')
     lat, lon = 37.8, -122.25
     lat_rad = np.deg2rad(lat)
     output = solarposition.spa_python(times, lat, lon, 100)
     solar_azimuth = np.deg2rad(output['azimuth'])  # spa
     solar_zenith = np.deg2rad(output['zenith'])
     # spencer
-    eot = solarposition.equation_of_time_spencer71(times.dayofyear)
+    eot = solarposition.equation_of_time_spencer71(times_utc.dayofyear)
     hour_angle = np.deg2rad(solarposition.hour_angle(times, lon, eot))
-    decl = solarposition.declination_spencer71(times.dayofyear)
+    decl = solarposition.declination_spencer71(times_utc.dayofyear)
     zenith = solarposition.solar_zenith_analytical(lat_rad, hour_angle, decl)
     azimuth_1 = solarposition.solar_azimuth_analytical(lat_rad, hour_angle,
                                                        decl, zenith)
     # pvcdrom and cooper
-    eot = solarposition.equation_of_time_pvcdrom(times.dayofyear)
+    eot = solarposition.equation_of_time_pvcdrom(times_utc.dayofyear)
     hour_angle = np.deg2rad(solarposition.hour_angle(times, lon, eot))
-    decl = solarposition.declination_cooper69(times.dayofyear)
+    decl = solarposition.declination_cooper69(times_utc.dayofyear)
     zenith = solarposition.solar_zenith_analytical(lat_rad, hour_angle, decl)
     azimuth_2 = solarposition.solar_azimuth_analytical(lat_rad, hour_angle,
                                                        decl, zenith)
@@ -665,21 +686,77 @@ def test_hour_angle():
         '2015-01-02 12:04:44.6340'
     ]).tz_localize('Etc/GMT+7')
     eot = np.array([-3.935172, -4.117227, -4.026295])
-    hours = solarposition.hour_angle(times, longitude, eot)
+    hourangle = solarposition.hour_angle(times, longitude, eot)
     expected = (-70.682338, 70.72118825000001, 0.000801250)
     # FIXME: there are differences from expected NREL SPA calculator values
     # sunrise: 4 seconds, sunset: 48 seconds, transit: 0.2 seconds
     # but the differences may be due to other SPA input parameters
-    assert np.allclose(hours, expected)
+    assert np.allclose(hourangle, expected)
+
+    hours = solarposition._hour_angle_to_hours(
+        times, hourangle, longitude, eot)
+    result = solarposition._times_to_hours_after_local_midnight(times)
+    assert np.allclose(result, hours)
+
+    result = solarposition._local_times_from_hours_since_midnight(times, hours)
+    assert result.equals(times)
+
+    times = times.tz_convert(None)
+    with pytest.raises(ValueError):
+        solarposition.hour_angle(times, longitude, eot)
+    with pytest.raises(ValueError):
+        solarposition._hour_angle_to_hours(times, hourangle, longitude, eot)
+    with pytest.raises(ValueError):
+        solarposition._times_to_hours_after_local_midnight(times)
+    with pytest.raises(ValueError):
+        solarposition._local_times_from_hours_since_midnight(times, hours)
+
+
+def test_hour_angle_with_tricky_timezones():
+    # GH 2132
+    # tests timezones that have a DST shift at midnight
+
+    eot = np.array([-3.935172, -4.117227, -4.026295, -4.026295])
+
+    longitude = 70.6693
+    times = pd.DatetimeIndex([
+        '2014-09-06 23:00:00',
+        '2014-09-07 00:00:00',
+        '2014-09-07 01:00:00',
+        '2014-09-07 02:00:00',
+    ]).tz_localize('America/Santiago', nonexistent='shift_forward')
+
+    with pytest.raises(pytz.exceptions.NonExistentTimeError):
+        times.normalize()
+
+    # should not raise `pytz.exceptions.NonExistentTimeError`
+    solarposition.hour_angle(times, longitude, eot)
+
+    longitude = 82.3666
+    times = pd.DatetimeIndex([
+        '2014-11-01 23:00:00',
+        '2014-11-02 00:00:00',
+        '2014-11-02 01:00:00',
+        '2014-11-02 02:00:00',
+    ]).tz_localize('America/Havana', ambiguous=[True, True, False, False])
+
+    with pytest.raises(pytz.exceptions.AmbiguousTimeError):
+        solarposition.hour_angle(times, longitude, eot)
 
 
 def test_sun_rise_set_transit_geometric(expected_rise_set_spa, golden_mst):
     """Test geometric calculations for sunrise, sunset, and transit times"""
     times = expected_rise_set_spa.index
+    times_utc = times.tz_convert('UTC')
     latitude = golden_mst.latitude
     longitude = golden_mst.longitude
-    eot = solarposition.equation_of_time_spencer71(times.dayofyear)  # minutes
-    decl = solarposition.declination_spencer71(times.dayofyear)  # radians
+    eot = solarposition.equation_of_time_spencer71(
+        times_utc.dayofyear)  # minutes
+    decl = solarposition.declination_spencer71(times_utc.dayofyear)  # radians
+    with pytest.raises(ValueError):
+        solarposition.sun_rise_set_transit_geometric(
+            times.tz_convert(None), latitude=latitude, longitude=longitude,
+            declination=decl, equation_of_time=eot)
     sr, ss, st = solarposition.sun_rise_set_transit_geometric(
         times, latitude=latitude, longitude=longitude, declination=decl,
         equation_of_time=eot)
@@ -742,6 +819,7 @@ def test__datetime_to_unixtime_units(unit, tz):
 
 
 @requires_pandas_2_0
+@pytest.mark.parametrize('tz', [None, 'utc', 'US/Eastern'])
 @pytest.mark.parametrize('method', [
     'nrel_numpy',
     'ephemeris',
@@ -749,7 +827,6 @@ def test__datetime_to_unixtime_units(unit, tz):
     pytest.param('nrel_numba', marks=requires_numba),
     pytest.param('nrel_c', marks=requires_spa_c),
 ])
-@pytest.mark.parametrize('tz', [None, 'utc', 'US/Eastern'])
 def test_get_solarposition_microsecond_index(method, tz):
     # https://github.com/pvlib/pvlib-python/issues/1932
 
@@ -758,8 +835,12 @@ def test_get_solarposition_microsecond_index(method, tz):
     index_ns = pd.date_range(unit='ns', **kwargs)
     index_us = pd.date_range(unit='us', **kwargs)
 
-    sp_ns = solarposition.get_solarposition(index_ns, 40, -80, method=method)
-    sp_us = solarposition.get_solarposition(index_us, 40, -80, method=method)
+    with warnings.catch_warnings():
+        # don't warn on method reload
+        warnings.simplefilter("ignore")
+
+        sp_ns = solarposition.get_solarposition(index_ns, 0, 0, method=method)
+        sp_us = solarposition.get_solarposition(index_us, 0, 0, method=method)
 
     assert_frame_equal(sp_ns, sp_us, check_index_type=False)
 
@@ -781,7 +862,7 @@ def test_nrel_earthsun_distance_microsecond_index(tz):
 
 
 @requires_pandas_2_0
-@pytest.mark.parametrize('tz', [None, 'utc', 'US/Eastern'])
+@pytest.mark.parametrize('tz', ['utc', 'US/Eastern'])
 def test_hour_angle_microsecond_index(tz):
     # https://github.com/pvlib/pvlib-python/issues/1932
 
@@ -813,7 +894,7 @@ def test_rise_set_transit_spa_microsecond_index(tz):
 
 
 @requires_pandas_2_0
-@pytest.mark.parametrize('tz', [None, 'utc', 'US/Eastern'])
+@pytest.mark.parametrize('tz', ['utc', 'US/Eastern'])
 def test_rise_set_transit_geometric_microsecond_index(tz):
     # https://github.com/pvlib/pvlib-python/issues/1932
 
@@ -838,7 +919,7 @@ def test_spa_python_numba_physical(expected_solpos, golden_mst):
     times = pd.date_range(datetime.datetime(2003, 10, 17, 12, 30, 30),
                           periods=1, freq='D', tz=golden_mst.tz)
     with warnings.catch_warnings():
-        # don't warn on method reload or num threads
+        # don't warn on method reload
         # ensure that numpy is the most recently used method so that
         # we can use the warns filter below
         warnings.simplefilter("ignore")
@@ -865,7 +946,7 @@ def test_spa_python_numba_physical_dst(expected_solpos, golden):
                           periods=1, freq='D', tz=golden.tz)
 
     with warnings.catch_warnings():
-        # don't warn on method reload or num threads
+        # don't warn on method reload
         warnings.simplefilter("ignore")
         ephem_data = solarposition.spa_python(times, golden.latitude,
                                               golden.longitude, pressure=82000,

pvlib/tests/test_spa.py

@@ -1,6 +1,8 @@
 import os
 import datetime as dt
 import warnings
+import pytest
+import pvlib
 
 try:
     from importlib import reload
@@ -234,7 +236,7 @@ class SpaBase:
 
     def test_solar_position(self):
         with warnings.catch_warnings():
-            # don't warn on method reload or num threads
+            # don't warn on method reload
             warnings.simplefilter("ignore")
             spa_out_0 = self.spa.solar_position(
                 unixtimes, lat, lon, elev, pressure, temp, delta_t,
@@ -423,3 +425,30 @@ class NumbaSpaTest(unittest.TestCase, SpaBase):
             nresult, self.spa.solar_position(
                 times, lat, lon, elev, pressure, temp, delta_t,
                 atmos_refract, numthreads=3, sst=True)[:3], 5)
+
+
+# Define extra test cases for issue #2077
+test_cases_issue_2207 = [
+    ((2000, 1, 1, 12, 0, 0), 2451545.0),
+    ((1999, 1, 1, 0, 0, 0), 2451179.5),
+    ((1987, 1, 27, 0, 0, 0), 2446822.5),
+    ((1987, 6, 19, 12, 0, 0), 2446966.0),
+    ((1988, 1, 27, 0, 0, 0), 2447187.5),
+    ((1988, 6, 19, 12, 0, 0), 2447332.0),
+    ((1900, 1, 1, 0, 0, 0), 2415020.5),
+    ((1600, 1, 1, 0, 0, 0), 2305447.5),
+    ((1600, 12, 31, 0, 0, 0), 2305812.5),
+    ((837, 4, 10, 7, 12, 0), 2026871.8),
+    ((-123, 12, 31, 0, 0, 0), 1676496.5),
+    ((-122, 1, 1, 0, 0, 0), 1676497.5),
+    ((-1000, 7, 12, 12, 0, 0), 1356001.0),
+    ((-1000, 2, 29, 0, 0, 0), 1355866.5),
+    ((-1001, 8, 17, 21, 36, 0), 1355671.4),
+    ((-4712, 1, 1, 12, 0, 0), 0.0),
+]
+
+
+@pytest.mark.parametrize("inputs, expected", test_cases_issue_2207)
+def test_julian_day_issue_2207(inputs, expected):
+    result = pvlib.spa.julian_day_dt(*inputs, microsecond=0)
+    assert result == expected, f"Failed for inputs {inputs}"

pvlib/tools.py

@@ -206,8 +206,32 @@ def _pandas_to_doy(pd_object):
     Returns
     -------
     dayofyear
+
+    Notes
+    -----
+    Day of year is determined using UTC, since pandas uses local hour
+    """
+    return _pandas_to_utc(pd_object).dayofyear
+
+
+def _pandas_to_utc(pd_object):
     """
-    return pd_object.dayofyear
+    Converts a pandas datetime-like object to UTC, if localized.
+    Otherwise, assume UTC.
+
+    Parameters
+    ----------
+    pd_object : DatetimeIndex or Timestamp
+
+    Returns
+    -------
+    pandas object localized to or assumed to be UTC.
+    """
+    try:
+        pd_object_utc = pd_object.tz_convert('UTC')
+    except TypeError:
+        pd_object_utc = pd_object
+    return pd_object_utc
 
 
 def _doy_to_datetimeindex(doy, epoch_year=2014):
@@ -230,7 +254,7 @@ def _doy_to_datetimeindex(doy, epoch_year=2014):
 
 
 def _datetimelike_scalar_to_doy(time):
-    return pd.DatetimeIndex([pd.Timestamp(time)]).dayofyear
+    return _pandas_to_doy(_datetimelike_scalar_to_datetimeindex(time))
 
 
 def _datetimelike_scalar_to_datetimeindex(time):